Python三级考试笔记【源源老师】

三级标准

一、 理解编码、数制的基本概念，并且会应用。 1. 能够进行二进制、十进制以及十六进制之间的转换； 2. 理解Python中的数制转换函数。

二、 掌握一维数据的表示和读写方法，能够编写程序处理一维数据。

三、 掌握二维数据的表示和读写方法，能够编写程序处理二维数据。

四、 掌握CSV格式文件的读写方法。

五、 理解程序的异常处理：try-except结构语句。

六、 理解算法的概念，掌握解析、枚举、排序、查找算法的特 征。能够用这些算法实现简单的Python程序。

七、 记住常用核心内置函数的功能及用法。

1. 进制

• 进制，或者称为数制，是一种表示数字的方法。以下是Python中支持的进制及其前缀：

1. 十进制（Decimal）：这是默认的进制，不需要任何前缀。例如，10表示十进制的10。
2. 二进制（Binary）：使用前缀0b来表示。例如，0b10表示二进制的10。
3. 八进制（Octal）：使用前缀0o来表示。例如，0o10表示八进制的10。
4. 十六进制（Hexadecimal）：使用前缀0x或0X来表示。例如，0x10表示十六进制的10。

• 进制对照表：

（1）十进制数转换成二进制数

v = bin(57) #利用了二进制的英文缩写，即bin()函数来转换
print(v) #0b111001

• 以上转换的运算过程：一个十进制数转换为二进制数，只需将该数反复除以2，所得的余数(先从最后一个余数读起)就是二进制的表示形式。

（2）二进制数转换成十进制数

v = int('0b1101',2) #int函数可以将一个字符串转换为整数，并指定这个数的进制
print(v) #13

• 以上转换的运算过程：

（3）十进制数转换成八进制数

v = oct(23) #利用了八进制的英文缩写，即oct()函数来转换
print(v) #0o27

• 以上转换的运算过程：类似十进制转二进制，只不过每次都是除以8

  

（4）十进制数转换成十六进制数

v = hex(28) #利用了十六进制的英文缩写，即hex()函数来转换
print(v) #0x1c

（5）十六进制数转换成二进制数

需求：将十六进制0x1C转为二进制数。

• 方法一：直接利用python内置bin()函数来转换

v = bin(0x1C) 
print(v) #0b11100

• 方法一：通常，如果不借助python中的内置函数，二进制、八进制、十六进制这三者之间是很难做到直接转换的，我们可以借助十进制作为中间人来把我们转换。

  

2. 单位

• 在计算机中，数据存储单位是用来衡量和表示数据大小的标准。以下是一些常见的计算机数据存储单位，从小到大依次为：

1. 位（bit，又称比特）：位是计算机存储数据的最小单位，表示一个二进制数的位，其值只能是0或1。它是计算机中所有数据存储的基础。
2. 字节（Byte）：字节是计算机中用于衡量存储容量的一种基本单位，它由8个位组成。字节是计算机信息处理的基本单位，通常用来表示一个字符、数字或其他字符。在计算机内部，CPU、内存、硬盘等存储设备的容量都是以字节为基础进行计算的。
3. 千字节（KB，KiloByte）：1KB等于1024个字节，通常用于表示较小的文件或数据块的大小。
4. 兆字节（MB，MegaByte）：1MB等于1024个千字节。它通常用于表示较大的文件或数据块的大小，如图片、音频文件等。
5. 吉字节（GB，GigaByte）：1GB等于1024个兆字节。它通常用于表示更大的数据量，如视频文件、大型数据库等。
6. 太字节（TB，TeraByte）：1TB等于1024个吉字节，用于表示非常大的数据量，如大型数据中心或云存储服务的存储容量。

3. 编码

（1）编码

• 将人类可识别的字符转换为机器可以识别的字节码
• 编码是给计算机底层用的，也是机器唯一能看懂的

（2）解码

• 将机器可以识别的字节码转化为人类可以识别的字符
• 解码是显示给人看的，凡是人眼能识别的字符都是要解码过的

#encode() 编码
#decode() 解码

# 举例：利用utf-8编码将文本‘元神启动’编码成bytes字节码
text1 = '元神启动'.encode('utf-8')
print(text1) # b'\xe5\x85\x83\xe7\xa5\x9e\xe5\x90\xaf\xe5\x8a\xa8'

# 举例：将bytes字节码解码成字符串文本
text2 = text1.decode('utf-8')
print(text2) #元神启动

4. 二维数据

• 一维数据：通常表示为一个序列，例如列表（list）或数组（array）。在Python中，列表是最常用的数据结构之一，可以包含任何类型的元素，并且大小是可变的。例如：my_list = [1, 2, 3, 4, 5]

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

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(my_list[1]) #[4, 5, 6]
print(my_list[1][1]) #5

（1）一维数据的读写

• 创建并写入文件

list = ['语文','数学','英语']
file = open('project.csv','w') #创建或打开一个名为 project.csv 的文件，w：表示写入
file.write(','.join(list)+'\n') #写入一个以逗号分隔的字符串
file.close() #关闭文件

• 读取文件

file = open('project.csv','r+') #打开 project.csv 的文件，'r+' ：表示将以读写模式打开
a = file.read().strip('\n') #读取文件的所有内容,同时移除字符串末尾的换行符
b = a.split(',')
file.close()
print(a) #语文,数学,英语
print(b) #['语文', '数学', '英语']

（2）二维数据的读写

• 创建并写入文件

list = [['小红','小明'],['小黄','小王'],['小黑','小白']]
file = open('name.csv','w') #创建或打开一个名为 name.csv 的文件，w：表示写入
for i in list:
    file.write(','.join(i)+'\n')
    print(i,type(i))
file.close()

• 读取文件

file = open('name.csv','r+') #打开name.csv的文件，'r+':表示将以读写模式打开
list = []
for line in file:
    line = line.replace('\n','')
    list.append(line.split(','))
print(list) #[['小红', '小明'], ['小黄', '小王'], ['小黑', '小白']]
file.close()

5. CSV文件

• csv文件：以纯文本的形式存储表格数据

需求：将以下文本数据存储到csv文件中

#导入了csv模块，该模块提供了用于读取和写入CSV文件的类
import csv 

# open: 打开一个csv的文件
# w: 表示写入,如果文件已经存在，它会被覆盖；如果文件不存在，它会被创建
# newline='': 确保在写入行时不会插入额外的空行或换行符
f = open('test.csv','w',newline='')

# 使用csv.writer类创建一个CSV写入器对象，这个对象允许你以CSV格式写入文件
w = csv.writer(f)

# 使用writerow方法写入一行数据
w.writerow(['name','age','score'])

# 使用writerows方法写入多行数据
w.writerows([['Harry','12','98'],['Hermione','10','99'],['Ron','11','95']])

# 关闭文件,确保所有数据都被实际写入到文件中
f.close()

运行以上代码后，test.csv文件创建成功，打开后如图所示：

import csv
f = open('test.csv','r') #'r': 以读取模式打开文件
r = csv.reader(f) #创建一个CSV读取器对象, 便于逐行读取CSV文件的内容
for line in r:
    print(line)
f.close()

#读取结果：
['name', 'age', 'score']
['Harry', '12', '98']
['Hermione', '10', '99']
['Ron', '11', '95']

6. try-except

• try-except的定义：在Python中，try和except语句用于处理运行时发生的异常。try块包含可能引发异常的代码，而except块包含处理这些异常的代码。如果try块中的代码引发了异常，则控制流将立即传递到相应的except块。

以下是一个简单的示例，在这个例子中，我们尝试执行除法操作1 / 0，这会引发ZeroDivisionError异常。由于这个操作位于try块中，因此当异常发生时，控制流会立即传递到except块。在except块中，我们打印一条错误消息。

try:  
    # 尝试执行可能会引发异常的代码  
    x = 1 / 0  
except ZeroDivisionError:  
    # 处理特定的异常类型（这里是除零错误）  
    print("除零错误！")

在except块中处理多种类型的异常。为此，可以使用多个except子句，每个子句处理一种特定类型的异常。例如：

try:  
    # 尝试执行可能会引发异常的代码  
    some_code()
except ZeroDivisionError:  
    # 处理除零错误  
    print("发生除零错误！")  
except TypeError:  
    # 处理类型错误  
    print("发生类型错误！")  
except:  
    # 处理所有其他异常  
    print("发生未知异常！")
finally:  
    # 无论是否发生异常，都会执行的代码  
    print("执行清理操作...")

7. 枚举算法

• 枚举的定义：根据所需解决问题的条件，把该问题所有可能的解，一一列举出来，并逐个检验出问题真正解的方法。枚举法也称穷举法。

（1）判断水仙花数

水仙花数：指一个 n 位数（n≥3），它的每个位上的数字的 n 次幂之和等于它本身。例如，153是一个水仙花数，因为1^3 + 5^3 + 3^3 = 153。

题目：找出100~999整数中的所有水仙花数.

• 方法一：使用while循环

num = 100
while num<1000:
    a = int(num/100) 
    b = int(num%100/10) 
    c = int(num%10)
    if a**3+b**3+c**3==num:
        print(num,'是一个水仙花数')
    num+=1
    
#提示：“/”表示除法，“%”表示取余，“**”表示幂次方

• 方法二：使用for循环

for x in range(100,1000):
    a = int(x/100) #百位数
    b = int(x%100/10) #十位数
    c = int(x%10) #个位数
    if a**3+b**3+c**3==x:
        print(x,'是一个水仙花数')
    x+=1

结果：

（2）鸡兔同笼

有一个笼子，里面有鸡和兔子。我们知道总共有7个头和18只脚，我们要找出有多少只鸡和多少只兔子。

假设笼子里有 x 只鸡和 y 只兔子。根据题目，我们可以建立以下方程：

1. 头的总数是 x + y = 7（鸡和兔子的头数加起来）。
2. 脚的总数是 2x + 4y = 18（鸡有2只脚，兔子有4只脚，总脚数就是2倍的鸡脚数加上4倍的兔脚数）。

现在我们要来解这个方程组，找出 x 和 y 的值。计算结果为： {x: 5, y: 2}。所以，笼子里有 5 只鸡和 2 只兔子。

以上我们用的是数学中列举方程的形式求解，我们也可以利用枚举法，通过python代码帮我们计算最终的结果。

• 枚举的思路如图所示：一一列举，最终得到总的脚数量为18的组合，答案即为5 只鸡和 2 只兔子。

# 使用while循环求解
head = 7 #鸡和兔总的个数
foot = 18 #鸡和兔总的脚数量
checkin = 0
rabbit = 0
while True:
    if 2*checkin+4*rabbit == 18:
        break   
    checkin += 1
    rabbit = head-checkin
print(checkin,rabbit) #5 2

-----------------------------------
# 也可使用for循环求解
for i in range(1,head):
    if 2*checkin+4*rabbit == 18:
        break   
    checkin+=1
    rabbit = head-checkin
print(checkin,rabbit) #5 2

8. 冒泡排序

思路：

• 比较所有相邻的元素，如果第一个比第二个大，则交换他们。
• 一轮下来，可以保证最后一个数是最大的。
• 以此类推，执行n-1轮，就可以完成排序。

list = [5,2,9,1,3,4]
L = len(list)
def fn(list):
    for i in range(0,L):
        for j in range(0,L-1-i):
            if list[j]>list[j+1]:
                list[j],list[j+1] = list[j+1],list[j]
    return list
print(fn(list))

9. 选择排序

• 方法一，思路：

• 找到数组中的最小值，把他更换到列表中的第一位。（具体做法：先假设第一数为最小值，记录它的索引值，将第一数和第二个数作比较，如果第一个数大于第二个数则交换他们，此时最小值变为两者中较小的一个数；接着用最小值和下一个数继续比较，如果最小值大于下一个数，则交换他们的值，依次循环比较，一轮比较下来，最小值就会被找到，并且更换到最开始的位置。
• 接着找到第二小的值，把他更换到列表中的第二位。
• 以此类推，执行n-1轮，就可以完成排序。

代码如下：

list = [5,2,9,1,3,4]
L = len(list)
def fn(list):
    for i in range(0,L-1):
        min = i
        for j in range(i,L):
            if list[min]>list[j]:
                list[j],list[min]=list[min],list[j]
    return list
print(fn(list))

• 方法二，思路：

• 找到数组中的最小值，把他更换到列表中的第一位。（具体做法：与方法一类似，只不过内层循环每次都是去记录最小值所在的位置，一轮比较结束后，可以获得最小值所在的位置，然后再和最开头的元素进行交换。
• 接着找到第二小的值，把他更换到列表中的第二位。
• 以此类推，执行n-1轮，就可以完成排序。

list = [5,2,9,1,3,4]
L = len(list)
def fn(list):
    for i in range(0,L-1):
        min = i
        for j in range(i,L-1):
            if list[min]>list[j+1]:
                min = j+1
        list[i],list[min]=list[min],list[i]
    return list
print(fn(list))       

10. 插入排序

思路：

• 从第二个数开始往前比。
• 如果第二个数比第一个数小，则需要交换他们的位置；再让第三个数和前两个数依次比较（从第二个数开始对比），如果第三个数比其中任何一个数小，则同样需要交换位置。
• 以此类推，进行到最后一个数。

举例：假如已经进行到31这个数了，31前面的数我们已经插入排序完毕了；那么对于31这个数，我们需要先将其与93比较，31<93，交换位置；接着比较31<77，交换位置；接着比较31<54，交换位置；接着比较31>26，不需要交换位置了，此时内层循环可以结束了。

初版代码：

list = [5,2,9,1,3,4]
L = len(list) 
for j in range(1,L):
    while j>0:
        if list[j]<list[j-1]:
            list[j],list[j-1]=list[j-1],list[j]
        j-=1
        print(list)

结果：

注意：从打印结果看，我们会发现内层循环会多了一些不必要的排序的比较，比方说：现在列表的顺序是这样的：[2, 5, 9, 1, 3, 4]，但我们对9这个数字做插入排序比较的时候，会发现9>5，不需要交换位置；从代码的书写来看，j递减一之后，还会做5和2的比较，虽然5>2，不需要交换位置，但是这样的打印次数就增多了，所以代码是存在优化的空间的。也就是所，对于已经排序好的数字，其实我们是不再需要做对比的，这样可以减少内层循环，即while循环的次数。

代码改进：

list = [5, 2, 9, 1, 3, 4]
L = len(list)
for j in range(1, L):
    while j > 0 and list[j] < list[j - 1]:
        list[j], list[j - 1] = list[j - 1], list[j]
        j -= 1
        print(list)

结果：

11. 顺序查找

思路：

• 遍历列表。
• 找到跟目标值相等的元素，就返回他的下标。
• 遍历结束后，如果没有搜索到目标值，就返回-1。

list = [5,2,9,1,3,4]
L = len(list)
num = input('请输入您要查找的数字：')
num = int(num)
for i in range(0,L):
    if num==list[i]:
        print('您查找到的数字其索引值为：',i)
        break
else:
    print('找不到该数字!')

注意：该else语句与for循环相关联，而不是与if语句相关联。如果for循环完成时没有遇到break，则意味着在列表中未找到该数字，else将会被执行。这个写法应该是 Python 特有的，与其他编程语言略有不同。

12. 二分查找

【注意】：二分查找的前提是数字是排序好的。

思路：

• 从数组的中间元素开始，如果中间元素正好是目标值，则搜索结束。
• 如果目标值大于或者小于中间元素，则在大于或小于中间元素的那一半数组中搜索。

list = [1, 2, 3, 4, 5, 9]
L = len(list)
left = 0
right = L-1
target = 9
while left<=right: #这里的判断是left<=right;避免查找的元素处于边缘位置，而没有查找到的情况。
    mid = (left+right)//2 #地板除：只保留整数
    if list[mid]<target:
        left = mid+1
    elif list[mid]>target:
        right = mid-1
    else:
        print('您查找的数字其索引值为：',mid)
        break
else:
    print('找不到该数字!')