day15 内置函数 续及 匿名函数

1查看内置属性

**dir:讲对象的所有方法名放置在一个列表中,并返回

print(dir(str))
print(dir("abc"))  查看字符串的各种用法

***range:函数可创建一个整数对象  一般用在for循环中

 **next 内部实际用了__next__方法,返回迭代器的下一个项目

**iter 函数用来生成迭代器 (讲一个可迭代对象,生成迭代器)

基础数据类型相关

1  数字相关(14)

　　数字类型(4)

　　　　**bool :用于将给定参数转换为布尔类型  如果没有参数 返回 Flase

　　　　　**int  函数用于讲一个字符串或数字转换为整型

例

print(bool(""))
print(int("111"))
print(int(12.73))
print(int("12.73"))  #报错
print(int("0100",base=2)

　　**float: 函数用于将证书和字符串转换成浮点数

print(1.22,type(1.22))  #1.22 <class 'float'>

　　*compelx:用于创建一个值位real+imag*j的复数或者转化为字符串

如果第一个参数为字符串,则不需要指定第二个参数

# print(complex(1,2))
# *bin：将十进制转换成二进制并返回。
# print(bin(3))  # 0b11
# *oct：将十进制转化成八进制字符串并返回。
# print(oct(9)) # 0o11
# print(oct(10)) # 0o11
# *hex：将十进制转化成十六进制字符串并返回。
# print(hex(10))  # 0xa
# print(hex(15))  # 0xf
# print(hex(17))  # 0x11

数学运算(7)

abs : 函数返回数字的绝对值

print(abs(-5))  #5

**divmod:计算除数与被除数的结果 返回一个包含商和余数的元祖

print(divmod(7,3))    #(2, 1)
print(divmod(103,8))  #(12, 7)

　　*round:保留浮点数的小数位数,默认保留整数

print(round(2.32561))  #2
print(round(2.3987,2))  #2.40

　　*pow  求x**y的次幂  (三个参数为x**y对z取余)

print(pow(3,3))  # pow(x,y) x ** y   27 
print(pow(3,3,5))  # pow(x,y) x ** y  2

　　***sum  对可迭代对象进行求和计算(可设置初始值)

l1 = [1, 2, 3, 55, 77]
print(sum(l1))   #138
print(sum(l1,100)) # 设置初始值  238

　***min:返回可迭代对象的最小值(可加key  key位函数名  通关函数的规则返回最小值)

l1 = [1, 2, 3, 55, 77]
l2 = [-1, -2, 3, 55, -77]
print(min(l1))  
print(min(l2,key=abs))  
print(max(l1))
print(max(l2,key=abs))

　　

dic = {'a': 3,'b': 2,'c': 1}
def func(x): 
    return dic[x]
print(min(dic,key=func))
print(max(dic,key=func))
lis = [[1517991992.94, 100], [1517992000.94, 200], [1517992014.94, 300], [1517992744.94, 350], [1517992800.94, 280]]
def func1(x): 
    return x[1]
print(max(lis,key=func1))

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

l1 = [1,2,3]
l2 = list([1,2,3])  #创建列表
l3 =  list((1,2,3))
print(l1)
print(l2)
print(l3)

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

相关内置函数

***reversde:讲一个序列翻转,冰返回此翻转序列的迭代器

l1 = [22, 33, 55, 11]
print(reversed(l1))
for i in reversed(l1):
    print(i)   #  11  55 33  22

　　**slice: 构造一个切片对象,用于列表的切片

l1 = [1, 2, 3, 55, 77]
l2 = [-1, -2, 3, 55, -77, 88]
print(l1[1:4])
print(l2[1:4])
rule = slice(1,6,2)  #步长
print(l1[rule])    
print(l2[rule])

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

print(format('test', '<20'))  #开头
print(format('test', '>20')) # 结尾是test
print(format('test', '^20'))  #居中

　　bytes:用于不同编码之间的转化 将unicode ---> bytes

s1 = 'alex'
b1 = s1.encode('utf-8')
b1 = bytes(s1,encoding='utf-8')
print(b1)  #b'alex'
print(b1)   #b'alex'
s2 = b1.decode('utf-8')
print(s2)  #alex
s1 = '中国'
b1 = s1.encode('utf-8')
b2 = b1.decode('utf-8').encode('gbk')
print(b2)  #b'xd6xd0xb9xfa'

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

ret = bytearray('alex', encoding='utf-8')  # [97,104,101,109]
print(id(ret))  #查看内存地址
print(ret)
print(ret[0])
ret[0] = 65
print(ret)  # [65,104,101,109]
print(id(ret))
2527428514512
bytearray(b'alex')
97
bytearray(b'Alex')
2527428514512

　　*memoryview

 ret = memoryview(bytes('你好',encoding='utf-8')) # [xe4,xbd,xa0,xe5,xa5,xbd]
# # 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'))
# print(ord('我'))
# *chr: 输入位置数字找出其对应的字符 unicode
# print(chr(97))
# *ascii: 是ascii码中的返回该值，不是就返回 / u...
# print(ascii('a'))
# print(ascii('中国'))  # 'u4e2du56fd'

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

print(repr('中国'))
print(repr('{"name": "alex"}'))
s1 = '我是%s人' % ('中国')
s2 = '我是%r人' % ('中国')
print(s1)
print(s2)

　　数据集合(3)

　　　　dict：创建一个字典。
　　　　set：创建一个集合。

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

  相关内置函数（8）

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

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

l1 = [1, 4, 5, 77, 2, 3,]
print(sorted(l1))
L = [('a', 4), ('c', 3), ('d', 1),('b', 2), ]
def func2(x):
    return x[1]
l2 = sorted(L,key=func2)
print(l2)　　

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

lst=[1,2,3,1]
for index,tupe  in enumerate(lst):
    print(index, tupe)  获取到他的索引跟元素

　　

　**all：可迭代对象中，全都是True才是True
　**any：可迭代对象中，有一个True

l1 = ['asv', 1, True]
print(all(l1))  #True
l2 = [True,"", 0, ()]
print(any(l2))  #True

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

l1 = [1, 2, 3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3), 2, 4)
print(zip(l1,l2,l3)) #可以视为:[(1, 'a', '*'),(2, 'b', '**'),(3, 'c', (1, 2, 3))]
for i in zip(l1,l2,l3): #(1, 'a', '*')(2, 'b', '**')(3, 'c', (1, 2, 3))
    print(i)

　　*** filter：过滤·

def func(x):
    return x % 2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
    print(i)
print((i for i in [1,2,3,4,5,6,7] if i % 2 == 0))

　　***map:会根据提供的函数对指定序列做映射。

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

　　

匿名函数 一句话函数 一行表示

def func1(x,y): return x+y
func = lambda x,y : x+y
print(func1(1,2))
print(func(1,2))
lis = [[1517991992.94, 100], [1517992000.94, 200], [1517992014.94, 300], [1517992744.94, 350], [1517992800.94, 280]]
# def func1(x): return x[1]
# func1 = lambda x:x[1]
print(max(lis,key=lambda x:x[1]))

dic={'k1':10,'k2':100,'k3':30}
print(dic[max(dic,key=lambda x: dic[x])])