python之基础篇（五）——数据类型

hwl198212

　　防伪码：忘情公子著
　　前面四篇我们已经讲了许多概念方面的东西，从此篇开始，我们将真正开始学习python。
　　在上一篇中，我们已经说过python有哪些核心数据类型，接下来我们将一一细说这些数据类型。
　　python数据类型之数字类型
　　python使用5种数字类型：布尔型、整型、长整型、浮点型和复数，所有数字类型均为不可变对象。
　　math模块是python中专门用来实现高级算术运算的模块。
　　数字支持以下操作：
　　+：加法
　　-：减法
　　*：乘法
　　/：除法
　　//：截断除法
　　**：乘方
　　%：取模
　　-=：一元减法
　　+=：一元加法
　　*=：一元乘法
　　/=：一元除法
　　数字支持以下比较运算：
　　<<：左移，右边补0
　　>>：右移，左边补0
　　&：按位与
　　|：按位或
　　^：按位异或（位相同则为0，不同则为1）
　　1 ^ 0值为1
　　1 ^ 1值为0
　　~：按位求反
　　python数据类型之序列类型
　　序列表示索引为非负整数的有序对象集合，包括字符串、列表和元组。
　　字符串是字符类型，字符串也属于序列类型，同样支持迭代。
　　列表和元组是任意python对象的序列。
　　字符和元组属于不可变序列，而列表则支持插入、删除和替换元素。
　　所有序列都支持迭代。
　　python序列类型之字符类型
　　指定字符串字面量：把文本放入单引号、双引号或三引号中。
　　在python2.0系列当中，字符串字面量（str）对应于8位字符（8bit数据）或面向字节的数据，因此无法完全支持国际字符集（Unicode）。
　　在python2系列中，如果想用Unicode进行编码，则必须在定义字符串时在其之前加上一个u来表示，如u'abc'，而python3系统则不用加u，python3可以自动在类型之间转换，而且已经支持Unicode编码。
　　python2系列提供两种字符串对象类型：
　　字节字符串：字节（8bit数据）序列；
　　Unicode字符串：Unicode字符（16bit）序列
　　python可以使用32bit整数保存Unicode字符，但此为可选特性。
　　文档字符串：若模块、类或函数的第一条语句是一个字符串的话，该字符串就成为文档字符串，可以使用__doc__属性来引用。
　　文档字符串在代码段中，要与其它语句的缩进保持一致。
　　适用于字符串的操作与方法：
　　s.captitalize()：首字符变大写
　　s.index(sub [, start [, end]])：找到指定字符串sub首次出现的位置，否则报错
　　s.join(t)：使用s作为分隔符连接序列t中的字符串
　　s.lower()：转换为小写形式
　　s.replace(old, new [, maxreplace])：替换一个字符串
　　s.split([sep [, maxsplit]])：使用sep作为分隔符对一个字符串进行划分，maxsplit是划分的最大次数
　　s.strip([chars])：删掉chars开头和结尾的空白或字符
　　s.upper()：将一个字符串转换为大写形式
　　python序列类型之列表
　　列表是一种容器类型：
　　可以包含任意对象的有序集合，通过索引进行访问其中的元素，是一种可变对象，其长度可变
　　支持异构和任意嵌套
　　支持在原处修改：
　　修改指定的索引元素
　　l1[2] = 'abc'
　　修改指定的分片
　　l1[1:3] = []
　　删除语句
　　del l1[2]
　　del l1[1:]
　　或使用del函数
　　del(l1[2])
　　del(l1[1:])
　　
　　适用于列表的操作与方法：
　　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]])：当s == x.start时返回最小的i，可选参数stop用于指定搜索的起始和结束索引
　　s.insert(i,x)：在索引i处插入x
　　s.pop()：返回元素i并从列表中移除它。如果省略i，则返回列表中最后一个元素并从列表中移除它
　　s.remove(x)：搜索x并从s中移除它
　　s.reverse()：颠倒s中的所有元素的顺序
　　s.sort([key [, reverse]])：对s中的所有元素进行排序。key是一个键函数。reverse是一个标志，表明以倒序对列表进行排序。key和reverse应该始终以关键字参数的形式指定
　　list1 + list2：合并两个列表，返回一个新的列表，不会修改原列表
　　list1 * N：把list1重复N次，返回一个新列表
　　in：成员关系判断字符，用法：object in container
　　not in：成员关系判断字符，用法：object not in container
　　浅复制与深复制的区别？
　　浅复制：浅复制时，复制者与被复制者在内存中实际上是同一个对象引用
In [1]: list1 = [1,2,3]　　

　　
In [2]: list2 = list1
　　

　　
In [3]: print list1
　　
[1, 2, 3]
　　

　　
In [4]: print list2
　　
[1, 2, 3]
　　

　　
In [5]: id(list1)
　　
Out[5]: 140347116298112
　　

　　
In [6]: id(list2)
　　
Out[6]: 140347116298112
　　深复制：深复制时，复制者与被复制者在内存中是两个不同的对象引用
In [7]: list1 = [1,2,3]　　

　　
In [8]: list2 = list1[:]
　　

　　
In [9]: print list1
　　
[1, 2, 3]
　　

　　
In [10]: print list2
　　
[1, 2, 3]
　　

　　
In [11]: id(list1)
　　
Out[11]: 140347117118024
　　

　　
In [12]: id(list2)
　　
Out[12]: 140347117098696
　　也可以通过copy模块的deepcopy方法来实现深复制
In [13]: import copy　　

　　
In [14]: list3 = copy.deepcopy(list1)
　　

　　
In [15]: print list1
　　
[1, 2, 3]
　　

　　
In [16]: print list3
　　
[1, 2, 3]
　　

　　
In [17]: id(list1)
　　
Out[17]: 140347117118024
　　

　　
In [18]: id(list3)
　　
Out[18]: 140347117091008
　　python序列类型之元组
　　元组是一种容器类型，但是其是不可变对象。表达式符号是()
　　可以包含任意对象的有序集合，通过索引访问其中的元素，是一种不可变对象，长度固定
　　支持异构和任意嵌套
　　支持索引、切片、成员关系判断、合并、重复
　　元组的常见操作有以下这些：
　　()：定义空元组
　　(1,)：定义一个元素的元组
　　(1,2,3)：定义元组
　　tuple1 + tuple2：全并两个元组，生成一个新元组，不会修改原元组
　　tuple1 * N：把tuple1重复N次，返回一个新元组
　　in：成员关系判断字符，用法：object in container
　　not in：成员关系判断字符，用法：object not in container
　　在不引起语法冲突的前提下，元组定义时、使用时允许省略()。一般而言，仅当元组作为字符传给函数调用以及当元组出现在print语句的特殊情况时，()是必要的。
　　元组本身不可变，但当元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组
　　例如当元组中包含列表时，可以对元组中列表的元素进行修改，但是不会返回一个新的元组，元组本身并未改变
In [19]: a = (1,2,3,['a','b','d','e'])　　

　　
In [20]: type(a)
　　
Out[20]: tuple
　　

　　
In [21]: id(a)
　　
Out[21]: 140347105497608
　　

　　
In [22]: a[3][2] = 5
　　

　　
In [23]: print a
　　
(1, 2, 3, ['a', 'b', 5, 'e'])
　　

　　
In [24]: id(a)
　　
Out[24]: 140347105497608
　　适用于所有序列的操作和方法：
　　s + r：连接
　　s * n：制作s的n个副本，n为整数
　　value1,value2...valuen = s：变量解包
　　s：索引运算符，返回一个序列的元素i
　　s[i:j]：切片运算符，返回一个切片
　　s[i:j:stride]：扩展切片运算符，返回一个扩展切片
　　对于切片运算，切片后的结果会生成为新对象
　　x in s，x not in s：从属关系
　　for x in s：迭代
　　len(s)：返回s中的元素个数
　　min(s)：返回s中的最小值
　　max(s)：返回s中的最大值
　　min(s)和max(s)只适用于能够对元素排序的序列
　　sum(s [, initial])：只适用于数字序列，返回s中各项的和
　　all(s)：检查s中的所有项是否为True
　　any(s)：检查s中的任意项是否为True
　　适用于可变序列的操作：
　　s = v  项目赋值
　　s[i:j] = t  切片赋值
　　s[i:j:stride] = t  扩展切片赋值
　　del s  项目剔除
　　del s[i:j]  切片剔除
　　del s[i:j:stride]  扩展切片剔除
　　适用于列表的方法：
　　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]])：当s == x.start时返回最小的i，可选参数stop用于指定搜索的起始和结束索引
　　s.insert(i,x)：在索引i处插入x
　　s.pop()：返回元素i并从列表中移除它。如果省略i，则返回列表中最后一个元素并从列表中移除它
　　s.remove(x)：搜索x并从s中移除它
　　s.reverse()：颠倒s中的所有元素的顺序
　　s.sort([key [, reverse]])：对s中的所有元素进行排序。key是一个键函数。reverse是一个标志，表明以倒序对列表进行排序。key和reverse应该始终以关键字参数的形式指定
　　python数据类型之字典：dict
　　字典在其它编程语言中又称作关联数组或散列表。
　　在python中，字典属于可变类型的容器，其长度可变，与列表不同的地方在于它的元素是无序的，只能通过键来实现元素存取。
　　序列类型的键只能是数字下标，而字典的键可以是任意可hash类型，不过一般使用字符串当作其键
　　支持异构和任意嵌套
　　字典支持的操作与方法：
　　{}：定义一个空字典
　　{key1:value1,key2:value2,...}：定义字典
　　{'x':32,'y':[1,2,3]}：定义一个异构字典
　　d1 = dict(name='tom',age=42,gender='n')：用dict定义一个字典
　　d1= dict(zip('xyz','123'))：用dict结合zip定义一个字典，此字典d1的结果为{'x':1,'y':2,'z':3}
　　d2 = d1.copy()：字典复制
　　d.get(key)：若key在字典d中存在，则返回key的值，否则返回空值
　　d[key]：若key在字典d中存在，则返回key的值，否则抛出异常
　　d.items()：把字典d中的键值对返回成元组列表。将字典转换成元组列表
　　d.has_key(key)：判断字典d中是否存在key
　　d.keys()：返回字典d中的键列表
　　d.values()：返回字典d中的值列表
　　d.pop(key)：弹出指定的key
　　d.popitem()：随机弹出键值映射
　　d1.update(d2)：将字典d2合并到字典d1中，合并时若有键相同，则覆盖原字典中对应的键
　　d.iteritems()：以键值对做为条目进行迭代，返回一个迭代器对象
　　d.iterkeys()：以键做条目进行迭代，返回一个迭代器对象
　　d.itervalues()：以值做条目进行迭代，返回一个迭代器对象
　　d.viewitems()：返回类似集合风格的字典，以键值对的元组形式显示字典构造。返回的结果类似dict.items([(key,value),(key,value),(key,value)...])
　　d.viewkeys()：返回类似集合风格的key列表。返回的结果类似dict.keys([key1,key2,key3....])
　　d.viewvalues()：返回类似集合风格的value列表。返回的结果类似dict.values([value1,value2,value3....])
　　python数据类型之集合：set
　　集合就是指一大堆的不重复的元素放到一起，是一组无序排列的可hash的值。
　　支持集合关系测试：
　　并集
　　交集
　　差集
　　支持成员关系测试：
　　in
　　not in
　　支持迭代、异构
　　不支持索引、元素获取、切片
　　集合的类型：
　　set()：可变对象
　　frozenset()：不可变对象
　　集合没有特定语法格式，可以通过以下方法创建：
　　1.通过工厂函数（set()、frozenset()）创建
　　2.通过{}创建，如s1 = {1,2,3,4,5,6}
　　集合类型支持的方法和操作：
　　s1 = set([1,2,3])：定义一个set集合。其参数必须是一个可迭代对象，可以是字符串、列表等
　　len(s)：返回s中的项目数
　　max(s)：返回s中的最大元素
　　min(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.union(t)：求并集。返回所有在s或t中的项
　　s.pop()：随机弹出一个项目
　　s.add(i)：在s集合中添加一个元素i
　　s | t：求s和t的并集
　　s & t：求s和t的交集
　　s - t：求差集
　　s ^ t：求对称差集
　　容器、类型、对象的相关概念：
　　列表、元组、字典字面量可以在不使用续行符的情况下直接分布在多行上。最后一个元素后面允许使用一个逗号，但是没有元素时不允许使用逗号。
　　所有对象都有引用技术，为对象分配一个新名称（用一个变量名引用它）或者将一个对象放进一个容器中时，都会导致对象引用技术增加。
　　当对象引用技术为0时，就会由垃圾回收器回收此对象。使用del语句执行删除操作或者某次引用的修改超出当前对象的作用域时，对象的引用技术就会减少。
　　可以使用sys模块的getrefcount()函数来查看对象的引用技术：
In [28]: import sys　　

　　
In [29]: a = 'black'
　　

　　
In [30]: sys.getrefcount(a)
　　
Out[30]: 3
　　列表和字典都支持两种类型的复制操作：浅复制和深复制。深复制可使用copy模块中的deepcopy()实现。
　　python中的所有对象都是"第一类的"。第一类就意味着，使用标识符命名的所有对象，都具有相同状态。因此，能够命名的所有对象，都可以当作数据直接处理。
　　序列表示索引为非负整数的有序对象集合，包括字符串、列表和元组。所有序列都支持迭代。
　　字符串是字符的序列；
　　列表和元组是任意python对象的序列