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