《Python程序设计》上机作业

Author : StarsAC

Date : May 18th, 2024

python程序设计 课程思政考核标准_开发语言

test 1-1

  1. 编写程序，生成包含1000个0到100之间的随机整数，并统计每个元素的出现次数。
import random

x = [random.randint(0, 100) for i in range(1000)]

y = set(x)

for i in y:
    print(i, "出现次数", x.count(i))

test 1-2

  1. 编写程序，生成包含20个随机数的列表，然后将前10个元素升序排列，后10个元素降序排列，并输出结果。
import random

x = [random.randint(0, 100) for i in range(20)]
print(x)
first_half = x[:11]
second_half = x[11:]
first_half.sort()
second_half.sort(reverse=True)
sorted_list = first_half + second_half
print(sorted_list)

test1-3

  1. 编写程序，运行后用户输入4位整数作为年份，判断其是否为闰年。如果年份能被400整除，则为闰年；如果年份能被4整除但不能被100整除也为闰年。
year = int(input("请输入年份:"))

if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
    print(year, "是闰年")
else:
    print(year, "不是闰年")

test 1-4

  1. 编写程序，实现分段函数计算。
x y
-------------------------------------
x < 0 ,0
0 <= x < 5 ,x
5 <= x < 10 ,3x - 5
10 <= x < 20 ,0.5x - 2
20 <= x ,0
x = int(input("Please input x:"))
if x < 0:
    print(0)
elif 0 <= x <= 5:
    print(x)
elif 5 <= x <= 10:
    print(3 * x - 5)
elif 10 <= x <= 20:
    print(0.5 * x - 2)
elif 20 <= x:
    print(0)

test 1-5

  1. 编写程序，用户在命令提示行输入文件名和该文件的编码格式，读入文件，将其转存成UTF-8格式。如果用户没有指定输入文件的编码格式，则使用chardet模块“猜”出其编码格式，用于解码。使用argparse模块解析用户命令提示行输入。
import argparse
import chardet
import codecs

# 创建ArgumentParser对象
parser = argparse.ArgumentParser(description='Convert file to UTF-8 encoding')
parser.add_argument('filename', help='Input file name')
parser.add_argument('--encoding', help='Input file encoding (optional)')

# 解析命令行参数
args = parser.parse_args()

# 获取文件名和编码格式
filename = args.filename
file_encoding = args.encoding

# 如果没有指定编码格式，则使用chardet来猜测
if not file_encoding:
    with open(filename, 'rb') as f:
        data = f.read()
        result = chardet.detect(data)
        file_encoding = result['encoding']

# 读取文件并转存成UTF-8格式
with codecs.open(filename, 'r', encoding=file_encoding) as f:
    content = f.read()

with codecs.open(filename + '_utf8', 'w', encoding='utf-8') as f:
    f.write(content)

print(f"文件 {filename} 已成功转存成UTF-8格式为 {filename}_utf8")

test 2-1

  1. 编写函数，接收一个字符串，分别统计大写字母、小写字母、数字、其他字符的个数，并以元组的形式返回结果。
def find_max_and_sum(*args):
    max_value = max(args)
    sum_value = sum(args)

    print("The maximum is", max_value, "and the sum is", sum_value)
    return 0

# find_max_and_sum(1,2,3,4,5,)

test 2-2

  1. 编写函数，可以接收任意多个整数并输出其中的最大值和所有整数之和。
def find_max_and_sum(*args):
   max_value = max(args)
   sum_value = sum(args)

   print("The maximum is", max_value, "and the sum is", sum_value)
   return 0

# find_max_and_sum(1,2,3,4,5,)

test 2-3

  1. 编写函数，模拟内置函数sorted()。（你需要先读内置函数 sorted() 的关方文档，搞清楚它的输入参数和输出）
def my_sorted(iterable, key=None, reverse=False):
    raw_list = list(iterable)

    for i in range(len(raw_list)):
        for j in range(len(raw_list) - i - 1):
            if key:
                key1 = key(raw_list[j])
                key2 = key(raw_list[j + 1])
            else:
                key1 = raw_list[j]
                key2 = raw_list[j + 1]
            if key1 > key2:
                raw_list[j], raw_list[j + 1] = raw_list[j + 1], raw_list[j]
    return raw_list

# print(my_sorted([1,2,4,3,5,6,8,7]))

test 2-4

  1. 以字典为基础建立一个通讯录，向字典中添加和删除通讯人（名字、电话、email、工作单位等），查询某个人的信息，然后输出通讯录中所有人的信息。
address_list = {}


def add_address(name, phone, email, company):
    if name not in address_list:
        address_list[name] = {}
    address_list[name].update({
        'phone': phone,
        'email': email,
        'company': company,
    })


def delete_address(name):
    if name in address_list:
        del address_list[name]


def display_address(name):
    if name in address_list:
        print(address_list[name]['phone'], address_list[name]['email'], address_list[name]['company'])
    else:
        print('Not found')


add_address('Alice', '12345678', 'alice@example.com', 'ABC Company')
add_address('John', '88888888', 'john_home@example.com', 'Home')
add_address('Bob', '87654321', 'bob@example.com', 'XYZ Company')

display_address('Alice')
print(address_list)

test 2-5

  1. 用生成器的方式计算任意起止范围内质数的和。质数又称素数，是大于1的自然数，除了1和它本身外，不能被其他自然数整除。
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True


def sum_prime(start, end):
    sum1 = sum(n for n in range(start, end+1) if is_prime(n))  # 生成器表达式
    return sum1


sum_1 = sum_prime(1, 10000)
print(sum_1)

test 3-1

编写代码，实现一个栈（Stack）类。栈是只能在一端插入和删除数据的序列，它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据，最后一个数据被第一个读出来 （学习pickle模块，并在编写程序中使用该模块）

import pickle


class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.is_empty():
            return self.items.pop()

    def is_empty(self):
        if len(self.items) == 0:
            return True
        return False

    def clear(self):
        self.items = []

    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        else:
            return None


stack = Stack()
stack.push(1)
stack.push(2)
print(stack.peek())
print(stack.pop())
stack.clear()
print(stack.peek())


# 保存栈
with open('stack.pickle', 'wb') as file:
    pickle.dump(stack, file)

# 加载栈
with open('stack.pickle', 'rb') as file:
    loaded_stack = pickle.load(file)

test3-2

  1. 编写代码，实现一个队列（Queue）类。并完成入栈、出栈的操作。
class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        if not self.is_empty():
            return self.items.pop(0)
        else:
            print("Queue is empty")
            return None

    def is_empty(self):
        return len(self.items) == 0

    def clear(self):
        self.items = []

    def peek(self):
        if not self.is_empty():
            return self.items[0], self.items[-1]
        else:
            print("Queue is empty")
            return None


queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue.dequeue())
print(queue.peek())
print(type(queue.peek()))  #tuple

test 4-1

  1. 编写代码，定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；包含一个可以计算圆柱体面积、体积的方法。然后编写相关程序测试相关功能。
import math


class Cylinder:
    def __init__(self, radius, height):
        self.radius = radius
        self.height = height

    def area(self):
        return 2 * ((self.radius**2) * math.pi) + 2 * math.pi * self.radius * self.height

    def volume(self):
        return math.pi * (self.radius**2) * self.height


cylinder = Cylinder(2, 4)
print(cylinder.area())
print(cylinder.volume())

test 4-2

  1. 在Python 3中定义一个基类Details，它有一个私有对象属性name；方法setDetails，用于输入name的值；方法showDetails用于输出name。从基类派生出一个子类：Employee。Employee有私有对象属性company；方法setEmployee，用于输入公司名字；方法setEmployee，用于输出公司名字。【完成对name和company的输入，并显示出他们的值。】
class Details:
    def __init__(self):
        self.__name = None

    def setDetails(self, name):
        self.__name = name

    def showDetails(self):
        return self.__name


class Employee(Details):
    def __init__(self):
        super().__init__()
        self.__company_name = None

    def setEmployee(self, company_name):
        self.__company_name = company_name

    def showEmployee(self):
        return self.__company_name


emp1 = Employee()
emp1.setDetails("John")
emp1.setEmployee("ABC Crop.")
print(emp1.showDetails())
print(emp1.showEmployee())