从入门到自闭之Python内置函数

内置函数一

1. eval：执行字符串类型的代码

2. exac：执行字符串社类型的代码

   eval与exac 禁止使用

3. hash（）作用就是区分可变数据类型与不可变数据类型

   # print(hash("123"))
   # print(hash(12))
   # print(hash(-1))
   # print(hash(-10))
   # print(hash((2,1)))
   
   # dic = {[1,2,3]:2}
   # print(hash([1,2,3]))
   

4. help（）：查看帮助信息

5. callable（）：查看对象是否可以调用，

   # def func():
   #     print(1)
   # lst = [1,23,4,]
   # print(callable(lst))   # 查看对象是否可调用
   

6. int（）：将字符串或数字转换成整型

7. float（）：转换成浮点数

8. complex（）：复数

9. bin（）：十进制转二进制

10. oct（）：十进制转八进制

11. hex（）：十进制转十六进制

12. divmod（）：计算除数与被除数结果，包含一个商和余数的元祖

13. round（）：保留浮点数的小数位数，可以设定保留位数，默认保留整数

14. pow（）：求x ** y次幂（三个参数的时候为x ** y的结果对第三个参数取余）

15. bytes（）：用于不同编码之间的转换，建议使用encode

16. ord（）：通过元素获取当前表位编码位置

17. chr（）：通过表位序号查找对应的元素

18. repr（）：查看数据的原生态（给程序员使用的）

19. all（）：判断容器汇总的元素是否都为真，返回true

20. any（）：判断容器中的元素有一个为真，就是True

匿名函数：一行函数lambda（必背）

def func（）：
	print（123）
func（）

1. 语法：

   1. 函数名 = lambda 参数 ：返回值

   2. 匿名函数的名字叫做lambda

   3. lambda是定义函数的关键字，相当于函数的def

   4. 只可以返回一个数据类型，

      面试题：
      print ([lambda : i for i in range(5)])
      （返回5个内存地址）
      
      print(lst[0]())---结果是4--因为循环最后一次输出是4，调用的全局最后一个就是4
      不加后面的小括号就是调用内存地址
      加了括号就是调用函数
      

      lst = [lambda X : X+1 for i in range(5)]
      print(lst[0](5))
      输出结果为：6，返回值是x+1
      

      tu = (lambda : i for i in range(3))
      print(tu[0])	#输出错误，不能索引
      print（tu）#输出内存地址
      print(next(tu))		#一个函数地址
      print(next(tu)())		#输出0
      print(next(tu)())		#输出1
      

      lst = [lambda : i for i in range(3)]
      print(lst[0]())
      tu = (lambda : i for i in range(3))
      print(next(tu)())
      输出结果：
      2
      0
      

      函数体中存放的是代码

      生成器中存放的也是代码

      ​ --原因：yield导致函数和生成器的执行结果不一致

      lst = [lambd x:x+5  for i in range(2)]
      print([i(2) for i in lst])
      
      解开顺序：
      lst = []
      for i in range (2):
          lst.append(lambda x :x+5)
      new_list
      for i in lst:
          print(i)		#两个函数的内存地址
          new_list.append(i(2))
      print(new_list)		#输出列表【7，7】
      
      输出结果：【7，7】
      
      lst = (lambda x:x+5  for i in range(2))
      print([i(2) for i in lst])
      
      输出结果：【7，7】
      
      lst = （lambda x:x*i  for i in range(2)）
      print([i(2) for i in lst])		#【0，2】
      
      

2. lambda == def == 关键字

   1. lambfa x: x
      • x:是普通函数的形参（位置，默认），可以写任意多个，也可以不写
      • ：后边是普通函数的返回值,必须写，没有默认，必须要有返回值，只能写一个数据类型

内置函数二（全记住）

内置函数

1. 两个字典合并成一个：

   1. update--- dic2.update(dic1)
   2. 打散：-- print(dict( ** dic1, ** dic2))
   3. print(dict([(1,2),(3,3)]))---括号里面的数字多一个少一个都不行，列表进行迭代，元祖也可以
   4. dict( ** dict1, ** dict2)

2. set（）：将可迭代对象转换成元祖

3. sep() : 每一个元素之间的分割的方法

   print(1,2,3,sep = "|")
   输出结果：1|2|3
   

4. end：print执行完后的结束语句，默认\n

   print(1,2,3,end = "")
   print()
   输出结果：全部在一行
   

5. print():屏幕输出

   • flush -- 刷新

6. file：文件句柄，默认显示到屏幕

   print (1,2,3,4,5,file = open ("test","w",encoding="utf-8"))
   

7. sum() -- 求和，必须是可迭代对象，对象中的元素必须为整型，字符串类型不能使用

   print (sum ([1,2,3,1]))
   print (sum ([1,2,3,1],100)		#100是起始值，就是从100开始进行取和，指定开始位置的值
   

8. abs() : 返回绝对值--转换成正数，不管你是不是负数

9. dir() : 查看当前对象具有什么方法

10. zip()：拉链，当可迭代对象的长度不一致时，选择最短的进行合并，可以是多个

    面试题：
    list1 =[1,2,3,4]
    lst2 = ["alex","wusir","meet"]
    print(list(zip(lst1,lst2)))
    
    输出结果：[(1,"alex"),(2,"wusir"),(3,"meet")]
    
    print(dict(zip(lst1,lst2)))	#返回一个字典
    输出结果：{1:"alex",2:"wusir",3:"meet"}
    

11. format(): 格式转换

    1. 对齐方式

       print(format("alex",">20"))	#右对齐
       print(format("alex","<20"))	#左对齐
       print(format("alex","^20"))	#居中
       

    2. 进制转换

       print(format(10,"b"))		#十进制转二进制
       print(format(10,"08b"))		#不够就补0
       

       print (format(10,"08o"))		#oct,八进制
       print (format(10,"08x"))		#hex，十六进制
       

       print(format(0b1010,"d"))	#二进制转十进制
       

12. reversed() : 将一个序列进行翻转，返回翻转序列的迭代器

    l = reversed('你好')  # l 获取到的是一个生成器
    print(list(l))
    ret = reversed([1, 4, 3, 7, 9])
    print(list(ret))  # [9, 7, 3, 4, 1]