abs()
abs(val)
val:该参数可以是整数，浮点数或复数
任何进制的数作为 abs() 函数的参数，结果最终返回的都是其10进制形式
print(abs(-10)) # 10
print(abs(25.68)) # 25.68
all()
all(val)
val:可以迭代的对象
列表,集合,元祖
比如：当列表中元素都为True返回True,如果其中一个元素False那么就是False
l1 = [True, True, 1, 'asdas']
print(all(l1)) # True
l2 = [True, False, 1, 'asdas']
print(all(l2)) # True
any()
# 与上面的all相似
all(val)
val:可以迭代的对象
列表,集合,元祖
比如：当列表中元素只要有一个True返回True,如果一个都没有就是False
l1 = [True, False, {}, ()]
print(any(l1)) # True
l2 = [False, [], {}, (), 0]
print(any(l2)) # False
ascii()
# https://zh.wikipedia.org/zh-cn/ASCII
ascii(val)
val：字符对象
返回一个包含对象的可打印表示形式的字符串，但是使用 \x、\u 和 \U 对 repr() 返回的字符串中非 ASCII 编码的字符进行转义
是基于拉丁字母的一套电脑编码系统。它主要用于显示现代英语，而其扩展版本延伸美国标准信息交换码则可以部分支持其他西欧语言，并等同于国际标准ISO/IEC 646。
print(ascii(1321)) # 1321
print(ascii('@@##$%^@#$@')) # '@@##$%^@#$@'
print(ascii('真的牛')) # '\u771f\u7684\u725b'
bin()
bin(val)
val:整数
将一个整数转换为带前缀 "0b" 的二进制数字符串。
print(bin(1)) # 0b1
print(bin(100)) # 0b1100100
bool()
用于返回布尔值，即 True 或 False 两者之一
print(bool(1)) # True
print(bool(0)) # False
print(bool([])) # False
print(bool({})) # False
print(bool(())) # False
print(bool('')) # False
print(bool(None)) # False
print(bool(-1)) # True
print(bool()) # False
breakpoint()
用于在代码中设置断点以进行调试
def func():
x = 10
y = 20
breakpoint() # 设置断点,使用调用模式直接从这个位置向下执行
z = x + y
return z
result = func()
print(result)
bytearray()
返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。
bytes()
返回一个新的“bytes”对象，这是一个不可变序列，包含范围为 0 <= x < 256 的整数。
callable()
callable(object)
检查当前object是否可以被调用，可以返回True 不是 False
调用仍失败可能，但如果返回 False，则调用 object 肯定不是一个对象
当前内置函数就是为了确定你的参数是否是个可以调用对象
def a():
print(1)
print(callable(a)) # True
class B:
def __init__(self):
pass
print(callable(B)) # True
def c():
print(1)
sadads
print(2)
c() # 报错 NameError: name 'sadads' is not defined
print(callable(c)) # True
chr()
返回一个Unicode编码的整数对应的字符。 https://www.fuhaoku.net/blocks
i = 65
print(chr(i)) # A
i = 8352
print(chr(i)) # ₠
@classmethod
将一个类中的方法封装为类类方法
不用实例化类，直接使用类名就可以调用类方法
class A:
@classmethod
def func(cls):
print("1")
A.func() # 1
compile()
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
将 source 编译成代码或 AST 对象
代码对象可以被 exec() 或 eval() 执行。source 可以是常规的字符串、字节字符串，或者 AST 对象
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志
source = "print('Hello, World')"
print(source) # print(12132)
code = compile(source, filename="", mode="exec")
print(code) # <code object <module> at 0x0000014AD03009D0, file "", line 1>
exec(code) # Hello, World
complex()
创建一个复数
real = 3
imag = 4
c = complex(real, imag)
print(c) # 输出：(3+4j)
delattr()
用来删除对象中的参数
其参数是一个对象和一个字符串。 其中字符串必须是对象的某个属性的名称。 该函数会删除指定的属性
class A:
name = 'xxx'
print(A.name) # xxx
delattr(A,'name')
print(hasattr(A,'name')) # False
dict()
创建一个类型：字典
print(dict(a=1, b=3, c=4)) # {'a': 1, 'b': 3, 'c': 4}
dir()
dir(object): 返回一个包含对象所有属性和方法名的列表
如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表
# 没有定义
class A:
attr = 10
obj = A()
print(dir(obj)) # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'attr', 'method']
# 定义dir函数
class A:
attr = 10
def __dir__(self):
return ['A', 'B', 'C']
obj = A()
print(dir(obj)) # ['A', 'B', 'C']
divmod()
divmod(a, b): 返回a除以b的商和余数。
print(divmod(10, 3)) # (3, 1)
enumerate()
enumerate(iterable, start=0): 返回一个枚举对象，包含索引和值。
l = ['A', 'B', 'C']
for index,value in enumerate(l):
print(index,value)
"""
0 A
1 B
2 C
"""
eval()
eval(expression, globals=None, locals=None): 执行一个字符串表达式，并返回结果。
print(exec("print('asdasdsa')"))
asdasdsa
None
exec()
exec(object, globals=None, locals=None, /, *, closure=None) 指定字符串表达式
object 必须是字符串或者代码对象
如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）
果是代码对象，它将被直接执行
print(exec("print('asdasdsa')"))
asdasdsa
filter()
filter(function, iterable) 使用 iterable 中 function 返回真值的元素构造一个迭代器
iterable 可以是一个序列，一个支持迭代的容器或者一个迭代器
如果 function 为 None，则会使用标识号函数也就是说，iterable 中所有具有假值的元素都将被移除。
# 使用给定的函数对可迭代对象进行过滤
def is_positive(number):
return 0 < number
l = [-1, -100, 1, 80, 4, 9]
r = filter(is_positive, l)
print(r) # <filter object at 0x00000243FFBD27C0>
for i in r:
print(i)
"""
1
80
4
9
"""
float()
float(x=0.0) 返回从数字或字符串 x 生成的浮点数
print(float(10)) # 10.0
format(value, format_spec='') 格式化内置函数
# https://docs.python.org/zh-cn/3/library/string.html#formatspec
value = 3.14159
result = format(value, ".2f")
print(result) # 输出：3.14
frozenset()
frozenset(iterable=set()) 创建一个不可变的集合，内部不能增删改查，但是可以作为字典的键，或者其他的数据结构的元素
l = [1, 2, 3, 8, 5, 8]
s = frozenset(l)
print(s) # frozenset({1, 2, 3, 5, 8})
getattr()
object 中指定名称的属性的值。 name 必须是字符串。 如果该字符串是对象的某一属性的名称，则结果将为该属性的值。 例如，getattr(x, 'foobar') 等同于 x.foobar。
# 返回创建类中的属性值
class A:
name = "xxx"
def func(self):
print("666")
a = A()
print(getattr(a, "name")) # xxx
print(getattr(a, "func")) # <bound method A.func of <__main__.A object at 0x000001C11D37DF70>>
getattr(a, "func")() # 666
globals()
print(globals()) 返回当前的全局字典
hasattr()
hasattr(object, name) 检查对象是否有指定的属性。有True 没有False
class A:
name = "asda"
print(hasattr(A, 'name')) # True
print(hasattr(A, 'age')) # False
hash()
返回对象的哈希值
x = 'asdasdas'
print(hash(x)) # 3236619515179111894
help()
返回对象帮助信息
help(list)
hex()
将整数转换为带前缀 "0x" 前缀的小写十六进制数字符串
print(hex(10)) # 0xa
print(hex(15)) # 0xa
id()
返回对象的“标识值”,对象在内存中的地址
name = 'xxx'
name1 = name
print(id(name)) # 2444552958064
print(id(name1)) # 2444552958064
input(prompt) # 存在实参就是标准输出
name = input("请输入你的名字：")
print(name)
请输入你的名字：asdasd
asdasd
int()
将数转为整数
x = 3.14
print(int(x)) # 输出：3
isinstance()
isinstance(object, classinfo) 检查一个'对象'是否为'指定类'或'类型元组'的实例
isinstance(object, classinfo)
class A(object):
pass
class B(A):
pass
a = A()
b = B()
print(isinstance(a, object)) # True
print(isinstance(b, A)) # True
issubclass()
issubclass(class, classinfo)检查一个类是否为另一个类的子类
class A(object):
pass
class B(A):
pass
print(issubclass(A, object)) # True
print(issubclass(B, A)) # True
iter()
iter(object, sentinel) 创建一个迭代器对象
l = [1, 2, 3]
i = iter(l)
print(i) # <list_iterator object at 0x000002B5B02A3880>
print(next(i)) # 1
print(next(i)) # 2
print(next(i)) # 3
len()
返回对象的长度（元素个数）
实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）
l = [1, 2, 3]
print(len(l)) # 3
list()
创建一个列表
l = (1, 2, 3)
print(list(l)) # [1, 2, 3]
locals()
返回局部作用域字典
print(locals())
map()
map(function, iterable) 对每一个迭代对象，应用函数,返回一个可迭代对象
def num(x):
return x * 2
l = (1, 2, 3)
print(map(num, l)) # <map object at 0x000002889C9BDEB0>
print(list(map(num, l))) # [2, 4, 6]
max()
返回可迭代对象中的最大值。
l = (1, 2, 3)
print(max(l)) # 3
min()
返回可迭代对象中的最小值。
l = (1, 2, 3)
print(max(l)) # 1
memoryview()
返回由给定实参创建的“内存视图”对象
https://docs.python.org/zh-cn/3/library/stdtypes.html#typememoryview
next()
返回迭代器下一个值
l = [1, 2, 3]
i = iter(l)
print(i) # <list_iterator object at 0x000002B5B02A3880>
print(next(i)) # 1
print(next(i)) # 2
print(next(i)) # 3
object()
返回一个不带特征的新对象。object 是所有类的基类。它带有所有 Python 类实例均通用的方法。本函数不接受任何参数。
obj = object()
print(obj) # 返回一个空对象
oct()
将一个整数转换为8进制字符串
x = 8
print(oct(x)) # 输出：0o10
open()
打开一个文件对象，进行读写操作
open('xxx.txt','f')
ord()
返回一个unicode编码
c = 'A'
print(ord(c)) # 输出：65
print()
打印内容到控制台
print(123) # 123
pow()
pow(base, exp, mod=None) 返回 base 的 exp 次幂，如果mod有值则返回 base 的 exp 次幂对 mod 取余
print(pow(10,3,3)) # 1
property()
函数的作用是在新式类中返回属性值
property(fget=None, fset=None, fdel=None, doc=None)
fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
# 使用在装饰器上
class MyClass:
def __init__(self):
self._attr = 0
@property
def attr(self):
return self._attr
@attr.setter
def attr(self, value):
self._attr = value
obj = MyClass()
obj.attr = 10
print(obj.attr) # 输出：10
range()
返回一个0到stop_num-1的整数序列迭代对象
for i in range(5):
print(i)
# 输出：
# 0
# 1
# 2
# 3
# 4
repr()
返回一个对象的字符串表示形式
s = "Hello"
print(repr(s)) # 输出：'Hello'
reversed()
返回一个倒叙的迭代器对象
l = [1, 2, 3, 4, 5, 6]
print(reversed(l)) # <list_reverseiterator object at 0x000001EA15BD2880>
print(list(reversed(l))) # [6, 5, 4, 3, 2, 1]
round()
round(number, ndigits=None) 对一个数值进行四舍五入
返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。
print(round(1.211313, 2)) # 1.21
print(round(1.211313, 3)) # 1.211
print(round(1.211313, 5)) # 1.21131
set()
创建一个集合
iterable = [1, 2, 3]
s = set(iterable)
print(s) # 输出：{1, 2, 3}
setattr()
给对象设置属性
class A:
name = 'asdads'
a = A()
setattr(A, 'age', 18)
print(a.age) # 18
print(A.age) # 18
slice()
slice(start, stop, step=None) 切片对象具有只读的数据属性 start, stop
numbers = [1, 2, 3, 4, 5]
s = slice(2)
print(numbers[s]) # 输出：[1, 2]
sorted()
sorted(iterable, /, *, key=None, reverse=False)
reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。
l = [3, 1, 4, 2, 5]
print(sorted(l)) # [1, 2, 3, 4, 5]
print(sorted(l,reverse=True)) # [5, 4, 3, 2, 1]
@staticmethod
@staticmethod 将类中的方法转变为静态方法 静态方法不会接收隐式的第一个参数，也就是cls(类对象)或self(实例对象)
class A:
@staticmethod
def f():
print(1)
A.f() # 1
str()
字符串，将对象转为字符串
x = 10001
print(str(x)) # '10001'
sum()
返回迭代对象的总和，前提：这个可迭代对象元素必须时整数
l = [1, 2, 10, 30, 50]
print(sum(l)) # 93
super()
返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重写的继承方法很有用
在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能super
class A:
def __init__(self):
self.name = 'xxx'
def d1(self):
print(self.name)
class B(A):
def __init__(self):
super().__init__() # 如果不是super,B类的__init__就会覆盖A类__init__就无法使用name属性
b = B() # 实例化B类
b.d1() # 通过实例化的B类对象调继承A类的d1函数
tuple()
元祖转换，创建元祖
l = [1, 2, 3]
t = tuple(l)
print(t) # 输出：(1, 2, 3)
type()
返回对象的类型是什么
l = [11, 4564]
print(type(l)) # <class 'list'>
vars()
返回对象的属性值与属性名的字典，与__dict__一样效果
class A:
def __init__(self):
self.name = 'xxx'
a = A()
print(vars(a)) # {'name': 'xxx'}
zip()
将多个可迭代对象中对应位置的元素打包成元组，并返回一个由这些元组组成的可迭代对象。
l = ['asda', 'qeq', 1231]
b = [45, 11, 66]
print(zip(l, b)) # <zip object at 0x000001B2A3F01A80>
print(list(zip(l, b))) # [('asda', 45), ('qeq', 11), (1231, 66)]
按照下标索引一个对一个将多个迭代对象的元素打包到一起
# 按照长度最小的可迭代带对象作为索引下标标准
l = ['asda', 'qeq', 1231]
b = [45, 11]
print(zip(l, b)) # <zip object at 0x000001B2A3F01A80>
print(list(zip(l, b))) # [('asda', 45), ('qeq', 11)]
