一、列表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