Python练习题

条件判断语句写出判断一个数是否能同时被3和7整除的条件语句，并且打印对应的结果num = int(input('请输入一个数:'))if num % 3 == 0 and num % 7 == 0:print('能同时被3和7整除')else:print('不能同时被3和7整除')写出判断一个数能否被3或7整除，但是不能同时被3或者7整除的条件语句，并且打印对应的结果num = int(input

Virgoxinyi

3141人浏览 · 2021-04-15 18:08:28

Virgoxinyi · 2021-04-15 18:08:28 发布

条件判断语句

写出判断一个数是否能同时被3和7整除的条件语句，并且打印对应的结果

num = int(input('请输入一个数:'))
if num % 3 == 0 and num % 7 == 0:
    print('能同时被3和7整除')
else:
    print('不能同时被3和7整除')

写出判断一个数能否被3或7整除，但是不能同时被3或者7整除的条件语句，并且打印对应的结果

num = int(input('请输入一个数:'))  #注意转成int类型
if (num % 3 or num % 7) and (num % 21):
    print('能被3或7整除，但是不能同时被3或者7整除')

同时被整除：最小公倍数

写入年，写代码判断输入的年是否为闰年，并打印对应的结果。（闰年的条件：能被4整除但是不能被100整除或者能被400整除）

year = int(input('请输入一个年份:'))
if year % 4 == 0 and year % 100 or year % 400 == 0:
    print(year, '是闰年')

假设今天的上课时间为15678秒，以XX时XX分XX秒表示出来

time = 15678
hour = time // 3600
minute = time % 3600 // 60
second = time % 60
print(hour, '时', minute, '分', second, '秒', sep='')

定义两个变量保存一个人的身高和体重，编程实现判断这个人的身材是否正常。

“体重（kg）/身高（m）的平方”在18.5-24.9之间属于正常

weight = float(input('请输入您的体重（kg）：'))
height = float(input('请输入您的身高（m）：'))
BMI = weight / height ** 2
if 24.9 >= BMI >= 18.5:
    print('您的身材正常')

区间可以连写，如：24.9 >= BMI >= 18.5

九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print(j, '*', i, '=', i * j, sep='', end='\t')
    print('\n')

\t :制表符

range(a,b)–>[a,b)

求素数

假设成立法

for i in range(2, 101):
    flag = True                          #假设成立
    for j in range(2, int(i ** 0.5)+1):  #注意+1
        if i % j == 0:
            flag = False                 #判断不成立
            break
    if flag:                             #则执行
        print(i, '是质数')

使用计数法

for i in range(2, 101):
    count = 0                           #flag为0，与上面反过来
    for j in range(2, int(i ** 0.5) + 1):
        if i % j == 0:
            count += 1
            break
    if count == 0:
        print(i, '是质数')
    else:
        print(i, '是合数')

求斐波那契数列中第n个数的值，n是正整数

num1 = 1
num2 = 1

n = 12
for i in range(0, n - 2):
    a = num1 
    num1 = num2
    num2 = a + num2
print(num2)

冒泡排序法：

num = [3, 4, 3, 7, 4, 9, 5, 2, 6]
i = 0
while i < len(num) - 1:
    n = 0
    flag = True
    while n < len(num) - 1 - i:
        if num[n] > num[n + 1]:
            num[n], num[n + 1] = num[n + 1], num[n]
            flag = False
        n += 1
    if flag:
        break  #没有任何数据交换，则已经完全排序好了
    i += 1
print(num)

找最大数

a = [33, 4, 6, 3, 6, 4, 7]
a.sort()
print(a[-1])

字典

students = [
    {'name': '张三', 'age': 18, 'score': 98, 'tel': '13888887988', 'gender': 'female'},
    {'name': '李四', 'age': 28, 'score': 95, 'tel': '13888887986', 'gender': 'male'},
    {'name': '王五', 'age': 21, 'score': 98, 'tel': '13888887989', 'gender': 'unknown'},
    {'name': 'chris', 'age': 17, 'score': 58, 'tel': '13888887983', 'gender': 'male'},
    {'name': 'jack', 'age': 23, 'score': 52, 'tel': '13888887988', 'gender': 'female'},
    {'name': 'tony', 'age': 115, 'score': 89, 'tel': '13888887988', 'gender': 'unknown'},
]
# （1）统计不及格学生的个数
# （2）打印不及格学生的名字和对应的成绩
# (3)统计未成年学生的个数
# (4)打印手机尾号是8的学生的名字
# （5）打印最高分和对应的学生的名字
# （6）删除性别不明的学生
# （7）将列表按学生成绩从大到小排序
score_count = 0
age_count = 0
max_score = students[0]['score']
for student in students:
    if student['score'] < 60:
        score_count += 1
        print('不及格学生的名字是%s,对应的成绩是%d' % (student['name'], student['score']))
    if student['age'] < 18:
        age_count += 1
    if student['tel'].endswith('8'):
        print('手机尾号是8的学生为：%s' % student['name'])
    if max_score <= student['score']:
        max_score = student['score']
        print('最高分为%d' % max_score)

for student in students:
    if max_score == student['score']:
        print('最高分学生的名字为：%s' % student['name'])
print('不及格学生的个数为%d' % score_count)
print('未成年学生的个数是%d' % age_count)

# 方法一：将不需要删除的数据添加到新列表
new_student = [student for student in students if student['gender'] != 'unknown']
print(new_student)

# 方法二：利用浅复制删除
for student in students[::]:
    if student['gender'] == 'unknown':
        students.remove(student)
print(students)

# 方法三：使用while删除，并及时补齐因删除数据而导致的列表数据索引变化，避免漏删
i = 0
while i < len(students):
    if students[i]['gender'] == 'unknown':
        students.remove(students[i])
        i -= 1  # 因删除抵消了自动跳到下一个
    i += 1  # 自动跳到下一个进行检验
print(students)

# 方法四：使用内建函数filter()和匿名函数
# filter(函数或无, 可迭代对象)，把可迭代对象中满足函数的/为True的挑出来
new_student = filter(lambda student: student['gender'] != 'unknown', students)
print(list(new_student))
# 注意转化为列表形式才能打印，否则是filter的形式

sorted_student = sorted(students, key=lambda student: student['score'], reverse=True)
print(sorted_student)
# sorted(iterable, key=要比较的，从大到小/从小到大)

用三个元组表示三门学科的选课学生姓名（一个学生可以同时选多门课）

求选课学生总共多少人
求只选了第一个学科的人的数量和对应的名字
求只选了一门学科的学生数量和对应的名字
求只选了两门学科的学生数量和对应的名字
求只选了三门学科的学生数量和对应的名字

# 用三个元组表示三门学科的选课学生姓名（一个学生可以同时选多门课）
#
# 1. 求选课学生总共多少人
# 2. 求只选了第一个学科的人的数量和对应的名字
# 3. 求只选了一门学科的学生数量和对应的名字
# 4. 求只选了两门学科的学生数量和对应的名字
# 5. 求只选了三门学科的学生数量和对应的名字
sing = ('李白', '白居易', '李清照', '杜甫', '王昌龄', '王维', '孟浩然', '王安石')
dance = ('李商隐', '杜甫', '李白', '白居易', '岑参', '王昌龄')
rap = ('李清照', '刘禹锡', '岑参', '王昌龄', '苏轼', '王维', '李白')

total = set(sing + dance + rap)
print(len(total))

first = []
for student in sing:
    if student not in dance and student not in rap:
        first.append(student)
print('只选了第一个学科的数量为{}，名字为{}'.format(len(first), first))

group = {}
ALL = sing + dance + rap
for student in total:
    if student not in group:
        group[student] = ALL.count(student)
print(group)

group1 = []
group2 = []
group3 = []
for k, v in group.items():
    if v == 1:
        group1.append(k)
    elif v == 2:
        group2.append(k)
    elif v == 3:
        group3.append(k)
print('报了一门课的有：{}'.format(group1))
print('报了二门课的有：{}'.format(group2))
print('报了三门课的有：{}'.format(group3))

Pycharm调试按键

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xLl1nE4d-1618481271367)(D:\python学习\笔记\图片\1.png)]

绿色三角箭头：运行到下一个断点
第一个蓝色箭头：运行下一步，会到第一层函数，但是不会到第二层
第二个蓝色箭头：可以到第二层函数
第四个向上的蓝色箭头：跳出第二层

函数

# 实现摇骰子的功能，打印N个骰子的点数和
import random
def tou(n):
    s = 0
    for i in range(n):
       s += random.randint(1, 6)
    return s


print(tou(4))

在for中运用次数n可以用range(n)

# 4. 交换指定字典的key和value
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {k: v for v, k in dict1.items()}
print(dict2)

注意是items

# 5. 提取指定字符串中所有字母，然后拼接在一起产生一个新的字符串
a = '12a&bc12d'
b = ''
for i in a:
    if i.isalpha():
       b += i
print(b)

字符串的拼接：+

# 将字符串的首字母变成大写字母
def my_capitalize(s):
    if 'z' >= s[0] >= 'a':
        return s[0].upper()+s[1:]
    return s


s = 'Sjfesof'
print(my_capitalize(s))

判断是否为字母：‘z’ >= s[0] >= 'a’

# 判断字符串是否只由数字组成
def my_isdigit(words):
    for i in words:
        if not '9' >= i >= '0':
            return False
    return True


print(my_isdigit('nws'))

1. 返回值是布尔值，如果2. 有判断语句可以3. 直接作为返回值

# 将字符串中所有的字母改成大写
def my_upper(words):
    new_str = ''
    for i in words:
        if 'z' >= i >= 'a'
            word = chr(ord(i) -32)
            new_str += word
        else:
             new_str += i
    return new_str


print(my_upper('djsjfJRGIjrf'))

凡是涉及字符串的修改，就设定一个空字符串‘’

对于字符串的转换，可以用chr和ord

# replace
def my_replace(lie, old, new):
    return new.join(lie.split(old))

def my_replace(lie, old, new):
    i = 0
    new_lie = ''
    while i < len(lie):
        if lie[i: i + len(old)] != old:
            new_lie += lie[i]
            i += 1
        else:
            new_lie += new
            i += len(old)
    return new_lie


print(my_replace('how are you? and you?', 'you', 'me'))

# max，如果序列是字典，取字典的最大值
def my_max(seq):
    if type(seq) == dict:
        seq = list(seq.values())
    x = seq[0]
    for i in seq:
        if i > x:
            x = i
    return x


m1 = 'ajiergragrz'
m2 = {'小明': 90, '张三': 76, '路飞': 98}
print(my_max(m2))

对于字典，seq.values()的结果是dict_values([90, 76, 98]), 要转换成列表即可

如果要字典和其他序列采取类似的操作，即可用转换的方法

面向对象

1

房子（House)有户型，总面积，剩余面积和家具名称列表属性

新房子没有任何家具

将家具的名称追加到家具名称列表中

判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具

家具（Furniture）有名字和占地面积属性，其中

席梦思（bed）,占地 4 平米

衣柜（chest），占地 2 平米

餐桌（table）, 占地1.5平米

将以上三件家具添加到房子中

打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表

class House(object):
    def __init__(self, house_type, total_area, fur_list=None):
        if fur_list is None:
            fur_list = []
        self.house_type = house_type
        self.total_area = total_area
        self.free_area = total_area * 0.6
        self.fur_list = fur_list

    def add_fur(self, x):
        # 对于别的类的变量：类名（形参）.变量名
        # 对于自身类的变量：self.变量名，所以要形参传递给self。
        # 共同点：都要个.
        if self.free_area < x.area:
            print('剩余面积不足！')
        else:
            self.fur_list.append(x.name)
            self.free_area -= x.area

    def __str__(self):
        return '户型={}，总面积={}，剩余面积={}，家具名称列表={}'.format(self.house_type, self.total_area, self.free_area, self.fur_list)


class Furniture(object):
    def __init__(self, name, area):
        self.name = name
        self.area = area


house = House('两室一厅', 56)  # house可以调用所有的House中属性与方法
bed = Furniture('席梦思', 4)
chest = Furniture('衣柜', 2)
table = Furniture('餐桌', 1.5)
# 注意：只有将House类转换成实例house，才能对House里面的函数方法进行运用
house.add_fur(bed)  # 调用house对象的fur方法，则add_fur中的self指向house，x指向bed内存
house.add_fur(chest)
house.add_fur(table)
print(house)

对于别的类的变量：类名（形参）.变量名
对于自身类的变量：self.变量名，所以要形参传递给self。
共同点：都要个.

只有将House类转换成实例house，才能对House里面的函数方法进行运用

2

class Person(object):

    def __init__(self, name, age):
        # 在创建对象时，会自动调用这个方法
        print('__init__方法被调用了')
        self.name = name
        self.age = age

    def __str__(self):
        return '姓名：{}，年龄：{}'.format(self.name, self.age)

    def __call__(self, *args, **kwargs):
        print('args={},kwargs={}'.format(args, kwargs))
####不用填*!!!!!!
        return kwargs['fn'](args[0], args[1]) ##########


p = Person('zhangsan', 18)
print(p)
# print(repr(p))  # 调用内置函数repr会触发对象的__repr__方法
# print(p.__repr__())  # 一般不手动调用
print(p(1, 2, fn=lambda x, y: x + y))

__init__方法被调用了
姓名：zhangsan，年龄：18
args=(1, 2),**kwargs={'fn': <function <lambda> at 0x000001F43E685B88>}**
3
会把函数存为字典

3

设计两个类：
一个点类，属性包括x,y坐标。一个Rectangle类（矩形），属性有左上角和右下角的坐标
方法：1. 计算矩形的面积；2. 判断点是否在矩形内
实例化一个点对象，一个正方形对象，输出矩形的面积，输出点是否在矩形内

class Pointer(object):
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y


class Rectangle(object):
    def __init__(self, top_left: Pointer, bottom_right: Pointer):
        self.top_left = top_left
        self.bottom_right = bottom_right

    def get_area(self):
        length = self.bottom_right.x - self.top_left.x
        width = self.top_left.y - self.bottom_right.y
        return length * width

    def is_inside(self, point):  # 把p传进来作为形参，注意不要在类里出现实例对象
        return self.bottom_right.x >= point.x >= self.top_left.x and self.top_left.y >= point.y >= self.bottom_right.y


p1 = Pointer(2, 20)
p2 = Pointer(20, 2)
p = Pointer(5, 8)
r = Rectangle(p1, p2)
print('矩形的面积是%d' % r.get_area())
print(r.is_inside(p))

关于类的打印：

   1. 统一放在`__str__`里
      2. 在方法里return，并且在实例调用后写print

尽可能找类之间的相同项，并运用 互相调用 和继承

4

# 写一个计算器，可以进行加减乘除计算
class Calculator(object):
    @staticmethod
    def add(a, b):
        return a + b

print(Calculator.add(3, 4))

如果没有用到实例对象，就不要创建实例对象!!!用@staticmethod

如果方法中增加或修改的是类里属性，就不要把属性返回了，直接用实例对象来调用该属性

5

# 宠物店类 PetShop
# 属性：店名，店中的宠物（使用列表存储宠物）
# 方法：展示所有宠物的信息
#
# 宠物狗类：PetDog
# 属性：昵称，性别，年龄，品种
# 方法：叫，拆家，吃饭
#
# 宠物猫类：PetCat
# 属性：昵称，性别，年龄，品种，眼睛的颜色
# 方法：叫，撒娇，吃饭
# 注意：狗的叫声是汪汪汪，猫的叫声是喵喵喵
#      狗吃的是骨头，猫吃的是鱼
class PetShop(object):
    def __init__(self, shop_name, pet_list=None):
        self.shop_name = shop_name
        if pet_list is None:
            pet_list = []
        self.pet_list = pet_list

    def show_pets(self):
        if len(self.pet_list) == 0:
            print('本店还没有宠物')
            return

        print('{}有{}个宠物,它们是:{}'.format(self.shop_name, len(self.pet_list), self.pet_list))

        # for pet in self.pet_list:
        #     print(pet)


class Pet(object):
    def __init__(self, name, gender, age, breed):
        self.name = name
        self.gender = gender
        self.age = age
        self.breed = breed

    def bark(self):
        print(self.name + '正在叫')

    def eat(self):
        print(self.name + '正在吃东西')

    def __repr__(self):
        return '姓名:{},性别{},年龄:{},品种:{}'.format(self.name, self.gender, self.age, self.breed)


class PetDog(Pet):
    # 没有新增的属性，不要写__init__方法
    def bark(self):
        print(self.name + '正在汪汪汪')

    def build_home(self):
        print(self.name + '正在拆家')

    def eat(self):
        print(self.name + '正在啃骨头')


class PetCat(Pet):
    def __init__(self, name, gender, age, breed, eyes_color):
        super(PetCat, self).__init__(name, gender, age, breed)
        self.eyes_color = eyes_color

    def bark(self):
        print(self.name + '正在喵喵喵')

    def sajiao(self):
        print(self.name + '正在撒娇')

    def eat(self):
        print(self.name + '正在吃鱼')

    def __repr__(self):
        x = super(PetCat, self).__repr__()
        x += ",眼睛颜色:{}".format(self.eyes_color)
        return x


class PetBird(Pet):
    pass


dog1 = PetDog('大黄', 'female', 3, '哈士奇')
dog2 = PetDog('二黄', 'male', 2, '萨摩耶')
cat1 = PetCat('tom', 'male', 2, '英短', 'blue')
cat2 = PetCat('包子', 'female', 3, '加菲猫', 'black')

ps = PetShop('萌宠', [dog1, dog2, cat1, cat2])
ps.show_pets()

如果子类没有新增属性，不要写__init__方法
如果要在一个类A中打印另一个类B的属性，直接把这个B的实例对象传入A中即可
如果要打印不同子类中不同的属性或任何内容，可以①在不同子类中的__str__中return不同的内容②print（实例名）
在方法上：子类对父类的返回值（字符串）有添加（方法的添加）：
x = super(PetCat, self).__repr__()
x += “,眼睛颜色:{}”.format(self.eyes_color)
打印多个实例合起来的列表：

①for i in list:一个个取出i.name
②直接print(list)，打印的内容要在类中的__repr__

权限因子和装饰器

user_permission = 15  # 0b111 , 位判断
# 权限银子：扩列即为8，16，32....每一位上的0/1表示是否有权限
# 用户权限&权限因子 ==> 即可判断，同1为1
DEL_PERMISSION = 8  # 1011 & 1000 ==> 1000
READ_PERMISSION = 4  # 0b100
WRITE_PERMISSION = 2  # 0b010
EXE_PERMISSION = 1  # 0b001


def check_permission(x, y):
    def handle_action(fn):
        def do_action():
            if x & y != 0:
                fn()
            else:
                print('对不起，您没有权限！')

        return do_action

    return handle_action


@check_permission(user_permission, READ_PERMISSION)
def read():
    print('我正在读取内容')


@check_permission(user_permission, WRITE_PERMISSION)
def write():
    print('我正在写入内容')


@check_permission(user_permission, EXE_PERMISSION)
def execute():
    print('我正在执行内容')


@check_permission(user_permission, DEL_PERMISSION)
def delete():
    print('我正在删除内容')


read()
# write()
# execute()

迭代器(类)

import time


class Fibonacci(object):
    def __init__(self, n):
        self.n = n
        self.num1 = self.num2 = 1
        self.count = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.count += 1
        if self.count <= self.n:
            x = self.num1
            self.num1, self.num2 = self.num2, self.num1 + self.num2
            return x
        else:
            raise StopIteration


# 1,1,2,3,5,8,13,21,34,55,89,144
f = Fibonacci(3000)  # 占时间，不占用空间。以时间换空间
for i in f:
    pass

print('--------------')
print(i)
# 既然有列表了，为什么还要有生成器呢?

# 占空间，不占时间。  以空间换时间
nums = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

迭代的属性必须是self.x类
让迭代器停止: raise StopIteration
可以自己调用自己__next__:__iter__中returen self
不断得调用这个对象的__next__方法

生成器

def fibonacci(n):
    num1 = 1
    num2 = 1
    count = 0
    while count <= n - 2:
        num1, num2 = num2, num1 + num2
        count += 1
        yield num1

        
F = fibonacci(12)  # 此时并不会调用函数
for i in F:
    print(i)

是一个特殊的迭代器，对代码进行了简化

对于yield，如果想要得到每一次迭代的结果，就可以把return改成yield，return只会得到最后一个值

文件

将指定路径下的音频文件剪切到其他路径下

import os

old_file = '../0 5分钟读懂Python，走进Python工程师.mp4'
new_file = '0 5分钟读懂Python，走进Python工程师.mp4'
read_handle = None
write_handle = None
try:
    write_handle = open(new_file, 'wb')
    read_handle = open(old_file, 'rb')
    file_size = os.path.getsize(old_file)
    has_read = 0
    while has_read < file_size:
        data = read_handle.read(1024)
        write_handle.write(data)
        write_handle.flush()  # 刷新
        has_read += 1024
except Exception as e:
    print(e)
finally:
    if write_handle is not None:
        write_handle.close()
    if read_handle is not None:
        read_handle.close()
        os.remove(old_file)

关于文件操作的套路：

    1. 设置文件的open()后的值handle为None，
       2. 尝试对于所有的文件操作是否成功
       3. 不成功==》提示错误
       4. 如果handle不是None，表明文件打开成功==》关闭文件

凡是关于文件，路径的操作，去看看 os 模块！！

import json
name = 'youbian.txt'
you = 100000
file_handle = open(name, 'r', encoding='utf8')
code_list = []
try:
    while True:
        content = file_handle.readline().rstrip(',\n')
        if not content:
            break
        x = json.loads(content)
        code_list.append(x)
except FileNotFoundError:
    print('文件打开失败')

for code in code_list:
    if code[0] == you:
        print(code[1])
        break
else:
    print('没有找到对应邮编')

读取一个大型的文本文件txt时：

所有的内容都是字符串的形式，要用json.load()转化。比如数字，列表等，转化后才能利用不同的属性进行操作
但凡看到中文的文档，都要记得encoding=‘utf8’！！！
如果同类数据之间有不需要的数据如 “,\n” ,

[100000,“北京市”],
[110100,“北京市市辖区”],
[110101,“北京市东城区”],
[110102,“北京市西城区”],
[110103,“北京市崇文区”],
[110104,“北京市宣武区”],

就用这样一点一点读取的套路
while True:
content = …
if not content:
break
警惕文档中看不见的\n, \t等等，记得删除。比如\n用rstrip(’\n’)

try:
    with open('xxx.txt', 'w', encoding='utf8') as f:
        s = 'I am a boy'
        sep = ' '
        s1 = list(s.split(sep))
        content = sep.join(s1[::-1])
        print(content, file=f)
except Exception as e:
    print(e)

反转：a.[::-1]或a.reverse()

名片管理系统

多行字符串的输入

"---------------------------\n名片管理系统 V1.0\n1:添加名片\n2:删除名片\n3:修改名片\n4:查询名片\n5:显示所有名片\n6:退出系统\n---------------------------"

或

"""
__________________________
名片管理系统 V1.0
1：添加名片
2：删除名片
3：修改名片
4：查询名片
5：显示所有名片
6：退出系统
__________________________"""

字典输入：

# print('您要修改的信息是:\n姓名:{},手机号:{},QQ号:{}'.format(user['name'], user['tel'], user['qq']))
print('您要修改的信息是:\n姓名:{name},手机号:{tel},QQ号:{qq}'.format(**user))

对于字典和实例对象的拆包，都需要在前面写变量名

关于验证密码：

都使用使用加密后的结果进行验证

主模块对于其他模块的变量修改：

在模块内定义一个参数，然后直接在外部改，无法传入到另一个模块,则不管在函数内还是函数外都是主模块中定义的值
用途：当其他模块中有一个参数时可变的，便于统一进行修改

关于用文件保存上一次输入的值

# json文件不能为空，否则运行会报错
# 第一次运行时，文件不存在，如果不给data赋一个空值，就无法在后面往data里面赋值
# 通用于保存上一次的输入值，有文件则读入文件，没有文件就是一个字典/列表（根据需要）
data = file_manager.read_json('data.json', {})

需要自动重复的操作

while True:  # 重新输入/自动重复的操作==》利用while True死循环，输入正确则退出

if 语句中出现多次重复的内容

# 如果在一个if..elif语句中出多次重复/大体上（小细节不同可以定义一个变量来保存）的，就把重复的内容拿出来放在if后面
# filter 对于 ’‘==’‘，注意不是students[''] == ''!!就不会有任何的过滤，因为就是True
key = ''
# 这里对key没有任何操作
students = filter(lambda ele: ele.get(key, '') == value, students)

关于生成器

# 关于filter要小心，filter的结果的结果时生成器，取一次, 数据(生成器内的)就没了

数据的选择

创建一个新的字典，把需要的数据放进去
把不需要的数据删除
给指定数据添加一个属性（如flag = True）, 作为标记

正则表达式

一个区间内的表示：

# ip地址检测 0.0.0.0 ~ 255.255.255.255
# num = input('请输入一个数字:')
# #    0~9      10~99            100 ~ 199  200~209 210~219 220~229 230~239 240~249  250~255
# # \d:一位数   [1-9]\d:两位数   1\d{2}:1xx  2:00~255
# x = re.fullmatch(r'((\d|[1-9]\d|1\d{2}|2([0-4]\d|5[0-5]))\.){3}(\d|[1-9]\d|1\d{2}|2([0-4]\d|5[0-5]))', num)
# print(x)

尽可能凑0-9：\d

用到一个路径的多个文件

work_dir="./course_datas/c15_excel_split_merge"
data.json’, {})


## 需要自动重复的操作

```python
while True:  # 重新输入/自动重复的操作==》利用while True死循环，输入正确则退出