Python内置函数和匿名函数

内容回顾:

1.列表推导式

[变量(加工后的变量) for 变量 in iterable] 循环模式

[变量(加工后的变量) for 变量 in iterable if 条件] 筛选模式

生成器表达式

(变量(加工后的变量) for 变量 in iterable) 循环模式

(变量(加工后的变量) for 变量 in iterable if 条件) 筛选条件

obj = (i for i in [1,2,3]) (1,2,3)
obj.__next__()
for i in obj:
　　pass
list(obj)

2.内置函数

python提供的常用方法,方便开发使用.

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

print(dir(str)

print(dir('abc')

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

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

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

基础数据类型相关

数字相关

数据类型:

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

print(bool(''))

**int: 函数用于将一个字符串或数字转换为整形.

print(int('111'))

print(int(12.73)) # 浮点型 转化成整数(取整)

print(int('12.73') #报错

print(int('0100',base=2)) # 将2进制的0100转化成十进制. 结果为4

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

print(1.22,type(1.22))

*complex: 函数用于创建一个值为 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

数学运算:

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

print(abs(-5)) # 5

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

print(divmod(7,3))

print(divmod(103,8))

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

print(round(2.3287654)) #默认保留整数

print(round(2.3287654,2)) # 保留两位小数,若最后一位小数是0,则不保留

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

print(pow(3,3)) # pow(x,y) x**y

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

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

l1 = [1,2,3,55,77]

print(sum(11))

print(sum(11,100)) # 设置初始值

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

l1 = [1,2,3,55,77]

l2 = [-1,-2,3,55,-77]

print(min(l1))

print(min(l2,key=abs))

***max: 返回可迭代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值).

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))

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

l1 = [1,2,3]

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

l3 = list((1,2,3))

print(l3)

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

相关内置函数

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

l1 = [22,33,55,11]

print(reversed(l1))

for i in reversed(l1):

　　print(i)

**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'))

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

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

unicode ---> utf-8

s1 = 'alex'

b1 = s1.encode('utf-8')

print(b1)/

print(b1)

s2 = b1.decode('utf-8')

print(s2)

s1 = '中国'

b1 = s1.encode('utf-8')

b2 = b1.decode('utf-8').encode('gbk')

print(b2)

*bytearray: 返回一个新字节数组. 这个数组里的元素是可变的, 并且每个元素的值范围: 0 <= x <256.

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

print(id(ret))

print(ret)

print(ret[0])

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

print(repr('中国'))

print(repr('{"name":"alex"}'))

s1 = '我是%s人' % ('中国')

s2 = '我是%r人' % ('中国')

print(s1)

print(s2)

数据集合

dict: 创建一个字典.

set: 创建一个集合.

frozenset: 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素.

相关内置函数:

*** 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: 枚举,返回一个枚举对象.

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

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

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

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):
    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])])