一、 列表推导式
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，
它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，
或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，
则会引发一个 TypeError 的异常。
列表推导式
x = ['1', '23', '34' ,'54']
list_x = [int(i) for i in x]
------------------------------------------------------------------------
2.1 列表推导
基础知识回顾，列表切片
list1 = list(range(10)) ==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list[0:3] = [0, 1, 2] 左边是闭合区间，右边是开
list[:4] 没有指定头发，那么默认从零开始， [0, 1, 2, 3】
list[1:] 没有指定结尾，那么默认到末尾 【1, 2, 3, 4, 5, 6, 7, 8, 9】
list[-3:] 只输出倒数三位 【 7, 8, 9]
list[:-3] 只输出前两位
复制切片 p = list1[:]
一个引子：序列中被2整除的数
# a example， 每次循环都要确定，哪部分被修改，且必须通过计数器来跟踪必须处理的元素
nums = range(10)
size = len(nums)
evens = []
i = 0
while i < size:
if i % 2 ==0:
evens.appned(i)
i += 1
evens
# 用列表推导式，十分高效简洁，且可以减少bug
[i for i in range(10) if i % 2 == 0]
# example 2, 使用enumerate， 这个内建函数为在循环中使用序列时
# 提供了更加便利的获得索引的方式
# 将列表中的元素，和它的索引一起打出来
方法1)
i = 0
seq = ['one', 'two', 'three']
for element in seq:
seq[i] = '%d: %s' % (i, seq[i])
i += 1
seq
方法2)
使用 enumerate(iterable, start=0)
enumerate()函数返回一个枚举对象，iterable必须是一个序列、一个迭代器或者其他支持迭代的对象（字符串，数组，列表等）
for index, element in enumerate(seq):
print((index, element))
也可以用用列表推导式
方法3）
# %s, %d, %f 都是一个输出格式，
# 比方这个
print ("Name:%10s Age:%8d Height:%8.2f"%("Alfred",25,1.70))
#输出效果：
Name: Alfred Age: 25 Height: 1.70
——————————————————————————————————————————————————————————————————-
def _treatment(pos, ele):
return "%d: %s" % (pos, ele)
[_treatment(pos, ele) for pos, ele in enumerate(seq)]
——————————————————————————————————————————————————————————————————-
2.2
--------------------------------------------------------------------
匿名函数 lambda
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
lambda [arg1 [,arg2,.....argn]]:expression
--------------------------------------------------------------------------------------
filter
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，
如果要转换为列表，可以使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
filter(function, iterable)
function -- 判断函数。
iterable -- 可迭代对象。
--------------------------------------------------------------------------------------
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
map(function, iterable, ...)
function -- 函数
iterable -- 一个或多个序列
--------------------------------------------------------------------------------------
二、生成式
生成器表达式的语法跟列表推导差不多，只不过把方括号换成圆括号而已。
如果生成器表达式是一个函数调用过程中的唯一参数，那么不需要额外再用括号把它围
起来。
str_1 = "QEjwqer"
tuple(ord(x) for x in str_1)
array 的构造方法需要两个参数，因此括号是必需的。 array
构造方法的第一个参数指
定了数组中数字的存储方式。
import array
array.array('I', (ord(i) for i in str1))
>> array('I', [81, 69, 106, 119, 113, 101, 114])
元组和记录
tuple1 = [("dai", "25", ), ("name", "daihao"), ("monney", "1$")]
for x in tuple1:
print('%s/%s' % x) #（%s/%s）输出第一个元素和第二个元素
for _, x in tuple1: # x表示的是元组的第二个元素
print(x)
元组还可以用来快捷赋值
city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)
等于 city, year, pop, chg, area = 'Tokyo', 2003, 32450, 0.66, 8014
还可以用 * 运算符把一个可迭代对象拆开作为函数的参数：
>>> divmod(20, 8) # divmod= （//, %）--->(a//b, a%b)
(2, 4)
还可以用 * 运算符把一个可迭代对象拆开作为函数的参数
>>> t = (20, 8)
>>> divmod(*t)
(2, 4)
>>> x1, x2 = divmod(*t)
>>> x1
2
>>> x2
4
import os
_, filename = os.path.split('/home/luciano/.ssh/idrsa.pub') # os.path.split() 将文件名和路径名分开
print(filename) --- idrsa.pub
用 * 来处理剩下的元素
>>> x
[1, (12, 33), {'w': 'wq'}]
>>> a, *b, c =x
>>> c
{'w': 'wq'}
>>>
format 实现定长（或者说是宽）输出
当对一组数据输出的时候，我们有时需要输出以指定宽度，来使数据更清晰。这时我们可以用format来进行约束。
mat = "{:20} {:28} {:32}"
print(mat.format("占4个长度","占8个长度", "占12长度"))
#如果需要居中输出在宽度前面加一个^
mat = "{:^20} {:^28} {:^32}"
print(mat.format("占4个长度","占8个长度", "占12长度"))
具名元组
优势：普通的元组，没有名称，有时候不太明白，每个字段的含义；而且具名元组很方便，不用创建类
创建一个具名元组需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可
以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。
存放在对应字段里的数据要以一串参数的形式传入到构造函数中（注意，元组的构造函
数却只接受单一的可迭代对象）。你可以通过字段名或者位置来获取一个字段的信息
对对象进行切片
str1 它的正向排序， str1[0:19] = "daihaolong_love_luo"
str1[-19:] = "daihaolong_love_luo"
str1[:-1] = str1[-19:-1] = "daihaolong_love_lu" (左闭右开，开的时候，没有选中倒数第一个)
str1 = "daihaolong_love_luo"
str1[::-1] 相当于，在开始和结束为止，右边每隔一个取一个出来
str1[::-1] = "oul_evol_gnoloahiad"
str1[::-1] 相当于，在开始和结束为止，右边每隔2个取一个出来
str1[::-2] = "oleo_nlaid"
由列表组成的列表
board = [['_'] * 3 for i in range(3)] #一个包含 3 个列表的列表，嵌套的 3 个列表各自有 3 个元素来代表井字游戏的一行方块
weird_board = [['_'] * 3] * 3 # 含有 3 个指向同一对象的引用的列表是毫无用处的
list.sort方法和内置函数sorted
与 list.sort 相反的是内置函数 sorted ，它会新建一个列表作为返回值(返回的是初始输入的参数)。
简单来说就是。sorted输出的排序，不会对源列表产生影响。list.sort会改变源列表
字典推导
列表推导和生成器表达式的概念就移植到了字典上，从而有了字典推
导（后面还会看到集合推导）。字典推导（dictcomp）可以从任何以键值对作为元素的可迭
代对象中构建出字典。
数组：
如果我们需要一个只包含数字的列表，那么 array.array 比 list 更高效。数组支持所有跟
可变序列有关的操作，包括 .pop 、 .insert 和 .extend 。另外，数组还提供从文件读取和存
入文件的更快的方法，如 .frombytes 和 .tofile 。