python 练习100题及答案解析

习题资源来自：https://www.w3cschool.cn/minicourse/play/antpython02

001 变量更新

#如下代码输出什么内容？
a = 2
a = 4
a = 6
print(a + a + a)

答案解析

答案：18

解释：

python读取和执行代码是从上往下的

变量a被更新了3次最后的值是6，所以a+a+a会是18

002 变量命名规则

# 如下代码会报什么错误？
a = 1
_a = 2
_a2 = 3
2a = 4

答案解析

答案：第4行会报错，因为变量的名字，不能以数字开头

解释：变量名字可以用字母或者下划线开头，不能是其他

003 比较和赋值

# 如下代码会报什么错误？
a = 1
b = 2
print(a == b)
print(b == c)

答案解析

答案：会报错说，变量c没有被定义

解释：变量需要先被声明定义，才能被使用

004 类型错误

#修改如下代码，让它的输出是数字1+2结果为3。要求：不要修改前两行，只修改第3行
a = "1"
b = 2
print(a + b)

答案解析

a = "1"
b = 2
print(int(a) + b)

解释：

• python的变量有不同的类型
• 这个练习中，a是字符串类型、b是数字类型
• 数字和字符串，是不能直接相加的
• 使用python自带的int()函数，可以将字符串转换成数字

005 缩进错误

# 如下代码想要判断字符串中的字母是不是等于e，等于的话输出这个字母
# 但是报错了，为什么？怎么修复？
for letter in "Hello":
    if letter == "e":
    print(letter)

答案解析

for letter in "Hello":
    if letter == "e":
        print(letter)

e

解释：

• if判断语句下的控制体，需要增加一个缩进，下方控制的代码可以有多行
• 注意，缩进是2个空格、4个空格、TAB键都可以，但是单个文件必须前后一致
• 代码有的是4个空格（小文件），有的是2个空格（大文件代码太多PPT放不下），只要是单个文件内一致，就能运行不影响

006 不正确的结束

print(type("Hey".replace("ey","i")[-1])

答案解析

print(type("Hey".replace("ey","i")[-1]))

解释：

• 代码会报错：SyntaxError: unexpected EOF while parsing，意思是Python发现了不正确的文件内容结尾
• 本代码中，缺少了最后面的括号，因为括号不匹配，报非正常结束EOF错误

007 关键字错误

pass = input("Please enter your password: ")
print(pass)

答案解析

pass1 = input("Please enter your password: ")
print(pass1)

Please enter your password: ts123654
ts123654

解释：

• 代码会报语法错误SyntaxError: invalid syntax
• 因为pass是Python自己保留的关键字
• pass不能作为普通的变量名，修改变量的名字例如pass1或者其他名字即可修复

008 名字未定义NameError

print(math.sqrt(9))

答案解析

import math
print(math.sqrt(9))

解释

• math是python内置模块，但是默认是不会自动引入的
  math这个模块如果想要引入，使用import math，然后就可以用它的方法了

009 序列索引

# 完成如下代码，输出序列的第二个元素"b"
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

答案解析

letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[1])

b

解释：

• 列表中每个元素的下标，都是从0开始，每次加1往后加的
• 使用元素的下标，可以访问对应位置的元素

H E L L O

0 1 2 3 4

010 序列切片

# 完成如下代码，输出子序列，包含元素d、e、f
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

答案解析

letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[3:6])

['d', 'e', 'f']

解释：

• d的下标是3、e的下标是4、f的下标是5
• 因为切片的第二个元素是不包含的，所以得写成[3:6]

011 序列前位置切片

# 完成如下代码，输出前三个元素的子序列，包含元素a、b、c
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

答案解析

letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[:3])

['a', 'b', 'c']

解释：

• [:3]是[0:3]的简写形式，两个办法都能达到目标

012 负数索引

# 完成如下代码，使用负数索引，输出字母i
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

答案解析

letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[-2])

i

解释：

• 负数索引从最后一个元素往前数，最后一个元素是-1，往前每次减去1

H E L L O

0 1 2 3 4

-5-4-3-2-1

013 负数切片

# 完成如下代码，获得一个切片，得到最后的3个元素[h, i, j]
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

答案解析

letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[-3:])

['h', 'i', 'j']

解释：

• [-3:]意思是从-3这个位置的下标的元素，到列表的末尾
• 对于这个场景，只能写[-3:]，冒号后面的数字不用写也没法写，这样就包含了列表后面的所有元素

014 序列索引步长

# 完成如下代码，获得一个切片，包含元素['a', 'c', 'e', 'g', 'i']
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

答案解析

letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[::2])

['a', 'c', 'e', 'g', 'i']

解释：

• 序列切片的完整语法，是[start:end:step]
• 如果不传step参数，默认是1
• [:]意思是整个列表，从开始到结尾
• [::2]意思是，从开始(包含)到结尾，但是步长2

015 Range函数

# 编写代码，生成如下数字List，注意要用函数生成，别手动生成
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

答案解析

my_range = range(1, 21)
print(list(my_range))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

解释：

• range()函数是一个python内置函数，可以生成数字序列
• range()函数生成的是一个range对象，不是python的list
• 如果想得到python的list，得用list()函数转换range对象到list对象

016 Range和推导式

# 完成如下代码
my_range = range(1, 21)
# 你的代码需要使用my_range变量最终产生如下输出：
# [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200]

答案解析

my_range = range(1, 21)
print([x * 10 for x in my_range])

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200]

解释：

• 列表推导式用于快速生成一个列表
• 形如：[x*2 for x in list if x>3]

017 Range字符串

# 完成如下代码
my_range = range(1, 21)

# 你的代码需要使用my_range变量最终产生如下输出：
# ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20'] 

答案解析

my_range = range(1, 21)
print([str(x) for x in my_range])

['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20']

解释：

• str函数可以将其他的变量类型，转换成字符串类型

018 移除重复元素

# 完成代码，移除列表中的重复值,最终产生如下输出：a = ["1", 1,  2]
a = ["1", 1, "1", 2]

答案解析

# 答案1：
a = ["1", 1, "1", 2]
a = list(set(a))
print(a)

['1', 1, 2]

解释：

• set函数可以把list变成set，达到去重的效果
• 对于set，可以用list函数重新变回列表
• 这个办法有点问题，可能会改变元素的顺序，因为set里面的元素是不固定的
• 例如结果可能是：[‘1’, 2, 1]，数字2跑到1的前面了

# 答案2：
a = ["1", 1, "1", 2]
b = []
for i in a:
    if i not in b:
        b.append(i)
print(b)

['1', 1, 2]

解释：

• 这个办法可以保持元素的顺序，一定会输出[‘1’, 1, 2]，而不会出现[‘1’, 2, 1]
• 问题在于，这个办法效率不高，对每个a的元素，都要挨个判断是不是在b列表，如果列表很大的时候，花费时间较长

019 列表的排序

# 完成代码，对列表排序，得到排序后的结果
lista = [20, 40, 30, 50, 10]
# 最终产生如下输出：lista is [50, 40, 30, 20, 10]

答案解析

lista = [20, 40, 30, 50, 10]
lista.sort(reverse=True)
print("lista is", lista)

lista is [50, 40, 30, 20, 10]

解释：

• list.sort可以实现排序
• 默认是升序排列，如果想要降序，加一个参数reverse=True

020 简单字典

# 编写代码，创建一个字典:字典的Key是字母a和b, 字典的value分别是1和2

答案解析

# 答案1:这是简单的大括号的语法

d = {"a": 1, "b": 2}
print(d)

{'a': 1, 'b': 2}

# 答案2: dict是一个函数，可以用key=value的方式进行，这时候key为a和b不用写成字符串形式

d = dict(a = 1, b = 2)
print(d)

{'a': 1, 'b': 2}

021 访问字典元素

# 完成如下代码,最终输出数值2
d = {"a": 1, "b": 2}

答案解析

d = {"a": 1, "b": 2}
print(d["b"])

2

解释：

• 字典使用key来访问对应的value

022 字典元素加和

# 完成如下代码，计算key为a和b的值value的加和,最终输出数值3
d = {"a": 1, "b": 2, "c": 3}

答案解析

d = {"a": 1, "b": 2, "c": 3}
print(d["b"] + d["a"])

3

解释：

• 字典的key可以多次访问
• 如果想加和所有的字典元素值，继续后面的练习题

023 字典KeyError

# 如下会报什么错误？为什么会报这个错误？
# 如果想得到"男"该怎么修正呢？
d = {"姓名": "小明", "性别": "男"}
print(d["男"])

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

 in ()
      2 # 如果想得到"男"该怎么修正呢？
      3 d = {"姓名": "小明", "性别": "男"}
----> 4 print(d["男"])


KeyError: '男'

答案解析

d["性别"]

'男'

会有如下报错信息:KeyError: ‘男’

答案：

• 字典中没有key==‘男’，'男’是一个字典的值
• 如果想访问’男’，可以用d[“性别”]

解释：

• 如果一个key在字典中不存在，却访问了它，就会报错说KeyError

024 添加字典key

# 给如下代码新增一对key:value，key是c，value是3最终输出为：{'a': 1, 'c': 3, 'b': 2}
d = {"a": 1, "b": 2}

答案解析

d = {"a": 1, "b": 2}
d["c"] = 3
print(d)

{'a': 1, 'b': 2, 'c': 3}

解释：

• 字典最直观的添加Key的方式，就是dict[key]=value

025 对字典使用函数

# 计算如下字典的所有value的数字的和，最终输出结果6
d = {"a": 1, "b": 2, "c": 3}

答案解析

d = {"a": 1, "b": 2, "c": 3}
print(sum(d.values()))

6

解释：

• d.values()返回一个类似list的dict_values对象
• sum()函数可以直接对dict_values对象求和

026 字典过滤

# 移除如下字典中所有value大于1的key:value对，过滤后，输出{'a': 1} 
d = {"a": 1, "b": 2, "c": 3}

答案解析

d = {"a": 1, "b": 2, "c": 3}
d = {key: value for key, value in d.items() if value <= 1}
print(d)

{'a': 1}

解释：

• 字典推导式的形式，形如 {key:value for 循环 if 条件} 的形式
• d.items()会返回每个key:value对

027 格式化输出

'''
创建一个字典：key是a、b、c，value分别是列表1~10、列表11~20、列表21~30
格式化输出字典，最终产生如下整齐的输出：
{'a': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
 'b': [11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
 'c': [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]}
'''

答案解析

from pprint import pprint
d = {"a": list(range(1, 11)),
    "b": list(range(11, 21)),
    "c": list(range(21, 31))}
pprint(d)

{'a': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
 'b': [11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
 'c': [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]}

解释：

• list(range)的组合，可以把一串数字变成list
• pprint打印数据，会产生比较整齐的输出

028 多层索引访问

# 对于如下字典dict,怎样访问key=b的列表的第3个元素，输出数字13

d = {"a": list(range(1, 11)), 
     "b": list(range(11, 21)),  
     "c": list(range(21, 31))}

答案解析

d = {"a": list(range(1, 11)),
    "b": list(range(11, 21)),
    "c": list(range(21, 31))}
print(d["b"][2])

13

解释：

• 先访问d[“b”]，是一个列表，11~21
• 对这个列表，用下标[2]得到第3个元素，即13

029 遍历字典

"""
遍历如下字典dict,得到以下三行输出：
a has value [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b has value [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
c has value [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
"""
d = {"a": list(range(1, 11)), 
     "b": list(range(11, 21)),  
     "c": list(range(21, 31))}

答案解析

d = {"a": list(range(1, 11)),
    "b": list(range(11, 21)),
    "c": list(range(21, 31))}
for key, value in d.items():
    print(key, "has value", value)

a has value [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b has value [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
c has value [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]

解释：

• d.items()可以遍历字典的每一对key和value

030 打印字母a到z

# 打印字母a到z，每行一个字母

答案解析

import string
for letter in string.ascii_lowercase:
    print(letter)

解释：

• string.ascii_lowercase，不要加括号，是一个字符串，包含a~z
• 使用for循环，可以遍历这个字符串，得到每个字母

031 打印数字1到10

# 编写代码，打印从1到10，每个数字一行

答案解析

for i in range(1, 11):
    print(i)

解释：

• for循环会重复操作，直到后面的序列被消耗完毕
• range函数[begin, end)，包括第一个数字，不包含第二个数字，所以需要是11

032 计算1到100数字的和

# 编写代码，计算从1到100的和，包含1和100,即：1+2+3+4+.....+99+100

答案解析

sum_value = 0
for i in range(1, 100 + 1):
    sum_value += i
print(sum_value)

5050

解释：

• 因为要包含100，所以range的第二个参数可以加1
• 用sum_value变量，循环加和即可得到结果

033 计算1到100偶数数字和

"""
编写代码，计算从1到100中偶数的数字和
即：2+4+6+8+.....+98+100
输出结果：2550

"""

答案解析

sum_value = 0
for i in range(1, 100 + 1):
    if i % 2 == 1:
        continue
    sum_value += i
print(sum_value)

2550

解释：

• 配合for和range函数
• number % 2 == 0 说明是偶数，%在这里是取余数的意思
• 如果是i是奇数，那么%2==1，则会跳过这数字

034 输出元素和下标

"""根据a产生如下输出：
Item 1 has index 0
Item 2 has index 1
Item 3 has index 2
"""
a = [1, 2, 3]

答案解析

a = [1, 2, 3]
for index, item in enumerate(a):
    print(f"Item {item} has index {index}")

Item 1 has index 0
Item 2 has index 1
Item 3 has index 2

解释：

• enumerate(a)函数产出数组的（下标index，数值item）数据对
• 用for index, item in enumerate(a)可以依次取出index和item
• 在字符串前面加个f符号，里面可以用{item}、{index}的方式访问变量，这叫f-string语法

035 同时遍历多个序列

"""
编写代码根据a,b经过处理产出如下内容，其中5=1+4、7=2+5、9=3+6：
5
7
9
"""

a = [1, 2, 3]
b = (4, 5, 6)

答案解析

a = [1, 2, 3]
b = (4, 5, 6)
for i, j in zip(a, b):
    print(i + j)

5
7
9

提示：

• 不同的序列（列表、元组都叫序列），可以用zip打包在一起
• zip的返回是一各个的元组，里面包含各个序列的对应元素

036 编写加速度函数

'''
创建函数，计算加速度，初始和结束的速度为v1和v2，初始和结束的时间为t1和t2
a=(v2-v1)/(t2-t1),
然后，将参数(v1, v2, t1, t2)分别取值为(0, 10, 0, 20)，调用函数，得到结果为：0.5
'''

答案解析

def acceleration(v1, v2, t1, t2):
    a = (v2 - v1) / (t2 - t1)
    return a
print(acceleration(0, 10, 0, 20))

0.5

解释：

• 定义函数的形式，为 def 函数名字（参数列表），在函数体内可以return结果
• 调用函数的形式，为 函数名（实际参数值列表），得到函数return的返回值

037 函数TypeError

# 如下代码会报错，为什么?怎么修复错误？
def foo(a, b):
    print(a + b)

x = foo(2, 3) * 10

答案解析

答案：

• 代码的第4行会报错，因为Python不能完成None和数字的相乘
• 这个函数做了print，但是没有return，没有return结果的函数，默认返回None

解决办法：
把print改成return，可以让函数返回一个具体的值

def foo(a, b):
    return a + b

x = foo(2, 3) * 10
print(x)

50

038 方法不存在

# 如下代码为了输出数字的cosine值，但是报错了说方法cosine不存在，该怎么修正？
import math
print(math.cosine(1))

答案解析

import math
print(dir(math))
print(help(math.cos))
print(math.cos(1))

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
Help on built-in function cos in module math:

cos(...)
    cos(x)
    
    Return the cosine of x (measured in radians).

None
0.5403023058681398

解释：

• print(dir(math))可以查看这个模块的所有方法名
• print(help(math.cos))可以看到这个方法的注释，看到是计算cosine的
• 如果在pycharm中，可以按住键盘的ctrl键同时鼠标左键点击math.cos方法名，可以看到这个方法的源代码的注释

039 函数参数数目错误

# 如下代码报错，为什么，怎么修正它?
import math
print(math.pow(2))

答案解析

import math
print(math.pow(2, 3))

8.0

解释：

• math.pow用于计算数字的N次方，需要2个参数，例如2的3次方
• 这里的数字3，可以随意改成其他数字，但是必须有这个第二个参数
• 可以print(help(math.pow))看下这个函数的说明

040 函数调用方式

# 如下代码会报错，为什么?怎么修复?
def foo(a=1, b=2):
    return a + b
 
x = foo - 1

答案解析

代码会报错：

TypeError: unsupported operand type(s) for -: ‘function’ and ‘int’ 原因：x = foo - 1，这里的foo是一个函数对象，函数对象和int数字是没法相减的报错

修复方式：要调用一个函数，得在函数名后面加上括号，本题目中是foo()

def foo(a=1, b=2):
    return a + b

x = foo() - 1
print(x)

041 函数计算球的体积

'''
编写函数，计算球的体积V=(4/3)*pi*r^3
要求函数的参数半径r，有一个默认值10
然后用r=2为参数，调用函数得到结果
'''

答案解析

import math
def volume(r=10):
    return (4 * math.pi * r ** 3) / 3

print(volume())

print(volume(2))

解释：

• 函数参数可以用等号的方式，提供默认值；
• 调用函数时，默认值可以不提供参数，也可以覆盖参数值

042 函数默认值参数

# 如下代码会报错，为什么?怎么修复?
def foo(a=2, b):
    return a + b

答案解析

报错信息：SyntaxError: non-default argument follows default argument

解释：

• 带默认值的参数，应该放到后面
• 这样如果只传1个参数，才能达到使用默认值参数的效果

def foo(b, a=2):
    return a + b

print(foo(3))
print(foo(3, 4))

043 全局变量

# 如下代码会输出什么内容？为什么呢？
c = 1
def foo():
    return c
c = 3
print(foo())

答案解析

解释：

• 第1行：c的值是1
• 第2~3行：创建了个函数，这时候只是函数定义，并没有被执行
• 第4行：变量c被更新，值是3
• 第5行：调用函数foo返回c，这时候c已经是3了，所以输出数字3

c = 1
def foo():
    return c
c = 3
print(foo())

044 函数局部变量

# 如下代码会输出什么内容？为什么呢？
c = 1
def foo():
    c = 2
    return c
c = 3
print(foo())

2

答案解析

解释：

• python的函数，从上往下一行一行执行
• 函数内可以访问函数外的全局变量，但是局部变量的优先级更高

045 局部变量和全局变量

# 如下代码的最后一行，会报错说NameError: name 'c' is not defined
# 怎样修复代码，让代码不报错，并且输出数值1？
def foo():
    c = 1
    return c
foo()
print(c)

答案解析

def foo():
    global c
    c = 1
    return c

foo()
print(c)

1

解释：

• 函数内的c是局部变量，不能直接被外部访问的
• 可以将函数内的c，声明成全局变量，在外部即可访问
• 加上global c，会将变量c的生效范围变成全局作用域
• print©的这个c，访问的是全局作用域的c，所以不报错了

046 字符串与数字计算

# 如下代码会报错，为什么?怎么修复?
age = input("What's your age? ")
age_last_year = age - 1
print("Last year you were %s." % age_last_year)

答案解析

age = input("What's your age? ")
age_last_year = int(age) - 1
print("Last year you were %s." % age_last_year)

What's your age? 20
Last year you were 19.

解释：

• input函数使得用户可以提供自己的输入给变量
• input函数每次都会返回一个str类型字符串
• 如果想实现字符串和数字的计算，得把字符串转换成数字，使用int(变量)即可

047 字符串格式化

# 如下代码让用户输入name和age，然后拼接字符串
# 但是代码会报错 TypeError,为什么？怎么修复？有另一种办法吗？
name = input("Enter name: ")
age = input("Enter age: ")
print("Your name is %s and your age is %s" % name, age)
      

答案解析

name = input("Enter name: ")
age = input("Enter age: ")
print("Your name is %s and your age is %s" % (name, age))
print(f"Your name is {name} and your age is {age}")

解释：

• 每个%占位符，在后面的%需要一个变量对应起来，如果多于一个%占位符，后面的%之后需要跟一个元组tuple包含多个变量，所以需要用(name, age)这个元组
• f-string是第二种好用的格式化方式，形如f"Your name is {name}"，在字符串中可以用{变量名}的方式格式化

048 字符串拆分

# 创建一个函数，以任何一个英文字符串作为入参数，返回英文单词的数目

答案解析

def count_words(string):
    string_list = string.split()
    return len(string_list)
print(count_words("You are a good student !"))

6

解释：

• split可以提供一个分隔符参数进行分割，例如split(",")，如果不传递则用空白分隔符
• split的结果是一个List，用len(list)可以得到元素个数

049 文件中的英文单词计数

"""
编写函数，传入.txt文件路径作为参数，统计文件中英文单词的数目
输入：新建一个txt文件，名字为p049.txt，粘贴如下内容到文件里，作为参数文件:
Living without an aim is like sailing without a compass.
"""

答案解析

def count_words(filepath):
    with open(filepath, 'r') as file:
        string = file.read()
        string_list = string.split(" ")
    return len(string_list)

print(count_words("p049.txt"))#注意路径

解释：

• 这段代码直接访问了p049.txt，那么要求p049.txt在当前.py代码同一个目录下
• 如果.txt不在当前目录，请用绝对路径，例如 D:/workbench/psstest/p049.txt
• file.read()读取文件的所有内容，str.split(" ")按空格分割

050 多分隔符单词计数

"""
编写函数，传入.txt文件路径作为参数，统计文件中英文单词的数目
注意，不只是空格分割，也可能是逗号分隔

输入：新建一个txt文件，名字为p050.txt，粘贴如下内容到文件里，作为参数文件:

A tree is a woody perennial plant,typically with branches.
"""

答案解析

import re
def count_words(filepath):
    with open(filepath, 'r') as file:
        string = file.read()
        string_list = re.split(r",| ", string)
        print(string_list)
        return len(string_list)

print(count_words("p050.txt"))

解释：

• re是python内置的正则表达式模块，可以实现模式匹配
• 模式的意思:例如一个字符串“包含10个数字”、“逗号或者空格作为分隔符”等模式
• re.split的第一个参数，一般都前一个r意思是raw-string，里面如果有反斜线不用多次转义

051 生成字母文件

# 编写代码，生成一个文件p051.txt，每一行是一个英文字母，从a~z

答案解析

import string
with open("p051.txt", "w") as file:
    for letter in string.ascii_lowercase:
        file.write(letter + "\n")

解释：

• open(“p051.txt”, “w”)用于新建一个文件并写入，"w"是write写入的意思
• string.ascii_lowercase是一个字符串，包含a~z的26个英文字母

052 成对字母文件

'''编写代码，生成文件p052.txt，每一行是两个英文字母的组合：
ab
cd
ef
...
yz
''' 

答案解析

import string
with open("p052.txt", "w") as f:
    for i, j in zip(string.ascii_lowercase[::2], string.ascii_lowercase[1::2]):
        f.write(i + j + "\n")

提示：

• string.ascii_lowercase[::2] 生成acegikmoqsuwy
• string.ascii_lowercase[1::2] 生成bdfhjlnprtvxz
• zip的返回是一个个的元组，里面包含各个序列的对应元素

053 成对三字母文件

'''编写代码，生成文件p053.txt，每一行是三个英文字母的组合：
abc
def
ghi
jkl
mno
pqr
stu
vwx
yz '''

答案解析

import string
letters = string.ascii_lowercase + " "
slice1 = letters[0::3]
slice2 = letters[1::3]
slice3 = letters[2::3]
with open("p053.txt", "w") as file:
    for s1, s2, s3 in zip(slice1, slice2, slice3):
        file.write(s1 + s2 + s3 + "\n")

解释：

• zip函数可以将多个序列同时打包在一起，不只是2个，可以是3个，这里的步长改成3
• zip函数的多个序列，如果遇到了最短的序列，就会结束zip，为了让yz，最后2个字母有所匹配，所以在最开始的letters，加了个空格，变成27个字母

054 每个字母一个文件

'''
编写代码，
1、在当前目录下新建一个目录，名字为 p054
2、给26个英文字母在p054目录下生成一个文件，文件名分别是a.txt、b.txt ~~ z.txt，文件内容分别是字母a、b~~z
'''

答案解析

import os
import string
if not os.path.exists("p054"):
    os.makedirs("p054")
    
for letter in string.ascii_lowercase:
    with open(f"p054/{letter}.txt", "w") as f:
        f.write(letter)

解释：

• os.makedirs可以创建目录，os.path.exists可以判断目录是否存在
• f"p054/{letter}.txt"是f-string的字符串格式化方法，前面加上f字母，字符串中可以用{变量名}的方式提供变量

055 扫描字母文件列表

'''
编写代码，
1、扫描p054文件夹，里面是a.txt/b.txt~z.txt共26个文件，每个文件的都是对应字母a~z
2、读取每个文件的内容，最终产出一个list，是字母a~z


'''

答案解析

import glob

letters = []
file_list = glob.glob("p054/*.txt")
for file in file_list:
    with open(file) as f:
        letters.append(f.read().strip())

print(letters)

解释：

• glob.glob(“p054/*.txt”) 可以匹配得到文件列表
• f.read()可以读取文件所有内容，.strip()可以去除两边的空格

056 满足条件的字母文件

'''编写代码，
1、扫描p054文件夹，里面是a.txt/b.txt~z.txt共26个文件，每个文件的都是对应字母a~z
2、如果文件里的内容字母，属于字符串"python"中的字母，则存入结果列表
3、打印结果列表'''

答案解析

import glob

letters = []
file_list = glob.glob("p054/*.txt")
check = "python"

for file in file_list:
    with open(file) as f:
        letter = f.read().strip()
        if letter in check:
            letters.append(letter)

print(letters)

解释：

• glob.glob(“p054/*.txt”) 可以匹配得到文件列表
• if letter in check，可以判断一个字母是不是在一个字符串里

057 多级字典

'''如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么访问employees的第二个人，得到他的lastName，即 Smith '''

d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}

答案解析

print(d['employees'][1]['lastName'])

解释：

• 访问d[‘employees’]，得到:
  [{‘firstName’: ‘John’, ‘lastName’: ‘Doe’},
  {‘firstName’: ‘Anna’, ‘lastName’: ‘Smith’},
  {‘firstName’: ‘Peter’, ‘lastName’: ‘Jones’}]
• 访问d[‘employees’][1]，得到:{‘firstName’: ‘Anna’, ‘lastName’: ‘Smith’}
• 访问d[‘employees’][1][‘lastName’]，得到Smith

058 修改多级字典

'''如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么访问 employees 的第二个人，修改他的 lastName 将值从 Smith 改成 Smooth'''

d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}

答案解析

d['employees'][1]['lastName'] = "Smooth" 

解释：

• 访问d[‘employees’][1][‘lastName’]，是Smith值的位置
• 直接给 d[‘employees’][1][‘lastName’] 赋值，即可修改这个位置的值

059 多级字典加值

'''
如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么给 employees 添加一个人：'firstName': 'Albert', 'lastName':'Bert'
'''

d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}

答案解析

d["employees"].append({'firstName': 'Albert', 'lastName': 'Bert'})

解释：

• 访问d[‘employees’]，得到一个list列表
  [{‘firstName’: ‘John’, ‘lastName’: ‘Doe’},
  {‘firstName’: ‘Anna’, ‘lastName’: ‘Smith’},
  {‘firstName’: ‘Peter’, ‘lastName’: ‘Jones’}]
• 执行d[“employees”].append({‘firstName’: ‘Albert’, ‘lastName’: ‘Bert’}，
  即可给这个列表添加一个元素，这个元素是一个字典

060 字典变JSON

# 把如下字典，变成JSON格式，存入一个文件 p060.json

{'employees': [{'firstName': 'John', 'lastName': 'Doe'},
               {'firstName': 'Anna', 'lastName': 'Smith'},
               {'firstName': 'Peter', 'lastName': 'Jones'}],
 'owners': [{'firstName': 'Jack', 'lastName': 'Petter'},
            {'firstName': 'Jessy', 'lastName': 'Petter'}]}

答案解析

import json

d = {"employees": [{"firstName": "John", "lastName": "Doe"},
        {"firstName": "Anna", "lastName": "Smith"},
        {"firstName": "Peter", "lastName": "Jones"}],
    "owners": [{"firstName": "Jack", "lastName": "Petter"},
            {"firstName": "Jessy", "lastName": "Petter"}]}

with open("p060.json", "w") as f:
    f.write(json.dumps(d, indent=2))

解释：

• json.dumps，可以把字典变成JSON字符串
• 使用with的方法写入文件，可以不用自己close文件，with会自己关闭
• indent=2可以加可以不加，加了之后会让JSON样式更加缩进美观

061 JSON变字典

# 用python加载p60.json文件，转成字典，并且进行格式化输出

答案解析

import json
import pprint

with open("p060.json") as f:
    d = json.loads(f.read())
pprint.pprint(d)

{'employees': [{'firstName': 'John', 'lastName': 'Doe'},
               {'firstName': 'Anna', 'lastName': 'Smith'},
               {'firstName': 'Peter', 'lastName': 'Jones'}],
 'owners': [{'firstName': 'Jack', 'lastName': 'Petter'},
            {'firstName': 'Jessy', 'lastName': 'Petter'}]}

解释：

• json.loads可以将字符串加载到JSON格式
• pprint可以实现字典的格式化输出

062 JSON添加数据

'''完成如下步骤：
1.用python加载p060.json文件，转成字典
2.给 employees 添加一个人：
'firstName': 'Albert', 'lastName': 'Bert'
3.将数据生成json，结果存到 p062.json文件'''

答案解析

import json

with open("p060.json") as f:
    d = json.loads(f.read())
    
d["employees"].append({'firstName': 'Albert', 'lastName': 'Bert'})

with open("p062.json", "w") as f:
    f.write(json.dumps(d, indent=2))

解释：

• open函数的第二个参数如果不加是读取模式，加w是写入模式
• json.loads从字符串加载到json格式
• json.dumps将对象变成json字符串

063 无限循环打印

'''实现python代码，无限循环，一直打印字符串 hello
输出如下内容，注意是无限输出：
hello
hello
hello
hello
hello
hello
hello
...
'''

答案解析

while True:
    print("hello")

while 1 < 2:
    print("hello")

解释：

• 只要while的条件一直为True即可
• 因为条件一直不结束，这个叫做“无限循环”，或者叫做“死循环”

064 定时打印

# 实现python代码，每两秒钟输出hello字符串，无限继续：

答案解析

import time

while True:
    print("Hello")
    time.sleep(2)

解释：

• time.sleep(2)可以让程序暂停2秒钟，这个数字可以自己指定，单位是秒

065 渐进式定时打印

# 实现python代码，输出hello，停顿1秒；输出hello，停顿2秒；输出hello，停顿3秒,...按此一直持续：

答案解析

import time

i = 0
while True:
    i = i + 1
    print("Hello")
    time.sleep(i)

解释：

• time.sleep(i)可以让程序暂停i秒钟
• i相当于一个计数器，可以从0开始计数

066 有结束条件的循环

# 实现python代码，输出hello，停顿1秒；输出hello，停顿2秒；输出hello，停顿3秒；
# 打印4次hello，然后退出循环：

答案解析

import time

i = 0
while True:
    i = i + 1
    print("Hello")
    if i > 3:
        print("End of loop")
        break
    time.sleep(i)

解释：

• 在while循环中，增加if和break配合，可以按条件退出循环
• break用于退出循环

067 空语句

# 如下代码只能输出一个Hello，只修改break这行代码，让程序交替输出Hello、Hi、Hello、Hi，持续不断

while True:
    print("Hello")
    if 2 > 1:
        break
    print("Hi")
    

答案解析

# while True:
#     print("Hello")
#     if 2 > 1:
#         pass
#     print("Hi")

解释：

• pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做
• 这个位置可以放其他的空语句，例如只放一个1+1，但是pass更加专业

068 忽略循环下一句

# 如下代码只能输出一个Hello，只修改break这行代码，让程序持续输出Hello、Hello、Hello，持续不断

while True:
    print("Hello")
    if 2 > 1:
        break
    print("Hi")

答案解析

while True:
    print("Hello")
    if 2 > 1:
        continue
    print("Hi")

解释：

• pass可以跳过当前语句，但是继续往下执行，也会进入下一次循环
• break会忽略当次循环下方语句，直接退出当前循环
• continue会忽略当次循环下方语句，依然进入下一个循环

069 英汉翻译

'''
完成如下程序，让用户可以输入一个英文单词，程序给出中文翻译结果。实现效果：
Enter word: apple
苹果
'''

d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}

答案解析

d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}

def translate(word):
    return d[word]
    word = input("Enter word: ")
    print(translate(word))

解释：

• 用函数的方式，将来可以复用translate功能
• 这个词典很小，如果是全量英文数据，就可以实现全部英文查询了

070 英汉翻译异常处理

'''
如下程序实现功能，让用户可以输入一个英文单词，程序给出中文翻译结果。
按以下要求修改程序：如果输入的英文单词不在字典中，输出信息“单词不在词典中”
限制：请使用try catch的异常机制完成本题目，效果如下:
Enter word: hello
单词不在词典中
'''

d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}

def translate(word):
    return d[word]

word = input("Enter word: ")
print(translate(word))

答案解析

d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}
def translate(word):
    try:
        return d[word]
    except KeyError:
        return "单词不在词典中"

word = input("Enter word: ")
print(translate(word))

解释：

• d[word]访问字典的数据，如果key不存在，会抛出KeyError错误
• 使用try…except可以捕获异常，在except中指定异常处理逻辑
• 这里的KeyError可以忽略，就会捕获所有异常

071 英汉翻译文件词典

"""
如下是英汉翻译词典文件，用python加载词典文件
当用户输入英语单词时，返回中文文字
增加：程序应该处理大小写情况，例如输入Apple也能返回apple的翻译

自己新建 p071.txt 粘贴内容如下:
apple,苹果
orange,桔子
banana,香蕉
pear,梨
peach,桃
grape,葡萄
lemon,柠檬

效果：
Enter word: Apple
苹果
"""

答案解析

engdict = {}
with open("p071.txt", encoding="utf8") as f:
    for line in f:
        eng, ch = line.strip().split(",")
        engdict[eng] = ch

def translate(word):
    try:
        return engdict[word]
    except KeyError:
        return "单词不在词典中"

word = input("Enter word: ").lower()
print(translate(word))

解释：

• 先将字典从文件加载，第一列是英文，第二列是中文
• 因为要处理小写，在input函数后加一个lower()即可

072 当前日期时间

"""
编写Python代码，输出当前的日期时间
形如：2023-06-09 20:20:27
提示：使用datetime模块
"""

答案解析

from datetime import datetime

print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

2023-06-09 13:48:27

解释：

• datetime是内置的日期时间处理模块
• datetime.now()返回当前的时间对象
• datetime.now().strftime可以将时间对象格式化
• 格式化字符串 %Y 等符号，参照文档：https://strftime.org/

073 输入年龄计算生日

"""编写Python代码，用户可以输入年龄数字，程序打印生日年份
请输入年龄：20
你的出生年份是：2003
提示：datetime.now().year可以得到当前时间的年份"""

答案解析

from datetime import datetime

age = int(input("请输入年龄："))
year_birth = datetime.now().year - age
print(f"你的出生年份是：{year_birth}")

请输入年龄：22
你的出生年份是：2001

提示：

• input函数得到的是字符串，需要转换成数字，才能执行减法
• datetime.now().year是当前的年份，减去年龄就是出生年份
• f-string是简单的格式化字符串的方法

074 计算活了多少天

"""编写Python代码，用户可以输入生日，程序打印活了多少天
请输入生日：2002-6-9
7665天 #执行代码的日期变化结果会跟着发生改变
提示：
datetime.datetime.strptime("2022-05-14", "%Y-%m-%d")，可以将字符串转换成日期对象
日期对象可以直接相减，差值对象可以得到天数"""

答案解析

import datetime

birthday = input("请输入生日：")
birthday_date = datetime.datetime.strptime(birthday, "%Y-%m-%d")
curr_datetime = datetime.datetime.now()
minus_datetime = curr_datetime - birthday_date
print(minus_datetime.days, "天")

请输入生日：2000-06-09
8400 天

提示：

• datetime.datetime.strptime(“2022-05-14”, “%Y-%m-%d”)，可以将字符串转换成日期对象
• 日期对象可以直接相减，差值对象可以得到天数

075 计算今天明天昨天的日期

"""
编写代码，输出今天、昨天、明天、一周前的日期
可以编写个函数实现

如果今天是2023-06-09，输出形如：
2023-06-09  2023-06-10  2023-06-08  2023-06-02

提示：
datetime.datetime.now()得到当前日期对象
datetime.timedelta(days=days)可以得到一个时间间隔对象
日期对象和间隔对象的加法和减法，得到结果对象
"""

答案解析

import datetime

def diff_days(days):
    pdate_obj = datetime.datetime.now()
    time_gap = datetime.timedelta(days=days)
    pdate_result = pdate_obj - time_gap
    return pdate_result.strftime("%Y-%m-%d")

print(diff_days(0), diff_days(1), diff_days(-1), diff_days(7))

提示：

• datetime.datetime.now()得到当前日期对象
• datetime.timedelta(days=days)可以得到一个时间间隔对象，days可以是0、正数、负数
• 日期对象和间隔对象的加法和减法，得到结果对象

076 输出间隔内的所有日期

'''
编写代码，输入开始日期，结束日期，返回中间的所有日期

例如，输入：begin_date = "2022-06-02"，end_date = "2022-06-09"
打印如下内容：
['2022-06-02','2022-06-03','2022-06-04','2022-06-05','2022-06-06','2022-06-07','2022-06-08','2022-06-09']
'''

答案解析

import datetime
def get_date_range(begin_date, end_date):
    date_list = []
    while begin_date <= end_date:
        date_list.append(begin_date)
        begin_date_object = datetime.datetime.strptime(begin_date, "%Y-%m-%d")
        days1_timedelta = datetime.timedelta(days=1)
        begin_date = (begin_date_object + days1_timedelta).strftime("%Y-%m-%d")
    return date_list

begin_date = "2023-06-02"
end_date = "2023-06-09"
date_list = get_date_range(begin_date, end_date)
print(date_list)

['2023-06-02', '2023-06-03', '2023-06-04', '2023-06-05', '2023-06-06', '2023-06-07', '2023-06-08', '2023-06-09']

077 用户名检测器

'''
写Python代码，要求用户输入用户名，进行检测：
1、用户名至少6位；
2、文件名不能在文件p077_users.txt中存在
自己新建文件：p077_users.txt，粘贴如下内容进去：
xiaoming
xiaowang
xiaozhang
xiaozhao
xiaoqian
xiaosun
结果演示：
请输入用户名: pss
长度小于6位，请重新输入

请输入用户名: xiaoming
用户名已存在，请重新输入

请输入用户名: abcdefg
用户名检测通过
'''

答案解析

while True:
    username = input("请输入用户名：")
    with open("p077_users.txt") as f:
        users = [name.strip() for name in f.readlines()]
    if len(username) < 6:
        print("长度小于6位，请重新输入")
        continue
    if username in users:
        print("用户名已存在，请重新输入")
        continue
    else:
        print("用户名检测通过")
        break

解释：

• f.readlines()可以得到文件中所有的行
• 本代码可以和检测密码的代码结合起来，实现用户名加密码的检测

078 随机密码生成器

"""
编写Python代码，用户输入密码位数，给出一个随机密码生成

请输入密码位数：20
@X_>;HrLM9f?0Elg+q{o

提示：
python自带的string模块，提供多种字符集合，小写字母：string.ascii_lowercase；大写字母：string.ascii_uppercase；数字：string.digits；标点符号：string.punctuation
random是随机数模块，random.sample可以从序列中随机得到几个字符的列表
"""
                   
                   

答案解析

import string
import random
words = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
len = int(input("请输入密码位数："))
chosen = random.sample(words, len)
password = "".join(chosen)
print(password)

请输入密码位数：8
@Y5QH-[U

提示：

• 先将string的几大字符串拼接在一起，作为候选集
• random.sample采样几个字符，得到一个列表
• 用str的join方法，可以将列表的每个元素，拼接成一个大字符串

079 密码强度检测器

"""编写Python代码，需要用户一直输入密码，直到满足如下条件才退出循环：

至少包含一个数字；
至少包含一个大写字母；
密码至少6位数；

实现效果如下，如果不满足条件会一直循环：
请输入密码: abcdefg
密码校验不通过，请重新输入

请输入密码: abc12
密码校验不通过，请重新输入

请输入密码: abcAA2
密码校验通过"""

答案解析

while True:
    pwd = input("请输入密码: ")
    have_number = any([i.isdigit() for i in pwd])
    have_upper = any([i.isupper() for i in pwd])
    if have_number and have_upper and len(pwd) >= 6:
        print("密码校验通过")
        break
    else:
        print("密码校验不通过，请重新输入")

解释：

• any这个方法，参数可以是一个list/set等序列，如果任何一个元素为True，那么any返回True
• 如果通过校验，则break退出循环；否则打印信息，继续下一次循环；

080 详细错误密码检测器

"""
编写Python代码，需要用户一直输入密码，直到满足如下条件才退出循环：
至少包含一个数字；
至少包含一个大写字母；
密码至少6位数；

实现效果如下，如果不满足条件会一直循环，注意会给出多个不满足的信息：

请输入密码: abcdefg
密码不通过，有如下原因:
*需要至少一位数字
*需要至少一位大写字母

请输入密码: abc12
密码不通过，有如下原因:
*需要至少一位大写字母
*需要至少6位密码

请输入密码: abcAA2
密码校验通过

"""

答案解析

while True:
    msgs = []
    psw = input("请输入密码: ")
    if not any([i.isdigit() for i in psw]):
        msgs.append("需要至少一位数字")
    if not any([i.isupper() for i in psw]):
        msgs.append("需要至少一位大写字母")
    if len(psw) < 6:
        msgs.append("需要至少6位密码")
    if len(msgs) == 0:
        print("密码检测通过")
        break
    else:
        print("密码不通过，有如下原因: ")
        for note in msgs:
            print("*", note)

解释：

• msgs为出错信息列表，任何一个检测不通过，就放进msgs；
• 如果msgs为空，说明所有检测通过；如果不为空，则有多条检测不通过，会挨个输出

081 文件内容乘数字

"""新建文件p081.txt，将如下内容粘贴到文件中
编写代码，给每个数字乘以2，结果输出到p081_output.txt

x,y
3,5
4,9
6,10
7,11
8,12"""

答案解析

with open("p081.txt") as fin, open("p081_output.txt", "w") as fout:
    for line in fin:
        if "x,y" in line:
            fout.write(line)
        else:
            x, y = line.strip().split(",")
            x = int(x) * 2
            y = int(y) * 2
            fout.write(f"{x},{y}\n")

解释：

• with后面的open，可以用逗号分割多个
• 读取文件时，返回的都是字符串形式，需要转成数字做计算

082 计算最大值最小值平均值

"""
输入一个成绩文件，计算成绩的最大值最小值平均值

文件名：p082.txt，自己复制如下内容进去即可：

学号,姓名,分数
101,小张,88
102,小王,77
103,小李,99
104,小赵,66
105,小强,55

"""

答案解析

def compute_score():
    scores = []
    with open("./p082.txt") as f:
        for line in f:
            line = line.strip()
            fields = line.split(",")
            scores.append(int(fields[-1]))
            max_score = max(scores)
            min_score = min(scores)
            avg_score = round(sum(scores) / len(scores), 2)
    return max_score, min_score, avg_score

max_score, min_score, avg_score = compute_score()
print(max_score, min_score, avg_score)

解释：

• max、min、sum是三个函数，可以统计list的结果
• 函数可以返回多个值，外部用多个变量接收即可
• round(数字, 2)会给小数保留两位数字

083 文件合并

"""
用python编写代码，把这两个txt纵向拼接在一个文件，存入p083.txt

自己粘贴文件：p083_xiaomei.txt
小美 看韩剧
小美 跳舞
小美 逛街
小美 看综艺

自己粘贴文件：p083_xiaohua.txt
小花 看电影
小花 逛街
小花 购物
小花 跳舞
小花 看小说

"""

答案解析

with open("p083.txt", "w", encoding='utf8') as fout:
    for fname in ["p083_xiaomei.txt", "p083_xiaohua.txt"]:
        with open(fname, encoding='utf8') as f:
            for line in f:
                fout.write(line)

解释：

• for循环可以遍历多个文件，每个文件单独读取和处理
• 因为源文件的每行都带结尾的\n换行符，所以写出文件时直接写入即可不用加换行符

084 文件交集

"""用python编写代码，计算两个人的爱好的交集

自己粘贴文件：p083_xiaomei.txt
小美 看韩剧
小美 跳舞
小美 逛街
小美 看综艺

自己粘贴文件：p083_xiaohua.txt
小花 看电影
小花 逛街
小花 购物
小花 跳舞
小花 看小说

输出：
逛街
跳舞

提示：set集合，有方法叫做 intersection，可以直接计算交集"""

答案解析

def get_aihao(fname):
    aihao = []
    with open(fname, encoding='utf8') as f:
        for line in f:
            aihao.append(line.split()[1])
    return aihao

xiaomei = get_aihao("p084_xiaomei.txt")
xiaohua = get_aihao("p084_xiaohua.txt")
for i in set(xiaomei).intersection(set(xiaohua)):
    print(i)

解释：

• set集合，有方法叫做 intersection，可以直接计算交集

085 每种爱好的喜欢人数

"""
输入一个（姓名，爱好）文件，计算每个爱好的人数

文件名：p085.txt，自己复制如下内容进去即可，姓名和爱好之间是一个空格分割的：
小张 篮球,羽毛球
小王 篮球,乒乓球
小李 篮球,台球
小赵 篮球,足球,台球
小马 乒乓球,台球
小钱 羽毛球,足球
小孙 乒乓球,台球
小强 羽毛球

输出如下内容：
篮球 4
羽毛球 3
乒乓球 3
台球 4
足球 2
"""

答案解析

like_count = {}
with open("p085.txt", encoding='utf8') as fin:
    for line in fin:
        line = line[:-1]
        sname, likes = line.split(" ")
        like_list = likes.split(",")
        for like in like_list:
            if like not in like_count:
                like_count[like] = 0
            like_count[like] += 1
                
for key, value in like_count.items():
    print(key, value)

解释：

• 用字典实现计数，key是爱好，value是人数
• dict.items()可以同时输出key和value

086 实现文件的关联

"""
有两个文件：
文件1：成绩文件，列为（学号、成绩）
文件2：学生信息文件，列为（学号，姓名）
关联两个文件，得到（学号、姓名、成绩），结果存入 p086.txt
自己新建文件粘贴内容：
p086_grade.txt
101,90
102,88
103,89
104,95


自己新建文件粘贴内容：
p086_student.txt
101,小明
102,小王
103,小张
104,小李


得到结果：
p086.txt
101,小明,90
102,小王,88
103,小张,89
104,小李,95
"""

答案解析

grade_dict = {}
with open("p086_grade.txt", encoding="utf8") as f:
    for line in f:
        sno, grade = line.strip().split(",")
        grade_dict[sno] = grade
fout = open("p086.txt", "w", encoding="utf8")
with open("p086_student.txt", encoding="utf8") as f:
    for line in f:
        sno, sname = line.strip().split(",")
        grade = grade_dict[sno]
        fout.write(f"{sno},{sname},{grade}\n")
fout.close()

解释：

• 要想实现文件关联，先将一个文件存入字典，第二个文件根据KEY获取第一个字典的VALUE，实现关联

087 判断日期格式

"""
编写函数date_is_right，判断日期是不是 YYYY-MM-DD 的格式
如果是返回True，否则返回False
测试结果形如：
2023-06-09 True
202-06-09 False
2026/06-09 False
20230609 False
20a30609 False
"""

答案解析

import re

def date_is_right(date):
    return re.match(r"\d{4}-\d{2}-\d{2}", date) is not None

print("2023-06-09", date_is_right("2023-06-09"))
print("202-06-09", date_is_right("202-06-09"))
print("2023/06-09", date_is_right("2023/06-09"))
print("20230609", date_is_right("20230609"))
print("20a30609", date_is_right("20a30609"))

解释：

• re.match会给字符串匹配模式，如果匹配成功返回Match对象，匹配不成功返回None
• \d可以代表0到9的任何一个数字，{2}和{4}表示前面的\d会出现2和4次

088 提取电话号码

如下文字中，有很多电话号码，用python提取打印出来
白日依19989881888山尽，黄河入45645546468798978海流。
欲穷12345千里目，更上15619292345一层楼。
输出内容：
19989881888
15619292345

提示：
电话号码的规则是：都是数字1开头，并且包含11位数字
re.findall方法，可以搜索文本中的所有匹配的模式

答案解析

import re

content = """ 白日依19989881888山尽，黄河入45645546468798978海流。
欲穷12345千里目，更上15619292345一层楼。
"""
pattern = r"1\d{10}"
results = re.findall(pattern, content)
for result in results:
    print(result)

解释：

• r"1\d{10}"可以匹配11位数字，第一个字母是数字1；r意思是raw-string，方便编写正则模式
• re.findall方法，可以搜索文本中的所有匹配的模式

089 提取邮箱地址

"""
如下文字中，有很多邮箱地址，用python提取打印出来
寻隐者[email protected]不遇
朝代：唐asdf12dsa#abc.com代
作[email protected]者：贾岛
松下问童子，言师python-abc@163com采药去。
只在[email protected]此山中，云深不知处。

输出内容：
[email protected]
[email protected]
[email protected]

提示：
邮箱地址的模式位：多位字母/数字/下划线/中划线 @ 多位字母数字 . 2~4位字母
"""

答案解析

import re

content = """ 寻隐者[email protected]不遇
朝代：唐asdf12dsa#abc.com代
作[email protected]者：贾岛
松下问童子，言师python-abc@163com采药去。
只在[email protected]此山中，云深不知处。
"""
pattern = re.compile(r"[a-zA-Z0-9_-]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,4}")
results = pattern.findall(content)

for result in results:
    print(result)

解释：

• re.compile可以提前编译正则表达式，后续多次使用性能更好
• re.findall可以搜索多种匹配模式
• 点号是正则的特殊符号，如果相匹配点号，得用.

090 多个禁用词替换

"""
如下文字中，有很多不允许使用的词语，包含 最好、最低、绝对
用python将这三个词语，都替换成***字符串
输入内容：
这个商品很好，质量最好、用起来很不错，并且价格最低，绝对的物美价廉

输出内容：
这个商品很好，质量***、用起来很不错，并且价格***，***的物美价廉

提示：
re.sub可以实现正则替换字符串
r"最好|最低|绝对"就可以同时匹配很多个字符串
"""

答案解析

import re

content = """ 这个商品很好，质量最好、用起来很不错，并且价格最低，绝对的物美价廉
"""
pattern = r"最好|最低|绝对"
print(re.sub(pattern, "***", content))

 这个商品很好，质量***、用起来很不错，并且价格***，***的物美价廉

解释：

• re.sub可以实现正则替换字符串
• r"最好|最低|绝对"就可以同时匹配很多个字符串

091 给手机号打上马赛克

"""
如下文字中，有一些手机号数字
用python将所有的手机号，只保留开始和结尾数字，中间用******代替

输入内容：
白日依19989881888山尽，黄河入45645546468798978海流。
欲穷12345千里目，更上15619292345一层楼。

输出内容：
白日依19******88山尽，黄河入45645546468798978海流。
欲穷12345千里目，更上15******45一层楼。

提示：
手机号总共11位数字，总是数字1开头
在正则里可以加括号，代表分组，在re.sub时可以用\1、\2代表第几个分组
"""

答案解析

import re

content = """ 白日依19989881888山尽，黄河入45645546468798978海流。
欲穷12345千里目，更上15619292345一层楼。
"""
pattern = r"(1\d)\d{7}(\d{2})"
print(re.sub(pattern, r"\1******\2", content))

解释：

• 每个括号是一个分组，(1\d)是开头代表2个数字，(\d{2})是结尾的2个数字，中间7个数字
• 在re.sub的第二个参数，用\1和\2可以引用前面的两个分组

092 扫描目录下所有文件

"""
提供一个目录路径，用python扫描所有的文件，列出文件路径
例如：
dir = r"D:\workbench\python-exercises-100p"

输出内容：
D:\workbench\python-exercises-100p\.gitignore
D:\workbench\python-exercises-100p\LICENSE
D:\workbench\python-exercises-100p\Python练习100题课件.pptx
D:\workbench\python-exercises-100p\ceshi01.py 1
D:\workbench\python-exercises-100p\p001.py 5
D:\workbench\python-exercises-100p\p002.py 4
D:\workbench\python-exercises-100p\p003.py 4
D:\workbench\python-exercises-100p\p004.py 3
D:\workbench\python-exercises-100p\p005.py 3
等等

提示：
os.walk可以递归扫描目录
根据自己电脑的实际情况自定义一个路径，并输出对应路径的的文件
"""

答案解析

import os
dir = r"D:\workbench\python-exercises-100p"
for root, dirs, files in os.walk(dir):
    for file in files:
        fpath = os.path.join(root, file)
        print(fpath)

解释：

• 因为反斜线\在python字符串中有特殊含义，例如\n其实是换行符，因此如果要写路径，在前面加个r表示raw-string，那么后面的字符串中反斜线将会是正常的字符而不是转义符号
• os.walk返回的root是当前扫描到的目录地址，dirs和files则是当前扫描到的目录下的子目录列表、子文件列表
• os.path.join，可以拼接一个目录和一个文件名，得到一个结果路径

093 扫描py文件的行数

"""
提供一个目录路径，用python找出所有的.py文件

展示文件路径，以及文件的行数

输入内容：
dir = r"D:\workbench\python-exercises-100p"
输出内容：
D:\workbench\python-exercises-100p\ceshi01.py 1
D:\workbench\python-exercises-100p\p001.py 5
D:\workbench\python-exercises-100p\p002.py 4
D:\workbench\python-exercises-100p\p003.py 4
D:\workbench\python-exercises-100p\p004.py 3
D:\workbench\python-exercises-100p\p005.py 3
    
提示：
os.walk可以递归扫描目录，判断如果是.py文件，则读取文件计算行数
使用file.endswith(".py")可以判断是不是.py文件
len(f.readlines())可以统计文件行数

"""

答案解析

import os

dir = r"D:\workbench\python-exercises-100p"
for root, dirs, files in os.walk(dir):
    for file in files:
        if file.endswith(".py"):
            fpath = os.path.join(root, file)
            with open(fpath, encoding="utf8") as f:
                print(fpath, len(f.readlines()))

解释：

• 使用file.endswith(".py")可以判断是不是.py文件
• len(f.readlines())可以统计文件行数

094 自动整理文件夹

"""
自己新建一个目录 arrange_dir
自己在文件夹下，手动新建多个“假文件”：
aaa.txt bbb.mp3 ccc.avi ccc.jpg ddd.jpg eee.txt fff.mp3 ggg.jpg hhh.txt iii.mp3

编写代码，按后缀名将文件移动到 arrange_dir 下的多个子目录（txt、mp3、avi、jpg），如下效果所示
arrange_dir
 txt
    aaa.txt
    eee.txt
    hhh.txt
mp3
    bbb.mp3
    fff.mp3
    iii.mp3
avi
    ccc.avi
jpg
    ccc.jpg
    ddd.jpg
    ggg,jpg

提示：
os.listdir可以列出当前目录下的所有文件
os.path.splitext可以得到文件后缀名，例如.txt、.mp3
os.mkdir可以创建目录
shutil.move可以移动文件
"""

答案解析

import os
import shutil
dir = "./arrange_dir"
for file in os.listdir(dir):
    ext = os.path.splitext(file)[1]
    ext = ext[1:]
    if not os.path.isdir(f"{dir}/{ext}"):
        os.mkdir(f"{dir}/{ext}")
    source_path = f"{dir}/{file}"
    target_path = f"{dir}/{ext}/{file}"
    shutil.move(source_path, target_path)

解释：

• os.listdir可以列出当前目录下的所有文件
• os.path.splitext可以得到文件后缀名，例如.txt、.mp3
• os.mkdir可以创建目录
• shutil.move可以移动文件

095 自动压缩文件夹

'''
提供任何一个目录地址，用python实现文件夹的压缩，压缩成zip格式
例如：dir = r"D:\workbench\python-exercises-100p"
则会生成一个文件 r"D:\workbench\python-exercises-100p.zip"
这个压缩文件是对这个目录的压缩结果

提示：
python自带的zipfile模块可以实现压缩
有些文件以~$字符串开头，是临时文件，需要忽略掉
'''

答案解析

import os
import zipfile
def do_zip_compress(dirpath):
    output_name = f"{dirpath}.zip"
    parent_name = os.path.dirname(dirpath)
    zip = zipfile.ZipFile(output_name, "w", zipfile.ZIP_DEFLATED)
    for root, dirs, files in os.walk(dirpath):
        for file in files:
            if str(file).startswith("~$"):
                continue
            filepath = os.path.join(root, file)
            writepath = os.path.relpath(filepath, parent_name)
            zip.write(filepath, writepath)
    zip.close()

dirpath = r"D:\workbench\python-exercises-100p"
do_zip_compress(dirpath)

解释：

• zipfile.ZipFile可以新建压缩文件，用write方法即可写入文件
• 需要处理相对路径的问题，os.path.relpath可以获取相对路径

096 Requests模块报错

"""
请自己创建一个空文件，文件名是requests.py，请注意文件名不要写错了,然后粘贴如下代码到文件中:
import requests

r = requests.get("https://www.baidu.com/")
print(r.text[:100])

执行代码会报错，module 'requests' has no attribute 'get'
想办法修正
"""

答案解析

答案：代码文件名不能是requests.py，改成其他名字即可

解释：

• requests是一个开源库，自己是有get方法的
• 报错是因为，python本身导入类库时，会先从本地文件导入，它发现了本地文件有一个requests.py就导入了，但是这是我们自己的文件，里面确实没有get方法
• 如果改完了文件名，报错说requests不存在，则需要自己安装一下代码包

097 来自URL的文件

"""
用Python访问URL：http://antpython.net/static/py100/life_is_great.txt
然后打印文件中的如下内容：
Life Is Great
I am happy.
I have many friends.
I have a large family.
I have four brothers and four 
--- 后面内容省略

提示：使用开源的requests模块实现
"""

答案解析

import requests

r = requests.get("http://antpython.net/static/py100/life_is_great.txt")
print(r.text)

解释：

• requests是python的开源模块，可以请求URL的结果
• requests.get可以访问一个URL
• requests.get的结果，有一个属性是text，放置了这个URL的结果内容

098 下载URL的图片

"""
这个URL是一个图片，用python下载图片，存入到本地p098.jpeg：
https://img2.baidu.com/it/u=16845247,2548960002&fm=253&fmt=auto&app=138&f=JPEG?w=500&h=627
"""
    

答案解析

import requests

url = "https://img2.baidu.com/it/u=16845247,2548960002&fm=253&fmt=auto&app=138&f=JPEG?w=500&h=627"
r = requests.get(url)
with open("p098.jpeg", "wb") as f:
    f.write(r.content)

解释：

• 如果要下载文件，需要用open的wb模式写入文件，写入的时候，用resp.content二进制形式，不能用resp.text

099 给网页提交数据

"""
这是一个网页，里面有一个表单可以提交数据
http://antpython.net/webspider/grade_form
使用python提交一条数据，并且在网页上看到效果：
姓名：B0901970_1，语文88，数学99，英语66

提示：
可以用chrome浏览器的f12打开network，查看后台请求
表单提交的Url是：http://antpython.net/webspider/grade_form
提交方法是post，数据格式为 sname: xx，yuwen: 66，shuxue: 77，yingyu: 88
用requests.post提交即可
"""

答案解析

import requests

url = "http://antpython.net/webspider/grade_form"
datas = {"sname": "B0901970_1", "yuwen": 66, "shuxue": 77, "yingyu": 88}

resp = requests.post(url, data=datas)
print(resp.status_code)

200

解释：

• requests.post可以发送表单post请求，data可以提供数据，可以是字典形式
• resp.status_code如果是200，说明请求成功

100 打开百度搜索

"""
编写代码，让用户输入一个词语，代码自动打开浏览器，在百度搜索关键词，展示结果
例如用户输入python，自动打开这个界面

提示：
百度搜索的URL：https://www.baidu.com/s?wd=python 这个wd=python，可以替换关键词
python有个模块webbrowser，用它的webbrowser.open(url)可以直接浏览器打开一个URL
f-string可以用f"https://www.baidu.com/s?wd={query}"的方式拼接字符串
"""

答案解析

import webbrowser

query = input("请输入搜索词: ")
webbrowser.open(f"https://www.baidu.com/s?wd={query}")

提示：

• 百度搜索的URL：https://www.baidu.com/s?wd=python 这个wd=python，可以替换关键词
• python有个模块webbrowser，用它的webbrowser.open(url)可以直接浏览器打开一个URL
• f-string可以用f"https://www.baidu.com/s?wd={query}"的方式拼接字符串