一、基础数据类型相关(38)
一、和数字相关(14)
1、数据类型(4)
1、bool:布尔值
2、int:整数
3、float:浮点数
4、compiex:复数
2、进制转换(3)
1、bin:将十进制转换成二进制并返回。
2、oct:将十进制转化成八进制字符串并返回。
3、hex:将十进制转化成十六进制字符串并返回。
# 将十进制转换成二进制并返回。 print(bin(5)) # 0b101 # 将十进制转化成八进制字符串并返回。 print(oct(9)) # 0o11 # 将十进制转化成十六进制字符串并返回。 print(hex(10)) # 0xa
3、数学运算(7)
1、abs:函数返回数字的绝对值
2、divmod:计算除数与被除数的结果,返回一个包含商和余数的元组(a // b, a % b)。
3、round:保留浮点数的小数位数,默认保留整数
4、pow:求x**y次幂。(三个参数x**y的结果对z取余)
5、sum:对可迭代对象进行求和计算(可设置初始值)
6、max:返回可迭代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值)
7、min:返回可迭代对象的最小值(可加key,key为函数名,通过函数的规则,返回最小值)
# *abs:函数返回数字的绝对值。 print(abs(-20)) # 20 # # *divmod:计算除数与被除数的结果,返回一个包含商和余数的元组(a // b, a % b)。 print(divmod(11,3)) # (3, 2) # # round:保留浮点数的小数位数,默认保留整数。 print(round(3.1415)) # 3 print(round(3.1415,3)) # 3.142 # # pow:求x**y次幂。(三个参数为x**y的结果对z取余) print(pow(2,3)) # 8 print(pow(2,3,5)) # 3 # # ***sum:对可迭代对象进行求和计算(可设置初始值)。 print(sum([1,2,3])) # 6 print(sum([1,2,3],100)) # 106 # # ***max:返回可迭代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值)。 print(max([1,2,3])) # 3 # ret = max([1,2,-5,],key=abs) # 按照绝对值的大小,返回此序列最大值 print(ret) # -5 # ***min ret = min([1,2,-5,],key=abs) # 按照绝对值的大小,返回此序列最小值 print(ret) # 1
二、和数据结构相关(24)
1、序列(13)
1、列表和元组相关(2)
1、list:将一个可迭代对象转化成列表(如果是字典,默认将key作为列表的元素)
2、tuple:将一个可迭代对象转化成元祖(如果是字典,默认将key作为元祖的元素)
# 1、list:将一个可迭代对象转化成列表(如果是字典,默认将key作为列表的元素) l = list((1,2,3)) print(l) # [1,2,3] l = list({'k1':1,'k2':2}) print(l) # ['k1','k2'] # 2、tuple:将一个可迭代对象转化成元祖(如果是字典,默认将key作为元祖的元素) tu = tuple((1,2,3)) print(tu) # (1,2,3) tu = tuple({'k1':1,'k2':2}) print(tu) # ('k1','k2')
2、字符串相关(9)
1、str:将数据转化成字符串
2、format:与具体数据相关,用于计算各种小数,精算等
3、bytes:用于不同编码之间的转化
4、bytearry:返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256
5、memoryview:函数返回给定参数的内存查看对象
6、ord:输入字符找该字符编码的位置
7、chr:输入位置数字找出其对应的字符
8、ascii:是ascii码中的返回该值,不是就返回/u
9、repr:返回一个对象的string形式(原形毕露)
# 1、str:将数据转化成字符串 # 2、format:与具体数据相关,用于计算各种小数,精算等,字符串可以提供的参数,指定对齐方式,<是左对齐, >是右对齐,^是居中对齐 print(format('test', '^20')) # 列为20,test居中 # 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None print(format(3,'b')) # 转换成二进制 11 print(format(97,'c')) # 转换unicode成字符 'a' print(format(11,'d')) # 转换成10进制 '11' print(format(11,'o')) #转换成8进制 '13' print(format(11,'x')) #转换成16进制 小写字母表示 'b' print(format(11,'X')) #转换成16进制 大写字母表示 'B' print(format(11,'n')) #和d一样 '11' print(format(11)) #默认和d一样 # '11' #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None print(format(314159267,'e')) #科学计数法,默认保留6位小数 '3.141593e+08' print(format(314159267,'0.2e')) #科学计数法,指定保留2位小数 '3.14e+08' print(format(314159267,'0.2E'))#科学计数法,指定保留2位小数,采用大写E表示 '3.14E+08' print(format(314159267,'f')) #小数点计数法,默认保留6位小数 '314159267.000000' print(format(3.14159267000,'f')) #小数点计数法,默认保留6位小数 '3.141593' print(format(3.14159267000,'0.8f')) #小数点计数法,指定保留8位小数 '3.14159267' print(format(3.14159267000,'0.10f')) #小数点计数法,指定保留10位小数 '3.1415926700' print(format(3.14e+1000000,'F')) #小数点计数法,无穷大转换成大小字母 'INF' #g的格式化比较特殊,假设p为格式中指定的保留小数位数,先尝试采用科学计数法格式化,得到幂指数exp,如果-4<=exp<p,则采用小数计数法,并保留p-1-exp位小数,否则按小数计数法计数,并按p-1保留小数位数 print(format(0.00003141566,'.1g')) #p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点 '3e-05' print(format(0.00003141566,'.2g')) #p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留1位小数点 '3.1e-05' print(format(0.00003141566,'.3g'))#p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留2位小数点 '3.14e-05' print(format(0.00003141566,'.3G')) #p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点,E使用大写 '3.14E-05' print(format(3.1415926777,'.1g')) #p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留0位小数点 '3' print(format(3.1415926777,'.2g')) #p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留1位小数点 '3.1' print(format(3.1415926777,'.3g')) #p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留2位小数点 '3.14' print(format(0.00003141566,'.1n')) #和g相同 '3e-05' print(format(0.00003141566,'.3n')) #和g相同 '3.14e-05' print(format(0.00003141566)) #和g相同 '3.141566e-05' # 3、bytes:用于不同编码之间的转化 s = '你好' bs = s.encode('utf-8') print(bs) # b'\xe4\xbd\xa0\xe5\xa5\xbd' s1 = bs.decode('utf-8') print(s1) # 你好 bs = bytes(s,encoding='utf-8') print(bs) # b'\xe4\xbd\xa0\xe5\xa5\xbd' b = '你好'.encode('gbk') b1 = b.decode('gbk') print(b1.encode('utf-8')) # b'\xe4\xbd\xa0\xe5\xa5\xbd' # 4、bytearry:返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256 ret = bytearray('alex',encoding='utf-8') print(id(ret)) # 2158681328192 print(ret) # bytearray(b'alex') print(ret[0]) # 97 ret[0] = 65 print(ret) # bytearray(b'Alex') print(id(ret)) # 2158681328192 # 5、memoryview:函数返回给定参数的内存查看对象 ret = memoryview(bytes('你好',encoding='utf-8')) print(len(ret)) # 6 print(ret) # <memory at 0x000001BC12D68A08> print(bytes(ret[:3]).decode('utf-8')) # 你 print(bytes(ret[3:]).decode('utf-8')) # 好 # 6、ord:输入字符找该字符编码的位置 print(ord('a')) # 97 # 7、chr:输入位置数字找出其对应的字符 print(chr(97)) # a # 8、ascii:是ascii码中的返回该值,不是就返回/u print(ascii('a')) # 'a' print(ascii('中')) # '\u4e2d' # 9、repr:返回一个对象的string形式(原形毕露) print(repr(2+3)) # 5
3、相关内置函数(2)
1、reversed:将一个序列翻转,并返回此翻转序列的迭代器
2、slice:构造一个切片对象,用于列表的切片
# 1、reversed:将一个序列翻转,并返回此翻转序列的迭代器 ite = reversed(['a',2,3,'c',4,2]) for i in ite: print(i) # 2 # 4 # c # 3 # 2 # a # 2、slice:构造一个切片对象,用于列表的切片 li = ['a','b','c','d','e','f','g'] sli_obj = slice(3) print(li[sli_obj]) # ['a', 'b', 'c'] sli_obj = slice(0,7,2) print(li[sli_obj]) # ['a', 'c', 'e', 'g']
2、数据集合(3)
1、dict:创建一个字典
2、set:创建一个集合
3、frozenset:返回一个冻结的集合,冻结后集合不能再添加或删除任何元素
3、相关内置函数(8)
1、len:返回一个对象中元素的个数
2、sorted:对所有可迭代的对象进行排序操作
3、enumerate:枚举,返回一个枚举对象
4、all:可迭代对象中,全都是True才是True
5、any:可迭代对象中,有一个True就是True
6、zip:函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同
7、filter:过滤
8、map:会根据提供的函数对指定序列做映射
# 1、len:返回一个对象中元素的个数 li = [1,2,3] print(len(li)) # 3 # 2、sorted:对所有可迭代的对象进行排序操作 L = [('a', 1), ('c', 3), ('d', 4), ('b', 2), ] sorted(L, key=lambda x: x[1]) # 利用key print(L) # [('a', 1), ('c', 3), ('d', 4), ('b', 2)] students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] a = sorted(students, key=lambda s: s[2]) # 按年龄排序 print(a) # [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] b = sorted(students, key=lambda s: s[2], reverse=True) # 按降序 print(b) # [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] # 3、enumerate:枚举,返回一个枚举对象 for i,j in enumerate([1,2,3],1): print(i,j) # 1 1 # 2 2 # 3 3 # 4、all:可迭代对象中,全都是True才是True print(all([1,2,True,0])) # Faluse # 5、any:可迭代对象中,有一个True就是True print(any([1,'',0])) # True # 6、zip:函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同 l1 = [1,2,3,] l2 = ['a','b','c',5] l3 = ('*','**',(1,2,3)) for i in zip(l1,l2,l3): print(i) # (1, 'a', '*') # (2, 'b', '**') # (3, 'c', (1, 2, 3)) # 7、filter:过滤 #filter 过滤 通过你的函数,过滤一个可迭代对象,返回的是True #类似于[i for i in range(10) if i > 3] 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) # 2 # 4 # 6 # 8、map:会根据提供的函数对指定序列做映射 a = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) for i in a:print(i) # 7 # 11 # 15 # 19
二、作用域相关(2)
1、locals:函数会以字典的类型返回当前位置的全部局部变量
2、globals:函数以字典的类型返回全部全局变量
def func(argv): c = 2 print(locals()) # {'c': 2, 'argv': 3} print(globals()) # {'__cached__': None, '__doc__': None, '__name__': '__main__', 'func': <function func at 0x000001CBF2AC17B8>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CBF286F470>, '__file__': 'D:/python第11期/分/test/test32.py', '__package__': None} func(3)
三、迭代器/生成器(3)
1、range:函数可创建一个整数对象,一般用于for循环中
2、next:内部实际使用了__next__方法,返回迭代器的下一个项目
3、iter:函数用来生成迭代器(讲一个可迭代对象,生成迭代器)
# 1、range:函数可创建一个整数对象,一般用于for循环中 li = [] for i in range(10): li.append(i) print(li) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 2、next:内部实际使用了__next__方法,返回迭代器的下一个项目 # 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: li = [] while True: try: # 获得下一个值: x = next(it) li.append(x) except StopIteration: # 遇到StopIteration就退出循环 break print(li) # [1, 2, 3, 4, 5] # 3、iter:函数用来生成迭代器(讲一个可迭代对象,生成迭代器) 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(l1,Iterable)) # True print(isinstance(l1,Iterator)) # True
四、反射相关(4)
1、setattr:设置属性
2、delattr:删除属性
3、getattr:获取属性
4、hasattr:检验是否含有某属性
class Foo: f = '类的静态变量' def __init__(self,name,age): self.name=name self.age=age def say_hi(self): print('hi,%s'%self.name) obj=Foo('egon',73) #检测是否含有某属性 print(hasattr(obj,'name')) # True print(hasattr(obj,'say_hi')) # True #获取属性 n=getattr(obj,'name') print(n) # egon func=getattr(obj,'say_hi') func() # hi,egon print(getattr(obj,'aaaaaaaa','不存在啊')) # 不存在啊 #设置属性 setattr(obj,'sb',True) setattr(obj,'show_name',lambda self:self.name+'sb') print(obj.__dict__) # {'show_name': <function <lambda> at 0x000001EADD5E17B8>, 'name': 'egon', 'sb': True, 'age': 73} print(obj.show_name(obj)) # egonsb #删除属性 delattr(obj,'age') delattr(obj,'show_name') # delattr(obj,'show_name111')#不存在,则报错 print(obj.__dict__) # {'sb': True, 'name': 'egon'}
五、面向对象相关(9)
1、type:type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象
2、isinstance:isinstance(obj,cls)检查是否obj是否是类 cls 的对象
3、issubclass:issubclass(sub, super)检查sub类是否是 super 类的派生类
4、classmethod:classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
5、object:新式类中所有类的父类
6、property:@property 能够将一个方法伪装成一个属性
7、staticmethod:python staticmethod 返回函数的静态方法
8、super:super() 函数是用于调用父类(超类)的一个方法。
9、vars:vars() 函数返回对象object的属性和属性值的字典对象。
# 1、type:type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象 # isinstance() 与 type() 区别: # type() 不会认为子类是一种父类类型,不考虑继承关系。 # isinstance() 会认为子类是一种父类类型,考虑继承关系。 # 如果要判断两个类型是否相同推荐使用 isinstance()。 class A:pass class B(A):pass print(isinstance(A(), A)) # True print(type(A()) == A) # True print(isinstance(B(), A)) # True print(type(B()) == A) # False # 2、isinstance:isinstance(obj,cls)检查是否obj是否是类 cls 的对象 # 3、issubclass:issubclass(sub, super)检查sub类是否是 super 类的派生类 class A:pass class B(A):pass print(issubclass(B, A)) # True # 4、classmethod:classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。 class A: bar = 1 @classmethod def func2(cls): print ('func2') print (cls.bar) A.func2() # func2 # 1 # 5、object:新式类中所有类的父类 # 6、property:@property 能够将一个方法伪装成一个属性 class Person: def __init__(self,name,weight,height): self.name = name self.__height = height self.__weight = weight @property def bmi(self): return self.__weight / self.__height ** 2 p = Person('大表哥',92,1.85) print(p.bmi) # 26.880934989043094 p._Person__weight = 90 print(p.bmi) # 26.296566837107374 # 7、staticmethod:python staticmethod 返回函数的静态方法 class C: @staticmethod def f(): print(111) C.f() # 静态方法无需实例化 111 cobj = C() cobj.f() # 也可以实例化后调用 111 # 8、super:super() 函数是用于调用父类(超类)的一个方法。 # python3.x class A:pass class B(A): def add(self, x): super().add(x) # python2.x class A(object): # Python2.x 记得继承 object pass class B(A): def add(self, x): super(B, self).add(x) # 9、vars:vars() 函数返回对象object的属性和属性值的字典对象。 print(vars()) # {'p': <__main__.Person object at 0x000001F973A0F780>, 'C': <class '__main__.C'>, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F9737BF470>, '__doc__': None, 'Person': <class '__main__.Person'>, '__file__': 'D:/python第11期/分/test/test32.py', 'B': <class '__main__.B'>, '__package__': None, '__name__': '__main__', 'cobj': <__main__.C object at 0x000001F973A0F860>, '__builtins__': <module 'builtins' (built-in)>, '__cached__': None, 'A': <class '__main__.A'>, '__spec__': None} class A:pass # {'__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>}
六、其他(12)
一、字符串类型代码的执行(3)
1、eval:将字符串类型的代码执行并返回结果
2、exec:将自字符串类型的代码执行
3、compile:将字符串类型的代码编译
# 1、eval:将字符串类型的代码执行并返回结果 print(eval('1+1')) # 2 # 2、exec:将自字符串类型的代码执行 s = ''' li = [] for i in [1,2,3]: li.append(i) print(li) ''' exec(s) # [1, 2, 3] # 3、compile:将字符串类型的代码编译 code2 = '1 + 2 + 3 + 4' compile2 = compile(code2,'','eval') print(eval(compile2)) # 10
二、输入输出(2)
1、input:输入
2、print:输出
三、内存相关(2)
1、hash(o):o是参数,返回一个可hash变量的哈希值,不可hash的变量被hash之后会报错
2、id(o):o是参数,返回一个变量的内存地址
# 1、hash(o):o是参数,返回一个可hash变量的哈希值,不可hash的变量被hash之后会报错 print(hash('alex')) # -7697999738255044320 print(hash(True)) # 1 # 2、id(o):o是参数,返回一个变量的内存地址 print(id(1)) # 1400918816
四、文件操作相关(1)
1、open:打开一个文件,返回一个文件操作符(文件句柄)
五、模块相关(1)
1、__import__:导入一个模块,函数用于动态加载类和函数 。
六、帮助(1)
1、help:帮助方法
七、调用相关(1)
1、callable(o):o是参数,看这个变量是不是可调用,如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。
# 1、callable(o):o是参数,看这个变量是不是可调用,如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。 print(callable(0)) # False class A:pass print(callable(A)) # True
八、查看内置属性(1)
1、dir:默认查看全局空间内的属性,也接受一个参数,查看这个参数内的方法或变量
>>>dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice'] >>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
内置函数思维导图:https://www.processon.com/view/link/5ae949b8e4b09b1bf63730c4