python基础（三）------常用的内置函数

python基础（二）------if、while、for、range()、enumerate()、异常处理、列表生成式及其他语句的常用方法

记录abs()、bin()、divmod()、eval()、int()、float()、oct()、hex() 、pow() 、round()、all()、any()、bool()、isinstance()、issubclass()、ascii()、bytes()、chr()、ord()、len()、range()、reversed()、sorted()、type ()、max()、min()、iter()、next()、help()、zip() 、filter()函数的使用。

1、与数字相关的常用内置函数

# 返回一个数的绝对值，参数可以是整数、浮点数，如果参数是一个复数，则返回它的模。
>>> abs(-2)
2

# 将整数转变为以“0b”前缀的二进制字符串
>>> bin(12)
'0b1100'
>>> bin(-12)
'-0b1100'

# 相除，返回商和余数
>>> divmod(13,5)
(2, 3)
>>> divmod(13.5,5)
(2.0, 3.5)

# 对参数进行运算，输出运算结果
>>> eval('2 + 9')
11
>>> a = 3
>>> eval('a + 2')
5

# int(x)、int(x, base=10)返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0，对于浮点数，它将向零舍入。
>>> int('123')
123
>>> int(12.5)
12
>>> int('101',2)
5
>>> int('101',8)
65
>>> int('101',10)
101
>>> int('101',16)
257

# float([x])返回从数字或字符串 x 生成的浮点数。如果参数是个字符串，则应包含一个十进制数字，前面可选带上符号，也可选前后带有空白符。符号可以是'+' 或 '-'；'+' 符号对值没有影响。参数也可以是一个代表 NaN（非数字）或正负无穷大的字符串,另一方面，如果实参是整数或浮点数，则返回具有相同值的浮点数。如果实参在 Python 浮点精度范围外，则会触发 OverflowError。
>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

# oct(x)将一个整数转变为一个前缀为“0o”的八进制字符串
>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'
# 若要将整数转换为八进制字符串，并可选择是否带有“0o”前缀，可采用如下方法：
>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

# hex(x)将整数转换为以“0x”为前缀的小写十六进制字符串
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
#如果要将整数转换为大写或小写的十六进制字符串，并可选择有无“0x”前缀，则可以使用如下方法：
>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')
# 如果要获取浮点数的十六进制字符串形式，请使用 float.hex() 方法。
>>> float.hex(12.5)
'0x1.9000000000000p+3'
>>> float.hex(-12.5)
'-0x1.9000000000000p+3'

# pow(base, exp[, mod])返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余
>>> pow(3,2)  # 3的2次幂：3*3
9
>>> pow(2,-2)  # 2的-2次幂：1/(2*2)
0.25
>>> pow(3,2,2) # 3的2次幂，然后对2求余：(3*3)%2
1

# round(number[, ndigits])返回 number 舍入到小数点后 ndigits 位精度的值
>>> round(4.5)
4
>>> round(4.6)
5
>>> round(4.6789456,3)
4.679
>>> round(-4.5)
-4
>>> round(-4.6)
-5
>>> round(-4.6789456,3)
-4.679

2、与判断相关的常用内置函数

# 所有元素均为真值返回True，否则返回False
>>> all([1,9,0])
False
>>> all([1,2,"a"])
True

# 任一元素为真值返回True，否则返回False
>>> any([1,9,0])
True
>>> any(["",0])
False

# 返回给定参数转化后的bool值
>>> bool("")
False
>>> bool("a")
True
>>> bool(4)
True

# isinstance(object, class) 如果 object 参数是 class 参数的实例，或其（直接、间接或 virtual ）子类的实例，则返回 True。 如果 object 不是给定类型的对象，则总是返回 False。如果 class 是类型对象的元组（或由该类元组递归生成）或多个类型的 union 类型，那么当 object 是其中任一类型的实例时就会返回 True。如果 class 不是某个类型或类型元组，将会触发 TypeError 异常。
>>> class Person:
...     def __init__(self,name):
...             self.name = name
...
>>> class Student(Person):
...     def __init__(self,name,age):
...             super().__init__(name)
...             self.age = age
...
>>> p = Person("ls")
>>> isinstance(p,Person)
True
>>> isinstance(p,Student)
False

# issubclass(class, classinfo)如果 class 是 classinfo 的子类（直接、间接或 虚的 ），则返回 True。类将视为自己的子类。classinfo 可为类对象的元组（或递归地，其他这样的元组）或 union 类型，这时如果 class 是 classinfo 中任何条目的子类，则返回 True 。任何其他情况都会触发 TypeError 异常。
>>> class Person:
...     def __init__(self,name):
...             self.name = name
...
>>> class Student(Person):
...     def __init__(self,name,age):
...             super().__init__(name)
...             self.age = age
...
>>> issubclass(Person,Student)
False
>>> issubclass(Student,Person)
True

3、其他常用的内置函数

# 返回参数以ASCII编码的字符串
>>> ascii("中国")
"'\\u4e2d\\u56fd'"

# 返回给定参数的二进制格式的字符串
>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes("中国",encoding = "utf-8")
b'\xe4\xb8\xad\xe5\x9b\xbd'

# 返回Unicode码位为参数中整数的字符的字符串格式
>>> chr(98)
'b'
# 与chr互为逆函数
>>> ord('a')
97

# 返回一个枚举对象，可以指定枚举开始的位置
>>> a = ["zs","ls","ww"]
>>> for i in enumerate(a):
...     print(i)
...
(0, 'zs')
(1, 'ls')
(2, 'ww')
>>> for i in enumerate(a,start = 2):
...     print(i)
...
(2, 'zs')
(3, 'ls')
(4, 'ww')

# len(s)返回对象的长度或者元素个数，实参可以是string、bytes、tuple、list、range、 dictionary、set等
>>> len('asdf')
4
>>> len([1,2,3,4])
4
>>> len(("a","b"))
2

# range(结束位置)、range(开始位置, 结束位置[, 步长])：包括开始位置，不包括结束位置
>>> for i in range(3):  
...     print(i)
...
0
1
2
>>> for i in range(2,5):
...     print(i)
...
2
3
4
>>> for i in range(3,10,2):
...     print(i)
...
3
5
7
9

# reversed(seq)返回一个反向的 iterator
>>> for i in reversed([1,2,3]):
...     print(i)
...
3
2
1
>>> for i in reversed(("a","b","c")):
...     print(i)
...
c
b
a

# sorted(iterable, key=None, reverse=False)根据 iterable 中的项返回一个新的已排序列表，key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)，默认值为 None (直接比较元素)。reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。
>>> sorted([3,1,2])
[1, 2, 3]
>>> sorted(("c","a","b"))
['a', 'b', 'c']
>>> sorted(("c","a","b"),reverse = True)
['c', 'b', 'a']
>>> sorted(("c","a","b"),reverse = False)
['a', 'b', 'c']

# type(object)返回 object 的类型
>>> type(10)
<class 'int'>
>>> type(10.5)
<class 'float'>
>>> type([1,2])
<class 'list'>

# max()返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。
>>> max([1,2,3])
3
>>> max(("a","b","c"))
'c'
>>> max([1,2,3],[4,5,6])
[4, 5, 6]

# min()返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。
>>> max([1,2,3],[4,5,6])
[4, 5, 6]
>>> min([1,2,3])
1
>>> min(("a","b","c"))
'a'
>>> min([1,2,3],[4,5,6])
[1, 2, 3]

# iter(x)把不可迭代的x变成可迭代的对象
>>> a = [1,2,3,4]
>>> b = iter(a)
>>> type(a)
<class 'list'>
>>> type(b)
<class 'list_iterator'>

# next(iterator[, default])获取下一个元素,如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration
>>> a = [1,2,3,4]
>>> b = iter(a)
>>> next(b)
1
>>> next(b)
2
>>> next(b)
3
>>> next(b)
4
>>> next(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> next(b,0)
0

# help([object])启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。
>>> help(list)
显示list的帮助信息

# zip(*iterables, strict=False)在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。
>>> for item in zip([1, 2, 3], ['sr', 'se', 'ice']):
...     print(item)
...
(1, 'sr')
(2, 'se')
(3, 'ice')
#默认情况下，zip() 在最短的迭代完成后停止,较长可迭代对象中的剩余项将被忽略，结果会裁切至最短可迭代对象的长度
>>> list(zip(range(3), ['f', 'i', 'o', 'u']))
[(0, 'f'), (1, 'i'), (2, 'o')]
# 通常 zip() 用于可迭代对象等长的情况下,这时用 strict=True 选项，输出与普通的 zip() 相同，如果长度不相同则触发 ValueError
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
>>>list(zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True))
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1

# filter(function, iterable)：用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for item in iterable if item)
>>> def func(i):
...     if(i>5):
...             return i
>>> for i in filter(func,[1,2,3,4,5,6,7]):
...     print(i)
...
6
7

python基础（四）------文件操作、自定义函数和匿名函数、类和对象