内置函数
作用域相关
# **globals() 已字典的形式返回全局变量
# **locals() 已字典的形式返回当前位置的局部变量
# q = 666 # def wrapper(argv): # a = 3 # print(locals()) # 1 {a:3,argv:2} # def inner(argv1): # b = 4 # c = 5 # print(locals()) # 2 {b:4 c:5,argv1:6} # inner(6) # # wrapper(2) # print(globals()) # 3
其他相关
#1.2.1 字符串类型代码的执行 eval，exec，complie
#***eval 去除字符串的引号，返回对应内部的值
# s = '{"a":1,"b":3}' # dic = eval(s) # print(dic,type(dic)) # print(eval('2 + 2')) # print(eval('print(666)'))
#*** exec 执行字符串内部的代码
# print(exec('1 + 1'))
# s = """ # for i in range(10): # print(i) # """ # exec(s)
#compile: pass
输入输出相关 input print
# name = input('请%s输入名字:' % 'alex') # print(name) # print(1, 2, 3,sep='*') # 设定打印元素的连接方式 # print('alex', end='') # end控制的是换行 # print('老男孩') # ***f1 = open('log', encoding='utf-8', mode='w') # print('666', file=f1) # file 操作文件句柄，写入文件。 # f1.close()
内存相关 hash id
# print(hash('name')) # print(hash('age')) # print(hash((1, 2, 3,))) # print(hash(1)) # print(hash(1)) # print(hash(100)) # *print(id('name'))
文件操作相关
# open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
模块相关__import__
# __import__：函数用于动态加载类和函数 。
帮助
# *help：函数用于查看函数或模块用途的详细说明。
# print(help(str))
调用相关
# *** callable：函数用于检查一个对象是否是可调用的。
# 如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
# def func1(): # print(666) # # age = 16 # print(callable('name')) # print(callable(age)) # print(callable(func1))
查看内置属性
# ** dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
# 带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
# print(dir(str))
迭代器生成器相关
*** range iter() next()
# print(len(range(100))) # l = [1, 2, 3, 4, 5] # l_obj = l.__iter__() # l_obj = iter(l) # print(l_obj) # print(l_obj.__next__()) # print(next(l_obj))
数字相关
数据类型
# bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
# int：函数用于将一个字符串或数字转换为整型。
# print(int('123')) # print(int(1.234)) # print(int(1.768))
# float：函数用于将整数和字符串转换成浮点数。
# i = 3.1415 # print(i, type(i)) # s = '1.234' # print(int(1.234)) # print(float(s)) # print(float(100))
# complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
# 如果第一个参数为字符串，则不需要指定第二个参数。。
# bin：将十进制转换成二进制并返回。
# print(bin(100))
# oct：将十进制转化成八进制字符串并返回。
# print(oct(10))
# hex：将十进制转化成十六进制字符串并返回。
# print(hex(13)) # print(hex(18))
数学运算
**abs：函数返回数字的绝对值。
# print(abs(-5))
***divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
# print(divmod(7, 3))
**round：保留浮点数的小数位数，默认保留整数。
# print(round(1.234,2))
*pow：求x**y次幂。（三个参数为x**y的结果对z取余）
# print(pow(2, 3)) # 2的三次幂 # print(pow(2, 3, 3)) # 2的三次幂对3取余数
***sum：对可迭代对象进行求和计算（可设置初始值）。
# print(sum([1, 2, 3, 4])) # print(sum([1, 2, 3, 4], 100))
*** min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
# print(min([1, 3, 5, 7, -4])) # print(min([1, 3, 5, 7, -4], key=abs))
*** max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
# print(max([1, 3, 5, 7, -4])) # print(max([1, 3, 5, 7, -9], key=abs))
和数据结构相关
列表和元祖（2）
# list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
#
# tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。
# tu = (1, 2, 3) # print(list(tu)) # l1 = list((1, 2, 3)) # l1 = list({'name':'alex','age':1000})
相关内置函数
*** reversed：将一个序列翻转，并返回此翻转序列的迭代器。
# l1 = [11, 22, 33, 44, 77, 66] # l_obj = reversed(l1) # # print(l_obj) # for i in l_obj: # print(i)
slice：构造一个切片对象，用于列表的切片。
# l1 = [11, 22, 33, 44, 77, 66] # l2 = [111, 222, 333, 444, 777, 666] # # print(l1[1::2]) # rule = slice(1, len(l2), 2) # print(l2[rule])
字符串相关
str：将数据转化成字符串。
format:与具体数据相关，用于计算各种小数，精算等。
# print(format('test', '<20')) # 左对齐 # print(format('test', '>20')) # 右对齐 # print(format('test', '^20')) # 居中
*** bytes：
str---> bytes
# s1 = 'alex' # # b1 = s1.encode('utf-8') # b2 = bytes(s1,encoding='utf-8') # print(b1) # print(b2)
bytearray
# ret = bytearray('alex', encoding='utf-8') # 类比：[97,103,....] # print(id(ret)) # print(ret) # bytearray(b'alex') # print(ret[0]) # ret[0] = 65 # print(ret) # print(id(ret))
memoryview
# 分字节去转换成str # b1 = bytes('你好',encoding='utf-8') # print(b1) # ret = memoryview(b1) # # print(len(ret)) # # print(ret) # print(bytes(ret[:3]).decode('utf-8')) # print(bytes(ret[3:]).decode('utf-8'))
ord:输入字符找该字符编码的位置
# print(ord('a')) # print(ord('中')) # unicode
chr:输入位置数字找出其对应的字符
# print(chr(65)) # print(chr(20013)) # unicode
ascii:是ascii码中的返回该值，不是就返回/u...
# print(ascii('a')) # print(ascii(1)) # print(ascii('中'))
*** repr:返回一个对象的string形式（原形毕露）。
# msg = '小数%f' %(1.234) # print(msg) # msg = '姓名：%r' % ( 'alex') # print(msg) # print(repr('{"name":"alex"}')) # print('{"name":"alex"}')
数据集合
dict：创建一个字典。
# dic = dict({'name': 'alex'}) # print(dic)
set：创建一个集合。
# set1 = set(('alex','wusir')) # print(set1)
frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
相关内置函数
*** len:返回一个对象中元素的个数。
*** sorted：对所有可迭代的对象进行排序操作。 返回的是列表
# print(sorted([1, 2, 3, 4, 5, -6]))
# print(sorted([1, 2, 3, 4, 5, -6], key=abs))
# L = [('a', 1), ('c', 2), ('d', 4), ('b', 3), ] # print(sorted(L))
# def func1(x): # return x[1] # L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ] # print(sorted(L, key=func1))
*all：可迭代对象中，全都是True才是True
# print(all([1, 'alex', True, (1,2,3)])) # print(all([0, 'alex', True, (1,2,3)]))
*any：可迭代对象中，有一个True 就是True
# print(any([0, '', False, (1,2,3)])) # print(any([0, '', False, ()]))
***zip 拉链方法 返回的是一个迭代器
# l1 = [1, 2, 3, 4] # tu1 = ('老男孩', 'alex', 'wusir') # l2 = ['*', '**', '***', "****"] # obj = zip(l1,tu1,l2) # for i in obj: # print(i)
***map: 循环模式
# def func2(x): # return x**2 # obj = map(func2, [1, 2, 3, 4]) # for i in obj: # print(i) # print((i**2 for i in [1, 2, 3, 4]))
# def func2(x, y): # return x + y # obj1 = map(func2, [1, 2, 3, 4, 6], (2, 3, 4, 5)) # for i in obj1: # print(i)
***filter 筛选模式
# def func(x): # return x % 2 == 0 # ret = filter(func,[1, 2, 3, 4, 5, 6, 7]) # print(ret) # for i in ret: # print(i) # print((i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0))
***lambda 匿名函数 一句话函数
# def func(x): return x % 2 == 0 # def func1(x, y): # return x + y # # ret = lambda x, y: x+y # # print(ret(2,3))
# def func1(x, y): # return x if x > y else y # # ret = lambda x, y: x if x > y else y # # print(ret(2,3))
# def func(x): # return x % 2 == 0 # ret = filter(lambda x:x % 2 == 0, [1, 2, 3, 4, 5, 6, 7]) # print(ret) # for i in ret: # print(i)
# [1, 2, 3, 4, 5, 6, 7] [1,4,9,16...] map lambda # ret2 = map(lambda x:x**2,[1, 2, 3, 4, 5, 6, 7]) # for i in ret2: # print(i)