Python学习笔记：序列构成的数组

列表推导是一种构建列表（list）的快捷方式

#列表推导
symbols = '!@#$%'
codes = [ord(symbol) for symbol in symbols] #ord()Python内置函数，将字符变成Unicode码位，返回值为对应十进制
print(codes)

 列表推导同filter()和map()比较

"""
1.fitter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
语法：
filter(function, iterable)
参数：
function -- 判断函数
iterable -- 可迭代对象

2.map()函数会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法：
map(function, iterable, ...)
参数：
function -- 函数
iterable -- 一个或多个序列

3.lambda函数是一个简短的匿名函数，可以接收任意数量的参数，但只能包含一个表达式。
语法：
lambda 参数：表达式
"""

symbols = '!@#$%'
codes = [ord(symbol) for symbol in symbols if ord(symbol) > 50]
print(codes)

codes = list(filter(lambda c: c > 50, map(ord, symbols)))
print(codes)

笛卡尔积：用列表推导可以生成两个或以上的可迭代类型的笛卡儿积。笛卡儿积是一个列表，列表里的元素是由输入的可迭代类型的元素对构成的元组，因此笛卡儿积列表的长度等于输入变量的长度的乘积

colors = ['black', 'white']
sizes = ['S', 'M', 'L']
tshirt = [(color, size) for color in colors for size in sizes]
print(tshirt)

tshirt = [ ]
for color in colors:
    for size in sizes:
        tshirt.append((color, size))
print(tshirt)

tshirts = [(color, size) for size in sizes
                         for color in colors]
print(tshirts)

虽然也可以用列表推导来初始化元组、数组或其他序列类型，但是生成器表达式是更好的选择。这是因为生成器表达式背后遵守了迭代器协议，可以逐个地产出元素，而不是先建立一个完整的列表，然后再把这个列表传递到某个构造函数里。前面那种方式显然能够节省内存。生成器表达式的语法跟列表推导差不多，只不过把方括号换成圆括号而已。

#用生成器表达式初始化元组和数组
symbols = '!@#$%'
codes = tuple(ord(symbol) for symbol in symbols)
print(codes)

import array
arr = array.array('I', (ord(symbol) for symbol in symbols))
print(arr)

#使用生成器表达式计算笛卡尔积
colors = ['black', 'white']
sizes = ['S', 'M', 'L']

# '%s'%表示格式化一个对象为字符
for tshirt in ('%s %s' % (c, s) for c in colors for s in sizes):
    print(tshirt)

—————————————————————————————————————————————————————————

元组拆包可以应用到任何可迭代对象上，唯一的硬性要求是，被可迭代对象中的元素数量必须要跟接受这些元素的元组的空档数一致。除非我们用 * 来表示忽略多余的元素。

#元组拆包: 平行赋值，也就是说把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中
alpha_num = ('a', 97)
alpha, num = alpha_num
print(alpha, num)

#不使用中间变量交换两个变量的值
a = 'a'
b = 97
b, a = a, b
print(a, b)

#用 * 运算符把一个可迭代对象拆开作为函数的参数
print(divmod(20, 8))#divmod(a, b)函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
t = (20, 8)
print(divmod(*t))

#让一个函数可以用元组的形式返回多个值
import os
_, filename = os.path.split('test.txt')#函数返回路径和文件名
print(filename)

#用*来处理剩下的元素
a, b, *rest = range(5)
print(a, b, rest)
#在平行赋值中，* 前缀只能用在一个变量名前面，但是这个变量可以出现在赋值表达式的任意位置
a, *body, c, d = range(5)
print(a, body, c, d)

#嵌套元组拆包
alpha_a = [('a', 'A', (97, 65))]
for small, capital, (num_small, num_capital) in alpha_a:
    print(num_small, num_capital)

#具名元组collections.namedtuple 是一个工厂函数，它可以用来构建一个带字段名的元组和一个有名字的类
#创建一个具名元组需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。
from collections import namedtuple
Country_Capital = namedtuple('c_c', 'country capital')
comb = Country_Capital('China', 'Beijing')
print(comb)

#具名元组还有一些自己专有的属性。中就展示了几个最有用的：_fields 类属性、类方法 _make(iterable) 和实例方法_asdict()。
#_fields 属性是一个包含这个类所有字段名称的元组，
#用 _make() 通过接受一个可迭代对象来生成这个类的一个实例，它的作用跟City(*delhi_data) 是一样的。
#_asdict() 把具名元组以 collections.OrderedDict 的形式返回，我们可以利用它来把元组里的信息友好地呈现出来。
print(Country_Capital._fields)
print(Country_Capital._make(comb))
print(comb._asdict())
for key, value in comb._asdict().items():
    print(key + ':', value)

 ——————————————————————————————————————————————————————