day14

列表和元祖

list:将一个可迭代对象转化成列表(如果是字典,默认将key作为列表的元素)

tuple:将一个可迭代对象转化成元祖(如果是字典,将默认key作为列表的元素)

reversed:将一个序列翻转,并返回翻转序列的迭代器

dic = {'name':'we','age':223,'hobby':'old'}
print(reversed(l1))
for i in reversed(l1):
    print(i)            #倒着从大到小
for i in reversed(s1):
    print(i)            #字符串可以翻转
for i in reversed(dic):
    print(i)              #字典不能反转

slice:构造一个切片对象,用于列表的切片,变成一个切片模板,后面的列表只需要引用就可以

1 = [i for i in range(10)]
l2 = l1[2:5]
print(l2)
l3 = [i for i in range(10,30)]
s = slice(0,5,2)
print(l3[s])

str:将数据转化成字符串

l = [1,2,3,4,5]
l2 =str(l)
print(l2,type(l2))
for i in l:
    print(str(i),type(str(i)))

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

print(format('test','<20'))
print(format('test','>20'))
print(format('test','^20'))

bytes:unicode ----->bytes 类型  互相转化

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

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  asiic码
ret[0] = 65         #把asiic码97换成65
print(ret)          #打印出相应的字母 
print(id(ret))      #bytearray(b'Alex')

memoryview

ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))           #6,按照字节,中文三个字节一个字符
print(ret)
print(bytes(ret[:3]).decode('utf-8'))        #你
print(bytes(ret[3:]).decode('utf-8'))        #好

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

print(ord('a'))       #97
print(ord('中'))      #20013

chr:输入位置数字找出相应的字符 unicode

print(chr(97))
print(chr(20013))

ascii:是ascii码中的返回该值,不是则返回他在unicode的位置(16进制)

print(ascii('a'))      #'a'
print(ascii('中'))      #'\u4e2d'

repr:返回一个对象的string形式(原形毕露)

print('alex')           #alex
print(repr("alex,x"))   #'alex,x'
print(repr("{'alex':'sb'}"))    #"{'alex':'sb'}"

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

格式化输出%s,字符串,%d,数字,%r,加引号

msg = 'alex是%r的人' % ('德高望重')
print(msg)          #alex是'德高望重'的人

sort:改变的是原列表

l1 = [8,7,6,4,3,5,6,7,9,2,1]
l1.sort()
print(l1)       #原列表变换

sorted:对所有与可迭代的对象进行排序操作

l1 = [8,7,6,4,3,5,6,7,9,2,1]
print(sorted(l1))  #形成了一个新列表
print(l1)          #原列表不变

　按照列表内元祖的第二个值排序

l2 = [(1,1000),(2,18),(4,250),(3,500)]
print(sorted(l2))     #这是按照第一个值排序呢
def func(x):
    return x[1]
print(sorted(l2,key=func))

enumerate:枚举,返回一个枚举对象

l1 = [1,2,3,4,5,6,7,8,9]
for k,v in enumerate(l1):
    print(k,v)  #输出的一个是索引位置,一个是对应的值

all:可迭代对象中,全部都是True才是True

l1 = [1,'',[1,3],(2,4)]
print(all(l1))   #返回False

any:可迭代对象中,有一个True,就是True

print(any([1,0,'',()]))    #True

zip:函数用于将可迭代的对象作为参数,将对象中一应的元素打包成一个个元祖,然后返回由这些元祖组成的列表

l1  = [1,2,3,4,5,6]
tu1 = ('alex','taibai','wusir','女神')
dic = {'name':'ske','age':23,'hobby':'tea','weight':20}
print(zip(l1,tu1,dic))
for i in zip(l1,tu1,dic):
    print(i)         #(1, 'alex', 'age')  (2, 'taibai', 'hobby')....

　并且以最短的为结束

filter:过滤,迭代器

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

map:会根据提供的函数对指定序列做映射,循环模式

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

匿名函数的表达式:lambda

普通函数,有且只有返回值的函数才可以用匿名函数进行简化,一行函数

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

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

l2 = [(1,200),(2,345),(6,29384),(3,500000)]
print(sorted(l2,key=lambda x:x[1]))