Python序列的概念与使用-课后作业[python123题库]

序列的概念与使用-课后作业

一、单项选择题

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’表示。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

按以下要求编写程序:‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

  1. 按顺序输出新牌
  2. 洗牌
  3. 按洗好的顺序输出洗过的牌
  4. 将牌轮流分给参与游戏的人,按分牌的顺序输出每个人手上的牌
  5. 对每个人手上的牌升序排序并输出
  6. 输出时,每张牌间用空格分隔

输入

输入一个正整数表示参与游戏的人数,题目限定使每个人分到的牌数相同,即人数为54的约数‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

输入一个正整数表示随机数种子,本题使用随机数种子保证产生序列的稳定性来完成自动评测‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

输出

按顺序输出新牌
按洗好的顺序输出洗过的牌
按分牌的顺序输出每个人手上的牌
输出每个人手上升序排序的牌‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

输入输出示例

输入输出
示例 12 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 个密码首字符不能一样。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

输入输出示例

输入输出
示例 1So2WpkoC7i 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))

先赞后看,养成习惯!!!^ _ ^ ❤️ ❤️ ❤️
码字不易,大家的支持就是我的坚持下去的动力。点赞后不要忘了关注我哦!

  • 4
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值