序列的概念与使用-课后作业
一、单项选择题
1、关于Python组合数据类型，以下描述错误的是：
- A 组合数据类型能够将多个相同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序、更容易
- B 组合数据类型可以分为3类：序列类型、集合类型和映射类型
- C Python的字符串、元组和列表类型都属于序列类型
- D 序列类型是二维元素向量，元素之间存在先后关系，通过序号访问
【答案】D
【解析】暂无解析
2、关于Python的元组类型，以下选项错误的是：
- A 元组一旦创建就不能被修改
- B 元组采用逗号和圆括号（可选）来表示
- C 元组中元素必须是相同类型
- D 一个元组可以作为另一个元组的元素，可以采用多级索引获取信息
【答案】C
【解析】暂无解析
3、以下不是Python序列类型的是：
- A 字符串类型
- B 列表类型
- C 数组类型
- D 元组类型
【答案】C
【解析】暂无解析
4、序列s，哪个选项对s.index(x)的描述是正确的？
- A 返回序列s中元素x第一次出现的序号
- B 返回序列s中序号为x的元素
- C 返回序列s中元素x所有出现位置的序号
- D 返回序列s中x的长度
【答案】A
【解析】暂无解析
5、列表ls，哪个选项对ls.append(x)的描述是正确的？
- A 替换列表ls最后一个元素为x
- B 向ls中增加元素，如果x是一个列表，则可以同时增加多个元素
- C 只能向列表ls最后增加一个元素x
- D 向列表ls最前面增加一个元素x
【答案】C
【解析】暂无解析
二、程序设计题
1、分配学号
类型：列表元组
描述
文件“schoolCode.csv”和“MajorCode.csv”中的数据是每个学院的编号和专业的编号，“studentList.csv”文件中有若干学生信息，学生出现的顺序是他在班级中排名顺序，每行中的数据用逗号分隔，各数据依顺代表：
学生姓名,学生性别,学院,专业名称,行政班（专业加班级号，例如经济1901）,入学年级。
假如本科的学生层次编号为012，请为“studentList.csv”中的数据增加学号，学号创建规则是：
学生层次+入学年份后两位+学院代码+专业代码+班级号+班中排名。
例如：012171985170110 表示本科生、2017年入学、文法学院、 编辑出版专业、1701班、排名为10的同学
输入格式说明
第一行输入学生姓名
第二行输入班级
输出格式说明
第一行输出该学生的学号、学生姓名、学生性别、学院、专业名称、行政班、入学年级信息，各项之间空格分隔
其后分行输出该班级所有同学的学号、学生姓名、学生性别、学院、专业名称、行政班、入学年级信息，各项之间空格分隔
示例 1
输入：
段宁
金融gj1701
输出：
012142172140101 段宁 女 国际学院 金融 金融gj1401 2014
012172172170101 罗愚 女 国际学院 金融 金融gj1701 2017
012172172170102 卢佳 女 国际学院 金融 金融gj1701 2017
012172172170103 张郁 女 国际学院 金融 金融gj1701 2017
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
####### BEGIN HELPER FUNCTIONS ####################
# read_file()函数帮助你读取文件到列表，直接调用就可以，此段不需修改
def read_file(filename):
"""接收一个文件名为参数，数据类型为字符串类型，文件编码为utf-8，
返回值为列表，列表元素为将文件每一行根据逗号切分成的列表"""
with open(filename, 'r', encoding='utf-8') as file:
file_to_list = [line.strip().split(',') for line in file]
# 文件全部内容读取出来放入列表中，每个元素为一行字符串
return file_to_list # 以列表形式返回文件中的数据
####### END HELPER FUNCTIONS ####################
def student_id(ls_student, ls_school, ls_major):
"""参数为三个文件对象，依序分别由读学生信息、学院信息和专业信息文件获得。返回值为列表，为包含了新生成的学号的学生信息列表。"""
student_detail = []
# =============================== #
# 此处按文档注释要求补充你的代码
ID = 1
dic = {}
for item in ls_student:
s = '012'
s += item[-1][-2:]
dic[item[-2]] = dic.get(item[-2], 0) + 1
for i in ls_school:
if item[2] == i[0]:
s += i[1]
break
for i in ls_major:
if item[3] == i[0]:
s += i[1]
break
s += item[4][-4:]
if dic[item[-2]] < 10:
s += '0'
s += str(dic[item[-2]])
ls = [s]
for i in item:
ls.append(i)
student_detail.append(ls)
# =============================== #
return student_detail # 返回加了学号的学生信息列表
def student_info(stu_name, ls_student):
"""参数为学生名字字符串和学生的信息列表，返回值为该学生的详细信息"""
# =============================== #
# 此处按文档注释要求补充你的代码
for item in ls_student:
if stu_name == item[1]:
return item
# =============================== #
def classmate(stu_class, ls_student):
"""参数为学生班级和学生信息列表，返回值为同班同学的信息列表"""
# =============================== #
# 此处按文档注释要求补充你的代码
mate_ls = []
for item in ls_student:
if stu_class == item[-2]:
mate_ls.append(item)
# =============================== #
return mate_ls
if __name__ == '__main__':
stuName = input() # 输入学生姓名
stuClass = input() # 输入班级
student_list = read_file('studentList.csv')[1:] # 获得学生信息列表
school_code = read_file('schoolCode.csv') # 获得学院信息列表
major_code = read_file('MajorCode.csv') # 获得专业信息列表
studentDetail = student_id(student_list, school_code, major_code) # 调用函数计算ID并插入到列表中
print(*student_info(stuName, studentDetail)) # 输出学生信息
ls_classmate = classmate(stuClass, studentDetail) # 返回同班同学信息列表
for classmate in ls_classmate: # 逐个输出同学信息
print(*classmate)
2、葡萄酒评论分析报告
类型：列表元组
描述
文件“winemag-data.csv” 包含编号、国家、描述、评分、价格、省份等6列和12974行葡萄酒评论的数据。数据格式如下所示：
number,country,description,points,price,province 30,France,“Red cherry fruit comes laced with…”,86,15,Beaujolais
50,Italy,“This blend of Nero Avola and Syrah…”,86,15,Sicily
100,US,“Fresh apple, lemon and pear flavors…”,88,18,New York
通过分析这些数据，用户可以根据产地、评份、价格等挑选适合自己的葡萄酒，商家可以分析消费者的购买行为习惯，可以更加准确地提供适合市场的产品，精准定位客户。
请读取文件中的数据，完成以下任务：
输入’国家名列表’，统计文件中出现的葡萄酒生产国家，输出不重复的国家名列表，按字母表升序排序， 若国家名数据缺失，略过该条数据，返回值中不包含空字符串元素
输入’平均分’，计算每个国家的葡萄酒的平均得分( 保留最多2位小数)，返回值为国家名和得分的列表
输入’平均分排序’，计算每个国家的葡萄酒的平均得分，返回值为国家名和得分的列表， 按评分由高到低降序排列
输入’评分最高’，输出评分最高的十款葡萄酒的编号、出产国、评分和价格，按评分降序输出
输入’价格最高’，输出价格最高的二十款葡萄酒的编号、出产国、评分和价格，按价格降序输出
输入’葡萄酒评分’，统计各个评分的葡萄酒数量是多少？输出各个评分的葡萄酒数量的列表，按评分升序排序；输出拥有葡萄酒数量最多的评分和数量；输出拥有葡萄酒数量最多的评分的葡萄酒的平均价格
输入其他时，输出“输入错误”
**读取文件示例：**
def csv_to_ls(file):
"""接收文件名为参数，用pandas读取数据为dataframe格式，
再将其数据部分(values)用tolist()方法转为二维列表，
返回这个二维列表。
@参数 file：文件名，字符串类型
"""
wine_list = pd.read_csv(file).values.tolist()
# print(wine_list)
return wine_list
输入输出示例
示例仅为格式展示，与测试用例无关
示例 1
输入：
国家名列表
输出：
['Argentina', 'Armenia', ...... 'US', 'Ukraine', 'Uruguay']
示例 2
输入：
平均分
输出：
[['Argentina', 86.72], ['Armenia', 87.0],...... ['Ukraine', 83.0], ['Uruguay', 88.0]]
示例 3
输入：
葡萄酒评分
输出：
[[80, 38], [81, 71], ...... [95, 140], [96, 50], [97, 26], [98, 8], [99, 3]]
[86, 1743]
31.02
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
import pandas as pd
import math
# 定义符号常量，用于索引，使之具有清晰的语义
NUMBER = 0
COUNTRY = 1
DESCRIPTION = 2
POINTS = 3
PRICE = 4
PROVINCE = 5
def csv_to_ls(file):
"""接收文件名为参数，用pandas读取数据为dataframe格式，
再将其数据部分(values)用tolist()方法转为二维列表，
返回这个二维列表。
@参数 file：文件名，字符串类型
"""
wine_list = pd.read_csv(file).values.tolist()
return wine_list
def country_ls(wine_list):
"""接收列表格式的葡萄酒数据为参数，略过标题行，返回不重复的国家名列表，按字母表升序排序，
若国家名数据缺失，略过该条数据，返回值中不包含空字符串元素。
@参数 wine_list：葡萄酒数据，列表类型
"""
country_list = []
for x in wine_list:
if x[COUNTRY] not in country_list:
country_list.append(x[COUNTRY])
country_list.sort()
return country_list
def avg_point(wine_list, country):
"""接收列表格式的葡萄酒数据和国家名列表为参数，计算每个国家的葡萄酒的平均得分，
返回值为国家名和得分的列表。
@参数 wine_list：葡萄酒数据，列表类型
@参数 country：国家名，列表类型
"""
avg_point_per_country = []
for country_name in country:
point_of_country = [x[POINTS] for x in wine_list[1:] if x[COUNTRY] == country_name] # 每个国家的葡萄酒评分列表
avg_point_per_country.append([country_name, round(sum(point_of_country) / len(point_of_country), 2)])
return avg_point_per_country
def avg_point_sort(wine_list, country):
"""接收列表格式的葡萄酒数据和国家名列表为参数，计算每个国家的葡萄酒的平均得分，
返回值为国家名和得分的列表，按评分由高到低降序排列。
@参数 wine_list：葡萄酒数据，列表类型
@参数 country：国家名，列表类型
"""
avg_point_per_country = []
for country_name in country:
point_of_country = [float(x[POINTS]) for x in wine_list[1:] if x[COUNTRY] == country_name] # 每个国家的葡萄酒评分列表
avg_point_per_country.append([country_name, round(sum(point_of_country) / len(point_of_country), 2)])
return sorted(avg_point_per_country, key=lambda x: x[1], reverse=True)
def top_10_point(wine_list):
"""接收列表格式的葡萄酒数据参数，返回评分最高的十款葡萄酒的编号、出产国、评分和价格，按评
分降序输出。
需要注意的是评分可能有缺失值，此时该数据为nan
if math.isnan(x) == False可用于判定x的值是不是nan
nan的数据类型是float,不可以直接用字符串判定方法。
@参数 wine_list：葡萄酒数据，列表类型
"""
wine_top_point = [[x[NUMBER], x[COUNTRY], x[POINTS], x[PRICE]] for x in wine_list if math.isnan(x[POINTS]) is False]
return sorted(wine_top_point, key=lambda x: x[2], reverse=True)[:10]
def top_20_price(wine_list):
"""接收列表格式的葡萄酒数据参数，返回价格最高的二十款葡萄酒的编号、出产国、评分和价格，按价
格降序输出。
@参数 wine_list：葡萄酒数据，列表类型
需要注意的是价格可能有缺失值，此时该数据为nan
if math.isnan(x) == False可用于判定x的值是不是nan
nan的数据类型是float,不可以直接用字符串判定方法。
"""
wine_top_price = [[x[NUMBER], x[COUNTRY], x[POINTS], x[PRICE]]for x in wine_list if math.isnan(x[PRICE]) is False]
return sorted(wine_top_price, key=lambda x: x[3], reverse=True)[:20]
def amount_of_point(wine_list):
"""接收列表格式的葡萄酒数据参数，统计每个评分的葡萄酒数量，忽略没有评分的数据。
返回二维列表，按评分升序排序。
例如[...[84, 645], [85, 959],...]表示得分为84的葡萄酒645种，得分85的葡萄酒有959种。
@参数 wine_list：葡萄酒数据，列表类型
"""
point_list = []
for x in wine_list:
if x[POINTS] not in point_list:
point_list.append(x[POINTS])
point_list.sort()
amount = [x[POINTS] for x in wine_list]
amount_of_points = [[point, amount.count(point)] for point in point_list]
# print(amount_of_points)
return amount_of_points
def most_of_point(amount_of_points):
"""接收每个评分的葡萄酒数量的列表为参数，返回获得该分数数量最多的评分和数量的列表。
@参数 amount_of_points：每个评分的葡萄酒数量，列表类型
"""
return sorted(amount_of_points, key=lambda x: x[1], reverse=True)[0]
def avg_price_of_most_point(wine_list, most_of_points):
"""接收列表格式的葡萄酒数据和获得最多的评分及数量的列表为参数
忽略缺失价格的数据，返回这个分数的葡萄酒的平均价格，保留2位小数。
@参数 wine_list：葡萄酒数据，列表类型
@参数 most_of_points：获得最多的评分及数量，列表类型
"""
price_of_point = [x[PRICE] for x in wine_list if x[POINTS] == most_of_points[0] and math.isnan(x[PRICE]) is False]
avg_price_of_point = sum(price_of_point) / len(price_of_point)
# print(price_of_point)
return round(avg_price_of_point, 2)
def judge(txt):
"""接收一个字符串为参数，根据参数值调用不同函数完成任务"""
filename = './winemag-data.csv'
wine = csv_to_ls(filename)
country = country_ls(wine)
if txt == '国家名列表':
print(country)
elif txt == '平均分':
print(avg_point(wine, country)) # 每个国家的葡萄酒的平均得分
elif txt == '平均分排序':
print(avg_point_sort(wine, country)) # 每个国家的葡萄酒的平均得分降序输出
elif txt == '评分最高':
print(top_10_point(wine)) # 评分最高的十款葡萄酒的编号、出产国、评分和价格，按评分降序输出
elif txt == '价格最高':
print(top_20_price(wine)) # 价格最高的二十款葡萄酒的编号、出产国、评分和价格，按价格降序输出
elif txt == '葡萄酒评分':
amount_point = amount_of_point(wine)
most_point = most_of_point(amount_point)
print(amount_point) # 各个评分的葡萄酒数量
print(most_point) # 拥有葡萄酒数量最多的评分和数量
print(avg_price_of_most_point(wine, most_point)) # 拥有葡萄酒数量最多的评分的葡萄酒的平均价格
else:
print('输入错误')
if __name__ == '__main__':
text = input()
judge(text)
3、扑克牌游戏
描述
本题限定用以下方法打乱序列中的元素
random.shuffle()
几个人用一副扑克牌玩游戏，游戏过程通常有洗牌、发牌、理牌等动作，编写程序模拟游戏过程。新牌花色顺序为♠、♥、♣、♦，花色相同时按2、3、4、5、6、7、8、9、10、J、Q、K、A，最后是小王和大王，小王用’jokers’、大王用 'JOKERS’表示。
按以下要求编写程序：
- 按顺序输出新牌
- 洗牌
- 按洗好的顺序输出洗过的牌
- 将牌轮流分给参与游戏的人，按分牌的顺序输出每个人手上的牌
- 对每个人手上的牌升序排序并输出
- 输出时，每张牌间用空格分隔
输入
输入一个正整数表示参与游戏的人数，题目限定使每个人分到的牌数相同，即人数为54的约数
输入一个正整数表示随机数种子，本题使用随机数种子保证产生序列的稳定性来完成自动评测
输出
按顺序输出新牌
按洗好的顺序输出洗过的牌
按分牌的顺序输出每个人手上的牌
输出每个人手上升序排序的牌
输入输出示例
| 输入 | 输出 | |
|---|---|---|
| 示例 1 | 2 1024 | 参与游戏的人数：2 新牌顺序 ♠2 ♠3 ♠4 ♠5 ♠6 ♠7 ♠8 ♠9 ♠10 ♠J ♠Q ♠K ♠A ♥2 ♥3 ♥4 ♥5 ♥6 ♥7 ♥8 ♥9 ♥10 ♥J ♥Q ♥K ♥A ♣2 ♣3 ♣4 ♣5 ♣6 ♣7 ♣8 ♣9 ♣10 ♣J ♣Q ♣K ♣A ♦2 ♦3 ♦4 ♦5 ♦6 ♦7 ♦8 ♦9 ♦10 ♦J ♦Q ♦K ♦A jokers JOKERS 洗牌顺序 ♣K ♠2 ♠7 ♠J ♦9 jokers ♣8 ♥2 ♦8 ♠3 ♣A ♥K ♠9 ♥J ♦J ♣5 ♠A ♠K ♣J ♥5 ♠10 ♥Q ♣3 ♦4 ♥8 ♣9 ♣7 ♥3 ♥10 ♣2 ♦10 ♦K ♦2 ♠8 ♠5 ♦6 ♠Q ♦5 ♦7 ♥7 ♦Q ♥9 ♠6 ♣Q ♣6 ♣4 ♠4 ♦A ♥4 ♥6 ♣10 ♦3 ♥A JOKERS 每个人手上分到的牌 ♣K ♠7 ♦9 ♣8 ♦8 ♣A ♠9 ♦J ♠A ♣J ♠10 ♣3 ♥8 ♣7 ♥10 ♦10 ♦2 ♠5 ♠Q ♦7 ♦Q ♠6 ♣6 ♠4 ♥4 ♣10 ♥A ♠2 ♠J jokers ♥2 ♠3 ♥K ♥J ♣5 ♠K ♥5 ♥Q ♦4 ♣9 ♥3 ♣2 ♦K ♠8 ♦6 ♦5 ♥7 ♥9 ♣Q ♣4 ♦A ♥6 ♦3 JOKERS 每个人手上排序的牌 ♠4 ♠5 ♠6 ♠7 ♠9 ♠10 ♠Q ♠A ♥4 ♥8 ♥10 ♥A ♣3 ♣6 ♣7 ♣8 ♣10 ♣J ♣K ♣A ♦2 ♦7 ♦8 ♦9 ♦10 ♦J ♦Q ♠2 ♠3 ♠8 ♠J ♠K ♥2 ♥3 ♥5 ♥6 ♥7 ♥9 ♥J ♥Q ♥K ♣2 ♣4 ♣5 ♣9 ♣Q ♦3 ♦4 ♦5 ♦6 ♦K ♦A jokers JOKERS |
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
import random
def start():
"""初始顺序，返回元素为字符串的列表"""
cards_start = [i + j for i in desigh for j in num] + ghost
return cards_start
def shuffle_cards(cards_start):
"""打乱顺序，返回元素为字符串的列表"""
random.shuffle(cards_start)
return cards_start
def traver(cards_shuffle, m):
"""发牌给m个人,返回二维列表"""
person = []
for i in range(m):
person.append(cards_shuffle[i::m])
return person
def sort_cards(person, m):
"""对m个人手上的牌进行升序排序，花色按黑红梅方，牌面按点数，大王最大，小王第二大"""
person_sort = []
for i in range(m):
if ('jokers' in person[i]) and ('JOKERS' in person[i]):
person[i].remove('jokers')
person[i].remove('JOKERS')
person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:])))+['jokers', 'JOKERS'])
elif 'jokers' in person[i]:
person[i].remove('jokers')
person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:])))+['jokers'])
elif 'JOKERS' in person[i]:
person[i].remove('JOKERS')
person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:])))+['JOKERS'])
else:
person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:]))))
return person_sort
if __name__ == '__main__':
desigh = ['♠', '♥', '♣', '♦'] # 表示黑桃、红桃、梅花、方块
num = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
ghost = ['jokers', 'JOKERS']
n = int(input()) # 输入参与游戏的人数
s = int(input())
random.seed(s)
print(f'参与游戏的人数：{n}')
cards = start()
print('新牌顺序')
print(*cards)
cards_after = shuffle_cards(cards)
print('洗牌顺序')
print(*cards_after)
cards_n = traver(cards_after, n)
print('每个人手上分到的牌')
for i in range(n):
print(*cards_n[i])
cards_sort = sort_cards(cards_n, n)
print('每个人手上排序的牌')
for i in range(n):
print(*cards_sort[i])
4、生成随机密码
请编写程序，生成随机密码。具体要求如下：
（1）使用 random 库，采用 0x1010 作为随机数种子。
（2）密码 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*中的字符组成。
（3）每个密码长度固定为 10 个字符。
（4）程序运行每次产生 10 个密码，每个密码一行。
（5）每次产生的 10 个密码首字符不能一样。
输入输出示例
| 输入 | 输出 | |
|---|---|---|
| 示例 1 | 无 | So2WpkoC7i armJ86eUG9 B*GcqsYC^B wQ3bcfcAJy Xdyg8pQTIS YO!1YH1AP3 cuhZUk@s5& D@4d9$TBfp TBm#WfYNHr Ue75y$E9Cv |
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
import random
# 设置随机数种子
random.seed(0x1010)
# 设置用于随机的字符串
str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*"
# 封装每次随机的密码
def randomPassword():
# 用于保存生成的密码
password = ""
# 密码长度 10
for i in range(10):
# 根据先前定义好的字符串来进行随机
password += random.choice(str)
# 返回本次生成的密码
return password
# 程序开始位置
if __name__ == '__main__':
i = 0
while i < 10:
password = randomPassword()
if password[len(password) - 1] == "*" :
continue
print(password)
i += 1
5、列表元素计算
描述
从键盘输入一个列表，计算输出列表元素的平均值。请完善代码。
def mean(numlist):
s = 0.0
for num in numlist:
s = s + num
return ___①___
#请输入一个列表：
ls = eval(input())
print("average:",___②___)
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
if __name__ == '__main__':
def mean(numlist):
s = 0.0
for num in numlist:
s = s + num
return s / len(numlist)
# 请输入一个列表：
ls = eval(input())
print("average:", mean(ls))
6、列表基本操作：元素增加、删除
描述
请补充横线处的代码，listA中存放了已点的餐单，让Python帮你增加一个“红烧肉”，去掉一个“水煮干丝”。
listA = ['水煮干丝','平桥豆腐','白灼虾','香菇青菜','西红柿鸡蛋汤']
listA.___①____ ("红烧肉")
listA.____②____ ("水煮干丝")
print(listA)
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
if __name__ == '__main__':
listA = ['水煮干丝', '平桥豆腐', '白灼虾', '香菇青菜', '西红柿鸡蛋汤']
listA.append("红烧肉")
listA.remove("水煮干丝")
print(listA)
7、列表增加元素
描述
随机产生10个100以内的整数，随机数种子是10，将这10个数添加到列表中。请完善代码。
import random
ls=[]
___________
for i in range(10):
a=random.randint(0,100)
__________
print(ls)
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
import random
if __name__ == '__main__':
ls = []
random.seed(10) # 设置随机数种子为10，以确保每次运行时生成的随机数序列相同
for i in range(10):
a = random.randint(0, 100) # 生成一个0到100之间的随机整数
ls.append(a)
print(ls) # 打印生成的随机数列表
8、最大值
类型：Python 组合数据类型
输入一组数字，采用逗号分隔，输出其中的最大值。
**示例1：**
输入："8,3,5,7"
输出："8"
代码：
# -*- coding = utf-8 -*-
# @Author:为一道彩虹
if __name__ == '__main__':
txt = eval(input())
print(0 if txt == 0 else max(txt))
先赞后看，养成习惯！！！^ _ ^ ❤️ ❤️ ❤️
码字不易，大家的支持就是我的坚持下去的动力。点赞后不要忘了关注我哦！
338
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
