Python初识之内置函数二

数据结构相关

　列表和元组：list()、tuple()、reversed()、slice()

l=[1, 2, 3, 4, 5]
l.reverse()  # 列表顺序反转
l2 = reversed(l)  # 得到一个反序的迭代器
print(l)
print(l2)

l=[1, 2, 3, 4, 5]
sli = slice(0, 3, 1)  # slice切片函数
print(l[sli])

　字符串相关:str()、format()、bytes()、bytearray()、memoryview()、ord()、chr()、ascii()、repr()

print(format('test', '<20'))  # 文本左对齐，一共20格 
print(format('test', '>20'))  # 文本右对齐，一共20格
print(format('test', '^20'))  # 文本居中对齐，一共20格

ret = bytes('你好，世界', encoding='utf-8')  # bytes确定编码方式
print(ret.decode())  # decode解码至unicode编码方式

ret = bytearray('你好', encoding='utf-8')  # 可以生成字符串的16进制编码列表，想修改时可以修改列表中的元素，节省内存
print(ret)

memoryview()  # 切片--字节类型，不占内存，但是想查看得转换成字符串类型，占内存，用处不大

print(ord('a'))  # 字符按照unicode转为数字
print(chr(99))  # 数字按照unicode转字符
print(ascii('Q'), ascii('臣'))  # 若元素在ascii码中就不改变打印，若不在则输出为u···

name = 'egg'
print(repr('你好%s'% (name)))
print(repr('你好%r'% (name)))  # 相比较%s而言，%r连着格式输出

 　字典、集合相关:dict()、set()、frozenset()、len()、all()、any()、enumerate()、sorted()、zip()、map()、filter()

print(len([1,2,3]))  # 长度（元素个数）
print(all(['a', '', 0, 2, 3]))  # 只接受可迭代类型，只要接收的可迭代类型中有一个元素是False，结果就是False
print(any(['a', '', 0]))  # 只接受可迭代类型，只要接收的可迭代类型中有一个元素是True，结果就是True

dic = {'a':1, 'b':2}
for k in enumerate(dic,1):  # 枚举，返回一个个小元组，可修改起始值
    print(k)

l = [1, 2, 3]
l2 = ['a', 'b', 'c', 'd']
for i in zip(l, l2):  # zip()被称为拉链方法，将l和l2合并,以少的一方为基础，结合两个列表形成元组
    print(i)
# 字典和元组也可以，字典可以选用key还是values
l3=(1,2,3)
l4={4:'a',5:'b'}
for i in zip(l3,l4.values()):
    print(i)

def func(x):
    return x%2==0  # 利用filter取出偶数
ret = filter(func,[2, 3, 4, 5, 6, 7, 8])  # filter的作用就是利用func函数进行一次筛选，func函数需要有判断的作用返回True或者False
print(list(ret))  # 注意filter返回的是一个迭代器,且执行前后不改变可迭代对象的值，只是进行筛选，所以执行完之后的集合<=执行之前

def func(x):
    return x**2  # 利用map求可迭代类型数据的平方
ret = map(func,[1, 2, 3, 4, 5])  # map的作用就是利用func函数对数据进行一次处理
print(list(ret))  # map函数执行前后元素的个数不变，值改变

# sorted(iterable,key=None,reverse=False)
# iterable:传入一个可迭代类型
# key:传入一个函数名，函数的参数是可迭代数据的每一个元素，根据返回值大小排序,但不改变原数据
# reverse:True表示降序 False表示升序
l = [-5, 2, 3, -4, 1]
l.sort(key=abs)  # 成员函数l.sort()在原列表的基础上进行排序
print(l)
l1= [1, 2, 3, -4, -5]
print(sorted(l1, key=abs, reverse=True), '
', l1)  # sorted()函数不改变原列表，生成了一个新列表

匿名函数：lambda()

# 函数名 = lambdad 参数：返回值  # lambda是匿名函数的关键字，参数可以有多个，用逗号隔开
# 匿名函数的特点：不管逻辑多复杂都只能写一行，逻辑执行后的内容就是返回值，返回值和正常的函数类型一致，可以是任意数据类型
print(list(map(lambda n: n**2,[1, 2, 3])))

　　匿名函数面试题三道精讲：

# 1.下面程序的输出结果
d = lambda p:p+2
t = lambda p:p*3
x = 2
x = d(x)
x = t(x)
x = d(x)
print(x)

# 2.现有两元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
t1 = (('a'),('b'))
t2 = (('c'),('d'))
print([{k:v} for k,v in zip(t1,t2)])  # 第一种方法，利用zip函数形成元组，用for循环取元组中的值构成字典，用列表生成器完成要求
l = lambda a,b:[{k:v} for k,v in zip(a,b)]  # 第二种方法，利用zip函数形成元组，用for循环取元组中的值构成字典，用匿名函数返回成列表完成要求
print(l(t1,t2))
print(list(map(lambda t:{t[0]:t[1]}, zip(t1, t2))))  # 第三种方法，利用zip函数形成的元组，用map调用元组，利用元组的索引和匿名函数完成要求

# 3.以下代码的输出是什么？请给出答案并解释。
def multipliers():
    return [lambda x:i*x for i in range(4)]  # 注意函数调用返回时执行了四次，但并没有被m调用，所以i的值已经成为了3
print([m(2) for m in multipliers()])  # 调用后函数其实执行的是2*3，执行了4次
# 请修改multipliers的定义来产生期望的结果。
# 将列表表达式改为生成器表达式即可解决问题，生成器返回时不会执行，只有在m调用时才执行，所以可以解决问题

　　在看到匿名函数时要想起5大内置函数，min()、max()、filter()、map()、sorted()