Python（一）

第一章 Python的介绍

1. Python是什么

​ Python是一种广泛使用的解释型、高级和通用的编程语言。Python支持多种编程范型，包括结构化、过程式、反射式、面向对象和函数式编程。它拥有动态类型系统和垃圾回收功能，能够自动管理内存使用，并且其本身拥有一个巨大而广泛的标准库。它的语言结构以及面向对象的方法，旨在帮助程序员为小型的和大型的项目编写逻辑清晰的代码。

​ Python的设计哲学强调代码的可读性和简洁的语法，尤其是使用空格缩进来划分代码块。相比于C语言或者Java，Python可以让开发者用更少的代码表达想法。Python解释器本身几乎可以在所有的操作系统中运行，Python是世界上最受欢迎的编程语言之一。

2. Python优点

• 易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。

• 广泛的标准库：Python最大的优势之一就是有着丰富的库。Python拥有一个强大的标准库，Python语言的核心只包含一些常见类型和函数，而Python标准库提供了系统管理、网络通信、文本处理、文件系统等额外的功能。

• 大量的第三方模块：Python社区提供了大量的第三方模块，使用方式与标准库类似。它们的功能覆盖Web开发 、数据分析 、人工智能 、自动化等多个领域。

3. Python的缺点

• 运行速度慢：和C程序相比非常慢，因为Python是解释型语言，代码在执行时会一行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时

4. Python解释器

当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。事实上，存在多种Python解释器，但使用最广泛的还是CPython。

当我们从Python官方网站下载并安装好Python 3.x后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。

5.Python代码规范

1. 缩进

在 Python 中，代码块的结束不像其他一些编程语言（如 C、Java 等）使用大括号 {} 来明确界定，而是通过缩进来表示。建议每级缩进都使用四个空格，这既可提高可读性，又留下了足够的多级缩进空间。

#正确使用：✅
def specification():
    x=10
    if x > 0:
        print("Positive")  
        print("This is inside the if block")
    print("This is outside the if block")  # 回到外层
    
# 错误使用 ❌   
def specification():
    x=10
    if x > 0:
     print("This is inside the if block")
     print("This is outside the if block")  

2. 分号

不要在行尾加分号.

#正确使用：✅
str1="abc" 
# 错误使用 ❌   
str2="bcd";

3. 不以空格结束一行代码

在任何地方都不要以空格结束本行代码， 因为行末的空格不可见， 这可能会出问题。

# 错误写法1：行末有空格（不可见）
message = "Hello, " \ 
          "World!"  # 这里 `\` 后面有一个空格（看不见但存在）

print(message)  # 报错：SyntaxError: unexpected character after line continuation character

# 错误写法2：行末有空格
str1 = "Hello, "    # 行末有空格
str2 = "World!"     # 行末有空格
combined = str1 + str2

print(combined)  # 输出 "Hello, World!"（但 str1 和 str2 实际包含多余空格）

4. 注释

4.1 单行注释

Python中 # 后的一行内的内容会被视为注释,为了保持注释的整洁，Python官方建议在#和注释的内容之间加一个空格。

# print("hello world")
print("hello world")  # 打印hello world

4.2 多行注释（块注释）

Python中使用三个引号开始，三个引号结束（单引号或者双引号都可以），为多行注释

多行注释在说明文字需要换行时使用，不能嵌套

#正确使用：✅
'''
这也是多行注释，
使用双引号效果相同。
但 Python 官方推荐用双引号写 docstring。
'''

"""
这也是多行注释，
使用双引号效果相同。
但 Python 官方推荐用双引号写 docstring。
"""

print("Hello, World!")  # 这行代码仍然会执行

# 错误使用 ❌ 
'''
外层注释
''' 内层注释 '''
''' 
# 函数/类的文档字符串（docstring）
def calculate_sum(a, b):
    """
    计算两个数的和（这是 docstring，属于函数的一部分）
    参数:
        a (int): 第一个数
        b (int): 第二个数
    返回:
        int: 两数之和
    """
    return a + b


# 查看函数的 docstring
print(calculate_sum.__doc__)

---

第二章 Python环境安装

1.1 Anaconda3的安装

Anaconda是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项。其中，conda是一个开源的包、环境管理器，可以用于在同一个机器上安装不同版本的软件包及其依赖 ，并能够在不同的环境之间切换

Anaconda对于新手十分友好，通过安装Anaconda可以省去很多安装Python主程序的麻烦。

​ https://www.anaconda.com/download

brew install --cask anaconda

编辑环境变量

Homebrew 默认会把 Anaconda 安装在 /usr/local/anaconda3（Intel Mac）或 /opt/homebrew/anaconda3（M系列 Mac）下。需要将它加入 PATH：

echo 'export PATH="/opt/homebrew/anaconda3/bin:$PATH"' >> ~/.zshrc

source ~/.zshrc

# 验证安装
conda --version

若输出版本号，如 conda 25.11.0，则说明安装成功。

创建与管理虚拟环境

# 创建一个新的虚拟环境 比如创建名为 XXX 的环境并使用 Python 3.10：
conda create -n YOUR_ENV_NAME python=3.10
conda create -n pyliming python=3.10

激活创建好的环境

conda activate YOUR_ENV_NAME
conda activate pyliming

# 退出环境
conda deactivate

# 查看所有环境
conda env list

# 删除环境
conda remove -n mlenv --all

1.2 Pycharm的安装

​ Pycharm可以从官方下载专业版，然后通过任意方式去激活。安装成功后，要去配置Python运行环境。

​ File -> Setting -> Pythoin YOUR_PROJECT

第三章 Python的基本语法

1.变量

1.1 变量的定义

​ 变量是在程序运行时，能储存计算结果或能表示值的抽象概念。

1.2 变量的定义格式

在Python中，定义变量的基本格式是：

变量名称 = 变量的值

其中：

• 变量值
  指的是赋值语句中等号右侧 的内容，代表实际存储的数据，比如一个数字、字符串、列表等。每个变量内部都会有一个存储的内容，称为变量值。
• 赋值
  等号（=）表示赋值操作 ，它的作用是把右边的值赋给左边的变量。即：先计算等号右边的值，再把这个值绑定到左边的变量名上。
• 变量名
  指的是等号左侧的名称，是对存储数据的一种标识符。变量名代表变量本身，可以通过这个名字来访问对应的变量值。

1.3 变量的创建

变量创建方式：变量名 = 变量值

Python 变量无需预先指定类型或显式声明存在，直接赋值即可自动创建并使用。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

# 简单变量的创建：
var1 = 2  # 定义一个变量，变量名为var1，变量值为2

var2 = 3  # 定义一个变量，变量名为var2，变量值为3

result = var1 + var2  # 定义一个变量，变量名为result，变量值为var1和var2相加的结果
print(result)  # 打印result变量的值

name = "张三"
age = 18
weight = 1000.3

# 多个变量的创建
var1 = var2 = var3 = 10  # 多个变量的值相同
var4, var5, var6 = 10, 20, 30  # 多个变量的值不同

变量的特点：

• 动态类型

  变量的类型由赋值的值决定，且可随时改变

  a = 10      # a 是整数
  a = "hello" # a 变成字符串

• 赋值即创建

  未赋值的变量不存在 ，直接使用会报 NameError

  print(x)  # 报错：NameError: name 'x' is not defined

• 变量是对象的引用

  Python 变量本质是对象的引用（指针），而非存储数据的容器：

  a = [1, 2, 3]
  b = a       # b 和 a 引用同一个列表
  b.append(4)
  print(a)    # 输出 [1, 2, 3, 4]

1.4 变量的修改

在程序中可随时修改变量的值，而Python将始终记录变量的最新值。

message = "hello world"
print(message)

message = "hello world hello world"
print(message)

1.5 常量

在程序中定义后就不再修改的值为常量，Python中没有内置的常量类型。一般约定使用全大写变量名来表示常量

PI = 3.1415926
E = 2.718282

2. 数据类型

2.1 数据类型的概念

在Python中，每一份数据都有一个确定的数据类型（Data Type）。

数据类型决定了：

• 数据的表现形式(书写、存储)
• 数据可以执行哪些操作
• 程序在运行时如何处理它

Python是一门动态类型语言，意味着变量在赋值时，不需要提前声明数据类型，解释器在运行时依然严格依赖类型规则，会根据赋的值自动推断出类型。

2.2 常见数据类型种类

Python3中常见的数据类型分类如下，主要类型有六种：

基本数据类型

数值

• 整数（int）、浮点数（float）、复数（complex）、布尔（bool）

字符串（str）

容器数据类型

• 列表（list）

  • 1,2,3

• 元组（tuple）

  • (10,11,12)

• 集合（set）

  • {1,3,5}

• 字典（dist）

  • {"name":"zs","age":"12"}

特殊数据类型

• None：表示空值或缺失值，只有一个值 None。常用于函数没有返回值时，或者表示变量没有被赋值。

​ 上图的int、float、complex、bool都属于Number（数值）数据类型。

3. 数值类型（number）

3.1 int整形

注意：Python可以处理任意大小的整数，包括负整数。

如 10、-7(负整数)

num1 = 10
num2 = -7

如 1_000_000_000_000_000 （很大的整数）

num1 = 1_000_000_000_000_000
print(num1)  # 1000000000000000

注意：

• 书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读
• 存储这种数时，Python会忽略其中的下划线

3.2 float浮点型

Python将所有带小数点的数称为浮点数

num1 = 0.1
num2 = 0.2
print(num1+num2)
###结果###
0.30000000000000004

注意：在使用浮点数进行计算时可能会存在微小误差，可以通过导入decimal解决。

from decimal import Decimal
num3 = Decimal('0.1') # '' 或 "" 都可以
num4 = Decimal('0.2') # '' 或 "" 都可以
print(num3+num4)
###结果###
0.3

3.3 bool类型

布尔型变量只有 True 和 False，用于真假的判断，注意True 不是true False 不是false

bool1 = True
bool2 = False
print(bool1, bool2)  # True False
###结果###
True False

注意：Python3中，bool 是 int 的子类，True 和 False 可以和数字相加。

print(issubclass(bool, int))
bool1 = True
bool2 = False
print(bool1+1)
print(bool2+1)
###结果###
True
2
1

同样，你可以用True==1 或者 False==0来检测。

bool1 = True
bool2 = False
print(bool1==1)
print(bool2==0)
###结果###
True
True

注意 ：is 运算符用于比较，但是它用于身份比较（即它们是否是同一个对象，是否在内存中占据相同的位置），

print(True is 1) 
print(False is 0) 
###结果###
False
False

a = [1, 2, 3] # 列表
b = a  # b 和 a 引用同一个列表对象
print(a is b)  # True（同一对象）

c = [1, 2, 3]
print(a is c)  # False（值相同，但不同对象）
###结果###
True
False

小总结：

操作符	比较内容	等效调用
==	值是否相等	a.eq(b)
is	是否同一对象	id(a) == id(b)

除此自外，多提一嘴，在Python中，能够解释为假的值不只有False，还有：

None

0

0.0

False

所有的空容器（空列表、空元组、空字典、空集合)以及空字符串）但是并不能说

None == False 或者None is False只能说布尔上下文中，它们都会被当作"假值"处理逻辑：

if not None:
    print("None is falsy")  # 会执行

if not False:
    print("False is falsy") # 会执行

4.字符串类型 (str)

4.1 字符串概念

字符串就是一系列字符。在Python中，用引号括起的都是字符串， 可以使用单引号 '...' 或双引号 "..." 创建。也可使用反斜杠 \ 转义特殊字符。

str1 = "Hello, Python!"
str2 = 'Hello, Python!'
print(str1)
print(str2)
###结果###
Hello, Python!
Hello, Python!

也可以方便的在字符串中包含单引号或双引号。

str1 = "This is a 'string'"
str2 = 'This is a "string" too'
print(str1)  # This is a 'string'
print(str2)  # This is a "string" too

也可以使用三个引号表示多行字符串。三引号允许一个字符串跨多行.一个典型的用例是，当你需要一块HTML或者SQL时，使用三个引号就很简单

str1 = """hello world
HELLO WORLD"""
print(str1)
###结果###
hello world
HELLO WORLD

4.2 字符串特点

• 字符串是不可变的、有序的。
• 字符串中元素不可修改
• 字符串使用单引号、双引号或三重引号定义。
• 字符串中每个值都有对应的位置值，称为索引或下标，索引从起始从0开始向后逐个递增，并且末尾从-1开始逐个向前递减。

4.3 字符串访问

str1 = "hello world"
print(str1[0])
print(str1[-1])
print(str1[4:-3]) # 前闭（包含）后开（不包含）左闭右开

4.4 字符串相加

str1 = "hello world\n"
str2 = "welcome to python"
print(str1 + str2)
### 结果###
hello world
welcome to python

4.5 字符串乘法

str1 = "hello world"
print(str1 * 2)  # hello worldhello world
#或者
str2 = "hello world"*2
print(str2)
###结果###
hello worldhello world
hello worldhello world

注意：不能用字符串+2（整数）这种写法。

str3 = "hello world"+2
print(str3)
### 结果###
TypeError: must be str, not int

字符串乘法 str \* n 的设计逻辑：

Python 的字符串类 (str) 定义了 __mul__ 方法，允许 * 操作符与整数交互。

字符串乘法 str \+ n 的设计逻辑：

Python 严格区分类型，字符串的 + 操作符（通过 __add__ 方法）仅支持与其他字符串拼接。整数与字符串拼接缺乏明确的语义（是转换成字符串再拼接，还是数学相加？），因此 Python 选择直接禁止，抛出异常。

4.6 字符串编解码

编码：将字符串数据类型转换为字节型数据的过程成为编码 encode，需要指定编码类型

解码： 将字节型数据转换为字符型数据的过程称为解码 decode

# 原始字符串
str1 = '你好中国'
print(str1)
# 编码
byte1 = str1.encode(encoding='utf8')
print(byte1)
print(type(byte1))  # <class 'bytes'>

# 解码
str2 = byte1.decode(encoding='utf8')
print(str2)  # 你好中国
print(type(str2))  # <class 'str'>

###结果###
你好中国
b'\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xb8\xad\xe5\x9b\xbd' # 12个字节
<class 'bytes'>
你好中国
<class 'str'>

4.7 成员是否为字符串中元素

str1 = "hello world"
print("lo" in str1)  # True
###结果###
True

4.8 字符串的常用函数操作

1.split()

str= "welcome to the world of python"
print(str.split()) # 默认按任何空白字符串分隔并在结果中丢弃空字符串

str1= "川菜,粤菜,湘菜,鲁菜"
print(str1.split(",",2)) #按x分隔字符串 可指定最大分隔次数

###结果###
['welcome', 'to', 'the', 'world', 'of', 'python']
['川菜', '粤菜', '湘菜,鲁菜']

2.replace()

str1= "川菜,粤菜,湘菜,鲁菜,粤菜,粤菜"
print(str1.replace("粤菜", "苏菜",2))

###结果###
川菜,苏菜,湘菜,鲁菜,苏菜,粤菜

3.join()

用法：str.join(iterable)

其中：

• str 是连接符（可以是任意字符串）。
• iterable 是需要连接的可迭代对象（如列表、字符串等）。

result = "-".join("abc")  
print(result)
###结果###
a-b-c

foods = ["川菜", "粤菜", "湘菜"]
result1 = "、".join(foods)  # 用 "、" 连接列表元素
print(result1)
###结果###
川菜、粤菜、湘菜

str1 = "川菜,粤菜,湘菜,鲁菜,粤菜,粤菜"
split_list = str1.split(",")  # 按逗号分割成列表
result = "-".join(split_list)  # 用 "-" 连接列表元素
print(result)
###结果###
川菜-粤菜-湘菜-鲁菜-粤菜-粤菜

4.find()

str= "welcome to the world of python"

print(str.find("world", 0, 20)) 
###结果###
15

5.index()

str= "welcome to the world of python"
print(str.index("to"))
###结果###
8

6.find()与index（）区别

# 1.找到子串时
s = "hello world"
print(s.find("world"))    # 输出: 6
print(s.index("world"))   # 输出: 6

# 2.未找到子串时
# find() 返回 -1
print(s.find("Python"))  # 输出: -1
# index() 抛出异常：
print(s.index("Python"))  # 抛出 ValueError: substring not found

# 3.index() 的扩展用法
# index() 还可用于 列表（list） 和 元组（tuple），而 find() 仅限字符串：
# 列表中使用 index()
lst = [10, 20, 30]
print(lst.index(20))  # 输出: 1

# 元组中使用 index()
tup = (1, 2, 3)
print(tup.index(3))   # 输出: 2

find()和index()区别对比

方法	适用类型	找到子串时	未找到子串时	错误处理
find()	字符串（str）	返回子串的起始索引（≥0）	返回 -1	不报错
index()	字符串、列表、元组	返回子串的起始索引（≥0）	抛出 ValueError	报错

其它函数：

函数	说明
str.replace(old,new,max)	把将字符串中的old替换成new,如果指定max，则替换不超过max次
str.split(x,n)	按x分隔字符串，默认按任何空白字符串分隔并在结果中丢弃空字符串。可指定最大分隔次数
str.rsplit(x,n)	与split()类似，从右边开始分隔
x.join(seq)	以x作为分隔符，将序列中所有的字符串合并为一个新的字符串
str.strip(x)	截掉字符串两边的空格或指定字符
str.lstrip(x)	截掉字符串左边的空格或指定字符
str.rstrip(x)	截掉字符串右边的空格或指定字符
str.removeprefix()	截掉字符串指定前缀
str.removesuffix()	截掉字符串指定后缀
str.upper()	将所有字符转为大写
str.lower()	将所有字符转为小写
str.swapcase()	反转字符串中字母大小写
str.capitalize()	将字符串第一个字母变为大写，其他字母变为小写
str.title()	将字符串每个单词首字母大写
str.casefold()	返回适合无大小写比较的字符串版本
len(str)	返回字符串长度
max(str)	返回字符串中最大值
min(str)	返回字符串中最小值
str.find(x,start,end)	返回字符串中第一个x的索引值，不存在则返回-1，可指定字符串开始结束范围
str.rfind(x,start,end)	与find()类似，从右边开始查找
str.index(x,start,end)	返回字符串中第一个x的索引值，不存在则报错，可指定字符串开始结束范围
str.rindex(x,start,end)	与index()类似，从右边开始查找
str.count(x,start,end)	返回字符串中x的个数，可指定字符串开始结束范围
str.startswith(x,start,end)	检查字符串是否以x开头，可指定字符串开始结束范围
str.endswith(x,start,end)	检查字符串是否以x结尾，可指定字符串开始结束范围
str.isspace()	检查字符串是否非空且只包含空白

5.输入与输出

5.1 输入

输入：如果接收用户在键盘上输入一些字符，Python提供了一个input()函数，可以让用户输入字符串，并存放到一个字符串变量里。

语法：字符串变量 = input("提示信息")

# Python开始等待你的输入。这时，你可以输入任意字符，然后按回车后完成输入。
input_str = input("请输入：")
# 输入完成后，不会有任何提示，刚才输入的内容存放到input_str变量里了
print("input_str数据类型为:",type(input_str))
# 输出input_str查看变量内容
print(input_str)

5.2 输出

• 普通输出

  # 使用 print() 可将内容打印。
  print("Hello Python")
  # 多个内容之间可以使用逗号隔开。
  int1=10
  float1=10.0
  print("int1=", int1)
  # 可以使用 end= 来控制 print() 以什么结尾
  print("使用\\n结尾", end="\n")  # 用\n结尾，默认就是 \n（换行）
  print('使用""结尾', end="")  # 用空字符串结尾
  
  ###输出结果###
  使用\n结尾
  使用""结尾Hello

• 格式化输出

  （1）字符串中使用 % 占位

  int1 = 10
  float1 = 3.14159
  # %d：d 是 decimal（十进制整数）的缩写，用于将数据格式化为整数 %.3f 表示保留 3 位小数
  str1 = "int1 = %d, float1 = %.3f" % (int1, float1)
  print(str1)  # int1 = 10, float1 = 3.141590
  
  ###输出结果###
  int1 = 10, float1 = 3.142

  （2）字符串.format()

  1. 显示指定索引,可灵活调整输出顺序。

     # 1.重复引用同一变量
     name = "Alice"
     age = 25
     greeting = "Hi {0}! {0} is {1} years old.".format(name, age)
     print(greeting)
     # 输出: Hi Alice! Alice is 25 years old.
     
     # 2.调整参数顺序
     x, y = 10, 20
     result = "y = {1}, x = {0}".format(x, y)
     print(result)

  2. 隐式索引

     #  隐式索引,直接按顺序填充，避免索引干扰格式化符号（如 `:02d`）
     # 1.简单顺序拼接
     fruit = "apple"
     price = 1.5
     msg = "The {} costs ${:.2f}.".format(fruit, price)
     print(msg)
     # 输出: The apple costs $1.50.
     # 2.结合数字格式化
     hours, minutes = 3, 5
     time = "{:02d}:{:02d}".format(hours, minutes)
     print(time)
     # 输出: 03:05

  3. 设置参数

     int1 = 10
     float1 = 3.14159
     bool1 = True
     str2 = "int1 = {i1}, float1 = {f1}, bool1 = {b1}".format(i1=int1, f1=float1, b1=bool1)
     print(str2)  # int1 = 10, float1 = 3.14159, bool1 = True
      
     ###输出结果###
     # int1 = 10, float1 = 3.14159, bool1 = True

  4. f-string(字符串)

     现代 Python 代码中，f-string 是更简洁、高效的格式化方案：

     字符串前加上一个 f ，字符串中的{}内写入变量名

     # 直接在字符串中嵌入变量名，可读性极强。
     # 支持表达式和函数调用
     int1 = 10
     float1 = 3.14159
     str1 = f"int1 = {int1}, float1 = {float1}"
     str2 = f"int1 = {int1+1}"
     print(str1)  # int1 = 10, float1 = 3.14159
     print(str2) # 11
     ###输出结果###
     # int1 = 10, float1 = 3.14159
     # 11

第四章 Python运算符

1. 算数运算符

运算符	说明	实例
+	加	a + b
-	减、或取负	a - b、-a
*	乘	a * b
/	除	a / b
//	整除，除后向下取整	a // b
%	模，返回除法的余数	a % b
**	幂	a ** b

a = 20
b = 10
c = a + b
print(a , "+" , b , "的结果为" , c)
c = a - b
print(a , "-" , b , "的结果为" , c)
c = a * b
print(a , "*" , b , "的结果为" , c)
c = a / b  #注意：结果为浮点类型
print(a , "/" , b , "的结果为" , c)
c = a % b
print(a , "%" , b , "的结果为" , c)
a = 2
b = 3
c = a ** b
print(a , "的" , b , "次方结果为" , c)
a = 10
b = 3
c = a // b
print(a , "//" , b , "的结果为" , c)
###输出结果###
20 + 10 的结果为 30
20 - 10 的结果为 10
20 * 10 的结果为 200
20 / 10 的结果为 2.0
20 % 10 的结果为 0
2 的 3 次方结果为 8
10 // 3 的结果为 3

2. 赋值运算符

运算符	说明	实例
=	赋值	a = 1
+=	加法赋值	a += 2，等同于a = a + 2
-=	减法赋值	a -= 2，等同于a = a - 2
*=	乘法赋值	a *= 2，等同于a = a * 2
/=	除法赋值	a /= 2，等同于a = a / 2
//=	整除赋值	a //= 2，等同于a = a // 2
%=	模赋值	a %= 2，等同于a = a % 2
**=	幂赋值	a **= 2，等同于a = a ** 2
:=	海象运算符，在表达式中同时进行赋值 和返回运算结果。Python3.8 版本新增	num1 = 20 print((num2 := 3**2) > num1) print(num2)

3. 比较运算符

运算符	说明	实例
==	相等，比较两者的值	a == b
!=	不相等	a != b
>	大于	a > b
<	小于	a < b
>=	大于等于	a >= b
<=	小于等于	a <= b

num1 = 10
num2 = 20
print(num1 == num2)  # False
print(num1 != num2)  # True
print(num1 > num2)   # Flase
print(num1 < num2)   # True
print(num1 >= num2)  # False
print(num1 <= num2)  # True
num3 = 'abc'
# 注意：不同的数据类型之间不能进行大小的比较
print(num1 > num3)
# 如果是字符串比较大小，是从最左边开始逐个比较字符串中相应位置的字符的ASCII码
print('5' > '6') # False # '5'（ASCII码）53 '6'（ASCII码）54 
print('15' > '6') # False # '1' 的 ASCII 码是 49。 '6' 的 ASCII 码是 54。49 < 54，所以 '1' < '6'，此时已经可以确定 '15' < '6'，直接返回 False,不会继续比较后面的字符（即使 '15' 比 '6' 长）

###输出结果###

TypeError: '>' not supported between instances of 'int' and 'str'
False
True
False
True
False
True
False

4. 逻辑运算符

运算符	说明
and	与&，x and y，从左到右依次求值， 如果 所有操作数为真 ，返回 最后一个真值 如遇到假值 ，直接返回 第一个假值，并停止后续计算。
or	或，x or y，从左到右依次求值 ， 如果 遇到第一个真值 ，直接返回它，并停止后续计算。 如果 所有操作数为假 ，返回 最后一个假值
not	非，not x，若x为True返回False，若x为False返回True

b1 = False
b2 = True
print(b1 and b2)  # False

print(b1 or b2)  # True
print(not(b1))  # True
print(5 and 8) # 8 非0表示True，0表示False 最后一个为真，返回最后一个真值
print(0 and 8) # 0 遇到假值 直接返回第一个假值，停止后面计算
print(5 or 8)  # 5 遇到真值 直接返回第一个真值，停止后面计算
print(0 or 8)  # 8 遇到真值 直接返回第一个真值
print(0 or 0.0) # 0.0 遇到价值 返回最后一个假值  
print(not(5))  # False

### 输出结果###
False
True
True
8
0
5
8
0.0
False

5. 成员运算符

运算符	说明	实例
in	在指定的序列中找到值返回 True，否则返回 False	a in 'a', 'b', 'c'
not in	在指定的序列中没有找到值返回 True，否则返回 False	a not in 'a', 'b', 'c'

num6 = 1
num7 = 20
test_list = [1,2,3,4,5]
print(test_list)
print(num6 in test_list) # True 判断1是不是列表中的的成员
print(num7 not in test_list) # True

###输出结果###
[1, 2, 3, 4, 5]
True
True

6. 身份运算符

运算符	说明	实例
is	判断两个标识符是不是引用自相同对象	a is b，类似id(a) == id(b)。如果引用的是同一个对象则返回True，否则返回False
not is	判断两个标识符是不是引用自不同对象	a is not b，类似id(a) != id(b)。如果引用的不是同一个对象则返回True，否则返回False

# -------------身份运算符---------------
m = 20
n = 20
q = 30
print(m is n)  # True 判断m和n在内存中是否指向同一个地址
print(n is q)  # False
print(n is not q)  # True
# id() 用于获取对象在内存中的地址
print(id(m) == id(n)) # True

print("-" * 30)
# -------------is和==的区别---------------
a = [1,2,3]
b = a

print(b is a)  # True
print(b == a)  # True

b = a[:]  #简单列表的复制
print(b)
print(b is a)  # False b 是一个新的列表对象，和 a 不是同一个对象（b is a 返回 False）
print(b == a)  # True 两个列表的元素值是一样

###输出结果###
True
False
True
True
------------------------------
True
True
[1, 2, 3]
False
True

---

第五章 流程控制语句

1. 顺序

按照程序正常的执行顺序，一条线直接走完，依次执行每条语句。

2. 分支

分支流程又叫条件控制语句或者分支语句或者选择语句，是通过条件判断来决定执行的代码。一条线不能直接走完。

2.1 单分支

• 语法

  if 条件:
  
    # 语句

• 说明

  Python程序语言指定任何非0和非空（null）值为True，0 或者 null为False。

  if语句的判断条件可以用条件表达式来表示其关系，后面的:必须加。其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围，缩进取消后，就不在分支范围了。如果条件不成立，不执行语句块内容。

• 案例

  商品价格50，若余额小于50则提示"余额不足，请充值"，最后打印"欢迎下次光临"。

from random import randint

# 余额
balance = randint(0, 100)
# 价格
price = 50
# 打印余额
print(f"余额：{balance}")
# 比较余额和价格
if balance < price:
    print("余额不足，请充值")
print("欢迎下次光临")

# 简单的语句组:你也可以在同一行的位置上使用if条件判断语句，例如
var = 100 
if ( var  == 100 ) : print("变量 var 的值为100")

2.2 双分支

• 语法

  if 条件:
  
    # 语句1
  
  else:
  
    # 语句2

• 说明

  先进行条件判断，如果条件判断成立就执行step1， 条件不成立就执行step2

• 案例

  余额随机，商品价格50。

  若余额小于50则提示"余额不足，请充值"。

  否则提示消费成功。

  最后打印"欢迎下次光临"。

  from random import randint
  
  # 余额
  balance = randint(0, 100)
  # 价格
  price = 50
  # 打印余额
  print(f"余额：{balance}")
  # 比较余额和价格
  if balance < price:
      # 如果余额小于价格
      print("余额不足，请充值")
  else:
      # 如果余额大于价格
      balance = balance - price
      print(f"消费成功，余额：{balance}")
  print("欢迎下次光临")

2.3 多分支

• 语法

  if 条件1:
  
    # 语句1 # 条件1满足时执行
  
  elif 条件2: #条件1不满足时检查条件2
  
    # 语句2   # 条件2满足时执行
  
  elif 条件3: #条件1条件2都不满足时检查条件3
  
    # 语句3 # 条件2满足时执行
  
  else:  # else如不需要可以省略 #所有条件都不满足执行
  
    # 语句4

• 说明

  if 语句后面可以跟 elif...else 语句，这种语句可以检测到多种可能的情况，所以也称之为多分支结构。

  如果条件判断1成立，那么执行语句块1的内容；如果条件判断2成立，那么执行语句块2的内容；如果条件判断3成立，那么执行语句块3的内容；如果条件判断1，2，3都不成立，那么执行语句块4的内容；

  使用多分支语句的时候，需要注意下面几点：

  1） if 语句至多有1个else语句，else语句在所有的else if语句之后。

  2）if语句可以有若干个 elif 语句，它们必须在else语句之前。

  3）一旦其中一个分支语句检测为 true，其他的elif以及else语句都将不再执行。

• 案例

  判断处于人生哪个阶段。

  →如果年龄小于2岁，就打印一条消息，指出这个人是婴儿。

  →如果年龄为2（含）～4岁，就打印一条消息，指出这个人是幼儿。

  →如果年龄为4（含）～13岁，就打印一条消息，指出这个人是儿童。

  →如果年龄为13（含）～20岁，就打印一条消息，指出这个人是青少年。

  →如果年龄为20（含）～65岁，就打印一条消息，指出这个人是成年人。

  →如果年龄超过65岁（含），就打印一条消息，指出这个人是老年人。

  from random import randint
  
  # 定义年龄并打印
  print("此人年龄为", age := randint(0, 100))
  if age < 2:
      # 如果年龄<2
      print("这是个婴儿")
  elif age < 4:
      # 如果2<=年龄<4
      print("这是个幼儿")
  elif age < 13:
      # 如果4<=年龄<13
      print("这是个儿童")
  elif age < 20:
      # 如果13<=年龄<20
      print("这是个青少年")
  elif age < 65:
      # 如果20<=年龄<65
      print("这是个成年人")
  
      # 如果65>=年龄
      print("这是个老人")

2.4 嵌套分支

• 语法

  if 条件1:
      if 条件2: # 嵌套在条件1内部
         # 语句1 # 条件1和条件2同时满足时执行
      else:
         # 语句2 # 条件1满足但条件2不满足时执行
  else: # 条件1不满足时执行
      if 条件3:  
         # 语句3 #条件1不满足条件3满足时执行
      else: 
         # 语句4 #条件1不满足条件3不满足时执行

• 说明

  在一个if语句中，又包含另外一个if语句，这就是if语句的嵌套

• 案例

  用户权限检查,如果是管理员，进一步判断是否有权限，对应不同管理员权限操作，如果不是普通用户，也进一步判断是否有权限，对应不同普通权限操作

  is_admin = False
  is_verified = True
  
  if is_admin:  # 外层条件
      if is_verified:  # 内层条件
          print("管理员且已验证，允许访问所有功能")  # 语句1
      else:
          print("管理员未验证，仅开放部分功能")  # 语句2
  else:
      if is_verified:  # 内层条件
          print("普通用户已验证，允许基础操作")  # 语句3
      else:
          print("未验证用户，禁止访问")  # 语句4

2.5 match case语句

• 语法

  match x:
      case a:
          # 语句1
      case b:
          # 语句2
      case _:
          # 语句3

• 说明

  Python3.10新增了match case的条件判断方式，match后的对象会依次与case后的内容匹配，匹配成功则执行相应语句，否则跳过。其中_可以匹配一切。match 后的对象可以是任何 Python 类型。

• 案例

  给定月份，求该月有多少天。

  | 是专门用于模式匹配的操作符，它能把多个常量或者模式组合起来，实现 "或" 逻辑。

  # 匹配基本类型
  match month := 1:
      case 1 | 3 | 5 | 7 | 8 | 10 | 12:
          print(f"{month}月有31天")
      case 4 | 6 | 9 | 11:
          print(f"{month}月有30天")
      case 2:
          print(f"{month}月可能有28天")
      case _:
          print(f"{month}月有?天")
          
  # 匹配数据类型        
  value = 3.14
  match value:
      case int():
          print("整数")
      case float():
          print("浮点数")  # 输出: 浮点数     
          
  # 匹配字典类型
  data = {"name": "Alice", "age": 30}
  match data:
      case {"name": str(name), "age": int(age)}:  # 类型+解构（匹配结构 + 提取变量"）
          print(f"{name}, {age}岁")  # 输出: Alice, 30岁
      case _:
          print("未知格式")

  解构模式vs传统模式

  data = {"name": "Alice", "age": 30}
  
  if "name" in data and "age" in data:
      name = data["name"]
      age = data["age"]
      print(f"姓名: {name}, 年龄: {age}")
  else:
      print("不匹配")
  match data:
      case {"name": name, "age": age}:
          print(f"姓名: {name}, 年龄: {age}")
      case _:
          print("不匹配")    

2.6 三目运算符

• 语法

  表达式1 if 判断条件 else 表达式2

• 案例

  num1 = 2
  num2 = 3
  if num1 > num2:
      max_num = num1
  else:
      max_num = num2
  print(max_num)
  # 使用三目运算符
  num1 = 2
  num2 = 3
  max_num = num1 if num1 > num2 else num2
  print(max_num)

3 .循环

3.1 while循环

在满足某个条件下，重复的执行某段代码。

注意 ：python中没有 do...while ，即 "先执行一次，再检查条件" 的语法，但可以用 while True + break 模拟它的行为：

• 语法

  while 表达式:
      # 语句-循环体
  # 或者搭配else使用    
  while 表达式：
      # 语句-循环体
  else
      # 语句

• 说明

  先判断条件是否成立，如果条件成立就执行循环体一次；然后再判断条件是否成立，如果成立，继续执行循环体，直到循环条件不成立的时候，才会结束循环，执行循环下面的其他语句。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。执行语句可以是单个语句或语句块。

  如果条件表达式一直成立，那称之为无限循环，也叫死循环。

• 案例1

  import time
  num = 1
  while num < 100:
      print("\r" + "=" * num,end="")  # \r 回到行首，覆盖上次输出
      num += 1
      time.sleep(0.05)  # 控制进度条速度

• 案例2：

  第1周有2只兔子，此后每周兔子的数量都增加上周数量的2倍，且期间没有兔子死亡，求第10周共有多少只兔子

  rabbit = 2
  week = 1
  while week < 10:
      rabbit = rabbit + rabbit * 2
      week += 1
  else:
       print(f"第{week}周有{rabbit}只兔子")

  不过此时else中代码，写在else中和写在循环外效果一样。

• 案例3：

  当用户输入quit退出循环,模拟do...while...

  while True:  # 无条件进入循环
      # 先执行一次代码
      user_input = input("请输入 'quit' 退出: ")
      if user_input == "quit":
          break  # 满足条件时退出

3.2 for循环

for 循环可以用来遍历可迭代对象，如列表或字符串。

for 循环后也可以加上 else，循环结束后会执行 else 中语句。

• 语法

  for 临时变量 in 可迭代对象:
      # 语句

  for 临时变量 in 可迭代对象:
      # 语句1
  else:
      # 语句2

• 说明

  关键字说明：

  • for是关键字
  • 临时变量是自己定义的用来存储遍历出来元素的变量名字
  • in是关键字
  • 可迭代对象是要遍历的序列
  • : 必须要有

  运行流程：

  • 首先判断是否有下一个元素可以获取
  • 如果有，则将元素取出，赋值给临时变量
  • 继续判断是否有下一个元素可以进行取出
  • 直到将所有元素都取出，循环结束

• 案例

  （1）遍历列表

  for i in [2, 3, 5, 7, 11, 13, 17, 19]:
      print(i)

  （2）遍历字符串

  for i in "hello world":
      print(i)

  （3）遍历range数列

  #  range(10) 生成一个从 0 开始到 9 结束的整数序列（共 10 个数字），不包含 10 本身。
  for i in range(10):
      print(i)
  # 指定生成数列的范围，从start到stop（不包含stop），可设定步长，默认步长为1，步长可正可负。   
  for i in range(-10, 10):
      print(i)
  
  for i in range(-10, 10,2):
      print(i)
      
  for i in range(10, -10, -3):
      print(i)

  (4) 嵌套循环

  使用嵌套循环打印九九乘法表。

  for row in range(1, 10):
      for col in range(1, row + 1):
          print(f"{row} × {col} = {row * col}", end="\t")
      print(end="\n")

3.3 continue

跳过当前循环块中的剩余语句，继续进行下一轮循环。一般写在if判断中。

• 案例

  打印0-9，跳过偶数。

  for i in range(10):
      if i % 2 == 0:
          continue
      print(i)

3.4 break

跳出当前for或while的循环体，一般写在if判断中。如果for 或while循环通过break终止，循环对应的else 将不执行。

• 案例：

  求0-9每个数自己幂自己的加和，如果大于10000000则循环终止

  Sum=0⁰⁺¹1+2²⁺³3+⋯+9^9>10000000

  sum = 0
  for i in range(10):
      sum = sum + i**i
      if sum > 10000000:
          break
      print(i, sum)
  else:
      print("循环完成,sum = ", sum)

3.5 pass

pass是空语句，是为了保持程序结构的完整性。

pass不做任何事情，一般用做占位语句。

例如：在一个循环中，如果循环体为空，语法会提示报错，

这个时候我们就可以使用pass占位

for i in range(10):
    pass