Python列表推导

一、 列表推导式

 

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}\t{:28}\t{:32}"

print(mat.format("占4个长度","占8个长度", "占12长度"))

#如果需要居中输出在宽度前面加一个^

mat = "{:^20}\t{:^28}\t{:^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 。