内置函数与匿名函数

一，内置函数

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'))   # 10
print(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='
', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='
', 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 time
for i in range(0,101,2):
    time.sleep(0.1)
    char_num = i//2
    per_str="
%s%%:%s
"%(i,"*"*char_num) if i==100 else"
%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=5
b=4
print(id(a))        #1828475808
print(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():pass
print(callable(func))  #参数是函数名，可调用，返回True
print(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+12j
6+15j

　　　4.12进制转换

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

print(bin(6))    #0b110
print(oct(6))    #0o6
print(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))                  #3
print(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)
# 如果是字典拉起来是key
l=[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**x
ret=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 reduce

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