电子学会python考级1-4级知识点

完全按照考纲辅导资料总结，知识点全面，适合编程初学者和少儿编程考试学员学习。考试无忧！

python知识点

一级知识点

编程环境

Python版本

Python2

Python3

python特点

解释型

不进行预先编译，以文本方式存储程序代码。

逐行解释执行

面向对象

以对象为核心， 类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。 对象间通过消息传递相互通信，来模拟现实世界中不同实体间的联系。

动态数据类型

动态语言 (又称弱类型语言），变量不用声明类型，具体类型根据指向的内存单元中的数据类型决定。相对应的还有静态数据类型

IDLE操作

两种模式

脚本模式（编辑器模式）

可以编辑多行命令，形成一个文件，然后可以运行文件的模式

交互模式（shell模式）

直接输入一行代码或者命令，立刻就可以反馈运行结果的模式，又称shell模式

新建文件

方法

File->New File

扩展名

.py和.pyw

打开文件

方法

File->Open

保存文件

方法

File->Save

代码缩进

缩进代表不同的逻辑层

Tab键和空格作为缩进不能混用

推荐使用空格键进行缩进

代码注释

单行注释

使用#

多行注释

使用’‘’或者“”“

程序运行

Run-> Run Module

可以在一行使用两个命令，两个命令之间用分号分隔

其他编程环境

VScode

PyCharm

编程基础

print（）语句

输出字符串（单引号双引号均可）

输出有数值的数字

输出变量

输出多个内容（用逗号隔开）

换行

不需要换行的话把默认参数改成end=‘‘

input（）语句

双引号和单引号

转义字符

Python中常见的转义字符如下： 转义字符描述\\反斜杠 \'单引号 \"双引号 \n换行 \r回车 \t制表符（Tab） \b退格（Backspace） \f换页（Form feed） 需要注意的是，在字符串中如果需要输出反斜杠字符本身，需要使用双反斜杠 \\ 来进行转义，否则会被当成转义字符的开始标志。例如，要输出一个反斜杠，可以这样写：

字符串及数值类型转换

变量的命名规则和使用

命名规则

大小写字母、数字、下划线以及汉字等字符串的组合

不能用数字开头，也不鼓励的下划线开头

变量名中不能有空格或标点符号（逗号、顿号）

不能使用保留字

大小写敏感

变量名命名规则-1.驼峰法2.下划线法

引用型数据类型

多个变量赋值

使用分号分隔

保留字（关键字共35 个）

一级18个-False、None、True、and、as、def、del、elif、else、for、from、if、import、in、is、not、or、while

一级以上17个-assert、async、await、break、class、continue、global、except、finally、lambda、nonlocal、pass、raise、return、try、with、yield

数据类型

不可变数据类型

数字 Number

整型-int

可以使用int()方法将其他类型转化成整型

浮点型-float

可以使用float()方法将其他类型转化成浮点型

字符串 String

可以使用str()方法将其他类型转化成字符串型，可以用+或者*对字符串进行操作

元祖Tuple

可变数据类型

列表List

集合Set

字典Dictionary

常用函数操作

type()函数

eval()函数

类型转换函数：int（）、float（）、str（）

输入输出函数：input（）返回值都是字符串、output（）

input()语句

（1）语法：input(<tips>) 参数说明 tips：提示信息，一般用引号引起来提示输出。 （2）用法：运行代码之后可自定义输入目标数据，返回结果为str（字符串）类型。

print()语句

s='Duan Yixuan' x=len(s) print('The length of %s is %d' %(s,x)) ''' 'The length of %s is %d' 这部分叫做：格式控制符 (s,x) 这部分叫做：转换说明符 % 字符，表示标记转换说明符的开始

一、format用法 相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’ 1.用法1： “{}曰：学而时习之，不亦{}”.format(参数1，参数2) 参数1对应第一个槽，参数2对应第二个槽 2.用法2：槽中包含序号 “{1}曰：学而时习之，不亦{0}”.format(参数1，参数2) 可以通过format()参数的序号在槽中指定参数使用，参数从0开始编号 3.用法3：槽中包含控制信息 {<参数序号>:<格式控制标记>} 其中格式控制标记用来控制参数显示时的格式，格式控制内容如图： ———————————————— 版权声明：本文为CSDN博主「#姚大姚」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_42402648/article/details/109199029

运算符

算术运算符

+、—、*、/、//（取整）、%、**（幂）

比较运算符

>、<、==、>=、<= 、!= 、is、is not

逻辑运算符

and、or、not

赋值运算符

=、+=、-=、*=、/=、%=、**=、//=

运算符的优先级

小括号 -> 单目运算符 -> 算术运算符 -> 关系（比较）运算符 -> 逻辑运算符 -> 位运算符 ->条件运算符 -> 赋值运算符

turtle库

导入库文件

import turtle

画布设置

画布大小及位置

turtle.setup(width, height, start-x, start-y)

可不设置，默认设置为800×600，位于正中央

设置画布和背景颜色

turtle.screensize(canwidth, canheight, bg)

画笔设置

画笔命名

pen = turtle.Pen()

画笔大小和初始化设置

turtle.goto(x, y)

画笔粗细

turtle.pensize(a)-a为画笔的像素数

画笔抬起

turtle.penup()

画笔落下

turtle.pendown()

隐藏画笔

turtle.hideturtle()

设置小海龟形状

turtle.shape()和turtle.Turtle()

“arrow”、“turtle”、“circle”、“square”、“triangle”、“classic”

在画笔处书写文字

turtle.write(arg,move = false, align = 'left', font = ('arial', 8, 'normal'))

与颜色相关的设置

turtle.pencolor(color)

设置画笔颜色

turtle.color(color1，color2 )

同时设置画笔及填充的颜色

turtle.fillcolor(color )

设置填充颜色

turtle.begin_fill()

设置填充的起始点-表示起点

turtle.end_fill()

设置填充的终点-表示终点

turtle.bgcolor(color)

设置画布的背景颜色

画笔操作

前进

turtle.forward(a)

后退

turtle.backward(a)

左转

turtle.left(angle)

右转

turtle.right(angle)

回到原点

turtle.home( )

落笔

turtle.pendown( )

提笔

turtle.penup( )

速度

turtle.speed(a)

绘制原点

turtle.dot(a)

绘制圆形

turtle.circle(radius, extent = none, steps = None)

其他函数

清空并重置

turtle.reset（）

清空窗口

turtle.clear（）

克隆

turtle.clone（）

印章

turtle.stamp（）

停止画笔绘制

turtle.mainloop()和turtle.done()

退出窗口

turtle.exitonclick（）

二级知识点

6种基本数据类型

不可变数据类型

数字 Number

字符串 String

字符串的概念及创建方法

概念：内置的不可变序列

创建方法：1.直接创建，用‘ ’或者“ ”。2.str()命令进行创建，将其他类型转换成字符串

字符串的访问

如a = "python" a[0] 就可以访问p

字符串的截取

st= "中国电子学会python" st[0:6] "中国电子学会"

其他通用操作

len()、in、max()、min()、+、sorted()、index()、count（）

转义字符

\\

反斜杠

“\\” ------\

\'

单引号

“\‘” ------’

\“

双引号

“\"” ------"

\b

退格键

“\b” ------

\n

换行符

\t

制表符

格式化输出

%

%d

格式化整数

print("这是第%d行"%3)

这是第3行

print("这是第%4d行"%3)

这是第 3行

%f

格式化浮点数

print(‘圆周率：%f’%3.1415926)

圆周率：3.1415926

%s

格式化字符串

print(‘圆周率：%.2f’%3.1415926)

圆周率：3.14

format

1、使用format后面的元祖索引位置格式

print（‘1乘以{0}等于{0}，2乘以{1}等于{2}’.format（3,4,8））输出：1乘以3等于3，2乘以4等于8

2、使用命名格式，给每个位置命名

print（‘我叫{name},我会的编程语言有{program1}和{program2}’.format（name = "张三"，program1 = "scratch" ,program2 = "python"））

其他专用操作

字符串分割

split()

分割成列表

格式：字符串名字.（"分隔符"）

字符串连接

join()

字符串连接

格式：“连接符”.join(字符串名)

元祖Tuple

元祖的概念及创建方法

概念：内置的不可变序列

创建方法：1.直接创建，用小括号括起来（）。2.tuple()命令进行创建，将元祖或字符串转换成列表

查找元祖元素（查）

index（）查找元素在元祖中的位置，返回值元祖中的下标

count( ) 统计出现的次数

元祖的排序

sorted()

对可迭代对象进行排序操作，生成新的元祖（因为元祖不可变，所以只能使用sorted，不能使用sort（））

格式：NewTuple = sorted(iterable, cmp = None, key = None, reverse = False) 不改变原列表的值

可变数据类型

列表List

列表的概念及创建方法

概念：内置的有序、可变序列，其中元素不需要相同类型

创建方法：1.直接创建，用中括号括起来[ ]。2.list()命令进行创建，将元祖或字符串转换成列表

添加列表元素（增）

append( obj) - 追加元素（对象）

insert( index, obj) -插入元素 （索引，对象）

删除列表元素（删）

del(index) 删除列表中的指定下标的值，不填写下标则删除整个列表，列表就没了

pop(index)出栈默认删除最后一个元素

remove(obj)删除指定的元素

clear( )清除所有的列表元素，列表还在，只是清空列表，长度为零

更新列表元素（改）

修改列表的值list[2] = ‘a’

查找列表元素（查）

index（）查找元素在列表中的位置，返回值列表中的下标

count( ) 统计出现的次数

列表的排序

sort()

对原列表进行排序，不返回新列表

格式：list_name.sort(cmp = None, key = None, reverse = False)其中三个参数均为可选参数

sorted()

对可迭代对象进行排序操作，生成新的列表

格式：NewList = sorted(iterable, cmp = None, key = None, reverse = False) 不改变原列表的值

列表的反转

内置函数--reverse()

直接反转方向，前后颠倒，会改变原列表的值

集合Set

集合的概念及创建方法

概念：内置的无序不重复元素的集。基本功能包括关系测试和消除重复元素。

创建方法:

1.使用大括号{} ,中间用逗号分隔开

2.使用set()，可以嵌套其他的数据结构

集合的特点：1.无序 2.不重复

集合的添加操作(增)

1、add()方法

把要传入的元素作为一个整体添加到集合中

>>> s=set('one') >>> s {'e', 'o', 'n'} >>> s.add('two') >>> s {'e', 'two', 'o', 'n'}

2、update()方法

是把要传入的元素拆分成单个字符，存于集合中，并去掉重复的字符。可以一次添加多个值

>>> s=set('one') >>> s {'e', 'o', 'n'} >>> s.update('two') >>> s {'e', 'n', 't', 'w', 'o'}

集合的删除操作（删）

1、remove(element)

setVar :为一个set类型的变量 element :表示要查找并删除的元素 函数作用： 在集合setVar中查找element元素，如果存在则删除；如果没找到，则报错。 >>> s=set('one') >>> s {'e', 'o', 'n'} >>> s.remove('e') >>> s {'n', 'o'}

2、discard(element)

setVar.discard(element) setVar :为一个set类型的变量 element :表示要查找并删除的元素 函数作用： 在集合setVar中查找element元素，如果存在则删除；如果没找到，则什么也不做。 >>> sList set([1, 2, 3, 4, 5]) >>> sList.discard(1) >>> sList set([2, 3, 4, 5])

3、pop()

s.pop() s：为set类型的变量 函数作用： 删除并返回set类型的s中的一个不确定的元素，如果为空引发KeyError错误。 >>> sList set([2, 3, 4, 5]) >>> sList.pop() 2

4、clear()

s.clear() s：set类型的变量 函数作用： 清空s集合中的所有元素 >>> sList set([3, 4, 5]) >>> sList.clear() >>> sList set([])

集合的遍历

1、for关键字

集合的遍历跟序列的遍历方法完全一样。 >>> s=set('one') >>> s {'e', 'o', 'n'} >>> for i in s: print(i) ... ... e o n >>>

2、另一种遍历方式：enumerate(s)

另一种遍历方式： >>> s=set('one') >>> s {'e', 'o', 'n'} >>> for idex,i in enumerate(s): print (idex,i) ... ... 0 e 1 o 2 n >>>

集合的其他操作

求交集

Python中求集合的交集使用的符号是“&”，返回连个集合的共同元素的集合，即集合的交集。

Python中求集合的交集使用的符号是“&”，返回连个集合的共同元素的集合，即集合的交集。 >>> st1 = set('python') >>> st1 set(['h', 'o', 'n', 'p', 't', 'y']) >>> st2 = set('htc') >>> st2 set(['h', 'c', 't']) >>> st1 & st2 set(['h', 't'])

求差集

　Python中差集使用的符号是减号“-”。

Python中差集使用的符号是减号“-”。 >>> st1 set(['1', '3', '2', '5', '4', '7', '6']) >>> st2 = set('4589') >>> st2 set(['9', '8', '5', '4']) >>> st1 - st2 set(['1', '3', '2', '7', '6']) 返回的结果是在集合st1中但不在集合st2中的元素的集合。

求并集（合集）

Python中求集合的并集用的是符号“|”，返回的是两个集合所有的并去掉重复的元素的集合。

Python中求集合的并集用的是符号“ ”，返回的是两个集合所有的并去掉重复的元素的集合。 >>> st1 set(['h', 'o', 'n', 'p', 't', 'y']) >>> st3 = set('two') >>> st3 set(['o', 't', 'w']) >>> st1 st3 set(['p', 't', 'w', 'y', 'h', 'o', 'n'])

找集合的不同

查看两个集合的不同之处，使用的difference函数，等价于差集。如： s1.difference(s3)

查看两个集合的不同之处，使用的difference函数，等价于差集。如： s1.difference(s3) 这种不同指的是集合s3相对于集合s1，不同的地方，也就是所有在集合s1中，而不再集合s2中的的元素组成的新集合。 >>> s1 set([1, 2, 3, 4, 5]) >>> s2 set([1, 2, 3, 4]) >>> s1.difference(s2) set([5]) >>> s3 set(['1', '8', '9', '5']) >>> s1.difference(s3) set([1, 2, 3, 4, 5])

集合的范围判断

　集合可以使用大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（！=）来判断某个集合是否完全包含于另一个集合，也可以使用子父集判断函数。

集合可以使用大于（>）、小于（=）、小于等于（ 定义三个集合s1，s2，s3： >>> s1＝set([1, 2, 3, 4, 5]) >>> s2＝set([1, 2, 3, 4]) >>> s3＝set(['1', '8', '9', '5']) 大于（>）或大于等于（>=） >>> s1 > s2 True >>> s1 > s3 False >>> s1 >= s2 True 表示左边集合是否完全包含右边集合，如集合s1是否完全包含集合s2。 小于（ >>> s2 True >>> s1 False >>> s3 False 表示左边的集合是否完全包含于右边的集合，如集合s1是否完全包含于集合s2。 等于（==）、不等于（！=） >>> s1 == s2 False >>> s2 == s3 False >>> s1 != s2 True 判断两个集合是否完全相同。

特殊结合

不可变集合frozenset

Python中还有一种不可改变的集合，那就是frozenset，不像set集合，可以增加删除集合中的元素，该集合中的内容是不可改变的，类似于字符串、元组。 >>> f = frozenset() >>> f frozenset([]) >>> f = frozenset('asdf') >>> f frozenset(['a', 's', 'd', 'f']) >>> f = frozenset([1,2,3,4]) >>> f frozenset([1, 2, 3, 4]) >>> f = frozenset((1,2,3,4)) >>> f frozenset([1, 2, 3, 4]) >>> f = frozenset({1:2, 'a':2, 'c':3}) >>> f frozenset(['a', 1, 'c']) 如果试图改变不可变集合中的元素，就会报AttributeError错误。 不可变集合，除了内容不能更改外，其他功能及操作跟可变集合set一样。

该集合中的内容是不可改变的，类似于字符串、元组。

字典Dictionary

字典的概念及创建方法

概念：内置的可变容器类型，由键值对组成

创建方法：用{}来建立，{键：值}键是唯一的，值不要求唯一

访问字典的两种方法(查)

使用字典名+键访问-字典名[键名]

例子：d = {"西瓜"：9，"樱桃"：12} d["樱桃"]的值等于12

使用字典中的get()函数进行访问

d.get("西瓜")

字典增加键值对（增）

字典加键直接赋值即可，有键则更新，无键则新添

例：d['梨'] = 8

字典删除已有的值（删）

使用del命令删除键值对

例：del d["西瓜"]

字典的修改操作（改）

字典加键直接赋值即可，将原有键值更新

字典的清空操作（清）

清空字典里的所有值

格式：字典名.clear()

序列的操作

通用操作

序列的访问

使用索引值 例：列表是L[3]，元祖是t(3)

序列的嵌套

序列里面再套序列（可以不必一个类型）

序列的截取

使用索引加中括号[ ]的形式截取 语法：变量[头下标：尾下标：步长] 例：t[1:4]t[:3]t[3:]

特点是：包头不包尾（不包含结束索引值）

取序列的长度

len( )-返回该序列的元素的个数

检查元素是否在序列中

in - 检查一个元素是否在序列中，返回逻辑值

找出序列中的最大元素

max（ ）- 方法返回序列中的最大值

找出序列中的最小元素

min( ) - 方法返回序列中的最小值

8、序列求和运算

sum( ) - 返回序列中所有数字的和

9、序列加法运算

使用 “+” 序列合并

10、序列乘法运算

使用 “*” 将序列重复正整数次

专用操作

详见上面数据类型处

流程控制

顺序结构

从上到下

分支结构

单分支结构

if条件表达式:代码块

二分支结构

if条件表达式:......else:.....

多分支结构

if条件表达式:......elif条件表达式:.....等

分支结构的嵌套

循环结构

条件循环（while循环）

格式为：while 判断条件：循环体

遍历循环（for循环）

格式为：for 变量 in 序列：循环体

常用语句：

1.break语句

循环的跳出

2.continue语句

停止当前循环，开启下次循环

计算思维

三级知识点

编码和数制

常用进制

HEX、DEC、OCT 和 BIN含义如下： HEX，英文全称 Hexadecimal，表示十六进制。 DEC，英文全称 Decimal，表示十进制。 OCT，英文全称 Octal，表示八进制。 BIN，英文全称 Binary，表示二进制。

二进制-0b/0B 前缀

基本数码:0和1，逢二进一

八进制 - 0o/0O前缀

基本数码:0、1、2、3、4、5、6、7，逢八进一

十进制

基本数码:0、1、2、3、4、5、6、7、8、9，逢十进一

十六进制-0x/0X前缀

基本数码:0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F， 逢十六进一

进制转换

int(x [,base ]) 将x转换为一个整数 long(x [,base ]) 将x转换为一个长整数 float(x ) 将x转换到一个浮点数 complex(real [,imag ]) 创建一个复数 str(x ) 将对象 x 转换为字符串 repr(x ) 将对象 x 转换为表达式字符串 eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象 tuple(s ) 将序列 s 转换为一个元组 list(s ) 将序列 s 转换为一个列表 chr(x ) 将一个整数转换为一个字符 unichr(x ) 将一个整数转换为Unicode字符 ord(x ) 将一个字符转换为它的整数值 hex(x ) 将一个整数转换为一个十六进制字符串 oct(x ) 将一个整数转换为一个八进制字符串

转二

bin()

返回字符串

转十

int()

返回字符串

转八

oct()

返回字符串

转十六

hex()

返回字符串

数据处理

数据的类型

一维数据

有对等关系的有序或无序数据组成，采用线性方式组成

二维数据

由多个一维数据构成，是一维数据的组合形式

CSV（Comma Separated Values）格式数据

表示

存储

格式化

打开文件open()

打开文件 在Python中打开文件需要使用内置函数open()，它需要两个参数：文件名和打开模式。打开模式包括以下几种： r：只读模式，从文件开头开始读取。 w：写入模式，如果文件存在则清空文件内容，如果文件不存在则创建新文件。 a：追加模式，从文件末尾开始写入，如果文件不存在则创建新文件。 x：排他模式，创建新文件并写入，如果文件已经存在则无法创建文件。 b：二进制模式，用于读取和写入二进制数据，例如图像、视频等。 打开文件的示例代码如下： python Copy code # 打开文件 f = open('file.txt', 'r') # 以只读模式打开文件 # 处理文件 # 关闭文件 f.close() 使用open()函数打开文件后，需要在代码中进行文件操作，操作完成后需要调用close()方法关闭文件。如果不关闭文件，可能会导致文件数据丢失或程序异常退出。

r：只读模式，从文件开头开始读取。

w：写入模式，如果文件存在则清空文件内容，如果文件不存在则创建新文件。

a：追加模式，从文件末尾开始写入，如果文件不存在则创建新文件。

x：排他模式，创建新文件并写入，如果文件已经存在则无法创建文件。

b：二进制模式，用于读取和写入二进制数据，例如图像、视频等。

读入文件

读取文件 打开文件后，可以使用read()、readline()和readlines()等方法读取文件中的数据。 read()方法 read()方法用于读取文件中的所有数据，示例代码如下： python Copy code # 打开文件 f = open('file.txt', 'r') # 读取文件内容 data = f.read() print(data) # 关闭文件 f.close() readline()方法 readline()方法用于读取文件中的一行数据，示例代码如下： python Copy code # 打开文件 f = open('file.txt', 'r') # 读取文件内容 line = f.readline() print(line) # 关闭文件 f.close() readlines()方法 readlines()方法用于读取文件中的所有行数据，并将其存储为列表，示例代码如下： python Copy code # 打开文件 f = open('file.txt', 'r') # 读取文件内容 lines = f.readlines() print(lines) # 关闭文件 f.close()

read()、readline()和readlines()

写入文件

写入文件 除了读取文件，还可以使用write()方法写入文件。write()方法用于向文件中写入数据，如果文件不存在则创建新文件，如果文件已经存在则清空文件内容。示例代码如下： python Copy code # 打开文件 f = open('file.txt', 'w') # 写入文件内容 f.write('Hello, World!') # 关闭文件 f.close()

write()

提取数据

CSV文件的操作

自动关闭with（）

当使用文件读写时，我们需要在操作完成后关闭文件，以释放操作系统资源。为了更方便地管理文件的打开和关闭操作，Python 提供了 with 语句。 使用 with 语句打开文件后，Python 会在操作完成后自动关闭文件，无需手动调用 close() 方法，从而避免忘记关闭文件或因为程序异常而没有关闭文件的情况。 以下是使用 with 语句读取文件的示例： python Copy code with open('example.txt', 'r') as f: content = f.read() print(content) 在这个示例中，with 语句会自动打开名为 example.txt 的文件，并将其赋值给变量 f。在代码块中，我们可以像使用普通的文件对象一样操作 f。当代码块执行完毕后，with 语句会自动关闭文件。 同样，我们也可以使用 with 语句写入文件： python Copy code with open('example.txt', 'w') as f: f.write('Hello, World!') 这个示例会创建一个名为 example.txt 的文件，然后将字符串 Hello, World! 写入文件中。在代码块执行完毕后，with 语句会自动关闭文件。 需要注意的是，使用 with 语句打开文件时，需要在第二个参数中指定文件的打开模式。常见的打开模式包括： r：只读模式，如果文件不存在则抛出异常。 w：写入模式，如果文件不存在则创建文件，如果文件已存在则清空文件。 a：追加模式，如果文件不存在则创建文件，如果文件已存在则在文件末尾追加内容。 x：独占写入模式，如果文件不存在则创建文件，如果文件已存在则抛出异常。 b：二进制模式，可以与上面的模式结合使用，例如 rb 表示二进制读取模式。 除了常见的模式外，还有一些特殊模式，如： +：读写模式，例如 r+ 表示可读可写模式。 t：文本模式，可以与上面的模式结合使用，例如 rt 表示文本读取模式。 在实际使用中，我们需要根据具体需求选择合适的打开模式。

异常处理

概念

在程序运行过程中，如果出现错误或异常，会导致程序停止执行或出现意外的结果。异常处理是一种处理这些错误或异常的机制，可以让程序在出现错误或异常时，能够正常地执行下去，不会因为错误或异常而停止运行。可以使用 try-except 语句来捕获异常并进行处理。当程序运行到 try 语句块时，如果发生了异常，则会跳转到 except 语句块中，并执行相应的处理代码。在Python中，异常处理是通过try-except语句实现的。try语句块包含可能会引发异常的代码，而except语句块包含处理异常的代码。

异常处理是一种处理这些错误或异常的机制，可以让程序在出现错误或异常时，能够正常地执行下去，不会因为错误或异常而停止运行。

语法规则

try: x = int(input("请输入一个整数: ")) print(f"你输入的整数是：{x}") result = 10 / x print(f"10除以{x}的结果是：{result}") except ZeroDivisionError: print("除数不能为0") except ValueError: print("请输入一个整数") except Exception as e: print(f"程序发生了异常：{e}") else: print("程序执行成功") finally: print("程序执行完毕")

try: # 可能会抛出异常的代码块 except ExceptionType1: # 处理 ExceptionType1 类型的异常的代码块 except ExceptionType2: # 处理 ExceptionType2 类型的异常的代码块 except: # 处理其他类型的异常的代码块 finally: # 无论是否有异常都会执行的代码块

算法

概念

解决问题的方法和步骤

特征

有穷性

确定性

可行性

有0个或多个输入

有一个或多个输出

表示方法

自然语言

流程图

处理框：表示要执行的操作或过程的区域。

判断框：用于表示条件或条件语句的区域。

起止框：用于表示流程的起始和结束位置的区域。

连接点：用于连接两个或多个判断框或处理框的区域。

流程线：用于描述流程的线条或连接点。

注释框：用于添加额外的文本说明或解释的区域。

程序设计语言

流程控制

顺序结构

选择结构

循环结构

种类

解析

解析算法是一种用于分析和解决问题的算法，它通常用于求解数学问题、最优化问题和图论问题等。解析算法的主要目的是通过分析问题的数学表达式，找到问题的解决方案。

通过表达式的计算来实现问题的求解

实现方法及步骤

解析算法的实现步骤通常包括以下几个步骤： 定义问题：首先需要明确问题的数学表达式，并将其转化为计算机可以理解的形式。 分析问题：通过分析问题的数学表达式，找到问题的关键因素和约束条件，并确定问题的解决方案。 设计算法：根据问题的数学表达式和关键因素，设计一个合适的算法来解决问题。 实现算法：根据设计的算法，编写代码来实现算法。 测试算法：在实现算法后，需要对算法进行测试，以确保算法的正确性和有效性。 优化算法：在测试算法后，可以对算法进行优化，以提高算法的效率和准确性。 总之，解析算法是一种用于分析和解决问题的算法，其实现步骤包括定义问题、分析问题、设计算法、实现算法、测试算法和优化算法等步骤。

枚举

枚举算法是一种基本的解决问题的算法，它的主要思想是从给定的可能解中逐一枚举出所有的解，直到找到符合要求的解为止。枚举算法通常用于求解组合问题、排列问题和二分查找问题等。

把问题的所有解一一地罗列出来，通过判断寻找真正的解

实现方法及步骤

枚举算法的实现步骤通常包括以下几个步骤： 定义问题：明确问题的要求和约束条件，并将其转化为计算机可以理解的形式。 枚举所有可能解：从问题的所有可能解中逐一枚举出所有的解，直到找到符合要求的解为止。 检查解是否符合要求：在枚举所有可能解后，需要检查每个解是否符合要求。可以使用不同的度量来判断一个解是否符合要求，如最大子序列长度、平均数等。 更新最优解：找到符合要求的解后，可以将其作为最优解。如果最优解不唯一，可以将所有符合要求的解都作为最优解。 重复步骤2-4：重复步骤2-4，直到找到符合要求的解或者无法找到符合要求的解为止。 总之，枚举算法是一种基本的解决问题的算法，其实现步骤包括定义问题、枚举所有可能解、检查解是否符合要求、更新最优解和重复步骤2-4等步骤。

排序

计算机排序算法是一种用于对数据进行排序的算法，它可以将数据元素按照一定的顺序排列

种类

冒泡排序

冒泡排序是一种简单的排序算法，它的基本思想是通过不断比较相邻的元素，将较大的元素向数组的末尾移动，较小的元素向数组的开头移动，从而实现排序。 以下是冒泡排序的简单实现： python 复制代码 def bubble_sort(arr): n = len(arr) for i in range(n): # 提前结束循环的标志 flag = False for j in range(0, n-i-1): # 如果当前元素比后面的元素大，则交换它们的位置 if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] flag = True # 如果没有元素需要交换，则说明已经有序，可以提前结束循环 if not flag: break return arr 在上面的代码中，外层循环控制排序的轮数，内层循环控制每轮比较和交换的次数。在每轮比较中，如果当前元素比后面的元素大，则交换它们的位置，否则不需要交换。最后，如果内层循环结束后仍然没有需要交换的元素，则说明已经有序，可以提前结束循环。 冒泡排序的时间复杂度为O(n^2)，它的空间复杂度也是O(n^2)，因此它不适用于大规模数据的排序。但是，冒泡排序是一种简单易懂的排序算法，它可以用于对数据进行排序，因此在实际应用中仍然有一定的应用价值。

选择排序

选择排序是一种简单的排序算法，它的基本思想是通过不断选择未排序部分中的最小元素，将其放置到已排序部分的末尾，从而实现排序。 以下是选择排序的简单实现： python 复制代码 def selection_sort(arr): n = len(arr) for i in range(n): min_idx = i for j in range(i+1, n): if arr[j] 在上面的代码中，外层循环控制排序的轮数，内层循环控制每轮比较和交换的次数。在每轮比较中，如果当前元素比后面的元素小，则交换它们的位置，否则不需要交换。最后，如果内层循环结束后仍然没有需要交换的元素，则说明已经有序，可以提前结束循环。 选择排序的时间复杂度为O(n^2)，它的空间复杂度也是O(n^2)，因此它不适用于大规模数据的排序。但是，选择排序是一种简单易懂的排序算法，它可以用于对数据进行排序，因此在实际应用中仍然有一定的应用价值。

插入排序

插入排序是一种简单的排序算法，它的基本思想是通过将一个元素插入到已排序的序列中，将其放置到正确的位置，从而实现排序。 以下是插入排序的简单实现： python 复制代码 def insertion_sort(arr): n = len(arr) for i in range(1, n): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j+1] = arr[j] j -= 1 arr[j+1] = key return arr 在上面的代码中，外层循环控制排序的轮数，内层循环控制每轮比较和交换的次数。在每轮比较中，如果当前元素比后面的元素大，则交换它们的位置，否则不需要交换。最后，如果内层循环结束后仍然没有需要交换的元素，则说明已经有序，可以提前结束循环。 插入排序的时间复杂度为O(n^2)，它的空间复杂度也是O(n^2)，因此它不适用于大规模数据的排序。但是，插入排序是一种简单易懂的排序算法，它可以用于对数据进行排序，因此在实际应用中仍然有一定的应用价值。

归并排序

归并排序是一种高效的排序算法，它的基本思想是将一个大的数据集分成两个子数据集，对每个子数据集递归地进行排序，最后将两个有序的子数据集合并成一个有序的数据集。 以下是归并排序的简单实现： python 复制代码 def merge_sort(arr): if len(arr) 在上面的代码中，merge_sort 函数是递归实现的归并排序算法，它将输入数组分成两个子数组，对每个子数组递归地进行排序，最后将两个有序的子数组合并成一个有序的数据集。merge 函数是归并排序的主要实现，它将两个有序的子数组合并成一个有序的数据集。 归并排序的时间复杂度为O(nlogn)，它的空间复杂度也是O(nlogn)，因此它是一种高效的排序算法。但是，归并排序需要进行递归调用，它的实现比较复杂，不适用于大规模数据的排序。

快速排序

快速排序是一种高效的排序算法，它的基本思想是通过选择一个基准元素，将待排序序列分成两个子序列，一个子序列中的所有元素都比基准元素小，另一个子序列中的所有元素都比基准元素大，然后分别对这两个子序列递归地进行快速排序，最终将两个有序的子序列合并成一个有序的数据集。 以下是快速排序的简单实现： python 复制代码 def quick_sort(arr): if len(arr) = pivot] return quick_sort(left) + [pivot] + quick_sort(right) 在上面的代码中，quick_sort 函数是递归实现的快速排序算法，它将输入数组分成两个子数组，对每个子数组递归地进行排序，最后将两个有序的子数组合并成一个有序的数据集。pivot 函数是快速排序的关键，它选择数组的第一个元素作为基准元素，然后将小于基准元素的元素放在左边，大于等于基准元素的元素放在右边。最后，将左边和右边的子数组分别递归地进行快速排序，并将它们合并成一个有序的数据集。 快速排序的时间复杂度为O(nlogn)，它的空间复杂度也是O(nlogn)，因此它是一种高效的排序算法。但是，快速排序需要进行递归调用，它的实现比较复杂，不适用于大规模数据的排序。

希尔排序

希尔排序是一种基于比较的排序算法，它的基本思想是通过不断比较相邻的元素，将较大的元素逐渐“挤”到数组的末尾，从而实现排序。 以下是希尔排序的简单实现： python 复制代码 def shell_sort(arr): n = len(arr) gap = n // 2 while gap > 0: for i in range(gap, n): temp = arr[i] j = i while j >= gap and arr[j - gap] > temp: arr[j] = arr[j - gap] j -= gap arr[j] = temp gap //= 2 return arr 在上面的代码中，shell_sort 函数是递归实现的希尔排序算法，它将输入数组分成两个子数组，对每个子数组递归地进行排序，最后将两个有序的子数组合并成一个有序的数据集。gap 变量控制每一轮比较的间隔，初始值为数组长度的一半，每次循环将间隔减半，直到间隔为1为止。在每一轮比较中，从第gap个元素开始，依次比较相邻的元素，如果前一个元素比后一个元素大，则交换它们的位置，这样一轮比较结束后，最大的元素就会被移动到数组的末尾。重复这个过程，直到所有的元素都被排序。 希尔排序的时间复杂度为O(n^2)，它的空间复杂度也是O(n^2)，因此它不适用于大规模数据的排序。但是，希尔排序是一种基于比较的排序算法，它可以用于对数据进行排序，因此在实际应用中仍然有一定的应用价值。

堆排序

堆排序是一种基于比较的排序算法，它的基本思想是通过建立一个大根堆或小根堆，将待排序序列中的元素逐渐“堆”到数组的末尾，从而实现排序。 以下是堆排序的简单实现： python 复制代码 def heapify(arr, n, i): largest = i l = 2 * i + 1 r = 2 * i + 2 if l arr[largest]: largest = l if r arr[largest]: largest = r if largest != i: arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest) def heap_sort(arr): n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr 在上面的代码中，heapify 函数用于将一个子树调整为大根堆，heap_sort 函数则是递归地将整个数组调整为大根堆。在每一轮堆排序中，首先将根节点与当前未排序部分的最后一个元素交换，然后对剩余的子树递归调用 heapify 函数，直到整个数组都被调整为大根堆。 堆排序的时间复杂度为O(nlogn)，它的空间复杂度也是O(nlogn)，因此它是一种高效的排序算法。但是，堆排序需要进行堆调整，它的实现比较复杂，不适用于大规模数据的排序。

8、计数排序

计数排序是一种非比较排序算法，它的基本思想是通过统计待排序序列中每个元素出现的次数，将元素按照从小到大的顺序排列。 以下是计数排序的简单实现： python 复制代码 def counting_sort(arr): max_value = max(arr) min_value = min(arr) # 初始化计数数组 count = [0] * (max_value + 1) # 计算每个元素出现的次数 for num in arr: count[num] += 1 # 统计每个元素的出现次数 for i in range(1, len(count)): count[i] += count[i - 1] # 将元素按照计数数组的顺序排列 result = [0] * len(arr) for i in range(len(arr)): result[count[arr[i]] - 1] = arr[i] count[arr[i]] -= 1 return result 在上面的代码中，counting_sort 函数是递归实现的计数排序算法，它将输入数组分成两个子数组，对每个子数组递归地进行排序，最后将两个有序的子数组合并成一个有序的数据集。在每一轮排序中，首先找到待排序序列中的最大值和最小值，然后初始化计数数组和计数值。接着，计算每个元素出现的次数，并将计数值存储在计数数组中。然后，将计数数组中的元素按照从小到大的顺序存储在结果数组中，并将计数值更新为对应的元素值。最后，返回结果数组即可。 计数排序的时间复杂度为O(n+k)，其中n是待排序序列的长度，k是待排序序列中最大值和最小值的差值。它的空间复杂度也是O(n+k)，因为它需要额外的空间来存储计数数组。

9、桶排序

桶排序是一种基于比较的排序算法，它的基本思想是将待排序序列中的元素分别放入不同的桶中，然后对每个桶中的元素进行排序，最后将所有桶中的元素合并成一个有序的数据集。 以下是桶排序的简单实现： python 复制代码 def bucket_sort(arr): # 获取最大值和最小值 max_value = max(arr) min_value = min(arr) # 计算桶的数量 bucket_num = (max_value - min_value) // len(arr) + 1 # 创建空桶列表 bucket_list = [[] for _ in range(bucket_num)] # 将元素放入对应的桶中 for num in arr: index = (num - min_value) // len(arr) bucket_list[index].append(num) # 对每个桶中的元素进行排序 for i in range(bucket_num): bucket_list[i].sort() # 将所有桶中的元素合并成一个有序的数据集 result = [] for bucket in bucket_list: result.extend(bucket) return result 在上面的代码中，bucket_sort 函数是递归实现的桶排序算法，它将输入数组分成两个子数组，对每个子数组递归地进行排序，最后将两个有序的子数组合并成一个有序的数据集。在每一轮排序中，首先找到待排序序列中的最大值和最小值，然后计算桶的数量。接着，创建空桶列表，将元素放入对应的桶中，并对每个桶中的元素进行排序。最后，将所有桶中的元素合并成一个有序的数据集，并返回结果数组。 桶排序的时间复杂度为O(n+k)，其中n是待排序序列的长度，k是待排序序列中最大值和最小值的差值。它的空间复杂度也是O(n+k)，因为它需要额外的空间来存储桶列表。

查找

顺序查找

顺序查找是一种最基本的查找方法，它按照从小到大的顺序依次查找每个元素。在计算机中，顺序查找通常使用数组或链表来实现。

二分查找

二分查找是一种高效的查找方法，它将待查找的数据集分成两部分，并分别在这两部分中查找目标元素。通常情况下，我们会将数据集的中间位置作为目标元素的可能位置。二分查找的时间复杂度为O(log n)。

插值查找

插值查找是一种基于函数拟合的查找方法，它可以在有序数组中寻找一个函数值与查找值接近的元素。在计算机中，插值查找通常使用多项式拟合来实现。

哈希查找

哈希查找是一种基于哈希表的查找方法，它可以快速地在大量数据中查找目标元素。在计算机中，哈希查找通常使用哈希表来实现。

布尔查找

布尔查找是一种结合了顺序查找和二分查找的方法，它可以在有序数组中快速查找一个元素是否存在。在计算机中，布尔查找通常使用位运算来实现。

核心函数（69个）

数学运算函数（7个）

abs、divmod、max、min、pow、round、sum

类型转换函数（15个）

bool、int、float、str、ord、chr、bin、hex、tuple、list、dict、set、enumerate、range、object

序列操作函数（6个）

all、any、filter、map、next、sorted

对象操作函数（6个）

help、dir、type、ascii、format、vars

交互操作函数（2个）

print、input

文件操作函数（1个）

open

计算思维

四级知识点

函数的相関概念

函数及过程

函数的参数

匿名函数

自定义函数的创建和调用

创建简单的自定义函数

函数体的概念

自定义函数的调用

函数的返回值

变量作用域

递归和递推

递归方法

由递归变递推的方法

分治算法

分支算法

用分支算法实现简单的python程序

算法优化

算法的概念

算法性能、算法效率的概念

算法时间复杂度和空间复杂度

第三方库（模块）的获取、安装与调用

模块化架构和包的管理

pip命令、集成安装方法和文件安装方法

import和from导入方法

源码文件组成

解释器声明

编码格式声明

模块注释或文档字符串

模块导入

常量和全局变量声明

顶级定义（函数或者类定义）

执行代码