标签：10 end list 列表 range 寒假 收获 print 中期
寒假中期学习收获
- 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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。