Python-基础_python课件-CSDN博客

本文链接：https://blog.csdn.net/code_ent/article/details/127274686

第一章：python语言基础

11python语言概述

Python是一种多功能、高级的编程语言，广泛应用于多个领域。

应用范围

科学计算：利用NumPy、SciPy等库进行高效计算。
大数据：通过Pandas、PySpark等处理大量数据。
GUI开发：使用Tkinter、PyQt等库创建图形用户界面。
WEB服务端和大型网站后端：如Django、Flask等框架。
云计算：适用于AWS、Azure等平台的自动化和管理。
系统运维：用于自动化脚本和DevOps工具。
嵌入式设备：如Raspberry Pi等。
移动设备：通过Kivy等库开发移动应用。
游戏开发：使用Pygame等库。
人工智能：TensorFlow、PyTorch等库用于机器学习和深度学习。

Python不适用的场景

Python由于是解释型语言，其运行效率在某些性能驱动的应用中不如编译型语言（如C/C++/Java/Go）。在这些场景下，考虑使用这些替代语言可能更合适。特别是Go，它运行效率类似C，但语法简洁，接近Python。

版本兼容问题

Python 2.x已停止支持，建议使用Python 3.x。对于遗留的2.x代码，可以使用2to3工具进行迁移。

解释器

CPython：官方解释器，用C语言编写。
Jython：运行在Java平台，可调用Java类库。
IronPython：适用于.NET平台，可调用.NET类库。
PyPy：用Python编写的解释器，注重提高执行速度。

开发环境

IDE（集成开发环境）提供了更便捷的编程体验。常见的有：

IDLE：Python官方IDE。
PyCharm：功能强大的专业IDE。
WingIDE：另一个专业的Python IDE。
Eclipse + PyDev：适用于多种语言的IDE。
IPython：一个更加强大的交互式解释器。

交互模式

打开命令行，输入python并回车。
出现>>>提示，表示已进入交互模式。
退出交互模式：Ctrl+Z后回车、输入quit()后回车、Ctrl+C或点击窗口关闭按钮。

IDLE使用介绍

IDLE是Python自带的IDE，提供了一些实用的快捷键：

Alt+N/P：浏览历史命令。
Ctrl+F6：重启IDLE。
F1：打开帮助文档。
Alt+/：自动补全。
Ctrl+[/]：代码缩进。
Alt+M：查看模块源码。
Alt+C：类浏览器。
F5：运行程序。

12人机交互

121 概述

Python中的人机交互主要体现为两种形式：

键盘交互（标准输入输出）：通过键盘输入数据到程序，程序处理后将结果显示在屏幕上。
文件交互：程序从文件中读取数据，运行后可以将结果写入文件。

在标准输入中，程序将键盘输入的文本数据转换为相应的数据类型。标准输出则将程序结果转换为字符型，显示在屏幕上。

122 输入输出函数

input(): 用于接收用户输入。
print(): 用于输出信息到控制台。

print() 函数的格式

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

value：输出对象，多个对象以逗号隔开。
sep：输出对象之间的分隔符，默认为空格。
end：输出语句的结束字符，默认为换行符。
file：设置输出目的地，默认为显示器。
flush：是否立即输出，默认为否。

123 格式控制串

使用格式化字符串，可以按照特定的格式输出变量。格式化字符串的基本形式为 '格式控制串' % (值序列)。

常见格式控制符号

%f：浮点数
%o：八进制整数
%d：十进制整数
%x：十六进制整数
%s：字符串
%e：科学计数法
%%：输出百分号%

a = 1.234
b = 10
c = 10000
d = 'hello'
print('The float is %f and the 10 int is %d, the ten is %e and the string is %s' % (a, b, c, d))

对于浮点数 %f，还可以指定字段宽度和精度，如 %x.yf，其中 x 是字段宽度，y 是小数点后的精度。

124 输入/输出重定向

在Python中，可以使用系统模块 sys 来重定向标准输入和输出。

sys.stdin：标准输入
sys.stdout：标准输出

控制台中的重定向

'<'：输入重定向
'>'：输出重定向

13对象与变量

131 对象

在Python中，对象具有三个主要特征：

标识（Identity）：对象在内存中的地址。使用 id(对象) 查询。
类型（Type）：对象存储数据的类型。使用 type(对象) 查询。
值（Value）：对象存储的数据信息。使用 print(对象) 查看。

132 变量

变量是存储在内存中的数据的表示。它具有以下特征：

声明变量的方式：变量名 = 表达式
变量赋值：使用变量前必须先赋值。

变量的使用方法

删除变量：del 变量名
链式赋值：变量名1 = 变量名2 = ... = 变量名n = 表达式
系列解包赋值：变量名1, 变量名2, ..., 变量名n = 1, 2, ..., n

变量交换：使用元组解包来实现变量交换，例如：

变量名1, 变量名2 = 变量名2, 变量名1
print(变量名1, 变量名2)  # 输出: b a

133 Python动态类型

Python是一种动态类型语言，这意味着变量的类型在运行时根据引用的对象自动确定。

134 Python常量

Python本身没有内置的常量类型。通常，通过约定俗成的命名规范来表示常量，例如使用全大写字母。虽然技术上可以修改这些“常量”，但通常应避免这样做。

135 引用

在Python中，变量本质上是对象的引用。变量存储的是对象的内存地址。变量本身存储在栈内存中，而对象存储在堆内存中。

14编码规范与注释

141 程序和模块

Python程序：由模块组成，每个模块对应一个源文件（.py格式）。
Python模块：由语句组成，语句按照在模块中的顺序执行。
Python语句：是程序的构造单元，用于创建对象、变量赋值、创建函数、控制语句等。

142 文件的创建和执行

在IDLE环境中：

通过 File > New File 创建新文件。
通过 File > Save/Save As 保存文件（保存为 .py 格式）。
执行文件，可以按 F5 或选择 Run > Run Module。

143 代码的组织和缩进

Python使用缩进来定义代码块。通常，一个缩进等于四个空格。

144 使用注释

单行注释：使用 # 后跟注释内容。
多行注释：使用三个单引号 ''' 或三个双引号 """ 包围注释内容。

145 使用行连接符

当一行代码太长时，可以使用反斜杠 \ 作为行连接符，将代码分成多行。

146 标识符

标识符是变量、函数、类、模块等的名称。它们遵循以下规则：

区分大小写。
第一个字符必须是字母或下划线。
不能使用Python关键字，如 if、or、while 等。
避免使用双下划线。

命名约定：

模块和包名：全小写，多个单词用下划线连接。
函数名：全小写，多个单词用下划线连接。
类名：首字母大写，多个单词用下划线连接。
常量名：全大写，多个单词用下划线连接。

若要查找Python关键字，可以在Python解释器中使用 help()，然后输入 keywords。

第二章：数值类型

21数值类型

211数值类型

Python支持多种数值类型，包括：

简单数据类型：
- 整型（int）：正整数、零和负整数，如 1, 2, 3, -1, -2。
- 浮点型（float）：带有小数点的数，如 3.14, -0.001。
- 复数（complex）：由实部和虚部组成的数，如 3 + 4j。
- 布尔类型（bool）：表示真（True）或假（False）。
序列对象：
- 字符串（str）：一串字符，如 ‘hello’。
- 元组（tuple）：不可变的序列，如 (1, 2, 3)。
- 列表（list）：可变的序列，如 [1, 2, 3]。
其它类型：
- 集合（set）：无序且元素唯一的集合，如 {1, 2, 3}。
- 字典（dict）：键值对的集合，如 {‘name’: ‘John’, ‘age’: 30}。

整数进制表示

二进制：以 0b 或 0B 开头，如 0b110 表示二进制数 110。
八进制：以 0o 或 0O 开头，如 0o24 表示八进制数 24。
十六进制：以 0x 或 0X 开头，如 0xff 表示十六进制数 FF。

使用范例

二进制转十进制：0b110 = 6（二进制 110 转换为十进制）。
八进制转十进制：0o24 = 20（八进制 24 转换为十进制）。
十六进制转十进制：0xff = 255（十六进制 FF 转换为十进制）。

浮点数的科学计数法

例如，3.14 可以写作 314e-2，表示 3.14 = 314 × 10^-2。

212时间的表示

计算机中时间的默认起点是1970年1月1日00:00:00 UTC（协调世界时），这个起点被称为“Unix时间戳”。时间以秒为单位进行计算，但在Python中，time.time() 函数返回的时间是以毫秒为精度的浮点数。

使用`time`模块获取当前时间

在Python中，您可以使用内置的time模块来获取当前时间。以下是获取当前Unix时间戳的示例：

import time

current_time = time.time()

current_time变量将包含一个浮点数，表示从Unix纪元开始到当前时刻的秒数。

从时间戳提取具体时间

您可以通过数值运算从这个时间戳中提取出当前的秒、分钟、小时、天等具体时间单位。例如，将时间戳除以3600可以得到小时数，除以60可以得到分钟数。但这种方法不适用于提取月份和年份，因为这些单位不是固定长度的。

注意

直接从时间戳提取月份和年份较为复杂，因为月份和年份的长度不是固定的。通常，我们会使用Python的datetime模块来处理具体的时间日期运算，例如提取当前日期的年、月、日等信息。

213布尔值

在Python中，布尔值主要用于逻辑运算，表示真（True）或假（False）。虽然它们在Python中以True和False表示，但在底层，它们实际上被当作1和0来处理。

布尔值在计算中的应用

您可以将布尔值当作整数1和0来使用，在计算中直接替换。例如：

result = True + 5  # 结果为6，因为True被视为1
is_valid = False * 10  # 结果为0，因为False被视为0

这种特性使得布尔值在条件表达式中非常有用，尤其是在进行数学运算或逻辑判断时。

注意事项

虽然布尔值可以用于数值计算，但建议在逻辑上下文中使用它们，以保持代码的可读性和清晰性。在需要进行数值运算的情况下，显式地使用整数0和1通常是一个更好的选择。

214复数类型数据complex

在Python中，复数由实部和虚部组成，通常表示为 a + bj，其中 a 和 b 是数值，j 是虚数单位。例如，3 + 4j 就是一个复数。

访问复数的实部和虚部

您可以分别使用 .real 和 .imag 属性来获取复数的实部和虚部。例如：

aComplex = 3 + 4j
real_part = aComplex.real  # 结果是 3.0
imaginary_part = aComplex.imag  # 结果是 4.0

复数的共轭

复数的共轭是将虚部的符号反转。在Python中，您可以使用 .conjugate() 方法来获取复数的共轭。例如：

conjugate_complex = aComplex.conjugate()  # 结果是 3 - 4j

复数的使用场景

复数在数学、工程和科学计算中非常重要，特别是在信号处理、流体动力学和其他需要复数表示的领域。

22数值类型转换

221自动转换

在Python中，运算时，如果操作数类型相同，则运算结果的类型也相同。然而，当操作数类型不同时，Python会自动进行类型转换，以使它们成为同类型，然后进行运算。

自动转换的规则

数值范围小的类型转换为数值范围大的类型：
- 当整数与浮点数运算时，系统会自动将整数转换为浮点数。
- 例如，3 + 2.5 的结果是 5.5，因为整数 3 被转换为浮点数 3.0。
布尔类型转换：
- 布尔值 True 和 False 可以与任何数值类型进行运算，通常被视为 1 和 0。
字符串与数字运算：
- 当字符串与数字运算时，字符串会被转换为数字。
- 例如，'3' + 2 的结果是 5，因为字符串 '3' 被转换为整数 3。
复数与实数运算：
- 当复数与实数（整数或浮点数）运算时，实数会被转换为复数。
- 例如，(3 + 4j) + 2 的结果是 5 + 4j，因为实数 2 被转换为复数 2 + 0j。

自动转换的优点

自动转换简化了编程，减少了类型错误，使得代码更易于编写和维护。然而，这也可能导致性能问题，特别是在处理大量数据时。

222强制转换

Python提供了多种方法来进行强制类型转换。这些方法可以用于将不同类型的数据转换为所需的类型。

int(x, base)

功能：将x转换为整数。
参数：base 可以是 2, 8, 16。如果 base 不提供，默认将x视为十进制数。
示例：int('1010', 2) 返回 10，int('17', 8) 返回 15。
注意：int(9.9) 返回 9，没有四舍五入。

float(x)

功能：将x转换为浮点数。
示例：float('3.14') 返回 3.14。

complex(real, imag)

功能：创建一个复数。
参数：real 是实系数，imag 是虚系数。
示例：complex(3, 4) 返回 3 + 4j。

str(x) / repr(x)

功能：将对象转换为字符串。
区别：str(x) 返回可打印的字符串，repr(x) 返回等效的字符串表示。
示例：str(3.14) 返回 '3.14'，repr('hello') 返回 "'hello'"。

ord(x)

功能：将字符转换为其ASCII码。
示例：ord('A') 返回 65，ord('a') 返回 97。

chr(x)

功能：将ASCII码转换为字符。
示例：chr(65) 返回 'A'，chr(97) 返回 'a'。

hex(x)

功能：将整数转换为十六进制字符串。
示例：hex(255) 返回 '0xff'。

oct(x)

功能：将整数转换为八进制字符串。
示例：oct(255) 返回 '0o377'。

eval(str)

功能：计算字符串中的有效Python表达式。
注意：此方法存在安全风险，因为它可以执行任意代码。
示例：eval('2 + 3') 返回 5。

round(value)

功能：返回四舍五入后的值。
示例：round(3.14159, 2) 返回 3.14。

23数值运算

231运算符

Python中的运算符分为多个类别，用于执行不同的操作。以下是部分常见运算符的概述：

逻辑运算符

and：逻辑与。
or：逻辑或。
not：逻辑非。

同一性测试

is：比较两个对象是否是同一个对象。
is not：比较两个对象是否不是同一个对象。

比较运算符

<：小于。
>：大于。
<=：小于等于。
>=：大于等于。
!=：不等于。
==：等于。

位运算符

|：按位或。
^：按位异或。
&：按位与。

移位运算符

<<：左移。
>>：右移。

取反运算符

~：按位取反。

整除和取余运算符

//：整除。
%：取余。

幂运算符

****：幂运算。

增量赋值运算符

+=：增量赋值，例如 x += 1 相当于 x = x + 1。

注意事项

is 和 == 的区别：is 用于比较对象的同一性，而 == 用于比较对象的值。当比较变量和 None 时，is 通常比 == 更高效。
浮点数比较：由于计算机中浮点数的表示方式，直接比较浮点数可能不准确。例如，2.1 - 2.0 不等于 0.1，因为存在舍入误差。为了准确比较，可以使用一个很小的数（如 esp）来判断浮点数的差值是否在可接受的误差范围内。例如：
```
esp = 0.000000001
abs((2.1 - 2.0) - 0.1) < esp
```
这将正确地返回 True。

24常用数值运算函数

Python提供了一系列内置函数来执行各种数值运算。以下是几个常用函数的概述：

divmod(被除, 除)

功能：同时返回除法的商和余数。
返回值：一个包含商和余数的元组。
示例：divmod(10, 3) 返回 (3, 1)。

abs(值)

功能：返回一个数的绝对值。
示例：abs(-5) 返回 5。

pow(数, 幂)

功能：计算数的幂。
示例：pow(2, 3) 返回 8。

round(值, 精准度范围)

功能：返回四舍五入后的值。
参数：精准度范围 指定了四舍五入到小数点后的位数。
示例：round(3.14, 0) 返回 3.0，round(3.14) 默认四舍五入到整数，返回 3。

25math模块及其应用

Python的 math 模块提供了一系列数学函数，这些函数可以用于执行各种数学运算。以下是 math 模块中的一些主要函数：

pi

功能：返回圆周率 π。

e

功能：返回自然对数的底数 e。

fabs(值)

功能：返回一个数的绝对值。

trunc(x)

功能：返回 x 的整数部分。

factorial(x)

功能：返回 x 的阶乘。

pow(x, y)

功能：返回 x 的 y 次幂。

sqrt(x)

功能：返回 x 的平方根。

sin(x), cos(x), tan(x)

功能：返回 x 的正弦、余弦和正切值。

ceil(x)

功能：返回大于或等于 x 的最小整数。

floor(x)

功能：返回小于或等于 x 的最大整数。

exp(x)

功能：返回 e 的 x 次幂。

fmod(x, y)

功能：返回 x 除以 y 的余数，结果为浮点数。

fsum(iterable)

功能：对可迭代对象中的每个元素进行求和操作。

gcd(x, y)

功能：返回 x 和 y 的最大公约数。

hypot(x, y)

功能：返回 x^2 + y^2 的平方根，即欧几里得范数。

isinf(x)

功能：如果 x 是无穷大，则返回 True，否则返回 False。

isnan(x)

功能：如果 x 不是数字，则返回 True。

ldexp(x, i)

功能：返回 x * 2^i。

log(x, a)

功能：返回 x 以 a 为底的对数。

modf(x)

功能：返回 x 的分数部分和整数部分。

radians(x)

功能：将角度转换为弧度。

使用方法

要使用 math 模块中的函数，您需要首先导入它：

from math import *

这样，您就可以直接使用 math 模块中的所有函数。

第三章：流程控制

31顺序结构

顺序结构是程序设计中最基本的结构，它指的是程序按照代码的编写顺序依次执行。在这种结构中，程序从上到下、按顺序执行每一条指令。

输入

定义：输入是程序接收外部数据的过程。
示例：用户通过键盘输入数据，程序接收并处理这些数据。

程式

定义：程式是指程序中的代码段，用于执行特定的任务。
示例：一个计算圆面积的程序，包含定义变量、计算公式、输出结果等代码段。

输出

定义：输出是程序将结果呈现给用户的过程。
示例：程序计算出结果后，显示在屏幕上或写入文件。

顺序结构的实现

在Python中，顺序结构通过编写代码实现。程序首先接收输入，然后执行程序代码（即程式部分），最后输出结果。这种结构简单直接，适用于大多数程序。

顺序结构的优点

易于理解：代码按照逻辑顺序执行，易于理解和维护。

32分支结构

321 单分支结构

单分支结构是指程序根据一个条件执行不同的代码块。它通常由一个 if 语句组成。

语法：
```
if XXX：
    结果输出
```
示例：
```
if 条件：
    print("条件为真")
```

322 双分支结构

双分支结构允许程序根据条件选择执行两个不同的代码块之一。它由一个 if 语句和一个 else 语句组成。

语法：

if XXX：
    结果输出
else：
    结果输出

示例：

if 条件：
    print("条件为真")
else：
    print("条件为假")

分支嵌套

分支结构可以进行嵌套，即一个 if 语句内可以包含另一个 if 语句。这样可以实现更复杂的逻辑判断。

示例：

if 条件A：
    if 条件B：
        结果输出

323 多分支结构

多分支结构使用多个 elif 语句来根据多个条件执行不同的代码块。

语法：

if 条件1：
    结果输出1
elif 条件2：
    结果输出2
elif 条件3：
    结果输出3
...
else：
    结果输出（其他情况）

示例：

if 分数 >= 90：
    print("A")
elif 分数 >= 80：
    print("B")
elif 分数 >= 70：
    print("C")
else：
    print("D")

逻辑表示

这些分支结构可以用思维导图或流程图直观地表示，以帮助理解程序的执行流程。

33循环结构

循环结构的机理是当某个条件返回 True 时，执行循环体内的代码，然后再次检查条件，直到条件变为 False。

331 `while` 循环

while 循环根据一个条件重复执行代码块，直到条件变为 False。

注意事项：如果 while 循环的条件不会改变，可能会导致死循环。
示例：
```
while 条件：
    执行语句
```

332 `for` 循环

for 循环用于遍历一个序列（如列表、元组、字符串）或一个范围。

range() 函数：range(x, y, z) 生成一个从 x 到 y-1 的整数序列，步长为 z。

示例：

for 变量 in 范围：
    执行语句

循环控制语句

break：跳出当前循环。
continue：结束当前循环，直接进入下一次循环。
pass：不执行任何操作，通常用作占位符。

推倒式创建序列

Python支持使用列表推导式、字典推导式和集合推导式来快速创建序列。

列表推导式：[表达式 for 对象 in 迭代范围 if 条件判断]
字典推导式：{keyexpression: valueexpression for 表达式 in 可迭代对象}
集合推导式：{item for 对象 in 可迭代对象 if 条件判断}

第四章：函数

41函数的基本使用

411函数的定义

函数是执行特定任务的可重用代码块。在Python中，函数可以独立存在，也可以相互依赖。它们之间的关系可以是：

独立函数：没有直接依赖关系的函数。
依赖函数：一个函数的输出可以作为另一个函数的输入。
嵌套函数：一个函数内部可以调用另一个函数。

函数的定义和调用

定义：首先定义函数，包括函数名、参数（如果有）和函数体。
调用：通过函数名来调用函数，并传递必要的参数。
执行：调用函数时，执行函数体内的代码。
返回值：函数执行完毕后，可能返回一个值。

412 使用函数的原因

使用函数有以下好处：

代码复用：避免重复编写相同的代码。
提高可维护性：将功能模块化，便于维护和修改。
增强可读性：使代码逻辑更清晰。
实现递归算法：递归算法需要函数内部调用自身。

413 函数的类型

Python中的函数可以分为几种类型：

自定义函数：用户自己编写的函数，如 main()。
内建函数：Python语言内置的函数，如 abs()。
标准库函数：位于Python标准库中的函数，如 math.sqrt()、string.split()。
对象方法：属于某个对象的函数，如 win.close()、p.draw()。

414 函数的定义格式

函数的定义格式如下：

def 函数名(<形参表>):
    函数语句块
    <return 返回值>

函数名：标识函数的名称。
形参表：函数的参数列表，用于传递数据给函数。

42函数的参数传递

421 函数调用的形式

函数可以以不同的方式调用：

语句形式：直接调用函数执行。
表达式形式：函数调用可以作为表达式的一部分。
作为其他函数调用的参数：函数可以作为另一个函数的参数。

422 函数调用的过程

暂停执行：调用函数时，程序暂停执行，转而执行函数体。
参数赋值：函数的形参被赋予实参的值。
执行函数体：执行函数体内的代码。
返回控制：函数执行完毕后，返回调用点，继续执行下一条语句。

423 函数定义与调用中参数的关系

形式参数：在函数定义时使用的参数。
实际参数：在函数调用时传递的参数。
参数一致性：实际参数的个数应与形式参数的个数一致。

424 程序的两个顺序

执行顺序：程序从入口点开始执行，遇到函数调用时执行函数，完成后返回继续执行。
书写顺序：函数的书写顺序与调用顺序无关，但建议不要在函数内部定义另一个函数。

425 传值和传地址

传值：将变量的值传递给函数，函数内部对该变量的操作不会影响原始变量。
传地址：将变量的内存地址传递给函数，函数内部对该变量的操作会永久改变原始变量的值。

426 “*”和“**”的妙用

星号（*）：
- 在函数形参中：表示将多余的实参作为一个元组传递。
- 在实参中：表示将元组解包为多个单独的值传递。
双星号（）**：
- 在函数形参中：表示将多余的实参作为一个字典传递。

43变量的作用域

局部变量和全局变量

局部变量：在函数内部定义的变量，只能在函数内部使用。
全局变量：在函数外部定义的变量，可以在整个程序中使用。

同名变量的处理

同名全局变量和局部变量：如果函数内部有与全局变量同名的局部变量，则局部变量会覆盖全局变量，仅在函数内部有效。

函数与调用者之间的数据沟通

输入：通过参数从调用者接收值。
输出：通过返回值向调用者提供值。

全局变量的访问

访问全局变量：在函数内部访问全局变量时，需要使用 global 关键字声明该变量是全局变量。
```
global 变量名
```

外部嵌套函数的变量访问

访问外部嵌套函数的变量：在嵌套函数中访问外部函数的变量时，需要使用 nonlocal 关键字声明该变量是外部函数的局部变量。
```
nonlocal 变量名
```

44推导式创建序列

441 列表推导式

列表推导式是创建列表的快速方式。它使用一个表达式和一个可选的循环条件。

语法：[表达式 for 元素 in 可迭代对象] 或 [表达式 for 元素 in 可迭代对象 if 条件]
示例：创建一个列表，包含从0到9的平方。
```
squares = [x**2 for x in range(10)]
```

442 字典推导式

字典推导式用于创建字典。

语法：{keyexpression: valueexpression for 元素 in 可迭代对象}
示例：创建一个字典，其中键是字符串，值是字符串的长度。
```
string_lengths = {s: len(s) for s in ['apple', 'banana', 'cherry']}
```

443 集合推导式

集合推导式用于创建集合。

语法：{表达式 for 元素 in 可迭代对象 if 条件}
示例：创建一个集合，包含列表中的唯一元素。
```
unique_elements = {x for x in [1, 2, 2, 3, 4, 3, 5]}
```

444 生成器推导式

生成器推导式用于创建生成器对象，而不是列表、字典或集合。

示例：生成一个包含从0到9的平方的生成器。
```
squares_gen = (x**2 for x in range(10))
```
生成器只能使用一次，即只能迭代一次。

第五章：字符串

51字符串基本特点

511 字符串的本质

字符串是字符序列的集合，它们是不可变的。字符串通常包含字母、数字和特殊字符。

512 字符串的转换

ord(字符)：将单个字符转换为其Unicode编码。
chr(十进制数字)：将十进制数字转换为其对应的字符。

513 可打印字符

可打印字符是指那些可以直接在屏幕上显示的字符，如字母（a-z、A-Z）、数字（0-9）、标点符号和键盘常见符号。

514 不可打印字符

不可打印字符是指那些在屏幕上不能直接显示的字符。它们通常用于表示控制信息或特殊字符。例如：

\a：响铃字符。
\b：退格字符。
\n：换行符。
\r：回车符。
\t：制表符。
\f：换页符。
\v：垂直制表符。

52创建字符串

在Python中，字符串可以用单引号或双引号表示。

单引号和双引号：
- 单引号和双引号都可以用来表示字符串。
- 如果在字符串中包含单引号或双引号，需要在前面加上反斜杠（\）作为转义字符。

多行字符串

多行字符串：
- 使用三个单引号（'''）或三个双引号（"""）来创建多行字符串。
- 这种方法允许字符串跨越多行，而不需要在每个换行处加上反斜杠。

空字符串

空字符串：
- 空字符串是允许的，它包含空格的字符串也是有效的。

53字符串的拼接

在Python中，字符串可以通过几种方式进行拼接：

相互粘连：
- 两个字符串直接相加，如 'aa' + 'bb' 得到 'aabb'。
- 这种方法适用于简单的字符串拼接。
复制字符串：
- 使用乘法操作符 * 来复制字符串，如 'a' * 3 得到 'aaa'。
- 这种方法适用于重复字符串。

不换行打印

不换行打印：
- 使用 print() 函数并设置 end 参数来控制打印后的行为。
- 例如，print('内容', end='末尾内容') 可以在一行内打印字符串，末尾不换行。

54索引

索引是用来表示字符串中字符位置的数字，用于指定取出字符串中的某个字符。

索引格式：<字符串>[<数值表达式>]

示例：

s = 'hellopython'
print(s[0])  # 输出 'h'

字符串的“替换”

不可变字符串：
- 字符串是不可变的，这意味着不能直接修改字符串中的字符。
替换方法：
- 虽然字符串不可变，但可以通过创建新字符串来实现“替换”。
- 使用 replace() 方法可以替换字符串中的特定字符。
- 示例：
```
a = 'ccdabcd'
a = a.replace('c', 'T')
print(a)  # 输出 'TTdabTd'
```

55字符串切片

字符串切片是用于获取字符串中指定部分的一种方法。切片格式如下：

切片格式：<字符串>[起始偏移量:终止偏移量:步长]
默认值：
- 起始偏移量默认是 0。
- 终止偏移量默认是字符串的长度减一。
- 步长默认是 1。

切片操作

示例：
- a[0:2] 获取从索引 0 到 2 的子串，不包括 2。
- a[0:2] 获取从索引 0 到 2 的子串，不包括 2。
- a[:2] 获取从开始到索引 2 的子串。
- a[::2] 获取从开始到结束，步长为 2 的子串。
- a[::-1] 获取字符串的反转。

切片异常处理

切片异常：如果起始或终止偏移量超出字符串的范围，它们会被自动调整到合法范围。
示例：
- 如果尝试获取一个超出字符串末尾的切片，起始偏移量会被调整为字符串末尾的位置。
- 如果尝试获取一个超出字符串开头的切片，终止偏移量会被调整为字符串开头的位置。

56子串测试操作

子串测试操作用于检查一个子串是否存在于另一个字符串中。

子串测试：
- 使用 in 关键字可以检查一个子串是否存在于字符串中。
- 示例：
  - 'cc' in a：如果字符串 a 中包含子串 'cc'，则结果为 True。
  - 'kk' in a：如果字符串 a 中不包含子串 'kk'，则结果为 False。

57分割

571 `split()` 函数

split() 函数用于根据指定的分隔符将字符串分割成多个子字符串，并将这些子字符串存储在一个列表中。

默认分隔符：如果不指定分隔符，split() 函数默认使用空白字符（如空格、制表符、换行符等）进行分割。

572 `split()` 函数的参数

分隔符：指定用于分割字符串的字符或字符串。
最大分割次数：可选参数，指定分割的最大次数。
选取子字符串：可选参数，指定选取列表中的第几个子字符串。

573 分割的赋值

分割赋值：使用 split() 函数分割字符串后，可以将结果赋值给多个变量。
- 示例：a, b, c = s.split('.', 2)：如果 s 被分割成三个子字符串，则 a、b、c 将分别存储这三个子字符串。

分割的注意事项

字符串不可变性：分割字符串不会改变原始字符串。
空字符串的产生：在字符串的开始和结束位置，以及连续多个分隔符之间，可能会产生空字符串。

58合并

581join（）

join() 函数用于将一个字符串列表中的所有元素合并成一个字符串。合并时，使用第一个参数（拼接符）作为各个元素之间的分隔符。

拼接符：指定用于连接字符串列表中元素的字符串。
字符串列表：需要合并的字符串列表。

使用示例

示例：

str_list = ['hello', 'world']
result = ' '.join(str_list)
print(result)  # 输出 'hello world'

59字符串常用方法汇总

591 字符串方法汇总

查找方法：
- find(‘字符’)：返回字符在字符串中首次出现的位置。
- rfind(‘字符’)：返回字符在字符串中最后一次出现的位置。
- count(‘字符’)：返回字符在字符串中出现的次数。
判断方法：
- startswith(‘字符串’)：判断字符串是否以指定字符串开头。
- endswith(‘字符串’)：判断字符串是否以指定字符串结尾。
- isalnum()：判断字符串是否只包含字母和数字。
- isdigit()：判断字符串是否只包含数字。
- isspace()：判断字符串是否只包含空白字符。
- isupper()：判断字符串是否全为大写字母。
- islower()：判断字符串是否全为小写字母。
大小写转换：
- capitalize()：将字符串的首字母大写。
- title()：将字符串的每个单词的首字母大写。
- upper()：将字符串中的所有字母转换为大写。
- lower()：将字符串中的所有字母转换为小写。
- swapcase()：将字符串中的所有字母大小写转换。
格式化：
- strip(‘指定’)：去除字符串首尾指定的字符。
- lstrip(‘指定’)：去除字符串左边的指定字符。
- rstrip(‘指定’)：去除字符串右边的指定字符。
- center(宽度, ‘填充字符’)：在字符串周围填充指定字符，使其宽度达到指定宽度。
- ljust(宽度, ‘填充字符’)：在字符串左边填充指定字符，使其宽度达到指定宽度。
- rjust(宽度, ‘填充字符’)：在字符串右边填充指定字符，使其宽度达到指定宽度。

592 `format()` 方法

基本用法：

format() 方法用于将格式化字符串中的占位符替换为实际的值。

示例：

a = '名字是：{0}，年龄是{1}'.format('eric', 18)
print(a)  # 输出 '名字是：eric，年龄是18'

填充与对齐：
- format() 方法允许指定字符串的填充和对齐方式。
- 示例：
```
print(':*>8'.format('256'))  # 输出 '*****256'
```
数字格式化：
- format() 方法也可以用于数字的格式化。
- 示例：
```
print('{:>8}'.format(256))  # 输出 '*****256'
```

第六章：序列类型

数据类型

Python支持多种序列类型，这些类型可以用于存储和操作批量数据。

有序序列：
- 字符串（str）：由字符组成的序列。
- 列表（list）：可变序列，可以修改。
- 元组（tuple）：不可变序列，一旦创建不能修改。
无序序列：
- 字典（dict）：键值对的无序集合。
- 集合（set）：无序且不重复元素的集合。

序列对象

序列对象是有序的数据集合体，其成员之间存在排列次序。

常见操作：
- 联接：x1 + x2，将两个序列连接起来。
- 复制：x * n，复制序列 x n 次。
- 索引：x[i]，访问序列中下标为 i 的元素。
- 切片：x[i:j] 或 x[i:j:k]，获取序列中从 i 到 j-1 的子序列，或者每隔 k 取一个元素。
- 长度：len(x)，返回序列中元素的数量。
- 最大值和最小值：max(x) 和 min(x)，分别返回序列中的最大和最小值。
- 成员检测：v in x 和 v not in x，检测 v 是否为序列 x 的成员。

类型构造器

类型构造器是与数据类型同名的函数，用于创建特定类型的对象。

示例：
- str()：将对象转换为字符串。
- int()：将对象转换为整数。
- float()：将对象转换为浮点数。
- list()：将对象转换为列表。

61列表

611 列表简介

列表是Python中的一种可变序列类型，可以存储任意数目和类型的数据。与字符串不同，列表可以修改。

612 列表的创建

基本语法：使用方括号 [] 创建列表，例如 a = [内容]。
嵌套列表：可以在列表中包含其他列表，例如 a = [[内容1], [内容2], [内容3]]。
使用 list() 函数：将其他数据结构（如元组）转换为列表，例如 a = list((‘he’, ‘she’, ‘we’))。
使用 range() 函数：创建一个整数列表，例如 list(range(3, 15, 2)) 创建从3到15（不包括15）的偶数列表。

613 列表元素的增加和删除

append() 方法：在列表末尾添加一个元素。
extend() 方法：将一个列表的所有元素添加到另一个列表的末尾。
insert() 方法：在列表的指定位置插入一个元素。
remove() 方法：删除列表中首次出现的指定元素。
pop() 方法：删除并返回列表中指定位置的元素。
列表乘法：将一个列表重复多次，例如 b = a * 3。
clear() 方法：删除列表中的所有元素。
del 语句：删除列表中指定位置的元素。

614 列表元素的访问和计数

索引访问：使用 a[指定位置] 访问列表中的元素。
修改元素：使用 a[指定位置] = b 修改列表中指定位置的元素。
index() 方法：返回指定元素在列表中首次出现的位置。
count() 方法：返回指定元素在列表中出现的次数。
len() 函数：返回列表中包含元素的个数。
切片：使用 [起始:终止:步长] 访问列表的子序列。

615 列表的复制

假复制：list2 = list1，这种复制实际上只是复制了引用，而不是复制了列表本身。
真复制：list2 = [] + list1，这种复制创建了一个新的列表，其中包含了原始列表的内容。

616 列表排序

sort() 方法：对列表进行排序，默认升序排列。
reverse=True：使用 sort() 方法时，指定 reverse=True 可以进行降序排列。
random.shuffle()：打乱列表中的元素顺序。
新列表排序：使用 sorted() 函数可以创建一个排序后的新列表。

617 列表相关的其他内置函数

max() 和 min()：返回列表中的最大值和最小值。
sum()：返回列表中所有数值元素的总和。

618 多维列表

多维列表格式：a = [[A, B, C], [D, E, F], [G, H, I]]。
索引方法：a[2][2] 表示访问第四行第三列的元素，即 I。

62元组

元组是Python中的一种不可变序列类型，与列表和字符串类似，但与列表不同，元组一旦创建就不能修改。

621 元组的创建

基本语法：使用圆括号 () 创建元组，例如 t = (1, 2, 3)。
包含不同类型元素：元组可以包含不同类型的元素。
只有一个元素时的特殊处理：如果元组只有一个元素，需要在元素后面加上逗号以区别于其他数据类型。
使用 tuple() 函数：直接调用 tuple() 函数来创建元组，例如 tuple('python')。

622 元组的元素访问和计数

不可变性：元组中的元素不能修改。
访问格式：元组的访问格式与列表相同，使用 a[start:end:step] 或 a[指定位置]。
排列与计数：使用 sorted() 函数可以对元组进行排序，但返回的是一个列表。
count() 方法：返回指定元素在元组中出现的次数。
index() 方法：返回指定元素在元组中首次出现的位置。

623 Zip组合元组

zip() 函数：可以将多个列表的对应位置元素组合成元组，例如 zip(a, b, c)。

示例：

a = [10, 20, 30]
b = [40, 50, 60]
c = [70, 80, 90]
d = zip(a, b, c)
print(list(d))  # 输出 [(10, 40, 70), (20, 50, 80), (30, 60, 90)]

624 生成器推导式创建元组

生成器推导式：类似于列表推导式，生成器推导式也可以用于创建元组。

第七章：集合与映射类型

71字典

711字典介绍

字典是Python中的一种无序序列类型，用于存储键值对。每个键（key）都是唯一的，而值（value）可以是任意类型，且可以重复。

键值对：字典由键值对组成，键用于查找对应的值。
无序性：字典中的元素没有固定的顺序。
可变性：可以添加、删除或修改字典中的键值对。

示例

dict_example = {'name': 'Tom', 'age': '18', 'job': 'programmer'}

在这个例子中，'name' 是键，'Tom' 是与之对应的值。

712字典创建

字典创建方法

基本语法：使用花括号 {} 创建字典，例如 a = {'a': 'b'}。
使用 dict() 函数：通过 dict() 函数创建字典，例如 a = dict(a='b')。

使用 zip() 函数转换列表为字典

示例：
- 创建两个列表，k = ['a', 'b', 'c'] 和 v = ['d', 'e', 'f']。
- 使用 zip(k, v) 将两个列表的元素组合成元组，并创建一个字典，例如 d = dict(zip(k, v))。

使用 dict.fromkeys() 创建字典

示例：
- 使用 dict.fromkeys() 方法创建一个所有键都具有相同值的字典，例如 a = dict.fromkeys(['内容为键'])。

713字典元素的访问

访问字典中的元素

通过键访问值：使用 a[‘键’] 访问字典 a 中对应的值。
避免错误：如果键不存在，访问将引发错误。可以使用 get() 方法来避免这种情况。
- a.get(‘键’)：返回键对应的值，如果键不存在则返回 None。
- a.get(‘不存在键’，’返回对象’)：返回键对应的值，如果键不存在则返回指定的 '返回对象'。

列出所有键值对

items() 方法：使用 items() 方法列出所有键值对。
- a.items()：返回一个包含字典中所有键值对的列表。

列出所有键和值

keys() 方法：使用 keys() 方法列出所有键。
- a.keys()：返回一个包含字典中所有键的列表。
values() 方法：使用 values() 方法列出所有值。
- a.values()：返回一个包含字典中所有值的列表。

计算键值对数量

len() 函数：使用 len() 函数计算字典中键值对的数量。

判断键是否存在于字典中

键 in 字典名：使用此表达式可以判断键是否存在于字典中。

714字典元素添加，修改，删除

改变字典中键对的值

修改值：使用 a[‘键’] = ‘值’ 来修改字典中键对应的值。

添加新的键值对

添加键值对：使用 a[‘新键’] = ‘新值’ 来添加新的键值对。

更新字典

update() 方法：使用 a.update(b) 来更新字典，其中 b 中的键值对将覆盖 a 中已有的键值对，并添加 b 中没有的键值对。

删除键值对

del 语句：使用 del a[‘键’] 来删除字典中指定的键值对。
clear() 方法：使用 a.clear() 方法来删除字典中的所有键值对。
pop() 方法：使用 a.pop(‘键’) 来删除指定的键值对，并将删除的值返回。
popitem() 方法：使用 a.popitem() 来随机删除字典中的一个键值对，并返回该键值对（以元组形式）。

715序列解包

解包字典中的键

解包键：当使用元组赋值 a, b, c = {...} 时，默认情况下，a, b, c 分别赋值为字典中的键，按照字典中键的顺序。

解包键值对

解包键值对：当使用 a, b, c = {...}.items() 时，a, b, c 将分别赋值为字典中的键值对。

解包值

解包值：当使用 a, b, c = {...}.values() 时，a, b, c 将分别赋值为字典中的值。

716表格数据使用字典和列表存储并实现访问

表格数据的存储

创建字典行：使用字典来创建表格的行，例如 r1 = {}, r2 = {}, r3 = {}。
创建表格：使用列表来存储这些字典行，例如 tb = [r1, r2, r3]。

访问表格数据

使用循环访问：使用 for 循环遍历表格中的每一行。
使用 get() 方法访问键值：在循环中，使用 tb[i].get('键') 来访问特定行的特定键的值。

示例：

tb = [r1, r2, r3]
for i in range(len(tb)):
    print(tb[i].get('键'))

在这个例子中，i 将遍历 0, 1, 2，对应于 r1, r2, r3。

717字典核心底层原理

72集合

721 集合的创建和删除

集合的创建

基本语法：使用花括号 {} 创建集合，例如 a = {...}。
添加元素：使用 add() 方法添加元素，例如 a.add(元素)。
转换列表或元组为集合：使用 set() 函数将列表或元组转换为集合，例如 a = set([...]) 或 a = set((...))。

集合的删除操作

删除元素：使用 remove() 方法删除指定元素，例如 a.remove(元素)。
清空集合：使用 clear() 方法清空整个集合，例如 a.clear()。

722 集合相关操作

集合运算

并集：使用 union() 方法获取两个集合的并集，例如 a.union(b)。
交集：使用 intersection() 方法获取两个集合的交集，例如 a.intersection(b)。
差集：使用 difference() 方法获取两个集合的差集，例如 a.difference(b)。

第八章：文件操作

程序的交互性

程序的交互性可以体现为两种形式：

键盘交互：通过键盘输入数据，并在显示屏上显示，称为“标准输入输出”。
文件交互：从文件读取数据，或运行后将结果写入一个文件。

81 文件的打开与关闭

811 文件和文件目录

文件定义：文件是永久存储的有序集合，由特定顺序的字节组成，并具有名称。
路径类型：路径分为绝对路径和相对路径。
文件类型：文件分为文本文件和二进制文件。
- 文本文件：存储普通字符文本，可以使用记事本打开。
- 二进制文件：使用“字节”存储数据，需要专用软件解码。

812 访问文件的流程

文件交互优势：可以处理大批量数据，可以长久保存。
访问流程：打开文件 → 访问文件 → 关闭文件。

打开文件

语法：使用 open() 函数打开文件。
参数：
- 文件名：可以是全路径或相对路径。
- 打开方式：包括读（r）、写（w）、追加（a）、二进制（b）、读写（+）等。

写入数据

写入方法：使用 write() 方法写入数据，或者使用 writelines() 方法写入字符串列表（不添加换行符）。

关闭文件

关闭文件流：使用 close() 方法关闭文件。

82文件的读写操作

821 文本文件的写入

追加内容：使用 open(r"文件位置,文件名","a") 以追加模式打开文件，然后使用 write() 或 writelines() 方法写入数据。

示例：

f = open(r"文件位置,文件名", "a")
s = "追加内容\n"  # 追加内容中，是更换一行的部分后直接加'\\n'
f.write(s)
f.close()

使用 with 语句确保文件关闭

with 语句：使用 with 语句可以确保文件在使用完毕后自动关闭。

s = ["追加内容\n", "追加内容\n"]
with open(r"文件位置", "a") as f:
    f.writelines(s)

822 文本文件的读取

读取方法：
- read([size])：读取文件中的 size 个字符。
- readline()：读取文件的一行内容。
- readlines()：读取整个文件，并将每一行作为一个字符串存入列表。

按行读取文件

示例：

with open(r"文件位置", "r") as f:
    while True:
        fragment = f.readline()
        if not fragment:
            break
        else:
            print(fragment, end="")

迭代器读取文件

示例：

with open(r"文件位置", "r") as f:
    for line in f:
        print(line, end="")

增加行号

示例：

with open("e.txt", "r", encoding="ISO-8859-1") as f:
    lines = f.readlines()
    lines = [line.rstrip() + " #" + str(index + 1) + "\n" for index, line in enumerate(lines)]
with open("e.txt", "w", encoding="GBK") as f:
    f.writelines(lines)

823 二进制文件的读取与写入

二进制文件模式：使用 wb、ab、rb 等模式打开二进制文件。

824 常用编码介绍

编码类型：包括 ASCII、ISO-8859-1、GB2312、GBK、GB18030、Unicode、UTF-8 等。
编码特点：
- ASCII：8位字符集，包含控制字符和可见字符。
- ISO-8859-1：Latin-1，兼容ASCII，包含西欧字符。
- GB2312：汉字编码字符集，主要收录汉字和符号。
- GBK：扩展GB2312，包含更多汉字。
- GB18030：包含GBK，并扩展到7万多个汉字。
- Unicode：固定两个字节，表示所有字符。
- UTF-8：变长编码，兼容ASCII，包含多语言字符。

83文件的应用

831 文件对象的常用属性和方法

属性：
- name：返回文件的名字。
- mode：返回文件的打开模式。
- closed：若文件被关闭则返回 True。
方法：
- read([size])：从文件中读取 size 个字节或字符的内容返回。
- readline()：从文本文件中读取一行内容。
- readlines()：把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回。
- write(str)：将字符串 str 内容写入文件。
- writelines(s)：将字符串列表 s 写入文件，不添加换行符。
- seek(offset, [,whence])：把文件指针移动到新的位置，offset 表示相对于 whence 的多少个字节。
- tell()：返回文件指针的当前位置。
- truncate([size])：从文件的首行首字节开始截断，截断文件为 size 个字节。
- flush()：把缓冲区的内容写入文件，但不关闭文件。
- close()：把缓冲区内容写入文件，同时关闭文件，释放文件对象相关资源。

832 文件任意位置操作

seek() 方法：用于移动文件指针到指定位置。
- offset：表示移动的偏移量。
- whence：可选参数，表示相对位置。0：从文件头开始计算，1：从当前位置开始计算，2：从文件尾开始计算。

833 CSV文件的读写操作

CSV文件：逗号分隔值文件，常用于存储表格数据。
示例操作：
- 使用 csv.writer 对象写入CSV文件。
- import csv
- 创建 headers 和 rows 列表。
- 使用 with 语句打开文件，并创建 csv.writer 对象。
- 写入标题行。
- 写入多行数据。