Python 内置函数功能汇总

最新推荐文章于 2024-05-09 06:01:25 发布

苏悦迪

最新推荐文章于 2024-05-09 06:01:25 发布

阅读量397

点赞数 1

分类专栏： Python

Python 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

转自：https://blog.csdn.net/oaa608868/article/details/53506188

内置函数简介

内置函数（BIF，built-in functions）是Python内置对象类型之一，不需要额外导入任何模块即可直接使用，这些内置对象都封装在内置模块builtins之中，用C语言实现并且进行了大量优化，具有非常快的运行速度，推荐优先使用。

内置函数用法

一. 数学运算（7个）

1.abs( ) 获取绝对值

函数	返回结果
abs(-2)	2
abs(0)	0

2.divmod：返回两个数值的商和余数

函数	返回结果
divmod(10,3)	(3,1)
divmod(5.5,2)	(2.0,1.5)
divmod(5,-2)	(-3,1)

3. max：返回可迭代对象中的元素中的最大值或者所有参数的最大值

函数	返回结果
max(-1,0)	0
max(‘1234’)	‘4’
max(-1,-2,key = abs)	-2

4. min：返回可迭代对象中的元素中的最小值或者所有参数的最小值

函数	返回结果
min(-1,0)	-1
min(‘1234’)	‘1’
min(-1,-2,key = abs)	-1

5. pow：返回两个数值的幂运算值或其与指定整数的模值

函数	返回结果
pow(2,3)	8
pow(2,3,5)	3(即2 ** 3 % 5）

6. round：对浮点数进行四舍五入求值

函数	返回结果
round(1.1314926,5)	1.13149
round(123.45,-2)	100.0(即在十位四舍五入）

7. sum：对元素类型是数值的可迭代对象中的每个元素求和

函数	返回结果
sum((1,2,3,4),-10))	0（可迭代，但元素必须是数值型）

二、类型转换（24个）

1.bool：根据传入的参数的逻辑值创建一个新的布尔值

函数	返回结果
bool()	False
bool(0)	False
bool(1)	True(参数不为数值0和空序列，值为真）
bool(2)	True

2.int：根据传入的参数创建一个新的整数

函数	返回结果
int()	0
int(3)	3
int(3.6)	3

3.float：根据传入的参数创建一个新的浮点数

函数	返回结果
float()	0.0
float(3)	3.0
float(‘3’)	3.0

4.complex：根据传入参数创建一个新的复数

函数	返回结果
complex()	0j
complex(‘1+2j’)	(1+2j)
complex(1,2)	(1+2j)

5.str：返回一个对象的字符串表现形式(给用户)

示例：str(None)
‘None’

6.bytearray：根据传入的参数创建一个新的字节数组

示例：bytearray('中文','utf-8')
bytearray(b’\xe4\xb8\xad\xe6\x96\x87’)

7.bytes：根据传入的参数创建一个新的不可变字节数组

示例：bytes('中文','utf-8')
b’\xe4\xb8\xad\xe6\x96\x87’

8.memoryview：根据传入的参数创建一个新的内存查看对象

示例：v = memoryview(b'abcefg')'
v[1]
98
v[-1]
103

9.ord：返回Unicode字符对应的整数

示例：ord('a')
97

10.chr：返回整数所对应的Unicode字符

示例：chr(97)
‘a’

11.bin：将整数转换成2进制字符串

示例：bin(3)
‘0b11’

12.oct：将整数转化成8进制数字符串

示例：oct(10)
‘0o12’

13.hex：将整数转换成16进制字符串

示例：hex(15)
‘0xf’

14.tuple：根据传入的参数创建一个新的元组

示例：tuple('121')
(‘1’, ‘2’, ‘1’)

15.list：根据传入的参数创建一个新的列表

示例：list('abcd')
[‘a’, ‘b’, ‘c’, ‘d’]

16.dict：根据传入的参数创建一个新的字典

示例：dict(a = 1,b = 2)
{‘b’: 2, ‘a’: 1}

17.set：根据传入的参数创建一个新的集合

示例：set(range(10))
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

18.frozenset：根据传入的参数创建一个新的不可变集合

示例：frozenset(range(10))
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

19.enumerate：根据可迭代对象创建枚举对象

示例：seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
[(0, ‘Spring’), (1, ‘Summer’), (2, ‘Fall’), (3, ‘Winter’)]
list(enumerate(seasons, start=1))#指定起始值
[(1, ‘Spring’), (2, ‘Summer’), (3, ‘Fall’), (4, ‘Winter’)]

20.range：根据传入的参数创建一个新的range对象

a = range(10)
b = range(1,10)
c = range(1,10,3)
a,b,c
(range(0, 10), range(1, 10), range(1, 10, 3))
list(a),list(b),list(c)
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

21.iter：根据传入的参数创建一个新的可迭代对象

a = iter('abcd')
a
<str_iterator object at 0x03FB4FB0>
next(a)
‘a’
next(a)
‘b’
next(a)
‘c’
next(a)
‘d’
next(a)
Traceback (most recent call last):
File “<pyshell#29>”, line 1, in
next(a)
StopIteration

22.slice：根据传入的参数创建一个新的切片对象

slice(5)
slice(None, 5, None)
slice(2,5)
slice(2, 5, None)
slice(1,10,3)
slice(1, 10, 3)

23.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

24.object：创建一个新的object对象

a = object()
a.name = 'kim'
Traceback (most recent call last):
File “<pyshell#9>”, line 1, in
a.name = ‘kim’
AttributeError: ‘object’ object has no attribute ‘name’

三、序列操作（8个）

1.all：判断可迭代对象的每个元素是否都为True值

2.any：判断可迭代对象的元素是否有为True值的元素

3.filter：使用指定方法过滤可迭代对象的元素

4.map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

5.next：返回可迭代对象中的下一个元素值

6.reversed：反转序列生成新的可迭代对象

7.sorted：对可迭代对象进行排序，返回一个新的列表

8.zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

四、对象操作（7个）

1.help：返回对象的帮助信息

2.dir：返回对象或者当前作用域内的属性列表

3.id：返回对象的唯一标识符

4.hash：获取对象的哈希值

5.type：返回对象的类型，或者根据传入的参数创建一个新的类型

6.len：返回对象的长度

7.ascii：返回对象的可打印表字符串表现方式

8.format：格式化显示值

9.vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

五、反射操作（8个）

1.import：动态导入模块

2.isinstance：判断对象是否是类或者类型元组中任意类元素的实例

3.issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类

4.hasattr：检查对象是否含有属性

5.getattr：获取对象的属性值

6.setattr：设置对象的属性值

7.delattr：删除对象的属性

8.callable：检测对象是否可被调用

六、变量操作（2个）

1.globals：返回当前作用域内的全局变量和其值组成的字典

2.locals：返回当前作用域内的局部变量和其值组成的字典

七、交互操作（2个）

1.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=?

2.input：读取用户输入值

s = input('please input your name:')
please input your name:Ain
s
‘Ain’

八、文件操作（1个）

1.open：使用指定的模式和编码打开文件，返回文件读写对象

#t为文本读写，b为二进制读写
a = open('test.txt','rt')
a.read()
‘some text’
a.close()

九、编译执行（4个）

1.compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)
0
1
2
3
4
5
6
7
8
9

2.eval：执行动态表达式求值

示例：eval('1+2+3+4')
10

3.exec：执行动态语句块

示例：exec('1+2')
3

4.repr：返回一个对象的字符串表现形式(给解释器)

a = 'some text'
str(a)
‘some text’
repr(a)
“‘some text’”

十、装饰器（3个）

1.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'

2.classmethod：标示方法为类方法的装饰器

>>> class C:
    @classmethod
    def f(cls,arg1):
        print(cls)
        print(arg1)
>>> C.f('类对象调用类方法')
<class '__main__.C'>
类对象调用类方法
>>> c = C()
>>> c.f('类实例对象调用类方法')
<class '__main__.C'>
类实例对象调用类方法

3.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
你好

苏悦迪

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python 内置函数功能汇总

转自：https://blog.csdn.net/oaa608868/article/details/53506188内置函数简介内置函数（BIF，built-in functions）是Python内置对象类型之一，不需要额外导入任何模块即可直接使用，这些内置对象都封装在内置模块builtins之中，用C语言实现并且进行了大量优化，具有非常快的运行速度，推荐优先使用。内置函数用法一. ...
复制链接

扫一扫

专栏目录