《练习100》56~60

题目56

M = 5
a = [1, 2, 3, 4, 5]
i = 1
j = M - 1
while i < M:# print(f"第{i+1}轮交换前：i = {i}, j = {j} , a[{i}] = {a[i]} , a[{j}] = {a[j]}")a[i], a[j] = a[j], a[i]# print(f"第{i+1}轮交换后：i = {i}, j = {j} , a[{i}] = {a[i]} , a[{j}] = {a[j]}")i += 1j -= 1for x in a:print(x, end=" ")
print()# 题目：分析上面的程序的输出结果。
# 分析：
#   一看题目，嗯两个循环变量，一个正向，一个反向，这就是一个倒序，然后就确定结果为[5,4,3,2,1]
# 实际程序运行结果为：[5,4,3,2,1]
# 原因其实很简单：
#   先人为执行一下：
#     当 i = 0， j = 4 的时候，是把第1个元素和最后一个元素交换
#     当 i = 1， j = 3 的时候，是把第2个元素和倒数第二个元素交换
#     当 i = 2， j = 2 的时候，这是同一个元素。 到此a的内容被变成了[5，4，3，2，1]
#     当 i = 3， j = 1 的时候，是把第4个元素和倒数第四个元素交换，注意此时的第四个元素已经在前面被换成了2，倒数第四个是4，一交换就变成了最初的样子了
#     当 i = 4， j = 0 的时候，是把第5个元素和最后一个元素交换，此时的第五个元素被换成了最初的第一个，再次交换后，第一个元素还是最初的第一个# 这个题就是在告诉我们，当我们实现倒序的时候，执行次数只需是长度的一半就行了。
a = [1, 2, 3, 4, 5]def my_reverse1(nums: list):print(f"{my_reverse1.__name__}--输入:{nums}")# list.reverse() # 就地逆序，逆序后的内容替代原有内容nums.reverse()   # 这里使用return，list是可变对象（有关可变对象的后续专门写一篇，网上博文也很多，可自行查看）print(f"{my_reverse1.__name__}--逆序后：{nums}")def my_reverse2(nums: list):print(f"{my_reverse2.__name__}--输入:{nums}")# reversed返回以后逆序后的iter# list() 可以将一个iter变成一个listtmp = list(reversed(nums))print(f"{my_reverse2.__name__}--逆序后：{tmp}")return tmpdef my_reverse(nums: list):# 利用负的index代表倒数这个特性print(f"{my_reverse.__name__}--输入:{nums}")for i in range(len(nums)//2):  # //才是地板除法nums[i], nums[-i-1] = nums[-1-i], nums[i]print(f"{my_reverse.__name__}--逆序后：{nums}")def my_reverse3(nums: list):print(f"{my_reverse3.__name__}--输入:{nums}")j = len(nums) - 1# 吸取题目中的经验，逆序时只执行长度一半的次数for i in range(len(nums)//2):  # //才是地板除法nums[i], nums[j] = nums[j], nums[i]j -= 1print(f"{my_reverse3.__name__}--逆序后：{nums}")# 递归实现
tmp = []
def my_reverse4(nums: list):print(f"{my_reverse4.__name__}--输入:{nums}")if not len(nums):print(f"{my_reverse4.__name__}--逆序后:{tmp}")return Nonetmp.append(nums[-1])nums = nums[:-1]my_reverse4(nums)b = [1, 2, 3, 4, 5, 6]
my_reverse(a)
my_reverse(b)
my_reverse1(a)
my_reverse2(a)
my_reverse3(a)
my_reverse3(b)
my_reverse4(b)# 1 2 3 4 5
# my_reverse--输入:[1, 2, 3, 4, 5]
# my_reverse--逆序后：[5, 4, 3, 2, 1]
# my_reverse--输入:[1, 2, 3, 4, 5, 6]
# my_reverse--逆序后：[6, 5, 4, 3, 2, 1]
# my_reverse1--输入:[5, 4, 3, 2, 1]
# my_reverse1--逆序后：[1, 2, 3, 4, 5]
# my_reverse2--输入:[1, 2, 3, 4, 5]
# my_reverse2--逆序后：[5, 4, 3, 2, 1]
# my_reverse3--输入:[1, 2, 3, 4, 5]
# my_reverse3--逆序后：[5, 4, 3, 2, 1]
# my_reverse3--输入:[6, 5, 4, 3, 2, 1]
# my_reverse3--逆序后：[1, 2, 3, 4, 5, 6]
# my_reverse4--输入:[1, 2, 3, 4, 5, 6]
# my_reverse4--输入:[1, 2, 3, 4, 5]
# my_reverse4--输入:[1, 2, 3, 4]
# my_reverse4--输入:[1, 2, 3]
# my_reverse4--输入:[1, 2]
# my_reverse4--输入:[1]
# my_reverse4--输入:[]
# my_reverse4--逆序后:[6, 5, 4, 3, 2, 1]

题目57

题目57讲述的是time模块

题目58讲述的是datetime模块

题目59讲述的是calender模块

%a	本地化的缩写星期中每日的名称。
%A	本地化的星期中每日的完整名称。
%b	本地化的月缩写名称。
%B	本地化的月完整名称。
%c	本地化的适当日期和时间表示。
%d	十进制数 [01,31] 表示的月中日。
%H	十进制数 [00,23] 表示的小时（24小时制）。
%I	十进制数 [01,12] 表示的小时（12小时制）。
%j	十进制数 [001,366] 表示的年中日。
%m	十进制数 [01,12] 表示的月。
%M	十进制数 [00,59] 表示的分钟。
%p	本地化的 AM 或 PM 。	(1)
%S	十进制数 [00,61] 表示的秒。	(2)
%U	十进制数 [00,53] 表示的一年中的周数（星期日作为一周的第一天）。 在第一个星期日之前的新年中的所有日子都被认为是在第 0 周。	(3)
%w	十进制数 [0(星期日),6] 表示的周中日。
%W	十进制数 [00,53] 表示的一年中的周数（星期一作为一周的第一天）。 在第一个星期一之前的新年中的所有日子被认为是在第 0 周。	(3)
%x	本地化的适当日期表示。
%X	本地化的适当时间表示。
%y	十进制数 [00,99] 表示的没有世纪的年份。
%Y	十进制数表示的带世纪的年份。
%z	时区偏移以格式 +HHMM 或 -HHMM 形式的 UTC/GMT 的正或负时差指示，其中H表示十进制小时数字，M表示小数分钟数字 [-23:59, +23:59] 。1
%Z	时区名称（如果不存在时区，则不包含字符）。已弃用。 [1]
%%	字面的 '%' 字符。

注释：

1. 当与 strptime()函数一起使用时，如果使用 %I指令来解析小时，%p` 指令只影响输出小时字段。

2. 范围真的是 0 到 61 ；值 60 在表示 leap seconds的时间戳中有效，并且由于历史原因支持值 61 。

3. 当与 strptime()函数一起使用时， %U 和 %W 仅用于指定星期几和年份的计算。

   # 时间模块 time
   # 时间模块提供了各种与时间相关的函数： 还有另外两个模块（datatime, calender）也提供了大量时间相关的函数# 产生时间 gmtime, localtime,strptime
   # 基础知识点：
   # 1.时间计时的开始点为：1970-01-01 00:00:00
   # 2.UTC是协调世界时
   import time as T# 返回秒数
   my_time = T.time()
   print(type(my_time))
   print(my_time)
   # 返回一个日期时间元组
   # 以下两个方法都有两个功能：1：将给定的描述转换为时间结构体 2：若无给定秒数，返回当前时间的时间元组
   my_time = T.gmtime()
   print(type(my_time))
   print(my_time)
   my_time = T.localtime()
   print(type(my_time))
   print(my_time)# 从字符串中解析出时间结构体(需要记住常用的年月日时分秒格式符)
   my_time = T.strptime('2043-08-18 20:02:00','%Y-%m-%d %H:%M:%S')
   print(type(my_time))
   print(my_time)# time.strftime(format[, t])
   # 转换一个元组或 struct_time 表示的由 gmtime() 或 localtime() 返回的时间到由 format 参数指定的字符串。
   # 如果未提供 t ，则使用由 localtime() 返回的当前时间。 format 必须是一个字符串。
   # 如果 t 中的任何字段超出允许范围，则引发 ValueError 。
   print(T.strftime('%Y-%m-%d %H:%M:%S'))
   print(T.strftime('%Y-%m-%d %H:%M:%S', T.strptime('2043-08-18 20:02:00','%Y-%m-%d %H:%M:%S')))
   # 将一个时间结构体转换为'Sun Jun 20 23:21:05 1993'格式的字符串，如果没有参数，那么就将当前时间转换为字符串
   my_time = T.asctime(T.strptime('2043-08-18 20:02:00','%Y-%m-%d %H:%M:%S'))
   print(type(my_time))
   print(my_time)
   my_time = T.asctime()
   print(type(my_time))
   print(my_time)# 将一个秒数转换为'Sun Jun 20 23:21:05 1993'格式的字符串，如果没有参数，通过time()获取当前的秒数，然后转换为字符串返回
   my_time = T.ctime(160000000.1232345)
   print(type(my_time))
   print(my_time)
   my_time = T.ctime()
   print(type(my_time))
   print(my_time)# time.mktime(t)
   # 这是 localtime() 的反函数。它的参数是 struct_time 或者完整的 9 元组（因为需要 dst 标志；
   # 如果它是未知的则使用 -1 作为dst标志），它表示 local 的时间，而不是 UTC 。它返回一个浮点数，
   # 以便与 time() 兼容。如果输入值不能表示为有效时间，则 OverflowError 或 ValueError 将被引发（这取决于Python或底层C库是否捕获到无效值）。
   # 它可以生成时间的最早日期取决于平台。
   my_time = T.mktime(T.localtime())
   print(type(my_time))
   print(my_time)# 完整的9元组，看之前的输出即可知道
   # 若何获取完整的9元组
   # 1.将年月日时分秒 转换为时间结构体，然后print输出
   print(T.strptime('1999-08-18 20:02:00','%Y-%m-%d %H:%M:%S'))
   # time.struct_time(tm_year=1999, tm_mon=8, tm_mday=18, tm_hour=20, tm_min=2, tm_sec=0, tm_wday=2, tm_yday=230, tm_isdst=-1)
   my_time = T.mktime((1999,8,18,20,2,0,2,230,-1))
   print(type(my_time))
   print(my_time)# time.sleep([secs])
   # 如其名，Suspend execution of the calling thread for the given number of seconds. 
   cur = T.time()
   print("现在准备开始sleep,当前时间：", cur)
   T.sleep(5.444)
   cur1 = T.time()
   print('已经醒来，当前时间：',cur1)
   print(f'睡了大概{cur1 - cur}s')
   T.sleep(3)
   cur2 = T.time()
   print('已经醒来，当前时间：',cur1)
   print(f'睡了大概{cur2 - cur1:.5f}s')# 补充说明：time模块还有很多方法。这里只写了我感觉能经常用得上的(个人看法，不喜勿喷)。
   

题目58

# datetime 模块提供用于处理日期和时间的类。
# 在支持日期时间数学运算的同时，实现的关注点更着重于如何能够更有效地解析其属性用于格式化输出和数据操作。
import datetime# 提供了6个类:date,time,datetime,timedelta,tzinfo,timezone
print(datetime.date)
print(datetime.time)
print(datetime.datetime)
print(datetime.timedelta)
print(datetime.timezone)
print(datetime.tzinfo)# date 对象
#date 对象代表一个理想化历法中的日期（年、月和日），即当今的格列高利历向前后两个方向无限延伸。# 获取日期
# today()
# 返回当前的本地日期。
print(datetime.date.today())# datetime.date(year, month,day)
# 所有参数都是必要的。 参数必须是在下面范围内的整数：
my_date = datetime.date(2025, 11,11)print(my_date.year,my_date.month, my_date.day)# datetime.date.fromtimestamp(timestamp)
# 返回对应于 POSIX 时间戳的当地时间，例如 time.time() 返回的就是时间戳。
# 可不可以理解成输入一个秒数，然后将时间转换为年-月-日？？？？
print(datetime.date.fromtimestamp(5645646154))# classmethod date.fromordinal(ordinal)
# 返回对应于预期格列高利历序号的日期，其中公元 1 年 1 月 1 日的序号为 1。
# 其实就是输入总的天数，然后这个函数给你生成一个年-月-日格式的日期
print(datetime.date.fromordinal(365000 *2 + 1000))# classmethod date.fromisoformat(date_string)
# Return a date corresponding to a date_string given in any valid ISO 8601 format, except ordinal dates (e.g. YYYY-DDD):
# 将一个符合ISO 8601格式的日期字符串，转换成日期？？？（有啥用？？）
print(datetime.date.fromisoformat('20080808'))
print(datetime.date.fromisoformat('2023-W01-1')) # 2023第一个周的第一天？？？ 看了日历是这个
print(datetime.date.fromisoformat('2008-08-08'))# date.fromisocalendar(year, week, day)
# 返回指定 year, week 和 day 所对应 ISO 历法日期的 date。 这是函数 date.isocalendar() 的逆操作。
# 这里的day指的是一周中的第几天，范围是1~7（周一是第一天）
print(datetime.date.fromisocalendar(2023,2,1))# date.replace(year=self.year, month=self.month, day=self.day)
# 返回一个具有同样值的日期，除非通过任何关键字参数给出了某些形参的新值。
print(my_date.replace(day=30))# date.timetuple()
# 返回一个 time.struct_time，即 time.localtime() 所返回的类型。
# hours, minutes 和 seconds 值均为 0，且 DST 旗标值为 -1。
print(my_date.timetuple())# date.toordinal()
# 返回日期的预期格列高利历序号，其中公元 1 年 1 月 1 日的序号为 1。 对于任意 date 对象 d，date.fromordinal(d.toordinal()) == d。
print(my_date.toordinal())# date.weekday()
# 返回一个整数代表星期几，星期一为0，星期天为6。例如， date(2002, 12, 4).weekday() == 2，表示的是星期三。参阅 isoweekday()。
print(my_date.weekday())# date.isoweekday()
# 返回一个整数代表星期几，星期一为1，星期天为7。例如：date(2002, 12, 4).isoweekday() == 3,表示星期三。参见 weekday(), isocalendar()。
print(my_date.isoweekday())# date.isocalendar()
# 返回一个由三部分组成的 named tuple 对象: year, week 和 weekday。
print(my_date.isocalendar())# date.isoformat()
# 返回一个以 ISO 8601 格式 YYYY-MM-DD 来表示日期的字符串:
print(my_date.isoformat())# date.ctime()
# 返回一个表示日期的字符串
print(my_date.ctime())# date.strftime(format)
# Return a string representing the date, controlled by an explicit format string.
print(my_date.strftime('%Y-%m-%d %H:%M:%S'))

# datetime对象
# datetime 对象是包含来自 date 对象和 time 对象的所有信息的单一对象。
import datetime
# 也可以这样导入模块
# from datetime import datetime
# datetime的构造函数：datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)
# 前三个是必须的，后面的以后用到再说吧
my_datetime = datetime.datetime(2025,11,11)# datetime 对象获取是时间的三种方法：
# 1: 通过datetime.today()获取,通过实例和通过类都一样
print(my_datetime.today())
print(datetime.datetime.today())# 2. 通过now(tz=None) 返回表示当前地方时的 date 和 time 对象。
print(datetime.datetime.now())
print(datetime.datetime.now(datetime.timezone.utc)) # 这个是建议使用的# 3.通过utcnow() 返回的是当前 UTC 日期和时间
print(datetime.datetime.utcnow())# 时间格式转换
# datetime.fromtimestamp(timestamp, tz=None) # 这个是建议使用的方法
# datetime.utcfromtimestamp(timestamp)print(my_datetime.date())
print(my_datetime.time())

题目59

import  calendarmy_calender = calendar.Calendar()# iterweekdays 返回一个迭代器，迭代器的内容为一星期的数字
for i in my_calender.iterweekdays():print(i)# itermonthdates(year, month)
# 返回一个迭代器，迭代器的内容为 year 年 month 月(1-12)的日期。
# 这个迭代器返回当月的所有日期 ( datetime.date 对象)，日期包含了本月头尾用于组成完整一周的日期。
# 打印出来的日期中可能会存在上一个月或下一月的日期。
for weeks, i in enumerate(my_calender.itermonthdates(2023,8)):if not weeks % 7:print()print(i, end=' ')# itermonthdays(year, month)
# 返回一个迭代器，迭代器的内容与 itermonthdates() 类似，为 year 年 month 月的日期，但不受 datetime.date 范围限制。
# 返回的日期为当月每一天的日期对应的天数。对于不在当月的日期，显示为 0
for weeks, i in enumerate(my_calender.itermonthdays(2023,8)):if not weeks % 7:print()print(f"{i:02d}", end=' ')# itermonthdays2(year, month)
# 返回一个迭代器，迭代器的内容与 itermonthdates() 类似为 year 年 month 月的日期，但不受 datetime.date 范围的限制。
# 迭代器中的元素为一个由日期和代表星期几的数字组成的的元组。
for weeks, i in enumerate(my_calender.itermonthdays2(2023,8)):if not weeks % 7:print()print(f"{i}", end=' ')# itermonthdays3(year, month)
# 返回一个迭代器，迭代器的内容与 itermonthdates() 类似为 year 年 month 月的日期，但不受 datetime.date 范围的限制。
# 迭代器的元素为一个由年，月，日组成的元组。
for weeks, i in enumerate(my_calender.itermonthdays3(2023,8)):if not weeks % 7:print()print(f"{i}", end=' ')# itermonthdays4(year, month)
# 返回一个迭代器，迭代器的内容与 itermonthdates() 类似为 year 年 month 月的日期，但不受 datetime.date 范围的限制。
# 迭代器的元素为一个由年，月，日和代表星期几的数字组成的元组。
for weeks, i in enumerate(my_calender.itermonthdays4(2023,8)):if not weeks % 7:print()print(f"{i}", end=' ')
print()# monthdatescalendar(year, month)
# 返回一个表示指定年月的周列表。周列表由七个 datetime.date 对象组成。
print(my_calender.monthdatescalendar(2023,8))# monthdays2calendar(year, month)
# 返回一个表示指定年月的周列表。周列表由七个代表日期的数字和代表周几的数字组成的二元元组。
print(my_calender.monthdays2calendar(2023,8))# monthdayscalendar(year, month)
# 返回一个表示指定年月的周列表。周列表由七个代表日期的数字组成。
print(my_calender.monthdayscalendar(2023,8))# yeardatescalendar(year, width=3)
# 返回可以用来格式化的指定年月的数据。返回的值是一个列表，列表是月份组成的行。每一行包含了最多 width 个月(默认为3)。
# 每个月包含了4到6周，每周包含1--7天。每一天使用 datetime.date 对象。
print(my_calender.yeardatescalendar(2023))# yeardays2calendar(year, width=3)
# 返回可以用来模式化的指定年月的数据(与 yeardatescalendar() 类似)。周列表的元素是由表示日期的数字和表示星期几的数字组成的元组。
# 不在这个月的日子为0。
print(my_calender.yeardays2calendar(2023))
# yeardayscalendar(year, width=3)
# 返回可以用来模式化的指定年月的数据(与 yeardatescalendar() 类似)。周列表的元素是表示日期的数字。不在这个月的日子为0。
# 年：[[1月],[2月]...]
# 月：[[第一周],[第二周]]
# 周：[周1,...周日]  不在这个月的日子为0。
print(my_calender.yeardayscalendar(2023))# TextCalendar 用于生成一个日历文本（就是一个多行字符串）
my_textcalendar = calendar.TextCalendar()# 生成一个月的日历有两种方法formatmonth 和prmonth
print(my_textcalendar.formatmonth(2023,8)) # 其实有其它参数，这样生成的日历感觉可以，其它参数就不说了
print(my_textcalendar.prmonth(2023,8))# 生成一年的日历也有两种方法 formatyear 和 pryear
print(my_textcalendar.formatyear(2023)) # 其实有其它参数，这样生成的日历感觉可以，其它参数就不说了
print(my_textcalendar.pryear(2023))# 还可以生成HTML 类名是HTMLCalendar# calendar模块还提供了一些其它的方法，以下是我觉得有意思的
# 判断是否是闰年的isleap
if calendar.isleap(2023):print("2023 是闰年")
else:print("2023 不是闰年")
# 判断年份之间有几个闰年的leapdays
print(calendar.leapdays(1999,2023))
# 判断某一天是星期几的 weekday (0是周一)
print(calendar.weekday(2023,8,8))

题目60

# 猜数游戏：随机生成一个数字（0~9），如果键盘输入的数字比该数字小，那么告知用户，请输入大一点的数字，反之则告知用户输入小一点。
# 用户猜中后，告知用户一共输入了几次，总耗时是多少秒（精确到小数点后3位）import random
import timenum = -1
isstart = False
time_start = 0
time_end = 0
times = 0
while True:try:key = ''if not isstart:key = str(input("是否开始游戏，请输入Y/N: "))match(key):case 'Y'|'y':isstart = Truecase 'N'|'n':print("不玩，就算了！！！")breakcase _:raise TypeError('请输入Yy/Nn!!!')    if isstart and num == -1:time_start = time.time()num = random.randint(0,9)key = int(input("请输入一个数字: "))if key == num:time_end = time.time()print(f'可以啊，居然猜中了,你一共猜了{times + 1}次，耗时{time_end - time_start:.3f}秒')isstart = Falsetimes = 0num = -1else:times += 1if key > num:raise TypeError('能不能输入小一点的数字？？？？')else:raise TypeError('能不能输入大一点的数字？？？？')except ValueError as ve:print("请输入一个数字！！！！！！")except TypeError as te:print(te)