Python前言

Python语言的特性

Python语言:作为一门脚本语言发展起来的编程语言，包含了很多对入门新手非常友好的特性

简单易学:语法非常简单，非常容易理解

胶水语言:可以和其他很多语言混合开发，这也是Python能作为人工智能首选语言的非常重要的特性

应用广泛:脚本运维、WEB网站(django，fask)、数据采集(爬虫)、数据分析(pandas,)

人工智能(pytouch,tensorfow)..都有很重委的应用

社区丰富:Python是一个全民语言，包含非常丰富的第三方功能工具，可以直接使用

Python语言的分类

·动态解释型——Python

动态：编译时，数据类型是不固定的

解释性：通过解释器将开发者书写的代码逐行翻译并递交cpu执行（代码→解释器→cpu）

·静态编译型——C语言、Java

静态：变量在创建时，必须指定数据类型，并且在之后的使用过程中不可以修改

编译型：通过编译器将开发者所写的代码翻译成可执行文件的动作（代码→编译器→.exe→cpu）

Python注释使用

·单行注释

 #打印num的值
 num=100
 print（100）

·多行注释：将多行代码选中按CTRL+/即可

 #打印num的值
 #num=100
 #print（100）

·三引号注释：写文档或者函数的使用说明

我们在IDE(集成开发环境)中查看函数的使用方法时，三引号中的内容就会显示在屏幕上

 def    sum（sum1，sum2）；
 """
 num1:是被加数
 num2:是加数
 返回值 是num1和num2的和
 """
 return    num1+num2

注：没有赋值的时候，他为注释；赋值时，它可以进行赋值，并且可以换行

在cmd中编写程序

1、打开cmd

2、进入python交互模式

---

一、变量

1.1变量的含义

一个容器，计算机当中的存储空间

1.2变量的作用

通过定义一个变量来给这个数据命名，就像一个标签。下次需要使用这个数据，只需要通过这个变量名就可以直接提取，大大提高了效率。

1.3变量命名规则（标识符命名规则）

1、字符范围：英文大小写、数字、下划线

2、变量不能是数字开头或者纯数字

3、变量名有具体的含义

4、变量命名法：小驼峰、大驼峰、下划线、匈牙利命名法

1.31小驼峰

常用于给变量、函数命名

 # 书单 book list
 # 小驼峰
 bookList = ""

1.32大驼峰

常用于给模块、类进行命名

 # 书单 book list
 # 大驼峰
 BookList = ""

1.33下划线

常用于给变量、函数命名

_代表空格

 # 书单 book list
 # 下划线
 book_list = ""

---

二、数据类型

type 函数可以查看数据类型

2.1基本数据类型（int、float、str、bool）

int——整型

float——浮点型

str——字符串型（拼接）

bool——布尔型（只有真或假，Ture和False；常用于条件判断；1为真，0为假）

None——空类型

2.2引用数据类型

引用数据类型在作为参数传递的时候，是引用传递

引用传递：将数据本体传入到函数中参与运算

---

三、运算符

注：1、所有的基本类型中，除了0，“”，none之外，其他都是真

2、参与运算的数，有一个为浮点数，则结果也为浮点数

3.1算术运算符

3.11加法运算符（+）

特点：用于整数、浮点数和其他数据类型（如字符串拼接）

 a = 5
 b = 3
 result = a + b 
 # 输出8

3.12减法运算符（–）

特点：可以应用于多种数据类型的数值

 a = 10
 b = 4
 result = a - b  
 # 输出6

3.13乘法运算符（*）

特点：对于字符串有特殊效果，可以重复字符串

a = 3
b = 4
result = a * b 
# 输出12

3.14除法运算符（/）

特点：总是返回浮点数结果，即使操作数都是整数

a = 7
b = 2
result = a / b  
# 输出3.5

3.15取余运算符（%）

特点：常用于判断奇偶性（m % 2 == 0）

print(7 % 3)   
# 输出1
print(5 % 3)   
# 输出2
print(3 % 5)   
# 输出3 (当m < n时，结果为m)

3.16取整运算符（//）

特点：结果总是向下取整

print(7 // 2)   
# 输出3
print(-7 // 2) 
# 输出-4

3.17幂次运算符（**）

特点：可以计算任意次方

print(2 ** 3)  
# 输出8
print(3 ** 4)  
# 输出81

示例：

# 购物总价计算
price = 2.5
quantity = 3
total = price * quantity  # 使用乘法运算符
print(f"总价: {total}元")  # 输出: 总价: 7.5元

# 判断奇偶性
number = 15
if number % 2 == 0:
print("偶数")
else:
print("奇数")  # 输出: 奇数

# 幂运算应用
area = 10 ** 6  # 计算10的6次方
print(f"面积: {area}平方米")  # 输出: 面积: 1000000平方米

运算符优先级

Python算术运算符的优先级从高到低为：

1. 括号 ()

2. 幂运算 **

3. 乘法 *、除法 /、取模 %、整除 //

4. 加法 +、减法 -

3.2比较（关系）运算符

比较运算符：会构成一个表达式，这个表达式会返回一个bool值结果

3.21等于运算符（==）

a = 10
b = 5
print(a == b)  
# 输出: False

3.22不等于运算符（！=）

a = 10
b = 5
print(a != b)  
# 输出: True

3.23大于运算符（>）

字符串在比较大小的时候，会参照ascii码来比较大小，会从第一个字符开始比较， 若s1[0]>s1[0]，则s1>s2；s1[0]<s1[0]，则s1<s2；若s1[0]==s2[0]，则取下一个字符进行比较

a = 10
b = 5
print(a > b) 
# 输出: True

3.24小于运算符（<）

a = 10
b = 5
print(a < b)  
# 输出: False

3.25大于等于运算符（>=）

a = 10
b = 5
print(a >= b)  
# 输出: True

3.26小于等于运算符（<=）

a = 10
b = 5
print(a <= b) 
# 输出: False

3.3赋值运算符

赋值具有特殊情况

（1）链式赋值：支持多个变量同时赋值为同一值。

x = y = z = 0  
# x、y、z均赋值为0

（2）解包赋值：将序列（如列表、元组）解包后赋值给多个变量。

a, b, c = [1, 2, 3]  
# a=1, b=2, c=3
# 交换变量值
a, b = b, a          
# 交换a和b的值

注意事项：

1、运算顺序：赋值运算符的执行顺序为从右到左。

a = b = c = 20 
# 等价于 c=20; b=c; a=b

2、类型转换：复合赋值运算符可能触发隐式类型转换。例如，整数与浮点数运算后，结果可能变为浮点数。

a = 10
a += 5.5      
# a变为15.5（浮点数）

3.4逻辑运算符

优先级顺序：not > and > or

3.41 and运算符

• 短路规则：若第一个操作数为False，直接返回False，不再计算第二个操作数。

• 返回值规则：若第一个操作数为True，返回第二个操作数的值（非布尔值时保留原值）。

• 真假规则：链接多个bool值或表达式，若一个为假，则整个表达式的结果为假

print(10 and 20)    
# 输出20（非零值视为True，返回第二个操作数）
print(0 and "hello") 
# 输出0（第一个操作数为False，直接返回）

3.42 or运算符

• 短路规则：若第一个操作数为True，直接返回其值，不再计算第二个操作数。

• 返回值规则：若第一个操作数为False，返回第二个操作数的值。

• 真假规则：链接多个bool值或表达式，若一个为真，则整个表达式的结果为真

print(0 or "world")  
# 输出"world"（第一个操作数为False，返回第二个）
print("hi" or 3.14)  
# 输出"hi"（第一个操作数为True，直接返回）

3.43 not运算符

• 单一操作数：对布尔值取反，非布尔值会先被转换为布尔类型再取反。

print(not None)      
# 输出True（None视为False）
print(not [1, 2])   
# 输出False（非空列表视为True）

3.5身份运算符

3.51 is运算符

• 功能：判断两个对象是否引用自同一个内存地址。

• 返回值：如果两个对象是同一个对象（即内存地址相同），则返回 True；否则返回 False。

• 查看：通过id（）

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

print(a is b)  
# True，因为 b 是 a 的引用
print(a is c)  
# False，虽然值相同，但内存地址不同

arr1 = [1,2,3]
arr2 = [1,2,3]
print（arr1 == arr2,id(arr1),id(arr2)）
#查看arr1与arr2的内存地址

3.52 is not 运算符

• 功能：判断两个对象是否引用自不同的内存地址。

• 返回值：如果两个对象不是同一个对象（即内存地址不同），则返回 True；否则返回 False。

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

print(a is not b) 
# False，因为 b 是 a 的引用
print(a is not c)  
# True，虽然值相同，但内存地址不同

3.6成员运算符

3.61 in运算符

• 功能：检查指定的元素是否存在于容器中。

• 返回值：如果元素存在于容器中，则返回True；否则返回False。

fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)  # 输出: True
print("orange" in fruits)  # 输出: False

3.62 not in运算符

• 功能：检查指定的元素是否不存在于容器中。

• 返回值：如果元素不存在于容器中，则返回True；否则返回False。

fruits = ["apple", "banana", "cherry"]
print("orange" not in fruits)  # 输出: True
print("apple" not in fruits)  # 输出: False

应用场景

成员运算符可以应用于多种数据容器类型，包括但不限于：

• 列表（List）：

  python复制numbers = [1, 2, 3, 4, 5]
  print(3 in numbers)  # 输出: True
  print(6 not in numbers)  # 输出: True

• 元组（Tuple）：

  python复制colors = ("red", "green", "blue")
  print("green" in colors)  # 输出: True
  print("yellow" not in colors)  # 输出: True

• 字符串（String）：

  python复制text = "Hello, World!"
  print("Hello" in text)  # 输出: True
  print("Python" not in text)  # 输出: True

• 字典（Dictionary）（检查键是否存在）：

  python复制person = {"name": "John", "age": 30}
  print("name" in person)  # 输出: True
  print("address" not in person)  # 输出: True

• 集合（Set）：

  python复制primes = {2, 3, 5, 7, 11}
  print(5 in primes)  # 输出: True
  print(4 not in primes)  # 输出: True

示例代码

python复制# 列表
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)  # True
print("orange" not in fruits)  # True

# 元组
colors = ("red", "green", "blue")
print("green" in colors)  # True
print("yellow" not in colors)  # True

# 字符串
text = "Hello, World!"
print("Hello" in text)  # True
print("Python" not in text)  # True

# 字典
person = {"name": "John", "age": 30}
print("name" in person)  # True
print("address" not in person)  # True

# 集合
primes = {2, 3, 5, 7, 11}
print(5 in primes)  # True
print(4 not in primes)  # True

3.7位运算符

3.71 与（&）运算符

• 描述：对两个操作数的每一位执行逻辑与操作。只有两个对应位都为1时，结果的该位才为1，否则为0。

• 示例

  a = 60  # 二进制: 00111100
  b = 13  # 二进制: 00001101
  c = a & b  # 结果: 00001100 (12)
  print(c)  # 输出: 12

3.72或（|）运算符

• 描述：对两个操作数的每一位执行逻辑或操作。只要两个对应位中有一个为1，结果的该位就为1，否则为0。

• 示例

  a = 60  # 二进制: 00111100
  b = 13  # 二进制: 00001101
  c = a | b  # 结果: 00111101 (61)
  print(c)  # 输出: 61

3.73异或（^）运算符

• 描述：对两个操作数的每一位执行逻辑异或操作。只有两个对应位不同时，结果的该位才为1，否则为0。

• 示例

  a = 60  # 二进制: 00111100
  b = 13  # 二进制: 00001101
  c = a ^ b  # 结果: 00110001 (49)
  print(c)  # 输出: 49

3.74取反（~）运算符

• 描述：对操作数的每一位执行逻辑非操作。将1变为0，0变为1。注意，Python中的整数是以补码形式存储的，因此结果会是负数。

• 简记：原有数字+1

• 示例

  a = 60  # 二进制: 00111100
  c = ~a  # 结果: 11000011 (补码表示，实际为-61)
  print(c)  # 输出: -61

3.75左移（<<）运算符

• 描述：将操作数的所有位向左移动指定的位数。右侧空出的位用0填充。

• 简记：左移一位，相当于*2

• 示例

  a = 60  # 二进制: 00111100
  c = a << 3  # 结果: 111100000 (480)
  print(c)  # 输出: 480

3.76右移（>>）运算符

• 描述：将操作数的所有位向右移动指定的位数。左侧空出的位用符号位填充（正数为0，负数为1）。

• 简记：右移一位，相当于/2

• 示例

  a = 60  # 二进制: 00111100
  c = a >> 4  # 结果: 00000011 (3)
  print(c)  # 输出: 3

总结：

• 按位与（&）：对应位都为1时结果为1，否则为0。

• 按位或（|）：对应位有一个为1时结果为1，否则为0。

• 按位异或（^）：对应位不同时结果为1，否则为0。

• 按位取反（~）：对应位取反，结果为负数。

• 左移（<<）：向左移动指定位数，右侧补0。

• 右移（>>）：向右移动指定位数，左侧补符号位。

3.8三目运算符

其基本语法为：

x if condition else y

其中：

• condition 是一个布尔表达式。

• x 是条件成立（True）时的值。

• y 是条件不成立（False）时的值。

示例

1. 基本用法

age = 18
status = "成年" if age >= 18 else "未成年"
print(status)  # 输出: 成年

2. 在函数参数中使用

def greeting(age):
return "欢迎光临成人区" if age >= 18 else "你还需要长大一点!"

print(greeting(20))  # 输出: 欢迎光临成人区

3. 嵌套的三目运算符

虽然可以嵌套三目运算符，但过度嵌套会降低代码的可读性。例如：

num = int(input('请输入数字:'))
result = '负数' if str(num)[0] == '-' else '大于等于100' if num >= 100 else '小于100的正数'
print(result)

这相当于以下 if-else 结构：

python复制num = int(input('请输入数字:'))
if str(num)[0] == '-':
print('负数')
else:
if num >= 100:
   print('大于等于100')
else:
   print('小于100的正数')

4.三目运算符与列表推导式结合

三目运算符可以与列表推导式结合使用，以根据条件生成列表元素。例如：

s = [i if i % 2 == 0 else 10 * i for i in range(10)]
print(s)  # 输出: [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]

在这个例子中，对于 range(10) 中的每个 i，如果 i 是偶数，则列表中添加 i；否则，添加 10 * i。

注意事项

1. 可读性：虽然三目运算符可以使代码更简洁，但在条件复杂或操作较多时，传统的 if-else 结构可能更清晰。

2. 适度使用：避免过度嵌套三目运算符，以免降低代码的可读性。

3.9字符串运算符

3.91 拼接运算符 +

+运算符用于将两个或多个字符串连接起来：

str1 = "Hello"
str2 = "World"
result = str1 + " " + str2
print(result)  # 输出: Hello World

注意事项：

1、+只能连接字符串类型，不能直接连接字符串和其他类型（如整数）

2、如果需要连接非字符串类型，需要先转换为字符串：

apple_count = 5
print("小明午饭吃了" + str(apple_count) + "个苹果")  # 正确
# 或者使用format()方法
print("小明午饭吃了{}个苹果".format(apple_count))  # 更优雅的方式3

3.92. 重复运算符 *

*运算符用于将字符串重复指定的次数：

str1 = "abc"
result = str1 * 3
print(result)  # 输出: abcabcabc

3.93. 索引运算符 []

[]运算符用于获取字符串中指定位置的字符：

str1 = "Python"
print(str1[0])  # 输出: P
print(str1[4])  # 输出: t

特点：

• 索引从0开始

• 如果索引超出范围会引发IndexError异常。

3.94. 切片运算符 [:]

[:]运算符用于获取字符串的子串，遵循左闭右开原则：

str1 = "Python is fun"
print(str1[0:5])    # 输出: Python
print(str1[7:])     # 输出: is fun
print(str1[0:-1])   # 输出: Python is fu
print(str1[::-1])   # 输出: nuf si nohtyP (逆序)
print(str1[2:5:2])  # 输出: th (从索引2到5，步长为2)

切片参数说明：

• start:end - 从start到end-1

• start:end:step - 从start到end-1，步长为step

• 省略start默认为0，省略end默认为字符串长度

3.95. 成员运算符 in 和 not in

in和not in用于检查一个字符串是否包含另一个字符串：

str1 = "Hello World"
print("World" in str1)      # 输出: True
print("Python" not in str1)  # 输出: True

3.96. 比较运算符

Python提供了完整的字符串比较运算符：

str1 = "apple"
str2 = "banana"
print(str1 == str2)  # 输出: False
print(str1 != str2)  # 输出: True
print(str1 < str2)   # 输出: True (按字典序比较)
print(str1 > str2)   # 输出: False
print(str1 <= str2)  # 输出: True
print(str1 >= str2)  # 输出: False

比较规则：

• 按字符的Unicode码点值逐个比较

• 比较是区分大小写的。

3.97. 格式化运算符 %

%运算符用于格式化字符串（Python 2风格，Python 3中仍支持）：

print("I am %s" % "yml")
print("I am %s, my age is %d" % ("yml", 25))
print("I have %.2f apples" % 7.9)  # 保留两位小数

3.98. 原始字符串运算符 r 或 R

原始字符串用于表示不转义特殊字符的字符串：

print(r'\n')  # 输出: \n (而不是换行)
print(R'\t')  # 输出: \t

3.99现代格式化方法

除了%格式化，Python还提供了更现代的格式化方法：

format()方法

name = "Alice"
age = 25
print("My name is {} and I am {} years old.".format(name, age))

f-string (Python 3.6+)

name = "Bob"
age = 30
print(f"My name is {name} and I am {age} years old.")

---

四、数据类型转换

4.1基本数据类型之间相互转换

int——整型

float——浮点型

str——字符串型

bool——布尔型（只有真或假，Ture和False；常用于条件判断；1为真，0为假）

# 基本数据类型
# int
num1 = 100
# int => float
print(float(num1))    #输出100.0
# int => str
print(str(num1),type(str(num1)))    #输出100 <class 'str'>
# int => bool
print(bool(num1))    #输出True

#float
num2 = 1.0
#float => int 
print(int(num2))    #输出1
#float => str
print(str(num2),type(str(num2)))    #输出1.0 <class 'str'>
#float =>  bool
print(bool(num1))    #输出True

#bool
#bool => int
flag = False + 1
print(flag)    #输出1
#bool => float
flag3 = True
print(float(flag3))    #输出1.0
#bool => str
print(str(flag3),type(str(flag3)))    #输出True <class 'str'>

#str
#字符串如果是一个浮点数，是没有办法直接转换为整型的
s4 = "1"
#str => int
print(int(s4),type(int(s4)))    #输出1 <class 'int'>
#str => float
print(float(s4),type(float(s4)))    #输出1.0 <class 'float'>
#str => bool
#只要不是空字符串，输出均为True
print(int(s4),type(bool(s4)))    #输出True <class 'bool'>

4.2基本数据类型之间自动相互转换

#数据自动类型转换：低精度和高精度数据进行运算时自动转换的
#只有int => float和bool => int
#int => float
num1 = 100 + 0.0
print(float(num1))    #输出100.0


#bool => int
flag = False + 1
print(flag)    #输出1

---

五、流程控制

5.1UML

5.11UML的基本概念

UML是一种国际标准的建模语言，广泛应用于软件工程领域。它通过14种标准图表来描述系统的各个方面，包括系统结构、运行流程、对象关系等。在Python中，常用的UML图包括类图、对象图、时序图和活动图等。

5.12Python中常用的UML图

1. 类图（Class Diagram）：

   • 作用：用于描述系统中的类、类之间的关系以及类的属性和方法。

   • 示例：在Python中，可以通过类图来展示类的继承关系、关联关系等。例如，一个Car类可以有Suv和Jeep两个子类，它们继承自Car类并可能重写其方法。

   • 实现：在Python中，可以使用第三方库或工具（如PyCharm的UML插件）来生成类图。

2. 对象图（Object Diagram）：

   • 作用：用于描述系统中对象之间的关系和状态。

   • 示例：可以展示在特定时刻系统中各个对象的状态以及它们之间的交互。

3. 时序图（Sequence Diagram）：

   • 作用：用于描述系统中对象之间的交互顺序和消息传递。

   • 示例：在电商系统中，可以用时序图来展示用户下单、支付、发货等流程中的对象交互。

4. 活动图（Activity Diagram）：

   • 作用：用于描述系统中的业务流程和活动顺序。

   • 示例：可以展示用户注册、登录、购物等业务流程中的活动顺序和条件分支。

5.13Python中使用UML的工具和库

1. PyCharm的UML插件：

   • PyCharm是一款流行的Python IDE，它提供了UML类图插件，可以帮助开发人员快速检查和理解代码结构。

   • 通过插件，可以生成类图、添加注释、导航至源码、查找引用、进行重构等操作。

2. 第三方库：

   • 虽然Python标准库中没有直接支持UML的模块，但有一些第三方库（如pyreverse）可以用于生成UML图。这些库通常需要与绘图工具（如Graphviz）结合使用。

5.14UML在Python开发中的应用

1. 提高沟通效率：

   • UML图作为一种通用的建模语言，可以帮助团队成员之间更好地沟通和理解系统设计。

2. 辅助代码设计：

   • 通过UML图，开发人员可以在编写代码之前先设计好系统的结构和关系，从而减少代码中的错误和冲突。

3. 文档和培训：

   • UML图可以作为项目文档的一部分，帮助新成员快速了解系统结构和功能。同时，也可以用于培训和教育目的。

5.15总结

在Python中，UML是一种强大的工具，它可以帮助开发人员更好地理解和沟通系统设计和架构。通过常用的UML图（如类图、对象图、时序图和活动图），开发人员可以清晰地展示系统的各个方面。同时，借助PyCharm等IDE的UML插件或第三方库，可以方便地生成和管理UML图。

5.2顺序结构

默认情况下，代码是行内从左到右，页内从上到下的执行，这符合我们书写逻辑的执行顺序。

5.3分支（选择）结构

注意事项

1. 在Python中，缩进非常重要。它用于表示代码块的范围，因此必须确保条件语句后的代码块有正确的缩进。

2. 条件语句可以是任何返回布尔值（True或False）的表达式。

3. 可以使用逻辑运算符（如and、or、not）来组合多个条件。

5.21单分支

单分支结构（if语句）

单分支结构是最简单的分支结构，它只包含一个条件判断。如果条件为真（True），则执行相应的代码块；如果条件为假（False），则跳过该代码块。

语法

if 条件:
# 条件为真时执行的代码块

示例：

age = int(input("请输入你的年龄"))
if 12 > age > 6:
	print("欢迎你小朋友~")
#若输入年龄不属于该区间，则不会有任何输出；反之则输出“欢迎你小朋友~”

5.22双分支

双分支结构包含两个条件判断分支。如果第一个条件为真，则执行if代码块；否则，执行else代码块。

语法：

if 条件:
# 条件为真时执行的代码块
else:
# 条件为假时执行的代码块

示例：

age = int(input("请输入你的年龄"))
if 12 > age > 6:
	print("欢迎你小朋友~")
else:
print("欢迎你")
#若输入年龄不属于该区间，输出“欢迎你”；反之则输出“欢迎你小朋友~”

5.23多分支

多分支结构允许程序根据多个条件进行判断，并选择执行相应的代码块。程序会依次判断每个条件，一旦某个条件为真，就执行对应的代码块，并跳过后续的条件判断。如果所有条件都不为真，则执行else代码块（如果存在的话）。

语法：

if 条件1:
# 条件1为真时执行的代码块
elif 条件2:
# 条件2为真时执行的代码块
...
else:
# 所有条件都不为真时执行的代码块

示例：

height = float(input("请输入身高（米）"))
weight = float(input("请输入体重（千克）"))
BMI = float(weight / height ** 2)
if BMI < 18.5 :
print("过轻")
elif 18.5 <= BMI < 25:
print("正常")
elif 25 <= BMI < 28:
print("过重")
elif 28 <= BMI < 32:
 print("肥胖")
else:
 print("严重肥胖")

5.24三元表达式

对if-else语句的简化

age = int (input("请输入你的年龄："))
print ("你已经成年了！") if age>=18 else print ("你还没有成年！")
#当输入年龄>=18时，输出：你已经成年了！
#当输入年龄<18时， 输出：你还没有成年了！

注意事项：

1. 不要过度使用：尽管三元表达式可以使代码更简洁，但如果一个表达式包含过多的逻辑，使用if-else语句可能会更好。复杂的三元表达式可能会使代码难以理解和维护。

2. 执行顺序：三元表达式的执行顺序是从左到右。在表达式 x = x + 1 if x > 0 else x - 1 中，如果 x 是未定义的变量，Python会抛出错误，因为在判断 x > 0 之前已经尝试执行 x + 1。

3. 副作用：在一个三元表达式中，if 和 else 部分的代码都会被执行（在逻辑判断之前）。这意味着，如果这两部分的代码有副作用（如改变全局变量的值或打印输出），这些副作用总是会发生。在编写三元表达式时需要注意这一点。

5.25嵌套分支

嵌套分支结构是指在一个分支结构内部再包含另一个分支结构。这种结构可以处理更复杂的条件判断情况。

示例：

x = 10
if x > 5:
print("x大于5")
if x > 8:
 print("x也大于8")
else:
print("x不大于5")

在这个例子中，首先判断x是否大于5，如果是，则打印出"x大于5"，并进一步判断x是否大于8。如果x也大于8，则会打印出"x也大于8"。

5.4循环结构

当循环次数不是特别清晰的时候，首选WHILE循环

5.41for循环

for循环用于遍历一个序列（如列表、元组、字符串等）中的元素。在每次迭代过程中，for循环会将序列中的一个元素赋值给一个变量，然后执行循环体中的代码。循环将继续执行，直到遍历完序列中的所有元素。

示例：

# 遍历字符串
for i in 'hello':
    print(i)

# 遍历列表
magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

# 使用range()函数
for i in range(1, 11):
    if i % 2 == 0:
        print(i, '是偶数')

5.42while循环

while循环用于在满足特定条件时重复执行一段代码。在每次迭代过程中，首先检查给定的条件是否为真（True）。如果条件为真，将执行循环体中的代码。循环将继续执行，直到条件不再满足（即为假/False）。

示例：

# 计算1到5之间所有整数的和
sum = 0
i = 1
while i <= 5:
    sum += i
    i += 1
print(sum)

5.43循环控制语句

在循环结构中，还可以使用一些控制语句来改变循环的正常执行流程：

• break语句：用于跳出当前整个循环，执行循环后的语句。

• continue语句：用于结束当次循环，继续执行后续次数的循环。

• pass语句：空语句，用于保持程序结构的完整性，不做任何操作。

示例：

# break示例
for i in range(1, 6):
    if i == 3:
        break
    print(i)

# continue示例
for i in range(1, 6):
    if i == 3:
        continue
    print(i)

5.44循环嵌套

循环结构也可以互相嵌套，但建议最多不超过三层，以保持代码的可读性。

示例：

# 嵌套循环示例
for i in range(1, 4):
    for j in range(1, 4):
        print(f"i={i}, j={j}")

总结

Python中的循环结构主要包括for循环和while循环。for循环用于遍历序列中的元素，而while循环则在满足特定条件时重复执行代码。此外，还可以使用break、continue和pass等控制语句来改变循环的执行流程。循环结构也可以互相嵌套，但需要注意保持代码的可读性。

bin：二进制转换

oct：八进制转换

---

六、格式化输出

6.1 str.format（）

str.format()提供了一种更为灵活和强大的字符串格式化机制。它使用{}作为占位符，并允许在字符串中嵌入表达式。

# str.format格式化输出
name = str("雒煊")
age = int(20)
sex = str（"男"）
print("我的名字：{},我的年龄：{}，我的性别：{}".format(name,age，sex))
#输出：我的名字：雒煊,我的年龄：20，我的性别：男

6.2 f-strings

f-strings提供了一种简洁、直观且性能优异的方式来嵌入变量和表达式的值到字符串中。

6.21基本使用

# f-strings格式化输出
name = str("雒煊")
age = int(20)
sex = str("男")
print(f"我的名字：{name},我的年龄：{age},我的性别：{sex}")
#输出：我的名字：雒煊,我的年龄：20,我的性别：男

6.22支持表达式

f-strings支持在字符串中嵌入任意的python表达式，包括函数调用、算术运算、属性访问等。

# f-strings表达式输出
a1 = 10
a2 = 12
print(f"{a1*a2}")
# 输出：120

6.23设置整数位数

f-strings对于整数可以设置最小宽度，并使用0或空格作为填充字符以达到这个宽度。

# f-strings整数位数输出
a1 = 10
print(f"我的号码：{a1:3d}")          #3d：设置三位数，不足默认前面补空格
print(f"我的号码：{a1:03d}")         #3d：设置三位数，不足默认前面补0
#输出  我的号码： 10
       我的号码：010

6.24设置小数精度

#设置小数精度
a1 = 3.1415926
print(f"保留三位小数：{a1:.3f}")       #.3f:保留3位小数点，超出三位小数点；将以四舍五入的规则，不足则补零
#输出：保留三位小数：3.142

---

七、转义字符

7.1转义字符基础概念

7.11什么是转义字符？

在Python字符串中，转义字符是由反斜杠\开头的特殊字符序列，用于：表示无法直接输入的字符（如换行符）；消除特殊字符的语法意义（如引号）；实现特定文本格式控制；表示特定的二进制。

7.12转义工作原理

源代码中的转义序列会被Python解释器处理，并转换为相应的字符或控制效果。例如，print('Line\\nBreak')会被解释器处理为Line后跟一个换行符，再跟Break

7.2常用转义字符一览表

7.3基本转义字符

7.31换行符 \n：

用于在字符串中插入一个换行符，使后续内容从下一行开始。

print("Hello\nWorld")
#输出：第一行是"Hello"，第二行是"World"

7.32回车符 \r：

将光标移动到当前行的开头，后续内容会覆盖当前行从光标位置开始的内容。

print("Hello\rWorld")
#输出：World

7.33水平制表符 \t：

插入一个水平制表符，相当于按Tab键，通常用于对齐文本。

print("Name:\tAlice")
#输出：Name:   Alice

7.34退格符 \b：

将光标向后移动一个字符位置，相当于按退格键。

print("Hello\bWorld")
#输出：HellWorld

7.35反斜杠 \\：

用于在字符串中表示一个实际的反斜杠字符。

print("C:\\Users\\Name")
#输出：C:\Users\Name

7.36单引号 \' 和双引号 \"：

• 用于在字符串中包含单引号或双引号字符，而不会与字符串的界定符冲突。

• 示例：print('It\'s a book') 或 print("He said, \"Hello\"")。

print('It\'s a book')
#输出：It's a book

print("He said, \"Hello\"")
#输出：He said, "Hello"

7.4八进制和十六进制转义字符

Python还支持使用八进制或十六进制数来表示字符：

7.41八进制转义字符 \ooo：

• ooo 表示1到3位的八进制数字，代表字符的ASCII码。

• 示例：print("\101") 会输出大写字母"A"（因为\101是八进制表示，对应ASCII码65）。

7.42十六进制转义字符 \xhh：

• hh 表示1到2位的十六进制数字，代表字符的ASCII码。

• 示例：print("\x41") 同样会输出大写字母"A"（因为\x41是十六进制表示，也对应ASCII码65）。

7.5原字符（Raw Strings）

如果你不希望字符串中的转义字符被解释，可以在字符串前加上r或R，使其成为原字符。在原字符中，反斜杠被视为普通字符。

• 示例：print(r"C:\Users\Name") 会输出"C:\Users\Name"，而不会将\U、\N等解释为转义序列。

• 注意：原字符的最后一个字符不能是反斜杠，即r"\"是无效的。

7.6实际应用示例

# 使用转义字符打印多行文本
print("Line 1\nLine 2\nLine 3")

# 使用制表符对齐文本
print("Name:\tAlice\nAge:\t25")

# 在字符串中包含引号
print('She said, "Hello!"')
print("It's a sunny day.")

# 使用原字符表示文件路径
print(r"C:\Program Files\Python")

# 使用八进制和十六进制转义字符
print("\101\x42\103")  # 输出"ABC"

---

八、字符串常见内建函数

8.1查找元素

sub：要查找的子字符串

start：开始查找的位置（可省略），省略则从字符串的开头开始查找

end：结束查找位置（可省略），省略则查找到字符串的末尾

8.11 find(sub,start,end)

查找子字符串在字符中首次出现的位置。如果找到了子字符串，则返回该子字符串首次出现的索引。如果没有找到，则返回-1。遵循包前不包后规则（包含起始位置，不包含结束位置）。

name = "xsnwcj"
print(name.find("w"))        #3
print(name.find("nwc"))      #2
print(name.find("xj"))       #-1
#使用start
print(name.find("w",3))      #3
#使用start、end
print(name.find("w",3,5))    #3

8.12 index(sub，start，end)

index() 方法用于查找元素在列表中首次出现的位置（索引）。如果找到该元素，则返回该子字符串首次出现的索引；如果元素不存在，会引发 ValueError 异常。

name = "xsnwcj"
print(name.index("w"))        #3
print(name.index("nwc"))      #2
print(name.index("xj"))       #引发 ValueError 异常
#使用start
print(name.index("w",3))      #3
#使用start、end
print(name.index("w",3,5))    #3

注：与find查找基本相同，都是返回首次出现的索引，但find未找到返回-1，index返回 ValueError 异常。

8.13 count（sub，start，end）

统计子字符串在字符串中出现的次数。如果子字符串在字符串中不存在，则返回0。

name = "xsnwcjxsnw"
print(name.count("w"))        #2
print(name.count("nwc"))      #1
print(name.count("xj"))       #0
#使用start
print(name.count("w",2))      #2
#使用start、end
print(name.count("w",2,5))    #1

8.2修改元素

old：需要被替换的子字符串

new：用于替换的子字符串

count：指定替换的最大次数。若省略，则替换所有；不省略，则只替换指定次数的子字符串

8.21 replace（old，new，count）

替换字符串中的某些部分

name = "i like you"
print(name.replace("like","love"))        #输出：i love you
#使用count
name = "i love you,i miss you"
print(name.replace("you","your heart",1))
#输出：i love your heart,i miss you

8.22 split（sep，maxsplit）

将字符串分割成列表中的子字符串。默认情况下，会根据任何空白字符（空格、换行符、制表符等）来分割，也可通过指定一个分隔符来改变分割行为。

sep：分隔符，默认为None，表示使用空白字符作为分隔符。若指定其它字符串作为分隔符，则该方法会在这个指定的分隔符出分割字符串。

maxsplit：可选参数，指定分割的最大次数，默认为-1，表示分割次数没有限制，即分割所有可能的子字符串。若指定非负整数n，则字符串被分割n次，并生成一个包含n+1个元素的列表。

#使用默认分隔符（空白字符）
bain_liang = "hello world! hello lx"
print(bain_liang.split())
#输出：['hello', 'world!', 'hello', 'lx']

#使用sep指定分隔符
bain_liang = "hello world! hello lx"
print(bain_liang.split("!"))
#输出：['hello world', ' hello lx']

#指定一个不存在的分隔符，不会进行分割，而是将整个字符串作为一个整体返回
bain_liang = "hello world! hello lx"
print(bain_liang.split("."))
#输出：['hello world! hello lx']

#使用sep和maxsplit
bain_liang = "hello world! hello lx"
print(bain_liang.split(" ",2))
#输出：['hello', 'world!', 'hello lx']

8.23 strip（chars）

去除字符串首尾的指定字符（默认是去除空白字符，包括空格、换行符\n、制表符\t等）

#去除首位空白字符
bain_liang = "  hello world! hello lx  "
print(bain_liang.strip( ))
#输出：hello world! hello lx

#去除首尾指定字符
bain_liang = "ooohello world! hello lxooo"
print(bain_liang.strip("o"))
#输出：hello world! hello lx

bain_liang = "opoohello world! hello lxopoo"
print(bain_liang.strip("op"))
#输出：hello world! hello lx

8.24 lower（）

将字符串中的所有大写字母转换为小写字母

bain_liang = "Hello World! Hello Lx"
print(bain_liang.lower())
#输出：hello world! hello lx

#若没有大写字母，则输出原字符串
bain_liang = "hello world!"
print(bain_liang.lower())
#输出：hello world!

#包含非字母的字符串
bain_liang = "Hello world!520"
print(bain_liang.lower())
#输出：hello world!520（非字母字符串不受影响）

8.25 upper（）

将字符串中的所有小写字母转换为大写字母

bain_liang = "hello world!"
print(bain_liang.upper())
#输出：HELLO WORLD!

#若没有小写字母，则输出原字符串
bain_liang = "HELLO WORLD!"
print(bain_liang.lower())
#输出：HELLO WORLD!

#包含非字母的字符串
bain_liang = "hello world!520"
print(bain_liang.lower())
#输出：HELLO WORLD!520（非字母字符串不受影响）

8.3判断元素

8.31 startswith(prefix,start,end)

检查字符串是否已制订的前缀开始，如果字符串以指定的前缀开始，则返回True，否则返回False。

prefix：要检查的前缀

start：开始检查的位置（可省），若省略，则从头开始

end：结束检查的位置，在这个位置之前停止（可省），若省略，则进行到字符串的末尾

bain_liang = "Hello world!"
print(bain_liang.startswith("H"))
#输出：True

bain_liang = "Hello world!"
print(bain_liang.startswith("el"))
#输出：False
#因为前两个字符是He，并不是el，所以输出：False

bain_liang = "Hello world!"
print(bain_liang.startswith("el",1))
#输出：True

bain_liang = "Hello world!"
print(bain_liang.startswith("el",1,5))
#输出：True

8.32 endswith（suffix，start，end）

检查字符串是否以指定的后缀结束。如果字符串以指定的后缀结束，则返回True，否则返回False。

suffix：要检查的后缀

start：开始检查的位置（可省），若省略，则从头开始

end：结束检查的位置，在这个位置之前停止（可省），若省略，则进行到字符串的末尾

bain_liang = "Hello world!"
print(bain_liang.endswith("!"))
#输出:True

bain_liang = "Hello world!"
print(bain_liang.endswith("ld!"))
#输出：True

bain_liang = "Hello world!"
print(bain_liang.endswith("ld"))
#输出：False

bain_liang = "Hello world!"
print(bain_liang.endswith("!",5))
#输出：True

bain_liang = "Hello world!"
print(bain_liang.endswith("lo",1,5))
#输出：True

8.33 isupper（）

检查字符串中的所有可识别的字母字符是否都是大写。如果字符串中至少有一个可识别的字母字符，并且所有这些字母字符都是大写，则返回 True。如果字符串为空、不包含任何字母字符，或者包含至少一个小写字母字符，则返回 False。

#所有字母全是大写
bain_liang = "HELLO WORLD!"
print(bain_liang.isupper())
#输出：True

#包含小写字母
bain_liang = "HELLO world!"
print(bain_liang.isupper())
#输出：False

#包含数字
bain_liang = "HELLO WORLD! 520"
print(bain_liang.isupper())
#输出：True

#没有字母
bain_liang = "520"
print(bain_liang.isupper())
#输出：False

8.34 islower（）

检查字符串中的所有可识别的字母字符是否都是小写。如果字符串中至少有一个可识别的字母字符，并且所有这些字母字符都是小写，则返回 True。如果字符串为空、不包含任何字母字符，或者包含至少一个大写字母字符，则返回 False。

#所有字母全是小写
bain_liang = "hello world!"
print(bain_liang.islower())
#输出：True

#包含大写字母
bain_liang = "hello World!"
print(bain_liang.islower())
#输出：False

#包含数字
bain_liang = "hello world!520"
print(bain_liang.islower())
#输出：True

#没有小写字母
bain_liang = "HELLO WORLD!"
print(bain_liang.islower())
#输出：False

#没有字母
bain_liang = "520"
print(bain_liang.islower())
#输出：False

---

九、容器

计算机组成部分：输入设备（）、输出设备（显示器、鼠标）、存储设备（内存、硬盘）、cpu

9.1容器的定义与分类

定义：容器是用来存储多个数据的对象。在Python中，容器根据数据是否有序、是否可变、是否重复等特性被划分为多种类型。

分类：

字符串（str）：存储字符编码值，不可变，序列。

列表（list）：存储变量，可变，序列。

元组（tuple）：存储变量，不可变，序列。

字典（dict）：存储键值对，可变，散列，键不能重复且不可变。

集合（set）：存储键，可变，无序且不重复。

9.2常见内置容器类型详解

9.21字符串（String, str）

特性：不可变的有序字符序列。

len(s)：返回字符串的长度。

s.lower()：转换为小写。

s.upper()：转换为大写。

s.strip()：去除两端的空格或指定字符。

s.split()：根据指定分隔符拆分字符串。

s.join(t)：用字符串连接可迭代对象的元素。

s.replace(a, b)：替换字符串中的子串a为b。

9.22. 列表（List）

特性：有序、可变的容器，可以存储任意类型的对象。

len(lst)：返回列表的长度。

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

lst.insert(i, x)：在索引i处插入元素x。

lst.pop([i])：删除并返回索引i处的元素（默认为末尾）。

lst.remove(x)：删除第一个值为x的元素。

lst.index(x)：返回元素x的索引。

lst.sort()：对列表进行排序。

lst.reverse()：反转列表。

9.23. 元组（Tuple）

特性：有序、不可变的容器，可以存储任意类型的对象。

特点：由于元组不可变，因此没有像列表那样的修改方法（如append、insert等）。

通过索引访问元素。

使用len()函数获取元组长度。

使用in关键字检查元素是否存在。

9.24. 字典（Dictionary, dict）

特性：存储键值对，可变，散列，键不能重复且不可变。

创建方法：

使用花括号{}：d = {"name": "laoqi", "age": 29}。

使用dict()函数：d = dict(name="laoqi", age=29)。

d[key]：访问键对应的值。

d[key] = value：添加或修改键值对。

del d[key]：删除键值对。

key in d：检查键是否存在。

d.keys()：返回所有键的视图。

d.values()：返回所有值的视图。

d.items()：返回所有键值对的视图。

9.25. 集合（Set）

特性：存储键，可变，无序且不重复。

创建方法：

使用花括号{}：s = {1, 2, 3}。

使用set()函数：s = set([1, 2, 3])。

常用方法：

s.add(x)：添加元素x。

s.remove(x)：删除元素x（如果x不存在则报错）。

s.discard(x)：删除元素x（如果x不存在则不报错）。

s.pop()：随机删除并返回一个元素。s.clear()：清空集合。

s.union(t)：返回集合s和t的并集。

s.intersection(t)：返回集合s和t的交集。

s.difference(t)：返回集合s中存在而t中不存在的元素。

9.3容器的选择与使用

根据需求选择：

1、需要有序且可变的数据结构时，选择列表。

2、需要不可变的数据结构时，选择元组。

3、需要快速查找和访问键值对时，选择字典。

4、需要去重或进行集合运算时，选择集合。

性能考虑：

1、列表的插入和删除操作在列表末尾时效率较高，但在列表开头或中间时效率低。

2、字典的查找和插入操作平均时间复杂度为O(1)，因此非常适合需要快速查找的场景。

3、集合的查找和插入操作也具有较高的效率。

9.4容器的底层实现与高层抽象

底层实现：Python的内建容器类型使用了不同的数据结构来实现其特性。例如，列表可能使用动态数组来实现，而字典则可能使用哈希表来实现。

高层抽象：容器的行为定义了其高层抽象。例如，所有容器都支持迭代操作，可以通过for循环来遍历容器中的元素。

---

十、列表

10.1认识列表

10.11列表的定义

列表是一种非常强大的数据结构，用于存储一系列有序的元素

li = [1,2,3]
print(li,type(li))
#输出：[1, 2, 3] <class 'list'>

b = list("luoxuan")
print(b)
#输出：['l', 'u', 'o', 'x', 'u', 'a', 'n']

注：列表中的元素不受限制，可以是数值类型、字符串、列表、元组、字典、集合等类型

10.12访问列表元素

可以通过索引（下标）来访问列表中的元素。

my_list = [10, 20, 30, 40, 50]

# 访问第一个元素
first_element = my_list[0]
print(f"第一个元素: {first_element}")  
# 输出: 第一个元素: 10

# 访问最后一个元素
last_element = my_list[-1]
print(f"最后一个元素: {last_element}")  
# 输出: 最后一个元素: 50

10.13列表切片

切片是一种访问列表中多个元素的方式，使用冒号:来表示。切片的语法是list[start:end：步长]，其中start是起始索引（包含），end是结束索引（不包含）。如果省略start，则默认为0；如果省略end，则默认为列表的长度。

my_list = [10, 20, 30, 40, 50]

# 访问前两个元素
first_two_elements = my_list[:2]
print(f"前两个元素: {first_two_elements}")  
# 输出: 前两个元素: [10, 20]

# 访问从第二个到第四个元素
middle_elements = my_list[1:4]
print(f"从第二个到第四个元素: {middle_elements}")  
# 输出: 从第二个到第四个元素: [20, 30, 40]

# 访问最后两个元素
last_two_elements = my_list[-2:]
print(f"最后两个元素: {last_two_elements}")  
# 输出: 最后两个元素: [40, 50]

10.14循环遍历列表

除了使用索引和切片来访问列表元素外，还可以使用循环来遍历列表中的所有元素。常见的循环方式有for循环和while循环。

# 创建一个列表
my_list = [10, 20, 30, 40, 50]

# 使用for循环遍历列表
print("使用for循环遍历列表:")
for element in my_list:
    print(element)
#输出：10 20 30 40 50

# 使用while循环遍历列表
print("使用while循环遍历列表:")
index = 0
while index < len(my_list):
    print(my_list[index])
    index += 1
#输出：10 20 30 40 50

10.2列表及其常见操作

10.21添加元素

object：要添加到列表末尾的元素（可以是任意数据类型）

（1）append（object）——到末尾

my_list = [1, 2, 3, 4, 5]
# 添加元素6到列表末尾
my_list.append(6)  
print(my_list)  
# 输出：[1, 2, 3, 4, 5, 6]

（2）extend（iterable）——到末尾

iterable：可迭代对象，如列表、元组、字符串等。将元素逐个添加到末尾

my_list = [1, 2, 3, 4, 5]
# 将another_list的所有元素添加到my_list末尾
another_list = [7, 8, 9]
my_list.extend(another_list)  
print(my_list)  
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

（3）insert（index，object）——指定位置

index：元素要插入的索引位置

object：要添加到列表末尾的元素（可以是任意数据类型）

my_list = [1, 2, 3, 4, 5]
# 在索引1处插入元素15
my_list.insert(1, 15)  
print(my_list)  
# 输出：[1, 15, 2, 3, 4, 5, 6]

注：若指定的索引超出列表的范围，则添加到末尾

10.22修改元素

list[index]=value

index：元素要插入的索引位置

value：要赋予指定索引位置的新值（可以是任意数据类型）

my_list = [1, 2, 3, 4, 5]
# 将第一个元素修改为10
my_list[0] = 10  
print(my_list)  
# 输出：[10, 2, 3, 4, 5]

10.23查找元素

（1）in

检查一个元素是否存在于列表中，若存在，返回True，否则返回False

#初等
my_list = [1, 2, 3, 4, 5]
print(1 in my_list)

#使用if-else语句
my_list = [1, 2, 3, 4, 5]
element = 3
if element in my_list:
    print(f"{element} is in the list")
else:
    print(f"{element} is not in the list")

（2）not in

检查一个元素是否不存在于列表中，若不存在，返回True，否则返回False

#初等
my_list = [1, 2, 3, 4, 5]
print(1 not in my_list)

#使用if-else语句
my_list = [1, 2, 3, 4, 5]
element = 3
if element in my_list:
    print(f"{element} is in the list")
else:
    print(f"{element} is not in the list")

（3）index（value，start，stop）

a1 = ["apple",'banana','cherry','apple']
print(a1.index("cherry"))
#输出：2

a1 = ["apple",'banana','cherry','apple']
print(a1.index("apple"))
#输出：0（检索到第一个后，不会继续向后）

my_list = [1, 2, 3, 4, 5]
element = 3
try:
    index = my_list.index(element)
    print(f"Element {element} found at index {index}")
except ValueError:
    print(f"Element {element} is not in the list")

（4）count（value）

统计某个元素在列表中出现的次数，若不存在，则返回0。

value：要统计出现的次数

li = [1,2,3,3,4,4,4]
print(li.count(3))
#输出：2

10.24删除元素

（1）del list（index）

根据索引删除列表中的元素，如果尝试删除一个不存在的索引对应的元素，则出现异常。

li = [1,2,3,4,5]
del li[2]
print(li)

（2）remove（value）

移除列表中第一个匹配指定值的元素，如果不存在对应的元素，则出现异常。

li = [1,2,3,4,5,2]
li.remove(2)
print(li)
#移除列表中第一个值为2的元素

10.25排序

（1）sort（key，reverse）

对列表中的元素进行排序

key：接受一个元素作为参数。该函数会在每个元素上调用，其返回值将作为排序的依据。如果未提供，则直接比较元素本身。

reverse：接收一个布尔值。若设置为True，则列表将以降序排列。反之则以升序排列。

li = [3,1,4,1,5,9,2]
li.sort()
print(li)
#输出：[1, 1, 2, 3, 4, 5, 9]

#使用reverse函数
li = [3,1,4,1,5,9,2]
li.sort(reverse=True)
#列表将以降序排列
print(li)
#输出：[9, 5, 4, 3, 2, 1, 1]

（2）reverse（）

就地反转列表中的元素顺序

li = [3,1,4,1,5,9,2]
li.reverse()
print(li)
#反转列表中的元素顺序
#输出：[2, 9, 5, 1, 4, 1, 3]

10.3列表推导式

10.31基本语法

new_list = [expression for item in iterable]

expression：用于生成新列表元素的表达式。

item：迭代变量。

iterable：可迭代对象（如列表、元组、集合等）。

示例：

#未使用列表推导式
li1 = []
for i in range(1,11):
	li1.append(i)
print ("li1:",li1)
#输出：li1: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#使用列表推导式
li2 = [i for i in range(1,11)]
print("li2",li2)
#输出：li2: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

10.32带有条件的列表推导式

new_list = [expression for item in iterable if condition]

condition：可选的筛选条件。

#方法一(不使用列表推导式)：
li1 = [11,22,33,44,55,66]
li2 = []
for i in li1:
    if i % 2 == 0:
        li2.append(i)
print("li2:",li2)
#输出：li2: [22, 44, 66]

#方法二（使用列表推导式）：
li2 = [i for i in li1 if i %2 == 0]
print("li2:",li2)
#输出：li2: [22, 44, 66]

10.4列表嵌套

li = [1,2,[3,4,5],[6,7,8]]
print(li[1])
print(li[2])
print(li[2][0])
print(li[3])
print(li[3][1])
#输出：
2
[3, 4, 5]
3
[6, 7, 8]
7

---

十一、元组

11.1认识元组

定义：元组是不可变的有序序列，使用圆括号()创建（括号可省略，但逗号不可省略）。

示例：

empty = ()          # 空元组
single = (10,)      # 单元素元组（逗号必须保留）
colors = "red", "green", "blue"  # 括号可省略

核心特性：

不可变性：元组创建后，元素不可修改（内存地址不变）。但若元素为可变对象（如列表），其内部内容可修改。

t = (1, [2, 3])
t[1][0] = 99  # 允许：修改嵌套列表的内容

有序性：支持索引和切片操作。

异构性：可包含任意数据类型（如整数、字符串、列表等）。

11.2元组的基础操作

11.21访问元素

(1)索引

colors = "red", "green", "blue"
print(colors[0])
#输出：red

（2）切片

colors = "red", "green", "blue"
print(colors[0:2])
#输出：('red', 'green')

#详细查看切片运算符3.94或列表切片9.13

（3）遍历元组

元组是可迭代对象，可以使用for循环来遍历元组中的每个元素

tua = ("a","b","c","b","d")
for i in tua；
	print(i)

11.3元组的常见操作

元组创建后，元素不可修改（内存地址不变）。因此元组只支持查找操作。

查询操作

11.31 in

检查一个元素是否存在于元组中，若存在，返回True，反之返回False

nums = (11,22,33,44,55)
print(11 in nums)
#输出：True

print(2 in nums)
#输出：False

11.32 not in

检查一个元素是否不存在于元组中，若存在，返回True，反之返回False

nums = (11,22,33,44,55)
print(11 not in nums)
#输出：False

print(2 not in nums)
#输出：True

11.33 index（value，start，stop）

查找元素在元组中首次出现的位置（索引）。如果找到该元素，则返回该子字符串首次出现的索引；如果元素不存在，会引发 ValueError 异常。

a1 = ("apple",'banana','cherry','apple')
print(a1.index("cherry"))
#输出：2

a1 = ("apple",'banana','cherry','apple')
print(a1.index("apple"))
#输出：0（检索到第一个后，不会继续向后）

11.34 count（value）

统计某个元素在列表中出现的次数，若不存在，则返回0。

li = (1,2,3,3,4,4,4)
print(li.count(3))
#输出：2

11.35 len(object)

获取容器（列表、元组、字典、字符串、集合等）中元素的数量，即“大小”或者“长度”。获取非容器类型（整型、浮点型等）的长度则出现异常。

tua = ("a","b","c")
#获取元组的长度
print(len(tua))
#输出：3

S = "HELLO"
#获取字符串的长度
print(len(S))
#输出：5

li = [1,2,3,4,5,6,7,8,9]
#获取列表的长度
print(len(li))
#输出：9

11.4其他操作

1、连接与重复：

t_concat = (1, 2) + (3,)    # (1, 2, 3)
t_repeat = ("ok",) * 3      # ("ok", "ok", "ok")

2、成员检测：

print("red" in colors)  # True

3、类型转换：

列表转元组：tuple([1, 2]) → (1, 2)

字符串转元组：tuple("abc") → ('a', 'b', 'c')

4、解包（Unpacking）：

将元组元素赋值给多个变量：

name, age = ("Alice", 25)

星号解包（Python 3+）：

first, *rest = (1, 2, 3)  # first=1, rest=[2, 3]

5、函数返回多个值：

Python函数通过返回元组实现多返回值：

def get_user():
    return "Alice", 25
name, age = get_user()

6、作为字典的键：

元组不可变，可作为字典的键（列表不行）：

d = {(1, 2): "value"}

11.5元组与列表的对比

11.6常见问题与注意事项

单元素元组：必须加逗号，否则会被识别为普通对象。

wrong = (10)    # 整数10
correct = (10,) # 元组

不可变性的限制：

直接修改元素会报错：TypeError。

若需完全不可变，避免嵌套可变对象（或使用frozenset）。

性能优化：元组比列表更节省内存，适合存储大量静态数据。

---

Python常见函数

Visual Studio Code→新建文件夹→新建文件（后缀.py）→代码生成

1、print函数

print(100,"hahaha",sep=" ",end="/")
print("zjj")
#输出100 hahaha/zjj

sep=“”→分隔符

end=""→换行

2、input函数

在Python中，input()函数是一个用于从用户获取输入的标准内置函数。它允许程序暂停并等待用户输入一些文本，然后将输入作为字符串返回。以下是关于input()函数的详细说明：

1. 函数原理：

   • input()函数会暂停程序的执行，等待用户输入一些文本。

   • 用户输入的文本会被作为字符串返回。

   • 可以提供一个可选的参数作为提示信息，显示给用户。

   message = input("Tell me something, and I will repeat it back to you: ")
   print(message)

   在这个例子中，程序会显示提示信息，并等待用户输入。用户输入的内容会被存储在变量message中，然后打印出来。

2. 将输入存储在变量中：

   • 可以将提示信息存储在一个变量中，然后将该变量作为input()函数的参数。

   prompt = "If you tell us who you are, we can personalize the messages you see."
   prompt += "\nWhat is your first name? "
   name = input(prompt)
   print("\nHello, " + name + "!")

   这里，提示信息被分成多行显示，用户输入的名字会被存储在变量name中，然后打印出问候语。

3. 使用int()进行数值输入转换：

   • 由于input()函数总是返回字符串，如果需要将输入作为数值使用，需要使用int()或float()进行转换。

   height = input("How tall are you, in inches? ")
   height = int(height)
   if height >= 36:
       print("\nYou're tall enough to ride!")
   else:
       print("\nYou'll be able to ride when you're a little older.")

   在这个例子中，用户输入的身高被转换为整数，然后根据身高判断是否满足坐过山车的条件。

3、range函数

start：起点；end：终点；step：步长（当range函数的start缺省时，start=0；step缺省时，step=1）

range（start，end，step）

表示创建一个序列，start和end构成序列的区间【start，end）

print （list(range(1,10,3)))#1,4,7
print （list(range(10，1，-2)))#10，8，6，4，2
#当step为正数时，起点必须小于终点，得到的序列是一个升序序列
#当step为负数时，起点必须大于终点，得到的序列是一个降序序列

4、break函数

用于跳出当前整个循环，执行循环后的语句。（终止当前循环）

5、continue函数

用于结束当次循环，继续执行后续次数的循环。（结束本次循环，进入下次循环）

6、pass函数

空语句，用于保持程序结构的完整性，不做任何操作。