Python学习从0开始——005数据结构

一、列表list
二、元组和序列
三、集合
四、字典
五、循环技巧
六、条件控制
七、序列和其它类型的比较

一、列表list

不是所有数据都可以排序或比较。例如，[None, ‘hello’, 10] 就不可排序，因为整数不能与字符串对比，而 None 不能与其他类型对比。有些类型根本就没有定义顺序关系，例如，3+4j < 5+7j 这种对比操作就是无效的。

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
#返回列表中元素 x 出现的次数
>>> fruits.count('apple')
2
#索引
>>> fruits.index('banana')
3
#从索引4开始查找
>>> fruits.index('banana', 4)
6
#反转
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
#末尾添加
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
#排序
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
#移除并返回
>>> fruits.pop()
'pear'

列表推导式：

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
... 
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]#简洁版
>>> squares=[]
>>> squares = [x**2 for x in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#元组
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]#嵌套的列表
>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]
#进行转置
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

列表推导式的方括号内包含以下内容：一个表达式，后面为一个 for 子句，然后是零个或多个 for 或 if 子句。结果是由表达式依据 for 和 if 子句求值计算而得出一个新列表。表达式是元组（例如上例的 (x, y)）时，必须加上括号。

二、元组和序列

输出时，元组都要由圆括号标注，这样才能正确地解释嵌套元组。输入时，圆括号可有可无，不过如果元组是更大的表达式的一部分会经常加上。不允许为元组中的单个元素赋值，但是可以创建含列表等可变对象的元组。
元组是 immutable （不可变的），一般可包含异质元素序列，通过解包或索引访问（如果是 namedtuples，可以属性访问）。列表是 mutable （可变的），列表元素一般为同质类型，可迭代访问。
构造 0 个或 1 个元素的元组比较特殊：为了适应这种情况，对句法有一些额外的改变。用一对空圆括号就可以创建空元组；只有一个元素的元组可以通过在这个元素后添加逗号来构建（圆括号里只有一个值的话不够明确）。

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
#不可变
>>> t[0] = 88888
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])#用一对空圆括号就可以创建空元组
>>> empty = ()
#通过在这个元素后添加逗号来构建
>>> singleton = 'hello', 
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

三、集合

集合是由不重复元素组成的无序容器。基本用法包括成员检测、消除重复元素。集合对象支持合集、交集、差集、对称差分等数学运算。
创建集合用花括号或 set() 函数。注意，创建空集合只能用 set()，不能用 {}，{} 创建的是空字典。

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False
#去重
>>> basket
{'banana', 'orange', 'apple', 'pear'}>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'r', 'c', 'a', 'd', 'b'}
>>> b
{'m', 'c', 'a', 'z', 'l'}
#a有b无
>>> a-b
{'d', 'r', 'b'}
#b有a无
>>> b-a
{'m', 'l', 'z'}
#或
>>> a|b
{'m', 'r', 'c', 'a', 'z', 'd', 'l', 'b'}
#与
>>> a&b
{'a', 'c'}
#异或
>>> a^b
{'m', 'd', 'r', 'l', 'z', 'b'}

四、字典

字典是以键进行索引的，键可以是任何不可变类型；字符串和数字总是可以作为键。如果一个元组只包含字符串、数字或元组则也可以作为键；如果一个元组直接或间接地包含了任何可变对象，则不能作为键。列表不能作为键，因为列表可以使用索引赋值、切片赋值或者 append() 和 extend() 等方法进行原地修改列表。
可以把字典理解为键值对的集合，但字典的键必须是唯一的。花括号 {} 用于创建空字典。另一种初始化字典的方式是，在花括号里输入逗号分隔的键值对，这也是字典的输出方式。
字典的主要用途是通过关键字存储、提取值。用 del 可以删除键值对。用已存在的关键字存储值，与该关键字关联的旧值会被取代。通过不存在的键提取值，则会报错。
对字典执行 list(d) 操作，返回该字典中所有键的列表，按插入次序排列（如需排序，请使用 sorted(d)）。检查字典里是否存在某个键，使用关键字 in。

>>> tel = {'jack': 4098, 'sape': 4139}
#由键取值
>>> tel['jack']
4098
#无则添加
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
#可赋值
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127, 'irv': 4127}
#由键删除
>>> del tel['sape']
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
#值排序
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
#其它创建方式
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

五、循环技巧

#对字典执行循环时，可以使用 items() 方法同时提取键及其对应的值。
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
... 
gallahad the pure
robin the brave#在序列中循环时，用 enumerate() 函数可以同时取出位置索引和对应的值：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
... 
0 tic
1 tac
2 toe
#同时循环两个或多个序列时，用 zip() 函数可以将其内的元素一一匹配：
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
... 
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.
#为了逆向对序列进行循环，可以求出欲循环的正向序列，然后调用 reversed() 函数
>>> for i in reversed(range(1, 10, 2)):
...     print(i)
... 
9
7
5
3
1
#按指定顺序循环序列，可以用 sorted() 函数，在不改动原序列的基础上，返回一个重新的序列：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for i in sorted(basket):
...     print(i)
... 
apple
apple
banana
orange
orange
pear
#set() 去重，使用 sorted() 加 set() 则按排序后的顺序，循环遍历序列中的唯一元素：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
... 
apple
banana
orange
pear#在循环中修改列表的内容时，创建新列表比较简单，且安全：
>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
...     if not math.isnan(value):
...         filtered_data.append(value)
... 
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

六、条件控制

运算符优先级：数值运算符>比较运算符>布尔运算符。

比较运算符 in 和 not in 用于执行确定一个值是否存在（或不存在）于某个容器中的成员检测。运算符 is 和 is not 用于比较两个对象是否是同一个对象。所有比较运算符的优先级都一样，且低于任何数值运算符。比较操作支持链式操作。例如，a < b == c 校验 a 是否小于 b，且 b 是否等于 c。

比较操作可以用布尔运算符 and 和 or 组合，并且结果都可以用 not 取反。这些操作符的优先级低于比较操作符；not 的优先级最高， or 的优先级最低，因此，A and not B or C 等价于 (A and (not B)) or C。与其他运算符操作一样，此处也可以用圆括号表示想要的组合。

布尔运算符 and 和 or 是所谓的短路运算符：其参数从左至右求值，一旦可以确定结果，求值就会停止。例如，如果 A 和 C 为真，B 为假，那么 A and B and C 不会对 C 求值。用作普通值而不是布尔值时，短路运算符的返回值通常是最后一个求了值的参数。

Python 与 C 不同，在表达式内部赋值必须显式使用海象运算符 :=。

七、序列和其它类型的比较

序列对象可以与相同序列类型的其他对象比较。这种比较使用字典式顺序：首先，比较前两个对应元素，如果不相等，则可确定比较结果；如果相等，则比较之后的两个元素，以此类推，直到其中一个序列结束。如果要比较的两个元素本身是相同类型的序列，则递归地执行字典式顺序比较。如果两个序列中所有的对应元素都相等，则两个序列相等。如果一个序列是另一个的初始子序列，则较短的序列可被视为较小（较少）的序列。对于字符串来说，字典式顺序使用 Unicode 码位序号排序单个字符。

当比较不同类型的对象时，只要待比较的对象提供了合适的比较方法，就可以使用 < 和 > 进行比较。例如，混合的数字类型通过数字值进行比较，所以，0 等于 0.0，等等。如果没有提供合适的比较方法，解释器不会随便给出一个比较结果，而是引发 TypeError 异常。

>>> (1, 2, 3)              < (1, 2, 4)
True
>>> [1, 2, 3]              < [1, 2, 4,5]
True
>>> [1, 2, 3]              < [1, 2]
False
>>> [1, 2, 3]              < [1, 2, 3,5]
True
>>> (1, 2, 3, 4)           < (1, 2, 4)
True
>>> (1, 2, 3)             == (1.0, 2.0, 3.0)
True
>>> (1, 2)                 < (1, 2, -1)
True
>>> (1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)
True
>>> 'ABC' < 'C' < 'Pascal' < 'Python'
True