内置函数

Posted 2020-12-31 qilin610

1.4.2和数据结构相关（24）

　　列表和元祖（2）

list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。

1 dic ={1:2,3:4}
2 print(list(dic))

tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）
字典转换成元祖

1 dic1={‘a‘:2,3:4}
2 tu1=tuple(dic1)
3 print(tu1)
4 dic2 = dict([tu1])
5 print(dic2)

字符串转换成元祖

1 str1 =‘abcd123‘
2 tup2 =tuple(str1)
3 print(tup2)

列表转换成元祖

1 lis1 = [1,2,3,4]
2 tup3 = tuple(lis1)
3 print(tup3)

reversed：将一个序列翻转，并返回此翻转序列的迭代器。
字符串的翻转

1 str = ‘abcdefg‘
2 print(reversed(str))    #<reversed object at 0x0000018530CF9E48>
3 print(list(reversed(str)))  #[‘g‘, ‘f‘, ‘e‘, ‘d‘, ‘c‘, ‘b‘, ‘a‘]

列表的转换

1 lis = [1,2,3,4,5,6]
2 reversed(lis)
3 print(list(reversed(lis)))

字典的转换(字典不支持翻转)

1 dic ={1:2,3:4,5:6}
2 print(list(reversed(dic)))  #TypeError: ‘dict‘ object is not reversible

集合的转换(集合不支持翻转)

 1 set1 ={1,2,3,4}
 2 reversed(set1)  #TypeError: ‘set‘ object is not reversible

 slice：构造一个切片对象，用于列表的切片。

1  lis = [1,2,3,4,5,6]   #列表切片
2  l1 =slice(0,6,3)
3  print(lis[l1])
4  str =‘abcdefghi‘  #字符串切片
5 sl=slice(0,len(str),2)
6 print(str[sl])

format:与具体数据相关，用于计算各种小数，精算等。

1 print(format(‘test‘,"<20"))     #一行20个字符test左对齐
2 print(format(‘test‘,">20"))      #一行20个字符test左对齐
3 print(format(‘test‘,"^20"))      #一行20个字符test居中对齐

bytes：unicode ---> bytes 类型  ****

 1 a1 = ‘太白‘
 2 # print(a1.encode(‘utf-8‘))
 3 print(a1.encode(‘utf-8‘).decode())
 4 
 5 bytes：unicode ---> bytes 类型
 6 a1 = ‘太白‘
 7 b1 = bytes(a1,encoding=‘utf-8‘)
 8 print(b1)
 9 
10 a1 = -100
11 b1 = -100
12 print(id(a1))
13 print(id(b1))

bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

1 ret = bytearray(‘alex‘,encoding=‘utf-8‘)
2 print(id(ret))
3 print(ret)  # bytearray(b‘alex‘)
4 print(ret[0])  # 97
5 ret[0] = 65
6 print(ret)  # bytearray(b‘Alex‘)
7 print(id(ret))

memoryview

1 ret = memoryview(bytes(‘你好‘,encoding=‘utf-8‘))
2 print(len(ret))  # 6
3 print(ret)  # <memory at 0x000001D3D6FCD048>  # [xe4,xbd,xa0,xe5,xa5,xbd]
4 print(bytes(ret[:3]).decode(‘utf-8‘))  # 你
5 print(bytes(ret[3:]).decode(‘utf-8‘))  # 好

ord:输入字符找该字符编码 unicode  的位置  **

1 print(ord(‘a‘))
2 print(ord(‘中‘))

chr:输入位置数字找出其对应的字符 unicode **

1 print(chr(97))
2 print(chr(20013))
3 ascii:是ascii码中的返回该值，不是则返回他在unicode的位置（16进制。） **
4 print(ascii(‘a‘))
5 print(ascii(‘中‘))  # ‘u4e2d‘

repr:返回一个对象的string形式（原形毕露）

1 a = ‘孙飞‘
2 print(a)
3 print(repr(a))

repr()  json pickle序列化模块 特殊字符串，python字符串的区别

格式化输出 %r
msg = ‘alex 是 %r的人‘ % (‘德高望重‘)
print(msg)

sorted：对所有可迭代的对象进行排序操作。
sorted（iterable，key,reverse=）
iterable:可遍历的对象：
key：接受的函数
reverse翻转
字符串排序，返回排序后的列表

1 str =‘2abc3de5f1g‘
2 print(sorted(str,reverse=True))  #可以将字符转转换为列表，注意与split的区别

列表的排序

 1 lis = [1,2,‘a‘,6,‘p‘]
 2 print(sorted(lis))  #不支持字符串和和数字列表直接排序‘<‘ not supported between instances of ‘str‘ and ‘int‘
 3 lis1 = [2,4,6,7,1,9,3]
 4 print(sorted(lis1))   #形成的时一个新列表，原列表不变
 5 l2 = [(1,1000),(2,18),(4,250),(3,500)]
 6 print(sorted(l2))
 7 
 8 def func1(x):
 9     return x[1]
10 print(sorted(l2,key=func1,reverse=True))

字典的排序

1 dic = {3:2,2:5,7:6,1:0}
2 print(sorted(dic))  #默认是以key排序
3 print(sorted(dic,key=lambda x:dic[x])) #自定义函数按后面元素排序

enumerate:枚举，返回一个枚举对象。可以用循环遍历得到对象的元素对应的所以和元素组成的元祖

1 ls =[1,2,3,4,5]
2 print(enumerate(ls))    #<enumerate object at 0x000001942E68C750>
3 print(list(enumerate(ls)))  #[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
4 for i in enumerate(ls,1):   #可以修改索引的初始值
5     print(i)

结果
(1, 1)
(2, 2)
(3, 3)
(4, 4)
(5, 5)

all：可迭代对象中，全都是True才是True 或为空时为True ***  多做条件判断

1 l1 = [1,‘‘,[1,3],(2,4)]
2 print(all(l1))
3 l2 = []
4 l3 = {}
5 l4 =‘‘
6 print(all(l2))
7 print(all(l3))
8 print(all(l4))

any：可迭代对象中，有一个True 就是True ,或为空时False ***  多做条件判断

1 print(any([1,0,‘‘,()]))
2 print(any([]))

zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。 *****
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
拉链方法  将多个iter 纵向组成一个个元组。

l1 = [1,2,3,5,6,7]
tu1 = (‘alex‘,‘太白‘, ‘wusir‘, ‘女神‘)
dic = {‘name‘: ‘日天‘, ‘age‘:28, ‘hobby‘: ‘tea‘, ‘weight‘:100}
# print(zip(l1,tu1,dic))
for i in zip(l1,tu1):
    print(i)

filter：过滤· 迭代器。 *****
filter(function=,iterable=)
function为可自定值得函数（过滤条件）
iterable为可迭代对象

1 l1 = [i for i in range(10)]
2 def func1(x):
3     return x % 2 == 0
4 print(list(filter(func1,l1)))

map:会根据提供的函数对指定序列做映射,返回映射对象。 循环模式
map(function,iter1,iter2)

 1 l1 = [1,2,3,4]
 2 # print([i**2 for i in l1])
 3 def func(x): return x**2
 4 print(list(map(func,l1)))
 5 
 6 l2 =[1,2,3,4,5]
 7 l3 = [‘a‘,‘b‘,‘c‘,‘d‘]
 8 l4 = [‘a‘,‘b‘,‘c‘,‘d‘]
 9 def add(x,y,z):
10     return x*y+z
11 print(list(map(add,l3,l2,l4)))

匿名函数  lambda表达式，
普通函数 有且只有返回值的函数才可以用匿名函数进行简化，一行函数。
func2 = lambda x: x*2
相当于
def func2(x):
    return x**2

匿名函数可以赋值给变量

1 func2 = lambda x : x**2
2 print(func2(6))
3 
4 func2 = lambda x,y: x+y
5 print(func2(1,2))

匿名函数 不单独使用，多与内置函数结合。

1 l2 = [(1,1000),(2,18),(4,250),(3,500)]
2 print(sorted(l2,key=lambda x:x[1]))

匿名函数可以用于三元运算

1 func = lambda x,y:x if x > y else y
2 print(func(89,98))

实例：

 1 dic={‘k1‘:10,‘k2‘:100,‘k3‘:30}
 2 #1,利用内置函数匿名函数将dic按照值进行排序。
 3 print(sorted(dic,key=lambda x:dic[x]))
 4 print(sorted(dic.items(),key=lambda x:x[1]))
 5 [1,5,7,4,8]
 6 #利用内置函数匿名函数 计算列表的每个数的2倍。
 7 print(list(map(lambda x:x*2,[1,5,7,4,8])))
 8 [5,8,11,9,15]
 9 #利用内置函数匿名函数，将值大于10的留下来。
10 print(list(filter(lambda x: x>10,[5,8,11,9,15])))