Python计算机二级考试复习指南（考前必备）：基于真题的考点提炼与全面覆盖复习资料

一、Python中的数据类型

1.数字类型

int: 整数 (3, -4)

float: 浮点数 (-1.72, 3.14)

bool: 布尔值 (True, False) 注意：在python内部，默认将True当作1处理，将False当作0处理

complex: 复数(-1+2j, 3-4j)

a = 4
b = 5.67
c = 8 + 2j
d = True

1.1 进制

bin(): 将十进制整数转换为二进制表达 (二进制字符串以0b开头)

oct(): 将十进制整数转换为八进制表达 (八进制字符串以0o开头)

hex(): 将十进制整数转换为十六进制表达 (十六进制字符串以0x开头)

int(): 将任意进制数转换为十进制整数

bin(225) # 其中'0b'是前缀，'11100001'是二进制数
oct(225) # 其中'0o'是前缀，'341'是二进制数
hex(225) # 其中'0x'是前缀，'e1'是二进制数

# 注意：非十进制字符串，必须指定第二个参数，第二个参数代表进制，可取2~36
int('0b11100001', 2) # 将二进制转换为十进制整数
int('0o341', 8) # 将八进制转换为十进制整数
int('0xe1', 16) # 将十六进制转换为十进制整数
int('1013', 6) # 将六进制转换为十进制整数

1.2 运算符的优先级

优先级从高到低：

1) 括号: ( ), [ ], { }

所有优先级规则均可被括号覆盖，强制改变运算顺序

print((3+4)*2)

2) 幂运算 (从右往左算):

具有右结合特性，多个幂运算符时从右向左计算

print(2**3**2)
print((2**3)**2)
print(2**(3**2)) # 与 2**3**2 等价

3) 单目运算符: +x, -x, ~x

用于数值符号，按位取反操作

按位取反(~x)：在计算机中整数以补码形式存储，正数的补码与原码相同，取反后符号位变为负，再根据补码规则还原为十进制值；负数的补码需先取反再转回原码

print(-3*5) # 与 (-3)*5 等价
print(2*~5) # 与 2*(~5) 等价，其中按位取反(~5) = 6

4) 乘除类运算符: *, @(矩阵乘法), /, //, %

同一优先级，左结合

print(3 + 5 % 6 * 2 // 8) # 从左往右，先取余，再相乘，再整除
print(3 + (((5 % 6) * 2) // 8))

5) 加减类运算符: +, –

左结合，注意字符串拼接与数值运算的差异

print(6 - 4 + 18 // 8) # 从左往右，先减再加

6) 位与 & ，位异或 ^ ，位或 |¶

flag = {2,3} ^ {2,4,6} | {4,5,6} & {2,3,5,9}
"""等价于 ({2,3} ^ {2,4,6}) | ({4,5,6} & {2,3,5,9}) = {3,4,6} | {5} = {3, 4, 5, 6}"""
print(flag)

7) 比较运算符: >, >=, <, <=, ==, !=

支持链式比较，优先级高于逻辑运算符

print(11 <= 22 < 33 and 3 > 5)
"""等价于 ((11 <= 22) < 33) and (3 > 5) = (1 < 33) and (3 > 5) = True and False = False"""

8) 逻辑运算符: not > and > or

优先级有区别：逻辑非 > 逻辑与 > 逻辑或

print(6 > 3 or 12/0) # 未出现报错 ZeroDivisionError: division by zero
print(3 > 1 and not 4 > 6) # 等价于 (3 > 1) and (not 4 > 6)

9) 赋值运算符: =, +=, -=

x = 2
y = 3
x += y
print(x)

1.3 数字与字符的转化 (Unicode)

chr(num): 将数字(Unicode码)转化为字符char，返回str字符串类型

ord(char): 将字符char转化为整数(Unicode码)，返回int整数类型

你知道吗，"0"对应的Unicode码为48，"A"对应的Unicode码为65，"a"对应的Unicode码为97，且我们知道一共有10个阿拉伯数字，26个英文字母，那么，就让我们根据这些信息，结合这一知识点，将它们全部打印出来吧！

# 打印10个阿拉伯数字
a = 48
for i in range(10):
    num_str = chr(a + i)
    print(num_str, end = ',')

# 打印26个英文大写字母
b = 65
for i in range(26):
    print(chr(b + i), end = ',')

# 打印26个英文小写字母
c = 97
for i in range(26):
    print(chr(c), end = ',')
    c += 1

1.4 转义字符

\n: 换行符。将光标移动到下一行行首，用于文本换行

\t: 水平制表符。插入相当于Tab键的空格

\': 在单引号包裹的字符串中插入单引号

\": 在双引号包裹的字符串中插入双引号

\r: 回车符，将光标移动到当前行首，覆盖已有内容(常用于动态进度条的更新)

\b: 退格符，删除前一个字符(常用于删除错误输入)

\v: 纵向制表符。垂直对齐文本

\0: 空字符。表示ASCII空字符(NULL)，常用于字符串终止或占位

\f: 换页符。在打印时强制换页(多用于打印机控制)

2. 序列类型

序列包括 字符串、列表、元组

str: 字符串，不可变的字符序列 ("Hello World")

list: 列表，可变的元素序列 ([1,'a',3.14])

tuple: 元组，不可变的元素序列((1,'a',3.14))

s = 'python' # 字符串
lst = ['Name', 24, 65.5] # 列表
tup = ('Name', 60, 74.9) # 元组

2.1 字符串的“增”、“删”、“改”、“查”

字符串为不可变序列，所有操作均生成新的字符串，原始字符串不变。

“增”

'_' . join(iterable): 以指定的连接符连接可迭代对象中的元素，返回字符串

# 通过简单的加法直接添加字符串
s = "Hello"
s += "World"
print(s)

tup = ('My','dog','is','3','years','old') # join用于连接字符串，故连接的对象中必须全部为字符串，不能有数值，如3必须为'3'
'_'.join(tup) # 以指定的连接符连接可迭代对象中的元素，返回字符串

chinese = ['今天','晚上','吃','什么','？']
''.join(chinese)

“删”

s.strip(chars = None): 掐头去尾，删除字符串首尾指定的chars元素，默认删除存在于首位的转义符(如果有的话)，并返回字符串

s = "HelloWorld"

# 删（不能直接删除的内容，可通过切片操作跳过部分字符）
s[:1] + s[-4:]

sentence = "\nI am fine, thank you. And you?\n"
sentence.strip() # 掐头去尾，删除字符串首尾指定的char元素，默认删除存在于首位的转义符(如果有的话)，并返回字符串

time = "1012"
index = "10" # 删除可能存在于字符串首尾的"10"字符串
time.strip(index)

chinese = ['今天','晚上','吃','什么','？']
('*'.join(chinese)).strip("今天")    # 删除可能存在于字符串首尾的"今天"字符串

“改”

s.replace(old, new, [,count]): 用new替换old，返回新的字符串，count为替换数量，默认替换所用(功能与word文档中的查找与替换相当)

s.split(sep = None, maxsplit = -1): 从前往后通过sep对string切分，返回切分子串组成的列表

s.upper(): 文本内容全部改为大写

s.lower(): 文本内容全部改为小写

s.title(): 文本内容首字母大写

sorted(s, key = None, reverse = False): 返回一个新的列表，在列表中实现对字符串s中的字符进行排序，默认从小到大，可通过key自定义元素处理函数

s = "HelloWorld"

# 替换
s.replace('o','X',1) # 使用'X'替换'o',只替换1个(如果不指定，则默认替换所有)

# 切分
sentence = "\nI am fine, thank you. And you?\n"
sentence.split(' ') # 指定分隔符，对字符串进行切分，返回一个列表

sentence.split() # 采用默认方式切分，比较一下与空格切分有什么不同呢

# 文本内容全大写
my_college = "institute of disaster prevention"
print(my_college.upper())

# 文本内容全小写
my_college = "Institute of DISASTER PREVENTION"
print(my_college.lower())

# 文本内容首字母大写
my_college = "institute of disaster PREVENTION"
print(my_college.title())

# 按照从大到小的顺序排列字符串，并返回字符串列表
sorted(s, reverse = True) # 返回一个新的顺序列表，不改变原可迭代对象的值
# 通过直接对unicode码排序，达到与上方相同的排序对应字符的效果
lst = list()
for i in s:
    lst.append(ord(i))
lst.sort(reverse = True) # 直接对原可迭代对象进行修改
sort_list = [chr(val) for val in lst]
print(sort_list)

“查”

len(s): 输出字符串s的总长度

max(s)/min(s): 根据字符在Unicode码中所处的位置顺序返回s中的最大/最小值

s.find(sub[,start[,end]]): 返回子串sub在s中第一次出现的位置，不存在则返回-1，start与end用于限定查找范围

s.index(sub[,start[,end]]): 从前往后查找，返回子串sub在s中第一次出现的位置，不存在时直接报错

s.count(sub[,start[,end]]): 返回子串sub在s中出现的次数

s = "HelloWorld"
# 输出总长度
len(s)

max(s) # 根据字符在Unicode码中所处的位置顺序决定最大值

lst = []
for i in range(len(s)):
    lst.append(ord(s[i]))
chr(max(lst)) # 通过直接比较字符Unicode码来输出最大Unicode码对应的字符

min(s) # 根据字符在Unicode码中所处的位置顺序决定最小值

lst = []
for i in s:
    lst.append(ord(i))
chr(min(lst)) # 通过直接比较字符Unicode码来输出最小Unicode码对应的字符

# 查找
s.find('m') # 返回substring第一次出现位置的索引，不存在时返回-1

# 查找
s.index('o') # 返回substring第一次出现位置的索引，不存在时报错

# 统计次数
s.count('l') # 返回substring在整个字符串中出现的次数

2.2 列表的“增”、“删”、“改”、“查”

“增”

lst.append(obj): 在列表末尾逐个添加obj对象

lst.insert(obj): 指定索引逐个插入obj对象

lst.extend(iterable): 在lst末尾扩展列表，将可迭代对象中的所有元素添加到lst末尾

# 在列表末尾添加元素
new_list = [4,3,2,1]
for val in new_list:
    my_list.append(val)
print(my_list)

# 先指定索引，再根据索引插入元素
my_list.insert(2,5)
print(my_list)

# 在末尾扩展列表，将可迭代对象元素添加到末尾
my_list.extend(new_list)
print(my_list)

# 在末尾扩展列表，将可迭代对象元素添加到末尾
tup = ('Xu', 23661427)
my_list.extend(tup)
print(my_list)

“删”

lst.pop(index = -1): 将index对应列表中的元素弹出，默认弹出列表末尾元素(列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素，且弹出的元素仍然可以继续使用)

lst.remove(value): 删除在列表中第一次出现的value，如指定的value不存在则报错

lst.clear(): 清空列表

my_list = ['a','b','c','a','b','b','c','c','c','d']

# 列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素，且弹出的元素仍然可以继续使用
get_jump = list()
for i in range(len(my_list)):
    get_jump.append(my_list.pop())
print(get_jump, my_list)

# 删除在列表中第一次出现的value
my_list.remove('c')
print(my_list)

# 清空列表
my_list.clear()
print(my_list)

“改”

列表中的元素可以通过索引直接进行访问和修改

sorted(lst, key = None, reverse = False): 返回一个新的列表，在列表中实现对列表lst中的元素进行排序，默认从小到大，可通过key自定义元素处理函数

lst.sort(key = None, reverse = False): 直接在原列表lst上进行排序操作，不返回任何新对象，默认从小到大，可通过key自定义元素处理函数

my_list = ['a','b','c','a','b','b','c','c','c','d']
my_list[7] = 'd'  # 通过索引直接进行访问并修改
print(my_list)

new_list = sorted(my_list) # 返回一个新的顺序列表，不改变原可迭代对象的值
print(my_list)
print(new_list)

new_list = my_list.sort() # 直接对原可迭代对象进行修改，不返回任何新对象
print(my_list)
print(new_list)

“查”

len(lst): 返回列表的长度(元素数量)

max(lst)/min(lst): 返回列表元素中的最大值/最小值

lst.index(value[,start[,stop]]): 返回value第一次在lst中出现的位置索引，通过定义start,stop来限定范围

lst.count(value): 统计value在lst中出现的总次数

my_list = ['a','b','c','a','b','b','c','c','c','d']
# 返回列表的长度(元素数量)
len(my_list)

# 返回列表中元素的最大/最小值
max(my_list)
min(my_list)

# index(val): 返回val第一次出现的位置
my_list.index('b') 

# count(val): 统计val在列表中出现的总次数
my_list.count('b')

2.3 元组的“增”、“删”、“改”、“查”

“增”

通过加法运算即可将新元组中的元素添加到原元组tup中

# 加法运算
tup = ('national_day', 1001, 1007)
tup += ('mid_autumn_festival', 815, 817)
print(tup)

“删”

del tuple: 无法对元组内部的元素进行局部删除只能一次性删除整个元组

tup = ('a', 100) 
del tup[0] # 报错，显示不支持删除元组中的元素(TypeError: 'tuple' object doesn't support item deletion)
del tup # 无法对元组内部的元素进行局部删除只能删除整个元组

“改”

虽然不能直接修改元组，但是可以通过转换为列表来间接实现修改

sorted(tup): 返回一个新的列表，在列表中实现对元组tup中的元素进行排序，默认从小到大，可通过key自定义元素处理函数

tup = ('xu', 24)
tup[0] = 'hu' # 报错，显示不支持修改元组中的元素(TypeError: 'tuple' object does not support item assignment)

# 虽然不能直接修改元组，但是可以通过转换为列表来间接实现修改
tmp_lst = list(tup)
tmp_lst[0] = 'hu'
tup = tuple(tmp_lst)
print(tup)

tup = ('H', 'E', 'L', 'L', 'O')
new_tup_lst = sorted(tup)  # 返回一个新的列表，在列表中将元组中的元素按照Unicode码从低到高的顺序重新排序
print(new_tup_lst)

“查”

len(tup): 返回元组tup的长度(内部元素个数)

max(tup)/min(tup): 返回元组tup中元素的最大值/最小值

tup.index(value): 返回value第一次在元组tup中出现的位置索引

tup.count(value) 统计value在元组tup中出现的总次数

tup = ('W','O','R','L','D','W','I','D','E')
len(tup) # 元组长度(字符数量)
max(tup) # 最大值
min(tup) # 最小值

# 返回D第一次在元组tup中出现的位置索引
tup.index('D')

# 统计D在元组中出现的次数
tup.count('D')

3. 映射类型

二级考试最后的应用题主要会考察两大题型：一是对文本文件中字符的统计与处理，二是.csv文件信息提取与字符串切片。而对这些文件进行处理的整体思路，就是将原本散乱的字符串，按照规则和顺序分门别类存储在列表或字典中，然后通过调用列表、字典类型的相关方法或函数，完成统计、排序、提取、数据切片等任务。

dict: 字典，键值对(key-value pair)的集合. 如：{'name':'Xu', 'age':24}

3.1 字典类型的函数

len(d): 字典d中的键值对(key-value pair)个数

min(d)/max(d): 字典d中“键”的最小/最大值

dict(): 生成空字典

# 二级考试大题题型一：文本统计与处理
# 找到文本中出现次数最多的字母
creed = """
        Where other men blindly follow the truth, remember, NOTHING IS TRUE.
        Where other men are limited, by morality or law, remember, EVERYTHING IS PERMITTED.
        To say that NOTHING IS TRUE, is to realize that the fundations of society are fragile, 
        and that we must be the shepherds of our own civilization.
        To say that everything is permitted, is to understand that we are the architects of our actions,
        and that we must live with their consequences, whether glorious or tragic.
        """
# 字典计数器
# 首先生成空字典
d = dict()
for letter in creed.strip().lower():
    d[letter] = d.get(letter,0) + 1
symbols = ['\n',' ',',','.'] 
for s in symbols:
    del d[s]
# 通过len(d)来获取字典中键值对的个数
print(len(d))
# max默认输出字典中 “键” 的最大值，但是由于d.items()将字典中的键值对以元组形式排开在列表中，故可以通过lambda x: x[1]的方式来获取值，并最终返回这一值所在的元组
print(max(d.items(), key = lambda x: x[1]))

3.2 字典类型的操作方法

d.keys(): 返回d的“键”信息

d.values(): 返回d的“值”信息

d.items(): 返回d的“键值对”元组组成的列表

d.get(a,b): 若a是字典中的“键”则返回“键”对应的值，否则返回b

d.pop(a,b): 若a是字典中的“键”，则弹出对应的“键值对”，并返回对应的“值”，否则返回b

d.clear(): 删除所有键值对

# 二级考试大题题型一：文本统计与处理
# 统计字数
creed = """
        Where other men blindly follow the truth, remember, NOTHING IS TRUE.
        Where other men are limited, by morality or law, remember, EVERYTHING IS PERMITTED.
        To say that NOTHING IS TRUE, is to realize that the fundations of society are fragile, 
        and that we must be the shepherds of our own civilization.
        To say that everything is permitted, is to understand that we are the architects of our actions,
        and that we must live with their consequences, whether glorious or tragic.
        """
# 字典计数器
d = {} # 字典的另一种创建方式
for letter in creed.strip().lower(): # 
    d[letter] = d.get(letter,0) + 1

# 与停用词表(stopwords)作用相同，这里用于去除转义符以及简单的标点符号
symbols = ['\n',' ',',','.'] 
for s in symbols:
    del d[s]

# 从多到少排序
lst = list(d.items())
lst.sort(key = lambda x: x[1], reverse = True)
print(','.join(["{}:{}".format(item[0], item[1]) for item in lst]))

正确使用相关方法与属性的前提，是要搞清楚通过调用不同方法和属性得到的结果的数据结构

接下来让我们一起来看一下吧：

print(d.keys()) # 返回 “键” 组成的列表
type(d.keys())

print(d.values())  # 返回 “值” 组成的列表
type(d.values())

print(d.items())  # 返回 “键值对” 组成的元组，并排开在列表中
type(d.items())

二级考试大题题型二：.csv文件信息提取与字符串切片
	节假日	开始月日	结束月日
0	元旦	1230	101
1	春节	215	221
2	清明节	405	407
3	劳动节	501	503
4	端午节	616	618
5	中秋节	922	924
6	国庆节	1001	1007

上面的表格来自二级考试真题，可作为题型二的代表，接下来让我们先看一下如何解决问题：

# 二级考试大题题型二：.csv文件信息提取与字符串切片

# 首先将上述表格转化为列表形式
with open(fpth,'r', encoding = 'utf-8') as f:
    df = f.readlines()

vac_info = []
for info in df[1:]:
    vac_info.append(info.strip().split(','))
print(vac_info)

while True:
    data = input("请输入假期名称(以空格间隔)，将显示假期及其对应的放假时间:")
    if data == 'q':
        break
    user_input = data.split(' ')
    d = {}
    for item in vac_info:
        d[item[1]] = item[2:]
    print(d)
    for idx, flag in enumerate(user_input):
        if flag not in d.keys():
            print("未查询到假期！")
            continue
        startM = d[flag][0][:-2]
        startD = d[flag][0][-2:]
        endM = d[flag][1][:-2]
        endD = d[flag][1][-2:]
        print("{}假期从{}月{}日到{}月{}日".format(flag, startM, startD, endM, endD))

大家可自行将表格保存为.csv文件格式，然后自己动手试一试吧！

二、格式化输出

操作题第一题常驻嘉宾，没什么好说的，记住几个抽象但固定的表达方式就好啦

# eval()的作用：将字符串作为python表达式执行并返回结果
eval("2 + 4")

# {: 符号 + 位置 + 总计字符数}
"{:*^9}".format(2) # ^代表输入内容居中对齐
"{:&>5}".format(3) # >代表输入内容右对齐
"{:$<6}".format(45678) # <代表输入内容左对齐

"{:.2f}".format(3.14159) # 保留小数点后2位
"{:,}".format(1234567) # 添加数字的千分位符
"{:b}".format(5) # 将十进制数转化为二进制数

接下来大家实操一下吧，又来一道真题：

01 >
02 >>
03 >>>
04 >>>>
05 >>>>>
06 >>>>>>
07 >>>>>>>
08 >>>>>>>>
09 >>>>>>>>>
10 >>>>>>>>>>
11 >>>>>>>>>>>
12 >>>>>>>>>>>>

请编写代码，用户输入不大于20的正整数，要求达到以上输出效果（代码就在下面~）

get_num = eval(input("请输入不大于20的正整数:"))
for i in range(get_num):
    print("{:0>2} {}".format(i+1, ">"*(i+1)))

三、文件

二级考试中，对于文件，主要考察文本文件或csv文件的打开、读取、写入、保存、关闭，这就要求我们能够结合自己的需求使用正确的文件处理命令，同时对不同方式处理得到结果的形式要熟悉，如同样是读取文件，对于文本文件可能采用read()命令，而对于.csv文件则可能采用readlines()命令，条条大路通罗马，但是采用不同的方法，实现相同功能和目标的时间成本可能会截然不同。

最后一点——不要忘记.close()关闭文件！不要忘记.close()关闭文件！不要忘记.close()关闭文件！

2.1 加载文件

open(fpath, mode='r', encoding=None): 打开文件

fpath: 支持绝对路径和相对路径（绝对路径是从文件系统或网络资源的根目录开始的完整路径，如r"D:\Desktop\test.txt"；相对路径以当前文件所在目录为基准，通过层级关系定位目标文件或资源，比如你把代码写在了"D:\Desktop"目录下，且你想要打开的test.txt文件也在该目录下，那么直接传入字符串r"test.txt"即可）

mode: 打开文件的模式:

 (1) "r": 只读模式

 (2) "w": 写入模式(文件一旦通过此模式打开，原先的内容被清空)

 (3) "a": 追加模式(不清空文件当前内容，继续追加)

 (4) "x": 新建唯一写入文件(只写)

 (5) "r+"/"w+": 读写方式打开

 (6) "rb","wb","rb+","wb+": 二进制读写，用于图片、二进制文件的读取或写入

encoding: 编码格式，一般采用"gbk"或"utf-8"

# 文件打开的两种方式：

# 正常打开
fpath = r"test.txt"
f = open(fpath, 'r', encoding = 'utf-8')
data = f.read()
f.close() # 最后一步不要忘记用 f.close() 关闭文件 f！最好是与 f = open() 同时写入代码行！

# with语句打开(with语句能够确保f.close()始终执行，不需要再另外编写f.close()，确保文件始终会被正确关闭，避免内存泄漏和文件句柄耗尽)
fpath = r"test.txt"
with open(fpath, 'r', encoding = 'utf-8') as f:
    data = f.read()

2.2 读

read(a): a表示要从文件中读取的数据长度(即字节数)，若没有传入a，则默认读取文件中的所有数据，并返回字符串
readline(): 一次性读取一行内容
readlines(): 返回包含整个文件内容的列表，列表中的每个元素代表文件中的一行，换行处由转义符"\n"表示

fpath = "test.txt"
f = open(fpath, 'r')
data = f.read() 
print(data, type(data))  # 将文件中的所有文本以字符串形式呈现
f.close()

fpath = "test.txt"
f = open(fpath, 'r')
data = f.readline() 
print(data, type(data))  # 将文件中的第一行文本以字符串形式呈现
f.close()

fpath = "test.txt"
f = open(fpath, 'r')
data = f.readlines() 
print(data, type(data))  # 返回以文件中每一行文本为元素的列表
f.close()

2.3 写

write(s): 将字符串s的全部内容写入文件
writelines(s): 把字符串列表写入文件，不添加换行符，注意写入的对象是字符串列表

# 二级考试大题题型一：文本统计与处理
# 统计字数
from collections import Counter

# 打开文件
fpath = "test.txt"
with open(fpath, 'r') as f:
    data = f.read()
c = Counter(data.strip().lower()) # 返回Counter类字典，故可以完全按照字典方法对其进行处理

# 删除符号
for s in [' ','\n',',','.']:
    del c[s]

# 输出文本文件
save_path = r"D:\Desktop\counter.txt"
fo = open(save_path, 'w')
fo.write(','.join(["{}:{}".format(item[0], item[1]) for item in c.most_common()]))
fo.close()

2.4 查

seek(cookie, whence): 把文件指针移动到新的位置

 (1) cookie: 偏移量
 (2) whence: 偏移位置（0: 文件开头；1: 当前位置；2: 文件结尾）

四、jieba分词

列表的倒叙操作 [::-1]

lst = ['zhi',23,'wei',19] # 队尾变队首
lst[::-1]

jieba分词成列表

jieba.lcut() 返回中文列表

import jieba
txt = input("请输入一段文本，我们将让它倒序输出:")
lst = jieba.lcut(txt)  # 对中文分词后返回列表
for word in lst[::-1]: # [::-1]使列表倒序输出
    print(word, end = '')

五、海龟先生turtle

为了激发青少年对于学习python的兴趣，蟒蛇先生请来了他最好的伙伴——海龟先生。

通过告诉海龟先生一些非常简单的指令，他就可以画出十分精美的图形。想要学习这些指令，与海龟先生深入交流的话，强力推荐B站@小王老师教编程《最轻松的Python入门课，5节课掌握海龟绘图》。先跟着老师学习海龟先生的绘画习惯，聪明的海龟先生能听懂的指令很多，不可能一次都学完，但是只要掌握了交流的逻辑与框架，相信你就可以与海龟先生共度一段美好的时光！

import turtle as t 

# 真题示例1：绘制五角星
for i in range(5):
    t.fd(200) # 向前直走200像素长度
    t.right(144) # 右转144度

# 真题示例2：绘制菱形
t.pensize(2)
d = 315
for i in range(4):
    t.seth(d) # 始终以平面直角坐标系中的x轴正向为0度起点，逆时针转向315度
    d += 90
    t.fd(200)  # 向前直走200像素长度

# 真题实例3：绘制等边三角形
for i in range(3):
    t.seth(i*120) # 始终以平面直角坐标系中的x轴正向为0度起点，逆时针转向 i*120 度
    t.fd(200)  # 向前直走200像素长度

六、写在最后——Python之禅

无论是否通过考试，学习Python更重要的意义，是将你的所学运用到解决实际生活问题中去，能够运用Python简化生活中的问题，让自己的创意通过Python实现，我想，这才应该是你学习Python这门脚本语言的初衷，也是在工作之余凭借兴趣开发出Python这门语言的Tim Peters所真正希望的。

最后，附上一段Tim Peters内置于Python中的Python之禅，同时，不要让自己电脑上的Python解释器闲下来~

import this

"""
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
"""

作者：ZW_Xu_307

物联沃分享整理
物联沃-IOTWORD物联网 » Python计算机二级考试复习指南（考前必备）：基于真题的考点提炼与全面覆盖复习资料

代码收藏家普通

分享到：