内置函数--python提供给你直接可以拿来使用的所有函数
内置函数大致分为六大类：反射相关、基础数据类型相关、作用域相关、面向对象相关、迭代器/生成器相关、其他。
作用域相关（2）：locals，globals
基于字典的形式获取局部变量和全局变量
locals() -----获取执行本方法所在命名空间内的局部变量
globals() ------获取当前所有的全局变量
迭代器/生成器相关(3) : range、next、iter
其他（12）：
字符串类型代码的执行：eval、exec、compile
eval()将字符串类型的代码执行并返回结果（有返回值 —— 有结果的简单计算）eval只能用在你明确知道你要执行的代码是什么
print(eval('1+2+3+4')) # 10
eval('print(123)') # 123
exec()将字符串类型的代码执行（没有返回值 —— 简单流程控制）
print(exec('1+2+3+4')) # None
exec("print('hello world')") # hello world
code = '''
for i in range(3):
print('*'*i)
'''
exec(code)
# *
# **
compile 将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
参数1：source 字符串或者AST对象。即需要动态执行的代码块
参数2：filename 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，参数2只需传入空字符即可。
参数3：model 指定编译代码的种类，可以指定为‘exec’,'eval','single'。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为'eval'；当source中包含了交互式命令语句，model应指定为'single'。
#流程语句使用exec
codel = 'for i in range(4): print(i)'
compile1 = compile(codel,'','exec')
exec(compile1)
0
1
2
3
#简单求值表达式用eval
code2 = '1 + 2 + 3'
compile2 = compile(code2,'','eval')
print(eval(compile2)) # 6
#交互语句用single
code3 = 'name = input("please input your name : ")'
compile3 = compile(code3,'','single')
# name
exec(compile3)
print(name)
输入输出相关：
input()输入
s = input('请输入内容 ：')
print(s)
print()输出
数据类型相关：
type(变量) #返回变量的数据类型
内存相关：
id(o) o是参数，返回一个变量的内存地址
hash(o) o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错
t = (1,2,3) li = [1,2,3] print(hash(t)) #不可变类型可哈希，不会报错 print(hash(li)) #可变类型不可哈希，会报错
hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。
每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。
文件操作相关：
open() 打开一个文件，返回一个文件操作符（文件句柄）
模块操作相关：
__import__导入一个模块
和调用相关：
callable(o),o是参数，查看这个变量是不是可以调用
如果o是一个函数名，就会返回True
def func():
pass
print(callable(func)) # True
print(callable(123)) # False
帮助方法：
在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出。
或者直接执行help(o),o是参数，查看和变量o有关的操作
查看参数所属类型的所有内置方法：
dir() 默认查看全局空间内的属性，也可以接收一个参数，查看这个参数内的方法或变量
print(dir(list)) #查看列表的内置方法 print(dir(int)) #查看整数的内置方法
基础数据类型相关：
和数字相关：
数据类型：bool、int、float、complex
进制转换：bin、oct、hex
数学运算：abs、divmod、round、pow、sum、min、max
print(bin(10)) #0b1010 转二进制 print(oct(10)) #0o12 转八进制 print(hex(10)) #0xa 转十六进制
print(abs(-5)) # 绝对值 print(abs(5)) print(divmod(7,2)) # (3,1) div出发 mod取余 print(divmod(9,5)) # (1,4) 除余 print(round(3.14159,3)) # 3.142 四舍五入 print(round(3.14159,1)) # 3.1 print(pow(2,3)) # 8 pow幂运算 == 2**3 print(pow(3,2)) # 9 print(pow(2,3,3)) # 2 幂运算之后再取余 print(pow(3,2,1)) # 0
ret = sum([1,2,3]) # 求和 print(ret) # 6 ret = sum([1,2,3],10) # 第二个参数表示起点从10开始，然后在10的基础上再加上列表中的各项的和 print(ret) # 16 print(min([1,2,3,4])) # 1 计算最小值 print(min(1,2,3,4)) # 1 print(min(1,2,3,-4)) # -4 print(min(1,2,3,-4,key = abs)) # 1 后面可加修饰参数，如abs，表示前面几个值的绝对值后比较最小值，但返回的还是最初的那个值 print(max([1,2,3,4])) # 4 计算最大值 print(max(1,2,3,4)) # 4 print(max(1,2,3,-4)) # 3 print(max(1,2,3,-4,key = abs)) # -4 后面可加修饰参数，如abs，表示前面几个值的绝对值后比较最大值，但返回的还是最初的那个值
和数据结构相关（24）
列表和元组（2）：list、tuple
相关内置函数 (2) : reversed、 slice
l = [1,2,3,4,5] l2 = reversed(l) print(list(l2)) # [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): str、format、bytes、bytearray、memoryview、ord、chr、ascii、repr
#bytes 转换成bytes类型
print(bytes('你好',encoding='GBK')) # unicode转换成GBK的bytes
print(bytes('你好',encoding='utf-8')) # unicode转换成utf-8的bytes
b_array = bytearray('你好',encoding='utf-8')
print(b_array) # bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(b_array[0]) #228
print(ord('好')) # 22909 字符按照unicode转数字
print(ord('1')) # 49
print(chr(97)) # a 数字按照unicode转字符
print(ascii('好')) # '\u597d'
print(ascii('1')) # '1'
name = 'egg'
print('你好%r'%name) # 你好'egg'
print(repr('1')) # '1' 用于%r格式化输出
print(repr(1)) # 1
数据集合（3）： 字典（1）-- dict 集合（2）-- set、frozenset
相关内置函数（8）： len、enumerate、all、any、zip、filter、map、sorted
# 判断是否有bool值为False的值 print(all(['a','',123])) # False print(all(['a',123])) # True print(all([0,123])) # False
# 判断是否有bool值为True的值 print(any(['',True,0,[]])) # True
#返回一个迭代器
l = [1,2,3,4,5]
l2 = ['a','b','c','d']
l3 = ('*','**',[1,2])
d = {'k1':1,'k2':2}
for i in zip(l,l2,l3,d):
print(i)
# (1, 'a', '*', 'k2')
# (2, 'b', '**', 'k1')
filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
# 例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：
def is_odd(x):
return x % 2 == 1
ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
# for i in ret:
# print(i)
print(list(ret)) # [1, 7, 9, 17]
# 利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def is_not_empty(s):
return s and len(s.strip()) > 0
ret = filter(is_not_empty, ['test', None, '', 'str', ' ', 'END'])
print(list(ret)) # ['test', 'str', 'END']
# 注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。 # 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下： a = ' 123' a.strip() print(a) # '123'
# 请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
from math import sqrt
def func(num):
res = sqrt(num)
return res % 1 == 0
ret = filter(func,range(1,101))
# for i in ret:
# print(i)
print(list(ret)) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
map()函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
ret = map(abs,[1,-4,6,-8])
# for i in ret:
# print(i)
print(list(ret)) # [1, 4, 6, 8]
# 有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理。
L = [1,2,3,4,]
def pow2(x):
return x*x
# filter 执行了filter之后的结果集合 <= 执行之前的个数 # filter只管筛选，不会改变原来的值# map 执行前后元素个数不变 # 值可能发生改变对List、Dict进行排序，Python提供了两个方法对给定的List L进行排序，方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变
l = [1,-4,6,5,-10] l.sort(key = abs) # 在原列表的基础上进行排序 print(l) # [1, -4, 5, 6, -10] #列表按照其中每一个值的绝对值排序 l = [1,-4,6,5,-10] print(sorted(l,key=abs)) # [1, -4, 5, 6, -10]生成了一个新列表 不改变原列表 占内存 print(l) # [1, -4, 6, 5, -10] # 列表按照每一个元素的len排序 l = [' ',[1,2],'hello world'] new_l = sorted(l,key=len) print(new_l) # [[1, 2], ' ', 'hello world']
匿名函数：
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数
def calc(n):
return n ** n
print(calc(3))
# 换成匿名函数
calc = lambda n: n ** n
print(calc(3))
#函数名 = lambda 参数 ：返回值 #参数可以有多个，用逗号隔开 #匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值 #返回值和正常的函数一样可以是任意数据类型
dic={'k1':10,'k2':100,'k3':30}
def func(key):
return dic[key]
print(max(dic,key=func)) # k2 根据返回值判断最大值，返回值最大的那个参数是结果
print(max(dic,key=lambda key:dic[key])) # k2
def func(x):
return x**2
ret = map(func,[-1,2,-3,4])
for i in ret:
print(i)
ret = map(lambda x:x**2,[-1,2,-3,4])
print(list(ret)) # [1, 4, 9, 16]
def func(x):
return x>10
res = filter(func,[5,8,11,9,15])
for i in res:
print(i) #[11,15]
min max filter map sorted —— 这五个函数都有key,都可以和lambda组合在一起
来源：https://www.cnblogs.com/huangjm263/p/8193382.html