Python【修炼1】

欢迎来到Cefler的博客😁
🕌博客主页：折纸花满衣
🏠个人专栏：Python

---

👉🏻字典（Dictionary）

Python 中的字典（Dictionary）是一种内置的数据结构，它存储了键值对（key-value pairs）的集合。每个键（key）都是唯一的，并且与某个值（value）相关联。字典对于存储需要快速查找的数据非常有用，比如存储用户信息、配置选项等。

基本概念

• 键（Key）：键必须是唯一的，且必须是=不可变类型，如字符串（str）、数字（int、float、complex 等）或元组（tuple）。列表（list）和字典（dict）等可变类型不能作为键。
• 值（Value）：值可以是任何数据类型，包括列表、字典等可变类型。
• 创建字典：使用花括号 {} 或 dict() 函数来创建字典。

# 使用花括号创建字典
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}# 使用 dict() 函数创建字典
my_dict_2 = dict(name='John', age=30, city='New York')
# 或者使用关键字参数的形式
my_dict_3 = dict([('name', 'John'), ('age', 30), ('city', 'New York')])

常见方法

1. 访问元素：使用键来访问字典中的值。

print(my_dict['name'])  # 输出: John

2. 添加元素：如果键不存在，则添加新键值对；如果键已存在，则更新该键对应的值。

my_dict['email'] = 'john@example.com'  # 添加新键值对
my_dict['age'] = 31  # 更新现有键的值

3. 删除元素：使用 del 语句或 pop() 方法来删除字典中的元素。

del my_dict['email']  # 删除键为 'email' 的元素
print(my_dict.pop('age', 'Key not found'))  # 删除键为 'age' 的元素，并返回其值；如果键不存在，则返回 'Key not found'

4. 遍历字典：

   • 遍历键（keys）：

   for key in my_dict.keys():print(key)
   

   • 遍历值（values）：

   for value in my_dict.values():print(value)
   

   • 遍历键值对（items）：

   for key, value in my_dict.items():print(key, value)
   

5. get() 方法：使用键来获取值，如果键不存在，可以返回指定的默认值，而不是抛出 KeyError。

print(my_dict.get('email', 'Not found'))  # 输出: Not found

6. update() 方法：使用另一个字典中的键值对来更新当前字典。

new_info = {'email': 'john@newdomain.com', 'job': 'Engineer'}
my_dict.update(new_info)
print(my_dict)

7. len() 函数：获取字典中键值对的数量。

print(len(my_dict))

8. 字典推导式：一种简洁的方式来创建或修改字典。

# 创建一个新字典，其键和值都是原字典值的平方
squared_dict = {key: value**2 for key, value in my_dict.items() if isinstance(value, int)}

👉🏻列表(list)

Python中的list（列表）是一种基本的数据结构，用于存储一系列的元素。这些元素可以是不同类型的数据，比如整数、浮点数、字符串、甚至是另一个列表（即列表的嵌套）。列表是可变的，意味着你可以在创建列表之后添加、删除或修改其中的元素。

基本概念

• 索引：列表中的每个元素都有一个索引（或位置），索引从0开始。
• 切片：通过指定起始索引和结束索引（可选），可以获取列表中的一部分元素。
• 嵌套：列表可以包含其他列表作为元素，这允许创建多维数据结构。

创建列表

• 使用方括号[]和逗号,来创建列表。

my_list = [1, 2.5, 'hello', [10, 20]]

常见方法

1. append(x)：在列表末尾添加一个元素。

my_list.append(3)

2. extend(iterable)：将另一个可迭代对象（如列表）的所有元素添加到列表的末尾。

my_list.extend([4, 5])

3. insert(i, x)：在指定位置i插入元素x。

my_list.insert(1, 1.5)

4. remove(x)：移除列表中第一个出现的元素x。如果元素不存在，将抛出ValueError。

my_list.remove(2.5)

5. pop([i])：移除并返回列表中的指定位置i的元素。如果不指定i，则默认移除并返回最后一个元素。

last_element = my_list.pop()
second_element = my_list.pop(1)

6. index(x)：返回列表中元素x的第一个出现的索引。如果元素不存在，将抛出ValueError。

index = my_list.index('hello')

7. count(x)：返回列表中元素x出现的次数。

count = my_list.count(1)

8. sort(*, key=None, reverse=False)：对列表进行就地排序。可选参数key用于指定一个函数，该函数会在每个元素上调用以提取用于比较的键；reverse为True时表示降序排序。

my_list.sort(reverse=True)

9. reverse()：将列表中的元素反向排列。

my_list.reverse()

10. copy()：返回列表的一个浅拷贝。

new_list = my_list.copy()

11. 列表推导式：一种简洁的构建列表的方式，通过表达式和循环来生成列表。

squares = [x**2 for x in range(10)]

注意事项

• 列表是可变的，意味着你可以修改其元素。
• 列表的索引越界（即访问不存在的索引）将抛出IndexError。
• 列表的切片操作返回一个新的列表，而不是修改原列表。
• 列表的sort()和reverse()方法会就地修改列表，即直接修改原列表而不是返回新列表。

👉🏻eval函数

eval 函数是 Python 中的一个内置函数，它允许一个字符串表达式被解析为 Python 表达式，并计算其值。简单来说，eval 可以执行一个字符串表达式，并返回表达式的值。这个函数在处理动态表达式、从字符串中读取和执行代码等场景中非常有用，但也因为安全性问题（比如执行恶意代码）而需要谨慎使用。

基本用法

result = eval(expression, globals=None, locals=None)

• expression：一个字符串表达式，表示要计算的 Python 表达式。
• globals（可选）：一个字典，指定全局变量。如果未提供，则使用当前的全局符号表。
• locals（可选）：一个字典，指定局部变量。如果未提供，则使用当前局部符号表。

示例

x = 5
expr = "x + 3"
result = eval(expr)
print(result)  # 输出: 8# 使用 globals 和 locals
y = 10
globals_dict = {'x': 2}
locals_dict = {'y': 5}
result = eval('x + y', globals=globals_dict, locals=locals_dict)
print(result)  # 输出: 7，因为这里使用了指定的 globals 和 locals

安全性问题

尽管 eval 函数功能强大，但它也带来了安全风险。如果你执行的字符串来自不受信任的源（如用户输入），恶意用户可能会构造表达式来执行不希望执行的代码，如删除文件、访问敏感数据等。

为了避免这种风险，有几种替代方案可以考虑：

• 使用 ast.literal_eval()：这个函数用于安全地评估一个字符串表达式，但它只能处理 Python 字面量表达式，不能执行任意代码。
• 自定义解析器：如果可能，编写一个专门解析你需要的特定格式的字符串的解析器，这样可以避免执行任意代码的风险。
• 限制环境：如果你必须使用 eval，尝试通过限制 globals 和 locals 字典来限制其能访问的变量和函数。

👉🏻输出格式

在 Python 中，输出格式可以通过多种方式实现，类似于 C 语言的 printf。以下是几种常用的方法来格式化输出整数和小数。

1. 使用 print() 函数

直接输出

x = 10
y = 3.14159print("整数:", x)
print("小数:", y)

字符串格式化

a. 使用 % 操作符
类似于 C 语言的 printf，可以使用 % 来格式化输出：

print("整数: %d" % x)        # 输出整数
print("小数: %.2f" % y)     # 输出小数，保留两位小数

b. 使用 str.format()

print("整数: {}".format(x))          # 输出整数
print("小数: {:.2f}".format(y))     # 输出小数，保留两位小数

c. 使用 f-string（Python 3.6 及以上）

print(f"整数: {x}")                 # 输出整数
print(f"小数: {y:.2f}")            # 输出小数，保留两位小数

---

• {:}：简单输出值。

数字格式

1. 整数格式

   • {:d}：十进制整数。
   • {:b}：二进制整数。
   • {:o}：八进制整数。
   • {:x}：十六进制小写字母。
   • {:X}：十六进制大写字母。

2. 浮点数格式

   • {:f}：浮点数，默认保留6位小数。
   • {:e}：科学计数法（小写）。
   • {:E}：科学计数法（大写）。
   • {:g}：根据值自动选择 f 或 e 格式。
   • {:G}：根据值自动选择 F 或 E 格式。

精度和宽度

• 宽度：可以在冒号前指定宽度，例如 {:10} 表示宽度为 10。
• 精度：在点（.）后指定精度，例如 {:0.2f} 表示浮点数保留2位小数。

对齐方式

• <：左对齐。
• >：右对齐（默认）。
• ^：居中对齐。

填充字符

• 可以在宽度前指定填充字符，例如 {:0>5} 表示用零填充到宽度5。

组合使用示例

x = 42
y = 3.14159# 整数格式化
print(f"十进制: {x:d}")
print(f"二进制: {x:b}")
print(f"八进制: {x:o}")
print(f"十六进制（小写）: {x:x}")
print(f"十六进制（大写）: {x:X}")# 浮点数格式化
print(f"浮点数: {y:f}")
print(f"科学计数法（小写）: {y:e}")
print(f"科学计数法（大写）: {y:E}")
print(f"自动选择格式: {y:g}")# 指定宽度和对齐
print(f"右对齐: {x:>5}")       # 右对齐，宽度为 5
print(f"左对齐: {x:<5}")        # 左对齐，宽度为 5
print(f"居中对齐: {x:^5}")      # 居中对齐，宽度为 5
print(f"零填充: {x:0>5}")       # 用 0 填充，宽度为 5# 浮点数指定精度
print(f"保留两位小数: {y:.2f}")
print(f"保留四位小数: {y:.4f}")

其他格式选项

• 千分位分隔符：使用 , 选项，例如 {:,.2f} 输出带有千分位的浮点数。
• 百分比：使用 % 选项，例如 {:,.2%} 输出为百分比并保留两位小数。

👉🏻字符串内置方法

在 Python 中，字符串有许多内置方法，可以帮助你处理和操作字符串。以下是一些常用的字符串内置方法：

1. 字符串方法

• str.capitalize(): 将字符串的首字母大写，其余小写。

  s = "hello world"
  print(s.capitalize())  # Output: Hello world
  

• str.upper(): 将所有字母转换为大写。

  print(s.upper())  # Output: HELLO WORLD
  

• str.lower(): 将所有字母转换为小写。

  print(s.lower())  # Output: hello world
  

• str.title(): 将每个单词的首字母大写。

  print(s.title())  # Output: Hello World
  

• str.strip([chars]): 去掉字符串两端的空格或指定字符。

  s = "  hello  "
  print(s.strip())  # Output: hello
  

• str.split([sep]): 将字符串按指定分隔符分割成列表。

  s = "a,b,c"
  print(s.split(','))  # Output: ['a', 'b', 'c']
  

• str.join(iterable): 将可迭代对象中的字符串用指定字符串连接。

  lst = ['a', 'b', 'c']
  print(','.join(lst))  # Output: a,b,c
  

• str.replace(old, new[, count]): 替换字符串中的指定子串。

  s = "hello world"
  print(s.replace("world", "Python"))  # Output: hello Python
  

• str.find(sub[, start[, end]]): 返回子串在字符串中首次出现的索引，未找到返回 -1。

  print(s.find("world"))  # Output: 6
  

• str.startswith(prefix[, start[, end]]): 检查字符串是否以指定前缀开头。

  print(s.startswith("hello"))  # Output: True
  

• str.endswith(suffix[, start[, end]]): 检查字符串是否以指定后缀结尾。

  print(s.endswith("world"))  # Output: True
  

• str.count(sub[, start[, end]]): 计算子串在字符串中出现的次数。

  print(s.count("o"))  # Output: 2
  

• str.isdigit(): 检查字符串是否只包含数字。

  print("123".isdigit())  # Output: True
  

• str.isalpha(): 检查字符串是否只包含字母。

  print("abc".isalpha())  # Output: True
  

• str.isalnum(): 检查字符串是否只包含字母和数字。

  print("abc123".isalnum())  # Output: True
  

2. 示例

下面是一个综合示例，展示如何使用这些方法：

s = "  Python Programming  "
print(s.strip().upper())  # Output: PYTHON PROGRAMMING
print(s.split())           # Output: ['Python', 'Programming']
print(', '.join(['Hello', 'World']))  # Output: Hello, World
print(s.replace("Python", "Java"))     # Output:   Java Programming  
print(s.find("Programming"))            # Output: 9

字符串逆序

在 Python 中，可以使用切片轻松逆序字符串。以下是示例：

s = "hello"
reversed_s = s[::-1]
print(reversed_s)  # Output: olleh

---

如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注🌹🌹🌹❤️ 🧡 💛,学海无涯苦作舟,愿与君一起共勉成长