python常见内置函数详解:作用、实例_综合用到python的三个常用内置函数的应用实例

1. abs(x)

• 作用：返回x的绝对值
• x ：可以是整数、浮点数、复数，若是复数则返回其模长。

abs(-2),abs(-2.3),abs(-3+4j)
# 输出：2,  2.3,  5.0
1
2

2. all(iterable)

• 作用：检查一个可迭代对象是否全部元素都是True，相当于问题：all elements are True？什么情况下一个元素是False呢？比如空字符串’’，0，False，None。当这个可迭代对象含有这些元素时，返回False。若没有则返回True。另外输入一个空可迭代对象返回True。
• iterable:可迭代对象，简单理解为可以使用for循环进行遍历的对象。

a = [] # 空返回True
b = [1,2] 
c = [1,2,''] # 含有空字符串，False
d = [1,2,None] # 含有None，False
e = [0,1,2] # 含有0，False
f = [1,2,False] # 含有False，False

all(a),all(b),all(c),all(d),all(e),all(f)
# 输出(True, True, False, False, False, False)
1
2
3
4
5
6
7
8
9

3. any(iterable)

• 作用：检查一个可迭代对象是否有一个元素是True，相当于问题：any one is True？输入一个空可迭代对象返回False。
• iterable:可迭代对象，简单理解为可以使用for循环进行遍历的对象。

a = [] # 空返回False
b = [1,2] # 1，2都是Ture
c = [False,'',0,None] # 没有一个是True
e = [1,False,'',0,None] # 有一个是就返回True

any(a),any(b),any(c),any(e)
# 输出(False, True, False, True)
1
2
3
4
5
6
7

4、bool(x)

• 输入x：任意对象，如果不填写参数x，则返回False。若是0,空字符串，None,False等则返回False。

a = None
b = ''
c = False
d = 0
e = ['',0] # 就算列表元素全是Flase，但是e不是一个空列表,所以返回True

bool(a),bool(b),bool(c),bool(d),bool(e)
# 输出False, False, False, False, True
1
2
3
4
5
6
7
8

5、callable(object)

• 输入object：任意对象。用于检查一个对象是否可调用，可调用返回 True,否则返回 False。像函数，对象方法等都是可以调用的。我的浅显理解就是这个对象后面能不能加括号（不确定）。一般一个对象拥有特殊方法__call__，那么就是可调用的。

callable(print),callable(callable),callable(np.array),callable(2)
# 输出 True, True, True, False
1
2

6、dict()

• Python有两种方法可以创建字典,第一种是使用花括号{},另一种是使用内置函数dict。参考以下代码了解可以通过传入不同形式的参数来创建字典。

# 直接通过输入若干组关键字, key=value来创建字典
my_dict = dict(name = 'zhangsan', age=17) 
# 通过传入若干组双值序列来创建字典，每个序列第一个元素为key，第二个为其对应的value
n1 = ('name','zhangsan')
n2 = ('age',17)
my_dict=dict((n1,n2))
# 通过映射函数zip方式来构造字典
keys = ['name','age']
values = ['zhangsan',17]
my_dict=dict(zip(keys,values))

1
2
3
4
5
6
7
8
9
10
11

7、dir(object)

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

8、divmod(a, b)

• divmod(a, b)，函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。

divmod(11,3) # 输出(3,2)
1

9、enumerate(iterable, start=0)

• enumerate的意思即为枚举，列举。一句话来说，enumerate的作用就是对可迭代的数据进行标号并将其里面的数据和标号一并打印出来。
• 输入为可迭代对象。

list1 = ['a','b','c']

for i,v in enumerate(list1):
    print(i,v)
# 输出： 0 a
	    1 b
        2 c
1
2
3
4
5
6
7

10、filter(function, iterable)

• filter(function, iterable) 函数用于过滤可迭代对象，过滤的规则就是function，function的输入为 iterable中的单个元素，用于判断其是否符合规则。要过滤的对象是iterable。 返回一个filter对象，里面存着符合规则的元素，可以用list、tuple等函数将其转化成列表、元祖等。

def filter_function(x):
    '过滤一个序列中比2小的元素'
    if x >= 2:
        return x
my_list = [0,1,2,3,4]
list(filter(filter_function,my_list)) # 输出为[2, 3, 4]
1
2
3
4
5
6

11、float(x)

• 输入x：数值或者字符串（字符串里是数字）。
• 返回：x转化成浮点类型的值

float(1),float('1.2') # 输出 1.0, 1.2
1

12、frozenset([iterable])

• frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

13、globals()

• 返回包含当前作用域的全局变量的字典。

14、getattr(object, name[, default ])

• 返回对象命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。例如， getattr(x, ‘foobar’) 等同于 x.foobar。如果指定的属性不存在，且提供了 default 值，则返回它，否则触发 AttributeError。

15、hasattr(object, name)

• hasattr(object, name)，该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。此功能是通过调用 getattr(object, name) 看是否有 AttributeError异常来实现的。

16、hash(object)

• 返回对象 object 的哈希值。hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

17、id(object)

• id(object), 返回该对象的内存地址

18、input([prompt ])

• input() 函数接受一个标准输入数据，返回为 string 类型。
• prompt 意思为提示，提示输入什么

age = input('please input your age:')  # 键盘上输入12
print(age) # 输出为字符串 '12'
1
2

19、int([x])

• 将一个字符串或数字转换为整型。

20、isinstance(object, classinfo)

• isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。 isinstance() 与 type() 区别： type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用 isinstance()。

21、issubclass(class, classinfo)

• issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

22、iter(object[, sentinel ])

• object ：支持迭代的集合对象。
• sentinel ：如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如函数），此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

iter_1 = iter([1,2,3])

for i in iter_1:
    print(i)
    1
    2
    3
1
2
3
4
5
6
7

23、len(s)

• 返回对象s的长度

24、list([iterable])

• 将可迭代对象转化成列表

25、locals()

• locals() 函数会以字典类型返回当前位置的全部局部变量。

26、map(function, iterable, …)

• map()函数是 Python 内置的高阶函数，它接收一个函数 f 和一个list(或多个 list,但list个数与f函数的参数个数必须相等)，并通过把函数 f 依次作用在 list 的每个元素上，得到一个迭代器并返回。

def number_plus_1(original_number):
    return original_number + 1
my_list = [1, 2, 3]

list(map(number_plus_1,my_list)) # 输出 [2, 3, 4]
1
2
3
4
5

def number_plus(num1,num2):
    return num1+num2
# 函数有两个参数，需要传递两个序列。每个序列相同index的元素作为一组参数输入
my_list_1 = [1, 2, 3]
my_list_2 = [1,1,1]

list(map(number_plus,my_list_1,my_list_2)) # 输出[2, 3, 4]
1
2
3
4
5
6
7

27、max()

• max可以传入两种形式的参数。一种就是每个元素当成一个参数，另一种是直接传入一个序列

max(1,2,10) 
max([1,2,10])
1
2

28、next(iterator[, default ])

• 输入为迭代器，每一次调用返回迭代器的一个值。当迭代器的值耗尽返回默认值(不设置默认值耗尽会报错StopIteration）

29、open()

• 作用：open用来打开文件

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None,closefd=True, opener=None)
1

• file：需要打开的文件路径
• mode:以什么模式打开这个文件。
  
• encoding：编码方式

30、pow(base, exp[, mod ])

• 函数是计算 base 的 exp 次方，如果 mod 存在，则再对结果进行取模，其结果等效于 pow(base,exp) %mod。

pow(3,2) # 输出9，即 3的2次方

pow(3,2,2) # 输出1，即3的2次方为9，9再对2取余为1
1
2
3

31、range()

• 作用：返回一个可迭代对象。
• 两种形式range(stop)、range(start, stop[, step ] )
• range(stop)产生包含整数0到stop-1的迭代器
• range(start, stop[, step ] )产生包含按步长step取于整数start到stop-1的迭代器。

32、reversed(seq)

• 作用：返回给定序列的反向迭代器

list(reversed([1,2,3])) # 输出[3,2,1]
1

33、round(number[, ndigits ])

• 作用：对数字进行四舍五入，未设置参数ndigits就取整数。参数 ndigits表示保留几位小数

round(2.111) # 输出 2

round(2.111,1) # 输出 2.1
1
2
3

34、set([iterable])

• set() 函数创建一个无序不重复元素集合，删除重复数据，可以用于计算交集、差集、并集等。不传参数就创建一个空集合。

35、sorted(iterable, *, key=None, reverse=False)

• 作用：对可迭代对象按照特定规则key排序。key=None默认就是按照元素大小排序。
• 返回：调用sorted函数返回的是一个排好序的列表，无论传入的可迭代对象是什么。
• sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。sort 方法返回的是对已经存在的列表进行操作而 sorted 方法返回的是一个新的列表。

sorted([1,3,2]) # 返回[1,2,3]
sorted(['d','ee','ccc']) # 返回 ['ccc', 'd', 'ee']
sorted(['d','ee','ccc'],key=len) # 返回 ['d', 'ee', 'ccc']
1
2
3

36、str(object)

• 作用：返回任何对象的字符串格式

37、sum(iterable, /, start=0)

• 默认初始值是0，即返回可迭代对象所有元素和再加上start

38、tuple([iterable ])

• 作用：将可迭代对象转换成元祖

39、type(object)， type(name,bases,dict)

• type(object)：查看对象object的类型。
• type(name,bases,dict)：传入三个参数时，返回一个新的 type 对象

class X:
    a = 1

Y = type('X', (object,), dict(a=1))

Y # 输出__main__.X
1
2
3
4
5
6

40、zip(*iterables)

• 作用：用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。
• 可以使用 list() 转换来输出列表, 如果各个迭代器的元素个数不一致，则返回的列表长度以最短的对象为准。

a = [1,2,3]
b = [4,5,6]
c = [7,8,9,10]

list(zip(a,b)) # 返回[(1, 4), (2, 5), (3, 6)]

list(zip(a,c)) # a只有三个元素，所以只有三个元祖，返回[(1, 7), (2, 8), (3, 9)]
1
2
3
4
5
6
7