Python 内置函数 I

1.今日内容

1. 内置函数I
2. 匿名函数
3. 内置函数II

2.具体内容

1. 内置函数I

   内置函数：内置的函数，python中的内置函数有68种，13种是在面向对象

   1、eval exce 去掉字符串两边的引号，还原本身（慎用）

   s1 = "{1:'dog'}"
   s2 = '1+3'
   #eval 剥取字符串的外衣，返回里面的本质
   ret = eval(s1)
   print(ret,type(ret))#{1: 'dog'} <class 'dict'>
   print(eval(s2)) #4
   #exec 代码流，过程
   s3 = '''
   for i in range(3):
   	print(i)
   '''
   exec(s3)#1 2 3
   

   2、hash() 获取对象的哈希值

   print(hash(123))
   print(hash('qw'))
   

   3、 help() 使用说明

   print(help(str.count))
   

   4、 callable ** 判断对象是否可以调用

   def a():
     pass
   b = 2
   print(callable(a))#T
   print(callable(b))#F
   

   5、int() ** 取整，将字符串转换成整数

   print(int('321'))#321
   print(int(3.14))#3
   #将一个字符串类型的转化成真正的十进制
   print('00000101',2)#5
   

   6、float() 将整数和字符串转换成浮点型

   print(float(321))#321.0
   print(float('321'))#321.0
   

   7、complex
   8、 bin() 将十进制转化成二进制
   9、oct() 将十进制转化成八进制
   10、hex()将十进制转化成十六进制

   print(bin(2))#0b10
   print(oct(8))#0o10
   print(hex(16))#0x10
   

   11、divmod() 计算除数与被除数的结果，返回一个包含商和余数的元组（分页用到）

   print(divmod(17,2))#(8,1)
   

   12、 round()保留小数的有次位置,(默认取整)

   print(round(3.21))#3
   print(round(3.1415926,3))#3.142
   
   

   13、pow() 求x**y此幂

   三个参数为x**y的结果对z取余

   print(pow(3,3))#27
   print(pow(3,3,2))#1
   
   

   14、ord() 输入字符寻找unicode的位置
   15、chr() ** 输入位置数字寻找对应的字符

   print(ord('a'))#97
   print(chr(97))#a
   
   

   16、repr ** 原形毕露

   print(repr('dog'))#'dog'
   
   

   17、all any **

   l1 = [1,2,[1,],{1:dog},(1,)]
   l2 = ['',{},(),[]]
   print(all(l1))#T
   print(any(l2))#F
   
   

   18、format

   print(format('test', '<20'))
   print(format('test', '>20'))
   print(format('test', '^20'))
   #将一个十进制转化成8位二进制（字符串类型）
   ret = format(10,'08b')
   print(ret,type(ret))
   #00001010 <class 'str'>
   

2. 匿名函数

   #匿名函数：一句话函数
   #此函数是有名字的，他的名字就是给其设置的变量，如func
   #lambda是定义匿名函数的关键字，相当于def
   #lambda后面直接加形参，形参加多少都可以，只有用逗号隔开
   #返回值在冒号后面设置，返回值与正常的函数一样，可以是任意的数据类型
   #匿名函数只能构建简单的函数，一句话函数
   #常用来与内置函数结合使用
   def func(x,y):
     return x+y
   #匿名函数的构建
   func1 = lambda x,y:x+y
   print(func1(1,3))
   #接收一个可切片的数据，返回索引为 0与2的对应的元素（元组形式）
   print(lambda x : (x[0],x[2]))
   #接收两个int参数，将较大的数据返回
   print(lambda x,y : x if x>y else y)
   
   

3. 内置函数II***

   1、 print()参数sep ，end

   print(self,*args,sep=' ',end='\n',file=None)
   #sep设定分割符
   #end默认换行，可以打印一行
   print(1,2,3,sep='|')#1|2|3
   
   print(1,2,end=' ')
   print(3,4)
   #1 2 3 4
   
   

   2、 list()构建列表

   l1 = list('qwer')
   print(l1)#['q','w','e','r']
   
   

   3、dict()创建字典

   #1.
   dic = dict(one=1,two=2)
   print(dic)#{'one':1,'two':2}
   #2.字典推导式
   print(i:1 for i in range(3))
   #3.
   dic = {'one':1,'two':2}
   #formkeys()
   
   

   4、abs()取绝对值
   5、sum()求和,可以设置初始值

   print(abs(-9))#9
   #sum(iterable)
   sum([1,2,3])#6
   sum([1,2,3],100)#106
   
   

   6、 min()取小，可以加功能，参数key
   7、 max()取大，可以加功能，参数key

   print(min([1,2,3,4]))#1
   #加功能,通过设置key去使用min
   l1 = [('alex', 73, 170), ('太白', 18, 185), ('武大', 35, 159),]
   #min 自动的将可迭代对象的每一个元素作为实参传给i
   def func(x):
     return x[1]
   print(min(l1,key=func))
   print(min(l1,key=lambda i:i[1]))
   
   # 练习：
   dic = {'a':3,'b':2,'c':1}
   # 将dic值最小的键返回
   print(min(dic,key=lambda i :dic[i]))#c
   # 将dic值最小的值返回
   print(dic[min(dic,key=lambda i :dic[i])])#1
   
   dic = {'A':['李业', 67],'b': ['怼哥', 95],'c': ['冯垚', 85]}
   # 将成绩最低的从属于的那个列表返回
   print(dic[min(dic,key=i:dic[i][1])])
   # 将成绩最低的分数返回
   print(dic[min(dic,key=i:dic[i][1])][1])#67
   
   max()与min 相同
   
   

   8、 reversed() 对一个可迭代对象进行翻转，返回一个迭代器

   s1 = 'qwe'
   print(reversed(s1))# <reversed object at 0x00000167DE269748>
   for i in reversed(s1):
     print(i)
   
   

   9、 bytes()

   s1 = '太白'
   #方法一
   print(s1.encode('utf-8'))
   #方法二
   print(bytes(s1,encoding='utf-8'))
   
   #	解码
   b1 = b'\xe5\xa4\xaa\xe7\x99\xbd'
   #方法一
   print(s1.decoding('utf-8'))
   print(str(s1,encoding='utf-8'))
   
   

   zip 拉链方法 返回一个迭代器

   l1 = [1, 2, 3, 4]
   tu = ('a', 'b', 'c')
   s = 'python'
   # print(zip(l1,tu,s))
   print(list(zip(l1,tu,s)))#[(1, 'a', 'p'), (2, 'b', 'y'), (3, 'c', 't')]
   

   10、 sorted() 排序

   l1 = [2,7,4,6,6,8,10]
   #列表原有的sort，改变原列表
   l1.sort()
   print(l1)
   #sorted()形成新的函数
   print(sorted(l1))
   print(l1)   
   
   #加key
   list1 = [
              {'name': 'alex', 'age': 73},
              {'name': 'wusir', 'age': 35},
              {'name': '太白', 'age': 25},
    ]
   print(sorted(list1))
   #not supported between instances of 'dict' and 'dict'
   print(sorted(list1,key = lambda x:x['age']))
   #[{'name': '太白', 'age': 25}, {'name': 'wusir', 'age': 35}, {'name': 'alex', 'age': 73}]
   print(sorted(list1,key = lambda x:x['age'],reverse = True))
   #[{'name': 'alex', 'age': 73}, {'name': 'wusir', 'age': 35}, {'name': '太白', 'age': 25}]
   

   11、filter() 返回一个生成器，生成器表达式的筛选模式

   l1 = [56,4,32,45,78,89,90]
   print([i for i in l1 if i > 45])
   ret = filter(lambda x :x>45,l1)
   print(list(ret))
   
   lst = [{'id':1,'name':'alex','age':50}, {'id':1,'name':'wusir','age':17}, {'id':1,'name':'taibai','age':16},]
   ret = filter(lambda x:x['age'] > 17,lst)
   print(list(ret))
   

   12、map() 返回一个迭代器，相当于生成器表达式的循环模式

   l1 = [56, 67, 12, 34, 78, 90,]
   ret = map(lambda x:x**2,l1)
   print(list(ret))
   
   ret = map(lambda x:x>34 ,l1)
   print(list(ret))#[True, True, False, False, True, True]
   

   13、reduce() 从内置函数中剔除了

   from functools import reduce
   print(reduce(lambda x,y:x+y,[1,2,3,4,5]))
   print(reduce(lambda x,y:x+'|'+y,['q','w','e','r']))#q|w|e|r