寒假中期学习收获
作者：互联网
寒假中期学习收获
- 1. 寒假前三周学习收获
总计学习天数12天，每天平均学习时间为4小时，平均每日代码量约100行。代码总计1000行
学习进度：已学习完Python基础操作 ，正在学习模块操作及其相关内容。
计划完成情况：学习进度（原计划学习完模块操作，现略落后）
代码行数（原计划1500行，现1000行，尚需努力）
学习时间（总计学习时间将近50小时，达标）
习题量（大于20道，达标）
- 2. 读书收获，学英语进展
只阅读了Python课程设计一本书（大约已经过半）
英语学习每天一篇文章
- 3. 学习中遇到的问题或建议
几乎没有什么问题，都问了度娘，哈哈哈哈
给自己的建议就是要劳逸结合，保证学习的效率，尽量不做无用功。
- 4. 学习心得或分享
掌握了python的一些基本操作，深刻体会到了这门语言相比于C语言的简便之处，同时接触到了一种解密算法还有汉诺塔算法，令我印象最深刻，感受到了用计算机解决复杂问题计算问题的强大之处，也体会到了计算机的核心就是数学这一特点。相比于传统学科，我感觉计算机具有更大的魅力。
- 5. 学习笔记
-
print('\n')
print('#################################################################################################')
print('1.格式化输出')
year = 2020
month = 3
day = 12
print('%4d年%02d月%02d日' % (year, month, day)) # 格式化输出不足高位补零
# print结尾默认end="\n"，会自动换行
pi = 3.1415926
print('%06.2f' % pi) # 格式化输出六位实型数据，小数点后保留两位，小数点占一位，整数部份占三位，不足高位补零
n = 50391
print('%.2e' % n) # 格式化输出，科学计数法输出，保留小数点后两位（竟然有四舍五入的机制）
n = 522
print('%4d' % n) # 十进制输出
print('%4o' % n) # 八进制输出
print('%4x' % n) # 十六进制输出
q = 0x522
print(q)
print('\n')
print('#################################################################################################')
print('2.算术运算符')
# 算术运算符
# + - * % 都相同
# **取平方运算
a = 7
b = a ** 2
c = a ** 3
d = a ** 4
print('a=%4d\na**2=%4d\na**3=%4d\na**4=%4d\n' % (a, b, c, d))
a = 2
b = 3
c = 4
print('2**3**4 = ', a ** b ** c)
print('2**81 = ', 2 ** 81) # **是右结合性，从右向左计算
# /与//的区别：//只保留整数部分，/既保留整数部分也保留小数部分(Python的/不同于C的/)
a = 7
b = a / 3
c = a // 3
print('7/3 = ', b)
print('7//3 = ', c)
print('')
# 应用: 利用除法与取余的方法提取身份证号信息
print('身份证号为：371402200103121215')
id = 371402200103121215
year = id // 100000000 % 10000
month = id // 1000000 % 100
day = id // 10000 % 100
sex = id % 100 // 10 # 倒数第二位是奇数为男性，是偶数为女性
if sex % 2 == 1:
print('性别为男性')
else:
print('性别为女性 ')
print('出生日期为：', year, '年', month, '月', day, '日')
print('\n')
print('#################################################################################################')
print('3.按位运算')
# 按位运算（二进制的按位运算）
# &按位与,两个二进制位都为1，结果为1，否则为0
# |按位或,两个二进制位有一个为1，结果为1，否则为0
# ^按位异或，两个二进制位相同，结果为1，否则为0
# ~按位取反，对每个二进制位取反
# <<按位左移，去掉高位，地位补0
# >>按位右移，去掉低位，高位补0
# 按位左移十进制数乘2，按位右移除2（左增右减）
a = 256
b = a << 1
c = a >> 1
d = a >> 2
print('a =', a, '\na<<1 =', b, '\na>>1 =', c, '\na>>2 =', d)
print('\n')
print('#################################################################################################')
print('4.分数型数据 (与C不同）')
from fractions import Fraction # 导入分数模fractions,Fraction(x,y) = x/y
a = Fraction(1, 2)
b = Fraction(1, 3)
print('a =', a, '\tb =', b)
print('a-b =', a - b)
print('a+b =', a + b)
print('a*b =', a * b)
print('a/b =', a / b)
print('')
print('#################################################################################################')
print('5.复数型数据')
# 实部与虚部都是存在的，可以直接运算。虚部用J或者j来表示
a = 2 + 7j
b = 3 - 6j
print('a =', a, '\tb =', b)
print('a+b =', a + b)
print('a-b =', a - b)
print('a*b =', a * b)
print('a/b =', a / b)
print('')
print('#################################################################################################')
print('6.字符串型数据')
# 转义字符
# \续行符 \\反斜杠号 \'单引号 \"双引号
# \b退格 \n换行 \v纵向制表符 \t横向制表符 \r回车
print('见注释')
print('')
print('#################################################################################################')
# 字符串测试函数
print('7.字符串测试函数')
# isalpha() 判断是否全为字母，是返回1（True),否返回0（False）
# isalnum() 判断是否全为字母和数字，是返回1（True),否返回0（False）
# isdiget() 判断是否全为数字，是返回1（True),否返回0（False）
# islower() 判断是否全为小写字母，是返回1（True),否返回0（False）
# isupper() 判断是否全为大写字母，是返回1（True),否返回0（False）
# isspace() 判断是否全为空格，是返回1（True),否返回0（False）
str = "Python 1234"
str2 = "123456845"
str3 = " "
print('str =', str, '\tstr2 =', str2, '\tstr3 =', str3)
print('str全为字母\t', str.isalpha())
print('str为数字或者字母\t', str.isalnum())
print('str2全为数字\t', str2.isdigit())
print('str3全为空格\t', str3.isspace())
print('')
print('#################################################################################################')
# 字符串运算
print('8.字符串运算')
# + 字符串拼接
# * 字符串重复
# [] 通过索引号获得字符串指定字符
# [: ] 截取字符串中的连续部分
# in 成员运算符，若字符串中包含指定字符则返回True，否则返回False
# not in 成员运算符，若字符串中不包含指定字符则返回True，否则返回False
str1 = '我是'
str2 = '大帅哥'
str3 = 'programming'
print('str1 =', str1, '\tstr2 =', str2, '\tstr3 =', str3)
print('')
print('str1+str2 =', str1 + str2)
print('str2*3 =', str2 * 3)
print('str3[2:6] =', str3[2:6]) # 从第零个字节开始，输出下标为2的字符串数组元素，输出个数为6-2个
print('sdfkj\tdfjhh\nsdfke') # 不加r
print(r'sdfkj\tdfjhh\nsdfke') # 加r
print(str2 in str1) # bool类型
print('gramm' in str3) # bool类型
print('\n')
print('#################################################################################################')
print('9.序列数据')
print('')
# 1.列表
# 列表的一大特点是元素之间可以是不同的类型
# 从左向右索引： 0 1 2 3 4 5
# 字符串： P y t h o n
# 从右向左索引：-6 -5 -4 -3 -2 -1 #左后一个元素下标为-1
# 创建列表用中括号括起来
print('9-1 列表')
list = [15, 23, 31, 46, 58, 69]
list2 = [123, '我是', 1354, '大帅哥', 154]
print(list)
list[4] = 22 # 赋值
print(list)
del list[3] # 删除第四个元素
print(list)
list.append(234) # append只能在列表尾部添加一个元素
print(list)
list.extend(list2) # 在extend后加添加另一个列表
print(list)
list3 = [15, 23, 31, 46, 58, 69] # 还原list
list3.append(list2)
print(list3) # 用append连接
# 总结append与expend的区别：append是将新列表作为一个元素插入原列表尾部，新列表是作为一个新元素出现在原列表中
# extend是将新列表中的所有元素都添加到原列表尾部。
print('\n')
# 对列表整体操作的函数
# cmp(list1,list2) 比较列表1与列表2的大小
# len(list) 计算列表的长度
# max(list) 找出列表中的最大元素
# min(list) 找出列表中的最小元素
print('list3的长度为：', len(list3))
# 对列表内元素操作的函数
# append() 在列表尾添加一个元素
# extend() 在列表尾部添加多个元素
# reverse() 倒置列表元素
# sort() 从小到大排序
list = [15, 23, 31, 46, 58, 69]
list.reverse()
print(list)
list.sort() # 用sort实现升序排序
print(list)
print(max(list))
print(min(list))
print('')
# 2.元组 #元组与列表不同，元组的元素不可更改，只能重新定义元组。可以不用括号。
print('9-2 元组')
t = 15, 23, 31, 46, 58, 69
print('元素个数为：', len(t))
print('元组中的最大值为:', max(t))
print('元素的和为：', sum(t))
print('')
# 3.字典 #用花格号包括
# 字典与列表同样可以更改元素的值，但是字典中的键值是不变的，键值在字典中相当于一个名字，
# 不能出现两次，所以只能用数字或字符串或元组表示。一个键值下的元素可以是任意类型,但必须一个键值对应一个数据。
print('9-3 字典')
dict = {'朱晓桐': 2414519951, 3: 'sjkdfh'}
print('字典为：', dict)
print(dict["朱晓桐"])
print(dict[3])
del dict[3]
print(dict)
print('')
# 4.集合
print('9-4 集合')
a = set('sadkjfhekhssjfkljvi')
b = set("1534,'朱晓桐',1654,822,(12,54,'ksdjfh')")
c = {1534, '朱晓桐', 1654, 822, (12, 54, 'ksdjfh')} # 注意集合B与集合C的区别
d = set('asdjkfhweh')
print('A集合为：', a)
print('D集合为：', d)
print(b)
# 由此可见 set('') 引号中的任何字符都被分成了元素
print(c)
print(len(c))
# 可以通过直接命名的方法创造集合，（）内的所有元素算是集合中的一个元素
print('')
# 集合的 &,|,^,-
print(a & c) # 空集
print(a | c)
print(a ^ d)
print(a - d)
print('\n')
# 10.流程控制
print('#################################################################################################')
print('10.流程控制')
print()
print('10-1 分支选择')
print('见注释')
# 分支选择
# if.....else 条件选择
# 单分支：
# if <语句> ：
# if <语句> ：
# .......
# 双分支：
# if <语句> :
# .....
# else :
# .....
# 多分支：
# if <语句>：
# .....
# elif <语句>:
# .....
# elif <语句>:
# .....
# 循环控制
print()
print('10-2 循环控制')
# while.....else 条件型循环
# for.....else 计数型循环
n = 1
while n <= 10:
n = n + 1
print('*', end='\t') # end='字符' 因为print结束自动默认end = '\n',及自动换行
# 所以要利用循环在同一行输出必须更改end的值
print('')
for n in range(10): # 如默认初值和步数，则初值默认为0，步数默认为1
print(n, end=' ') # range函数，等差数列，不包括终值
print()
for n in range(1, 10, 1):
for i in range(1, n, 1):
print('？', end='') # 嵌套循环
print()
print('')
# 显示斐波那契数列的前15项
f1 = 1
f2 = 2
print(f1, '\t', f2, end='\t')
for i in range(3, 16): # 注意，此处初值为3为了确保每行输出的数据个数为5
f = f1 + f2
f1 = f2
f2 = f
print(f, end='\t')
if i % 5 == 0: print()
# 分子分母都为斐波那契数列，求分式各项和
# 求2/1,3/2,5/3,8/5,13/8,......的前20项和
# 分子2，3，5，8，13..... 分母1，2，3，5，8.....
f1 = 1
f2 = 2
sum = 0
for i in range(20):
sum = sum + f2 / f1
f = f1 + f2
f1 = f2 # 算法原理：前一个分数的分子分母之和为下一个分数的分子，
f2 = f # 前一个分数的分子为下一个分数的分母
print(sum)
print()
# 计算 1-20 的阶乘之和
sum = 0
fact = 1
for i in range(1, 21):
print('第', i, '个')
fact = fact * i # 算法原理：利用单层循环，i的值会保留到下一次循环中，所以只需做阶乘然后累加即可
sum = sum + fact
print(sum)
print('1到20的阶乘之和为：', sum)
print()
# 折半累加数学模型
# 假设初始值为 100，每次减半，相加，无数次操作后，最终的和与初始值无限接近
begin = 100
sum = 0
print('初始值为100')
for n in range(1, 11): # 假设操作次数为10
begin = begin / 2
sum = sum + begin
print('第', n, '次的和为：', sum)
print('无限接近初始值')
print('最后反弹高度为：', begin)
print()
print('10-3 辅助控制')
# 辅助控制
# break 终止循环
# continue 结束本次循环，及跳过循环剩下的全部语句，进入下一次循环
# pass 空语句,不执行,具有占位的作用
# return 从函数中返回
# try...catch 异常处理
# 用continue输出9x9乘法表
for i in range(1, 10):
for j in range(1, 10):
if j > i: continue
k = j * i
print(i, 'x', j, '=', k, end='\t')
print()
print()
# 把整数316分成两个数之和，其中一个数为13的倍数，另一个数位11的倍数，求所有可能的两个数
for n in range(13, 316, 13):
m = 316 - n
if m % 11 == 0:
print(n, m, end='\t')
print()
# 爱因斯坦阶梯问题
for i in range(1, 1000):
if i % 2 == 1 and i % 3 == 2 and i % 5 == 4 and i % 6 == 5 and i % 7 == 0:
print(i, end='\t')
print('\n')
print('#################################################################################################')
print('11.列表处理')
# 列表逆序
list = [15, 55, 662, 1564, 54, 1, 231, 157] # 8个元素
for i in range(0, 8):
print(list[i], end=' ')
print()
for j in range(-1, -9, -1):
print(list[j], end=' ')
print()
print()
# 用一维列表显示斐波那契数列
list = [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
for i in range(2,20):
list[i] = list[i-1]+list[i-2]
print(list)
# 用筛法求1-100内的质数
count = 0
for i in range(2,101):
if i%2==0 or i%3==0 or i%5==0 or i%7==0 :
pass
else:
print(i,end = '\t')
print('\n')
# 列表实现
list = []
count = 0
for i in range(2,102): # 创建容量为100的列表
list.append(i)
count = count+1
print(list[i-2],end="\t")
if count%10==0:print()
a = []
print()
count2 = 0
for n in range(0,100):
if list[n]%2!=0 and list[n]%3!=0 and list[n]%5!=0 and list[n]%7!=0:
a.append(0)
a[count2] = list[n]
count2 = count2+1
list[n] = 0
print(list[n],end="\t")
if (n+1)%10==0:print()
print()
print('质数为:',a)
print()
# 10-2 二维列表
print('10-2 二维列表')
a = [[1,23,4,51,70],[25,48,65,24,8],[13,2,98,44,71],[321,49,56,28,66],[12,54,25,15,33]]
for i in range(0,5):
for j in range(0,5):
print(a[i][j],end='\t')
print()
# 计算主对角线元素的和
count = 0
for n in range(0,5):
count = count+a[n][n]
print('主对角线的和为：',count)
# 找出最大值以及其所对应的行列号
hang = 0
lie = 0
m = 0
n = 0
most = a[m][n]
for m in range(0,5):
for n in range(0,5):
if a[m][n]>most:
most = a[m][n]
hang = m+1
lie = n+1
print('最大值为：',most)
print('第%d行第%d列'%(hang,lie))
# 6x6杨辉三角形
a = [[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]
for i in range(0,6):
a[i][0] = 1
a[i][i] = 1 # 初始化对角线和第一列元素都为1
for i in range(2,6):
for j in range(1,6):
a[i][j] = a[i-1][j-1]+a[i-1][j] # 构造杨辉三角
for i in range(0,6):
for j in range(0,i+1):
print(a[i][j],end = '\t') # 输出杨辉三角
print()
# 调整格式后的输出
for i in range(0,6):
for n in range(0,6-(i+1)):
print(end = ' ')
for j in range(0,i+1):
print(a[i][j],end=' ')
print()
print()
# 判断一个数是否为鞍点（即该数在行上最大，在列上最小）5x5列表
a = [[1,23,100,51,70],[25,48,101,24,8],[13,2,98,44,71],[321,49,130,28,66],[12,54,113,15,33]]
for i in range(0,5):
for j in range(0,5):
print(a[i][j],end='\t') # 列表输出
print()
flag = 0
for i in range(0,5):
most = a[i][0]
for j in range(0,5):
if a[i][j]>most:
most = a[i][j]
hang = i+1
lie = j+1
min = a[0][lie - 1]
for n in range(0,5):
if a[n][lie-1]<min:
min = a[n][lie-1]
if most==min:
print(most)
print(min)
print('鞍点值为：',a[hang-1][lie-1])
print('位置：%d行%d列'%(hang,lie))
print()
# 10-3 折半查找
print('10-3 折半查找')
# 构造元素数量为20的列表
list = [13,45,12,87,65,15,24,51,99,78,14,23,46,58,22,54,30,27,66,69]
list.sort() # 折半查找前提是有序，如想从大到小排序只需再调用reverse()函数
space = len(list)
top = 0 # 查找范围的起始角标
bot = space-1 # 查找范围的结束角标
mid = 0 # 中间元素的下标
number = 54 # 假设所要查找的数值为46
flag = 0
while top<=bot: #注意此处一定为<=号，否则造成最后一次循环没办法进入
mid = (top+bot)//2
if list[mid] == number:
print('查到了')
flag = 1
break
elif list[mid]<number:
top = mid+1
elif list[mid]>number:
bot = mid-1
if flag==0:
print('没找到')
print('\n')
print('#################################################################################################')
print('11.字符串处理')
str = '人人为我,我为人人' # 判断是否为回文序列 (也支持中文字符串，一个汉字算一个字符)
print(str)
flag = 0
space = len(str)
print(len)
for i in range(0,space//2):
if str[i] == str[space-1-i]:
flag = flag+1
if flag==space//2:
print('是回文序列')
else:
print('不是回文序列')
print()
# 统计一句英文中的单词个数
str2 = 'I am a handsome man'
print(str2)
space = len(str2)
atmp = 0
number = 0
for i in range(0,space):
if str2[i]==' ':
atmp = 0
else:
if atmp==0:
number = number+1
atmp = 1
print('单词个数为：',number)
print()
#利用编码翻译密文（解密）
#加密算法：第一个字母对应最后一个，第二个对应倒数第二个
s = 'R droo erhrg Xsrmz mvcg dvvp.' # 密文
space = len(s)
print('密文：',s)
print('明文：',end = '')
for i in range(0,space):
if s[i]>='a' and s[i]<='z':
print(chr(219-ord(s[i])),end='') # chr()将ASCLL码值转化为字符，ord()将字符转化为ASCLL码值
elif s[i]>='A' and s[i]<='Z':
print(chr(155-ord(s[i])),end='')
else:
print(s[i],end='')
print()
print('\n')
print('#################################################################################################')
print('12.函数')
# 通过返回列表返回多值
import random
def my_random(n):
a = []
for i in range(n):
a.append(random.random())
return a
n = 8 # 随机数个数
a = my_random(n)
for i in range(n):
print(a[i],end="\n")
print()
# 计算 m!/n!/(m-n)!,算法相同，所以调用三次相同的函数
def comp(k):
tol = 1
for i in range(1,k+1):
tol = tol*i
return tol
n = 2
m = 6
result = comp(m)/comp(n)/comp(m-n)
print('结果为：',result)
print()
# 用欧几里得算法计算最大公约数
def fuc(x,y):
while x%y!=0:
r = x%y
x = y
y = r
return y
x = 128
y = 48
y = fuc(x,y)
print('最大公约数为：',y)
print()
# 验证哥德巴赫猜想 (任何一个大于6的偶数都可被分为两个质数的和)
def judge(m): # 判断该数是否为质数
for n in range(2,m):
if m%n==0: # 不是质数
return 0
return 1 #是质数
# 主函数
count = 0
for i in range(2,101):
if i%2 == 0: # 确定为偶数
for j in range(2,i//2+1):
if judge(j)==1 and judge(i-j)==1:
count = count+1
print('%3d=%2d+%2d'%(i,j,i-j),end =' ')
if count%5 == 0:
print()
print('\n')
# 找出100以内所有相邻的质数 如(3 5,5 7,11 13),相差2的为一组
def f(m): #判断是否为质数
for i in range(2,m):
if m%i==0: #不是质数
return 0
return 1 #是质数
# 主函数
a = [] # 定义空列表
for i in range(2,101):
if f(i)==1:
a.append(i)
print(a)
print('结果为：')
for i in range(len(a)-1):
if a[i+1]-a[i]==2:
print('(%d,%d)'%(a[i],a[i+1]))
print()
# 找出500以内的全部亲密数对（A的因数之和（包括1但不包括本身）相加等于B
# 同时B的因数之和相加也等于A,则称A与B互为亲密数对）
def p(m): # 求m的因数之和
s = 0
for i in range(1,m):
if m%i==0:
s = s+i
return s
# 主函数
for i in range(2,501):
A = i
B = p(A)
if p(B)==A and A!=B:
print('%d与%d为亲密数对'%(A,B))
print()
# 整数n的9倍恰为n的反序数
def revers(m):
s = 0
for i in range(4):
if a != 0:
s = s * 10 + m % 10
m = m // 10
return s
# 主函数
for n in range(1000,1111): # 因为最大四位数为9999，所以n最大为1111
if 9*n == revers(n):
print('该反序数为：',n)
print()
# 验证6174猜想
def rev(k): # 倒序数字
s = 0
for i in range(4):
s = s*10 + k%10
k = k//10
return s
def make(m): # 生成由大到小的四位数
a = [0,0,0,0]
a[0] = m%10
a[1] = m//10%10
a[2] = m//100%10
a[3] = m//1000%10
a.sort()
a.reverse()
return a[0]*1000+a[1]*100+a[2]*10+a[3]
# 主函数
m = 5298 # 假设测试数据为 1584
number = make(m) # 创造每位数由大到小排序的四位数(大数)
count = 0
while number!=6174:
count = count + 1
A = make(number)
B = rev(A)
number = A-B
print('第%d次：%d-%d=%d' % (count, A, B, A-B))
print('\n')
print('12-2 一维列表作为实参')
# 定义函数
def most(b):
m = b[0]
for i in range(1,9):
if m<b[i]:
m = b[i]
return m
# 主程序及其调用函数
# 创建一维列表并初始化
a = [1,2,3,4,5,0,9,8,7,6]
print('全部数：',end = '')
for i in a:
print(i,end = ' ')
print()
print('最大数：',most(a))
print()
# 一维列表中的元素作为实参
# 定义函数
def large (x,y):
if x>y:
return 1
elif x<y:
return -1
else:
return 0
# 主程序及其调用函数
a = [3,5,7,9,8,6,4,2,0,0]
b = [3,8,9,-1,-3,5,6,0,4,0]
print('列表a：',end='')
for i in a:
print(i,end = ' ')
print()
n=m=k=0
for i in range(0,len(a),1):
if large(a[i],b[i])==1:
n = n+1
elif large(a[i],b[i])==0:
m = m+1
else:
k = k+1
print('a[i]>b[i]:',n)
print('a[i]=b[i]:',m)
print('a[i]<b[i]:',k)
if n>k:
print('列表a大于列表b')
elif n<k:
print('列表a小于列表b')
else:
print('列表a等于列表b')
print()
# 二维列表作为实参
# 定义函数
def mst(a):
most = a[0][0]
for i in range(3):
for j in range(4):
if a[i][j]>most:
most = a[i][j]
return most
# 主程序
a = [[1,3,5,7],[2,4,6,8],[15,17,34,12]]
print('列表：')
for i in range(3):
for j in range(4):
print(a[i][j],end = '\t')
print()
print('最大值为：',mst(a))
print()
# 可变参数
def sum(a,b,*c):
s = a+b
for n in c:
s = s+n
return s
print('1+2+3 =',sum(1,2,3)) # 计算 1+2+3
print('1+2+3+4 =',sum(1,2,3,4)) # 计算1+2+3+4
print('1+2+3+4+5 =',sum(1,2,3,4,5))# 计算1+2+3+4+5
print()
# 函数的作用域
A = 13
B = -8
# 定义函数
def most(x,y):
if x>y:
z = x
else:
z = y
return z
# 主程序
print('A =',A,'\tB =',B)
print('较大数：',most(A,B))
# global语句，定义全局变量
a = 6
# 函数定义
def power(n):
global a
y = 1
for i in range(1,n+1):
y = y*a
return y
# 主函数
b = 4
m = 3 #假设测试数据为3
c = a*b
print(a,'x',b,'=',c)
d = power(m)
print(a,'和',m,'乘方=',d)
# lambda 函数（匿名函数）
def com(n):
if n==1:
return lambda x,y:x+y # lambda <参数>：<表达式> # lambda 函数只能表达较为简单的表达式
if n==2:
return lambda x,y:x-y
# 主函数
print('输出调用结果')
operate = com(1)
print('46+2 =',operate(46,2))
operate = com(2)
print('46-2 =',operate(46,2))
print('\n')
print('12-3 递归函数')
# 定义递归函数计算 n 的阶乘
def fact(m):
if m == 1:
return 1
else:
return fact(m-1)*m
# 计算5的阶乘
print('5! =',fact(5))
print('\n')
#汉诺塔问题
print('#################################################################################################')
print('汉诺塔问题')
count = 0
def move(one,three):
print(one,'->',three)
def hanoi(n,one,two,three): #意为从A借助B移到C
global count
count = count+1
if n==1:
move(one,three)
else:
hanoi(n-1,one,three,two) #意为从A借助C移到B
move(one,three)
hanoi(n-1,two,one,three) #意为从B借助A移到C
return count
n = 3 #假设测试数据为3
print('步骤为：')
hanoi(n,'A','B','C')
print('总计%d次操作'%count)
print('#################################################################################################')
# 简便版
def mov(A,C):
print(A,'->',C)
def fuc(n,A,B,C):
if n==1:
move(A,C)
else:
fuc(n-1,A,C,B)
move(A,C)
fuc(n-1,B,A,C)
n = 5
fuc(n,'A','B','C')
print('#################################################################################################')
print('\n')
# 用递归函数计算最大公约数
def f(m,n):
if m%n==0:
return n
else:
return f(n,m%n)
# 主函数
m = 128
n = 48
print('%d与%d的最大公约数为：%d'%(m,n,f(m,n)))
# 用递归函数计算n阶调和数 1+1/2+1/3.....+1/n
def p(n):
if n == 1:
return 1
else:
return p(n-1)+1/n
# 主函数
n = 5 # 假设测试数据为5
print('%d阶调和数为：%f'%(n,p(5)))
# 用递归函数实现反序数 #注意此种方法未定义变量并赋值，只是单纯的显示
def f(p): # 对m实现反序
print(p%10,end = '')
if p//10 != 0:
f(p//10)
p = 13548
print('原数据：%d'%p)
print('倒序数据：',end = '')
f(p)
# 模块
print('#################################################################################################')
print('13-1 模块')
# 导入模块
import math
print('pi = \t\t',math.pi)
print('e = \t\t',math.e)
print('sqrt(2) = \t',math.sqrt(2))
print()
# 导入模块成员
from math import fabs,sqrt,pow
print('fabs(-9) =',fabs(-9))
print('sqrt(9) =',sqrt(9))
print('pow(2,5) =',pow(2,5))
print()
# math 模块中的常用函数
import math
print('ceil(2.56) =',math.ceil(2.56)) # 返回大于x的最小整数
print('floor(2.56) =',math.floor(2.56)) # 返回小于x的最大整数
print('factorial(5) =',math.factorial(5)) # 返回x的阶乘值
print('hypot(3,4) =',math.hypot(3,4)) # 返回直角三角形中斜边的值
print('log(e) =',math.log(math.e)) # 返回以自然对数为底的对数值
print('log10(pow(10,5)) =',math.log10(pow(10,5))) # 返回以10为底的对数值
print()
标签：10,end,list,列表,range,寒假,收获,print,中期 来源： https://www.cnblogs.com/zhuxiaotong/p/12251088.html