python详细基础知识笔记

注：

print("@author--fengjin")

·第一章 学习准备

1.1高级语言、机器语言、汇编语言

1. 高级语言
   高级语言是一种相对高层次的计算机编程语言，它通过使用类似英语的语法和结构使程序更易于阅读和编写。高级语言通常包含许多预定义的函数和库，可以大大简化编程过程。高级语言还可以隐藏底层细节，如内存管理和寄存器分配，以方便程序员专注于程序的逻辑实现。常见的高级语言包括C++、Java、Python等。
2. 机器语言
   机器语言是计算机可直接理解的语言，也是最基本的计算机语言。机器语言由一系列二进制代码组成，用于控制计算机的硬件系统。由于机器语言命令使用的是计算机硬件体系结构的指令集，因此机器语言程序必须编写得相当精确，错误将导致计算机出现严重问题。机器语言虽然非常底层，但在实现一些高性能应用时具有优势。它通常由汇编语言翻译为人类可读的格式以方便程序员编写和调试。
3. 汇编语言
   汇编语言是一种介于高级语言和机器语言之间的语言。与高级语言相比，汇编语言更接近计算机硬件的操作方式；与机器语言相比，它提供了更多的抽象层次，使程序员可以使用符号名称而不是0和1来代表指令和寄存器。通过使用汇编语言，程序员可以更加精确地控制计算机硬件系统的操作，并且可以在性能和代码可读性之间进行权衡。汇编语言程序需要翻译为机器语言才能在计算机上运行。常见的汇编语言有x86汇编语言、ARM汇编语言等。

1.2 汇编、解释

1. 汇编
   汇编是将汇编语言翻译成机器语言的过程。在汇编过程中，程序会被一步步地转换成二进制代码，最终形成可执行文件。由于汇编语言直接操作硬件，因此生成的程序具有高效性和高精度性。然而，在编写过程中必须考虑到底层硬件的细节，如内存管理和寄存器分配等，因此汇编语言编写复杂程序往往非常困难。汇编生成的程序也不可移植，因为不同计算机的指令集可能不同。
2. 解释
   解释是一种直接执行程序，逐行读取并解释源代码的过程。解释器可以由高级语言开发，它将源代码行解释并实时执行。解释器执行程序的方式更加灵活，使得程序员可以更快地开发原型和进行调试。此外，由于解释器本身是跨平台的，解释生成的程序也是可移植的。然而，解释性语言通常比编译性语言执行速度慢，因为它每次都需要重新解释源代码。

1.3 静态语言、脚本语言

1. 静态语言
   静态语言是在编译期进行类型检查的语言。在编写代码时，需要指定变量类型。编译器会在编译时检查类型和语法错误，并生成可执行代码文件。静态语言具有较好的性能和可靠性，因为编译器可以优化代码、避免由于类型错误引发的运行时异常等问题。但是，静态语言程序的开发速度相对较慢，因为变量类型必须在编写代码时就确定，这使得代码相对较长和繁琐。
2. 脚本语言
   脚本语言是一种在运行时才进行类型检查的语言。不需要指定变量类型，脚本语言解释器会在运行时根据变量值进行类型推断。脚本语言可以快速开发并且易于阅读，减少了开发人员的编写和测试时间。然而，脚本语言在执行时会频繁调用解释器，因此性能相对较低。此外，脚本语言可能会由于运行时类型错误引发运行时异常。

1.4 Python的历史

Python是一种高级编程语言，由Guido于1989年在荷兰创造并编写。Python的设计目标是简单、易读、易维护。它具有丰富的库和数据结构以及各种应用领域。Python已成为当今最流行的编程语言之一，因其简单易用而广受欢迎，越来越多的程序员选择Python作为其开发应用程序的首选编程语言。

1.5 Python语言的优点、缺点

优点：

1. 简单易用：Python语法简单明了，易于学习和使用，并且大大减少了代码量，提高了开发效率。
2. 跨平台性：Python可以在不同的操作系统上运行，包括Windows、Mac OS、Linux等，这使得开发者可以在不同操作系统上轻松地编写和运行应用程序。
3. 强大的标准库：Python内置了大量的模块和库，能够处理各种任务，如文本处理、网络编程、GUI编程等，极大地扩展了Python的功能。
4. 应用范围广泛：Python在各个领域都有广泛的应用，如Web开发、数据分析和科学计算、人工智能、游戏开发等。

缺点：

1. 执行速度较慢：由于Python是解释型语言，相比编译型语言执行速度稍慢，尤其是在处理大规模数据时表现不佳。
2. 内存占用较高：Python在运行时需要占用较多的内存，特别是处理大型数据时，容易出现内存不足的问题。

1.6 Python环境安装与配置

1. 下载并安装Python：官网下载对应操作系统的Python安装包，然后按照界面提示进行安装。
2. 配置环境变量：将Python安装路径添加到系统环境变量中。在Windows中，需将Python安装目录下的Scripts文件夹路径添加到系统环境变量的Path变量中。
3. 配置IDE环境：IDE是集成开发环境，可提供更加友好的开发体验。常见的Python IDE有PyCharm、VS Code等。只需要下载并安装即可使用。

·第二章 变量、数据类型

2.1 print（）函数

print()函数用于输出指定的文本、变量和表达式等信息。该函数可接收一个或多个参数，多个参数之间用逗号分隔，将它们依次输出到屏幕上，并在输出内容之间自动添加空格。以下是一些使用print()函数的示例：

1. 输出字符串
   当我们需要向屏幕输出指定的字符串时，可以直接在print()函数中输入该字符串，例如：

print('Hello, world!')

输出结果为：

Hello, world!

2. 输出变量和表达式
   当我们需要输出已定义的变量或者表达式值时，可以将这些值作为print()函数的参数进行输出，例如：

age = 20
print('My age is', age)

输出结果为：

My age is 20

我们也可以在print()函数中输出一些基本的数学表达式，并打印出其计算结果，例如：

a = 3
b = 5
print('a + b =', a + b)

输出结果为：

a + b = 8

总结：print()函数是Python中常用的一个函数，可以用于输出各种信息，包括字符串、变量和表达式等

2.2 变量命名规则、type（）函数

1. Python中的变量命名遵循以下规则：

• 变量名只能包含字母、数字和下划线（_），不能使用其他特殊字符。
• 变量名不能以数字开头。
• 变量名不能使用Python中的关键字（如if、else、while、for等）。
• 变量名应该具有描述性，能够清晰地表达其所存储的数据的含义。

2. 在Python中，变量可以直接赋值，无需提前声明变量类型。例如：

a = 1
b = 'hello'
c = [1, 2, 3]

3. Python中支持多重赋值，这意味着可以将多个变量同时赋值给一个值或一个序列。例如：

a, b, c = 1, 'hello', [1, 2, 3]

或者

a = b = c = 1

4. Python中的变量可以存储不同类型的数据，可以动态改变数据类型。例如：

a = 1
a = 'hello'

5. 变量的作用域是指变量在哪些地方可以被访问到。Python中存在全局变量和局部变量两种作用域。全局变量定义在函数外部，可以在整个程序中访问。局部变量定义在函数内部，在函数外部不可访问。
6. Python中，可以使用type()函数来查看变量的数据类型。例如：

a = 1
b = 'hello'
c = [1, 2, 3]
    
print(type(a)) # 输出
print(type(b)) # 输出
print(type(c)) # 输出

7. 在Python中，也可以使用del关键字来删除变量。例如：

a = 1
del a # 删除变量a

2.3 简单数据类型

Python中，有五种基本的“简单数据类型”，分别为整型、浮点型、布尔型、字符串和空值。
1.整型（int）
整型是Python中表示整数的数据类型。例如：1，100，-3 等都是整型。在Python 3.x中，整数类型没有大小限制，可以表示任意大的整数。
例如：

x = 10
print(type(x))  # 

2. 浮点型（float）
   浮点型是Python中表示小数的数据类型。例如：1.0，3.14，-0.5 等都是浮点型。在Python中，浮点数可以用科学计数法表示。
   例如：

x = 3.14
print(type(x))    # 
y = 4e2   # 表示 4 * 10^2
print(y)    # 400.0

3. 布尔型（bool）
   布尔型是Python中表示真假的数据类型，只有两个值：True 和 False。在Python中，布尔值可以直接与整数相加减，True 相当于1，False相当于0。
   例如：

x = True
y = False
print(type(x), type(y))    #  
print(x + y)    # 1

4. 字符串（str）
   字符串是Python中表示文本的数据类型，通常使用单引号（’）或双引号（"）括起来。字符串也可以使用三引号（’’’ 或 “”"）括起来，用于表示多行文本。
   例如：

x = 'Hello World'
y = "Python programming"
z = '''My name is Tom.
I'm 20 years old.'''
print(type(x), type(y), type(z))    #   

5. 空值（NoneType）
   空值是Python中表示空对象的数据类型，它只有一个值：None。在Python中，None常用于表示函数或方法没有返回值。
   例如：

x = None
print(type(x))    # 

2.4 注释、常用转义字符

1.Python中的注释以“#”开头，可以用于在代码中添加一些解释说明。注释文本在程序执行时会被忽略，不会被解释器执行。注释可以用于解释代码的作用、说明部分代码的功能、添加开发者信息等。
例如：

# 这是一条单行注释，用于解释下面的一行代码的作用
print('Hello, World!')  # 这是另一条单行注释，用于解释这行代码的作用

除了单行注释，还可以使用多行注释。多行注释可以用一对三引号或者一对三个单引号来表示，可以跨越多行，通常用于添加函数或类的说明文档。
例如：

"""
这是一个演示函数的多行注释
函数名：add
作用：实现两个数字相加并返回结果
参数：
 - num1: 第一个数字
 - num2: 第二个数字
返回值：相加的结果
"""
def add(num1, num2):
    return num1 + num2

2.在Python中，常用的转义字符有：

• \n：表示换行
• \t：表示制表符
• \r：表示回车
• \：表示反斜杠
• '：表示单引号
• "：表示双引号
  例如：

print('Hello,\nWorld!')  # 输出Hello和World占据两行
print('First line\tSecond line')  # 输出First line和Second line中间有一个制表符
print('Hello\rWorld!')  # 输出World!，因为\r会将光标移动到行首并覆盖前面的内容
print('\\ is a backslash.')  # 输出\ is a backslash.
print('What\'s your name?')  # 输出What's your name?
print("I said, \"You are beautiful.\"")  # 输出I said, "You are beautiful."

2.5 类型转换

1. int(x)：将x转换为一个整数。例如：

 num1 = "10"
 num2 = int(num1)
 print(num2)  # 输出10，num1被成功转换为整数类型

2. float(x)：将x转换为一个浮点数。例如：

  num1 = "10.1"
  num2 = float(num1)
  print(num2)  # 输出10.1，num1被成功转换为浮点数类型

3. str(x)：将x转换为一个字符串。例如：

  num1 = 10
  num2 = str(num1)
  print(num2)  # 输出"10"，num1被成功转换为字符串类型

4. bool(x)：将x转换为一个布尔值。例如：

 num1 = 10
 num2 = bool(num1)
 print(num2)  # 输出True，因为10在Python中被视为True

5. list(x)：将x转换为一个列表类型。例如：

  str1 = "hello"
  list1 = list(str1)
  print(list1)  # 输出['h', 'e', 'l', 'l', 'o']，str1被成功转换为列表类型

6. tuple(x)：将x转换为一个元组类型。例如：

  list1 = ['h', 'e', 'l', 'l', 'o']
  tuple1 = tuple(list1)
  print(tuple1)  # 输出('h', 'e', 'l', 'l', 'o')，list1被成功转换为元组类型

7. set(x)：将x转换为一个集合类型。例如：

  list1 = [1, 2, 3, 4, 4]
  set1 = set(list1)
  print(set1)  # 输出{1, 2, 3, 4}，list1被成功转换为集合类型，并去除了其中的重复项

·第三章 一些内置函数

3.1 input()函数

input()函数是Python内置函数之一，用于从用户处获取输入。该函数的基本语法为：

input([prompt])

其中，prompt为可选参数，用于设置提示信息，若没有则不显示
input()函数返回一个字符串类型的值

示例代码：

name = input("请输入您的名字：")
print("您好，" + name)

输入：

请输入您的名字：Tom

输出：

您好，Tom

3.2 id()函数

id()函数也是Python内置函数之一，用于获取对象的唯一标识符（即内存地址）。该函数的基本语法为：

id(object)

其中，object为要获取标识符的对象。id()函数返回一个整数型的值。

示例代码：

a = 10
print(id(a))

输出：

140732661413312

说明a的内存地址为140732661413312。
还可以在创建对象时，使用id()函数查看其初始的内存地址：

class MyClass:
    pass

obj = MyClass()
print(id(obj))

输出：

140732661260352

说明MyClass类的实例obj的内存地址为140732661260352。

3.3 help()函数

Python中的help()函数是一个内置函数，用于获取对象的帮助信息。该函数可以接受一个参数，即需要获取帮助信息的对象，如模块、函数、类等。

使用方法：
在Python交互式环境中，输入`help()`可获取该函数的帮助信息
而输入`help(object)`则可以获取指定对象的帮助信息。

例如，输入help(print)可以获取print()函数的帮助信息，而输入help(list)可以获取list类型的帮助信息。

3.4 dir()函数

在Python中，dir()函数是一个内置函数，用于获取指定对象的所有属性和方法列表。这些属性和方法可以是对象自身定义的，也可以是从其类继承的。

使用方法：
在Python交互式环境中，输入`dir()`可获取当前命名空间下的所有变量和函数名列表
而输入`dir(object)`则可以获取指定对象的所有属性和方法列表。

例如，输入dir(list)可以获取list类型的所有属性和方法列表。

3.5 bin()函数

在 Python 中，bin() 函数是一个内置函数，用于返回一个整数的二进制表示。

3.6 abs()函数

abs() 函数是求绝对值的函数，它的语法如下：

abs(x)

其中，`x` 是任意一个数值型数据类型的对象（如整数、浮点数、复数等）
返回值为 `x` 的绝对值。如果 `x` 是复数，则返回 `x` 的模长。

例如：

print(abs(-1))  # 输出 1
print(abs(3+4j))  # 输出 5.0

3.7 pow()函数

pow() 函数用于计算幂，它的语法如下：

pow(x, y)

其中，`x` 和 `y` 是两个数值型数据类型的参数，表示底数和指数

例如：

print(pow(2, 3))  # 输出 8

3.8 sort()函数和sorted()函数

1.sort()函数是Python中内置的一种排序函数，它可以对一个列表进行原地排序，也就是直接修改该列表，而不是返回一个新的已排序列表。
sort()函数有两个可选参数key和reverse，其中key用于指定一个函数来为每个元素提取比较键（默认使用元素自身），reverse用于指定是否降序排序，默认为升序排序。
下面是一个简单的例子：

nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
#升序排序
nums.sort()
print(nums)  # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
#降序排序
nums.sort(reverse=True)
print(nums)  # [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

2.sorted() 函数是 Python 中常用的内置函数之一，用于对列表、元组等序列类型进行排序
sorted() 函数的基本用法

sorted(iterable, *, key=None, reverse=False)

其中：

• iterable：表示要进行排序的序列，可以是列表、元组等可迭代对象；
• key：表示用于排序的函数，可以是自定义函数，也可以是 Python 内置函数；
• reverse：表示排序结果是否要反转，默认为 False，即升序排序。
  下面给出一个简单的示例：

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 8, 9]

在这个例子中，我们首先定义了一个包含多个数字的列表 numbers，然后使用 sorted() 函数对其进行升序排序，并将结果存储在 sorted_numbers 变量中。最后输出 sorted_numbers 的值，发现它已经按照从小到大的顺序排列。

需要注意的是，sorted() 函数返回的是一个新的列表，而不是原始列表的排序结果。
如果要在原始列表上进行排序，可以使用列表的 sort() 方法。

3.9 len()函数

len()函数是Python中内置的一种函数，它可以用于获取一个变量的长度或元素个数。
len()函数可以接受多种数据类型，如字符串、列表、元组、字典、集合等等。不同数据类型返回的长度值也会有所区别，比如字符串返回的是字符串的字符个数，而列表返回的是列表中元素的个数。
下面是几个简单的例子：

# 获取字符串长度
str = "hello world"
print(len(str))  # 11
# 获取列表长度
lst = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(len(lst))  # 11
# 获取元组长度
tpl = (3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)
print(len(tpl))  # 11
# 获取字典长度
dict = {'apple': 5, 'banana': 2, 'orange': 3}
print(len(dict))  # 3
# 获取集合长度
set = {3, 1, 4, 1, 5, 9, 2, 6, 5}
print(len(set))  # 7

3.10 eval()函数

eval()函数是Python中内置的一种函数，可以接受任何有效的Python表达式作为参数，比如数值、字符串、列表、元组、字典、函数等等
以下是几个简单的例子：

# 将字符串转换为数字
num = eval("5 + 7")
print(num)  # 12

# 将字符串转换为列表
lst = eval("[1, 2, 3, 4]")
print(lst)  # [1, 2, 3, 4]

# 将字符串转换为元组
tpl = eval("(1, 2, 3, 4)")
print(tpl)  # (1, 2, 3, 4)

# 将字符串转换为字典
dict = eval("{'apple': 5, 'banana': 2, 'orange': 3}")
print(dict)  # {'apple': 5, 'banana': 2, 'orange': 3}

3.11 max()和min()函数、sum()函数

max()和min()函数是Python中内置的常用函数，它们分别可以返回给定序列的最大值和最小值。sum()函数也是内置的常用函数，它可以返回给定序列的元素之和。
max()和min()函数可以接受任何可以迭代的对象作为参数，包括列表、元组、字典、集合等。在传入参数时，可以通过关键字参数key来指定一个可调用对象，帮助max()和min()函数确定比较大小的规则。例如，我们可以通过以下方式找出一个列表中长度最长的字符串：

lst = ['apple', 'banana', 'orange', 'kiwi']
longest_str = max(lst, key=len)
print(longest_str)  # 'banana'

sum()函数同样也可以接受任何可以迭代的对象作为参数，并且可以通过关键字参数start来指定累加的初始值。例如，我们可以通过以下方式计算一个列表的元素之和：

lst = [1, 2, 3, 4, 5]
total = sum(lst)
print(total)  # 15

需要注意的是，在使用max()、min()和sum()函数时，如果传入的参数是空序列，它们将会抛出异常。
因此，在使用这些函数时，需要确保传入的参数不为空。

3.12 reverse()函数

reverse()函数是Python中列表对象的一个方法，它可以将列表中的元素反转。这个方法会修改原始列表，而不是返回一个新的反转后的列表。
reverse()方法没有参数，直接调用即可：

lst = [1, 2, 3, 4, 5]
lst.reverse()
print(lst)  # [5, 4, 3, 2, 1]

3.13 ord()和chr()函数

ord() 和 chr() 函数是 Python 中常用的内置函数，用于字符和 Unicode 码之间的相互转换。

1.ord() 函数
ord() 函数可以将一个单字符的字符串转换为对应的 Unicode 码。例如：

print(ord('A'))  # 65
print(ord('中'))  # 20013

ord() 函数也可以用于获取特殊字符（如空格、Tab、换行符等）的 Unicode 码。例如：

print(ord(' '))  # 32
print(ord('\t'))  # 9
print(ord('\n'))  # 10

需要注意的是，ord() 函数只接受一个单字符的字符串作为参数。
如果尝试将多个字符的字符串传给 ord() 函数，会抛出异常。

2.chr() 函数
与 ord() 函数相反，chr() 函数可以将一个 Unicode 码转换为对应的字符。例如：

print(chr(65))  # A
print(chr(20013))  # 中

与 ord() 函数一样，chr() 函数也可以用于获取特殊字符的字符值。例如：

print(chr(32))  # 空格
print(chr(9))  # 制表符
print(chr(10))  # 换行符

需要注意的是，chr() 函数只接受一个整数作为参数，并且该整数必须是有效的 Unicode 码。
如果尝试将无效的整数传给 chr() 函数，会抛出异常。

·第四章 语法初步

4.1 缩进

在 Python 中，使用缩进来表示代码块，缩进有固定数目的空格或制表符。每一个缩进级别通常为 4 个空格字符。
示例代码：

if 2 > 1:
    print("2 大于 1")
else:
    print("2 小于等于 1")

4.2 复合运算符

Python 中的复合运算符允许将一个数字变量与另一个数字进行运算后再赋值给该变量。例如，a += 1 相当于 a = a + 1。
示例代码：

a = 10
a += 5     # 等价于 a = a + 5
print(a)  # 输出 15

4.3 比较与逻辑运算符

Python 中的比较运算符包括：==、!=、>、<、>= 和 <=。逻辑运算符包括：and、or 和 not。
示例代码：

x = 5
y = 10

if x == 5 and y == 10:
    print("x = 5 且 y = 10")

if x < 10 or y < 5:
    print("x 小于 10 或者 y 小于 5")

if not x > y:
    print("x 不大于 y")

4.4 进制

在数字前加上 0x 表示十六进制，加上 0o 表示八进制，加上 0b 表示二进制。在转换为十进制时，可以使用 int() 函数。
示例代码：

a = 0x1a   # 十六进制数表示为 26
b = 0o36   # 八进制数表示为 30
c = 0b1101 # 二进制数表示为 13

print(a, b, c)
print(int("10010", 2)) # 将二进制数 10010 转换为十进制数

输出结果为：`26 30 13` 和 `18`（十进制）。

·第五章 列表

5.1 列表的定义

Python中的列表（List）是一种有序、可变的数据结构，其中可以存储任意类型的元素，包括数字、字符串、甚至其他列表等。以下是一个定义列表和操作列表的例子：
要定义一个列表，只需要用方括号 [] 将元素括起来，并用逗号 , 分隔每个元素即可：

fruits = ['apple', 'banana', 'orange']
numbers = [1, 2, 3, 4, 5]
mixed_list = ['apple', 2, True, 3.14]

上述代码定义了三个不同的列表，分别是只包含字符串的 fruits 列表，
只包含数字的 numbers 列表，以及混合元素的 mixed_list 列表。

5.2 列表元素的访问和修改

1.访问列表元素
可以通过下标运算符 [] 来访问列表中的元素。下标从0开始，所以第一个元素的下标是0，第二个元素的下标是1，以此类推。例如：

print(fruits[0])    # 输出 'apple'
print(numbers[2])   # 输出 3
print(mixed_list[3]) # 输出 3.14

2. 修改列表元素
   由于列表是可变的数据结构，因此可以通过下标运算符修改列表中的元素：

fruits[0] = 'pear'
print(fruits)    # 输出 ['pear', 'banana', 'orange']

5.3 列表元素的增加和删除

增加元素

1. 使用append()方法，在列表末尾添加一个元素。

fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')
print(fruits)  # ['apple', 'banana', 'cherry', 'orange']

2. 使用insert()方法，在指定位置插入一个元素。

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'orange')
print(fruits)  # ['apple', 'orange', 'banana', 'cherry']

3. 使用extend()方法，在列表末尾一次性添加另一个列表中的所有元素。

fruits1 = ['apple', 'banana']
fruits2 = ['cherry', 'orange']
fruits1.extend(fruits2)
print(fruits1)  # ['apple', 'banana', 'cherry', 'orange']

删除元素

1. 使用del语句，删除列表中指定位置的元素。

fruits = ['apple', 'banana', 'cherry', 'orange']
del fruits[1]
print(fruits)  # ['apple', 'cherry', 'orange']

2. 使用remove()方法，删除列表中指定值的元素。

fruits = ['apple', 'banana', 'cherry', 'orange']
fruits.remove('banana')
print(fruits)  # ['apple', 'cherry', 'orange']

3. 使用pop()方法，删除列表中指定位置的元素，并返回被删除的值。如果没有指定位置，默认删除最后一个元素。

fruits = ['apple', 'banana', 'cherry', 'orange']
popped_fruit = fruits.pop(1)
print(popped_fruit)  # 'banana'
print(fruits)  # ['apple', 'cherry', 'orange']

popped_fruit2 = fruits.pop()
print(popped_fruit2)  # 'orange'
print(fruits)  # ['apple', 'cherry']

5.4 列表的嵌套

列表嵌套是指在一个列表中包含另外的列表。Python中，列表可以包含任意类型的元素，包括其他的列表。
下面举例说明列表的嵌套：

1. 创建一个嵌套列表

a = [1, 2, [3, 4], 5]

上面这个嵌套列表包含了四个元素，其中第三个元素是一个列表。

2. 访问嵌套列表中的元素

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

可以看出，在访问嵌套列表的元素时，需要使用多个方括号来表示访问嵌套的层数。

3. 修改嵌套列表中的元素

a[1] = 'hello'
a[2][1] = 'world'
print(a) # 输出: [1, 'hello', [3, 'world'], 5]

4. 遍历嵌套列表中的元素

for element in a:
    if type(element) == list:
        for nested_element in element:
            print(nested_element)
    else:
        print(element)

# 输出:
# 1
# hello
# 3
# world
# 5

5.5 列表元素的排序问题

1. sort()方法
   sort()方法可以对列表进行原地排序，即改变原列表的顺序。sort()默认按升序排序，也可以通过reverse参数指定是否倒序排序。
   示例代码如下：

a = [3, 2, 1]
a.sort()
print(a) # 输出: [1, 2, 3]

a.sort(reverse=True)
print(a) # 输出: [3, 2, 1]

2. sorted()函数
   sorted()函数返回一个新的排好序的列表，不改变原列表的顺序。sorted()函数默认按升序排序，也可以通过reverse参数指定是否倒序排序。
   示例代码如下：

a = [3, 2, 1]
b = sorted(a)
print(a) # 输出: [3, 2, 1]
print(b) # 输出: [1, 2, 3]

c = sorted(a, reverse=True)
print(c) # 输出: [3, 2, 1]

3. 使用关键字进行排序
   对于一个由元组组成的列表，可以根据元组中的某个元素进行排序。
   示例代码如下：

a = [(1, 'a'), (2, 'c'), (3, 'b')]
b = sorted(a, key=lambda x: x[1])
print(b) # 输出: [(1, 'a'), (3, 'b'), (2, 'c')]

上面的示例中，利用key参数指定按元组中第二个元素进行排序，即('a', 'c', 'b')

5.6 for循环遍历列表

1. 基本语法

for item in list:
    # 对每个元素执行操作

其中，item是列表中的每个元素，list是需要遍历的列表。

2. 遍历整个列表
   可以使用for循环遍历整个列表，对每个元素执行相同的操作。例如，可以输出每个元素的值：

fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(fruit)

输出结果为：

apple
banana
orange

3. 访问列表中的特定元素
   可以通过索引访问列表中的特定元素。例如，可以输出第二个元素的值：

fruits = ['apple', 'banana', 'orange']
print(fruits[1])

输出结果为：

banana

4. 使用range()函数进行遍历
   可以使用range()函数生成一系列数字，然后使用这些数字来遍历列表中的元素。例如，可以输出前三个元素的值：

fruits = ['apple', 'banana', 'orange', 'grape', 'kiwi']
for i in range(3):
    print(fruits[i])

输出结果为：

apple
banana
orange

5. 在for循环中修改列表
   可以在for循环中修改列表中的元素。例如，可以将列表中所有元素的值都加上1：

numbers = [1, 2, 3, 4, 5]
for i in range(len(numbers)):
    numbers[i] += 1
print(numbers)

输出结果为：

[2, 3, 4, 5, 6]

5.7 range()函数

range()函数是Python内置的一个函数，用于生成一个整数序列。其语法为：

range(start, stop[, step])

其中，start 表示序列的起始值（可以省略，默认为0），stop 表示序列的结束值（必须指定），
step 表示步长（可以省略，默认为1）

以下是一些使用range()函数的示例：

1. 生成一个简单的整数序列：

for i in range(10):
    print(i)

该代码段将输出从0到9的整数。

2. 指定起始值和结束值：

for i in range(5, 10):
    print(i)

该代码段将输出从5到9的整数。

3.指定步长：

for i in range(0, 10, 2):
    print(i)

该代码段将输出从0开始，每隔2个整数输出一个元素，直到小于10为止，即输出0、2、4、6、8。

5.8 列表的运算

1. 列表的加法（+）运算符：
   列表的加法运算符可以将两个列表合并成一个新的列表。

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)   # [1, 2, 3, 4, 5, 6]

2. 列表的乘法（*）运算符：
   列表的乘法运算符可以将一个列表重复多次。

a = [1, 2, 3]
b = a * 3
print(b)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

3. 列表的切片操作：
   列表的切片操作可以获取列表中的某个子集，包括起始和结束位置。

a = [1, 2, 3, 4, 5]
b = a[2:4]
print(b)   # [3, 4]

5.9 列表的成员函数

1. append()方法：
   append()方法可以在列表末尾添加一个元素。

a = [1, 2, 3]
a.append(4)
print(a)  # [1, 2, 3, 4]

2. extend()方法：
   extend()方法可以将一个列表中的元素添加到另一个列表的末尾。

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)  # [1, 2, 3, 4, 5, 6]

3. insert()方法：
   insert()方法可以在列表的指定位置插入一个元素。

a = [1, 2, 3]
a.insert(1, 4)
print(a)  # [1, 4, 2, 3]

4. remove()方法：
   remove()方法可以从列表中删除指定的元素。

a = [1, 2, 3, 2]
a.remove(2)
print(a)  # [1, 3, 2]

5. pop()方法：
   pop()方法可以从列表中删除指定位置的元素，并返回该元素的值。

a = [1, 2, 3]
b = a.pop(1)
print(a)  # [1, 3]
print(b)  # 2

6. index()方法：
   index()方法可以查找指定元素在列表中的位置。

a = [A, B, C]
b = a.index(B)	#查找元素B的位置
print(b)  #位置为下标 1

7. count()方法：
   count()方法可以统计指定元素在列表中出现的次数。

a = [1, 2, 3, 2]
b = a.count(2)
print(b)  # 2

5.10 列表的复制

列表有两种复制方式：浅复制和深复制。

1. 浅复制
   浅复制会创建一个新的列表，并将原列表中的元素复制到新列表中，但元素本身并不复制。这意味着，新列表中的元素和原列表中的元素指向相同的内存地址。当修改原列表中的元素时，新列表中的对应元素也会被修改。

举例：

# 创建一个原列表
original_list = [[1, 2, 3], [4, 5, 6]]
# 进行浅复制
shallow_copy_list = original_list.copy()

# 修改原列表中的元素
original_list[0][0] = 100
print(original_list)  # 输出 [[100, 2, 3], [4, 5, 6]]
print(shallow_copy_list)  # 输出 [[100, 2, 3], [4, 5, 6]]

上面的例子中，先创建了一个原列表 `original_list`，包含两个列表 `[1, 2, 3]` 和 `[4, 5, 6]`
然后通过 `copy()` 方法进行浅复制，得到一个新列表 `shallow_copy_list`
接着我们修改了原列表中的第一个子列表的第一个元素为 `100`，
可以看到修改后，原列表和新列表中的第一个子列表都变成了 `[100, 2, 3]`
这是因为两个列表中的子列表指向了同一个内存地址

2. 深复制
   深复制会创建一个新的列表，并将原列表中的元素复制到新列表中，同时也会对元素进行复制。这意味着，新列表中的元素和原列表中的元素指向不同的内存地址。当修改原列表中的元素时，新列表中的对应元素不会被修改。

举例：

import copy

# 创建一个原列表
original_list = [[1, 2, 3], [4, 5, 6]]
# 进行深复制
deep_copy_list = copy.deepcopy(original_list)

# 修改原列表中的元素
original_list[0][0] = 100
print(original_list)  # 输出 [[100, 2, 3], [4, 5, 6]]
print(deep_copy_list)  # 输出 [[1, 2, 3], [4, 5, 6]]

上面的例子中，使用了 Python 的 `copy` 模块中的 `deepcopy()` 方法进行深复制
其他部分和浅复制的例子类似，但注意到修改原列表中的元素后，
只有原列表中的第一个子列表变成了 `[100, 2, 3]`，而新列表中的第一个子列表仍然是 `[1, 2, 3]`
这是因为深复制创建的新列表中的元素和原列表中的元素是相互独立的

5.11列表的切片

在 Python 中，可以使用切片来操作列表。切片的基本语法是：列表[起始索引:终止索引:步长]，其中起始索引表示切片的起始位置，终止索引表示切片的结束位置(不包括该索引所对应的元素)，步长表示每两个元素之间的距离

1. 通过切片获取列表的子列表

举例：

# 创建一个列表
lst = [1, 2, 3, 4, 5]
# 获取列表的第2个到第4个元素
sub_lst = lst[1:4]
# 输出获取的子列表
print(sub_lst) # 输出 [2, 3, 4]

2. 通过切片修改列表的一部分元素

举例：

# 创建一个列表
lst = [1, 2, 3, 4, 5]
# 将列表的第2个到第4个元素赋值为新的值
lst[1:4] = [6, 7, 8]
# 输出修改后的列表
print(lst) # 输出 [1, 6, 7, 8, 5]

注意使用切片修改列表时，切片的长度和赋值的序列的长度可以不相等。

3. 通过切片反转列表

举例：

# 创建一个列表
lst = [1, 2, 3, 4, 5]
# 反转列表
rev_lst = lst[ : : -1]
# 输出反转后的列表
print(rev_lst) # 输出 [5, 4, 3, 2, 1]

这里我们通过`lst[ : : -1]`的方法选中了列表`lst`中的所有元素，并按照步长为`-1`进行切片，
从而实现了对列表的反转。

4. 通过切片复制列表

举例：

# 创建一个列表
lst = [1, 2, 3, 4, 5]
# 复制列表
copy_lst = lst[ : ]
# 输出复制后的列表
print(copy_lst) # 输出 [1, 2, 3, 4, 5]

通过`lst[ : ]`的方法选中了列表中的所有元素，并将其作为新列表的内容，从而实现了对列表的复制。
注意到在这个例子中，我们没有指定起始和终止索引，这意味着复制的内容就是整个列表。

·第六章 元组

6.1 元组的定义

元组（tuple）是一种不可变序列，与列表相似但有一些不同之处。元组由小括号“()”包含，其中的元素可以是任意类型，不同元素间用逗号“,”隔开。元组内元素的值可以访问，但不能修改。与列表相比，元组的访问速度更快，但无法修改和删除其中的元素。也因此，元组适合存储一些不变的数据

6.2 创建元组

# 空元组
tup1 = ()
# 含有一个元素的元组需要加上逗号
tup2 = (50,)
# 多个元素的元组
tup3 = (1, 2, 3, 4, 5)

6.3 元组的访问

元组可以通过下标（索引）来访问其中的元素，其下标从0开始。例如：

tup = ('a', 'b', 'c', 'd', 'e')
print("tup[0]: ", tup[0])
print("tup[1:3]: ", tup[1:3])

输出为 “tup[0]: a” 和 “tup[1:3]: ('b', 'c')”
因为第一个元素的下标为0，第二个到第三个（不包含）的下标分别为1和2。

6.4 元组的操作

元组可以进行连接（+）和重复（*）操作：

tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
# 连接元组
tup3 = tup1 + tup2
print(tup3)
# 输出：(1, 2, 3, 4, 5, 6)

# 重复元组
tup4 = ('hello',) * 3
print(tup4)
# 输出：('hello', 'hello', 'hello')

6.5 元组的删除和修改

由于元组是不可变序列，无法直接删除和修改其中的元素。但可以使用切片的方式来删除和修改元组的一部分。例如：

tup = (1, 2, 3, 4, 5, 6)
# 删除下标为2到4（不包含）的元素
tup = tup[:2] + tup[4:]
print(tup)
# 输出：(1, 2, 5, 6)

# 修改下标为1的元素，需要先将元组转换成列表进行修改再转换回来
tup = list(tup)
tup[1] = 10
tup = tuple(tup)
print(tup)
# 输出：(1, 10, 5, 6)

6.6 元组的内置方法

• count()：返回元组中指定元素出现的次数。
• index()：返回元素在元组中第一次出现的位置。

例如：

tup = ('a', 'b', 'c', 'c', 'd', 'e', 'f')
# 计算元素'c'在元组中出现的次数
print(tup.count('c'))
# 输出：2

# 查找元素'd'在元组中的位置
print(tup.index('d'))
# 输出：4

·第七章 集合

7.1 集合的创建

集合（set）是一组互不相同元素的无序集合，可以通过花括号 {} 或者 set() 函数来创建。

1. 使用花括号创建集合：

# 创建空集合
empty_set = {}

# 创建包含元素的集合
animals = {'猫', '狗', '猴子'}
print(animals)
# output: {'狗', '猴子', '猫'}

在使用花括号创建集合时，如果只写一个空花括号 {} ，则创建的其实是一个空字典（dictionary）
而不是空集合。因此，应该使用 set() 函数来创建空集合。

2. 使用 set() 函数创建集合：

# 创建空集合
empty_set = set()

# 创建包含元素的集合
fruits = set(['苹果', '香蕉', '橘子'])
print(fruits)
# output: {'苹果', '橘子', '香蕉'}

集合的元素必须是不可变的类型，如数字、字符串、元组等。不能包含列表、字典等可变类型。
同时，集合中每个元素都是唯一的，重复的元素会被自动移除

7.2 集合的运算

集合（set）支持基本的数学运算，如交集、并集、差集等。

1. 交集：返回两个集合中都包含的元素，使用 & 或 intersection() 方法

set_a = {1, 2, 3}
set_b = {2, 3, 4}
intersection_set = set_a & set_b
print(intersection_set)
# Output: {2, 3}

# 使用 intersection() 方法
set_c = {2, 3, 4}
intersection_set = set_a.intersection(set_c)
print(intersection_set)
# Output: {2, 3}

2. 并集：返回两个集合中所有不重复的元素，使用 | 或 union() 方法

set_a = {1, 2, 3}
set_b = {2, 3, 4}
union_set = set_a | set_b
print(union_set)
# Output: {1, 2, 3, 4}

# 使用 union() 方法
set_c = {3, 4, 5}
union_set = set_a.union(set_c)
print(union_set)
# Output: {1, 2, 3, 4, 5}

3. 差集：返回第一个集合中有，而第二个集合中没有的元素，使用 - 或 difference() 方法

set_a = {1, 2, 3}
set_b = {2, 3, 4}
diff_set = set_a - set_b
print(diff_set)
# Output: {1}

# 使用 difference() 方法
set_c = {3, 4, 5}
diff_set = set_a.difference(set_c)
print(diff_set)
# Output: {1, 2}

4. 对称差集：返回两个集合中不重复的元素，使用 ^ 或 symmetric_difference() 方法

set_a = {1, 2, 3}
set_b = {2, 3, 4}
sym_diff_set = set_a ^ set_b
print(sym_diff_set)
# Output: {1, 4}

# 使用 symmetric_difference() 方法
set_c = {3, 4, 5}
sym_diff_set = set_a.symmetric_difference(set_c)
print(sym_diff_set)
# Output: {1, 2, 4, 5}

集合运算的结果都是一个新的集合，不会改变原有的集合。

7.3 集合的操作

集合支持增加、删除元素等基本操作，如：

animals = {'猫', '狗', '猴子'}
# 添加元素
animals.add('鸟')
print(animals)  # Output: {'狗', '鸟', '猴子', '猫'}

# 删除元素
animals.remove('狗')
print(animals)  # Output: {'鸟', '猴子', '猫'}

# 清空集合
animals.clear()
print(animals)  # Output: set()

7.4 is和==

1. is 运算符
   is 运算符用于判断两个对象是否指向同一个内存地址。如果两个变量指向同一个内存地址，那么它们是同一个对象；否则，它们是不同的对象。如下所示：

a = [1, 2, 3]
b = a
print(a is b)  # 输出：True

b = [1, 2, 3]
print(a is b)  # 输出：False

第一个例子中，变量 a 和 b 指向同一个列表对象，因此 a is b 的结果为 True
而第二个例子中，变量 a 和 b 分别指向两个不同的列表对象，因此 a is b 的结果为 False

2. == 运算符
   == 运算符用于比较两个对象的值是否相等。如果两个对象的值相等，那么它们被认为是相等的；否则，它们被认为是不相等的。如下所示：

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # 输出：True

c = [3, 2, 1]
print(a == c)  # 输出：False

在第一个例子中，变量 a 和 b 分别指向两个值相等的列表对象，因此 a == b 的结果为 True
而在第二个例子中，变量 a 和 c 分别指向两个值不相等的列表对象，因此 a == c 的结果为 False

·第八章 字典

8.1 字典的创建

在 Python 中，字典可以用来存储键值对，每个键值对之间使用冒号（:）分隔，不同的键值对之间使用逗号（,）分隔

1. 直接创建字典
   我们可以使用花括号（{}）表示一个空字典，也可以在花括号中添加键值对来创建具有初始值的字典。如下所示：

# 创建空字典
dict1 = {}
print(dict1)  # 输出：{}

# 创建具有初始值的字典
dict2 = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(dict2)  # 输出：{'name': 'Tom', 'age': 18, 'gender': 'male'}

2. 使用 dict() 函数创建字典
   使用 dict() 函数来创建字典。dict() 函数可以接受列表、元组、集合等可迭代对象作为参数，每个可迭代对象中的元素必须是长度为 2 的序列，其中第一个元素表示键，第二个元素表示值。如下所示：

# 创建具有初始值的字典
dict3 = dict([('name', 'Tom'), ('age', 18), ('gender', 'male')])
print(dict3)  # 输出：{'name': 'Tom', 'age': 18, 'gender': 'male'}

8.2 dict()函数

使用 dict() 函数来创建字典。dict() 函数可以接受多种类型的参数，并返回一个字典对象。下面是dict() 函数的几种用法。

1. 使用关键字参数创建字典
   使用关键字参数的方式来创建字典，其中每个键值对都由一个 key 和对应的 value 组成。如下所示：

# 使用关键字参数创建字典
dict3 = dict(name='John', age=18)
print(dict3)  # 输出：{'name': 'John', 'age': 18}

2. 使用迭代器创建字典
   使用迭代器来创建字典，其中迭代器需要返回一个可迭代对象，其中每个元素都是包含两个值的序列，第一个值表示 key，第二个值表示 value。如下所示：

# 使用迭代器创建字典
iter_dict = [('name', 'John'), ('age', 18)]
dict4 = dict(iter_dict)
print(dict4)  # 输出：{'name': 'John', 'age': 18}

3. 使用字典推导式创建字典
   使用字典推导式的方式来创建字典，通过对一个可迭代对象进行操作生成字典。如下所示：

# 使用字典推导式创建字典
list1 = [1, 2, 3, 4]
dict5 = {key: key**2 for key in list1}
print(dict5)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16}

8.3字典的基本操作

1. 访问字典中的元素
   字典中的元素是通过“键”来访问的，可以使用方括号 [] 或者 get() 方法来实现

# 使用方括号 [] 访问字典中的元素
student = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(student['name']) # 输出 Tom

# 使用 get() 方法访问字典中的元素，如果键不存在返回默认值
print(student.get('grade', 'unknown')) # 输出 unknown

2. 修改字典中的元素
   字典中的元素可以通过“键”来进行修改，直接赋值即可

student = {'name': 'Tom', 'age': 18, 'gender': 'male'}
student['age'] = 20
print(student) # 输出 {'name': 'Tom', 'age': 20, 'gender': 'male'}

3. 删除字典中的元素
   使用 del 关键字或者 pop() 方法可以删除字典中的元素

student = {'name': 'Tom', 'age': 18, 'gender': 'male'}
del student['gender']
print(student) # 输出 {'name': 'Tom', 'age': 18}

student = {'name': 'Tom', 'age': 18, 'gender': 'male'}
student.pop('gender')
print(student) # 输出 {'name': 'Tom', 'age': 18}

4. 添加字典元素
   使用赋值语句添加字典元素，如果键存在，则更新对应的值，不存在则新建键值对。

student = {'name': 'Tom', 'age': 18}
student['gender'] = 'male'
print(student) # 输出 {'name': 'Tom', 'age': 18, 'gender': 'male'}

5. 判断是否存在某个键
   使用 in 关键字可以判断一个键是否存在于字典中。

student = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print('name' in student) # 输出 True
print('grade' in student) # 输出 False

8.4 字典的嵌套

字典可以嵌套，即一个字典中的值可以是另一个字典

1. 创建嵌套字典

student = {'name': 'Tom', 
           'age': 18, 
           'grade': {
               'math': 90, 
               'english': 85, 
               'history': 95
           }
          }
print(student)
# 输出 {'name': 'Tom', 'age': 18, 'grade': {'math': 90, 'english': 85, 'history': 95}}

2. 访问嵌套字典中的元素
   访问字典中嵌套的字典，需要使用两层方括号或者 get() 方法。

# 使用两层方括号访问嵌套字典中的元素
student = {'name': 'Tom', 
           'age': 18, 
           'grade': {
               'math': 90, 
               'english': 85, 
               'history': 95
           }
          }
print(student['grade']['math']) # 输出 90

# 使用 get() 方法访问嵌套字典中的元素
print(student.get('grade').get('english')) # 输出 85

3. 修改嵌套字典中的元素
   修改字典中嵌套的字典元素，需要通过两次访问来完成。

student = {'name': 'Tom', 
           'age': 18, 
           'grade': {
               'math': 90, 
               'english': 85, 
               'history': 95
           }
          }
student['grade']['math'] = 95
print(student) # 输出 {'name': 'Tom', 'age': 18, 'grade': {'math': 95, 'english': 85, 'history': 95}}

4. 添加嵌套字典
   如果字典中嵌套的字典不存在，则可以通过赋值语句进行添加。

student = {'name': 'Tom', 
           'age': 18, 
           'grade': {
               'math': 90, 
               'english': 85, 
           }
          }
# 为嵌套字典添加键值对
student['grade']['history'] = 95
print(student) # 输出 {'name': 'Tom', 'age': 18, 'grade': {'math': 90, 'english': 85, 'history': 95}}

5. 遍历嵌套字典
   遍历字典中嵌套的字典，需要使用多层 for 循环。

student = {'name': 'Tom', 
           'age': 18, 
           'grade': {
               'math': 90, 
               'english': 85, 
               'history': 95
           }
          }
# 遍历嵌套字典中的键和值
for key in student:
    if type(student[key]) == dict:
        for sub_key in student[key]:
            print(sub_key, student[key][sub_key])
    else:
        print(key, student[key])

8.5 字典的成员函数

1. clear()：清空字典

my_dict = {'a': 1, 'b': 2}
my_dict.clear()
print(my_dict)  # {}

2. copy()：复制字典

my_dict = {'a': 1, 'b': 2}
new_dict = my_dict.copy()
print(new_dict)  # {'a': 1, 'b': 2}

3. get()：获取指定键的值，如果键不存在则返回默认值

my_dict = {'a': 1, 'b': 2}
value = my_dict.get('c', 0)
print(value)  # 0

4. items()：返回字典所有项（键值对）的列表

my_dict = {'a': 1, 'b': 2}
items = my_dict.items()
print(items)  # [('a', 1), ('b', 2)]

5. keys()：返回字典所有键的列表

my_dict = {'a': 1, 'b': 2}
keys = my_dict.keys()
print(keys)  # ['a', 'b']

6. values()：返回字典所有值的列表

my_dict = {'a': 1, 'b': 2}
values = my_dict.values()
print(values)  # [1, 2]

7. pop()：删除指定键的项，并返回对应值

my_dict = {'a': 1, 'b': 2}
value = my_dict.pop('a')
print(value)  # 1
print(my_dict)  # {'b': 2}

8. popitem()：弹出任意一项（键值对），并返回对应键值对

my_dict = {'a': 1, 'b': 2}
item = my_dict.popitem()
print(item)  # ('b', 2)
print(my_dict)  # {'a': 1}

9. setdefault()：获取指定键的值，如果键不存在则设置默认值并返回

my_dict = {'a': 1, 'b': 2}
value = my_dict.setdefault('c', 0)
print(value)  # 0
print(my_dict)  # {'a': 1, 'b': 2, 'c': 0}

10. update()：合并字典

my_dict = {'a': 1, 'b': 2}
other_dict = {'c': 3, 'd': 4}
my_dict.update(other_dict)
print(my_dict)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

8.6 字典的遍历

1. 遍历字典中所有键值对
   通过 items() 方法可以遍历字典中的所有键值对，代码如下：

dict1 = {'name': '张三', 'age': 18, 'gender': '男'}

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

输出结果如下：

name 张三
age 18
gender 男

2. 遍历字典中的所有键
   通过 keys() 方法可以遍历字典中的所有键，代码如下：

dict1 = {'name': '张三', 'age': 18, 'gender': '男'}

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

输出结果如下：

name
age
gender

3. 遍历字典中的所有值
   通过 values() 方法可以遍历字典中的所有值，代码如下：

dict1 = {'name': '张三', 'age': 18, 'gender': '男'}

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

输出结果如下：

张三
18
男

4. 使用列表推导式遍历字典

dict1 = {'name': '张三', 'age': 18, 'gender': '男'}

result = [(key, value) for key, value in dict1.items()]

print(result)

输出结果如下：

[('name', '张三'), ('age', 18), ('gender', '男')]

·第九章 条件语句、循环语句

9.1 if-else语句

if-else语句是一种基本的条件语句，它允许我们根据某个条件来执行不同的代码块。如果条件成立，则执行if语句中的代码块；否则执行else语句中的代码块。

例如：

if x > 5:
    print("x大于5")
else:
    print("x小于或等于5")

9.2 if-else-else语句

if-else-else语句是if-else语句的进阶版，它允许我们根据更多的条件来执行不同的代码块。当第一个条件不成立时，判断第二个条件，以此类推。

例如：

if x > 5:
    print("x大于5")
elif x < 5:
    print("x小于5")
else:
    print("x等于5")

9.3 for循环

for循环是一种常用的循环语句，它可以遍历列表、元组、字典等数据类型，并对其中的每个元素执行相同的操作。

例如：

words = ["hello", "world", "python"]
for word in words:
    print(word)

输出结果为：

hello
world
python

9.4 while循环

while循环是另一种常用的循环语句，它允许我们在满足某个条件的情况下重复执行同一段代码。

例如：

i = 0
while i < 5:
    print(i)
    i += 1

输出结果为：

0
1
2
3
4

9.5 break与continue

break和continue关键字可以用于控制循环的执行流程。break语句可以强制退出循环，而continue语句则可以跳过当前循环中的剩余代码，直接进入下一次循环。

例如：

for i in range(10):
    if i == 3:
        continue
    elif i == 6:
        break
    print(i)

输出结果为：

0
1
2
4
5

9.6 冒泡排序、水仙花树

1.冒泡排序：
冒泡排序是一种基础的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作会重复进行多次，每次遍历都会确定一个最大值或最小值。
实现代码如下：

def bubble_sort(lst):
    n = len(lst)
    for i in range(n):
        for j in range(0, n-i-1):
            if lst[j] > lst[j+1]:
                lst[j], lst[j+1] = lst[j+1], lst[j]
    return lst

其中，lst为待排序的列表。

2.水仙花数：
水仙花数（Narcissistic number），也被称为自恋数、自幂数、阿姆斯特朗数或者超完全数字不变数，它是指一个三位数，其每个位上的数字的立方和等于该数本身。例如，153是一个水仙花数，因为153 = 1^3 + 5^3 + 3^3。
实现代码如下：

for i in range(100, 1000):
    x = i // 100   # 获取百位数
    y = (i // 10) % 10   # 获取十位数
    z = i % 10   # 获取个位数
    if i == x**3 + y**3 + z**3:
        print(i)

·第十章 函数

10.1 函数的定义

函数是一段封装好的代码，可以通过名称来调用。在Python中，函数使用def关键字进行定义，如下所示：

def function_name(argument1, argument2, ...):
    # 函数体
    return result

这里的function_name是函数名称，argument1, argument2等是函数的参数，
return语句用于返回函数的结果

10.2 函数参数

Python中的函数可以接收0个或多个参数，包括位置参数、默认参数和可变参数。位置参数是指按照顺序传入的参数，而默认参数是指在定义函数时给参数设置默认值，例如：

def greet(name, message="Hello"):
    print(message + ", " + name)

greet("Tom") # 输出 "Hello, Tom"
greet("Bob", "Hi") # 输出 "Hi, Bob"

可变参数可以接收不定数量的参数，包括关键字参数和位置参数，例如：

def calc(*args, **kwargs):
    print(args)
    print(kwargs)

calc(1, 2, 3, a=4, b=5) # 输出 (1, 2, 3) 和 {'a': 4, 'b': 5}

10.3 作用域

Python中的作用域有两种，分别是全局作用域和局部作用域。在函数内部定义的变量属于局部作用域，而在函数外部定义的变量属于全局作用域。例如：

x = 10

def func():
    y = 5
    print(x) # 输出 10
    print(y) # 输出 5

func()
print(y) # 报错，y未定义

当在函数内部使用global关键字声明变量时，可以将局部变量转换为全局变量。

10.4递归

递归是指函数内部调用自身的过程。在Python中，递归可以用于解决一些复杂的问题，例如计算斐波那契数列：

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(5)) # 输出 5

递归必须有一个结束条件，否则会导致无限循环

·第十一章 字符串进阶

11.1 字符串格式化

Python中的字符串格式化可以通过字符串的format()方法来实现

下面是一些关于字符串格式化的例子：

1. 使用位置参数

name = 'John'
age = 20
print('{} is {} years old.'.format(name, age))
# 输出：John is 20 years old.

2. 使用命名参数

name = 'John'
age = 20
print('{n} is {a} years old.'.format(n=name, a=age))
# 输出：John is 20 years old.

3. 使用数字索引

name = 'John'
age = 20
print('{0} is {1} years old.'.format(name, age))
# 输出：John is 20 years old.

4. 使用字典作为参数

person = {'name': 'John', 'age': 20}
print('{name} is {age} years old.'.format(**person))
# 输出：John is 20 years old.

5. 使用列表作为参数

info = ['John', 20]
print('{} is {} years old.'.format(*info))
# 输出：John is 20 years old.

11.2 center()函数

center()函数是Python中用来对齐字符串的函数，可以将一个字符串居中对齐，并在两边填充指定的字符。

使用格式：string.center(width, fillchar)
其中，width表示要对齐后的字符串长度，fillchar表示要填充的字符，默认为空格。

下面是center()函数的一个例子：

str = 'hello'
print(str.center(10, '*'))
# 输出：***hello**

以上代码中，我们将字符串'hello'居中放置，总共长度为10个字符，用星号(*)对字符串两侧进行填充。

11.3 find()函数

find()函数可以用来查找一个字符串中是否包含指定的子字符串，如果包含，则返回子字符串的索引值。如果不包含，则返回-1.

使用格式：string.find(sub, start, end)
其中，sub表示要查找的子字符串，start和end表示搜索的起始位置和结束位置，默认为0和-1.

下面是find()函数的一个例子：

str = 'hello, world'
index = str.find('world')
print(index)
# 输出：7

以上代码中，我们在字符串'hello, world'中查找子字符串'world'，并返回它在字符串中的索引值。

11.4 replace()函数

replace()函数可以用来将一个字符串中的某个子字符串替换成另一个字符串

使用格式：string.replace(old, new, count)
其中，old表示要被替换的字符串，new表示用来替换old的新字符串，
count表示要替换的数量，默认为全部替换。

下面是replace()函数的一个例子：

str = 'hello, world'
new_str = str.replace('world', 'python')
print(new_str)
# 输出：hello, python

以上代码中，我们将字符串'world'替换成了'python'，并生成了新的字符串'hello, python'。

11.5 split()函数

split()函数可以将一个字符串按照指定的分隔符切分成多个子字符串，并以列表的形式返回。如果不传入任何参数，则默认以空格为分隔符。

例如，我们有一个字符串：

str = "hello-world"

可以使用split()函数将其按照-进行切分：

lst = str.split('-')
print(lst)

输出结果为：

['hello', 'world']

11.6 join()函数

join()函数可以将一个列表中的多个字符串通过指定的分隔符连接成一个大字符串，并返回这个大字符串。

例如，我们有一个列表：

lst = ['hello', 'world']

可以使用join()函数将其通过-符号连接起来：

newstr = '-'.join(lst)
print(newstr)

输出结果为：

'hello-world'

11.7 修改字符串大小写的方法

• lower()：将字符串中的所有字母转换为小写；
• upper()：将字符串中的所有字母转换为大写；
• title()：将字符串中每个单词的首字母大写，其他字母小写；
• capitalize()：将字符串中第一个字母大写，其他字母小写。

例如，我们有一个字符串：

str = "hello world"

可以使用上述方法对其进行修改：

print(str.lower())      # hello world
print(str.upper())      # HELLO WORLD
print(str.title())      # Hello World
print(str.capitalize()) # Hello world

·第十二章 面向对象

12.1 面向对象程序设计

面向对象程序设计（OOP）是一种计算机编程的编程范型，它以“对象”为基本单位，将数据和对数据的操作封装在一起，以此来实现程序的组织和设计。

在Python中，一切皆为对象。Python支持多重继承和动态绑定

12.2 创建类

在Python中，可以使用class关键字来创建类。如下所示：

class MyClass:
    pass

上面的代码定义了一个名为MyClass的类，它没有任何方法和属性
可以简单地理解为，它就像是一个蓝图，用于生成对象

12.3 创建对象

在Python中，通过类可以创建对象（也称为类的实例）。创建对象的方法是在类名后加一对圆括号，并传入初始化数据。如下所示：

class MyClass:
    def __init__(self, name):
        self.name = name

my_object = MyClass('John')

上面的代码创建了一个名为my_object的对象，它属于MyClass类，且传入了一个参数name，值为'John'
注意，在初始化方法__init__中，第一个参数self代表对象自身，
在方法体中可以使用self来访问对象的属性和方法。

对象创建完成后，我们可以访问它的属性和方法。如下所示：

print(my_object.name)  # 输出：John

上面的代码输出了my_object对象的name属性，值为'John'

12.4 封装、接口与实现

在面向对象编程中，封装是一种将数据和对数据的操作封装在一起的技术。封装可以起到保护数据的作用，防止外部代码直接访问和修改数据，同时也可以提高代码的可读性和可维护性。

接口是一种定义了类的公共行为的方式。类的实现者通过接口暴露了类的功能，而类的使用者只需要了解接口，就可以使用该类的功能，而无需关心具体的实现细节。

实现是指类的实现者所编写的代码，它实现了类的属性和方法，并实现了接口所定义的公共行为。

12.5 继承

在面向对象编程中，继承是一种派生机制，它允许我们从已有的类中派生出新的类，并继承父类的所有属性和方法。继承展开了面向对象编程的实现空间，并使得程序变得更加灵活和易于维护
在Python中，使用关键字class后跟一个或多个父类的名称，即可实现继承。如下所示：

class ParentClass:
    pass

class ChildClass(ParentClass):
    pass

上面的代码定义了一个名为ParentClass的父类和一个名为ChildClass的子类
它从ParentClass中继承了所有属性和方法。

12.6 类对象的属性和方法

在Python中，类对象同样可以拥有自己的属性和方法。它们与实例对象所拥有的属性和方法存在差异，并被称为类属性和类方法。

类属性是指类对象所拥有的属性。它可以被所有实例对象所共享，并且在任何一个实例对象中进行修改都会影响到其它实例对象。类属性通常用于存储一些与类相关的数据。下面是一个示例：

class MyClass:
    class_variable = 123

my_object1 = MyClass()
my_object2 = MyClass()

print(my_object1.class_variable)  # 输出：123
print(my_object2.class_variable)  # 输出：123

MyClass.class_variable = 456

print(my_object1.class_variable)  # 输出：456
print(my_object2.class_variable)  # 输出：456

类方法是指类对象所拥有的方法。它可以访问类属性和类方法，并且不需要实例化对象即可调用。类方法通常用于提供一些与类相关的功能。下面是一个示例：

class MyClass:
    class_variable = 123

    @classmethod
    def class_method(cls):
        print('Class variable:', cls.class_variable)

MyClass.class_method()  # 输出：Class variable: 123

这就是Python中类对象的属性和方法的基础知识。了解并掌握这些内容，将使得我们能够更加灵活地使用面向对象编程技术，并编写出更加复杂和强大的程序。

注：

print("@Creation time--2023·6·13")