[Python] 入门（3）：Python 基础 -- 内建函数

[Python] 入门（3）：Python 基础 – 内建函数

Python 入门系列：

• [Python] 入门（1）：安装 Python 及必要组件
• [Python] 入门（2）：Python 基础 – 变量
• [Python] 入门（3）：Python 基础 – 内建函数（本文）
• [Python] 入门（4）：Python 基础 – 列表和词典的方法
• [Python] 入门（5）：Python 基础 – 字符串的方法
• [Python] 入门（6）：Python 基础 – Python 基础 – 循环，条件和迭代器
• [Python] 入门（7）：Python 基础 – 自定义函数
• [Python] 入门（8）：Python 基础 – 解析式，生成器和程序错误
• [Python] 入门（9）：Python 基础 – 字符串格式化
• [Python] 入门（10）：Python 基础 – 面向对象编程

---

本文目录

函数的调用形式是 fun(*obj, *param)，其中 fun 是函数， obj 是函数的作用对象， param 是函数的参数。Python 中一共内建了 69 种函数。因为数量实在太多，仅仅挑选一些最重要、最常用的函数进行解读，并分为两篇。

名词：

• iterable： 可遍历对象（列表，元组，范围）
• fun：函数
• object：对象
• iterator：迭代器

老宅知道 iterable 和 iterator 很让人困惑。通过示例来说吧：

>>> a = [1, 2, 3]
>>> it = iter(a)

a 是一个可以遍历（iterate）的对象，是 iterable；而 it 是一个可以记住遍历的位置的对象，是 iterator。这个以后会专门讲。

打个比方，可遍历对象（iterable）是一个一个、聚成一堆的汤圆，迭代器（iterator）是每个汤圆依次加工的机器，遍历（iterate）是对每个汤圆做的动作，可以是你吃汤圆也可以是把汤圆下锅煮，但是必须一个一个地做。

首先是上篇文章中提到的函数：

bool([x])

如果对象为 0，返回 False，其它返回 1.

>>> bool(0)
False
>>> bool([0])
True
>>> bool([])
False

注：[0] 是一个非空列表（虽然仅有一个值 0），所以返回 True；而空列表 [] 返回 False。

dict(**kwarg)

创建或把一个 object 转化成一个词典。

>>> a = dict({"a":1, "b":2}) # 创建词典
>>> print(a)
{'a': 1, 'b': 2}

# 转化成字典
>>> b = [1, 2]
>>> c = []
>>> for i, j in enumerate(b):
...    c.append([i,j])
>>> c = dict(c)
>>> print(c)
{0: 1, 1: 2}

注：以上示例涉及好多知识点，enumerate 函数本文下面会提到；.append 方法下一篇会讲到；**kwarg 和 for 循环以后会谈到。

list([iterable])

创建或把一个可遍历对象转化成一个列表。

>>> list([1, 2, 3]) #创建列表
[1, 2, 3]
>>> list(enumerate(["a", "b", "c"])) #转化为列表
[(0, 'a'), (1, 'b'), (2, 'c')]

range([start, ]stop[, step])

这个上一篇已经讲过，这里就不重复了。举个例子复习一下：

>>> range(1, 8, 2)
[1, 3, 5, 7]

set([iterable])

创建或转化成一个集合，不说了。

str(object)

创建或转化成一个字符串。

>>> str(1)
'1'

tuple([iterable])

创建或转化成一个元组，略。

下面开始是新的函数：

abs(x)

返回绝对值。

>>> abs(-5)
5

all(iterable)

如果所有在可遍历对象里的元素为真，返回 True。

>>> all([True, True])
True

any(iterable)

如果任一在可遍历对象里的元素为真，返回 True。

>>> any([True, False])
True

dir([object])

返回一个对象的所有属性（attribute），以上面创建的 a 为例（仅保留首尾各三个属性）：

>>> dir(a)
['__class__',
 '__contains__',
 '__delattr__',
 ...
 'setdefault',
 'update',
 'values']

enumerate(iterable[, start = 0])

返回一个包含对象内元素的索引序号与该元素的元组的列表。start 为可选项（凡是用方括号括起来的变量都是可选项），默认为 0。

>>> enumerate([0, 1, 2]) # 这个函数本身返回的是一个 iterator，而 iterator 对象都不能直接显示
<enumerate at 0x108f94bd0>
>>> list(enumerate([0, 1, 2]))
[(0, 0), (1, 1), (2, 2)]

filter(fun, iterable)

过滤 iterable，返回包含 fun 判断为 True 的元素的 iterator。

>>> list(filter(lambda x:x>1, [0, 1, 2, 3]))
[2, 3]

注：lambda 暂时不需要知道是什么，现在只知道是一种自定义函数的表达形式就可以了。

float([x])

将一个数转换为浮点形式。

>>> float(1)
1.0

input([prompt])

让用户输入字符串。

>>> input("说点什么: ")
说点什么: 123
'123'

int([x])

返回一个浮点数的整数部分。

>>> int(1.5)
1

iter(object)

创建一个迭代器。迭代器有两个基本函数：iter() 和 next()，还可以用 for 遍历迭代器。这些以后会讲到。

len(s)

返回一个对象的长度。

>>> len([1, 2])
2
>>> len("abc")
3

max(iterable)

返回可遍历对象中的最大元素。

>>> max([1, 2, 3])
3

min(iterable)

返回可遍历对象中的最小元素。

>>> min([1, 2, 3])
1

next(iterator)

遍历迭代器的函数。以后再详细说。

print(*objects[, sep = ‘’, end = ‘\n’])

这个命令我们已经见过了，它可以将对象打印到屏幕上。它还有几个可选项，sep 设定了打印的元素之间的间隔，默认是“无”；end 设定了打印以什么字符结束，默认是“换行”。

>>> print("1", "2", "3", sep = '-', end = '!') #这样结尾就不换行了，慎重！
1-2-3!

open(file[, mode = ‘r’)

读取文件的函数，以后再说。

resreved(seq)

返回一个元素顺序颠倒的迭代器。

>>> list(reversed([1, 2, 3]))
[3, 2, 1]

round(number[, ndigits])

四舍五入一个浮点数到整数。如果提供了 ndigits 则四舍五入到该小数点。如果该数字以 5 结尾，则取整到最近的偶数。

>>> round(0.5)
0
>>> round(-0.5)
0
>>> round(1.5)
2
>>> round(1.55, 1)
1.6

sorted(iterable[, key = None, reverse = False])

在可选项均为空的情况下，为一个可遍历对象生序排列。如果 key 提供了（比如 key = str.lower），则先将元素按照提供的函数进行处理，然后排列（显示的元素还是原来没有变化的元素）。如果 reserve 为 True 则降序排列。

>>> sorted(["apple", "Zoo"])
['Zoo', 'apple'] # 'Zoo' 在前，因为'Z' 比 'a' 小
>>> sorted(["apple", "Zoo"], key = str.lower) # 将元素转化为小写再比较
['apple', 'Zoo'] # 'apple' 在前，因为比较的时候 'Z' 先转换成了 'z',比 'a' 大
>>> sorted(["apple", "Zoo"], reverse = True)
['apple', 'Zoo'] # 'apple' 在前，因为排序颠倒了

sum(iterable[, start])

将一个可迭代对象取总和。start 若不为 0，则加和开始于给定数字。

>>> sum([1, 2, 3])
6
>>> sum([1, 2, 3], 100) # 从 100 开始计算
106

type(object)

返回一个对象的类型。

>>> type([])
list
>>> type(())
tuple

zip(iterables)

将多个列表中***相同索引位置***的元素（***相同索引位置***要额外注意！）压缩成一个个元组；如果列表中元素数量不同，以少的为准。zip(*zipped) 可以将压缩后的元组解压，若原列表中元素数量不同，压缩后再解压会损失多余的元素。

>>> a = [1, 2, 3]
>>> b = [4, 5, 6, 7, 8]
>>> c = zip(a, b)
>>> list(c)
[(1, 4), (2, 5), (3, 6)]
>>> a2, b2 = list(zip(*zip(a, b)))
>>> a2
(1, 2, 3)
>>> b2
(4, 5, 6)

---

练习（写出生成如下变量的代码或结果）：

给定一个范围迭代器 rng = range(17827, 7645932, 123)

1. 其中一共有几个元素？
2. 最大的一个元素是多少？
3. 所有元素的总和是多少？
4. 使用正序列表的切片找出倒数第 1，3，5 个元素分别是多少？（提示：查找正序列表的末尾元素用负数索引）

答案下篇文章公布。欢迎把答案留言与老宅交流、互动！

---

上一篇练习的答案：

# 1. 生成 1~5 的列表：
>>> list(range(1, 6))
[1, 2, 3, 4, 5]
# 2. 颠倒 [1, 2, 3, 4, 5] 的列表后选择前 3 个数:
>>> [1, 2, 3, 4, 5][::-1][:3] # 先颠倒再切片；
[5, 4, 3]
>>> [1, 2, 3, 4, 5][2:][::-1] # 先切片再颠倒。注意切片位置索引的变化！
# 3. 生成一个字典，key 是 a~e，value 是数字 1~5:
>>> {"a":1, "b":2, "c":3, "d":4, "e":5}
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# 4. 1 + False 等于什么？5 / (True + True)呢？
>>> 1 + False
1
>>> 5 / (True + True)
2.5
# 5. 生成 [1, 1, 1, 1, 1]:
>>> [1] * 5 # 最简单的方法，也可以将 5 个 [1] 相加。
[1, 1, 1, 1, 1]
# 6. 9101049632 除以 13644752 的余数多少？
>>> 9101049632 % 13644752
48
# 7. "1" 是否等于 1？为什么？
>>> "1" == 1
False # 两者不同，因为 1 是整数，"1" 是字符串。
# 8. ["banana", "elephant"] 和 ["Barbara", "Edward"] 哪个大？为什么？
>>> ["banana", "elephant"] > ["Barbara", "Edward"]
True
# ["banana", "elephant"] 大，因为与 ["Barbara", "Edward"] 比较时，先比较 "Barbara" 和 "banana" 的大小，实际上先要比较 "b" 与 "B" 的大小，"b" 更大。