内置函数（二）

1.4.2和数据结构相关（24）

　　列表和元祖（2）

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

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

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

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

字符串转换成元祖

str1 ='abcd123'
tup2 =tuple(str1)
print(tup2)

列表转换成元祖

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

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

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

列表的转换

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

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

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

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

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

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

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

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

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

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

a1 = '太白'
# print(a1.encode('utf-8'))
print(a1.encode('utf-8').decode())

bytes：unicode ---> bytes 类型
a1 = '太白'
b1 = bytes(a1,encoding='utf-8')
print(b1)

a1 = -100
b1 = -100
print(id(a1))
print(id(b1))

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

ret = bytearray('alex',encoding='utf-8')
print(id(ret))
print(ret)  # bytearray(b'alex')
print(ret[0])  # 97
ret[0] = 65
print(ret)  # bytearray(b'Alex')
print(id(ret))

memoryview

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

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

print(ord('a'))
print(ord('中'))

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

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

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

a = '孙飞'
print(a)
print(repr(a))

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

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

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

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

列表的排序

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

def func1(x):
    return x[1]
print(sorted(l2,key=func1,reverse=True))

字典的排序

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

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

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

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

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

l1 = [1,'',[1,3],(2,4)]
print(all(l1))
l2 = []
l3 = {}
l4 =''
print(all(l2))
print(all(l3))
print(all(l4))

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

print(any([1,0,'',()]))
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为可迭代对象

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

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

l1 = [1,2,3,4]
# print([i**2 for i in l1])
def func(x): return x**2
print(list(map(func,l1)))

l2 =[1,2,3,4,5]
l3 = ['a','b','c','d']
l4 = ['a','b','c','d']
def add(x,y,z):
    return x*y+z
print(list(map(add,l3,l2,l4)))

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

匿名函数可以赋值给变量

func2 = lambda x : x**2
print(func2(6))

func2 = lambda x,y: x+y
print(func2(1,2))

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

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

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

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

实例：

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