|
测试代码执行环境为Ubuntu18 + python3.7
max
max(iterable, *[, key, default]) max(arg1, arg2, *args[, key])，分多种使用方式，可以传入多个参数，返回这些参数的最大值，可以传入可迭代对象，返回该对象的最大值；指定key，按照key进行排序，获取最大值。如果可迭代对象为空则返回default的值，如果没有指定default则报valueerror错误。如果最大值有多个，则返回访问到的第一个，这与其他稳定排序实现一致。
测试代码：
def test_max():
print("max of 4, 2, 6, 7, 8: ", max(4, 2, 6, 7, 8))
print("max of string 'biggerwillam': ", max("biggerwillam"))
print("max of empty: ", max((), default='e'))
p1 = Person("Allen", 19, 70)
p2 = Person("Cral", 25, 67)
p3 = Person("Ellen", 23, 80)
p3 = Person("Hell", 25, 55)
print("max person: ", max(p1, p2, p3).name)
print("max person: ", max(p1, p2, p3, key=lambda k: k.name).name)
print("max person: ", max(p1, p2, p3, key=lambda k: k.age).name)
d1 = Dog("pappy", 40)
print("max person: ", max(p1, p2, p3, d1, key=lambda k: k.weight).name)
test_max()
测试结果：
max of 4, 2, 6, 7, 8: 8
max of string 'biggerwillam': w
max of empty: e
max person: Cral
max person: Hell
max person: Cral
max person: Allen
memoryview
class memoryview(obj)，根据传入的obj参数返回一个"memory view"对象。memoryview 对象允许 Python 代码访问支持缓冲区协议的对象的内部数据，而无需复制。
测试代码：
def test_memoryview():
v = memoryview(b'abcefg')
print("v[1]: ", v[1])
print("v[-1]: ", v[-1])
print("v[1:4]: ", v[1:4], "; bytes(v[1:4]): ", bytes(v[1:4]))
import array
a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
m = memoryview(a)
print("m[0]: ", m[0])
print("m[-1]: ", m[-1])
print("m[::2].tolist(): ", m[::2].tolist())
data = bytearray(b'abcefg')
v = memoryview(data)
print("v.readonly:", v.readonly)
v[0] = ord(b'z')
print("data: ", data)
v[1:4] = b'123'
print("data: ", data)
v[2:6] = b'spam'
print("data: ", data)
test_memoryview()
测试结果：
v[1]: 98
v[-1]: 103
v[1:4]: <memory at 0x7fd2c2177e20> ; bytes(v[1:4]): b'bce'
m[0]: -11111111
m[-1]: 44444444
m[::2].tolist(): [-11111111, -33333333]
v.readonly: False
data: bytearray(b'zbcefg')
data: bytearray(b'z123fg')
data: bytearray(b'z1spam')
min
min(iterable, *[, key, default]) min(arg1, arg2, *args[, key])，min函数与max对应，max返回最大值，min返回最小值，这里不再介绍了。
next
next(iterator[, default]) 通过调用iterator的__next__() 方法从迭代器中获取下一项。 访问到结束时如果给出默认值，则返回默认值，否则抛出StopIteration。next() 函数要和生成迭代器的 iter() 函数一起使用。
测试代码：
def test_next():
l1 = [1, 2, 3, 4 ,5, 6, 7]
it = iter(l1)
while True:
try:
x = next(it)
print(x)
except StopIteration:
break
it = iter(l1)
while True:
x = next(it, 100)
print(x)
if x == 100:
break
test_next()
测试结果：
1
2
3
4
5
6
7
1
2
3
4
5
6
7
100
object
class object，返回一个新object对象，该对象是没有任何属性的。 object 是所有类的基础。 它具有所有 Python 类实例通用的方法。 此函数不接受任何参数。
注意: object 没有__dict__，因此您不能给object对象赋任意属性。
测试代码：
def test_object():
obj = object()
print("obj type: ", type(obj), "; class of obj: ", obj.__class__)
test_objcect()
测试结果：
obj type: <class 'object'> ; class of obj: <class 'object'>
otc
oct(x), 将整数转换为前缀为“0o”的八进制字符串。 结果是一个有效的 Python 表达式。 如果 x 不是 Python int 对象，它必须定义一个返回整数的 index() 方法。转换的八进制字符串可以带有前缀"0o"也可以不带前缀，方法在下面代码中介绍。
需要注意的是:Python2.x 版本的 8 进制以 0 作为前缀表示。Python3.x 版本的 8 进制以 0o 作为前缀表示。
测试代码:
def test_oct():
print("oct(8): ", oct(8))
print("oct(-56): ", oct(-56))
print("'%#o' % 10, '%o' % 10")
print(format(10, '#o'), format(10, 'o'))
print(f"'{10:#o}', f'{10:o}'")
test_oct()
测试结果:
oct(8): 0o10
oct(-56): -0o70
'%#o' % 10, '%o' % 10
0o12 12
'0o12', f'12'
open
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)，打开文件并返回对应的file对象，如果打开失败则抛出OSError的异常。file是一个指定打开文件的字符串可以是相对路径或者绝对路径，或者是一个文件描述符，如果给定的是文件描述符，则返回的对象关闭时该文件描述负也会关闭，如果closefd设置为False则不会关闭。
mode是可选参数，默认值为’r’。在文本模式下，如果未指定编码，则使用的编码取决于平台：调用 locale.getpreferredencoding(False) 以获取当前的语言环境编码。 （对于读取和写入原始字节，请使用二进制模式，并且不指定编码。）
mode取值如下, 下面的各种模式可以进行组合使用：
| Character | Meaning |
|---|
| ‘r’ | 只读, 默认值 | | ‘w’ | 写文件,如果文件存在则覆盖原始内容, 如果不存在则创建文件 | | ‘x’ | 以独占方式创建文件,如果文件已存在则报错 | | ‘a’ | 以追加方式打开文件, 在文件最好最佳内容 | | ‘b’ | 以二进制方式打开文件 | | ‘t’ | 以文本方式打开文件 | | ‘+’ | 打开的文件可读可写 |
测试代码:
def test_open():
f = open("./test.txt", mode='w')
f.write("this is test string\n")
f.write("this is test string2\n")
f.close()
with open("./test.txt") as f:
content = f.readline(100)
print("file content: ", content)
test_open()
测试结果:
file content: this is test string
pow
pow(x, y[, z])，返回x的y次幂xy的值；如果传入z的话则对z取模(运算效率比pow(x, y) % z高)。只传两个参数与x**y是等价的。
参数必须是数字。 如果第二个参数是负的，则必须省略第三个参数。 如果 z 存在，则 x 和 y 必须是整数类型，并且 y 必须是非负数。
测试代码：
def test_pow():
print("pow(3, 6): ", pow(3, 6))
print("pow(3, 6, 77): ", pow(3, 6, 77))
print("pow(10, 0.1): ", pow(10, 0.1))
print("pow(100, -2): ", pow(100, -2))
test_pow()
测试结果：
pow(3, 6): 729
pow(3, 6, 77): 36
pow(10, 0.1): 1.2589254117941673
pow(100, -2): 0.0001
print
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)，将对象打印到文本文件，以sep作为多个对象的分隔符，最后以end结尾。 sep、end、file 和 flush(如果有)必须作为关键字参数给出。
所有非关键字参数都像 str() 一样转换为字符串并写入流，由 sep 分隔，后跟 end。 sep 和 end 都必须是字符串； 它们也可以是 None，这意味着使用默认值。 如果没有给出任何要写入对象， print() 将输出end。
文件参数必须是一个带有 write(string) 方法的对象； 如果没有指定file则使用sys.stdout输出到标准输出。 由于打印的参数被转换为文本字符串，print() 不能与二进制模式文件对象一起使用。 对于这些，请改用 file.write(…) 。
输出是否缓冲通常由文件决定，但如果flush关键字参数为真，则流被强制刷新。在 3.3 版更改: 添加了 flush 关键字参数。
测试代码:
def test_print():
test_str = "this is a test string"
print("this""is")
print("this", "is")
print("this""is", "test", "string", sep=";", end="99999")
f = open("test.txt", mode='w')
print("this""is", "test", "string", sep=";", end="99999\n", file=f)
for i in range(10):
print(".", end=" ", flush=True)
time.sleep(0.5)
print("\n")
for i in range(10):
print(".", end=" ")
time.sleep(0.5)
test_print()
测试结果:
thisis
this is
thisis;test;string99999. . . . . . . . . .
. . . . . . . . . .
property
class property(fget=None, fset=None, fdel=None, doc=None)，返回一个属性。fget 是一个获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是删除属性值的函数。 并且 doc 为该属性创建一个文档字符串。
一个典型的用途是定义一个托管属性 x：
class C:
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。
doc是该属性的文档说明字符串。 否则，该属性将复制fget的文档字符串(如果存在)。 这使得使用 property() 作为装饰器可以轻松实现只读属性：
class Parrot:
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
property 的 getter,setter 和 deleter 方法同样可以用作装饰器：
class C:
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
此代码与第一个示例功能完全相同。 确保相关函数的名称与与原始属性相同(在本例中为x)。
在 3.5 版更改: 属性对象的文档字符串现在是可写的。
|