Python笔记【十二】
本文为博主原创，未经授权，严禁转载及使用。
本文链接：https://blog.csdn.net/zyooooxie/article/details/129037817
继续学习Python，继续更新。
这是我自己学习Python的系列博客： https://blog.csdn.net/zyooooxie/category_9592654.html
个人博客：https://blog.csdn.net/zyooooxie
_call_()
https://docs.python.org/zh-cn/3.8/reference/datamodel.html#object.call
"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: [email protected]
"""
def test_0407():
# object.__call__(self[, args...])
# 此方法会在 实例作为一个函数被“调用”时 被调用；
# 如果定义了此方法，则 x(arg1, arg2, ...) 就大致可以被改写为 type(x).__call__(x, arg1, ...)。
# 如果类中定义了__call__()方法，那么该类的实例对象也将成为可调用对象。
# 该实例对象被调用时，就会自动触发这个方法，执行__call__()中的代码。
pass
class TestClass(object):
def __call__(self, *args, **kwargs):
Log.info('TestClass __call__() 开始执行')
Log.info(args)
Log.info(kwargs)
Log.info(self)
Log.info(' __call__() 执行完')
class TestClass2(object):
pass
if __name__ == '__main__':
pass
tc = TestClass()
Log.info(tc)
Log.info(isinstance(tc, TestClass))
tc()
tc('参数1')
tc('参数1', k2='v2')
tc2 = TestClass2()
tc2() # TypeError: 'TestClass2' object is not callable
callable()
https://docs.python.org/zh-cn/3.8/library/functions.html?#callable
"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: [email protected]
"""
def test_callable():
# callable(object)
# 如果参数object是可调用的，就返回 True，否则返回 False。
# 如果返回 True，调用仍可能失败，
# 但如果返回 False，则调用 object 将肯定不会成功。
# 请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 __call__() 则它就是可调用的。
Log.info(callable(list))
Log.info(callable(list())) # 如果类中未设置__call()__方法的话是会返回False的
def test_callable2():
# 一个可callable的对象是指可以被调用执行的对象，并且可以传入参数；
# 下面列举callable对象的种类
# 1.函数（自定义函数、Python内置函数、lambda表达式）
# 2.类
# 3.类的方法
# 4.实现了__call__()的 类实例对象
# 对于可调用对象，对象名() 等价于 对象名.__call__()
pass
def func_0407():
Log.info('func_0407() 在执行')
class TestClass(object):
pass
class TestClass1(object):
def func_0407001(self):
Log.info('TestClass1 -- func_0407001')
Log.info(self)
class TestClass2(object):
def __call__(self, *args, **kwargs):
Log.info('TestClass2 -- __call__')
Log.info(self)
if __name__ == '__main__':
pass
Log.info(callable(func_0407))
func_0407()
func_0407.__call__()
Log.info(callable(int))
Log.info(int(1.2))
Log.info(int.__call__(-11.2))
Log.info(callable(lambda x: x * 2))
Log.info((lambda x: x * 2)(88))
Log.info((lambda x: x * 2).__call__(-888))
Log.info('*')
Log.info(callable(TestClass))
TestClass()
TestClass.__call__()
Log.info(TestClass())
Log.info('**')
Log.info(callable(TestClass1().func_0407001))
t = TestClass1()
t.func_0407001()
t.func_0407001.__call__()
Log.info(t.func_0407001())
Log.info('')
res = TestClass1().func_0407001
Log.info(callable(res))
res()
res.__call__()
Log.info(res())
Log.info('***')
Log.info(callable(TestClass2()))
TestClass2()() # 像调用函数一样使用
TestClass2().__call__()
Log.info(TestClass2()())
Log.info('')
res = TestClass2()
Log.info(callable(res))
res()
res.__call__()
Log.info(res())
operator模块【1】
https://docs.python.org/zh-cn/3.8/library/operator.html
"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: [email protected]
"""
# operator 模块提供了一套与Python 的内置运算符对应的高效率函数。
# 许多函数名与特殊方法名相同，只是没有双下划线。为了向后兼容性，也保留了许多包含双下划线的函数。
# 为了表述清楚，建议使用没有双下划线的函数。
def test_1():
# 比较运算：eq()，ne()，lt()，le()，gt()，和ge()
# 适用于所有的对象，函数名根据它们对应的比较运算符命名。
# python的比较运算符有6种，对应着两个对象之间的6种大小关系：相等，不相等，大于，小于，大于等于，小于等于。
a1 = 14.0
a2 = 14
b1 = '15'
b2 = 'abc'
# operator.lt(a, b)
# operator.le(a, b)
# lt(a, b) 与a < b 相同，
# le(a, b) 与a <= b 相同
Log.info(operator.lt(a1, a2))
Log.info(operator.le(a1, a2))
Log.info(operator.lt(b1, b2))
Log.info(operator.le(b1, b2))
Log.info('')
# operator.eq(a, b)
# operator.ne(a, b)
# eq(a,b) 与a == b 相同，
# ne(a, b) 与a != b 相同
Log.info(operator.eq(a1, a2))
Log.info(operator.ne(a1, a2))
Log.info('')
# operator.gt(a, b)
# operator.ge(a, b)
# gt(a, b) 与a > b 相同，
# ge(a, b)与 a >= b 相同
Log.info(operator.gt(a1, a2))
Log.info(operator.ge(a1, a2))
Log.info(operator.gt(b1, b2))
Log.info(operator.ge(b1, b2))
# operator.__lt__(a, b)
# operator.__le__(a, b)
# operator.__eq__(a, b)
# operator.__ne__(a, b)
# operator.__ge__(a, b)
# operator.__gt__(a, b)
# 比较运算会产生布尔值: True 或 False。 自定义的 富比较方法 可能返回非布尔值。
# 比较运算可以任意串连，例如 x < y <= z 等价于 x < y and y <= z，除了 y 只被求值一次（但在两种写法下当 x < y 值为假时 z 都不会被求值）
pass
def test_2():
# 逻辑运算：not_()，truth()，is_()，is_not()
# 通常也适用于所有对象，并且支持真值检测、标识检测和布尔运算
a1 = '15'
a2 = 15
# operator.not_(obj)
# operator.__not__(obj)
# 返回not obj 的结果。（请注意对象实例并没有__not__() 方法；只有解释器核心可定义此操作。结果会受__bool__() 和__len__() 方法影响。）
Log.info(operator.not_(a1))
Log.info(operator.not_(a2))
Log.info(operator.not_(True))
Log.info(operator.not_(False))
Log.info(operator.not_(0))
Log.info(operator.not_(1))
Log.info(operator.not_(None))
Log.info('')
# operator.truth(obj)
# 如果obj 为真值则返回True，否则返回False。
# 这等价于使用bool 构造器。
Log.info(operator.truth(a1))
Log.info(operator.truth(a2))
Log.info(operator.truth(True))
Log.info(operator.truth(False))
Log.info(operator.truth(0))
Log.info(operator.truth(1))
Log.info(operator.truth(None))
Log.info('')
# operator.is_(a, b)
# 返回a is b。检测对象标识。
Log.info(operator.is_(a1, a2))
Log.info(operator.is_(a1, True))
Log.info(operator.is_(a1, 15))
Log.info(operator.is_(a2, 15))
Log.info('')
# operator.is_not(a, b)
# 返回a is not b。检测对象标识。
Log.info(operator.is_not(a1, a2))
Log.info(operator.is_not(a1, True))
Log.info(operator.is_not(a1, 15))
Log.info(operator.is_not(a2, 15))
def test_3():
# 数学运算：abs() add() mul() neg() pos() pow() sub()
a1 = -555
a2 = 555
a3 = -55.5
a4 = 5.55
# operator.abs(obj)
# operator.__abs__(obj)
# 返回obj 的绝对值。
Log.info(operator.abs(a3))
Log.info(operator.abs(a4))
Log.info('')
# operator.add(a, b)
# operator.__add__(a, b)
# 对于数字a 和b，返回a + b。
Log.info(operator.add(a1, a2))
Log.info(operator.add(a1, a3))
Log.info('')
# operator.mul(a, b)
# operator.__mul__(a, b)
# 对于数字a 和b，返回a * b。
Log.info(operator.mul(a1, a2))
Log.info(operator.mul(a3, a4))
Log.info('')
# operator.neg(obj)
# operator.__neg__(obj)
# 返回obj 取负的结果(-obj)。
Log.info(operator.neg(a3))
Log.info(operator.neg(a4))
Log.info('')
# operator.pos(obj)
# operator.__pos__(obj)
# 返回obj 取正的结果(+obj)。
Log.info(operator.pos(a3))
Log.info(operator.pos(a4))
Log.info('')
# operator.pow(a, b)
# operator.__pow__(a, b)
# 对于数字a 和b，返回a ** b。
Log.info(operator.pow(a1, a4))
Log.info(operator.pow(a2, a4))
Log.info('')
# operator.sub(a, b)
# operator.__sub__(a, b)
# 返回a - b。
Log.info(operator.sub(a1, a2))
Log.info(operator.sub(a3, a4))
def test_3_():
# floordiv() mod() truediv()
a1 = -555
a2 = 555
a3 = -55.5
a4 = 5.55
# operator.floordiv(a, b)
# operator.__floordiv__(a, b)
# 返回a // b。
Log.info(operator.floordiv(a1, a2)) # 地板除
Log.info(operator.floordiv(a3, a4)) # floordiv()函数也用于对两个数字 地板除法，并返回 最大小整数；
Log.info(operator.floordiv(a2, a4)) # 向下取整
Log.info(operator.floordiv(a4, a4))
Log.info('')
# operator.truediv(a, b)
# operator.__truediv__(a, b)
# 返回a / b 例如2/3 将等于.66 而不是0。这也被称为“真”除法。
Log.info(operator.truediv(a1, a2)) # 传统的除法
Log.info(operator.truediv(a3, a4))
Log.info(operator.truediv(a2, a4))
Log.info(operator.truediv(a4, a4))
Log.info('')
# operator.mod(a, b)
# operator.__mod__(a, b)
# 返回a % b。
Log.info(operator.mod(a3, a1))
Log.info(operator.mod(a2, a4))
Log.info(operator.mod(a1, a4)) # 这个是取模操作，也就是取余数
Log.info(operator.mod(abs(a1), a4))
def test_0316():
# 将运算符映射到函数
# 取绝对值 abs(obj)
# 加法 a + b add(a, b)
# 普通除法 a / b truediv(a, b)
# 除法 a // b floordiv(a, b)
# 取幂 a ** b pow(a, b)
# 取模 a % b mod(a, b)
# 乘法 a * b mul(a, b)
# 减法 a - b sub(a, b)
# 取反（算术） - a neg(a)
# 正数 + a pos(a)
# 真值测试 truth(obj)
# 取反（逻辑） not_(obj) not_(a)
# 标识 a is b is_(a, b)
# 标识 a is not b is_not(a, b)
# 比较 a < b lt(a, b)
# 比较 a <= b le(a, b)
# 相等 a == b eq(a, b)
# 不等 a != b ne(a, b)
# 比较 a >= b ge(a, b)
# 比较 a > b gt(a, b)
pass
open()
https://docs.python.org/zh-cn/3.7/library/functions.html#open
"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: [email protected]
"""
def test_open():
# open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# 打开file 并返回对应的file object。
# 如果文件不存在则引发FileNotFoundError异常，如果文件存在却不能被打开，则引发OSError异常。
# file 是一个path-like object，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。
# （如果是文件描述符，它会随着返回的I/O 对象关闭而关闭，除非 closefd 被设为False）
# --------
# mode 是一个可选字符串，用于指定打开文件的模式。
# 默认值是'r' ，这意味着它以文本模式打开并读取。It defaults to 'r' which means open for reading in text mode.
# 其他常见模式有：写入'w' （截断已经存在的文件）；排它性创建'x' ；追加写'a'；
# 默认模式为'r' (打开用于读取文本，与'rt' 同义)。模式'w+' 与'w+b' 将打开文件并清空内容。模式'r+' 与'r+b' 将打开文件并不清空内容。
# 可用的模式有：
# 'r' 读取（默认）（打开文件进行读取，如果文件不存在，则发生错误）
# 'w' 写入，并先截断文件（如果指定的文件不存在，将创建一个文件）
# 'x' 【写入】排它性创建，（将创建一个文件，如果文件存在则返回错误）
# 'a' 写入，如果文件存在则在末尾追加（如果指定的文件不存在，将创建一个文件）
# 'b' 二进制模式
# 't' 文本模式（默认）
# '+' 打开用于更新（读取与写入）
# 'r' open for reading (default)
# 'w' open for writing, truncating the file first
# 'x' create a new file and open it for writing
# 'a' open for writing, appending to the end of the file if it exists
# 'b' binary mode
# 't' text mode (default)
# '+' open a disk file for updating (reading and writing)
# --------
# encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。
# 在文本模式下（默认情况下，或者在*mode* 参数中包含`’t’‘ ）时，文件内容返回为str ，首先使用指定的encoding （如果给定）或者使用平台默认的的字节编码解码。
# 在文本模式，如果encoding 没有指定，则根据平台来决定使用的编码：使用locale.getpreferredencoding(False) 来获取本地编码。
pass
def test_open_mode1():
# 文本模式（默认）：
# file_path = '123456.txt'
file_path = '一直会被删除的不存在.txt'
# r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。如果该文件不存在，报错。
# file_obj = open(file_path) # 因为 "r" (读取)和 "t" (文本)是默认值，所以不需要指定它们。
# file_obj = open(file_path, encoding='utf-8')
# file_obj = open(file_path, mode='r', encoding='utf-8')
# 如果该文件不存在，FileNotFoundError: [Errno 2] No such file or directory: '一直会被删除的不存在.txt'
# w 打开一个文件只用于写入。如果该文件已存在则将其覆盖，即原有内容会被删除。如果该文件不存在，创建新文件。
# file_obj = open(file_path, mode='w', encoding='utf-8')
# a 打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# file_obj = open(file_path, mode='a', encoding='utf-8')
# x 排它性创建；
# The 'x' mode implies 'w' and raises an `FileExistsError` if the file already exists.
# file_obj = open(file_path, mode='x', encoding='utf-8') # FileExistsError: [Errno 17] File exists: '123456.txt'
# file_obj = open(file_path, mode='x+', encoding='utf-8')
# file_obj = open(file_path, mode='+', encoding='utf-8') # ValueError: Must have exactly one of create/read/write/append mode and at most one plus
# --------
# r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
# 直接写入会覆盖文件开头的内容。【是 从前往后 覆盖】
# file_obj = open(file_path, mode='r+', encoding='utf-8')
# w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
file_obj = open(file_path, mode='w+', encoding='utf-8')
# a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写
# file_obj = open(file_path, mode='a+', encoding='utf-8')
# --------
Log.info(f'{file_obj, type(file_obj)}')
# 如果文件是可写，则 writable() 返回 True，否则返回 False。
# 如果文件是可读的，则 readable() 返回 True，否则返回 False。
# closed,True if the stream is closed.
Log.info(file_obj.writable())
Log.info(file_obj.readable())
Log.info(file_obj.closed)
# tell() 给出文件中的当前位置，以文件的开头为原点；seek() 设置文件当前位置。
Log.info(file_obj.tell()) # TODO 需要特别留意：指针位置！！！ 尤其是 可读可写时，常常出现：读 但没数据，因为指针在最后。
# write() 将字符串写入文件，返回写入的字符数。
# write(s)
# Write the string s to the stream and return the number of characters written.
# writelines() 向文件写入一个序列（如字符串、列表），如果需要换行，则要自己加入每行的换行符。
# writelines(lines)
# Write a list of lines to the stream. Line separators are not added, so it is usual for each of the lines provided to have a line separator at the end.
# readlines() 以列表的形式返回文件里的所有数据，文件有多少行，列表里就有多少个字符串。
# 如果文件特别大，readlines() 会一次性把数据读取到内存中，这样会非常耗费内存；
# readlines(hint=-1)
# Read and return a list of lines from the stream.
Log.info(file_obj.write('写入{}()')) # 返回的是写入的字符长度
file_obj.write('\n')
file_obj.write('随机写入-{}-'.format(random.randint(1, 99999))) # 使用r时，报错 io.UnsupportedOperation: not writable
Log.info(file_obj.tell())
file_obj.writelines(['a', 'b', 'c', 'A', 'B', 'C', '\n'])
file_obj.writelines('123')
# Log.info(f'{file_obj.readlines()}') # 使用w时，使用a时，使用x时，报错 io.UnsupportedOperation: not readable
Log.info(file_obj.tell())
file_obj.seek(0, os.SEEK_SET)
for _ in range(5):
Log.info(f'{file_obj.readline(3)}') # readline() 在一行中每次读取3个字节
file_obj.seek(0, os.SEEK_SET)
for _ in range(5):
Log.info(f'{file_obj.readline(13)}') # readline() 读取的字节长度若是大于本行长度时，不会继续读取下一行的。
# close() 关闭文件。关闭后文件不能再进行读写操作
file_obj.close()
Log.info(file_obj.closed)
# --------
file_path = os.path.join(os.path.curdir, file_path)
Log.info(f'{type(file_path), file_path}')
if os.path.exists(file_path):
# 打开的文件对象一定要记得在使用结束后 调用close方法关闭文件，否则将引发内存泄漏，
# 使用with可以避免遗忘关闭文件
with open(file_path, encoding='utf-8') as f:
Log.info(f)
Log.info(type(f))
Log.info(f.readline()) # 每一行数据都包含了换行符
Log.info(f.readline().rstrip())
f.seek(0, 0)
data = f.readlines() # 每一行数据都包含了换行符
Log.info(data)
Log.info([d.rstrip() for d in data])
Log.info(f.tell())
f.seek(0)
# hint can be specified to control the number of lines read: no more lines will be read if the total size (in bytes/characters) of all lines so far exceeds hint.
Log.info(f.readlines(200)) # 其实readlines()的内部是通过循环调用readline()来实现
# Log.info(f.readlines(20))
Log.info(f.readlines(2))
if file_path.find('一直会被删除的') != -1:
os.remove(file_path)
def test_open_mode2():
# 二进制模式：
# Python 区分二进制和文本I/O。以二进制模式打开的文件（包括mode 参数中的'b' ）返回的内容为bytes`对象，不进行任何解码。
file_path = '7u908.png'
# file_path = '一直会被删除的不存在{}.png'.format(random.randint(1, 1000))
# rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
# 如果文件不存在：FileNotFoundError: [Errno 2] No such file or directory: '一直会被删除的不存在.png'
# file_obj = open(file_path, mode='rb')
# wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
# file_obj = open(file_path, mode='wb')
# ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# file_obj = open(file_path, mode='ab')
# --------
# rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
file_obj = open(file_path, mode='rb+')
# wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
# file_obj = open(file_path, mode='wb+')
# ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写
# file_obj = open(file_path, mode='ab+')
# --------
file_obj.write(bytes(12)) # 使用rb时，会报错 io.UnsupportedOperation: write
r = random.randint(1, 9999)
Log.info(file_obj.write(bytes('zfc{}'.format(r), encoding="utf-8")))
w = ['字符串{}'.format(r).encode(encoding='utf-8'), '\n'.encode(encoding='utf-8'),
'string{}'.format(r).encode(encoding='utf-8')]
random.shuffle(w)
file_obj.writelines(w)
Log.info(file_obj.tell())
# SEEK_SET = 0
# SEEK_CUR = 1
# SEEK_END = 2
file_obj.seek(0, os.SEEK_SET)
# read() 从文件中读取指定数量的字节。 如果未指定字节数，它将读取整个文件。
# read(size=-1)
# Read and return at most size characters from the stream as a single str. If size is negative or None, reads until EOF.
Log.info(file_obj.read(5))
Log.info(file_obj.read())
file_obj.seek(0) # whence: int = 0；默认whence=0，从开头起；
# readline() 一次只读取一行（一整行）；若指定size，将从该行读取最多size数量的字符。 函数到达文件末尾时，将返回一个空字符串。
# readline(size=-1)
# Read until newline or EOF and return a single str. If the stream is already at EOF, an empty string is returned.
# If size is specified, at most size characters will be read.
Log.info(f'{file_obj.readline()}') # 使用wb时，使用ab时，会报错 io.UnsupportedOperation: read
for _ in range(3):
Log.info(f'{file_obj.readline(3)}')
file_obj.close()
file_p = os.path.join(os.path.curdir, file_path)
Log.info(f'{type(file_p), file_p}')
with open(file_p, mode='rb') as f:
Log.info(f)
Log.info(type(f))
# Note that it’s already possible to iterate on file objects using for line in file: ...
# without calling file.readlines().
# open返回的文件句柄，是一个可迭代对象，因此，你可以像迭代列表一样去迭代一个文件
for line in f:
Log.info(line)
f.seek(0, os.SEEK_SET)
Log.info(list(f))
if file_p.find('一直会被删除的') != -1 and os.path.exists(file_path):
os.remove(file_p)
str.format()
https://docs.python.org/zh-cn/3.7/library/stdtypes.html#str.format
https://docs.python.org/zh-cn/3.7/library/string.html#format-string-syntax
https://docs.python.org/zh-cn/3.7/library/string.html#format-specification-mini-language
https://docs.python.org/zh-cn/3.7/tutorial/inputoutput.html#the-string-format-method
之前写了些 字符串的format()： https://blog.csdn.net/zyooooxie/article/details/106348204
"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: [email protected]
"""
# replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"
# field_name ::= arg_name ("." attribute_name | "[" element_index "]")*
# arg_name ::= [identifier | digit+]
# attribute_name ::= identifier
# element_index ::= digit+ | index_string
# index_string ::= +
# conversion ::= "r" | "s" | "a"
# format_spec ::= 见 test_str_format1() 前面
def test_str_format_0():
# field_name 本身以一个数字或关键字 arg_name 打头。如果为数字，则它指向一个位置参数，而如果为关键字，则它指向一个命名关键字参数。
# 使用 conversion 字段在格式化之前进行类型强制转换。 目前支持的转换有三种: '!s' 会对值调用 str()，'!r' 调用 repr() 而 '!a' 则调用 ascii()。
# format_spec 字段包含值应如何呈现的规格描述，例如字段宽度、对齐、填充、小数精度等细节信息。
Log.info('')
# '.name' 形式的表达式会使用 getattr() 选择命名属性，而 '[index]' 形式的表达式会使用 __getitem__() 执行索引查找。
# 位置参数说明符对于 str.format() 可以省略，因此 '{} {}'.format(a, b) 等价于 '{0} {1}'.format(a, b)。
# 一些简单的格式字符串示例:
# "First, thou shalt count to {0}" # References first positional argument 引用第一个位置参数
# "Bring me a {}" # Implicitly references the first positional argument 隐式引用第一个位置参数
# "From {} to {}" # Same as "From {0} to {1}" 同"从{0}到{1}"
# "My quest is {name}" # References keyword argument 'name' 引用关键字参数 'name'
# "Weight in tons {0.weight}" # 'weight' attribute of first positional arg 第一个位置参数的 weight属性
# "Units destroyed: {players[0]}" # First element of keyword argument 'players' 关键字参数“players”的第一个元素
abc_list = ['1one', '2TWO', '3叁', '4四', '5Ⅴ']
Log.info('{0!s}||{1!s}||{2!s}||{3!s}||{4!s}'.format(*abc_list))
Log.info('{0!r}||{1!r}||{2!r}||{3!r}||{4!r}'.format(*abc_list))
Log.info('{0!a}||{1!a}||{2!a}||{3!a}||{4!a}'.format(*abc_list))
Log.info('')
# 按位置访问参数:
Log.info('{0}-{1}'.format('A', 'B'))
Log.info('{2}-{3}-{1}-{0}'.format('A', 'bb', 'CCC', 'd'))
Log.info('{}-{}-{}'.format('a', 'b', 'CCC'))
Log.info('{0}-{0}-{1}-{1}-{1}'.format('a', 'B', 'c'))
Log.info('{1}-{0}-{4}'.format(*abc_list))
# Log.info('{1}-{55}'.format(*abc_list)) # IndexError: Replacement index 55 out of range for positional args tuple
Log.info('')
# 按名称访问参数:
Log.info('{长}-{宽}'.format(长=11, 宽=22, 高=33))
abc_dict = dict(长=111, 宽=-2222, 高=3, 重量=44, 密度=55555.55)
Log.info('{长}-{重量}-{宽}-{宽}-{宽}-{宽}'.format(**abc_dict))
Log.info('{长:.2f}||{重量:%}||{宽:+9}||{高:#o}'.format(**abc_dict))
Log.info('{1}-{4}-{0}||{密度}-{重量}'.format(*abc_list, **abc_dict))
Log.info('')
# 访问参数的属性:
from collections import namedtuple
human = namedtuple('人', '身高, 体重, 性别')
xiaoMing = human(1.8, 180, '男')
xiaoHong = human(1.6, 160, '女')
Log.info('小明的性别是{.性别}，身高是{.身高:.0%}CM。'.format(xiaoMing, xiaoMing).replace('%', ''))
Log.info('小明的身高是{0.身高}M，体重是{0.体重}；小红的性别是{1.性别}。'.format(xiaoMing, xiaoHong))
Log.info('')
# 访问参数的项:
Log.info('元素:{0[1]}-{0[4]}-{0[0]}'.format(abc_list))
Log.info('元素:{0[密度]}'.format(abc_dict))
Log.info('abc_list的元素:{1[1]}；abc_dict的其中一个value:{0[宽]}'.format(abc_dict, abc_list))
# Log.info('{0[假的]}'.format(abc_dict)) # KeyError: '假的'
# Log.info('{0[-1]}'.format(abc_list)) # TypeError: list indices must be integers or slices, not str
Log.info('再来几个:{list_[0]} {list_[3]} {list_[2]}'.format(list_=abc_list))
Log.info('再来几个:{dict_[密度]} {dict_[密度]:,} {dict_[重量]} {dict_[重量]:x}'.format(dict_=abc_dict))
Log.info('')
# 对齐文本以及指定宽度:
Log.info('{:<30}'.format('left aligned'))
Log.info('{:>30}'.format('right aligned'))
Log.info('{:^30}'.format('centered'))
# 定义的width 和 小数点前长度+小数点后补齐的位数，后面的优先级更高
Log.info('{:+^+6f}'.format(765.432))
Log.info('{:+^+16f}'.format(765.432))
Log.info('{:+^6.4f}'.format(765.432))
Log.info('{:+^8.4f}'.format(765.432))
Log.info('{:+^18.4f}'.format(765.432))
Log.info('')
# 替代 %+f, %-f 和 % f 以及指定正负号:
Log.info('{:+f}; {:+f}'.format(3.1415, -3.1415))
Log.info('{: f}; {: f}'.format(3.1415, -3.1415))
Log.info('{:-f}; {:-f}'.format(3.1415, -3.1415))
Log.info('{:f}; {:f}'.format(3.1415, -3.1415))
Log.info('')
# 替代 %x 和 %o 以及转换基于不同进位制的值:
Log.info("int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(44))
Log.info("int: {1:d}; hex: {1:#x}; oct: {1:#o}; bin: {1:#b}".format(55, 44))
Log.info('')
# 使用逗号作为千位分隔符:
Log.info('{:,}'.format(12345.1234567890123))
Log.info('{:,}'.format(1234567.1234567890123))
Log.info('{:,}'.format(123456789.1234567890123))
Log.info('{:,}'.format(12345678901.1234567890123))
Log.info('{:,}'.format(1234567890123.1234567890123))
Log.info('{:,}'.format(123456789012345.1234567890123))
Log.info('')
# 表示为百分数:
Log.info('百分数:{:.2%}'.format(7 / 21))
Log.info('')
# 使用特定类型的专属格式化:
import datetime
d = datetime.datetime(2000, 1, 22, 3, 44, 5)
Log.info('{:%Y-%m-%d %H:%M:%S}'.format(d))
Log.info('')
# 占位宽度 以变量形式 传入
s = '123456'
width = 20
Log.info('{:*^{w}}'.format(s, w=width))
Log.info('{0:*^{2}}||{1:.>{w}}||'.format(s, s[-3:], width - 10, w=width))
Log.info('{:.<{}}'.format(s, width))
# format_spec ::= [[fill]align][sign][#][0][width][grouping_option][.precision][type]
# fill ::= .format(dd))
Log.info('{:^d}'.format(dd))
Log.info('{:=d}'.format(dd))
Log.info('{:a>d}'.format(dd))
Log.info('{:b.format(dd))
Log.info('{:c^d}'.format(dd))
Log.info('{:d=d}'.format(dd))
Log.info('给width')
Log.info('{:>20d}'.format(dd))
Log.info('{:<20d}'.format(dd))
Log.info('{:^20d}'.format(dd))
Log.info('{:=20d}'.format(dd))
Log.info('{:A>20d}'.format(dd)) # 强制字段在可用空间内右对齐。
Log.info('{:B<20d}'.format(dd)) # 强制字段在可用空间内左对齐。
Log.info('{:C^20d}'.format(dd)) # 强制字段在可用空间内居中。
Log.info('{:D=20d}'.format(dd)) # 强制将填充放置在符号（如果有）之后但在数字之前。这用于以“+00000111”形式打印字段。此对齐选项仅对数字类型有效。
Log.info('{:e^10d}'.format(dd))
# 使用 str.format() 方法时是无法使用花括号字面值 ("{" or "}") 作为 fill 字符的。
Log.info('{:{}^20d}'.format(dd, '{'))
Log.info('{:{}^20d}'.format(dd, '}'))
Log.info('')
# sign 选项仅对数字类型有效
Log.info('{:+d}'.format(dd)) # '+' 表示标志应该用于正数和负数。
Log.info('{:-d}'.format(dd)) # '-' 表示标志应仅用于负数（这是默认行为）。
Log.info('{: d}'.format(dd)) # space 表示应在正数上使用前导空格，在负数上使用减号。
Log.info('')
# '#' 选项可以让“替代形式”被用于转换。 替代形式可针对不同类型分别定义。 此选项仅对整数、浮点、复数和 Decimal 类型有效。
# 对于整数类型，当使用二进制、八进制或十六进制输出时，此选项会为输出值添加相应的 '0b', '0o' 或 '0x' 前缀。
Log.info('{:#b}'.format(dd))
Log.info('{:#o}'.format(dd))
Log.info('{:#x}'.format(dd))
Log.info('')
# width 是一个定义最小总字段宽度的十进制整数，包括任何前缀、分隔符和其他格式化字符。 如果未指定，则字段宽度将由内容确定。
Log.info('{:25d}'.format(dd))
Log.info('{: 25d}'.format(dd))
Log.info('{:d}'.format(dd))
# 当未显式给出对齐方式时，在 width 字段前加一个零 ('0') 字段将为数字类型启用感知正负号的零填充。 这相当于设置 fill 字符为 '0' 且 alignment 类型为 '='。
Log.info('{:025d}'.format(dd))
Log.info('{:10d}'.format(dd))
Log.info('')
# ',' 选项表示使用逗号作为千位分隔符。
# '_' 选项表示对浮点表示类型和整数表示类型 'd' 使用下划线作为千位分隔符。 对于整数表示类型 'b', 'o', 'x' 和 'X'，将为每 4 个数位插入一个下划线。 对于其他表示类型指定此选项则将导致错误。
Log.info('{:,}'.format(dd))
Log.info('{:_}'.format(dd))
Log.info('{:_b}'.format(dd))
Log.info('{:_o}'.format(dd))
Log.info('{:_x}'.format(dd))
Log.info('{:_X}'.format(dd))
Log.info('')
# 对于整数值则不允许使用 precision。
# Log.info('{:.1d}'.format(dd)) # ValueError: Precision not allowed in integer format specifier
# Log.info('{:.1}'.format(dd)) # ValueError: Precision not allowed in integer format specifier
Log.info('')
# type 确定了数据应如何呈现。
# 可用的整数表示类型是：
# 'b' 二进制格式。 输出以 2 为基数的数字。
Log.info('{:b}'.format(dd))
Log.info('使用内置函数转换:{}'.format(bin(dd))) # 前缀为“0b”
# 'c' 字符。在打印之前将整数转换为相应的unicode字符。
for i in range(50, 70):
Log.info(str(i) + ' 对应的unicode字符: ' + '{:c}'.format(i))
# 'd' 十进制整数。 输出以 10 为基数的数字。
Log.info('{:d}'.format(dd))
# 'o' 八进制格式。 输出以 8 为基数的数字。
Log.info('{:o}'.format(dd))
Log.info('使用内置函数转换:{}'.format(oct(dd))) # 前缀为“0o”
# 'x' 十六进制格式。 输出以 16 为基数的数字，使用小写字母表示 9 以上的数码。
Log.info('{:x}'.format(dd))
Log.info('使用内置函数转换:{}'.format(hex(dd))) # 以“0x”为前缀
# 'X' 十六进制格式。 输出以 16 为基数的数字，使用大写字母表示 9 以上的数码。
Log.info('{:X}'.format(dd))
Log.info('使用内置函数转换:{}'.format(hex(dd))) # 以“0x”为前缀
# 'n' 数字。 这与 'd' 相似，不同之处在于它会使用当前区域设置来插入适当的数字分隔字符。
Log.info('{:n}'.format(dd))
Log.info('')
# 浮点数和小数值可用的表示类型有：
# 【整数还可以通过下列的浮点表示类型来格式化 (除了 'n' 和 None)。 当这样做时，会在格式化之前使用 float() 将整数转换为浮点数】
# 'e' 指数表示。 以使用字母 'e' 来标示指数的科学计数法打印数字。 默认的精度为 6。
Log.info('{:e}'.format(dd))
# 'E' 指数表示。 与 'e' 相似，不同之处在于它使用大写字母 'E' 作为分隔字符。
Log.info('{:E}'.format(dd))
# 'f' 定点表示。 将数字显示为一个定点数。 默认的精确度为 6。
Log.info('{:f}'.format(dd))
# 'F' 定点表示。 与 'f' 相似，但会将 nan 转为 NAN 并将 inf 转为 INF。
Log.info('{:F}'.format(dd))
# 'g' 常规格式。 对于给定的精度 p >= 1，这会将数值舍入到 p 位有效数字，再将结果以定点格式或科学计数法进行格式化，具体取决于其值的大小。
Log.info('{:g}'.format(dd))
# 'G' 常规格式。 类似于 'g'，不同之处在于当数值非常大时会切换为 'E'。 无穷与 NaN 也会表示为大写形式。
Log.info('{:G}'.format(dd))
# 'n' 数字。 这与 'g' 相似，不同之处在于它会使用当前区域设置来插入适当的数字分隔字符。
Log.info('{:n}'.format(dd))
# '%' 百分比。 将数字乘以 100 并显示为定点 ('f') 格式，后面带一个百分号。
Log.info('{:%}'.format(dd))
Log.info('')
Log.info('{:.0f}'.format(dd)) # 会在格式化之前使用 float() 将整数转换为浮点数
Log.info('{:.2f}'.format(dd))
Log.info('{:.9f}'.format(dd))
def test_str_format2():
# ff = 77777.55555552222111444
ff = 77777.55555552222
ff = ff * -1
Log.info('{}'.format(ff))
Log.info('')
Log.info('{:*^20f}'.format(ff))
Log.info('{:+<20f}'.format(ff))
Log.info('{:->20f}'.format(ff))
Log.info('')
Log.info('{:*>+20f}'.format(ff))
Log.info('{:*>-20f}'.format(ff))
Log.info('{:*> 20f}'.format(ff))
Log.info('')
# '#' 选项可以让“替代形式”被用于转换。
# 对于浮点数、复数和 Decimal 类型，替代形式会使得转换结果总是包含小数点符号，即使其不带小数。
Log.info('{:*>+#20f}'.format(ff))
Log.info('{:*>+#20.0f}'.format(ff))
Log.info('')
Log.info('{:*>+#20,f}'.format(ff))
Log.info('{:*>+#20_f}'.format(ff))
Log.info('')
# precision 是一个十进制数字，表示对于以 'f' and 'F' 格式化的浮点数值要在小数点后显示多少个数位，或者对于以 'g' 或 'G' 格式化的浮点数值要在小数点前后共显示多少个数位。
Log.info('{:*>+#20,.0f}'.format(ff))
Log.info('{:*>+#20,.3f}'.format(ff))
Log.info('{:*>+#20_.5f}'.format(ff))
Log.info('')
Log.info('{:*>+#20,.3e}'.format(ff))
Log.info('{:*>+#20,.3E}'.format(ff))
Log.info('{:*>+#20,.4f}'.format(ff))
Log.info('{:*>+#20,.4F}'.format(ff))
Log.info('{:*>+#20,.2%}'.format(ff))
Log.info('')
Log.info('{:}'.format(ff))
Log.info('{:f}'.format(ff))
Log.info('{:,}'.format(ff))
Log.info('{:%}'.format(ff))
Log.info('{:+}'.format(ff))
Log.info('{:-}'.format(ff))
Log.info('{: }'.format(ff))
def test_str_format3():
ss = 'zyooooxie'
# 's' 字符串格式。这是字符串的默认类型，可以省略。
Log.info('{:s}'.format(ss))
Log.info('{:->20}'.format(ss))
Log.info('{:-^20}'.format(ss))
# precision 对于非数字类型，该字段表示最大字段大小，换句话说就是要使用多少个来自字段内容的字符。
Log.info('{:*<20.5}'.format(ss))
Log.info('{:*<20.15}'.format(ss))
ll = ['zyooooxie', '博客', 'https://blog.csdn.net/zyooooxie', 123456789]
Log.info('{!r}'.format(ll))
Log.info('{!s}'.format(ll))
Log.info('{!a}'.format(ll))
Log.info('{!s:100}'.format(ll))
Log.info('{!s:^100}'.format(ll))
Log.info('{!s:>100}'.format(ll))
Log.info('{!s:>100.10}'.format(ll))
本文链接：https://blog.csdn.net/zyooooxie/article/details/129037817
个人博客 https://blog.csdn.net/zyooooxie