Python程序笔记20230306

谈心

判断闰年

初始版本

1. year = input('请输入一个年份：')
3. while not year.isdigit():
4.     year = input("抱歉，您的输入有误，请输入一个整数：")
6. year = int(year)
7. if year % 400 == 0:
8.     print(year, "是闰年！")
9. else:
10.     if year % 4 == 0 and year % 100 != 0:
11.         print(year, "是闰年！")
12.     else:
13.         print(year, "不是闰年！")

复制代码

isdigit()函数

isdigit() 是 Python 字符串对象的方法，用于判断字符串是否只包含数字字符。该方法返回一个布尔值，如果字符串中所有字符都是数字，则返回 True，否则返回 False。如果字符串为空，则返回 False。

1. my_string = "12345"
2. print(my_string.isdigit()) # 输出 True
4. my_string = "123abc"
5. print(my_string.isdigit()) # 输出 False
7. my_string = ""
8. print(my_string.isdigit()) # 输出 False

复制代码

在实际编程中，可以使用 isdigit() 来检查输入的是否是数字，以确保输入的是有效数据。例如，在一个需要输入数字的程序中，可以使用 isdigit() 来验证用户的输入是否为数字，如果不是，则提示用户重新输入。
优化版本

将判断闰年的逻辑封装到一个函数中，这样使得程序结构更加清晰。另外，对于输入的异常处理，可以考虑添加一个循环让用户在输入错误时可以重新输入，而不是只提示一次。这是一个修改后的版本：

1. def is_leap_year(year: int) -> bool:
2.     if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
3.         return True
4.     return False
7. def get_year_input(prompt: str) -> int:
8.     while True:
9.         year = input(prompt)
10.         if year.isdigit():
11.             return int(year)
12.         else:
13.             print("抱歉，您的输入有误，请输入一个正整数。")
16. def main():
17.     year = get_year_input("请输入一个年份：")
18.     if is_leap_year(year):
19.         print(year, "是闰年！")
20.     else:
21.         print(year, "不是闰年！")
24. if __name__ == "__main__":
25.     main()

复制代码

语法分析

def is_leap_year(year: int) -> bool

• year: int 是一个类型提示注释，用于告诉程序员和解释器该函数的参数 year 应该是一个整数类型。
  
• -> 的语法是一种函数注解（function annotation），它可以用来为函数的参数和返回值添加一些元数据，比如类型、描述等。函数注解是可选的，它不会影响函数的执行，也不会强制类型检查，它只是提供了一些额外的信息，方便阅读和理解代码。你可以使用 __annotations__ 属性来访问函数的注解。例如：
  

1. # 定义一个带有注解的函数
2. def is_leap_year(year: int) -> bool:
3.     if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
4.         return True
5.     return False
7. # 查看函数的注解
8. print(is_leap_year.__annotations__)

复制代码

输出结果：

1. {'year': <class 'int'>, 'return': <class 'bool'>}

复制代码

这个例子中，-> bool 表示这个函数的返回值是一个布尔值，year: int 表示这个函数的参数 year 是一个整数。这样，其他人在阅读或调用这个函数时，就可以清楚地知道这个函数的输入和输出类型。当然，你也可以使用其他类型或表达式作为注解，比如字符串、列表、字典等，只要它们是合法的 python 表达式即可。你也可以使用 typing 模块中的一些特殊类型来表示更复杂的类型，比如 Union、Optional、List 等。
Python 安装交互式查询程序

问题展现

Python 历史上有几个重要的版本节点：

• January 1994，Python1.0 发布
  
• 2000年10月16日，Python2.0 发布
  
• 2010年7月3日，Python2.7 发布，这是Python2.x的最后一个版本，Python2.x 和 Python3.x不兼容
  
• 2008年12月3日，Python3.0 发布，Python3引入多个和Python2.x不兼容的特性，Python 从2.x到3.x的迁移经历了比较长的时间，编程语言版本不兼容有时候会是个致命错误（例如Perl6），好在Python挺过来了。
  
• 2021年10月5号，Python3.10 发布，这是目前到2021年为止最新的版本
  
• 而最新的开发中版本是 Python3.11
  

不同平台对Python环境的默认支持是不同的：

• Windows 平台没有默认安装 Python
  
• Linux/Mac 平台大部分默认安装了 Python2.7
  

一般建议安装Python3.x 版本进行学习或开发。下面的Python字典给出了不同平台的安装信息：

1. install = {
2.     "Windows": "请下载 Windows 安装包安装：https://www.python.org/downloads/windows/",
3.     "CentOS": "使用yum包管理器，执行命令：yum install -y python3",
4.     "Ubuntu": "使用apt-get包管理器，执行命令：apt-get install -y python3",
5.     "MacOS": "安装brew包管理器，然后执行命令： brew install python3",
6. }

复制代码

基于这个信息，我们可以编写一个交互式Python程序，要求支持用户操作：

• 反复输入平台快捷键字符查询不同平台应该如何快速安装 Python3.x 版本
  
• 按q退出查询
  

1. if __name__ == '__main__':
2.     install = {
3.         "Windows": "请下载 Windows 安装包安装：https://www.python.org/downloads/windows/",
4.         "CentOS": "使用yum包管理器，执行命令：yum install -y python3",
5.         "Ubuntu": "使用apt-get包管理器，执行命令：apt-get install -y python3",
6.         "MacOS": "安装brew包管理器，然后执行命令： brew install python3",
7.     }
9.     shortcut_keys = {}
10.     for platform in install:
11.         key = platform[0].lower()
12.         shortcut_keys[key] = platform
13.    
14.     # TODO(You): 请在此添加Python3.x安装文档交互式查询代码

复制代码

以下是交互式执行的操作样例:

1. 请选择安装平台[w/c/u/m, 按q退出]：w
2. Windows: 请下载 Windows 安装包安装：https://www.python.org/downloads/windows/
3. 请选择安装平台[w/c/u/m, 按q退出]：c
4. CentOS: 使用yum包管理器，执行命令：yum install -y python3
5. 请选择安装平台[w/c/u/m, 按q退出]：u
6. Ubuntu: 使用apt-get包管理器，执行命令：apt-get install -y python3
7. 请选择安装平台[w/c/u/m, 按q退出]：m
8. MacOS: 安装brew包管理器，然后执行命令： brew install python3
9. 请选择安装平台[w/c/u/m, 按q退出]：q

复制代码

解决方案

方案 1

1. while True:
2.     ret = input("请选择安装平台[w/c/u/m, 按q退出]：")
3.     if ret != 'q':
4.         platform = shortcut_keys.get(ret)
5.         if platform is not None:
6.             doc = install.get(platform)
7.             print(f"{platform}: {doc}")
8.         else:
9.             print("不支持的平台")
10.     else:
11.         break

复制代码

方案 2

1. while True:
2.     ret = input("请选择安装平台[w/c/u/m, 按q退出]：")
3.     platform = shortcut_keys.get(ret)
5.     if ret == 'q':
6.         break
7.    
8.     if platform is None:
9.         print("不支持的平台")
10.         continue
11.    
12.     doc = install.get(platform)
13.     print(f"{platform}: {doc}")

复制代码

方案 3

1. while True:
2.     ret = input("请选择安装平台[w/c/u/m, 按q退出]：")
3.     if ret == 'q':
4.         break
5.     platform = shortcut_keys.get(ret)
6.     if platform is None:
7.         print("不支持的平台")
8.     else:
9.         doc = install.get(platform)
10.         print(f"{platform}: {doc}")

复制代码

重点语法分析

1. shortcut_keys = {}
2. for platform in install:
3.     key = platform[0].lower()
4.     shortcut_keys[key] = platform

复制代码

1. shortcut_keys = {platform[0].lower(): platform for platform in install}

复制代码

两段代码的目的都是根据 install 字典创建一个新的 shortcut_keys 字典，键是平台名字的首字母的小写形式，值是完整的平台名字。
第一段代码：使用了一个 for 循环来遍历 install 字典的键（即平台名字）。对于每个平台名字，它首先提取平台名字的第一个字符（platform[0]），然后将其转换为小写形式（platform[0].lower()），并将其作为新字典 shortcut_keys 的键。接着，它将完整的平台名字作为键对应的值。这样，我们就得到了一个与 install 字典具有相同值但键不同的新字典。
在这一段 python 语句中，shortcut_keys = {} 用的是大括号{}，是因为 shortcut_keys 是一个字典(dictionary)。字典是一种用来存储键值对(key-value pairs)的数据结构，它们用大括号{}来表示。字典的键(key)可以是任何不可变的类型，比如字符串、数字或元组，而值(value)可以是任何类型，比如列表、函数或对象。字典的元素可以通过键来访问，而不是通过索引(index)。例如，shortcut_keys[‘i’] 会返回 install  这个值。
第二段代码：这段代码使用了字典推导（dictionary comprehension），它是一种更简洁的创建字典的方法。字典推导的语法类似于列表推导，但使用大括号 {}（而不是方括号 []），并在其内部包含键值对（而不是单个元素）。
字典推导的基本结构是：{key_expression: value_expression for item in iterable}
在这个例子中，key_expression 是 platform[0].lower()，value_expression 是 platform，iterable 是 install。这个字典推导的含义是：对于 install 字典的每个键（即平台名字 platform），创建一个键值对，键是 platform[0].lower()，值是 platform。这样，我们得到了与第一段代码相同的结果。
优化结果

1. if __name__ == '__main__':
2.     install = {
3.         "Windows": "请下载 Windows 安装包安装：https://www.python.org/downloads/windows/",
4.         "CentOS": "使用yum包管理器，执行命令：yum install -y python3",
5.         "Ubuntu": "使用apt-get包管理器，执行命令：apt-get install -y python3",
6.         "MacOS": "安装brew包管理器，然后执行命令： brew install python3",
7.     }
9.     shortcut_keys = {platform[0].lower(): platform for platform in install}
11.     while True:
12.         platform_input = input("请选择安装平台[w/c/u/m, 按q退出]：")
13.         if platform_input.lower() == 'q':
14.             break
16.         platform = shortcut_keys.get(platform_input.lower())
17.         if platform:
18.             print(f"{platform}: {install[platform]}")
19.         else:
20.             print("输入有误，请重新输入。")

复制代码

可以考虑将用户输入和指令显示的功能封装到函数中，以提高代码的可读性。

1. def display_install_instructions(install_dict, shortcut_keys):
2.     while True:
3.         platform_input = input("请选择安装平台[w/c/u/m, 按q退出]：")
4.         if platform_input.lower() == 'q':
5.             break
7.         platform = shortcut_keys.get(platform_input.lower())
8.         if platform:
9.             print(f"{platform}: {install_dict[platform]}")
10.         else:
11.             print("输入有误，请重新输入。")
14. if __name__ == "__main__":
15.     install = {
16.         "Windows": "请下载 Windows 安装包安装：https://www.python.org/downloads/windows/",
17.         "CentOS": "使用yum包管理器，执行命令：yum install -y python3",
18.         "Ubuntu": "使用apt-get包管理器，执行命令：apt-get install -y python3",
19.         "MacOS": "安装brew包管理器，然后执行命令： brew install python3",
20.     }
22.     shortcut_keys = {platform[0].lower(): platform for platform in install}
23.     display_install_instructions(install, shortcut_keys)

复制代码

字典和列表

字典（dictionary）和列表（list）都是 Python 中常用的数据结构，但它们之间存在一些关键的区别：

• 键值对 vs. 有序元素集合：
  
  
  
  • 字典是一个基于键值对（key-value pair）的无序集合。在字典中，每个元素都有一个唯一的键（key）与之对应。字典中的元素通过键来访问，而不是通过索引。
    
  • 列表是一个有序的元素集合。列表中的元素可以通过索引访问，索引从 0 开始，按元素在列表中的顺序递增。
    
  
  
• 可变性：
  
  
  
  • 字典和列表都是可变的（mutable），这意味着它们的内容可以在运行时修改。
    
  
  
• 查找速度：
  
  
  
  • 字典使用散列（hashing）技术，因此在查找特定键时，字典的查找速度通常非常快。字典的查找速度与字典的大小无关。
    
  • 列表查找元素的速度通常较慢，尤其是在大型列表中。列表的查找速度取决于列表的大小。
    
  
  
• 语法：
  
  
  
  • 字典使用大括号 {} 来创建，每个元素由键和值组成，键值对之间用冒号 : 分隔，元素之间用逗号 , 分隔。例如：{'key1': 'value1', 'key2': 'value2'}。
    
  • 列表使用方括号 [] 来创建，元素之间用逗号 , 分隔。例如：[1, 2, 3, 4]。
    
  
  

常用的列表（list）和字典（dictionary）的操作方法：
列表（list）操作

• 创建列表：
  my_list = [1, 2, 3, 4]
  
• 访问列表元素：
  first_element = my_list[0] second_element = my_list[1]
  
• 修改列表元素：
  my_list[0] = 10 my_list[1] = 20
  
• 添加元素到列表末尾：
  my_list.append(5)
  
• 在列表指定位置插入元素：
  my_list.insert(1, 1.5)
  
• 从列表中删除元素（通过索引）：
  del my_list[0]
  
• 从列表中删除元素（通过值）：
  my_list.remove(2)
  
• 弹出列表中的最后一个元素：
  last_element = my_list.pop()
  
• 弹出列表中的指定位置的元素：
  second_element = my_list.pop(1)
  
• 列表切片（截取列表的一部分）：
  sublist = my_list[1:3]
  
• 列表排序（从小到大）：
  my_list.sort()
  
• 列表反转：
  my_list.reverse()
  
• 计算列表中元素的个数：
  length = len(my_list)
  
• 计算列表中特定元素出现的次数：
  count = my_list.count(2)
  
• 查找列表中特定元素的索引（如果元素不存在，会抛出异常）：
  index = my_list.index(3)
  
• 列表拼接：
  list1 = [1, 2, 3] list2 = [4, 5, 6] combined_list = list1 + list2
  
• 列表复制：
  copied_list = my_list.copy()
  
• 清空列表：
  my_list.clear()
  

字典（dictionary）操作

• 创建字典：
  my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
  
• 访问字典元素：
  value1 = my_dict['key1']
  value2 = my_dict['key2']
  
• 修改字典元素：
  my_dict['key1'] = 'new_value1'
  my_dict['key2'] = 'new_value2'
  
• 添加新的键值对到字典：
  my_dict['key4'] = 'value4'
  
• 从字典中删除键值对：
  del my_dict['key1']
  
• 检查字典中是否存在某个键：
  if 'key1' in my_dict:     print("Key 'key1' exists in the dictionary.")
  
• 获取字典中所有的键：
  keys = my_dict.keys()
  
• 获取字典中所有的值：
  values = my_dict.values()
  
• 获取字典中所有的键值对（元组形式）：
  items = my_dict.items()
  
• 使用get()方法访问字典元素（如果键不存在，返回默认值）：
  value1 = my_dict.get('key1', 'default_value')
  
• 使用 update() 方法将另一个字典的键值对合并到当前字典中（如果有重复的键，当前字典的值将被覆盖）：
  another_dict = {'key5': 'value5', 'key6': 'value6'} my_dict.update(another_dict)
  
• 使用pop()方法删除并返回字典中指定键的值（如果键不存在，返回默认值或抛出异常）：
  value3 = my_dict.pop('key3', 'default_value')
  
• 使用popitem()方法删除并返回字典中最后一个键值对（如果字典为空，抛出异常）：
  last_item = my_dict.popitem()
  
• 设置字典中指定键的默认值（如果键已经存在，则不修改其值）：
  my_dict.setdefault('key1', 'default_value1')
  
• 清空字典：
  my_dict.clear()
  

来源:https://www.cnblogs.com/taurusxw/p/17315357.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！