目录
- 逻辑相关
- 类型相关
- complex([real[, imag]])
- float(x)
- int(x, base=10)
- bytearray([source[, encoding[, errors]]])
- bytes([source[, encoding[, errors]]])
- dict(iterable, **kwarg)
- frozenset([iterable])
- list([iterable])
- set([iterable])
- tuple([iterable])
- str(object=b'', encoding='utf-8', errors='strict')
- isinstance(obj, classinfo)
- issubclass(class, classinfo)
- 进制相关
- 计算相关
- 执行字符串代码
- 其他
- chr(i)
- ord(c)
- delattr(obj, name)
- setattr(obj, name, value)
- getattr(obj, name[, default])
- dir([obj])
- enumerate(iterable, start=0)
- globals()
- locals()
- help(obj)
- id(obj)
- input([prompt])
- print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
- iter(obj[,sentinel])
- next(iterator[, default])
- len(s)
- range(start, stop[,step])
- reversed(seq)
- zip(*iterables)
- sorted(iterable, *, key=None, reverse=False)
- filter(function, iterable)
- map(function, iterbale, ...)
- type(name, bases, dict, **kwds)
- 操作文件
逻辑相关
bool(obj)
返回True或False。对于对象而言,在默认情况下都是返回True,只有当该对象所属类定义了__bool__
并且返回False,或是定义了__len__
返回0。
内置返回False的对象:
- None, False
- 数值为0:0、0.0 等
- 空的序列:‘’, (), [], {}, set(), range(0)等
all(iterable)
如果iterable的所有元素均为True,则返回True,等价实现:
def all(iterable):
for element in iterable:
if not element:
return False
return True
注意: 如果传入的是空的可迭代对象也是返回True
any(iterable)
如果iterable的其中一个元素为True则返回True,等价实现:
def any(iterable):
for element in iterable:
if element:
return True
return False
callable(obj)
如果obj可被调用(obj()
不会触发异常)就返回True
对于对象需要定义__call__
方法
类型相关
complex([real[, imag]])
返回一个real+imag*j的复数。如果real是字符串,则将它强转为复数。
对于自定义的对象,查找优先级__complex__
> __float__
> __index__
(python3.8)
class A:
def __complex__(self):
return complex(2, 3)
def __float__(self):
return 2.1
print(complex(A()))
float(x)
返回数值或字符串生成的浮点数
对于自定义的对象,查找优先级 __float__
> __index__
int(x, base=10)
返回一个字符串或者数值类型转化的整数,base为转为整数时的进制
bytearray([source[, encoding[, errors]]])
返回一个新的bytes数组,该类型是可变类型,包含可变类型的大部分方法
- 如果source是string类型,则encoding参数必须给定
- 如果source是一个integer类型,则使用该数字来初始化,并用null字节填充
- 如果source是bytes、bytearray或array.array类型
- 如果source是iterable类型,它的元素必须全是
0 <= x < 256
的整数
bytes([source[, encoding[, errors]]])
返回一个bytes对象,与bytearray不同的是,该类型为不可变类型
dict(iterable, **kwarg)
返回一个字典
frozenset([iterable])
返回一个不可变的集合
list([iterable])
返回一个列表
set([iterable])
返回一个集合
tuple([iterable])
返回一个元组
str(object=b’', encoding=‘utf-8’, errors=‘strict’)
返回一个字符串
isinstance(obj, classinfo)
如果obj是classinfo的实例或子类返回True,clasinfo可以给定多个元素的元组,如果obj是其中之一的实例或子类返回True
issubclass(class, classinfo)
如果class是classinfo的子类返回True,classinfo也可以是元组
进制相关
bin(x)
将整数转化成0b开头的二进制字符串,对于对象需定义__index__
class A:
def __index__(self):
return -1
print(bin(A()))
hex(x)
将整数转为0x开头的十六进制字符串,对于对象需定义__index__
, 浮点数的十六进制表示请用float.hex()
oct(x)
将整数转为0o开头的八进制字符串,对于对象需定义__index__
计算相关
abs(x)
计算数值的绝对值
自定义类可实现__abs__
方法
class A:
def __abs__(self):
return -1
print(abs(A()))
divmod(a, b)
返回商和余数组成的元组
如果是整数:(a // b, a % b)
如果是浮点数: (q, a % b)
,其中q=math.floor(a/b)
不管a,b是什么类型的值,都满足q * b + a % b == a
hash(obj)
返回obj的哈希值,返回的哈希值是整数类型。另外数值类型如果值相同,则他们具有相同的hash,比如1和1.0。可自定义__hash__
max(iterable, *[, key, default])
返回iterable中最大的元素,其中key是一个函数,用于提取实际比较的值
第二个例子是将字符串转为十六进制数再进行比较,最后一个例子是只比较字符串的最后一个字符,返回最大的那个字符串
min(iterable, *[, key, default])
返回iterable中最小的元素
pow(base, exp[, mod])
返回 base 的 exp 次幂,等价于base**exp
。如果mod存在,则返回pow(base, exp) % mod
的值,比这样取余更高效,
round(number[,ndigits])
返回数字number四舍五入到小数点后ndigits位的值
sum(iterable, /, start=0)
返回iterable全部加起来的总和
执行字符串代码
eval(expression[, globals[, locals]])
执行expression字符串代码并返回执行结果,globals和locals如果不给定,默认使用当前环境下的
exec(object[, globals[, locals]])
执行字符串代码,无返回值。与eval不同的是,exec用于执行代码段,而eval用于执行表达式
其他
chr(i)
返回整数i在Unicode码表的字符,i的范围:0-0x10FFFF
ord©
返回c字符在Unicode码表的整数
delattr(obj, name)
删除obj对象的name属性,等价于del obj.name
setattr(obj, name, value)
设置obj对象的name的值,等价于obj.name = value
getattr(obj, name[, default])
获取obj对象的name的值,约等于obj.name
。如果obj没有name属性,则返回default给定的值,如果没给,则触发AttributeError
异常
dir([obj])
返回obj对象的有效属性列表,可自定义__dir__
class A:
def __dir__(self):
return ("a", "b")
print(dir(A()))
如果不给参数则返回locals作用域的名称列表,约等价于list(locals().keys())
enumerate(iterable, start=0)
返回一个包含两个元素组成的元组的可迭代对象,第一个元素是个计数器,从start开始
等价实现:
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1
globals()
返回全局作用域的字典
locals()
返回本地作用域的字典
help(obj)
返回obj的帮助信息
class A:
def a(self, name:str) -> str:
'''
这是个函数
'''
return name
help(dir)
print('-'*100)
help(A)
print('-'*100)
help(A())
print('-'*100)
help(A().a)
id(obj)
返回obj的一个整数格式的"标识值",该值在当前声明周期内是唯一且不会改变的
input([prompt])
阻塞接收标准输入的字符,prompt为提示信息
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
将信息输出到file指定的流中,默认是sys.stdout(标准输出)
- sep: 多个object输出之间使用的分隔符
- end:最后加上的字符
- flush:是否强制刷新到流
iter(obj[,sentinel])
返回一个iterable对象,obj可以是任意可迭代对象。如果是可被调用的对象,则必须给定sentinel参数,直到迭代的值等于sentinel触发StopIteration
异常
next(iterator[, default])
取出iterator的下一个值,如果没有了,就返回default,否则触发StopIteration异常
len(s)
返回对象的长度(元素个数)
range(start, stop[,step])
返回从start到stop每间隔step的值组成的可迭代对象
reversed(seq)
返回一个反向的iterator,seq必须实现__reversed__
,或者是支持该方法的对象如同时实现了__len__
和__getitem__
方法的对象
zip(*iterables)
创建一个聚合了来自每个可迭代对象中的元素的迭代器,等价实现:
def zip(*iterables):
# zip('ABCD', 'xy') --> Ax By
sentinel = object()
iterators = [iter(it) for it in iterables]
while iterators:
result = []
for it in iterators:
elem = next(it, sentinel)
if elem is sentinel:
return
result.append(elem)
yield tuple(result)
sorted(iterable, *, key=None, reverse=False)
返回iterable排序后的列表,key和min函数一样,reverse表示是否反序
filter(function, iterable)
迭代iterable,依次执行function,并返回结果为True的所有值组成的可迭代对象,等价于(item for item in iterable if function(item))
,如果function传None,则相当于bool
map(function, iterbale, …)
迭代iterable,依次执行function,并返回所有结果组成的可迭代对象。当有多个iterable,到元素最少的结束。等价于(function(item) for item in iterable)
type(name, bases, dict, **kwds)
如果只有一个参数,则返回该对象的类型,建议使用isinstance() 来判断类型
如果传入多个参数,表示定义一个新类,name是类名,bases是继承哪些类,dict表示定义哪些属性
X = type('X', (), dict(a=1))
等价于:
class X:
a = 1
再举个例子:
class B:
pass
class A(B, object):
def a(self, name:str) -> str:
'''
这是个函数
'''
return name
A1 = type("A", (B, object), {"a": lambda self, name:name})
print(A().a("cccccc"))
print(A1().a("cccccc"))
操作文件
open
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
- file: file一般是字符串
- mode:打开文件的模式
字符 | 含义 |
---|---|
r | 读取(默认) |
w | 写入,不存在会创建,存在会覆盖 |
x | 排它性创建,如果文件已存在则失败 |
a | 写入,如果文件存在则在末尾追加 |
b | 二进制模式 |
t | 文本模式(默认) |
+ | 打开用于更新(读取与写入) |
- buffering: 缓冲策略,0表示关闭缓冲(仅支持二进制模式) 1表示行缓冲 >1的整数则表示固定大小的块缓冲(单位:字节)。默认对二进制文件使用块缓冲,文本文件使用行缓冲
- encoding:编码
- errors:错误处理的方式,感觉没啥用
- newline :行分隔符的处理方式,取值:
None
,''
,'\n'
,'\r'
和'\r\n'
对于读取:如果为None,表示\n,\r`和 \r\n都会被转化成\n,如果是’‘,则不会转化,如果是其他值,感觉没什么用
对于写入:如果是None,写入的\n都会被替换成os.linesep, 如果是’',则不会替换 - closefd: 如果是False,表示file传入的不是文件名而是文件描述符
- opener:看不懂
newline给个例子:
import os
print("linesep: ", repr(os.linesep))
with open('1.txt', 'w', newline=None, encoding='utf-8') as f:
s = '\n\r\n\r'
f.write(s)
print("写入内容:", repr(s))
with open('1.txt', newline=None, encoding='utf-8') as f:
s = f.read()
print("读取:None, 写入:None, 读取结果: ", repr(s))
with open('1.txt', newline='',encoding='utf-8') as f:
s = f.read()
print("读取:'', 写入:None 读取结果: ", repr(s))
with open('1.txt', 'w', newline='',encoding='utf-8') as f:
f.write('\n\r\n\r')
with open('1.txt', newline='',encoding='utf-8') as f:
s = f.read()
print("读取:'', 写入:'' 读取结果: ", repr(s))
with open('1.txt', newline=None, encoding='utf-8') as f:
s = f.read()
print("读取:None, 写入:'' 读取结果: ", repr(s))
代码执行结果:
只有在读取和写入的newline都为空字符串时,读取的结果和写入的结果才是一样的