2023.3.22每日总结

一 实验目的

l 使学生熟悉Python环境的安装与配置，熟悉Python解释器的使用。 

l 使学生掌握Python控制语句、函数结构等的基本语法知识和使用。

l 使学生掌握Python的基本数据类型、列表、元组、字典和集合等的基本应用。

二 实验环境及实验准备

l 所需软件环境为Pyhton 3.x等；

l 掌握Python控制语句和函数结构等基本语法知识；

l 掌握Python的输入输出；

l 掌握Python的基本数据类型、列表、元组、字典和集合等；

三 实验内容

（一）、练习安装Python解释器

【实验截图】

 

 

 

 

 

（二）、练习搭建Python+Eclipse+pydev编程环境

【实验截图】

 

 

 

 

（三）、练习安装Python扩展库

【实验截图】

 

（四）、【Python0002】排列组合序列

【题目描述】

用户输入整数n（1<=n<=26）和整数m（m<=n），然后输入n个不同的字母，请编写程序输出在这n个字母中选择m个字母的所有排列序列和组合序列。

【源代码程序】

# 定义一个函数，获取所有的排列序列

def get_permutations(arr, m):

    if m == 0:

        # 如果m为0，则返回空列表

        return [[]]

    permutations = []

    for i in range(len(arr)):

        # 获取剩余元素的所有排列序列

        remaining_elements = arr[:i] + arr[i+1:]

        remaining_permutations = get_permutations(remaining_elements, m - 1)

        # 将当前元素和剩余元素的排列序列组合在一起

        for permutation in remaining_permutations:

            permutations.append([arr[i]] + permutation)

    return permutations

 

# 定义一个函数，获取所有的组合序列

def get_combinations(arr, m):

    if m == 0:

        # 如果m为0，则返回空列表

        return [[]]

    combinations = []

    for i in range(len(arr)):

        # 获取剩余元素的所有组合序列

        remaining_elements = arr[i+1:]

        remaining_combinations = get_combinations(remaining_elements, m - 1)

        # 将当前元素和剩余元素的组合序列组合在一起

        for combination in remaining_combinations:

            combinations.append([arr[i]] + combination)

    return combinations

 

# 获取输入数据

n, m = map(int, input().split())

letters = input().split()

 

# 获取所有的排列序列并输出

print("Permutation:")

permutations = get_permutations(letters, m)

for permutation in permutations:

    print(" ".join(permutation))

 

# 获取所有的组合序列并输出

print("Combination:")

combinations = get_combinations(sorted(letters), m)

for combination in combinations:

    print(" ".join(combination))

 

 

    

 

 

【运行测试】

 

 

（五）、【Python0003】蒙特·卡罗法计算圆周率

【题目描述】

蒙特·卡罗方法是一种通过概率来得到问题近似解的方法，在很多领域都有重要的应用，其中就包括圆周率近似值的计问题。假设有一块边长为2的正方形木板，上面画一个单位圆，然后随意往木板上扔飞镖，落点坐标(x,y)必然在木板上（更多的时候是落在单位圆内），如果扔的次数足够多，那么落在单位圆内的次数除以总次数再乘以4，这个数字会无限逼近圆周率的值。这就是蒙特·卡罗发明的用于计算圆周率近似值的方法。编写程序，模拟蒙特·卡罗计算圆周率近似值的方法，输入掷飞镖次数，然后输出圆周率近似值。

【源代码程序】

# 导入随机数模块

import random

 

# 输入掷飞镖的次数

n = int(input())

 

# 初始化落在圆内的点数为0

count = 0

 

# 循环n次，每次生成两个-1到1之间的随机数，作为飞镖落点的横纵坐标

for i in range(n):

    x, y = random.uniform(-1, 1), random.uniform(-1, 1)

    # 如果点(x,y)在以原点为圆心、半径为1的圆内，则计数器加1

    if x**2 + y**2 <= 1:

        count += 1

 

# 计算圆周率近似值，输出结果

pi = 4 * count / n

print('{:.5f}'.format(pi))

 

 

 

 

【运行测试】

 

 

（六）、【Python0004】验证6174猜想

【题目描述】

1955年，卡普耶卡(D.R.Kaprekar)对4位数字进行了研究，发现一个规律：对任意各位数字不相同的4位数，使用各位数字能组成的最大数减去能组成的最小数，对得到的差重复这个操作，最终会得到6174这个数字，并且这个操作最多不会超过7次。请编写程序验证这个猜想。

【源代码程序】

# 输入一个任意各位数字不相同的4位数

num = input()

 

# 循环操作，最多重复7次

for i in range(7):

    # 将数字转换为字符串，并在前面补0，保证其长度为4

    num_str = str(num).zfill(4)

 

    # 对数字升序排列和降序排列，并计算它们之间的差

    asc_num = int("".join(sorted(num_str)))

    desc_num = int("".join(sorted(num_str, reverse=True)))

    diff = desc_num - asc_num

 

    # 输出结果，数据间以空格为间隔

    print(diff, end=" ")

 

    # 如果差为6174，则结束循环

    if diff == 6174:

        break

    

    # 否则，将差作为下一轮的数字

    num = diff

 

 

 

【运行测试】

 

（七）、【Python0005】模拟页面调度LRU算法

【题目描述】

所谓LRU算法，是指在发生缺页并且没有空闲主存块时，把最近最少使用的页面换出主存块，腾出地方来调入新页面。

问题描述：一进程获得n个主存块的使用权，对于给定的进程访问页面次序，问当采用LRU算法时，输出发生的缺页次数。

【源代码程序】

# 输入进程获得使用权的主存块数量n

n = int(input())

 

# 输入进程访问页面的次序，将其转换为列表形式

page_list = input().split()

 

# 初始化主存块和缺页计数器

cache = []

miss_count = 0

 

# 遍历页面访问列表

for page in page_list:

    # 如果该页面已经在主存块中，则将其从主存块中删除，并添加到末尾

    if page in cache:

        cache.remove(page)

    cache.append(page)

 

    # 如果主存块已满，则删除最近最少使用的页面，并将缺页计数器加1

    if len(cache) > n:

        cache.pop(0)

        miss_count += 1

 

# 输出缺页次数

print(miss_count)

 

 

 

 

 

【运行测试】

 

（八）、【Python0006】爬楼梯

【题目描述】

 假设一段楼梯共n(n>1)个台阶，小朋友一步最多能上3个台阶，那么小朋友上这段楼梯一共有多少种方法。

【源代码程序】

def ways_to_climb_stairs(n):

    """

    计算小朋友登上n个台阶的楼梯时可行的方法总数。

    """

    if n == 1:

        # 当只有一个台阶时，只有一种上法，即一步上去。

        return 1

    elif n == 2:

        # 当只有两个台阶时，有两种上法：一步一步地上或直接两步上去。

        return 2

    elif n == 3:

        # 当只有三个台阶时，有四种上法：一步一步地上、一步两步地上、两步一步地上或直接三步上去。

        return 4

    else:

        # 对于其他情况，假设最后一步只可能是一步、两步或三步，分别计算这三种情况下的方案数之和。

        return ways_to_climb_stairs(n - 1) + ways_to_climb_stairs(n - 2) + ways_to_climb_stairs(n - 3)

 

# 读取输入

n = int(input())

 

# 输出结果

print(ways_to_climb_stairs(n))

 

 

 

【运行测试】

 

（九）、【Python0007】杨辉三角形

【题目描述】

输出n（0<n）行杨辉三角形，n由用户输入。

【源代码程序】

# 读取输入

n = int(input())

 

# 初始化杨辉三角形的第一行

row = [1]

 

# 逐行生成并输出杨辉三角形

for i in range(n):

    # 输出该行的数字，并在每个数字之间添加空格，使其格式化为占5位、右对齐的形式

    for num in row:

        print(f"{num: >5}", end="")

    print()  # 每输出完一行后换行

 

    # 为下一行生成数字

    next_row = [1]  # 左侧的1

    for j in range(len(row) - 1):  # 计算中间的数字

        next_num = row[j] + row[j+1]

        next_row.append(next_num)

    next_row.append(1)  # 右侧的1

 

    # 更新当前行

    row = next_row

 

 

 

 

【运行测试】

 

（十）、【Python0008】筛法求素数

【题目描述】

用户输入整数n和m（1<n<m<1000），应用筛法求[n,m]范围内的所有素数。

【源代码程序】

# 读取输入

n, m = map(int, input().split())

 

# 初始化标记数组，先假定所有数都是素数

is_prime = [True] * (m + 1)

 

# 特殊处理0和1

is_prime[0] = is_prime[1] = False

 

# 筛掉不是素数的数

for i in range(2, int(m ** 0.5) + 1):  # 只需要枚举到根号m即可

    if is_prime[i]:

        for j in range(i * i, m + 1, i):

            is_prime[j] = False

 

# 输出结果

count = 0

for i in range(n, m + 1):

    if is_prime[i]:

        print(f"{i: >5}", end="")

        count += 1

        if count % 5 == 0:  # 每输出5个数字后换行

            print()  

if count % 5 != 0:  # 输出完毕后如果最后一行没有满5个数字，则再输出一个换行符

    print()

 

 

 

【运行测试】

 

（十一）、【Python0009】查找鞍点

【题目描述】

对于给定5X5的整数矩阵，设计算法查找出所有的鞍点的信息（包括鞍点的值和行、列坐标，坐标从1开始）。

提示：鞍点的特点：列上最小，行上最大。

【源代码程序】

# 定义一个函数，用于查找矩阵中所有的鞍点

def find_saddle_points(matrix):

    # 定义一个空列表，用于存储所有的鞍点信息

    saddle_points = []

    # 遍历矩阵的每一行

    for i in range(len(matrix)):

        # 找到该行中最大的数

        max_row_value = max(matrix[i])

        # 找到该最大数所在的列号

        max_row_index = matrix[i].index(max_row_value)

        # 检查这一列是否是该列中的最小值

        column_values = [matrix[j][max_row_index] for j in range(len(matrix))]

        if max_row_value == min(column_values):

            # 如果是，就将该位置的信息加入鞍点列表中

            saddle_points.append([i+1, max_row_index+1, max_row_value])

    # 返回所有的鞍点信息

    return saddle_points

 

# 主函数

if __name__ == '__main__':

    # 读取5X5的整数矩阵

    matrix = []

    for i in range(5):

        row = input().split()

        for j in range(5):

            row[j] = int(row[j])

        matrix.append(row)

 

    # 调用函数查找鞍点

    saddle_points = find_saddle_points(matrix)

 

    # 输出所有鞍点信息

    for point in saddle_points:

        print('[{},{},{}]'.format(point[0], point[1], point[2]), end='')

 

 

 

 

【运行测试】

 

（十二）、【Python0010】正整数的因子展开式

【题目描述】

编写程序，输出一个给定正整数x（x>1）的质因子展开式。

 

【源代码程序】

# 定义一个函数，用于获取给定正整数x的质因子列表

def get_prime_factors(x):

    # 定义一个空列表，用于存储质因子

    prime_factors = []

 

    # 从2开始循环，直至x为1

    factor = 2

    while x > 1:

        # 如果x能被当前的因子整除，则将该因子加入质因子列表，并不断除以该因子

        if x % factor == 0:

            prime_factors.append(factor)

            x //= factor

        else:

            # 如果不能整除，则试探下一个因子

            factor += 1

 

    # 返回质因子列表

    return prime_factors

 

# 主函数

if __name__ == '__main__':

    # 读取输入的正整数x的值

    x = int(input())

 

    # 获取x的质因子列表

    prime_factors = get_prime_factors(x)

 

    # 输出x的质因子展开式

    print('{}='.format(x), end='')

    for factor in prime_factors:

        print('{}'.format(factor), end='')

 

 

 

 

【运行测试】

 

（十三）、【Python0011】牛顿迭代法

【题目描述】

编写程序，使用牛顿迭代法求方程在x附近的一个实根。

【源代码程序】

import math

 

# 定义一个函数，用于计算方程f(x)及其导数f'(x)在给定点x处的值

def fx(a, b, c, d, x):

    f = a*x**3 + b*x**2 + c*x + d

    fp = 3*a*x**2 + 2*b*x + c

    return f, fp

 

# 定义一个函数，用于使用牛顿迭代法求解方程f(x)=0的实根（初始点为x0）

def newton_raphson_method(a, b, c, d, x0):

    # 迭代次数

    n = 0

    # 判断误差是否足够小

    while True:

        n += 1

        # 计算f(x0)和f'(x0)

        f, fp = fx(a, b, c, d, x0)

        # 如果导数为0，则直接退出循环

        if fp == 0:

            break

        # 计算下一个估计点

        x1 = x0 - f/fp

        # 如果估计误差足够小，则返回解

        if abs(x1-x0) < 1e-5:

            return x1

        # 否则，更新估计点并继续迭代

        x0 = x1

 

# 主函数

if __name__ == '__main__':

    # 读取输入的方程系数a、b、c、d和实数x

    a, b, c, d, x = input().split()

    a, b, c, d, x = float(a), float(b), float(c), float(d), float(x)

 

    # 使用牛顿迭代法求解方程的实根

    root = newton_raphson_method(a, b, c, d, x)

 

    # 输出结果，保留小数点后2位

    print('{:.2f}'.format(root))

 

 

 

【运行测试】

 

四 实验分析及问题思考

【Python0012】针对Python中的列表、元组、字典、集合、字符串，请以条目形式从各方面对比它们之间的异同。

【答案】1.列表（List）

列表是 Python 中最常用的数据类型之一。它是有序的，可以包含任何类型的对象，包括数字、字符串、函数等，每个元素都可以通过索引访问。列表是可变的，即可以增加、删除、修改列表中的元素。下面是列表的一些特点和用法：

 

定义方式：使用方括号 [] 定义，元素之间用逗号分隔。可以通过 list() 函数将其他序列或可迭代对象转换为列表。

例子：[1, 2, 3]

访问方式：可以使用索引或切片访问列表中的元素。例如，a[0] 表示访问列表 a 中的第一个元素；a[1:3] 表示访问列表 a 中的第二个到第四个元素（不包括第四个）。

基本操作：可以添加、删除、修改、遍历等。例如，a.append(4) 表示在列表 a 的末尾添加一个元素 4；a.pop() 表示弹出列表 a 的最后一个元素；`a[2] =5 表示将列表 a 中的第三个元素修改为 5；for x in a:` 表示遍历列表 a 中的每个元素并执行相应操作。

 

2.元组（Tuple）

元组是另一种序列型数据类型，与列表类似，但是它是不可变的，即一旦创建就不能再次修改。元组通常用于存储同类型或异类型的有序对象序列，但是顺序不可改变。下面是元组的一些特点和用法：

 

定义方式：使用圆括号 () 定义，元素之间用逗号分隔。可以省略括号，只用逗号分隔。

例子：(1, 'a', True) 或 1, 'a', True

访问方式：可以使用索引或切片访问元组中的元素。与列表相同，元组的索引从零开始。例如，a[0] 表示访问元组 a 中的第一个元素；a[1:3] 表示访问元组 a 中的第二个到第四个元素（不包括第四个）。

基本操作：由于元组是不可变的，因此只能进行遍历等基本操作，无法进行添加、删除、修改等操作。例如，for x in a: 表示遍历元组 a 中的每个元素并执行相应操作。

3.字典（Dictionary）

字典是另一种 Python 内置的数据类型，它是一个无序的键值对集合。字典通常用于存储键值对，其中每个键都是唯一的，并且可以使用键来查找相应的值。下面是字典的一些特点和用法：

 

定义方式：使用花括号 {} 定义，每个键值对之间用冒号 : 分隔，键与值之间用逗号分隔。也可以通过 dict() 函数将其他映射对象转换为字典。

例子：{'name': 'Alice', 'age': 30}

访问方式：可以通过键名访问字典中的值。例如，a['name'] 表示访问字典 a 中键为 'name' 的值。

基本操作：可以进行添加、删除、修改、遍历等基本操作。例如，a['gender'] = 'female' 表示在字典 a 中添加一个键为 'gender'，值为 'female' 的键值对；del a['age'] 表示从字典 a 中删除键为 'age' 的键值对；a['name'] = 'Bob' 表示将字典 a 中键为 'name' 的值修改为 'Bob'；for k, v in a.items(): 表示遍历字典 a 中的每个键值对并执行相应操作。

4.集合（Set）

集合是 Python 中的一种无序、不重复的数据类型，用于存储元素。由于集合中的元素不能重复，因此可以用来进行去重操作或进行集合运算。下面是集合的一些特点和用法：

 

定义方式：使用花括号 {} 定义，每个元素之间用逗号分隔。也可以通过 set() 函数将其他序列或可迭代对象转换为集合。

例子：{1, 2, 3}

访问方式：可以通过元素或集合运算符访问集合中的元素。例如，1 in a 表示判断元素 1 是否在集合 a 中；a | b 表示计算集合 a 和集合 b 的并集。

基本操作：可以进行添加、删除、集合运算、遍历等基本操作。例如，`a

 

 

 

 

 

Pyhton环境与基础训练

班级:信2105-2          学号:20213862         姓名:张正权

实验自评

实验内容	自评结果（在对应格内打ü）
	不熟练	一般	比较熟练	熟练
Pyhton环境安装与配置			ü
Pyhton扩展库的安装			ü
Python基本控制结构的应用			ü
Python序列的基本应用			ü
Python函数的应用			ü

实验体会

 

通过该实验，对所学的知识有了进一步的了解。在实验的过程

中，出现了一些问题，不过最后都得以解决。不过通过这些错误，使

我对这些知识点更加印象深刻。

Python是一门十分有用的学科，通过对其认真学习，能够学习

很多先进的管理思想。

Python是一门综合性的学科，通过对其学习我感觉是对有些科

目的一些回顾和综合，像会计学、管理学等。之所以对Python的操

作会遇到这样或那样的关卡，的问题在于缺乏经验。通过对Python

的学习尤其是上机实验我更发觉了自己的不足之处，动手操作水平比

较弱，虽然理论上头头是道，可真正做到电脑跟前时，头脑反应速度

似乎很慢很慢，即便对里面的相关知识点都有相当的了解，操作起来

感觉也是力不从心，这可能是与自己平时不注意锻炼动手水平有着直

接的联系，另外经验不足也是一个原因。

通过对Python系统的学习，我已经对其管理理念与具体操作流

程有了一定的了解。