Python实验二

Posted 2023-04-06 谭你一个脑瓜崩

程序片段编程题

1. 题库：把数列的元素重复n次，然后元素的平方形成新列表，然后去除重复元素
【问题描述】

读入一个整数列表和正整数n(n>1)，把列表中每个元素重复n次，并对每个元素进行平方形成新的列表，最后去除列表中的重复元素。打印输出新列表。
【输入形式】

第一行输入列表，包括方括号，元素之间用逗号分隔。

第二行输入重复的次数。
【输出形式】

直接用print输出列表
【样例输入】

[2,3,4,5,5]

5

【样例输出】

[4, 9, 16, 25]

ls = eval(input())
n = eval(input())
# 重复列表元素n次
ls2=[];
for i in range(n):
    ls2+=ls
ls3 = [x*x for x in ls2]
# 下面代码去除重复元素
ls4=[]
for x in ls3:
   if not x in ls4:
           ls4.append(x)

print(ls4)

2. 题库：找出列表中的多数元素
【问题描述】

读入一个大小为n的列表，找出其中的多数元素。多数元素是指在列表中出现次数大于n//2的元素（每个列表最多一个多数元素）。根据代码框架编写一个函数。
【输入形式】

输入列表，包括方括号，逗号分隔
【输出形式】

如果有多数元素，输出这个元素的值，如果没有多数元素，输出False
【样例输入】

[3,2,3]
【样例输出】

3

def search(y):
    for x in y:
        if(y.count(x)>(len(y)//2)):
            return x;
    return False;

nums = eval(input())
y = search(nums)
print(y)

3. 题库：找出不是两个列表中的共有元素，在结果列表升序没有重复元素
【问题描述】

给定两个整型列表，找出不是两者共有的元素。这些元素不重复的放入新的列表，并升序排列。输出结果列表

【输入形式】

第一行输入一个列表，包括方括号，逗号分隔

第二行输入一个列表，包括方括号，逗号分隔
【输出形式】

直接用print打印结果列表
【样例输入】

[1,2,3,4,5,6,7,8,8,9,9]

[1,2,3,4,7,7,7,10,10]

【样例输出】

[5, 6, 8, 9, 10]

【样例说明】

在第一个列表中8,9有重复元素，在结果列表中只能有一个。第二个列表中的10也有重复元素，去除。升序排列元素。

nums1 = eval(input())
nums2 = eval(input())
nums3 = []
# 把不nums1中和nums2不重复的元素加入nums3
for x in nums1:
    if x not in nums2:
        if x not in nums3:
            nums3.append(x);

# 把num2中的元素不重复的加入nums3
for x in nums2:
    if x not in nums1:
        if x not in nums3:
            nums3.append(x)
# True为逆序，False为正序
nums3.sort(reverse = False)

print(nums3)

4. 题库：判断一个数的两个加数是否在列表中
【问题描述】

读入一个列表nums和整数n，判断构成n的两个加数是否在列表中。每个元素可以使用多次。如果存在，这输出True，不存在输出False。
【输入形式】

第一行输入列表，包括方括号，列表元素逗号分隔

第二行输入整数
【输出形式】

True或者False
【样例输入】

[1,2,2,3]

6
【样例输出】

True
【样例说明】

输入的样例中，6=3+3，所以结果输出为True

如果第二行输入的是7。则输出False

nums = eval(input())
n = eval(input())
for x in nums:
    if n-x in nums:
        print(True)
        break
else:
    print(False)

5. 题库：判断一个和的两个加数是否在列表中，每个元素不能使用2次（片段）。
【问题描述】

读入一个整数列表nums，读入一个整数sum。判断列表中是否有两个元素的和为sum。每个位置的元素只能使用一次。如果满足条件输出True，不满足输出False。
【输入形式】

第一行输入列表，包含方括号，逗号分隔

d第二行输入一个整数
【输出形式】

True或者False
【样例输入】

[1,2,3,4,5,6,6]

12

【样例输出】

True
【样例说明】

如果上面的输入列表中只有一个6，则不能构成和12. 因为每个元素只能使用一次。

nums = eval(input())
sum = eval(input())
for x in range(len(nums)):
    n = sum-nums[x]
    if n in nums:
        if n!=nums[x]:
            print(True)
            break
        else:
            if nums.count(n)>=2:
                print(True)
                break
else:
    print(False)

6. 题库：计算列表的度
【问题描述】

对于一个包含自然数的列表nums，计算他的度。列表的度定义为列表里任一元素出现的频率的最大值。

【输入形式】

从键盘输入一个列表，包含方括号，逗号分隔
【输出形式】

整数
【样例输入】

[1,2,3,3,4,5,4,3,3]

【样例输出】

4
【样例说明】

列的所有元素的频率中，元素3的频率最大为4.

def calDegrees(y):
    z=0;
    for x in y:
        if y.count(x)>z:
            z=y.count(x);
    return z;
        
nums = eval(input())
d=calDegrees(nums) #调用自定义函数
print(d)

编程题

1. 题库：计算整数列表平均值(根据结果判断是否输出小数部分）
【问题描述】

输入一个整数列表，计算所有元素的平均值，如果结果中小数为0，请只输出整数部分，如果结果中的小数部分不为0，则输出结果保留两位小数。
【输入形式】

从键盘输入列表，包含方括号，列表元素用逗号分隔。

【输出形式】

纯整数，或者带两位小数的浮点数
【样例输入1】

[1,2,3,4,5]
【样例输出1】

3

【样例输入2】

[2,2,3,7,5,1]
【样例输出2】

3.33

【样例说明】

[1,2,3,4,5]列表平均值为3，计算出来结果小数部分为0，只输出整数3；[2,2,3,7,5]列表平均值为浮点数，所以输出结果保留两位小数为3.33

import math
from statistics import mean
def pr(y):
    x = mean(y) 
    z=math.floor(x);
    if(x==z):
        print(z)
    else:
        print("%.2f" %x)

sums=eval(input());
pr(sums);

2. 题库：生成指定长度的等差数列
【问题描述】

输入三个正整数n，m，l，生成指定长度的等差数列，存入列表中。其中n表示起始值，m表示列表元素的数量，l表示公差。
【输入形式】

在同一行输入n，m，l三个值，中间用英文逗号分隔。
【输出形式】

打印输出列表
【样例输入】

2,3,2
【样例输出】

[2, 4, 6]

【样例说明】

第一个数字表示数列的起始值，第二个数字表示数据的个数，第三个数字表示差。

def shulie(n,m,l):
    sums = list(range(n,(n+m*l),l));
    print(sums);
x,y,z=eval(input());
shulie(x,y,z);

3. 题库： 把列表中数值为0的元素移动到列表的尾端，其他元素相对顺序不变。
【问题描述】

读入一个整数列表，把数值为0的元素移动到列表尾部，其他元素的相对顺序不变。输出调整后的列表。
【输入形式】

按照列表的形式输入，包括方块号，逗号分隔。
【输出形式】

直接使用print打印
【样例输入】

[1,0,2,0,3,0,4]

【样例输出】

[1, 2, 3, 4, 0, 0, 0]

def ling(y):
    z=[0];
    x=y.count(0);
    while 0 in y:
        y.remove(0);
    for i in range(x):
        y=y+z;
    print(y);
sums=eval(input());
ling(sums);

4. 题库：在列表中找出只出现一次的元素，并排序输出
【问题描述】

输入一个自然数列表，找出只出现一次的元素，并升序输出。如果没有只出现一次的元素，则输出False。
【输入形式】

输入包含自然数的列表，包括方括号，逗号分隔
【输出形式】

排序后的数字，每个数字之间用英文逗号分隔。或者False。
【样例输入1】

[1,2,3,5,2,3,4]
【样例输出1】

1,4,5

【样例输入2】

[9,9,9,12,12]
【样例输出2】

False

【样例说明】

[9,9,9,12,12]列表中，9出现3次，12出现2次，没有出现一次的元素，则输出False。

def one(y):
    x=[];
    for i in y:
        if y.count(i)==1:
            x.append(i);
    x.sort(reverse=False);
    if x==[]:
        print(False);
    else:
        print(*x,sep=',');
sums=eval(input());
one(sums);

5. 题库：从一个列表中取出第n个元素，并重复m次，放到末尾，然后输出列表
【问题描述】

输入一个整数列表和整数n(n可以是负数）和正整数m，从该列表中选择第n个元素，把该元素重复m次，然后放到列表的尾端，最后输出列表。如果输入的n值不在列表下标范围之内，则输出"error"
【输入形式】

输入时，第一行输入列表的元素，用英文逗号分隔。

第二行输入两个数字n和m，用英文逗号分隔。

【输出形式】

直接使用print输出列表
【样例输入1】

1,2,3,4,5

2,3
【样例输出1】

[1, 2, 3, 4, 5, 3, 3, 3]

【样例输入2】

1,2,3,4,5

5,3
【样例输出2】

error

【样例说明】

样例2中，输入的n值为5，但是列表的元素一共才5个，超出下标范围，输出error

import math
def mowei(y,n,m):
    if n!=math.floor(n):
        print('error');
    else:
        if n>=(-len(y)) and n<len(y):
            x=y[n];
            for i in range(m):
                y.append(x);
            print(y);
        else:
            print('error');   
            
sums=list(eval(input()));
n,m=eval(input());
mowei(sums,n,m);

6. 题库：交换列表中两个元素的值，并输出列表
【问题描述】

输入一个由字符串构成的列表和两个整数n和m（n和m在输入列表的下标范围以内），交换其中两个元素的值，打印输出交换后的列表。
【输入形式】

第一行输入由空格分隔的多个字符串

第二行输入两个整数n和m，表示元素的位置，两个数字之间用空格区分。
【输出形式】

直接使用print函数输出列表
【样例输入1】

hello world python is great

2 3
【样例输出1】

[‘hello’, ‘world’, ‘is’, ‘python’, ‘great’]

【样例输入2】

hello world python is great

-2 3
【样例输出2】

[‘hello’, ‘world’, ‘python’, ‘is’, ‘great’]

【样例说明】

多个字符串由空格区分，程序读入后，转变成列表，然后交换指定位置的元素，最后使用print直接输出列表。

def Change(y,m,n):
    y[m],y[n]=y[n],y[m];
    print(y);
sums=input();
m,n = list(map(int, input().strip().split()))
y=sums.split();
Change(y,m,n);

7. 题库：计算整数列表的平均值
【问题描述】

输入一个整数列表，计算所有元素的平均值。结果保留两位小数。输入数据用逗号分隔
【输入形式】

从键盘输入一个整数列表，包括方括号，元素逗号分隔
【输出形式】

输出所有元素的平均值，结果保留两位小数

【样例输入】

[1,2,3,4,5]

【样例输出】

3.00
【样例说明】

用列表的形式输入一串整数，然后计算平均值，输出3.00，结果保留了两位小数。

def pingjun(y):
    print("%.2f" %(sum(y)/len(y)));
sums=eval(input());
pingjun(sums);

8. 题库：找出自然数列表中的素数，并放入另外一个列表，然后输出找出的素数
【问题描述】

读入一个自然数构成的列表，找出其中的每一个素数，然后放入另外一个列表，并输出这个列表。
【输入形式】

按照列表的形式输入，包括方括号，元素之间用逗号分隔。
【输出形式】

直接用print输出列表
【样例输入】

[2,3,5,7,9,11,23]

【样例输出】

[2, 3, 5, 7, 11, 23]

【样例说明】

所有的输入数据在一行。所有的输出在一行。

def sushu(y):
    x=[];
    for i in y:
        if i>=2:
            for j in range(2,i,1):
                if i%j==0:
                    break;
            else:
                x.append(i);
    print(x);
sums=eval(input());
sushu(sums);

20192308王泽荣python实验二报告

20192308 2022-2022-2 《Python程序设计》实验二报告

课程：《Python程序设计》
班级： 1923
姓名： 王泽荣
学号：20192308
实验教师：王志强
实验日期：2022年3月31日
必修/选修： 公选课

1.实验内容

• 设计并完成一个完整的应用程序，完成加减乘除模等运算，功能多多益善。

• 考核基本语法、判定语句、循环语句、逻辑运算等知识点

2. 实验过程及结果

   #两数运算
   import re

def calculate(n1, n2, operator):

   \'\'\'
   :param n1: float
   :param n2: float
   :param operator: + - * /
   :return: float
   \'\'\'
   result = 0
   if operator == "+":
       result = n1 + n2
   if operator == "-":
       result = n1 - n2
   if operator == "*":
       result = n1 * n2
   if operator == "/":
       result = n1 / n2
   return result


# 判断是否是运算符，如果是返回True
def is_operator(e):
   \'\'\'
   :param e: str
   :return: bool
   \'\'\'
   opers = [\'+\', \'-\', \'*\', \'/\', \'(\', \')\']
   return True if e in opers else False


# 将算式处理成列表，解决横杠是负数还是减号的问题
def formula_format(formula):
   # 去掉算式中的空格
   formula = re.sub(\' \', \'\', formula)
   # 以 \'横杠数字\' 分割， 其中正则表达式：(\\-\\d+\\.?\\d*) 括号内：
   # \\- 表示匹配横杠开头； \\d+ 表示匹配数字1次或多次；\\.?表示匹配小数点0次或1次;\\d*表示匹配数字1次或多次。
   formula_list = [i for i in re.split(\'(\\-\\d+\\.?\\d*)\', formula) if i]

   # 最终的算式列表
   final_formula = []
   for item in formula_list:
       # 第一个是以横杠开头的数字（包括小数）final_formula。即第一个是负数，横杠就不是减号
       if len(final_formula) == 0 and re.search(\'^\\-\\d+\\.?\\d*$\', item):
           final_formula.append(item)
           continue

       if len(final_formula) > 0:
           # 如果final_formal最后一个元素是运算符[\'+\', \'-\', \'*\', \'/\', \'(\'], 则横杠数字不是负数
           if re.search(\'[\\+\\-\\*\\/\\(]$\', final_formula[-1]):
               final_formula.append(item)
               continue
       # 按照运算符分割开
       item_split = [i for i in re.split(\'([\\+\\-\\*\\/\\(\\)])\', item) if i]
       final_formula += item_split
   return final_formula


def decision(tail_op, now_op):
   \'\'\'
   :param tail_op: 运算符栈的最后一个运算符
   :param now_op: 从算式列表取出的当前运算符
   :return: 1 代表弹栈运算，0 代表弹运算符栈最后一个元素， -1 表示入栈
   \'\'\'
   # 定义4种运算符级别
   rate1 = [\'+\', \'-\']
   rate2 = [\'*\', \'/\']
   rate3 = [\'(\']
   rate4 = [\')\']

   if tail_op in rate1:
       if now_op in rate2 or now_op in rate3:
           # 说明连续两个运算优先级不一样，需要入栈
           return -1
       else:
           return 1

   elif tail_op in rate2:
       if now_op in rate3:
           return -1
       else:
           return 1

   elif tail_op in rate3:
       if now_op in rate4:
           return 0   # ( 遇上 ) 需要弹出 (，丢掉 )
       else:
           return -1  # 只要栈顶元素为(，当前元素不是)都应入栈。
   else:
       return -1


def final_calc(formula_list):
   num_stack = []       # 数字栈
   op_stack = []        # 运算符栈
   for e in formula_list:
       operator = is_operator(e)
       if not operator:
           # 压入数字栈
           # 字符串转换为符点数
           num_stack.append(float(e))
       else:
           # 如果是运算符
           while True:
               # 如果运算符栈等于0无条件入栈
               if len(op_stack) == 0:
                   op_stack.append(e)
                   break

               # decision 函数做决策
               tag = decision(op_stack[-1], e)
               if tag == -1:
                   # 如果是-1压入运算符栈进入下一次循环
                   op_stack.append(e)
                   break
               elif tag == 0:
                   # 如果是0弹出运算符栈内最后一个(, 丢掉当前)，进入下一次循环
                   op_stack.pop()
                   break
               elif tag == 1:
                   # 如果是1弹出运算符栈内最后两个元素，弹出数字栈最后两位元素。
                   op = op_stack.pop()
                   num2 = num_stack.pop()
                   num1 = num_stack.pop()
                   # 执行计算
                   # 计算之后压入数字栈
                   num_stack.append(calculate(num1, num2, op))
   # 处理大循环结束后 数字栈和运算符栈中可能还有元素 的情况
   while len(op_stack) != 0:
       op = op_stack.pop()
       num2 = num_stack.pop()
       num1 = num_stack.pop()
       num_stack.append(calculate(num1, num2, op))

   return num_stack, op_stack

测试结果截图

3. 实验过程中遇到的问题和解决过程

• 正则表达式 re的学习
• 对于运算符的判断
• 出入栈

其他（感悟、思考等）

本次实验主要是计算器的制作，在编写过程中我收获了许多，加深了自己对python语言的理解程序设计是一个严谨的学科，要求我们认真对待每一行代码，每一个概念。在编写的过程中，注意清晰的思路，明确自己的目的，自己在做什么。我会继续努力，不断学习，保持进步