Python3内置函数

目录

目录结构

abs

abs(x) 返回数字的绝对值。 x 可以是整数，浮点数，复数；如果是复数，则返回它的大小。

1
2
3
4

a=abs(-50)
print(a)
b=abs(3 + 4j )
print(b)

dict

1. class dict(**kwarg) 等号模式
2. class dict(mapping, **kwarg) zip模式
3. class dict(iterable, **kwarg) 二元组列表

主要是zip模式和二元元组模式

1
2
3
4
5
6
7
8
9

x = dict()  # 创建空字典{}
y = dict(a='a', b='b', t='t')  # 传入关键字，等于号模式
z = dict(zip(['one', 'two', 'three'], [1, 2, 3]))  # 映射函数方式，zip模式
u = dict([('one', 1), ('two', 2), ('three', 3)])  # 可迭代对象方式，二元元组代替等号模式，二元列表元素会警告
print(x, y, z, u)

# 也可直接用{}、:创建字典
v = {123: '123', 456: '456'}
print(v, type(v))

help

help([object]) object – 对象；

返回对象帮助信息。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

help(list)

# 输出：
# 
# Help on class list in module builtins:
# class list(object)
#  |  list(iterable=(), /)
#  |  
#  |  Built-in mutable sequence.
#  |  
#  |  If no argument is given, the constructor creates a new empty list.
#  |  The argument must be an iterable if specified.
#  |  
#  |  Methods defined here:
#  |  
# ......

min_max

返回可迭代参数中的最小、最大元素。

1
2

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(80, 100, 1000) : ", max(80, 100, 1000))

setattr、getattr

(attr——attribute)

setattr用于设置对象的属性值，getattr用于获取对象的属性值。相比于 “.” 功能更丰富。

• 当实例a有属性bar时，当使用setattr(a, ‘bar’, 5)时，会将实例a属性bar设置为5;
• 当实例a无属性bar时，会为实例a创建一个实例属性bar，赋值为5，而类属性不变。
• getattr当属性不存在时避免抛出AttributeError，若设置默认值，则不会报错。例如，getattr(a, ‘baz’, ‘default’)会返回’default’，而a.baz则会引发异常。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class A(object):
    bar = 1

a = A()
print(getattr(a, 'bar'))          # 获取属性 bar 值
setattr(a, 'bar', 5)
setattr(a, 'weight', 5)       # 设置属性 weight 值，不存在会为该对象创建，但类不变
print(a.bar, a.weight)

b=A()
try:
    print(getattr(b, 'weight'))
except AttributeError as e:
    print(f"属性访问错误: {e}")		# 为对象创建，但类不变，b无weight属性
    
print(getattr(b, 'weight'，-1))		# 设置默认值，返回-1不报错

all 、any

• all：是否都为True any：是否存在True

• all(iterable, /)

  1. 判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
  2. 元素除了是 0、空、None、False 外都算 True。
  3. 空元组、空列表返回值为True，这里要特别注意。
  4. 不会进入内层。

1
2
3

print(all(['a', 'b', 'c', 'd']))  # 元素都不为空或0，True
print(all(['a', 'b', '', 'd']))   # 存在一个为空的元素，False
print(all([[''],['']]))			 # 不会进入内层，首层元素['']不为0、空、None、False 

• any(iterable, /)
  • “是否存在 True”的意思，True代表的是 非空类数据。

dir

• dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表
• 带参数时——dir([object])，返回参数的属性、方法列表。
• 如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class MyClass:
    def __init__(self):
        self.public_attr = 10
        self.__private_attr=20
        
    def normal_method(self):
        pass
     
obj = MyClass()		# 实例化对象
print(dir(obj))

输出包含 ‘_MyClass__private_attr’, ’normal_method’, ‘public_attr’

[ ‘_MyClass__private_attr’, ‘__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, …… ‘normal_method’, ‘public_attr’ ]

• 实际应用场景

  1. 快速查看对象内容
  2. 动态检查对象功能
  3. 限制暴露的接口（设置接口）

1
2

# 快速查看对象内容
print(dir())  # 查看字典的方法，如 keys, values, items

1
2
3
4

# 动态检查对象功能
obj = SomeClass()
if "__iter__" in dir(my_object):
       print("对象是可迭代的")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 限制暴露的接口（设置接口）
class SecureAPI:
   def __init__(self):
       self._internal_data = 100

   def __dir__(self):
       return ["public_method"]  # 隐藏内部实现

   def public_method(self):
       return "Safe data"

拓展：属性名以双下划线 __ 开头且不以双下划线结尾 —— 名称修饰，避免子类与父类的私有属性命名冲突，Python会自动将其转换为：_类名__属性名 (如刚才的_MyClass__private_attr)

1
2
3
4
5
6
7
8

class A:
   def __init__(self):
       self.__x = 1  # _A__x

class B(A):
   def __init__(self):
       super().__init__()
       self.__x = 2  # _B__x

hex 、oct

• hex(x)：将10进制int转为16进制且为字符串，0x为前缀。

  1 2 3 4 5

  a=16 print(type(a)) # <class 'int'> b=hex(a) print(b) # 0x10 print(type(b)) # <class 'str'>

• hex(x)：将10进制int转为8进制且为字符串，0o为前缀。

  1 2 3 4

  a=16 b=hex(a) print(b) # 0o20 print(type(b)) # <class 'str'>

next

• next()返回迭代器的的下一个项目；要和生成迭代器函数 iter() 配合使用。

1

next(iterable[, default])

• 一个参数是iter()生成的迭代器实例，另一个是默认值，如果指针超出范围就输出默认。

• 常见应用

1
2

with open(file_path, 'r', encoding='utf-8') as f:  # 强制使用UTF-8编码读取
    lines = [next(f) for _ in range(5)]  # 读取前5行到列表

• 我理解的next()是python 内置的__next__方法，因为iter类有__next__方法，而其他的如生成器也有，自定义一个类并定义__next__方法，该类弄出的实例也可以用next()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 自定义迭代器
class MyClass:

  # 迭代相关
  __iter__(self)      # 迭代：for i in obj
  __next__(self)      # 下一个：next(obj)

# 生成器（本身就是迭代器）
# <class 'generator'> 不是 <class 'list'>，用括号的
gen = (x for x in range(3))		
print(next(gen))  # 0
print(next(gen))  # 1

# 文件对象（本身就是迭代器）
with open('data.txt') as f:
  print(next(f))  # 直接读取第一行
  print(next(f))  # 读取第二行

• 拓展 这样有双下划线的方法和无双下划线的有什么区别？如__getitem__(self)。 —— Python 的特殊方法（魔术方法）是由 Python 语言规范定义的。这些方法与 Python 的内置操作直接关联：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class MyClass:
  # 基本操作
  __init__(self)      # 实例化：obj = MyClass()
  __str__(self)       # 字符串转换：str(obj)
  __len__(self)       # 长度：len(obj)

  # 迭代相关
  __iter__(self)      # 迭代：for i in obj
  __next__(self)      # 下一个：next(obj)

  # 运算符
  __add__(self)       # 加法：obj + other
  __sub__(self)       # 减法：obj - other

  # 容器操作
  __getitem__(self)   # 索引访问：obj[key]
  __setitem__(self)   # 索引赋值：obj[key] = value

# 使用这些特殊方法
lst = MyList()
len(lst)               # 调用 __len__
3 in lst              # 调用 __contains__  判断是否contain
for x in lst: ...     # 调用 __iter__


# 查看所有特殊方法
# 方法1：查看内置文档
help(object)

# 方法2：dir() 函数
print([m for m in dir(object) if m.startswith('__')])

slice

• slice()返回一个切片对象。

• slice(stop)
  slice(start, stop[, step])，(起点，终点，步长)

  直接使用	创建slice
  [:5]	slice(None, 5) / slice(None, 5)
  [3::2]	slice(3, None, 2)
  [::-1]	slice(None, None, -1)

• 类似于a​:b:c

1
2
3
4
5

a=list(range(10))
print(lst[2:7:2])
print(slice(2, 7, 2))
assert lst[2:7:2] == lst[slice(2, 7, 2)]
  

但是要保存为对象的话:

1
2

x=2:7:2		#   ❌ 非法写法
x=slice(2, 7, 2)	#   ✅ 正确写法	

• 对于 lst[slice(95, 105, 2)]，为什么不用 lst[95:105:2] ? —— 定义slice的优势

  1. 动态参数配置

     1 2 3 4 5 6 7

     def dynamic_slicer(config): """根据外部配置生成切片""" return data[slice(*config)] # 从配置文件读取参数 config = json.loads('{"start": 95, "stop": 105, "step": 2}') print(dynamic_slicer(config.values())) # 动态应用切片参数

  2. 切片对象复用

     1 2 3 4 5 6

     # 定义标准切片规则 DOWNSAMPLE_SLICE = slice(None, None, 4) # 每4个元素取1个 # 复用切片 video_frames = raw_frames[DOWNSAMPLE_SLICE] audio_samples = raw_audio[DOWNSAMPLE_SLICE]

  3. 多维切片基础

     1 2 3 4 5 6 7 8 9 10 11 12 13

     import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(arr[0:2, 1:3]) # 输出 [[2 3], [5 6]] # 定义行和列的切片对象 row_slice = slice(0, 2) # 第0行到第1行（不含2） col_slice = slice(1, 3) # 第1列到第2列（不含3） print(arr[row_slice, col_slice]) # 输出 [[2 3], [5 6]]

divmod

• divmod() 函数接受两个参数 x y（通常是两个数字），返回二元组，第一个值是 x 除以 y 的商（即整数部分），第二个值是余数。

• 对于3.x，参数不能是复数， x 可以为整数/浮点数，y 也如此

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

a=13
b=3
x,y=divmod(a,b)
print(x,y) 	# 4 1

a=13.6
b=3
x,y=divmod(a,b)
print(x,y)	# 4.0 1.5999999999999996
print(x,round(y,1))	# 4.0 1.6

a=13.6
b=3.1
x,y=divmod(a,b)
print(x,y)	# 4.0 1.1999999999999993

• 应用场景

  1. 进制转换

     1 2 3 4 5 6 7 8

     def int_to_base(n, base): digits = [] while n > 0: n, rem = divmod(n, base) # 除留余数法 digits.append(rem) # 余数先存进去，是低位 return digits[::-1] # 逆序 print(int_to_base(42, 16)) # [2, 10] 表示 0x2A

  2. 时间单位转换

     1 2 3 4

     total_seconds = 7541 hours, rem = divmod(total_seconds, 3600) minutes, seconds = divmod(rem, 60) print(f"{hours}:{minutes}:{seconds}") # 2:5:41

  3. 循环缓冲区处理，类似哈希表的“线性法直接mod”

     1 2 3 4 5 6

     buffer_size = 1024 write_pos = 1500 # 计算实际写入位置 chunk, offset = divmod(write_pos, buffer_size) print(f"写入第 {chunk} 个缓冲区的 {offset} 位置")

id

• id()函数返回对象的唯一标识符，标识符是一个整数。

  CPython 中 id() 函数获取的是对象的内存地址。（python3.9——CPython3.9）

  1 2 3 4 5

  a=13 b=3 print(id(a)) # 3054276471472 print(id(b)) # 3054276471152 print(type(id(a))) # <class 'int'>

• 拓展：不同的python

• 需要最佳兼容性 → CPython （主，兼容性最好，标准）

  与 Java 生态整合 → Jython

  需要 .NET 互操作 → IronPython

  追求高性能 → PyPy

  嵌入式开发 → MicroPython

object

• object()：不接收任何参数，返回一个空对象

1
2
3
4
5
6

x = object()
print(dir(x))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
# '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', 
# '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', 
# '__str__', '__subclasshook__']

• object() 的核心价值：

  1. 所有类的基类：提供默认行为

  2. 轻量级对象：用于简单场景

  3. 方法继承：提供默认的 __str__、__eq__ 等方法

sorted

• sorted() 对 所有可迭代的对象 进行排序操作。

• sort 与 sorted 区别：

  sort 是 list 的方法，sorted 可对所有可迭代的对象应用。

  list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

• sorted(iterable, key=None, reverse=False)，三个参数，依次是 可迭代变量、选择内层元素的函数方法、升序or降序。

• 1 2 3 4

  ls=[(3,2),(1,4),(5,3),(2,6)] new_ls=sorted(ls,key=lambda x:x[0],reverse=True) # 对象为列表 ls，方法是 通过首层元素的第0个元素排序，True->降序 print(ls) # [(3, 2), (1, 4), (5, 3), (2, 6)] print(new_ls) # [(5, 3), (3, 2), (2, 6), (1, 4)] 得到 5 3 2 1 降序

• sorted<->sort reversed<->reverse

ascii

• ascii(object) ，返回object的字符串，对于字符串中的非 ASCII 字符则通过 repr() 函数使用 \x, \u 或 \U 编码。

• 1 2 3 4

  a=[[1,2,3],[3,4,5]] b=ascii(a) print(type(b)) # <class 'str'> print(b.split(',')) # ['[[1', ' 2', ' 3]', ' [3', ' 4', ' 5]]']

enumerate

• enumerate(seq, [start=0])

• 将seq的元素挨个取出和0,1,2,3….组成二元组，各个二元组组成enumerate类型，enumerate不可索引。

  1 2 3 4 5 6 7 8

  seasons=[[1,2,3],[4,5,6]] print(type(enumerate(seasons))) # <class 'enumerate'> for i, element in enumerate(seasons): print(i, element) # 0 [1, 2, 3] 1 [4, 5, 6] for j in enumerate(seasons): print(type(j)) # <class 'tuple'> print(j[0],j[1]) # 0 [1, 2, 3] break

• （主）同时获取索引 i，和元素本身element：

  1 2	for i, element in enumerate(seasons): print(i, element)

input

• input([prompt]) ：在命令行提示prompt，然后接收命令行输入的信息为字符串。

  1 2	a = input("input:") type(a) # <class 'str'>

• 和strip、map结合

  1 2 3 4 5 6 7

  # strip() 去掉文末空格 a=input('输入：').strip() # 输入“123 ” 去掉文末空字符 print(len(a)) # 3 a=input('输入：') # 输入“123 ” 不去掉文末空字符 print(len(a)) # 4 b=list(map(int, input('输入：').split())) # 输入“1 2 3” 输出[1,2,3]
  • 标准空白字符

    字符名称	转义序列
    空格	\x20
    水平制表符（Tab）	\t
    换行符（LF）	\n
    回车符（CR）（Mac 换行)	\r
    垂直制表符	\v
    换页符	\f

staticmethod

• @staticmethod 用于定义静态方法的装饰器，返回函数的静态方法。

  1 2 3 4

  class C(object): @staticmethod def add(a, b): return a + b

  特点：

  1. 代码中的add函数不能有“self”（实例引用）和“cls”类引用
  2. 是类命名空间中的函数，不需要实例便可调用
  3. 不能直接访问实例属性或类属性，因为无self/cls

• 静态方法与普通方法对比

  特征	普通方法	静态方法
  第一个参数	self（实例引用）	非self非类
  调用方式	实例调用	类/实例均可调用
  访问权限	可访问实例属性	仅能访问传入参数

  1 2 3 4 5 6 7

  class MyClass: def normal_method(self): print(f"实例方法：{self}") # 依赖实例 @staticmethod def static_method(): print("静态方法") # 无依赖

bin

• bin() 输入：一个整数 int 或者长整数 long int。返回：二进制的字符串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

a=3

print(bin(a))	# 0b11

print(type(bin(a)))	# <class 'str'>

for i in bin(a):
    print(i)	# 0\nb\n1\n1\n

help(bin)
# bin(number, /)
# Return the binary representation of an integer.
# 
# >>> bin(2796202)
# '0b1010101010101010101010'

open

• open(name[, mode[, buffering]])

  常与with联用

  1 2 3 4 5

  # 例子 with open('_20_data.txt', 'r') as file: # 读取数据 N\n1 2 3 n = int(file.readline().strip()) data = list(map(int, file.read().split()))

• w从头写 r只读 a追加

  读写方式	是否为 二进制	是否为 可读可写
  r	空	空
  w	b	+
  a

  共 3*2*2=12种

• 模式对照表 和 f.seek(n)

  模式	描述	文件存在	文件不存在	指针位置
  r+	读写（文件必须存在）	不清空，从指针位置“覆盖写”	报错	开头
  w+	写读（清空后读写）	必定清空，从指针位置写	创建	开头
  a+	追加读写	必定从末尾写	创建	末尾

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  # 创建文件 with open('test_r+.txt', 'w') as f: f.write('旧内容') # r+ try: # 不存在改文件会报错 with open('test_r+.txt', 'r+') as f: print(f.read()) # 输出: 旧内容^ （^指针位置） f.seek(0) # ^旧内容 （移动指针位置到开头） f.write('新') # 新^内容 （从指针位置覆盖写入） f.seek(0) # ^新内容 print(f.read()) # 输出: 新内容 except FileNotFoundError: print("文件不存在")

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  # 创建文件 with open('test_w+.txt', 'w') as f: f.write('原始内容') # w+ with open('test_w+.txt', 'w+') as f: f.write('全新内容') # 清空后写入 全新内容^ f.seek(0) # 移动指针到开头 ^全新内容 print(f.read()) # 输出: 全新内容 # 文件不存在时 import os with open('new_w+.txt', 'w+') as f: f.write('创建内容') f.seek(0) print(os.path.abspath('new_w+.txt')) # 输出: 创建的文件的绝对路径

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  # 创建文件 with open('test_a+.txt', 'w') as f: f.write('初始行\n') # a+ with open('test_a+.txt', 'a+') as f: f.write('追加行\n') # 追加行\n^ f.seek(0) # ^初始行\n追加行\n print(f.read()) # 输出: 初始行\n追加行\n # 验证指针特性 f.seek(5) # 初始行\n追^加行\n f.write('中间插入') # 仍然追加到文件末尾！ f.seek(0) print(f.read()) # 输出: 初始行\n追加行\n中间插入

eval

• eval(表达式的字符串[, globals[, locals]])，执行一个字符串表达式，并返回表达式的值。

  1 2 3 4 5 6 7 8 9 10 11 12 13

  # 简单表达式 result = eval("2 + 3 * 4") print(result) # 输出: 14 # 变量引用 x = 10 result = eval("x + 5") print(result) # 输出: 15 # 指定变量空间 namespace = {'a': 2, 'b': 3} # 必须是字典 result = eval("a + b", namespace) print(result) # 输出: 5

• eval() 执行代码有安全风险，可能导致代码注入漏洞，并确保仅执行可信任的字符串表达式。 设置命名空间的内置函数和类型 —— __builtins__

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  # 安全沙箱环境配置 safe_globals = { '__builtins__': { 'abs': abs, 'max': max, 'min': min, 'pow': pow, 'round': round } } # 安全计算示例 result = eval("pow(2, 3) + abs(-5)", safe_globals) # 输出: 13 # 危险操作示例（将被阻止） try: eval("open('test.txt')", safe_globals) except NameError as e: print(f"安全拦截: {e}") # 输出: name 'open' is not defined

• 拓展: __builtins__

  1 2 3 4 5 6 7

  # 查看内置函数列表 print(dir(__builtins__)) # 输出: ['ArithmeticError', 'AssertionError', ...,' iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', ...] # 调用内置函数 print(__builtins__.len([1,2,3])) # 输出: 3 print(len([1,2,3])) # 等价

int

• int(x, base=10) -> integer，将一个数字或字符串转为一个int类型数据（10进制）, 如果没有参数返回0。 如果带参数base的话，第一个参数一定要是字符串

  1 2 3 4 5 6 7 8 9

  #小数点后直接删了 print(int(3.6)) # 3 # 如果带参数base的话，第一个参数一定要是字符串。1a为 16进制。 print(int('1a',16)) # 26 # int被print时都是10进制，int其他进制字符串转为10进制表示的int print(int('0xaa',16)) # 16 * 10 + 1 * 10 = 70 print(int('0b110',2)) # 4+2=6

• int([x]) -> integer，[x]可以是str, bytes, or bytearray 且符合该进制（由base确定）的字面量。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  with open('test.txt','wb+') as f: # 写入bytes类型内容 f.write(b'12') f.seek(0) # 读取bytes byte_ls=f.readline() print(byte_ls) # b'12' print(type(byte_ls)) # <class 'bytes'> # 默认10进制转换 int_ls=int(byte_ls) print(int_ls) # 12 print(type(int_ls)) # <class 'int'> # 设置为8进制 int_ls=int(byte_ls, 8) print(int_ls) # 10

str

• str(object=’’)，返回一个对象的字符串。

  1	print(type(str(123))) # <class 'str'>

• 对比str()和ascii()

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  dict = {'a': 'b'} # 转换一些数据结构是一样的 print(str(dict)) # {'a': 'b'} print(ascii(dict)) # {'a': 'b'} # 对于字符串数据，str不会将'转字符串里，ascii严格转 s = 'rooobeam' print(str(s)) # RUNOOB print(ascii(s)) # 'RUNOOB' # 对于非ASCII字符，str没事，转义为Unicode码点 ss = '阿道夫' print(str(ss)) # 阿道夫 print(ascii(ss)) # '\u963f\u9053\u592b'

  	输出目标	非ASCII字符处理	字符处理	特殊字符转义	主要用途
  str	人类可读的字符串	原样	无	仅转义控制字符如\n	用户友好
  ascii	Python可解析str	Unicode码点(如\u4e2d)	始终用单引号包裹	转义所有非ASCII字符	调试和安全

bool

• bool(x) 将给定参数转换为布尔类型，如果没有参数，返回 False。

  1 2 3

  print(bool(0)) # False print(bool(1)) # Ture print(bool(2)) # True

  （bool是int的子类，然并卵。）

• Returns True when the argument x is true, False otherwise.

exec

• exec(object[, globals[, locals]])，执行储存在字符串或文件中的 Python 语句，可执行更复杂的 Python 代码。

  1 2 3 4

  exec(''' print("where you are") print("where is love") ''')

• globals，locals类似 eval。

• 非常不安全，永远不要执行没有检验过的代码。

• 可用__builtins__限制命名空间。

isinstance

• isinstance(object, classinfo)——isinstance(实例a, 类A)，判断实例a 是不是 A 或 A的子类 的实例化。

  1 2 3 4

  a = 2 isinstance(a,int) # True a是int类型 isinstance(a,str) # False a不是str类型 isinstance(a,(str,int,list)) # True 元组里有a的类型

• isinstance() 与 type() 区别：

  1. type() 不会认为子类是一种父类类型，不考虑继承关系。
  2. isinstance() 会认为子类是一种父类类型，考虑继承关系。

  如果要判断两个类型是否相同推荐使用 isinstance()。

  1 2 3 4 5 6 7 8

  a = bool() print(type(a)==int) # False # 子类是父类的一种，a是子类则a是父类 print(isinstance(a,int)) # True # 反之不成立 b = int() print(isinstance(b,bool)) # False

ord、chr

• ord(c)，c为字符，返回 Unicode 码点 (十进制int) for a one-character string.

  1 2 3 4

  print(ord('a')) # 97 print(ord("a")) # 97 print(ord('€')) # 8364 print(type(ord('a'))) # int

• chr(i) ，ord的反向操作 返回一个one-character string 对应输入的unicode码点(十进制int)， 0 <= i <= 0x10ffff (unicode的最大码点).

  1 2 3

  print(chr(65)) # 'A'（65对应'A'） print(chr(9731)) # '☃'（9731对应雪人符号） print(type(chr(9731))) # str

sum

对iterable的元素求和

1
2
3

print(sum([1,2,3]),sum((1,2,3)),sum({1,2,3})) 	# 6 6 6

print(sum(1,2,3),1)		# 7		组计算总和后再加 1

bytes、bytearray

1. 初始化空bytearray、bytes
   • bytearray() -> empty bytes array
   • bytes() -> empty bytes object

1

print(bytearray())		# bytearray(b'')

2. 初始化n个 \x00
   • bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
   • bytes() -> empty bytes object

1
2

print(bytearray(2))		# bytearray(b'\x00\x00')
print(bytes(2))		# b'\x00\x00'

3. 转换int的可迭代类型（[1,2,3], (1,2,3), {1,2,3}等）
   • bytearray(iterable_of_ints) -> bytearray
   • bytes(iterable_of_ints) -> bytes

1
2
3

# 每个int范围 in range(256)
print(bytearray([1,2,3,4]))		# bytearray(b'\x01\x02\x03\x04')
print(bytes([1,2,3,4]))	

4. 转换字符串类型

1
2

a=bytearray('八寸', 'utf-8')
print(a)		# bytearray(b'\xe5\x85\xab\xe5\xaf\xb8')

5. bytes、bytearray、memoryview 和其他自定义的缓冲区对象间相互转换
   • bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
   • bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer

1
2
3

a=b"abc"	# bytes类型
b=bytearray(a)
print(b)	# bytearray(b'abc')		bytearray类型

6. 对比。

   不同：

   • 是否可修改

   • 使用 b’’ 或 bytes() 创建还是使用 bytearray() 创建

   • file.read()得出的是bytes

   相同：

   • 存储内容：都存储字节数据（0到255之间的整数，\x00~\xff）。

   • 二进制数据：都适合处理二进制数据，如文件、网络通信等。

   • 索引和切片：都支持通过索引和切片访问数据。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

4ea=bytearray('abc', 'utf-8')
b=bytes("ABC",'utf-8')

print(a[0])		# 97
a[0]=65
print(a[0])		# 65

try:
     b[0]=97
except Exception as e:
    print(f"{e}")	# 'bytes' object does not support item assignment

filter

• filter(function or None, iterable) –> filter object
• filter 函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，函数需返回 True 或 False，最后将返回 True 的元素放到filter中。

1
2
3
4
5
6

def is_odd(n):
    return n % 2 == 1
 
a = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
b = list(a)
print(b)	# [1, 3, 5, 7, 9]

• 如果function那里填了None，则返回非空元素。

1
2
3

a = filter(None ,[1, 2, 0, 4, '', 6])
b = list(a)
print(b)	# [1, 2, 4, 6]

• filter 对象是惰性求值的，这点类似于生成器。

  一旦迭代过 filter 对象，其内容就会被消耗，无法再次使用。

  如果需要多次访问，可转换为列表或其他可迭代对象。

1
2
3
4
5
6
7
8

def is_odd(n):
    return n % 2 == 1
a = filter(is_odd, [1, 2, 3])
for i in a:
    print(i)	# 1\n3\n

b=list(a)
print(b)	# []

issubclass

• issubclass(class1, class2)，判断 class1 是否为 class2 的子类。

1
2
3
4
5
6

class A:
    pass
class B(A):
    pass
    
print(issubclass(B,A))    # True

pow

pow(base, exp, mod=None) pow(底数，指数，模数=None)

两个参数时，得到 base**exp，三个参数时，得到 base**exp % mod

对于一些类型的参数如int型参数它能算得更快。

1
2
3
4
5
6
7

# 两个参数
print(pow(2,3))		# 8
print(pow(2.5,2))	# 6.25
print(pow(2,2.5))	# 5.656854249492381

# 三个参数
print(pow(2,34,13))		# 10

super

• 一句话概括：调用父类方法，改变传入实例。

• super(class, obj )，class——指定从哪个类开始查找父类方法，obj——传入的对象

  译为 创建一个 传入了对象obj的 可调用class的父类的方法的 对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Parent:
    def greet(self):
        print('Parent')

class Child(Parent):
    def greet(self):
        print('Child')
    def react(self):
        print('c')

# 在类外部调用父类方法
c = Child()
super(Child, c).greet()  # Parent

• 在一个类里，super()=super(当前类, self)，会自动绑定当前类和实例(self)，适用于类方法中。

  译为 创建一个 传入了self的 可调用当前类的父类的方法的 对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Parent(object):
    def __init__(self):
        # 定义传入的对象的属性
        self.parent = 'I\'m the parent.'	
        # 证明执行__init__方法的语句
        print ('Parent')
    
    def bar(self, message):
        # 证明可调用其他方法如bar
        print ("%s from Parent" % message)
 
class Child(Parent):
    def __init__(self):
        # 调用parent的初始化函数，如继承父类属性
        super().__init__()    
        print ('Child')
        
    def bar(self, message):
        super(Child, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    Child = Child()
    Child.bar('HelloWorld')
  
# 输出
# Parent
# Child
# HelloWorld from Parent
# Child bar fuction
# I'm the parent.

• 可不可以理解为 super(Child,self) 首先找到 Child 的父类（Parent），然后把类 Child 的对象转换为类 Parent 的对象？ —— False

  可能会发生死循环吗？ —— True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Parent:
    def __init__(self):
        # Parent 对象必有a属性
        self.a=123	
    def react(self):
        self.react()

class Child(Parent):
    def react(self):
        super().react()
        
# 证明不是Parent的对象
try:
  print(b.a)
except Exception as e:
  print(f"{e}")	# 'super' object has no attribute 'a'

# 证明死循环
c = Child()
b=super(Child, c)
try:
    super(Child, c).react()
except Exception as e:
    print(f"{e}")	# maximum recursion depth exceeded

• 多重继承问AI

float

将一个字符串或整数转为浮点数

1
2
3

float(123)	# 123.0
float('123')	# 123.0
float('123.123')	# 123.123

iter

• iter() 用于获取可迭代对象的迭代器，两种传参：(iterable) 、(callable, sentinel)

• iter(iterable) -> iterator 传入可迭代对象，如列表、字符串，转为iter.

  （“给对象生成__iter__() 和 __next__()”）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 配合 next() 逐步获取元素时应用
a=iter("123")
print(next(a))	# 1
print(next(a))	# 2
print(next(a))	# 3
# iterator 惰性计算
print(list(a))	# []

# 在for循环中隐式调用
a=iter("123")
for i in a:
    print(i)

• iter(callable, sentinel) -> iterator，重复调用无参函数callable，直到其返回值等于sentinel（哨兵值）时停止

1
2
3
4
5
6
7
8

import random

def get_random():
    return random.randint(1, 10)

it = iter(get_random, 7)
for num in it:
    print(num)  # 持续输出随机数，直到出现7时停止

• 拓展（__iter__）

  Python 的迭代器：实现 __iter__() 和 __next__() 方法的对象被视为迭代器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Counter:
    def __init__(self, low, high):
        self.current = low
        self.high = high

    def __iter__(self):
        return self
	
    def __next__(self):
        if self.current > self.high:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1

# 使用
counter = Counter(1, 3)
for num in counter:
    print(num)  # 输出1, 2, 3

• 以后遇到了再补充了

print

print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

sep间隔 默认一个空格，print完成后补充内容 默认一个换行符，输出文件 默认控制台，是否刷新缓存默认否。

1
2
3
4
5
6

# sep
print("apple", "banana", "cherry", sep=", ")	# apple, banana, cherry

# end
for i in range(3):
    print(i, end=" | ")  # 0 | 1 | 2 | （同一行）

tuple

• tuple(iterable=(), /)，将可迭代对象转为元组类型，元组数据不可修改。

1
2

a=tuple([1,2,3])
print(a)	# (1,2,3)

• 判断是否为可迭代对象

1
2

a=[1,2,3]
print('__iter__' in dir(a))	# True

callable

• callable（可调用对象）是指任何可以通过 () 运算符调用的对象。例如：函数、方法、类，或者实现了 call 方法的对象，是否具有__call__

1
2
3
4
5
6
7
8

# 用 def 或 lambda 定义的函数是callable
def greet():
    print("Hello!")

add = lambda x, y: x + y

print(callable(greet))	# True
print(callable(add))	# True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 类本身是 callable （类可被调用来创建实例，但对象未必）
class A:
	pass
a=A()
print(callable(A))	# True
print(callable(a))	# False

# 类里定义了__call__，这样得到的对象是callable （能实现b()）
class B:
    def __call__(self):
        return 0
b=B()
print(callable(b))	# True
print(b())	# 0

1
2
3
4
5
6
7
8
9

# 对象的方法是 callable
class A:
    def react(self):
        print("great!")

a = A()
print(callable(a.react))	# True	 	
# a.react()不是callable，方法react没有返回一个有__call__的对象
print(callable(a.react())	# False	 

• 拓展：类装饰器（通过 __call__ 实现）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class countcalls:
    def __init__(self, func):
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):  # 类实例成为 Callable
        self.count += 1
        print(f"函数已被调用 {self.count} 次")
        return self.func(*args, **kwargs)

@CountCalls
# 装饰器相当于：say_hello=countcalls(say_hello)
def say_hello():
    print("Hello!")

say_hello()  # 输出：函数已被调用 1 次 → Hello!
say_hello()  # 输出：函数已被调用 2 次 → Hello!

format、f-string

• 基础用法：基本替换、位置索引、传递变量值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# format
text = "{} is {}".format('a','b')
print(text)  # a is b

text="{1} is {0}".format('a','b')
print(text)  # b is a

c=123
text="hi,{}".format(c)	# hi,123

ls=['1','2']
text="{0[0]}  {0[1]}".format(ls)
print(text)	 # 1  2

1
2
3

# f-string
name=八寸
text=f"i love {name}"

• 常用控制格式：小数位数、进制转换、小数转百分比

  特别是 f"{num:2f}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 小数位数控制
decimal=123.125
a="2位：{decimal:.2f}"
b="3位：{:3f}".format(decimal)

# 进制
n = 255
print("二进制: {:b}".format(n))  # 二进制: 11111111
print("十六进制: {n:x}")  # 十六进制: ff
print("十进制: {n:d}")  # 十进制: 255
print("八进制: {:o}".format(n))  # 八进制: 377

# 小数转百分比，百分号要放大括号{}里
rate = 0.8523
a = "完成度: {rate:.2%}"  # 取整百分比
b= "完成度: {:.2}%".format(rate)  
print(a)  # 输出：完成度: 85.23%
print(b)  # 输出：完成度: 0.85%

• format或f-string下大括号用{{}}(双重大括号)

1
2

text = "格式占位符: {{}}".format()
print(text)  # 格式占位符: {}

• 其他对齐、填充啥的要用再查就好了，太没用了

len

求各种序列的长度

1
2
3
4
5

text = "Hello, 世界!\n"  # 包含英文、中文、符号、换行符
print(len(text))  # 11

ls=[[],[]]
print(len(ls)) # 2

property

• property 的核心用途是将类的方法转换为“虚拟属性”，1 将方法伪装成"属性”， 优雅地控制"属性"。

  @property @ method.setter @method.deleter

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class Circle:
    def __init__(self, radius):
        self._radius = radius  # 私有变量
        self._pi = 3.141592653589793
    
    @property
    # 通过方法返回变量，起到保护_radius作用（只读）
    def radius(self):
        return self._radius
    
    @property
    # 实时计算面积area
    def area(self):
        return self._pi*(self._radius**2)
    
    @radius.setter
    # 控制radius的修改
    def radius(self, value):
        if value < 0:
            raise ValueError("半径不能为负")
        self._radius = value  # 合法时存储
    
    @radius.deleter
    # 控制radius的删除
    def radius(self):
        print("禁止删除半径！")
        
c = Circle(5)
print(c.radius) # 5
print(c.area)	# 78.53981633974483

• 对比 “.” 访问属性 和 使用property

type

• type(object) -> the object’s type 返回对象的type，打印type会显示<….>