python常识(二)

list.sort( key=None, reverse=False)

key -- 只有一个传入参数的函数,参数取自于可迭代对象中

reverse=True表示降序, reverse=False表示升序

该方法没有返回值,但会改变原列表

>>># 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
 
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
random.sort(key=takeSecond)
 
# 输出类别
print ('排序列表：', random)

排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

---

列表作为队列使用(“先进先出”), collections.deque被设计用于快速地从两端操作

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

---

一些编程小技巧

# 构造一个元素位置与原列表相对一致的新列表
>>>[(x, y) for i,x in enumerate([1,2,3]) for j,y in enumerate([3,1,4]) if i==j]
[(1, 3), (2, 1), (3, 4)]

# 从一个多维列表中取出最内层列表的每一个元素
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 矩阵的转置
>>> 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]]

---

zip(*iterables)函数, 创建一个聚合了来自每个可迭代对象中的元素的迭代器.
返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。
当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。
# zip('ABCD', 'xy') --> Ax By

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

---

del语句的使用,, 移除列表的一个元素,一个切片,甚至清空整个列表

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
# 也可以删除整个变量, 此后再引用 a 时会报错
>>> del a

---

关于集合类型
集合是由不重复元素组成的无序的集。它的基本用法包括成员检测和消除重复元素。
集合对象也支持像 联合，交集，差集，对称差分等数学运算。
类似于<u>列表推导式</u>，集合也支持推导式形式
花括号或 set() 函数可以用来创建集合。
注意：要创建一个空集合你只能用 set() 而不能用 {}，因为后者是创建一个空字典

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

# 推导式形式
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

---

关于字典:
可以用 del 来删除一个键值对。
对一个字典执行 list(d) 将返回包含该字典中所有键的列表，按插入次序排列
(如需其他排序，则要使用 sorted(d))。
要检查字典中是否存在一个特定键，可使用 in 关键字。

# 添加新键值对
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}

# 删除键值对
>>> del tel['sape']

# 返回包含所有键的列表
>>> list(tel)
['jack', 'guido']

# 按键升序排序
>>> sorted(tel)
['guido', 'jack']

# dict() 构造函数可以直接从键值对序列里创建字典。
>>> 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}

---

**比较操作符in和not in校验一个值是否在一个序列里;操作符is和is not比较两个对象是不是同一个对象.
所有的比较操作符的优先级都比数值运算符低.
在and or not中,优先级not > and > or
因此A and not B or C 等价于 (A and (not B)) or C
布尔运算符 and 和 or 也被称为 短路 运算符：它们的参数从左至右解析，一旦可以确定结果解析就会停止。
例如，如果 A 和 C 为真而 B 为假，那么 A and B and C 不会解析 C
**

>>>print(0 or 'a' or 'b')
a
>>>print(0 and 'a' and 'b')
0

---

关于海象运算符:=Python 3.8 新增功能,把变量赋值和使用合在一起。这个是新加的语法，3.8之前不支持。

if (n := len(a)) > 10:
    pass

# 相当于

n = len(a)
if n > 10:
    pass

---

关于序列比较:
序列对象通常可以与相同序列类型的其他对象比较。
首先比较开头的两个对应元素，如果两者不相等则比较结果就由此确定；
如果两者相等则比较之后的两个元素，以此类推，直到有一个序列被耗尽。
如果要比较的两个元素本身又是相同类型的序列，则会递归地执行上述顺序比较。
比如t1 = (1, 2, ('aa', 'ab')) ,t2 = (1, 2, ('abc', 'a'), 4)中
比较双方的第一个元素,它们都是1 -> 第二个元素,都是2 -> 第三个元素,分别是 ('aa', 'ab')和('abc', 'a')
(接着在内部进行了这样的比较: -> 'aa'和'abc' ->'a'和'a' ->'a' 和 'b')
至此由于'a'<'b',因此我们可以知道t1 < t2
另外,如果一个序列是另一个的初始子序列，则较短的序列被视为较小

>>>(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)
True
>>>(1, 2, 3, 4)           < (1, 2, 4)
True
>>>(1, 2)                 < (1, 2, -1)
True

---

关于函数标注:
函数标注 以字典的形式存放在函数的 __annotations__ 属性中，并且不会影响函数的任何其他部分。
形参标注的定义方式是在形参名称后加上冒号，后面跟一个表达式，该表达式会被求值为标注的值。
返回值标注的定义方式是加上一个组合符号 ->，后面跟一个表达式

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

---