一，内置函数

1，迭代器/生成器相关的

（1）range ， range是可迭代的但不是一个迭代器。

（2）next，next（迭代器）和迭代器.__next__()效果是一样的。

（3）iter，iter（迭代器）和迭代器.__iter__()效果是一样的。

2，作用域相关

（1）locals，  返回本地作用域中的所有名字。

（2）global，返回全局作用域中的所有名字。

3，其他

（1）字符串类代码的执行

　　eval ，可以执行字符串类型的代码，有返回值-------有结果的简单计算，只能用在明确知道执行的代码是什么。

　　exec，可以执行字符串类型的代码，无返回值-------简单的流程控制

　　compile，编译

exec('print(123)')eval('print(123)')print(eval('1+2+3+4'))   # 10print(exec('1+2+3+4'))   #没有返回值，（1+2+3+4）code = '''for i in range(10):    print(i*'*')'''exec(code)code1 = 'for i in range(0,10): print (i)'compile1 = compile(code1,'','exec')exec(compile1)code2 = '1 + 2 + 3 + 4'compile2 = compile(code2,'','eval')print(eval(compile2))

（2）输入输出

  input()输入

s=input（“输入内容：”）       print（s）                            #打印，数据类型是str

 print()输出

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print    """    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件    sep:   打印多个值之间的分隔符，默认为空格    end:   每一次打印的结尾，默认为换行符    flush: 立即把内容输出到流文件，不作缓存    """

print("我们是",end="")     #指定输出的结束符print("我们",)   #我们是我们

print(1,2,3,4,sep="y")  #指定输出多个值之间的分隔符#1y2y3y4

f = open('tmp_file','w')print(123,456,sep=',',file = f,flush=True)

打印进度条

import timefor i in range(0,101,2):    time.sleep(0.1)    char_num = i//2    per_str="\r%s%%:%s\n"%(i,"*"*char_num) if i==100 else"\r%s%%:%s"%(i,"*"*char_num)    print(per_str,end="",flush=True)

（3）内存相关

 hash（哈希），hash（o）o是参数，返回一个可hash变量的哈希值（一串数字），不可hash的变量被hash之后会报错。

　　对于相同可hash的数据的hash值在一次程序的执行中总是不变的。

t=（1,2,3）l=[1,2,3]print(hash(t))      #print(hash(l))      #报错

id(查看内存地址）

a=5b=4print(id(a))        #1828475808print(id(b))        #1828475776

（4）文件操作相关

 open（）打开一个文件，返回一个文件操作符（文件句柄）

操作文件的模式有r,w,a,r+,w+,a+,每一种都可以用二进制的形式操作，可以用encoding指定编码。

（5）模块相关

import (__import__)导入一个模块

import  math    数学模块        math.sqrt  开平方根

 

import math def is_sqr(x):     return math.sqrt(x)%1==0            #maath.sqrt 开平方根 ret=filter(is_sqr,range(1,101)) for i in ret:     print(i)

 

import  time    时间模块

import   os

（6）调用相关

　　callable（o），o是参数，看这个变量是不是可以调用。

如果o是一个函数名，就会返回True

def func():passprint(callable(func))  #参数是函数名，可调用，返回Trueprint(callable(123))   #参数是数字，不可调用，返回False

（7）帮助

　　help     在控制台执行help（）进入帮助模式。可以随意输入变量或者变量的类型，输入q退出

或者直接执行hplp（o），o是参数，查看和变量o有关的操作。

（8）查看内置方法

dir（），默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量。

print(dir(list))  #查看列表的内置方法print(dir(int))  #查看整数的内置方法

4，基础数据类型相关

  4.1和数字相关的

　　4.11数据类型

　　　　bool，int，float（浮点数），complex（复数）

　float（浮点数：有限循环小数，无限循环小数）

354.123=3.54123*10**2=35.4123*10#小数点位置是可变化的复数(实部+虚部），且复数不能比大小5+12j6+15j

　　　4.12进制转换

　　　　bin（二进制），oct（八进制），hex（十六进制）

print(bin(6))    #0b110print(oct(6))    #0o6print(hex(6))    #0x6

　　　4.13数学运算

　　abs，divmod，round，pow

a=-1 print(abs(a))      #绝对值  1# 除余 print(divmod(3,2))   #(1, 1) print(divmod(2,4))   #(0, 2)#小数精确 print(round(21.2314,2))  #21.23#幂运算 print(pow(2,3))      #8 print(pow(2,3,3))    #2,幂运算之后再取余

　　sum（求和），min，max

#求和 ret=sum([1,2,5,6,7]) print(ret)     #21 print(sum([1,2,3,4,5],3))       #18#求最小值 print(min([1,2,3,4,-1]))          #-1 print(min(1,2,3,-4,key=abs))  #1，绝对值最小的,key是设置的#求最大值print(max(1,2,3,-4))                  #3print(max(1,2,3,-4,key=abs))   #-4

 　4.2和数据结构相关

　　4.21序列

list，tuple：数据类型强制转换

slice，reversd(参数：序列，返回值：反序列迭代器）

# 保留原列表，返回一个反向的迭代器l=[1,2,3,4,5]l1=reversed(l)print(list(l1))   #[5, 4, 3, 2, 1]print(l)           #[1, 2, 3, 4, 5]l = (1,2,23,213,5612,342,43)sli = slice(1,5,2)print(l[sli])         #（2,213）print(l[1:5:2])    #（2,213）

字符串（9）

bytes，str，repr

# 拿到的是gbk编码的，转成utf-8编码 print(bytes('你好',encoding='GBK'))     # unicode转换成GBK的bytes print(bytes('你好',encoding='utf-8'))   # unicode转换成utf-8的bytes name = 'egg' print('你好%r'%name)    #r，代表的是repr print(repr('1')) print(repr(1))       #是什么类型，就打印什么类型

　　4.22数据集合

dict，       set，frozenset（可将集合转变为不可变数据类型）

　　4.23相关内置函数（8）

len，enumerate（枚举）

se={
   "k":1,"k3":2,"j7":6}print(len(se))l="jian"for i in enumerate(l,1):     #默认从0开始，可设置    print(i)

zip：拉链方法

l=[1,2,3,4,45] li=("q","w","r","g","1") l1=zip(l,li)         #返回 一个生成器 for i in l1:     print(i)# 如果是字典拉起来是keyl=[1,2]dic={
   "k1":"a","k2":"b","k3":"c"}dic1=zip(l,dic)for i in dic1:    print(i)(1, 'k3')    # 字典是无序的，组成元组的key随机的(2, 'k2')

filter，map，sorted

def odd(x):     return x>5 ret=filter(odd,[1,2,5,3,4,8])           #过滤筛选，留下True的，过滤掉False的 for i in ret:     print(i)#删除None或空字符串 def str_1(x):     return x and len(x.strip())>0 ret=filter(str_1,[None,"1","2"," "]) for i in ret:     print(i)

map函数应用于每一个可迭代的项，返回的结果list。如果有其他可迭代参数传进来，map则会把每一参数都以相应的函数进行迭代处理。map（）函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每一个元素，并把结果作为行的list返应用。

ret=map(abs,[1,2,-3,5])for i in ret:    print(i)def func(x):    return x**xret=map(func,[1,2,3,])for i in ret:    print(i)

#列表按照每一个值的绝对值排序l1 = [1,3,5,-2,-4,-6]l2 = sorted(l1,key=abs)         #生成了一个新列表，不改变原列表，占内存print(l2)print(l1) print（sorted（l1，key=abs，reverse=True）） #绝对值反向排序#列表按照每一个元素的len排序l = [[1,2],[3,4,5,6],(-7),"123"]print(sorted(l))

 扩展：reduce，在Python2是内置函数，Python3中移到了functools模块。它的作用——从左到右对一个序列的项累计地应用有两个参数的函数，以此合并序列到一个单一值。

from functools import reducereduce(lamdba x,y:x*10+y,[1,2,3,4,5])#结果   12345 reduce工作过程，先传入前两个值，得到结果，这个结果在和第三个值，作为两个参数传入函数，一次类推，最终得到一个值。

 

 

二，匿名函数

函数名=lambda 参数：返回值

调用和普通函数一样

1，参数可以有多个，用逗号隔开

2，匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值

3，返回值和正常的函数一样可以是任何数据类型

# dic={'k1':10,'k2':100,'k3':30}# def func(key):#     return dic[key]# print(max(dic,key=func))   #根据返回值判断最大值，返回值最大的那个参数是结果# print(max(dic,key=lambda key:dic[key]))# max([1,2,3,4,5,-6,-7],key=abs)

ret=map(lambda x:x**2,[1,5,7,4,8])for i in ret:    print(i)

现有两个元组(('a'),('b')),(('c'),('d'))，请使用python中匿名函数生成列表[{
   'a':'c'},{
   'b':'d'}] ret = zip((('a'),('b')),(('c'),('d'))) res = map(lambda tup:{tup[0]:tup[1]},ret) print(list(res))