一、Python对象的相关术语
Python中一切皆对象，python程序中保存的所有数据都是围绕对象这个概念展开的；所有的对象都是由类实例化而来的，只不过这些类有些是python内置的类；例如，整数和浮点数，字符串都是由python内置的类实例化而来的。除此之外用户还可以自定义类型，就是类。
python程序中存储的所有数据都是对象
每个对象都有一个身份、一个类型和一个值
例如，school=“MaGe Linux”会以“MaGe Linux”创建一个字符串对象，其身份是指向它在内存中所处位置的指针(其在内存中的地址)，而school就是引用这个具体位置的名称
对象的类型也称对象的类别，用于描述对象的内部表示及它支持的方法和操作
创建特定类型的对象时，有时也将该对象称为该类型的实例
class：自定义类型
type：内置类型
instance：实例化
实例被创建后，其身份和类型就不可改变
如对象值是可修改的，则称为可变对象
如果对象的值不可修改，则称为不可变对象
如果某个对象包含对其它对象的引用，则将其称为容器；
大多数对象都拥有大量特有的数据属性和方法
类=数据（变量）+方法（函数）
属性：与对象相关的值；就是类实例化为对象时可以为内部的变量赋值，对象内部可用变量名就称之为对象的属性
方法：被调用时将在对象上执行某些操作的函数
使用点(.)运算符可以访问属性和方法
In [1]: name="xiejun" #name是引用内存中的地址的名称
In [2]: id(name)
Out[2]: 28642832 #身份就是内存中的地址
In [3]: type(name)
Out[3]: str #类型也就是类
In [4]: str.
str.capitalize str.format str.isupper str.rfind str.startswith
str.center str.index str.join str.rindex str.strip
str.count str.isalnum str.ljust str.rjust str.swapcase
str.decode str.isalpha str.lower str.rpartition str.title
str.encode str.isdigit str.lstrip str.rsplit str.translate
str.endswith str.islower str.mro str.rstrip str.upper
str.expandtabs str.isspace str.partition str.split str.zfill
str.find str.istitle str.replace str.splitlinesPython内置函数id()可返回一个对象的身份，即该对象在内存中的位置
is运算符用于比较两个对象的身份
type()用于返回一个对象的类型
对象类型本身也是一个对象，称为对象的类
该对象的定义是唯一的，且对于某类型的所有实例都是相同的
所有类型对象都有一个指定的名称，可用于执行类型检查，
两个对象的比较：
1、值比较：对象中的数据是否相同
2、身份比较：两个变量名引用的是否为同一对象
3、类型比较：两个对象的类型是否相同
In [4]: num1=5
In [5]: num2=5
In [6]: num1==num2 #值相同
Out[6]: True
In [7]: num1 is num2 #值相同身份不一定相同，只是此处恰好相同
Out[7]: True
In [8]: type(num1) is type(num2) #类型相同
Out[8]: True二、Python对象类型
1、Python核心数据类型
类型分类 对象类型 例子
数字 int，long(长×××),foloat,complex（复数）,bool（布尔值） 3077, 3.14, 300000
字符 str,unicode, ‘mageedu.com’, “spam”
列表 [‘one’, ‘two’, ‘three’]
字典 {‘course’:’linux’, ‘tutor’:’mage’}
元组 (32, ‘spam’, ‘eggs’)
文件 myFile=open(‘/tmp/tfile’,’r’)
集合 set(‘abc’), frozenset(不可变类型) {‘a’, ‘b’, ‘c’}
其它类型 类类型、None（空）、bool(布尔型)
编程单元类型 函数、模块、类
与实现相关的类型 编译的代码堆栈跟踪
其它文件类型工具：pipes(管道)，fifos(先进先出管道)，sockets
2、类型转换
1）使用内置函数： #显示转换
str(),repr()精确值或format()转换为特定格式：将非字符型数据转换为字符串
int()：转换为整数
float()：转换为浮点数
list()：将字符串转换为列表
tuple（）：将字符串转换为元祖
set()：将字符串转为集合
frozenset()：将字符串转换为不可变集合
dict(d):创建字典;d必须元素为键值对的元祖的列表
chr():将整数转换为字符
ord():将字符转换为整数值
hex（）：将整数转换为十六制字符串
bin()：二进制
oct（）：八进制
In [20]: l1="xie jun"
In [21]: type(l1)
Out[21]: str
In [22]: l2=list(l1)
In [23]: type(l2)
Out[23]: list
In [24]: print l2
['x', 'i', 'e', ' ', 'j', 'u', 'n']
In [25]: l3=12345
In [26]: type(l3)
Out[26]: int
In [27]: l4=list(l3)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-da565bf35804> in <module>()
----> 1 l4=list(l3)
TypeError: 'int' object is not iterable
In [28]:
In [36]: d1=dict([("x",1),("y",2)]) # d必须是元素为键值对的元祖的列表
In [37]: d1
Out[37]: {'x': 1, 'y': 2}3、数字类型
python的数字字面量
布尔型：True，False 1，0
整数：
浮点数：
复数：
注意：
字面量是指由字母，数字等构成的字符串或者数值，它只能作为右值出现，所谓右值是指等号右边的值，如：int a=123这里的a为左值，123为右值。
常量和变量都属于变量，只不过常量是赋过值后不能再改变的变量，而普通的变量可以再进行赋值操作
例如：
int a; #a变量
const int b=10; #b为常量,10为字面量
string str="hello world"; #str为变量,hello world为也字面量数字类型操作
Python使用5种数字类型：布尔型、整型、长整型、浮点型和复数，所有数字类型均为不可变
数字操作：
比较运算：
In [7]: 3<<3 #就是在用二进制表示向左移动3位，加3个0
Out[7]: 24
In [8]: 24>>3 #就是在用二进制表示向向移动3位，去掉前3位，剩下2位就是2**0+2**1=3
Out[8]: 3
In [9]: 9<<3
Out[9]: 72
In [10]: 9>>3
Out[10]: 1
In [11]: 10>>3
Out[11]: 1
In [12]: 20>>3
Out[12]: 2
In [14]: 56>>3
Out[14]: 7
In [15]: import math #实现高级算计运算的库
In [16]: math.
math.acos math.cos math.factorial math.ldexp math.sin
math.acosh math.cosh math.floor math.lgamma math.sinh
math.asin math.degrees math.fmod math.log math.sqrt
math.asinh math.e math.frexp math.log10 math.tan
math.atan math.erf math.fsum math.log1p math.tanh
math.atan2 math.erfc math.gamma math.modf math.trunc
math.atanh math.exp math.hypot math.pi
math.ceil math.expm1 math.isinf math.pow
math.copysign math.fabs math.isnan math.radians
In [16]: math.pi
Out[16]: 3.141592653589793
In [17]: math.sqrt
Out[17]: <function math.sqrt>
In [18]: math.sqrt(4) #开平方
Out[18]: 2.0
In [22]: math.pow(2,4) #平方
Out[22]: 16.04、序列类型
序列表示索引为非负整数的有序对象集合，包括字符串、列表和元组
字符串字面量：把文本放入单引号（必须在同一行） ，双引号（必须在同一行），三引号（跨行）中；
字符串是字符的
列表和元组是任意Python对象的序列
字符和元组属于不可变序列，而列表则支持插入、删除和替换元素
所有序列都支持迭代
如果要使用unicode编码，则在字符之前使用字符u进行标识，如u“magedu”
文档字符串：模块、类或函数的第一条语句是一个字符串的话，该字符串就是就成为文档字符串，可以使用__doc__引用。
In [24]: str1="magedu"
In [25]: type(str1)
Out[25]: str
In [26]: str2=u"magedu" #3.0的Python则不用加u
In [27]: type(str2)
Out[27]: unicodeIn [28]: def printName():
....: "test function"
....: print "hello magedu.com"
....:
In [31]: printName
Out[31]: <function __main__.printName>
In [32]: printName()
hello magedu.com
In [33]: printName().
.Xauthority .bash_logout .bashrc .ipython/ .tcshrc
.bash_history .bash_profile .cshrc .lesshst .viminfo
In [33]: printName().__doc__ #调用函数
hello magedu.com
In [34]: printName.__doc__ #引用函数对象
Out[34]: 'test function'适用于所有序列的操作和方法：
s[i]: 索引运算符
s[i:j]为切片运算符
s[i:j:stride]为扩展切片运算符
min(s)和max(s)只适用于能够对元素排序的序列
sum(s)只适用于数字序列
适用于字符串的的操作：
Python 2提供两种字符串对象类型
字节字符串: 字节(8bit数据)序列
Unicode字符串: Unicode字符(16bit数据)序列
Python可以使用32 bit整数保存Unicode字符，但此为可选特性
In [51]: name="xiejun"
In [52]: name.
name.capitalize name.format name.isupper name.rindex name.strip
name.center name.index name.join name.rjust name.swapcase
name.count name.isalnum name.ljust name.rpartition name.title
name.decode name.isalpha name.lower name.rsplit name.translate
name.encode name.isdigit name.lstrip name.rstrip name.upper
name.endswith name.islower name.partition name.split name.zfill
name.expandtabs name.isspace name.replace name.splitlines
name.find name.istitle name.rfind name.startswith
In [52]: name.capitalize()
Out[52]: 'Xiejun'
In [56]: name.index("u")
Out[56]: 4
In [47]: l1=list("xiejun")
In [48]: l1
Out[48]: ['x', 'i', 'e', 'j', 'u', 'n']
In [49]: ''.join(l1)
Out[49]: 'xiejun'
In [50]: ';'.join(l1)
Out[50]: 'x;i;e;j;u;n'适用于列表的操作：
容器类型
任意对象的有序集合，通过索引访问其中的元素，可变对象，支持异构，任意嵌套
支持在原处修改，
In [65]: l1=[1,2,3,4,5]
In [66]: l1[0]
Out[66]: 1
In [68]: l1[1:3]
Out[68]: [2, 3]
In [69]: l1[1:3]=''
In [70]: l1
Out[70]: [1, 4, 5]
In [72]: l1[:]=''
In [73]: l1
Out[73]: []可用于列表的方法：
list(s)可将任意可迭代类型转换为列表，而如果s已经是一个列表，则该函数构造的新列表是s的一个浅复制
l1+l2：是合并2个列表，返回一个新的列表，不会修改原列表
l1*N：把l1重复N次，返回一个新列表
in：成员判定符，
not in：
列表解析：[ ]
In [76]: l1=[1,23,"xj"]
In [77]: l1*2
Out[77]: [1, 23, 'xj', 1, 23, 'xj']
In [78]: 2 in l1
Out[78]: False
In [79]: 23 in l1
Out[79]: True
In [80]: 23 not in l1
Out[80]: False
In [81]: 2 not in l1
Out[81]: True注意列表复制时：
In [1]: l1=[1,2,3,4]
In [2]: l2=l1 #浅复制
In [4]: print l2
[1, 2, 3, 4]
In [5]: l1.
l1.append l1.extend l1.insert l1.remove l1.sort
l1.count l1.index l1.pop l1.reverse
In [5]: l1.append(4)
In [6]: l1
Out[6]: [1, 2, 3, 4, 4]
In [7]: l2
Out[7]: [1, 2, 3, 4, 4]
In [8]: id(l1)
Out[8]: 19737488
In [9]: id(l2)
Out[9]: 19737488
In [10]: l3=l1[:] #深复制
In [11]: l3
Out[11]: [1, 2, 3, 4, 4]
In [12]: id(l3)
Out[12]: 19724480
In [15]: l1.append(6)
In [16]: l1
Out[16]: [1, 2, 3, 4, 4, 6]
In [17]: l2
Out[17]: [1, 2, 3, 4, 4, 6]
In [18]: l3
Out[18]: [1, 2, 3, 4, 4]
In [3]: import copy
In [4]: copy.
copy.Error copy.deepcopy copy.name
copy.PyStringMap copy.dispatch_table copy.t
copy.copy copy.error copy.weakref
In [5]: l1=[1,2,3]
In [6]: id(l1)
Out[6]: 36145056
In [7]: l2=copy.deepcopy(l1) #深复制
In [8]: l2
Out[8]: [1, 2, 3]
In [9]: id(l2)
Out[9]: 37443344元组：
In [26]: t2=1,2,3 #括号可省略，但特殊情况下必须使用括号，建议不省略
In [27]: type(t2)
Out[27]: tuple
In [28]: t3="1",2
In [29]: type(t3)
Out[29]: tuple注意：虽然元祖是不可变类型（不支持原处修改），但如果元祖内嵌套了可变类型的元素，那么此元素的修改不会返回新元祖（支持原处修改）
序列操作总结：
5、映射类型
字典在其它编程语言中又称作关联数组或散列表
通过键实现元素存取，无序集合，可变类型容器，长度可变，支持异构、嵌套
格式：｛key1:value1,key2:value2,...｝
{}:空字典
映射类型表示一个任意对象的集合，而且可以通过另一个几乎是任意键值的集合进行索引
与序列不同，映射是无序的，它通过键进行索引
任何不可变对象都可用作字典的键，如字符串、数字、元组等
包含可变对象的列表、字典和元组不能用作键
m[k]运算符用于选择映射对象中的一项，其中“k”是一个键值
引用不存在的键会引发KeyError异常
m.iteritems()：返回一个迭代器，m.next()的结果是键值对的元祖
m.itervalues():返回一个迭代器，m.next()的结果是值
m.iterkeys()：返回一个迭代器，m.next()的结果是键
m.next()：遍历迭代器对象
m.viewitems()
m.viewkeys()
m.viewvalues()
zip()
In [43]: zip
Out[43]: <function zip>
In [45]: zip('abc',"123")
Out[45]: [('a', '1'), ('b', '2'), ('c', '3')]
In [46]: dict(zip('abc','123'))
Out[46]: {'a': '1', 'b': '2', 'c': '3'}字典的方法和操作：
6、集合类型
无序排列，可哈希，支持集合关系测试，不支持索引，元素获取、切片
没有特定语法格式：只能通过工厂函数创建
In [48]: s1=set()
In [49]: s1
Out[49]: set()
In [50]: print s1
set([])
In [51]: s2=set(123)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-51-a88bf1ca99f8> in <module>()
----> 1 s2=set(123)
TypeError: 'int' object is not iterable
In [52]: s2=set(1,2,3)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-52-2a6eb463da1e> in <module>()
----> 1 s2=set(1,2,3)
TypeError: set expected at most 1 arguments, got 3
In [53]: s2=set([1,2,3]) #集合的元素要支持迭代的
In [54]: s2
Out[54]: {1, 2, 3}
In [55]: print s2
set([1, 2, 3])
In [56]: s3=set("xiejun")
In [57]: s3
Out[57]: {'e', 'i', 'j', 'n', 'u', 'x'}
In [58]: print s3
set(['e', 'i', 'j', 'n', 'u', 'x'])
In [65]: s5=set(["Mon",'Tus'])
In [66]: s5
Out[66]: {'Mon', 'Tus'}集合是唯一项的无序集
与序列不同，集合不提供索引或切片操作
与字典不同，集合不存在相关的键值
放入集合中的项目必须是不可变的
集合有两种类型：
可变集合：set()
不可变集合：frozenset()
集合类型的方法和操作：
可变集合类型set的方法：
三、其它总结
1、引用计数与垃圾收集
所有对象都有引用计数
给对象分配一个新名称或将其放入一个容器中，其引用计数都会增加
使用del语句或为变量名重新赋值时，对象的引用计数会减少
sys.getrefcount()可以获得对象的当前引用计数
一个对象的引用计数器归零时，它将被垃圾收集机制回收
2、点号运算符
属性：数据
返回一个数据，显示则要使用print语句
方法：操作（），就是函数
调用，执行一段代码
括号：调用可调用对象（函数，类，对象中的方法）
3、如何获取使用帮助
获取对象支持使用的属性和方法：dir()，
某方法的具体使用帮助：help(),例如：help(list.pop),
获取可调用对象的文档字串：print obj.__doc__
4、容器、类型、对象
1）容器类对象（列表，元祖，字典字面量）可以在不使用续航符的情况下分布于多行，最后一个元素的后面允许使用一个逗号
2）列表和字典都支持两种类型的复制操作：浅复制和深复制，深复制可使用copy模块中的deepcopy（）实现
3）Python中的所有对象都是“第一类的”这意味着使用标识符命名的所有对象都有相同的状态，于是，能够命名的所有对象都可以直接当数据进行处理。
4）所有序列都支持迭代
5）所有序列都支持的操作和方法
s[i]
s[i:j]
s[i:j:stride]
len(s)
min(s)
max(s)
sun(s)
all(s)
any(s)
s1+s2
s1*N
obj in s1
obj not in s1
6）可变序列的操作
s1[index]=value 元素赋值
s1[i:j]=t 切片赋值
s1[i:j:stride]=t
del s1[index]
del s1[i:j]
del s1[i:j:stride]
