day013 内置函数

查看内置属性dir()

print(dir()) # 打印dir的内置属性

print(dir([]))  # 打印列表的内置属性

迭代器生成器相关range,next,iter

range() # 自动生成一个列表

a=iter('asd') # 把迭代对象转换成迭代器

 print(next(a))

print(next(a))  # 用next把迭代器里面的内容一个一个取出来

基础数据类型相关bool,int,float,complex

>>>complex(1, 2)

(1 + 2j)

>>> complex(1)    # 数字

(1 + 0j)

>>> complex("1")  # 当做字符串处理

(1 + 0j)

# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错

>>> complex("1+2j")

(1 + 2j)

进制转换bin,oct,hex

print(bin(10),type(bin(10)))    # 十进制转换成二进制字符串并返回,

print(oct(10),type(oct(10)))    # 十进制转换成八进制字符串并返回

print(hex(10),type(hex(10)))    # 将十进制转换成十六进制字符串并返回

数学运算

abs：函数返回数字的绝对值。

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

round：保留浮点数的小数位数，默认保留整数。

pow：求x**y次幂。（三个参数为x**y的结果对z取余）

print(abs(-6))  #返回这个数的绝对值

print(divmod(9,6))  # 计算除数与被除数的结果,返回一个包含商和余数的元组(a//b,a%b)

print(round(3.999,2))   #保留浮点数的小数位数,默认保留整数,四舍五入

print(pow(6,6,7))   # 3个参数,1**2的次幂,算好之后再对参数3的取余

sum：对可迭代对象进行求和计算（可设置初始值）。

min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。

max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。

print(sum([1,2,3],10))  # 计算所有数的和,参数1是要算的可迭代对象,参数2是计算的起始位置

print(min([1,2,3])) #返回此序列的最小值

print(min([1,6,-0,-6],key=abs)) #取绝对值的最小数

dic = {'add':12,'ass':35}    # 取这个字典所有value的最小的那个print(max(dic,key=lambda x:dic[x]))

列表和元祖

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

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

print(tuple({'ass':123,'add':456})) # 他们都是取的是字典key的值

print(list({'ass':123,'add':456}))

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

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

ite = reversed([1,2,3,4,5,6])   # 将一个序列翻转,并返回翻转序列的迭代器

print(list(ite))

li = [1,2,3,4,56,78,9,6,3,2,2,2,2,2]

sli_obj=slice(-3)

print(li[sli_obj])

sli_obj=slice(0,7,3) # 就类似于一个固定的切割方法

print(li[sli_obj])

字符串相关 

str：将数据转化成字符串。

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

print(format(3,'b'))    # 转换为二进制

print(format(6400,'c'))   # 转换为unicode对应的字符

print(format(11,'d'))   # 转换为十进制

print(format(11,'o'))   # 转换为8进制

print(format(11,'x') )   #转换为16进制,小写字母表示

print(format(11,'X'))   #转换为16进制,大写字母表示

print(format(11,'n'))   # 和d一样

print(format(11))   # 默认也和d一样

bytes：用于不同编码之间的转化

k =bytes('数',encoding='utf-16') # 可以转换成任意编码的bytes

print(k)

print(k.decode('utf-16')) # encode和decode是配套使用

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

ret = bytearray('alex',encoding='utf-8')

print(id(ret))

print(ret)

print(ret[0])

ret[0] = 65

print(ret)

print(id(ret))

memoryview:没什么用

ret = memoryview(bytes('你好',encoding='utf-8'))

print(len(ret))

print(ret)

print(bytes(ret[:3]).decode('utf-8'))

print(bytes(ret[3:]).decode('utf-8'))

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

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

ascii:是ascii码中的返回该值，不是就返回/u...

print(ord('a'))

print(ord('国')) #输入字符找到该字符编码的位置

print(chr(97))  # 输入未知数字找到对应的字符

print(chr(20018))

print(ascii('a'))   # 是ascii码中的返回值,不是返回/u

print(ascii('哈'))

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

print(repr('{1,2}'))  # 里面是什么样还返回什么样

数据集合 

　　　　dict：创建一个字典。

　　　　set：创建一个集合。

　　　　frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

　　　相关内置函数（8）

 　　　　len:返回一个对象中元素的个数。

　　　　 sorted：对所有可迭代的对象进行排序操作。

li = [1,4,-5,6,7,-8,9]

print(sorted(li,reverse=True)) # 排序降序

print(sorted(li)) # 排序升序

enumerate:枚举，返回一个枚举对象。

print (list( enumerate([1,2,3],100))) # 返回这个列表的每个值和它的索引,你也可以设置它索引的起始位置

all：可迭代对象中，全都是True才是True

any：可迭代对象中，有一个True 就是True

print(all((1,2,6))) # all当所有为True才为真和and相似

print(any([0,'',[],{},(),({}),1]))#当一个为真都为真

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

li1= "1234"

li2= "1234"

li3= "1234"

print(list(zip(li1,li2,li3))) # 用zip返回一个迭代器,他是竖着切下来的,按照最短的那个结束

filter：过滤·

lst = filter(lambda x:x%3==0,[1,2,3,4,5])# 和筛选式列表一样

print(set(lst))

map:他就和循环性列表推导式一样

print(list(map(lambda x : x**3,(1,2,3))))

匿名函数

函数名 = lambda 参数 ：返回值

参数可以有多个，用逗号隔开

匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值

返回值和正常的函数一样可以是任意数据类型

dic={'k1':10,'k2':100,'k3':30}

print(max(dic))

print(dic[max(dic,key=lambda k:dic[k])])