--- slide1.xml ---
授课教师：
周宇文
第2章
python程序设计基础
--- slide2.xml ---
引言
计算机的工作原理
人与计算机交流的工具
--- slide3.xml ---
计算机的工作原理
认识计算机
计算机是以逻辑部件为物质基础，能够对信息进行自动处理的机器。逻辑部件其实就是指计算机的硬件系统，而对信息的自动处理则是由计算机的软件系统来实现的。
什么是计算机
--- slide4.xml ---
计算机的工作原理
认识计算机
计算机系统
硬件系统
软件系统
控制器
存储器
运算器
输入设备
输出设备
内存
外存
CPU
主机
外围设备
系统软件
应用软件
硬件是指构成计算机的物理装置，看得见、摸得着，是一些实实在在的有形实体
软件是指计算机程序及有关程序的技术文档资料
--- slide5.xml ---
计算机的工作原理
计算机硬件系统
尽管不同类型计算机的性能和用途差异很大，但其基本结构是相同的，即均采用冯•诺伊曼体系结构。
冯·诺伊曼体系结构将计算机硬件系统分为运算器、控制器、存储器、输入设备和输出设备5个部分。
--- slide6.xml ---
计算机的工作原理
计算机硬件系统
CPU
中央处理器（Central Processing Unit，CPU）是计算机硬件系统的核心部件，包括
运算器
和
控制器
两个部分。CPU不仅提供了最基本的运算功能，还控制着存储器、输入设备和输出设备的协调运行。
cpu
正面
cpu
反面
--- slide7.xml ---
计算机的工作原理
计算机硬件系统
存储器
存储器是计算机中具有记忆能力的部件，用来存放程序或数据。存储器一般分
内存
和
外存
。
内存
--- slide8.xml ---
计算机的工作原理
计算机硬件系统
存储器
内存储器简称内存
，又称主存，是
CPU
能根据地址线直接寻址的存储空间，是计算机运行时临时存放数据和程序的硬件设备。
内存中存放数据或程序是以相应的内存单元为单位进行存放的，每个内存单元都有一个编号，它表示该内存单元所对应的内存地址。
--- slide9.xml ---
计算机的工作原理
计算机硬件系统
存储器
--- slide10.xml ---
计算机的工作原理
计算机硬件系统
存储器
外存储器简称外存
，它作为一种辅助存储设备，主要用来存放一些暂时不用而又需长期保存的程序或数据（以文件的形式进行保存）。当需要执行外存中的程序或处理外存中的数据时，必须通过
CPU
输入／输出指令，将其调入内存中才能被
CPU
执行处理。
--- slide11.xml ---
计算机的工作原理
计算机硬件系统
存储器
外存储器
-
硬盘
机械硬盘
机械硬盘内部
--- slide12.xml ---
计算机的工作原理
计算机硬件系统
存储器
外存储器
-
硬盘
SSD
（固态硬盘）
--- slide13.xml ---
计算机的工作原理
计算机硬件系统
输入/输出设备
输入设备主要用于接收用户输入的程序或数据，并将其
转换为二进制格式存放到内存
中，如键盘、鼠标、麦克风和扫描仪等。输出设备主要用于
将内存中的二进制数转换为用户能读懂的格式呈现给用户
，如显示器、打印机、耳机等。
--- slide14.xml ---
计算机的工作原理
计算机软件系统
系统软件
系统软件是指管理、控制和监督计算机软/硬件资源协调运行的各类程序。
它面向计算机硬件设备，负责调度、协调计算机及其外部设备之间的工作，支持应用软件开发和运行、系统监控和维护等。
常见的系统软件包括操作系统、语言处理程序和数据库管理系统等。
--- slide15.xml ---
计算机的工作原理
计算机软件系统
应用软件
应用软件是指用户为解决各种实际问题而编制的计算机程序及有关的数据与文档，如Office办公软件、Photoshop图像处理软件、教务管理系统、图书管理系统和京东在线商城等。
--- slide16.xml ---
计算机的工作原理
计算机工作过程
1.
通过键盘、鼠标
、
麦克风等
输入设备采集数据
2.
数据放入内存
3.
运算器对数据进行处理运算
4.
处理后的数据放入内存
5.
调用内存中的数据显示输出到屏幕、打印机等输出设备。
整个过程由控制器进行控制。
--- slide17.xml ---
人与计算机交流的工具
在计算机的世界里，程序设计语言是人与计算机进行交流的工具，是人指挥计算机工作的工具，是由字、词和语法规则构成的指令系统。
指令是计算机能够直接识别并执行的操作命令。每条指令通常包含
操作码
（
Opcode
）和
操作数
（
Operand
）两部分。
在计算机硬件层面，指令是由
CPU
（中央处理器）直接执行的。
CPU
从内存中读取指令，解码操作码以确定要执行的操作，然后根据操作数执行相应的操作。这个过程不断重复，直到程序执行完毕。
--- slide18.xml ---
人与计算机交流的工具
在编程时，通常使用机器语言、汇编语言和高级编程语言（如
C++
、
Java
、
python
等）编写程序，这些程序最终会被编译或解释成计算机可以直接执行的指令序列。
# 计算两个数的和
a = 1
b = 2
result = a + b
print("结果是：", result)
高级语言语言（
python)
编写的程序
机器语言编写的程序
00110001 00000001 00000000 00000000
00110001 00000010 00000000 00000000
00110001 00000001 00000000 00000000
00110001 00000010 00000000 00000000
00110001 00000001 00000000 00000000
汇编语言编写的程序
mov eax, [a] ;
mov ebx, [b] ;
add eax, ebx ;
mov [c], eax ;
mov eax, 1 ;
--- slide19.xml ---
本章学习目标
01
了解 Python 的基本概念,以及数据类型、控制结构和函数。
03
熟悉 Python 的编程环境,掌握 Anaconda 的安装与配置方法,以及 Spyder 和 Jupyter
Notebook 的使用方法。
05
学习 Python 文件操作的基本方法,包括文件的打开、读取、写入和关闭。
02
掌握利用 Python 进行基本程序设计的基础理论及编程实现,包括变量的使用、运算符的应用、条件语句和循环语句的编写。
04
理解 Python 中模块和包的概念,掌握如何导入和使用标准库以及第三方库。
06
培养良好的编程习惯和代码风格。
--- slide20.xml ---
目录
2.2
Python程序控制语句
2.3
函数定义与调用
2.1
Python基础知识
--- slide21.xml ---
2.1 Python基础知识
Python组合数据类型
2.1.4
内置函数
2.1.5
运算符与表达式
2.1.6
Python简介
2.1.1
Python编程环境
2.1.2
Python基本数据类型
2.1.3
--- slide22.xml ---
2.1.1 Python 简介
丰富的标准库和第三方库
多范式支持
动态类型
跨平台支持
强大的社区支持
简洁易读
Python 是一种功能强大且易于使用的编程语言,其具有以下主要特点。
--- slide23.xml ---
2.1.2 Python编程环境
Anaconda 内置 Spyder 和 Jupyter Notebook 工具,极大地提高了数据分析和代码开发的效率。
Anaconda 提供了一个强大的包管理器 Conda,允许用户轻松地安装、更新、卸载和管理不同的库与依赖项。
Anaconda 是一个广泛使用的开源数据科学平台,集成了众多工具和库,方便用户进行科学计算、数据可视化和深度学习等任务。
--- slide24.xml ---
课外作业
1.
下载Anaconda安装包
官网(https://www.anaconda.com/)下载速度较慢,可以选择国内的清华大学开源软件镜像站(https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/),根据电脑系统和CPU型号选择安装包,如Anaconda3-2024.10-1-Windows-x86_64.exe。
2.
安装Anaconda
双击下载的安装程序,启动安装向导,然后按照向导一步一步进行即可。
注意:在配置选项这一步,尽量
勾选“创建开始快捷方式”,以便在“开始”菜单中找到Anaconda。
关于“自动将Anaconda3添加到我的PATH环境变量”的选项。如果不勾选,则需要手动配置环境变量。
如果希望Anaconda成为默认的Python版本,可以勾选“注册Anaconda3作为我默认的Python”。
3.
测试Anaconda是否安装成功
打开Anaconda Prompt，输入以下命令验证安装：输入“conda --version”或“conda -v”命令,然后按回车键。如果显示Anaconda的版本号,则表示conda已经正确安装。
使用快捷键“WIN+R”打开运行面板,输入“cmd”,然后点击“确认”按钮。在命令提示符窗口中,输入“python”命令,然后按回车键。如果显示Python的版本信息和提示符(>>>),则表示Python环境已经正确配置。
请在自己电脑上安装
anaconda
--- slide25.xml ---
2.1.2 Python编程环境
Jupyter Notebook是一种基于网页的交互式开发工具,它支持多种编程语言,尤其以 Python 为主。通过Jupyter Notebook,用户可以在单一环境中编写代码、运行程序、可视化结果并
记录笔记
,使其非常适合数据探索和项目展示。
Jupyter Notebook
Anaconda Prompt是Anaconda环境中的一个命令行工具,专门用于管理和操作Anaconda生态系统。通过Anaconda Prompt执行与Conda相关的命令,例如创建、激活或删除虚拟环境,安装或更新Python包,以及管理Anaconda中的其他工具。
Anaconda Prompt
Spyder是一个功能强大的集成开发环境(IDE),专为Python编程语言设计,特别适合科学计算和数据分析。Spyder提供了直观的用户界面,支持代码编辑、调试、变量浏览和绘图等功能。
Spyder
02
01
03
anaconda
--- slide26.xml ---
2.1.2 Python编程环境
Spyder
Jupyter Notebook
Anaconda Prompt
三个工具的操作演示
--- slide27.xml ---
1.Anaconda Prompt
启动路径为：“开始”菜单→Anaconda程序组→Anaconda Prompt。
（1）要安装一个包，使用以下命令：
conda install [package-name]
（2）如果你想查看已经安装了哪些包，可以使用：
conda list
（3）如果你想卸载一个包，可以使用：
conda remove [package-name]
--- slide28.xml ---
2.Spyder
启动路径为：“开始”菜单→Anaconda程序组→Spyder。
Spyder的界面如图2-1所示。其用户工作区主要包括程序编辑区和IPython控制台。
--- slide29.xml ---
3
.
j
upyter Notebook
启动路径为：“开始”菜单→Anaconda程序组→Jupyter Notebook。或者在Anaconda prompt中运行“jupyter notebook”。
启动后，Jupyter Notebook的界面包含两个。一个是服务器终端，显示服务器信息，使用期间不能关闭
。另一个是启动浏览器显示的Web主页，是用户工作界面，如图2-6所示。
--- slide30.xml ---
Jupyter Notebook工具
--- slide31.xml ---
Python 程序主要书写规范
（
1
）书写规则
实例演示
通常每行只写一条语句,避免多条语句出现在同一行上,以保证代码简洁明了。
如果确实需要将多条语句写在同一行上,此时可以用分号(;)分隔多条语句。
如果语句过长，可以使用续行符反斜杠（\）来表示该语句将在下一行继续。
每条语句独占一行：
使用分号分隔多条语句（不推荐，但合法）：
续行符示例：
print("Hello, World!")
x = 10
y = 20
x = 10; y = 20; print(x, y)
content = '在Python源程序中
如果一行内
\
写多条语句，
语句间用分号（;）隔开。
\
如果一条语句过长，可以使用反斜杠符\
实现多行书写。'
--- slide32.xml ---
Python 程序主要书写规范
（
2
）缩进规则
实例演示
语句块是由一组相关联的代码行组成的,它们共同完成某个功能,Python 通过缩进来划分代码块的层级,同一级的代码缩进必须一致。
从显示效果来看,4 个空格与 1 个 Tab 的缩进一致,但其实不同,故混用空格和 Tab 可能会导致缩进错误。
缩进非常重要
--- slide33.xml ---
Python 程序主要书写规范
（
3
）注释规则
实例演示
注释是一种在代码中嵌入说明文字的方式,用于解释代码的逻辑、功能或其他重要信息,方便程序员理解和维护代码,但它不会被 Python 解释器执行。
单行注释以“#”开头,“#”后面的内容被视为注释。
使用成对的三单引号(''')或三双引号(""")可实现多行注释。
单行注释：
多行注释：
# 单行注释示例
x = 10 # 这是一个单行注释
'''
多行注释示例
这是一个多行注释，用于解释下面的代码块
'''
"""
计算两个数的和
参数: a -- 第一个数
，
b -- 第二个数
返回: a和b的和
"""
--- slide34.xml ---
Python程序的运行原理
Python程序的运行原理可以概括为：编写代码 → 解释器将代码编译成字节码 → Python虚拟机执行字节码 → 输出结果。
Python是一种解释型语言，这意味着Python代码在运行时会被逐行解释执行，而不是像编译型语言（如C或C++）那样先被编译成机器语言。
--- slide35.xml ---
Python程序的运行方式
（
1
）交互方式
实例演示
启动交互方式：在Spyder中，IPython控制台就是交互方式的入口。“In[序号]:”提示符表示代码输入位置。
代码执行：用户输入代码后，按回车键即可立即执行，并看到执行结果。使用“Out[序号]:”提示符表示执行结果的输出位置
获取帮助信息：在交互方式下，用户可以使用help()函数来获取关于Python中各种函数、对象和模块的文档和帮助信息。
In [1]: a = 20
In [2]: b = 10
In [3]: a + b
Out[3]: 30
In [4]: a - b
Out[4]: 10
--- slide36.xml ---
Python程序的运行方式
（
2
）文件方式
实例演示
创建Python文件：在Spyder中，用户可以新建一个Python文件（通常以.py为扩展名），并在其中编写代码。
保存代码：在Spyder中，可以通过点击工具栏上的保存按钮或使用快捷键（如Ctrl+S）来保存代码。
运行Python文件：在Spyder中通过点击运行按钮或使用快捷键来执行该文件。Spyder将调用Python解释器来读取并执行文件中的代码，并在IPython控制台中显示执行结果。
--- slide37.xml ---
2.1.3 Python基本数据类型
可以改变的操作数、变量名
变量
保持不变的操作数、立即数
常量
--- slide38.xml ---
变量
知识点
实例演示
通过给变量名赋值的方式来创建变量，例：
可以改变变量的值，下面的命令将变量a的值改为4：
Python中，不但可以改变变量的值，还可以改变它的类型：
可以同时给多个变量赋值，如：
a = 3
b = ‘Welcome to China’
c = (34, 56, 78)
In: a = 4
In: a = [2, 5, 7]
In: a, b, c = 2.3, 3.5, 6.7
--- slide39.xml ---
变量
知识点
实例演示
Python变量命名规则如下：
变量名只能包含字母（a-z 或 A-Z）、数字（0-9）和下划线（_）。
变量名不能以数字开头
变量名区分大小写
变量名不能使用Python的保留关键字
Python变量命名没有强制不能使用内置函数，但是此后不能再使用该内置函数。
del是一个常用的关键字，用于删除对象。它可以删除变量、列表中的元素、切片，或整个列表。使用del后，删除的对象将从内存中移除，且再也无法访问。
In: x = 10
del x # 访问 x 会引发NameError，因为 x 已被删除
例如，list()是一个内置函数，用来构造一个列表。执行以下语句会报错“TypeError: 'list' object is not callable”。原因是第一个语句把list定义为一个变量，它不再是一个内置函数。
In: list = [3,4,5]
In:
list('abc')
问题：怎么恢复
list
内置函数？
--- slide40.xml ---
python
关键字
--- slide41.xml ---
数据类型
基本数据类型
基本数据类型是用于存储单个值的数据类型。
整型：表示整数值，如213，1701等。
浮点型：表示带有小数部分的数值，如3.14，78.56等。
复数：表示复数，如2+3j，10.2+6.7j等。
布尔值：仅有两个值：真和假，用True 和 False表示。
字符串：表示文本数据，需要用一对界定符号。
Python的界定符号可以是单引号、双引号、三单引号及三双引号。
一对单引号和一对双引号可以生成一个单行字符串，如'广东'和"广州"。
一对三单引号和一对三双引号可以生成一个多行字符串，如：
'''广东
金融
学院'''
三单引号和三双引号也可表示注释，如何区分是作为注释还是多行字符串？
--- slide42.xml ---
数据类型
基本数据类型
基本数据类型是用于存储单个值的数据类型。
整型：表示整数值，如213，1701等。
浮点型：表示带有小数部分的数值，如3.14，78.56等。
复数：表示复数，如2+3j，10.2+6.7j等。
布尔值：仅有两个值：真和假，用True 和 False表示。
字符串：表示文本数据，需要用一对界定符号。
用转义字符表示在字符串中无法直接表示或具有特殊含义的字符，转义字符以反斜杠（\）开始，后跟一个或多个字符，这些字符组合起来表示一个特定的字符或执行某些特定的操作。例如，一个包含\n转义字符的字符串“Hello, Tom!\nThis is a new hotel.”。输出这个字符串的结果为：
Hello, Tom!
This is a new hotel.
--- slide43.xml ---
Python常见的转义字符
在字符串前面加上
r
或者
R
，表示字符串中的字符都不转义。
例如：由于\t将被识别成转义字符，字符串“D:\test\exer”将不能表示合法的Windows资源管理器路径。为了避免这种情况，可以在字符串前面加上r或者R，表示字符串中的字符都不转义， 字符串“r'D:\test\exer'”就可以表示合法的路径了。
--- slide44.xml ---
数据类型
基本数据类型
基本数据类型是用于存储单个值的数据类型。
整型：表示整数值，如213，1701等。
浮点型：表示带有小数部分的数值，如3.14，78.56等。
复数：表示复数，如2+3j，10.2+6.7j等。
布尔值：仅有两个值：真和假，用True 和 False表示。
字符串：表示文本数据，需要用一对界定符号。
在Python中，字符串是不可变的，这意味着一旦创建了字符串对象，其内容就无法被修改。由于这种特性，字符串对象没有增加或删除元素的方法。任何试图修改字符串内容的操作都会生成一个新的字符串对象，而不是在原有的字符串上直接修改。字符串的常用成员方法如表2-3所示。
--- slide45.xml ---
字符串的常用成员方法
--- slide46.xml ---
字符串的常用成员方法
format()
方法
实例演示
format()成员方法以指定的格式将变量插入字符串中，从而生成一个新的字符串，其基本语法如下所示。
"模板字符串{ }{ }".format(变量1,变量2)
模板字符串中包含的成对花括号，称为占位符，它的作用是将参数中的变量插入模板字符串中的占位符去，生成新的字符串。变量与占位符可以按照从左到右的顺序一一对应。
In: "身高{}厘米，年龄{}岁".format(170, 28)
Out: '身高170厘米，年龄28岁'
--- slide47.xml ---
字符串的常用成员方法
format()
方法
实例演示
也可以使用位置参数指定变量与占位符的对应关系，占位符中的序号代表format()方法的参数序号，从0开始。
如果参数是实数，则可以指定保留小数位数。
In: "身高{1}厘米，年龄{0}岁".format(28, 170)
Out: '身高170厘米，年龄28岁'
In: "Pi保留3位小数是: {:.3f}".format(3.141592653)
Out: 'Pi保留3位小数是: 3.142'
--- slide48.xml ---
字符串的常用成员方法
find()
方法
实例演示
find()用于查找子字符串在主字符串中的位置。它返回子字符串首次出现位置的索引，如果子字符串不存在，则返回-1。
In: "Hello, world!".find("world")
Out: 7
In: "Hello, world!".find("你好")
Out: -1
--- slide49.xml ---
字符串的常用成员方法
split()
方法
实例演示
split()将字符串分割成一个列表，分隔符由参数指定。如果省略参数，默认按空白字符分割。
In: '19.3 82.5 39.0 28.8'.split()
Out: ['19.3', '82.5', '39.0', '28.8']
In: '93,85,90,88'.split(',')
Out: ['93', '85', '90', '88']
--- slide50.xml ---
字符串的常用成员方法
strip()
方法
实例演示
strip()用于删除字符串开头和结尾处的空白字符，包括空格、换行符、制表符等。
In: " Hello, World! ".strip()
Out: 'Hello, World!'
--- slide51.xml ---
字符串的常用成员方法
join()
方法
实例演示
join()用于将可迭代对象（如列表、元组等）中的元素连接成一个字符串。它通过指定的分隔符（即调用 join() 的字符串）将可迭代对象中的每个元素连接起来，生成一个新的字符串。join() 方法只能用于包含字符串元素的可迭代对象。
In: '+'.join(['语文', '数学', '英语'])
Out: '语文+数学+英语'
什么是可迭代对象？
--- slide52.xml ---
数据类型
组合数据类型
组合数据类型则将若干个值组合成一个单一的数据项。
组合数据类型主要有
列表
元组
字典
集合
--- slide53.xml ---
组合数据类型
列表
列表是一种有序且可变的集合，用于存储多个元素。列表中的元素可以是任意类型，包括数字、字符串甚至其他列表。
创建列表有[]和list()两种方法。
通过方括号[]定义时，元素之间用逗号分隔。
list()由一个可迭代对象构造一个列表。
实例演示
In: [1,2,3]
In: ['a', 'b', 'c']
In: [[4,5,],[6,7]]
In: list('abc')
Out: ['a', 'b', 'c']
--- slide54.xml ---
组合数据类型
元组
元组是一种有序且不可变的集合，用于存储多个元素。与列表类似，元组中的元素可以是任意类型，但一旦创建，元组的内容就无法更改。
创建元组有()和tuple()两种方法。
元组通过圆括号()定义时，元素之间用逗号分隔。
tuple()由一个可迭代对象构造一个元组。
实例演示
In: (2.3, 3.5)
In: ('gduf', 'guang')
In: (1213,)
In: tuple(['a', 'b', 'c'])
Out: ('a', 'b', 'c')
--- slide55.xml ---
组合数据类型
集合
集合是一种无序且不重复的元素集合。
创建集合有{}和set()两种方法。
集合通过花括号{}定义时，元素之间用逗号分隔。集合中的每个元素都是唯一的，这意味着集合自动去除了重复的元素。如{2,3,3,4}创建的集合，结果是集合{2, 3, 4}。
set()由一个可迭代对象构造一个集合。
实例演示
In: {2,3,3,4}
Out: {2, 3, 4}
In: set('11223344')
Out: {'1', '2', '3', '4'}
--- slide56.xml ---
组合数据类型
字典
字典是一种用于存储键值对且无序的数据类型。字典的键必须是不可变类型，如字符串、整数或元组，每个键必须是唯一的，而值可以是任意类型。
创建字典有{}和dict()两种方法。
字典通过花括号{}定义，键值对之间用冒号分隔，每对键值对之间用逗号分隔。
dict() 方法。
实例演示
In: {"姓名": "张三", "年龄": 25, "籍贯": "广州"}
In: dict(name="Alice", age=25, city="New York")
Out: {'name': 'Alice', 'age': 25, 'city': 'New York'}
In: dict([("name", "Alice"), ("age", 25), ("city", "New York")])
Out: {'name': 'Alice', 'age': 25, 'city': 'New York'}
可以使用关键字参数的方式直接传递键值对来创建字典。
可以使用包含元组或列表的列表来创建字典，每个元组或列表表示一个键值对。
--- slide57.xml ---
序列对象的索引和切片访问方法
1.
索引访问单个元素
序列中的元素是有序排列的，可以通过索引获取单个元素或通过切片操作获取多个元素。
用整数索引访问单个元素，Python序列元素有正索引和负索引，如图2-10所示。
正索引从序列的起始位置（左侧）开始计数，索引值从 0 开始，依次递增。
负索引从序列的末尾位置（右侧）开始计数，索引值从 -1 开始，依次递减。
一般形式为：列表对象[索引]
实例演示
In: a = ['广', '东', '金', '融', '学', '院']
In: a[1]
Out: '东'
--- slide58.xml ---
序列对象的索引
--- slide59.xml ---
序列对象的索引和切片访问方法
2.
切片访问一个子序列
切片是一种用于从序列对象中提取子序列的方法。切片操作不会修改原始序列，而是返回一个新的序列。通过指定起始位置、结束位置和步长从序列中提取出一个新的子序列，如：
sequence[start:stop:step]
（1）start：切片的起始索引（包含该位置的元素）。如果省略，默认为序列的开头。
（2）stop：切片的结束索引（不包含该位置的元素）。如果省略，默认为序列的结尾。
（3）step：步长，表示切片的间隔。默认值为 1，表示每个元素都被包括在内。
实例演示
In: myList = [10, 20, 30, 40, 50]
In:
print(myList[1:4]) #print函数的功能是输出内容
In:
print(myList[:3])
In:
print(myList[2:] )
In:
print(myList[::2])
上面
4
条
print
函数的输出结果是什么？
[20, 30, 40]
[10, 20, 30]
[30, 40, 50]
[10, 30, 50]
--- slide60.xml ---
序列对象的索引和切片访问方法
3.
遍历可迭代对象的全部元素
使用遍历方法访问可迭代对象的全部元素，如字符串、元组、列表、集合和字典等。for...in 是一种用于遍历可迭代对象的循环结构，可以依次访问可迭代对象中的每个元素。它的语法如下：
for element in iterable:
#对element 进行操作
element：每次迭代时，element 代表可迭代对象中的一个元素。
iterable：可迭代对象，如range对象、字符串、列表、字典等。
实例演示
遍历range对象：
In: for v in range(8):
print( v, end = ' ' )
Out: 0 1 2 3 4 5 6 7
遍历字符串：
In: for v in "Guangdong":
print( v, end = ' ' )
Out: G u a n g d o n g
遍历列表：
In: for v in [2.1, 3.4, 6.5, 1.8]:
print( v, end = ' ' )
Out: 2.1 3.4 6.5 1.8
--- slide61.xml ---
列表的常用成员方法
--- slide62.xml ---
列表的常用成员方法
append()用于在列表的末尾添加一个新元素。调用 append()方法后，新元素会直接附加到列表的最后位置，列表的长度会增加1。
extend()用于将另一个可迭代对象（如列表、元组、集合等）的所有元素一次性添加到当前列表的末尾。
insert()用于在列表的指定位置插入一个新元素。insert()方法需要两个参数：插入位置的索引 i 和要插入的元素 x。调用insert(i, x) 后，元素 x 会被插入列表中索引 i 处，原本位于该位置及其后面的元素都会向后移动一位。
实例演示
In: a = [1, 2, 3]
a.append(4)
print(a)
Out: [1, 2, 3, 4]
In: a = [1, 2, 3]
a.extend([4, 5, 6])
print(a)
Out: [1, 2, 3, 4, 5, 6]
In: a = [1, 2, 3]
a.insert(1, 4)
print(a)
Out: [1, 4, 2, 3]
--- slide63.xml ---
列表的常用成员方法
remove()用于从列表中移除第一次出现的指定元素。它的参数表示要删除的元素，而不是索引。remove()会搜索列表中的元素，并删除找到的第一个匹配项。如果列表中不存在指定的元素，remove()会引发ValueError异常。
pop()用于移除并返回列表中指定索引位置的元素。它的参数表示要移除的元素的索引。pop()默认移除并返回列表中的最后一个元素。pop()方法不仅移除指定的元素，还将其返回，允许对该元素进行进一步处理。如果列表为空或索引超出范围，pop()会引发IndexError异常。
实例演示
In: a = [1, 2, 3, 2, 4]
a.remove(2)
print(a)
Out: [1, 3, 2, 4]
In: a = ['a', 'b', 'c', 'd']
r = a.pop(2)
print(r)
print(a)
Out: c
Out: ['a', 'b', 'd']
下面的列表
a
中有两个元素
2
，
remove
只删除第一个。
--- slide64.xml ---
列表的常用成员方法
index()用于查找并返回指定元素在列表中第一次出现的索引。如果列表中存在多个相同的元素，index()只会返回第一个匹配项的索引。如果列表中不存在指定的元素，index()会引发ValueError异常。
count()用于统计列表中某个指定元素出现的次数。count()方法遍历整个列表，返回指定元素在列表中出现的次数。
实例演示
In: a = ['a', 'b', 'c', 'd']
i = a.index( 'b')
print(i)
Out: 1
In: a = ['a', 'b', 'c', 'd', 'b', 'd', 'b']
c = a.count( 'b')
print(c)
Out: 3
--- slide65.xml ---
列表的常用成员方法
sort()是列表对象的一个方法，用于对列表中的元素进行原地排序，修改原列表，将其元素按照指定的排序顺序重新排列。sort()方法默认以升序排列列表中的元素，但可以通过 reverse 参数来进行降序排序。
实例演示
In: a = [3, 1, 4, 1, 5, 9]
a.sort()
print(a)
Out: [1, 1, 3, 4, 5, 9]
In: a = [3, 1, 4, 1, 5, 9]
a.sort(reverse=True)
print(a)
Out: [9, 5, 4, 3, 1, 1]
--- slide66.xml ---
range()函数
range()函数使用频率较高，生成一个可迭代对象，对象的值是不可变的，并且在实际迭代时才会计算出具体的值，输出对象不能输出序列值，常用来构造列表以及用于控制循环的迭代次数。它可以接受一个、两个或三个参数，用于指定序列的起始值、结束值和步长，它的语法格式如下：
range(start, stop, step)
（1）start（可选）：序列的起始值，默认为 0
（2）stop：序列的结束值（不包括该值），是必须的
（3）step（可选）：两个值之间的步长，默认为 1
实例演示
只指定结束值生成序列：
In: r = range(5)
print(list(r))
Out: [0, 1, 2, 3, 4]
指定起始值和结束值生成序列：
In: r = range(3,8)
print(list(r))
Out: [3, 4, 5, 6, 7]
指定起始值、结束值和步长生成序列：
In: r = range(0, 10, 2)
print(list(r))
Out: [0, 2, 4, 6, 8]
指定负数步长生成反向序列：
In: r = range(15, 0, -3)
print(list(r))
Out: [15, 12, 9, 6, 3]
--- slide67.xml ---
列表生成式
列表生成式是一种简洁而高效的创建列表的方式。通过列表生成式，可以用简洁的代码生成一个新的列表，该列表的每个元素是对已有序列或可迭代对象的操作结果。列表生成式的语法格式如下：
[expression for item in iterable if condition]
（1）expression：生成新列表中每个元素的计算表达式。
（2）item：可迭代对象中的每个元素。
（3）iterable：任何可迭代对象，如列表、元组、字符串、字典等。
（4）condition（可选）：一个条件表达式，用于过滤符合条件的元素。
实例演示
生成平方数列表：
In: squares = [x**2 for x in range(10)]
print(squares)
Out: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
指定条件，筛选出偶数：
In: evens = [x for x in range(10) if x % 2 == 0]
print(evens)
Out: [0, 2, 4, 6, 8]
统计列表的元素长度：
In: words = ['python', 'list', 'comprehension']
upper_words = [len(word) for word in words]
print(upper_words)
Out: [6, 4, 13]
--- slide68.xml ---
二维列表
如果列表的每个元素都是一个列表，就形成列表嵌套，称为二维列表。依次类推，还可以形成三维，甚至高维列表。二维列表常用于表示表格、矩阵或其他二维数据。
通过两层索引来访问二维列表中的元素——第一个索引用于访问行，第二个索引用于访问该行中的具体元素。这两个索引分别称为二维列表的行索引和列索引，一般形式如下：
列表对象[行索引][列索引]
实例演示
In: a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
例如,下面的命令创建了一个二维列表a，a有3个元素，每个元素是一个长度为3的一维列表。它可以表示一个3行3列的表格，或者3行3列的矩阵。
In: a[1][2]
Out: 6
--- slide69.xml ---
元组的常用成员方法
元组与列表不同的是，元组一旦创建，其内容就不能被修改（即不能增删元素或改变元素值），所以元组对象的成员方法也较少，元组又称为轻量级列表。
元组的成员方法只有count和index。这两个方法的使用方法与列表对应的方法相同。
--- slide70.xml ---
字典的常用成员方法
字典允许以键（key）和值（value）进行快速查找、插入和删除操作，字典对象的成员方法如表2-5所示。
--- slide71.xml ---
字典的常用成员方法
字典的访问非常简单且直观。要访问字典中的值，只需通过键来索引字典。可以使用方括号[]语法来获取对应键的值。如果访问的键不存在，会引发KeyError。为了避免这种情况，可以使用字典的get()方法，它会在键不存在时返回None或指定的默认值。
实例演示
In: font = {'字体':'宋', '字号':14, '颜色':'黑色'}
In: font['字体']
Out: '宋'
In: font.get('颜色') #未指定默认值
Out: '黑色'
In: font.get('字号', 12) #如果font对象没有字号键，则返回12
Out: 14
--- slide72.xml ---
字典的常用成员方法
要在字典中增加一项，只需为新的键赋值。如果该键已存在，原有的值会被覆盖。
实例演示
In: font = {'字体':'宋', '字号':14, '颜色':'黑色'}
font['加粗'] = '是'
font
Out: {'字体': '宋', '字号': 14, '颜色': '黑色', '加粗': '是'}
In: font['字号'] = 12
font
Out: {'字体': '宋', '字号': 12, '颜色': '黑色'}
加粗键不存在，将为字典增加该键，结果如下：
字号键已存在，将改变对应的值，结果如下：
--- slide73.xml ---
字典的常用成员方法
pop()用于删除并返回指定键对应的值。pop()方法允许安全地移除字典中的某个键值对，同时获取被移除的值。
实例演示
In: ziti = font.pop('字体')
ziti
Out: '宋'
In: font
Out: {'字号': 14, '颜色': '黑色'} #字体键已经从字典中移除
--- slide74.xml ---
字典的常用成员方法
items()、keys() 和values()分别用于获取字典的键值对、键和值，均返回一个可迭代对象。
items()返回的可迭代对象包含字典中所有键值对，每个键值对以元组的形式存在。
keys()返回的可迭代对象包含字典中所有键。
values()返回的可迭代对象包含字典中所有值。
需要注意的是，这三个函数返回的对象都不是列表，而是可迭代对象，可以用for…in进行遍历
实例演示
In: font.items()
Out: dict_items([('字体', '宋'), ('字号', 14), ('颜色', '黑色')])
In: font.keys()
Out: dict_keys(['字体', '字号', '颜色'])
In: font.values()
Out: dict_values(['宋', 14, '黑色'])
In: for item in font.items():
print(item)
Out: ('字体', '宋')
('字号', 12)
('颜色', '黑色')
--- slide75.xml ---
字典应用实践
从网上复制一个英语段落，并统计此段落中每个字母（不区分大小写）的出现次数。
如
Artificial intelligence (AI) is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and animals. Leading AI textbooks define the field as the study of 'intelligent agents': any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals. Colloquially, the term 'artificial intelligence' is often used to describe machines (especially computer programs) that mimic cognitive functions such as learning and problem-solving.
--- slide76.xml ---
字典的应用实践
s='''Artificial intelligence (AI) is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and animals. Leading AI textbooks define the field as the study of 'intelligent agents': any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals. Colloquially, the term 'artificial intelligence' is often used to describe machines (especially computer programs) that mimic cognitive functions such as learning and problem-solving.'''
dct={ } # 统计结果类似 {'p':21, 'a':5, 'x':2}
for c in s.lower():
dct[c]=dct.get(c,0) + 1 # 此处不能写 dct[c] = dct[c] + 1
print(dct) # 输出字典
--- slide77.xml ---
集合
集合常用来去除可迭代对象中的重复元素。
实例演示
In: a = [1, 2, 2, 3, 4, 4, 4, 5]
b = set(a)
print(b)
Out: {1, 2, 3, 4, 5}
下面的例子去除列表中的重复元素，得到不重复的元素。
--- slide78.xml ---
2.1.5 内置函数
数据类型转换
int()、float()、str()、list()、tuple()、set()、dict()
对象与属性
type(),dir()
数学运算
abs()、round()、max()和min()
序列操作
len()、sum()、range()
输入输出
input()、print()
--- slide79.xml ---
数据类型转换函数
int()、float()、str()、list()、tuple()、set()、dict()等函数用于在不同的数据类型之间进行转换。
int()可以将字符串或者实数转换为整数，int("123")得到整数123，int(3.45)得到整数3，将实数转换为整数会造成信息丢失。
函数float()可以将字符串或者整数转换为实数，float('3.14')得到3.14，float(56)得到56.0。
函数str()将多种对象转换为字符串，包括整数、实数以及组合数据类型等，str(1248)得到字符串'1248'。
str([2, 5, 7])
的结果是什么
？
--- slide80.xml ---
数学运算函数
包括abs()（取绝对值）、round()（四舍五入）、max()和min()（求最大值和最小值）等常用的数学函数。
实例演示
In: max([2.1,5.4,3.8])
Out: 5.4
In: round(3.25632, 2)
Out: 3.26
--- slide81.xml ---
序列操作函数
函数len()可以获取序列的长度
sum()可以对序列中的元素求和
range() 函数用于生成一个整数序列。
实例演示
In: len('Thank you!')
Out: 10
In: sum([3,4,5])
Out: 12
--- slide82.xml ---
输入输出函数
input()用于从用户获取输入
input()用于从用户那里获取输入数据。程序运行时，input() 会暂停执行，并等待用户输入文本。当用户按下回车键后，输入的数据会以字符串形式返回。它的参数是一个字符串，用于向用户显示提示信息。
因为无论用户输入的是什么内容，input()的返回都是字符串，所以如果需要得到整数或者实数，需要用int()和float()函数进行转换。
实例演示
In: input("Please enter your name: ")
Please enter your name: xiaoli
Out: 'xiaoli'
In: int(input("Please enter in integer: "))
Please enter in integer: 23
Out: 23
--- slide83.xml ---
输入输出函数
print()用于将输出内容显示在控制台或终端上。它可以将任意数量的对象作为参数，并将它们转换为字符串后输出到标准输出设备（通常是屏幕）。print()可以接受多个参数，并将它们以空格分隔后输出。每个参数都可以是不同的数据类型，如字符串、数字、列表等。
print()默认是以空格符分隔输出项，以换行结束。可以使用
sep
参数指定参数之间的
分隔符
。使用
end
参数指定输出结束后输出的字符（
结束符
），而不是以换行结束。
实例演示
In: print("Python", "is", "fun!")
Out: Python is fun!
In: print("Python", "is", "fun!", sep='---', end=' ');print('I love it!')
Out: Python---is---fun! I love it!
--- slide84.xml ---
对象操作函数
type( )
可以返回对象的类型，
dir( )
可以列出对象的所有属性和方法。
实例演示
In: a=3.54
type(a)
Out: float
In: b = 'string'
dir(b)
Out: … #
输出为字符串变量
b
的所有属性和方法，由于篇幅所限，此处未列出
--- slide85.xml ---
2.1.6 运算符与表达式
Python中的运算符用于执行各种操作，例如数学计算、比较、逻辑判断和赋值等。运算符是Python编程的基础部分，它们使得我们可以对变量和数据进行操作，从而实现各种功能。Python提供了丰富的运算符类型，包括算术运算符、关系运算符、逻辑运算符、赋值运算符和成员运算符。
--- slide86.xml ---
算术运算符
算术运算符用于执行基本数学运算。它们允许我们对数值数据进行加、减、乘、除、取整除法、求余、幂运算等操作，帮助开发者在程序中实现各种数值计算，算术运算符如表2-6所示。
当只有一个运算对象时，-是求该对象的相反数。当有两个运算对象时，-是减法运算。
//和%常用于整数之间，分别计算两整数相除的商和余数。
--- slide87.xml ---
关系运算符
关系运算符（也称为比较运算符）用于比较两个值的大小，判断两个值是否相等、大小关系如何等，当使用关系运算符进行比较时，其结果为布尔值 True 或 False，关系运算符如表2-7所示。
实例演示
In: a= 87
a >= 60
Out: True
In: a <= 100
Out: True
--- slide88.xml ---
逻辑运算符
逻辑运算符是用于布尔值（True和False）之间的运算，逻辑运算符如表2-8所示。
实例演示
要表达变量a的值为60~100，可以这样写：
In: (a>=60) and (a<=100)
Out: True
也可以这样写，更接近数学中的书写习惯：
In: 60<=a<=100
Out: True
--- slide89.xml ---
赋值运算符
基本赋值运算符是等号=，它将右侧的表达式结果赋给左侧的变量。除了基本赋值运算符外，Python还提供了多种复合赋值运算符，结合了算术运算和赋值操作，如表2-9所示。
实例演示
In: a = 5
b = a + 3
a
Out: 5
In: b
Out: 8
In: a = 4
a += 3
a
Out: 7
复合赋值运算符的运算规则如下：
a += b相当于a = a + b。
a -= b–3
的结果是什么
？
--- slide90.xml ---
成员运算符
成员运算符用来测试一个值是否存在于字符串、列表、元组、集合或字典中，成员运算符如表2-10所示。
实例演示
In: 'abc' in 'abc def'
Out: True
In: 3 in [3, 6, 9]
Out: True
In: font = {'字体':'宋', '字号':14, '颜色':'黑色'}
'字体' in font
Out: True
In: '宋' in font
Out: False
i
n
可以测试一个键是否在字典中，而不能测试一个值是否在字典中。
--- slide91.xml ---
表达式
表达式是由操作数（即变量、常量）和运算符连接起来符合语法规则的式子。运算符的优先级决定了表达式中运算符的执行顺序。运算符优先级定义了不同运算符计算顺序，优先级较高的运算符会先于优先级较低的运算符进行计算。Python运算符优先级从高到低大致为：算术运算符、关系运算符、逻辑运算符、赋值运算符、成员运算符。为了确保复杂表达式的计算顺序符合需求，使用括号来明确指定优先级是一种良好的编程习惯，使用括号使得程序的可读性更高。
实例演示
a>=100 and a<=200 and a%2==0
((a>=100) and (a<=200))and (a%2==0)
哪个表达式可读性高
？
--- slide92.xml ---
2.2 Python程序控制语句
2.2.2
循环语句
2.2.3
异常处理语句
2.2.1
条件语句
--- slide93.xml ---
2.2.1 条件语句
条件语句
一般形式如下,其中条件1和else后面的冒号必不可少
要素:条件1、代码块1和代码块2
执行过程:
先计算条件1,若为真则执行代码块1,否则执行代码块2
if 条件1:
代码块1
else:
代码块2
--- slide94.xml ---
实例演示
判断输入的成绩是否及格。
a = int(input('输入学生成绩：'))
if a >= 60:
print('成绩及格')
else:
print('成绩不及格')
判断输入的字符是否为大写字母。
a = input('输入一个字符：')
if 'A' <= a <= 'Z':
print('是大写英文字母')
else:
print('不是大写英文字母')
判断输入的3个国家名字是否包含中国。
x = input("输入3个国家名字")
if x.find('中国') >= 0:
print( '包含中国' )
else:
print( '不包含中国' )
判断输入的课程是否合法。
course = ['计算机', '数学', '英语']
x = input("输入选择的课程：")
if x in course:
print( '选课成功' )
else:
print( '选课失败' )
--- slide95.xml ---
实例演示
grades = [85, 90, 38, 52, 88, 41, 63]
# 计算平均分
average = sum(grades) / len(grades)
# 判断平均分是否及格
if average >= 60:
print("平均成绩及格。")
else:
print("平均成绩不及格。")
【例2-1】列表grades=[85, 90, 38, 52, 88, 41, 63]记录了一个班学生的成绩，判断该班学生的平均成绩是否及格，并输出相应的提示信息。
--- slide96.xml ---
单分支结构
特殊情况下，条件语句可以没有else分支，形成单分支条件语句，其一般形式如下：
实例演示
a = float(input('输入一个实数：'))
if a < 0:
a = -a
print(a)
例如，输入一个实数，计算并输出它的绝对值。当实数a大于等于0时，它的绝对值就是它自身，无须计算，当a小于0时，它的绝对值是它的相反数，需要计算，从而形成单分支条件语句。
if 条件1:
代码块1
--- slide97.xml ---
多分支结构
当需要根据多种不同的条件执行不同的代码时，就会形成多分支条件语句，其一般形式如下：
实例演示
bmi = float(input('输入bmi指数：'))
if bmi < 18.5:
print('偏瘦')
elif bmi < 24:
print('正常')
elif bmi < 28:
print('超重')
else:
print('肥胖')
成年人的BMI指数分类程序如下：
if 条件1：
代码块1
elif条件2：
代码块2
…
elif 条件n：
代码块n
else:
代码块n+1
--- slide98.xml ---
实例演示
# 输入一个月份
month = int(input("请输入月份(1-12)："))
# 判断月份所属的季节
if 3 <= month <= 5:
print("{} 月是春季".format(month))
elif 6 <= month <= 8:
print("{} 月是夏季".format(month))
elif 9 <= month <= 11:
print("{} 月是秋季".format(month))
elif month == 12 or 1 <= month <= 2:
print("{} 月是冬季".format(month))
else:
print("输入的月份不合法")
【例2-2】编写一个程序，输入一个月份的数字，输出该月份所在的季节。规则为：3月到5月为春季，6月到8月为夏季，9月到11月为秋季，12月到2月为冬季。
--- slide99.xml ---
嵌套的
分支结构
嵌套的分支结构的一般形式为：
在嵌套的分支结构中，保持代码缩进整齐是关键。Python依赖缩进来区分代码块，因此不正确的缩进会导致语法错误或逻辑错误。
if 条件1：
if 条件2：
代码块1
else：
代码块2
代码块3
else：
if 条件3：
代码块4
else：
代码块5
代码块6
--- slide100.xml ---
实例演示
# 输入年份和月份
year = int(input("请输入年份："))
month = int(input("请输入月份(1-12)："))
# 嵌套分支条件判断月份的天数
if month ==1 or month==3 or month==5 or month==7 or month==8 or month==10 or month ==12:
print("{} 月有 31 天".format(month))
elif month == 4 or month == 6 or month == 9 or month == 11:
print("{} 月有 30 天".format(month))
elif month == 2:
# 判断是否为闰年
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
print("{} 月有 29 天 (闰年)".format(month))
else:
print("{} 月有 28 天".format(month))
else:
print("输入的月份不合法")
【例2-3】编写一个程序，输入一个年份和月份，判断该月份有多少天。如果是2月份，还需要判断该年份是否为闰年（2月有29天）或平年（2月有28天）。其他月份按常规天数处理。
--- slide101.xml ---
实践
检验
求解思路：
1.
构建正确单词的词典
2.
提示用户输入一个英文单词
3.
将用户输入的单词与词典中的单词进行比对
3.1
如果用户输入的单词在词典中，则输出单词拼写正确的信息；
3.2
如果用户输入的单词不在词典中，则输出单词拼写错误的信息。进一步可给出正确拼写的建议。
请设计一个英语单词拼写检查的程序，即让用户随便输入一个单词，然后评判他的输入是否正确
(
如果不正确的话，给出正确的拼写建议
)。
--- slide102.xml ---
参考代码
import enchant
# 创建英语词典对象
d = enchant.Dict("en_US")
# 提示用户输入一个单词
word = input("请输入一个英语单词：")
# 检查单词拼写
if d.check(word):
print(f"单词 '{word}' 拼写正确.")
else:
print(f"单词 '{word}' 拼写错误.")
suggestions = d.suggest(word) # 获取拼写建议
print(f"正确拼写建议: {suggestions}")
--- slide103.xml ---
代码
解读
1.
import enchant
这行代码是导入enchant库。enchant库是一个用于检查单词拼写和提供拼写建议的 Python 库。导入该库后，代码才能使用enchant库中提供的各种功能和类来进行拼写检查等操作。
导入前需要安装这个库，库名为
pyenchant
。
2.
d = enchant.Dict("en_US")
这行代码创建了一个enchant库中的Dict类的实例对象d，该对象代表了一个特定语言的词典。其中
字符串参数
"en_US"表示创建的是美式英语（English, United States）的词典对象。如果想要检查其他语言的单词拼写，可以将"en_US"替换为相应的语言代码，如"en_GB"（英式英语）等。
3.
if d.check(word)
语句的作用是判断用户输入的单词word在已创建的美式英语词典d中是否被认为是拼写正确的单词。d.check(word)方法返回一个布尔值。如果单词word在词典中被认为是拼写正确的，该方法返回True；如果单词word在词典中被认为是拼写错误的，该方法返回False。
4.
当d.check(word)返回False，即判断单词拼写错误时，代码执行else分支中的语句。
5.
suggestions = d.suggest(word)
这行代码调用了d对象的suggest方法，传入拼写错误的单词word作为参数。suggest方法会根据词典中的数据和算法，生成一个可能的正确拼写的单词列表，并将其赋值给变量suggestions。
6.
print(f"正确拼写建议: {suggestions}")
这行代码将获取到的可能的正确拼写建议列表打印输出，让用户看到这些建议。
--- slide104.xml ---
2.2.2 循环语句
循环结构是程序设计中的一种核心控制结构，允许反复执行指定代码，直到特定条件不再满足为止。循环结构不仅可以处理简单的任务重复，还能根据程序的运行情况动态调整执行次数，是编写高效、灵活程序的重要工具之一。
Python中可以用for和while实现循环结构，称为循环语句。
for循环通常用于已知迭代次数的情况，例如遍历一个可迭代对象，它依次访问对象中的每个元素，无须手动管理循环计数器。
while循环适用于迭代次数未知的情况，它根据一个条件来决定是否继续执行循环体，需要手动设置和更新循环条件，让循环趋向于结束，否则会形成无限循环。
--- slide105.xml ---
for
循环语句
for循环通常用于已知迭代次数的情况,例如遍历一个可迭代对象,它依次访问对象中的每个元素,无须手动管理循环计数器。
如：
实例演示
# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
--- slide106.xml ---
for
循环语句
for循环通常用于已知迭代次数的情况,例如遍历一个可迭代对象,它依次访问对象中的每个元素,无须手动管理循环计数器。
如：
实例演示
# 遍历字符串
text = "hello"
for char in text:
print(char)
--- slide107.xml ---
for
循环语句
for循环通常用于已知迭代次数的情况,例如遍历一个可迭代对象,它依次访问对象中的每个元素,无须手动管理循环计数器。
如：
实例演示
# 遍历字典
person = {"name": "Alice", "age": 30, "city": "New York"}
for key, value in person.items():
print(f"{key}: {value}")
--- slide108.xml ---
2.2.
2
循环语句
while
循环语句
一般形式
要素：循环条件1、代码块1
执行过程：循环条件1为真就执行代码块1，否则结束循环。
while 循环条件1：
代码块1
while循环适用于迭代次数未知的情况，它根据一个条件来决定是否继续执行循环体，需要手动设置和更新循环条件，让循环趋向于结束，否则会形成无限循环。
--- slide109.xml ---
while
循环语句
在while循环中，通过比较一个或多个变量的值形成循环条件1，从而控制循环过程，这些变量称为循环变量。
实例演示
i = 1
s = 0
while i <= 100:
s += i
i += 1#改变循环变量的值
print( '1到100的和是：', s )
在下面的程序中，变量i就是循环变量，在循环语句的代码块中，语句
i += 1
必不可少，它的作用是改变循环变量的值，让循环趋向于结束。
这段代码的功能是什么
？
--- slide110.xml ---
break
和
continue
语句
break 语句是用于提前终止循环的一条控制语句，常用于for和while循环中。当程序执行到break时，当前循环立即停止，程序跳出循环体，继续执行循环之后的代码。
continue 语句是用于跳过当前循环的剩余代码，立即开始下一次循环的一条控制语句，常用于for和while循环中。当程序执行到continue语句时，循环体后续的代码将被忽略，直接进入下一次循环判断。它通常用于在某些条件下跳过不需要处理的部分，继续执行其他部分。
--- slide111.xml ---
实例演示
from random import randint
a = [randint(5000,20000) for i in range(100)]
for v in a:
if v > 10000:
print( v )
break
【例2-4】一个列表代表某公司100名员工的工资，找到第一个大于10000元的员工工资，并输出该工资。
根据题目要求，当找到第一个大于10000元的工资时，后面的列表元素就不必再访问了，因此应立即退出循环，不再继续执行多余的操作
。
--- slide112.xml ---
实例演示
from random import randint
a = [randint(500,2000) for i in range(10)]
for v in a:
if v % 2 == 1:
continue
v //= 2
print( v )
【例2-5】遍历一个整数列表中的元素，对其中的偶数减半输出。
在遍历列表的过程中，发现偶数，则对其减半操作，然后输出。如果发现奇数，则跳过该操作。
--- slide113.xml ---
循环嵌套
如果在一个循环的代码块内又包含另一个循环语句，就形成循环嵌套。依此类推还可以形成多层嵌套。循环嵌套使得程序能够处理多维数据或执行更复杂的任务。在嵌套循环中，外层循环每执行一次，内层循环会完整运行一遍。这种结构经常用于处理表格、矩阵、多维数组等场景，或实现多重条件下的重复操作。
--- slide114.xml ---
实例演示
a = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
for i in range(4):
for j in range(4):
print(a[i][j], end=' ')
print()
【例2-6】二维列表a表示一个4行4列的二维矩阵，按行输出矩阵的所有元素，元素之间用空格分隔。
处理二维数据需要采用二层嵌套循环，外层循环变量表示行索引，内层循环变量表示列索引
。
外层循环每迭代一次，内存循环就要全部执行一遍，故内层循环的代码需要执行的次数是
4
*4
，即
1
6
次。
--- slide115.xml ---
2.2.3 可迭代对象的遍历方法
Python中的许多内置函数会返回可迭代对象，故遍历可迭代对象是一种常见操作。
内置函数map()接受两个参数：一个函数和一个可迭代对象，它将一个函数应用于可迭代对象中的每个元素，并返回一个新的可迭代对象，其元素为函数作用的结果。
实例演示
In: chengji = ['87', '95', '76', '84']
mapped = map(int, chengji)
print(list(mapped))
Out: [87, 95, 76, 84]
在上面的例子中，
m
ap()
的第一个参数是内置函数
i
nt(),
第二个参数是一个元素是字符串的列表。它的作用是将
i
nt(
)
应用到列表中的每一个元素，即将列表中的每一个元素转换成整数，结果保存在一个可迭代对象中。最后将该对象转换成列表才可以输出其中的内容。
--- slide116.xml ---
2.2.3 可迭代对象的遍历方法
内置函数zip()接收两个或多个可迭代对象作为参数，将可迭代对象中对应位置的元素配对，形成一个元组，并将元组作为一个可迭代对象的元素，最后返回该可迭代对象。
实例演示
In: names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
zipped = zip(names, scores)
print(list(zipped))
Out: [('Alice', 85), ('Bob', 92), ('Charlie', 78)]
在上面的例子中，int()的两个参数是两个列表，它将两个列表中对应位置的元素配对，形成一个元组，并返回一个可迭代对象，最后将该对象转换成列表才能输出其中的内容。
--- slide117.xml ---
2.2.3 可迭代对象的遍历方法
Python遍历可迭代对象有三种方法
（1）用for…in遍历
实例演示
from random import randint
a = [randint(10,200) for i in range(100)]
t = 0
for v in a:
if v % 3 == 0:
t += 1
print( '3的倍数数量是：', t )
【例2-7】求一个长度为100的随机整数列表中，3的倍数有多少个。
--- slide118.xml ---
2.2.3 可迭代对象的遍历方法
Python遍历可迭代对象有三种方法
（2）使用enumerate()内置函数
用for…in遍历时，能够访问可迭代对象的全部元素，但是很难掌握每个元素的索引。enumerate()内置函数在遍历可迭代对象时同时获取元素的索引和值，返回一个包含索引和值的元组，常用于需要在循环中同时访问元素和其索引的场景。
实例演示
from random import randint
a = [randint(0,100) for i in range(50)]
for i, v in enumerate(a):
print(i+1, v)
【例2-8】一个列表保存了一个班50名学生的成绩，输出每个学生的序号以及对应的成绩。
用enumerate函数遍历时，同时得到元素的索引和值，分别赋给变量i和v,由于第一个元素的索引是0，给它加1以表示学号。
--- slide119.xml ---
2.2.3 可迭代对象的遍历方法
Python遍历可迭代对象有三种方法
（3）依次遍历可迭代对象的索引，用while和for…in均可。
需要注意的是，在用for…in或者enumerate函数时，修改遍历的变量不能作用于原来的列表，故
右边
的程序是错误的：
实例演示
from random import randint
a = [randint(0,100) for i in range(10)]
print(a)
for v in a:
v *= 2
print(a)
【例2-9】将一个整数列表中的每个元素变成原来的2倍。
for循环之前和之后输出来的列表是相同的，原因是语句v *= 2只是把变量v变成了原来的2倍，并没有改变列表中的元素。
--- slide120.xml ---
2.2.3 可迭代对象的遍历方法
Python遍历可迭代对象有三种方法
（3）依次遍历可迭代对象的索引，用while和for…in均可。
实例演示
from random import randint
a = [randint(0,100) for i in range(10)]
print(a)
for i in range(len(a)):
a[i] *= 2
print(a)
【例2-9】将一个整数列表中的每个元素变成原来的2倍。
下面的程序用函数len()计算列表的长度，并用range()函数生成一个可迭代对象，对象的元素代表列表的索引，对它进行迭代时，变量i就表示原列表的索引。因为其中的语句a[i] *= 2改变了列表中的元素，所以此程序能够实现题目的目标。
--- slide121.xml ---
2.2.4 异常处理
异常处理机制用于捕获错误并做出相应的处理，从而提高程序的稳健性和容错能力，提升用户体验。
Python 提供了try-except结构来实现异常处理。
将执行代码块放在try块中，如果在执行过程中发生异常，程序会跳到对应的except异常处理代码块进行处理。
实例演示
try:
result = 10 / 0
except:
print("除零错误")
try:
# 执行代码块
except:
#异常处理代码块
--- slide122.xml ---
2.3 函数
2.3.1 函数定义
2.3.3 模块与包的使用
2.3.5 文件操作
2.3.2 函数调用
2.3.4 第三方库的安装与使用
--- slide123.xml ---
2.
3
.
1
函数定义
关键字：def
要素：函数名、形式参数列表、函数体
函数定义形式如下：
实例演示
def add(a, b):
s = a + b
return s
例如，以下代码定义一个函数add，此函数具有两个参数 a 和 b，函数体计算两个参数的和，然后返回它们的和。
def 函数名([形式参数列表]):
# 函数体
[return 返回值]
调用者调用函数add，输入两个参数，将得到它们的和。
In: add(3,4)
Out: 7
--- slide124.xml ---
2.
3
.
1
函数定义
函数可以没有参数，称为无参函数。
定义无参函数时，函数名后面的圆括号也不能省略。
函数也可以没有返回值，这时可以不写return语句。
实例演示
def sayHello():
print( 'Hello, everybody!' )
--- slide125.xml ---
2.
3
.
1
函数定义
Python函数可以返回多个值。定义函数时，将需要返回的多个值依次放在return后面，并以逗号分隔。
实例演示
def getMinMax( alist ):
minValue = min( alist )
maxValue = max( alist )
return minValue, maxValue
以下函数接收一个列表参数，同时返回列表的最小值和最大值。
--- slide126.xml ---
2.
3
.
1
函数定义
一个函数可以包含多个return语句，用于在不同的条件下返回不同的结果。return语句不仅用于返回函数的结果，还可以结束函数的执行。当函数执行到return语句时，函数会立即终止，并返回指定的值，因此，多个return语句不会相互干扰。
实例演示
def sort(a, b):
if a >= b:
return a, b
else:
return b, a
以下代码定义的函数sort接收两个参数，并按照从大到小的顺序返回。
--- slide127.xml ---
函数调用
函数调用通过函数名和传递的参数进行。形式如
下：
调用时，程序会跳转到函数定义处执行函数体中的代码，完成后将结果返回到调用位置。
实例演示
函数名([实际参数列表])
def add(a, b):
s = a + b
return s
函数
定义：
x
= add(5, 4)
函数
调用：
--- slide128.xml ---
2.
3
.
2
函数调用
对于有参函数，需要给形式参数传递值，这些值称为实际参数，简称实参。
实参向形参传递值的方式有以下几
种：
位置参数
实际参数与形式参数是
按位置一一对应进行传递
的，故称为位置参数。
实例演示
def add(a, b):
s = a + b
return s
x
= add(5, 4)
#实际参数5、4分别传递给形式
参数a、b
--- slide129.xml ---
2.
3
.
2
函数调用
默认值参数
默认值参数允许在函数定义时为某些参数指定默认值。这样，在调用函数时，如果未提供这些参数的值，函数将使用预设的默认值。
给参数设置默认值的形式如下：
当有的参数没有默认值，有的参数具有默认值时，要求默认值参数必须放在非默认值参数的后面。
实例演示
In: def default(x, y = 3):
#默认值参数放在后面
s = x + y
print( 'Sum of x and y is:', s)
为了降低复杂度，建议只使用不可改变对象作为参数的默认值。
def 函数名(…，形参名=默认值):
# 函数体
[return 返回值]
In: default( 2 )
default( 2, 4 )
两次调用的结果是多少？请解释实参与形参的传递
。
--- slide130.xml ---
2.
3
.
2
函数调用
关键字参数
在Python中，函数参数可以通过位置参数和关键字参数两种方式进行传递。
按位置参数传递时，按照参数的位置，实际参数与形式参数从左到右一一对应。
按关键字参数传递时，允许在函数调用时明确指定每个参数的名称和对应的值，实际参数与形式参数
不需要遵循函数定义中的参数顺序
，还可以跳过某些具有默认值的参数。
实例演示
In: def keyParameter(x, y = 3, z=4):
s = x + y + z
print( 'Sum of x and y is:', s)
keyParameter(z = 3, y = 2, x = 1)
#改变参数顺序
keyParameter(x = 1, z = 2)
#跳过默认值参数
Out: Sum of x, y and z is: 6
Sum of x, y and z is: 6
In: keyParameter(
1
, y = 2,
3
)
#这种函数调用的格式是错误的, 关键字参数后面
#
不能再有位置参数
--- slide131.xml ---
不可变对象和可变对象
如果变量的值发生了改变，其对应的内存地址也会发生改变，这种数据类型称为不可变数据类型。
整型、浮点型、字符串型和元组
属于不可变数据类型。
不可变是指不能修改原内存单元里的数据。
实例演示
In: a = 10
In: id(a)
#id
内置函数的功能是查看变量的内存地址
Out: 262719776
#注意：不同机器、不同时刻执行上面的代码，变量a的内存地址可能不同
In: a = 20 # 改变a 的值
In: id(a)
Out: 262719936 # 变量a的内存地址发生改变
不可变对象
--- slide132.xml ---
不可变对象和可变对象
不可改变对象作为实参时，在函数内部改变形参的值，不会导致实参的值发生改变。
实例演示
In： def modify( x ):
x = x * x
#改变形参
print( 'x =', x )
y = 5
modify( y )
print( 'y = ', y )
Out: x = 25
y = 5
#实参的值不发生改变
变量y是一个不可改变对象，将它作为实际参数调用函数modify()，传递给形式参数x，函数内部将x修改为它的平方。函数调用结束后，输出变量y的值，没有发生改变。
不可变对象
--- slide133.xml ---
不可变对象和可变对象
如果变量的值发生了改变，但其对应的内存地址不变，则这种数据类型称为可变数据类型。
即：可修改原内存单元的数据。
列表、字典和集合
是可变数据类型。
实例演示
In: lst = [1, 2, 3]
In: id(lst)
Out: 204715272 # lst的内存地址
In: lst.append(4) # lst添加元素4
In: lst[0] = 9
#
改变列表第
0
个元素的值
In: lst
Out: [9, 2, 3, 4]
In: id(lst)
Out: 204715272 # lst的内存地址没有改变
可变对象
--- slide134.xml ---
不可变对象和可变对象
可变对象作为实参时，向形参传递的不是值，而是实参的内存地址，这样，实参和形参是共用相同的存储空间
的。因而在函数内部改变形参的值，会导致实参的值发生改变。
实例演示
In: def modifyList( b ):
for i in range(len(b)):
b[i] *= b[i]
#改变形参
print( 'b = ', b)
a = [4,5,6]
modifyList( a )
print( 'a = ', a )
Out: b = [16, 25, 36]
a = [16, 25, 36]
#实参发生改变
列表对象a是一个可改变对象，将它作为实际参数调用函数modifyList()，传递给形式参数b，函数内部将b的元素修改为它的平方。函数调用结束后，输出变量a的值，也发生了改变。
可变对象
实参向形参传递：
b=a
此时，是把列表
a
的地址赋值给
b
--- slide135.xml ---
变量的作用域
变量的作用域指的是变量在程序中的可访问范围。作用域决定了变量在哪些地方可以被引用或修改。根据变量的定义位置，变量分为局部变量和全局变量。
1.
局部变量
局部变量是在函数或代码块内部定义的变量。局部变量只能在该函数内部使用，函数执行结束后，这些变量就会被销毁，无法在函数外部访问。
实例演示
def localVar( a ):
b = 0
if a >= 0:
c = 1
print(a, b, c)
下面函数中的形参变量
a
，函数内定义变量
b
，代码块内定义的变量
c
都是局部变量，在函数外部无法访问。
--- slide136.xml ---
变量的作用域
（
2
）全局变量
全局变量是在函数外部定义的，它们的作用域从变量定义开始，一直持续到程序结束。
实例演示
变量
x
在函数globalVar()中可以使用。
x = 10
#
变量x是在函数外部定义
，是全局变量
def globalVar():
y = x * x
print( 'x={}, y={}'.format(x,y) )
globalVar()
--- slide137.xml ---
变量的作用域
如果全局变量和局部变量同名，则各自的作用域
如何？
实例演示
def local(b): # 此处b是形式参数，它是局部变量
a = 3 # 引处a是在函数内定义的变量，是局部变量
b
= 5 # 修改的是局部b
print("a = {}, b = {}".format(a, b)) #输出的是局部变量a,b的值
def fun():
print('fun内 b=', b) # 此处是访问全局b
b
= 4 # 此处的 b 定义在所有函数的外面，是全局变量
local(
b=b
) # 形参b和实参b可以同名，其实是两个变量，第1个b是形式参数，第2个b是实际参数
fun()
--- slide138.xml ---
实例演示
# 定义函数，计算偶数的平方和
def sumSquaresEvens(numbers):
sum_squares = sum(x**2 for x in numbers if x % 2 == 0)
return sum_squares
# 调用函数并输出结果
number_list = [1, 2, 3, 4, 5, 6, 7, 8]
result = sumSquaresEvens(number_list)
print("所有偶数的平方和是: {}".format(result))
【例2-10】编写一个函数，计算一个整数列表中的所有偶数的平方和。具体要求如下。
定义一个函数 sumSquaresEvens(numbers)，该函数接收一个整数列表作为参数，计算并返回所有偶数的平方和。
--- slide139.xml ---
lambda表达式
lambda 表达式是一种用于创建匿名函数的简洁方式。匿名函数是指没有名字的函数，通常用于定义简单的、短小的函数，而无须正式使用def关键字来声明函数。
lambda表达式的格式如下：
形参列表对应函数的形参列表，表达式对应函数的函数体，表达式的值就是匿名函数的返回值。
lambda表达式常常用作函数参数。
实例演示
【例2-11】随机产生一个长度为8的列表，取值范围为[-100,100]，对该列表按元素平方值从小到大的顺序排序，输出原列表和排序后的列表。
In: from random import randint
t = [randint(-100, 100) for i in range(8)]
print( '原列表：', t)
t.sort(key=lambda y : y * y)
#lambda表达式作参数
print( '排序后：', t)
Out: 原列表： [19, 72, -52, 44, -26, 20, 43, 99]
排序后： [19, 20, -26, 43, 44, -52, 72, 99]
lambda 形参列表：表达式
--- slide140.xml ---
2.3.3 模块与包的使用
概念：
模块：一个包含Python代码的文件。
包：一个包含__init__.py文件的目录。
编程时如需使用某个模块，首先要使用 import 语句将该模块导入。导入有如下几种方式：
（1）导入整个模块
（2）导入模块中的指定对象
（3）导入模块中的所有内容
（4）给导入的模块或对象起别名
实例演示
（1）导入整个模块
导入格式为： import 模块名
使用格式为：模块名.函数名
In: import math # 导入整个math模块
In: math.pi # 调用math模块中的pi常量
Out: 3.141592653589793
In: math.sin(math.pi / 2) # 调用math模块中的pi常量和sin()函数
Out: 1.0
--- slide141.xml ---
2.3.3 模块与包的使用
概念：
模块：一个包含Python代码的文件。
包：一个包含__init__.py文件的目录。
编程时如需使用某个模块，首先要使用 import 语句将该模块导入。导入有如下几种方式：
（1）导入整个模块
（2）导入模块中的指定对象
（3）导入模块中的所有内容
（4）给导入的模块或对象起别名
实例演示
（2）导入模块中的指定对象
导入格式为：
f
rom 模块名 import 对象名列表
使用格式为：直接使用导入的对象名，而不加模块名
In: from math import cos, pi
cos(pi/4)
Out: 0.7071067811865476
--- slide142.xml ---
2.3.3 模块与包的使用
概念：
模块：一个包含Python代码的文件。
包：一个包含__init__.py文件的目录。
编程时如需使用某个模块，首先要使用 import 语句将该模块导入。导入有如下几种方式：
（1）导入整个模块
（2）导入模块中的指定对象
（3）导入模块中的所有内容
（4）给导入的模块或对象起别名
实例演示
（3）导入模块中的所有内容
导入格式为：from 模块名 import *
使用格式为：导入后可以使用模块中的所有对象，而不加模块名
In: from math import *
sqrt(16.0)
Out: 4.0
--- slide143.xml ---
2.3.3 模块与包的使用
概念：
模块：一个包含Python代码的文件。
包：一个包含__init__.py文件的目录。
编程时如需使用某个模块，首先要使用 import 语句将该模块导入。导入有如下几种方式：
（1）导入整个模块
（2）导入模块中的指定对象
（3）导入模块中的所有内容
（4）给导入的模块或对象起别名
实例演示
（4）给导入的模块或对象起别名
导入格式为：import 模块名 as 别名
from 模块名 import 对象名 as 别名
使用格式为：
使用简短的别名代替
模块名
In: from random import randint as rand
rand(10,20)
Out: 13
in:
import
numpy
as np
import pandas
as pd
--- slide144.xml ---
2.3.3 模块与包的使用
概念：
模块：一个包含Python代码的文件。
包：一个包含__init__.py文件的目录。
编程时如需使用某个模块，首先要使用 import 语句将该模块导入。导入有如下几种方式：
（1）导入整个模块
（2）导入模块中的指定对象
（3）导入模块中的所有内容
（4）给导入的模块或对象起别名
实例演示
random模块是 Python 标准库中的一个模块，专门用于生成随机数和执行随机操作。
【例2-12】常用随机函数应用。
In: from random import randint, random, uniform
for i in range(10):
print(randint(20,60), end=' ')
Out: 38 58 34 60 39 55 60 53 41 22
In: for i in range(2):
print(random(), end=' ')
Out: 0.4775563536570093 0.09605185135549033
In: for i in range(2):
print(uniform(3,4), end=' ')
Out: 3.5772165060646866 3.2553078582266086
--- slide145.xml ---
2.3.4 第三方库的安装与使用
概念：
库：指的是一个功能集合，通常是开发者预先编写的一组工具、函数或类，供其他开发者调用和使用。
安装：
库以模块或者包的形式安装到计算机上，用户采用导入模块或者包的方法就可以使用第三方库。
实例演示
jieba 是一个中文分词库，专门用于处理中文文本的分词任务。
wordcloud是一个用于生成词云图的库，词云图是一种文本可视化的方式，通过不同词语的大小、颜色来表示其在文本中出现的频率。
安装：
pip install jieba
pip install wordcloud
pip install 库名
conda install 库名
--- slide146.xml ---
2.3.4 第三方库的安装与使用
概念：
库：指的是一个功能集合，通常是开发者预先编写的一组工具、函数或类，供其他开发者调用和使用。
安装：
库以模块或者包的形式安装到计算机上，用户采用导入模块或者包的方法就可以使用第三方库。
实例演示
绘制词云图：
import wordcloud
string = 'Python is a versatile, high-level programming language known for its readability and efficiency. It was first released by Guido van Rossum in 1991 and has since grown to become one of the most popular languages for web development, data analysis, artificial intelligence, and more.'
wc = wordcloud.WordCloud(background_color='white', width=800, height=600)
wc.generate( string )
wc.to_file( r'd:\ying.png' )
pip install 库名
conda install 库名
--- slide147.xml ---
2.3.4 第三方库的安装与使用
概念：
库：指的是一个功能集合，通常是开发者预先编写的一组工具、函数或类，供其他开发者调用和使用。
安装：
库以模块或者包的形式安装到计算机上，用户采用导入模块或者包的方法就可以使用第三方库。
实例演示
绘制词云图：
import wordcloud
import jieba
string = '励学首在立志，成为有知识、有教养、有思想、有才干的人；励学重在勤勉，勤于阅读，勤于观察，勤于思考，勤于总结；励学贵在坚持，知难而进，迎难而上，活到老、学到老。'
spacestring = ' '.join(jieba.lcut(string))
wc = wordcloud.WordCloud(font_path='simk人工智能.ttf', background_color='white', width=800, height=600)
wc.generate( spacestring )
wc.to_file( r'd:\zhong.png' )
pip install 库名
conda install 库名
--- slide148.xml ---
2.3.5 文件操作
文件是存储数据的基本单位。
文件可以包含多种类型的数据，如文本、图像、音频、视频等。
文件是通过文件名和路径来定位和访问。每个文件都有其特定的格式和结构，通常由文件扩展名（如 .txt、.jpg、.mp3等）标识文件的类型。
Python读/写文件的基本流程如图所示
文件操作主要包含3个步骤：
（1）打开文件。
（2）读、写文件。
（3）关闭文件。
--- slide149.xml ---
2.3.5 文件操作
（1）打开文件。
操作文件前一定要先打开文件。内置函数open()可打开文件，格式为
实例演示
该语句的作用是以“w”只写方式打开d盘根目录下的文本文件"test.txt"。
注：此处的r表示原始字符串，这样\t就不会被视为转义字符。如果没有r, d:\test.txt 由于转义不会被理解为正确的文件名，将报错。
fw = open(r"d:\test.txt", "wt") # w写, t文本
file = open(文件名，文件模式，编码方式)
--- slide150.xml ---
2.3.5 文件操作
（3）关闭文件。
文件使用过后一定要注意及时关闭。文件对象的close()方法和with关键字是两种常用的方式都可以确保文件在使用后正确关闭。使用close()方法关闭文件的格式为：
使用with关键字的格式为：
file.close()
with open(文件名, 'r') as file:
#读写文件代码块
--- slide151.xml ---
2.3.5 文件操作
（2）读、写文件。
读文件常有两种方式：
（1）按字符数读。对象file的read方法可以读取指定数量的字符。
实例演示
【例2-13】当前文件目录下有一个文件log.txt，其内容如下：
广东金融学院互联网金融与信息工程学院
编写程序读取其中的学校名称。
with open( 'log.txt', encoding='utf-8' ) as file:
name = file.read(6)
print( name )
--- slide152.xml ---
2.3.5 文件操作
（2）读、写文件。
读文件常有两种方式：
（2）按行读。readlines()用于一次性读取文件中的所有行，并将它们封装为一个列表返回，每个列表元素是一个字符串，对应文件中的一行，包含行尾的换行符 \n，文件的最后一行没有换行符。
实例演示
【例2-14】按行遍历文件log.txt的所有行。
with open( 'log.txt', encoding='utf-8' ) as file:
for line in file.readlines():
print( line )
--- slide153.xml ---
2.3.5 文件操作
（2）读、写文件。
文件对象的write()方法可以将字符串写入文本文件中。要将整数和浮点数写入文本文件中，需要先转换成字符串再写入。write()方法写字符串到文件中时不会自动换行，需要在一行的末尾手动加上换行符。
--- slide154.xml ---
实例演示
from random import uniform
wage = [round(uniform(100,200),2) for i in range(100)]
with open( 'salary.txt', 'w' ) as file:
wagestr = ''
for i, w in enumerate(wage):
wagestr = wagestr + str(w) + ' ' #用空格分隔数据
if (i + 1) % 20 == 0:
wagestr = wagestr + '\n' #行尾要加上换行符
file.write( wagestr )
wagestr = ''
【例2-15】一维列表wage存储的是一个公司员工的工资数据（保留2位小数），写程序将该列表写入文本文件中salary.txt，每行写20个数据，数据之间用逗号分隔。
--- slide155.xml ---
实例演示
wage = []
with open( 'salary.txt', 'r' ) as file:
for line in file: #遍历文件对象
line = line.strip()
line = line.split() #将字符串打断
for w in line:
w = float( w ) #将字符串转换为浮点数
wage.append( w )
print( wage )
【例2-16】写程序读取工资文件salary.txt中的工资数据，保存到一个列表中。