一、内置函数（68个）
1. 作用域相关（2）
locals()： 局部作用域中的变量
global()： 全局作用域中的变量
在全局中执行这两个变量，结果相同
def func():
pass
func()
print(locals())
print(globals())
在局部执行locals()表示函数内的名字，globals()始终不变
def func():
a= 0
b = 1
print(locals())
print(globals())
func()
2. 迭代器和生成器相关（3）
a. iter()： 只接收一个内部含有__iter__()方法的对象统一接口（iter() 和 __iter__()是一样的，在python里尽量少的调用双下方法）
b. next(迭代器)： next()和__next__()是一样的
c. range（*****）： range生成的是一个可迭代对象，最好循环取结果
*. range(100) 0-99
*. range(0,100)
*. range(0,100,2)可以设置步长
3. 基础数据类型（39）
1. 数字相关（14）
a. 数据类型（4）
bool() # 强转布尔类型(*****) int() # 强转整数类型(*****) float() # 强转浮点类型(*****) complex(实部, 虚部) # 转为复数类型 print(complex(1,2)) # 结果为：(1+2j)
b. 进制转换（3）
bin() # 二进制 oct() # 八进制 hex() # 十六进制
c. 数学运算（7）
*. abs() 绝对值
ret = abs(-99)
print(ret) # 99
*. divmod(被除数，除数) 应用：分页
print(divmod(9,5)) # (1,4)
*. round(小数，留几位小数)
print(round(2.4567432,3)) # 2.456
*. pow(x,y)幂运算 x的y次幂
pow(x,y,z) x的y次幂对z取余，z的默认值是1
print(pow(2, 3)) # 8 print(pow(3, 3, 5)) # 2
*. sum() 求和
sum(iterable，start)
start：开始计算值，默认是0
应用，求本钱加利息sum(利息，本钱)
print(sum(range(5),3))
*. min(iterable，key，default)
ierable：可迭代对象或多个值
key: 判断最小值的条件函数
default：未计算出最小值时返回值
# 什么也不设置的时候： li = [1, -2, 3, -5] print(min(li)) # -5 # 设置key值的时候； li = [1, -2, 3, -5] print(min(li, key=abs)) # 1 # 设置default的时候： li = [] print(min(li, key=abs, default=1)) # 1
*. max(iterable，key，default)
ierable：可迭代对象或多个值
key: 判断最小值的条件函数
default：未计算出最小值时返回值
# 什么也不设置的时候： li = [1, -2, 3, -5] print(max(li)) # 3 # 设置key值的时候； li = [1, -2, 3, -5] print(max(li, key=abs)) # -5 # 设置default的时候： li = [] print(max(li, key=abs, default=1)) # 1
2. 列表、元组（4）
a. list()： 强转为列表类型
b. tuple()： 强转为元组类型
c. reversed()： 反转，针对本身有序的对象，结果是一个反序迭代器（列表，元组，字符串通用）
ret = reversed([1, 2, 3, 4, 5, 6, 7])
ret = reversed("sjkfndjdk")
print(list(ret))
ret = reversed("sjkfndjdk")
print("".join(list(ret)))
d. slice(start, end, length) 切片操作（列表，元组，字符串通用）
li = [2, 3, 5, 6, 8, 9, 0, 0, 4, 1] my_s = slice(1, 5, 2) print(li[my_s]) # 等价于li[1:5:2]
3. 字符串（10）
a. str()：强转为字符串类型
b. format("content", "对齐方式")： 字符串拼接，对齐方式有三种，<左对齐，>右对齐，^居中
print(format("abc", ">20"))
print(format("abc", "<20"))
print(format("abc", "^20"))
c. bytes()： 强转为字节类型
by = bytes("字符", encoding="utf-8") # 转换成unicode编码
print(by)
# 结果：b'xe5xadx97xe7xacxa6'
by = bytes("字符", encoding="utf-8")
by = by.decode("utf-8") # 转为string类型
print(by)
# 结果：字符
d. bytearray()：强转为字节数组类型
ret = bytearray("字符", encoding="utf-8")
print(ret) # 结果：bytearray(b'xe5xadx97xe7xacxa6')
e. memoryview()： 内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问，即在不开辟新的内存空间的情况下，展现字符串的一部分。
ret = memoryview(bytes('你好', encoding='utf-8'))
print(len(ret)) # 6
print(bytes(ret[:3]).decode('utf-8')) # 你
print(bytes(ret[3:]).decode('utf-8')) # 好
f. ord()： 字符转为数字，根据Unicode转变
g. chr()： 数字转为字母，根据Unicode转变
h. ascii()： 转为ascii码
i. repr()： 将对象转化为供解释器读取的形式，返回对象的字符串格式。用于%r格式化输出
j. basestring(): 判断一个对象是否为 str 或者 unicode 的实例
basestring是 str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化.，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
4. 字典、集合（3）
a. dict()： 强转成字典
b. set()： 强转成集合
c. frozenset()：改为不可变集合
set_test = set('hello')
f_set_test = frozenset(set_test)
# dic = {set_test:1} 这样直接写会报错，因为集合是可变的，而字典的key值只能是不可变数据类型
dic = {f_set_test: 1}
print(dic)
5. 各类数据类型相关的内置函数（8）
a. len()： 求长度
b. enumerate()： 给一个可迭代对象加序号
se = {'computer': 10000, 'umbrella': 200}
for num, goods in enumerate(se, 1):
print(num, goods, se[goods])
c. all(可迭代对象)： 判断bool值是否有Flase的值
print(all([1,"",3,5])) # False
d. any(可迭代对象)： 判断bool值是否有True的值
print(any(["",[],3])) # True
e. zip(可迭代对象,可迭代对象.....)： 得到的是迭代器，返回的是列表
li = [1, 2, 3, 4, 5, 6]
a = "faskdlfj"
print(zip(li, a))
ret = zip(li, a)
for i in ret:
print(i)
f. filter(函数，可迭代对象)：过滤，过滤条件是函数。
从可迭代对象里取值，在函数里运行，符合条件时，就放到返回值里，返回值是迭代器。
例一：
def func(n):
if type(n) is str:
return True
li = ["af", [1, 2, 3], (3, 4, 5)]
ret = filter(func, li)
for i in ret:
print(i)
例二：
def func(n):
if n and n.strip():
return True
li = ['test', None, '', 'str', ' ', 'END']
ret = filter(func, li)
print(list(ret))
g. map(函数，可迭代对象)： 返回的是列表
def func(n):
return n + n
li = [1, 2, 3, 4, 5]
ret = map(func, li)
for i in ret:
print(i)
h. sorted(对象)： 排序，默认从小到大 #有返回值
li = [1, 2, 53, 1234, 3, 4, -455] print(sorted(li))
sort()： 排序，没有返回值，只用在list对象上。
li = [1, 2, 53, 1234, 3, 4, -455] li.sort() print(li)
4. 类相关（8）
1. super()： 继承中用来调用父类的方法
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3
2. 装饰器（3）
a. classmethod(function)：类方法
对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 调用 foo 方法
A.func2() # 不需要实例化
b. staticmethod(function)：静态方法
class C(object):
@staticmethod
def f():
print('runoob');
C.f(); # 静态方法无需实例化
cobj = C()
cobj.f() # 也可以实例化后调用
c. property(function)：把类中的方法假装成属性
class Book:
def __init__(self,name):
self.name = name
@property
def get_name(self):
return self.name
book = Book("Fluent Python")
print(book.name)
print(book.get_name) # 这里去调用的时候，就是相当于调用一个属性
3. 类的属性方法（4）
a. setattr() 函数对应函数getattr()，用于设置属性值，该属性不一定是存在的。
b. getattr(object, name[, default])： 返回一个对象属性值。
object -- 对象。
name -- 字符串，属性名。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
c. hasattr(object, name)： 函数用于判断对象是否包含对应的属性。如果对象有该属性返回 True，否则返回 False。
d. delattr(object, name)： 删除属性。
delattr(x, 'foobar') 相等于 del x.foobar。
5. 其他类型（16）
a. 执行字符串中的代码（3）
eval：计算（有返回值）
exec：流程控制（无返回值）
print(eval("1+2+3+4")) # 结果是：10
print(exec("1+2+3+4")) # 结果：None
# 这样执行才会有返回值
exec("print('hello,word')")
compile(source,filname,mode)： 当需要对某一个字符串类型的python代码多次执行的时候，用compile先编译一下。
source：字符串，或AST(Abstract Syntax Trees)对象，即需要动态执行的代码段
filename：代码文件名称，如果不是从文件读取代码传递一些可辨认的值。当传入了source参数时，filename参数传入空字符串即可
model：指定编译代码的种类，可以指定为，exec，eval，single,三种，
# 示例
# 1. 当source中含有流程语句时，model = exec
code = "for i in range(10):print(i)"
compile1 = compile(code, "", 'exec')
exec(compile1)
# 2. 当source中含有一个简单的求值表达式时，model = eval
code = "1+2+3+4"
compile1 = compile(code, "", 'eval')
print(eval(compile1))
# 3. 当source中含有交互式命令语句的时候，model = single
code = "name= input('>>>')" # input交互式命令语句
compile1 = compile(code, "", 'single')
exec(compile1)
print(name)
b. 输入输出函数（2）
input(): 返回字符串类型
print(): 输出
import sys value = "string print" print(value, ..., sep=' ', end=' ', file=sys.stdout, flush=False) # file: 输出内容到指定文件夹，默认输出到控制台 # sep: 字符串之间的分隔符，默认是空格 # end: 字符串结束符，默认是 换行符 # flush: 是否立即把内容输出
import time
import sys
# 实现进度条
for i in range(0, 101, 2):
time.sleep(2)
char_num = i // 2 # 打印多少个#
per_str = '
%s%% : %s
' % (i, '*' * char_num) if i == 100 else '
%s%% : %s' % (i, '*' * char_num)
print(per_str, end='', file=sys.stdout, flush=True)
c. hash()： 哈希方法，结果是一个数字，同一个对象的哈希值,在python的一次执行中是一样的，但是重新执行程序后就不一样了。
可变的数据类型（列表，字典，集合）是不能被哈希的。
hashlib()计算出来的结果永远不会变
d. id(): 查看对象的内存地址
e. 文件相关（2）
*. open(filename，encoding，mode)： 操作文件，生成文件对象
*. execfile(filename)：执行一个文件，输出文件内容
f. import module ： 导入模块
g. help()： 进入help模式，退出"q"
h. callable(对象)： 判断一个对象是否可以调用
i. dir()： 查看内置属性
print(dir(__builtins__)) # 所有内置名字
j. 判断对象类型（3）
type()： 返回该对象的类型
isinstance(object, type)： 判断对象是否是该类型数据，或者用来判断继承关系
issubclass(子类，父类/多个父类)： 判断两个类是不是父子关系
二、匿名函数
1. 一句话的python
a. 三元运算
b. 推导式，生成器表达式
c. lambda表达式（解决简单问题）
2. lambda表达式
funcname = lambda 参数:返回值
print(funcname(arguments))
func = lambda x,y:x+y print(func(2,5))
规则：
a. 参数可以有多个，用逗号隔开
b. 不管逻辑多复杂，lambda表达式只写一行，且逻辑执行结束后的内容就是返回值
c. 返回值和正常函数一样可以是任何数据类型
# 现有两个元祖(("a"),("b")),(("c"),("d")),请使用python中的函数生成列表[{"a":"c"},{"b":"d"}]
print(list(map(lambda t:{t[0]:t[1]},zip((("a"),("b")),(("c"),("d"))))))
d = lambda p:p*2 t = lambda p:p*3 x = 2 x = d(x) x = t(x) x = d(x) print(x)