python 实验

二实验环境及实验准备

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

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

l 掌握Python的输入输出；

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

三实验内容

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

【实验截图】

<你的安装练习过程截图>

1、打开 Python 官方网站 http://www.python.org。

2、下载 Python 3.5.x 或 Python 3.6.x

3、在开始菜单中找到成功安装的 IDLE，输入下面的代码，确保 IDLE 运行正常

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

【实验截图】

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

【实验截图】

1、在资源管理器中进入 Python 安装目录的 scripts 子目录，然后按下 Shift 键，在空白处单击鼠标右键，在弹出来的菜单中选择“在此处打开命令窗口”进入命令提示符环境。如图所示：

2、使用 pip 命令在线安装 Python 扩展库 numpy、pandas、scipy、matplotlib、jieba、 openpyxl、pillow。安装 openpyxl 的命令如图所示：

3、如果遇到安装不成功的扩展库，使用浏览器打开下面的网址下载 whl 文件进行离线安装：https://www.lfd.uci.edu/~gohlke/pythonlibs/

4、在 IDLE 中使用 import 导入安装好的扩展库，验证是否安装成功

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

【题目描述】

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

【源代码程序】

import itertools

# 输入整数n和m

n = int(input("请输入整数n（1<=n<=26）："))

m = int(input("请输入整数m（m<=n）："))

# 输入n个不同的字母,存入列表中

print("请输入%s个不同的字母（中间用空格隔开）" % n)

letters = input().split()

if len(letters) != n:

print("输入的字母个数与n不符")

exit()

# 输出所有排列序列

perms = itertools.permutations(letters, m)

print("所有排列序列：")

for perm in perms:

# join方法将序列中的元素连接成字符串，方便输出

print(''.join(perm))

# 输出所有组合序列

combs = itertools.combinations(letters, m)

print("所有组合序列：")

for comb in combs:

print(''.join(comb)) >

【运行测试】

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

【题目描述】

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

【源代码程序】

import math

import random

# 输入扔飞镖的次数n

n = int(input("输入扔飞镖的次数n:"))

count = 0

# 循环n次，每次生成两个范围为（-1，1）的小数并赋值给x，y

for i in range(n):

x = random.uniform(-1, 1)

y = random.uniform(-1, 1)

# 求x,y的平方和的平方根

c = math.sqrt(x ** 2 + y ** 2)

# 如果c小于等于1，说明（x，y）落在单位圆里，次数加1

if c <= 1:

count += 1

print("落在单位圆内的次数为%s" % count)

# 落在单位圆内的次数除以总次数再乘以4，这个数字会无限逼近圆周率的值

pi = (count / n) * 4

print("圆周率近似为%s" % pi)【运行测试】

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

【题目描述】

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

【源代码程序】

def kaprekar(num):

# 将数字转换为4位字符串

num_str = str(num)

# 判断4位数字是否有重复

if len(num_str) != len(set(num_str)):

print("输入有误，请输入4位各不相同数字")

return 0

count = 0

# 循环

while num != 6174:

# 分别将数字从大到小和从小到大排序

num1 = int(''.join(sorted(num_str, reverse=True)))

num2 = int(''.join(sorted(num_str)))

# 两数相减

num = num1 - num2

# 操作次数加一

count += 1

# 输出每次操作的过程

print("第%s次 max=%s min=%s max-min=%s" % (count, num1, num2, num))

# 将得到的数字再转换为4位字符串

num_str = str(num)

return count

# 输入

num = input("请输入4位各不相同的数字：")

# 输出结果

print("总次数:%s" % kaprekar(num))【运行测试】

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

【题目描述】

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

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

【源代码程序】

queue = []

count = 0

piece = int(input())

process = input()

page = process.split(" ")

for i in page[::]:

if i == '':

page.remove(i)

for i in range(0, len(page)):

queue.append(page[i])

if i == len(page) - 1:

break

if len(queue) == piece:

j = 0

while j in range(0, piece):

if page[i + 1] == queue[j]:

queue.append(queue[j]) # 如果后一个页面与这三个页面中的相同，那么就将这个页面提前

queue.pop(j) # 删除到原来所处的位置

page.pop(i + 1) # 删除，进入下一个页面

j = 0

else:

j += 1

queue.pop(0) # 淘汰页面

count += 1

print(count)

【运行测试】

（八）、【Python0006】爬楼梯

【题目描述】

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

【源代码程序】

def climbStairs(n):

foot3 = {1: 1, 2: 2, 3: 4} # 前三阶的三种情况

if n in foot3.keys():

return foot3[n]

else:

return climbStairs(n - 1) + climbStairs(n - 2) + climbStairs(n - 3) # 下一阶的方法数为前三阶的和

n = int(input())

print(climbStairs(n))【运行测试】

<你的程序运行测试截图>

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

【题目描述】

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

【源代码程序】

n = int(input("请输入要打印的杨辉三角的行数: "))

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

triangle = [[1]]

# 循环生成杨辉三角

for i in range(1, n):

# 初始化当前行的第一个元素为1

row = [1]

# 循环生成当前行的中间元素

for j in range(1, i):

# 当前元素等于上一行中前一个元素和同一位置元素的和

element = triangle[i - 1][j - 1] + triangle[i - 1][j]

# 将当前元素加入当前行

row.append(element)

# 将当前行的最后一个元素设为1

row.append(1)

# 将当前行加入杨辉三角

triangle.append(row)

# 循环输出杨辉三角

for i in range(n):

# 计算当前行前面需要填充的空格数量

spaces = ' ' * (n - i)

# 用join函数将当前行中的数字转为字符串，并用空格连接

# 然后再在前面添加空格，输出当前行

print(spaces + ' '.join(map(str, triangle[i])))【运行测试】

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

【题目描述】

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

【源代码程序】

def sieve(n, m):

"""

输入两个正整数n和m，返回[n,m]范围内的所有素数的列表

"""

# 初始化一个长度为m-n+1的列表，用于标记数值是否为素数

is_prime = [True] * (m - n + 1)

# 如果n为1，则将1标记为合数

if n == 1:

is_prime[0] = False

# 从2开始，将所有能被2整除的数标记为合数

for i in range(2, int(m ** 0.5) + 1):

for j in range(max(i ** 2, (n + i - 1) // i * i), m + 1, i):

if j >= n and is_prime[j - n]:

is_prime[j - n] = False

# 将所有未被标记为合数的数加入素数列表

primes = [i + n for i in range(m - n + 1) if is_prime[i]]

return primes

# 输入n和m

n, m = map(int, input("请输入n和m(1 < n < m < 1000):").split())

if not 1 < n < m < 1000:

print("输入有误，请重新输入")

n, m = map(int, input("请输入n和m(1 < n < m < 1000):").split())

else:

print("该范围内的所有素数为：", end='')

print(sieve(n, m))【运行测试】

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

【题目描述】

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

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

【源代码程序】

matrix = []

matrix2 = []

matrix3 = []

for i in range(5):

a = input()

a1 = a.split(" ") # a1中的元素都是字符串，需要转换

for i in a1[::]:

if i == '':

a1.remove(i) # 去掉空元素

a1 = [int(x) for x in a1] # 将其中的元素转为int类型，方便排序

matrix.append(a1) # 插入到一个新列表

for i in range(0, 5):

matrix2 = []

for j in range(0, 5):

matrix2.append(matrix[j][i])

matrix3.append(matrix2) # 将每一列收集起来组合成新的列表

for i in range(0, 5):

for j in range(0, 5):

if matrix[i][j] == max(matrix[i]): # 判断是否为该行最大值

if matrix[i][j] == min(matrix3[j]): # 判断是否为该列最小值

print([i + 1, j + 1, matrix[i][j]], end="")

# 11 3 5 6 9

# 12 4 7 8 10

# 10 5 6 9 11

# 8 6 4 7 8

# 15 10 11 20 25【运行测试】

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

【题目描述】

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

【源代码程序】

num = int(input())

newnum = num

text = ""

counter = 2

while counter * counter <= newnum:

if newnum % counter == 0: # 判断是否能够整除2

text = text + str(counter) # 将质因子组合起来

newnum = int(newnum / counter)

else:

counter += 1

if newnum != 1: # 如果结果不为1，就加上目前的newnum质因子

text = text + str(newnum)

if text == "" + str(newnum): # 判断质因子就是其本身

text = str(newnum)

print(str(num) + "=" + text)

【运行测试】

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

【题目描述】

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

【源代码程序】

num = input()

n1 = num.split(" ")

n = []

for i in n1[::]:

if i == '':

n1.remove(i)

for i in n1:

n.append(float(i))

def f(x):

return n[0] * pow(x, 3) + n[1] * pow(x, 2) + n[2] * pow(x, 1) + n[3]

def fd(x):

return 3 * n[0] * pow(x, 2) + 2 * n[1] * pow(x, 1) + n[2]

def newtonMethod(assum):

x = assum

a = f(x)

b = fd(x)

if f(x) == 0.0:

print(round(x, 2))

return x

else:

next = x - a / b

# print('next x = ' + str(next)) # 输出下一条切线的值

if a - f(next) < 1e-6:

print(round(next, 2)) # 设置跳出条件，同时输出满足f(x) = 0 的x的值

else:

return newtonMethod(next) # 递归

newtonMethod(n[4])【运行测试】

四实验分析及问题思考

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

【答案】1.数据类型

列表、元组、字典、集合、字符串均属于python3的标准数据类型。

字符串和元组属于不可变数据，即创建后不可修改。

列表、字典、集合属于可变数据，即创建后可以修改元素。

2.创建有元素的对象

3.创建没有元素的对象

列表使用eval()或list()或中括号[]进行创建，元素之间使用逗号分隔。若不添加任何元素，则创建空列表。

# 使用[]创建

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

print(type(list_)) # <class 'list'>

# 使用eval()创建,eval()方法用来执行一个字符串表达式,并返回表达式的值

list_ = eval("[1,2,3,4,5]")

print(type(list_)) # <class 'list'>

# 使用list()创建,list()方法用于将元组转换为列表

list_ = list((1, 2, 3, 4, 5))

print(type(list_)) # <class 'list'>

元组使用eval()或tuple()或小括号()进行创建，元素之间使用逗号分隔。若不添加任何元素，则创建空元组。如果元组只有一个元素，则必须在这个元素后面加上逗号。

# 使用()创建

tuple_ = (1, 2, 3, 4, 5)

print(type(tuple_)) # <class 'tuple'>

# 使用eval()创建

tuple_ = eval("(1,2,3,4,5)")

print(type(tuple_)) # <class 'tuple'>

# 使用tuple()创建,tuple()函数用于将列表转换为元组

tuple_ = tuple([1, 2, 3, 4, 5])

print(type(tuple_)) # <class 'tuple'>

字典使用eval()或dict()函数或者大括号{}创建，元素之间用逗号分隔。每个元素必须是一个键(key)值(value)对。若不添加任何元素，则创建空字典。

# 使用{}创建

dict_ = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}