Python教程
Python练习题
本文主要是介绍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('请输入一个数:')) #注意转成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死循环，输入正确则退出
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"
splits_dir=f"{work_dir}/splits"
这篇关于Python练习题的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Python编程基础：变量与类型11-25
-
Python编程基础与实践11-25
-
Python编程基础详解11-24
-
Python编程基础教程11-21
-
Python编程基础与实践11-20
-
Python编程基础与高级应用11-20
-
Python 基础编程教程11-19
-
Python基础入门教程11-19
-
在FastAPI项目中添加一个生产级别的数据库——本地环境搭建指南11-17
-
`PyMuPDF4LLM`：提取PDF数据的神器11-16
-
四种数据科学Web界面框架快速对比：Rio、Reflex、Streamlit和Plotly Dash11-16
-
获取参数学习：Python编程入门教程11-14
-
Python编程基础入门11-14
-
Python编程入门指南11-14
-
Python基础教程11-13
栏目导航
