博文
Day16 重要的内置函数
|
一、python的数据类型和数据结构
（一）数据类型
python中有六种标准数据类型：数字（number）、字符串（str）、列表（list）、元组（tuple）、集合（sets）、Dictionary（字典）
其中，除列表和字典外，其他数据类型皆为不可变数据类型
（二）数据结构
python 中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（sets）是三类主要的容器。
列表与元组：
列表用[],元组用()
列表内容可变，元组内容不可变，但可以通过嵌套的形式添加
元组内可嵌套列表
在定义只有一个元素的元组时，加入逗号一面产生和数学运算的歧义
元组通常有不同的数据类型，而列表是相同类型的数据队列，元组表示的是结构，而列表表示的顺序
列表不能当作字典的Key，而元组可以
二、内置函数
1、reverse():
是python中列表的一个内置方法（也就是说，在字典，字符串或者元组中，是没有这个内置方法的），用于列表中数据的反转；
l = [1,2,4,3] l.reverse() print(l) ''' [3, 4, 2, 1] '''
其实，l.reverse()这一步操作的返回值是一个None，其作用结果需要通过打印被作用的列表才可以查看出具体的效果。
2、reversed()
是python自带的一个方法，准确的说应该是一个类；reverse(sequence)——>反转迭代器的序列值，返回的是一个反向的迭代器，也就是说，在经过reversed(）的作用后，返回的是一个把序列值经过反转之后的迭代器，所以，需要通过遍历，或者list，或者next()等方法，获取作用后的值。
l = [1,2,6,4] print(list(reversed(l))) ''' [4, 6, 2, 1] ''' tu = (1,3,2) print(tuple(tu)) ''' (1, 3, 2) ''' l = [1,2,3,4] l2 = reversed(l) print(l2) # <list_reverseiterator object at 0x0000020BF48DF708>,为节省空间生成一个迭代器 # 保留原列表，返回一个反序的迭代器 for i in l2: print(i)
3、slice()
slice()函数实现切片对象，主要用在切片操作函数里的参数传参，返回一个切片对象
slice(start,stop,step)，start--起始位置，stop--结束位置，step--间距
l = (1,2,3,4,5,6) sli = slice(1,5,2) # 得到的是一个切片规则 print(l[sli]) #两者相同，其实内部机制都一样 print(l[1:5:2])
4、.format()
（1）字符串格式化
str.format(),增强了字符串格式化的功能。
基本语法是通过{}和:来代替以前的%，format函数可以接受不限个参数，位置可以不按顺序。
（2）数字格式化
print(format('test','<20')) #开20个字符的空间左对齐
print(format('test','^20'))#开20个字符的空间居中
print(format('test','>20'))#开20个字符的空间靠右5、bytes()函数
bytes()函数返回一个新的bytes对象，该对象是一个0<=x<=256区间内的整数不可变序列，它是bytearray的不可变版本。
bytes()把utf-8类型，转换成bytes(utf-8,gbk)类型，数据读到内存里都是unicode,需要根据需要转成utf-8或gbk（即bytes类型）
由gbk转成utf-8的过程，首先将数据读到内存里，将gbk转化成unicode(.decode())，再转成utf-8(bytes())。
print(bytes('你好',encoding='GBK')) # GBK类型的bytes
print(bytes('你好',encoding='utf-8')) # utf-8类型的bytes
print(bytes('你好',encoding='GBK').decode('gbk'))
print(bytes('你好',encoding='utf-8').decode('utf-8'))
print(bytes('你好',encoding='GBK').decode('utf-8')) #报错
'''
b'\xc4\xe3\xba\xc3'
b'\xe4\xbd\xa0\xe5\xa5\xbd'
你好
你好
'''6、bytearray()
bytearray()方法返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围：0<=x<=256。
b_array = bytearray('你好', encoding='utf-8')
print(b_array)
print(b_array[0])
'''
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
228
'''7、ord()函数和chr(）函数
ord()函数是chr(）函数（对于8位的ASCII字符串）或unichr()函数（对于Unicode对象）的配对函数，它以一个字符（长度位1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的Unicode字符超出了你的python定义范围，则会引发typeerror的异常。
print(ord('a'))
print(chr(97))
print(ord('好')) # unicode中的
print(ascii('1'))8、repr()函数
repr(）函数将对象转化为供解释器读取的形式。
语法：repr(object)
参数：object——对象
返回值：返回一个对象的string格式
name = 'egg'
print('你好%s'%name) # %s对应str
print('你好%r'%name) # %r对应repr
print(repr('1')) #repr让一个字符原封不动的输出
print(repr(1))
'''
你好egg
你好'egg'
'1'
1
'''三、重要的内置函数
1、all()函数、any()函数
all()函数用于判断给定的可迭代参数iterable中的所有元素是否都为True，如果是返回True，否则，返回False。元素除了是0，空，None，False外都算True。
print(all(['a','',123])) print(all(['a',123])) print(all([0,123])) # any ，若可迭代对象中，有一个True则返回True print(any(['a','',123])) ''' False True False True '''
2、zip()函数
zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表。
l=[1,2,3] l2=['a','b','c'] print(zip(l,l2)) # 迭代器 for i in zip(l,l2): print(i) ''' <zip object at 0x000001CF5A1CA088> (1, 'a') (2, 'b') (3, 'c') '''
l=[1,2,3] l2=['a','b','c','d'] l3=['*','**',[1,2]] for i in zip(l,l2,l3): print(i) ''' (1, 'a', '*') (2, 'b', '**') (3, 'c', [1, 2]) '''
l=[1,2,3]
l2=['a','b','c','d']
l3=['*','**',[1,2]]
d = {'k1':1,'k2':2} #只添加key,且无序
for i in zip(l,l2,l3,d):
print(i)
'''
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')
'''3、filter()函数
filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件元素组成的新列表。
该函数接受两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或False，最后将返回True的元素放到新列表中。
语法：filter(function,iterable)，function——判断函数。iterable——可迭代对象。返回值：返回列表。
def is_odd(x): #判断奇数偶数 return x%2 ==1 ret = filter(is_odd,[1,4,6,9,63]) # [i for i in [1,4,6,9,63] if i%2 ==1] print(ret) #迭代器 for i in ret: # 输出的都是奇数 print(i)
def is_odd(x): return x%2 ==1 ret = filter(is_odd,[1,2,3,4]) for i in ret: print(i)
# 筛选字符串,过滤列表中所有字符串 def is_str(s): if type(s) == str: return True ret = filter(is_str,[1,2,3,4,'hello','world','hello world']) for i in ret: print(i) ''' hello world hello world '''
def is_str(s): return type(s) == str ret = filter(is_str,[1,2,3,4,'hello','world','hello world']) for i in ret: print(i)
删除None或者空字符串
def str(s): if type(s) != int: return s and s.strip() else: return s ret = filter(str,[1,2,3,4,[],' ','hello', None,'']) for i in ret: print(i) ''' 1 2 3 4 hello '''
过滤100以内数字平方根是整数的数
from math import sqrt def func(x): # res = sqrt(x) # return res%1 ==0 return pow(x,0.5).is_integer() ret = filter(func,range(1,101)) for i in ret: print(i)
4、map()
map（）会根据提供的函数对指定序列做映射，第一个参数function以参数序列中的第一个元素调用function函数，返回包含每次function函数返回的新列表
语法：map(function,iterable,...)，function——函数，iterable——一个或多个序列，返回值：python3.x返回迭代器。
def square(x): return x**2 ret = map(square,[1,2,3,4]) for i in ret: print(i) # == ret = map(lambda x:x**2,[1,2,3,4]) for i in ret: print(i) ''' 1 4 9 16
ret = map(abs,[1,-4,6,-8]) print(ret) for i in ret: print(i)
filter：执行了filter之后的结果集合数目一定小于等于执行之前的个数，filter只管筛选，不会改变原来的值。
map：元素执行前后，元素个数不变，而值可能发生改变。
5、sort()和sorted()
(1) sort()函数
用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法：list.sort(key=None, reverse=False)，key——主要是用来进行比较的元素，只有一个参数，具体的函数参数就是取自可迭代对象中，指定可迭代对象中的一个元素来进行排序。resverse——排序规则，reverse=True降序，reverse=False，升序（默认），该方法没有返回值，但是会对列表的对象进行排序。
l = [1,-9,8,7] l.sort() print(l) ''' [-9, 1, 7, 8] '''
l = [1,-9,8,7] l.sort(key=abs) print(l)
(2) sorted()函数
对所有可迭代的对象进行排序操作。
sort和sorted区别：sort是应用再list上的方法，sorted可以对所有可迭代的对象进行排序操作。list的sort方法返回的是对已经存在的列表进行操作，无返回值，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作，比较占内存。
sorted()语法：
sorted(iterable,cmp=None,key=None,reverse=False)
参数说明：cmp——比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。key——主要是用来进行比较的元素，只有一个参数，具体的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素进行排序。reverse——排序规则，reverse=True降序，reverse=False升序（默认）。
返回值：返回重新排序的列表。
l = [1,-9,8,7] print(sorted(l)) # l = [1,-9,8,7] print(sorted(l, reverse = True)) # l = [1,-9,8,7] print(sorted(l, reverse = True,key = abs)) # 根据绝对值进行排序 # 按照列表中每个元素的len排序 l = ['1','3456','2','123'] new_l = sorted(l, key=len) print(new_l)
6、匿名函数
python使用lambda来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多
lambda的主题是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，但却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法：
lambda[arg1,[,arg2,...,argn]]:expression
为了解决哪些功能很简单的需求而涉及的一句话函数 def calc(n): return n*n print(calc(10))
# 换成匿名函数,匿名函数不允许换行 calc = lambda n:n*n print(calc(10))
def add(x,y): return x+y add = lambda x,y:x+y print(add(1,2))
dic = {'k1':10,'k2':100,'k3':30}
def func(k):
return dic[k]
print(max(dic,key=func))
# ===
print(max(dic,key=lambda k:dic[k]))筛选列表中大于10的数 res = filter(lambda x:x>10,[5,8,9,6155]) for i in res: print(i)
min、max、filter、map、sorted都可以于lambda合作
例题：
# 例2 现有两元组(('a'),('b')), (('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
#匿名函数 == 内置函数
# zip
ret = zip((('a'),('b')),(('c'),('d')))
def func(tup):
return {tup[0]:tup[1]}
res = map(func,ret)
# ==
res = map(lambda tup:{tup[0]:tup[1]},ret)
print(list(res))# 例3 def mul(): #生成器 return [lambda x:i*x for i in range(4)] print([m(2) for m in mul()]) def mul(): # 迭代器 return (lambda x:i*x for i in range(4)) print([m(2) for m in mul()]) # 执行过程 def mul(): return [lambda x:i*x for i in range(4)] print([m(2) for m in [lambda x:i*x,lambda x:i*x,lambda x:i*x,lambda x:i*x]])
https://blog.sciencenet.cn/blog-3405644-1222841.html
上一篇：Day15生成器函数进阶
下一篇：Day17 递归函数
