Python 基础知识全通关 最終更新日時：2021-10-01 17:22:15 python  設定

简介

Python 的优点很多，简单的可以总结为以下几点。

1. 简单和明确，做一件事只有一种方法。
2. 学习曲线低，跟其他很多语言相比，Python更容易上手。
3. 开放源代码，拥有强大的社区和生态圈。
4. 解释型语言，天生具有平台可移植性。
5. 支持两种主流的编程范式（面向对象编程和函数式编程）都提供了支持。
6. 可扩展性和可嵌入性，可以调用 C/C++ 代码，也可以在 C/C++ 中调用Python。
7. 代码规范程度高，可读性强，适合有代码洁癖和强迫症的人群。

Python 的缺点主要集中在以下几点。

1. 运行速度慢，和C程序相比非常慢，因为Python是解释型语言，你的代码在执行时会一行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢。
2. 代码无法加密，发布出去的 Python 代码都是源代码，这是所有解释型语言的共性。
3. 在开发时可以选择的框架太多（如Web框架就有100多个），有选择的地方就有错误。

目前 Python 在 Web 应用开发、云基础设施、DevOps、网络爬虫开发、数据分析挖掘、机器学习等领域都有着广泛的应用，因此也产生了 Web 后端开发、数据接口开发、自动化运维、自动化测试、科学计算和可视化、数据分析、量化交易、机器人开发、图像识别和处理等一系列的职位。

安装

本文作为学习示例，以 windows 作为学习环境，Python 当前文档版本号： 3.9.6

Windows 环境

官网下载：https://www.python.org

从官网下载安装文件 python-3.9.6-amd64.exe 并双击执行安装：

注意：安装时请勾选 Add Python *.* to PATH ，它将会为您自动配置环境变量。

检验是否安装成功：

如图所示，则表示 Python 安装成功！

Linux 环境

部分主机或虚拟机版本会内置安装 Python，如内置 Python 以足够，即可跳过此小节。

1. 选择 Python 版本（可选）。

   如需指定版本号，点击此处前往官网进行选择，本文将以 3.9.6 作为示例。

2. 安装并更新。

   在合适的位置下载安装包：

   wget https://www.python.org/ftp/python/3.9.6/Python-3.9.6.tgz # 下载
   tar -zxvf Python-3.9.6.tgz -C /opt/module/ # 解压
   yum -y install gcc zlib* libffi-devel # 安装编译Python所需要的开发包

   进入解压目录，进行编译和安装：

   cd /opt/module/Python-3.9.6
   ./configure --prefix=/usr/local/bin/python3
   make&&make install

   如在编译过程中提示 make 命令不存在，会给出相应的提示，可根据提示进行安装。

   删除原先的命令，并建立新的软连接：

   python3 -V # 此时仍是旧版本
   rm -rf /usr/bin/python3
   ln -s /usr/local/bin/python3/bin/python3 /usr/bin/python3
   python3 -V # 此时被替换为新安装的版本

   注意：

   1. 如果安装过程中出现网络问题，可尝试临时关闭防火墙。
   2. 如果出现权限问题，可尝试使用 root 或 sudo 用户身份。

Hello World

安装成功后，我们将开始学习如何编写第一个 Python 程序。

命令行模式与 Python 交互模式

正式编写 Python 程序之前，需要先了解一下什么是命令行模式，什么是 Python 模式。

1. 命令行模式

   命令行模式，即命令提示符，也就是我们常说的 CMD 、小黑框等，它用于执行一些 Windows 命令。

2. Python 交互模式

   在命令行模式下，输入 python ，即可进入 Python 交互模式，它以 >>> 作为提示符。

   在 Python 交互模式下，输入 exit() 或使用快捷键 Ctrl + Z 并回车，即可退出，回到命令行模式。

   Python 只是为调试代码提供方便，并非正式运行 Python 代码的环境。

尝试在 Python 交互模式下，执行一些简单的指令：

>>> 100 + 20
120
>>> print('Hello World~')
Hello World~
>>> 2 ** 10
1024

在命令行模式下，也可以执行 python hello.py 运行一个 .py 文件。

hello.py 内容示例：

100 + 20
print('Hello World~')
print(2 ** 10)

在命令行模式下执行：

C:\>python hello.py
Hello World~
1024

选择开发工具

在上文中，我们已经能够通过命令行执行一些简单的 Python 指令，但……总有点重上幼儿园的感觉。好吧，这不怪我们，怪只怪没有用上趁手的工具。这里提出几款可供选择的 Python 开发工具：

• PyCharm（推荐1）

  下载地址：https://www.jetbrains.com/pycharm

• Visual Studio Code（推荐2）

• Eclipse（不推荐）

PyCharm 社区版是免费的，商业版是收费的。我对用过的所有 JetBrains 的产品都欲罢不能，在选择开发工具方面，我个人的首选当然是 PyCharm 啦。

使用 PyCharm 创建一个 Python 项目并运行，如下图所示：

输入打印

在上述示例中，我们反复用到了 print() 这个函数，它的作用就是将内容打印（输出）到控制台。而如果需要从控制台获取用户自定义输入的内容，则需要使用到 input() 函数，使用方式如下：

name = input('Please input your name: ')# 开启输入，并提示
print('Hello, ' + name)# 打印用户输入的内容

注意，与 Java 不同，Python 每一行代码的结尾部分不需要添加 ; 。

Python 基础

Python 的语法比较简单，采用缩进方式，示例代码如下：

# print absolute value of an integer:
a = 100
if a >= 0:
    print(a)
else:
    print(-a)

Python 语法特点：

1. 关于注释

   Python 以 # 来表示注释，与其他语言一样，注释的作用只是为开发人员提供方便，对程序没有实际意义，解释器（或编译器）会忽略掉注释内容。

2. 代码块

   当缩进的语句以冒号 : 结尾时，缩进的语句被视为代码块。

3. 缩进

   Python 采用缩进方式组织代码，它对缩进是十分敏感的，但同时，它又并未规定具体的缩进方式，理论上两个或四个空格的缩进方式与一个制表符的缩进方式都是可以的，甚至在很多情况下混合使用也能够正常执行。但缩进作为 Python 语法的一部分，它是需要严谨对待的，编码人员一定要强制要求自己，在书写 Python 代码时，使用 4 个空格作为缩进方式。

   注意区分 4 个空格与 1 个 tab 的区别。

   另外，Python 的缩进与 Java 不同，Java 缩进的作用仅仅是为了代码的美观和可读性。

4. 字母大小写

   和 Java 一样，Python 程序也是大小写敏感的。

数据类型和变量

1. 整数

   Python 可以处理任意大小的整数（包括负整数），如需使用十六进制，则需要以 0x 作为前缀，例如 0xff00 。

   对于较大的数值，为了提高可读性，Python 支持使用下划线来分割位数，例如 10_000_000_000 。

2. 浮点数

   浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。浮点数可以用数学写法，例如 3.14 。但是对于很大或很小的浮点数，就必须用科学计数法表示。

   整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差。

3. 字符串

   字符串是以英文单引号或双引号括起来的任意文本，引号本身只是一种表示方式，不是字符串的一部分。如果字符串内容本身带有引号，则要进行区分，关于引号的各种情况，可以参照以下代码清单：

   print('It\'s a nice day!')  # 输出结果：It's a nice day!
   print("It's a nice day!")  # 输出结果：It's a nice day!
   print("He said: \"It's a nice day!\"")  # He said: "It's a nice day!"

   这里使用到的 \ 被称为转义字符，它除了可以对引号进行转义之外，还可以表示换行（\n）、制表符（\t）以及该字符本身（\\）。但是，当字符串中存在较多需要进行转义处理的字符时，Python 还允许使用 r'' 来表示引号内部的字符串内容不转义，例如：

   print(r'\n表示换行' + "\nr''表示引用原字符")

   但如果字符串内存在多个换行，使用 \n 换行时候，会对阅读造成不便，因此 Python 允许使用 '''...''' 的格式表示多行内容，例如：

   print('''My learning tasks:
   Java
   Python
   Golang
   ''')

   同样，多行字符 '''...''' 前也可以加上 r 字符结合使用。

4. 布尔值

   布尔值和布尔代数的表示完全一致，一个布尔值只有 True 、 False 两种值，要么是 True ，要么是 False ，在Python中，可以直接用 True 、 False 表示布尔值（注意大小写），也可以通过布尔运算计算出来：

   bool = 1 < 2
   print(1 > 2)  # False
   print(bool)  # True
   print(True)  # True
   print(bool == False)  # False

   布尔值可以使用 and 、 or 和 not 进行运算。

   t1 = 1 < 2  # True
   f1 = 1 > 2  # False
   t2 = 2 > 1  # True
   f2 = 2 < 1  # False
   print('and ------->')
   print(t1 and f1)  # True and False => False
   print(t1 and t2)  # True and True => True
   print(f1 and f2)  # False and False => False
   print('or ------->')
   print(t1 or f1)  # True or False => True
   print(t1 or t2)  # True or True => True
   print(f1 or f2)  # False or False => False
   print('not ------->')
   print(not t1)  # not True => False
   print(not f1)  # not False => True

5. 空值

   空值是 Python 里一个特殊的值，用 None 表示。

6. 变量

   变量名必须是大小写英文、数字和 _ 的组合，且不能用数字开头，例如：

   age = 20  # age是一个数值型的变量，它的值为20
   birth_98 = '1998年'  # birth_98是一个字符串类型的变量，它的值为【1998年】
   MyAnswer = True  # 布尔型变量...

   在 Python 中，等号 = 是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：

   totalPrice = 0
   bookPrice = 299
   pencilPrice = 84
   print('この本は　いくらですか？')  # 询问价格
   priceAStr = bookPrice.__str__() + '円です'
   print(priceAStr)
   totalPrice = totalPrice + bookPrice
   print('その鉛筆は？')
   print(pencilPrice)
   totalPrice += pencilPrice  # A += B ==> A = A + B
   print('全部でいくらですか？')
   totalPrice = totalPrice.__str__() + '円です'
   print(totalPrice)
   
   # 哈哈，最近在日语入门，有点疯魔，不要介意

   示例中，变量 totalPrice 被进行了多次赋值，而且可以看到，对于同一变量，可以为其赋予不同类型的值。

   这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。也可以理解为强类型与弱类型，Python 是弱类型的语言。

   和静态语言相比，动态语言更灵活。

   注意理解赋值语句与数学上的等号的区别。

7. 常量

   所谓常量就是不能变的变量，比如常用的数学常数 π 就是一个常量。在Python中，通常用全部大写的变量名表示常量：

   PI = 3.14159265359

   但其实 Python 中并不存在常量，因为即便是通过大写的方式生命变量名，但它并没有与其他语言的 const 类似的修饰符，它不能保证它所谓的常量不被修改。而使用大写标识常量也只是人为的规定而已，实际上是可以被修改的。简单来说，Python 中没有常量。

Python 中的除法：

Python 的除法有两种方式：

1. / 获取浮点数结果。

   这种除法方式的结果始终都是浮点数，不论是否能够被整除。

   print(10 / 3)  # 3.3333333333333335
   print(9 / 3)  # 3.0

2. // 被称为地板除。

   这种除法会舍去运算结果的小数部分，如果是整数相除，则结果为整数类型，否则，结果为浮点类型，例如：

   print(10 // 3)  # 3
   print(9 // 3)  # 3
   print(9.6 // 3)  # 3.0
   print(9.6 // 3.2)  # 2.0
   print(0.0006 // 3)  # 0.0

注意：和 Java 不同，Python的整数没有大小限。Python 的浮点数也没有大小限制，但是超出一定范围就直接表示为 inf（无限大）。

字符串和编码

在最新的 Python 3 版本中，字符串是以 Unicode 编码的，也就是说，Python 的字符串支持多语言。

对于单个字符的编码，Python 提供了 ord() 函数获取字符的整数表示，chr() 函数把编码转换为对应的字符，例如：

print(ord('A'))  # 65
print(ord('甲'))  # 30002
print(ord('あ'))  # 12354
print(chr(65))  # A
print(chr(30002))  # 甲
print(chr(12354))  # あ

另外，你也可以直接使用字符的整数编码，例如：

print('\u7532\u4e59\u4e19\u4e01')  # 甲乙丙丁

关于中文转码，可以使用在线转码工具：https://www.bejson.com/convert/unicode_chinese

由于 Python 的字符串类型是 str ，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把 str 变为以字节为单位的 bytes 。

Python 对 bytes 类型的数据用带 b 前缀的单引号或双引号表示：

x = b'ABC'

以 Unicode 表示的 str 通过 encode() 方法可以编码为指定的 bytes ，例如：

print('ABC'.encode('ascii'))  # b'ABC'
print('中文'.encode('utf-8'))  # b'\xe4\xb8\xad\xe6\x96\x87'
print('中文'.encode('ascii'))  # 报错，因为 ASCII 无法表示中文

反过来，如果需要从磁盘上读取字节流，就需要将 bytes 转换为字符串，这时就需要使用 decode() 方法：

print(b'ABC'.decode('ascii'))  # ABC
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))  # 中文

Python 还提供了一个 len() 函数，用于计算字符长度或字节数：

print(len('中文'))  # 2
print(len(b'\xe4\xb8\xad\xe6\x96\x87'))  # 6
len('中文'.encode('utf-8'))  # 6

在 Unicode 编码中，一个中文字符占用3个字节，在字符串操作过程中，如果经常需要对将字符串与字节流进行转换，则需要尽量保持编码的一致性。

我们在保存 Python 源代码时，为了让 Python 解释器在读取源码时按照 UTF-8 的编码读取，我们可以在文件开头位置指定读取的编码方式：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

字符串的格式化方式：

1. % 占位符格式化

   在 Python 中，也可以对字符串进行格式化，它采用的格式化方式和C语言是一致的，用 % 实现，例如：

   print('Hello, %s!' % 'World')
   print('I\'m learning %s! It had took me %d hours yet.' % ('Python', 4))

   % 用于占位和替换，其对应的占位符有四种类型：

   1. %s 表示字符串占位。
   2. %d 表示整数占位。
   3. %f 表示浮点数占位。
   4. %x 表示十六进制整数占位。

   其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

   print('%.2f' % 3.1415926)  # 保留2位小数

2. format() 格式化

   print('Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125))

   这种方式相比占位符更加麻烦。

3. f-string 格式化

   这种格式化字符串的方法是使用以 f 开头的字符串，称之为 f-string ，它和普通字符串不同之处在于，字符串如果包含 {xxx} ，就会以对应的变量替换：

   r = 2.5
   s = 3.14 * r ** 2
   print(f'The area of a circle with radius {r} is {s:.2f}')
   # The area of a circle with radius 2.5 is 19.62

list 和 tuple

list

list（列表）是 Python 内置的一种数据类型，它是一种有序的集合，可以随时添加和删除其中的元素。

使用 len() 函数则可以获取到集合的大小。

language = ['Zh-CN', 'En', 'Ja']
print(len(language))  # 3

Python 中的列表概念 Java 基本一样，都是一个有序的列表，都是以 0 作为起始索引，所以超出范围会报越界错误。

我们可以向列表中插入追加数据，数据会默认追加到最后位置。

language = ['Zh-CN', 'En', 'Ja']
language.append('Zh-TW')
print(language)  # ['Zh-CN', 'En', 'Ja', 'Zh-TW']

当然，也可以将新的数据插入到指定的下标位置，例如：

language = ['Zh-CN', 'En', 'Ja']
language.insert(1, 'Zh-TW')
print(language)  # ['Zh-CN', 'Zh-TW', 'En', 'Ja']

删除列表中的元素，需要使用 pop() ，如下：

language = ['Zh-CN', 'Zh-TW', 'Ko', 'En', 'Ja', 'Fran']
language.pop()  # 不指定pop()函数的参数，则删除最后一个元素
print(language)
language.pop(2)  # 删除指定下标位置的元素
print(language)  # ['Zh-CN', 'Zh-TW', 'En', 'Ja']

替换元素：

language = ['Zh-CN', 'En', 'Ja']
language[0] = 'Zh-TW'
print(language)  # ['Zh-TW', 'En', 'Ja']

列表中元素的数据类型并不一定要保持一致，如果数组列表中包含有列表类型的元素，则被称为多维数组。

tuple

tuple（元组）是另一种有序列表，它和 list 非常相似，但 tuple 一旦初始化就不能修改。

language = ('Zh-CN', 'En', 'Ja')
language[0] = 'Zh-TW'  # 报错：'tuple' object does not support item assignment
print(language)

元组列表没有提供 append() 和 insert() 类似的方法。

因为 tuple 初始化后是不可改变的，因而更具有安全性。

tupleA = ()  # 定义一个空的tuple
tupleB = (5,)  # 当tuple内只有一个元素时，也需要添加逗号，以避免和数学公式符号混淆
print(len(tupleB))  # 1

可变的 tuple ？

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)  # ('a', 'b', ['X', 'Y'])

这里的可变并不是真正的可变，这里变化的只是 tuple 内部的 list 元素，而 tuple 本身的指针指向并没有变。

条件判断

Python 使用 if-elif-else 作为条件判断的语法结构，其中 elif 其实是 else if 的缩写，该语法的完整形式的使用如下：

condition = 'A'

if condition.__eq__('A'):
    print('do A')
elif condition.__eq__('B'):
    print('do B')
elif condition.__eq__('C'):
    print('do C')
else:
    print('do D')

if 判断条件不一定要求是布尔类型或布尔类型的表达式，也可以是一些其他的数据类型，如果这些数据类型是非零数值、非空字符串、非空数组等，条件判断则为 True ，否则为 False ，例如：

str = input('Please input and enter to judge true or false: ')
if str:
    print('Your input is: ' + str + ', it\'s true')
else:
    print('Your input is: ' + str + ', it\'s false')

通过输入不同内容，即可判断该输入内容是否为 True ，可以在您的开发工具中尝试一下，并观察返回结果。但同时，请注意，通过 input() 获取到的用户输入的所有内容都是字符串类型。

如需要将字符串内容转换为数值型，可以使用 int() 函数。

循环

Python 中有两种循环方式：

1. for...in

   total = 0
   arr = [1, 2, 3, 4, 5]
   for num in arr:
       total += num
   print(total)

   Python 也提供了一个 range() 方法用于生成整数序列，而通过 list() 方法可以将整数序列转换为数组，例如：

   str = '| '
   arr = list(range(5))
   for num in arr:
       str += num.__str__() + ' | '
   print(str)  # | 0 | 1 | 2 | 3 | 4 | 

   range() 函数有两个参数，一个是起始值，一个是终止值，当起始为 0 时，可以省略不写。

2. while

   对于 while 循环，只要条件满足，就不断循环，条件不满足时退出循环。

   # 计算100以内所有奇数之和
   sum = 0
   n = 99
   while n > 0:
       sum += n
       n = n - 2
   print(sum)

break 和 continue ：

1. break

   在循环中，break 语句可以提前退出循环。

   # 获取大于100的最小立方数
   result = 0
   n = 0
   while True:
       n += 1
       result = n * n * n
       if result > 100:
           break
   print(result)  # 125

2. continue

   在循环过程中，也可以通过 continue 语句，跳过当前的这次循环，直接开始下一次循环。

   # 获取100以内所有奇数的总和
   total = 0
   n = 0
   while n < 100:
       n += 1
       if (n % 2) == 0:
           continue  # 当条件满足时，进入下一次循环
       total += n
   print(total)  # 2500

break 和 continue 的区别在于，前者是直接跳出整个循环结构，而后者当前正在循环的某一轮，可以理解为跳过当前循环，继续下一次。另外，break 往往适用于从众多数据中找到某一个符合特定条件的数据，而 continue 则适用于从众多数据中找到某一系列符合条件的数据。

注意：由于逻辑不够完善，或循环和跳出语句使用不当，可能会出现死循环的情况，就需要终止当前程序并检查代码逻辑。（在终端可使用 Ctrl + C 终止程序）

dict 和 set

dict

Python 内置了字典（在其他语言中也称为 map ），它使用 key-value （键值对）的方式存储，具有极快的查找速度。

data = {'dataA': 30, 'dataB': 73, 'dataC': -7}
print(data['dataB'])  # 73

也可以对 dict 中的值进行添加、修改或移除等操作：

data = {'dataA': 30, 'dataB': 73, 'dataC': -7}
print(len(data))  # 计算dict元素个数
data['dataB'] = 54  # 根据key值修改dict中的元素
data['dataD'] = 108  # 向dict中添加元素
data.pop('dataA')
print(data)  # {'dataB': 54, 'dataC': -7, 'dataD': 108}
# dict的遍历
for key in data:
    print(data[key])
data.clear()  # 清空dict
print(data)  # {}

但是，在根据 key 从 dict 中获取值时，可能会出现 key 不存在的情况，这时就会引起程序报错，我们可以通过如下方式避免：

data = {'dataA': 30, 'dataB': 73, 'dataC': -7}
# 方式一：判断要查询的key是否存在
if 'dataD' in data:
    print(data['dataD'])
# 方式二：推荐
print(data.get('dataD'))  # 未查询到时，返回None
print(data.get('dataD', -1))  # 未查询到时，指定返回内容（这里是-1）

注意：在 Python 交互环境中，返回值为 None 是不会输出到控制台的，另外， dict 内部元素的存放顺序和 key 放入的顺序无关。

dict 和 list 比较：

1. 对于查找和插入，dict 处理极快，不会随着 key 的增加而变慢，而 list 则会因为元素的不断增加变慢。
2. 对于内存占用而言，dict 由于要存储键值对，占用内存较多，而 list 则占用很少。

所以，list 的优势在于空间占用少，而 dict 的优势在于时间消耗少。

此外，由于 dict 是通过 key 来计算 value 的存储位置，所以程序需要保证 key 的对象的不可变性，这种不可变性，需要通过哈希算法进行保证。在 Python 中，字符串和整数都是不可变的，可以作为 dict 的 key 使用，但 list 却是可变的，不应当作为 key 使用。

set

set 和 dict 类似，也是一组 key 的集合，但是 set 中不存储 value，由于 key 是不可重复的，所以 set 中不存在重复的数据。

要创建一个 set，需要先提供一个 list 作为输入集合：

s1 = {1, 2, 2, 3}  # 直接声明set，重复值时无效的
s1.add(4)  # 向set中添加元素
s1.add(1)  # 如果添加元素已存在，不会引起报错，但也不会重复添加
s1.remove(2)  # 移除set中某个元素
print(s1)  # {1, 3, 4}
print(len(s1))  # 计算元素个数
list1 = [1, 2, 3, 3, 3]
s2 = set(list1)  # 将list转为set
print(s2)  # {1, 2, 3}
s1.clear()  # 清空set

set 无序不重复的元素集合，它可以做数学意义上的交集、并集处理：

s1 = {1, 2, 3, 4}
s2 = {2, 4, 6, 8}
# 交集
print(s1 & s2)  # {2, 4}
# 并集
print(s1 | s2)  # {1, 2, 3, 4, 6, 8}
# set中存放list会导致报错
s3 = {[1, 2], 2, 3}
print(s3)  # 报错：TypeError: unhashable type: 'list'

set 中存放 list 作为元素会引起报错，其原理和 dict 是一样的。

函数

Python 内置了很多有用的函数，我们可以直接调用，例如在上文中频繁使用到的 len() 。

调用函数

要调用一个函数，需要知道函数的名称和参数，而且需要保证参数的类型及顺序的一致，否则就会引起程序错误。

也有一些函数可以接收任意多个参数。

print(abs(-13.2))  # 13.2
print(max(2, 3, 18, 9, 33, 5))  # 33
# 类型转换函数
print(int('15'))  # 15
print(float('2.18'))  # 2.18
print(str(1.62))  # 1.62
print(bool(1))  # True
print(bool(''))  # False

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个别名：

a = abs
print(a(-6))  # 6

定义函数

在 Python 中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号 : ，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回（无返回值不写即可）。

def division(m, n):
    if n == 0:
        return  # return None 可以直接简写为 return
    else:
        return m / n

print(division(10, 4))  # 2.5

当暂未想好如何定义函数的实现时，可以定义一个空函数，它的目的是进行占位，当想好函数的实现内容时在填充即可。

i = 1001
u = 1005
def say(str):
    print(str)
    pass

if i == u:  # if I were You
    pass  # I would ...  # if内容暂未确定，但留空又会报错
say('Anyway!!!')  # but I'm not, so, >>>

调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出 TypeError 错误，但是如果参数类型不对，Python 解释器就无法帮我们检查。

但是现在的 IDE 工具很智能了，PyCharm 在代码编写时就可以帮助我们规避很多错误，例如参数检查。

因此，我们定义函数的时候，可以进行参数类型检查：

def division(m, n):
    if not isinstance(m, (int, float)):
        raise TypeError('您传入的除数必须是数值型')
    if not isinstance(n, int):
        raise TypeError('您传入的被除数必须是整数')
    if n == 0:
        return
    else:
        return m / n

print(division(10, 4.5))  # 抛出【您传入的被除数必须是整数】错误

Python 函数也可以返回多个值：

def maxAndMin(arr):
    max = arr[0]
    min = arr[0]
    for item in arr:
        if item > max:
            max = item
        if item < min:
            min = item
    return max, min

max, min = maxAndMin([2, 53, 6, -1, 28, 7])
print('max = ', max)  # max =  53
print('min = ', min)  # min =  -1
print(maxAndMin([2, 53, 6, -1, 28, 7]))  # (53, -1)

从示例中可以看到，Python 函数返回多个值其实是一种假象，它返回多个值，其实本质上是返回一个 tuple 。

尝试定义一个函数 quadratic(a, b, c) 来求出一元二次方程的解，公式定义：$ax^2 + bx + c = 0$

提示：

1. 一元二次方程的求根公式为：

   $$\begin {array}{c} x = \frac{-b±\sqrt {b^2-4ac}}{2a} \end {array}$$

2. 计算平方根可以调用 math.sqrt() 函数。

使用下面的代码来尝试一下吧：

import math

def quadratic(a, b, c):
    pass  # 在这里写入你的代码逻辑

a = input('Input parameter a: ')
b = input('Input parameter b: ')
c = input('Input parameter c: ')
try:
    a = float(a)
    b = float(b)
    c = float(c)
except ValueError:
    raise ValueError('参数错误：请传入数值类型的参数')
print('Get result = ' + quadratic(a, b, c).__str__())

import math

def quadratic(a, b, c):
    x1 = None
    x2 = None
    # 1. 参数校验
    if a == 0:
        print('参数错误：一元二次方程的a值不能为0')
        return
    # 2. 判断有多少个解
    d = b ** 2 - 4 * a * c
    if d < 0:  # 该方程只有一个解，或两个解相同
        print('该一元二次方程没有【无解】')
    elif d == 0:
        x1 = b / (-2 * a)
        x2 = x1
    else:  # 该方程有两个解
        x1 = (-b + math.sqrt(d)) / (2 * a)
        x2 = (-b - math.sqrt(d)) / (2 * a)
    return x1, x2

a = input('Input parameter a: ')
b = input('Input parameter b: ')
c = input('Input parameter c: ')
try:
    a = float(a)
    b = float(b)
    c = float(c)
except ValueError:
    raise ValueError('参数错误：请传入数值类型的参数')
print('Get result = ' + quadratic(a, b, c).__str__())

函数的参数

1. 位置参数

   在前文中，我们已经多次使用到位置参数，所谓位置参数，就是在调用函数时，指定的实际参数的数量，必须和形式参数的数量保持一致，否则就会抛出 TypeError 异常。

   def power(x, n):
       s = 1
       while n > 0:
           s *= x
           n -= 1
       return s
   
   print(power(2, 3))

2. 默认参数

   默认参数是指当函数调用方不传递时，函数指定参数具有一个默认的值。

   def power(x, n=2):  # 次方数默认为2
       s = 1
       while n > 0:
           s *= x
           n -= 1
       return s
   
   print(power(4))

   使用默认参数需要记住以下原则：

   • 位置参数放前，默认参数放后。

   • 确定性大的参数放前，确定性小的参数放后。

   • 调用的函数需要传递默认参数，但参数位置不匹配时，需要指定参数名。

     def test(name, age, school='', gender='Male'):
         pass
     
     a = 1
     test('Susan', 20, gender='Female')

   • 默认参数必须指向不变对象【坑点】。

     例如，当默认参数定义为数组时，将出现如下情况：

     def add_end(l=[]):
         l.append('END')
         return l
     
     print(add_end([1, 2, 3]))  # [1, 2, 3, 'END']
     print(add_end())  # ['END']
     print(add_end())  # ['END', 'END']
     print(add_end())  # ['END', 'END', 'END']

     这是因为默认参数指定为 list 时，指定的其实只是一个指针，当我们每次使用默认参数，使用的都是指针对应的值，多次调用就会反复修改 list 指针对应的值，导致多重拼接。

     要理解这一点，请务必理解可变对象和不可变对象。（在 Java 语言中，被称为值类型和引用类型）

3. 可变参数

   可变参数，即参数的个数是可以变化的，可以传入任意多个参数（包括0个）。定义函数可变参数的方式如下：

   def sum(*nums):
       sum = 0
       for num in nums:
           sum += num
       return sum
   
   print(sum(3, 4, 1, 5, 29))  # 42

   可变参数接收到的是一个 tuple 类型。

   如果调用函数时，某一个参数本身即是 tuple 类型的参数，为了区分可变参数与参数的 tuple 类型参数，可以使用如下方式调用函数：

   def sum(*nums):
       sum = 0
       for num in nums:
           sum += num
       return sum
   
   nums = [3, 4, 1, 5, 29]
   print(sum(*nums, 8))  # 50

   这里是将 tuple 转换为可变参数，再传入到函数中。

4. 关键字参数

   关键字参数允许传入任意多个参数，这些关键字参数在函数内部会自动组装成一个 dict 。

   def person(name, age, **kw):
       print('name:', name, 'age:', age, 'extra:', kw)
   
   person('Lily', 24, city='Shanghai', job='teacher')  # name: Lily age: 24 extra: {'city': 'Shanghai', 'job': 'teacher'}

   关键字参数可以扩展函数的功能，函数调用方可以根据情况自由选择是否传递某些参数字段，上面的函数也可以做如下简化：

   def person(name, age, **kw):
       print('name:', name, 'age:', age, 'extra:', kw)
   
   extra = {'city': 'Shanghai', 'job': 'teacher'}
   person('Lily', 24, **extra)

   注意：函数内的关键字参数只是传入实际参数的一份拷贝，对它进行改动并不会影响到函数调用方的变量。

5. 命名关键字参数

   对于关键字参数，调用方对参数名称可以任意指定，但如需进行参数名称限制，我们可以进行如下声明：

   def person(name, age, *, city, job):
       print('name:', name, 'age:', age, 'city:', city, 'job:', job)
   
   extra = {'city': 'Shanghai', 'job': 'teacher'}
   person('Lily', 24, **extra)

   这种通过 * 分隔被命名的关键字参数，可以实现对参数命名的限制，但通过这种方式传递参数时，调用方必须传递所有关键字参数（除非关键字参数中使用了默认参数），否则会引起报错。

   另外，当函数中已经定义了一个可变参数，那么，这个函数中的可变参数前就不再需要使用 * 分隔符了，例如：

   def person(name, age, *args, city='Taiyuan', job):
       pass

6. 参数组合

   在 Python 中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数，例如：

   def f1(a, b, c=0, *args, school, **kw):
       print('a =', a, 'b =', b, 'c =', c, 'args =', args, school, 'kw =', kw)
   
   f1('zhangsan', 'nanjing', 5, 12, 33, school='NanJin University', email='abc@q.com', phone='15625376')
   # a = zhangsan b = nanjing c = 5 args = (12, 33) NanJin University kw = {'email': 'abc@q.com', 'phone': '15625376'}

   但是，由于多种类型的组合参数可读性并不太高，不推荐同时使用较多种类型的参数进行组合。

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数，例如：

# 阶乘
def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

print(fact(5))  # 120

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。（例如在示例中调用 fact(1000) ）

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

对于 Python 而言，因为其解释器并未对尾递归做优化，所以，Python 使用尾递归方式也不能解决栈溢出的问题。

尾递归是指，在函数返回的时候，调用自身本身，并且，return 语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

# 尾递归阶乘
def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

print(fact(5))  # 120

两者的区别在于：

# 递归方式：
fact(3)
3 * fact(2)
3 * (2 * fact(1))
3 * (2 * 1)
3 * 2
6
# 尾递归方式：
fact_iter(3, 1)
fact_iter(2, 3)
fact_iter(1, 6)
6

高级特性

切片

在 Python 中，可以通过切片截取数组中任意任意位置的元素。

arr = []
for i in range(100):
    arr.append(i)

print(arr[0:3])  # [0, 1, 2]
print(arr[:3])  # [0, 1, 2]
print(arr[10:14])  # [10, 11, 12, 13]
print(arr[-1])  # [99] # 倒数第一个元素
print(arr[-4:-1])  # [96, 97, 98]
print(arr[-4:])  # [96, 97, 98, 99] # 倒数四个参数
print(arr[-4:0])  # []
print(arr[:10:3])  # [0, 2, 4, 6, 8] # 前10个数中，每3个数取一个
print(arr[:])  # 拷贝原数组

倒数第一个元素的索引是 -1。

字符串和 tuple 也是看做是一种 list ，因此它们同样支持切片操作：

print((0, 1, 2, 3, 4, 5)[:3])  # (0, 1, 2)
print('PYTHON'[:3])  # PYT
print('PYTHON'[:5:2])  # PTO

在很多编程语言中，针对字符串提供了很多各种截取函数（例如，substring），其实目的就是对字符串切片。Python没有针对字符串的截取函数，但可以直接使用切片方式实现。

迭代

对于一个 list 或 tuple ，我们可以通过循环来进行遍历，这种遍历被称为迭代。

在 Python 中，迭代是通过 for ... in 来完成的，它既可以迭代一个 list 和 tuple ，也可以迭代字符串。

而且在 Python 中，程序只需要关注对象是否可迭代，而不需要关注迭代对象的类型，判断对象是否可迭代：

from collections.abc import Iterable

print(isinstance('abc', Iterable))  # True
print(isinstance([1, 2, 3], Iterable))  # True
print(isinstance(123, Iterable))  # False # 整数不可迭代

另外，Python 也内置了一个 enumerate 函数，可以将 list 变为一个 索引-元素 对，这样就可以在for循环中同时迭代索引和元素本身：

for i, v in enumerate(['A', 'B', 'C']):
    print(i, v)

Python 也可以同时遍历多个内部元素，但需要注意个数需要完全匹配，否则会报错：

for x, y, z in [(1, 1, 3), (2, 4, 3), (3, 9, 3)]:
    print(x, y, z)

for x, y, z in [(1, 1, 3), (2, 4, 3), (3, 9)]:  # ValueError: not enough values to unpack
    print(x, y, z)

列表生成式

列表生成式即 List Comprehensions ，是 Python 内置的非常简单却强大的可以用来创建 list 的生成式。

print([x * x for x in range(1, 11)])  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

for 循环后面还可以加上条件判断：

print([x * x for x in range(1, 11) if x % 2 == 0])  # [4, 16, 36, 64, 100]
print([x * 2 if x > 5 else x * x for x in range(1, 11) if x % 2 == 0])  # [4, 16, 12, 16, 20]

注意：在列表生成式中， for 后面的条件判断的作用是进行筛选，所以不能带有 elif 或 else 判断。而 for 前面也可以使用 if 语句，但如果是在 for 前面添加条件判断，它的作用则是作为一个表达式，这时它必须有 else 语句，以便能够保证所有的情况都得到处理。

在一个列表生成式中，for 前面的 if ... else 是表达式，而 for 后面的 if 是过滤条件，不能带 else。

还可以使用多个 for 循环生成全排列：

print([a + b + c for a in 'BC' for b in '12' for c in 'あう'])
# ['B1あ', 'B1う', 'B2あ', 'B2う', 'C1あ', 'C1う', 'C2あ', 'C2う']

运用列表生成式，可以写出非常简洁的代码。例如，列出当前目录下的所有文件和目录名：

import os

print([d for d in os.listdir('.')])  # ['.idea', 'main.py', 'venv']

for 循环其实可以同时使用两个甚至多个变量，比如 dict 的 items() 可以同时迭代 key 和 value：

d = {'x': 'A', 'y': 'B', 'z': 'C'}
for k, v in d.items():
    print(k, '=', v)

print([k + '=' + v for k, v in d.items()])  # ['x=A', 'y=B', 'z=C']

另外，还可以对字符串进行处理，例如：

L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])  # ['hello', 'world', 'ibm', 'apple']

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

但如果列表元素可以按照某种算法推算出来，那我们就可以在循环的过程中不断推算出后续的元素，这样就不必创建完整的 list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator 。

要创建一个 generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [] 改成 () ，就创建了一个 generator：

d = {'x': 'A', 'y': 'B', 'z': 'C'}
g = (k + '=' + v for k, v in d.items())
print(g)  # <generator object <genexpr> at 0x00000210690ADBA0>
print(next(g))  # x=A
print(g.__next__())  # y=B
print(next(g))  # z=C
print(next(g))  # 抛出异常 StopIteration

generator 可以通过实例中 next() 的方式依次取出相应的值，但这种做法较为笨拙，而且越界时会抛出异常，由于 generator 也是可遍历对象，因此更加常见的是结合循环进行使用：

d = {'x': 'A', 'y': 'B', 'z': 'C'}
g = (k + '=' + v for k, v in d.items())
for n in g:
    print(n)

另一种创建 generator 的方法：

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, …

# 函数实现斐波拉契数列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

fib(10)

将上述算法修改为一个生成器：

# 斐波拉契数列生成器
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b  # yield中断执行并返回每轮执行的结果
        a, b = b, a + b
        n = n + 1
    return 'done'

# 这里得到的 fib(10) 是一个 generator 对象
for n in fib(10):
    print(n)

这就是第二种创建 generator 的方法，如果一个函数中定义了 yield 字段，这个函数就不再是一个普通函数，而是一个生成器。

函数和生成器有一个较为突出的区别：函数是按照顺序执行，如果遇到 return 语句或执行到最后一行语句就返回；而生成器却是在每次调用 next() 方法时才执行，遇到 yield 语句时就返回，而当再次执行 next() 时，就从上一次 yield 返回语句处继续执行。

# 在这里，注释中的 [ ] 表示执行顺序，其后表示输出内容
def odd():
    print('step 1')  # [1] step 1
    yield 1
    print('step 2')  # [3] step 2
    yield 3
    print('step 3')  # [5] step 3
    yield 5

odd = odd()
print(next(odd))  # [2] 1
print(next(odd))  # [4] 3
print(next(odd))  # [6] 5

# 也可以使用循环进行遍历
# for n in odd():
#     print(n)

如果在取出生成器中的所有值之后，希望获得生成器中返回语句定义的内容，可以通过异常捕获的方式：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b  # yield中断执行并返回每轮执行的结果
        a, b = b, a + b
        n = n + 1
    return 'done'

fib = fib(6)
while True:
    try:
        x = next(fib)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)  # 获取到生成器中return语句的返回值。
        break

迭代器

在前文的迭代部分，我们已经提到过迭代器，可以直接作用于 for 循环的对象，都被称为可迭代对象，并且可以使用 isinstance() 函数来判断一个对象是否可迭代。而其实，可以被 next() 函数调用并不断返回下一个值的对象，即为迭代器（Iterator）。

生成器都是迭代器对象，而数组、字典、字符串等虽然具有可迭代属性，却并不是迭代器对象，这是因为迭代器对象可以被 next() 函数不断获取下一个值，但其本身却并不知晓当前序列的长度，只能通过 next() 函数实现按需计算下一个元素。因此，迭代器的计算是惰性的，只有在需要返回下一个数据的时候，才会进行计算。

迭代器甚至可以表示一个无限大的数据流，而列表等类型则是有限的。判断是否是迭代器对象很简单，只需要知道它是否是可作用于 next() 函数的对象即可。

函数式编程

函数是 Python 内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

而函数式编程（Functional Programming）虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python 对函数式编程提供部分支持。由于 Python 允许使用变量，因此，Python 不是纯函数式编程语言。

高阶函数

函数本身可以赋值给一个变量，即变量可以指向函数。

当一个变量指向了某个函数，那么就可以通过这个变量来调用该函数：

f = abs
print(f(-12))  # 12

其实，函数名本身就是一个指向函数的变量，那么，这个变量自然也可以被重新赋值：

from collections.abc import Iterable

abs = isinstance
print(abs('abc', Iterable))  # True
print(abs(-5))  # 报错：TypeError

由此可知，函数本身也是一个变量，反过来说，我们可以定义一个函数类型的变量，而函数本身是可以接收变量作为参数的，那么，同样函数就也可以接收一个函数类型的参数。这种接收函数作为参数的函数，就被称为高阶函数，例如：

def add(x, y, f):
    return f(x) + f(y)

result = add(2, -4, abs)
print(result)  # 6

总而言之，把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

map / reduce

Python 内建了 map() 和 reduce() 函数。

1. map

   map() 函数接收两个参数，一个是函数，一个是 Iterable，map 将传入的函数依次作用到序列的每个元素，并把结果作为新的 Iterator 返回，例如：

   def f(x):
       return x * x
   
   r = map(f, list(range(1, 10)))  # 返回值是一个Iterator对象
   print(list(r))  # [1, 4, 9, 16, 25, 36, 49, 64, 81]

   通过 map 传递不同的函数参数，可以实现对数组的不同处理。

2. reduce

   reduce 把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce 会把结果继续和序列的下一个元素做累积计算，其效果就是：

   reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

   例如：

   from functools import reduce
   
   def f(x, y):
       return (y - 2) ** x
   
   result = reduce(f, list(x for x in range(2, 7) if x % 2 == 0))
   print(f(f(2, 4), 6))  # 256
   # f(f(2, 4), 6) ==> (6 - 2) ** ((4 - 2) ** 2) ==> 4 ** (2 ** 2) ==> 4 ** 4 ==> 256
   print(result)  # 256

   当然，map 和 reduce 也可以进行组合使用。

filter

Python 内建的 filter() 函数用于过滤序列，它和 map() 类似，也接收一个函数和一个序列。但不同的是，filter() 把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素，例如：

# 过滤掉奇数，保留偶数
def is_odd(x):
    return x % 2 == 1

f = filter(is_odd, list(range(10)))
print(list(f))  # [1, 3, 5, 7, 9]

除了上述示例的用法，还可以有很多用途，例如：去除字符串中的特殊字符、移除数组中的空元素、保留数组中具有某种特征的元素等，总之，filter 的主要作用在于对序列进行过滤和赛选。

map 和 filter 返回的都是 Iterator 。由于迭代器是惰性序列，因此，要强迫其完成计算结果，需要使用 list() 函数获取所有结果并返回数组。

可以尝试用已有知识求出100以内所有素数。

sorted

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个 dict 比较的过程就必须通过函数抽象出来。

Python 内置的 sorted() 函数就可以对 list 进行排序：

print(sorted([36, 5, -12, 9, -21]))  # [-21, -12, 5, 9, 36]

但 sort() 作为一个高阶函数，除了默认的排序之外，它还可以接收一个 key 指定的函数来实现自定义的排序，例如：

def f(x):
    return x ** x - x

# 按绝对值大小排序
print(sorted([36, 5, -12, 9, -21], key=abs))  # [5, 9, -12, -21, 36]
# 按自定义函数方式进行排序
print(sorted([36, 5, -12, 9, -21], key=f))  # [-12, -21, 5, 9, 36]

而如果要对字符串进行排序，sort 默认会对字符串的 ASCII 码进行比较。

而要进行反向排序，只需要指定一个 reverse=True 参数即可：

print(sorted([36, 5, -12, 9, -21]))  # [-21, -12, 5, 9, 36]
print(sorted([36, 5, -12, 9, -21], reverse=True))  # [36, 9, 5, -12, -21]

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回，例如：

# 可变参数求和的懒执行方式
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

f = lazy_sum(1, 3, 5, 7, 9)
# 返回的函数并不是立即执行
print(f)  # <function lazy_sum.<locals>.sum at 0x000001875C48EB80>
# 而是f()函数调用时才执行
print(f())  # 25

这种在函数中定义的函数，称为内部函数，内部函数可以引用外部函数的参数和局部变量，当外部函数被调用并返回内部函数时，相关的参数和变量都会保存在返回的函数中，这种被称为闭包的结构在许多程序中都有广泛的应用。

另外，每次调用外部函数时，返回的内部函数都是一个新的实例：

def fn(x):
    def f():
        return abs(x)
    return f

f1 = fn(-5)
f2 = fn(-5)
print(f1 == f2)  # False

另外，需要注意的是，返回函数不要引用任何循环变量，或者后续会发生变化的变量，反例如下：

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i * i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print(f1())  # 9 （预期是1）
print(f2())  # 9 （预期是4）
print(f3())  # 9

这就会出现函数的返回值和预期不一致，这是因为在返回的函数中引用了循环变量，但这种返回函数并非立即执行，而当多个循环函数都被返回时，循环变量已经变为循环周期的最大值，所以最终调用函数进行计算时，就不会得到预期的循环效果产生的值。

而如果一定要引用循环变量，可以通过如下方式，将循环变量作为参数传入到另一内部函数中，这样就可以保证被绑定的循环变量参数不变：

def count():
    def f(j):
        def g():
            return j * j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i))  # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

f1, f2, f3 = count()
print(f1())  # 1
print(f2())  # 4
print(f3())  # 9

匿名函数

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。

n = list(map(lambda x: x * x, list(range(1, 10))))
print(n)  # [1, 4, 9, 16, 25, 36, 49, 64, 81]

关键字 lambda 表示匿名函数，冒号前面的变量表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写 return ，返回值就是该表达式的结果。

匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数；同样地，也可以把匿名函数作为返回值返回。

f = lambda x: x * x
print(f(4))  # 16

def fn(x):
    return lambda: x ** x

print(fn(3)())  # 27

装饰器

装饰器（Decorator）可以在代码运行期间，动态地增加功能，而其实本质上，装饰器就是一个返回函数的高阶函数。

由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。而函数对象有一个 __name__ 属性，可以获取到函数的名字，据此，我们可以尝试实现一个简单的打印日志的功能：

def log(func):
    def wrapper(*args, **kw):
        print('call %s()' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log  # 通过Python的@语法，将装饰器置于函数的定义处，相当于执行了：say_hi = log(say_hi)
def say_hi(name):
    print('Hi,', name)

say_hi('Zhang San')
print(say_hi.__name__)

# call say_hi()
# Hi, Zhang San
# wrapper  # 函数名错误

当然，你也可以为以上程序添加断点，并观察其执行流程。

但是，如果装饰器本身需要传入参数，那就需要编写一个返回装饰器的高阶函数，相对而言会更加复杂：

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s()' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log("Python")  # 相当于执行了：now = log('Python')(say_hi)
def say_hi(name):
    print('Hi,', name)

say_hi('Zhang San')
print(say_hi.__name__)

# Python say_hi()
# Hi, Zhang San
# wrapper  # 函数名错误

但如代码所示，通过现在的方式调用，被装饰器修饰的函数（say_hi）在执行结束后，其函数名称被替换了，这是因为装饰器是将被修饰的函数（say_hi）作为参数传递到了装饰器的内部，并且最终将其赋值为装饰器内部定义的一个内部函数（wrapper），因此，装饰器修饰的函数所对应的名称（say_hi），其实际上指向的不再是原本定义的函数，而是指向其作为参数传递，并且被赋值到的装饰器的一个内部参数（wrapper），所以最终通过 say_hi.__name__ 获取到的函数名称变为了 wrapper 。

而要解决这样的问题，我们就需要在装饰器中实现类似 wrapper.__name__ = func.__name__ 的功能，但我们其实并不需要手动编写这样的代码，因为 Python 内置了一个 functools.wraps 函数可以实现这样的功能：

import functools  # 导入functools模块

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            # wrapper.__name__ = func.__name__  # 当然，通过这种方式也是可以的，但不推荐
            print('%s %s()' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log("Python")
def say_hi(name):
    print('Hi,', name)

say_hi('Zhang San')
print(say_hi.__name__)

# Python say_hi()
# Hi, Zhang San
# say_hi  # 函数名正确

偏函数

Python 的 functools 模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。

通过函数 functools.partial ，我们可以创建一个偏函数：

# hex字符串转10进制
import functools

int2 = functools.partial(int, base=2)
print(int2('101000', base=10))  # 101000
print(int2('101000'))  # 40
# 相当于
print(int('101000', **{'base': 2}))  # 40

functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，这样调用这个新函数会更简单。而且，调用方可以根据自己的需要，选择是否传递新的值覆盖默认值。

创建偏函数时，实际上可以接收函数对象、 *args 和 **kw 这3个参数，在上面的二进制示例中，实际上是固定了 int() 函数的关键字参数 base 。而其他偏函数也是类似地，是将向偏函数中传入的值作为远函数的一部分，自动添加到所有参数左侧，例如：

import functools

args1 = (5, 6, 7)
max1 = functools.partial(max, 10)
print(max1(*args1))
# 相当于
args2 = (10, 5, 6, 7)
max2 = max(*args2)
print(max2)

当函数的参数个数太多，需要简化时，使用 functools.partial 可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

课间休息，听听音乐吧！

@start.audio

• title: 音乐推荐
  list:
  • https://music.163.com/#/song?id=1501450521
  • https://music.163.com/#/song?id=28461702
  • https://music.163.com/#/song?id=857606
  • http://music.163.com/#/song?id=31545838
  • https://music.163.com/#/song?id=1815109509
  • https://music.163.com/#/song?id=1485319473
    @end.audio

模块

在计算机程序的开发过程中，随着业务逐渐完善，代码会越来越多，也越来越不容易维护。所以，为了便于更好地维护代码，提高开发效率，所有开发语言都有意识地将代码模块进行分化，这也是也是必然的。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在 Python 中，一个 .py 文件就称之为一个模块（Module）。

在不同的模块中，函数的命名是可以重复的，但是我们所编写的函数，应当尽量与 Python 的内置函数区别开来，避免引起不必要的误会和冲突。

可以在官方文档中查看 Python 的所有的内置函数。

另外，对于模块的命名， Python 按照目录来组织模块结构，并且称之为包（Package），而这种目录结构，通常推荐使用公司或企业的组织结构进行命名。

Python 的每个包目录下，都应当存在一个 __init__.py 文件，这个文件是必须的，否则，这个目录就不会被识别为包，而这个 __init__.py 文件本身可以是空文件，也可以有代码内容。

在开发时创建模块，命名时需要注意避开 Python 自带的模块名称，例如系统自带了 sys 模块，就不可再命名为 sys.py ，否则将导致系统的 sys 模块无法导入。

使用模块

Python 本身内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用，一个标准的 Python 文件模板如下：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

""" a test module """

__author__ = 'Chinmoku'

import sys


def test():
    args = sys.argv
    print(args)  # ['A:/pycharm-workspace/py-test/main.py']
    if len(args) == 1:
        print('Hello, world!')
    elif len(args) == 2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')


if __name__ == '__main__':
    test()

前两行是标准注释，第一行注释指定了 Python 的环境，可以让这个文件直接在 Unix/Linux/Mac 环境上运行；而第二行注释则表明了这个文件使用的编码格式，避免解释器读取代码时产生乱码。第四行的字符串是用来指定当前模块的文档注释内容，任何模块的第一个字符串都将被视为该模块的文档注释。而第六行的 __author__ 则指定了当前文件的开发者姓名，方便合作开发和维护。

要使用一个模块，第一步是导入该模块，与其他开发语言大同小异，Python 导入模块的语法如下：

import sys

sys 模块被导入后，就可以通过 sys 这个变量来访问该模块的所有功能。

sys.argv 变量使用 list 存储了命令行的所有参数，它最少有一个参数，即是当前 .py 文件的全名称。

另外，在一个模块中，我们可能会定义很多函数或变量，但是我们希望一些函数或变量仅仅在模块内部进行使用，这时就要通过 _ 前缀来实现。

正常的函数和变量名是公开的（public），可以被直接引用，，比如：abc，x123，PI 等；而特殊变量使用 __xxx__ 方式命名，可以被直接引用，但是有特殊用途，例如 __author__ 、 __name__ 就分别代表作者和当前模块名，而且模块定义的文档注释其实也可以使用变量 __doc__ 来访问（非常规）。

类似 _xxx 和 __xxx 这样的函数或变量就是非公开的（private），不应该被直接引用，比如 _abc ，__abc 等；

但是，Python 其实并没有一种方法可以完全限制访问 private 函数或变量，但是，从编程习惯上不应该引用 private 函数或变量。

外部不需要引用的函数尽量全部定义成 private，只有外部需要引用的函数才定义为 public。

安装第三方模块

在Python中，安装第三方模块，是通过包管理工具pip完成的。

一般来说，第三方库都会在Python官方的 pypi.python.org 网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者 pypi 上搜索，比如 Pillow 的名称叫 Pillow，因此，安装 Pillow 的命令就是：

pip install Pillow

在使用 Python 时，我们经常需要用到很多第三方库，例如，上面提到的Pillow，以及 MySQL 驱动程序，Web 框架 Flask，科学计算 Numpy 等。用 pip 一个一个安装费时费力，还需要考虑兼容性。因此，更加推荐地是使用 Anaconda ，这是一个基于 Python 的数据处理和科学计算平台，它已经内置了许多非常有用的第三方库，可以从Anaconda官网下载安装包。

下载完成后进行安装，推荐不要在安装时勾选自动配置环境变量的选项，而是手动进行配置，配置示例：

在 path 环境变量中，添加如下配置：

A:\anaconda3
A:\anaconda3\Scripts
A:\anaconda3\Library\bin

在命令行中输入 python ，在回车输出的结果中，如果有 Anaconda 字符，就表示安装成功。

当我们试图加载一个模块时，Python 会在指定的路径下搜索对应的 .py 文件，如果找不到，就会抛出 ModuleNotFoundError 异常。

默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在 sys 模块的 path 变量中：

import sys
print(sys.path)

如果要添加自定义的搜索目录，有以下两种方式：

1. 直接修改 sys.path ，添加自定义的搜索目录：

   import sys
   sys.path.append('/Users/chinmoku/py_test)

   这种方法是在运行时进行修改，程序运行结束后即失效。

2. 设置环境变量 PYTHONPATH ，该环境变量的内容会被自动添加到模块搜索路径中。

面向对象编程

由于本人的第一开发语言 Java 本身就是一种面向对象的语言，因此，部分与 Java 共通的思想或基础概念，这里会有所省略。

类和实例

Python 通过如下方式定义一个类：

class Student(object):
    pass

其中， class 是定义类的关键字， Student 是类名，而紧接着的 (object) 表示当前类所继承的父类，所有的类最终都会继承自 object 类。

根据已有的类创建类的实例：

# 定义一个类
class Student:
    def __init__(self, name):
        self.name = name

    def get_name(self):  # 方法
        return self.name


zhang = Student('zhang')
print(zhang)  # <__main__.Student object at 0x000002153559BA60>
print(zhang.get_name())  # zhang

__init__() 是一个特殊的函数，这个方法在获取类的实例时被调用，可以进行对实例进行一些初始化定义，它可以有多个参数，但第一个参数必须是 self ，表示创建的实例本身。在创建实例时，要根据 __init__() 函数所需要的参数匹配传值，但 self 参数在传值时可以忽略，因为 Python 解释器会自动将实例变量传入到这个函数中。

在类中声明的函数与普通函数基本一样，但在类中声明的函数默认会有一个 self 参数，和 __init__() 函数一样，调用函数时忽略 self 参数即可。

数据封装是面向对象编程的一个重要特点。

我们定义一个类，并且通过 __init__() 函数可以创建出该类的实例，但对于创建的实例，是可以调用类内部定义的方法的，这些在类内部的函数与类本身是关联起来的，我们称这些函数为类的方法，如上述代码片段中的 get_name() 函数。而要调用类的方法也很简单，通过实例直接调用即可。这样，对于实例而言，它并不需要关心调用的方法内部的实现细节，这是封装的好处之一。封装的另一好处是可以给类增加新的方法，而类的实例只需要直接调用方法即可。

总而言之：

• 类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；

• 方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；

• 通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节；

Python 允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同。

访问限制

在 Class 内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。但是，外部仍旧可以自由访问和修改一个实例内部的属性，如果不希望内部属性被外部访问，可以使用 __name 这种方式对属性进行命名。该变量就会变为一个私有变量，这样，这个变量就只有内部可以访问，而外部是无法访问的。

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

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

zhang = Student('zhang')
print(zhang._Student__name)  # zhang
print(zhang.__name)  # AttributeError: 'Student' object has no attribute '__name'
zhang.set_name('zhou')

print(zhang.get_name())  # zhou

其实在上文已经多次提到，以 __xxx 方式命名变量，并不能保证变量不被外部直接访问，例如在上面的代码清单中，其实通过 .Student__name 依然能够得到私有变量的值，而之所以说通过 __xxx 方式可以声明为私有变量，其实仅仅是出于约定俗成的规定，而非出于程序的强制要求，往往更多的是需要开发者拥有主动意识，自觉遵守这些约定或规范。

注意： __xxx__ 命名方式，表示这个变量是一个特殊变量，它不是私有变量，可以被直接访问，所以在属性命名时，不应当以这种方式命名。另外，以 _xxx 这种方式命名的变量，是可以被外部访问的，但作为一种约定俗成的规定，我们应当尽量将它当做私有变量看待。

继承和多态

前面提到封装是面向对象编程的一个重要特点，而继承和多态则是面向对象编程的另外两大特点。

当我们定义一个类的时候，我们定义的这个类可以从某个类继承，因此新创建的类相对被继承的类而言就是子类，而被继承的类就是基类、父类或超类。

class Animal:
    def run(self, ani):
        print('%s can run' % ani)

class Dog(Animal):
    def __init__(self, type_name):
        self.type_name = type_name

    def get_type_name(self):
        return self.type_name

    # 子类可以重写父类的方法
    def run(self, type):
        print('%s can run every!' % type)

class Cat(Animal):
    def __init__(self):
        pass

catA = Cat()
catA.run('Cat')  # 子类可以调用父类的方法
# Cat can run

dogA = Dog('Dog')

dogA.run(dogA.get_type_name())
# Dog can run every!

继承的好处在于不用进行任何声明就可以获得父类的全部功能，而且子类仍然可以对自身进行扩展和增强而不受父类限制，例如新增属性和方法。

当子类和父类存在相同的方法时，我们便说子类覆盖了父类的方法。当实例调用该同名方法时，就只会调用子类的方法，而不会调用父类，这种特性在面向对象的思想里被称为多态。

在 Python 基础中我们提到过，可以使用 isinstance() 函数来判断某个变量是否是某种类型。而在这里的实例中，我们同样可以通过这种方法来对拥有继承关系的子类对象和父类进行判断：

print(isinstance(catA, Cat))  # True
print(isinstance(dogA, Dog))  # True
print(isinstance(catA, Animal))  # True
print(isinstance(dogA, Animal))  # True
animal = Animal()
print(isinstance(animal, Dog))  # False

静态语言与动态语言：

对于静态语言来说（例如 Java），如果需要传入 Animal 类型，那么就必须传入 Animal 类型或它的子类，否则无法调用其 run() 方法。

而对于 Python 这样的动态语言来说，则不一定非要传入 Animal 类型或其子类，我们只需要保证传入的对象有一个 run() 方法即可。

Python 具有这种 file-like-object 的特点，它并不严格要求继承体系，这就是所谓的“鸭子类型”。

鸭子类型：一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

获取对象信息

当我们获得一个对象的引用时，我们可以通过 type() 函数来判断该对象的类型，当然，如果一个变量指向函数或类，也可以使用 type() 函数进行判断：

print(type(dogA))  # <class '__main__.Dog'>
print(type(dogA) == Dog)  # True
print(type(dogA) == type(catA))  # False

type() 函数返回的是一个 Class 类型，除了自定义的类型之外，也可以判断内置的类型：

import types

def fn():
    pass

print(type(fn) == types.FunctionType)  # True
print(type(lambda x: x) == types.LambdaType)  # True
print(type((x for x in range(10)))==types.GeneratorType)  # True

type 函数可以判断一个对象的类型，但对于拥有继承关系的对象而言，就无法判断它的父级类型，对于这种情况，我们仍旧可以使用 isinstance() 函数进行判断，它可以判断对象是否处于某一继承链上。

print(isinstance(catA, Animal))  # True
print(isinstance(dogA, Animal))  # True
print(isinstance(dogA, Cat))  # False
print(isinstance(dogA, (Cat, Dog)))  # True # 判断是否是多个对象中的一种

如果要获得一个对象的所有属性和方法，可以使用 dir() 函数，它返回一个包含字符串的 list ；如果想要获取对象长度，可以使用 __len__() 方法或 len() 函数，他们是等价的，并且，我们可以重写类中的 __len__() 方法。

class Cat(Animal):
    def __init__(self):
        pass
    
    def __len__(self):
        return 20

catA = Cat()
print(dir(catA))  # ['__class__', '__delattr__', '__dict__', '__dir__' ...
print(len(catA))  # 20

另外，对象还提供了 getattr() 、 setattr() 、 hasattr() 函数，可用于操作类中的属性。

# print(getattr(dogA, 'color'))  # AttributeError: 'Dog' object has no attribute 'color'
print(getattr(dogA, 'color', None))  # None # 获取属性时，可以传入一个默认值，当属性不存在时生效
print(hasattr(dogA, 'color'))  # False
setattr(dogA, 'color', 'brown')
print(hasattr(dogA, 'color'))  # True
print(getattr(dogA, 'color'))  # brown
print(getattr(dogA, 'run'))  # <bound method Dog.run of <__main__.Dog object at 0x000001BB085C2FA0>> # 判断是否有某方法

这些用于获取属性的方法或函数，通常是在不知道某一个类是否具有该方法时才使用的。

实例属性和类属性

对于一个类的实例，我们可以通过实例变量直接声明或使用 self 参数的方式声明以为其绑定属性。但对一个类本身，我们也可以通过如下方式为这个类声明属性：

class Student:
    name = 'Student'

    def __init__(self):
        pass

student = Student()
print(student.name)  # Student
print(Student.name)  # Student
student.name = 'Teacher'
print(student.name)  # Teacher
del student.name
print(student.name)  # Student

这个为类声明的属性虽然为类所有，但这个类的所有实例均可以访问该属性。如果类属性与实例属性同名，调用属性时默认从实例属性中获取，如实例属性未获取到，则从类属性中获取。因此，在编程时，我们应当尽量避免出现实例属性与类属性同名的情况。

面向对象高级编程

_slots_

对于一个已声明的对象的实例，我们可以为其绑定任何属性和方法，但是为某一实例绑定的属性或方法，仅对当前实例有效，如果需要为所有实例都绑定属性或方法，则可以直接将属性或方法绑定到类上。给类绑定实例或方法后，这个类的所有实例均可调用。

class Student:
    def __init__(self):
        pass

student1 = Student()
student1.name = 'Zhang'
print(student1.name)  # Zhang
student2 = Student()
# print(student2.name)  # AttributeError: 'Student' object has no attribute 'name'
Student.age = 17
print(student1.age)  # 17
print(student2.age)  # 17

但是，为示例绑定属性或方法并不受任何限制，如果需要限定实例需要绑定的属性或方法，可以通过 __slots__ 来指定：

class Student:
    __slots__ = ('name', 'study')

    def __init__(self):
        pass

def study(name):
    print('%s is studying!' % name)

student1 = Student()
student1.name = 'Zhang'
student1.study = study
student1.study(student1.name)  # Zhang is studying!
student1.age = 17  # AttributeError: 'Student' object has no attribute 'age'

__slots__ 使用 tuple 来指定多个属性名，实例在绑定属性或方法时，所绑定的属性或方法的名称必须在 __slot__ 属性中存在，否则就会抛出异常。

注意： __slots__ 中定义的属性仅仅对当前类的实例起作用，对继承的子类是不起作用的，除非在子类中也进行声明，这样，子类和父类的 __slots__ 限制会进行叠加。

class Person:
    __slots__ = ('name', 'age')

class Student(Person):
    __slots__ = ('grade', 'score')

student1 = Student()
student1.name = 'Zhang'
print(student1.name)  # Zhang
student1.character = 'forthright'  # AttributeError: 'Student' object has no attribute 'character'

@property

对于一个类的属性，声明的实例直接调用属性是不安全而且无法进行任何限制的，如果需要对属性进行限制，我们可以使用 Python 内置的 @property 装饰器来将一个方法变为属性调用。

class Student(object):

    @property  # getter
    def score(self):
        return self._score

    @score.setter  # setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

student1 = Student()
# student1.score = 'C'  # ValueError: score must be an integer!
# student1.score = 120  # ValueError: score must between 0 ~ 100!
student1.score = 60
print(student1.score)  # 60

如果需要定义一个只读属性，那么，我们只需要不对 setter 进行定义即可。

但需要注意一点，属性的方法名不应当与实例变量重名，这样会导致无线递归，最终赵成栈溢出，错误示例：

class Student(object):

    @property
    def score(self):  # 属性方法名为 score
        return self.score  # 实例变量名也为 score

多重继承

在面向对象的思想中，一个类是可以同时继承多个类的，但在设计类的继承关系时，通常，主线都是单一继承下来的，如果需要“混入”额外的功能，通过多重继承就可以实现，这种设计通常称之为 MixIn 。

class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
    pass

MixIn 的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个 MixIn 的功能，而不是设计多层次的复杂的继承关系。

Python 自带的很多库也使用了 MixIn。例如 Python 自带了 TCPServer 和 UDPServer 这两类网络服务，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由 ForkingMixIn 和 ThreadingMixIn 提供，于是，我们可以通过不同的组合来创建合适的服务。

# 多进程模式的TCP服务
class MyTCPServer(TCPServer, ForkingMixIn):
    pass

# 多线程模式的UDP服务
class MyUDPServer(UDPServer, ThreadingMixIn):
    pass

通过这种 MixIn 方式，我们不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类。

只允许单一继承的语言（如Java）不能使用 MixIn 的设计。

定制类

_str_

当我们在打印一个类的实例时，通常打印的都是都是这个实例的内存地址信息，如需要有意义的自定义实例信息，可以使用 __str__() 方法：

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

    def __str__(self):
        return 'class Student(name: %s)' % self.name

class Teacher:
    pass

teacher1 = Teacher()
print(teacher1)  # <__main__.Teacher object at 0x000001D2DAC21FD0>
student1 = Student('Zhang')
print(student1)  # class Student(name: Zhang)

_iter_

如果一个类想被用于 for ... in 循环，就必须实现一个 __iter__() 方法，该方法返回一个迭代对象，然后，Python 的 for 循环就会不断调用该迭代对象的 __next__() 方法拿到循环的下一个值，直到遇到 StopIteration 错误时退出循环，例如：

# 斐波那契数列
class Fib:
    def __init__(self):
        self.a, self.b = 0, 1  # 初始化两个计数器a，b

    def __iter__(self):
        return self  # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b  # 计算下一个值
        if self.a > 1000:  # 退出循环的条件
            raise StopIteration()
        return self.a  # 返回下一个值

fib = Fib()
tu = []
for x in fib:
    tu.append(x)

print(tu)  # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]

_getitem_

在上面的斐波那契数列代码清单中，声明的实例对象虽然和 list 很像，但它还不能通过下标获取对应的元素，要实现这一点，可以通过加入 __getitem__() 方法来实现：

def __getitem__(self, n):
    a, b = 1, 1
    for x in range(n):
        a, b = b, a + b
    return a

print(Fib()[4])  # 5

而如果要支持切片方式，则需要更加完善的逻辑：

def __getitem__(self, n):
    if isinstance(n, int): # n是索引
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a
    if isinstance(n, slice): # n是切片
        start = n.start
        stop = n.stop
        if start is None:
            start = 0
        a, b = 1, 1
        L = []
        for x in range(stop):
            if x >= start:
                L.append(a)
            a, b = b, a + b
        return L

print(fib[5:10])  # [8, 13, 21, 34, 55]

_getattr_

当一个实例调用不存在的属性或方法时，就会抛出异常，我们可以定义一个 __getattr__() 方法来动态地返回属性或函数。

class Student(object):

    def __init__(self):
        self.name = 'Michael'

    def __getattr__(self, attr):
        if attr == 'score':
            return 60
        if attr == 'age':
            return lambda: 18
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

student1 = Student()
print(student1.score)  # 60
print(student1.age())  # 18
print(student1.test)  # None

注意：只有在没有找到属性的情况下，才会调用 __getattr__() ，并且，当调用一个不存在的方法或属性时， __getattr__() 方法会默认返回为 None ，我们也可以做自定义处理，例如抛出自定义异常。

实现一个动态路由链：

class Chain(object):

    def __init__(self, path=''):
        self._path = path

    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))

    def __call__(self, path):
       return Chain('%s/%s' % (self._path, path))

    def __str__(self):
        return self._path

url = Chain().user('zhang').status.timeline.list
print(url)  # /user/zhang/status/timeline/list

_call_

在动态路由链的代码清单中，我们使用到了一个 __call__() 方法，这个方法可以直接在实例本身的基础上调用方法。

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

    def __call__(self, str):
        print('Mr. %s is %s' % (self.name, str))

Person('Zhang')('working!')  # Mr. Zhang is working!
person1 = Person('Wang')
print(callable(person1))  # True # 可以使用 callable() 函数判断是否是可调用对象
person1('studying!')  # Mr. Wang is studying!

Python 的 class 允许定义许多定制方法，可以让我们非常方便地生成特定的类，还有很多可定制的方法，详情可参考官方文档。

枚举类

Python 枚举类的声明及使用方式如下：

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

print(Month.May)  # Month.May
print(Month.May.name)  # May
print(Month.May.value)  # 5 # 默认从1开始计数
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)

如果需要更精确地控制枚举类型，可以从 Enum 派生出自定义类：

from enum import Enum, unique

@unique  # 用于检查重复
class Weekday(Enum):
    Sun = 0  # 自定义值
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

print(Weekday.Thu)  # Weekday.Thu
print(Weekday.Thu.name)  # Thu
print(Weekday.Thu.value)  # 4
print(Weekday(3))  # Weekday.Wed # 也可以通过value来获取对应的枚举
for name, member in Weekday.__members__.items():
    print(name, '=>', member, ',', member.value)

元类

动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，而是运行时动态创建的。

通过 type() 函数可以查看一个类型或变量的类型，同时， type() 函数既可以返回一个对象的类型，又可以创建出新的类型，而无需通过 class Hello(object)... 这样的方式定义。

def fn(self, name='world'):
    print('Hello, %s!' % name)

Hello = type('Hello', (object,), dict(hello=fn))
h = Hello()
h.hello()
# Hello, world!

通过 type 函数创建类需要接收三个参数：

1. class 类名。
2. 继承的父类集合。
3. class 的方法名称与函数绑定。

通过 type 函数创建的类和直接创建的类没有任何区别，因为通过 class 定义的类在解释器执行时，实际上也是通过调用 type 函数来进行定义的。正常情况下，我们通过 class 来创建类即可，但 type 函数允许我们动态地将类创建出来。也就是说，动态语言本身支持运行期动态创建类。

除了使用 type 函数动态创建类以外，要控制类的创建行为，还可以使用 metaclass （元类），元类可以对类进行创建和修改等操作。

# 定义一个元类
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

# 使用元类来创建类
class MyList(list, metaclass=ListMetaclass):
    pass

l = MyList()
l.add(1)
l.add(9)
print(l)  # [1, 9]