globals()——获取全局变量的字典
locals()——获取执行本方法所在命名空间内的局部变量的字典
input() 输入
print() 输出 # file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件，sep: 打印多个值之间的分隔符，默认为空格 end: 每一次打印的结尾，默认为换行符 ，flush: 立即把内容输出到流文件，不作缓存
-------------------------------------------
-------------------------------------------
字体色 | 背景色 | 颜色描述
-------------------------------------------
30 | 40 | 黑色
31 | 41 | 红色
32 | 42 | 绿色
33 | 43 | 黃色
34 | 44 | 蓝色
35 | 45 | 紫红色
36 | 46 | 青蓝色
37 | 47 | 白色
-------------------------------------------
-------------------------------
显示方式 | 效果
-------------------------------
0 | 终端默认设置
1 | 高亮显示
4 | 使用下划线
5 | 闪烁
7 | 反白显示
8 | 不可见
-------------------------------
显示颜色格式：\033[显示方式;字体色;背景色m......[\033[0m]
type(o) 返回变量o的数据类型
id(o) o是参数，返回一个变量的内存地址
hash(o) o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。*每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。
open() 打开一个文件，返回一个文件操作符(文件句柄)
__import__导入一个模块 #os = __import__('os')
help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出
callable(o)，o是参数，看这个变量是不是可调用。
dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
eval() 将字符串类型的代码执行并返回结果
exec()将自字符串类型的代码执行
compile # compile1 = compile(code1,'','exec') compile2 = compile(code2,'','eval') compile3 = compile(code3,'','single') #将字符串类型的代码编译。代码对象能够通过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'。
数字——数据类型相关：bool，int，float，complex
数字——进制转换相关：bin，oct，hex
数字——数学运算：abs，divmod，min，max，sum，round，pow
序列——列表和元组相关的：list和tuple
序列——字符串相关的：str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr
序列：reversed，slice
数据集合——字典和集合：dict，set，frozenset
数据集合：len，sorted，enumerate，all，any，zip，filter，map
filter() # filter(lambda i:i%2==0, [1, 4, 6, 7, 9, 12, 17]) #函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
map() # map(func,[])函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
sort()
sorted() # l2 = sorted(l1,key=abs) # iterable：是可迭代类型;key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;reverse：排序规则. reverse = True 降序 或者 reverse = False 升序，有默认值。返回值：有序列表
locals ： 函数会以字典的类型返回当前位置的全部局部变量。 # print(locals())
globals： 函数以字典的类型返回全部全局变量。 # print(globals())
eval： 执行字符串类型的代码，并返回最终结果。 # eval("n + 4") # 85
# {"ip":{"HTTPS": "117.88.49.230:9999"},"addr":"江苏南京"} <class 'str'>
# eval({"ip":{"HTTPS": "117.88.49.230:9999"},"addr":"江苏南京"}) <class 'dict'>
exec: 执行字符串类型的代码。 # s = '''for i in [1,2,3]:print(i)''' exec(s)
compile: 将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
# >>> #流程语句使用exec #简单求值表达式用eval >>> #交互语句用single
# >>> code3 = 'name = input("please input your name:")'
# >>> compile3 = compile(code3,'','single')
# 有返回值的字符串形式的代码用eval，没有返回值的字符串形式的代码用exec，一般不用compile。
input: 函数接受一个标准输入数据，返回为 string 类型。 # name = input('>>>name is ')
print: 打印输出。
# print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
# file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
# sep: 打印多个值之间的分隔符，默认为空格 # print(111,222,333,sep='*') # 111*222*333
# end: 每一次打印的结尾，默认为换行符 # print(111,end='') print(222) # 两行的结果 111222
# flush: 立即把内容输出到流文件，不作缓存 # print('写入文件',file=f,flush=True)
hash： 获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。 # print(hash('123')) # -2996001552409009098
id: 用于获取对象的内存地址。 # print(id('abc')) # 2033192957072
open： 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
__import__：函数用于动态加载类和函数 。
help： 函数用于查看函数或模块用途的详细说明。 # print(help(list))
callable： 函数用于检查一个对象是否是可调用的。 # callable("runoob") # False
dir： # >>> dir([ ]) # 查看列表的方法 # 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
range： 函数可创建一个整数对象，一般用在 for 循环中。 # for i in range(10)
next： 内部实际使用了__next__方法，返回迭代器的下一个项目。# it = iter([1, 2, 3, 4, 5]) # next(it)
iter： 函数用来生成迭代器（将一个可迭代对象，生成迭代器）。# it = iter([1, 2, 3, 4, 5])
bool ： 用于将给定参数转换为布尔类型。 #数值0、空序列等值为False # bool('') False bool(3) True
int： 函数用于将一个字符串或数字转换为整型。 # print(int('12')) # 12
float： 函数用于将整数和字符串转换成浮点数。 # print(float('4')) # 4.0
complex： 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
bin： 将十进制转换成二进制并返回。 # print(bin(10),type(bin(10))) # 0b1010 <class 'str'>
oct： 将十进制转化成八进制字符串并返回。 # print(oct(10),type(oct(10))) # 0o12 <class 'str'>
hex： 将十进制转化成十六进制字符串并返回。 # print(hex(10),type(hex(10))) # 0xa <class 'str'>
abs： 函数返回数字的绝对值。 # print(abs(-5)) # 5
divmod： 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。# print(divmod(7,2)) # (3, 1)
round： 保留浮点数的小数位数，默认保留整数。 # print(round(3.32567,3)) # 3.326
pow： 求x**y次幂。（三个参数为x**y的结果对z取余） # print(pow(2,3)) # 两个参数为2**3次幂 # print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。
sum： 对可迭代对象(元素是数字)进行求和计算（可设置初始值）。
# print(sum([1,2,3])) # 6 # print(sum((1,2,3),100)) # 106
min： 返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
# print(min([1,2,3])) # 返回此序列最小值 # min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值
max： 返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
# print(max([1,2,3])) # 返回此序列最大值 # max([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最大值
list： 将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。 # l = list({1,2,3})
tuple： 将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。 # tu = tuple([1,2,3])
reversed： 将一个序列翻转，并返回此翻转序列的迭代器。 # reversed(['a',2,3,'c',4,2])
slice： 构造一个切片对象，用于列表的切片。 # sli_obj = slice(0,7,2) print(li[sli_obj])
str： 将数据转化成字符串。
format: 与具体数据相关，用于计算各种小数，精算等。 # print(format('test', '<20')) # str,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐 # 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None # 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
bytes： 用于不同编码之间的转化。 # bytes('你好',encoding='utf-8') # '你好'.encode('utf-8') # '你好'.decode('utf-8')
bytearry： 返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。 # ret = bytearray('alex',encoding='utf-8') ret[0] = 65
ord: 输入字符找该字符编码的位置 # print(ord('a'))
chr: 输入位置数字找出其对应的字符 # print(chr(97))
ascii: 是ascii码中的返回该值，不是就返回/u... # print(ascii('a'))
repr: 返回一个对象的string形式（原形毕露）。 # print('我叫%r'%name) # %r 原封不动的写出来 # print(repr('{"name":"alex"}'))
dict： 创建一个字典。
set： 创建一个集合。
frozenset： 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
len: 返回一个对象中元素的个数。
sorted： 对所有可迭代的对象进行排序操作。
# sort 在原列表的基础上进行排序 # l.sort(key = abs)
# 生成了一个新列表 不改变原列表 占内存 # sorted(L, key=lambda x:x[1],reverse=True) # 利用key# 按降序
enumerate: 枚举，传入可迭代对象，返回一个枚举对象。# for i in enumerate([1,2,3]):print(i) # (0, 1) (1, 2) (2, 3)
all： 可迭代对象中，全都是True才是True # print(all([1,2,True,0]))
any： 可迭代对象中，有一个True 就是True # print(any([1,'',0]))
zip： 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
# l1 = [1,2,3,] # l2 = ['a','b','c',5] #l3 = ('*','**',(1,2,3)) for i in zip(l1,l2,l3):print(i) #最后一个值为 (3, 'c', (1, 2, 3))
filter： 过滤。#filter只管筛选，不会改变原来的值 # ret = filter(func,[1,2,3,4,5,6,7]) # ret = filter(lambda dic:True if dic['price'] > 100 else False,portfolio)
map: 会根据提供的函数对指定序列做映射。 # map(lambda x, y: x + y, [1, 3,], [2, 4, 6, 8, 10]) # map(func, *iterables) # 提供了两个列表，对相同位置的列表数据进行相加，返回一个可迭代对象
函数名 = lambda 参数 ：返回值
# 匿名函数：为了解决那些功能很简单的需求而设计的一句话函数。通常与含有key的内置函数搭配使用：# res = filter(lambda x:x>10,[5,8,11,9,15]) # for i in res:print(i)
isinstance： 判断对象是否是类或者类型元组中任意类元素的实例 # >>> isinstance(1,int)
issubclass： 判断类是否是另外一个类或者类型元组中任意类元素的子类 # >>> issubclass(bool,int)
hasattr： 检查对象是否含有属性 # >>> class Student:#self.name = name # >>> s = Student('Aim') # >>> hasattr(s,'name') #a含有name属性
getattr： 获取对象的属性值 # getattr(s,'name') #存在属性name # >>> getattr(s,'age',6) # 不存在属性age，但提供了默认值，返回默认值
setattr： 设置对象的属性值 # >>> setattr(a,'name','Bob')
delattr： 删除对象的属性 # >>> delattr(a,'name')
callable： 检测对象是否可被调用 # callable(b) #实例b是可调用对象 # b()
classmethod： 标示方法为类方法的装饰器 # >>> class C: @classmethod def f(cls,arg1):
staticmethod： 标示方法为静态方法的装饰器 # >>> class Student(object): @staticmethod def sayHello(lang):
property 内置装饰器函数 只在面向对象中使用
