Python内置函数

Python3.9.2的内置函数

原文来自 Python官方文档与菜鸟教程。以原文档为主，菜鸟教程为辅。

1. 内置函数一览表(Python3.9.2)

内建功能	参数	说明
abs()	x	返回数字(整数、浮点数、实现的对象__abs__()、复数[返回其大小])的绝对值
all()	iterable	一个可迭代参数，该参数中的所有元素都为True则返回True，否则返回False
any()	iterable	一个可迭代参数，该参数中的所有元素都为False则返回False，有一个为True则返回True
ascii()	object	一个对象参数，返回该参数的字符串类型
bin()	x	int或long int数字，将整数转换为以"0b"为前缀的二进制字符串
bool()	[x]	将给定参数转换为布尔类型(True/False)并返回，没有参数返回False
breakpoint()	*args,**kwargs	呼叫站点的调试器，sys.breakpointbook()
bytearray()	[source[,encoding[,errors]]]	返回一个新字节数组，数组里的元素是可变的，每个元素的值范围：0<=x<256
bytes()	[source[,encoding[,errors]]]	返回一个新的“字节”对象，该对象是0<=x<256中整数的不可变序列
callable()	object	判断对象是否可调用，可调用返回True，object仍然可能调用失败；如果返回False说明object绝对不可调用。函数、方法、lambda、类和实现了__call__方法的类实例都返回True
chr()	i 10进制或16进制的形式的数字，范围0~1114111(16进制为0×10FFFF)	返回当前整数对应的ASCII字符
classmethod()	无	修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可用来调用类的属性，类的方法，实例化对象等，返回函数的类方法
compile()	source，filename，mode，flags=0，dont_inherit=False，optimize=-1	该函数将一个字符串编译为字节代码，返回表达式执行结果
complex()	[real[,imag]] real是int、long、float或str；imag是int、long、float	返回值为read + imag * j 的复数，或将字符串/数字转换为复数。如果指定第一个参数为字符串，则不需要指定第二个参数
delattr()	object,name 对象,字符串	name必须是object属性之一的名称。删除命名属性，无返回值。 delattr(x,‘f’)相当于del x.f
dict()	**kwarg或mapping,**kwarg或iterable,**kwarg	**kwargs是关键字，mapping是元素的容器，iterable是可迭代对象。创建一个字典并返回
dir()	[object] 对象、变量、类型	不带参数返回当前范围内的变量、方法和定义的类型列表；带一个参数返回该参数的有效属性和方法列表。如果参数包含方法__dir__()，该方法将被调用，如果不含则将最大化的收集参数信息。返回模块的属性列表
divmod()	a,b 两个数字类型(非复数)	返回一个包含商和余数的元组(a // b, a % b)
enumerate()	sequence,[start=0] sequence是一个序列、迭代器或其他支持迭代对象，start下标起始位置	将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。返回enumerate(枚举)对象
eval()	expression[,globals[,locals]]	执行一个字符串表达式，并返回表达式的计算结果
exec()	object[, globals[,locals]]	执行存储在字符串或文件中的Python语句，相比于eval，exec可执行更复杂的Python代码。返回值永远为None
filter()	function,iterable	过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可用list()转换
float()	x	将整数和字符串转换成浮点数并返回
format()	str.format()	格式化函数，语法：通过 {} 和 : 来代替以前的 %，接收多个参数，位置可以不受限制，增强字符串格式化的功能
frozenset()	[iterable] 可迭代对象，列表、字典、元组等	返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。返回新的frozenset对象，如果不提供任何参数，默认会生成空集合
getattr()	object,name[, default]	object：对象。name：字符串，对象属性。default：默认返回值，如果不提供该参数，在没有对应属性时将触发AttributeError。该函数返回一个对象属性值
globals()	无	以字典形式返回当前位置的全部全局变量
hasattr()	object,name	object：对象；name：字符串，属性名。判断对象是否包含对应的属性，有返回True，没有返回False
hash()	object 对象	返回一个对象(字符串或数值等)的哈希值
help()	[object] 对象	返回对象帮助信息
hex()	x 一个整数	将一个指定数字转换为16进制，返回一个字符串，以0×开头
id()	[object] 对象	返回对象的内存地址
input()	[prompt] 提示信息	接受一个标准输入数据，返回str类型
int()	x, base=10	x：字符串或数字；base：进制数，默认十进制。返回整形数据
isinstance()	object,classinfo	object:实例对象；classinfo:可以是直接或间接类名、基本类型或者由它们组成的元组(int、float、bool、complex、str、list、dict、set、tuple)。判断一个对象是否是一个已知的类型，类似type()，对象类型与参数二类型相同返回True，否则返回False
issubclass()	class, classinfo	class:类；classinfo:类。判断参数class是否是类型参数classinfo的子类，是返回True，否则返回False
iter()	object[, sentinel]	object:支持迭代的集合对象;sentinel:如果传递第二个参数，则参数object必须是一个可调用的对象(如函数)，此时iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时就会调用object，返回迭代器对象
len()	s 对象	返回对象(字符、列表、元组、集合等，不支持int)长度或项目个数
list()	seq 要转换为列表的元组或字符串	将元组或字符串转换为列表。注意：元组、列表、集合三者可相互转化
locals()	无	以字典类型返回当前位置的全部局部变量。对于函数、方法、lambda、类、实现了__call__方法的类实例，都返回True
map()	function, iterable, …	function:函数；iterable:一个或多个序列。根据提供的函数对指定序列做映射，function作用于序列的每个元素，返回包含每次function函数返回值的新列表，返回一个迭代器
max()	x,y,z,… 数值表达式	返回给定参数的最大值，参数可以为序列
memoryview()	obj 对象	返回给定参数的内存查看对象(memory view)，内存查看对象是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上运行Python代码访问。返回元组列表
min()	x,y,z,… 数值表达式	返回给定参数的最小值，参数可以为序列
next()	iterable[, default]	iterable:可迭代对象;default:可选，设置在没有下一元素时返回该默认值，如果不设置而且没有下一元素会触发StopIteration异常。返回迭代器的下一个项目，该函数要和生成迭代器的iter()函数一起使用
object()	无	返回一个新的无特征对象。object是所有类的基础，具有所有Python类实例通用的方法。object没有__dict__，所以不能指定任意属性的实例object类
oct()	x 整数	将一个整数转换成八进制字符串，八进制以0o作为前缀表示
open()	file,mode=‘r’ 文件名,打开模式	打开一个文件，并返回文件对象。在对文件进行处理过程都需要使用这个函数，如果文件无法打开会抛出OSError
ord()	c 字符	该函数是chr()函数(对于8位的ASCII字符串)的配对函数，它以一个字符串(Unicode字符)作为参数，返回对应的ASCII数值，或者Unicode数值，即返回对应的十进制整数
pow()	x, y[, z] x,y,z都是数值表达式	返回x的y次方的值
print()	*object,sep=’’,end=’\n’,file=sys.stdout,flush=False	用于打印输出，最常见的一个函数。没有返回值
property()	fget[, fset[, fdel[, doc]]]	在新式类中返回属性值
range()	range(stop)和range(start, stop[, step]) 含前不含后	返回一个可迭代对象(类型是对象)，而不是列表类型，打印不会打印列表。(Python2 range()函数返回列表)。Python3 list()函数是对象迭代器，可以把range()返回的可迭代对象转换为一个列表，返回的变量类型是列表
repr()	object 对象	将对象转化为供解释器读取的形式，返回一个对象的string格式
reversed()	seq 要转换的序列，可以是tuple、str、list或range	返回一个反转的迭代器
round()	x [, n] x:数字表达式; n:表示从小数点位数，其中x需要四舍五入，默认值为0	返回浮点数x的四舍五入值，准确的说保留值将保留到离上一位更近的一端(四舍六入)，精确度要求高的不建议使用该函数。Python版本不同返回的数值不一样
set()	[iterable] 可迭代对象	创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等，返回新的集合对象
setattr()	object,name,value 对象;字符串,对象属性;属性值	该函数对应函数getattr()，用于设置属性值，该属性不一定是存在的。无返回值
slice()	slice(stop)或slice(start, stop[, step])	实现切片对象，主要用在切片操作函数里的参数传递。返回一个切片对象
sorted()	iterable,key=None,reverse=False	对所有可迭代的对象进行排序操作，返回重新排序的列表
sataticmethod()	function	返回函数的静态方法。该方法不强制要求传递参数
str()	object 对象	将对象转化为适于人阅读的形式，即string格式。语法：class str(object=’’)
sum()	iterable[, start]	iterable:可迭代对象，如列表、元组、集合；start:指定相加的参数，如果未设置该参数，默认为0。对序列进行求和计算，返回计算结果
super()	type[, object-or-type] type:类;object-or-type:类，一般是self	super()函数用来调用父类(超类、基类)的一个方法；用来解决多重继承问题，直接用类名调用父类方法，使用单继承没问题，但如果使用多继承会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题；MRO就是类的方法解析顺序表，其实也就是继承父类方法时的顺序表
tuple()	iterable 要转换为元组的可迭代序列	将可迭代序列(如列表)转换为元组
type()	type(object)或type(name,bases,dict)	name:类型名称;bases:基类的元组;dict:字典，类内定义的命名空间变量。如果只有第一个参数则返回对象的类型，三个参数返回新的类型对象
vars()	object 对象	返回对象object的属性和属性值的字典对象。如果没有参数，就打印当前调用位置的属性和属性值，类似locals()
zip()	[iterable, …] 一个或多个迭代器	将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少内存。可以用list()转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元祖解压为列表
__import__	name 模块名	用于动态加载类和函数。如果一个模块经常变化就可以使用__import__()来动态载入。语法：import(name[, globals[, locals[, fromlist[, level]]]])。返回元组列表

注： 元素除了 0、空、False 外都算True，空列表

2. 内建函数的例子

abs()

>>> abs(2)
2
>>> abs(-4)
4
>>> abs(1.3)
1.3
>>> abs(2+3j)
3.605551275463989

all()

>>> all([])
True
>>> all({})
True
>>> all('str')
True
>>> all([1,0])  # 有0则为False
False
>>> all((2,''))  # 有空字符串则为False
False

any()

>>> any([])
False
>>> any([1,2,3])
True
>>> any([1,2,0])
True
>>> any([0,'',False])  # 0、空字符串、False都为False
False

ascii()

>>> ascii(12)
'12'
>>> ascii('s')
"'s'"
>>> ascii([1,2,33])
'[1, 2, 33]'

bin()

>>> bin(12)
'0b1100'
>>> bin(67)
'0b1000011

bool()

>>> bool()
False
>>> bool(1)
True
>>> bool(0)
False
>>> bool('0')
True
>>> issubclass(bool, int)  # bool是int子类
True

breakpoint()

bytearray()

• source为整数，返回一个长度为source的初始化数组；
• source为字符串，按指定encoding将字符串转换为字节序列；
• source为可迭代类型，元素必须为[0.255]中的整数；
• source为与buffer接口一致的对象，此对象也可以被用于初始化bytearray；
• 没有参数，默认是初始化数组为0个元素

>>> bytearray(2)  # 整数
bytearray(b'\x00\x00')
>>> bytearray('a','utf-8')  # 字符串
bytearray(b'a')
>>> bytearray([1,2,3])  # 可迭代类型
bytearray(b'\x01\x02\x03')
>>> bytearray()  # 无参数
bytearray(b'')

bytes()

• source为整数，返回一个长度为source的初始化数组；
• source为字符串，按指定encoding将字符串转换为字节序列；
• source为可迭代类型，元素必须为[0.255]中的整数；
• source为与buffer接口一致的对象，此对象也可以被用于初始化bytearray；
• 没有参数，默认是初始化数组为0个元素

>>> bytes(3)
b'\x00\x00\x00'
>>> bytes('hello', 'ascii')
b'hello'
>>> bytes([1,2,3,4])
b'\x01\x02\x03\x04'
>>> bytes()
b''

callable()

>>> def add(a, b):
...     return a + b
...
>>> callable(add)  # 函数add，返回True
True
>>> la = lambda x : x + 2
>>> callable(la)  # lambda，返回True
True
>>> class A:
...     def method(self):
...             return o
...
>>> callable(A)  # 类A，返回True
True
>>> a = A()
>>> callable(a)  # 类的实例a，因为未实现`__call__`方法所以返回False
False
>>> class B:
...     def __call__(self):
...             return 0
...
>>> b = B()
>>> callable(b)  # 实现了`__call__`方法的类实例，返回True
True

chr()

>>> chr(0x30)
'0'
>>> chr(2)
'\x02'
>>> chr(97)
'a'
>>> chr(8366)
'?'

classmethod()

class A(object):
    bar = 1

    def func1(self):
        print('func1')
        
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)  # 调用类属性 bar
        cls().func1()  # 调用类方法 func1()

A.func2()  # 直接调用，不需要实例化

输出结果：

func2
1
func1

compile()

• source：必需。字符串或AST(Abstract Syntax Trees)对象
• filename：必需。代码文件名称，如果不是从文件读取代码则传递一些可辨认的值
• mode：必需。指定编译代码的种类，可指定为exec(源是语句块)、eval(源是单个表达式)、single(源是单个交互式语句)
  • exec可以编译单个表达式；eval不能编译语句块
• flags：可选。变量作用域，局部命名空间，如果被提供，可以是任何映射关系，默认0
• dont_inherit：可选。和flags都是用来控制编译源码时的标志，默认False
• optimize：可选。定义编译器的优化级别，默认-1

>>> str = "for i in range(5): print(i)"
>>> c = compile(str, '', 'exec')
>>> c
<code object <module> at 0x0000028A83173AE0, file "", line 1>
>>> exec(c)
0
1
2
3
4
>>> str = '2 * 3 + 4'
>>> a = compile(str, '', 'eval')
>>> eval(a)
10

complex()

>>> complex(1,2)
(1+2j)
>>> complex(2)
(2+0j)
>>> complex('1')
(1+0j)
>>> complex('12')
(12+0j)
>>> complex("1 + 2j")  # 不能有空格
# ValueError: complex() arg is a malformed string
>>> complex("1+2j")
(1+2j)

delattr()

>>> class C:
...     x = 10
...     y = -5
...     z = 0
...
>>> print1 = C()
>>> print('x = ', print1.x)
x =  10
>>> print('y = ', print1.y)
y =  -5
>>> print('z = ', print1.z)
z =  0
>>> delattr(C, 'z')
>>> print('z = ', print1.z)  # 报错
AttributeError: 'C' object has no attribute 'z'

dict()

>>> dict()  # 创建空字典
{}
>>> dict(a='a',b='b')  # 传入关键字
{'a': 'a', 'b': 'b'}
>>> dict(zip(['name','age','gender'],['Bob',25,'male']))  # 映射函数方式来构造字典
{'name': 'Bob', 'age': 25, 'gender': 'male'}
>>> dict([('id',1),('book','西游记'),('author','吴承恩')])  # 可迭代对象方式来构造字典
{'id': 1, 'book': '西游记', 'author': '吴承恩'}

dir()

>>> dir()  # 获得当前模块的属性列表
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir([])  # 查看列表的方法
['__add__', '__class__',...,'reverse', 'sort']
>>> dir(2)
['__abs__', '__add__', '__and__', '__bool__',...,'real', 'to_bytes']

divmod()

• 如果a和b都是整数，函数返回的结果相当于(a//b, a%b)
• 如果其中一个参数是浮点数，返回的结果相当于(q,a%b)，q通常是math.floor(a/b)，但也有可能是1或比1小，不过q*b+a%b的值会非常接近a
• 如果a%b的求余结果不为0，则余数的正负符号跟参数b是一样的，若b是正数，余数为正数，若b是负数，余数也是负数，并且0<=abs(a%b) < abs(b)

>>> divmod(7,2)
(3, 1)
>>> divmod(8,2)
(4, 0)
>>> divmod(8,-2)
(-4, 0)
>>> divmod(3,1.3)
(2.0, 0.3999999999999999)

enumerate()

>>> names = ['Aili','Bob','Jason']
>>> list(enumerate(names))  # 转成列表
[(0, 'Aili'), (1, 'Bob'), (2, 'Jason')]
>>> tuple(enumerate(names, start=1))  # 转成元组
((1, 'Aili'), (2, 'Bob'), (3, 'Jason'))
>>> str = 'hello'
>>> list(enumerate(str, start=2))  # 遍历字符串
[(2, 'h'), (3, 'e'), (4, 'l'), (5, 'l'), (6, 'o')]

eval()

• expression：表达式
• globals：变量作用域，全局命名空间，如果被提供则必须是一个字典对象
• locals：变量作用域，局部命名空间，如果被提供可以是任意映射对象

>>> x = 2
>>> eval('3 * x')
6
>>> eval('pow(2,3)')  # pow(x,n) 计算x的n次方
8
>>> eval('3+4')
7

exec()

• object：必需。表示需要被指定的python代码，必须是字符串或code对象。如果object是一个字符串则先被解析为一组python语句再执行；如果object是一个code对象则只是被简单的执行
• globals：可选。表示全局命名空间(存放全局变量)，如果被提供，则必须是一个字典对象
• locals：可选。表示当前局部命名空间(存放局部变量)，如果被提供，可以是任何映射对象。如果该参数被忽略，那它将会取与globals相同的值

x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""

def func():
    y = 20
    exec(expr)  # 60 = 10 + 20 + 30
    exec(expr, {'x': 1, 'y': 2})  # 33 = 1 + 2 + 30，全局，x=1,y=2
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})  # 34 = 1 + 3 + 30，全局x=1,y=2,局部y=3,z不起作用

func()

filter()

• 接收两个参数，一个是函数，一个是序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或False，最后将返回True的元素放到新列表中
• function：判断函数
• iterable：可迭代对象

demo1：使用lambda省去创建函数的繁琐代码，过滤奇数。序列是1~10的列表

>>> fi = filter(lambda x: x % 2 == 1, range(1,11))
>>> fi  # filter返回迭代器对象
<filter object at 0x000002D47DA81A88>
>>> list(fi)  # 通过list()将该迭代器对象转换成列表
[1, 3, 5, 7, 9]

demo2：过滤出1~100中平方根是整数的数

>>> import math
>>> def is_sqr(x):
...     return math.sqrt(x) % 1 == 0
...
>>> tmplist = filter(is_sqr, range(1,101))
>>> list(tmplist)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

float()

>>> float(1)
1.0
>>> float(12)
12.0
>>> float(-1.23)
-1.23
>>> float('123')
123.0

format()

demo1：不设置参数，只设置是否指定位置

# 不设置指定位置，按默认顺序
>>> "{} {}".format("hello", "world")
'hello world'

# 设置指定位置
>>> "{0} {1}".format("hello", "world")
'hello world'

# 设置指定位置
>>> "{1} {0} {1}".format("hello", "world")
'world hello world'

demo2：设置参数

# 设置参数
>>> str4 = "网站名：{name}, 地址：{url}".format(name="百度", url="www.baidu.com")
>>> str4
'网站名：百度, 地址：www.baidu.com'

# 通过字典设置参数
>>> site = {"name": "百度", "url": "www.baidu.com"}
>>> print("网站名：{name}，地址：{url}".format(**site))
网站名：百度，地址：www.baidu.com

# 通过列表索引设置参数
>>> my_list = ["百度", "www.baidu.com"]
>>> print("网站名：{0[0]}，地址：{0[1]}".format(my_list))
网站名：百度，地址：www.baidu.com

# 向 str.format() 传入对象
>>> class A(object):
...     def __init__(self, value):
...             self.value = value
...
>>> my_value = A(5)
>>> print('value 是 ：{0.value}'.format(my_value))  # 0是可选的
value 是 ：5

# 数字格式化
int_fm = "{:.2f}".format(3.1415926)
print(int_fm)  # 3.14

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零(填充左边，宽度为2)
5	{:x>4d}	5xxx	数字补x(填充右边，宽度为4)
10	{:x<4d}	10xx	数字补x(填充右边，宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2f}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐(默认，宽度为10)
13	{:<10d}	13	左对齐(宽度为10)
13	{:^10d}	13	中间对齐(宽度为10)
11	‘{:b}’.format(11)	1011	进制
11	‘{:d}’.format(11)	11	进制
11	‘{: o}’.format(11)	13	进制(冒号和o之间没有空格)
11	‘{:x}’.format(11)	b	进制
11	‘{:#x}’.format(11)	0×b	进制
11	‘{:#X}’.format(11)	0×B	进制

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

• + 表示在正数前显示+，负数前显示-；(空格)表示在正数前加空格

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

• 大括号{}转义大括号（两个大括号转义成一个）：

  >>> print("{}对应的位置是{{0}}".format("demo"))
  demo对应的位置是{0}
  

frozenset()

• 普通集合set可变，frozenset不可变，可满足集合中的元素是另一个集合的情况

>>> a = frozenset(range(10))  # 生成一个新的不可变集合
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> b = frozenset('demo')  # 生成一个不可变集合
>>> b
frozenset({'o', 'e', 'm', 'd'})
# 判断某个元素是否在不可变集合内
>>> 5 in b
False
>>> 5 in a
True
# for循环获取不可变集合的所有元素
>>> for i in b:
...     print(i)
...
o
e
m
d

getattr()

>>> class A:
		# 设置两个类属性x和y
...     x = 10
...     y = -5
...
>>> a = A()
10
>>> getattr(A, 'x')  # 获取类属性x
10
>>> getattr(a, 'x')  # 获取实例属性x
10
>>> getattr(a, 'z')  # 类实例a没有'z'属性报AttributeError错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'z'
>>> getattr(a, 'z', 2)  # 给属性'z'设置默认值，因为没有'z'所以返回默认值
2

globals()

>>> a = 2
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None,'a': 2}

hasattr()

>>> class B:
...     x = 10
...
>>> hasattr(B, 'x')
True
>>> hasattr(B, 'y')
False

hash()

>>> hash('test')
-1018549955822377378
>>> hash(1)
1
>>> hash(str([1,2,3]))
1465739304648619780

help()

>>> help('sys')  # 查看 sys 模块的帮助
...显示帮助信息...
>>> help('str')  # 查看 str 数据类型的帮助
...显示帮助信息...

hex()

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(12)
'0xc'
>>> type(hex(12))  # 字符串
<class 'str'>

id()

>>> id('str')
3111662336176
>>> id(1)
140708073864256
>>> id([1,2,3])
3111670637512

input()

demo1：单纯获取一个值

>>> a = input('input:')
input:123
>>> type(a)
<class 'str'>

demo2：接收多个值（实际是用str.strip()切分成多个变量）

a, b, c = (input("请输入三角形三边的长：").strip())  # 将输入的三个数字切分，分别赋给a,b,c
a, b, c = int(a), int(b), int(c)  # 将字符串格式的a,b,c转换成整型
p = (a + b + c) / 2  # 计算三角形的半周长p
s = (p * (p - a) * (p - b) * (p - c)) ** 0.5  # 计算三角形的面积s

# 输出三角形的面积
print("三角形的面积是：", format(s, '.2f'))
# 执行结果：
请输入三角形三边的长：345
三角形的面积是： 6.00

int()

>>> int()  # 不传参，得到结果0
0
>>> int(3)
3
>>> int(2.3)
2
>>> int(2.9)  # float只去整数部分，不会四舍五入
2
>>> int('5')
5
>>> int('12', 16)  # base=16,12以字符串的形式输入，12位16进制
18
>>> int('0xa',16)
10
>>> int('10',8)
8

isinstance()

demo1

>>> isinstance(2, int)
True
>>> isinstance('2',(int, str))  # '2'是元组中的一个str，返回True
True
>>> isinstance([], tuple)  # []列表不是tuple，返回False
False

demo2：type()与isinstance()区别

>>> class A:
...     pass
...
>>> class B(A):
...     pass
...
>>> isinstance(A(), A)
True
>>> type(A()) == A
True
>>> isinstance(A(), A)
True
>>> type(B()) == A
False

issubclass()

>>> class A:
...     pass
...
>>> class B(A):
...     pass
...
>>> issubclass(B,A)
True
>>> issubclass(A,B)
False

iter()

>>> for i in iter([1,2,3]):
...     print(i)
...
1
2
3

len()

>>> len([1,2,3,4])  # 列表长度
4
>>> len('str')  # 字符串长度
3

list()

>>> aTuple =(123, 'str', 'str2')
>>> list(aTuple)  # 元组转成列表
[123, 'str', 'str2']
>>> aStr = 'hello world'
>>> list(aStr)  # 字符串转成列表
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

locals()

>>> def func(arg):  # 两个局部变量：arg、z
...     z = 1
...     print(locals())
...
>>> func(5)
{'arg': 5, 'z': 1}  # 返回一个名字/值对的字典

map()

>>> m = map(lambda x: x ** 2, range(1,5))
>>> m
<map object at 0x000002AAC96D1A08>
>>> list(m)
[1, 4, 9, 16]

max()

>>> max(2,5,3)
5
>>> max(2,-5,3)
3
>>> max('b','f','A')  # 字符串
'f'
>>> max([1,2,4,3])  # 列表也可以
4

memoryview()

>>> v = memoryview(bytearray('abc', 'utf-8'))
>>> v[1]
98
>>> v[-1]
99
>>> v[1:4]
<memory at 0x000002AAC966C1C8>
>>> v[1:4].tobytes()
b'bc

min()

>>> min(1,4,2)
1
>>> min(1,-4,2)
-4
>>> min((3,2,-5,4))  # 元组
-5
>>> min('z','b','c')  # 字符串
'b'

next()

it = iter([1,2,3,4,5])  # 首先获得可Iterator对象
while True:
    try:
        x = next(it)  # 获取下一个值
        print(x)
    except StopIteration:
        break
# 执行结果:
1
2
3
4
5

oct()

>>> oct(10)
'0o12'
>>> oct(20)
'0o24'
>>> oct(15)
'0o17'

open()

• 使用该函数一定要保证关闭文件对象，即调用close()函数
• open()函数常用形式是接收两个参数：文件名(file)和模式(mode)
• 完整语法：open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None
  • file: 必需，文件路径（相对或者绝对路径）。
  • mode: 可选，文件打开模式
  • buffering: 设置缓冲
  • encoding: 一般使用utf8
  • errors: 报错级别
  • newline: 区分换行符
  • closefd: 传入的file参数类型
  • mode参数：

模式	描述
t	文本模式(默认)
x	写模式，新建一个文件，如果该文件已存在则会报错
b	二进制模式
+	打开一个文件进行更新(可读可写)
U	通用换行模式(不推荐)
r	只读方式打开文件。文件指针放在文件开头。这是默认模式
rb	二进制格式打开文件用于只读。文件指针放在文件开头。这是默认模式，一般用于非文本文件如图片等
r+	打开一个文件用于读写。文件指针放在文件开头
rb+	二进制格式打开文件用于读写。文件指针放在文件开头。一般用于非文本文件如图片等
w	打开文件只用于写入。如果该文件已存在则打开文件并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
wb	二进制格式打开文件只用于写入。如果该文件已存在则打开文件并从开头开始编辑，即原有内容会被删除，如果该文件不存在，创建新文件。一般用于非文本文件如图片等
w+	打开文件用于读写。如果该文件已存在则打开文件并从开头开始编辑，即原有文件会被删除。如果该文件不存在，创建新文件
wb+	二进制格式打开文件用于读写。如果该文件已存在则打开文件并从开头开始编辑，即原有内容会被删除，如果该文件不存在，创建新文件。一般用于非文本文件如图片等
a	打开文件用于追加，如果该文件已存在，文件指针放在文件结尾，也就是说新内容将会被写入到已有内容之后；如果该文件不存在，则创建新文件进行写入
ab	二进制格式打开文件用于追加。如果该文件已存在，文件指针放在文件结尾，也就是说新内容会被写入到已有内容之后；如果该文件不存在，则创建新文件进行写入
a+	打开文件用于读写，如果该文件已存在，文件指针放在文件结尾。文件打开时会是追加模式；如果文件不存在则创建新文件用于读写
ab+	二进制格式打开文件用于追加。如果该文件已存在，文件指针放在文件结尾；如果该文件不存在则创建新文件用于读写

• 默认为文本模式，如果要以二进制模式打开，加上b

# 正常打开文件
>>> f = open('test.txt')
>>> f.read()
'Hello world!\nhi, Python'
>>> f.close()
# with语句打开（推荐）
>>> with open('test.txt') as f:
...     f.read()
...
'Hello world!\nhi, Python'

ord()

>>> ord('a')
97
>>> ord('$')
36

pow()

• 语法：
  import math
math.pow(x,y)
• 内置的pow()方法：
  pow(x, y[], z)
  函数是计算x的y次方，如果z存在，则再对结果进行取模，其结果等效于pow(x,y)%z。
• 注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而math模型则会把参数转换为float。

>>> import math
>>> pow(2,3)
8
>>> math.pow(2,3)
8.0
>>> pow(2,3)%4
0
>>> math.pow(2,3)%4
0.0
>>> pow(2,3)%3
2
>>> math.pow(2,3)%3
2.0
>>> pow(100,-2)
0.0001
>>> math.pow(100,-2)
0.0001

print()

• 语法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
  • object：复数，表示可以一次输出多个对象。输出多个对象时，需要用,分隔
  • sep：用来间隔多个对象，默认值是一个空格
  • end：用来设定以什么结尾。默认值是换行符\n，可以换成其他字符串
  • file：要写入的文件对象
  • flush：输出是否被缓存通常取决于file，但如果flush关键字参数为True，流会被强制刷新

demo1：正常输出

>>> print(1)
1
>>> print("hello world")
hello world
>>> print("aaa", "bbb")
aaa bbb
>>> print("www", "baidu", "com", sep=".")
www.baidu.com

demo2：使用flush参数生成一个Loading效果

import time

print("---Print Example: Loading 效果---")
print("Loading", end="")
for i in range(20):
    print(".", end="", flush=True)
    time.sleep(0.5)
# 运行结果（Loading后每隔0.5秒生成一个点，生成20个后结束）：
---Print Example: Loading 效果---
Loading....................

property()

• 语法：class property([fget[, fset[, fdel[, doc]]]])
  • fget：获取属性值的函数
  • fset：设置属性值的函数
  • fdel：删除属性值函数
  • doc：属性描述信息

demo1：定义一个可控属性值x

class C(object):
    def __init__(self):
    	# 初始化 _x
        self._x = None

    def getx(self):
    	# 获取 x
        return self._x

    def setx(self, value):
    	# 设置 x
        self._x = value

    def delx(self):
    	# 删除 x
        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

测试：

c = C()

# 获取 c.x
get_x = c.x
print(get_x)  # None

# 设置 c.x并获取
c.x = 5
get_x = c.x
print(get_x)  # 5

# 删除 c.x
del c.x
get_x = c.x
print(get_x)  # AttributeError: 'C' object has no attribute '_x'

将 property 函数用作装饰器

demo2: 只读例子

class Parrot(object):
    def __init__(self):
        self._value = 100

    @property
    def value(self):
        # 获取当前value
        return self._value

demo3：获取、设置、删除（和demo1一样）

# 要注意这些额外函数的名字和property下的一样。例如x
class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        # 获取
        return self._x

    @x.setter
    def x(self, value):
        # 设置
        self._x = value

    @x.deleter
    def x(self):
        # 删除
        del self._x

range()

• 参数说明：
  • start：计数从start开始，默认是从0开始。例如 range(5)等价于 range(0,5)
  • stop：计数到stop结束，但不包括stop。例如 range(0,5) 是 [0,1,2,3,4] 没有5
  • step：步长，默认为1。例如 range(0,5) 等价于 range(0,5,1)

demo1：一个参数

>>> range(5)
range(0, 5)
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(0))
[]

demo2：两个或三个参数

>>> list(range(1,8))
[1, 2, 3, 4, 5, 6, 7]
>>> list(range(1,8,2))
[1, 3, 5, 7]
>>> list(range(1,-8,-2))
[1, -1, -3, -5, -7]

demo3：几个特殊例子

>>> range(1,-8)
range(1, -8)
>>> list(range(-8))  # 默认从0开始向数轴正方向输出，-8为反方向，返回空
[]
>>> list(range(1,-8))  # 1到-8倒序，返回空
[]

repr()

s = ‘flag’
repr(s)
“‘flag’”

dict = {‘name’: ‘Bob’, ‘age’:25}
repr(dict)
“{‘name’: ‘Bob’, ‘age’: 25}”

reversed()

seq_1 = ‘flag’
reversed(seq_1)
<reversed object at 0x000001746E3202C8> # 返回一个迭代器，可用list()转换为列表

list(reversed(seq_1))
[‘g’, ‘a’, ‘l’, ‘f’]

seq_2 = (1,2,3,4,5)
list(reversed(seq_2))
[5, 4, 3, 2, 1]

seq_3 = range(2,7)
tuple(reversed(seq_3))
(6, 5, 4, 3, 2)

round()

round(3.1415926)
3

round(3.5)
4

round(3.575,2)
3.58

round(2.6775,3)
2.678

round(2.675,2)
2.67

• 最后一个例子2.675保留2位小数，结果应该是2.68但却是2.67，是因为跟浮点数精度有关。机器中浮点数不一定能精确表达，换算成一串1和0后可能是无限位的，机器做了截断处理。机器保存的数字2.67比实际数字小，导致它离2.67近一点点，所以保留2位小数就是2.67了。

set()

a = set(‘hello’)
b = set(‘world’)
a,b
({‘o’, ‘l’, ‘h’, ‘e’}, {‘r’, ‘l’, ‘d’, ‘o’, ‘w’}) # a中的重复的被删除

a & b # 交集(都包含的)
{‘o’, ‘l’}

a | b # 并集(两个相加)
{‘h’, ‘r’, ‘l’, ‘e’, ‘d’, ‘o’, ‘w’}

a - b # 差集(a独有的)
{‘h’, ‘e’}

b -a # 差集(b独有的)
{‘r’, ‘d’, ‘w’}

setattr()

class A:
… x = 2
…

a = A()
getattr(a,‘x’)
2

setattr(a,‘x’,4) # 设置实例a的x属性由2变成4
a.x # 获取实例a的x属性
4

setattr(a,‘y’,5) # 设置一个不存在的属性，会创建
a.y
5

slice()

myslice = slice(5)
myslice
slice(None, 5, None)

arr = range(10)
arr
range(0, 10)

list(arr)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

arr[myslice]
range(0, 5)

list(arr[myslice])
[0, 1, 2, 3, 4]

sorted()

• sort 与 sorted 区别：

  • sort 是应用在list上的方法，sorted 可以对所有可迭代的对象进行排序操作
  • list的sort方法返回的是对已经存在的列表进行操作(id不变)，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作(id改变)

• 语法：sorted(iterable, key=None, reverse=False)

  • iterable：可迭代对象
  • key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
  • reverse：排序规则，reserve=True 降序；reverse=False 升序(默认)

demo1：列表的sorted方法排序

sorted([4,2,6,-3,8,-3.5])
[-3.5, -3, 2, 4, 6, 8]

demo2：列表的sort方法排序

>>> a = [4,2,6,-3,8,-3.5]
>>> a.sort()
>>> a
[-3.5, -3, 2, 4, 6, 8]

demo3：sorted对dict的key排序

>>> sorted({1:'D', 2:'B', 3:'B', 4:'E', 5:'A'})
[1, 2, 3, 4, 5]

demo4：sorted利用key进行倒序排序

>>> li = [4,2,6,-3,8,-3.5]
>>> li2 = sorted(li, key=lambda x: x * -1)
>>> li2
[8, 6, 4, 2, -3, -3.5]

demo5: 排序学生成绩

stu_grades = [{'name': 'a', 'grade': 80}, {'name': 'b', 'grade': 86},{'name': 'c', 'grade': 79},{'name': 'd', 'grade': 93}]
new_stu_grades = sorted(stu_grades, key=lambda x: x['grade'])
print(new_stu_grades)
# [{'name': 'c', 'grade': 79}, {'name': 'a', 'grade': 80}, {'name': 'b', 'grade': 86}, {'name': 'd', 'grade': 93}]

demo6：sorted使用reverse反向排序

>>> li = [4,2,6,-3,8,-3.5]
>>> sorted(li, reverse=True)
[8, 6, 4, 2, -3, -3.5]

demo7：list的sort方法和sorted方法比较

# list.sort()
>>> a = [4,2,6,-3,8,-3.5]
>>> a.sort()
>>> a
[-3.5, -3, 2, 4, 6, 8]
# sorted(list)
>>> a = [4,2,6,-3,8,-3.5]
>>> sorted(a)
[-3.5, -3, 2, 4, 6, 8]

• 这两个方法得到的结果是一样的，但list.sort()方法是在list原有数据上修改，返回值为None，内存地址id不变；sorted(list)方法返回的是一个新的列表，内存地址id发生变化
• 通常sort()不如sorted()方便，但如果不需要原始的list，list.sort()方法效率会稍微高一些

sataticmethod()

• 不强制要求传递参数，如下声明一个静态方法
• 声明了静态方法 f, 可以实现实例化使用 C().f()；也可以不实例化调用该方法 C().f()

 class C(object):
    @staticmethod
    def f(arg1, arg2, arg3):
        print('hello')

C().f(2, 3, 4)  # 静态方法无需实例化
# hello

c = C()
c.f(2, 3, 4)  # 静态方法也可以实例化后调用
# hello

str()

>>> str(12)
'12'
>>> str('hello')
'hello'
>>> str([1,2,3])
'[1, 2, 3]'

sum()

>>> sum([1,3,5])
9
>>> sum([1,3,5], 10)  # 计算完1+3+5后，再加10
19

super()

• Python3.x和Python2.x的一个区别是：Python3可以直接使用super().xxx代替super(Class,self).xxx。

demo1：Python3.x实例

class A:
    def add(self, x):
        y = x + 1
        print(y)

class B(A):
    def add(self, x):
        super().add(x)

b = B()
b.add(3)  # 4

demo2：Python2.x实例

class A(object):  # python2要继承object
    def add(self, x):
        y = x + 1
        print(y)

class B(A):
    def add(self, x):
        super(B, self).add(x)

b = B()
b.add(3)  # 4

demo3：python3应用实例

class Parent(object):
    def __init__(self):
        self.parent = 'I\'m the parent'
        print('Parent')

    def bar(self, message):
        print('%s from Parent' % message)

class Child(Parent):
    def __init__(self):
        super().__init__()  # 调用父类init方法，打印 'Parent'
        print('Child')

    def bar(self, message):
        super().bar(message)
        print('Child bar function')
        print(self.parent)


if __name__ == '__main__':
    Child = Child()  # 打印 'Parent' 和 'Child'
    Child.bar('Hello world')

# 执行结果：
'''
Parent
Child
Hello world from Parent
Child bar function
I'm the parent
'''

• Child.bar(‘Hello world’)解析：
  • 调用Child的bar()方法，传递message参数：‘Hello world’
  • super().bar(message)：调用父类bar()方法，打印 ‘Hello world from Parent’
  • print('Child bar function')：打印 ‘Child bar function’
  • print(self.parent)：子类本身没有parent，去父类里找，在父类__init__()方法中self.parent为’I’m the parent’，print该变量，则打印’I’m the parent’

tuple()

>>> li = ['Baidu','Google', 'Taobao']
>>> tu = tuple(li)
>>> tu
('Baidu', 'Google', 'Taobao')

type()

• isinstance() 和type() 区别：
  • type() 不会认为子类是一种父类类型，不考虑继承关系
  • isinstance() 会认为子类是一种父类类型，考虑继承关系
  • 如果要判断两个类型是否相同推荐使用 isinstance()。

demo1：一个参数

>>> type(1)
<class 'int'>
>>> type('abc')
<class 'str'>
>>> type([1,2,3])
<class 'list'>
>>> type(1) == int
True

demo2：三个参数

>>> class X(object):
...     a = 10
...
>>> X = type('X', (object,), dict(a=1))  # TypeError: 'dict' object is not callable
>>> X
<class '__main__.X'>

demo3：isinstance() 和 type() 区别

>>> class A:
...     pass
...
>>> class B(A):
...     pass
...
>>> isinstance(A(), A)
True
>>> type(A()) == A
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

vars()

>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>> class A:
...     a = 1
...
>>> vars(A)
mappingproxy({'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None})
>>> a = A()
>>> vars(a)
{}

zip()

• zip()方法在py2和py3中的不同：在py2.x中zip()返回的是一个列表

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)  # 返回一个对象
>>> zipped
<zip object at 0x000001746E320C88>
>>> list(zipped)  # 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))  # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b))  # 与zip相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

__import__

import os
import sys
from django import http