内置函数和匿名函数

内置函数 68个

　　Python封装好的了，直接可以使用的函数，例如print()

1、作用域相关 globals()   locals()

def func():
    a = 1
    def func2():
        pass
    func2()
    print(locals()) #以字典的类型返回当前位置的全部局部变量  {'func2': <function func.<locals>.func2 at 0x1040f3950>, 'a': 1}
func()
print(globals()) #以字典的类型返回全部全局变量

2、其他相关

2.1字符串类型代码的执行  eval exec compile

# eval 执行字符串类型的代码，并返回最终结果
print(eval('1+2')) # 3

#exec:执行字符串类型的代码
code = """
for i in range(1,10):
    print(i)
"""
exec(code) # 打印1-9

#compile :将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值
'''
参数说明：　　　

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　

2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。　　

3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。
'''
#流程语句使用exec
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)


#简单求值表达式用eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
eval(compile2)

#交互语句用single
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')

# name #执行前name变量不存在
# Traceback (most recent call last):
#   File "<pyshell#29>", line 1, in <module>
#     name
# NameError: name 'name' is not defined
exec(compile3) #执行时显示交互命令，提示输入
# please input your name:'pythoner'
# name #执行后name变量有值
"'pythoner'"

有返回值的字符串形式的代码用eval() 没有返回值的用exec() ，一般不用compile

2.2 输入输出相关 input() print()

2.3 内存相关 hash id

# hash - 获取一个对象的哈希值 可哈希对象：int、str、bool、tuple
print(hash('arg')) # 1938977906152356211

# id - 获取对象的内存地址
print(id('123')) # 4354764960

2.4 文件操作相关

　　open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

2.5 模块相关__import__　

　　__import__：函数用于动态加载类和函数 。

2.6 帮助

　　help：函数用于查看函数或模块用途的详细说明。

2.7 调用相关

　　callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

　　callable(要判断的对象)

2.8 查看内置属性

　　dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

　　dir(str)

迭代器生成器相关

-***-
range():函数可创建一个可迭代对象，一般用在for循环中
-**-
next():内部实际使用了__next__方法，一般用在for循环中。
iter()：函数用来生成迭代器

#首先获得Iterator对象：
it = iter([1,2,3,4,5])
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        #遇到StopIteration就退出循环
        break

#判断一个对象是否是可迭代对象或者迭代器
from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable)) #true
print(isinstance(l,Iterator)) #False

l1 = iter(l)
print(isinstance(l,Iterable)) #true
print(isinstance(l,Iterator)) #true

基础数据类型相关

'''
** abs:函数返回数字的绝对值
** divmod:计算除数与被除数的结果，返回一个包含商和余数的元组(a//b,a%b)
* round:保留浮点数的小数位数，默认保留整数。
* pow:求x**y次幂，三个参数的情况下x**y结果对z取余
'''
print(abs(-5)) # 5
print(divmod(15,4)) # (3,3)
print(round(1.234)) #1.23 四舍五入
print(pow(2,3)) # 8
print(pow(2,3,5)) # 3

'''
*** sum：对可迭代对象进行求和运算，可设置初始值
*** min:返回可迭代对象的最小值（key为规则）
*** max:返回可迭代对象的最大值（key为规则）
'''
print(sum([1,2,3])) # 6
print(min([1,2,3,4])) # 1
dic = {'a':3,'b':2,'c':1}
#依据value求出最小值的键
print(min(dic,key=lambda x:dic[x])) # c
#max 同理

和数据结构相关：

列表和元组：

list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）

tuple：将一个可迭代对象转化成列表（如果是字典，默认将key作为元组的元素）

相关内置函数：

reversed：将一个序列翻转，并返回此翻转序列的迭代器。

slice：构造一个切片对象，用于列表的切片

ls = [1,2,3,4,5]
print(reversed(ls)) # <list_reverseiterator object at 0x1040f5208>

ret = slice(1,5,2)
print(ls[ret]) # [2,4]

字符串相关：

str：将数据转化为字符串

format：与具体数据相关，用于计算各种小数、精算等。

#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))

#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'

#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F')  #小数点计数法，无穷大转换成大小字母
'INF'

#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'

bytes：用于不同编码之间的转化 将unicode ---> bytes

s = '你好'
print(bytes(s,encoding='utf-8')) # b'\xe4\xbd\xa0\xe5\xa5\xbd'

bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值的范围：0<=x<256

ret = bytearray('array',encoding='utf-8')
ret[0] = 65
print(ret) # bytearray(b'Array')
print(list(ret)) # [65, 114, 114, 97, 121]

memoryview：

ret = memoryview(bytes('你好',encoding='utf-8')) # [\xe4,\xbd,\xa0,\xe5,\xa5,\xbd]
print(len(ret))  # 6
print(ret)
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))

ord：输入字符找该字符编码的位置

chr：输入位置数字找出其对应的字符

ascii：是ascii码中的返回该值，不是就返回\u...

print(ord('a')) # 97
print(ord('中')) #20013

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

print(ascii('a')) # a
print(ascii('中')) # '\u4e2d'

repr：返回一个对象的string形式（原形毕露）

%r - 原封不动写出来
name = 'alex'
print("我叫%r"%name) # 我叫‘alex’

数据集合

dict：创建一个字典

set：创建一个集合

frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

相关内置函数：

len：返回一个对象中元素的个数

sorted：对所有可迭代对象进行排序操作

L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ]
sorted(L,key=lambda x:x[1]) #按照每个元素第二个值进行排序

enumerate：枚举，返回一个枚举对象

all：可迭代对象中，全都是TRUE，才是True

any：可迭代对象中，有一个是True就是True

for i in enumerate([1,2,3]):
    print(i) # (0, 1) (1, 2) (2, 3) 返回每个元素的索引和元素
print(all([1,2,True,0])) # False
print(any([1,2,True,0])) # True

zip：函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

ls_1 = [1,2,3]
ls_2 = [4,5,6,7]
ls_3 = [8,9]
for i in zip(ls_1,ls_2,ls_3):
    print(i)
结果：
    [1,4,8]
    [2,5,9]

filter：过滤

map：根据提供的函数对指定序列做映射

ret = filter(lambda x:x%2==0,[1,2,3,4,5,6,7])
print(list(ret))

ret = map(lambda x:x**2,[1,2,3,4])
print(list(ret)) # [1, 4, 9, 16]
re = map(lambda x,y:x+y,[1,2,3],[4,5,6])
print(list(re)) # [5, 7, 9]

匿名函数：

为了解决那些功能很简单的需求而设计的一句话函数

函数名 = lambda 参数:返回值

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

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

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

其他方法

t1 = (1,2,3)
t2 = (6,7,8)
print(t1.__add__(t2)) # t1 和 t2 拼接
print(t1.__contains__(1)) # 是否包含

print(t1.__rmul__(4)) # t1重复4次 反向拼接

li = [1,2,3,4,5]
for i in li.__reversed__(): # 反向迭代器
    print(i)