PyThon最详细入门语法笔记

写在前面：这篇笔记是由本人原创(也是第一篇原创，萌新.jpg)，兄弟萌如果觉得不错的话，可以点个关注或收藏，方便以后查阅呀。

前言

由于疫情的原因，今年考研复试推迟，得以多出很多准备复试的时间。在此期间（被困武汉啦，痛苦.jpg），我自学了PyThon，为了总结这段时间的学习成果，同时方便今后的查阅，遂写下这篇PyThon入门学习笔记。
几乎任何一门高级编程语言，都由两部分组成：语法（语言法则）和函数库（如C++的STL），PyThon也不例外。目前，PyThon之所以非常火热的原因之一，就在于它有丰富且功能强大的标准库和第三方库（如科学数值计算库NumPy、Pandas，计算机视觉库OpenCV，深度学习库Keras、TensorFlow，绘图库Matplotlib)。由于时间有限，这篇笔记只包含PyThon的语法部分和部分内置库（标准库）。
本人使用的调试工具是Jupyter Notebook在线调试工具，具体使用方法参考了以下这篇良心佳作：
Jupyter Notebook介绍、安装及使用教程

一、PyThon数据：常量与变量

1. 常量

PyThon共有4个基本数据类型：整型（int），浮点型（float），字符串（str），布尔型（bool），均以对象的形式存在。

1.1 整型

默认无小数点的数据为整型（int），如var = 123，123被默认为整型常量。

1.2 浮点型

默认有小数点的数据为浮点型（float），如var = 123.或123.0，123.被默认为浮点型常量。

1.3 字符串

PyThon字符串可以被单引号、双引号或三引号包裹，如'abc'、"abc"、'''abc'''
单引号或双引号只能包裹单行字符串，而三引号可以包裹多行字符串。

1.4 布尔型

只有真值（True）和假值（Flase），注意PyThon区分字母大小写，首字母均大写。

2. 变量

跟其他高级语言不一样，PyThon是一种动态语言，变量无需定义，直接赋值，可理解为是赋值对象的标签或引用（即不是赋值对象本身）。动态是指：变量的类型可变，取决于赋值对象的类型。

2.1 查看变量类型：type(变量名)

2.2 强制类型转换：类型名 (变量名)

如：int (var)
bool(var)：非0数字或非空串返回True，否则返回False

二、PyThon数据运算

1. 数学运算

1.1 加：var1 + var2

1.2 减：var1 - var2

1.3 乘：var1 * var2

1.4 除

9/5：返回浮点型商1.8
9//5：返回商的整数部分1

1.5 求余

9%5：返回余数4

1.6 乘方

计算x的y次幂：
方法1：x ** y
方法2：
import math
math.pow(x, y)

1.7 根方

计算x的y次根方：
import math
math.pow(x, 1/y)

特殊地，计算x的平方根：
方法1：x ** 0.5
方法2：import math
math.pow(x, 0.5)
方法3：import math
math.sqrt(x)

2. 比较运算

2.1 等于==

2.2 不等于 !=

2.3 其他比较运算符

<、<=、>、>=

3. 逻辑运算

注意：PyThon中使用英文单词表示逻辑运算，没有逻辑运算符&&、||、！。

3.1 与运算：and

3.2 或运算：or

3.3 非运算：not

3.4 异或运算：!=

4. 统计运算

4.1 求最大值：max(DS对象)

4.2 求最小值：min(DS对象)

三、PyThon数据结构(重要)

1. 字符串str

1.1 创建字符串

str_var = 'xiaoMing' 或 “xiaoMing" 单引号或双引号包裹单行字符串

#三引号包裹多行字符串
str_var = '''xiaoMing 
			xiaoHong'''                      

1.2 类型转换为字符串型

整型int转换为str：str(123)
浮点型float转换为str：str(123.0)
布尔型bool转换为str：str(True)或str(False)

1.3 转义字符\的应用

转变原本字符的含义：
\n：换行
\t：制表
'：单引号
\：反斜杠

1.4 字符串的数学运算

1.4.1 字符串拼接

'xiao' + 'Ming' 不会修改’xiao’本身
'xiao' += 'Ming' 会修改 'xiao’本身

1.4.2 字符串复制

'ab' * 3 返回 字符串 ‘ababab’

1.5 字符串切片操作：提取子串

english = 'abcdefg'，注意以下切片操作均不会改变english本身。

1.5.1 整数索引：切单个字符

english[0] = 'a' 第一个元素索引为0
english[-1] = 'g' 最后一个元素索引为-1

1.5.2 切片索引：用冒号分割，前闭后开

english[0: 2]或english[: 2] = 'ab' 从前切
english[-3: ] = 'efg' 从倒数第3个开始一直切到最后
english[-3: -1] = 'ef' 前闭后开
english[: ] = 'abcdefg' 切整个字符串
english[0: 4: 2] = 'ac' 加步长2
english[ : : -1] = 'gfedcba' 或 glish[ : : -2] = 'geca'
负步长从后往前切，只支持整体切片

1.6 字符串函数或方法

english = 'abcdefg'，注意以下函数或方法不会改变english本身，只会返回一个新串对象。

1.6.1 求长度函数

len(english) = 7

1.6.2 分割方法

字符串.split() 默认以空格为分隔符，返回一个子串列表。
字符串.split('a')以字母a为分隔符，返回一个子串列表。
以此类推。

1.6.3 去空白符方法

字符串.strip() 默认去掉字符串前后所有空白符 (包括空格、\n、\t、\r、\f)。
字符串.strip('.') 去掉字符串前后所有的小数点。
字符串.strip('a') 去掉字符串前后所有的字母a。
以此类推。

1.6.4 大小写转换方法

字符串.upper() 转大写
``字符串.lower() 转小写

1.6.5 首字母大写方法

字符串.capitalize()

1.6.6 右对齐方法

字符串.rjust(n) 不足n位填充空格

1.6.7 居中方法

字符串.center(n)

1.6.8 替换方法

字符串.replace(被替换子串，替换串)
如：english.replace('cd', 'qq') = 'abqqefg' 查找english中所有的’cd’并替换为 ‘qq’。

1.6.9 子串计数方法

字符串.count(子串） 计算子串的数量

1.6.10 是否以指定子串开头或结尾方法

字符串.startswith(子串) 返回True或False
字符串.endswith(子串) 返回True或False

1.6.11 查找子串方法

字符串.find(子串) 返回子串第一次出现的位置索引(从左数）
字符串.rfind(子串) 返回子串第一次出现的位置索引 (从右数)

1.6.12 连接方法

','.join(子串列表） 用逗号将子串连接成一个新的字符串
字符串.join(子串列表) 用指定字符串将子串连接成一个新的字符串

2. 列表list

重要特性：可以包含不同类型的元素，但元素有序，用[ , ]表示。

2.1 创建列表

方法1：直接创建，[123, 123.4, 'abc', True]。[]代表空列表。
方法2：list()函数将其他数据结构对象(如字符串、元组、集合等)、迭代器、生成器转换为列表
如：list(range(5)) 返回[0, 1, 2, 3, 4]

2.2 列表嵌套

列表元素也可以是列表，提取子列表元素使用双重索引。

2.3 列表切片操作

类似于字符串的切片操作，分为整数索引切片和切片索引切片两种，不同之处在于，无论是整数索引还是切片索引，字符串切片返回的均是子串，类型为str。而列表整数索引返回指定元素，切片索引返回子列表。

2.4 列表修改

可使用切片索引同时对多个元素修改
如a[ : 2] = [100, 200]

2.5 列表合并

方法1：a + b，返回新列表，但a和b不变
方法2：a.extend(b) 将b的元素添加至a的末尾，a变b不变

2.6 列表添加元素

方法1：a.append(新元素) 将新元素添加至末尾，返回None
方法2：a.insert(index, 新元素) 将新元素添加至指定位置

2.7 列表删除元素

方法1：a.pop() 默认删除最后一个元素并将其返回
方法2：a.pop(index) 删除指定位置元素并将其返回
方法3：del a[index] 删除指定位置元素但不作返回
方法4：a.remove(元素值) 删除指定元素值，返回None

2.8 判断指定值是否在列表中

元素值 in a 返回True或False

2.9 列表元素定位

a.index(元素值) 类似字符串的find()方法

2.10 统计指定元素的个数

a.count(元素值)

2.11 列表排序

a.sort()

2.12 列表求长度

len(a)

3. 字典dict

重要特性：无序，用{key1:value1, ...}表示，每一个元素的键key互不相同。

3.1 创建字典

方法1：直接创建，{k1: v1, k2: v2, ...}，{}代表空字典。
方法2：dict()将其他类型的数据结构、迭代器、生成器转换为字典。

3.2 字典取值

因为字典无序，所以没有切片操作。
方法1：a[key]做右值时，代表对应的value，取值。如果不存在，会报KeyError异常。
方法2：a.get(key)，如果不存在，默认返回None
方法3：a.get(key, return_default)，如果不存在，返回指定return_default。

3.3 字典修改(一定条件下添加)

a[key] = value，如果存在key，则修改其值，如果不存在，则添加一个键值对。

3.4 字典合并

a.update(b) 将字典b中的键值对添加至字典a中，a变b不变。

3.5 字典删除

del a[key] 删除指定键值对

3.6 清空字典

a.clear() 清空字典a中元素，使a变为空字典{}

3.7 判断指定键是否在字典中

key in a 返回True或False

3.8 字典方法

a.keys()、a.values()、a.items()分别返回键、值和键值对元组组成的列表迭代器 (即封装起来的列表)

4. 元组tuple

重要特性：元组一旦指定便不可改变(元素的值和顺序均不可改变)，因此元组对象可以作为字典或集合的key，而列表对象不能；元素类型可以不同；有序 (可以进行切片操作)。

4.1 创建元组

方法1：直接创建：注意PyThon解释器通过逗号，判断是否是一个元组，而不是小括号()
多元素：(123, 123.4, 'abc')或123, 123.4, 'abc'
单元素：(123,)或123,
空元组：()
方法2：tuple()将其他类型数据结构、迭代器、生成器转换为元组。

4.2 元组解包赋值

a = (1, 2, 3)
b, c, d = a
相当于元组a赋值给由b、c、d组成的元组，b = 1, c = 2, d = 3。

4.3 解包数据交换

a, b = b, a 等价于a与b交换数据。

5. 集合set

重要特性：元素值唯一；无序；用{key1, key2, ...}表示。

5.1 创建集合

方法1：直接创建，{key1, key2, ...}。
方法2：set()将其他类型数据结构、迭代器、生成器转换为集合。
注意：{}表示空字典，而不是空集合。只能使用set()创建或表示。

5.2 集合运算

5.2.1 交集 &

set1 & set2

5.2.2 并集 |

set1 | set2

5.2.3 差集 -

set1 - set2

5.3 添加元素

方法1：set1.update(新元素)
方法2：set1.update(set2) 等价于并集运算，但会改变set1。

5.4 判断元素是否在集合中

key in set1 返回True或False。

四、PyThon程序

1. 代码结构风格

1.1 代码块

与C语言、Java等高级语言使用成对的{}区分代码块不同，PyThon使用缩进Tab(4个空格)区分代码块。

1.2 注释

PyThon使用 # 作为注释的起始标志符，但只能注释单行。
PyCharm编辑器中注释多行文本的快捷键：Ctrl + /

1.3 代码连接符：反斜杠\

当一行写不下完整代码时，只需在这行末尾写下反斜杠\，然后回车换行在下一行继续写即可。

2. 程序控制结构

跟其他高级语言一样，PyThon有三种控制结构：顺序结构，条件分支结构和循环结构。

2.1 条件分支结构

2.1.1 if-else结构

if 条件表达式：
	代码块1
else：
	代码块2

2.1.2 if-elif-else结构

if 条件表达式1：
	代码块1
elif 条件表达式2：
	代码块2
else：
	代码块3

2.1.3 条件表达式

形式1：var1 条件运算符 var2
形式2：var1 条件运算符 var2 逻辑运算符 var3 条件运算符 var4
形式2：元素 in 数据结构DS
形式3：bool(var)，为False的情形有：var = None、0、0.0、''(空串)、[]空列表、()空元组、{}空字典、set()空集合。

2.2 循环结构

2.2.1 while循环结构

while 条件表达式：
	代码块

2.2.2 for循环结构

2.2.2.1 一般形式

for 元素变量 in 数据结构对象DS：
	代码段

2.2.2.2 循环遍历字典

for i in dict1 等价于for key in dict1.keys()，即循环遍历字典的键key。
for value in dict1.values()，循环遍历字典的值value。
for key, value in dict1.items()，循环遍历字典的键值对。

2.2.2.3 并行迭代多个数据结构

for var_a, var_b, var_c in zip(list_a, list_b, list_c)：
	代码块

zip(list_a, list_b, list_c)是打包函数，返回一个迭代器，list_a, list_b, list_c的长度可不同，按最短长度计算。

2.2.2.4 并行迭代元素索引和元素值

for id_, x in enumerate(list_DS)
可以理解为enumerate将每个列表元素和它的索引打包成元组，然后包装成一个列表迭代器。

2.2.2.5 循环遍历range对象

for i in range(start, end, step)：
	代码块

range(start, end, step)返回一个生成器，前闭后开[start, end)。默认start = 0，step = 1，range(end) 等价于range(0, end, 1)。
list(range(start, end, step))返回一个列表。

2.2.2.6 for循环的应用–推导式

由一个或多个迭代器生成数据结构DS

2.2.2.6.1 列表推导式

[expression for 元素变量 in DS或迭代器或生成器 if 条件表达式]
如:
[word.title() for word in list1]
[word for word in list1 if len(word) > 5]

2.2.2.6.2 字典推导式

{word: len(word) for word in list1}

2.2.2.6.3 集合推导式

{len(word) for word in list1}

2.2.2.6.4 无元组推导式

(expression for 元素变量 in DS或迭代器或生成器 if 条件表达式)是一个生成器，而不是一个元组推导式。

2.2.2.7 迭代器与生成器的联系与区别

联系：二者都可以理解为是PyThon数据结构的包装，可用于for循环中；
区别：迭代器是一个对象，在内存中实际存在，可被反复使用，如dict.keys()等方法返回值均是迭代器；而生成器可理解为是一个临时对象，只能迭代使用一次，使用完毕之后便被释放。

2.2.3 终止循环

方法1：break跳出整个循环
方法2：continue跳出本轮循环

3. 程序异常处理

Exception是异常基类，IndexError是派生异常类。

3.1 异常处理形式1

try：
	正常代码
except：
	错误处理代码(与异常对象无关)

3.2 异常处理形式2

try：
	正常代码
except Exception as e：
	错误处理代码(与异常对象e有关)

3.3 异常处理形式3

try：
	正常代码
except IndexError as e1：
	错误处理代码1(与异常对象e1有关)
except 异常类2 as e2：
	错误处理代码2(与异常对象e2有关)
except Exception as other：
	错误处理代码3(与异常对象other有关)

4. PyThon解释环境

在cmd对话框中输入python进入交互式PyThon解释器；退出：exit()

5. 程序保存和执行

程序完成之后保存为*.py文件
在cmd对话框中输入python *.py便可执行该PyThon文件。

五、PyThon模块

模块通常完成一个相对独立的功能。
一个.py文件就是一个模块或者一个模块保存成一个.py文件，里面可以包含若干函数定义。如常用数学函数模块就是math.py文件，里面定义有求平方根的函数sqrt(x)。

1. 导入模块

import filename 或 import filename as fn(别名)
其实就是导入一个.py文件，无需写后缀名.py。

2. 调用导入模块下的函数

想要使用模块中的某个函数：filename.函数名(...)

3. 导入模块下的函数

from 模块名 import 函数名
或
from 模块名 import 函数名 as 别名

4. 直接导入PyThon标准库中的模块

import 标准模块名
即可直接写标准模块名，而不用管标准模块在标准库中的路径。

5. 常用PyThon标准模块

5.1 sys标准模块

sys.argv可理解为是sys.py文件中的全局变量，用于保存命令行参数，如当在命令行窗口中输入python a.py b c d，那么解释器会将参数打包成字符串列表传递给sys.argv = ['a.py', 'b', 'c', 'd']。

5.2 time标准模块

5.2.1 求当前系统时间

import time
time.time()

6. 模块管理：包

多个模块(.py文件)放在同一个文件夹dir下，并且当在这个文件夹中添加一个init.py模块(可以为空)时，这个文件夹dir就变成了PyThon包。

7. PyThon包管理工具

pip是PyThon内置的包管理工具，负责安装和管理第三方库。其实它就是安装PyThon时自带的一个可执行文件，位置在：安装根目录\Python36\Scripts

7.1 安装命令

在cmd对话框中输入：
pip install 包名
Pypi是第三方工具包的安装发布网站。

7.2 卸载命令

在cmd对话框中输入：
pip uninstall 包名

六、PyThon函数

函数的作用：接受参数输入，返回计算结果。

1. 函数定义

1.1 无参函数定义

def 函数名()：
	函数体/pass
	return 表达式（可选）

1.2 有参函数定义

无需指明返回值类型和参数类型

def 函数名(参数名1，参数名2，...)：
	函数体/pass
	return 表达式（可选）

1.3 函数定义的位置

可以定义在一个.py文件的非类体的任何位置。定义完毕之后可以在该.py文件的任何位置(包括类体)处调用。如果想要在另外一个.py文件中调用，只需import导入该.py文件的这个函数即可。

2. 函数调用

无参函数名()或有参函数名(实参1，实参2，...)

3. 函数参数

从实参赋值角度出发，函数参数分为两种：位置参数和关键字参数。

3.1位置参数

实参与形参按位置一一对应赋值，即实参的排列顺序必须形参的排列顺序一致。

3.2 关键字参数

实参赋值时，指定形参关键字，这时赋值的排列顺序不必与形参的排列顺序一致。
即：函数名(arg1 = value1, arg2 = value2, ...)

从其他角度出发的特殊函数参数

3.3 默认参数

在定义函数时指定形参默认值。

3.4 不定参数1：在形参前加一个*

def 函数名(* arg)：
	函数体

arg是不定参数，不定的含义是指：调用时实参的个数不确定。可以使用位置参数或关键字参数，解释器会将实参打包成元组赋值arg，可以理解为arg是这个元组的引用。
如函数名(1, 2)或函数名(a = 1, b = 2)，解释器会将实参打包为元组(1, 2)赋给arg。

3.5 不定参数2：在形参前加两个*

def 函数名(** arg)：
	函数体

arg是不定参数，不定的含义是指：调用时实参的个数不确定。只能使用关键字参数，解释器会将形参关键字和实参打包成字典赋值arg，可以理解为arg是这个字典的引用。
如函数名(a = 1, b = 2)，解释器会将形参和实参打包为字典 {‘a’: 1, ‘b’: 2} 赋给arg。

4. 匿名函数(lambda函数)

通常可以在一行写完。

4.1 匿名函数定义

lambda 变量x：函数体(对变量x操作)

4.2 匿名函数调用

map(lambda x：函数体，DS)
map()函数的作用是：循环遍历DS中的每一个元素，将其赋值给变量x并应用到lambda函数体上，最终返回一个迭代器(在内存中实际存在)。

5. 函数返回值

函数接受输入，最终以两种形式返回计算结果：return和yield。

5.1 return返回

return 表达式是可选项，当不写时，等价于 return None；
一个函数体中可以包含多个return 表达式，但至多有一个执行，因为一旦执行其中某个return 表达式，函数执行完毕并返回相应结果。

5.2 yield返回

5.2.1 带有yield的函数定义

函数定义：

#参数通常是一个数据结构DS，如列表list
def 函数名(参数)：
	函数体
	yield 表达式

yield 表达式通常在for循环体中，迭代一次生成一个值，并将这个值添加到临时数据结构中，迭代完毕时，会将这个临时数据结构封装成generator object生成器对象返回。

5.2.2 带有yield的函数调用

函数调用：
函数名(DS名) 类型：生成器对象

6. 命名空间：name space

一个函数对应一个命名空间。
一个.py文件中，定义在所有函数外的变量称为全局变量，即全局命名空间(主函数命名空间__main__)中的变量。

6.1 引用全局变量 global s

如果全局变量没有跟局部变量重名，那么可以在函数体内直接引用全局变量的值(即全局变量做右值)；

如果全局变量跟局部变量重名，但是没有显示引用全局变量，那么在函数体内局部变量覆盖全局变量的作用域。

如果想要在函数体内修改全局变量s的值，必须先引用global s，再修改。

6.2 查看全局变量和局部变量

globals() 返回全局命名空间__main__中的变量字典。
locals() 返回局部命名空间中的变量字典。

七、PyThon类

1. 创建类

#类名通常首字母大写
class 类名()：		
	#对象方法__init__相当于是构造器，用于定义对象属性。
	#被self修饰的arg1、arg2、arg3是对象属性，即成员变量。
	def __init__(self, arg1, arg2, ...)：
		self.arg1 = arg1
		self.arg2 = arg2
		self.arg3 = 0
	#定义对象方法，即成员函数
	def 方法名(self, 参数表)：
		方法体			

2. 创建对象

a = 类名()
类名通常首字母大写

3. 类继承

3.1 继承格式

class 子类名(父类名)：
	新类体

子类会继承父类的构造器和方法。
默认父类为object基类，因此class 类名()等价于class 类名(object)。

3.2 在继承父类的属性基础上添加新属性

重新定义__init__方法，并且在类体中使用 super().__init__(旧参表)继承父类属性，然后使用 self.新属性 = 新属性值 添加新属性。

3.3 覆盖或重写父类方法

默认情况下，子类会自动继承父类方法，如果子类想要重写父类的某个方法，只需在子类体中重新定义同名方法即可。

4. 类的属性

类的属性既可以分为类属性和对象属性，又可以分为公有属性和私有属性。

4.1 类属性和对象属性

区别1：从定义角度看，对象属性是通过在特殊的对象方法__init__(self, ...)中被self修饰定义得到，而类属性是在所有类方法体外直接定义得到，即类属性名 = 初始类属性值。
区别2：从访问角度看，对象属性只能通过对象访问，对象名.属性名，而类属性既可以通过对象名访问，也可以通过类名访问。
区别3：从共享角度看，每个对象拥有自身的对象属性，有n个同类对象，那么在内存中便有n份对象属性，不共享，而类属性在内存中只有1份，由所有该类对象共享，可以理解为全局变量。

4.2 公有属性和私有属性

区别1：从定义角度看，以__开头的属性名指定为私有属性。
区别2：从访问角度看，私有属性不能在类外通过对象访问，即不能使用 对象名.私有属性名 访问或修改

4.3 私有属性的访问

假设类有一个 __weight 私有属性，

#PyThon装饰器
@property		
def weight(self):
	return self.__weight

通过添加装饰器property，方法名weight变成了一个可读属性，用户可以通过 对象名.weight 访问，而无需加小括号()。

4.3 私有属性的修改或设置

装饰器中的weight必须与要修改的私有属性名__weight对应

#PyThon装饰器
@weight.setter	
def weight(self, input_weight)：
	self.__weight = input_weight
	#方法体中也可以添加其他逻辑

通过添加装饰器weight.setter，方法名weight变成了一个可写属性，用户可以通过 对象名.weight = 具体值 访问，而无需加小括号()。
执行逻辑：调用对象的weight(self, 具体值)方法，执行其内部逻辑。

5. 类的方法

对象方法第一个参数是self，类方法第一个参数是cls，静态方法第一个参数是自定义参数；类方法和静态方法都可以通过类或实例对象来调用，而对象方法必须通过对象调用。

5.1 对象方法：必须通过对象调用

对象方法的第一个参数必须是self，即：
def 方法名(self, 参数表)

5.2 类方法：可以通过类或实例对象来调用

通过classmethod装饰器修饰并且第一个参数必须是cls，即：
@classmethod
def 方法名(cls, 参数表)

5.3 静态方法：可以通过类或实例对象来调用

通过staticmethod装饰器修饰并且第一个参数是自定义参数，即：
@classmethod
def 方法名(参数表)

5.4 PyThon特殊方法：魔法方法

方法名一般以 __开头并以__结尾，用以实现一些特殊功能。

5.4.1 __init__方法

用于定义对象属性

5.4.2 __str__方法

当调用print(对象名)时，此对象默认调用它的__str__对象方法并将返回值传递给print函数打印。

5.4.3 __repr__方法

在命令行中直接输入对象名并执行后默认调用的对象方法，最终命令行会输出该对象方法的返回值。

5.4.4 __eq__方法

当遇到对象1 == 对象2时，默认调用对象1的__eq__(对象2)方法，并且以该方法的返回值作为该比较运算的结果。

八、PyThon输入输出

1. PyThon输入

有待更新，PyThon中通常是通过读取文件输入数据。

2. PyThon输出：print函数

2.1 print输出字符串

格式：print(文本格式化字符串)
文本格式化的含义：将data变量插值到字符串中。

2.1.1 旧式格式化：%方式

格式：str对象 % data变量
执行逻辑：用data变量替换str对象中的格式化字符，形成新的字符串对象。
str对象中可以包含以下格式化字符：
%s 插入一个字符串
%d 插入一个整数
%-m.nf 插入一个左对齐、总占位m、小数位n的小数

2.1.2 新式格式化：{}+format方式

str对象.format(data变量1，data变量2，...)

2.1.2.1 按位置替换

'...{}...{}...'.format(var1, var2)
var1替换第一个{}，var2替换第二个{}。

2.1.2.2 按索引替换

'...{1}...{0}...'.format(var1, var2)
var1替换第二个{}，var2替换第一个{}。

2.1.2.3 按别名赋值替换

'...{a}...{b}...'.format(a = var1, b = var2)
var1替换第一个{}，var2替换第二个{}。

2.1.2.4 变量替换符{}

{}里可以为空，可以指定变量索引0、1…，可以指定替换符的别名a、b…，也可以指定替换风格：
{m：<nd} m代表替换变量索引，<代表左对齐，n代表总占位n，d代表整数；
{m：>nd} >代表右对齐；
{m：^n.sf} ^代表居中，n代表总占位，s代表小数位，f代表小数。

2.2 print输出对象

当调用print(对象名)时，此对象默认调用它的__str__对象方法并将返回值传递给print函数打印。参考5.4.2。

九、PyThon文件读写

1. PyThon编码与解码

1.1 字符串

Unicode字符序列，用于存储文本数据，可以理解为从内存中的二进制数据解码后在屏幕上显示输出的文本序列，如abcdefg。

1.2 字节数组

每一个字节占8bit，可以理解为一个字节就是一个整数，那么字节数组就是字节序列或者整数序列，用于存储二进制数据(每8位一组)，可以理解为字节数组就是8位一组的一串二进制码，如00000000 11111111 00000000 11111111。

1.3 编码与解码

PyThon中字符串str 和 字节数组bytes 是两个不同的类型，它们之间的转换就是编码与解码。
编码：将字符串转化为字节数组(二进制)的过程
方式1：bytes(str对象，encoding = 编码方式)
方式2：str对象.encode(encoding = 编码方式)
二者均返回一个bytes字节数组(二进制)。

解码：将字节数组(二进制)转化为字符串的过程
方式1：str(bytes对象，encoding = 编码方式)
方式2：bytes对象.decode(encoding = 编码方式)
二者均返回一个str对象。

1.4 编码方式

编码方式其实可以理解为就是一个密码表，上面记载着每一个字符与对应数字的映射关系。
经典的编码方式有：

1.4.1 ASCII编码

American Standard Code for Information Interchange美国标准信息交换代码
每一个字符对应一个字节(8bit)，共有128个字符（最高位不用），0-127
优点：简单，存储量小。
缺点：专门为英语设计，表示的字符太少。

1.4.2 ASCII扩展编码

包含256个字符，著名的有IBM字符集、ISOLatin-1字符集。

1.4.3 Unicode编码

每一个字符对应两个字节(8bit)。
优点：几乎可以表示全球任何一个地区的文字。
缺点：存储量太大，对于某些地区的字符集，它的高8位全是0，所以容易造成资源浪费。

1.4.4 UTF编码

Unicode Transformation Format通用格式转换
它是针对Unicode的一种可变长度字符编码，可以表示Unicode标准中的任何一个字符，并且其编码的第一个字节仍与ASCII兼容。
可以理解为是介于ASCII和Unicode之间的中间格式字符集。
如UTF-8是PyThon、Linux和HTML的标准文本编码方式。

1.4.5 gbk编码

Chinese Internal Code Specification汉字内码扩展规范，也称国标扩展。
采用双字节表示，共有23940个码位，收录21886个汉字和图形符号。

2. PyThon打开或关闭文件

无论是读取文件还是写入文件，都需要先打开文件，读取或写入完毕后，还要及时关闭文件。

2.1 打开文件

file = open(filename, 'mode', encoding = 编码方式）
返回文件号，可以理解为文件引用，指代文件本身。

2.1.1 打开文件模式

mode指定读写模式，是一个字符串，要用引号括起来。mode可以取以下值：
wt 写文本文件.txt
rt 读文本文件.txt
at 追加文本文件.txt
wb 写二进制文件
rb 读二进制文件
ab 追加二进制文件

2.1.2 编码方式

同样是字符串，常用的有'utf-8'、'gbk'。

2.2 关闭文件

file文件hao.close()

2.3 上下文管理器：with

with open(filename, 'mode', encoding = 编码方式) as f:
	f.write()或f.read()
	文件读写逻辑

上下文管理器的作用：负责打开文件，当执行完毕后，自动关闭文件，无需手动关闭。

3. PyThon读取文件

假设f是文件号

3.1 读取二进制文件

首先用rb模式打开文件，然后 f.read() 直接将内存中的二进制数据以bytes字节数组类型返回。
注意rb模式下不能使用encoding参数

3.2 读取文本文件

首先用rt模式打开文件，可以指定编码方式，用于将内存中的二进制数据转换为字符串，默认编码方式：UTF-8

3.2.1 一次性读取

f.read() 返回由换行符\n在内所有字符组成一个整体字符串。

3.2.2 一次读取一行

f.readline() 一次读取并返回一行文本(包括换行符)，并将读取指针指向下一行的起始位置。

3.2.3 一次读取所有行

f.readlines() 读取所有行并放在列表中，即返回一个列表，列表的每一个元素是行字符串。

3.2.4 直接迭代每一行

其实文件号f本身就是一个迭代器(可多次使用)，可以理解为是被封装了的列表，列表元素是行字符串。
使用方法：

for line in f:    	#f是一个迭代器，可直接使用
·	print(line.upper())

4. PyThon写入文件

首先指定模式wb、wt、at、ab打开文件，然后使用 f.write(str对象) 将字符串str写入到文件中，既可以是文本文件，也可以是二进制文件。

5. CSV格式文件

CSV格式：以逗号，、制表符\t、竖线| 分割的结构化文件，一行代表一条记录，一列代表一个字段或属性，用分隔符分割。一个CSV文件可以理解为是一个嵌套列表。

5.1 CSV文件读取

#导入PyThon内置模块csv
import csv	
with open('filename.csv', 'r') as f:
	#由迭代器f生成CSV二维列表迭代器，列表元素是每行对应的列表
	csvreader = csv.reader(f)
	#由二维列表迭代器生成二维列表
	dim2list = [row for row in csvreader]

5.2 CSV文件写入

#导入PyThon内置模块csv
import csv	
with open('filename.csv', 'w') as f:
	#创建一个与文件f相关联的csv写入器，它负责将一维或二维列表写入文件f
	csvwriter = csv.writer(f)
	#将一维列表写入文件，一次写入多行
	csvwriter.writerow(一维列表)
	#将二维列表写入文件，一次写入多行，多行的格式和数量可以不同
	csvwriter.writerows(二维列表)

注意：open打开.csv文件写入时，默认每写入一行插入一个空行，如果想要取消空行，可以指定newline参数为空串，即：open('filename.csv', 'w', newline = '')。

6. json格式文件

它是web数据交换(客户端与服务器)的一种常用格式，是一种字符串str型数据。但本质上，它也是一种结构化数据(由PyThon数据结构转换转换成json字符串)。

6.1 json编码与解码

计算机擅长存储序列数据，如二进制串或字符串(可以编码成二进制)。那么如果将PyThon的数据结构变成序列数据存储在计算机中呢？答案是：将之编码成json字符串。

6.1.1 json编码

import json #PyThon内置模块
json_str = json.dumps(PyThon_DS)
PyThon_DS通常是一个多重嵌套字典dict，该函数将dict编码成json字符串。
注意：并不是所有数据都能被编码成json字符串，即被json序列化。

6.1.2 json解码

import json #PyThon内置模块
PyThon_DS = json.loads(json_str)
该函数将json_str解码成PyThon数据结构。

7. pickle格式文件

为了将PyThon数据结构序列化，即将内存中的数据结构转换为二进制数据存储在外存的文件中，json使用的方式是先将数据结构转换为字符串，然后在对字符串编码，因为后一过程(字符串编码)不依赖于PyThon，所以json格式利于数据交换。而pickle可将大部分PyThon数据结构序列化，但是因为它是PyThon独有文件，可以理解为字符与二进制的映射关系(编码方式)属于PyThon独有，所以不利于数据交换。

7.1 pickle编码与解码

7.1.1 pickle编码(序列化)

import pickle #PyThon内置模块
pickledata = pickle.dumps(PyThon_DS)
该函数将PyThon_DS编码成pickle二进制数据。

7.1.2 pickle解码

import pickle #PyThon内置模块
PyThon_DS = pickle.loads(pickledata)
该函数将pickle二进制数据解码成PyThon数据结构。