Python3 学习笔记2-基本数据类型

        在 Python 中，变量的声明和赋值是紧密联系在一起的，但与一些静态类型语言（如 C 或 Java）不同，Python 不需要显式声明变量的类型。Python 是一种动态类型语言，这意味着变量的类型在运行时会自动确定，并且可以在程序执行过程中改变。

（1）赋值：

• 示例：

# 给变量 x 赋一个整数值
x = 10
print(x)  # 输出: 10

# 变量 x 现在可以重新赋值为一个字符串
x = "Hello, World!"
print(x)  # 输出: Hello, World!

# 给变量 y 赋一个浮点数值
y = 3.14159
print(y)  # 输出: 3.14159

# 创建一个列表
my_list = [1, 2, 3, 4, 5]
print(my_list)  # 输出: [1, 2, 3, 4, 5]

# 创建一个字典
my_dict = {'name': 'xxxx', 'age': 25}
print(my_dict)  # 输出: {'name': 'xxxx', 'age': 25}

• 每次使用等号（=）时，都是在创建或修改一个变量，并将其与右侧的值关联起来。Python 解释器根据赋值的右侧对象自动确定变量的类型。
• 值得注意的是，虽然变量本身没有类型，但赋给变量的值（对象）确实有类型。在 Python 中，一切都是对象，包括数字、字符串、列表、字典等。这些对象在内存中存储，并由变量引用。
• Python 的这种灵活性使得编程更加直观和动态，但也需要程序员注意类型管理，以避免类型错误和相关的 bug。

（2）多个变量赋值：

        在 Python 中，你可以在一行中为多个变量赋值，这种特性被称为“多重赋值”或“并行赋值”。这种方式使得代码更加简洁，特别是当你需要将相同的值赋给多个变量时。

• 示例：

a = b = c = 1

• 这行代码创建了一个整数值 1，并将其赋给了三个变量 a、b 和 c。这意味着 a、b 和 c 现在都指向同一个整数对象 1。
• 多重赋值的另一个常见用法是在同一行中交换两个变量的值，而不需要使用额外的临时变量：
• 示例： 

a = 1
b = 2
a, b = b, a

• 在这个例子中，a 和 b 的值被交换了。在执行了最后一行代码后，a 的值变为 2，而 b 的值变为 1。
• Python 还允许你进行更复杂的多重赋值，例如同时为多个变量赋不同的值：
• 示例：

a, b, c = 1, 2, 3

• 这行代码将 a 赋值为 1，将 b 赋值为 2，将 c 赋值为 3。
• 多重赋值的这种灵活性在函数返回多个值时特别有用，因为可以一次性地将返回的值赋给多个变量：

def get_coordinates():
    return 10, 20

x, y = get_coordinates()

• 在这个例子中，get_coordinates 函数返回一个包含两个值的元组。通过多重赋值，我们可以直接将这两个值赋给变量 x 和 y。
• 总之，多重赋值是 Python 中一个非常有用的语言特性，它可以让代码更加简洁和易于阅读。

（3）标准数据类型：

        在 Python 中，数据类型用于定义变量可以存储的数据的种类。Python 是一种动态类型语言，这意味着你不需要（也不能）在声明变量时指定其类型。Python 会自动根据赋给变量的值来确定类型。以下是 Python 中一些常见的数据类型及其特点：

• Number（数字）：

  • 用于存储数值。
  • 可以是整数（如 42）、浮点数（如 3.14）、复数（如 1 + 2j）等。
  • 数字是不可变的，这意味着不能改变一个数字变量的值。
  • 在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

• String（字符串）：

  • 用于存储文本数据。
  • 可以是字母、数字、符号和空格的序列。
  • 字符串是不可变的，这意味着不能改变一个字符串中的单个字符。

• List（列表）：

  • 用于存储有序的元素集合。
  • 可以包含不同类型的元素，如整数、字符串、甚至其他列表。
  • 列表是可变的，这意味着你可以修改列表的内容，如添加、删除或更改元素。

• Tuple（元组）：

  • 与列表类似，但用于存储不应更改的数据集合。
  • 一旦创建，元组中的元素就不能被修改。
  • 元组是不可变的，这使得它们在某些情况下比列表更安全。

• Set（集合）：

  • 用于存储无序的元素集合，且元素唯一。
  • 集合是可变的，可以添加或删除元素。
  • 集合支持数学上的集合操作，如并集、交集、差集等。

• Dictionary（字典）：

  • 用于存储键值对。
  • 键必须是不可变类型，如字符串或数字。
  • 字典是可变的，可以添加、删除或更改键值对。

• Bool（布尔类型）：

  • 表示逻辑值 True 或 False。
  • 布尔类型是不可变的。

• Bytes（字节数组）：

  • 用于存储字节序列。
  • 与字符串类似，但用于表示二进制数据。
  • 字节数组是不可变的。
• 不可变数据类型（Number、String、Tuple）的特点是一旦创建，其内容不能被改变。如果尝试修改一个不可变类型的值，实际上 Python 会创建一个新的对象。
• 可变数据类型（List、Dictionary、Set）则允许修改其内容，不会创建新的对象。
• 内置的 type() 函数可以用来查询变量所指的对象类型。
• 示例：

# 获取不同类型的变量类型
a = 10                # 整数
b = "Hello, World!"   # 字符串
c = [1, 2, 3]         # 列表
d = (4, 5, 6)         # 元组
e = {7, 8, 9}         # 集合
f = {10: "ten"}       # 字典
g = 3.14              # 浮点数
h = 1 + 2j            # 复数

# 打印变量类型
print(type(a))  # 输出: <class 'int'>
print(type(b))  # 输出: <class 'str'>
print(type(c))  # 输出: <class 'list'>
print(type(d))  # 输出: <class 'tuple'>
print(type(e))  # 输出: <class 'set'>
print(type(f))  # 输出: <class 'dict'>
print(type(g))  # 输出: <class 'float'>
print(type(h))  # 输出: <class 'complex'>

• isinstance ()函数判断变量所指的对象类型。
• 示例：

# 定义一个简单的类
class Animal:
    pass

class Dog(Animal):
    pass

# 创建一个 Animal 类的实例
animal = Animal()

# 创建一个 Dog 类的实例
dog = Dog()

# 使用 isinstance() 检查类型
print(isinstance(animal, Animal))  # 输出: True
print(isinstance(dog, Animal))     # 输出: True
print(isinstance(dog, Dog))        # 输出: True

# 检查是否是其他类型
print(isinstance(animal, Dog))     # 输出: False
print(isinstance(dog, str))        # 输出: False

# 检查是否是元组中的某个类型
print(isinstance(dog, (Dog, Animal)))  # 输出: True

• isinstance 和 type 的区别在于：
• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类。
• 在 Python 3 中，布尔类型 bool 是整数类型 int 的子类，这使得布尔值可以参与数学运算，并且可以与整数相加。然而，尽管 True 和 1、False 和 0 在数值上等价，它们在类型上是不同的，这一点在使用 is 操作符进行类型检查时尤为重要。
• 在 Python 中，del 语句用于删除对象。它可以删除变量、列表元素、字典项等。使用 del 可以释放对象占用的内存，尽管 Python 通常会自动管理内存（通过垃圾回收机制）。
• del 语句用法示例：

• 删除变量：

x = 5
print(x)  # 输出: 5
del x
# 再次尝试打印 x 将会引发错误
# print(x)  # 将会引发: NameError: name 'x' is not defined

• 删除列表元素

my_list = [1, 2, 3, 4, 5]
print(my_list)  # 输出: [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为 2 的元素
print(my_list)  # 输出: [1, 2, 4, 5]

# 删除整个列表
del my_list
# 再次尝试打印 my_list 将会引发错误
# print(my_list)  # 将会引发: NameError: name 'my_list' is not defined

• 删除字典项：

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}
del my_dict['b']  # 删除键为 'b' 的项
print(my_dict)  # 输出: {'a': 1, 'c': 3}

# 删除整个字典
del my_dict
# 再次尝试打印 my_dict 将会引发错误
# print(my_dict)  # 将会引发: NameError: name 'my_dict' is not defined

• 删除多个变量:

a = 1
b = 2
c = 3
print(a, b, c)  # 输出: 1 2 3
del a, b  # 同时删除 a 和 b
# 再次尝试打印 a 或 b 将会引发错误
# print(a)  # 将会引发: NameError: name 'a' is not defined
# print(b)  # 将会引发: NameError: name 'b' is not defined
print(c)  # 输出: 3

• 删除对象的属性:

class MyClass:
    def __init__(self):
        self.x = 10

obj = MyClass()
print(obj.x)  # 输出: 10
del obj.x
# 尝试访问已删除的属性将会引发错误
# print(obj.x)  # 将会引发: AttributeError: 'MyClass' object has no attribute 'x'

• 使用 del 语句时要小心，因为一旦删除了变量或对象，就不能再访问它们，否则会引发 NameError 或 AttributeError。此外，del 语句不能用于删除全局变量或内置函数。

（4）数值运算：

        Python 提供了丰富的内置函数和运算符来进行数值运算。        

• +（加法）：将两个数相加：

print(5 + 3)  # 输出: 8

• -（减法）：从一个数中减去另一个数：

print(5 - 3)  # 输出: 2

• *（乘法）：将两个数相乘：

print(5 * 3)  # 输出: 15

• /（除法）：将一个数除以另一个数，结果是浮点数：

print(5 / 3)  # 输出: 1.6666666666666667

• //（整除）：将一个数除以另一个数，结果取整数部分：

print(5 // 3)  # 输出: 1

• %（取模）：求两个数相除的余数：

print(5 % 3)  # 输出: 2

**（幂运算）：求一个数的另一个数次幂：

print(5 ** 3)  # 输出: 125

数值函数

        Python 的 math 模块提供了许多用于数值运算的函数，例如：

• math.sqrt(x)：计算 x 的平方根：

import math
print(math.sqrt(16))  # 输出: 4.0

• math.pow(x, y)：计算 x 的 y 次幂：

import math
print(math.pow(2, 3))  # 输出: 8.0

• math.log(x[, base])：计算 x 的自然对数（默认以 e 为底）或以 base 为底的对数：

import math
print(math.log(10))    # 输出: 2.3025850929940459
print(math.log(10, 2)) # 输出: 3.3219280948873626

• math.sin(x), math.cos(x), math.tan(x)：分别计算 x 的正弦、余弦和正切值，x 应该是以弧度为单位的角度：

import math
print(math.sin(math.pi / 2)) # 输出: 1.0
print(math.cos(0))           # 输出: 1.0
print(math.tan(math.pi / 4)) # 输出: 0.9999999999999999

复数运算

        Python 也支持复数运算，可以直接使用 j 或者 J 作为虚数单位：

• 创建复数：使用 real + imag*j 的形式：

c = 3 + 4j
print(c)        # 输出: (3+4j)
print(c.real)  # 输出: 3.0
print(c.imag)  # 输出: 4.0

其他数值类型

• 分数（Fractions）：可以使用 fractions 模块中的 Fraction 类来创建分数：

from fractions import Fraction
f = Fraction(1, 3)
print(f)  # 输出: 1/3

• 有理数（Rational numbers）：decimal 模块中的 Decimal 类用于创建十进制浮点数，它提供了更高精度的浮点数运算：

from decimal import Decimal
d = Decimal('0.1') + Decimal('0.2')
print(d)  # 输出: 0.3

注意事项：

• Python可以同时为多个变量赋值，如a, b = 1, 2。
• 一个变量可以通过赋值指向不同类型的对象。
• 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
• 在混合计算时，Python会把整型转换成为浮点数。
• Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

（5）String（字符串）：

        在 Python 中，字符串（str）是用来表示文本的数据类型。字符串可以包含字母、数字、符号、空格以及任何其他 Unicode 字符。Python 中的字符串是不可变的，这意味着一旦创建，它们的值就不能被改变。

以下是 Python 字符串的一些特性和操作：

字符串的表示：

• 字符串可以用单引号 ''、双引号 "" 或三引号 ''' 或 """ 来表示，三引号可以跨越多行。

s1 = 'Hello, World!'
s2 = "Hello, World!"
s3 = """Hello,
World!"""
s4 = """Hello, 
World!"""

字符串的不可变性：

• 尝试修改字符串中的单个字符会导致错误，因为字符串是不可变的。

s = 'Python'
s[0] = 'p'  # 这会引发 TypeError

字符串索引和切片：

• 字符串可以像列表一样被索引和切片，但是不能被修改。

s = 'Hello, World!'
print(s[0])  # 输出: H
print(s[-1])  # 输出: !
print(s[7:12])  # 输出: World

字符串是可迭代的：

• 字符串可以用于循环和其他迭代场景。

s = 'Hello, World!'
for char in s:
    print(char)

字符串连接和重复：

• 可以使用 + 运算符连接字符串，使用 * 运算符重复字符串。

s1 = 'Hello, '
s2 = 'World!'
s3 = s1 + s2  # 输出: Hello, World!
s4 = s1 * 3  # 输出: Hello, Hello, Hello,

字符串方法：

• Python 字符串有许多内置方法，可以用来操作和查询字符串。

s = 'Hello, World!'
print(s.upper())  # 输出: HELLO, WORLD!
print(s.lower())  # 输出: hello, world!
print(s.startswith('Hello'))  # 输出: True
print(s.endswith('!'))  # 输出: True
print(s.replace('World', 'Python'))  # 输出: Hello, Python!

字符串格式化：

• Python 支持多种字符串格式化方法，包括 % 操作符、str.format() 方法和 f-strings（Python 3.6+）。

name = 'xxx'
age = 30
print('My name is %s, I am %d years old.' % (name, age))
print('My name is {}, I am {} years old.'.format(name, age))
print(f'My name is {name}, I am {age} years old.')

字符串编码：

• 字符串在 Python 中以 Unicode 形式存储，可以通过编码转换为其他格式，如 UTF-8。

s = 'Hello, World!'
encoded = s.encode('utf-8')  # 编码为 utf-8
print(encoded)  # 输出: b'Hello, World!'

• 字符串是 Python 中最常用的数据类型之一，它们是文本处理、文件操作和用户交互的基础。由于字符串的不可变性，Python 能够提供一致的性能和安全的操作。

        在 Python 中，截取字符串的部分内容通常指的是切片操作。字符串切片允许你获取字符串的一部分，这可以通过指定起始索引、结束索引以及步长来实现。

基本切片语法:

string[start:end:step]

• start：切片开始的位置（包含该位置）。
• end：切片结束的位置（不包含该位置）。
• step：步长，指定选择元素的间隔。
• 如果省略 start、end 或 step 中的任何一个，Python 会使用默认值。默认情况下，start 是 0，end 是字符串的长度，step 是 1。

切片示例:

s = 'Hello, World!'

# 截取从索引 0 到索引 5（不包括索引 5）
print(s[0:5])  # 输出: Hello

# 截取从索引 7 到字符串末尾
print(s[7:])   # 输出: World!

# 截取从索引 0 到字符串末尾，步长为 2
print(s[0::2]) # 输出: Heo!

# 截取从字符串末尾到索引 0，步长为 -1（反向切片）
print(s[::-1]) # 输出: !dlroW ,olleH

切片的高级用法:

• 省略 start，从字符串的开头开始切片。

  print(s[:5])  # 输出: Hello

• 省略 end，切片一直到字符串的末尾。

  print(s[7:])   # 输出: World!

• 使用负数索引，从字符串的末尾开始计数。

  print(s[-6:-2]) # 输出: Worl

• 省略 step，步长默认为 1。

  print(s[0:5])   # 输出: Hello

• 使用负数步长，进行反向切片。

  print(s[::-1])  # 输出: !dlroW ,olleH

切片与字符串不可变性：

• 虽然字符串本身是不可变的，但是切片操作并不会创建原始字符串的副本，而是创建了一个新的字符串对象，它是原始字符串的子集。因此，对切片进行修改不会影响原始字符串。

original = 'Hello, World!'
substring = original[0:5]  # 'Hello'
substring = substring.upper()  # 'HELLO'

print(original)  # 输出: Hello, World! （原始字符串未改变）
print(substring) # 输出: HELLO

（6）bool（布尔类型）：

        在 Python 中，bool 是一种特殊的数据类型，它只有两个可能的值：True 和 False。布尔值主要用于逻辑条件判断，如 if 语句、while 循环和循环中的 break 和 continue 语句。

特点：

• 布尔值是整数的子类：在 Python 中，bool 是 int 的子类，其中 True 等价于整数 1，而 False 等价于整数 0。

• 布尔运算：布尔值支持逻辑运算符，如 and、or 和 not。

• 布尔表达式：任何非零数值、非空对象或非 None 的值在布尔上下文中被视为 True，而 0、0.0、None、False、空字符串 ''、空列表 []、空字典 {} 和空元组 () 被视为 False。

• 布尔值可以转换：可以使用 bool() 函数将其他类型的值转换为布尔值。

示例：

• 布尔值的使用：

is_active = True
is_admin = False

# 使用布尔值进行条件判断
if is_active and is_admin:
    print("User is active and an admin.")
else:
    print("User does not have the required privileges.")

• 布尔值与整数的等价性：

print(True + 1)  # 输出: 2
print(False - 1)  # 输出: -1

# 布尔运算同时返回布尔值和整数值
print((True and True) is True)  # 输出: True
print((False or True) is True)  # 输出: True
print(not False is True)  # 输出: True

• 布尔运算符：

# and 运算符
print(True and True)  # 输出: True
print(True and False)  # 输出: False
print(False and False)  # 输出: False

# or 运算符
print(True or True)  # 输出: True
print(True or False)  # 输出: True
print(False or False)  # 输出: False

# not 运算符
print(not True)  # 输出: False
print(not False)  # 输出: True

• 布尔值与其他类型的转换：

# 使用 bool() 函数转换
print(bool(10))   # 输出: True
print(bool(0))    # 输出: False
print(bool(-1))   # 输出: True
print(bool([]))   # 输出: False
print(bool([1]))  # 输出: True
print(bool(''))   # 输出: False
print(bool('text'))  # 输出: True

• 布尔值在循环中的应用：

# 使用布尔值控制循环
items = [1, 2, 3, 0, 5]
for item in items:
    if not item:  # 当 item 为 0 时，not item 为 False，循环会跳过
        continue
    print(item)  # 只有非零值会被打印

（7）List（列表）：

        在 Python 中，列表（list）是一种可变的序列类型，它可以存储不同类型的元素，如整数、浮点数、字符串甚至其他列表。列表是 Python 中最灵活和最常用的数据结构之一。

特点：

• 可变性：列表的内容可以在运行时修改，可以添加、删除或更改其中的元素。
• 异质性：列表可以包含不同类型的元素。
• 动态大小：列表的大小不固定，可以根据需要动态增长或缩小。
• 索引：列表中的每个元素都有一个索引，从 0 开始。
• 切片：可以对列表进行切片操作，获取部分元素。
• 内置方法：列表支持多种内置方法，如 append()、remove()、pop()、reverse() 等。

示例：

# 创建列表
my_list = [1, 2, 3, 4, 5]

# 访问列表元素
print(my_list[0])  # 输出: 1
print(my_list[-1]) # 输出: 5

# 修改列表元素
my_list[1] = 20
print(my_list)  # 输出: [1, 20, 3, 4, 5]

# 添加元素
my_list.append(6)
print(my_list)  # 输出: [1, 20, 3, 4, 5, 6]

# 插入元素
my_list.insert(2, 'a')
print(my_list)  # 输出: [1, 20, 'a', 3, 4, 5, 6]

# 删除元素
my_list.remove('a')
print(my_list)  # 输出: [1, 20, 3, 4, 5, 6]

# 弹出元素
popped_element = my_list.pop()
print(popped_element) # 输出: 6
print(my_list)        # 输出: [1, 20, 3, 4, 5]

# 列表切片
print(my_list[1:4])  # 输出: [20, 3, 4]

# 列表遍历
for item in my_list:
    print(item)

# 列表推导式
squares = [x**2 for x in range(5)]
print(squares)  # 输出: [0, 1, 4, 9, 16]

# 嵌套列表
nested_list = [1, 2, [3, 4], 5]
print(nested_list[2][1]) # 输出: 4

列表提供了许多内置方法来操作列表：

• append(x)：在列表末尾添加一个元素。
• extend([item1, item2, ...])：在列表末尾一次性追加另一个序列中的多个值。
• insert(i, x)：在指定位置插入一个元素。
• remove(x)：移除列表中第一个值为 x 的元素。
• pop([i])：移除列表中的一个元素（默认最后一个），并返回它。
• clear()：清空列表。
• index(x[, start[, end]])：返回列表中第一个值为 x 的元素的索引。
• count(x)：返回 x 在列表中出现的次数。
• sort(key=None, reverse=False)：对列表进行排序。
• reverse()：反转列表中的元素。

（8）Tuple（元组）：

        在 Python 中，元组（tuple）是一种不可变的序列类型，用于存储不同类型的元素，这些元素是有序的，并且可以通过索引来访问。元组一旦创建，其内容不能被修改，这意味着你不能添加、删除或更改元组中的元素。

元组的特点：

• 不可变性：元组是不可变的，这意味着一旦创建，就不能更改元组中的元素。
• 有序性：元组中的元素保持其添加顺序。
• 索引：元组中的元素可以通过索引访问，索引从 0 开始。
• 可迭代：元组是可迭代的，可以用于循环和其他迭代场景。
• 轻量级：与其他数据结构相比，元组是轻量级的，因为它们不允许修改，所以 Python 可以优化它们。
• 可以包含不同类型的元素：元组可以包含数字、字符串、甚至其他元组。
• 元组也可以使用 + 操作符进行拼接。

创建元组：

• 创建元组非常简单，可以使用圆括号 () 来创建，或者直接用逗号分隔的元素序列。

# 使用圆括号创建元组
my_tuple = (1, 2, 3)
print(my_tuple)  # 输出: (1, 2, 3)

# 直接使用逗号分隔的元素序列
another_tuple = 1, 2, 3
print(another_tuple)  # 输出: (1, 2, 3)

# 创建一个包含字符串的元组
string_tuple = ("apple", "banana", "cherry")
print(string_tuple)  # 输出: ('apple', 'banana', 'cherry')

# 创建一个空元组
empty_tuple = ()
print(empty_tuple)  # 输出: ()

# 创建一个单元素元组（需要在元素后加逗号）
single_element_tuple = (42,)
print(single_element_tuple)  # 输出: (42,)

元组的操作：

• 访问元组元素：

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1])  # 输出: 2

• 切片：

print(my_tuple[1:4])  # 输出: (2, 3, 4)

• 遍历元组：

for item in my_tuple:
    print(item)

• 元组的连接：

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # 输出: (1, 2, 3, 4, 5, 6)

• 元组的解包：

a, b, c = (1, 2, 3)
print(a)  # 输出: 1
print(b)  # 输出: 2
print(c)  # 输出: 3

• 元组的不可变性：

my_tuple = (1, 2, 3)
# my_tuple[0] = 4  # 这会引发 TypeError，因为元组是不可变的

（9）Set（集合）：

        在 Python 中，集合（set）是一个无序的、不包含重复元素的容器。它支持数学上的集合操作，如并集、交集、差集和对称差分等。集合由大括号 {} 定义，或者使用 set() 函数创建。

特点：

• 无序性：集合中的元素没有特定的顺序。
• 唯一性：集合中的每个元素都是唯一的，不允许重复。
• 可变：集合的内容可以在运行时改变，可以添加或删除元素。
• 支持集合操作：提供了丰富的集合操作，如并集、交集等。
• 字典是一种映射类型，它的元素是键值对。
• 创建空字典使用 { }。

示例：

• 创建集合：

# 使用大括号创建集合
my_set = {1, 2, 3}
print(my_set)  # 输出: {1, 2, 3}

# 使用 set() 函数创建集合
my_set2 = set([1, 2, 3])
print(my_set2)  # 输出: {1, 2, 3}

• 添加和删除元素：

# 添加元素
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}

# 删除元素
my_set.remove(2)
print(my_set)  # 输出: {1, 3, 4}

# 删除集合中的最后一个元素
my_set.discard(3)
print(my_set)  # 输出: {1, 4}

# 清空集合
my_set.clear()
print(my_set)  # 输出: set()

• 集合操作：

# 并集
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2)  # 输出: {1, 2, 3, 4, 5}

# 交集
print(set1 & set2)  # 输出: {3}

# 差集
print(set1 - set2)  # 输出: {1, 2}
print(set2 - set1)  # 输出: {4, 5}

# 对称差分（元素在一个集合中但不在两个集合中）
print(set1 ^ set2)  # 输出: {1, 2, 4, 5}

• 集合与可迭代对象：

• 集合可以与任何可迭代对象一起使用，例如列表、元组等，来创建新的集合。

# 从列表创建集合
my_list = [1, 2, 2, 3, 4]
my_set_from_list = set(my_list)
print(my_set_from_list)  # 输出: {1, 2, 3, 4}

# 从元组创建集合
my_tuple = (1, 2, 3, 4, 4)
my_set_from_tuple = set(my_tuple)
print(my_set_from_tuple)  # 输出: {1, 2, 3, 4}

集合的不可变性：

• 虽然集合本身是可变的，可以添加和删除元素，但是集合的元素必须是不可变类型。例如，你不能将列表或另一个集合作为集合的元素，因为它们是可变的。

# 正确
my_set = {1, 2, 3}

# 错误，因为列表是可变的
# my_set = {[1, 2], 3}

（10）Dictionary（字典）：

        在 Python 中，字典（dict）是一种内置的数据类型，用于存储键值对（key-value pairs）。字典是可变的，这意味着你可以在创建后修改它们，比如添加、修改或删除键值对。

字典的特点：

• 无序性：在 Python 3.6 之前，字典是无序的，这意味着键值对的顺序是不确定的。从 Python 3.7 开始，字典是有序的，这意味着它们会按照插入的顺序保持键值对。
• 唯一性：字典中的键必须是唯一的，不能有两个相同的键。
• 可变和不可变：字典是可变类型，键通常是不可变类型，如整数、浮点数、字符串、元组等。
• 动态性：字典可以动态地增长和缩小，可以随时添加新的键值对或删除旧的键值对。
• 查找效率：字典的查找效率很高，因为它们是基于哈希表实现的。

字典的基本操作示例：

# 创建一个空字典
empty_dict = {}

# 创建一个包含键值对的字典
person = {
    'name': 'John',
    'age': 30,
    'city': 'New York'
}

# 访问字典中的值
print(person['name'])  # 输出: John

# 添加新的键值对
person['email'] = 'john@example.com'

# 修改键值对
person['age'] = 31

# 删除键值对
del person['city']
# 或者使用 pop 方法，它还会返回被删除的值
removed_value = person.pop('city', None)

# 检查键是否存在
if 'name' in person:
    print("Name is a key in the dictionary")

# 获取所有键
print(person.keys())  # 输出: dict_keys(['name', 'age', 'email'])

# 获取所有值
print(person.values())  # 输出: dict_values(['John', 31, 'john@example.com'])

# 获取所有键值对
print(person.items())  # 输出: dict_items([('name', 'John'), ('age', 31), ('email', 'john@example.com')])

# 遍历字典
for key, value in person.items():
    print(f"{key}: {value}")

字典的切片和索引：

• 字典不支持切片操作，因为它们不是序列类型。
• 你可以通过键来索引字典中的值。

字典的方法：

Python 字典提供了多种方法来操作字典，例如 clear(), copy(), get(), update(), keys(), values(), items() 等。

字典推导式：

字典推导式是创建字典的一种简洁方式，类似于列表推导式。

# 创建一个新字典，其中包含原始字典的键和值的平方
squared = {key: value**2 for key, value in person.items()}
print(squared)  # 输出: { 'name': 'John', 'age': 1024, 'email': 'john@example.com' }

（11）bytes 类型：

        在 Python 中，bytes 类型是用于表示二进制数据的不可变序列。bytes 对象是一系列的字节值，每个字节是一个介于 0 和 255 之间的整数。这种数据类型在处理二进制文件、网络通信、加密数据等方面非常有用。

特点：

• 不可变性：bytes 对象一旦创建就不能被修改。尝试修改 bytes 对象的操作（如添加、删除或更改字节）将会引发错误。
• 二进制数据：bytes 用于存储原始二进制数据，而不是文本。如果你需要处理文本数据，通常使用 str 类型。
• 字节序列：bytes 可以看作是字节的序列，每个字节对应一个整数。
• 编码和解码：bytes 对象可以被编码（转换成 str 类型的文本）和解码（从 str 类型的文本转换成 bytes）。

示例：

• 创建 bytes 对象：

# 使用字节字面量创建 bytes 对象
b = b'Hello, World!'
print(b)  # 输出: b'Hello, World!'

# 使用 bytes 函数创建 bytes 对象
b = bytes([72, 101, 108, 108, 111], 'utf-8')
print(b)  # 输出: b'Hello'

# 使用字符串编码创建 bytes 对象
s = '你好，世界！'
b = s.encode('utf-8')
print(b)  # 输出: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'

• 切片 bytes 对象：

b = b'Hello, World!'
print(b[0:5])  # 输出: b'Hello'
print(b[7:])   # 输出: b'World!'

• 修改 bytes 对象：

• 由于 bytes 对象是不可变的，你不能直接修改它。但是，你可以创建一个新的 bytes 对象。

b = b'Hello, World!'
# b[0] = 72  # 这会引发 TypeError

# 创建一个新的 bytes 对象
b_new = bytes([72] + list(b[1:]))
print(b_new)  # 输出: b'Hello, World!'

• 编码和解码 bytes 对象：

# 编码字符串为 bytes
s = '你好，世界！'
b = s.encode('utf-8')
print(b)  # 输出: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'

# 解码 bytes 为字符串
s_decoded = b.decode('utf-8')
print(s_decoded)  # 输出: 你好，世界！

• bytes 与 str 的转换：
• bytes 和 str 可以通过编码和解码相互转换，但它们代表的数据类型不同。bytes 用于二进制数据，而 str 用于文本数据。

# 将 bytes 转换为字符串
b = b'\xff\xfe\x01\x02'
s = b.decode('utf-16')
print(s)  # 输出: ��

# 将字符串转换为 bytes
s = 'ABC'
b = s.encode('ascii')
print(b)  # 输出: b'ABC'