资源简介

(共79张PPT)
第三部分　计算机编程基础
——Python语言
第四章　面向对象程序设计基础
考点一~十一
考
纲
要
求 一、基本概念
1.理解面向对象程序设计的基本特征
2.理解对象与类
3.掌握类的三大特性：继承、封装、多态
4.掌握事件、方法、属性
二、Tkinter库
1.掌握Button按钮
2.掌握Checkbutton控件
3.掌握Entry控件
4.掌握Label控件 5.掌握Listbox控件
6.掌握Radiobutton控件
7.掌握Text控件
8.掌握Message控件
三、面向对象程序设计
1.掌握事件与事件响应(仅限于鼠标事件和键盘事件)
2.掌握控件布局
3.综合应用简单GUI界面程序设计
命
题
趋
势 1.要求学生理解面向对象程序设计的基本概念，能够综合应用类、方法、属性等进行程序设计
2.掌握Tkinter常用控件(Button、Checkbutton、Entry、Label、Listbox、Radiobutton、Text、Message)，能够熟练使用常用控件完成程序设计
3.考查学生对事件响应(鼠标、键盘)、控件布局以及综合运用面向对象思想设计简单GUI界面程序的能力。
4.考查学生对面向对象核心概念的理解与记忆，以及将Tkinter控件与事件响应相结合、在面向对象框架下进行模块化编程并完成简单GUI界面设计的能力
考
向
分
析 【考查内容】
面向对象程序设计的基本特征，继承、封装、多态，Tkinter库，事件与事件响应，控件布局，简单GUI界面程序设计
【考查题型】
填空题、单项选择题和综合应用题
【考查分值】
一般为12~20分
面向对象是相对于面向过程而言的，是一种以对象为基础，以事件来驱动对象执行处理的程序设计技术。
一、面向过程程序设计
面向过程程序设计方法主要是分析出实现需求所需要的步骤，采用函数(或过程)来描述对数据的操作，通过函数一步一步实现这些步骤，接着依次调用函数即可。
面向过程程序设计性能更高，适合于简单系统，容易理解。
面向过程程序设计方法以功能为中心划分模块，难以维护，可扩展性差。
二、面向对象程序设计
1.面向对象程序设计(Object-Oriented Programming，简记为OOP)先分析需求中涉及哪些对象，这些对象各自有哪些特征、有什么功能，对象之间存在何种关系等，最后通过对象的组合和调用完成需求。
2.面向对象程序设计开发模式以数据为中心，封装对象，更有利于人们开拓思维，在具体的开发过程中便于程序的划分，方便程序员分工合作，提高开发效率。面向对象程序设计有以下优点：
(1)可重用性：代码重复使用，减少代码量，提高开发效率。
(2)可扩展性：指新的功能可以很容易地加入系统中来，便于软件的修改。
(3)可管理性：能够将功能与数据结合，方便管理。
面向对象程序设计开发模式之所以使程序设计更加完善和强大，主要是因为面向对象具有继承性、封装性和多态性3个核心特性。
一、继承性
程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。在继承的过程中“子类”具有“父类”的全部属性和方法，同时“子类”还具有自己的新属性和方法。通过继承“父类”的属性和方法对于共有的属性和方法“子类”不必再定义，这样可以减少代码量，提高开发效率。
二、封装性
封装是将代码及其处理的数据绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部干扰且不被误用。封装的目的在于保护信息，使用它的主要优点：
1.保护类中的信息。它可以阻止在外部定义的代码随意访问内部代码和数据。
2.隐藏细节信息，一些不需要程序员修改和使用的信息。比如取款机的键盘内部是如何运行的，用户不需要知道。
3.有助于建立各个系统之间的松耦合关系，提高系统的独立性。当一个系统的实现方式发生变化时，只要它的接口不变，就不会影响其他系统的使用。例如U盘，不管里面的存储方式怎么改变，只要U盘上的USB接口不变，就不会影响用户的正常操作。
4.提高软件的复用率，降低成本。每个系统都是一个相对独立的整体，可以在不同的环境中得到使用。
三、多态性
多态性是允许你将父对象设置成为和一个或更多个它的子对象相等的技术，赋值之后父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单来说，就是父类引用可指向子类对象，同一方法在不同子类中呈现不同行为，支持“同一接口，多种实现”。
一、类
类是用来描述一组具有相同属性和方法的对象的集合，是对这组对象的概括、归纳和抽象表达。定义一个类是为了重复创建该类的实例，同一个类的多个实例具有相同的特征，而类则是定义多个实例的共同特征。类不是一种具体存在，实例才是具体存在。
二、对象
对象是类的具体表现形式，是实际存在的个体。对象可以是各种事物，例如桌子、汽车、学生等。对象通常包含两部分信息：属性和行为。一般使用变量表示对象的属性，用函数或方法表示对象的行为。
现实世界中，先有对象后有类，而在计算机的世界里，先有类后有对象。在面向对象程序设计中，先在类中定义共同的属性和行为，然后通过类创建具有特定属性值和行为的实例，这便是对象。
一、属性
对象的特性称为对象的属性，它体现对象的静态特征。描述对象特性的具体数据称为属性值，在程序设计中一般使用变量表示对象的属性。不同对象可以定义不同的属性来描述对象的各自特征。
二、事件
事件是对象可以识别的操作，它是预先定义的特定操作。使用相同类生成的实例能识别的事件是一样的。每种对象的事件集是固定的，不能由用户创建。事件可分为系统事件和用户事件，系统事件由系统激发，用户事件由用户激发。
三、方法
方法是对象的事件被激发时执行的操作。不同对象在执行同种操作时的方法可以不同。用户可通过定义不同的方法来实现各种操作。
一、类的定义
在Python中，通过class关键字定义类，然后通过定义的类创建实例对象。在Python中定义类的语法：
class 类名：
代码块
1.class关键字后是类名，类名由用户自由指定，通常用首字母大写，见名知意，类名后跟冒号。类体由缩进的语句块组成。
2.类的成员分为两种类型，即描述属性的数据成员和描述行为的方法成员。在类中定义的类属性和类方法类似于包含在类中的变量和函数。
二、创建类的对象
类是一种抽象的概念，要使用类定义的功能，就必须进行类的实例化，即创建类的对象。比如定义一个抽象的Student类，必须创建一个该类的对象。创建类的对象的方式类似函数调用方式：
对象名 = 类名(参数列表)
创建了类的对象以后我们就可以通过对象来调用相关的属性和方法了。调用的格式：
对象名.对象的属性
对象名.对象的方法()
【示例】
class Student: # 定义类
age = 15 # 定义类属性(类变量)，有初始值
height = 180
def eat(self): # 定义类方法
self.height = self.height + 0.1
xiaoming = Student() # 创建一个类对象
# 创建对象属性(仅属于该对象)
xiaoming.weight = 80
xiaoming.eat() # 调用对象方法
三、类中的变量
成员变量用于存储描述类或对象属性的值，根据位置不同可分为：类变量和实例变量。成员变量可以被该类中定义的方法访问，也可以在外部通过对象进行访问，而在方法体中定义的局部变量，则只能在方法内进行访问。
1.类变量
类变量是在类中所有方法之外定义的变量，可以在所有实例之间共享，类变量可以通过“类名.类变量名”进行访问，也可以通过“对象名.类变量名”进行访问，但一般不建议这么做。直接访问一个不存在的类变量时，将会抛出属性异常：AttributeError。直接对一个不存在的类变量赋值，将会为该类添加一个类变量。
对类变量的赋值只能通过“类名.类变量名”来执行，对“对象名.类变量名”进行赋值相当于创建了一个同名的实例变量。当类变量名和实例变量名相同时，通过“对象名.变量名”访问时访问的是实例变量。如果确实想要访问类变量，只能通过“类名.类变量名”。
【示例】
class Student: # 定义类
age = 15 # 定义类属性(类变量)有初始值
height = 180
def eat(self): # 定义类方法
self.height = self.height + 0.1
xiaoming = Student()
xiaoming.weight = 80
xiaoming.eat() # 调用对象方法
print(Student.age) # 输出类变量
Student.age = 20 # 修改类变量的值
xiaoming.age = 16 # 创建同名的实例变量
print(Student.age, xiaoming.age) # 输出类变量和实例变量
运行结果：
15
20 16
2.实例变量
实例变量是在方法内部通过“self.变量名”定义的变量，注意和局部变量的区别，实例变量在类的内部通过“self.变量名”访问，在外部通过“对象名.变量名”来访问。
实例变量一般是在__init__() 方法中进行初始化，通过self.变量名=形参名的方式将创建对象时传入的实参值保存到实例变量中。也可以在其他方法中定义或创建对象后添加，但不建议。
直接访问一个不存在的实例变量时，将会抛出属性异常：AttributeError。直接对一个不存在的实例变量赋值，将会为该对象添加一个实例变量。
【示例】
class Student: # 定义学生类
age = 15 # 定义类属性，有初始值
height = 180
def __init__(self):
# 定义实例变量，有初始值
self.name = "xiaowei"
运行结果：
xiaowei
def eat(self)： # 定义例方法
self.height = self.height + 0.1
xiaoming = Student() # 创建一个类对象
print(xiaoming.name) # 输出对象的实例变量
四、类的方法
实例方法和函数定义类似，但第一个参数必须为实例对象，参数名通常为self，表示当前调用这个方法的对象。
1.类的实例方法由该类创建的对象来调用，在类的内部通过self.方法名(参数)来调用实例方法，在类的外部需通过：对象名.方法名(参数)调用实例方法。调用时无需传递self参数。
定义实例方法的格式有两种：
格式一(无参方法)：
def 方法名(self):
方法体
def 方法名(self,形参1,形参2,…):
方法体
格式二(有参方法)：
2.构造方法：
__init__()方法，也称为构造方法，创建对象时为对象初始化实例变量。__init__()方法在创建对象时自动被运行，无需手工调用，所有通过__init__()方法实例化后的对象都具有该属性。__init__()方法有两种语法格式：
格式一：
def __init__(self):
self.变量名1 = 值1
格式二：
def __init__(self,形参1,形参2,…):
self.属性名1 = 形参1
self.属性名2 = 形参2
__init__()方法中如果有形参，在创建对象时需要传递对应的实参。如果用户在类中未提供__init__()方法，系统将默认调用父类的初始化方法。Python中所有的类都直接或间接继承于object类，该类中提供了__init__()方法。
1.Tkinter是Python的自带GUI库。基于TCL/TK实现。对于简单的图形界面，使用Tkinter是完全可以胜任的。Tkinter的优点是内置Python中的，缺点是运行速度
较慢。
2.Tkinter提供了多种的标准控件(Widget)，比如按钮、输入框等，如表4-1所示。
表4-1　Tkinter常用控件
控件 描述
Label 标签控件：可以显示文本和位图。多用来显示提示信息
Entry 输入控件：用于输入或者显示文本内容
Button 按钮控件：按钮一般与一个回调函数绑定，完成指定的功能
Radiobutton 单选按钮控件：显示一个单选的按钮状态，实现多选一的功能
控件 描述
Checkbutton 多选按钮控件：有on-off两种状态，一般用于选中或者未选中
Listbox 列表框控件：可以显示一组字符串(选项)，用户可以选择一个或者多个选项
Message 消息控件：用来显示短消息，功能与Label类似
Messagebox 消息框控件：提供了8种对话框，可实现人机交互
Text 文本控件：用于显示多行文本
Spinbox 数值调整控件：与Entry类似，但是可以指定数值的输入范围
Scale 尺度条控件：显示一个数值刻度，用户拖动滑块选择数值。可以设定最大值与最小值
一、窗口的创建
窗口是Tkinter的容器对象，在窗口中我们可以放置其他的对象，如：标签、文本框等。我们在设计程序时通常只需要创建一个根窗口。在正确引入Tkinter库后，通常使用Tk()创建根窗口的。
【示例】
from tkinter import *
root=Tk() #创建根窗口
root.title("这是根窗口")
root.mainloop()
运行结果：
二、窗口的属性设置
1.在Tkinter中常用设置窗口属性的方法如表4-2：
表4-2　窗口常用属性方法
方法 说明
title() 设置窗口的标题
geometry() 设置窗口的大小和位置
config(bg=“color”) 设置窗口的背景颜色
【示例】
from tkinter import *
root=Tk()
root.title("这是根窗口") #设置窗口标题
#设置窗口大小和位置
root.geometry("300x300+100+100")
root.config(bg='red') #设置窗口背景色
root.mainloop()
2.窗口其他常规属性设置
(1)altributes()方法：设置窗口其他常规属性，如窗口透明度、是否全屏、是否置顶、是否为工具窗口等。
(2)-alpha参数：设置窗口是否透明，取值0~1，0代表完全透明，1代表不透明。通过-fullscreen参数设置是否全屏，取值为False或 True，True代表全屏。通过-topmost参数设置是否置顶，取值为False/True，True代表置顶。通过-toolwindow参数设置是否为工具窗口(无最大化最小化按钮)，取值为False/True，True代表为工具窗口。
(3)attributes()方法可以用 wm_attributes()方法代替，两者功能一致。
标签控件可以用来显示图片和文本，且不允许用户修改。使用Label()方法可以在窗口内建立标签。
标签的语法格式如下：
Label(父对象,options,……)
Label()方法的第一个参数是该对象的父对象，表示这个标签将建立在哪个父对象(窗口或容器)内。常用属性见表4-3。
表4-3　标签控件常用属性
属性名 功能 值的类型
text 指定标签显示的文本，可以多行文字 字符
textvariable 标签显示的内容与变量绑定(如果设置该参数text属性设置将无意义) 字符型变量
anchor 标签文字的对齐方式，共有9种对齐方式，默认的是中部居中对齐(center) 字符
属性名 功能 值的类型
bg 标签背景色 颜色名称或者十六进制色彩方案
fg 标签前景色 颜色名称或者十六进制色彩方案
height 标签高度 数值
width 标签宽度 数值
font 显示的文本字体、字号、加粗等 字符串或元组
padx 文本左右两侧的空格数(默认为1) 数值
pady 文本上下两侧的空格数(默认为1) 数值
【示例】
from tkinter import *
root=Tk()
root.title("这里有一个标签") #设置窗口标题
root.geometry("300x300") #设置窗口大小
root.config(bg='red') #设置窗口背景色
#以下创建一个标签
wenben1=Label(root,text="你好！\n我的祖国",bg='yellow',fg='red')
wenben1.pack()
root.mainloop()
运行结果：
功能按钮也可称作按钮，按钮控件(Button)是Tkinter最常用的图形控件之一，通过Button可以方便地与用户进行交互。
Button()方法语法格式如下：
Button(父对象,options,……)
按钮的常用属性如表4-4所示：
表4-4　按钮控件常用属性
属性名 功能 值的类型
text 按钮显示的文字，通常用于说明按钮的功能 字符
textvariable 按钮显示的内容与变量绑定(如果设置该参数text属性设置将无意义) 字符型变量
command 单击按钮时触发方法 方法名
anchor 按钮文字的对齐方式，共有9种对齐方式，默认的是中部居中对齐 字符
属性名 功能 值的类型
bg 背景色 颜色名称或者十六进制色彩方案
fg 前景色 颜色名称或者十六进制色彩方案
state 设置组件状态，默认为NORMAL，可设置为：DISABLED禁用使用 指定值
height 高度 数值
width 宽度 数值
font 显示的文本字体等 字符串或元组
padx 文本左右两侧的空格数(默认为1) 数值
pady 文本上下两侧的空格数(默认为1) 数值
【示例】
from tkinter import *
def dayin(): #自定义一个方法，打印标签的内容
print("当前标签的文字为：",biaoqian1['text'])
root=Tk()
root.title("功能按钮的应用") #设置窗口标题
root.geometry("300x300") #设置窗口大小
#以下创建一个标签
biaoqian1=Label(root，text="我是一个标签",bg='yellow',fg='red')
biaoqian1.pack()
#以下创建一个按钮
anniu1=Button(root,text="打印",command=dayin)
anniu1.pack(pady=10)
root.mainloop()
运行结果：
Entry(父对象,options,……)
单行文本控件(Entry)是用来接收用户输入的最基本的控件。我们可以使用它输入单行字符串，如果输入的字符串长度大于文本框的宽度，所输入的文字会自动隐藏造成部分内容无法显示。
Entry()方法语法格式如下：
一、文本框的常用属性
如表4-5所示。
表4-5　文本框的常用属性
属性名 功能 值的类型
bg 标签背景色 颜色名称或者十六进制色彩方案
fg 标签前景色 颜色名称或者十六进制色彩方案
height 高度 数值
width 宽度 数值
属性名 功能 值的类型
font 显示的文本字体等 字符串或元组
show 将Entry框中的文本替换为指定字符，用于输入密码等 字符
state 设置组件状态，默认为NORMAL，可设置为DISABLED禁用使用 指定值
textvariable 与字符变量绑定 变量
【示例】
from tkinter import *
root=Tk()
root.title("这里有一个文本框") #设置窗口标题
root.geometry("300x300") #设置窗口大小
x=StringVar() #定义字符型变量
x.set("你好！") #设置变量值为“你好！”
#以下创建一个文本框
wenbenk=Entry(root,bg='yellow',fg='red',textvariable=x)
wenbenk.pack(pady=10)
root.mainloop()
运行结果：
二、文本框的常用方法
1.get()方法
使用get()方法可以获取Entry对象的字符串内容。
【示例】
from tkinter import *
def hq():
biaoqian1.config(text="文本框的内容是："+wenbenk.get())
root=Tk()
root.title("这里有一个文本框") #设置窗口标题
root.geometry("300x300") #设置窗口大小
#以下创建一个标签
biaoqian1=Label(root,text="文本框的内容是：",bg='yellow',fg='red')
biaoqian1.pack()
#以下创建一个文本框
wenbenk=Entry(root,bg='yellow',fg='red')
wenbenk.pack(pady=10)
#以下创建一个按钮
anniu1=Button(root,text="获取",command=hq)
anniu1.pack(pady=10)
root.mainloop()
运行结果：
2.insert()方法
使用insert(index,s)方法可以在Entry对象的文本框内输入文字，其中index是字符串插入的位置，s是要插入的字符串。若要在文本框开头插入字符串s，可以使用：insert(0,s)，要在文本框末尾插入字符串s可以使用：insert(END,s)。
【示例】
from tkinter import *
def charu():
wenbenk2.insert(0,wenbenk1.get())
root=Tk()
root.title("这里有一个文本框") #设置窗口标题
root.geometry("300x300") #设置窗口大小
#以下创建一个文本框
wenbenk1=Entry(root,bg='yellow',fg='red')
wenbenk1.pack(pady=10)
#以下创建第二个文本框
wenbenk2=Entry(root,bg='yellow',fg='red')
wenbenk2.pack(pady=10)
#以下创建一个按钮
anniu1=Button(root,text="插入",command=charu)
anniu1.pack(pady=10)
root.mainloop()
#以下创建一个按钮
anniu1=Button(root，text="插入",command=charu)
anniu1.pack(pady=10)
root.mainloop()
运行结果：
3.delete()方法
使用delete(first，last=None)方法可以删除Entry对象的文本框内从first字符到last-1字符间的字符串，如果要删除整个字符串，可以使用delete(0，END)。
4.config()方法
使用config()方法可以设置Entry对象的属性值。
5.focus()方法
使用focus()方法可以设置Entry对象获得焦点。
在Tkinter中如果要将控件的参数以变量方式处理时要借助Tkinter模块内的变量类别(Variable Classes)。这个类别有4个子类别，每个类别对应一个数据类型的构造方法。我们在使用中可以根据其数据类型将它们控件的相关参数相结合。四种数据类型如下：
1.x=IntVar()：定义x为整型变量，默认值为0。
2.x=DoubleVar()：定义x为浮点型变量，默认值为0.0。
3.x=StringVar()：定义x为字符串变量，默认值为空字符串。
4.x=BooleanVar()：定义x为逻辑型变量，True是1，False是0。
【参考答案】A
【答题分析】利用父类定义子类，实现的是面向对象中的继承。
例1　(2022年真题)利用父类定义子类，实现的是面向对象中的( )
A.继承 B.多态
C.绑定 D.封装
【参考答案】B
【答题分析】多态实现的关键是让具有继承关系的不同类的对象(对同一消息做出不同响应)。
例2　在Python面向对象编程中，下列可以实现多态的方式是( )
A. 定义多个同名函数
B. 子类重写父类的方法
C. 定义多个不同名的方法
D. 一个类中有多个构造函数
【参考答案】C
【答题分析】在类的内部，通常使用self来访问类的属性和方法。self代表类的实例本身。
例3　下列选项中，用于在类的内部访问类的属性是( )
A. cls B. this
C. self D. super
【参考答案】class
【答题分析】在Python中，通过class关键字定义类，然后通过定义的类创建实例对象。
例4　(2023年真题)在Python语言编程中，使用 关键字来定义类。
【参考答案】A
【答题分析】__init__()方法在创建对象时自动调用，用于初始化对象的属性。__str__()主要用于定义对象的字符串表示形式，__del__()用于在对象被销毁时进行清理操作。__new__()是一个静态方法，用于创建类的实例。它在__init__()方法之前被调用，并且返回一个新的实例对象。
例5　在Python类中，用于初始化对象属性的方法是( )
A. __init__() B. __str__()
C. __del__() D. __new__()
【参考答案】B
例6　在Python中，关于类变量，下列说法正确的是( )
A.类变量是在类的实例方法中定义的变量，每个实例都有自己独立的副本
B.类变量在整个类中共享，所有实例都可以访问和修改它
C.类变量只能通过类名来访问，不能通过实例来访问
D.类变量在类的每个实例中都有独立的存储空间，其值不会互相影响
【答题分析】在实例方法中定义的变量是实例变量，不是类变量。类变量是在类定义中，方法之外定义的变量。类变量在整个类中共享，所有实例都可以访问和修改它。当一个实例修改了类变量的值，这个修改会反映到其他实例中，因为它们共享这个变量。类变量可以通过类名访问，也可以通过实例访问。类变量在类的所有实例中共享存储空间，不是独立的，修改一个实例中的类变量会影响其他实例。
【参考答案】C
例7　关于Tkinter主窗口和顶层窗口(Toplevel对象)关系的描述，错误的是( )
A.关闭主窗口，则自动关闭顶层窗口
B.创建顶层窗口，则自动创建主窗口
C.顶层窗口和主窗口是相互独立的
D.顶层窗口不能脱离主窗口而存在
【答题分析】在一个GUI应用程序中，主窗口通常是应用程序的核心窗口，它包含了主要的用户界面元素和功能。它是整个应用程序布局和交互的中心部分，其他的部件(如菜单、工具栏、各种容器和控件等)通常都放置在主窗口内。
顶层窗口(Toplevel Window)是独立于主窗口的窗口，它可以和主窗口同时存在。顶层窗口可以用于显示一些额外的信息、对话框或者作为一个辅助的交互界面，比如弹出一个文件选择对话框、消息提示框等。从应用程序整体的角度看，它们都是应用程序窗口体系的一部分，顶层窗口通常依赖于主窗口存在，并非完全独立。(共62张PPT)
第三部分　计算机编程基础
——Python语言
第三章　函数与模块、文件与数据
考点一~七
考
纲
要
求 一、函数与模块
1.掌握内置函数
2.掌握math模块
3.理解datetime模块
4.综合应用random模块
5.综合应用string模块
二、自定义函数
1.理解函数的定义与调用
2.综合应用函数的参数
3.综合应用变量的作用域 三、文件操作
1.理解文件的打开和关闭
2.掌握文件的读写
3.综合应用数据的格式化
四、数据库的使用
1.理解Python数据库应用接口
2.掌握Sqlite3模块
3.理解数据表的创建
4.掌握数据表的操作
命
题
趋
势 1.识记常用内置函数，理解math模块中的数学函数、datetime模块中的时间处理功能，并能综合应用random模块生成随机数与string模块处理字符串
2.要求学生理解自定义函数的定义与调用方法，能够综合运用各类函数参数(包括位置参数、默认参数、可变参数等)，并明确区分局部变量与全局变量的作用域
3.要求学生理解文件的打开与关闭机制，掌握文本文件的读写方法，并能够综合运用各类数据格式化技术(如字符串格式化、CSV、JSON等)进行结构化数据的存储与读取
4.要求学生理解Python数据库应用接口的基本规范，掌握Sqlite3模块的连接与操作方法，能够创建符合规范的数据表，并完成对数据表的增、删、改、查等基本操作
考
向
分
析 【考查内容】
自定义函数的运行；lambda函数、嵌套函数；程序调试；文件的打开、关闭与读写
【考查题型】
填空题、选择题、程序分析题
【考查分值】
20分左右
函数是指通过专门的代码组织，用来实现特定功能的代码段，它具有相对独立性，可供其他代码重复调用。
在Python应用过程中，我们常将应用范围较广、功能或任务单一的程序代码块，注入软件安装内，并给出一个名字，将其定义为函数，这就是Python内置函数。
而在实际的应用过程中，对有些针对性的功能或操作，需多处引用，为解决某一类问题编写的代码块，按规定的模式组织起来并命名，加以引用，减少代码的冗余，这就是自定义函数。
另外自定义函数的引入，让程序结构清晰、代码的可读性增强，程序的逻辑结构明了。
一、自定义函数基本语法
1.函数定义的一般语法形式：
def 函数名(参数列表):
函数体
2.定义函数的5个组成部分(图3-1)：
(1)关键字def：标志着函数头的开始，函数头的结尾必须用冒号(:)标记。
(2)函数名(function name)：唯一标识一个函数，函数命名遵循标识符的编写规则。
(3)参数(parameters)：通过它可以将值传递给函数。参数外面有中括号和逗号，中括号是可选参数，逗号是参数之间的分隔符。参数可以为0个或多个。
图3-1　定义函数的组成部分
(4)函数体：由一个或多个有效的Python语句构成。
(5)return语句：用于从函数返回一个值或多个值(多个值返回结果为元组)，也可以没有return语句，此时返回结果为None。
图3-1　定义函数的组成部分
二、示例
1.定义返回两个数平均值的函数。
def myaverage(a,b):
　　return (a+b)/2
2.定义返回多个数平均值的函数。
def average(a,*b):
s=a
for i in b:
s+=i
return s/(len(b)+1)
a=5
b=[2,5,7,9]
print(average(a,*b))
程序运行结果：
5.6
3.定义一个无返回值的函数。
def str1(ch):
print(ch.center(20,"*"))
ch="12321"
str1(ch)
程序运行结果：
*******12321********
使用函数的过程称为调用函数，调用函数的方法是直接使用函数名及传入用圆括号括起的参数。
从调用的角度来说，函数参数分为形式参数和实际参数(图3-2)。形式参数是一种意义上的参数，在定义的时候并不占用内存地址。
图3-2　形参与实参
形式参数(形参)：自定义函数结构中，包含的参数就是形参。在函数被调用时，它才会占用内存地址。
实际参数(实参)：调用函数时，使用的变量、值、表达式，就是实参。
实际参数值默认按位置顺序依次传递给形式参数。如果参数个数不对，将会产生错误。
函数调用是表达式。如果函数有返回值，可以在表达式中直接使用；如果函数没有返回值，则可以单独作为表达式语句使用。
1.无return返回值的自定义函数。
【示例】
def str2(n):
print(("*"*n).center(30,"."))
for i in range(1,10,2):
str2(i)
程序运行结果：
..............*...............
.............***..............
............*****.............
...........*******............
..........*********...........
2.有return返回值的函数。
【示例】输入圆的半径，求圆的面积。
def eara(r):
pi=3.1415926
return r*r*pi
r=float(input("请输入圆的半径:"))
print("圆的面积:{:2f}".format(eara(r)))
程序运行结果：
请输入圆的半径:3.2
圆的面积:32.169908
3.有return多个返回值。
【示例】调用自定义函数，计算三角形的面积和周长。
def ab(a,b,c):
p=(a+b+c)/2
s=(p*(p-a)*(p-b)*(p-c))**0.5
return 2*p,s
a,b,c=map(float，input("输入三条边的长:中间用空格间隔").split())
if a+b>c and a+c>b and b+c>a:
l,s=ab(a,b,c)
print("三角形的周长{:.2f}，面积{:.2f}".format(l,s))
else:
　　print("输入的三条边长度不能构成三角形")
程序运行结果：
输入三条边的长:中间用空格间隔3 4 6
三角形的周长13.00，面积5.33
一、位置参数
在调用函数时，传递的参数必须与函数定义的参数一一对应。
【示例】
def fact(m,n):
　　s=1
　　for i in range(1,n+1):
　　　　s*=i
　　return s//m
print(fact(5,10))　　
程序运行结果：
725760
二、关键字参数
在调用时，采用“参数名=值”的方式，可以无须考虑函数定义中参数的位置顺序。
【示例】
def fact(m,n):
s=1
for i in range(1,n+1):
　　　　s*=i
return s//m
print(fact(n=10,m=5))
程序运行结果：
725760
三、默认值参数
当函数被调用时，如果传入实参，则将该值传递给形参；如果没有传入实参，则使用函数定义时的默认值替代。
程序运行结果：
3628800
725760
def fact(n,m=1):
s=1
for i in range(1,n+1):
s*=i
return s//m
#只给n赋值，没有给m赋值。m使用默认值方式传递
print(fact(10))
print(fact(10,5)) #位置对应传递(位置参数)
【示例】
四、不定长参数
在定义函数时，允许传递给函数的参数数量是可变的。
Python自定义函数中有两种不定长参数，第一种是*args，在传入额外的参数时可以不用指明参数名，直接传入参数值即可，返回的是元组。第二种是**kwargs，这种类型返回的是字典，传入时需要指定参数名。
【示例1】
def pr(a,*b):
print(a)
print(b)
pr(1,3,5,7,9)
t1=(6,4,7,-1,5,9)
l1=[4,5,6,1,8]
pr(2,*t1)
pr(3,*l1)
程序运行结果：
1
(3,5,7,9)
2
(6,4,7,-1,5,9)
3
(4,5,6,1,8)
【示例2】
def pr_1(a,**b):
print(a)
print(b)
print(b.items())
a=list("python")
b={"x":1,"y":2,"z":3}
pr_1(a,**b)
程序运行结果：
('p','y','t','h','o','n')
{'x':1,'y':2,'z':3}
dict_items([('x',1),('y',2),('z',3)])
五、按参数值是否发生变化分类(表3-1)
表3-1　参数值变化应对
分类 传递参数数据类型 描述
不可变
参数 字符串
数字
元组 当该数据类型的值作为参数，传递到函数内时，相当于复制一个变量；在函数内使用时，该变量在函数内的变化，不影响该变量在函数外的值
可变
参数 列表
字典
集合 当该数据类型的值作为参数，传递到函数内时，函数内对该变量的操作将影响该变量本身的值，也就是两者指向的是同一个内存位置
一、概念
Python提供了一种精简好用的、一行自定义函数的方法lambda，可以实现一行语句用完即丢的自定义函数。语法形式：
二、lambda函数的四种用法
1.将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。
例如，定义了加法函数lambda x, y: x+y，并将其赋值给变量add，这样变量add便成为具有加法功能的函数。
例如，执行add(2,3)，输出为5。
2.将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。
例如，为了把标准库time中的函数sleep的功能屏蔽，我们可以在程序初始化时调用：
这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。
当执行time.sleep(3)时，程序不会休眠3秒钟，而是什么都不做。
time.sleep=lambda x:None
3.将lambda函数作为其他函数的返回值，返回给调用者。函数的返回值也可以是函数。
例如，语句return lambda x, y: x+y，返回一个加法函数。
这时，lambda函数实际上是定义在某个函数内部的函数，称之为嵌套函数，或内部函数。
4.将lambda函数作为参数传递给其他函数。部分Python内置函数接收函数作为
参数。
(1)配合filter函数，过滤列表元素。
例如：
filter(lambda x:x%3==0,[1,2,3,4,5,6])
指定将列表[1,2,3,4,5,6]中能够被3整除的元素过滤出来，其结果是[3,6]。
(2)配合map函数，转换列表元素。
将列表[1, 2, 3]中的元素分别加1，其结果是[2, 3, 4]。
(3)配合sorted函数，自定义排序规则。
将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序，其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。
map(lambda x: x+1,[1,2,3])
sorted([1, 2, 3, 4, 5, 6, 7, 8, 9],
key=lambda x: abs(5-x))
如果一个函数在内部调用自己本身，这个函数就是递归函数。通过分解问题为更小的同类子问题来解决复杂任务。递归函数特性如下：
1.自己调用自己；
2.必须有一个明确的结束条件；
3.每次进入更深一层递归时，问题规模相比上次递归都应有所减少；
4.相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一步的输出就作为后一步的输入)。
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
调用流程:
递归效率不高，递归层次过多会导致栈溢出。
【示例2】利用递归调用，逆序输出字符串。
def nxs():
if =="":
return
else:
return nxs([1:])+[0]
print(nxs("hello python"))　　
程序运行结果：
nohtyp olleh
变量的作用域是程序运行时可被访问的范围。变量一般可以分为局部变量和全局变量两类。
一、全局变量
在函数体外定义的变量称为全局变量。全局变量所有域都可读。
二、局部变量
在函数内部定义的变量称为局部变量。局部变量只能在本函数内可读。
函数在读取变量时，优先读取函数本身自有的局部变量，再去读全局变量。
三、global关键字
全局变量一般只能在函数内进行读取，不能修改。全局变量默认可读，如需要修改，必须使用global关键字进行声明。
四、示例
1.全局/局部变量读取示例。
name='李明' 　　#全局变量
def d1():
age=18　　#局部变量
print(age,name)
def d2():
age=19　　#局部变量
print(age,name)
d1()
d2()
程序运行结果：
18　李明
19　李明
2.global关键字修改全局变量示例。
name='李明'　　　#全局变量
def f1():
age=18 #局部变量
global name 　#定义全局变量
name='张明明'
print(age,name)
f1()
print(name)
程序运行结果：
18 张明明
张明明
特殊情况：列表、字典无需global即可修改内容，但不能重新赋值，如果需要重新赋值，需要在函数内部使用global定义全局变量。
【参考答案】代码段
【答题分析】函数实际上就是能完成某一功能或某一操作的独立体，是编写的代码段供大家直接调用，而无需再编写的小程序块。
例1　函数是指通过专门的代码组织，用来实现特定功能的　　　　，它具有相对独立性，可供其他代码重复调用。
【参考答案】C
例2　(2023年真题)Python使用　　　　关键字定义函数。(　　)
A.while B.if
C.def D.for
【答题分析】关键字def：标志着函数头的开始，函数名(function name)：唯一标识一个函数，函数命名遵循标识符的编写规则。参数(parameters)：通过它可以将值传递给函数，是可选的。冒号(:)：用于标记函数头的结尾。文档字符串(docstring)：用于描述函数的功能，是可选的。函数体:由一个或多个有效的Python语句构成，语句必须具有相同的缩进级别(通常为4个空格)。return语句：用于从函数返回一个值或多个值，也可以没有return语句，可选的。自定义函数的5部分：关键字def、函数名、[参数]、函数体、[return返回值]。
【参考答案】位置参数　不定长参数
【答题分析】需明确参数调用的几种形式，掌握参数的分类方式。
例3　函数中的参数可以按不同的方式进行分类。按调用方式分，有　　　　、关键字参数、默认值参数和　　　　。按参数值是否发生变化分类，有可变参数、不可变参数。
按调用方式进行分类
分类 描述
位置参数 在调用函数时，传递的参数必须与函数定义的参数一一对应
关键字参数 在调用时，采用"参数名=值"的方式，可以无须考虑函数定义中参数的位置顺序
默认参数 在函数定义的时候，为参数设置默认值，当在调用函数的时候，没有给该参数传值时，该参数自动选择默认值
分类 描述
不定长参数 在调用函数的时候，参数个数不固定，因此在定义函数时，可引入不定长参数
传递任意数量参数值的参数格式:函数名([参数，参数，]*参数)
传递任意数量键值对的参数格式:函数名([参数，参数，]**参数)
【参考答案】C
【答题分析】在Python中，函数定义func1(*n)表示函数可以接受任意数量的位置参数，这些参数会被收集为一个元组n。因此调用该函数时，可以传递任意个数。
例4　(2023年真题)有函数定义格式为func1(*n)，对该函数进行调用时可以传递　　　　个参数。(　　)
A.0 B.1
C.任意个数 D.固定个数
【参考答案】B
【答题分析】匿名函数的功能也就是函数：g(x,y,z=3)计算(x*y)%z。下面计算每个选项：g(2,3,4):2*3=6，6%4=2。g(5,6)：这里z取默认值3，5*6=30，30%3=0。g(2,4)：z取默认值3，2*4=8，8%3=2。g(2,7,3)：z=3，2*7=14，14%3=2。因此返回值不是2的是B。
例5　(2024年真题)g=lambda x,y,z=3:x*y%z，下列返回值不是2的是(　　)
A.g(2,3,4) B.g(5,6)
C.g(2,4) D.g(2,7,3)
【参考答案】B
例6　(2022年真题)下列Python程序的运行结果是(　　)
A.5 B.3
C.2 D.0
def f(x,y=0):
　　 return x-y
y=f(6,3)
print(y)
【答题分析】世界上第一个计算机网络阿帕网(ARPANET)诞生于1969年的美国，采用的是分组交换技术，该技术具有线路利用率高，传输速率高和不易阻塞等特点。
【参考答案】global
【答题分析】在 Python 中，若要在一个函数内部要修改全局变量(或设置全局变量)，需要使用 global 关键字。
例7　(2022年真题)使用关键字　　　　可以在一个函数中设置一个全局变量。(共112张PPT)
第三部分　计算机编程基础
——Python语言
第三章　函数与模块、文件与数据
考点九~十四
考
纲
要
求 一、函数与模块
1.掌握内置函数
2.掌握math模块
3.理解datetime模块
4.综合应用random模块
5.综合应用string模块
二、自定义函数
1.理解函数的定义与调用
2.综合应用函数的参数
3.综合应用变量的作用域 三、文件操作
1.理解文件的打开和关闭
2.掌握文件的读写
3.综合应用数据的格式化
四、数据库的使用
1.理解Python数据库应用接口
2.掌握Sqlite3模块
3.理解数据表的创建
4.掌握数据表的操作
命
题
趋
势 1.识记常用内置函数，理解math模块中的数学函数、datetime模块中的时间处理功能，并能综合应用random模块生成随机数与string模块处理字符串
2.要求学生理解自定义函数的定义与调用方法，能够综合运用各类函数参数(包括位置参数、默认参数、可变参数等)，并明确区分局部变量与全局变量的作用域
3.要求学生理解文件的打开与关闭机制，掌握文本文件的读写方法，并能够综合运用各类数据格式化技术(如字符串格式化、CSV、JSON等)进行结构化数据的存储与读取
4.要求学生理解Python数据库应用接口的基本规范，掌握Sqlite3模块的连接与操作方法，能够创建符合规范的数据表，并完成对数据表的增、删、改、查等基本操作
考
向
分
析 【考查内容】
自定义函数的运行；lambda函数、嵌套函数；程序调试；文件的打开、关闭与读写
【考查题型】
填空题、选择题、程序分析题
【考查分值】
20分左右
一、模块的概念
将函数存储在独立的文件中，可与其他程序共享这些文件而不是整个程序，这个独立文件被称为模块。把相关的函数存储到一个模块里，可以让函数更好用，更易懂，能够更有逻辑地组织Python代码。
模块可隐藏程序代码细节，程序员在编写程序时，引入某个模块，即可调用该模块中的函数，无须关注函数实现过程，进而提升编程效率。模块分为标准库模块和自定义模块。
二、模块引用方式
1. import 模块名 [as 别名]
使用这种方式导入之后，使用时需要在对象之前加上“模块名”作为前缀，必须以“模块名.对象名”的形式进行访问。如果模块名字很长的话，可以为导入的模块设置一个别名，然后使用“别名.对象名”的形式来使用其中的对象。
如“import tensorflow as tf”这个就是典型的为模块设置别名的用法。
【示例1】导入标准库math。
>>> import math
>>> math.sin(0.5) #求0.5(单位是弧度)的正弦
0.479425538604203
【示例2】导入标准库os.path，并设置别名为path。
>>> import os.path as path
>>> path.isfile(r'C:\windows\notepad.exe')
True
【示例3】导入标准库numpy，并设置别名为np。
>>> import numpy as np
>>> a=np.array([1,2,3,4])
# 通过模块的别名来访问其中的对象
>>> a
array([1,2,3,4])
>>> print(a)
[1 2 3 4]
2.from模块名import对象名[as别名]
使用这种方式仅导入明确指定的对象，并且可以为导入的对象确定一个别名。这种导入方式可以减少查询次数，提高访问的速度，同时也可以减少程序员需要输入的代码量，不需要使用模块名作为前缀。
【示例1】只导入模块中的指定对象。
>>> from math import sin
>>> sin(3)
0.1411200080598672
【示例2】给导入的对象起个别名。
>>> from math import sin as f
>>> f(3)
0.1411200080598672
【示例3】检查文件是否存在，若存在则输出True。
>>> from os.path import isfile
>>> isfile(r'C:\windows\notepad.exe')
True
3.from 模块名 import *
这是上面用法的一种极端情况，可以一次导入模块中通过__all__变量指定的所有对象。
【示例】导入标准库math中所有对象
>>> from math import *
>>> gcd(36, 18) #最大公约数
18
>>> pi #常数π
3.141592653589793
>>> e #常数e
2.718281828459045
>>> log2(8) #计算以2为底的对数值
3.0
>>> log10(100) #计算以10为底的对数值
2.0
>>> radians(180) #把角度转换成弧度
3.141592653589793
这种方式可以直接使用模块中的所有对象而不需要再使用模块名作为前缀。但一般并不推荐这样使用。一方面这样会降低代码的可读性，有时候很难区分自定义函数和从模块中导入的函数；另一方面，这种导入对象的方式将会导致命名空间的混乱。如果多个模块中有同名的对象，那么只有最后一个导入的模块中的对象是有效的，而之前导入的模块中的同名对象都将无法访问，不利于代码的理解和维护。
一、turtle模块
turtle模块是Python语言中一个绘制图像的函数库，就像一个乌龟，在一个横轴为x纵轴为y的坐标系原点(0，0)位置开始，根据一组函数指令的控制，在这个平面坐标系中移动，从而在它爬行的路径上绘制图形。
其中的函数：
turtle.dot()：绘制一个指定直径和颜色的圆点；
turtle.fillcolor()：绘制图形的填充颜色；
turtle.bgcolor()：设置窗口背景颜色；
turtle.pencolor()：设置画笔的颜色；
turtle.setheading()：画笔转动绝对角度，值为正(负)，表示逆(顺)时针转动；
turtle.pensize()：设置画笔的粗细；
turtle.speed()：设置绘制的速度。0，无动画，直接绘成；1-10，1最慢，10最快；
turtle.begin_fill()：准备开始填充图形；
turtle.circle(50，steps=3)：circle函数在之前用到过，是画一个半径为radius的圆，这里是扩展，steps表示在半径为50的圆内的正steps多边形；
turtle.end_fill()：填充完成；
turtle.write(s，font=("fontname"，font_size，"font_type"))：写文本，s为文本内容，font是字体的参数，里面分别为字体名称，大小和类型；
turtle.hideturtle()：隐藏画笔(箭头)显示；
另外，还有其他一些turtle函数，如：
turtle.backward(d)：与forward()函数对应，这里是从当前方向相反方向移动d长度；
turtle.left(angle)：逆时针转动相对角度；
turtle.undo()：撤销上一个turtle动作；
turtle.screensize(w，h)：设置画布尺寸；
turtle.clear()：清空turtle窗口，但是turtle的位置和状态不会改变；
turtle.reset()：清空窗口，重置turtle状态为起始状态；
turtle.showturtle()：与hideturtle()函数对应；
turtle.filling()：返回当前是否在填充状态；
turtle.isvisible()：返回当前turtle是否可见。
【示例】画一个边长为60的三角形。
import turtle
a=60
turtle.forward(a)
turtle.left(120)
turtle.forward(a)
turtle.left(120)
turtle.forward(a)
turtle.left(120)
turtle.done()
二、os模块
1.os模块概述
Python os模块包含普遍的操作系统功能，对目录和文件操作提供了非常多的方法。
2.常用方法
(1)os.name
输出字符串指示正在使用的平台。如果是Windows则用'nt'表示，对于Linux/Unix用户，它是'posix'。
(2)os.getcwd()
函数得到当前工作目录，即当前Python脚本工作的目录路径。
3.其他os模块的常用方法(表见3-4)
表3-4　os模块的常用方法
方法 功能说明
os.rename(src，dst) 重命名(从src到dst)文件或目录，可以实现文件的移动，若目标文件已存在则抛出异常
os.remove(path) 删除路径为path的文件，如果path是一个文件夹，则抛出异常
os.mkdir(path[，mode]) 创建目录，要求上级目录必须存在，参数mode为创建目录的权限，默认创建的目录权限为可读可写可执行
方法 功能说明
os.chdir(path) 将path设为当前工作目录
os.listdir(path) 返回path目录下的文件和目录列表
os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出异常
os.removedirs(path) 删除多级目录，目录中不能有文件
4.os.path模块常用方法(见表3-5)
表3-5　os.path模块常用方法
方法 功能
os.path.abspath(path) 返回给定路径的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.splitext(path) 分离文件名与扩展名；默认返回(fname，fextension)元组，可做分片操作
方法 功能
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.getsize(path) 返回path文件的大小(字节)
os.path.getatime(filename) 得到指定文件最后一次的访问时间
os.path.getctime(filename) 得到指定文件创建时间
os.path.getmtime(filename) 得到指定文件最后一次的修改时间
5.拓展工具：shutil模块
其常用方法如表3-6所示。
表3-6　shutil模块的常用方法
方法 功能说明
shutil.copy(src，dst) 复制文件内容以及权限
shutil.copy2(src，dst) 复制文件内容以及文件的所有状态信息
方法 功能说明
shutil.copyfile(src，dst) 复制文件，不复制文件属性，如果目标文件已存在则直接覆盖
shutil.copytree(src，dst) 递归复制目录内容及文件状态信息
shutil.rmtree(path) 递归删除文件夹
shutil.move(src，dst) 移动文件或递归移动文件夹，也可给文件和文件夹重命名
一、random库概述
Python的random模块包含许多随机数生成器，是Python标准库之一，直接导入即可使用。
二、常见函数及功能
1.random.seed(a=None)：初始化伪随机数生成器。如果未提供a或者a=None，则使用系统时间为种子。如果a是一个整数，则作为种子。
(1)当a=None(无参数)时，可以看到两次生成的结果不一样。
import random
random.seed() #生成当前系统时间的种子
print(random.random())
random.seed()
#生成当前系统时间的种子，和上述结果不同
print(random.random())
运行结果：
0.21862313562837132
0.3484708514061614
(2)当seed(a)有参数时，
①当参数相同(即随机数种子相同)，生成的随机数也一样；
②当参数不同，生成的随机数不一样。
import random
random.seed(10)
print(random.random())
random.seed(10)
print(random.random())
random.seed(9)
print(random.random())
运行结果：
0.5714025946899135
0.5714025946899135
0.46300735781502145
如果编程中使用了种子，当程序下一次运行，产生的随机数是相同的。对于使用随机数的程序，可以复现或者再现你程序运行的过程。否则每一次执行结果都是不同的。如果不给种子，默认的种子是当前调用第一次random函数所对应的系统时间。
2.random.randrange(stop)：返回range(0,stop)之间的一个整数。
3.random.randrange(start, stop[, step])：返回range[start,stop)之间的一个整数，可加step，跟range(0,10,2)类似。
import random
print(random.randrange(10,100,8))
返回结果：
50
4.random.randint(a,b)：返回range[a,b]之间的一个整数，等价于range(a,b+1)。
import random
print(random.randint(1,10))
返回结果：
5
5.random.choice(seq)：从非空序列seq中随机选取一个元素。若seq为空则会弹出异常。
import random
print(random.choice("abcdefg"))
返回结果：
d
6.random.choices(population,weights=None,*,cum_weights=None,k=1)：3.6版本新增。从population集群中随机抽取k个元素(可重复)。weights是相对权重列表，cum_weights是累计权重，两个参数不能同时存在。
7.random.shuffle(x[, random])：随机打乱序列x内元素的排列顺序。只能针对可变的序列，对于不可变序列，请使用sample()方法。
import random
guo=[1,2,3,4,5]
random.shuffle(guo)
print(guo)
返回结果：
[1, 5, 3, 2, 4]
8.random.sample(population, k)：从population样本或集合中随机抽取k个不重复的元素形成新的序列。常用于不重复的随机抽样。返回的是一个新的序列，不会破坏原有序列。要从一个整数区间随机抽取一定数量的整数，请使用sample(range
(10000000)，k=60)类似的方法。若k大于population的长度，则弹出异常。
import random
print(random.sample([1,3,2,4],2))
返回结果：
[4, 2]
9.random.random()：返回一个介于左闭右开[0.0， 1.0)区间的浮点数。
import random
print(random.random())
返回结果：
0.7764590171730322
10.random.uniform(a,b)：返回一个介于a和b之间的浮点数。如果a>b，则是b到a之间的浮点数。a和b都有可能出现在结果中。
import random
print(random.uniform(0.1,0.5))
返回结果：
0.433088294634417
11.getrandbits(k)：生成一个k比特长度的随机整数。
import random
print(random.getrandbits(3))
返回结果：
7
【示例】从字符串、列表、元组中随机返回一个值。
运行结果：
>>> str='python'
>>> import random
>>> print(random.choice(str))
h
>>> list1=[i for i in range(1,6)]
>>> print("list1:",list1)
list1:[1,2,3,4,5]
>>> print(random.choice(list1))
4
>>> tuple1=(10,20,30,40,50)
>>> print(random.choice(tuple1))
30
一、大小写转换
大小写转换主要分三种类型：
1.大小写全部转换：upper()与lower()。
将指定字符串变更大小写后新生成字符串存储。
这里是生成新的字符串来存放，所以不能作为原地操作来使用。
(1)upper()：负责将指定字符串变为大写，可以单独使用，也可以放到print函数中。
(2)lower()：负责将指定字符串变为小写，可以单独使用，也可以放到print函数中。
s="abcde"
print(s.upper()) ###ABCDE
print(s.lower()) ###abcde
print("abcdef".upper()) ###ABCDEF
print("QWERT".lower()) ###qwert
#生成新的字符串而不是更改原来字符串
s.upper()
print(s) ###abcde
2.字符串首部变更大小写：capitalize()与title()。
(1)title()：将给定的字符串中所有单词的首字母大写，其他全部小写。
(2)capitalize()：将给定的字符串中首字母大写，其他小写。
import string
s="abcde,qweRTY"
t="abcde qweRTY"
#以＂,＂隔开的单词
print(s.title()) ###Abcde,Qwerty
print(s.capitalize()) ###Abcde,qwerty
#以空格隔开的单词
print(t.title()) ###Abcde Qwerty
print(t.capitalize()) ###Abcde qwerty
3.大小写反转：swapcase()。
swapcase()的功能是将原字符串中的大写改为小写，小写改为大写。
print("qweASDrtZX".swapcase())
运行结果：
QWEasdRTzx
二、is判断函数
is判断函数是根据规定字符串判断是否符合条件，结果返回True或者False。
主要判断如下：
isdecimal()：判断给定字符串是否全为十进制数字；
isalpha()：判断给定字符串是否全为字母；
isalnum()：判断给定的字符串是否只含有数字与字母；
isupper()：判断给定的字符串是否全为大写字母；
islower()：判断给定的字符串是否全为小写字母；
istitle()：判断给定的字符串是否符合title()格式；
isspace()：判断给定的字符串是否全为空白符(空格、换行、制表符)；
isprintable()：判断给定的字符串是否全为可打印字符(空格可以打印，换行、制表符都不可以)；
isidentifier()：判断给定的字符串是否符合Python命名规则。
【示例】
#1234全是数字，为True
print("1234".isdecimal()) ###True
#asdf4中4是数字不是字母，为False
print("asdf4".isalpha()) ###False
#qwe12@中@既不是数字也不是字母，为False
print("qwe12@".isalnum()) ###False
#asdf全是小写，为True
print("asdf".islower()) ###True
#ADS全是大写，为True
print("ADS".isupper()) ###True
#Wshd，qwe中虽然W大写，但是第二个单词qwe中
#q小写，不符合title()，所以为False
print("Wshd，qwe".istitle()) ###False
#\n为换行,是空白符，为True
print("\n".isspace()) ###True
#\t为制表符，不可打印，为False
print("\t".isprintable()) ###False
#qe123符合命名规则，为True
print("qe123".isidentifier()) ###True
三、字符串填充
1.扩充的长度(width)：当字符串长度小于width时才会扩充，否则返回字符串本身。
2.扩充的位置，分三类：源字符串居左、居右和居中。
(1)居中为center(width)，这时候源字符串将会在中间，扩充物出现在两边；
(2)居左为ljust(width)，l为left的缩写，源字符串在左边，填充物出现在字符串右边；
(3)居右为rjust(width)，r为right的缩写，源字符串在右边，填充物出现在字符串左边。
填充物fillchar是可选的，其默认为空格，可以更改为任意单个字符。
运行结果：
qwer++++++
zfill(width)函数只需要传入参数width即可，填充物为“0”，采用居右填充的方式。另外，该函数会识别字符串开头的正负号，若为“+”或“-”则不变，越过正负号继续填充。
print("qwer".ljust(10,"+"))
【示例】
import string
#不加"+""-"纯数字，用"0"将字符串前填充满
print("12345".zfill(10)) ###0000012345
#加"-"纯数字，越过"-"用"0"将字符串前填充满
print("-125".zfill(10)) ###-000000125
#加"+"数字字母，越过"+"用"0"将字符串前填充满
print("+qwe125".zfill(10)) ###+000qwe125
#加其他符号，用"0"将字符串前填充满
print("#qwe12".zfill(10)) ###0000#qwe12
四、子字符串搜索
1.count(sub[，start[，end]])：子字符串位置搜索。
主要对指定字符串搜索是否包含给定的子字符串sub，若具有则返回出现次数。
start与end代表搜索边界，若无写则代表整个字符串搜索。
【示例】
#整个字符串内搜索qwe出现的次数
print("qwertasdqwezxcqwe".count("qwe"))###3
#由于字符串从0开始计数，1为字符串第二个，
#相当于从w开始
print("qwertasdqwezxcqwe".count("qwe",1))###2
#从字符串第2个开始到第15个截止，
#共出现qwe的次数
print("qwertasdqwezxcqwe".count("qwe",1,14))
###1
2.字符串开始与结尾判断：
startswith(prefix[,start[,end]])：开始；
endswith(suffix[,start[,end]])：结尾。
(1)两个函数作用相同，判断字符串的开头结尾是否为指定字符串；
(2)与之前的搜索相同，可以给字符串指定索引边界，若无则为整字符串搜索；
(3)两个函数都属于判断函数，返回结果为True与False。
这里不仅可以输入子字符串，还可输入元组，若为元组时只要有一个元素匹配成功即为True。
#搜索开头位置为qwe符合条件，为True
print("qwertasdqwezxcqwe".startswith("qwe")) ### True
#从字符串第二个开头，wer与qwe不同为False
print("qwertasdqwezxcqwe".startswith("qwe",1)) ### False
#结尾位置为qwe符合条件为True
print("qwertasdqwezxcqwe".endswith("qwe"))### True
3.字符串位置锁定find与index函数：
(1)find(sub[,start[,end]])：返回第一个子字符串的位置信息，若无则为-1；
(2)rfind(sub[, start[, end]])：返回最后一次出现子字符串的位置信息，若无则为-1；
(3)index(sub[, start[, end]])：返回第一个子字符串的位置信息，若无则抛出异常；
(4)rindex(sub[, start[, end]])：返回最右边的第一次出现子字符串的位置信息，若无则抛出异常。
【示例】
s="qweraqwesfgzqweop"
print(s.find("qwe")) ### 0
print(s.rfind("qwe")) ### 12
print(s.index("qwe")) ### 0
print(s.rindex("qwe")) ### 12
五、字符串替换
1.replace(old, new[, count])：将搜索到的旧字符串改为新字符串。作为替换函数，旧字符串与新字符串是必须传入的参数。
count：可选择输入的参数，代表替换个数。
s="qweraqwesfgzqweop"
#将字符串全部的qwe换为asd
print(s.replace("qwe","asd"))
###asdraasdsfgzasdop
#将字符串前两个qwe换为asd
print(s.replace("qwe","asd",2))
###asdraasdsfgzqweop
#将全部qew换为asd，没有则输出原字符串
print(s.replace("qew","asd"))
###qweraqwesfgzqweop
【示例】
2.expandtabs(N)：将制表符\t改为指定数量的空格。
空格计算方式：N-(之前字符串长度)=空格数。
若N-(之前字符串长度)=0，则空格数为N；
若N-(之前字符串长度)<0，则空格数为1。
【示例】
t="qwe\tqwer\tqasdsdf\tas"
print(t.expandtabs(4))
### qwe qwer qasdsdf as
第一个\t：设定长度为4，之前字符串qwe长度为3，4-3=1，替换1个空格；
第二个\t：设定长度为4，之前字符串qwer长度为4，4-4=0，替换4个空格；
第三个\t：设定长度为4，之前字符串qsdfsdf长度为7，4-7=-3<0，替换1个空格。
六、字符串分割
1.partition()和rpartition()：字符串分割常用函数。
partition(sep)对给定字符串进行切割，切割成三部分：首先搜索到字符串sep，将sep之前的部分为一部分，sep本身作为一部分，剩下作为一部分。
rpartition()与partition()之间十分相似，主要不同体现在当字符串中没有指定sep时：
(1)partition()分为三部分：原字符串、空白、空白；
(2)rpartition()分为三部分：空白、空白、原字符串。
【示例】
t="qwertyuasdfghjkl"
print(t.partition("yua"))
###('qwert','yua','sdfghjkl')
print(t.partition("asqw"))
###('qwertyuasdfghjkl','','')
print(t.rpartition("asqw"))
###('','','qwertyuasdfghjkl')
2.另一类常见的函数为split(sep=None, maxsplit=-1)和rsplit(sep=None,maxsplit
=-1)。
split()函数传参有两种：sep为切割，默认为空格；maxsplit为切割次数，给值
-1或者none，将会从左到右每一个sep切割一次。
rsplit()与之相同，但其切割顺序为从右到左。
七、字符串拼接
join()：将可迭代数据用字符串连接起来。可迭代数据简单理解就是字符串(string)、列表(list)、元组(tuple)、字典(dict)、集合(set)。而且每个参与迭代的元素必须是字符串类型，不能包含数字或其他类型。
【示例】
#字符串类型
a="qwer"
print("_".join(a)) ###q_w_e_r
#元组类型
b=("a","b","c","d")
print("=".join(b)) ###a=b=c=d
#集合类型
c={"qwe","asd","zxc"}
print(" ".join(c)) ###qwe zxc asd
八、字符串修剪
1.strip()是为移除指定字符集char，如果未传入参数，则移除空格、制表符、换行符。
2.lstrip()中 l为left缩写，函数表示从左到右遍历，移除字符串左侧指定字符集；
3.rstrip()中 r为right缩写，函数表示从右边开始遍历，移除右侧指定字符集。
【示例】
import string
a="qweasdzxcrtqwe"
print(a.strip()) ###qweasdzxcrtqwe
b="qweasdzxcrtqwe"
print(b.lstrip('q')) ###weasdzxcrtqwe
c="qweasdzxcrtqwe"
print(c.rstrip('qew')) ###qweasdzxcrt
一、math 模块常量(表3-7)
表3-7 math模块常量
常量 描述
math.e 返回欧拉数 (2.7182...)
math.inf 返回正无穷大浮点数
math.nan 返回一个浮点值 NaN (not a number)
math.pi π，圆周率。PI (3.1415...)
math.tau 数学常数 τ = 6.283185...，精确到可用精度。τ等于2π，为圆的周长与半径之比
二、math 模块方法(表3-8)
表3-8 math模块方法
方法 描述
math.acos(x) 返回x的反余弦，结果范围在0到π之间
math.acosh(x) 返回x的反双曲余弦值
math.asin(x) 返回x的反正弦值，结果在-π/2到π/2之间
math.asinh(x) 返回x的反双曲正弦值
math.atan(x) 返回x的反正切值，结果在-π/2到π/2之间
方法 描述
math.atan2(y， x) 返回给定的x及y坐标值的反正切值，结果在-π和π之间
math.atanh(x) 返回x的反双曲正切值
math.ceil(x) 将x向上舍入到最接近的整数
b(n， k) 返回不重复且无顺序地从n项中选择k项的方式总数
math.copysign(x， y) 返回一个基于x的绝对值和y的符号的浮点数
math.cos(x) 返回x弧度的余弦值
math.cosh(x) 返回x的双曲余弦值
方法 描述
math.degrees(x) 将角度x从弧度转换为度数
math.dist(p， q) 返回p与q两点之间的欧几里得距离，以一个坐标序列(或可迭代对象)的形式给出。两个点必须具有相同的维度
math.erf(x) 返回一个数的误差函数值
math.erfc(x) 返回x处的互补误差函数值
math.exp(x) 返回e的x次幂，其中e=2.718281...是自然对数的基数
math.expm1(x) 返回e的x次幂减1，比math.e**x或pow(math.e，x)减去1更精确
方法 描述
math.fabs(x) 返回x的绝对值
math.factorial(x) 返回x的阶乘。如果x不是整数或为负数时，则引发ValueError异常
math.floor(x) 将数字向下舍入到最接近的整数
math.fmod(x， y) 返回x/y的余数
math.frexp(x) 以(m，e)对的形式返回x的尾数和指数。m是一个浮点数， e 是一个整数，正好是 x ==m*2**e。如果x为零，则返回 (0.0， 0) ，否则返回 0.5 <= abs(m) < 1
方法 描述
math.fsum(iterable) 返回可迭代对象 (元组， 数组， 列表等)中的元素总和，是浮点值
math.gamma(x) 返回 x 处的伽马函数值
math.gcd(x，y) 返回给定的整数参数的最大公约数
math.hypot() 返回欧几里得范数，sqrt(sum(x**2 for x in coordinates))是从原点到坐标给定点的向量长度
math.isclose(a，b) 检查两个值是否彼此接近，若 a 和 b 的值比较接近则返回 True，否则返回 False
方法 描述
math.isfinite(x) 判断 x 是否有限，如果 x 既不是无穷大也不是 NaN，则返回 True ，否则返回 False
math.isinf(x) 判断 x 是否是无穷大，如果 x 是正或负无穷大，则返回 True，否则返回 False
math.isnan() 判断数字是否为 NaN，如果 x 是 NaN(不是数字)，则返回True，否则返回 False
math.isqrt() 将平方根数向下舍入到最接近的整数
math.ldexp(x， i) 返回x*(2**i)。这基本上是 math.frexp( )函数的反函数
方法 描述
math.lgamma(x) 返回伽玛函数在x绝对值的自然对数
math.log(x[, base]) 使用一个参数时，返回x的自然对数(底为e)
math.log10(x) 返回x以10为底的对数
math.log1p(x) 返回1+x的自然对数(以e为底)
math.log2(x) 返回x以2为底的对数
math.perm(n，k=None) 返回不重复且有顺序地从n项中选择k项的方式总数
math.pow(x， y) 将返回x的y次幂
方法 描述
math.prod(iterable) 计算可迭代对象中所有元素的乘积
math.radians(x) 将角度x从度数转换为弧度
math.remainder(x， y) 返回IEEE 754标准的x除于y的余数
math.sin(x) 返回x弧度的正弦值
math.sinh(x) 返回x的双曲正弦值
math.sqrt(x) 返回非负数x的平方根
math.tan(x) 返回x弧度的正切值
math.tanh(x) 返回x的双曲正切值
math.trunc(x) 返回x截断整数的部分，即返回整数部分，删除小数部分
datetime模块提供了五个常用类：date、time、datetime、timedelta、tzinfo。
一、date类
date类包含三个参数，分别为year，month，day，返回格式为year-month-day。
1.date对象表示理想化日历中的日期(年、月和日)，公历1年1月1日被称为第一天，依次往后推。
【示例】
import datetime
print("今天的日期是:",datetime.date.today())
#今日的日期
print("使用时间戳创建的日期:",datetime.
date.fromtimestamp(1234567896))
#使用时间戳创建日期
print("使用公历序数创建的日期:",datetime.date.fromordinal(1))
#使用公历序数创建的日期
运行结果：
今天的日期是: 2026-02-25
使用时间戳创建的日期: 2009-02-14
使用公历序数创建的日期: 0001-01-01
2.对象的属性及方法如下：
import datetime
today=datetime.date(year=2026,month=1,day=10)
#使用参数创建日期
print('date对象的年份:',today.year)
print('date对象的月份:',today.month)
print('date对象的日:',today.day)
print("date对象的struct_time结构为:",today.timetuple())
print("返回当前公历日期的序数:“,today.toordinal())
#与fromordinal函数作用相反
print("当前日期为星期(其中:周一对应0):{}".
　　　　format(today.weekday()))
print("当前日期为星期(其中:周一对应1):{}".
　　　　format(today.isoweekday()))
print("当前日期的年份、第几周、周几(其中返回为元组):",
today.isocalendar())
print("以ISO 8601格式‘YYYY-MM-DD’返回date的字符串形式:",
today.isoformat())
print("返回一个表示日期的字符串(其格式如:Mon Aug 31 00:00:00 2020):",
today.ctime())
print("指定格式为:",today.strftime("%Y/%m/%d"))
print("替换后的日期为:",today.replace(2026,2,10))
运行结果：
date对象的年份: 2026
date对象的月份: 1
date对象的日: 10
date对象的struct_time结构:time.struct_time(tm_year=2026,tm_mon=1,
tm_mday=10，tm_hour=0,tm_min=0,tm_sec=0,tm_wday=5,tm_yday=10,
tm_isdst=-1)
返回当前公历日期的序数: 739660
当前日期为星期(其中:周一对应0):5
当前日期为星期(其中:周一对应1):6
当前日期的年份、第几周、周几(其中返回为元组): (2026, 2, 6)
以ISO 8601格式‘YYYY-MM-DD’返回date的字符串形式: 2026-01-10
返回一个表示日期的字符串(其格式如:Mon Aug 31 00:00:00 2020): Sat Jan 10 00:00:00 2026
指定格式为: 2026/01/10
替换后的日期为: 2026-02-10
3.时间日期格式化符号(见表3-9)
表3-9　时间日期格式化符号
符号 含义
%y 两位数的年份表示(00-99)
%Y 四位数的年份表示(0000-9999)
%m 月份(01-12)
%d 月内中的一天(01-31)
%H 24小时制小时数(00-23)
%I 12小时制小时数(01-12)
符号 含义
%M 分钟数(00-59)
%S 秒(00-59)
%a 本地缩写星期名称
%A 本地完整星期名称
%b 本地缩写的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
符号 含义
%j 年内的第几天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)，星期天为星期的开始
%w 星期(0-6)，星期天=0
%W 一年中的星期数(00-53)，星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
二、time类
time类包含六个参数，分别为hour，minute，second，microsecond，tzinfo，fold；返回格式为hour:minute:second(.microsecond)。常用的参数有三个：hour、minute、second。
import datetime #使用参数创建时间
create_time=datetime.time(hour=11,minute=18,second=31)
print('create_time对象的小时为:', create_time.hour)
print('create_time对象的分钟为:', create_time.minute)
print('create_time对象的秒数为:', create_time.second)
print("返回create_time的字符串形式:",create_time.isoformat())
print("指定格式为:",create_time.strftime("%H/%M/%S"))
print("替换后的时间为:",create_time.replace(22,2,10))
其对象的属性和方法如下：
运行结果：
create_time对象的小时为: 11
create_time对象的分钟为: 18
create_time对象的秒数为: 31
返回create_time的字符串形式: 11:18:31
指定格式为: 11/18/31
替换后的时间为: 22:02:10
三、datetime类
1.datetime类可以看作date和time类的合体，其包含了这两个类中的全部参数，其中创建datetime类的常用类方法如下：
import datetime
print("现在的时间是:",datetime.datetime.today())
print("返回现在的时间是:",datetime.datetime.now())
print("当前UTC日期和时间是:",datetime.datetime.utcnow())
print("对应时间戳的日期和时间是:",
　　　datetime.datetime.fromtimestamp(1234567896))
print("对应UTC时间戳的日期和时间是:",
　　　datetime.datetime.utcfromtimestamp(1234567896))
print("公历序列对应的日期和时间是:",
　　　datetime.datetime.fromordinal(1))
print("日期和时间的合体为:",datetime.bine(datetime.
　　　date(2020,8,31),datetime.time(12, 12, 12)))
运行结果：
现在的时间是: 2026-02-25 12:34:56.789012
返回现在的时间是: 2026-02-25 12:34:56.789123
当前UTC日期和时间是: 2026-02-25 04:34:56.789456
对应时间戳的日期和时间是: 2009-02-14 08:31:36
对应UTC时间戳的日期和时间是: 2009-02-14 00:31:36
公历序列对应的日期和时间是: 0001-01-01 00:00:00
日期和时间的合体为: 2020-08-31 12:12:12
2.对象的属性和方法如下：
import datetime
now = datetime.datetime(2026,2,10,12,10,10)
print("年为:",now.year)
print("月为:",now.month)
print("日为:",now.day)
print("小时为:",now.hour)
print("分钟为:",now.minute)
print("秒数为:",now.second)
print('当前日期为:', now.date() )
print('当前时间:', now.time() )
#和date一样
print("返回struct_time为:",now.timetuple())
print("返回UTC的struct_time为:",now.utctimetuple())
print("返回的公历序列数为:",now.toordinal()) #和date一样
print("返回标准日期格式为:",now.isoformat()) #和date一样
print("返回的周几(1表示周一):",now.isoweekday()) #和date一样
print("返回的周几(0表示周一):",now.weekday()) #和date一样
print("now.isocalendar():", now.isocalendar()) #和date一样
#和date一样
print("now.ctime():",now.ctime())
#把日期按照format指定的格式进行格式化
print("格式化时间为:",now.strftime('%Y/%m/%d %H:%M:%S'))
#将字符串格式转换为日期格式
print(datetime.datetime.strptime("2026/1/10 8:8:00",
　　　'%Y/%m/%d %H:%M:%S'))
运行结果：
年为: 2026
月为: 2
日为: 10
小时为: 12
分钟为: 10
秒数为: 10
当前日期为: 2026-02-10
当前时间: 12:10:10
返回struct_time为: time.struct_time(tm_year=2026, tm_mon=2, tm_mday=10, tm_hour=12, tm_min=10, tm_sec=10, tm_wday=1, tm_yday=41, tm_isdst=-1)
返回UTC的struct_time为: time.struct_time(tm_year=2026, tm_mon=2, tm_mday=10, tm_hour=12, tm_min=10, tm_sec=10, tm_wday=1, tm_yday=41, tm_isdst=0)
返回的公历序列数为: 739660
返回标准日期格式为: 2026-02-10T12:10:10
返回的周几(1表示周一): 2
返回的周几(0表示周一): 1
now.isocalendar(): (2026, 7, 1)
now.ctime(): Tue Feb 10 12:10:10 2026
格式化时间为: 2026/02/10 12:10:10
2026-01-10 08:08:00
四、timedelta类
timedelta类代表两个datetime对象之间的时间差，即两个日期或者日期时间之差。支持参数：weeks、days、hours、minutes、seconds、milliseconds、microseconds。
【示例】
import datetime
now=datetime.date.today()
before_5_date=now+datetime.timedelta(days=-5)
print("now date is:",now) #表示现在的日期
print("before five days date is:",before_5_date) #表示五天前的日期
now_time = datetime.datetime.now()
print(now_time)
after_5_hours_10_minutes=now_time +datetime.timedelta(hours=5,
minutes=10)
print(after_5_hours_10_minutes)
运行结果：
now date is:2026-02-25
before five days date is:2026-02-20
2026-02-25 12:34:56.789123
2026-02-25 17:44:56.789123
五、tzinfo类
tzinfo类是一个虚拟基类，代表时区(time zone)，创建子类时必须重写tzname()，utcoffset()，dst()，tzinfo类在日常工作中用得少。
【参考答案】random
【答题分析】randint(n,m)函数是random模块里的一个函数，用来随机生成n到m(包括n和m)区间的随机整数。
例12　(2023年真题)在Python语言编程中，使用　　　　模块的函数randint()可以获取随机数。
【参考答案】A
例13　(2023年真题)python中提供了用于处理随机数的random库，该库中的函数randint(a,b)主要用于产生(　　)
A.[a,b]之间的随机整数
B.[a,b]之间的随机小数
C.(a,b)之间的随机整数
D.(a,b)之间的随机小数(共103张PPT)
第三部分　计算机编程基础
——Python语言
第三章　函数与模块、文件与数据
考点十五~二十
考
纲
要
求 一、函数与模块
1.掌握内置函数
2.掌握math模块
3.理解datetime模块
4.综合应用random模块
5.综合应用string模块
二、自定义函数
1.理解函数的定义与调用
2.综合应用函数的参数
3.综合应用变量的作用域 三、文件操作
1.理解文件的打开和关闭
2.掌握文件的读写
3.综合应用数据的格式化
四、数据库的使用
1.理解Python数据库应用接口
2.掌握Sqlite3模块
3.理解数据表的创建
4.掌握数据表的操作
命
题
趋
势 1.识记常用内置函数，理解math模块中的数学函数、datetime模块中的时间处理功能，并能综合应用random模块生成随机数与string模块处理字符串
2.要求学生理解自定义函数的定义与调用方法，能够综合运用各类函数参数(包括位置参数、默认参数、可变参数等)，并明确区分局部变量与全局变量的作用域
3.要求学生理解文件的打开与关闭机制，掌握文本文件的读写方法，并能够综合运用各类数据格式化技术(如字符串格式化、CSV、JSON等)进行结构化数据的存储与读取
4.要求学生理解Python数据库应用接口的基本规范，掌握Sqlite3模块的连接与操作方法，能够创建符合规范的数据表，并完成对数据表的增、删、改、查等基本操作
考
向
分
析 【考查内容】
自定义函数的运行；lambda函数、嵌套函数；程序调试；文件的打开、关闭与读写
【考查题型】
填空题、选择题、程序分析题
【考查分值】
20分左右
一、文件的打开和关闭(理解)
文件指存储在外部介质(如磁盘等)上有序的数据集合，这个数据集有一个名称，称为文件名。
常见的文件有记事本文件、日志文件、各种配置文件、数据库文件、图像文件、音频和视频文件等。
按数据的组织形式不同，可以将文件分为文本文件和二进制文件两大类。
文本文件一般由一种基于特定的编码的字符组成，如UTF-8编码。大部分文本文件都可以将文件通过文本编辑软件或文字处理软件创建、修改和阅读。由于存在编码，文本文件可看作是存储在磁盘上的长字符串。例如，在Windows平台中扩展名为txt、log、ini的文件都属于文本文件，可以使用记事本进行编辑。
二进制文件直接由比特0和比特1组成，无统一字符编码，内部数据的组织格式与文件用途有关。例如，图形图像文件、音频视频文件、可执行文件、数据库文件、Office文件等都属于二进制文件。二进制文件以字节流形式存储信息，无法用记事本或其他普通文字处理软件直接修改或阅读，需要使用对应软件进行解码或反序列化后才能正确地读取、显示、修改或执行。
1.文件打开
Python对文本文件和二进制文件采用统一的操作步骤：
(1)打开文件，或新建文件；
(2)读/写文件；
(3)关闭文件。
操作系统中的文件默认处于存储状态，首先需要将其打开，使得当前程序有权操作这个文件，若打开不存在的文件则可创建新文件。打开后的文件处于占用状态，此时，另一个进程不能操作该文件。接下来，可以通过一组方法读取文件的内容或向文件写入内容。操作完成后需要关闭文件，释放文件控制权，使文件恢复存储状态，此时其他进程才能操作该文件。
Python内置了文件对象，通过open()函数即可按照指定模式打开指定文件，并创建文件对象，其语法格式如下：
其中，文件名指定了被打开的文件名称，如果使用open()函数打开文件时，只带一个文件名参数，默认以只读方式打开文件，而且当文件不存在时会抛出异常。
文件对象名=open(文件名[,打开方式])
例如，打开名为“1.txt”的文件，代码为file=open('1.txt')。
文件名亦可包含文件路径，写路径时注意分隔符。若路径和文件名为“c:myfile”，应写成“c:\\myfile”。例如：file=open('c:\\myfile')。
2.文件打开方式及含义
如果想要编辑文件，就需要在打开文件时指明文件的打开方式。Python中文件的打开方式有多种，具体表示方法及含义如表3-10所示。
表3-10　文件打开方式及含义
文件打开方式 含义 文件不存在时
r(只读) 打开一个文本文件，只允许读数据 报错
w(只写) 打开或新建一个文本文件，只允许写数据 建立新文件
a(追加) 打开一个文本文件，并在文件末尾增加数据 建立新文件
文件打开方式 含义 文件不存在时
rb(只读) 以二进制格式打开一个文件，只允许读数据 报错
wb(只写) 以二进制格式打开或建立一个文件，只允许写数据 建立新文件
ab(追加) 以二进制格式打开一个文本文件，并在文件末尾写数据 建立新文件
r+(读写) 打开一个文本文件，允许读和写 报错
w+(读写) 打开或建立一个文本文件，允许读和写 建立新文件
文件打开方式 含义 文件不存在时
a+(读写) 带开一个文本文件，允许读或在文件末追加数据 建立新文件
rb+(读写) 以二进制格式打开一个文件，允许读和写 报错
wb+(读写) 以二进制格式打开或新建一个文件，允许读和写 建立新文件
ab+(读写) 以二进制格式打开一个文件，允许读或在文件末尾追加数据 建立新文件
(1)用只读方式“r”打开文件时，该文件必须已经存在，否则出错；仅允许读取操作，文件位置指针默认在文件的开头。
(2)用只写方式“w”打开文件时，如文件不存在，则指定的文件名新建文件。若打开的文件已经存在，则清空原文件内容重新写入，且只能进行写操作。
(3)用追加方式“a”打开文件时，如果文件已存在，文件位置指针在文件的末尾，新内容被写入到已有内容之后；如果文件不存在，则新建文件进行写入。
(4)“r+”“w+”“a+”都是既可读亦可写，区别在于“r+”与“r”一样，文件必须已经存在；“w+”和“w”一样，如文件不存在则新建文件，写后可读；“a+”则是打开文件名后可以在文件末尾增加新数据，亦可读取文件。
(5)打开方式带上“b”，表示是以二进制格式操作文件。
3.文件关闭
(1)手动关闭：文件对象名.close()
在Python中，虽然文件会在程序退出后自动关闭，但是考虑到数据的安全性，每次使用完文件后，都需要使用close()方法关闭文件。
【示例】以只写方式打开一个名为“test.txt”的文件，然后关闭文件，代码如下：
file=open('test.txt','w')
file.close() #关闭文件
(2)自动关闭：上下文管理语句with
Python中with语句用于对资源进行访问，保证不管处理过程中是否发生错误或者异常，都会执行规定的__exit__()(清理)操作，释放被访问的资源，常用于文件操作、数据库连接、网络通信连接、多线程与多进程同步时的锁对象管理等场合。其语法格式如下：
with context_expression[as target(s)]:
with-body
context_expression为表达式，target(s)为对象名。例如，用文件内容读写时，with语句的用法如下：
with open(文件名[,打开方式]) as 文件对象名:
二、文件的读写(掌握)
文件打开后，可根据打开方式执行对应的读写操作。当文件以文本方式打开时，按照字符串方式进行读写，采用当前计算机使用的编码或指定编码；当文件以二进制文件方式打开时，按照字节流方式进行读写。
对于所有读操作，文件都必须以读或读写方式打开；对于所有写操作，文件都必须以写、读写或追加方式打开；如希望重建文件，可采用只写或读写方式打开文件；如希望保留原文件内容，且从末尾开始增加新内容，可采用追加或读写方式打开文件。
1.写文件
Python提供了2个与文件写入有关的方法：write()和writelines()。
(1)write()方法
write()方法用于向文件中写入指定字符串，其语法格式如下：
文件对象名.write(str)
其中，str为要写入文件的字符串。
【示例】向文件“testfile.txt”中写入如下数据。
Interface options
Generic options
分析：首先以只写方式打开文件(当文件不存在时会创建文件)；然后向文件中写入数据，这里需要注意的是write()方法不会自动在字符串的末尾添加换行符，因此，当输入多行时，需要在write语句中包含换行符；最后关闭文件。
参考代码：
#打开名为“testfile.txt”的文件 file=open('testfile.txt','w')
#向文件中输入字符串 file.write('Interface options\n') file.write('Generic options\n') file.close()
运行结果：程序运行后，会在程序所在路径下生成一个名为“testfile.txt”的文件，打开该文件，可以看到数据被成功写入到文件中。
如果打开文件时，文件打开方式带“b”，那么写入文件内容时，str(参数)要用encode()方法转为字节流形式，否则会抛出异常。例如：file.write('Interface options'.encode())。
(2)writelines()方法
writelines()方法用于向文件中写字符串序列。这一个字符串序列可以是由迭代对象产生的，如一个字符串列表，语法格式如下：
文件对象名.writelines(sequence)
其中sequence为要写入文件的字符串序列。
【示例】使用writelines()方法向已有的“example.txt”文件中追加如下数据。
line 1
line 2
line 3
lines=['line 1\n','line 2\n','line 3\n']
with open('example.txt','a') as f:
f.writelines(lines)
运行结果：程序运行后，会将数据追加到程序所在路径下的名为“example.txt”的文件中，打开该文件，可以看到数据被成功追加到文件中。
2.读文件
Python提供了3个常用的文件内容读取方法：read()、readline()和readlines()。
(1)read()方法
用于从文件中读取指定的字节数，如果为给定参数或参数为负，则读取整个文件内容。其语法格式如下：
文件对象名.read([size])
其中，size为从文件中读取的字节数，该方法返回从文件中读取的字符串。
【示例】使用read()方法读取“testfile.txt”文件。
#以只读方式打开文件
with open('testfile.txt','r') as file: line=file.read(10) #读取前10个字节 print(line) #输出前10个字节 print('*'*30) #输出30个*用于分割 #读取文件中剩余的所有内容
content=file.read()
print(content) #输出
程序说明：打开文件时，文件位置指针在文件的开头，运行“line=file.
read(10)”语句，就会从文件的开头读取10个字符，因此输出“Interface ”后面包含了一个空格；当执行“content=file.read()”语句时，文件的指针已经在第10个字符处，因此，执行该语句时，读取了文件中剩余的所有内容(不包含前10个字符)。
(2)readline()方法
readline()方法用于从文件中读取整行，包括“\n”字符。如果指定一个非负数的参数，则表示读入指定大小的字符串，其语法格式如下：
其中，size为从文件中读取的字节数。
文件对象名.readline([size])
【示例】使用readline()方法读取“testfile.txt”文件。
with open('testfile.txt','r') as file: line=file.readline() print(line) print('*'*30) line=file.readline(10) print(line)
(3)readlines()方法
readlines()方法用于读取所有行(直到结束符EOF)并返回列表，列表中每个元素为文件中的一行数据，其语法格式如下：
文件对象名.readlines()
【示例1】使用readlines()方法读取“testfile.txt”文件。
with open('testfile.txt','r') as file:
#读取所有行并返回列表
content=file.readlines() print(content) print('*'*60) for temp in content: 　　　　print(temp) #输出列表每个元素
程序说明：从运行结果可以看出，readlines()方法读取文件后返回的值为列表。遍历列表时，由于每个元素后面有一个“\n”，而print语句也会加上一个换行符，因此会多出来空白行。
上述代码存在一个缺点：当读取文件非常大时，一次性将内容读取到列表中会占用很多内存，影响程序执行速度。可以将文件本身作为一个行序列进行读取，遍历文件的所有行可以直接用下面代码实现。
with open('testfile.txt','r') as file: for line in file: print(line)
【示例2】将文件“testfile.txt”中的内容复制到另一个文件“copy.txt”中。
分析：如果想要将文件“testfile.txt”中的内容复制到另一个文件“copy.txt”中，则需要读取原文件数据，并将获取的数据写入新文件。
参考代码：
with open('testfile.txt') as file1,open('copy.txt','w') as file2:
file2.write(file1.read())
程序说明：程序运行后，会在当前目录中打开“copy.txt”文件(如不存在则新建)和“testfile.txt”文件，并将从“testfile.txt”文件中读取的内容写入到“copy.txt”文件中。
三、文件的定位(理解)
文件位置指针，是系统设置的用来指向文件当前读写位置的指针，不需要用户定义，但会随着文件的读写操作而移动。因此，在对文件进行操作前，需先清楚当前文件位置指针的位置，在不同位置进行操作时，也需将文件位置指针定位在相应位置。
1.获取当前读写位置
在读写文件的过程中，如果想知道当前文件指针的位置，可以通过调用tell()方法来获取。tell()方法返回文件的当前位置，即文件位置指针当前的位置。其语法格式如下：
文件对象名.tell()
【示例】使用tell()方法获取文件当前的读写位置。
with open('testfile.txt','r') as file: line=file.read(8) print(line)
p=file.tell() #获取指针当前位置 print('当前位置:',p) line=file.read(4) print(line) p=file.tell() print('当前位置:',p)
2.定位到某个位置
如果在读写文件的过程中，需要从指定的位置开始读写操作，就可以使用seek()方法实现。seek()方法用于移动文件位置指针到指定位置。其语法格式如下：
文件对象名.seek(offset[,whence])
参数介绍如下：
(1)offset：表示偏移量，也就是需要偏移的字节数。
(2)whence：可选，默认值为0，表示起始点，即位移量的参考点，有三种取值，0代表“文件开始位置”，1代表“当前位置”，2代表“文件末尾位置”。
【示例1】创建名为“seek.txt”的文件，输入字符串“This is a test!”并存放进文件中，读取单词“test”并输出到终端。
分析：首先创建并打开指定的文件，文件名由终端输入。然后在文件中写入“This is a test!”字符串，接着利用seek()方法将文件位置指针指向“test”单词的字母“t”处，最后读取单词“test”并输出到终端。
with open('seek.txt','w+') as file: file.write("This is a test!") file.seek(10)
con=file.read(4) print(con)
程序说明：上述代码中“file.seek(10)”表示将文件位置指针移到从文件起始位置开始的第10个字符处，这里省略了whence参数，该语句也可写成“file.seek
(10,0)”。
提示：以文本文件格式打开文件时，seek()方法中的whence参数取值只能是0，即只允许从文件开始位置计算偏移量。若想从当前位置或文件末尾位置计算偏移量，需要使用“b”模式(二进制格式)打开文件。
【示例2】读取“seek.txt”文件中倒数第2个字符。
with open('seek.txt','rb') as file:
file.seek(-2,2)
#将文件位置指针定位到倒数第二个字符处 con=file.read(1) #读取一个字符给con print(con)
程序说明：上述代码中，如果以文本文件格式打开文件，即第一条语句中的open()方法改为open('seek.txt'，'r')，运行程序将提示错误信息。
一、数据文件类型
数据文件主要有文本文件和二进制文件两种类型。
1.文本文件
由一种基于特定编码的字符构成，通常由文本编辑器或文档处理软件建立。表3-11列出了文本文件的几种编码格式。
表3-11　文本文件的编码方式
编码格式 说明
ANSI 计算机系统预设的标准文字储存格式
Unicode 国际通用编码字符集
UTF-8 通用字集转换格式，Unicode的8位元格式
在打开文本文件时，应当注意其编码格式。如若要显示文件中汉字内容，通常应用UTF-8编码格式。带有编码格式的文件打开函数格式如下：
<对象名>=open(<文件名>[,<打开模式>[,>]])
【示例】用open()函数打开文件“静夜思.txt”，对象名为file1，读取文件内容。
file1=open('静夜思.txt','r',encoding='utf-8')
f=file1.read()
print(f)
file1.close()
运行结果：
静夜思
唐 李白
床前明月光，疑是地上霜。
举头望明月，低头思故乡。
2.二进制文件
由二进制数据0和1构成，按照非字符编码但以特定字节格式形成的文件，如文档、图片、视频、音频等字节流文件。
二进制文件一般由相应的应用程序创建，二进制文件的打开不能使用encoding参数。
【示例】应用open()函数以二进制文件形式打开文件“静夜思.txt”，对象名为file2，读取文件内容。
file2=open('静夜思.txt','rb')
f=file2.read()
print(f)
file2.close()
二、数据的格式化
数据的格式化是将数据按照一定的结构进行整理组织，形成有效信息的过程。格式化数据具有维度，Python支持一维数据和二维数据。
1. 一维数据
一维数据是以线性结构组织的数据。常见的一维数据有数组、列表和集合等。一维数据通常以结构化的文本文件形式保存在磁盘中，数据之间可以空格、逗号、“/”等分隔符分开。
2. 二维数据
二维数据是以表格形式组织的数据，也称之为二维表。二维数据也是以结构化的文本文件形式保存在磁盘中，其中CSV是将数据列用逗号分隔的较为常用的数据交换格式。
3. csv模块
在Python中，使用csv模块进行CSV文件的操作。Python的csv模块主要进行reader对象和writer对象的操作。
(1)reader对象的定义
<对象名>=csv.reader(<文件对象名>)
【示例】定义CSV文件“ex.csv”的reader对象为r_ex。
import csv #导入csv模块
f=open('ex.csv') #打开文件ex.csv
r_ex=csv.reader(f) #定义reader对象
#输出reader对象r_ex的地址
print(r_ex)
f.close() #关闭文件ex.csv
(2)writer对象的定义
<对象名>=csv.writer(<文件对象名>)
writer对象的操作：
#CSV文件中写入单行
.writerow(<一维列表>)
#CSV文件中写入多行
.writerows(<二维列表>)
【示例】定义文件“ex.csv”的writer对象为w_ex，将下表中表头和前二行数据写入对象中。
学号 姓名 性别 成绩
2022001 张三 男 98
2022002 李四 女 94
2022003 王五 男 73
2022004 赵六 男 82
2022005 钱七 女 89
import csv #导入csv模块
f=open('ex.csv','w') #打开文件ex.csv
w_ex=csv.writer(f) #定义writer对象
#表头数据
hd=['学号','姓名','性别','成绩']
#前二行数据
sj=[['2022001','张三','男',98],['2022002','李四','女',94]]
w_ex.writerow(hd) #写入表头
w_ex.writerows(sj) #写入二行数据
f.close() #关闭文件ex.csv
Python访问数据库的一般步骤：①导入相关模块；②连接数据库并获取数据连接对象； ③获取游标对象；④应用游标对象的方法进行数据库相关操作；⑤关闭游标对象。
一、DB-API常用模块
Python通过DB-API接口实现对数据库的使用。DB-API系统地定义了数据库对象和数据库存取方式，为各类数据库系统提供了统一的访问接口(见表3-12)。
表3-12　DB-API常用模块作用
模块名称 说明
pyodbc 以ODBC(开放数据库互连，Open Database Connectivity)方式连接数据库
win32com.client 以ADO(ActiveX Data Object)方式连接数据库
模块名称 说明
cx_Oracle Python连接Oracle数据库的专用模块
SQLite3 Python连接数据库的内置模块
mysql-connector MySQL官方驱动
二、数据库对象
1.connect对象
Python应用connect()函数创建一个数据库连接对象。connect()函数的格式如下所示：
connect(<数据库名>,<用户名>,<用户密码>)
关闭数据库连接对象如下所示：
.close()
2.cursor对象
cursor对象也称为游标对象，通过cursor()函数获取数据库游标。游标的作用是进行数据操作时定位数据记录。游标对象的定义如下所示：
关闭游标对象如下所示：
.cursor()
.close()
三、数据库操作
DB-API 2.0规范支持SQL-92标准。通过execute()函数调用SQL语句进行数据库的相关操作。execute()函数的格式如下所示：
.execute()
一、数据库连接对象
sqlite3通过connect()函数创建一个数据库连接对象，connect()函数的格式如下所示：
说明：若连接的数据库已存在，则建立数据库连接对象。
=sqlite3.connect(<数据库名>)
【示例】应用connet()函数连接数据库文件“exdb.db”，对象名为db_ex。
import sqlite3
db_ex=sqlite3.connect('exdb.db')
db_ex.close()
二、游标对象
sqlite3通过cursor()函数创建一个数据库游标对象，cursor()函数的格式如下所示：
【示例】应用cursor()函数定义连接数据库对象db_ex的游标对象名为db_cur。
=.cursor()
import sqlite3
db_ex=sqlite3.connect('exdb.db')
db_cur=db_ex.cursor()
db_cur.close()
db_ex.close()
创建数据表有两个步骤：建立表结构和录入表数据。Python的sqlite3模块可以调用相关的SQL-CREATE语句创建一个数据表。
一、建立表结构
1.SQL-CREATE语句
SQL-CREATE语句格式如下：
CREATE TABLE<数据表名>(
<列名1 数据类型[PRIMARY KEY]>[，
<列名2 数据类型[PRIMARY KEY]>][，
<列名3 数据类型[PRIMARY KEY]>][，
......])
说明：
(1)<数据表名>为建立数据表的名称，是以二维表形式构成的数据。二维表是以行列组织数据的表格，列表示属性，表头为属性的集合，行为数据记录。
(2)[PRIMARY KEY]为主键值，表示该列数据不允许有重复值。
(3)sqlite3数据类型如表3-13所示。
表3-13　sqlite3支持的数据类型
数据类型 描述
INTEGER 整数
TEXT 文本型(UTF-8编码等)
REAL 浮点数
NULL 空值
BLOB 数据块(二进制数据)
2.创建表文件
在“student.db”中创建数据体能测试表“stud”，学号、姓名、性别的数据类型为TEXT、50米跑的数据类型为REAL，立定跳远和坐位体前屈的数据类型也为REAL。
(1)新建数据库。
新建数据库文件“student.db”，定义数据库连接对象和游标对象。
import sqlite3
stu=sqlite3.connect('student.db')
st=stu.cursor()
(2)创建数据表“stud”的SQL-CREATE语句。
s='create table stud(学号TEXT,姓名TEXT,性别TEXT,50米跑REAL,立定跳远\
REAL,坐位体前屈REAL)'
(3)调用execute()函数执行SQL语句创建数据表“stud”。
execute()函数语法格式为：
<游标对象>.execute(SQL语句)
st.execute(s)
(4)关闭游标对象和数据库。
st.close()
stu.close()
【示例1】编程实现建立数据库xsda.db，创建学生信息表xsxx。
import sqlite3
stu=sqlite3.connect('xsda.db')
st=stu.cursor()
s='create table xsxx(学号TEXT,姓名TEXT,性别TEXT,入学成绩REAL)'
st.execute(s)
st.close()
stu.close()
【示例2】编程实现，在数据库xsda.db中创建学生成绩表xscj，要求从键盘录入列名和数据类型。
import sqlite3
xs=sqlite3.connect('xsda.db')
xs_cur=xs.cursor()
s='create table xscj('
while True:
s1=input("请输入列名:")
s2=input("请输入数据类型:")
s += s1+" "+s2+"，"
yn=input("是否继续(y/n) ")
if yn.upper()!='Y':
break
s=s.rstrip(',')+')'
xs_cur.execute(s)
mit()
xs_cur.close()
xs.close()
二、录入表数据
1.SQL-INSERT语句
Python的sqlite3模块可以调用相关的SQL-INSERT语句录入数据表记录。SQL-INSERT语句在<数据表>的文件末尾添加一条记录，语句格式如下：
INSERT INTO <数据表名>(<列名1>,<列名2>,<列名3>,......)
VALUES (<值1>,<值2>,<值3>,......)
说明：
SQL-INSERT语句若为所有列都添加值，则可以省略(<列名1>,<列名2>,<列名3>, ......)，语法格式如下：
INSERT INTO <数据表名>
VALUES (<值1>,<值2>,<值3>, ......)
2.添加表记录
sqlite3调用SQL操纵语句时需要应用commit()函数提交数据库执行确认，才能进行数据库记录的插入、删除和更新操作。
commit()函数格式如下：
.commit()
【示例】编程实现在数据库xsda.db中录入学生入学信息表xsxx的数据记录。
import sqlite3
st=sqlite3.connect("xsda.db")
stu=st.cursor()
s1="insert into xsxx(学号,姓名,性别,入学成绩)values('2022001',\
'李丽','女',98.5)"
stu.execute(s1)
s2="insert into xsxx values('2022002','王强','男',86.3)"
stu.execute(s2)
s3=[("2022003","张晓璐","女",82.4),("2022004","赵平平","男",91.0)]
sq="insert into xsxx values( , , , )"
stu.executemany(sq,s3)
mit()
stu.close()
st.close()
Python的sqlite3模块通过调用SQL语句进行数据表的操作，数据表的操作语句如表3-14所示：
操作类型 操作命令 描述
数据查询 SELECT 查询满足条件的数据记录
数据定义 CREATE 创建数据库表
ALTER 修改数据表结构
DROP 删除数据库表
数据操纵 INSERT 添加数据记录
DELETE 删除数据记录
UPDATE 更新数据记录
表3-14　数据表的操作语句
一、数据查询
SQL-SELECT语句格式如下：
SELECT <查询项> from <数据表名>
[where <条件>]
[group by <分组关键字> having <条件>]
[order by <排序关键字>]
说明：
(1)这里的<查询项>可以是<列名>，也可以是关于<列名>的表达式。
(2)查询项中可以用AVG()函数求平均值，类似的函数有求和SUM()、计数COUNT()、最大值MAX()和最小值MIN()等。
(3)<排序关键字>后加ASC表示为升序，加DESC为降序，默认为升序。
(4)在sqlite3中调用SQL-SELECT语句时，会应用游标对象方法程序(表3-15)。
表3-15　游标对象的常用方法
方法 功能描述
execute() 调用SQL语句
executemany() 多次调用SQL语句
fetchone() 查询数据表结果的一条记录
fetchmany() 查询数据表结果的多条记录
fetchall() 查询数据表结果的全部记录
【示例1】应用SQL-SELECT语句查询数据库“student.db”中数据表stud的学号列和姓名列。
import sqlite3
st=sqlite3.connect('student.db')
su=st.cursor()
s=su.execute("select 学号,姓名 from stud")
r=su.fetchone()
print(r)
r=su.fetchone()
print(r)
su.close()
st.close()
【示例2】应用SQL-SELECT语句查询数据库“student.db”数据表stud中性别为“男”的学号列和姓名列。
……
s=su.execute("select 学号,姓名from stud where 性别='男'")
……
【示例3】应用SQL-SELECT语句查询数据库“student.db”中数据表stud的学号列和姓名列，查询结果以姓名为关键字进行降序排列。
……
s=su.execute("select 学号,姓名 from stud order by 姓名 DESC")
……
二、数据定义
1.修改表结构
sqlite3中调用SQL-ALTER语句可以实现对数据表结构的修改，即添加数据表列。sqlite3不支持SQL-ALTER语句的修改和删除数据表列。语法格式如下：
ALTER TABLE <数据表名> ADD COLUMN <列名><数据类型>
【示例】应用SQL-ALTER语句为数据库“xsda.db”中数据表“学生信息表(xsxx)”增加“手机号码(TEXT)”列。
import sqlite3
xs=sqlite3.connect('xsda.db')
xscur=xs.cursor()
sql1='alter table xsxx add column 手机号码TEXT'
xscur.execute(sql1) #添加列“手机号码”
xscur.close()
xs.close()
2.删除数据表
sqlite3中调用SQL-DROP语句可以实现对数据表删除，SQL-DROP语句的格式如下：
DROP TABLE <数据表名>
【示例】应用SQL-DROP语句删除数据库“xsda.db”中数据表“学生信息表(xsxx)”。
import sqlite3
xs=sqlite3.connect('xsda.db')
xscur=xs.cursor()
sql2='drop table xsxx'
xscur.execute(sql2) #删除数据表xsxx
xscur.close()
xs.close()
三、数据操纵
1.更新表记录
sqlite3中调用SQL-UPDATE语句可以实现对数据表记录的修改，SQL-UPDATE语句的格式如下：
UPDATE<数据表名>SET<列名1>=<表达式1>,
<列名2>=<表达式2>, ......[WHERE<条件>]
【示例】应用SQL-UPDATE语句更新数据库“student.db”中数据表xscj的数据。
import sqlite3
st=sqlite3.connect('student.db')
stu=st.cursor()
stu.execute('update xscj set 姓名="王玉" where 学号="202001005"')
stu.execute('select学号,姓名 from stud where 学号="202001005"')
r=stu.fetchall()
print(r)
mit()
stu.close()
st.close()
2.删除表记录
sqlite3中调用SQL-DELETE语句可以实现对数据表记录的删除，SQL-DELETE语句的格式如下：
DELETE FROM<数据表名>[WHERE<条件>]
【示例】应用SQL-DELETE语句删除数据库“student.db”中数据表stu的数据。
import sqlite3
st=sqlite3.connect('student.db')
stu=st.cursor()
stu.execute('delete from stud ''where学号="202001005"')
stu.execute('select 学号，姓名 from stud')
r=stu.fetchall()
print(r)
mit()
stu.close()
st.close()
【参考答案】D
【答题分析】{:8.3f}表示:格式化为浮点数，总宽度8个字符，保留3位小数。对数字123.5678，保留3位小数时，会四舍五入到小数点后3位：123.568。123.568作为字符串长度是7个字符(包括小数点)，因此在左侧补1个空格(默认右对齐数字)。所以选D。
例14　(2022年真题)Python语句print('score={:8.3f}'.format(123.5678))执行后的输出结果(选项中的□代表空格)是(　　)
A.□123.568 B.□123.57
C.score=123.56 D.score=□123.568
例15　(2024年真题)编写一个程序，实现将5×5的矩阵，采用覆盖写模式写入到一个已经存在的“guo.txt”文件中，并将“guo.txt”文件另存为“guo.csv”文件。“guo.txt”“guo.csv”与编写的程序文件处于同一层次同一个文件夹中。说明:逗号分隔的存储格式称为CSV格式，相对应的存储文件称为csv文件。5×5的矩阵如下图所示(注：每行中的数字，以一个空格间隔，行与行间无间隔)。
【参考答案】
matrix=[[0,1,2,3,4],[1,2,3,4,5],[2,3,4, 5,6],[3,4,5,6,7],
[4,5,6,7,8]] with open('guo.txt','w')as f: for row in matrix: # 将每行的数字转换为字符串，并以空格分隔 row_str=" ".join(str(num) for num in row)
# 写入每行数据并换行 f.write(row_str+"\n")
# 读取guo.txt文件内容 with open('guo.txt','r')as f1,open('guo.csv','w')as f2: content=f1.readlines() # 读取所有行
for line in content: line=line.strip() #去除每行的换行符 values=line.split() csv_line=",".join(values) f2.write(csv_line+"\n") #写入到guo.csv文件并换行
【答题分析】先用列表存储数据模拟矩阵；接下来，将矩阵以覆盖写模式写入到guo.txt文件中；最后，将guo.txt文件的内容读取出来，然后以CSV格式写入到guo.csv文件中。
例16　创建一个名为employees.db的数据库，在其中创建一个名为employees_info的表。此表包含employee_id(整数类型，作为主键)、first_name(文本类型)、last_name(文本类型)、department(文本类型)和hire_date(日期类型)。
【答题分析】使用Python的sqlite3模块创建employees.db数据库，再通过SQL-CREATE语句创建一个employees_info数据表。
import sqlite3 conn = sqlite3.connect('employees.db') c = conn.cursor() create_table_query="""
CREATE TABLE employees_info (employee_id INTEGER PRIMARY KEY,
first_name TEXT,last_name TEXT,department TEXT,hire_date DATE)
""" c.execute(create_table_query) conn.commit() conn.close()
【参考答案】
例17　在employees.db数据库中有employees表，包含employee_id(整数型主键)、name(文本型)、department(文本型)和salary(整数型)字段。编写代码查询出department为'Sales'的所有员工信息。
【答题分析】在关系型数据库中，SELECT语句用于从表中检索数据。我们只需要导入sqlite3模块连接employees.db数据库，再通过SELECT语句依据条件查询数据。
import sqlite3 conn = sqlite3.connect('employees.db') c = conn.cursor() query="SELECT*FROM employees WHERE department = 'Sales' " c.execute(query) results = c.fetchall() for row in results: print(row) conn.close()
【参考答案】(共120张PPT)
第三部分　计算机编程基础
——Python语言
第三章　函数与模块、文件与数据
考点八
考
纲
要
求 一、函数与模块
1.掌握内置函数
2.掌握math模块
3.理解datetime模块
4.综合应用random模块
5.综合应用string模块
二、自定义函数
1.理解函数的定义与调用
2.综合应用函数的参数
3.综合应用变量的作用域 三、文件操作
1.理解文件的打开和关闭
2.掌握文件的读写
3.综合应用数据的格式化
四、数据库的使用
1.理解Python数据库应用接口
2.掌握Sqlite3模块
3.理解数据表的创建
4.掌握数据表的操作
命
题
趋
势 1.识记常用内置函数，理解math模块中的数学函数、datetime模块中的时间处理功能，并能综合应用random模块生成随机数与string模块处理字符串
2.要求学生理解自定义函数的定义与调用方法，能够综合运用各类函数参数(包括位置参数、默认参数、可变参数等)，并明确区分局部变量与全局变量的作用域
3.要求学生理解文件的打开与关闭机制，掌握文本文件的读写方法，并能够综合运用各类数据格式化技术(如字符串格式化、CSV、JSON等)进行结构化数据的存储与读取
4.要求学生理解Python数据库应用接口的基本规范，掌握Sqlite3模块的连接与操作方法，能够创建符合规范的数据表，并完成对数据表的增、删、改、查等基本操作
考
向
分
析 【考查内容】
自定义函数的运行；lambda函数、嵌套函数；程序调试；文件的打开、关闭与读写
【考查题型】
填空题、选择题、程序分析题
【考查分值】
20分左右
一、数学函数
数学函数顾名思义，就是与数学相关的一些函数，如表3-2所示。
表3-2　常用的数学函数
函数 描述示例
abs(X) 返回数字X的绝对值
abs(-1.5)，值：1.5
max() 返回给定参数的最大值
max(3.2，5.3，1.2，6.9，4.5，8.7，6.2，5.3)，值：8.7
函数 描述示例
min() 返回给定参数的最小值
min(3.2，5.3，1.2，6.9，4.5，8.7，6.2，5.3)，值：1.2
sqrt(X) 返回数字平方根，先导入math模块
math.sqrt(100)，值：10.0
pow(x，y) 返回x的y次方的值
pow(3，2)，值：9
log(x) 以e为底的x 的对数
math.log(1)，值：0.0
函数 描述示例
exp(x) e的x次方
math.exp(0)，值：1
divmod(x，y) 返回x除以y的商和余数
divmod(12，10)，值：(1，2)
round(x，n) 对x四舍五入，保留n位小数
round(3.1415926，2)，值：3.14
在PyCharm中输入：print(dir(math)，可以查看更多的数学函数。
【示例1】输入一个3位数，计算并输出其百位、十位、个位数字。
方法一：
x=input("请输入一个3位数:")
x=int(x)
a,b=divmod(x,100)
b,c=divmod(b,10)
print(a,b,c)
方法二：
运行结果：
>>> x="258"
>>> a,b,c=map(int,x)
>>> a,b,c
2 5 8
【示例2】自定义函数，实现与数学函数max()相同功能(自定义函数，适用于列表、元组、集合及多元素参数等)。
def getmax(*nums):
m=nums[0]　#若使用0，限制数据类型
for i in nums:
if mm=i
return m
l="sdjhgxcbnm"　#不定长参数，可以使用字符串
#不定长参数，可以使用集合
l={2.5,3.6,7.8,1.2,2.4,6.5}
#不定长参数，可以使用元组
l=(2.5,3.6,7.8,1.2,2.4,6.5)
#不定长参数，可以使用列表
l=[2.5,3.6,7.8,1.2,2.4,6.5]
print(f"列表中的最大数为:{getmax(*l)}")
运行结果：
列表中的最大数为:7.8
def fzg(a,b,c):
if a==0:
x1="输入变量a的值无效"
x2="错误!"
elif b**2-4*a*c>=0:
x1=(-b+(b**2-4*a*c)**0.5)/(2*a)
x2=(-b-(b**2-4*a*c)**0.5)/(2*a)
elif b**2-4*a*c<0:
x1=str(-b/(2*a))+"+"+str(abs((b**2-4*a*c)**0.5)/(2*a))+"j"
x2=str(-b/(2*a))+"-"+str(abs((b**2-4*a*c)**0.5)/(2*a))+"j"
print("方程的根为{}，{}".format(x1,x2))
a,b,c=map(int,input().split())
fzg(a,b,c)
运行结果分三种情况：
结果1：
8 3 2
方程的根为-0.1875+0.46351240544347894j，
-0.1875-0.46351240544347894j
结果2：
3 8 2
方程的根为-0.2792407799438735，
-2.3874258867227933
结果3：
0 3 2
方程的根为输入变量a的值无效，错误!
二、字符串函数
字符串函数，是与字符串相关的一些函数。Python常见的字符串函数：
len()、max()、min()、str.replace(old,new)、str.find(x)、",".join(str)、str.
upper()、str.lower()、str.count()、str.split()、str.strip()。
【示例1】
>>> len("abcd")
4
>>> len("中国灵璧")
4

>>> max("abcd")
'd'
>>> max("中国灵璧")
'璧'
>>> min("abcd")
'a'
>>> min("中国灵璧")
'中'

【示例2】
>>> st="abcd123abcd1245kjab12"
>>> st.replace("cd","789") #字符串是不变的
'ab789123ab7891245kjab12'
>>> st.replace("123","中国灵璧") #是新字符串
'abcd中国灵璧abcd1245kjab12'
>>> st.find("12") #返回查找到的字符串的索引值
4
三、列表函数
列表函数指与列表相关的一些函数。将列表作为参数传递给函数提供更多的信息，将列表传递给函数后，函数就能直接访问并修改其内容。
【示例】输入一行字符，分别统计出其中英文字母、空格、数字和其他字符。
st=input("请输入一行字符:")
zm,kg,num,qt=0,0,0,0
for i in st:
if i.isalpha(): #字母判断方法 　　　　zm+=1
elif i.isspace(): #空格判断方法 kg+=1 elif i.isdigit(): #数字判断方法 num+=1 #判断字母、数字
else:
qt+=1
print("输入的字符串中包含{}个英文字母、{}个空格、{}个数字和其他字符\　　　　
　　　　{}个".format(zm,kg,num,qt))
程序运行结果：
请输入一行字符:dsdfgh659832.../nji159@#$%^&*
输入的字符串中包含9个英文字母、0个空格、9个数字和其他字符11个
1.更新列表：append()方法。
可以对列表的数据项进行修改或更新，也可以使用 append() 方法来添加列表项
【示例】
list=['Google','Runoob',1997,2000]
print("第三个元素为:",list[2])
list[2]=2001
print("更新后的第三个元素为:",list[2])
list1=['Google','Runoob','Taobao']
list1.append('Baidu')
print("更新后的列表:",list1)
输出结果：
第三个元素为:1997
更新后的第三个元素为:2001
更新后的列表:['Google','Runoob','Taobao','Baidu']
2.删除列表元素：del语句。
可以使用del语句来删除列表的元素。
【示例】
list=['Google','Runoob',1997,2000]
print("原始列表:",list)
del list[2]
print("删除第三个元素:",list)
输出结果：
原始列表:['Google','Runoob',1997,2000]
删除第三个元素:['Google','Runoob',2000]
3.Python列表脚本操作符(见表3-3)。
表3-3　Python列脚本操作符
Python 表达式 结果 描述
len([1， 2， 3]) 3 长度
[1， 2， 3] + [4， 5， 6] [1， 2， 3， 4， 5， 6] 组合
['Hi!'] * 4 ['Hi!'， 'Hi!'， 'Hi!'， 'Hi!'] 重复
3 in [1， 2， 3] True 元素是否存在于列表中
for x in [1， 2， 3]:
print(x， end=" ") 1 2 3 迭代
列表对+和*的操作符与字符串相似，+号用于组合列表，*号用于重复列表。
4.Python列表截取与拼接：
(1)Python的列表截取与字符串操作类似：
已知L=['Google'，'Runoob'，'Taobao']，则
Python 表达式 结果 描述
L[2] 'Taobao' 读取第三个元素
L[-2] 'Runoob' 从右侧开始读取倒数第二个元素:count from the right
L[1:] ['Runoob'， 'Taobao'] 输出从第二个元素开始后的所有元素
(2)列表还支持拼接操作：
>>> squares=[1,4,9,16,25]
>>> squares+=[36,49,64,81,100]
>>> squares
[1,4,9,16,25,36,49,64,81,100]
5.嵌套列表。
使用嵌套列表即在列表里创建其他列表，例如：
>>> a=['a','b','c'] >>> n=[1,2,3] >>> x=[a,n] >>> x [['a','b','c'],[1,2,3]] >>> x[0] ['a','b','c'] >>> x[0][1] 'b'
6.列表比较需要引入operator模块的eq方法：
import operator # 导入 operator 模块 a=[1,2] b=[2,3] c=[2,3] print("operator.eq(a,b):",operator.eq(a,b)) print("operator.eq(c,b):",operator.eq(c,b))
输出结果：
operator.eq(a,b):False
operator.eq(c,b):True
7.Python列表函数与方法：
(1)Python列表包含以下函数：
len(list) ：列表元素个数
list1=['Google','Runoob','Taobao']
print(len(list1))
list2=list(range(5))#创建一个0-4的列表
print(len(list2))
输出结果：
3
5
max(list) ：返回列表元素最大值
list1,list2=['Google','Runoob','Taobao'],[456,700,200]
print("list1最大元素值:",max(list1)) print("list2最大元素值:",max(list2))
输出结果：
list1最大元素值:Taobao
list2最大元素值:700
min(list) ：返回列表元素最小值
list1,list2=['Google','Runoob','Taobao'],[456,700,200]
print("list1最小元素值:",min(list1))
print("list2最小元素值:",min(list2))
输出结果：
list1最小元素值:Google
list2最小元素值:200
list(seq)：将元组转换为列表
aTuple=(123,'Google','Runoob','Taobao')
list1=list(aTuple)
print("列表元素:",list1)
str="Hello World"
list2=list(str)
print("列表元素:",list2)
输出结果：
列表元素:[123,'Google','Runoob','Taobao']
列表元素:['H','e','l','l','o',' ','W','o','r','l','d']
(2)Python列表包含以下方法：
list.append(obj) ：在列表末尾添加新的对象
list1=['Google','Runoob','Taobao'] list1.append('Baidu') print("更新后的列表:",list1)
输出结果：
更新后的列表:['Google','Runoob','Taobao','Baidu']
list.count(obj)：统计某个元素在列表中出现的次数
aList=[123,'Google','Runoob','Taobao',123] print("123元素个数:",aList.count(123)) print("Runoob元素个数:",aList.count('Runoob'))
输出结果：
123元素个数:2
Runoob元素个数:1
list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list1=['Google','Runoob','Taobao']
list2=list(range(5)) #创建0-4的列表
list1.extend(list2) #扩展列表
print("扩展后的列表:",list1)
输出结果：
扩展后的列表:['Google','Runoob','Taobao',0,1,2,3,4]
list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
list1=['Google','Runoob','Taobao'] print('Runoob索引值为',list1.index('Runoob')) print('Taobao索引值为',list1.index('Taobao'))
输出结果：
Runoob 索引值为 1
Taobao 索引值为 2
list.insert(index,obj)：将对象插入列表
list1=['Google','Runoob','Taobao'] list1.insert(1,'Baidu') print('列表插入元素后为:',list1)
输出结果：
列表插入元素后为:['Google','Baidu','Runoob','Taobao']
list.pop([index=-1])：移除列表中一个元素(默认最后一个元素)，并且返回该元素的值
list1=['Google','Runoob','Taobao'] list1.pop() print("列表现在为:",list1) list1.pop(1) print("列表现在为:",list1)
输出结果：
列表现在为:['Google','Runoob']
列表现在为:['Google']
list.remove(obj) ：移除列表中某个值的第一个匹配项
list1=['Google','Runoob','Taobao','Baidu'] list1.remove('Taobao') print("列表现在为:",list1) list1.remove('Baidu') print("列表现在为:",list1)
输出结果：
列表现在为:['Google','Runoob','Baidu']
列表现在为:['Google','Runoob']
list.reverse()：反转列表中元素
list1=['Google','Runoob','Taobao','Baidu']
list1.reverse()
print("列表反转后:",list1)
输出结果：
列表反转后:['Baidu','Taobao','Runoob','Google']
list.sort(key=None,reverse=False)：对原列表进行排序
【示例1】
aList=['Google','Runoob','Taobao', 'Facebook']
aList.sort()
print("List:",aList)
输出结果：
List:['Facebook','Google','Runoob','Taobao']
【示例2】
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
# 列表
random=[(2,2),(3,4),(4,1),(1,3)]
# 指定第二个元素排序
#等同于random.sort(key=lambda x:x[1])
random.sort(key=takeSecond)
# 输出列表
print('排序列表:',random)
输出结果：
排序列表:[(4,1),(2,2),(1,3),(3,4)]
list.clear() ：清空列表
list1=['Google','Runoob','Taobao','Baidu'] list1.clear() print ("列表清空后: ", list1)
输出结果：
列表清空后: []
list.copy() ：复制列表
list1=['Google','Runoob','Taobao','Baidu']
list2=list1.copy() list2[1]='douyin' print("list1列表:",list1) print("list2列表:",list2)
输出结果：
list1列表:['Google','Runoob','Taobao','Baidu']
list2列表:['Google','douyin','Taobao', 'Baidu']
四、元组内置函数
1.Python元组包含以下内置函数:
len(tuple) ：计算元组元素个数
>>> tuple1=('Google','Runoob','Taobao')
>>> len(tuple1)
3
max(tuple)：返回元组中元素最大值
>>> tuple2=('5','4','8')
>>> max(tuple2)
'8'
min(tuple):返回元组中元素最小值
>>> tuple2=('5','4','8')
>>> min(tuple2)
'4'
tuple(iterable)：将可迭代系列转换为元组
>>> list1=['Google','Taobao','Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google','Taobao','Runoob','Baidu')
2.元组不可变是指元组所指向的内存中的内容不可变。
>>> tup=('r','u','n','o','o','b') >>> tup[0]='g' # 不支持修改元素 Traceback(most recent call last): File"",line1,in TypeError:'tuple'object does not support item assignment
>>> id(tup) # 查看内存地址 4440687904 >>> tup=(1,2,3) >>> id(tup) 4441088800 # 内存地址已改变
从以上示例可以看出重新赋值的元组 tup，绑定到新的对象而不是修改原来的
对象。
五、字典函数
1.字典内置函数&方法
(1)Python字典包含了以下内置函数：
len(dict)：计算字典元素个数，即键的总数
>>> tinydict={'Name':'Runoob','Age':7,'Class':'First'}
>>> len(tinydict)
3
str(dict)：输出字典，可以打印的字符串表示
>>> tinydict={'Name':'Runoob','Age':7,'Class':'First'}
>>> str(tinydict)
"{'Name':'Runoob','Class':'First','Age':7}"
type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型
>>> tinydict={'Name':'Runoob','Age':7,'Class':'First'}
>>> type(tinydict)

(2)Python字典包含了以下内置方法：
dict.clear()：删除字典内所有元素
tinydict={'Name':'Zara','Age':7} print("字典长度:%d" % len(tinydict)) tinydict.clear() print("字典删除后长度:%d" % len(tinydict))
输出结果：
字典长度:2
字典删除后长度:0
dict.copy( )：返回一个字典的浅复制
dict1={'Name':'Runoob','Age':7,'Class':'First'}
dict2=dict1.copy()
print("新复制的字典为:",dict2)
输出结果：
新复制的字典为:{'Name':'Runoob','Age':7,'Class':'First'}
2.直接赋值和copy的区别
dict1={'user':'runoob','num':[1,2,3]}
dict2=dict1 #浅拷贝:引用对象
#浅拷贝:深拷贝父对象，子对象不拷贝，子对象是引用
dict3=dict1.copy()
#修改data数据
dict1['user']='root'
dict1['num'].remove(1)
print(dict1)
print(dict2)
print(dict3)
实例中dict2其实是dict1的引用(别名)，所以输出结果都是一致的，dict3父对象进行了深拷贝，不会随dict1修改而修改，子对象是浅拷贝所以随dict1的修改而修改。
输出结果：
{'user':'root','num':[2,3]}
{'user':'root','num':[2,3]}
{'user':'runoob','num':[2,3]}
dict.fromkeys( )：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
seq=('name','age','sex')
tinydict=dict.fromkeys(seq)
print("新的字典为:%s"%str(tinydict))
tinydict=dict.fromkeys(seq,10)
print("新的字典为:%s"%str(tinydict))
输出结果：
新的字典为:{'name':None,'age':None,'sex':None}
新的字典为:'name':10,{'age':10,'sex':10}
dict.get(key,default=None)：返回指定键的值，如果键不在字典中，返回default设置的默认值
tinydict={'Name':'Runoob','Age':27} print("Age:",tinydict.get('Age')) #没有设置Sex,也没有设置默认的值,输出None print("Sex:",tinydict.get('Sex')) #没有设置Salary,输出默认的值0.0 print('Salary:',tinydict.get('Salary',0.0))
输出结果：
Age:27
Sex:None
Salary:0.0
3.get() 方法 和 dict[key] 访问元素区别
get(key)方法在 key(键)不在字典中时，可以返回默认值None或者设置的默认值。
dict[key]在 key(键)不在字典中时，会触发KeyError异常。
key in dict ：如果键在字典dict里返回True，否则返回False
thisdict={'Name':'Runoob','Age':7}
# 检测键Age是否存在
if 'Age' in thisdict:
print("键Age存在")
else:
print("键Age不存在")
# 检测键Sex是否存在
if 'Sex' in thisdict:
print("键Sex存在")
else:
print("键Sex不存在")
#使用not in,检测键Age是否存在
if 'Age' not in thisdict:
print("键Age不存在")
else:
print("键Age存在")
输出结果：
键Age存在
键Sex不存在
键Age存在
dict.items( )：以列表返回键值对视图对象
tinydict={'Name':'Runoob','Age':7}
print("Value:%s"%tinydict.items())
输出结果：
Value:dict_items([('Name','Runoob'),('Age',7)])
dict.keys()：返回键视图对象
>>> phone_book={'sam':'1234','tom':'5678'} #创建字典
>>> phone_book.keys() #调用keys方法
dict_keys(['sam','tom'])
>>> list(phone_book.keys()) #调用list函数
['sam','tom']
dict.setdefault(key,default=None)：和get()类似，但如果键不存在于字典中，将会添加键并将值设为default
tinydict={'Name':'Runoob','Age':7}
print("Age键的值为:%s"%tinydict.setdefault('Age',None))
print("Sex键的值为:%s"%tinydict.setdefault('Sex',None))
print("新字典为:",tinydict)
输出结果：
Age键的值为:7
Sex键的值为:None
新字典为:{'Age':7,'Name':'Runoob','Sex':None}
dict.update(dict2)：把字典dict2的键/值对更新到dict里
tinydict={'Name':'Runoob','Age':7}
tinydict2={'Sex':'female'}
tinydict.update(tinydict2)
print("更新字典tinydict:",tinydict)
输出结果：
更新字典tinydict:{'Name':'Runoob','Age':7,'Sex':'female'}
dict.values()：返回值视图对象
>>> dishes={'eggs':2,'sausage':1,'bacon':1, 'spam':500} >>> keys=dishes.keys() >>> values=dishes.values() >>> #迭代 >>> n=0 >>> for val in values: ... n += val >>> print(n) 504
>>> #keys和values以相同顺序(插入顺序)进行迭代 >>> list(keys) #使用list()转换为列表 ['eggs','sausage','bacon','spam'] >>> list(values) [2,1,1,500]
>>> #视图对象是动态的，受字典变化的影响，以下删除#字典的key，视图对象转为列表后也跟着变化
>>> del dishes['eggs'] >>> del dishes['sausage'] >>> list(values) [1,500] >>> #相同两个dict.values()比较返回都是False >>> d={'a':1} >>> d.values()==d.values() False
pop(key[,default]) ：删除字典key(键)所对应的值，返回被删除的值
【示例1】
site={'name':'菜鸟教程','alexa':10000,'url':'www.'} element=site.pop('name') print('删除的元素为:',element) print('字典为:',site)
输出结果：
删除的元素为:菜鸟教程
字典为:{'alexa':10000,'url':'www.'}
【示例2】如果删除的键不存在会触发异常，可以设置默认值来避免异常。
site={'name':'菜鸟教程','alexa':10000,'url':'www.'} element=site.pop('nickname','不存在的key') print('删除的元素为:',element) print('字典为:',site)
输出结果：
删除的元素为:不存在的key
字典为:{'name':'菜鸟教程','alexa':10000, 'url':'www.'}
popitem()：返回并删除字典中的最后一对键和值
site={'name':'菜鸟教程','alexa':10000,'url':'www.'} #('url':'www.')最后插入会被删除 result=site.popitem() print('返回值=',result) print('site=',site) #插入新元素
site['nickname']='Runoob' print('site=',site)
#现在('nickname','Runoob')是最后插入的元素 result=site.popitem() print('返回值=',result) print('site=',site)
输出结果：
返回值=('url','www.')
site={'name':'菜鸟教程','alexa':10000}
site={'name':'菜鸟教程','alexa':10000,'nickname':'Runoob'}
返回值=('nickname','Runoob')
site={'name':'菜鸟教程','alexa':10000}
六、集合函数
1.集合的基本操作
(1)添加元素：
s.add(x)：将元素x添加到集合s中，如果元素已存在，则不进行任何操作
>>> thisset=set(("Google","Runoob","Taobao")) >>> thisset.add("Facebook") >>> print(thisset) {'Taobao','Facebook','Google','Runoob'}
s.update(x)：也可以添加元素，且参数可以是列表，元组，字典等，x可以有多个，用逗号分开
>>> thisset=set(("Google","Runoob","Taobao")) >>> thisset.update({1,3}) >>> print(thisset) #结果不唯一 {1,3,'Taobao','Google','Runoob'} >>> thisset.update([1,4],[5,6]) >>> print(thisset) #结果不唯一 {1,3,4,'Taobao',5,6,'Google','Runoob'}
(2)移除元素：
s.remove(x)：将元素x从集合s中移除，如果元素不存在，则会发生错误
>>> thisset=set(("Google","Runoob","Taobao")) >>> thisset.remove("Taobao") >>> print(thisset) {'Google','Runoob'}
#不存在会发生错误 >>> thisset.remove(“Facebook”) Traceback (most recent call last): File"",line 1,in KeyError:'Facebook'
s.discard(x)：移除集合中的元素，且如果元素s不存在x，不会发生错误
>>> thisset=set(("Google","Runoob","Taobao")) >>> thisset.discard("Facebook") >>> print(thisset) {'Google','Runoob','Taobao'}
s.pop()：设置随机删除集合中的一个元素
thisset=set(("Google","Runoob","Taobao","Facebook")) x=thisset.pop() print(x)
输出结果：
Runoob #多次执行测试结果都不一样
set集合的pop方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
(3)计算集合元素个数：
len(s)：计算集合s元素个数
>>> thisset=set(("Google","Runoob","Taobao")) >>> len(thisset) 3
(4)清空集合：
s.clear()：清空集合s
>>> thisset=set(("Google","Runoob","Taobao")) >>> thisset.clear() >>> print(thisset) set()
(5)判断元素是否在集合中存在：
x in s：判断元素x是否在集合s中，存在返回True，不存在返回False
>>> thisset=set(("Google","Runoob","Taobao")) >>> "Runoob" in thisset True >>> "Facebook" in thisset False
2.集合内置方法完整列表
add()：为集合添加元素
fruits={"apple","banana","cherry"}
fruits.add("orange")
print(fruits) #输出不唯一
{'apple','banana','orange','cherry'}
输出结果：
已存在的元素，则不执行添加操作：
fruits={"apple","banana","cherry"}
fruits.add("apple")
print(fruits)
输出结果：
{'apple','banana','cherry'}
clear()：移除集合中的所有元素
fruits={"apple","banana","cherry"}
fruits.clear()
print(fruits)
输出结果：
set()
copy()：拷贝一个集合
sites={"Google","Runoob","Taobao"}
x=sites.copy()
print(x)
输出结果：
{'Google','Runoob','Taobao'}
difference()：返回多个集合的差集
x={"apple","banana","cherry"}
y={"google","microsoft","apple"}
z=x.difference(y)
print(z)
输出结果：
{'cherry','banana'}
difference_update()：移除集合中的元素，该元素在指定的集合也存在
x={"apple","banana","cherry"}
y={"google","microsoft","apple"}
x.difference_update(y)
print(x)
输出结果：
{'cherry','banana'}
discard()：删除集合中指定的元素
fruits={"apple","banana","cherry"}
fruits.discard("banana")
print(fruits)
输出结果：
{'cherry','apple'}
intersection()：保留集合的交集
【示例1】返回一个新集合，该集合的元素既包含在集合x又包含在集合y中：intersection(set)，set参数可以不是集合，可以是任何序列。
x={"apple","banana","cherry"}
y={"google","runoob","apple"}
z=x.intersection(y)
print(z)
输出结果：
{'apple'}
【示例2】计算多个集合的交集。
x={"a","b","c"}
y={"c","d","e"}
z={"f","g","c"}
result=x.intersection(y,z)
print(result)
输出结果：
{'c'}
intersection_update()：保留集合的交集
【示例1】移除x集合中不存在于y集合中的元素。
x={"apple","banana","cherry"}
#y集合不包含banana和cherry,被移除
y={"google","runoob","apple"}
x.intersection_update(y)
print(x)
输出结果：
{'apple'}
【示例2】计算多个集合的交集。
x={"a","b","c"}
y={"c","d","e"}
z={"f","g","c"}
x.intersection_update(y,z)
print(x)
输出结果：
{'c'}
isdisjoint()：判断两个集合是否包含相同的元素，如果没有返回True，否则返回False
【示例1】判断集合y中是否有包含集合x的元素，如果不包含返回True。
x={"apple","banana","cherry"}
y={"google","runoob","facebook"}
z=x.isdisjoint(y)
print(z)
输出结果：
True
issubset()：判断指定集合是否为该方法参数集合的子集
用于判断集合的所有元素是否都包含在指定集合中，如果是则返回True，否则返回 False。
【示例】如果没有全部包含返回False。
x={"a","b","c"}
y={"f","e","d","c","b"}
z=x.issubset(y)
print(z)
输出结果：
False
issuperset()：判断该方法的参数集合是否为指定集合的子集
用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回True，否则返回False。
【示例】如果全部包含返回True。
x={"f","e","d","c","b","a"}
y={"a","b","c"}
z=x.issuperset(y)
print(z)
输出结果：
True
pop()：随机移除元素
【示例1】
fruits={"apple","banana","cherry"}
x=fruits.pop()
print(x)
输出结果：
banana #不唯一
【示例2】
fruits={"apple","banana","cherry"}
fruits.pop()
print(fruits)
输出结果：
{'apple','banana'}
remove()：移除指定元素
该方法不同于discard()方法，因为该方法在移除一个不存在的元素时会报错，而discard()方法不会。
fruits={"apple","banana","cherry"}
fruits.remove("banana")
print(fruits)
输出结果：
{'cherry','apple'}
symmetric_difference()：返回两个集合中不重复的元素集合。即返回两个集合组成的新集合，且移除两个集合的重复元素
x={"apple","banana","cherry"}
y={"google","runoob","apple"}
z=x.symmetric_difference(y)
print(z)
输出结果：
{'google','cherry','banana','runoob'}
symmetric_difference_update()：移除当前集合中在另外一个指定集合的相同元素，并将另外一个指定集合中不同的元素插入到当前集合中
【示例】在原始集合x中移除与y 集合中的重复元素，并将不重复的元素插入到集合 x 中：
x={"apple","banana","cherry"}
y={"google","runoob","apple"}
x.symmetric_difference_update(y)
print(x)
输出结果：
{'google','cherry','banana','runoob'}
union()：返回两个集合的并集
【示例1】返回一个由两个集合合并的新集合，且重复元素只会出现一次。
x={"apple","banana","cherry"}
y={"google","runoob","apple"}
z=x.union(y)
print(z)
输出结果：
{'cherry','runoob','google','banana','apple'}
【示例2】合并多个集合。
x={"a","b","c"}
y={"f","d","a"}
z={"c","d","e"}
result=x.union(y,z)
print(result)
输出结果：
{'c','d','f','e','b','a'}
update()：给指定集合添加另一个集合的元素，重复元素只会出现一次
x={"apple","banana","cherry"}
y={"google","runoob","apple"}
x.update(y)
print(x)
输出结果：
{'banana','apple','google','runoob','cherry'}
len()：计算集合元素个数，返回对象长度
my_set={5,10,15,20}
#len(my_set)返回集合my_set中的唯一元素数量
length=len(my_set)
print(length)
输出结果：
4
【参考答案】C
【答题分析】Python中导入模块有三种方式： 1.import 模块名 [as 别名]； 2.from 模块名 import 对象名 [as 别名]； 3.from 模块名 import *。
例8　(2023年真题)下列不能导入math库的是(　　)
A.import math B.from math import *
C.include math D.import math as m
【参考答案】[1,2,3,2]
【答题分析】列表的pop()方法可指定元素的索引值来移除列表中的某个元素；无参数时默认是最后一个元素。
例9　(2023年真题)在Python语言编程中，已知x=[1,2,3,2,3]，执行语句x.pop()之后，x的值为　　　　。
【参考答案】9
【答题分析】values()方法是获取字典中所有的值并返回可迭代对象。
例10　(2023年真题)在Python语言编程中，已知x={1:2,2:3,3:4}，那么表达式sum(x.values())的值为　　　　。
【参考答案】D
【答题分析】pow(1.5, 3)=1.53=1.5×1.5×1.5=3.375，round(3.375,1)表示四舍五入保留1位小数，所以向前进位：3.375→3.4。
例11　(2024年真题)round(pow(1.5,3),1)的运行结果是(　　)
A.3.3 B.3.5
C.3.0 D.3.4(共7张PPT)
第三部分　计算机编程基础
——Python语言
Python3常见异常与警告类型
1.ZeroDivisionError——除或取模为零
2.ValueError——传入无效的参数
3.AssertionError——断言语句失败
4.StopIteration——迭代器耗尽
5.IndexError——序列中没有此索引(index)
6.IndentationError——缩进错误
7.OSError——输入/输出操作失败
8.ImportError——导入模块/对象失败
9.NameError——未声明/初始化对象(没有属性)
10.AttributeError——对象属性不存在
11.GeneratorExit——生成器(generator)发生异常来通知退出
12.TypeError——对类型无效的操作
13.KeyboardInterrupt——用户中断执行(通常是按下Ctrl+C)
14.OverflowError——数值运算超出最大限制
15.TimeoutError——超时
16.BaseException——所有异常的基类
17.SystemExit——解释器请求退出
18.Exception——常规错误的基类
19.FileExistsError——创建已存在的文件
20.ArithmeticError——所有数值计算错误的基类
21.EOFError——没有内建输入，到达EOF 标记
22.FileNotFoundError——文件未找到
23.LookupError——无效数据查询的基类
24.KeyError——映射中没有这个键
25.MemoryError——内存溢出错误(对于Python 解释器不是致命的)
26.UnboundLocalError——访问未初始化的本地变量
27.RuntimeError——一般的运行时错误
28.NotImplementedError——尚未实现的方法
29.SyntaxError ——Python语法错误
30.TabError——Tab 和空格混用
31.SystemError——一般的解释器系统错误
32.UnicodeError——Unicode 相关的错误
33.UnicodeDecodeError——Unicode 解码时的错误
34.UnicodeEncodeError——Unicode 编码时错误
35.UnicodeTranslateError——Unicode 转换时错误
以下为警告类型
1.Warning——警告的基类
2.DeprecationWarning——关于被弃用的语法或功能的警告
3.FutureWarning——关于构造未来语义会有改变的警告
4.ImportWarning——关于导入模块时非致命问题的警告
5.PendingDeprecationWarning——关于特性将会被废弃的警告
6.RuntimeWarning——可疑的运行时行为(runtime behavior)的警告
7.SyntaxWarning——可疑的语法的警告
8.UserWarning——用户代码生成的警告(共128张PPT)
第三部分　计算机编程基础
——Python语言
第四章　面向对象程序设计基础
考点十二~十八
考
纲
要
求 一、基本概念
1.理解面向对象程序设计的基本特征
2.理解对象与类
3.掌握类的三大特性：继承、封装、多态
4.掌握事件、方法、属性
二、Tkinter库
1.掌握Button按钮
2.掌握Checkbutton控件
3.掌握Entry控件
4.掌握Label控件 5.掌握Listbox控件
6.掌握Radiobutton控件
7.掌握Text控件
8.掌握Message控件
三、面向对象程序设计
1.掌握事件与事件响应(仅限于鼠标事件和键盘事件)
2.掌握控件布局
3.综合应用简单GUI界面程序设计
命
题
趋
势 1.要求学生理解面向对象程序设计的基本概念，能够综合应用类、方法、属性等进行程序设计
2.掌握Tkinter常用控件(Button、Checkbutton、Entry、Label、Listbox、Radiobutton、Text、Message)，能够熟练使用常用控件完成程序设计
3.考查学生对事件响应(鼠标、键盘)、控件布局以及综合运用面向对象思想设计简单GUI界面程序的能力。
4.考查学生对面向对象核心概念的理解与记忆，以及将Tkinter控件与事件响应相结合、在面向对象框架下进行模块化编程并完成简单GUI界面设计的能力
考
向
分
析 【考查内容】
面向对象程序设计的基本特征，继承、封装、多态，Tkinter库，事件与事件响应，控件布局，简单GUI界面程序设计
【考查题型】
填空题、单项选择题和综合应用题
【考查分值】
一般为12~20分
单选按钮可以使用鼠标单击选取此选项，设计一组选项按钮与同一个变量绑定，通过各按钮值的设定可以实现一次只能有一个选项被选取(常用属性见表4-6)。
Radiobutton()方法语法格式如下：
Radiobutton(父对象,options,……)
表4-6　选项按钮控件的常用属性
属性名 功能 值的类型
text 按钮旁显示的文字，通常用于说明按钮的功能 字符
属性名 功能 值的类型
value 选项按钮的值，用于区分所选取的选项按钮 数值或字符
variable 单选按钮索引变量，通过变量的值确定哪个单选按钮被选中。一组单选按钮使用同一个索引变量 数值或字符
command 单选按钮选中时执行的方法 方法名
bg 背景色 颜色名称或十六
进制色彩方案
fg 前景色 颜色名称或十六
进制色彩方案
属性名 功能 值的类型
state 设置组件状态，默认为NORMAL，可设置为DISABLED禁用使用 指定值
height 高度 数值
width 宽度 数值
font 显示的文本字体等 字符串或元组
padx 文本左右两侧的空格数(默认为1) 数值
pady 文本上下两侧的空格数(默认为1) 数值
【示例】
方法一：
from tkinter import *
def xb():
t=x.get()
if t==1:
a1.config(text="你是男生")
else:
a1.config(text="你是女生")
root=Tk()
root.title("选项按钮")
root.geometry("300x300")
a1=Label(root,text="这是默认值，尚未选择",font="宋体,20")
a1.pack(pady=10)
x=IntVar()
x.set(0)
b1=Radiobutton(root,text=“男生”,variable=x,value=1,command=xb)
b1.pack(pady=10)
b2=Radiobutton(root,text="女生",variable=x,value=2,command=xb)
b2.pack(pady=10)
root.mainloop()
方法二：
from tkinter import *
def xb():
a1.config(text="你是"+x.get())
root=Tk()
root.title("选项按钮")
root.geometry("300x300")
a1=Label(root,text="这是默认值，尚未选择",font="宋体,20")
a1.pack(pady=10)
x=StringVar()
x.set("未选择")
b1=Radiobutton(root,text="男生",variable=x,value="男生",
command=xb)
b1.pack(pady=10)
b2=Radiobutton(root,text="女生",variable=x,value="女生",
command=xb)
b2.pack(pady=10)
root.mainloop()
运行结果：
与单选按钮相对的是复选按钮(Checkbutton)。选项之间没有互斥作用，可以一次选择多个，每一个复选按钮都需要与一个变量绑定，且每一个复选按钮绑定的变量都不同(常用属性见4-7)。
Checkbutton()方法语法格式如下：
Checkbutton(父对象,options,……)
属性名 功能 值的类型
text 按钮旁显示的文字，通常用于说明按钮的功能 字符
variable 按钮索引变量，通过变量的值确定哪个按钮被选中。不同的按钮使用应使用不同的索引变量 数值或字符
onvalue 复选按钮选中(有效)时变量的值，默认为1 数值或字符
offvalue 复选按钮未选中(无效)时变量的值，默认为0 数值或字符
command 单选按钮选中时执行的方法 方法名
bg 背景色 颜色名称或者十六进制色彩方案
表4-7　复选按钮控件的常用属性
属性名 功能 值的类型
fg 前景色 颜色名称或者十六进制色彩方案
state 设置组件状态，默认为NORMAL，可设置为DISABLED禁用使用 指定值
height 高度 数值
width 宽度 数值
font 显示的文本字体等 字符串或元组
padx 文本左右两侧的空格数(默认为1) 数值
pady 文本上下两侧的空格数(默认为1) 数值
【示例】
from tkinter import *
def dayin():
num1=var1.get()
num2=var2.get()
num3=var3.get()
print("你喜欢的运动有：",end='')
if num1==1:
print("美式足球",end='、')
if num2==1:
print("棒球",end='、')
if num3==1:
print("篮球",end='、')
root=Tk()
root.title("复选按钮")
root.geometry("300x300")
la=Label(root,text="选择你喜欢的运动",fg="blue",bg="lightyellow",
width=30)
la.pack(pady=5)
var1=IntVar()
cbt=Checkbutton(root,text="美式足球",variable=var1)
cbt.pack(pady=5)
var2=IntVar()
cbt2=Checkbutton(root,text="棒球",variable=var2)
cbt2.pack(pady=5)
var3=IntVar()
cbt3=Checkbutton(root,text="篮球",variable=var3)
cbt3.pack(pady=5)
btn=Button(root,text="确定，打印",width=20,command=dayin)
btn.pack(pady=5)
root.mainloop()
运行结果：
打印结果：
一、列表框控件的格式及常用属性
列表框(Listbox)控件是一个选项列表，用户可以从中选择选项(常用属性见表4-8)。
Listbox()方法语法格式如下：
Listbox(父对象,options,……)
属性名 功能 值的类型
bg 背景色 颜色名称或者十六进制色彩方案
fg 前景色 颜色名称或者十六进制色彩方案
height 高度 数值
width 宽度 数值
font 显示的文本字体等 字符串或元组
表4-8　列表框控件的常用属性
【示例】
from tkinter import *
root=Tk()
root.title("建立列表框")
root.geometry('300x300')
lb1=Listbox(root) #创建列表框1
lb1.pack(side=LEFT,padx=10,pady=10)
lb2=Listbox(root,height=5) #创建列表框2
lb2.pack(anchor=N,side=LEFT,padx=10,pady=10)
root.mainloop()
运行结果：
二、列表框的常用操作方法
1.insert()方法
可以使用insert()方法为列表框建立列表选项，方法格式如下：
insert(index,s)
【示例】
from tkinter import *
root=Tk()
root.title("建立列表框")
root.geometry('300x300')
lb1=Listbox(root)
lb1.pack(padx=10,pady=10)
lb1.insert(0,"第一项")
lb1.insert(END,"第三项")
lb1.insert(1,"第二项")
root.mainloop()
运行结果：
2.delete()方法
delete()方法内含有一个参数，表示删除这个索引项；内含有两个参数时，表示删除区间选项，第一个参数表示起始索引项，第二个参数表示结束索引项。如果要删除列表框的所有选项可以使用delete(0,END)方法。
【示例】
from tkinter import *
def yi():
lb1.delete(0)
def er():
lb1.delete(0,1)
def qk():
lb1.delete(0,END)
root=Tk()
root.title("建立列表框")
root.geometry('300x300')
lb1=Listbox(root)
lb1.pack(padx=10,pady=5)
lb1.insert(0,"第一项")
lb1.insert(END,"第三项")
lb1.insert(1,"第二项")
anniu1=Button(root,text="删除第一项",command=yi)
anniu1.pack(padx=10,pady=5)
anniu2=Button(root,text="删除前2项",command=er)
anniu2.pack(padx=10,pady=5)
anniu3=Button(root,text="清空列表",command=qk)
anniu3.pack(padx=10,pady=5)
root.mainloop()
运行结果：
3.get()方法
get()方法内含有一个参数，表示传回这个索引项的内容；内含有两个参数时，表示传回区间选项的内容，这时传回的值以元组方式传回。第一个参数表示起始索引项，第二个参数表示结束索引项。如果要传回列表框的所有选项可以使用get(0,END)方法。
【示例】
from tkinter import *
def yi():
print(lb1.get(0))
def er():
print(lb1.get(0,1))
def qb():
print(lb1.get(0,END))
root=Tk()
root.title("建立列表框")
root.geometry('300x300')
lb1=Listbox(root) #创建列表框
lb1.pack(padx=10,pady=5)
lb1.insert(0,"第一项")
lb1.insert(END,"第三项")
lb1.insert(1,"第二项")
anniu1=Button(root,text="打印第一项",command=yi)
anniu1.pack(padx=10,pady=5)
anniu2=Button(root,text="打印前2项",command=er)
anniu2.pack(padx=10,pady=5)
anniu3=Button(root,text="打印全部",command=qb)
anniu3.pack(padx=10,pady=5)
root.mainloop()
运行结果：
当单击第二个按钮时的打印结果：
4.size()方法
size()方法可以传回列表的选项数量，常用于统计列表的总项目的多少。
【示例】
from tkinter import *
def yi():
print('该列表的项目数：',lb1.size())
root=Tk()
root.title("建立列表框")
root.geometry('300x300')
lb1=Listbox(root)
lb1.pack(padx=10,pady=5)
li=["李明","王亮","刘德兰","刘强","赵大标"]
for i in li:
lb1.insert(END,i)
anniu1=Button(root,text="打印列表项目总数",command=yi)
anniu1.pack(padx=10,pady=5)
root.mainloop()
运行结果：
打印结果：
该列表的项目数：5
5.curselection()方法
curselection()方法可以传回列表所选取项的索引以元组方式返回值，常用对列表选择项进行操作。
【示例】
from tkinter import *
def yi():
print("选中的项目是：",lb1.curselection())
print("该项的内容是：",lb1.get(lb1.curselection()))
root=Tk()
root.title("建立列表框")
root.geometry('300x300')
lb1=Listbox(root) #创建列表框1
lb1.pack(padx=10，pady=5)
li=["李明","王亮","刘德兰","刘强","赵大标"]
for i in li:
lb1.insert(END,i)
anniu1=Button(root,text="打印选中项",command=yi)
anniu1.pack(padx=10,pady=5)
root.mainloop()
运行结果：
单击按钮时输出如下结果：
一、消息(Message)控件
很多时候需要给用户发送消息，一般内容较多，如帮助信息等。消息(Message)控件提供了显示多行文本的方法，且可以设置字体和颜色(常见属性见表4-9)。
Message()方法语法格式如下：
Message(父对象,options,……)
属性名 功能 值的类型
text 显示内容，多行文字使用“\n”换行 字符
textvariable 显示的内容与变量绑定(如果设置该参数text属性设置将无意义) 字符型变量
anchor 标签文字的对齐方式，共有9种对齐方式，默认的是中部居中对齐 字符
bg 标签背景色 颜色名称或者十六进制色彩方案
表4-9　Message控件的常用属性
属性名 功能 值的类型
fg 标签前景色 颜色名称或者十六进制色彩方案
height 高度 数值
width 宽度 数值
font 显示的文本字体等 字符串或元组
padx 文本左右两侧的空格数(默认为1) 数值
pady 文本上下两侧的空格数(默认为1) 数值
【示例】
from tkinter import *
root=Tk()
root.title("短消息")
root.geometry("300x300")
m1=Message(root,text="这是\n一个短消息",fg="blue",bg="yellow",
width=100)
m1.pack(pady=5)
root.mainloop()
运行结果：
二、消息框(messagebox)控件
消息框(messagebox)控件用于弹出提示框向用户提供信息，或让用户选择下一步如何操作，消息框可以实现人机交互。消息框是放在Tkinter库内的message模块下，所以若要使用消息框需要使用模块导入语句“from tkinter import messagebox”引入模块。消息框包括8种类型，但创建格式基本一致。
messagebox()方法语法格式如下：
messagebox.<类型>(title,message,options)
“title”表示弹出消息框的标题，“message”表示弹出消息框内的提示内容，“options”是选择性参数我们一般不设置其值。
1.一般提示消息框
语法格式如下：
【示例】
messagebox.showinfo(title,message,options)
from tkinter import *
from tkinter import messagebox
def ms():
#弹出消息框
messagebox.showinfo('问候框','同学们，早安！！！')
root=Tk()
root.title("弹出消息窗口")
root.geometry("300x300")
bt=Button(root,text='早安',command=ms)
bt.pack(padx=10,pady=10)
root.mainloop()
运行结果：
2.警告消息框
语法格式如下：
【示例】
messagebox.showwarning(title,message,options)
from tkinter import *
from tkinter import messagebox
def ms():
messagebox.showwarning('警告','小心病毒！！！')
root=Tk()
root.title("弹出消息窗口")
root.geometry("300x300")
bt=Button(root,text='确定',command=ms)
bt.pack(padx=10,pady=10)
root.mainloop()
运行结果：
3.错误提示消息框
语法格式如下：
messagebox.showerror(title,message,options)
【示例】
……
messagebox.showerror('错误','数据读取错误！！！')
……
运行结果：
4.显示询问消息框
语法格式如下：
【示例】
messagebox.askquestion(title,message,options)
……
messagebox.askquestion('离开提示','确定要离开？')
……
运行结果：
在弹出消息框中若单击“是”按钮会传回“yes”，若单击“否”按钮会传回“no”。
5.显示确定或取消消息框
语法格式如下：
【示例】
messagebox.askokcancel(title,message,options)
……
messagebox.askokcancel('离开提示','确定要离开？')
……
运行结果：
在弹出消息框中若单击“确定”按钮会传回True，若单击“取消”按钮会传回False。
6.显示“是或否”消息框
语法格式如下：
【示例】
messagebox.askyesno(title,message,options)
……
messagebox.askyesno('离开提示','确定要离开？')
……
运行结果：
该消息框与显示询问消息框：类似弹出的消息框都显示“是”“否”，但是该消息框中若单击“是”按钮会传回True，若单击“否”按钮会传回False。
7.显示“是或否或取消”消息框
语法格式如下：
【示例】
messagebox.askyesnocancel(title,message,options)
……
messagebox.askyesnocancel('离开提示','确定要离开？')
……
运行结果：
在弹出消息框中若单击“是”按钮会传回True，若单击“否”按钮会传回False，若单击“取消”按钮会传回None。
8.显示“重试或取消”消息框
语法格式如下：
【示例】
messagebox.askretrycancel(title,message,options)
……
messagebox.askretrycancel('警告','程序安装错误请重试！')
……
运行结果：
在弹出消息框中若单击“重试”按钮会传回True，若单击“取消”按钮会传回False。
一、Text控件的格式和常用属性
文字区域(Text)控件是用来接收或显示用户输入的多行内容，类似Entry控件的扩充(常用属性见表4-10)。Text()方法语法格式如下：
Text(父对象,options,……)
属性名 功能 值的类型
bg 标签背景色 颜色名称或者十六进制色彩方案
fg 标签前景色 颜色名称或者十六进制色彩方案
height 高度 数值
width 宽度 数值
font 显示的文本字体等 字符串或元组
state 设置组件状态，默认为NORMAL，可设置为DISABLED禁用使用 指定值
表4-10 Text控件的常用属性
二、Text控件的常用方法
1.insert()方法
使用insert()方法可以把字符串插入到指定的索引位置，它的使用格式如下：
若是位置参数index使用END或者INSERT，表示将字符串插入到末尾和光标位置。
insert(index,s)
【示例】
from tkinter import *
def cr():
li=["李明","王亮","刘德兰","刘强","赵大标"]
for i in li:
text.insert(END,i+'\n')
root=Tk()
root.title("文字区域")
root.geometry('300x400')
text=Text(root) #创建文字区域
text.pack(padx=10,pady=5)
anniu1=Button(root,text="插入",command=cr)
anniu1.pack(padx=10,pady=5)
root.mainloop()
运行结果：
insert(index，s)中index可用行(line)从1开始计数、列(column)从0开始计数，中间用点分隔来表示。如：insert(1.2,"你好")表示在第一行的第3位插入“你好”。
2.get()方法
使用get(startindex，endindex)方法可以获取Text中的文字，startindex表示开始索引，endindex表示结束索引。可用行(line)从1开始计数、列(column)从0开始计数，中间用点分隔来表示。使用get()方法也可以获取Text控件目前所选择的文字。在使用Text文字区域时，如果有选取的文字操作发生时，Text控件会将所选文字起始索引放在SEL_FIRST，结束索引放在SEL_LAST，将SEL_FIRST和SEL_LAST作为get()的参数来获取选中的文字。
【示例】
from tkinter import *
def dy():
print(text.get(SEL_FIRST,SEL_LAST))
root=Tk()
root.title("文字区域")
root.geometry('300x400')
text=Text(root) #创建文字区域
text.pack(padx=10,pady=5)
text.insert(1.0,"我爱背景天安门")
anniu1=Button(root,text="打印",command=dy)
anniu1.pack(padx=10,pady=5)
root.mainloop()
运行结果：
选中“天安门”后单击打印，输出结果：
3.delete()方法
使用delete()方法可以删除Text控件中的文字。在使用Text控件时，如果有选取的文字操作发生时，Text控件会将所选文字起始索引放在SEL_FIRST，结束索引放在SEL_LAST，将SEL_FIRST和SEL_LAST作为delete()的参数来删除选中的文字。
格式如下：
delete(INSERT) #删除插入点字符
delete(SEL_FIRST,SEL_LAST) #删除所选文本
删除指定区间文本，按照行、列的形式给出：
delete(startindex,endindex)
delete(1.0,END) #删除所有文字、清空文字区域
【示例】
from tkinter import *
def sc():
text.delete(SEL_FIRST,SEL_LAST)
def qk():
text.delete(1.0,END)
root=Tk()
root.title("文字区域")
root.geometry('300x400')
text=Text(root) #创建文字区域
text.pack(padx=10,pady=5)
text.insert(1.0,"我爱背景天安门\n""天安门前太阳升")
anniu1=Button(root,text="删除选择内容",command=sc)
anniu1.pack(padx=10,pady=5)
anniu2=Button(root,text="清空",command=qk)
anniu2.pack(padx=10,pady=5)
root.mainloop()
运行结果：
事件是对象可以识别的操作，它是预先定义的特定操作。Tkinter通过控件的bind()方法实现事件绑定，通过绑定的事件来调度处理程序完成工作。在Tkinter应用程序中最后一个指令是mainloop()，这个方法是让程序进入事件等待循环，在程序执行过程中Tkinter提供了很多为事件绑定处理程序的机制。
它的语法格式如下：
其中“对象名”表示用户定义的对象，“事件”表示Tkinter能够识别的事件，“handler”表示对应的事件发生时定义的处理程序(用户自定义的方法)。
对象名.bind(事件,handler)
一、鼠标事件
常用鼠标事件如表4-11所示：
表4-11　常用鼠标事件
事件 说明
单击鼠标左键，鼠标光标相对控件位置会被存入事件对象的x和y变量
单击鼠标中键，鼠标光标相对控件位置会被存入事件对象的x和y变量
事件 说明
单击鼠标右键，鼠标光标相对控件位置会被存入事件对象的x和y变量
移动鼠标事件，鼠标光标相对控件位置会被存入事件对象的x和y变量
拖拽，按住鼠标左键再移动鼠标，鼠标光标相对控件位置会被存入事件对象的x和y变量
事件 说明
拖拽，按住鼠标中键再移动鼠标，鼠标光标相对控件位置会被存入事件对象的x和y变量
拖拽，按住鼠标右键再移动鼠标，鼠标光标相对控件位置会被存入事件对象的x和y变量
放开鼠标左键，鼠标光标相对控件位置会被存入事件对象的x和y变量
事件 说明
放开鼠标中键，鼠标光标相对控件位置会被存入事件对象的x和y变量
放开鼠标右键，鼠标光标相对控件位置会被存入事件对象的x和y变量
双击鼠标左键，鼠标光标相对控件位置会被存入事件对象的x和y变量
事件 说明
双击鼠标中键，鼠标光标相对控件位置会被存入事件对象的x和y变量
双击鼠标右键，鼠标光标相对控件位置会被存入事件对象的x和y变量
鼠标光标进入对象
鼠标光标移出对象
【示例】
from tkinter import *
def callback(event):
print("当前鼠标位置",event.x,event.y)
root =Tk()
root.title("鼠标事件绑定")
root.geometry('300x400')
B1=Button(root,text="打印位置")#生成对象
B1.pack(padx=10,pady=10)
B1.bind("",callback)#对象绑定事件
l1=Label(root，text="我是一个标签","我也有单击事件了!")
l1.pack(padx=10,pady=10)
l1.bind("",callback)#对象绑定事件
root.mainloop()
运行结果：
callback(event)方法需要有参数event，event名称可以自定义，这是因为事件会传递事件对象给此事件处理程序。以上程序运行时单击按钮和标签都能触发callback(event)方法，打印出当前鼠标的位置。
二、键盘事件
键盘常用相关的事件如表4-12所示：
表4-12　常用键盘事件
事件 说明
按下键盘字母或数值键触发，该键值会被存储在event对象的char中，用event.char参数可取得该键值
按下Shift+↑键触发事件
按下Alt+↑键触发事件
按下Ctrl+↑键触发事件
按下Esc键触发事件
【示例】
from tkinter import *
from tkinter import messagebox
#自定义方法对应“Esc”键
def key(event):
ret=messagebox.askyesno("是否提示","是/否 ")
if ret:
print("是")
root.destroy()
else:
print("否")
root =Tk()
root.title("键盘事件")
root.geometry('300x200')
#对象事件绑定“Esc”键
root.bind("",key)
lab=Label(root,text="ESC键退出")
lab.pack(padx=10,pady=10)
root.mainloop()
运行结果：
三、取消绑定
对于已经绑定了事件的对象使用取消绑定的方法可以解除事件的绑定。语法格式如下：
对象名.unbind(事件)
【示例】对象名.unbind("")可以解除该对象的鼠标左键事件。
from tkinter import *
def callback(event):
A1.config(text="你好！")
def jc():
A1.config(text="")
#解除对象的事件绑定　
B1.unbind("")
root =Tk()
root.title("解除绑定")
root.geometry('300x200')
A1=Label(root)
A1.pack(padx=10,pady=10)
B1=Button(root,text="你好") #生成对象
B1.pack(padx=10,pady=10)
B1.bind("",callback)
B2=Button(root,text="解除绑定",command=jc)
B2.pack(padx=10,pady=10)
root.mainloop()
运行结果：
在一个容器内同时存在多个对象，我们要对多个对象位置关系进行合理布局，要使多个对象位置关系合理需要调整组件自身的大小，还要设计和其他组件的相对位置。Tkinter库中常用的布局方法有三种。
一、pack()方法
pack()方法以块的方式布局对象，它是最常用的控件布局方法。常用参数如表4-13：
参数 对应值 功能
side TOP 是默认值，表示由上往下排列
BOTTOM 表示由下往上排列
LEFT 表示由左往右排列
RIGHT 表示由右往左排列
表4-13 pack常用参数
参数 对应值 功能
padx 数值 控件与其他控件的水平间距
pady 数值 控件与其他控件的垂直间距
anchor NW，N，NE，W，
CENTER，E，SW，S，SE 水平和垂直的9种对齐方式；默认的是CENTER，表示中部居中对齐
fill X 控件填充满x轴方向
Y 控件填充满y轴方向
BOTH 控件同时填充满x轴方向y轴方向
NONE 默认值，表示控件保持原大小
【示例】
from tkinter import *
root = Tk()
root.title("布局练习程序")
root.geometry("300x300")
label1=Label(root,text="明志科技大学",bg='red')
label2=Label(root,text="长庚大学",bg='yellow')
label3=Label(root,text="长庚科技大学",bg='red')
label4=Label(root,text="长庚大学2",bg='yellow')
label5=Label(root,text="长庚科技大学2",bg='red')
label1.pack(anchor=NW)
label2.pack(side=RIGHT,padx=10,pady=10,fill=Y)
label3.pack(side=LEFT,padx=5,pady=5)
label4.pack(side=RIGHT)
label5.pack(side=BOTTOM)
root.mainloop()
运行结果：
二、grid()方法
grid()是Tkinter网格布局方法，它按照二维表格的形式，将容器划分为若干行和列，组件的位置由行列所在位置确定。常用参数如表4-14所示：
表4-14　grid常用参数
参数 对应值 功能
row 数值 组件所在行，从0开始计数
column 数值 组件所在列，从0开始计数
参数 对应值 功能
rowspan 数值 组件从所在位置起跨的行数，默认值为1
columnspan 数值 组件从所在位置起跨的列数，默认值为1
sticky N，S，W，E 上/下/左/右四种对齐方式也可以使用组合形式。如sticky=N+S表示拉长控件实现实现顶端和低端对齐
padx 数值 控件与其他控件的水平间距
pady 数值 控件与其他控件的垂直间距
【示例】
from tkinter import *
def tj(n):
s=len(acct.get())
acct.insert(s,n)
def js():
try:
t=str(eval(acct.get()))
acct2.delete(0,END)
acct2.insert(0,acct.get()+'='+t)
except:
acct2.delete(0,END)
acct2.insert(0,"表达式错误")
def sc():
acct.delete(0,END)
acct2.delete(0,END)
root=Tk()
root.title("grid布局") #设置窗口标题
acct=Entry(root)
acct.grid(row=0,column=0,columnspan=4)
acct2=Entry(root)
acct2.grid(row=1,column=0,columnspan=4)
ann7=Button(root,text="7",width=3,command=lambda:tj('7'))
ann7.grid(row=2,column=0,padx=5,pady=5)
ann8=Button(root,text="8",width=3,command=lambda:tj('8'))
ann8.grid(row=2,column=1,padx=5，pady=5)
ann9=Button(root,text="9",width=3,command=lambda:tj('9'))
ann9.grid(row=2,column=2,padx=5,pady=5)
ann11=Button(root,text="*",width=3,command=lambda:tj('*'))
ann11.grid(row=2,column=3,padx=5,pady=5)
ann4=Button(root,text="4",width=3,command=lambda:tj('4'))
ann4.grid(row=3,column=0,padx=5,pady=5)
ann5=Button(root,text="5",width=3,command=lambda:tj('5'))
ann5.grid(row=3,column=1,padx=5,pady=5)
ann6=Button(root,text="6",width=3,command=lambda:tj('6'))
ann6.grid(row=3,column=2,padx=5,pady=5)
ann12=Button(root,text="-",width=3,command=lambda:tj('-'))
ann12.grid(row=3,column=3,padx=5,pady=5)
ann1=Button(root,text="1",width=3,command=lambda:tj('1'))
ann1.grid(row=4,column=0,padx=5,pady=5)
ann2=Button(root,text="2",width=3,command=lambda:tj('2'))
ann2.grid(row=4,column=1,padx=5,pady=5)
ann3=Button(root,text="3",width=3,command=lambda:tj('3'))
ann3.grid(row=4,column=2,padx=5,pady=5)
ann13=Button(root,text="+",width=3,command=lambda:tj('+'))
ann13.grid(row=4,column=3,padx=5,pady=5)
ann0=Button(root,text="0",width=3,command=lambda:tj('0'))
ann0.grid(row=5,column=0,padx=5,pady=5)
ann14=Button(root,text=".",width=3,command=lambda:tj('.'))
ann14.grid(row=5,column=1,padx=5,pady=5)
ann15=Button(root,text="/",width=3,command=lambda:tj('/'))
ann15.grid(row=5,column=2,padx=5,pady=5)
ann16=Button(root,text="=",width=3,command=js)
ann16.grid(row=5,column=3,padx=5,pady=5)
ann17=Button(root,text="计算",width=3,command=js)
ann17.grid(row=6,column=0,sticky=W+E,columnspan=2)
ann18=Button(root,text="清除",width=3,command=sc)
ann18.grid(row=6,column=2,sticky=W+E,columnspan=2)
root.mainloop()
运行结果：
上例中部分按钮的command方法中使用了lambda表达式进行了参数传递。
三、place()方法
place()方法使用位置坐标指定控件的位置，它比grid()和pack()布局更精确地控制组件在容器中的位置。常用参数见表4-15：
表4-15　place常用参数
参数 对应值 功能
x 数值 用绝对坐标指定控件的水平位置
y 数值 用绝对坐标指定控件的垂直位置
height 数值 指定控件的高度，默认值为控件的原始大小
width 数值 指定控件的宽度，默认值为控件的原始大小
参数 对应值 功能
relx 数值 用相对于父对象的比例大小指定控件的水平位置，其值为0.0-1.0
rely 数值 用相对于父对象的比例大小指定控件的垂直位置，其值为0.0-1.0
relheight 数值 用相对于父对象的比例大小指定控件的高度，其值为0.0-1.0
relwidth 数值 用相对于父对象的比例大小指定控件的宽度，其值为0.0-1.0
【示例】
from tkinter import *
root = Tk()
root.title("布局练习程序")
root.geometry("300x300")
label1=Label(root,text="明志大学",bg='red')
label2=Label(root,text="明志科技大学2",bg='yellow',width=20)
label3=Label(root,text="长庚大学",bg='red')
label1.place(x=0,y=0)
label2.place(x=50,y=120)
label3.place(x=50,y=150,relheight=0.5)
root.mainloop()
运行结果：
例8　编程实现：利用随机函数模拟投币，方法是：每次随机产生一个0或1的整数，相当于一次投币，0代表正面，1代表反面。程序运行后，在输入框中输入总次数，然后单击“抛掷”按钮，按照输入的次数模拟投币，分别统计出现正面、反面的次数，并显示结果。请根据题意，将程序代码中空缺部分补充完整。程序界面如下图所示：
import tkinter as tk
import random
def on_throw():
times = int(entry.get())
if times < 1:
label_result.config( (1) ="请输入正确的抛掷次数！")
return
results = [0,0]
for i in range(times):
if random.randint(0,1)==0:
results[0] += 1
else:
results[1] += 1
prob_heads = results[0] / times
prob_tails = results[1] / times　
label_result.config(text=f"正面概率:{prob_heads:.2f}\n"
f"反面概率:{prob_tails:.2f}")
root = tk.Tk()
root.title(" (2) ")
root.geometry("300x150")
label_input = tk.Label(root,text=" (3) ")
label_input.pack()
entry = tk.Entry(root,width=10)
entry.pack()
button_throw=tk.Button(root, text="抛掷", (4) =on_throw)
button_throw.pack()
label_result=tk.Label(root,text="结果将显示在这里")
(5) .pack()
root.mainloop()
【参考答案】(1)text　(2)硬币抛掷模拟 (3)输入抛掷次数：　(4)command　 (5)label_result s(共53张PPT)
第三部分　计算机编程基础
——Python语言
第一章 Python基础
考点十七~二十
考
纲
要
求 一、程序设计语言概述
1.理解程序与算法
2.识记程序设计语言
3.理解程序的执行方式
二、Python概述
1.识记Python的发展、特点和应用
2.识记Python的开发环境 3.识记Python的运行环境
三、程序文件
1.识记程序文件格式
2.掌握程序文件的建立与修改
3.掌握程序文件的运行
四、Python语法基础
1.掌握变量与常量
2.掌握表达式 3.掌握运算符
4.理解语句
五、基本数据类型
1.掌握整型
2.掌握布尔型
3.掌握浮点型
4.掌握字符串型
考
纲
要
求 六、结构数据类型及其操作
1.综合应用列表
2.综合应用元组
3.综合应用字典
4.综合应用集合 七、数据运算
1.掌握算术运算
2.掌握关系运算
3.综合应用逻辑运算
4.掌握运算优先级
命
题
趋
势 1.要求学生掌握程序执行方式(编译与解释)及Python语言特点等基础概念；理解Python开发环境与运行环境的区别
2.要求学生掌握程序文件的创建、编辑与保存等基本操作方法；了解常见语法结构，并能初步应用于简单程序编写；考查学生是否能够理解变量、常量、表达式及各类运算符的含义，并掌握其基本语法与优先级规则
3.熟知整型、字符串、列表、字典等基本与结构数据类型的特点及其常用操作；理解不同类型数据间的转换与嵌套使用，并能选择合适的数据结构进行综合应用完成数据组织与处理
考
向
分
析 【考查内容】
程序基本元素的使用、相互关联，函数方法的运用，Python程序的输入和输出
【考查题型】
选择题、填空题、程序填空题等
【考查分值】
10分以上
一、列表
列表是Python内置的可变序列，列表中的所有元素放在一对方括号[]内，并以逗号分隔。
列表是Python中最基本的数据结构，是最常用的Python数据类型，列表的数据项不需要具有相同的类型。
列表是一种有序的集合，可以随时添加和删除其中的元素。
创建列表后，就可以访问列表中的元素，同字符串一样，列表同样可以使用索引来访问列表中的元素，但列表与字符串不同，列表是可变的，但字符串是不可变的。列表的索引从0开始。
二、创建列表
可以通过赋值语句，也可以用list()函数将一个对象转换成列表。
【示例】
>>> list1=["python1.0",1991,"python2.0",2000,"python3.0", 2008]
>>> list2=list("python")
>>> list1
['python1.0',1991,'python2.0',2000,'python3.0',2008]
>>> list2
['p','y','t','h','o','n']
三、访问列表中的元素
【接上示例】
>>> list2
['p','y','t','h','o','n']
>>> list2[:]
['p','y','t','h','o','n']
>>> list2[2:4]
['t','h']
>>> list2[::2]
['p','t','o']
>>> list2[::-1]
['n','o','h','t','y','p']
从索引的使用可以看出，与字符串的切片一样，索引定义方式相似，但字符串的字符是单一的，而列表中的索引是针对列表项的，可能是一个单词也可能是一个数据，更有可能是一个列表。
>>> list3=[1,2,3,list("abcd"),"python"]
>>> list3
[1,2,3,['a','b','c','d'],'python']
一、元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号()，列表使用方括号[]。
元组创建只需要在括号中添加元素，并使用逗号隔开即可。
【示例】
>>> tup1=('Google','Runoob',1997,2000) >>> tup2=(1,2,3,4,5) >>> tup3="a","b","c","d" #不需要括号
>>> type(tup3)
二、创建空元组
当元组中只包含一个元素时，需要在元素后面添加逗号“,”，否则括号会被当作运算符使用。
【示例】
tup1=()
>>> tup1=(50) >>> type(tup1) #不加逗号，类型为整型 >>> tup1=(50,) >>> type(tup1) #加上逗号，类型为元组
三、访问元组
元组可以使用下标索引来访问元组中的值。
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
【示例】
tup1=('Google','Runoob',1997,2000)
tup2=(1,2,3,4,5,6,7)
print("tup1[0]:",tup1[0])
print("tup2[1:5]:",tup2[1:5])
输出结果：
tup1[0]:Google
tup2[1:5]:(2,3,4,5)
四、修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。
【示例】
tup1=(12,34.56)
tup2=('abc','xyz')
#以下修改元组元素操作是非法的，执行会报错
#tup1[0]=100
#创建一个新的元组
tup3=tup1+tup2
print(tup3)
输出结果：
(12,34.56,'abc','xyz')
五、删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
【示例】
tup=('Google','Runoob',1997,2000)
print(tup)
del tup
print("删除后的元组tup:")
print(tup)
元组被删除后，输出变量会触发异常，输出结果如下所示：
('Google','Runoob',1997,2000)
删除后的元组tup：
Traceback (most recent call last):
　　File "test.py", line 8, in
　　print (tup)
NameError: name 'tup' is not defined
六、元组运算符
与字符串一样，元组之间可以使用+、+=和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
常见元组运算符及其描述如表1-6所示：
表1-6　元组运算符
Python 表达式 结果 描述
len((1,2,3)) 3 计算元素个数
>>>a=(1,2,3)
>>>b=(4,5,6)
>>>c=a+b
>>>c (1, 2, 3, 4, 5, 6) 连接：c就是一个新的元组，它包含了a和b中的所有元素
Python 表达式 结果 描述
>>>a=(1,2,3)
>>>b=(4,5,6)
>>>a+=b
>>>a (1, 2, 3, 4, 5, 6) 连接：a就变成了一个新的元组，它包含了a和b中的所有元素
('Hi!',)*4 ('Hi!','Hi!','Hi!','Hi!') 复制
3 in (1,2,3) True 元素是否存在
for x in(1,2,3)：
print(x,end="") 1 2 3 迭代
七、元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中指定位置的元素，也可以截取索引中的一段元素。
【示例】
tup=('Google','Runoob','Taobao','Wiki','Weibo','Weixin')
>>> tup[1]#读取第2个元素，索引为1 'Runoob' >>> tup[-2]#反向读取，索引为-2 'Weibo' >>> tup[1:]#截取元素，索引为1，2，3，4，5
('Runoob','Taobao','Wiki','Weibo','Weixin')
>>> tup[1:4]#截取元素，索引为1，2，3
('Runoob','Taobao','Wiki')
八、关于元组是不可变的
所谓元组的不可变，指的是元组所指向内存中的内容不可变。
【示例】
>>> tup=('r','u','n','o','o','b') >>> tup[0]= 'g' # 不支持直接修改元素 Traceback (most recent call last): 　　File"",line 1,in
TypeError: 'tuple' object does not support item assignment >>> id(tup) # 查看内存地址 4440687904 >>> tup=(1,2,3) >>> id(tup) 4441088800 # 内存地址已改变
从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象，不是修改原来的对象。
集合(set)是一个无序的不重复元素序列。并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号“{}”创建集合，元素之间用逗号“,”分隔，也可以使用set()函数创建集合。
创建格式：
parame={value01,value02,…}
或者
set(value)
【示例】
set1={1,2,3,4} #直接使用大括号创建集合
# 使用set()函数从列表创建集合
set2=set([4,5,6,7])
创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。
更多实例演示：
>>> basket={'apple','orange','apple','pear','orange','banana'} >>> print(basket) # 这里演示的是去重功能 {'orange','banana','pear','apple'} >>> # 快速判断元素是否在集合内 >>> 'orange' in basket
True
>>> 'crabgrass' in basket False ... >>> # 下面展示两个集合间的运算 >>> a=set('abracadabra') >>> b=set('alacazam') >>> a {'a','r','b','c','d'}
>>> a-b # 集合a中包含而集合b中不包含的元素 {'r','d','b'} >>> a|b # 集合a或b中包含的所有元素 {'a','c','r','d','b','m','z','l'} >>> a&b # 集合a和b中都包含了的元素 {'a','c'} >>> a^b # 不同时包含于a和b的元素 {'r','d','b','m','z','l'}
类似列表推导式，集合同样支持集合推导式(Set comprehension)：
>>> a={x for x in 'abracadabra' if x not in'abc'}
>>> a
{'r','d'}
一、字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值对用冒号“:”分割，每个对之间用逗号“,”分割，整个字典包括在大括号“{}”中。
d={key1:value1,key2:value2,key3:value3}
【示例】
tinydict={'name':'runoob','likes':123,'url':'www.'}　
dict作为Python的关键字和内置函数，变量名不建议命名为dict。
键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
【示例】
tinydict1={'abc':456}
tinydict2={'abc':123,98.6:37}
二、创建空字典
1.使用大括号 { } 创建空字典：
emptyDict = {} # 打印字典
print(emptyDict) # 查看字典的数量 print("Length:", len(emptyDict)) # 查看类型 print(type(emptyDict))
输出结果：
{}
Length: 0

2.使用内建函数 dict() 创建空字典：
emptyDict = dict() # 打印字典 print(emptyDict) # 查看字典的数量 print("Length：",len(emptyDict)) #查看类型 print(type(emptyDict))
输出结果：
{}
Length： 0

三、访问字典里的值
把相应的键放入到方括号中：
tinydict={'Name':'Runoob','Age':7,'Class':'First'}
print("tinydict['Name']:",tinydict['Name'])
print("tinydict['Age']:",tinydict['Age'])
输出结果：
tinydict['Name']:Runoob
tinydict['Age']:7
如果用字典里不存在的键访问数据，会触发错误：
tinydict={'Name':'Runoob','Age':7,'Class':'First'}
print("tinydict['Alice']:",tinydict['Alice'])
输出结果：
Traceback (mostrecentcalllast):
　　File"test.py",line2,in
print("tinydict['Alice']:",tinydict['Alice'])
KeyError: 'Alice'
四、修改字典
向字典中添加新内容的方法是增加新的键/值对；也可直接修改或删除已有键/值对：
tinydict={'Name':'Runoob','Age':7,'Class':'First'}
tinydict['Age']=8 #更新Age
tinydict['School']="菜鸟教程" #添加信息
print("tinydict['Age']:",tinydict['Age'])
print("tinydict['School']:",tinydict['School'])
输出结果：
tinydict['Age']: 8
tinydict['School']: 菜鸟教程
五、删除字典元素
字典支持删除单个元素，也可清空整个字典，清空只需一次操作。
用del命令删除整个字典：
tinydict={'Name':'Runoob','Age':7,'Class':'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
print("tinydict['Age']:",tinydict['Age'])
print("tinydict['School']:",tinydict['School'])
尝试访问会触发异常，因为执行del操作后字典已删除：
Traceback (most recent call last):
　　File"/runoob-test/test.py",line 5,in
print("tinydict['Age']:",tinydict['Age'])
NameError:name'tinydict'is not defined
六、字典键的特性
字典值可以是任何的python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1.不允许同一个键出现两次。创建时如果同一个键被赋值多次，后一个值会覆盖之前的值。
【示例】
输出结果：
tinydict={'Name':'Runoob','Age':7,'Name':'小菜鸟'}
print("tinydict['Name']:",tinydict['Name'])
tinydict['Name']:小菜鸟
2.键必须不可变，所以可用数字、字符串或元组充当，但不可用列表。
【示例】
tinydict={['Name']:'Runoob','Age':7}
print("tinydict['Name']:",tinydict['Name'])
Traceback(most recent call last)：
　　File"test.py",line 1,in
　　tinydict={['Name']:'Runoob','Age':7}
TypeError: unhashable type: 'list'
输出结果：
【参考答案】D
【答题分析】clear()：清空列表，即删除所有元素。remove()：删除列表中第一个指定的值。pop()：删除指定索引位置的元素并返回它。reverse()：反转列表的顺序，不删除元素。
例16　(2024年真题)下列列表类型的操作方法中，　　　　不可以进行元素的删除操作。(　　)
A.clear() B.remove()
C.pop() D.reverse()
【参考答案】C
【答题分析】在Python中，集合的元素必须是不可变的。因此，只有不可变类型可以作为集合的元素。
例17　(2024年真题)下列集合数据类型正确的是(　　)
A.{1,2,{3}}
B.{1,2,[2,3]}
C.{1,2,(3,)}
D.{1,2,{'A':1}}
【参考答案】C
【答题分析】字典中的键不能是可变序列。
例18　(2022年真题)下列语句中，不能创建一个字典的是(　　)
A.dict1 = { }
B.dict2 = {(1,2,3): "uestc"}
C.dict3= {[1,2,3]: "uestc"}
D.dict4= { 3 : 5 }(共119张PPT)
第三部分　计算机编程基础
——Python语言
第二章　结构化程序设计
考
纲
要
求 一、结构化程序设计
1.综合应用结构化程序设计思想
2.理解结构化程序设计基本结构：顺序、选择、循环
3.综合应用程序流程图(N-S)
二、顺序结构程序设计
1.掌握赋值语句
2.掌握输入语句
3.掌握输出语句 三、选择结构程序设计
1.掌握单分支程序设计
2.掌握双分支程序设计
3.综合应用分支嵌套程序设计
四、循环结构程序设计
1.掌握while 语句程序设计
2.掌握for语句程序设计
3.综合应用循环嵌套
4.理解break/continue/pass 语句
命
题
趋
势 1.考查学生对结构化程序设计思想的综合应用能力，要求其理解顺序、选择、循环三种基本结构，并能综合应用程序流程图(N-S图)描述程序逻辑
2.要求学生掌握顺序结构程序设计的赋值、输入与输出语句的语法、执行过程及相关数据处理方法
3.掌握选择结构的语法与逻辑，考查学生能否正确使用单分支与双分支进行程序设计，能否利用分支嵌套结构解决实际问题
4.要求学生掌握循环结构中while与for语句的语法与执行流程，理解break、continue、pass等控制语句的作用与区别，并考查其对循环嵌套结构的综合应用能力
考
向
分
析 【考查内容】
1.程序基本结构
2.程序文件的建立、运行、调试分支嵌套、循环嵌套
3.程序的逻辑结构和语法规则
【考查题型】
填空题、选择题、程序运行题、程序填空题
【考查分值】
30分以上
程序流程图用来描述程序执行的逻辑结构，通常使用箭头、菱形、矩形等表明程序的运行过程。绘制流程图能帮助程序开发人员理清程序设计思路、完善程序逻辑、协同开发过程。
1.常见基本图形含义
在程序控制结构中，通常会用到菱形、长方形、箭头等基本图形绘制程序执行流程图，不同基本图形在程序流程图中代表的含义不同，如表2-1所示。
表2-1　流程图常见图形及其含义
常见图形 使用方法 含义
流程图开始或者结束阶段使用 流程图开始或结束
①菱形中填写判断条件；
②菱形外的四个角和箭头结合使用 判断条件
常见图形 使用方法 含义
①长方形中填写执行代码；
②长方形上下两条边中点和箭头结合使用 存放执行代码
↓→ ①箭头起点连接上一环节图形；
②箭头终点连接下一环节图形 控制程序流程走向
2.程序流程图绘制方法
(1)绘制顺序从上到下、从左到右。
(2)箭头起点到终点指向需明确。
3.绘制程序流程图优点
在程序设计过程中，通常会规划业务需求，并绘制程序流程图，这样做主要有以下几个优点：
(1)梳理程序执行逻辑，有问题及时调整。
(2)流程绘制简洁清晰，方便与协作开发人员沟通。
(3)功能删减方便，便于后期维护。
1.顺序结构
顺序结构是按语句的书写先后顺序逐条执行，直到执行该段程序的最后一条语句时为止。
2.顺序结构的流程图
流程图如图2-1所示。
图2-1　顺序结构执行流程
3.顺序结构的语法格式
流程图对应的语法格式如下：
语句1
语句2
语句3
…
语句n
【示例】输入矩形的边长，计算矩形的面积。
a,b=map(int,input("请输入矩形的长和宽：(输入的数据之间用空格间隔)").
split())
s=a*b
print("矩形的面积：{}".format(s))
1.含义
根据给定的条件，选择相应的分支进行操作，这就是选择结构。不同的执行流程就是程序的一个分支。
2.单分支结构
(1)单分支选择结构流程图如图2-2所示。
图2-2　单分支选择结构执行流程
(2)单分支语法格式如下：
if 条件表达式:
　　语句块
【示例】请输入一个正整数，如果能被2整除，就输出此数是偶数。
n=int(input("请输入一个正整数："))
if n%2==0:
　　print("{}是偶数".format(n))
3.双分支结构
(1)双分支结构程序执行时，根据条件进行判断，若条件成立，执行一个分支；若条件不成立，执行另一个分支。
(2)双分支结构流程图：根据判断条件结果而选择不同向前路径的运行方式，如图2-3所示。
图2-3　双分支结构执行流程
(3)语句格式如下：
if 条件表达式:
　　语句块1
else:
　　语句块2
【示例】请输入一个正整数，判断是偶数还是奇数。
n=int(input("请输入一个正整数："))
if n%2==0:
　　print("{}是偶数".format(n))
else:
　　print("{}是奇数".format(n))
【示例】
guess=eval(input())
if guess==99:
　　print("猜对了")
else:
　　print("猜错了")
双分支选择结构，条件表达式的结果应该是相斥的，不能相容。
另外：双分支的紧凑形式，通过双分支变化而成，可以解决简单问题，格式如下：
<表达式1>if<条件>else<表达式2>
【示例】
guess=eval(input())
print("猜{}了".format("对"if guess==99 else "错"))
图2-4　多分支选择结构执行流程
4.多分支结构
(1)多分支结构需逐个检查条件，直到其中一个条件为True，执行紧跟着的语句块，忽略其他语句块。
(2)多分支选择结构流程图
流程图如图2-4所示。
(3)语法格式
if 条件表达式1:
　　语句块1
elif 条件表达式2:
　　语句块2
···
elif 条件表达式n:
　　语句块n
else:
　　语句块n+1
【示例】根据学生成绩分等级显示。
(对不同分数分级的问题)
score = int(input("成绩："))
if score >= 90:
　　grade = "A"
elif score >= 80:
　　grade = "B"
elif score >= 70:
　　grade = "C"
elif score >= 60:
　　grade = "D"
else:
　　grade = "E"
print("输入成绩属于级别{}".format(grade))
【示例】输入一个学生成绩，判断成绩等级，等级划分：100~90，优秀；89~70，良好；69~60，及格；59~0，不及格。
cj=float(input("请输入学生的成绩(100以内)："))
if 90<=cj:
　　print("优秀")
elif 70<=cj:
　　print("良好")
elif 60<=cj:
　　print("及格")
else:
　　print("不及格")　
多分支选择结构，条件表达式使用时需注意下列情况：
①各分支条件要相斥，不能相容。
②使用条件时，按照从大到小的顺序或者从小到大顺序进行，不能交叉。
【错误示例】上面这个例题，若将程序条件改一下：
cj=float(input("请输入学生的成绩(100以内)："))
if 60<=cj:
　　print("及格")
elif 70<=cj:
　　print("良好")
elif 90<=cj:
　　print("优秀")
else:
　　print("不及格")
cj若输入99，程序运行时，遇到第一个分支，99>=60，执行第一个分支，显示“及格”，后续分支不再执行，无法显示“优秀”等级。
原因：if-elif-else 是自上而下依次判断，满足一个条件后立即终止，因此必须把“范围更小、更严格”的条件放在前面。
再比如，输入一个数，判断是2的倍数、3的倍数还是5的倍数时。而条件中的2、3、5倍数，不是相斥的，而是相容的，一个数既可能是2的倍数，也可能是3的倍数，更有可能是5的倍数。如果使用多分支结构，就错了。遇到此类问题，应改成独立的单分支结构进行处理。
5.组合条件的分支结构
【示例】根据体重和身高，计算BMI的值，输出相应结果。
国际：世界卫生组织；国内：国家卫生健康委员会。
分类 国际BMI值(kg/m2) 国内BMI值(kg/m2)
偏瘦 <18.5 <18.5
正常 18.5~25 18.5~24
偏胖 25~30 24~28
肥胖 ≥30 ≥28
# CalBMIv3.py
input_str = input("请输入身高(米)和体重(公斤)[逗号隔开]：")
height, weight = map(float, input_str.split("，"))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".format(bmi))
who, nat = "",""
if bmi < 18.5:
　　who,nat = "偏瘦", "偏瘦"
elif 18.5 <= bmi < 24:
　　who, nat = "正常", "正常"
elif 24 <= bmi < 25:
　　who, nat = "正常", "偏胖"
elif 25 <= bmi < 28:
　　who, nat = "偏胖", "偏胖"
elif 28 <= bmi < 30:
　　who, nat = "偏胖", "肥胖"
else: # BMI ≥30
　　who, nat = "肥胖", "肥胖"
print("BMI 指标:国际'{0}',国内'{1}'".format(who,nat))
在Python中，for循环常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素。运行循环体，直到序列元素执行完毕。
【示例】
由保留字for和in组成，完整遍历所有元素后结束。
每次循环，所获得元素放入循环变量，并执行一次语句块。
遍历结构：字符串、列表、元组、集合、字典。
而range( )函数，也可以应用于for 循环。
如计数循环(N次)：
for i in range(N):
　　<语句块>
遍历由range( )函数产生的数字序列，产生循环。
一、for循环的流程图
流程图如图2-5所示。
图2-5　for循环执行流程图
二、语句格式
for迭代变量in字符串|列表|元组|字典|集合|range():
循环体
for循环中，若使用内置函数range( )，方便生成一系列整数序列，Python中的range( )函数的格式如下：
range(开始,结束[,步长])
三、示例
1.利用for循环，使用range( )函数，解析循环执行过程。
方法一：
#计数循环(N次)
for i in range(5):
print(i,end="")
print("Hello：",i)
结果：
0Hello：0
1Hello：1
2Hello：2
3Hello：3
4Hello：4
从上面程序可以看出循环执行的过程，range( )函数产生的数值，既可以应用于循环体，也可不应用于循环体，只进行循环计次。
方法二：
for i in range(5): 　 for i in range(5):
　　print(i)　　　　 print(i,end="　")
程序运行结果：
前一个每行输出一个数据，分5行输出；而后一个，在一行输出5个数据：0 1 2 3 4。
print()函数的使用：print(values,sep,end)。
2.利用序列类型进行遍历循环
(1)将输入的字符串逆序输出。
st=input("请输入字符串")
chr=""
n=len(st)
for i in range(n-1,-1,-1):
reverse_chr=reverse_chr+st[i]
print(reverse_chr)
程序运行结果：
请输入字符串abcdefgh123
321hgfedcba
(2)请将列表l中的偶数删除。
方法一：
L=[2,5,7,4,3,1,9,6,8]
L1=[]
for i in L:
　　if i%2 != 0:
　　　　L1.append(i)
print(L1)
方法二：
L=[2,5,7,4,3,1,9,6,8]
print([x for x in L if x%2!=0])
程序运行结果：
[5,7,3,1,9]
循环执行流程：在Python语言中，while循环执行顺序：判断条件为True，执行语句块1，返回再判断条件，若为True，继续执行循环体，直到条件为False时退出循环，执行else子句中的语句块2(else子句可以省略)。
【示例】
由条件控制的循环运行方式
条件可终止的循环和无限循环：
a=3　　　 a=3
while a>0: while a>0:
a=a-1 a=a+1
print(a) print(a)
运行结果： 运行结果：
2 4
1 5
0 ...(CTRL+C退出执行)
一、while循环流程图
流程图见图2-6。
图2-6　while循环执行流程图
二、语句格式
while 条件表达式:
　　语句块1
else:
　　语句块2
三、示例
1.计算1+2+3+4+…直到和不少于5000时为止，输出此时的最小的累加数。
s,i=0,1
while s<=5000:
　　s=s+i
　　i=i+1
print("计算1+2+3+…,直到和不小于5000时,最小的累加数为:}".format(i-1))
计算1+2+3+…,直到和不小于5000时,最小的累加数:100
程序运行结果：
2.随机生成一个整数，进行猜数游戏，并给出提示信息，直到猜中为止。
import random
num=random.randint(1,20)
t=0
while t!=num:
　　t=int(input("请输入你要猜的数："))
　　if t==num:
　　　　print("恭喜!猜对了!")
　　elif t　　　　print("很遗憾!猜的数字偏小了")
　　elif t>num:
　　　　print("很遗憾!猜的数字偏大了")
3.while循环中带有else部分：
s,i=0,1
while i<=100:
s+=i
i+=1
else:
print("1+2+3+…+100={}".format(s))
程序运行结果：
也可以使用for循环，运行结果是相同的：
1+2+3+…+100=5050
s=0
for i in range(1,101):
s+=i
else:
print("1+2+3+…+100={}".format(s))
一、循环嵌套概念
1.一个循环里面嵌入另一个循环体时，称为“循环嵌套”。
Python不仅支持if语句相互嵌套，while和for循环结构也支持嵌套。所谓嵌套(Nest)，就是一条语句里面还有另一条语句，例如for里面还有for，while里面还有while，甚至while中有for或者for中有while也都是允许的。
当2个(甚至多个)循环结构相互嵌套时，位于外层的循环结构常简称为外层循环或外循环，位于内层的循环结构常简称为内层循环或内循环。
2.循环嵌套结构的代码，Python解释器执行的流程：
(1)当外层循环条件为True时，则执行外层循环结构中的循环体；
(2)外层循环体中包含了普通程序和内循环，当内层循环的循环条件为True时会执行此循环中的循环体，直到内层循环条件为False，跳出内循环；
(3)如果此时外层循环的条件仍为True，则返回第(2)步，继续执行外层循环体，直到外层循环的循环条件为False；
(4)当内层循环的循环条件为False时，且外层循环的循环条件也为False，则整个嵌套循环执行完毕。
二、循环嵌套的流程图
流程图如图2-7所示。
图2-7　循环嵌套执行流程图
三、示例
1.while-for嵌套循环。
i=0
while i<10:
print("i=",i)
for j in range(10):
print("j=",j,end=" ")
print()
i+=1
程序运行结果：
从上面的运行结果图例可以看出，外圈(外层循环)对应的是行，内圈(内层循环)对应的是列。根据这种情况，控制输出，可解决一类问题：数字图案、符号图案、不定方程，乘法口诀等。
2.打印三角形。
row=0
# 外层循环控制行数
while row<5:
col=0
# 内层循环控制列数
while col<=row:
print("*",end=" ")
col+=1
print(" ")
row+=1 #增加行数　
程序运行结果：
*
* *
* * *
* * * *
* * * * *
3.用while循环嵌套实现九九乘法表。
i=1 #外层循环控制行数
while i<=9:
j=1 #内层循环控制列数
while j<=i:
print("%d*%d=%d"%(j,i,j*i),end=" ")
j+=1
print()
i+=1
0
程序运行结果：
4.统计字母下划线数字个数。
a= "ABCD_abcd_1234"
i=0
#定义计数器
zm=0
shuzi=0
xhx=0
while iif a[i]>="0" and a[i]<="9":
shuzi+=1
elif ((a[i]>="A" and a[i]<="Z") or (a[i]>="a" and a[i]<="z")):
zm+=1
else:
xhx+=1
i+=1
print("数字是%d，下划线是%d，字母是%d"%(shuzi,xhx,zm))
程序运行结果：
数字是4，下划线是2，字母是8
5.图案类。
图案一：
def pattern(n):
for i in range(0,n):
for j in range(0,i+1):
print("*",end="")
print("\r")
for i in range(n,0,-1):
for j in range(0,1+i):
print("*",end="")
print("\r")
pattern(5)
程序运行结果：
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * *
* * * *
* * *
* *
图案二：
for i in range(5):#内层控制列
for j in range(5):
if i==0 or i==4 or j==0 or j==4:
print("*",end=" ")
else:
print(" ",end=" ")
print()
运行结果：
* * * * *
* *
* *
* *
* * * * *
1.“冒泡排序”思路：将需要排序的元素看作是一个个的“气泡”，最小(或最大)的“气泡”最快浮出水面，排在前面；较小(或较大)的“气泡”排在第二个位置，以此类推。
list1=[33,25,-12,45,68,11,0,-22]
n=len(list1)
for i in range(n):
for j in range(0,n-i-1):
if list1[j]>list1[j+1]:
list1[j],list1[j+1]=(list1[j+1],list1[j])
print(list1)
【示例】对列表中的元素按照从小到大的顺序进行排列(冒泡排序)。
程序运行结果：
[-22,-12,0,11,25,33,45,68]
2.插入排序。
def insertion_sort (sort_list):
iter_len=len(sort_list)
if iter_len<2:
return　sort_list
for i in range(1,iter_len):
key=sort_list[i]
j=i-1　
while j>=0 and sort_list [j]> key:
sort_list[j+1]=sort_list[j]
j-=1
sort_list[j+1]=key
return sort_list
3.选择排序。
def selection_sort(sort_list):
iter_len=len(sort_list)
if iter_len<2:
return sort_list
for i in range(iter_len-1):
smallest = sort_list[i]
location=i
for j in range(i, iter_len):
if sort_list[j]smallest=sort_list[j]
location=j
if i !=location:
(sort_list[i],sort_list[location])=(sort_list[location],
　　　　　　　　 sort_list[i])
return sort_list
一、break语句
1.概念
break语句用来终止循环，即循环条件不为False，或者序列还没遍历完，也会停止执行循环语句。
break语句用在while和for循环中。
如果使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行
代码。
2.流程图
流程图如图2-8所示。
图2-8　break语句执行流程图
3.示例
(1)break终止字符串遍历。
for i in "python":
if i=="o":
break
print("执行循环输出的字母：",i)
程序运行结果：
执行循环输出的字母：p
执行循环输出的字母：y
执行循环输出的字母：t
执行循环输出的字母：h
(2)判断一个数是否为素数。
n=int(input("请输入一个大于1的正整数："))
k=0　#k为0表示为素数，否则不是素数
for i in range(2,n):
if n%i==0:
k=1
break
if k==0:
print("{}是素数".format(n))
else:
print("{}不是素数".format(n))
程序的运行结果：
请输入一个正整数：5
5是素数
二、continue语句
1.概念
continue语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环，用在while和for循环中。
continue语句是跳出本次循环剩余语句，而break语句是跳出整个循环，循环不再执行。
2.流程图
流程图如图2-9所示。
图2-9　continue语句执行流程图
3.示例
(1)continue跳过指定字符。
for i in "python":
if i=="o":
continue
print("执行循环输出的字母：",i)
程序运行结果：
执行循环输出的字母：p
执行循环输出的字母：y
执行循环输出的字母：t
执行循环输出的字母：h
执行循环输出的字母：n
(2)将列表中的偶数去除。
list1=[23,24,52,63,27,59,37,61,49,80]
list2=[]
for i in list1:
if i%2==0:
continue
list2.append(i)
print(list2)
程序运行结果：
[23,63,27,59,37,61,49]
三、pass语句
1.概念
pass是空语句，是为了保持程序结构的完整性。pass不做任何事情，一般用作占位语句。
2.示例
#输出 Python 的每个字母
for letter in 'Python':
　if letter=='h':
　　　　pass
　　　　print ('这是 pass 块')
print ('当前字母：', letter)
print ("Good bye!")
程序运行结果：
当前字母：P
当前字母：y
当前字母：t
这是pass块
当前字母：h
当前字母：o
当前字母：n
Good bye!
一、概述
本知识点介绍Python的for...else和while...else等用法，这些是Python中相对不常用、易被误解的语法特性之一。
Python中的for、while等循环都有一个可选的else分支(类似if语句和try语句中的else分支)，在循环迭代正常完成之后执行。如果循环不是以非正常方式退出循环，也就是在循环体内没有break语句、没有return语句，或者没有异常出现，那么else分支将被执行。可理解为循环正常执行后的附加操作。
循环与else
for<循环变量> in <遍历结构>: 　　while <条件>:
<语句块1> <语句块1>
else: else:
<语句块2> <语句块2>
【示例】
循环控制语句与else
for c in "PYTHON": for c in "PYTHON":
if c=="T": if c=="T":
continue break
print(c,end="") print(c,end="")
else: else:
print("正常退出") print("正常退出")
运行结果： 运行结果：
PYHON正常退出　　　　 　　　　　　PY
二、示例
1.与for关键字一起用。
在满足以下情况的时候，else 下的代码块会被执行：
(1)for循环中的语句执行完成。
(2)for循环中的语句没有被break语句打断。
(3)示例1：
程序运行结果：
if语句已执行!
else语句被执行!
示例2：
程序运行结果：
if语句条件成立，执行break语句，循环退出!
我们在if里添加了一个break，这是因为else是在for后执行的，但只有for循环正常退出时才会执行else语句(不是由break结束循环)。而当循环是由break语句中断时，else就不被执行。
(3)示例：找出(81，99)中最大的完全平方数并输出，找不到则输出提示。
from math import sqrt
for n in range(99,81,-1):
root=sqrt(n)
if root ==int(root):
print(n)
break
else:
print("此范围内无完全平方数!")
程序的运行结果：
此范围内无完全平方数!
2.与while关键字一起用。
在满足以下情况的时候，else下的代码块会被执行：
(1)while循环中的语句执行完成。
(2)while循环中的语句没有被break语句打断。
(3)示例1：
a=0
while a <= 5:
print(a)
a += 1
else:
print("else语句块被执行!")
程序运行结果：
0
1
2
3
4
5
else语句块被执行！
示例2：
a=50
loop=0
while a >= 10:
print(a)
if loop==5:
break
a += 1
loop+=1
else:
print("else语句块被执行!")
程序运行结果：
50
51
52
53
54
55
3.异常处理的高级形式(try—except—else-finally)。
try:
<语句块1>
except:
<语句块2>
else:　　　　　　
#else对应语句块3在不发生异常时执行
<语句块3>
finally:
<语句块4> #finally对应语句块4一定执行
示例：
try:
a=int(input("输入被除数："))
b=int(input("输入除数："))
c=a/b
print("您输入的两个数相除的结果是：",c)
except (ValueError, ArithmeticError)：
print("程序发生了数字格式、算术异常之一")
except:
print("未知异常")
print("程序继续运行")
程序运行结果：
第一种方案：a和b 的值正确。
输入被除数：8
输入除数：3
您输入的两个数相除的结果是： 2.666666666666665
程序继续运行
第二种方案：a数据正常，b数据不正常。
输入被除数：3
输入除数：a
程序发生了数字格式、算术异常之一
程序继续运行
第三种方案：a和b数据类型正常，但算术异常。
输入被除数：3
输入除数：0
程序发生了数字格式、算术异常之一
程序继续运行
【参考答案】先后
【答题分析】掌握顺序的含义，程序的执行是按照书写的顺序，在执行的过程中无任何变化。
例1　顺序结构是编写程序代码的基础，顺序结构是按语句的　　　　顺序逐条执行，直到执行该段程序的最后一条语句为止。
【参考答案】A
【答题分析】掌握分支结构关键字。
例2　下列属于Python选择结构的是(　　)
A.if 　　　　 B.loop
C.do for　 D.while
【参考答案】A
【答题分析】单分支结构，只有一个关键字if，没有else或elif。
例3　下列关于Python选择结构的描述中，错误的是(　　)
A.每个if后面必须有elif或else
B.if-else结构可以嵌套
C.if语句先判断条件表达式，当表达式为True时，执行if后续的语句块
D.缩进是Python分支语句的语法部分，缩进不正确会影响分支功能
分支结构共有3种，掌握每种结构的特点，选择时要根据条件的相容和相斥来决定使用哪种结构，而不是根据选择条件来进行确定结构；另外对于多分支结构，对条件的使用，要按照一定的顺序执行，最好不要打乱条件的顺序。
【参考答案】从属
【答题分析】选择结构进行嵌套时，条件语句中的语句块是通过缩进来划分的，不同层的分支结构，语句块的缩进量也不同，根据不同的缩进量来区分语句块属于哪个分支结构，从而决定它们之间的从属关系。
例4　选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的　　　　关系。
选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。语法格式如下
【参考答案】C
【答题分析】由保留字for和in 组成，完整遍历所有元素后结束。每次循环，所获得元素放入循环变量，并执行一次语句块。遍历结构：字符串、列表、元组、集合、字典。
例5　(2022年真题)在下列Python类型中，for ... in循环不能遍历的是(　　)
A.字典 B.列表
C.浮点数 D.字符串
【参考答案】83
【答题分析】range(-8， 0， 5) 生成序列：-8，-3从 -8 开始，步长 5，下一个是
-3，再下一个是2(超出0停止，不包含)。循环两次：i = -8时：-i = 8，输出8(不换行)；i = -3时：-i = 3，输出3(不换行)。end=' ' 使输出连续，最终得到字符串 “83”。
例6　(2024年真题)写出下列程序的运行结果：　　　　。
for i in range(-8,0,5):
print(-i,end='')
例7　以下代码的运行结果为(　　)
A.123 B.1 2 3 C.12 D.1 2
a=1
while a<=3:
print(a, end=" ")
a += 1
【参考答案】B
【答题分析】根据循环条件，判断是否能执行循环，能执行几次，循环终止条件是什么。
【参考答案】####
####
例8　(2022年真题)
运行结果是：　　　　。
for i in range(2):
for j in range(4):
print("#",end="")
print()
【答题分析】这是一个嵌套循环： 外层循环 for i in range(2) 执行 2 次(i = 0， 1)。内层循环 for j in range(4) 每次执行4次，打印 4 个 #(end="" 使它们在同一行)。每执行完一次内层循环后，print() 会换行，因为默认 end="\n"。 因此输出结果是两行，每行四个#。
【参考答案】前面
【答题分析】根据冒泡排序理论知识的描述，前后语义分析，进行填空。
例9　“冒泡排序”是将需要排序的元素看作是一个个的“气泡”，最小(或最大)的“气泡”最快浮出水面，排在　　　　；较小(或较大)的“气泡”排在第二个位置，以此类推。
【参考答案】B
【答题分析】在Python中，用于提前结束循环的关键字是break。continue是跳过当前循环的剩余部分，进入下一次循环；pass是空语句，不做任何事情；try是异常处理语句的关键字，与结束循环无关。
例10　(2023年真题)Python在进行循环句的执行时，设置了可以提前结束循环的功能。下列用于结束循环的关键字是(　　)
A.continue B.break C.pass D.try
break语句是终止循环，continue语句结束本次循环，pass是空语句。
break语句用来终止循环，即循环条件没有False条件，或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
若使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
continue语句用来告诉Python跳过当前循环的剩余语句, 然后继续进行下一轮循环。
pass是空语句，是为了保持程序结构的完整性。pass不做任何事情，一般用作占位语句。
【参考答案】执行
【答题分析】理解循环结构的特殊用法。
例11　Python中的for、while等循环都有一个可选的else分支(类似if语句和try语句那样)，在循环迭代正常完成之后　　　　。(共72张PPT)
第三部分　计算机编程基础
——Python语言
第一章 Python基础
考点一~八
考
纲
要
求 一、程序设计语言概述
1.理解程序与算法
2.识记程序设计语言
3.理解程序的执行方式
二、Python概述
1.识记Python的发展、特点和应用
2.识记Python的开发环境 3.识记Python的运行环境
三、程序文件
1.识记程序文件格式
2.掌握程序文件的建立与修改
3.掌握程序文件的运行
四、Python语法基础
1.掌握变量与常量
2.掌握表达式 3.掌握运算符
4.理解语句
五、基本数据类型
1.掌握整型
2.掌握布尔型
3.掌握浮点型
4.掌握字符串型
考
纲
要
求 六、结构数据类型及其操作
1.综合应用列表
2.综合应用元组
3.综合应用字典
4.综合应用集合 七、数据运算
1.掌握算术运算
2.掌握关系运算
3.综合应用逻辑运算
4.掌握运算优先级
命
题
趋
势 1.要求学生掌握程序执行方式(编译与解释)及Python语言特点等基础概念；理解Python开发环境与运行环境的区别
2.要求学生掌握程序文件的创建、编辑与保存等基本操作方法；了解常见语法结构，并能初步应用于简单程序编写；考查学生是否能够理解变量、常量、表达式及各类运算符的含义，并掌握其基本语法与优先级规则
3.熟知整型、字符串、列表、字典等基本与结构数据类型的特点及其常用操作；理解不同类型数据间的转换与嵌套使用，并能选择合适的数据结构进行综合应用完成数据组织与处理
考
向
分
析 【考查内容】
程序基本元素的使用、相互关联，函数方法的运用，Python程序的输入和输出
【考查题型】
选择题、填空题、程序填空题等
【考查分值】
10分以上
一、程序设计的定义(理解)
程序设计是指设计、编制、调试程序的方法和过程，是目标明确的智力活动。程序设计的目的是将待解决的问题进行分析，定义用户需求，描述数据和加工过程，并将其细化、编码，转换成计算机可以接受的表示形式。
程序设计=算法+数据结构
算法：是一系列解决问题的明确指令。它描述了如何对数据进行操作以实现特定的功能。算法是程序设计的核心和灵魂。
算法的五大特性：确定性、有穷性、可行性、输入、输出。
数据结构：计算机中存储、组织数据的方式。
程序的编写基本方法：IPO模式，输入(In-put)、处理(Process)、输出(Output)。
二、程序设计语言的分类(识记)
程序语言种类繁多，可以分为机器语言、汇编语言和高级语言。
1.机器语言用二进制代码表示，是一种机器指令的集合，能被计算机直接识别和执行，编写的程序全是由0和1的指令代码组成。
2.汇编语言又称符号语言，即用某种助记符号代替指令中的操作码和操作数，不同设备对应不同的指令集。
机器语言和汇编语言有相同的特点，所以将机器语言和汇编语言统一称为低级语言。
3.高级语言接近自然语言和数学语言，是一种符号化的语句序列，也称为源代码。
目前，流行的高级语言有C、C++、C#、Java、Python等。特点如下：
①C语言：面向过程、抽象化的程序设计语言。特点：工作量小、可读性好、易于调试、修改和移植。
②C++：扩充和完善了C语言。特点：面向过程、面向对象、泛型编程。
③C#：继承了C语言和C++的强大功能。特点：语法简洁、跨平台、快速开发。
④Java：跨平台的面向对象的程序设计语言。特点：高通用性、高效性、可移植性、安全性。
⑤Python：是一种跨平台、面向对象的动态类型语言，应用于各种领域。特点：丰富的库、可嵌入性、可扩展性。
三、程序设计语言的执行方式(理解)
高级语言根据计算机执行机制的不同可分成两类，即静态语言和脚本语言。静态语言采用编译方式执行，脚本语言采用解释方式执行。
1.编译：编译是将源代码转换成目标代码的过程。通常源代码是高级语言代码，目标代码是机器语言代码，执行编译的计算机程序称为编译器。
2.解释：解释是将源代码逐条转换成目标代码的同时逐条运行目标代码的过程。
3.编译与解释的区别：编译是一次性翻译，一旦程序被编译，就不再需要编译程序或者源代码。解释则在每次程序运行时都需要解释器和源代码。
4.静态语言：C语言、Java语言等。
5.脚本语言：Python语言、PHP语言、JavaScript(JS)语言等。
如图1-1所示，1989年，荷兰程序员吉多·范·罗苏姆开发了一种继承ABC语言(一种结构化高级语言)的脚本语言，即Python语言。并于1991年发布了第一个版本；2008年发布Python 3.0，对源程序进行重大升级，修改了Python 2.0中不理想的设计，打破了程序“向下兼容”惯例，Python 3.x不完全兼容之前的版本。
图1-1　Python发展历史
Python语言是目前最为流行的一种语言，我们需要认识和学习Python。
一、Python的概念
Python语言是一种解释型、面向对象的计算机程序设计语言，其语法简单、易学、易读、易维护。比如，完成同一个任务，C语言要写1000行代码，Java只需要写100行，而Python可能只要20行。言外之意，Python集成度更高，引用的库更完善，用更少的时间，软件开发者就可以实现以前所实现的功能。
二、Python的作用
用Python可以做日常任务，比如自动备份你的MP3；可以做网站，比如国外的YouTube，国内的豆瓣；还可以做网络游戏的后台。
Python为我们提供了功能丰富的标准库、第三方库及适用于各个领域的包，覆盖了网络、文件、GUI、数据库、文本等大量内容，被形象地称作“内置电池(batteries included)”。用Python开发，绝大部分功能不必从零编写，直接使用现成的代码库即可。
三、Python的缺点
第一个缺点是运行速度慢，第二个缺点是语法独特，以缩进来区分语句关系的方式，易让初学者困惑。
四、Python的学习
第一步是学习编写以.py结尾的文件，第二步就是在Python环境中运行程序。目前存在的解释器有CPython、IPython、PyPy、Jython、IronPython等，而我们需要掌握的Python的运行环境有Python自带的IDLE和第三方软件PyCharm。
五、Python语言的特点
1.更易理解：Python抽象出对象的行为和属性，解决了结构化程序的复杂性，使程序设计更贴近生活。
2.简化设计：Python的数据类型中有元组、列表、字典、集合等。
3.易于学习：Python的关键字较少，结构也相对简单。
4.“胶水”语言：Python与多种高级语言易组合，程序内部和直接调用其他高级语言编写程序。
5.可移植性：Python的源代码完全开放，可运行于不同的OS中，不同平台代码移植性高。
6.开源免费：Python的使用完全免费，不同领域、不同层次程序员都可以参与开发、扩充功能。
六、Python的应用领域
Python在Web开发、网络编程、爬虫开发、数据分析、人工智能、自动化运维和常规软件开发等方面均有广泛应用。
一、了解机器运行环境
选择Python软件的版本前，要查看电脑的操作系统及操作系统位数，如图1-2所示。
右击桌面上“计算机”→“属性”→“系统属性”，就可以了解计算机中的相关信息。
图1-2　计算机基本信息
二、下载Python相应版本软件
在Python的官网下载与本地计算机适配的Python版本，建议下载Windows x86 64 executable
installer版本，如图1-3所示。
官网下载地址如下：
https：//www.python.org/downloads/windows/
图1-3　Python下载界面
三、安装Python软件
1.下载完成后双击执行下载的exe程序，进入安装界面(图1-4)。
安装界面可以选择默认安装，也可以自定义安装，建议使用自定义安装，因为默认安装路径都比较深，自定义安装可以选择定义一个较浅的目录，后续容易找。
图1-4　Python安装界面
2.在选择路径安装时，可以把下方的“Add Python 3.6 to PATH”勾选上，这个就直接默认把用户变量添加上了，后续不用再添加。
3.选择好后，继续下一步，全部默认选择即可，如有需要可变更，再下一步时直接更新安装存储的路径。
4.继续下一步，则提示安装成功(图1-5-1)。在安装目录内也可以看到如图
1-5-2所示的相关信息。
至此Python已成功安装，可以使用了。
图1-5-1　Python安装成功界面
图1-5-2　Python安装文件夹
5.安装完成后在cmd中执行python V则可看到成功安装的版本。示意图如图1-6所示。
图1-6　查看Python版本信息
四、Python运行界面
安装完成后，即可运行Python软件。
1.利用命令窗口，运行Python(图1-7)。
(可以在Python文件夹下，Shift+右击，选择“在此处打开命令窗口”)
图1-7　命令窗口运行Python
2.利用菜单方式运行IDLE(图1-8)。
图1-8　菜单方式运行Python
五、PyCharm的安装
PyCharm是由JetBrains打造的一种Python集成开发环境，支持多种操作系统。
PyCharm的运行环境具备调试、语法高亮显示、项目管理、代码跳转、智能提示、自动完成、单元测试、版本控制等功能，因此大大提升Python的开发效率。
第1步：从PyCharm的官方网站下载所需的软件包或可执行文件。如图1-9所示，“Professional”表示专业版，“Community”表示社区版。
专业版包含所有高级功能，并在几天内免费试用，用户必须在试用期之后购买授权密钥才能激活。社区版是免费的，可以根据需要进行下载和安装。它包含安装所需的所有基本功能。作为初学者，我们在教学中使用社区版本。
图1-9　PyCharm下载界面
第2步：将社区软件包下载到本地计算机中，双击“pycharm-community-2018.1.4.exe”，如图1-10所示。
图1-10　PyCharm社区版下载界面
第3步：安装程序。
(1)运行安装程序进行安装，建议修改安装路径(图1-11-1)，可以根据自己的计算机系统选择32位还是64位(图1-11-2)。
图1-11-1　安装路径界面 图1-11-2　选择系统位数界面
(2)勾选“Create Associations”下“.py”复选框，这样，凡是扩展名为“.py”的文件就会使用PyCharm打开。
(3)勾选“Update PATH variable(restart needed)”下“Add launchers dir to the PATH”复选框，可将启动器目录添加到环境变量中。
第4步：安装成功以后，PyCharm会要求您导入现有软件包的设置(可选择)，如图1-12所示。
这有助于创建一个新的Python项目，可以从头开始工作。需要注意的是，PyCharm与其他IDE不同，只专注于使用Python脚本语言的项目。
图1-12　PyCharm软件包设置界面
六、PyCharm的运行界面
PyCharm的工作界面如图1-13所示。
添加代码后，按快捷键Ctrl+F5或者右上角“运行”按钮，该程序代码就开始运行。
图1-13　PyCharm运行界面
七、Python的工作模式
1.命令行模式
命令行模式常用操作：
(1)python：命令行模式切换到交互模式。
(2)python -V：查看Python安装版本。
(3)python+程序文件名：运行程序，文件名必须包含路径和扩展名。
(4)pip install：是Python 中用于安装第三方库(也称为包)的命令行工具。
(5)pip list：是用于查看当前Python环境中已经安装的所有第三方库及其版本信息的命令行工具。
2.交互模式
Python交互模式是一种即时执行Python代码的环境。当你启动Python交互解释器(在终端输入python或python3，具体取决于你的系统和Python安装)后，会看到提示符(通常是>>>)，在这个提示符后输入Python代码，解释器会立即执行代码并返回结果。其中：
exit()或quit()函数退出交互模式并返回到命令行模式。
一、注释
注释是用自然语言写的一行或多行的说明性文字，用于解释代码的功能或标注相关信息。其最大作用是提高程序的可读性。Python解释器在执行代码时会忽略注释，不被计算机执行。
注释分为单行注释和多行注释。
1.Python的单行注释
使用#作为单行注释的符号。
从#开始，直到这行结束为止的所有内容都是注释。Python 解释器遇到#时，会忽略它后面的整行内容。
#使用print输出字符串
print("Hello World!")
print("python语言网")
#使用 print输出数字
print(10)
print(3+10*2)
print((3+10)*2)
(1)说明多行代码的功能时一般将注释放在代码的上一行，例如：
(2)说明单行代码的功能时一般将注释放在代码的右侧，例如：
#输出Python教程的地址
print("http：//c./python/")　
print(36.7*14.5)　#输出乘积
print(100 % 7)　#输出余数
2.Python的多行注释
多行注释指一次性注释程序中多行的内容(包含一行)。
Python使用三个连续的单引号'''或者三个双引号"""注释多行内容，具体格式如下：
'''
使用 3 个单引号分别作为注释的开头和结尾，可以一次性注释多行内容，这里面的内容全部是注释内容。
'''
或者
"""
使用 3 个双引号分别作为注释的开头和结尾，可以一次性注释多行内容，这里面的内容全部是注释内容。
"""
多行注释通常用来为 Python 文件、模块、类或者函数等添加版权或者功能描述信息。
二、注释的注意事项
1.Python多行注释不支持嵌套，所以以下写法是错误的：
'''
外层注释
　　'''
　　内层注释
　　'''
'''
2.不管是多行注释还是单行注释，当注释符作为字符串的一部分出现时，就不能再将它们视为注释标记，而应该看作正常代码的一部分，例如：
print('''Hello,World!''')
print("""http：//c./cplus/""")
print("#是单行注释的开始")
对于前两行代码，Python 没有将这里的三个引号看作是多行注释，而是将它们看作字符串的开始和结束标志。
对于第3行代码，Python也没有将#看作单行注释，而是将它看作字符串的一部分。
运行结果：
Hello,World!
http://c./cplus/
#是单行注释的开始
三、注释可以帮助调试程序
给代码添加说明是注释的基本作用，除此之外，它还可以用来调试程序。
例如：如果你觉得某段代码可能有问题，可以先把这段代码注释起来，让Python 解释器忽略这段代码，然后再运行。如果程序可以正常执行，则可以说明错误就是由这段代码引起的；反之，如果依然出现相同的错误，则可以说明错误不是由这段代码引起的。
在调试程序的过程中使用注释可以缩小错误所在的范围，提高调试程序的效率。
四、缩进
Python语言采用严格的“缩进”来表示程序逻辑。缩进指每行语句开始前的空白区域，用来表示Python程序间的包含和层次关系。一般代码不需要缩进，顶行编写且不留空白。
当表示分支、循环、函数、类等程序含义时，在if、while、for、def、class等保留字所在完整语句后通过英文冒号(：)结尾并在之后行进行缩进，表明后续代码与紧邻无缩进语句的所属关系。缩进可以用Tab键实现，也可以用多个空格实现(4个空格)，但两者不能混用。例如：
#请输入一个大于1的正整数N，
#求1至N之间的整数和。
N=eval(input("请输入一个大于1的正整数N："))
m=1
s=0
while m<=N：
s=s+m
m=m+1
print("求和的结果为：",s)
一、定义
常量：在程序运行过程中，其值不发生改变的量。
变量：在程序运行过程中，其值会发生变化的量。
二、特征
1.变量
Python中的变量是用来标识对象或引用对象的；每个变量在使用前必须先赋值才能使用。
Python中的变量赋值不需要先进行类型声明，它会根据赋值或运行结果自动判断变量的类型。
NAME="张明"(本质还是变量)
2.常量
Python中没有专门定义常量的方式，通常用全部大写的标识符来表示常量，如：PI=3.1415926。
但事实上PI仍然是一个变量，Python没有任何机制保证PI不会被修改，所以，用全部大写的标识符表示常量只是一个习惯上的用法。例如：
定义方式一般有驼峰体和下划线(详见考点八)。如：
StudyLanguage='Python'
Study_language='Python'
变量的三个特征是标识、类型、值，获取方法分别是id(变量名)，type(变量名)，变量名。
动态类型是Python的重要特色之一，即Python中对象的类型和内存空间都是在运行时确定的。每个对象会在内存中申请开辟一块空间来保存该对象，该对象在内存所在位置的地址被称为“引用”(id)。
【示例】
一、基础规则
1.字母或者下划线开头，其后的字符可以包含字母、数字和下划线。
2.不能以数字开头，中间不能出现空格。
3.英文字母区分大小写。
二、变量命名的约定
以“见名知意”的原则来命名变量并遵循以下命名规范。
1.大驼峰命名法：每一个单词首字母大写。
2.小驼峰命名法：第一个单词首字母小写，其余单词首字母大写。
3.下划线命名法：单词之间以下划线相连。
三、注意事项
1.不能使用系统关键字作为变量名。
2.不建议使用系统内置函数名、类型名、模块名来定义变量。
常见的Python关键字有33个：False，None，True，and，as，assert，break，class，continue，def，del，elif，else，except，finally，for，from，global，if，import，in，is，lambda，nonlocal，not，or，pass，raise，return，try，while，with，yield。
四、正确的命名方式
MyName， myName，Myname， Student_1：大驼峰命名、小驼峰命名、英文方式，见名而知意。
num1， NUM1， nUm1， num_1，NUM_1：英文字母区分大小写，字母相同，实际表示不同的变量。
五、错误的命名方式
1.1_student， 12abc ：变量命名，不能用数字开头。
2.My name：产生歧义，若作为2个变量则是正确的，但要作为一个变量就是错误的，中间不能加空格。
3.from， if， global：错误，Python关键字不能用作变量名。
4.math， turtle， os：错误，模块名不能作为变量名。
【参考答案】A
【答题分析】Python代码在运行时由解释器逐行解释执行，不需要事先编译成机器码。机器语言是二进制指令，计算机直接执行，Python属于高级语言。Python支持面向过程编程，但也支持面向对象、函数式编程，是多范式语言，不能单纯归类为面向过程语言。Python不是像C/C++那样需要先编译再执行的编译型语言。
例1　(2022年真题)Python是一种(　　)
A.解释型语言 B.机器语言
C.面向过程语言 D.编译型语言
【参考答案】C
例2　(2023年真题)下列选项中，不属于Python语言特点的是(　　)
A.简洁 B.开源
C.面向过程 D.可移植
【参考答案】C
例3　(2024年真题)关于Python的语法，下列说法错误的是(　　)
A.Python程序是逐行编写的，每行代码长度并无限制
B.单行代码不利于阅读，可以使用续行符将单行代码分割为多行表达
C.续行符后可以存在空格
D.续行符后必须直接换行
【答题分析】Python代码按行执行，每行长度没有语法上的硬性限制，但建议每行不超过79字符以提高可读性。为了提高代码可读性，可以使用反斜杠(\)作为续行符将长代码分割成多行，或在括号内直接换行。续行符(\)后面不能有任何字符(包括空格)，必须直接换行，否则会引发SyntaxError。续行符后必须立即换行，中间不能有任何其他字符。
【参考答案】B
【答题分析】第一步是学习编写以.py结尾的文件，第二步就是在Python环境中运行程序。目前存在的解释器有CPython、IPython、PyPy、Jython、IronPython等，而我们需要掌握的Python的运行环境有Python自带的IDLE和第三方软件PyCharm。
例4　(2023年真题)Python源文件的扩展名为(　　)
A..bmp B..py
C..jpg D..psd
【参考答案】缩进
【答题分析】在Python中，代码缩进是一种特殊的语法规则，用于表示代码的结构和层次关系。它告诉Python哪些代码属于同一个代码块，表明了后续代码间的所属关系。
例5　(2024年真题)在def等保留字所在完整语句后通过英文冒号结尾并在之后进行
　　　　 表明后续代码间的所属关系。
【参考答案】C
【答题分析】标识符就是变量名的意思，要遵循变量命名规则，规则是字母或者下划线开头，其后的字符可以包含字母、数字和下划线。不能以数字开头，中间不能出现空格。英文字母区分大小写。
例6　(2023年真题)下列选项中，可以作为Python标识符的是(　　)
A.12a B.{12a}
C._12a D.+12a
【参考答案】C
【答题分析】在Python中，变量名不能使用保留字(关键字)。
例7　(2023年真题)下列变量命名正确的是(　　)
A.for B.elif
C.xinl D.try
【参考答案】type()
【答题分析】变量的3个特征是标识、类型、值，获取方法分别为：id(变量)、type(变量名)、变量名。
例8　(2023年真题)在Python语言编程中，查看变量类型的Python内置函数是
　　　　。(共48张PPT)
第三部分　计算机编程基础
——Python语言
第一章 Python基础
考点九~十六
考
纲
要
求 一、程序设计语言概述
1.理解程序与算法
2.识记程序设计语言
3.理解程序的执行方式
二、Python概述
1.识记Python的发展、特点和应用
2.识记Python的开发环境 3.识记Python的运行环境
三、程序文件
1.识记程序文件格式
2.掌握程序文件的建立与修改
3.掌握程序文件的运行
四、Python语法基础
1.掌握变量与常量
2.掌握表达式 3.掌握运算符
4.理解语句
五、基本数据类型
1.掌握整型
2.掌握布尔型
3.掌握浮点型
4.掌握字符串型
考
纲
要
求 六、结构数据类型及其操作
1.综合应用列表
2.综合应用元组
3.综合应用字典
4.综合应用集合 七、数据运算
1.掌握算术运算
2.掌握关系运算
3.综合应用逻辑运算
4.掌握运算优先级
命
题
趋
势 1.要求学生掌握程序执行方式(编译与解释)及Python语言特点等基础概念；理解Python开发环境与运行环境的区别
2.要求学生掌握程序文件的创建、编辑与保存等基本操作方法；了解常见语法结构，并能初步应用于简单程序编写；考查学生是否能够理解变量、常量、表达式及各类运算符的含义，并掌握其基本语法与优先级规则
3.熟知整型、字符串、列表、字典等基本与结构数据类型的特点及其常用操作；理解不同类型数据间的转换与嵌套使用，并能选择合适的数据结构进行综合应用完成数据组织与处理
考
向
分
析 【考查内容】
程序基本元素的使用、相互关联，函数方法的运用，Python程序的输入和输出
【考查题型】
选择题、填空题、程序填空题等
【考查分值】
10分以上
一、算术运算符
常见的算术运算符及含义如表1-1所示：
表1-1　算术运算符
运算符 含义 示例
+ 加 3+2(值为5)
- 减 3-2(值为1)
* 乘 3*2(值为6)
运算符 含义 示例
/ 除 4/2(值为2)
** 乘方 2**3(值为8)
// 取整 7//2(值为3)
% 取余 7%2(值为1)
二、赋值运算符
常见的赋值运算符及含义如表1-2所示：
表1-2　赋值运算符
运算符 含义
= 简单的赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
运算符 含义
/= 除法赋值运算符
//= 整除赋值运算符
%= 取模(余数)赋值运算符
**= 幂赋值运算符
例如：
num=3+2是将3+2值赋给变量num；
num+=2等同于num=num+2。
(4*x+2)/4+(3+4*y)/5
关系运算符也称为比较运算符，根据表达式的值返回布尔值True或False。
常见的关系运算符及功能如表1-3所示：(假设a=5，b=3)
表1-3　关系运算符
运算符 描述 示例 功能
< 小于 a<= 小于等于 a<=b a小于等于b值为True，否则值为False
运算符 描述 示例 功能
> 大于 a>b a大于b值为True，否则值为False
>= 大于等于 a>=b a大于等于b值为True，否则值为False
== 等于 a==b a等于b值为True，否则值为False
!= 不等于 a!=b a不等于b值为True，否则值为False
在Python语言中，进行逻辑运算时，任何对象都可以表示为True或者False，我们可以使用bool( )函数判断某个对象的逻辑值(图1-14)。
图1-14　逻辑运算中对象的真与假
常见的逻辑运算符如表1-4所示：
表1-4　逻辑运算符
运算符 描述 举例
and 与 x and y：如果x为True，返回y值，如果x为False，返回x值
or 或 x or y：如果x为True，返回x的值，否则返回y值
not 非 not x：如果x为True，返回False，如果x为False，返回True
逻辑运算符的运算逻辑类似于数学中的交、并、补运算。
【示例】
对于数值，0表示False，非0表示True。
Python有两个成员运算符，in和not in， 可以用来判断一个元素是否在某一个序列中。常见的序列有字符串、列表、集合、元组、字典。
>>> "a" in"abc" ————————————字符串
True
>>> "a" in list("abc")————————————列表
True
>>> "a" in set("abc") ————————————集合
True
>>> "a" in tuple("abc") ————————————元组
True
>>> "a" in {"a":1,2:"abc"}
True >>> "a" in {1:"a",2:"abc"} False ————————————字典，序列为键，而不是值
一、身份运算符
用于比较两个对象的存储单元。运算符描述实例：
1.is：is是判断两个标识符是不是引用自一个对象，x is y，类似 id(x)==id(y)，如果引用的是同一个对象则返回True，否则返回False。
2.is not：is not是判断两个标识符是不是引用自不同对象，x is not y，类似id(a) != id(b)。如果引用的不是同一个对象则返回结果True，否则返回False。
3.is与==区别：
is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。
二、位运算符
&：按位与运算符；
|：按位或运算符；
^：按位异或运算符；
~：按位取反运算符；
<<：左移动运算符；
>>：右移动运算符。
当表达式中有多种运算符时，表达式的运算按照运算符优先级“从高到低，从左到右”的顺序进行。
1.运算符的一般优先级顺序
算术运算符→位运算符→关系运算符→身份运算符→成员运算符→逻辑运算符→赋值运算符。
例如：
a=3
1+2*3**2%2>12 and "b" in "abc"+"cde" and a is 3
在这个表达式中，有算术运算符、关系运算符、成员运算符、身份运算符、逻辑运算符。
它们运算顺序为**、*、%、+、>、is、in、and；
运算结果为False。
(1+2*3**2%2>12) and ("b" in "abc"+"cde") and (a is 3)
2.括号( )
在表达式中，括号优先级最高，也可以通过( )来增加易读性，将各运算符括起来，也能改变运算符的优先级。如：
1.Python中的数值型有整型、浮点型和复数三种形式。示例如下：
整型：1、33、-12、0。
浮点型：10.88、-23.47、0.12、1.2e3、-2E5。
复数类型：10+2J、0.2+3J、4J。
2.三者之间的相互转换如图1-15所示。
图1-15　数值转换关系
3种类型的转换函数：int( )、float( )和complex( )。值得注意的是，用int( )将浮点型转换成整型时，小数部分将舍弃。
【示例】int(3.2)，int(9.8)，float(8)，complex(3.2)，complex(5)。
①整型有多种表示方法，常用的有十进制整型、二进制整型(以0b或0B开头)、八进制整型(以0o开头)、十六进制整型(以0X或0x开头)。
②浮点型不能用整型的二进制、八进制、十六进制表示。
正确：-3、10.2、1.2+3J、0b1011、0o2574101、0X459daf。
错误：0b1021、0o257.41、0X459dafk。
③整型与浮点型、浮点型与浮点型进行运算时，其表达式结果为浮点型。
1.Python中字符串中使用的引号可以是单引号、双引号或三引号。
字符串有2类，共3种。
【示例】
S1="abc"
S2='123'
S3=''' Python
语言 '''
三引号也是注释，Python中注释本质上就是一个字符串。
2.特殊字符(换行符、制表符等)可以通过转义字符“\”进行表示。
常见的转义字符如表1-5所示：
表1-5　转义字符
转义字符 作用 转义字符 作用
\\ 单个\ \r 回车
\n 换行 \’ 单引号
\t 制表符 \” 双引号
【示例】
3.原样输出引号内字符串可以使用在引号前加r的形式来表示。
【示例】
4.字符串索引。
字符串是一组字符的序列，一旦定义，是不可变的。
访问字符串中的字符需要知道它在字符串中的位置，这个位置号就是索引，和其他语言一样，索引号是从0开始；在Python语言中，索引的序号可以是正数，也可以是负数。
正数是从0开始，从左到右，负数从-1开始，从右到左的顺序。
【示例】
正向索引
0 1 2 3 4 5 6 7 8
不 忘 初 心 ， 牢 记 使 命
-9 -8 -7 -6 -5 -4 -3 -2 -1
逆向索引
从上图可以看出，Python语言与其他语言不同，中文、英文、标点、大写、小写都独立占据一个位置，但索引编号的规则是一样的。
5.字符串的切片：要访问字符串中的一段字符，可以用字符串名[起始索引：结束索引]的方法来表示。这种方法称之为“字符串切片”。
格式1：字符串名[起始索引：结束索引]。
功能：切片是指从字符串的起始索引位置开始，到结束索引位置终止，不包括结束索引位置上的字符。
冒号左右两边的索引是可以省略的。省略起始索引表示从字符串的首位开始，省略结束索引表示取值到字符串的末位；两者都省略，则表示整个字符串。
【示例】
0 1 2 3 4 5 6 7 8 9
学 习 P y t h o n 语 言
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1
st="学习Python语言"
st[2:8]切片起点是"P"，终点索引位置字符是"语"，但不含"语"，只到"语"前一个字符"n"，所以其值为"Python"，个数为8-2=6个字符。
“语言”——st[8:]，或st[8:10]。
“学习”——st[0:2]或st[:2]或st[-10:-8]或st[:-8]。
格式2：字符串名[起始索引:结束索引:步长]。
功能：从字符串起始位置到结束位置，按步长取出字符构成字符串。
【示例】
>>> st[3:9:2]
'yhn'
2 ○
3 4 ○
5 6 ○
7 8 9
P y t h o n 语 言
几个特殊的应用：
还有一种情况：正序和逆序混合使用。
【参考答案】[1，2，2]
【答题分析】列表中的“+”是连接的含义，“*”是重复的含义，先运算“*”结果为[2，2]，再运算“+”，结果为[1，2，2]。
例9　(2024年真题)[1]+[2]*2的运行结果是　　　　。
【参考答案】6
【答题分析】赋值运算符中num*=2等同于num=num*2。
例10　(2022年真题)已知x=2，语句x*=x+1执行后，x的值是　　　　。
【参考答案】True
例11　(2023年真题)在Python语言编程中，表达式3<6的值为　　　　。
【参考答案】5
【答题分析】根据Python运算符的优先级，not的优先级高于and，因此表达式not 0 and 5 等价于(not 0) and 5。not 0的结果为True，而True and 5返回第二个操作数5。 故运算结果为5。
例12　(2023年真题)语句not 0 and 5的运算结果为　　　　。
【参考答案】99.0
【答题分析】float函数是强制类型转换函数，将99转换为浮点数，所以输出结果是99.0。
例13　(2023年真题)语句print(float(99))的运算结果为　　　　。
【参考答案】D
【答题分析】Python中的数值型有整型、浮点型和复数三种形式。如，整型：1、33、-12、0；浮点型：10.88、-23.47、0.12、1.2e3，-2E5；复数类型：10+2J、0.2+3J、4J。
例14　(2023年真题)下列选项中，属于数值类型的是(　　)
A.0 B.1.0
C.1+2j D.以上都是
【参考答案】B
【答题分析】chr(x)：给定一个整数(Unicode码点)，返回对应的字符。ord(x)：给定一个字符(长度为1的字符串)，返回对应的Unicode编码(整数)。hex(x)：给定一个整数，返回其十六进制表示字符串。oct(x)：给定一个整数，返回其八进制表示字符串。
例15　(2024年真题)下列字符串处理函数中，　　　　可以返回x对应的Unicode编码。(　　)
A.chr(x) B.ord(x)
C.hex(x) D.oct(x)

展开更多......

收起↑