python（16）- python内置函数
python内置了一系列的常用函数，以便于我们使用，python英文官方文档详细说明：https://docs.python.org/3/library/functions.html
1. abs() 获取绝对值
abs(-10) --->10 abs(10) --->10 abs(0) --->0 a = -10 a.__abs__() --->10
2. all() 参数为可迭代对象，迭代对象为空时，返回True.如果迭代对象的所有元素都为真，那么返回True，否则返回False.
all(['python',123])
--->True
all([])
--->True
all([0])
--->False
all(" ")
--->True
all(1,' ',2,None)
--->False
3.any() 参数为可迭代对象，参数为空时返回True
print(any([None,0,' ',{},1]))
--->True
print(any(' '))
--->True
4.sum() 求和
res=sum(i for i in range(5)) #(i for i in range(5))为生成器表达式 print(res) --->12
5.bin() 将参数转化为二进制
print(bin(3)) --->0b11
6.bool() 布尔函数，返回bool值，False或True
print(bool(0))
--->False
print(bool(None))
--->False
print(bool(' '))
--->False
7. ascii() 调用对象的__repr__()方法，获得该方法的返回值.
8.bytes() 将一个字符串转化为字节类型
print(bytes('hello',encoding='utf8'))
--->b'hello'
s = 'python'
print(bytes(s, encoding='utf-8'))
--->b'python'
a = '王'
print(bytes(a, encoding='utf-8'))
--->b'\xe7\x8e\x8b'
9.str() 将字符类型/数值类型等转换为字符串类型
print(str(b'\xe7\x8e\x8b', encoding='utf-8')) # 字节转换为字符串 --->'王' str(1) # 整数转换为字符串 --->'1'
10.chr() 查看十进制数对应的ASCII字符
print(chr(67)) --->C print(chr(65)) --->A
11.ord() 查看某个ASCII对应的十进制数
print(ord('A'))
--->65
12.callabe() 判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例
def test():
pass
print(callable(test))
--->True
print(callable(sum))
--->True
13. classmethod() 用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法
class Province:
country = "中国"
def __init__(self, name):
self.name = name
@classmethod
def show(cls): # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls
print(cls)
# 调用方法
Province.show()
14.complie() 将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译
1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) 2 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。 3 参数source：字符串或者AST（abstract syntax trees）对象。 4 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。 5 参数model：指定编译代码的种类。可以指定'exec', 'eval', 'single'。 6 参数flag和dont_inherit：这两个参数为可选参数。
s = "print('helloworld')"
print(compile(s, "<string>", "exec"))
---><code object <module> at 0x000001C648038390, file "<string>", line 1>
15.complex()
1 创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数是字符串，则不需要指定第二个参数。 2 参数real：int，long，float或字符串。 3 参数imag：int，long，float。
x=complex(1-2j) print(x.real) --->1.0 print(x.imag) --->2.0
16. delattr() 删除对象的属性
17.int() #数据类型，整型
int num=1 #num=int(1) print(type(num)) #查看num的类型 ---> <class 'int'> print(isinstance(num,int)) #判断num是否为int类型 print(num is 1) #is 是身份运算，根据id去判断身份
18. float() 讲一个字符串或整数转换为浮点数
print(float())
--->0.0
print(float('123'))
--->123.0
print(float(1))
--->1.0
print(float('a'))
Traceback (most recent call last):
File "<pyshell#45>", line 1, in <module>
float('a')
ValueError: could not convert string to float: 'a'
19.list() 参数为可迭代对象
list x=[] x=list(i for i in range(10)) #生成器表达式，以元组的形式呈现 print(x) --->[0,1,2,3,4,5,6,7,8,9] 列表构造函数 list([iterable]) list的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。 该函数创建一个元素值，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建 列表的一个拷贝并返回，就像语句iterables[:]。
20.tuple() 元组
21.dict() 创建数据字典
d={'a':1}
d=dict(x=1,y=2,z=3)
print(d)
--->{'y':2,'x':1,'z':3}
print(dict()) 空字典
--->{}
print(dict(one = 1, two =2))
--->{'one': 1, 'two': 2}
print(dict({'one':1 ,'two':2}))
--->{'one': 1, 'two': 2}
22.set() 集合
s={1,2,3,4,4}
print(s)
--->{1,2,3,4}
s.add(5)
print(s)
--->{1,2,3,4,5}
23.frozenset() 不可变集合
frozenset([iterable])
set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set，
一般来说使用fronzet的地方都可以使用set。
参数iterable：可迭代对象。
f=frozenset({1,2,3,4})
print(type(f))
---> <class 'frozenset'>
24.dir() 不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表
print(dir()) --->['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1'] >>> dir(list) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] print(dir(sum)) #输出sum下有哪些可被sum调用的方法。（对象.方法），sum.方法
25.divmod() 分别取商和余数.二个参数x和y，输出元组（x//y,x%y）
print(divmod(100,33)) --->(3,1)
26. enumerate() 返回一个可以枚举的对象，该对象的next()方法将返回一个元组
for i in enumerate(['a','b','c','d']):
print(i)
--->(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(0, 'x')
(1, 'y')
for i in enumerate({'x':1,'y':2}):
print(i)
---->(0, 'x')
(1, 'y')
27.eval() 将字符串str中的表达式提取出来并运行
s = "1+2*3" print(type(s)) ---> <class 'str'> print(eval(s)) ---> 7
28.exec() 执行字符串或complie方法编译过的字符串，没有返回值
29.filter() 过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据
filter(function, iterable)
参数function：返回值为True或False的函数，可以为None。
参数iterable：序列或可迭代对象。
def bigerthan5(x):
return x > 5
print(filter(bigerthan5, [3, 4, 5, 6, 7, 8]))
---> [6, 7, 8]
30.format() 格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法
print("I am {0}, I like {1}!".format("xu", "moon"))
--->'I am xu, I like moon!'
31.getattr() 获取对象的属性
getattr(object, name [, defalut]) 获取对象object名为name的特性，如果object不包含名为name的特性，将会抛出AttributeError异常；如果不包含名为name的特性 且提供default参数，将返回default。 参数object：对象 参数name：对象的特性名 参数default：缺省返回值 print(getattr(list, 'append')) ---> <method 'append' of 'list' objects> mylist = [3, 4, 5] append(mylist, 6) print(mylist) --->[3, 4, 5, 6] print(getattr(list, 'add')) --->Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: type object 'list' has no attribute 'add' print(getattr(list, 'add', 'NoMethod')) ---> 'NoMethod'
32.globals() 返回一个描述当前全局变量的字典
a = 1
print(globals())
---> {'__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'a': 1, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__name__': '__main__', '__package__': None, '__spec__': None}
33.hasattr()
hasattr(object，name) 判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。 参数object：对象 参数name：特性名称 print(hasattr(list, 'append')) ---> True print(hasattr(list, 'add')) ---> False
34.hash() 哈希值
hash(object) hash是一种算法，二个数值相等hash值是确定的唯一的，常用来校验数据。
hash值不能逆推。 如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。 两个数值如果相等，则哈希值也相等。
35.hex() 十进制转化为十六进制
print(hex(10)) ---> 0xa
36. id() 查看唯一标识的身份
37. help() 返回对象的帮助文档
38. input() 获取用户输入内容
39. isinstance() 检查对象是否是类的对象，返回True或False
isinstance(obj, cls)
检查obj是否是类cls的对象, 返回True 或 False
class Foo(object):
pass
obj = Foo()
isinstance(obj, Foo)
40. issubclass() 检查一个类是否是另一个类的子类。返回True或False
issubclass(sub, super)
检查sub类是否是super类的派生类（子类）。返回True 或 False
class Foo(object):
pass
class Bar(Foo):
pass
issubclass(Bar, Foo)
41. iter()
iter(o[, sentinel]) 返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。 如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法）， 参数为整数，从零开始。如果不支持这两种功能，将触发TypeError异常。 如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无 参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。
42. len() 返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）
43. locals() 打印当前可用的局部变量的字典
不要修改locals()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。 在函数体内调用locals()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。 不能在类区域内返回自由变量。
44. lambda匿名函数
因为lambda函数没有函数名，引用计数为0，内存会被清理，所有匿名函数常与内置函数一起使用。
求出工资最高的
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
def get_value(k):
return salaries[k]
print(max(salaries))
---->yuanhao
print(max(salaries,key=get_value)) #迭代输出key,调用get_value函数，参数为key,得到每个人工资， max再进行比较工资，打印最大的人名key值
--->alex
使用匿名函数求出工资最高的
f=lambda k:salaries[k] #匿名函数不写函数名，返回值为salaries[k]
print(f) #f 相当于函数名
-----> <function <lambda> at 0x0000000002823A60>
print(f('egon'))
---->3000
print(max(salaries,key=lambda k:salaries[k])) #求出最高工资的人
---->alex
print(min(salaries,key=lambda k:salaries[k])) #求出最低工资的人
---->yuanhao
45. zip() ‘拉链’，一对一的
l1=[1,2,3]
s="hel"
for i in zip(l1,s): #zip(l1,s)为可迭代的
print(i)
---->(1, 'h')
(2, 'e')
(3, 'l')
l1=[1,2,3,4],s不变，输出结果也同上；l1不变，s="hell",输出结果也同上。
因为zip()函数为一一对应的
用zip函数求最高工资的人
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(salaries.keys(),salaries.values())#dict_keys(['egon', 'alex', 'wupeiqi', 'yuanhao']) dict_values([3000, 1000000, 10000, 2500])
z=zip(salaries.keys(),salaries.values())
print(z)
----> <zip object at 0x00000000027F3C08>
for i in z:
print(i) ---->('egon', 3000)
('alex', 1000000)
('wupeiqi', 10000)
('yuanhao', 2500)
z=zip(salaries.values(),salaries.keys()) #工资value和人名key互换位置
print(max(z))
---->(1000000, 'alex')
z=zip(salaries.values(),salaries.keys()) #因为已经迭代完成了，所以要重新迭代
print(min(z))
---->(2500, 'yuanhao')
46. sorted() 返回列表，列表包含所有的元素，按升序排列
l=[3,4,1,0,9,10] print(sorted(l)) ---->[0, 1, 3, 4, 9, 10] s="hello abc" print(sorted(s)) ----->[' ', 'a', 'b', 'c', 'e', 'h', 'l', 'l', 'o'] #降序 reverse 反转 print(sorted(l,reverse=True)) ---->[10, 9, 4, 3, 1, 0]
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(sorted(salaries)) #默认是按照字典salaries的key去排序的
----->['alex', 'egon', 'wupeiqi', 'yuanhao']
排序且修改 l=[3,2,0,10] l=sorted(l) print(l) --->[0, 2, 3, 10]
47. map() 映射，第一个参数为函数，第二个参数为可迭代对象
l=[1,2,3,4,7,5]
x=[i**2 for i in l]
print(x)
---->[1, 4, 9, 16, 49, 25]
#上述用map函数实现
#迭代取l 的值，传递给lamba函数
m=map(lambda item:item**2,l)
print(m)
----><map object at 0x00000000021DC3C8>
for i in m:
print(i)
--->1 4 9 16 49 25
for 循环也可用print(list(m))来实现，不过要重新迭代
m=map(lambda item:item**2,l)
print(list(m))
---->[1, 4, 9, 16, 49, 25]
map(function, iterable,...) 对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回。 如果有多个iterable参数，那么fuction函数必须接收多个参数，这些iterable中相同索引处的元素将并行的作为function函数的参数。 如果一个iterable中元素的个数比其他少，那么将用None来扩展改iterable使元素个数一致。 如果有多个iterable且function为None，map()将返回由元组组成的列表，每个元组包含所有iterable中对应索引处值。 参数iterable必须是一个序列或任何可遍历对象，函数返回的往往是一个列表(list)。 li = [1,2,3] data = map(lambda x :x*100,li) print(type(data)) data = list(data) print(data) 运行结果： <class 'map'> [100, 200, 300]
48.max() 返回给定元素里最大值
max(iterable [,args...][, key]) 如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最大的非空元素。 如果提供多个参数，那么返回值最大的那个参数。 可选参数key是单参数的排序函数。 如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)
49.min() 返回给定元素里最小值
min(iterable [,args...][, key]) 如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最小的非空元素。 如果提供多个参数，那么返回值最小的那个参数。 可选参数key是单参数的排序函数。 如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)
50.object()
1 获取一个新的，无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。 2 该函数时2.2.版本新增，2.3版本之后，该函数不接受任何参数。
51.open() 打开文件
open(filename [, mode [, bufsize]]) 打开一个文件，返回一个file对象。 如果文件无法打开，将处罚IOError异常。 应该使用open()来代替直接使用file类型的构造函数打开文件。 参数filename表示将要被打开的文件的路径字符串； 参数mode表示打开的模式，最常用的模式有：'r'表示读文本，'w'表示写文本文件，'a'表示在文件中追加。 Mode的默认值是'r'。 当操作的是二进制文件时，只要在模式值上添加'b'。这样提高了程序的可移植性。 可选参数bufsize定义了文件缓冲区的大小。0表示不缓冲；1表示行缓冲；任何其他正数表示使用该大小的缓冲区； 负数表示使用系统默认缓冲区大小，对于tty设备它往往是行缓冲，而对于其他文件往往完全缓冲。如果参数值被省却。 使用系统默认值。
52.print() 输出函数
python2中的print语句被python3中的print()函数取代。
如何限制print的默认换行：
1. python2版本下，在print输出的最后加一个逗号','
2. python3.4以后，print(value, ...,sep='',end='\n',file=sys.stdout,flush=False),将end设为空即可。
53.range() 根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数
用于创建包含连续算术值的列表(list)。常用于for循环。参数必须是普通整数。 参数step默认值为1，参数start的默认值为0。 全参数调用该函数将返回一个普通整数列表。 step 可以是正整数或者负整数。不可以为0，否则将处罚ValueError异常。 range(3)代表0,1,2.等价于range(0,3) print(range(0,10,2)) #第一个参数是起始数，第二个是终止数(不包含这个)，第三个数步数 ---->[0,2,4,6,8]
55. repr() 将任意值转换为字符串，供计时器读取的形式
返回一个对象的字符串表示。有时可以使用这个函数来访问操作。 对于许多类型来说，repr()尝试返回一个字符串，eval()方法可以使用该字符串产生对象； 否则用尖括号括起来的，包含类名称和其他二外信息的字符串被返回。
56.reversed() 反转，逆序对象，反着排序。
返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__()) 该函数是2.4中新增的
print(list(reversed([1,3,5,9]))) ----->[9,5,3,1]
57.round() 四舍六入五留双，五留双留离整数最近的偶数
print(round(10.3)) ----> 10 print(round(10.5)) ----> 10 print(round(10.6)) ----> 11 print(round(10.9)) ----> 11 print(round(11.5)) ----> 12
58.pow() 幂函数
print(pow(3,2)) #3**2 ---->9 print(pow(3,2,2)) #3**2%2 ---->1
59. reduce() 合并，第一个参数为函数，第二个参数为可迭代对象。第三个参数可有可无，默认初始值。
from functools import reduce #合并 l=list(range(100)) print(l) ---->[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] print(reduce(lambda x,y:x+y,l,100)) i=iter(l) # 100 next(i) --->100,0----->x,y-x+y-->100 # 100 next(i)---->100,1----->x,y--x+y-->101 # 101 next(i)----->101,2 ---->5050
60. filter 过滤
name_l=[
{'name':'egon','age':18},
{'name':'dragonFire','age':1000},
{'name':'gaoluchuan','age':9000},
{'name':'fsw','age':10000},
]
f=filter(lambda d:d['age'] > 100,name_l)
print(f)
-----><filter object at 0x00000000027DCCF8>
print(list(f)) #与map函数不同的是其返还的是查询的内容
---->[{'name': 'dragonFire', 'age': 1000},{'name': 'gaoluchuan', 'age': 9000},{'name': 'fsw', 'age': 10000}]
for i in f: print(i)
---->{'name': 'dragonFire', 'age': 1000}
{'name': 'gaoluchuan', 'age': 9000}
{'name': 'fsw', 'age': 10000}
61.oct() 十进制转化为八进制
print(oct(10)) ---->0o12
62.slice 切片
l=[1,2,3,4,5] print(l[2:4]) --->[3,4] s=slice(2,4) print(l[s]) ---->[3,4]
63. vars 没有参数时和locals()一样，有参数得到字典
64. __import__
import time
#print(time) ----><module 'time' (built-in)>
time.sleep(3)
上述代码等价于下面代码内容
m=__import__('time')
#print(m) ----><module 'time' (built-in)>
m.sleep(3)
64. 简单列表(list)排序
list = ['a', 'b', 'c'] print(sorted(list)) # ['a', 'b', 'c'] print(sorted(list, reverse=True)) # ['c', 'b', 'a']
65. 字典(dict)的键(key)排序
dict = {'c': 1, 'b': 2, 'a': 3}
print(sorted(dict))
# ['a', 'b', 'c']
print(sorted(dict, reverse=True))
# ['c', 'b', 'a']
66. 字典(dict)的值(value)排序
dict = {'c': 1, 'b': 2, 'a': 3}
print(sorted(dict, key=lambda k: dict[k]))
# ['c', 'b', 'a']
print(sorted(dict, key=lambda k: dict[k], reverse=True))
# ['a', 'b', 'c']
67. 列表(list)内嵌套列表(list)排序
list = [[4, 2, 9], [1, 5, 6], [7, 8, 3]] # 以列表中列表的第一个数排序 print(sorted(list, key=lambda k: k[0])) # [[1, 5, 6], [4, 2, 9], [7, 8, 3]] # 以列表中列表的第二个数排序 print(sorted(list, key=lambda k: k[1])) # [[4, 2, 9], [1, 5, 6], [7, 8, 3]] # 以列表中列表的第三个数排序 print(sorted(list, key=lambda k: k[2])) # [[7, 8, 3], [1, 5, 6], [4, 2, 9]] # 以列表中列表的第一个数排序，且降序 print(sorted(list, key=lambda k: k[0], reverse=True)) # [[7, 8, 3], [4, 2, 9], [1, 5, 6]]
68. 字典(dict)内嵌套字典(dict)排序
dict = {
'a': {'x': 3, 'y': 2, 'z': 1},
'b': {'x': 2, 'y': 1, 'z': 3},
'c': {'x': 1, 'y': 3, 'z': 2}
}
# 以内部字典的'x'对应的值排序
print(sorted(dict, key=lambda k: dict[k]['x']))
# ['c', 'b', 'a']
# 以内部字典的'y'对应的值排序
print(sorted(dict, key=lambda k: dict[k]['y']))
# ['b', 'a', 'c']
# 以内部字典的'z'对应的值排序
print(sorted(dict, key=lambda k: dict[k]['z']))
# ['a', 'c', 'b']
# 以内部字典的'x'对应的值排序,并降序
print(sorted(dict, key=lambda k: dict[k]['x'], reverse=True))
# ['a', 'b', 'c']
69. 列表(list)中嵌套字典(dict)排序
list = [
{'x': 3, 'y': 2, 'z': 1},
{'x': 2, 'y': 1, 'z': 3},
{'x': 1, 'y': 3, 'z': 2},
]
print(sorted(list, key=lambda k: k['x']))
# [{'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}]
print(sorted(list, key=lambda k: k['y']))
# [{'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}]
print(sorted(list, key=lambda k: k['z']))
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}]
print(sorted(list, key=lambda k: k['x'], reverse=True))
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 3, 'x': 2, 'y': 1}, {'z': 2, 'x': 1, 'y': 3}]
70. 字典(dict)中嵌套列表(list)排序
dic = {
'a': [1, 2, 3],
'b': [2, 1, 3],
'c': [3, 1, 2],
}
print(sorted(dic, key=lambda k: dic[k][0]))
# ['a', 'b', 'c']
print(sorted(dic, key=lambda k: dic[k][1]))
# ['b', 'c', 'a']
print(sorted(dic, key=lambda k: dic[k][2]))
# ['c', 'b', 'a']
print(sorted(dic, key=lambda k: dic[k][0], reverse=True))
# ['c', 'b', 'a']
