python学习之【第十篇】：Python中的内置函数

时间：2024-11-20 13:07:25

1.前言

内置函数，就是Python内部预先定义好的函数，可以直接使用，Python中内置函数有以下这么多个：

python学习之【第十篇】：Python中的内置函数

2.map()

  • 描述：

    map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

  • 语法：

    map(function, iterable, ...)

  • 参数：

    • function -- 函数
    • iterable -- 一个或多个序列

  • 返回值：

    • Python 2.x 返回列表。
    • Python 3.x 返回迭代器。

  • 示例：

# 计算列表各个元素的平方

def square(x):

    return x ** 2

res = map(square,[1,2,3])

print(list(res))   # 输出[1, 4, 9]

# 也可以写作lambda函数

res1 = map(lambda x : x ** 2,[1,2,3])

print(list(res1))   # 输出[1, 4, 9]

3.filter()

  • 描述：

    filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。该接收两个参数，第一个为函数，第二个为序列，序列中的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

  • 语法：

    filter(function, iterable)

  • 参数：

    • function -- 函数
    • iterable -- 可迭代对象

  • 返回值：

    • Python 2.x 返回列表。
    • Python 3.x 返回迭代器。

  • 示例：

# 过滤出列表中的所有奇数

def is_odd(x):

    return x % 2 == 1

res = filter(is_odd,[1,2,3,4,5,6,7,8,9,10])

print(list(res))  # 输出[1, 3, 5, 7, 9]

4.reduce()

  • 描述：

    reduce() 函数会对参数序列中元素进行累积。函数将一个数据集合（列表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用function 函数运算，最后得到一个结果。

    在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 fucntools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数：from functools import reduce

  • 语法：

    reduce(function, iterable[, initializer])

  • 参数：

    • function -- 函数，有两个参数
    • iterable -- 可迭代对象
    • initializer -- 可选，初始参数

  • 注意：

    当使用初始参数时，先把初始参数传给function作为第一个参数，再从数据集合中取第一个数据作为第二个参数进行运算，然后把得到的结果再与第三个数据用function 函数运算，最后得到一个结果。

  • 返回值：

    返回函数计算结果。

  • 示例：

# 计算列表所有数据之和

from functools import reduce

def add(x, y):

    return x + y

res = reduce(add, [1, 2, 3, 4, 5, 6])

print(res)  # 输出1+2+3+4+5+6=21

# 在初始参数基础上计算列表所有数据之和

res1 = reduce(add, [1, 2, 3, 4, 5, 6],100)

print(res)  # 输出100+1+2+3+4+5+6=121

5.zip()

  • 描述：

    zip() 函数，即“拉链函数”，以两个可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。

    如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

  • 语法：

    zip(iterable, ...)

  • 参数：

    • iterable -- 一个或多个可迭代的对象

  • 返回值：

    返回一个对象。

  • 示例：

# zip函数

a1 = ('a', 'b', 'c')

b1 = (1, 2, 3)

print(list(zip(a1, b1)))     # 输出[('a', 1), ('b', 2), ('c', 3)]

a2 = ('a', 'b', 'c', 'd')

b2 = (1, 2, 3)

print(list(zip(a2, b2)))     # 输出[('a', 1), ('b', 2), ('c', 3)]

a3 = ('a', 'b', 'c')

b3 = (1, 2, 3, 4)

print(list(zip(a3, b3)))    # 输出[('a', 1), ('b', 2), ('c', 3)]

dic = {'name': 'NLRX', 'age': 18, 'gender': 'man'}

res = zip(dic.keys(), dic.values())

print(list(res))            # 输出[('name', 'NLRX'), ('age', 18), ('gender', 'man')]

6.max(),min()

max()和min()两个函数用法基本相同，以下示例代码中仅以max()函数举例，min()函数类同。

6.1基本用法

  • 描述：

    max() 函数，返回给定参数的最大值，参数可以为可迭代的序列。

  • 语法：

    max( x, y, z, .... )

  • 原理：

    max()函数处理的是可迭代对象，相当于for循环取出每个元素进行比较，每个元素间进行比较，是从每个元素的第一个位置依次比较，如果这一个位置分出大小，后面的就都不再比较了，直接得出这两个元素的大小。

  • 返回值：

    返回给定参数的最大值。

  • 注意：

    不同数据类型之间的元素不能比较。

  • 示例：

    # 基本用法
    
print(max(80, 100, 1000))   # 输出1000
    
print(max(-20, 100, 400))   # 输出400
    
print(max(-80, -20, -10))   # 输出-10
    
print(max(0, 100, -400))   # 输出100

# 不同数据类型之间的元素不能比较
    
l1 = [1, 2, 3, 'a']
    
print(max(l1))   # 报错 TypeError: '>' not supported between instances of 'str' and 'int'

# 每个元素间进行比较，是从每个元素的第一个位置依次比较，
    
# 如果这一个位置分出大小，后面的就都不再比较了，直接得出这两个元素的大小。
    
l2 = [
    
    (5, 'e'),
    
    (1, 'b'),
    
    (3, 'a'),
    
    (4, 'd')
    
]
    
print(max(l2))   # 输出(5, 'e')

l3 = ['a100', 'a2', 'a4']
    
print(max(l3))   # 输出a4

6.2高级用法

  • 结合zip函数

    # 打印出年龄最大的人和这个人的年龄
    
age_dic = {
    
    '张三':18,
    
    '李四':30,
    
    '王五':45,
    
    '赵六':60
    
}

print(max(zip(age_dic.values(), age_dic.keys())))  # 输出(60, '赵六')

  • 使用key参数

    people = [
    
    {'name': '张三', 'age': 18, },
    
    {'name': '李四', 'age': 30, },
    
    {'name': '王五', 'age': 45, },
    
    {'name': '赵六', 'age': 60, }
    
]
    
print(max(people, key=lambda dic: dic['age']))  #输出 {'name': '赵六', 'age': 60}

7.其他内置函数

1. all()

  • 描述：

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

  • 语法：

    all(iterable)

  • 参数：

    • iterable -- 元组或列表

  • 返回值：

    如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；

    注意：空元组、空列表返回值为True。

  • 示例：

print(all(['a', 'b', 'c', 'd']))   # 列表中元素都不为空或0            True

print(all(['a', 'b', '', 'd']))    # 列表中存在一个为空的元素         False

print(all([0, 1, 2, 3]))           # 列表中存在一个为0的元素          False

print(all(('a', 'b', 'c', 'd')))   # 元组中元素都不为空或0            True

print(all(('a', 'b', '', 'd')))    # 元组中存在一个为空的元素          False

print(all((0, 1, 2, 3)))           # 元组中存在一个为0的元素           False

print(all([]))                     # 空列表                          True

print(all(()))                     # 空元组                          True

2. any()

  • 描述：

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

    any(iterable)
  • 参数：
    • iterable -- 元组或列表
  • 返回值：

    如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
  • 示例：
print(any(['a', 'b', 'c', 'd']))   # 列表中元素都不为空或0            True

print(any(['a', 'b', '', 'd']))    # 列表中存在一个为空的元素         True

print(any([0, 1, 2, 3]))           # 列表中存在一个为0的元素          True

print(any(('a', 'b', 'c', 'd')))   # 元组中元素都不为空或0            True

print(any(('a', 'b', '', 'd')))    # 元组中存在一个为空的元素          True

print(any((0, 1, 2, 3)))           # 元组中存在一个为0的元素           True

print(any([]))                     # 空列表                          False

print(any(()))                     # 空元组                          False

3.bin()

  • 描述：

    将int型的整数转化成二进制表示。
  • 语法：

    bin(x)
  • 参数：
    • x -- int数字
  • 返回值：

    二进制表示的字符串。
  • 示例：
print(bin(10))   # 输出'0b1010'

print(bin(20))   # 输出'0b10100'

4.dir()

  • 描述：

    dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
  • 语法：

    dir([object])
  • 参数：
    • object -- 对象、变量、类型。
  • 返回值：

    返回模块的属性列表。
  • 示例：
print(dir([]))  # 查看列表的属性和方法

# 输出

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__',

 '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',

 '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__',

 '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__',

 '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__',

 '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear',

 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

5.divmod()

  • 描述：

    divmod() 函数把除数和余数运算结果结合起来。
  • 语法：

    divmod(a, b)
  • 参数：
    • a -- 数字
    • b -- 数字
  • 返回值：

    返回一个包含商和余数的元组(a // b, a % b)。
  • 示例：
print(divmod(7,2))    # 输出(3, 1)

print(divmod(10,3))   # 输出(3, 1)

print(divmod(10,2))   # 输出(5, 0)

6.isinstance()

  • 描述：

    isinstance() 函数用来判断一个对象是否是一个已知的类型的实例，考虑继承关系。
  • 语法：

    isinstance(object, classinfo)
  • 参数：
    • object -- 实例对象
    • classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
  • 返回值：

    如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
  • 示例：
print(isinstance(123, int))       # True

print(isinstance(123, str))       # False

print(isinstance('hello', str))   # True

print(isinstance([], list))       # True

print(isinstance({}, dict))       # True
# 考虑继承关系

class A:

    pass

class B(A):

    pass

print(isinstance(A(), A))    # True

print(isinstance(B(), A))    # True

相关文章