Python内置函数

Posted on Edited on In Views:
Symbols count in article: 3.9k Reading time ≈ 4 mins.
Python的一些内置函数，对一些过程有极大的简化作用。

Python内置函数

[TOC]

abs()

取绝对值。

1
2
>>> abs(-8)
8
1
2
>>> abs(12*(-3)/4) # 可进行运算
9.0
1
2
3
4
5
>>> abs('e') # 无法对字符进行处理
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    abs('e')
TypeError: bad operand type for abs(): 'str'

max()

遍历参数，取最大值。

1
2
3
4
5
6
7
8
>>> max(1,2,4) # 多参数（数字）输入
4
>>> max({1,2,3}) # 单个参数（元组），处理元组中的元素
3
>>> max([1,2,3]) # 单个参数（列表），处理列表中的元素
3
>>> max([1],[2],[3]) # 多个参数（列表）
[3]

max()函数接受有限个参数，参数可为数字、列表、元组、集合，参数可以含有多个元素。

1、【数字】：取最大的参数或元素

1
2
3
4
5
# 多个参数（含有多个元素的列表），元组亦同。
>>> max([1,2,3],[1,2,3,4]) # 优先取含最大值的参数
[1, 2, 3, 4]
>>> max([1,2,4],[1,2,3,4]) # 同时含有最大值，优先取元素少的参数
[1, 2, 4]

2、【数字列表】：单个参数：取最大的元素；多个参数： 优先取含最大值的参数，其次取元素少的参数

1
2
3
4
5
6
>>> max(['q','w']) # 按ASCⅡ码比大小
'w'
>>> max(['qa','qb']) # 依次比较各个字母，返回整个字符串
'qb'
>>> max(['qa','qb'],['qb']) # 优先取含最大值的参数，其次取元素少的参数
['qb']

`3、【字符串列表】：单个参数：依次按字母取ASCⅡ码大的字符串所在参数；多个参数：优先取含最大值的参数，其次取元素少的参数（实质是转换成ASCⅡ码再依次比较）

1
2
>>> list(max("A1","B2","C3","D0"))
['D', '0']

4、【混合列表】：依次比较，使用list函数将字符串转换成各个单元素的列表

5、【字典】：默认遍历key，以字符串规则比大小；加.valuse()遍历value。

注意返回值是参数，还是参数含有的元素！

(っ °Д °;)っ还有好多用法~https://blog.csdn.net/ifubing/article/details/79250000

min()

使用规则同max()。

sum()

各种意义上的求和。

1
2
sum(iterable, start=0, /)
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers

可迭代类型求和

1
2
>>> sum([1, 2, 3])
>>> 6
1
2
3
>>> sum([[1, 2], [3], [4, 5, 6]], [])
>>> [1, 2, 3, 4, 5, 6]
# 等同于[] + [1, 2] + [3] + [4, 5, 6]

divmod()

取模，返回值为元组，（商，余数）。

len()

求序列长度，可求列表、元组、字典、集合。

map()

map函数 
1
2
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])
<map object at 0x000002A3901F5438>

Python2直接返回列表，Python3返回对象（迭代器）。

因此使用时可以使用set(), list(), tuple()转换成相应结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> a = map(lambda x:x**2,[1,2,3,4])
>>> a
<map object at 0x000001FDA93BFB00>
>>> type(a)
<class 'map'>
>>> list(a)
[1, 4, 9, 16]
>>> tuple(a)
()

>>> a = map(lambda x:x**2,[1,2,3,4])
>>> tuple(a)
(1, 4, 9, 16)
>>> list(a)
[]

可以发现，一旦使用list()等生成映射序列，就无法再使用迭代器a生成其他序列。这是因为迭代器内部有特殊变量记录迭代位置，使用后迭代完成，无法再生成映射序列。

lambda()

临时定义简单匿名函数。

1
2
3
4
5
>>> f = lambda x : x**2
>>> f(2)
4
>>> f(3)
9
lambda

filter()

用于过滤，原理与map()类似。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
>>> def f1(x):
	if x % 2 == 1:
		return x
	else:
		pass
# 定义函数f1，输出奇数

>>> def printSeq(seq):
	for i in seq:
		print("{:d}".format(i),end = '')
	print(end='\n')
# 定义函数printSeq，依次输出序列元素

>>> li = [x for x in range(1,10)]
>>> type(li)
<class 'list'>

>>> g = (x for x in range(1,10))
>>> type(g)
<class 'generator'>

>>> printSeq(li)
123456789
>>> printSeq(g)
123456789
>>> printSeq(filter(f1,li))
13579
# 列表可以过滤，第一次生成的生成器可以过滤。

reduce()

Python2中为内置函数，Python3中在functools中。

reduce

作为参数的函数必须有两个自变量，输出一个自变量，以达到缩小的目的。

由上图，返回值作为下一轮递归参数，最终输出一个元素。

可自定义阶乘、序列求和函数

1
2
3
4
5
6
7
>>> from functools import reduce
# 阶乘
>>> reduce(lambda x, y: x*y, [1,2,3,4])
24
# 序列求和
>>> reduce(lambda x, y: x+y, [1,2,3,4])
10

print()

1
2
3
4
5
print(objects, sep=' ', end='\n', file=sys.stdout)
# objects：输出的对象，可以是字符串、数字、列表等
# sep：间隔符，用来间隔多个对象，默认'<space>'
# end：结尾符，用来设定结尾的字符，默认为'\n'（换行）
# file：设定要写入到文件的对象

P.S.推荐与format函数连用。

input()

1
2
3
4
input().rstrip().split()
# rstrip()：删除字符串末尾的指定字符，默认为空格
# split()：以指定分隔符对字符串进行切片，默认为空格
# str.split(str="", num=string.count(str))，num为分割次数

zip()

1
2
3
4
5
6
zip(list1, list2)
# 压缩
# zip(list1, list2)对可迭代序列list1、list2进行一一配对，组成元组。无其他元素配对的目标元素被舍弃。
# 返回一个生成器
# list(zip("123", "ab"))
# >> [("1", "a"), ("2", "b")]

zip(*)

1
2
3
4
5
6
zip(*List(Tuple))
# 解压
# zip(*List(Tuple))对元素为元组的列表List(Tuple)进行一一配对，组成一个序列。无其他元素配对的目标元素被舍弃。
# 返回一个生成器
# list(zip(*["123", "ab"]))
# >> ["1a", "2b"]