本文我们主要讲解和整理Python3.8中的68个内置函数,并将它们进行归类,它们的分类如下图所示:

下面我来依次讲解

1.交互操作函数

1.1 print:向标准输出对象打印输出

下面演示一下它的用法

print("我见青山多妩媚", "料青山见我应如是")
print("我见青山多妩媚", "料青山见我应如是", sep=",")
print("我见青山多妩媚", "料青山见我应如是", sep=",", end="。")
"""
我见青山多妩媚 料青山见我应如是
我见青山多妩媚,料青山见我应如是
我见青山多妩媚,料青山见我应如是。
"""

sep:表示多个参数输出的连接字符,默认为空格
end:表示输出结束字符

1.2 input:读取用户输入值

下面演示一下它的用法

print("上联:鱼跃此时海")
val = input("输入下联:")
print("下联:", val)
"""
上联:鱼跃此时海
输入下联:花开彼岸天
下联:花开彼岸天
"""

2.变量操作函数

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

下面演示一下它的用法

print(globals())
addVar = "我是新来的"
print(globals())
print(globals()["addVar"])

执行程序关注一下输出,我们会发现第二次输出的时候在结尾新增了一个addVar变量,最后可以通过字典取值的方式获取指定变量值

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

下面演示一下它的用法

def func():
    print("方法作用域新增变量前:", locals())
    loc_var = "我是方法变量"
    print("方法作用域新增变量后:", locals())
    return


func()
print("全局作用域:", locals())

"""
方法作用域新增变量前: {}
方法作用域新增变量后: {'loc_var': '我是方法变量'}
全局作用域: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000271B2730910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/PycharmProjects/HelloWorld/Hello.py', '__cached__': None, 'func': <function func at 0x00000271B43FA280>}
"""

3.反射操作函数

3.1 import:动态导入模板

下面演示他的用法

# Index.py
def func():
    print("方法作用域新增变量前:", locals())
    loc_var = "我是方法变量"
    print("方法作用域新增变量后:", locals())
    return

# Hello.py
index = __import__("Index")
index.func()

"""
方法作用域新增变量前: {}
方法作用域新增变量后: {'locVar': '我是方法变量'}
"""

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

下面演示一下它的用法

print(isinstance(1, int))
print(isinstance("str", int))
print(isinstance("str", (int, str)))

"""
True
False
True
"""

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

下面演示一下它的用法

print(issubclass(bool, int))
print(issubclass(bool, str))
print(issubclass(bool, (str, int)))

"""
True
False
True
"""

3.4 hasattr和delattr:检查对象是否含有属性与删除对象属性

下面演示它们的用法

class Human:
    def __init__(self, name):
        self.name = name


s = Human('Naaman')
print(hasattr(s, 'name'))
print(hasattr(s, 'age'))
delattr(s, "name")
print("删除属性后:")
print(hasattr(s, 'name'))

"""
True
False
删除属性后:
False
"""

3.5 getattr和setattr:获取和设置对象属性值

下面演示它们的用法

class Human:
    def __init__(self, name):
        self.name = name


s = Human('Naaman')
print("修改前:", getattr(s, "name"))
setattr(s, 'name', "Jim")
print("修改后:", getattr(s, "name"))

"""
修改前: Naaman
修改后: Jim
"""

3.6 callable:检测对象是否可被调用

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

print(callable(0))


def add(a, b):
    return a + b


print(callable(add))


class A:
    def method(self):
        return 0


print(callable(A))
a = A()
print(callable(a))


class B:
    def __call__(self):
        return 0


print(callable(B))
b = B()
print(callable(b))
"""
False
True
True
False
True
True
"""

5.装饰器操作函数

5.1 property:标示属性的装饰器

将 property 函数用作装饰器可以很方便的创建只读属性:

class Parrot(object):
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage


p = Parrot()
p.voltage = 10
"""
Traceback (most recent call last):
  File "D:/PycharmProjects/HelloWorld/Hello.py", line 12, in <module>
    p.voltage = 10
AttributeError: can't set attribute
"""

property 的 getter,setter 和 deleter 方法同样可以用作装饰器:

class Parrot(object):
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

    @voltage.setter
    def voltage(self, value):
        self._voltage = value

    @voltage.deleter
    def voltage(self):
        del self._voltage

5.2 classmethod:标示方法为类方法的装饰器

下面来演示一下它的用法

class C:
    @classmethod
    def f(cls, arg1):
        print(cls)
        print(arg1)


C.f('类对象调用类方法')
c = C()
c.f('类实例对象调用类方法')
"""
<class '__main__.C'>
类对象调用类方法
<class '__main__.C'>
类实例对象调用类方法
"""

5.3 staticmethod:标示方法为静态方法的装饰器

下面来演示它的用法

class Student(object):
    def __init__(self, name):
        self.name = name

    @staticmethod
    def say(lang):
        print(lang)
        if lang == 'en':
            print('Welcome!')
        else:
            print('你好!')


Student.say('en')
b = Student('Kim')
b.say('zh')

"""
en
Welcome!
zh
你好!
"""

6.对象操作函数

6.1 help:返回对象的帮助信息

使用很简单,比如help(int)

6.2 dir:返回对象或者当前作用域内的属性列表

同样使用很简单,比如dir(str)

6.3 id:返回对象的唯一标识符

比如

a = 'some text'
print(id(a))

"""
2077429959536
"""

6.4 hash:获取对象的哈希值

使用也很简单,比如hash('xuetang9')

6.5 type:返回对象类型或者根据传入的参数创建一个新的类型

下面来演示一下

# 返回对象的类型
print(type(1))
# 使用type函数创建类型D,含有属性InfoD
D = type('D',(), dict(InfoD='some thing defined in D'))
d = D()
print(d.InfoD)

"""
<class 'int'>
some thing defined in D
"""

6.5 len:返回对象长度

见下面示例

print(len('abcd'))  # 字符串
print(len(bytes('abcd', 'utf-8')))  # 字节数组
print(len((1, 2, 3, 4)))  # 元组
print(len([1, 2, 3, 4]))  # 列表
print(len(range(1, 5)))  # range对象
print(len({'a': 1, 'b': 2, 'c': 3, 'd': 4}))  # 字典
print(len({'a', 'b', 'c', 'd'}))  # 集合
print(len(frozenset('abcd')))  # 不可变集合

6.6 ascii:返回对象的可打印表字符串表现方式

比如

print(ascii(9000000))
print(ascii('中文'))

"""
9000000
'\u4e2d\u6587'
"""

6.7 format:格式化显示值

下面列举一下常见使用方式

# 字符串可以提供的参数 's' None
format('some string', 's')
format('some string')
# 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
format(3, 'b')  # 转换成二进制
format(97, 'c')  # 转换unicode成字符
format(11, 'd')  # 转换成10进制
format(11, 'o')  # 转换成8进制
format(11, 'x')  # 转换成16进制 小写字母表示
format(11, 'X')  # 转换成16进制 大写字母表示
format(11, 'n')  # 和d一样
format(11)  # 默认和d一样
# 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
format(314159267, 'e')  # 科学计数法,默认保留6位小数
format(314159267, '0.2e')  # 科学计数法,指定保留2位小数
format(314159267, '0.2E')  # 科学计数法,指定保留2位小数,采用大写E表示
format(314159267, 'f')  # 小数点计数法,默认保留6位小数
format(3.14159267000, 'f')  # 小数点计数法,默认保留6位小数
format(3.14159267000, '0.8f')  # 小数点计数法,指定保留8位小数
format(3.14159267000, '0.10f')  # 小数点计数法,指定保留10位小数
format(3.14e+1000000, 'F')  # 小数点计数法,无穷大转换成大小字母
# g的格式化比较特殊,假设p为格式中指定的保留小数位数,先尝试采用科学计数法格式化,得到幂指数exp,如果-4<=exp<p,则采用小数计数法,并保留p-1-exp位小数,否则按小数计数法计数,并按p-1保留小数位数
format(0.00003141566, '.1g')  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点
format(0.00003141566, '.2g')  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留1位小数点
format(0.00003141566, '.3g')  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留2位小数点
format(0.00003141566, '.3G')  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点,E使用大写
format(3.1415926777, '.1g')  # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留0位小数点
format(3.1415926777, '.2g')  # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留1位小数点
format(3.1415926777, '.3g')  # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留2位小数点
format(0.00003141566, '.1n')  # 和g相同
format(0.00003141566, '.3n')  # 和g相同
format(0.00003141566)  # 和g相同

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

比如

# 作用于类实例
class A(object):
    pass


ai = A()
print(vars(ai))
ai.name = 'Kim'
print(vars(ai))
"""
{}
{'name': 'Kim'}
"""

7.数学运算操作函数

7.1 abs:求数字的绝对值

使用很简单,比如abs(-1)

7.2 divmod:返回两个数值的商和余数

比如

print(divmod(5, 2))
print(divmod(5.5, 2))
"""
(2, 1)
(2.0, 1.5)
"""

7.3 max:返回可迭代对象中的元素中的最大值或所有参数的最大值

比如

print(max(1, 2, 3))  # 传入3个参数 取3个中较大者
print(max('1234'))  # 传入1个可迭代对象,取其最大元素值
print(max(-1, 0))  # 数值默认去数值较大者
print(max(-1, 0, key=abs))  # 传入了求绝对值函数,则参数都会进行求绝对值后再取较大者

"""
3
4
0
-1
"""

7.4 min:返回可迭代对象中的元素中的最小值或所有参数的最小值

比如

print(min(1, 2, 3))  # 传入3个参数 取3个中较小者
print(min('1234'))  # 传入1个可迭代对象,取其最小元素值
print(min(-1, 0))  # 数值默认去数值较小者
print(min(-1, 0, key=abs))  # 传入了求绝对值函数,则参数都会进行求绝对值后再取较小者

"""
1
1
-1
0
"""

7.5 pow:返回两个数值的幂运算值或其与指定整数的摸值

比如

print(pow(2, 3))
print(pow(2, 3, 5))  # 等价于pow(2, 3) % 5

"""
8
3
"""

7.6 round:对浮点数进行四舍五入求值

比如

print(round(1.1314926, 1))
print(round(1.1314926, 5))

"""
1.1
1.13149
"""

其中第2个参数表示保留小数位数

7.7 sum:对元素类型是数值的可迭代对象中的每个元素求和

比如

# 传入可迭代对象
print(sum((1, 2, 3, 4)))
# 元素类型必须是数值型
print(sum((1.5, 2.5, 3.5, 4.5)))
print(sum((1, 2, 3, 4), -10))

"""
10
12.0
0
"""

8.类型转换函数

下面通过示例说明

# bool:根据传入的参数的逻辑值创建一个新的布尔值
print(bool())  # 未传入参数
print(bool(0))  # 数值0、空序列等值为False
print(bool(1))
"""
False
False
True
"""

# int:根据传入的参数创建一个新的整数
print(int())  # 不传入参数时,得到结果0。
print(int(3))
print(int(3.6))
"""
0
3
3
"""

# float:根据传入的参数创建一个新的浮点数
print(float())  # 不提供参数的时候,返回0.0
print(float(3))
print(float('3'))
"""
0.0
3.0
3.0
"""

# complex:根据传入参数创建一个新的复数
print(complex())  # 当两个参数都不提供时,返回复数 0j。
print(complex('1+2j'))  # 传入字符串创建复数
print(complex(1, 2))  # 传入数值创建复数
"""
0j
(1+2j)
(1+2j)
"""

# str:返回一个对象的字符串表现形式(给用户)
print(str())  # 输出空字符
print(str(None))
print(str('abc'))
print(str(123))
"""

None
abc
123
"""

# bytearray:根据传入的参数创建一个新的字节数组
print(bytearray('中文', 'utf-8'))  # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

# bytes:根据传入的参数创建一个新的不可变字节数组
print(bytes('中文', 'utf-8'))  # b'\xe4\xb8\xad\xe6\x96\x87'

# memoryview:根据传入的参数创建一个新的内存查看对象
v = memoryview(b'abcefg')
print(v[1])
print(v[-1])
"""
98
103
"""

# ord:返回Unicode字符对应的整数
print(ord('a'))  # 97

# chr:返回整数所对应的Unicode字符
print(chr(97))  # a

# bin:将整数转换成2进制字符串
print(bin(3))  # 0b11

# oct:将整数转化成8进制数字符串
print(oct(10))  # 0o12

# hex:将整数转换成16进制字符串
print(hex(15))  # 0xf

# tuple:根据传入的参数创建一个新的元组
print(tuple())  # 不传入参数,创建空元组
print(tuple('121'))  # 传入可迭代对象。使用其元素创建新的元组
"""
()
('1', '2', '1')
"""

# list:根据传入的参数创建一个新的列表
print(list())  # 不传入参数,创建空列表
print(list('abcd'))  # 传入可迭代对象,使用其元素创建新的列表
"""
[]
['a', 'b', 'c', 'd']
"""

# dict:根据传入的参数创建一个新的字典
print(dict())  # 不传入任何参数时,返回空字典。
print(dict(a=1, b=2))  # 可以传入键值对创建字典。
print(dict(zip(['a', 'b'], [1, 2])))  # 可以传入映射函数创建字典。
print(dict((('a', 1), ('b', 2))))  # 可以传入可迭代对象创建字典。
"""
{}
{'a': 1, 'b': 2}
{'a': 1, 'b': 2}
{'a': 1, 'b': 2}
"""

# set:根据传入的参数创建一个新的集合
print(set())  # 不传入参数,创建空集合
a = set(range(10))  # 传入可迭代对象,创建集合
print(a)
"""
set()
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
"""

# frozenset:根据传入的参数创建一个新的不可变集合
a = frozenset(range(10))
print(a)  # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

# enumerate:根据可迭代对象创建枚举对象
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
print(list(enumerate(seasons, start=1)))  # 指定起始值
"""
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
"""

# range:根据传入的参数创建一个新的range对象
a = range(10)
b = range(1, 10)
c = range(1, 10, 3)
print(a, b, c)  # 分别输出a,b,c
print(list(a), list(b), list(c))  # 分别输出a,b,c的元素
"""
range(0, 10) range(1, 10) range(1, 10, 3)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 4, 7]
"""

# iter:根据传入的参数创建一个新的可迭代对象
a = iter('abcd')  # 字符串序列
print(a)
print(next(a))
print(next(a))
print(next(a))
print(next(a))
"""
<str_iterator object at 0x0000019F625D7640>
a
b
c
d
"""

# slice:根据传入的参数创建一个新的切片对象
c1 = slice(5)  # 定义c1
print(c1)
c2 = slice(2, 5)  # 定义c2
print(c2)
c3 = slice(1, 10, 3)  # 定义c3
print(c3)
"""
slice(None, 5, None)
slice(2, 5, None)
slice(1, 10, 3)
"""


# 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()
print(B.__init__)
print(A.__init__)
"""
<function B.__init__ at 0x0000027F0343A550>
<function A.__init__ at 0x0000027F0343A280>
"""

# object:创建一个新的object对象
a = object()
# a.name = 'kim'  # 不能设置属性

9.序列操作函数

9.1 all:判断可迭代对象的每个元素是否为True值

比如

print(all([1, 2]))  # 列表中每个元素逻辑值均为True,返回True
print(all([0, 1, 2]))  # 列表中0的逻辑值为False,返回False
print(all(()))  # 空元组
print(all({}))  # 空字典
"""
True
False
True
True
"""

9.2 any:判断可迭代对象的元素是否有True值的元素

比如

print(any([0, 1, 2]))  # 列表元素有一个为True,则返回True
print(any([0, 0]))  # 列表元素全部为False,则返回False
print(any([]))  # 空列表
print(any({}))  # 空字典
"""
True
False
False
Fal

9.3 filter:使用指定方法过滤可迭代对象的元素

比如

fa = list(range(1, 10))  # 定义序列
print(fa)


def if_odd(x):  # 定义奇数判断函数
    return x % 2 == 1


print(list(filter(if_odd, fa)))  # 筛选序列中的奇数
"""
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
"""

9.4 map:使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象

比如

# map:使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象
ma = map(ord, 'abcd')
print(ma)
# 输出: <map object at 0x000001A076497790>

9.5 next:返回可迭代对象中的下一个元素值

比如

na = iter('abcd')
print(next(na))
print(next(na))
print(next(na))
print(next(na))
"""
a
b
c
d
"""
# 传入default参数后,如果可迭代对象还有元素没有返回,则依次返回其元素值,如果所有元素已经返回,则返回default指定的默认值而不抛出StopIteration 异常
print(next(na, 'e'))
print(next(na, 'f'))
"""
e
f
"""

9.6 reversed:反转序列生成新的可迭代对象

比如

ra = reversed(range(10))  # 传入range对象
print(ra)  # 类型变成迭代器
"""
<range_iterator object at 0x00000277A70ACA90>
"""

9.7 sorted:对可迭代对象进行排序,返回一个新的列表

比如

sa = ['a', 'b', 'd', 'c', 'B', 'A']
print(sa)
print(sorted(sa))  # 默认按字符ascii码排序
print(sorted(sa, key=str.lower))  # 转换成小写后再排序,'a'和'A'值一样,'b'和'B'值一样
"""
['a', 'b', 'd', 'c', 'B', 'A']
['A', 'B', 'a', 'b', 'c', 'd']
['a', 'A', 'b', 'B', 'c', 'd']
"""

9.8 zip:聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器

比如

x = [1, 2, 3]  # 长度3
y = [4, 5, 6, 7, 8]  # 长度5
print(list(zip(x, y)))  # 取最小长度3
"""
[(1, 4), (2, 5), (3, 6)]
"""

10.文件操作函数

10.1 open:使用指定的模式和编码打开文件,返回文件读写对象

比如

# test.txt
hello 老九学堂
# Hello.py
# t为文本读写,b为二进制读写
f = open('test.txt', 'rt',encoding="utf8")
print(f.read())
f.close()
"""
hello 老九学堂
"""

11.编译执行函数

11.1 编译执行函数

  • compile:将字符串编译为代码或者AST对象,使之能够通过exec语句来执行或者eval进行求值
  • eval:执行动态表达式求值
  • exec:执行动态语句块

比如

# 流程语句使用exec
code1 = 'for i in range(0,5): print (i)'
compile1 = compile(code1, '', 'exec')
exec(compile1)
"""
0
1
2
3
4
"""

# 简单求值表达式用eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2, '', 'eval')
print(eval(compile2))

"""
10
"""

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

比如

a = 'some text'
print(str(a))
print(repr(a))

"""
some text
'some text'
"""

Leave a Comment