文章目录
-
- Python基础语法
- python程序设计内容指导
- python练习题
-
- 1. 编写程序，生成包含1000个0～100的随机整数，并统计每个元素的出现次数。
- 2. 编写程序，用户输入一个列表和2个整数作为下标，然后输出列表中介于2个下表闭区间之间的元素组成的子列表。例如用户输入[1,2,3,4,5,6]和2,5，程序输出[3,4,5,6]。
- 3. 设计一个字典，并编写程序，用户输入内容作为“键”，然后输出字典中对应的“值”，如果用户输入的“键”不存在，则输出“您输入的键不存在！”。
- 4.编写程序，生成包含20个随机数的列表，然后将前10个元素升序排列，后10个元素降序排列，并输出结果。
- 5. 尼姆游戏
- 6. 猜数字游戏
- 7. 有一段英文文本，其中有单词连续重复了2次，编写程序检查重复的单词，并只保留一个。
- 8. 编写程序,用户输入一段英文,然后输出这段英文所有长度为3个字母的单词。
- 9. 打字练习评定
- 10.
Python基础语法
python程序设计内容指导
chapter2 Python运算符，内置函数，序列数基本用法
# 1
num = input('请输入一个自然数：')
print(sum(map(int, num)))
# 2
setA = eval(input('请输入一个集合：'))
setB = eval(input('再输入一个集合：'))
print('交集: ',setA & setB )
print('并集: ',setA | setB )
print('setA - setB', setA - setB)
# 3
num = int(input('请输入一个自然数：'))
print('2进制：', bin(num))
print('8进制：', oct(num))
print('16进制：', hex(num))
# 4
lst = input('请输入一个包含若干整数的列表：')
lst = eval(lst)
print(list(filter(lambda x: x%2 == 0, lst)))
# 5
lstA = eval(input('请输入若干整数的列表lstA: '))
lstB = eval(input('请输入若干整数的列表lstB: '))
result = dict(zip(lstA, lstB))
print(result)
# 6
lst = eval(input('请输入包含若干整数的列表lst: '))
print(sorted(lst, reverse = True))
# 7
from functools import reduce
lst = eval(input('请输入包含若干集合的列表lst：'))
print(reduce(lambda x,y : x * y, lst))
# 8
lstA = eval(input('请输入包含2个整数的列表lstA：'))
lstB = eval(input('请输入包含2个整数的列表lstB：'))
print(sum(map(lambda i, j : abs(i-j), lstA, lstB)))
# 9
from functools import reduce
lstSets = eval(input('请输入包含若干集合的列表：'))
print(reduce(lambda x,y : x | y, lstSets))
# 10
al = int(input('请输入等比数列首项：'))
q = int(input('请输入等比数列公比（不等于1且小于36的正整数）：'))
n = int(input('请输入一个自然数：'))
result = al * int('1' * n, q)
print(result)
# 11
data = input('请输入一个字符串：')
d = dict()
for ch in data :
d[ch] = d.get(ch, 0) + 1
mostCommon = max(d.items(), key = lambda items: items[1])
print(mostCommon)
chapter3 使用蒙特·卡罗方法计算圆周率的近似值
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)
chapter4 使用列表实现筛选法求素数
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的自然数：'))
lst = list(range(2, maxNumber))
# 最大整数的平方根
m = int(maxNumber ** 0.5)
for index, value in enumerate(lst):
if value > m:
break
for value1 in lst[:index:-1]:
print(value1)
if value1%value == 0:
lst.remove(value1)
print(lst)
chapter6 使用filter()函数统计列表中所有非素数
from random import randint
def isPrime(n):
if n in (2,3):
return True
if n%2 == 0:
return False
for i in range(3, int(n**0.5)+1 , 2):
if n%i == 0:
return False
return True
lst = [randint(1,100) for _ in range(50)]
print(lst)
print(list(filter(lambda n:isPrime is False, lst)))
chapter7 理解浮点数运算的误差
def cni(n, i):
minNI = min(i, n-i)
result = 1
for j in range(1, minNI):
result = result * (n-j)/(minNI-j)
return result
def cni(n,i): # 修改后
minNI=min(i,n-i)
result = 1
for j in range(1, minNI+1):
result = (result * (n -minNI+j)) /j
return result
print(cni(8, 5))
chapter12 模拟报数游戏（约瑟夫环问题）
from itertools import cycle
def demo(lst, k):
t_lst = lst[:]
while len(t_lst) > 1:
print(t_lst)
c = cycle(t_lst)
for i in range(k):
t = next(c)
index = t_lst.index(t)
t_lst = t_lst[index + 1:] + t_lst[:index]
return t_lst[0]
lst = list(range(1, 11))
print(demo(lst, 3))
chapter13
from random import randrange
def playGame():
value = randrange(360)
for k, v in areas.items():
if v[0] <= value < v[1]:
return k
areas = {
'一等奖': (0, 30),
'二等奖': (30, 108),
'三等奖': (108, 360)}
# 记录每一个奖项的中奖次数
result = dict()
for i in range(1000):
r = playGame()
result[r] = result.get(r, 0) + 1
for item in result.items():
print('{0[0]}:{0[1]}次'.format(item))
python练习题
1. 编写程序，生成包含1000个0～100的随机整数，并统计每个元素的出现次数。
import random
from collections import Counter
i = 0 # 定义计数器
num_list = []
while i <= 1000: # 循环结束条件
num = random.randint(0, 100)
num_list.append(num)
# print(num)
i += 1 # 计数器自增
num_list.sort()
res = Counter(num_list)
for key in res:
print(key, end = ":")
print(res[key], "次")
2. 编写程序，用户输入一个列表和2个整数作为下标，然后输出列表中介于2个下表闭区间之间的元素组成的子列表。例如用户输入[1,2,3,4,5,6]和2,5，程序输出[3,4,5,6]。
list = eval(input("请输入一个列表："))
a = eval(input("请输入第一个下标："))
b = eval(input("请输入第二个小标："))
if a>b:
for i in range(b,a):
print(list[b:a])
break
elif a<b:
for i in range(a,b):
print(list[a:b])
break
elif a==b:
print([])
3. 设计一个字典，并编写程序，用户输入内容作为“键”，然后输出字典中对应的“值”，如果用户输入的“键”不存在，则输出“您输入的键不存在！”。
# 设计一个字典，并编写程序，用户输入内容作为“键”，然后输出字典中对应的“值”，
# 如果用户输入的“键”不存在，则输出“您输入的键不存在！”。
dic = {
'sever' : 'your sever', 'database' : 'sql'}
inp = input()
print(dic.get(inp, "The key you entered does not exist!"))
4.编写程序，生成包含20个随机数的列表，然后将前10个元素升序排列，后10个元素降序排列，并输出结果。
# 编写程序，生成包含20个随机数的列表，然后将前10个元素升序排列，后10个元素降序排列，并输出结果。
import random
listA = [random.randint(1, 20) for _ in range(20)]
print(listA)
tempA = sorted(listA[:10])
tempB = sorted(listA[:10:-1])
listA = [tempA + tempB]
print(listA)
5. 尼姆游戏
尼姆游戏是个著名的游戏，有很多变种玩法。两个玩家轮流从一堆物品中拿走一部分。从每一步中，玩家可以自由选择拿走多少物品，但是必须至少拿走一个并且最多只能拿走一半物品，然后轮到下一个玩家。拿走最后一个物品的玩家输掉游戏。
在聪明模式中，计算机每次拿走一定数量的物品使得堆的大小是2的幂次方减1，也就是3，4，15，31，63等。如果无法做到这一点，计算机就随机拿走一些。
编写程序，模拟聪明版本的尼姆游戏
from math import log2
from random import randint, choice
def everyStep(n):
half = n / 2
m = 1
# 所有可能满足条件的取法
possible = []
while True:
rest = 2 ** m - 1
if rest >= n:
break
if rest >= half:
possible.append(n - rest)
m = m + 1
# 如果至少存在一种取法使得剩余物品数量为2^n-1
if possible:
return choice(possible)
# 无法使得剩余物品数量为2^n-1，随机取走一些
return randint(1, int(half))
def smartNimuGame(n):
while n > 1:
# 人类玩家先走
print("It is your turn, and we have {0} left.".format(n))
# 确保人类玩家输入合法的整数值
while True:
try:
num = int(input('How many do you want to take:'))
assert 1 <= num <= n//2
break
except:
print('Must be between 1 and {0}'.format(n // 2))
n -= num
if n == 1:
return 'I fail'
# 计算机玩家拿走一些
n -= everyStep(n)
else:
return 'You fail.'
print(smartNimuGame(randint(1,100)))
6. 猜数字游戏
编写程序模拟猜数字游戏。程序运行时，系统在制定范围内生成一个随机数，然后提示用户进行猜测，并更加用户输入进行必要的提示（才对了，太大了，太小了），如果猜对则提前结束程序，如果次数用完仍没有才对，提示游戏结束并给出正确答案。
import random
''' 编写程序模拟猜数字游戏。
程序运行时，系统在制定范围内生成一个随机数，然后提示用户进行猜测，
并更加用户输入进行必要的提示（才对了，太大了，太小了），
如果猜对则提前结束程序，如果次数用完仍没有才对，提示游戏结束并给出正确答案。'''
a = random.randint(1, 10)
count = 3
while count:
num = input("请输入一个1-10的整数(你有" + str(count) + "次机会)：")
num = int(num)
count = count - 1
if count == 0:
print("你没有机会了。中奖数为" + str(a))
break
if num > a:
print("你输入的数太大了！")
elif num < a:
print("你输入的数太小了！")
else:
print("恭喜你答对了！")
break
7. 有一段英文文本，其中有单词连续重复了2次，编写程序检查重复的单词，并只保留一个。
例如，文本内容是“This is is a banana.”，输出为"This is a banana."。
import re
x = 'This is is a banana.'
pattern = re.compile(r'\b(\w+)(\s+\1){1,}\b')
matchResult = pattern.search(x)
x = pattern.sub(matchResult.group(1), x)
print(x)
8. 编写程序,用户输入一段英文,然后输出这段英文所有长度为3个字母的单词。
import re
sr=input('请输入一段英文：')
print(re.findall(r'\b[a-zA-Z]{3}\b',sr))
9. 打字练习评定
编写程序，模拟打字练习程序的成绩评定，假设origin为原始内容，userlnput为用户练习时输入的内容，要求用户输入的内容长度不能大于原始内容的长度。如果对应位置的字符一致则认为正确，否则判定输入错误。最后成绩为:正确的字符数量/原始字符串长度，按百分制输出，要求保留2位小数。
def rate(origin, userInput):
if not (isinstance(origin,str)
and isinstance(userInput, str)):
return 'The two parameters must be strings.'
if len(origin) < len(userInput):
return 'Sorry. I suppose the second string is shorter.'
right = sum(1
for oc, uc in zip(origin, userInput)
if oc == uc)
return right/len(origin)
origin = '''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.'''
userInput = '''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.'''
print(round(rate(origin, userInput)*100, 2), '%', sep='')
10.