使用蒙特-卡罗方法计算圆周率近似值

蒙特-卡罗方法是一种通过概率来得到问题近似解的方法。假设又一块边长为2的正方形木板，上面画一个单位圆，然后随意往木板上扔飞镖，落点坐标(x,y)必然在木板上(更多的是落在单位圆内)，如果扔的次数足够多，那么落在单位圆内的次数除以总次数再乘以4，这个次数会无限接近圆周率的值。

from random import random

times = int(input('请输入掷飞镖次数：'))

hits = 0

for i in range(times):

x = random()

y = random()

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

hits += 1

print(4.0*hits/times)

求素数

1.使用列表实现筛选法

maxNumber = int(input('请输入一个大于2的自然数：'))

lst = list(range(2,maxNumber))

# 最大整数的平方根

m = int(maxNumber**0.5)

for index,value in enumerate(lst):

# 如果当前数字已大于最大整数的平方根，结束判断

if value > m:

break

# 对该位置之后的元素进行过滤

lst[index+1:] = filter(lambda x: x%value != 0,lst[index+1:])

print(lst)

2.使用集合实现筛选法

maxNumber = int(input('请输入一个大于2的自然数：'))

numbers = set(range(2,maxNumber))

# 最大整数的平方根，以及小于该数字的所有素数

m = int(maxNumber**0.5)+1

primesLessThanM = [p for p in range(2,m)

if 0 not in [p%d for d in range(2,int(p**0.5)+1)]]

# 遍历最大整数平方根之内的自然数

for p in primesLessThanM:

for i in range(2,maxNumber//p+1):

# 在集合中删除数字所有的倍数

numbers.discard(i*p)

print(numbers)

小明爬楼梯

假设一段楼梯共15个台阶，小明一步最多能上3个台阶。递推法，递归法。

def climbStairs1(n):

# 递推法

a = 1

b = 2

c = 4

for i in range(n-3):

c,b,a = a+b+c,c,b

return c

def climbStairs2(n):

# 递归法

first3 = {1:1,2:2,3:4}

if n in first3.keys():

return first3[n]

else:

return climbStairs2(n-1) + \

climbStairs2(n-2) + \

climbStairs2(n-3)

print(climbStairs1(15))

print(climbStairs2(15))

蒙蒂霍尔

假设你正参加一个有奖游戏节目，并且有3道门可选：其中一个后面是汽车，另外两个后面是山羊。你选择一个门，比如说1号门，主持人当然知道每个门后面是什么并且打开了一个门，比如说3号门，后面是一只山羊。这时，主持人会问你“你想改选2号门吗？”，然后根据你的选择确定最终要打开的门，并确定你获得山羊(输)或者汽车(赢)。

from random import randrange

def init():

# 返回一个字典，键为3个门号，值为门后的物品

result = {i: 'goat' for i in range(3)}

r = randrange(3)

result[r] = 'car'

return result

def startGame():

# 获取本次游戏中每个门的情况

doors = init()

# 获取玩家选择的门号

while True:

try:

firstDoorNum = int(input('Choose a door to open:'))

assert 0 <=firstDoorNum <= 2

break

except:

print('Door number must be between {} and {}'.format(0,2))

# 主持人查看另外两个门后的物品情况

for door in doors.keys()-{firstDoorNum}:

# 打开其中一个后面为山羊的门

if doors[door] == 'goat':

print('"goat" behind the door', door)

# 获取第三个门号，让玩家纠结

thirdDoor = (doors.keys()-{door,firstDoorNum}).pop()

change = input('Switch to {}?(y/n)'.format(thirdDoor))

finalDoorNum = thirdDoor if change == 'y' else firstDoorNum

if doors[finalDoorNum] == 'goat':

return 'I win!'

else:

return 'You win.'

while True:

print('='*30)

print(startGame())

r = input('Do you want to try once more?(y/n)')

if r == 'n':

break

猜数游戏

程序运行时，系统生成一个随机数，然后提示用户进行猜测，并根据用户输入进行必要的提示(猜对了、太大了、太小了)，如果猜对则提前结束程序，如果次数用完仍没有猜对，提前游戏结束并给出正确答案。

from random import randint

def guessNumber(maxValue=10,maxTimes=3):

# 随机生成一个整数

value = randint(1,maxValue)

for i in range(maxTimes):

prompt = 'Start to GUESS:(1-10)' if i==0 else 'Guess again:'

# 使用异常处理结构，防止输入不是数字的情况

try:

x = int(input(prompt))

except:

print('Must input an integer between 1 and ',maxValue)

else:

if x == value:

# 猜对了

print('Congratulations!')

break

elif x > value:

print('Too big')

else:

print('Too little')

else:

# 次数用完还没猜对，游戏结束，提示正确答案

print('Game ouer.FAIL.')

print('The value is ',value)

guessNumber()

抓狐狸游戏

假设一共有一排5个洞口，小狐狸最开始的时候在其中一个洞口，然后玩家随机打开一个洞口，如果里面有狐狸就抓到了。如果洞口里没有狐狸就第二天再来抓，但是第二天狐狸会在玩家来抓之前跳到隔壁洞口里。

from random import choice,randrange

def catchMe(n=5,maxStep=10):

'''模拟抓小狐狸，一共n个洞口，允许抓maxStep次

如果失败，小狐狸就会跳到隔壁洞口'''

# n个洞口，有狐狸为1，没有狐狸为0

positions = [0] * n

# 狐狸的随机位置

oldPos = randrange(0,n)

positions[oldPos] = 1

# 抓maxStep次

while maxStep >= 0:

maxStep -= 1

# 这个循环保证用户输入的是有效洞口编号

while True:

try:

x = input('今天打算打开哪个洞口(0-{0})：'.format(n-1))

# 如果输入的不是数字，就会跳转到except部分

x = int(x)

# 如果输入的洞口有效，结束这个循环，否则就继续输入

assert 0 <= x < n,'要按套路来啊，再给你一次机会。'

break

except:

# 如果输入的不是数字，就执行这里的代码

print('要按套路来啊，再给你一次机会。')

if positions[x] == 1:

print('成功，我抓到小狐狸啦。')

break

else:

print('今天又没抓到。')

# 如果这次没抓到，狐狸就跳到隔壁洞口

if oldPos == n-1:

newPos = oldPos - 1

elif oldPos == 0:

newPos = oldPos + 1

else:

newPos = oldPos + choice((-1,1))

positions[oldPos],positions[newPos] = 0,1

oldPos = newPos

else:

print('放弃吧，你这样乱试是没有希望的。')

# 启动游戏，开始抓狐狸吧

catchMe()

汉诺塔问题

据说古代有一个梵塔，塔内有三个底座A、B、C，A座上有64个盘子，盘子大小不等，大的在下，小的在上。有一个和尚想把这64个盘子从A座移到C座，但每次只能允许移动一个盘子。在移动盘子的过程中可以利用B座，但任何时候3个座上的盘子都必须始终保持大盘在下、小盘在上额顺序。如果只有一个盘子，则不需要利用B座，直接将盘子从A移动到C即可。

def hannoi(num,src,dst,temp=None):

if num < 1:

return

global times # 声明用来记录移动次数的变量为全局变量

# 递归调用函数本身，先把除最后一个盘子之外的所有盘子移动到临时柱子上

hannoi(num-1,src,temp,dst)

# 移动最后一个盘子

print('The {0} Times move:{1}-->{2}'.format(times,src,dst))

towers[dst].append(towers[src].pop())

for tower in 'ABC': # 输出3根柱子上的盘子

print(tower,':',towers[tower])

times += 1

# 把除最后一个盘子之外的其他盘子从临时柱子上移动到目标柱子上

hannoi(num-1,temp,dst,src)

times = 1 # 用来记录移动次数的变量

n = 3 # 盘子的数量

towers = {'A':list(range(n,0,-1)),

'B':[],

'C':[]

}

# A 表示最初放置盘子的柱子，C是目标柱子，B是临时柱子

hannoi(n,'A','C','B')

凯撒加密

输入一个字符串，然后输入一个整数作为凯撒加密算法的密钥，然后输出该字符串加密后的结果。

import string

def kaisa():

s = input('请输入一个字符串：')

k = int(input('请输入一个整数密钥：'))

lower = string.ascii_lowercase

upper = string.ascii_uppercase

before = string.ascii_letters

after = lower[k:] + lower[:k] + upper[k:] + upper[:k]

table = str.maketrans(before,after)

out = s.translate(table)

print(out)

kaisa()

自定义类模拟三维向量及运算

定义一个三维向量类，并定义相应的特殊方法实现两个该类对象之间的加、减运算(要求支持运算符+、-)，实现该类对象与标量的乘、除运算(要求支持运算符*、/)，以及向量长度的计算(要求使用属性实现)。

class Vector3:

# 构造方法，初始化，定义向量坐标

def __init__(self,x,y,z):

self.__x = x

self.__y = y

self.__z = z

# 与一个向量相加，对应分量相加，返回新向量

def __add__(self, anotherPoint):

x = self.__x + anotherPoint.__x

y = self.__y + anotherPoint.__y

z = self.__z + anotherPoint.__z

return Vector3(x,y,z)

# 减去另一个向量，对应分量相减，返回新向量

def __sub__(self, anotherPoint):

x = self.__x - anotherPoint.__x

y = self.__y - anotherPoint.__y

z = self.__z - anotherPoint.__z

return Vector3(x, y, z)

# 向量与一个数字相乘，各分量乘以同一个数字，返回新向量

def __mul__(self, n):

x, y, z = self.__x*n, self.__y*n, self.__z*n

return Vector3(x,y,z)

# 向量除以一个数字，各分量除以同一个数字，返回新向量

def __truediv__(self, n):

x, y, z = self.__x/n, self.__y/n, self.__z/n

return Vector3(x, y, z)

# 查看向量长度，所有分量平方和的平方根

@property

def length(self):

return (self.__x**2 + self.__y**2 + self.__z**2)

def __str__(self):

return 'Vector3({},{},{})'.format(self.__x,

self.__y,

self.__z)

v1 = Vector3(3, 4, 5)

v2 = Vector3(5, 6, 7)

print(v1+v2)

print(v1-v2)

print(v1*3)

print(v2/2)

print(v1.length)

文本文件操作

编写一个程序demo.py，要求运行该程序后，生成demo_new.py文件，其中内容与demo.py一样，只是在每一行的后面加上行号以#开始，并且所有行的#符号垂直对齐。

filename = 'demo.py'

with open(filename, 'r') as fp:

lines = fp.readlines()

maxLength = len(max(lines, key=len))

lines = [line.rstrip().ljust(maxLength)+'#'+str(index)+'\n'

for index, line in enumerate(lines)]

with open(filename[:-3]+'_new.py', 'w') as fp:

fp.writelines(lines)

磁盘垃圾文件清理器

要求程序运行时，通过命令行参数指定要清理的文件夹，然后删除该文件夹及其子文件夹中所有扩展名为tmp、log、obj、txt以及大小为0的文件。

from os.path import isdir,join,splitext

from os import remove,listdir,chmod,stat

filetypes = ('.tmp','.log','.obj','.txt')

def test2(directory):

if not isdir(directory):

return

for filename in listdir(directory):

temp = join(directory,filename)

if isdir(temp):

test2(temp)

elif splitext(temp)[1] in filetypes or stst(temp).st_size == 0:

chmod (temp,0o777)

remove(temp)

print(temp,'deleted...')

test2(r'D:\test')