Python程序中保存的所有数据都是围绕对象这个概念展开的：
程序中存储的所有数据都是对象；
每个对象都有一个身份、一个类型和一个值；
例如：school="MaGe Linux"会以"MaGe Linux"创建一个字符串对象，其身份是指向它在内存中所处位置的指针(其在内存中的地址),而school就是引用这个具体位置的名称。
对象的类型也称对象的类别，用于描述对象的内部表示及它支持的方法和操作；
- 创建特定类型的对象时，有时也将该对象称为该类型的实例；
- 实例被创建后，其身份和类型就不可改变；
- 如果对象值是可改变的，则称为可变对象；
- 如果对象值是不可改变的，则称为不可变对象；
- 如果某个对象包含对其他对象的引用，则将其称为容器；
- 大多数对象都拥有大量特有的数据属性和方法：
属性：与对象相关的值；
方法：被调用时将在对象上执行某些操作的函数；
使用点(.)号运算符可以访问对象的属性和方法；class：在自定义类型时使用；
type：类型。
instance：实例化；
类：数据和方法组成；
数据：变量；
方法：函数；
类：实例化成对象；
CA：
IA：
IB：
Python内置函数id()可返回一个对象的身份，即该对象在内存中的位置；
- is运算符用于比较两个对象的身份；
- type()用于返回一个对象的类型；
- 对象类型本身也是一个对象，称为对象的类；
该对象的定义是唯一的，且对于某类型的所有实例都是相同的；
所有类型对象都有一个指定的名称，可用于执行类型检查，如list,dictif a is b: # 身份比较；
statements
if a == b: # 值比较；
statements
if type(a) is type(b): # 类型比较；
statements两个对象比较：
- 1、值比较：对象中的数据是否相同； num1 == num2
- 2、身份比较：两个变量名引用是否为同一对象； num1 is num2
- 3、类型比较：两个对象的类型是否相同； type(num1) is type(num2)
- 数字：int,long,float,complex,bool 3077，3.14，300000
- 字符: str,unicode 'mageedu.com',"spam"
- 列表：list ['one','two','three']
- 字典：dict {'course':'linux','language':'python'}
- 元组：tuple (32,'spam','eggs')
- 文件: file myFile=open('/tmp/tfile','r')
- 集合：set,frozenset(冻结集合) set('abc'),{'a','b','c'}
- 其他类型： 类类型，None，布尔型；
- 编程单元类型： 函数、模块、类
- 与实现相关的类型： 编译的代码堆栈跟踪；
- 其他文件类工具：pipes,fifos,sockets
- str(),repr()或format()：将非字符型数据转换为字符； str1 = repr(num1)
- int():转换为整数；
- float():转换为浮点数；
- list(s): 将字串s转换为列表；
- tuple(s):将字串转换为元组；
- set(s): 将字串s转换为集合；
- frozenset(s)：将字串s转换为不可变集合；
- dict(d): 根据指定的键值对，创建字典，d必须是(key,value)的元组序列；
- chr(x): 将整数转换为单个字符；
- ord(x): 将字符转换为整数值；
- hex(x): 将整数转换为16进制字符；
- bin(x): 将整数转换为2进制字符；
- oct(x): 将整数转换为8进制字符；
-
库：
- numpy：科学运算相关；
- math：数学相关的运算；
-
python的数字字面量：布尔型，整数，浮点数，复数；
-
布尔型：
True：1
False：0
-
-
数字类型的算术运算：
x + y 加法
x - y 减法
x * y 乘法
x / y 除法
x // y 截断除法
x ** y 乘方；
x % y 取模(x mod y)
-x 一元减法(负数)
+x 一元加法(正数)-
位移运算：
- 正数：
向左移，数字增大；
向右移，数字变小；
x << y 左移
x >> y 右移
x & y 按位与
x | y 按位或
x ^ y 按位抑或
~x 按位求反序列类型表示索引为非负整数的有序对象集合，包括字符串、列表和元组；
- 字符串是字符的序列；
- 列表和元组是任意python对象的序列；
- 字符串和元组属于不可变序列，而列表则支持插入、删除和替换元素；
- 所有序列都支持迭代；
-
字符串字面量：把文本放入单引号、双引号、三引号中；三(单|双)引号可以实现跨行定义；
-
如果要使用unicode编码，则在字符之前使用字符u进行标识，如: u"magedu.com"
-
文档字串：模块、类或函数的第一条语句是一个字符串的话，该字符串就成为文档字符串，可以通过__doc__变量引用；
In [14]: def printName():
...: "test function"
...: print "Hello,sslinux.com"
...:
In [15]: printName() #使用括号()运算符，表示调用函数；
Hello,sslinux.com
In [16]: printName().__doc__ # 函数的内置属性，调用函数的开头说明文档；
Hello,sslinux.com
In [17]: printName.__doc__ #不适用括号运算符()表示调用函数对象本身；
Out[17]: 'test function'运算符：
- s[i]: 索引运算符；
- s[i:j]: 为切片运算符；
- s[i:j:stride] 为扩展切片运算符；
- 切片运算，切片后的结果会生成新对象；
**内置函数：**对象的自有的方法；
- min(s)和max(x)，只适用于能够对元素排序的序列；按ASCII码排序；
- sum(s)只适用于数字序列；求各项之和；
- all(s) 检查序列中的各项是否都为True；只要有一项为False就为False；
- len(s) 序列s中的元素个数；
- any(s) 检查序列s中的任意项是否为true；只要又一项为True就为True；
Python2 提供两种字符串对象类型：
- 字节字符串：字节(8bit数据)序列；
- Unicode字符串：Unicode字符(16bit数据)序列；
Python可以使用32 bit整数保存Unicode字符，但此为可选特性；
- s.captitalize() 首字符变大写；
- s.index(sub [, start [,end]]) 找到指定字符串sub首次出现的位置，否则报错；
- s.join(t) 使用s作为分隔符,连接序列t中的字符串；
In [18]: str1 = "www.sslinux.com"
In [19]: l1 = list(str1)
In [20]: print l1
['w', 'w', 'w', '.', 's', 's', 'l', 'i', 'n', 'u', 'x', '.', 'c', 'o', 'm']
In [21]: ''.join(l1)
Out[21]: 'www.sslinux.com'- s.lower() 转换为小写形式；
- s.upper() 将一个字符串转换为大写形式；
- s.replace(old,new [,maxreplace]) 替换一个子字符串；
- s.split([sep [,maxaplit]]) 使用sep作为分隔符对一个字符串进行划分。maxsplit是划分的最大次数；
- s.strip([chrs]) 删掉chrs开头和结尾的空白或指定字符；
- s[i] = v 元素赋值；
- s[i:j] = t 切片赋值；
- s[i:j:stride] = t 扩展切pain赋值；
- del s[i] 元素删除；
- del s[i:j] 切片删除；
- del s[i:j:stride] 扩展切片删除；
容器类型：
任意对象的有序集合，通过索引访问其中的元素，可变对象；
异构，任意嵌套；
l2 = [1,'b']
l3 = [[1,2],['a','b']]
支持在原处修改；修改的是元素的引用；
修改操作包括：
修改指定的索引元素，修改指定的分片，删除语句，内置方法；
l2[1:3] = [] # 指定分片的元素将会被删除；
list(s)可将任意可迭代类型转换为列表，而如果s已经是一个列表，则该函数构造的新列表是s的一个浅复制；
-
list(s) 将s转换为一个列表；
-
s.append(x) 将一个新元素x追加到s末尾；
-
s.extend(t) 将一个新列表t追加到s末尾；合并两个列表中的元素；
-
s.count(x) 计算s中元素x的出现次数；
-
s.index(x[,start[,stop]]) 返回指定元素在列表中首次出现的索引号，可选参数start,stop用于指定搜索的起始和结束索引；
-
s.insert(i,x) 在索引i处插入x，元素占用原来索引i的位置；
-
s.pop([i]) 返回索引i所在位置的元素，并从列表中移除该元素。如果省略i，则返回列表中最后一个元素并移除；选择并且不重复的场景可使用。
-
s.remove(x) 搜索元素x并从s中移除它
-
s.reverse() 颠倒s中的所有元素的顺序；在原处修改，无返回值；
-
s.sort([key [,reverse]]) 对s中的所有元素进行排序。key是一个键函数。reverse是一个标志，表明是否以倒序对列表进行排序。key和reverse应该始终以关键字参数的形式指定；
-
l1 + l2: 合并两个列表，返回一个新的列表；不会修改原有列表；字符串也一样；
-
l1 * N ：把l1重复N次，返回一个新列表；字符串也支持；
-
in操作符：成员关系判断符；判断在指定容器中是否出现了指定元素；返回Bool值； 用法：obj in container
-
not in: 成员关系判断； obj not in container
-
内置函数range： 返回一个range对象； l1 = range(10)
-
列表解析：[i**2 for i in range(1,10) if i % 2 == 1]
-
列表赋值特殊情况：
In [1]: l1 = [1,2,3]
In [2]: l2 = l1 # l1 和 l2 指向了同一个内存对象；
In [3]: l1.append(4)
In [5]: print(l1)
[1, 2, 3, 4]
In [6]: print(l2)
[1, 2, 3, 4]要想在赋值时生成新的列表，应该使用： l3 = l1[:];
相当于将l1的所有元素复制了一份给l3,深复制(copy.deepcopy)；
import copy
- 列表复制方式：
l1 = [1,2,3,4] # 浅复制；
l2 = l1
import copy
l2 = copy.deepcopy(l1) # 深复制；
l2 = l1[:]表达式符号；()
容器类型：
任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定；
支持异构，迭代；
In [7]: t1 = (1,2,3,4)
In [8]: t1.count(3) # 对象在元组中出现的次数；
Out[8]: 1
In [9]: t1.index(2) # 查询对象在元组中的索引；
Out[9]: 1
In [10]: t1.count(10)
Out[10]: 0
In [11]: t1.index(15) # 如果对象不存在于元组中，抛出异常，应该先使用in判读一下对象是否存在于元组中；
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-11-0176c55361fa> in <module>()
----> 1 t1.index(15)
ValueError: tuple.index(x): x not in tuple- () : 定义空元组； 相当于 t1 = () <==> t1 = tuple()
- 切片，返回的是新元组；
- 定义元组时，小括号()可省略，t1 = 1,2,3,4，建议尽量不要省略，以免造成歧义；
- 加法运算(t1 + t2)：合并两个元组，生成新元组；
- 乘法运算(t1 * N)：重复元组元素N次，生成新元组；
- 'x' in t4 : 成员关系判断；
- 虽然元组本身不可变，但如果元组内嵌套了可变类型的元素(如:列表等)，那么此类元素的修改不会返回新元组；
例如：
In [13]: t1 = ('x',[1,2,3])
In [14]: id(t1)
Out[14]: 70619904
In [15]: type(t1)
Out[15]: tuple
In [16]: t1[1]
Out[16]: [1, 2, 3]
In [17]: t1[1].pop()
Out[17]: 3
In [19]: print(t1[1])
[1, 2]
In [20]: print(t1)
('x', [1, 2])
In [21]: id(t1) # 元组t1的id还是没有变哦。
Out[21]: 70619904
映射类型表示一个任意对象的集合，而且可以通过另一个几乎是任意键值的集合进行索引；
与序列不同，映射是无序的，它通过键进行索引；
任意不可变对象都可用作字典的键，如字符串、数字、元组等；
包含可变对象的列表、字典和元组不能用作键；
-
m[k]运算符用于选择映射对象中的一项，其中'k'是一个键：
引用不存在的键会引发KeyError异常；
字典在其他编程语言中又称作关联数组或散列表；
dict特性：
通过键来实现元素存取；
无序集合；
可变类型容器，长度可变；
支持异构，支持嵌套；
{key1:value1,key2:value2,....}
{}：空字典；
len(d1):返回字典元素个数；字典内置方法：
d1.clear: #清除其中的所有元素；
d2 = d1.copy(): #字典复制；深复制；
dict.get() : #返回指定键的值；
dict.haskey(): #判断字典是否有指定键；
dict.items(): #将字典转换为元组列表的形式；
dict.keys(): #返回键列表；
dict.values(): #返回值列表；
dict.pop(): #弹出指定键的元素，并返回该键的值；
dict.popitem(): #随机弹出键值映射；
dict.update(d1): #合并两个字典，若两个字典中键有重复，以d1为结果；
dict.iteritem: #返回一个键值对迭代器对象；可以使用next()方法。py3中无；
dict.iterkeys: #返回一个键迭代器对象；py3: dict.keys()
dict.itervalue: #返回一个值的迭代器对象；
dict.viewitems: #返回键值对所拆分的元组；
dict.viewkeys: #返回键列表；
dict.viewvalues: #返回值列表；
-
zip()函数：返回以元组为元素的列表；
可以使用zip()帮助生成dict；
In [23]: dict(zip('xyz','123'))
Out[23]: {'x': '1', 'y': '2', 'z': '3'}字典的键必须是可hash的；一般为字符或数字；
类：数据 + 方法
实例：
3 + 5 <==> 3.__add__(5)
列表和字典：
变量名：仅仅是指向对象的引用；
对象：实际存储在内存中；
点号运算符：
属性：数据；
返回一个数据，显示则要使用print语句或函数；
方法：操作；()
调用：执行一段代码；
可调用对象，判断对象是否可调用：内置函数callable()
字串：
单引号：''
双引号：""
三个单引号：''','''
三个双引号：""" """元组: ()
列表: []
字典: {}
数值：
获取对象支持使用的属性和方法：dir()
某方法的具体使用帮助：help() : help(list.pop)
获取可调用对象的文档字串：print(obj.__doc__)
-
支持集合关系测试：
并集，交集，差集
-
支持成员关系测试：
in，
not in，
迭代，
-
不支持：索引、元素获取、切片；
-
集合的类型：set()、frozenset()
没有特定语法格式，只能通过工厂函数创建；
help(set)
s1 = set()
s1 = set(一个可迭代对象)len(s) 返回s中项目数；
s.copy() 制作s的一份副本；
s.difference(t) 求差集，返回所有在s中，但不再t中的项目；
s.intersection(t) 求交集。返回所有同时在s和t中的项目；
s.isdisjoint(t) 如果s和t没有相同项，则返回True；
s.issubset(t) 如果s是t的一个子集，则返回True；
s.issuperset(t) 如果s是t的一个超集，则返回True；
s.symmetric_difference(t)
# 求对称差集。返回所有在s或t中，但又不同时在这两个集合中的项求并集。返回所有在s或t中的项；
s.union(t) 求并集。返回所有在s或t中的项；
s.pop() 弹出元素；
s.update(s3) 将可hash对象合并为一个集合；
s.add() 往集合中加入一个元素；s | t # s和t的并集
s & t # s和t的交集
s - t # 求差集；
s ^ t # 求对称差集；
len(s) # 集合中项数
max(s) # 最大值
min(s) # 最小值；- frozenset(): 冻结集合，不可变集合；与set()类似，但修改操作无效；
1、列表、元组、字典字面量可在不使用续行符的情况下跨行定义，最后一个元素后面可以使用逗号，为空的情况下不可以使用逗号；
2、所有对象都有引用计数，为某个对象指定新名称或将某个对象放入容器中，都会增加该对象的引用计数；当引用计数为0时，垃圾回收器就可以在后台将对象回收；
查看对象的当前引用计数：
import sys
name = "sslinux"
sys.getrefcount(name)3、列表和字典都支持两种类型的复制操作：浅复制和深复制；
深复制可使用copy模块中的deepcopy()方法复制；
4、Python中的所有对象都是"第一类的"，这意味着使用标识符命名的所有对象都具有相同状态，于是，能够命名的所有对象都可以直接当数据进行处理；
5、所有序列都支持迭代；
6、所有序列都支持的操作和方法：
s[i]
s[i:j]
s[i:j:stride]
len(s)
min(s)
max(s)
sum(s)
all(s)
any(s)
s1 + s2: 连接
s1 * N: 重复
obj in s1 : 成员关系判断
obj not in s1: 7、可变序列的操作：
s1[index] = value 元素赋值；
s1[i:j] = t 切片赋值；
del s1[index] 删除指定元素；
del s1[i:j] 删除切片；
del s1[i:j:stride] 删除扩展切片；