python的列表支持推导表达式
# python的 列表中可以存放不同数据类型的数据In [23]: L = [1,2,'egg']
In [24]: len(L)
Out[24]: 3
# 列表也支持拼接操作
In [25]: L + [4,5,6]
Out[25]: [1, 2, 'egg', 4, 5, 6]
# 列表同样支持重复操作
In [26]: L*2
Out[26]: [1, 2, 'egg', 1, 2, 'egg']
列表的边界检查
python的列表没有固定的大小,但是同样有边界检查,不允许引用不存在的元素. 也就是说,列表结尾之外的索引是不支持的.
In [27]: L = [1,2,3]In [28]: L[3]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-28-28c5e42e8527> in <module>
----> 1 L[3]
IndexError: list index out of range
如果我们需要增加列表的元素,可以使用内置方法append
In [29]: L[3]=4---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-29-3e20e34dcd62> in <module>
----> 1 L[3]=4
IndexError: list assignment index out of range
In [30]: L.append(4)
In [31]: L
Out[31]: [1, 2, 3, 4]
列表推导式
这就是python强大的地方了,列表中除了可以存放已知的,实际的数据外,还可以通过公式来生成一个列表. 这在矩阵处理中十分有用.
In [32]: M = [[1,2,3],[4,5,6],[7,8,9]]In [33]: M
Out[33]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [36]: diag=[M[i][i] for i in [0,1,2]]
In [37]: diag
Out[37]: [1, 5, 9]
# 传说中的列表生成式
In [38]: L = [[x,x/2,x*2] for x in range(-6,7,2) if x>0]
In [39]: L
Out[39]: [[2, 1.0, 4], [4, 2.0, 8], [6, 3.0, 12]]
字典
字典有很多的名字,字典,散列,哈希列表,映射等等. 字典不是一种序列,它是一种映射.是通过键-值对的形式来存储数据的.
它的存储原理和列表不同. 简答来说,字典的存储是将键(key)通过散列函数进行转换,得到一个地址,然后将值(value)放入该地址.
那也就是说,字典的查询速度和其大小无关. 所以对于搜索来说,字典比列表更合适.
字典的构造这里列举出了字典的三种构造方式.
In [42]: bob = {'name':'bob','age':40,'job':'dev'}In [43]: bob
Out[43]: {'name': 'bob', 'age': 40, 'job': 'dev'}
In [44]: bob2 = dict(name='bob',age=40,job='dev')
In [45]: bob2
Out[45]: {'name': 'bob', 'age': 40, 'job': 'dev'}
In [46]: bob3 = dict(zip(['name','job','age'],['bob','dev',40]))
In [47]: bob3
Out[47]: {'name': 'bob', 'job': 'dev', 'age': 40}
关于zip()方法的用法,后续的文章会讲到
字典中的值可以是简单的数值和字符串,也可以是其他类型,比如:
In [48]: bob4 = {'name':{"first":'bob','last':'Smith'},'job':['dev','test'],'age':40}In [49]: bob4
Out[49]: {'name': {'first': 'bob', 'last': 'Smith'}, 'job': ['dev', 'test'], 'age': 40}
字典的键
字典的键是其索引,我们可以通过键来访问对应的数据,也可以通过键来增加新的数据. 但是对于不存在的键,同样是不支持访问的.
In [50]: abc = {'A':'a','B':'b','C':'c'}In [51]: abc['B']
Out[51]: 'b'
In [52]: abc['D']='d'
In [53]: abc
Out[53]: {'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd'}
In [54]: abc['E']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-54-15e1b0b37eaa> in <module>
----> 1 abc['E']
KeyError: 'E'
那么在访问字典数据之前,为了避免这种错误,我们可以检查一下我们要访问的键是否存在.
先说一个最容易理解的方式,通过if语句进行检查
In [57]: if 'D' in abc:...: print('hit')
...: if not 'F' in abc:
...: print('miss')
...:
hit
miss
其次还可以使用get方法来进行检查,关于get方法,做一个简单的解释.
dict.get(key, default=None) get方法可以通过键来访问数据,如果访问不到则返回第二个参数.
In [58]: value = abc.get('D',0)In [59]: value
Out[59]: 'd'
In [60]: value = abc.get('F',0)
In [61]: value
Out[61]: 0
另外,字典还支持通过keys方法返回一个包含所有键的可迭代对象.
In [67]: Ks = abc.keys()In [71]: for key in Ks:
...: print(key)
...:
A
B
C
D
元组
python中的元组可以理解为是一种不可改变的列表. 用来表示确定的元素的集合. 语法很简单.如下:
In [72]: T1 = (1,2,3)In [73]: type(T1)
Out[73]: tuple
In [74]: T1[1]
Out[74]: 2
In [77]: T1.count(2)
Out[77]: 1
In [78]: T1 +(4,5,6)
Out[78]: (1, 2, 3, 4, 5, 6)
元组同样像列表那样支持分片操作和索引. 但是元组不支持append等方法. 不准确的说,元组其实更像一个可以存放任意的类型的"字符"串.
那么,既然我们已经有了列表,为什么还需要元组呢?
元组和列表的主要区别在于,元组是不可改变的. 在一些特定的场景下,元组提供了一种完整性的约束.
文件文件是一种比较特殊的类型,没有特定的字面量可以创建文件. 一般我们是通过open函数传递一个文件名和操作符来生成文件句柄.
In [79]: f = open('data.txt','wb')In [81]: f.write(b'hello world')
Out[81]: 11
In [83]: f.close()
集合
python集合不是序列,也不是映射. 它是python中到目前为止,唯一一种不可变的对象的无序集合. 其实python中的集合其实就是数学上所谓的集合. 对,就是那个我们初中学习的交集,并集啥啥啥的玩意儿.
集合的创建有两种方法:
In [85]: X = {1,2,3,4}In [87]: Y = set([3,4,5,6])
In [88]: X
Out[88]: {1, 2, 3, 4}
In [89]: Y
Out[89]: {3, 4, 5, 6}
# 交集
In [90]: X&Y
Out[90]: {3, 4}
# 并集
In [91]: X|Y
Out[91]: {1, 2, 3, 4, 5, 6}
# 差集
In [92]: X-Y
Out[92]: {1, 2}
# X是否为Y的超集
In [93]: X>Y
Out[93]: False
其他数据类型
除了以上介绍的核心类型之外,python中的数据类型还有: