函数 功能 abs 返回输入参数的绝对值 max 返回输入参数的最大值 min 返回输入参数的最小值 pow 返回两个数值的幂运算 sum 返回输入参数的和 round 返回输入参数（浮点数）四舍五入 divmod 返回输入参数的商和余数
abs：返回输入参数的绝对值 >>> abs(-1)
1
max：返回输入参数的最大值 >>> max(-1,1,3,5,7)
7
>>> max('1357')
7
min：返回输入参数的最小值 >>> min(-3,-1,1,3,5,7)
-1
>>> min('1357')
1
pow：返回两个数值的幂运算 >>> pow(2,3)
8
>>> pow(-2,3)
-8
>>> pow(2,3,5) == pow(2,3)%5
3
sum：返回输入参数的和 >>> sum(1,2,3,4)
10
>>> sum(1.0,2.0,3.0,4.0)
10.0
>>> sum((1,2,3),-4)
2
round：返回输入参数（浮点数）四舍五入 >>> round(1.23456,3)
1.234
>>> round(1.23456,4)
1.2346
divmod：返回输入参数的商和余数 >>> divmod(10,3)
(3,1)
>>> divmod(10,3.3)
(3.0,0.1)
函数 功能 int 将输入参数转换为整数形式 float 将输入参数转换为浮点数形式 complex 将输入参数转换为复数形式 bool 输出输入参数的布尔值 str 将输入参数转换为字符串形式 ord 返回Unicode编码的整数 chr 输入整数返回所代表的Unicode编码 bin 整数转二进制字符串 oct 整数转八进制字符串 hex 整数转十六进制字符串 list 将输入参数转换为列表形式 dict 将输入参数转换为字典形式 tuple 将输入参数转化为元组形式 set 将输入参数转化为可变集合 frozenset 将输入参数转化为不可变集合 bytearray 将输入参数转化为字节数组 bytes 将输入参数转化为不可变字节数组 memoryview 将输入参数转化为内存查看对象 enumerate 将输入参数转化为枚举对象 range 将输入参数转化为range对象 iter 将输入参数转化为可迭代对象 slice 将输入参数转化为切片对象 super 将输入参数转化为子类和父类关系的代理对象 object 将输入参数转化为object对象
int：整数 >>> int()
0
>>> int(5)
5
>>> int(1.5)
1
float：浮点数 >>> float()
0.0
>>> float(1.5)
1.5
>>> float(8)
8.0
>>> float('4')
4
complex：复数 >>> complex()
0j
>>> complex(1,5)
1+5j
>>> complex('1+5j')
1+5j
bool：布尔型 >>> bool(0)
False
>>> bool()
False
>>> bool(1)
True
str：字符串 >>> str()
''
>>> str(1015)
'1015'
>>> str(acd)
'acd'
ord：返回Unicode编码的整数 >>> ord('a')
97
chr：输入整数返回所代表的Unicode编码 >>> chr(97')
a
bin：整数转二进制字符串 >>> bin(2)
'0b10'
oct：整数转八进制字符串 >>> oct(4)
'0o4'
hex：整数转十六进制字符串 >>> hex(8)
'0x8'
list：列表 >>> list()
[]
>>> list('1234')
['1', '2', '3', '4']
>>> list('acdf')
['a', 'c', 'd', 'f']
dict：字典 >>> dict()
{}
>>> dict(b = 1,j = 0)
{'b': 1,'j': 0}
>>> dict((('b',1),('j',0)))
{'b': 1, 'j': 0}
>>> dict(zip(['b','j'],[1,0]))
{'b': 1,'j': 0}
tuple：元组 >>> tuple()
>()
>>> tuple('1234')
>('1', '2', '3', '4')
set：可变集合 >>> set()
set()
>>> set('123')
{'1', '2', '3'}
>>> set(range(5))
{0, 1, 2, 3, 4}
frozenset：不可变集合 >>> frozenset()
frozenset()
>>> frozenset('123')
frozenset('123')
>>> frozenset(range(5))
>frozenset({0, 1, 2, 3, 4})
bytearray：字节数组 >>> bytearray()
bytearray(b'')
>>> bytearry(8)
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00')
>>> bytearray('中国','utf-8')
bytearray(b'\xe4\xb8\xad\xe5\x9b\xbd')
>>> bytearray([3,4,5])
bytearray(b'\x03\x04\x05')
bytes：不可变字节数组 >>> bytes()
b''
>>> ytes(8)
b'\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes('中国','utf-8')
b'\xe4\xb8\xad\xe5\x9b\xbd
>>> bytes([3,4,5])
b'\x03\x04\x05'
memoryview：内存查看对象 >>> memoryview(bytearray())
memory at 0x000000000573EC48
enumerate：枚举对象 >>> enumerate(bytearray())
enumerate at 0x5784ca8
range：range对象 >>> range(10)
range(0, 10)
>>> range(1, 10)
range(1, 10)
>>> range(1, 10, 3)
range(1, 10, 3)
iter：可迭代对象 >>> iter('acbd')
str_iterator at 0x5783940
>>> iter('123')
str_iterator at 0x578b198
slice：切片对象 >>> slice(1)
slice(None, 1, None)
>>> slice(3, 1)
slice(2, 1, None)
>>> slice(3, 1, 2)
slice(3, 1, 2)
super：子类和父类关系的代理对象 #定义父类A
>>> class A(object):
def __init__(self):
print('A.__init__')
#定义子类B，继承A
>>> class B(A):
def __init__(self):
print('B.__init__')
super().__init__()
#super调用父类方法
>>> b = B()
B.__init__
A.__init__
object：object对象 >>> object()
object at 0x511b2c0
>>> a = object()
>>> a.name = 'kim' # 不能设置属性
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
a.name = 'kim'
AttributeError: 'object' object has no attribute 'name'
函数 功能 all 判断可迭代对象的每个元素是否都为True值 any 判断可迭代对象的每个元素是否都为True值 filter 使用指定方法过滤可迭代对象的元素 map 使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象 next 返回可迭代对象中的下一个元素值 reversed 反转序列生成新的可迭代对象 sorted 对可迭代对象进行排序，返回一个新的列表 zip 聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
all：判断可迭代对象的每个元素是否都为True值 >>> all([0, 1, 2])
False
>>> all([1,2])
True
any：判断可迭代对象的每个元素是否都为True值 >>> any([0, 1, 2])
True
>>> any([0, 0])
False
filter：使用指定方法过滤可迭代对象的元素 >>> a = list(range(1,10)) #定义序列
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> def if_odd(x): #定义奇数判断函数
return x%2==1
>>> list(filter(if_odd,a)) #筛选序列中的奇数
[1, 3, 5, 7, 9]
map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象 >>> a = map(ord,'adf')
>>> list(a)
[97, 100, 102]
next：返回可迭代对象中的下一个元素值 >>> a = iter('acd')
>>> next(a)
a
>>> next(a)
b
>>> next(a)
d
>>> next(a)
报错
reversed：反转序列生成新的可迭代对象 >>> a = range(10)
>>> reversed(a)
range_iterator at 0x5585790
>>> list(reversed(a))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
sorted：对可迭代对象进行排序，返回一个新的列表 >>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']
>>> sorted(a) # 默认按字符ascii码排序
['A', 'B', 'a', 'b', 'c', 'd']
>>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
['a', 'A', 'b', 'B', 'c', 'd']
zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器 >>> x = [1,2,3] #长度3
>>> y = [4,5,6,7,8] #长度5
>>> list(zip(x,y)) # 取最小长度3
[(1, 4), (2, 5), (3, 6)]
函数 功能 help 返回对象的帮助信息 dir 返回对象或者当前作用域内的属性列表 id 返回对象的唯一标识符 hash 获取对象的哈希值 type 返回对象的类型，或者根据传入的参数创建一个新的类型 len 返回对象的长度 ascii 返回对象的可打印表字符串表现方式 format 格式化显示值 vars 返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
help：返回对象的帮助信息 >>> import math
>>> help(math)
Help on built-in module math:
NAME
math
DESCRIPTION
This module is always available. It provides access to the
mathematical functions defined by the C standard.
FUNCTIONS
........
dir ： 返回对象或者当前作用域内的属性列表 >>> import math
>>> dir(math)
['__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'acos',
'acosh',
'asin',
......
id：返回对象的唯一标识符 >>> a = 'lyf'
>>> id(a)
44659296
hash：获取对象的哈希值 >>> hash('lyf')
-7551145293359038215
type：返回对象的类型，或者根据传入的参数创建一个新的类型 >>> type(123)
int
#使用type函数创建类型D，含有属性InfoD
>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))
>>> d = D()
>>> d.InfoD
'some thing defined in D'
len：返回对象的长度 >>> len('acdfr')
5
>>> len(1, 3, 5, 7, 9, 3)
6
ascii：返回对象的可打印表字符串表现方式 >>> ascii(1)
'1'
>>> ascii('%')
"'%'"
>>> ascii(9000)
'9000'
format：格式化显示值 #字符串可以提供的参数 's' None
>>> format('some string','s')
'some string'
>>> format('some string')
'some string'
#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'
#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母
'INF'
vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表 #作用于类实例
>>> class A(object):
pass
>>> a.__dict__
{}
>>> vars(a)
{}
>>> a.name = 'Kim'
>>> a.__dict__
{'name': 'Kim'}
>>> vars(a)
{'name': 'Kim'}
函数 功能 import 动态导入模块 isinstance 判断对象是否是类或者类型元组中任意类元素的实例 issubclass 判断类是否是另外一个类或者类型元组中任意类元素的子类 hasattr 检查对象是否含有属性 getattr 获取对象的属性值 setattr 设置对象的属性值 delattr 删除对象的属性 callable 检测对象是否可被调用
import ：动态导入模块index = __import__('index')
index.sayHello()
isinstance：判断对象是否是类或者类型元组中任意类元素的实例 >>> isinstance(1,int)
True
>>> isinstance(1,str)
False
>>> isinstance(1,(int,str))
True
issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类 >>> issubclass(bool,int)
True
>>> issubclass(bool,str)
False
>>> issubclass(bool,(str,int))
True
hasattr：检查对象是否含有属性 #定义类A
>>> class Student:
def __init__(self,name):
self.name = name
>>> s = Student('Aim')
>>> hasattr(s,'name') #a含有name属性
True
>>> hasattr(s,'age') #a不含有age属性
False
getattr：获取对象的属性值 #定义类Student
>>> class Student:
def __init__(self,name):
self.name = name
>>> getattr(s,'name') #存在属性name
'Aim'
setattr：设置对象的属性值 >>> class Student:
def __init__(self,name):
self.name = name
>>> a = Student('Kim')
>>> a.name
'Kim'
>>> setattr(a,'name','Bob')
>>> a.name
'Bob'
delattr：删除对象的属性 #定义类A
>>> class A:
def __init__(self,name):
self.name = name
def sayHello(self):
print('hello',self.name)
#测试属性和方法
>>> a.name
'小麦'
>>> a.sayHello()
hello 小麦
#删除属性
>>> delattr(a,'name')
>>> a.name
Traceback (most recent call last):
File "<pyshell#47>", line 1, in <module>
a.name
AttributeError: 'A' object has no attribute 'name'
callable：检测对象是否可被调用 >>> class B: #定义类B
def __call__(self):
print('instances are callable now.')
>>> callable(B) #类B是可调用对象
True
>>> b = B() #调用类B
>>> callable(b) #实例b是可调用对象
True
>>> b() #调用实例b成功
instances are callable now.
函数 功能 globals 返回当前作用域内的全局变量和其值组成的字典 locals 返回当前作用域内的局部变量和其值组成的字典
globals：返回当前作用域内的全局变量和其值组成的字典 >>> globals()
{'In': ['', 'global()', 'globals()'],
'Out': {},
'_': '',
'__': '',
'___': '',
'__builtin__': <module 'builtins' (built-in)>,
'__builtins__': <module 'builtins' (built-in)>,
'__doc__': 'Automatically created module for IPython interactive environment',
'__loader__': None,
'__name__': '__main__',
...... }
locals：返回当前作用域内的局部变量和其值组成的字典 >>> def f():
print('before define a ')
print(locals()) #作用域内无变量
a = 1
print('after define a')
print(locals()) #作用域内有一个a变量，值为1
>>> f
<function f at 0x03D40588>
>>> f()
before define a
{}
after define a
{'a': 1}
函数 功能 print 向标准输出对象打印输出 input 读取用户输入值
print：向标准输出对象打印输出 >>> print(1,2,3)
1 2 3
>>> print(1,2,3,sep = '+')
1+2+3
>>> print(1,2,3,sep = '+',end = '=?')
1+2+3=?
input：读取用户输入值 >>> s = input('please input your name:')
please input your name:Ain
>>> s
'Ain
函数 功能 open 使用指定的模式和编码打开文件，返回文件读写对象
open：使用指定的模式和编码打开文件，返回文件读写对象 >>> a = open('test.txt','rt') #t为文本读写，b为二进制读写
>>> a.read()
'some text'
>>> a.close()
函数 功能 compile 将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译 eval 执行动态表达式求值 exec 执行动态语句块 repr 返回一个对象的字符串表现形式(给解释器)
compile：将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译 >>> code2 = '1 + 2 + 3 + 4'
>>> compile2 = compile(code2,'','eval')
>>> eval(compile2)
10
eval：执行动态表达式求值 >>> eval('1+2+3+4')
10
exec：执行动态语句块 >>> exec('a=1+2') #执行语句
>>> a
3
repr：返回一个对象的字符串表现形式(给解释器) >>> a = 'some text'
>>> str(a)
'some text'
>>> repr(a)
"'some text'"
property 标示属性的装饰器 classmethod 标示方法为类方法的装饰器
property：标示属性的装饰器 >>> class C:
def __init__(self):
self._name = ''
@property
def name(self):
"""i'm the 'name' property."""
return self._name
@name.setter
def name(self,value):
if value is None:
raise RuntimeError('name can not be None')
else:
self._name = value
>>> c = C()
>>> c.name # 访问属性
''
>>> c.name = None # 设置属性时进行验证
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
c.name = None
File "<pyshell#81>", line 11, in name
raise RuntimeError('name can not be None')
RuntimeError: name can not be None
>>> c.name = 'Kim' # 设置属性
>>> c.name # 访问属性
'Kim'
>>> del c.name # 删除属性，不提供deleter则不能删除
Traceback (most recent call last):
File "<pyshell#87>", line 1, in <module>
del c.name
AttributeError: can't delete attribute
>>> c.name
'Kim'
classmethod：标示方法为类方法的装饰器 >>> class C:
@classmethod
def f(cls,arg1):
print(cls)
print(arg1)
>>> C.f('类对象调用类方法')
<class '__main__.C'>
类对象调用类方法
>>> c = C()
>>> c.f('类实例对象调用类方法')
<class '__main__.C'>
类实例对象调用类方法
staticmethod：标示方法为静态方法的装饰器 # 使用装饰器定义静态方法
>>> class Student(object):
def __init__(self,name):
self.name = name
@staticmethod
def sayHello(lang):
print(lang)
if lang == 'en':
print('Welcome!')
else:
print('你好！')
>>> Student.sayHello('en') #类调用,'en'传给了lang参数
en
Welcome!
>>> b = Student('Kim')
>>> b.sayHello('zh') #类实例对象调用,'zh'传给了lang参数
zh
你好
https://blog.youkuaiyun.com/oaa608868/article/details/53506188 https://www.cnblogs.com/xiao1/p/5856890.html
本文详细介绍了Python的内置函数，涵盖数学运算、类型转换、序列操作等多个类别。数学运算函数如abs、max等；类型转换有int、float等；还介绍了序列操作、对象操作、反射操作等各类函数，为Python开发者提供了全面的函数参考。
扫一扫
1166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
