Python编程练习100例（含答案）
背景：最近在学习Python编程，看到菜鸟教程中的Python 100例，就在pycharm中进行练习，学没学会，先把代码敲下来，慢慢回味吧~
以下100个实例是基于Win10系统，并且在Python3.12下测试执行通过的（pycharm中运行）：
# 题目1：有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？
# for i in range(1, 5):
# for j in range(1, 5):
# for k in range(1, 5):
# if (i != k) and (i != j) and (j != k):
# print(i, j, k)
# 题目2：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
# 20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，
# 高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？
# num = int(input('请输入利润：'))
# arr = [1000000, 600000, 400000, 200000, 100000, 0]
# rat = [0.01, 0.015, 0.03, 0.05, 0.075, 0.1]
# bonus = 0
# for i in range(0, 6):
# if num > arr[i]:
# bonus += (num - arr[i]) * rat[i]
# print((num-arr[i])*rat[i])
# num = arr[i]
# print(bonus)
# 题目3：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
# 假设该数为 x。 1、则：x + 100 = n平方, x + 100 + 168 = m平方；
# 2、计算等式：m2 - n2 = (m + n)(m - n) = 168
# 3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数；
# 4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。
# 5、从 3 和 4 推导可知道，i 与 j 均是大于等于 2 的偶数。
# 6、由于 i * j = 168， j>=2，则 1 < i < 168 / 2 + 1。
# 7、接下来将 i 的所有数字循环计算即可。
# def find_interger():
# for i in range(2, 85):
# if 168 % i == 0:
# j = 168 // i
# if i > j and (i+j) % 2 == 0 and (i-j) % 2 ==0:
# m = (i+j) // 2
# n = (i-j) // 2
# x = n * n - 100
# print(f"x: {x}, m: {m}, n: {n}")
#
#
# find_interger()
# 题目4：输入某年某月某日，判断这一天是这一年的第几天？
# 程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于2时需考虑多加一天：
# year = int(input('year:\n'))
# month = int(input('month:\n'))
# day = int(input('day:\n'))
#
# months = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334)
# if 0 < month <= 12:
# sum = months[month - 1]
# else:
# print('data error')
# sum += day
# print(sum)
# leap = 0
# if (year % 400 == 0) or ((year % 4 == 0) and (year % 100 != 0)):
# leap = 1
# if (leap == 1) and (month > 2):
# sum += 1
# print('it is the %dth day.' % sum)
# 题目5：输入三个整数x,y,z，请把这三个数由小到大输出。
# ls = []
# for i in range(3):
# x = int(input('integer:\n'))
# ls.append(x)
# ls.sort()
# print(ls)
# 题目6：斐波那契数列
# 程序分析：斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……。
# def fib(n):
# if n == 1 or n == 2:
# return 1
# else:
# return fib(n-2)+fib(n-1)
#
#
# print(fib(10))
# 题目6：斐波那契数列 方法二
# def fib2(n):
# a, b = 1, 1
# for i in range(n-1):
# a, b = b, a+b
# return a
#
#
# print(fib2(10))
# 题目7：将一个列表的数据复制到另一个列表中。
# ls1 = [1, 2, 'a']
# # ls2 = []
# # ls2 = ls1.copy()
# ls2 = ls1[:]
# print(ls2)
# 题目8：输出 9*9 乘法口诀表
# for i in range(1, 10):
# for j in range(1, i+1):
# s = i * j
# print('%d*%d=%2ld' % (i, j, s), end=" ")
#
# print()
# 题目9：暂停一秒输出。程序分析：使用 time 模块的 sleep() 函数。
# import time
# myD = {1: 'a', 2: 'b'}
# for key, value in dict.items(myD):
# print(key, value)
# time.sleep(1) # 暂停一秒
# 题目10：暂停一秒输出，并格式化当前时间。
# import time
# print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
# time.sleep(1)
# print(time.strftime('%Y-%m-%D %H:%M:%S', time.localtime(time.time())))
# 题目11：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
# 程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....
# m1 = 1
# m2 = 1
# for i in range(1, 22):
# print('%12ld %12ld' % (m1, m2), end=" ") # 以12字符宽度打印m1和m2，不换行
# if (i % 3) == 0: # 每3次循环换行一次
# print('')
# m1 = m1 + m2
# m2 = m1 + m2
# 题目12：判断101-200之间有多少个素数，并输出所有素数.
# h = 0
# for i in range(101, 201):
# for j in range(2, i):
# if i % j == 0:
# break
# else:
# print(i, end=' ')
# h += 1
# print("\n101-200之间素数共有:%d个" % h)
# 题目13：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
# 程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
# for i in range(100, 999):
# ones = i % 10
# ten = i // 10 % 10
# hundred = i // 100
# if i == pow(ones, 3)+pow(ten, 3)+pow(hundred, 3):
# print(i)
# 题目14：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
#
# 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
# (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
# (2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。
# (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
# def reduceNum(n):
# print('{}='.format(n), end=" ")
# if not isinstance(n, int) or n <= 0: # 检查n是否为正整数
# print('请输入一个正确的数字 ！')
# exit(0) # 退出程序
# elif n in [1]: # 处理n=1的特殊情况
# print('{}'.format(n))
# while n not in [1]: # 当n不等于1时循环，循环保证递归
# for i in range(2, n+1): # 从2开始寻找因数
# if n % i == 0: # 找到能整除n的最小i
# n //= i # n 等于 n除以i的商
# if n == 1:
# print(i)
# else: # i 一定是素数
# print('{} *'.format(i), end=" ") # 打印因数加*号
# break # 跳出for循环
#
#
# reduceNum(1)
# reduceNum(100)
# 题目15：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
# 程序分析：程序分析：(a>b) ? a:b 这是条件运算符的基本例子。
# score = int(input('输入分数：'))
# if score >= 90:
# grade = 'A'
# elif 60 <= score <= 89:
# grade = 'B'
# else:
# grade = 'C'
#
# print('%d 属于 %s' % (score, grade)) # %s格式化字符串
# 题目16：输出指定格式的日期。
# 程序分析：使用 datetime 模块
# import datetime
# if __name__ == '__main__':
# # 输出今天日期，格式为dd/mm/yyyy
# print(datetime.date.today().strftime('%d/%m/%Y'))
#
# # 创建日期对象
# mycountryBirthDate = datetime.date(1945, 10, 1)
# print(mycountryBirthDate.strftime('%d/%m/%Y'))
#
# # 日期算术运算
# mycountryBirthNextDay = mycountryBirthDate + datetime.timedelta(days=1)
# print(mycountryBirthNextDay.strftime('%d/%m/%Y'))
#
# # 日期替换
# mycountryFirstBirthday = mycountryBirthDate.replace(year=mycountryBirthDate.year + 1)
# print(mycountryFirstBirthday.strftime('%d/%m/%Y'))
# 题目17：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
# 程序分析：利用 while 或 for 语句,条件为输入的字符不为 '\n'。
import string
# s = input('请输入一个字符串：')
# letters = 0
# space = 0
# digit = 0
# others = 0
# for c in s:
# if c.isalpha():
# letters += 1
# elif c.isspace():
# space += 1
# elif c.isdigit():
# digit += 1
# else:
# others += 1
# print('char = %d,space= %d,digit= %d,others = %d' % (letters, space, digit, others))
# 题目18：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
# from functools import reduce
#
# Tn = 0
# Sn = []
# n = int(input('n = '))
# a = int(input('a = '))
# for count in range(n):
# Tn = Tn + a
# a = a * 10
# Sn.append(Tn)
# print(Tn)
#
# Sn = reduce(lambda x, y: x+y, Sn) # 使用 lambda 匿名函数
# print("计算和为：", Sn)
# 题目19：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。
# from sys import stdout
# for j in range(2, 1001):
# k = [] # 初始化空列表k，用于存储因数
# n = -1 # 初始化计数器n为-1，用于记录因数的个数
# s = j # 初始化s为当前数字j，用于后续计算
# for i in range(1, j): # i从1遍历到j-1
# if j % i == 0: # 判断i是否是j的因数
# n += 1
# s -= i # 从s中减去当前因数i
# k.append(i) # 将因数i添加到列表k中
# if s == 0: # 检查所有因数之和是否等于原数j
# print(j) # 如果是完数，打印该数
# for i in range(n): # 循环打印所有因数（最后一个除外）
# stdout.write(str(k[i]))
# stdout.write(' ')
# print(k[n])
# 完数：方法二
# def fac(num):
# res = set() # 初始化一个空集合res，用于存储因数
# for i in range(1, num):
# if num % i == 0: # 判断i是否是num的因数
# res.add(i) # 将因数i添加到集合中
# res.add(num/i) # 将对应的另一个因数num/i也添加到集合中
# return res # 返回包含所有因数的集合
#
#
# for j in range(2, 1001):
# if j == sum(fac(j)) - j: # 检查j是否等于其所有因数之和减去自身（即判断是否为完全数）
# print(j)
# 题目20：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
# tour = [] # 创建空列表，用来记录每次弹跳的行程距离
# height = [] # 创建一个空列表，用来记录每次反弹后的高度
# initial_height = 100.0 # 初始高度
# num_bounces = 10 # 弹跳次数
# for i in range(1, num_bounces + 1): # 循环10次，模拟10次弹跳
# # 从第二次开始，落地时的距离应该是反弹高度乘以2（弹到最高点再落下）
# if i == 1: # 第一次弹跳特殊处理
# tour.append(initial_height) # 第一次只有下落，所以直接记录初始高度
# else:
# tour.append(2 * initial_height) # 每次弹跳包含上升和下降，所以是高度的两倍
# initial_height /= 2 # 每次弹跳后高度减半
# height.append(initial_height) # 记录每次弹跳后的新高度
#
# total_distance = sum(tour) # 计算总距离
# final_bounce_height = height[-1] # 获取第10次反弹后的高度
#
# print(f"总高度：tour = {total_distance}")
# print(f"第{num_bounces}次反弹高度：height={final_bounce_height}")
# 题目21：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
# 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
# 以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
# 程序分析：采取逆向思维的方法，从后往前推断。
# x2 = 1 # 第10天的桃子数量
# for day in range(9, 0, -1): # 从第9天倒推到第1天
# x1 = (x2+1) * 2 # 计算前一天的桃子数量：（当天数量+1）*2
# x2 = x1 # 将计算结果赋值给x2，用于下一次循环
# print(x1) # 输出第1天的桃子总数
# 题目22：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。
# 已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
# for i in range(ord('x'), ord('z')+1): # i从‘x’到‘z’的ASCII码值
# for j in range(ord('x'), ord('z')+1): # j从‘x’到‘z’的ASCII码值
# if i != j: # i和j不同
# for k in range(ord('x'), ord('z')+1): # k从‘x’到‘z’的ASCII码值
# if (i != k) and (j != k): # 确保k与i，j都不同
# if(i != ord('x')) and (k != ord('x') and (k != ord('z'))):
# print('order is a-- %s\t b--%s\tc--%s' % (chr(i), chr(j), chr(k)))
# 题目22：方法二
# a = set(['y', 'z']) # 创建集合a，包含元素‘y’和‘z’
# b = set(['x', 'y', 'z'])
# c = set(['y'])
# for i in a: # 遍历集合a中的元素
# for j in b:
# for k in c:
# if len(set((i, j, k))) == 3: # 检查i，j，k是否互不相同
# print('a--%s\tb--%s\tc--%s' % (i, j, k))
# 题目23：打印出如下图案（菱形）:
# *
# ***
# *****
# *******
# *****
# ***
# *
# 程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重for循环，第一层控制行，第二层控制列。
# def print_diamond(rows): # 定义打印菱形的函数，rows指定菱形最大宽度
# # 上半部分
# for i in range(1, rows, 2): # 从1开始，步长为2，生成奇数序列（1,3,5...)
# spaces = " " * ((rows - i) // 2) # 计算每行前面的空格数：（总宽度-当前星数）/2
# stars = "*" * i # 生成星号字符串
# print(spaces + stars)
# # 下半部分
# for i in range(rows, 0, -2):
# spaces = " " * ((rows - i) // 2) # // 总是舍弃小数部分，/ 保留完整精度
# stars = "*" * i
# print(spaces + stars)
#
#
# # 设置行数，根据需要进行调整
# rows = 7
# print_diamond(rows)
# 题目24：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
# 程序分析：请抓住分子与分母的变化规律。
# from functools import reduce
# a = 2.0 # 初始化第一个分子值
# b = 1.0 # 初始化第一个分母值
# ls = [a / b] # 创建列表存储比例值
# for i in range(1, 20): # 循环1到19
# b, a = a, a+b # 斐波那契递推：b取旧a值，a变为旧a+旧b
# ls.append(a/b) # 计算并存储新的比例值
# print(reduce(lambda x, y: x+y, ls)) # 使用reduce累加列表中的所有比例值
# 题目25：求1+2!+3!+...+20!的和。
# s = 0 # 初始化累加器，用于存储阶乘和
# t = 1
# for n in range(1, 21):
# t *= n # 计算当前n的阶乘：t = t * n
# s += t # 将当前阶乘值累加到总和s中
# print('1!+2!+3!+...+20! = %d' % s)
# 题目26：利用递归方法求5!。
# def fact(n):
# s = 0
# if n == 0:
# s = 1
# else:
# s = n * fact(n-1)
# return s
#
#
# print(fact(5))
# 题目27：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
# def output(s, l):
# if l == 0:
# return
# print(s[l-1])
# output(s, l-1)
#
#
# s = input("请输入字符串：")
# l = len(s)
# output(s, l)
# 题目28：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。
# 问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
# 程序分析：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。
# one = 10
# def age(a):
# if a == 1:
# return 10
# else:
# return age(a-1) + 2
#
# print(age(5))
# 题目29：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
# n = int(input("请输入一个正整数：\n"))
# a = n // 10000
# b = n % 10000 // 1000
# c = n % 1000 // 100
# d = n % 100 // 10
# e = n % 10
#
# if a != 0:
# print("5位数：", e, d, c, b, a)
# elif b != 0:
# print("4位数", e, d, c, b)
# elif c != 0:
# print("3位数：", e, d, c)
# elif b != 0:
# print("2位数：", e, d)
# else:
# print("1位数：", e)
# 题目30：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
# num = int(input("请输入一个5位数："))
# s = str(num)
# flag = True
# for i in range(len(s)//2):
# if s[i] != s[-i - 1]:
# flag = False
# break
# if flag:
# print("%d 是回文数!" % num)
# else:
# print("%d 不是回文数!" % num)
# 题目31：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。
# letter = input("please input letter:")
# if letter == 'S':
# print('please input second letter')
# letter = input("please input:")
# if letter == 'a':
# print('Saturday')
# elif letter == 'u':
# print('Sunday')
# else:
# print('data error')
# elif letter == 'F':
# print('Friday')
# elif letter == 'M':
# print('Monday')
# elif letter == 'T':
# print('please input second letter')
# letter = input("please input:")
#
# if letter == 'u':
# print('Tuesday')
# elif letter == 'h':
# print('Thursday')
# else:
# print('data error')
# elif letter == 'W':
# print('Wednesday')
# else:
# print('data error')
# 题目32：按相反的顺序输出列表的值。
# ls = ['one', 'two', 'three', 'four', 'five']
# for i in ls[::-1]: # 表示从右往左以步长为1进行切片。步长小于0时，返回序列为倒序
# print(i)
# 题目33：按逗号分隔列表。
# L = [1, 2, 3, 4, 5, 6]
# s1 = '，'.join(str(n) for n in L)
# print(s1)
# 题目34：练习函数调用。
# def hello_myWorld():
# print('Hello my python world')
#
#
# def hello_world():
# for i in range(3):
# hello_myWorld()
#
#
# if __name__ == '__main__':
# hello_world()
# 题目35：文本颜色设置。
# class bcolors: # 定义名为bcolors的类,用于封装ANSI颜色控制码
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m' # 重置所有样式（必须放在彩色文本结尾）
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m' # 下划线文本样式
#
#
# print(bcolors.WARNING + "警告的颜色字体？" + bcolors.ENDC)
# 题目36：求100之内的素数。
# lower = int(input("请输入区间最小值："))
# upper = int(input("请输入区间最大值："))
# for num in range(lower, upper+1):
# # 素数大于1
# if num > 1:
# for i in range(2, num):
# if (num % i ) == 0:
# break
# else:
# print(num)
# 题目37：对10个数进行排序。
# if __name__ == "__main__": # 主程序入口，当脚本直接运行时执行下方代码块
# N = 10
# print('请输入10个数字：\n')
# ls = []
# for i in range(N):
# ls.append(int(input("输入一个数字：\n")))
#
# for i in range(N):
# print(ls[i], end=" ") # 打印原始输入的数字列表
#
# # 排列10个数字
# for i in range(N - 1): # 控制排序轮次
# min = i # 记录当前最小值位置
# for j in range(i+1, N): # 查找后续元素中的最小值
# if ls[min] > ls[j]:
# min = j # 更新最小值位置
# ls[i], ls[min] = ls[min], ls[i] # 交换元素实现选择排序
# print('\n排列之后：')
# for i in range(N):
# print(ls[i], end=" ")
# 题目38：求一个3*3矩阵主对角线元素之和
# if __name__ == '__main__':
# a = [] # 初始化空列表a（将用于存储3x3矩阵）
# sum = 0.0
# for i in range(3): # 控制矩阵行数（3行）
# a.append([]) # 每行添加空子列表
# for j in range(3): # 控制每行的列数（3列）
# a[i].append(float(input("请输入数字：\n"))) # 将用户输入转为浮点数存入矩阵
# for i in range(3): # 遍历对角线元素（行号=列号）
# sum += a[i][i] # 累加主对角线元素（a[0][0], a[1][1], a[2][2]）
# print(sum)
# 题目39：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
# 程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置。
# if __name__ == '__main__':
# # 0作为加入数字的占位符
# a = [1, 4, 6, 9, 13, 16, 19, 28, 40, 100, 0]
# print('原始列表：')
# for i in range(len(a)):
# print(a[i])
# number = int(input("\n请输入一个数字：\n"))
# end = a[9] # 获取当前列表的最大值（第10个元素，索引9）
# if number > end: # 如果输入数字大于当前最大值
# a[10] = number # 直接替换末尾占位符
# else: # 否则执行插入排序
# for i in range(10):
# if a[i] > number: # 找到第一个比输入数字大的位置
# temp1 = a[i] # 保存当前位置原值
# a[i] = number # 插入新数字
# for j in range(i+1, 11): # 后移后续元素
# temp2 = a[j]
# a[j] = temp1
# temp1 = temp2
# break # 完成插入后退出循环
#
# print("排序后列表：")
# for i in range(11):
# print(a[i])
# 题目40：将一个数组逆序输出。
# if __name__ == '__main__':
# a = [9, 6, 5, 4, 1, 10]
# N = len(a)
# print(a)
# for i in range(len(a) // 2):
# a[i], a[N-i-1] = a[N-i-1], a[i]
# print(a)
# 题目41：模仿静态变量的用法。
# 第一部分：函数调用
# def varfunc():
# var = 0 # 每次调用都会重新初始化为0
# print('var = %d' % var)
# var += 1 # 这个递增操作不会保留到下次调用
#
# if __name__ == '__main__':
# for i in range(3):
# varfunc()
#
#
# # 第二部分：类属性操作
# class Static:
# StaticVar = 5 # 类属性（所有实例共享）
#
# def varfunc(self):
# self.StaticVar += 1 # 实际上创建了实例属性
# print(self.StaticVar)
#
#
# print(Static.StaticVar) # 直接访问类属性
# a = Static()
# for i in range(3):
# a.varfunc()
# 题目42：学习使用auto定义变量的用法。
# num = 2 # 定义全局变量
#
#
# def autofunc():
# num = 1 # 函数内部创建局部变量（与全局变量同名但独立），作用域仅在该函数内有效
# print('internal block num = %d' % num)
# num += 1 # 递增局部变量（每次调用函数都会重新初始化为1）
#
#
# for i in range(3):
# print('The num = %d' % num) # 打印全局变量
# num += 1 # 递增全局变量
# autofunc()
# 题目43：模仿静态变量(static)另一案例。
# class Num:
# nNum = 1 # 定义类属性
#
# def inc(self): # 定义实例方法inc
# self.nNum += 1 # 当首次访问时，会创建实例属性nNum(值为类属性值+1），后续调用会递增实例属性
# print('nNum = %d' % self.nNum)
#
#
# if __name__ == '__main__':
# nNum = 2 # 定义全局变量nNum（与类属性无关）
# inst = Num() # 创建Num类的实例
# for i in range(3):
# nNum += 1
# print('The num = %d' % nNum)
# inst.inc() # 调用实例的inc方法
# 题目44：两个 3 行 3 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵：
# X = [[12,7,3],
# [4 ,5,6],
# [7 ,8,9]]
# Y = [[5,8,1],
# [6,7,3],
# [4,5,9]]
# 创建一个3x3的二维列表（矩阵），包含3行3列的数字
# X = [[12, 7, 3],
# [4, 5, 6],
# [7, 8, 9]]
#
# Y = [[5, 8, 1],
# [6, 7, 3],
# [4, 5, 9]]
#
# result = [[0, 0, 0],
# [0, 0, 0],
# [0, 0, 0]]
# # 迭代输出行
# for i in range(len(X)): # len(X)获取矩阵行数(3)
# # 迭代输出列
# for j in range(len(X[0])): # len(X[0])获取第一行的列数(3)
# result[i][j] = X[i][j] + Y[i][j]
# for r in result:
# print(r)
# 题目45：统计 1 到 100 之和。
# sum = 0
# for i in range(1, 101):
# sum += i
# print('1到100的和为:%d' % sum)
# 题目46：求输入数字的平方，如果平方运算后小于 50 则退出。
# TRUE = 1
# FALSE = 0
#
#
# def SQ(x):
# return x * x
#
#
# print('如果输入的数字平方运算后小于50，程序将停止运行。')
# again = 1
# while again:
# num = int(input("请输入一个数字："))
# print('平方运算结果为：%d' % (SQ(num)))
# if SQ(num) >= 50:
# again = TRUE
# else:
# again = FALSE
# 题目47：两个变量值互换。
# def exchange(a, b):
# a, b = b, a
# return (a, b)
#
#
# if __name__ == '__main__':
# x = 10
# y = 20
# print('x = %d,y = %d' % (x, y))
# x, y = exchange(x, y)
# print("互换后：x=%d,y=%d" % (x, y))
# 题目48：数字比较。
# if __name__ == '__main__':
# i = 10
# j = 20
# if i > j:
# print('%d 大于 %d' % (i, j))
# elif i == j:
# print('%d 等于 %d' % (i, j))
# elif i < j:
# print('%d 小于 %d' % (i, j))
# else:
# print('未知')
# 题目49：使用lambda来创建匿名函数。
# 求两个数的较大值：原理：利用布尔值在算术运算中会转换为1（True）/0（False）的特性；
# 当x>y时：(x>y)=1,(x<y)=0 -->结果为1x+0y=x
# 当x<y时：(x>y)=0，(x<y)=1 → 结果为0x+1y=y
# MAXIMUM = lambda x, y: (x > y)*x+(x < y)*y # lambda表达式使函数定义更紧凑
# MINIMUM = lambda x, y: (x > y)*y+(x < y)*x # 原理相似，求最小值：当x>y时返回y，当x<y时返回x
#
# if __name__ == '__main__':
# a = 100
# b = 20
# print('The larger one is %d' % MAXIMUM(a, b))
# print('The lower one is %d' % MINIMUM(a, b))
# 题目50：输出一个随机数。
# import random
# # 生成10到20之间的随机数
# print(random.uniform(10, 20))
# 题目51：学习使用按位与 & 。
# 程序分析：0&0=0; 0&1=0; 1&0=0; 1&1=1
# if __name__ == '__main__':
# a = 0x77 # 定义变量a并赋值为十六进制数0x77（对应十进制119）,二进制表示为01110111
# b = a & 3 # 进行位与运算(&):3的二进制00000011，按位与运算规则：两位同时为1时结果为1，否则为0
# print('a & b = %d' % b)
# b &= 7 # b=b&7,7的二进制是00000111，当前b=3(00000011)
# print('a & b = %d' % b)
# 题目52：学习使用按位或 | 。
# 程序分析：0|0=0; 0|1=1; 1|0=1; 1|1=1
# if __name__ == '__main__':
# a = 0o77 # 将八进制数77（前缀0o表示八进制）赋值给变量a,0o77转换为十进制是7*8 + 7 = 63
# b = a | 3 # 对a和3进行按位或运算(|),a=63（二进制111111），3（二进制000011）,按位或运算结果：111111 | 000011 = 111111（即63）
# print('a | b is %d' % b)
# b |= 7 # 复合赋值运算符，等价于b = b|7, 111111 | 000111 = 111111（63）
# print('a | b is %d' % b)
# 题目53：题目：学习使用按位异或 ^ 。
# 程序分析：0^0=0; 0^1=1; 1^0=1; 1^1=0
# if __name__ == '__main__':
# a = 0o77 # 将八进制数77（前缀0o表示八进制）赋值给变量a,0o77转换为十进制是7*8 + 7 = 63
# b = a ^ 3 # a=63（二进制111111），3（二进制000011）,按位异或运算结果：111100 (60)
# print('The a ^ 3 = %d' % b)
# b ^= 7 # 111100 ^ 000111 = 111011 (59)
# print('the a ^ b = %d' % b)
# 题目54：取一个整数a从右端开始的4〜7位。 *********不太懂***********
# 程序分析：可以这样考虑：
# (1)先使a右移4位。
# (2)设置一个低4位全为1,其余全为0的数。可用~(~0<<4)
# (3)将上面二者进行&运算。
# if __name__ == '__main__':
# a = int(input("请输入一个数字：\n"))
# b = a >> 4 # 将变量a的值向右位移4位（相当于除以16取整）后赋值给b,例如：若a=32(二进制100000)，b=32>>4=2(二进制10)
# print(b)
# c = ~(~0 << 4) # ~0得到全1的二进制数（在Python中是-1）,<<4左移4位得到...11110000,~取反后得到00001111（即十进制15）,最终c的值是二进制后4位为1的掩码(0b1111)
# d = b & c # 将b的值与掩码c进行按位与运算,效果是保留b的最低4位，其他位清零
# print('%o\t%o' % (a, d)) # 以八进制格式输出：第一个%o输出原始数字a的八进制表示,第二个%o输出处理后d的八进制表示
# 题目55：学习使用按位取反~。
# 说明：二进制数在内存中以补码的形式存储。
# 按位取反：二进制每一位取反，0 变 1，1 变 0。
# 最高位为符号位，正数的符号位为 0，负数为 1。
# 对正数来说，最高位为 0，其余各位代表数值本身(以二进制表示)，如 +42 的补码为 00101010。
# 对负数而言，把该数绝对值的补码按位取反，然后对整个数加 1，即得该数的补码。如 -42 的补码为 11010110(00101010 按位取反11010101+1 即 11010110)。
#
# a = 7 # 二进制：0 0111，补码：0 0111；取反：1 1000 即-8
# b = ~a # ~是Python的按位取反运算符
# # 负数的补码是在原码的基础上，除符号位外，其他各位按位取反，而后末位+1，若有进位则产生进位；
# c = -7 # -7的补码：1 1001；取反：0 0110 即6
# d = ~c
# print('变量a取反结果为：%d' % b) # 变量a取反结果为：-8
# print('变量c取反的结果为：%d' % d) # 变量c取反的结果为：6
# 题目56：画图，学用circle画圆形。
# if __name__ == '__main__':
# from tkinter import * # 导入tkinter图形界面库的所有组件
#
# canvas = Canvas(width=800, height=600, bg='yellow') # 创建一个800x600像素的画布，背景色为黄色
# canvas.pack(expand=YES, fill=BOTH) # 将画布放置到主窗口中，设置expand和fill参数让画布随窗口大小变化
# k = 1 # 初始化变量k，用于控制圆的半径
# j = 1 # 初始化变量j，用于控制圆的半径增量
# for i in range(0, 26): # 循环26次，绘制26个同心圆
# canvas.create_oval(310-k, 250-k, 310+k, 250+k, width=1) # 左上角坐标(310-k,250-k)，右下角坐标(310+k,250+k),线条宽为1像素
# k += j
# j += 0.5
#
# mainloop() # 启动tkinter的主事件循环，显示GUI窗口
# 题目57：画图，学用line画直线。
# if __name__ == '__main__':
# from tkinter import *
# canvas = Canvas(width=400, height=400, bg='green')
# canvas.pack(expand=YES, fill=BOTH) # 将画布放置到窗口中，允许扩展填充
# x0 = 263
# y0 = 263
# y1 = 275
# for i in range(19):
# canvas.create_line(x0, y0, x0, y1, width=1, fill='red') # 在画布上绘制红色垂直线
# x0 = x0 - 5
# y0 = y0 - 5
# y1 = y1 + 5
# x0 = 263
# y0 = 263
# y1 = 275
# for i in range(21):
# canvas.create_line(x0, y0, x0, y1, fill='red')
# x0 += 5
# y0 += 5
# y1 += 5
#
# mainloop()
# 题目58：画图，学用rectangle画方形。
# 程序分析：
# rectangle(int left, int top, int right, int bottom)
# 参数说明：(left ，top )为矩形的左上坐标，(right,bottom)为矩形的右下坐标，两者可确定一个矩形的大小
# if __name__ == '__main__':
# from tkinter import *
# root = Tk()
# root.title('Canvas')
# canvas = Canvas(root, width=400, height=400, bg='yellow')
# x0 = 263
# y0 = 263
# x1 = 275
# y1 = 275
# for i in range(19):
# canvas.create_rectangle(x0, y0, x1, y1)
# x0 -= 5
# y0 -= 5
# x1 += 5
# y1 += 5
# canvas.pack()
# root.mainloop()
# 题目59：画图，综合例子。
# 程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。。
# if __name__ == '__main__':
# from tkinter import *
# canvas = Canvas(width=300, height=300, bg='green')
# canvas.pack(expand=YES, fill=BOTH)
# # 设置中心点坐标
# x0 = 150
# y0 = 100
# # 绘制三个同心圆(半径10,20,50像素)
# canvas.create_oval(x0-10, y0-10, x0+10, y0+10)
# canvas.create_oval(x0-20, y0-20, x0+20, y0+20)
# canvas.create_oval(x0-50, y0-50, x0+50, y0+50)
# import math
# B = 0.809 # 设置y轴缩放系数
# for i in range(16):
# a = 2 * math.pi / 16 * i # 计算16个等分角度
# x = math.ceil(x0 + 48 * math.cos(a)) # 计算每个角度对应的终点坐标
# y = math.ceil(y0 + 48 * math.sin(a)*B) # 计算每个角度对应的终点坐标
# canvas.create_line(x0, y0, x, y, fill='pink', width=2) # 从中心点绘制16条红色直线
# canvas.create_oval(x0-60, y0-60, x0+60, y0+60) # 绘制大圆(半径60)
#
# for k in range(501):
# for i in range(15):
# a = (2 * math.pi / 16) * i + (2 * math.pi / 180) * k # 计算动态旋转角度(每次增加1度)
# x = math.ceil(x0 + 48 * math.cos(a))
# y = math.ceil((y0 + 48 + math.sin(a)*B))
# canvas.create_line(x0, y0, x, y, fill='red')
# for j in range(50):
# a = (2 * math.pi / 16) * i + (2 * math.pi / 180) * k - 1
# x = math.ceil(x0 + 48 * math.cos(a))
# y = math.ceil((y0 + 48 * math.sin(a) * B))
# canvas.create_line(x0, y0, x, y, fill='yellow')
# mainloop()
# 题目60：计算字符串长度。
# str1 = 'str1len'
# print(len(str1))
# 题目61：打印出杨辉三角形（要求打印出10行如下图）。
# if __name__== '__main__':
# a = [] # 初始化空列表a
# # 创建一个10x10的二维列表，初始值全为0
# for i in range(10):
# a.append([]) # 添加10个空子列表
# for j in range(10):
# a[i].append(0) # 在每个子列表中添加10个0
# for i in range(10):
# a[i][0] = 1 # 每行的第0列设为1
# a[i][i] = 1 # 每行的对角线元素设为1
# for i in range(2, 10): # 从第2行开始
# for j in range(1, i): # 从第1列到第i-1列
# a[i][j] = a[i-1][j-1] + a[i-1][j] # 当前元素等于上方两个元素之和
# from sys import stdout
# for i in range(10):
# for j in range(i+1): # 每行只输出i+1个元素
# stdout.write(str(a[i][j]))
# stdout.write(' ')
# print() # 换行
# 题目62：查找字符串。
# str1 = 'abcdefg'
# str2 = 'cde'
# print(str1.find(str2))
# 题目63：画椭圆。(使用 Tkinter。)
# if __name__ == '__main__':
# from tkinter import *
# x = 360
# y = 160
# top = 130
# bottom = 130
#
# canvas = Canvas(width=400, height=600, bg='white')
# for i in range(20):
# canvas.create_oval(250-top, 250-bottom, 250+top, 250+bottom)
# top -= 5
# bottom += 5
# canvas.pack()
# mainloop()
# 题目64：利用ellipse 和 rectangle 画图。。
# if __name__ == '__main__':
# from tkinter import *
# canvas = Canvas(width=400, height=600, bg='white')
# left = 20
# right = 50
# top = 50
# num = 15
# for i in range(num):
# canvas.create_oval(250-right, 250-left, 250+right, 250+left)
# # canvas.create_oval(250-20, 250-top, 250+20, 250+top)
# canvas.create_rectangle(20-2*i, 20-2*i, 10*(i+2), 10*(i+2))
# right += 5
# left += 5
# top += 5
# canvas.pack()
# mainloop()
# 题目65：一个最优美的图案。
# import math
# from tkinter import *
#
#
# class PTS: # 定义PTS类，用于存储点的x/y坐标
# def __init__(self): # 初始化方法将坐标设为(0,0)
# self.x = 0
# self.y = 0
#
#
# points = [] # 创建全局空列表，用于存储点对象
#
#
# def LineToDemo():
# screenx = 400
# screeny = 400
# canvas =Canvas(width=screenx, height=screeny, bg='white') # 设置画布尺寸
#
# AspectRatio = 0.85 # 设置纵横比
# MAXPTS = 15 # 设置最大点数
# h = screeny
# w = screenx
# xcenter = w / 2
# ycenter = h / 2 # 设置画布中心点坐标
# radius = (h - 30) / (AspectRatio*2) - 20 # 计算圆的半径
# step = 360 / MAXPTS # 计算每个点之间的角度间隔
# angle = 0.0
# for i in range(MAXPTS): # 循环生成15个点
# rads = angle * math.pi / 180.0 # 将角度转为弧度
# p = PTS() # 创建PTS对象
# p.x = xcenter + int(math.cos(rads) * radius)
# p.y = ycenter - int(math.sin(rads) * radius * AspectRatio) # 计算该点在圆周上的x/y坐标(考虑纵横比)
# angle += step # 角度递增
# points.append(p) # 将点存入列表
# canvas.create_oval(xcenter - radius, ycenter - radius, xcenter + radius, ycenter + radius) # 在画布上绘制圆形
# for i in range(MAXPTS): # 双重循环连接所有点（避免重复连线）
# for j in range(i, MAXPTS):
# canvas.create_line(points[i].x, points[i].y, points[j].x, points[j].y) # 每个点与其他所有后续点连线
#
# canvas.pack() # 显示画布
# mainloop() # 进入主事件循环
#
#
# if __name__ == '__main__':
# LineToDemo()
# 题目66：输入3个数a,b,c，按大小顺序输出。
# if __name__ == '__main__':
# n1 = int(input('n1 = : '))
# n2 = int(input('n2 = : '))
# n3 = int(input('n3 = : '))
#
# def swap(p1, p2):
# return p2, p1
#
# if n1 > n2:
# n1, n2 = swap(n1, n2)
# if n1 > n3:
# n1, n3 = swap(n1, n3)
# if n2 > n3:
# n2, n3 = swap(n2, n3)
#
# print(n1, n2, n3)
# 题目67：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
# def inp(numbers):
# for i in range(6):
# numbers.append(int(input('输入一个数字： ')))
#
#
# P = 0 # 定义全局变量
#
#
# def arr_max(array): # 定义查找最大值函数
# max = 0 # 初始化最大值索引为0
# for i in range(1, len(array) - 1): # 遍历数组（跳过第一个和最后一个元素）
# P = i
# if array[P] > array[max]: # 比较最大值索引
# max = P
# k = max
# array[0], array[k] = array[k], array[0]
#
#
# def arr_min(array):
# min = 0
# for i in range(1, len(array) - 1):
# P = i
# if array[P] < array[min]:
# min = P
# l = min
# array[5], array[l] = array[l], array[5]
#
#
# def outp(numbers):
# for i in range(len(numbers)):
# print(numbers[i])
#
#
# if __name__ == '__main__':
# array = [] # 创建空数组
# inp(array) # 调用输入函数获取6个数字
# arr_max(array) # 调用arr_max将最大值移动首位
# arr_min(array) # 调用arr_min将最小值移动到末尾
# print('计算结果是：')
# outp(array)
# 题目68：有 n 个整数，使其前面各数顺序向后移 m 个位置，最后 m 个数变成最前面的 m 个数
# if __name__ == '__main__':
# n = int(input('整数n为： '))
# m = int(input('向后移动m个位置为： '))
#
# def move(array, n, m):
# array_end = array[n-1] # 保存数组最后一个元素
# for i in range(n-1, -1, -1): # 从后向前循环移动元素
# array[i] = array[i-1] # 每个元素向后移动一位
# array[0] = array_end # 将最后一个元素放到首位
# m -= 1 # 移动次数减1
# if m > 0:
# move(array, n, m) # 递归调用直到完成所有移动
#
# numbers = [] # 创建空数组
# for i in range(n):
# numbers.append(int(input('输入一个数字： ')))
# print('原始列表：', numbers)
#
# move(numbers, n, m) # 调用移动函数处理数组
# print('移动之后：', numbers)
# 题目69：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
# if __name__ == '__main__':
# n = int(input('请输入总人数： '))
# num = [] # 创建空列表
# for i in range(n): # 循环n次
# num.append(i+1) # 将1到n的数字存入列表
#
# i = 0 # 当前索引位置
# k = 0 # 报数计数器
# m = 0 # 已淘汰人数计数器
#
# while m < n-1: # 当淘汰人员未达n-1时循环
# if num[i] != 0: # 如果当前位置未被淘汰
# k += 1 # 报数器加1
# if k == 3: # 报到3的人淘汰
# num[i] = 0 # 标记为淘汰
# k = 0 # 重置报数器
# m += 1 # 淘汰人数加1
# i += 1 # 移动到下一个人
# if i == n: # 如果超出列表长度
# i = 0 # 回到列表开头
#
# # 找出最后剩下的人
# i = 0 # 重置索引
# while num[i] == 0: # 跳过已淘汰的人
# i += 1 # 移动到下一个人
# print(num[i]) # 输出最后剩下的人
# 题目70：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
# if __name__ == '__main__':
# str1 = input('请输入字符串： ')
# print('字符串有%d个字符' % len(str1))
# 题目71：编写input()和output()函数输入，输出5个学生的数据记录。
# N = 5
# # stu:
# # num:string name:string score[4]:list
# student = []
# for i in range(5):
# student.append(['', '', []])
#
#
# def input_stu(stu):
# for i in range(N):
# stu[i][0] = input('请输入学生学号： ')
# stu[i][1] = input('请输入学生姓名： ')
# for j in range(3):
# stu[i][2].append(input('分数： '))
#
#
# def output_stu(stu):
# for i in range(N):
# print('%-6s%-10s' % (stu[i][0], stu[i][1]))
# for j in range(3):
# print('%-8s' % stu[i][2][j])
#
#
# if __name__ == '__main__':
# input_stu(student)
# print(student)
# output_stu(student)
# 题目72：创建一个链表。
# if __name__ == '__main__':
# ptr = []
# for i in range(5):
# num = int(input('请输入一个数字：'))
# ptr.append(num)
# print(ptr)
# 题目73：反向输出一个链表。
# if __name__ == '__main__':
# ptr = []
# for i in range(5):
# num = int(input('请输入一个数字：'))
# ptr.append(num)
# print(ptr)
# ptr.reverse()
# print(ptr)
# 题目74：列表排序及连接
# 程序分析：排序可使用 sort() 方法，连接可以使用 + 号或 extend() 方法。
# if __name__ == '__main__':
# a = [1, 3, 2]
# b = [2, 4, 5]
# a.sort() # 对列表a进行排序
# print(a)
#
# # 连接列表a与b
# print("a+b：", a+b)
#
# # 连接列表a与b
# a.extend(b)
# print("extend方法", a)
# 题目75：放松一下，算一道简单的题目。
# if __name__ == '__main__':
# for i in range(5):
# n = 0
# if i != 1: n += 1
# if i == 3: n += 1
# if i == 4: n += 1
# if i != 4: n += 1
# if n == 3: print(64+i)
# 题目76：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/n
# def peven(n):
# i = 0
# s = 0.0
# for i in range(2, n+1, 2): # 从2开始到n，步长为2（所有偶数）
# s += 1.0 / i # 累加每个偶数的倒数;Python 3.x 中的除法运算：/ 除法：总是返回浮点数
# return s
#
#
# def podd(n):
# s = 0.0
# for i in range(1, n+1, 2): # 从1开始到n，步长为2（所有奇数）
# s += 1.0 / i # 累加每个奇数的倒数
# return s
#
#
# # def dcall(fp, n): # 定义高阶函数
# # s = fp(n) # 调用传入的函数fp处理n
# # return s
#
#
# if __name__ == '__main__':
# n = int(input('请输入一个正整数： '))
# if n % 2 == 0: # 判断是否为偶数
# # sum = dcall(peven, n)
# sum = peven(n)
# else:
# # sum = dcall(podd, n)
# sum = podd(n)
# print(sum)
# 题目77：循环输出列表
# if __name__ == '__main__':
# s = ["man", "woman", "girl", "boy", "sister"]
# for i in range(len(s)):
# print(s[i])
# 题目78：找到年龄最大的人，并输出。
# if __name__ == '__main__':
# person = {"li": 18, "wang": 50, "zhang": 20, "sun": 22, "zhao": 60}
# m = 'li'
# for key in person.keys():
# if person[m] < person[key]:
# m = key
# print('%s,%d' % (m, person[m]))
# 题目79：字符串排序。
# if __name__ == '__main__':
# str1 = input('请输入字符串： ')
# str2 = input('请输入字符串： ')
# str3 = input('请输入字符串： ')
# print("排序前：", str1, str2, str3)
#
# # 字符串比较是基于Unicode码点值,冒泡排序算法
# if str1 > str2:
# str1, str2 = str2, str1
# if str1 > str3:
# str1, str3 = str3, str1
# if str2 > str3:
# str2, str3 = str3, str2
#
# print('排序后：', str1, str2, str3)
# *************************不懂*******************************
# 题目80：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
# 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，
# 第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
# if __name__ == '__main__':
# i = 0 # 循环计数器
# j = 1 # 循环尝试次数计数器
# x = 0 # 存储桃子总数
# while i < 5: # 外层循环条件（i<5时继续），控制整个分桃过程需要进行5次（对应5只猴子）
# x = 4 * j # 计算初始x值：每次尝试从4的倍数开始(因为最后要能分成5份剩1)
# for i in range(0, 5): # 循环0-4，模拟5只猴子依次分桃的过程
# if x % 4 != 0: # 检查x是否能被4整除，如果当前桃子数不能整除4，说明不符合分桃规则，跳出
# break # 不能整除则跳出内层循环
# else:
# i += 1 # 成功分桃，计数器增加
# x = (x/4)*5 + 1 # 还原分桃前的数量：除以4是每只猴子拿走的1/5，乘以5是还原拿走前的数量，加1是每次分桃时被扔掉的1个
# j += 1 # 尝试次数增加：当前尝试失败时增加j值继续尝试
# print(x)
# 题目81：809*??=800*??+9*?? 其中??代表的两位数, 809*??为四位数，8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。
# a = 809 # 常量
# for i in range(10, 100): # 循环遍历所有两位数（10到99）
# b = a * i # 计算a与当前数字i的乘积
# if b >= 1000 and b <= 10000 and 8 * i < 100 and 9 *i >= 100: # b是四位数（1000-9999），8*i是两位数（小于100），9*i是三位数（大于等于100）
# print(b, '= 800 * ', i, '+ 9 *', i)
# 题目82：八进制转换为十进制
# if __name__ == '__main__':
# num = 0
# p = input('请输入一个八进制数：')
# for i in range(len(p)): # 遍历输入的八进制字符串的每一位数字，循环次数等于字符串长度
# num = num * 8 + ord(p[i]) - ord('0') # ord(p[i])获取当前字符的ASCII码值，ord('0')获取字符串‘0’的ASCII码值，两者相减得到当前数字的实际数值
# print(num)
# 题目83：求0—7所能组成的奇数个数。
# 程序分析：
# 组成1位数是4个。
# 组成2位数是7*4个。
# 组成3位数是7*8*4个。
# 组成4位数是7*8*8*4个。
# ......
# if __name__ == '__main__':
# sum = 4
# s = 4
# for j in range(2, 9): # 循环变量j从2到8（range(2,9)包含2但不包含9），共循环7次
# print(sum)
# if j <= 2:
# s *= 7
# else: # 循环(j>2)时，s乘以8
# s *= 8
# sum += s
# print('sum = %d' % sum)
# 题目84：连接字符串。
# delimiter = ','
# mylist = ['Brazil', 'Russia', 'India', 'China', 'USA']
# print(delimiter.join(mylist))
# 题目85：输入一个奇数，然后判断最少几个 9 除于该数的结果为整数。
# 程序分析：999999 / 13 = 76923。
# if __name__ == '__main__':
# odd = int(input('输入一个奇数： ')) # 获取用户输入并转为整数
# n1 = 1 # 控制循环的初始标志
# c9 = 1 # 统计9的个数
# m9 = 9 # 当前要加的9
# sum = 9 # 总和初始值（第一个9）
#
# while n1 != 0: # 当n1为0时退出循环
# if sum % odd == 0: # 检查当前总和是否能被odd整除
# n1 = 0
# else: # 不能整除则继续
# m9 *= 10 # m9变为90（下一个要加的9）
# sum += m9 # 将m9加到总和
# c9 += 1 # 统计9的个数增加
# print('%d 个 9 可以被 %d 整除：%d' % (c9, odd, sum))
# r = sum / odd
# print('%d / %d = %d' % (sum, odd, r))
# 题目86：两个字符串连接。
# if __name__ == '__main__':
# a = "acegikm"
# b = "bdfhjlnpq"
#
# # 连接字符串
# c = a + b
# print(c)
# 题目87：结构体变量传递。
# if __name__ == '__main__':
# class student:
# x = 0
# c = 0
# def fun(stu):
# stu.x = 20
# stu.c = 'c'
# a = student()
# a.x = 3
# a.c = 'a'
# fun(a)
# print(a.x, a.c)
# 题目88：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
# if __name__ == '__main__':
# n = 1
# while n <= 7:
# a = int(input('输入一个1—50内的数字：'))
# while a < 1 or a > 50:
# a = int(input('输入一个1—50内的数字：'))
# print(a * '*')
# n += 1
# 题目89：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，
# 加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
# from sys import stdout
# if __name__ == '__main__':
# a = int(input('输入四个数字：'))
# # 提取每位数字
# aa = []
# aa.append(a % 10) # 个位
# aa.append(a % 100 // 10) # 十位
# aa.append(a % 1000 // 100) # 百位
# aa.append(a // 1000) # 千位
# # 加密规则
# for i in range(4):
# aa[i] += 5 # 每位数字都加上5
# aa[i] %= 10 # 然后用和除以10的余数代替该数字
# for i in range(2):
# aa[i], aa[3-i] = aa[3-i], aa[i] # 第一位和第四位交换，第二位和第三位交换
# for i in range(3, -1, -1): # 逆序遍历
# stdout.write(str(aa[i])) # 直接输出到控制台
# 题目90：列表使用实例。
# # 新建列表
# testlist = [10086, '中国移动', [1, 2, 4, 5]]
# # 列表长度
# print(len(testlist))
# # 到列表结尾
# print(testlist[1:])
# # 向列表添加元素
# testlist.append('i\'m new here!')
#
# print(len(testlist))
# print(testlist[-1])
#
# # 弹出列表的一个元素
# print(testlist.pop(1)) # 移除并返回索引1处的元素 '中国移动' 注：pop() 函数用于移除列表中的一个元素，并且返回该元素的值。
# print(len(testlist))
# print(testlist)
#
# # 创建二维矩阵
# matrix = [[1, 2, 3],
# [4, 5, 6],
# [7, 8, 9]]
# print(matrix)
# print(matrix[1]) # 输出第二行
#
# col2 = [row[1] for row in matrix] # 提取第二列元素
# print(col2)
# col2even = [row[1] for row in matrix if row[1] % 2 == 0] # 提取第二列中的偶数元素
# print(col2even)
# 题目91：时间函数举例1
# if __name__ == '__main__':
# import time
# # time.time() 获取当前时间戳（从1970.1.1开始的秒数）
# print(time.ctime(time.time())) # time.ctime() 将时间戳转换为可读字符串，格式如："Wed Aug 20 17:37:04 2025"
# # time.asctime() 将struct_time转换为与ctime相同的字符串格式
# print(time.asctime(time.localtime(time.time()))) # time.localtime() 将时间戳转换为本地时间的struct_time对象
# print(time.asctime(time.gmtime(time.time()))) # time.gmtime() 将时间戳转换为UTC时间的struct_time对象;输出格林威治标准时间
# 题目92：时间函数举例2。
# if __name__ == '__main__':
# import time
# # time.time()获取当前时间戳（从1970.1.1开始的秒数）并赋值给start变量
# start = time.time() # 记录程序开始执行的时刻
# for i in range(3000): # 循环打印0-2999的数字
# print(i)
# end = time.time() # 获取循环结束后的时间戳
# print(end - start)
# 题目93：时间函数举例3。
# if __name__ == '__main__':
# import time
# start = time.perf_counter() # 高精度计时器perf_counter
# for i in range(10000):
# print(i)
# end = time.perf_counter()
# print('different is %6.3f' % (end - start)) # 输出格式化为6字符宽度3位小数
# 题目94：时间函数举例4,一个猜数游戏，判断一个人反应快慢。
# if __name__ == '__main__':
# import time
# import random
#
# play_it = input('do you want to play it.(\'y\' or \'n\'): ')
# while play_it == 'y':
# i = random.randint(0, pow(2, 32)) % 100 # 生成0-99的随机数
# print('please input number you guess: ')
# start = time.perf_counter() # 记录精确开始时间
# guess = int(input('input your guess: '))
# while guess != i: # 循环直到猜中
# if guess > i:
# print('please input a little smaller')
# else:
# print('please input a little bigger')
# guess = int(input('input your guess: ')) # 获取新猜测
# end = time.perf_counter() # 记录精确结束时间
# var = end - start
# print('it take time: ', var)
# # 根据反应时间进行评级
# if var < 15:
# print('you are very clever!')
# elif var < 25:
# print('you are normal!')
# else:
# print('you are stupid')
# print('Congradulations')
# print('The number you guess is %d' % i) # 打印正确的答案
# play_it = input('do you want to play it? ') # 询问是否继续
# 题目95：字符串日期转换为易读的日期格式。
# from dateutil import parser
# dt = parser.parse("Aug 21 2025 3:20PM")
# print(dt)
# 题目96：计算字符串中子串出现的次数。
# if __name__ == '__main__':
# str1 = input('请输入一个字符串： ')
# str2 = input('请输入一个子字符串： ')
# ncount = str1.count(str2)
# print(ncount)
# 题目97：从键盘输入一些字符，逐个把它们写到磁盘文件上，直到输入一个 # 为止。
# if __name__ == '__main__':
# from sys import stdout
# import os.path
# filename = input('输入文件名： ')
# file = os.path.dirname(os.path.abspath(__file__)) + '\\' + filename
# fp = open(file, 'w') # 以写入模式打开指定文件
# ch = input('输入字符串： ')
# while ch != '#':
# fp.write(ch) # 将输入内容写入文件
# stdout.write(ch) # 将输入内容输出到控制台
# ch = input('') # 继续获取用户
# fp.close() # 关闭文件
# 题目98：从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘文件"test"中保存。
# if __name__ == '__main__':
# fp = open(r'C:\Users\admin\PycharmProjects\pythonProject\learn\test.txt', 'w')
# string = input('please input a string: ')
# string = string.upper()
# fp.write(string)
# fp = open(r'C:\Users\admin\PycharmProjects\pythonProject\learn\test.txt', 'r')
# print(fp.read())
# fp.close()
# 题目99：有两个磁盘文件A和B,各存放一行字母,要求把这两个文件中的信息合并(按字母顺序排列), 输出到一个新文件C中。
# if __name__ == '__main__':
# import string
# fp = open(r'C:\Users\admin\PycharmProjects\pythonProject\learn\test1.txt')
# a = fp.read()
# fp.close()
#
# fp = open(r'C:\Users\admin\PycharmProjects\pythonProject\learn\test2.txt')
# b = fp.read()
# fp.close()
#
# fp = open(r'C:\Users\admin\PycharmProjects\pythonProject\learn\test3.txt', 'w')
# l = list(a + b)
# l.sort()
# s = ''
# s = s.join(l)
# fp.write(s)
# fp.close()
题目100：列表转换为字典。
代码：
i = ['a', 'b']
ls = [1, 2]
print(dict([i, ls]))pycharm运行结果：
