Python3 内置函数

abs() 函数

abs() 函数返回数字的绝对值。
abs( x ) 参数:x -- 数值表达式，可以是整数，浮点数，复数。
函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。
print ("abs(-40) : ", abs(-40))
print ("abs(100.10) : ", abs(100.10))
以上实例运行后输出结果为：

abs(-40) :  40
abs(100.10) :  100.1

any() 函数：

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

函数等价于：
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
用法：
any(iterable)   参数：iterable -- 元组或列表。
如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
实例：
>>>any(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True
>>> any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
True
>>> any([0, '', False]) # 列表list,元素全为0,'',false
False
>>> any(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0
True
>>> any(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素
True
>>> any((0, '', False)) # 元组tuple，元素全为0,'',false
False
>>> any([]) # 空列表
False
>>> any(()) # 空元组
False

all() 函数

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、FALSE 外都算 TRUE。

函数等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
all(iterable)  参数：  iterable -- 元组或列表。
如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；

注意：空元组、空列表返回值为True，这里要特别注意。
实例：
>>>all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3]) # 列表list，存在一个为0的元素
False
>>> all(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0
True
>>> all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素
False
>>> all((0, 1, 2, 3)) # 元组tuple，存在一个为0的元素
False
>>> all([]) # 空列表
True
>>> all(()) # 空元组
True

ascii() 函数

ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 x, u 或 U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。

语法
ascii(object) 参数:object -- 对象。
返回值:返回字符串
实例：
>>> ascii('runoob')
"'runoob'"

bin() 函数

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
语法
bin(x) 参数：x -- int 或者 long int 数字
返回值：字符串
实例：
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'

bool() 函数

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
bool 是 int 的子类。
语法：
class bool([x])   参数：x -- 要进行转换的参数。
返回值：返回 Ture 或 False
实例：
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int) # bool 是 int 子类
True

bytearray() 函数

bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
语法：
class bytearray([source[, encoding[, errors]]])
参数
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray
如果没有输入任何参数，默认就是初始化数组为0个元素。
返回值：返回新字节数
实例：
>>>bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'x01x02x03')
>>> bytearray('runoob', 'utf-8')
bytearray(b'runoob')

bytes 函数

bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本
语法
class bytes([source[, encoding[, errors]]])
参数
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。
返回值：返回一个新的 bytes 对象。
实例：
>>>a = bytes([1,2,3,4])
>>> a
b'x01x02x03x04'
>>> type(a)
<class 'bytes'>
>>>
>>> a = bytes('hello','ascii')
>>>
>>> a
b'hello'
>>> type(a)
<class 'bytes'>

callable() 函数

callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

语法
callable(object)    参数：object -- 对象
返回值
可调用返回 True，否则返回 False。
实例：
>>>callable(0)
False
>>> callable("runoob")
False
>>> def add(a, b):
... return a + b
...
>>> callable(add) # 函数返回 True
True
>>> class A: # 类
... def method(self):
... return 0
...
>>> callable(A) # 类返回 True
True
>>> a = A()
>>> callable(a) # 没有实现 __call__, 返回 False
False
>>> class B:
... def __call__(self):
... return 0
...
>>> callable(B)
True
>>> b = B()
>>> callable(b) # 实现 __call__, 返回 True
True

chr() 函数

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符
语法 ：chr(i)  参数：i -- 可以是10进制也可以是16进制的形式的数字
返回值
返回值是当前整数对应的ascii字符
实例：
>>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97) # 十进制
0 1 a

classmethod 修饰符

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
语法
classmethod 语法：
classmethod
参数
无。
返回值
返回函数的类方法
实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 调用 foo 方法
A.func2() # 不需要实例化

compile() 函数

compile() 函数将一个字符串编译为字节代码。
语法:
compile(source, filename, mode[, flags[, dont_inherit]])
参数:
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志
返回值:
返回表达式执行结果。
实例：

>>>str = "for i in range(0,10): print(i)"
>>> c = compile(str,'','exec') # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17

complex() 函数

complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
complex 语法：

    class complex([real[, imag]])
参数说明：
    real -- int, long, float或字符串；
    imag -- int, long, float；
返回值
    返回一个复数。
实例：
    >>>complex(1, 2)
(1 + 2j)
>>> complex(1) # 数字
(1 + 0j)
>>> complex("1") # 当做字符串处理
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

delattr() 函数

delattr 函数用于删除属性。
delattr(x, 'foobar') 相等于 del x.foobar
setattr 语法：
delattr(object, name)
参数
object -- 对象。
name -- 必须是对象的属性。
返回值
无。
实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
delattr(Coordinate, 'z')
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
# 触发错误
print('z = ',point1.z)
输出结果：
('x = ', 10)
('y = ', -5)
('z = ', 0)
--删除 z 属性后--
('x = ', 10)
('y = ', -5)
Traceback (most recent call last):
  File "test.py", line 22, in <module>
    print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'

dict() 函数

dict() 函数用于创建一个字典。
dict 语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数说明：
**kwargs -- 关键字
mapping -- 元素的容器。
iterable -- 可迭代对象。
返回值
返回一个字典。
实例：
>>>dict() # 创建空字典
{}
>>> dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}

dir() 函数

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
dir 语法：
dir([object])
参数说明：
object -- 对象、变量、类型。
返回值
返回模块的属性列表。
dir 的使用方法：
>>>dir() # 获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ]) # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

divmod() 函数

python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
在 python 2.3 版本之前不允许处理复数。
语法
divmod(a, b)
参数说明：
a: 数字
b: 数字
实例
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

enumerate() 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
语法
以下是 enumerate() 方法的语法:
enumerate(sequence, [start=0])
参数
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
返回值
返回 enumerate(枚举) 对象。
enumerate() 方法的实例：

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>>list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>>list(enumerate(seasons, start=1)) # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
普通的 for 循环
>>>i = 0
>>>seq = ['one', 'two', 'three']
>>>for element in seq:
... print(i, seq[i])
... i += 1
...
0 one
1 two
2 three
for 循环使用 enumerate
>>>seq = ['one', 'two', 'three']
>>>for i, element in enumerate(seq):
... print(i, seq[i])
...
0 one
1 two
2 three

eval() 函数

eval() 函数用来执行一个字符串表达式，并返回表达式的值。
eval() 方法的语法:
eval(expression[, globals[, locals]])
参数
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。
eval() 方法的实例：
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

exec 函数

exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
exec 的语法:
exec(object[, globals[, locals]])
参数
object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
返回值
exec 返回值永远为 None。
exec 的实例：

实例 1
>>>exec('print("Hello World")')
Hello World
# 单行语句字符串
>>> exec("print ('runoob.com')")
runoob.com
# 多行语句字符串
>>> exec ("""for i in range(5):
... print ("iter time: %d" % i)
... """)
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
实例 2
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20
exec(expr)
exec(expr, {'x': 1, 'y': 2})
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
func()
输出结果：

60
33
34

filter() 函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

filter() 方法的语法:
filter(function, iterable)
参数
function -- 判断函数。
iterable -- 可迭代对象。
返回值
返回一个迭代器对象
 filter 函数的实例：

过滤出列表中的所有奇数：
#!/usr/bin/python3
def is_odd(n):
return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
输出结果 ：

[1, 3, 5, 7, 9]
过滤出1~100中平方根是整数的数：
#!/usr/bin/python3
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)
输出结果 ：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

float() 函数

float() 函数用于将整数和字符串转换成浮点数。
语法
float()方法语法：
class float([x])
参数
x -- 整数或字符串
返回值
返回浮点数。
float() 的使用方法：
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123') # 字符串
123.0

format 格式化函数

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
实例
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'

也可以设置参数：
实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
输出结果为：

网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com

也可以向 str.format() 传入对象：
实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
输出结果为：
value 为: 6    

　　

　　数字格式化

　　下表展示了 str.format() 格式化数字的多种方法：

　　>>> print("{:.2f}".format(3.1415926));
　　3.14
　　

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；  （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

#!/usr/bin/python # -*- coding: UTF-8 -*- print ("{} 对应的位置是 {{0}}".format("runoob"))

输出结果为：

runoob 对应的位置是 {0}

% 操作符，格式如下：

%[(name)][flags][width].[precision]typecode
 (name) 为命名
 flags 可以有 +，-，' '或 0。+ 表示右对齐。- 表示左对齐。' ' 为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0 表示使用 0 填充。
 width 表示显示宽度
 precision 表示小数点后精度
以下是类型码：

%s    字符串 (采用str()的显示)
%r    字符串 (采用repr()的显示)
%c    单个字符
%b    二进制整数
%d    十进制整数
%i    十进制整数
%o    八进制整数
%x    十六进制整数
%e    指数 (基底写为e)
%E    指数 (基底写为E)
%f    浮点数
%F    浮点数，与上相同%g    指数(e)或浮点数 (根据显示长度)
%G    指数(E)或浮点数 (根据显示长度)
%%    字符"%"
举例

>>> print("%6.3f" % 2.3)
 2.300
 第一个 % 后面的内容为显示的格式说明，6 为显示宽度，3 为小数点位数，f 为浮点数类型
 第二个 % 后面为显示的内容来源，输出结果右对齐，2.300 长度为 5，故前面有一空格
>>> print("%+10x" % 10)
    +a
x 为表示 16 进制，显示宽度为 10，前面有 8 个空格。

>>>print("%-5x" % -10)
-a  
%-5x 负号为左对齐，显示宽度为 5，故 -a 后面有 3 个空格

>>>pi=3.1415
>>>print ("pi的值是%s"%pi)
pi的值是3.1415

>>>print ("pi的值是%.8f"%pi)
pi的值是3.14150000
上面的 width, precision 为两个整数。我们可以利用 *，来动态代入这两个量。比如：

>>> print("%10.*f" % (4, 1.2))
  1.2000
以下是补充

简单的说，这是一种将其他变量置入字符串特定位置以生成新字符串的操作，比如说:

>>> n = "Runoob"
>>> "My name is %s" % n
'My name is Runoob'
这段代码首先定义了一个名为 n 的变量，内容为 Runoob。然后下方的字符串中有一个 %s，他的含义是“这里将被替换成一个新的字符串”，用作替换的内容放在字符串后面的%后面，就是那个 n。所以最终这个字符串会变成 My name is Runoob。

frozenset() 函数

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法
frozenset() 函数语法：
class frozenset([iterable])
参数
iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回值
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
 frozenset() 的使用方法：

>>>a = frozenset(range(10)) # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合

getattr() 函数

getattr() 函数用于返回一个对象属性值。
语法
getattr 语法：
getattr(object, name[, default])
参数
object -- 对象。
name -- 字符串，对象属性。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
返回值
返回对象属性值。
getattr 的使用方法：

>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
>>> getattr(a, 'bar2') # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3) # 属性 bar2 不存在，但设置了默认值
3

globals() 函数

globals() 函数会以字典类型返回当前位置的全部全局变量。
globals() 函数语法：
globals()
参数
无
返回值
返回全局变量的字典。
globals() 的使用方法：

>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}

hasattr() 函数

hasattr() 函数用于判断对象是否包含对应的属性。
hasattr 语法：
hasattr(object, name)
参数
object -- 对象。
name -- 字符串，属性名。
返回值
如果对象有该属性返回 True，否则返回 False。
hasattr 的使用方法：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no')) # 没有该属性
输出结果：

True
True
True
False

hash() 函数

hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
hash 语法：
hash(object)
参数说明：
object -- 对象；
返回值
返回对象的哈希值。
 hash 的使用方法：

>>>hash('test') # 字符串
2314058222102390712
>>> hash(1) # 数字
1
>>> hash(str([1,2,3])) # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
>>>

hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。

class Test:
    def __init__(self, i):
        self.i = i
for i in range(10):
    t = Test(1)
    print(hash(t), id(t))

2834009 45344144
2867409 45878544
2834009 45344144
2867365 45877840
2834009 45344144
2867409 45878544
2834009 45344144
2867365 45877840
2834009 45344144
2867409 45878544