内置函数，匿名函数

1.dir() 查找对象的所有方法
 print(dir([]))

2.print()

第一种用途:
print("666",end="")          #去除换行符，连接到一起
print(666)
第二种用途:
print(1,2,3,4,5,sep="|")  #1|2|3|4|5  连接符
第二种用途:
f = open('file','a',encoding='utf-8')
print(666,file=f)
f.close()

3.locals()将局部的变量储存起来     globals()将全局的变量，函数名，等等储存起来

def func():
    name = "alex"
    print(locals())
    print(globals())
func()

4.help(str) #查看你查询的对象所有的方法，解释等，不用print

5.abs()取绝对值


6.max()最大值  （可迭代对象，key = 函数名）

ret = max(["s","a","b"])     #asii最大位
print(ret)        #s

ret = max([1,2,3])          #可迭代对象的最大值
print(ret)       #3

ret = max(1,2,-3,key=abs)
print(ret)     #-3

min 最小值    （可迭代对象，key = 函数名）

ret = min([1,2,3])
print(ret)   #1

求和sum (iterable,初始值)

ret = sum([1,2,3],10)
print(ret)  #16

7.callable() 判断此变量是不是函数名

name = "alex"
print(callable(name))    #False
def func():
    print(666)
print(callable(func))     #True

8.hash() 通过哈希表的规则，将对象转换成哈希值

print(hash("hfjsahfasjfhak"))
print(hash("sdhsdhfiejksdfji"))
print(hash("huerweunoehfs"))

9.十进制转化成二进制

print(bin(100))     #0b1100100
  将十进制转化成八进制
print(oct(9))       #0o11
  将十进制转化成十六进制
print(hex(33))       #0x21

10.all 可迭代对象里面的所有的值转化成bool值如果都是True则,返回True

  any()一个为真，则为真

11.数据类型
   float :有限小数，无限循环小数，不包含（无线不循环小数）

print(1.35432,type(1.35432))    #1.35432 <class 'float'>
print(float(3))                 #3.0

12.divmod()    分页

print(divmod(7,2))    #(商，余数) (3, 1)

13.enumerate() 枚举

l = ["a","b","c"]
for i in enumerate(l):
    print(i)                  #元组类型

for k,v in enumerate(l,100):   #可以设置起始值
    print(k,v)

14.eval/exec
eval有返回值，除去字符串两边的引号，返回里面的内容
exec 没有返回值，除去字符串两边的引号，执行里面的代码(流程语句),返回值是none

s = "{'name':'alex'}"
s1 = "1+2+3+4+5"
print(eval(s),type(eval(s)))
print(exec(s),type(exec(s)))
print(eval(s1))

15.ord（）把字母，汉字变成数字

print(ord("b"))     #98
print(ord("中"))    #20013

16. chr（）输入编码的位置，返回unicode对应的字符

print(chr(97))      #a
print(chr(20013))   #中

17. ascii() 包括小大写，特殊字符

print(ascii("a"))
print(ascii("国"))    #u（表示不是ascii）

18.%r  占位符

name = "alex%r"%("sb")
print(name)                 #alex'sb' 合并在一起，并且加带双引号

print(repr("[1,2]"))         #'[1,2]'

19.slice()切片，基类

l1 = [11,22,33,44]
print(l1[1::2])     #[22, 44]
# 效果是一样的
s1 = slice(1,4,2)
print(l1[s1])       #[22, 44]

20.reversed()  形成一个新的迭代器,取元素用for循环或者 next

l1 = [11,22,33,44]
l1.reverse()         #反转
print(l1)            #[44, 33, 22, 11]

l1 = [11,22,33,44]
l2 = reversed(l1)
print(l2)          #<list_reverseiterator object at 0x0000021964DC7198>
for i in l2:
    print(i)

21.format()用于科学计算

22.max()  可迭代对象，key = 函数名

例子1

li = max([1,2,3,-4],key = abs)
print(li)       #-4

例子2，返回值是什么，就按照什么比较大小

dic = {"1":20,"2":30,"3":100}
def func(x):
    return dic[x]
l1 = max(dic,key = func)
print(l1)      #3

例子3

dic = {"k1":20,"k2":30,"k3":100}
def func(x):
    return x
l1 = max(dic,key = func)
print(l1)     #k3

23.zip()  可以放置多个可迭代对象，以最少的可迭代对象的个数为基准，返回一个迭代器。
 
判断是不是迭代器

l1 = [1,2,3]
l2 = ["wusir","alex","taibai"]
l3 = ["*","**"]
from collections import Iterator
print(isinstance(zip(l1,l2),Iterator))   #True
print(zip(l1,l2))                        #<zip object at 0x000002A97F57F988>
                    
for i in zip(l1,l2,l3):
    print(i)
# 元组形式
# (1, 'wusir', '*')
# (2, 'alex', '**')

列表转换成字典

l1 = [1,2,3]
l2 = ["wusir","alex","taibai"]
l3 = ["*","**"]
print(dict(zip(l1,l2)))            #{1: 'wusir', 2: 'alex', 3: 'taibai'}

字典的话，以key为基准

dic1 = {"k1":20,"k2":30,"k3":100}
dic2 = {"k1":20,"k2":30,"k3":100}
for i in zip(dic1,dic2):
    print(i)
    # ('k1', 'k1')
    # ('k2', 'k2')
    # ('k3', 'k3')

24.map()     （函数名，可迭代对象，迭代器 ）（for循环，next取值）                
             将你迭代对象的元素当作函数的参数，将返回值返回给map（）

def func(x):
    return x*x
for i in map(func,[0,1,2,3,4]):
    print(i)  

25.filter()     （函数名，可迭代对象，迭代器） （for循环，next取值） 过滤功能
                 将你迭代对象的元素当作函数的参数，将返回值返回给filter（）
                 返回值返回给迭代器，省内存

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

 列表推导式，费内存
li = [i for i in [1,2,3,4,5,6] if i % 2 == 0]
print(li)

26.sorted     可迭代对象，key = 函数名  
              执行效率最高
              排序，返回的是列表
  sorted(l1) 和 l1.sort() 区别，
  sorted(l1)形成新列表，并返回。不对原列表进行操作
  l1.sort()改变原列表

 例子1：

l1 = [1,2,5,6,8,6]
print(sorted(l1))    #[1, 2, 5, 6, 6, 8]

l1.sort()
print(l1)           #[1, 2, 5, 6, 6, 8]

 例子2

li = ["khdfgua","jfhauh","hf"]
print(sorted(li,key = len))     #['hf', 'jfhauh', 'khdfgua']

总结：

 带key的（max,min,map返回的是迭代器,filter返回的是迭代器，sorted返回的是列表

27.bytes（） 
s = "中国".encode("gbk")  #编码
print(s)

s.decode("gbk")    #解码

例题

 s GBK的bytes ----> utf-8 的bytes

 方法一
s = b'xd6xd0xb9xfa'
s1 = s.decode("gbk").encode("utf-8")
print(s1)     #b'xd6xd0xb9xfa'

 方法二
s = "中国"
s1 = bytes(s,encoding= "utf-8").decode("utf-8")
print(s1)     #中国

28.exit() 退出此程序

29.匿名函数

func = lambda x:x   #函数名 = lamda 形参 : 返回值
print(func(3))

例题1

def func(x,y):
    return x+y
print(func(1,2))

func1 = lambda x,y : x+y
print(func1(1,2))