Python二级考试笔记

巨人张

已于 2024-04-08 17:47:36 修改

阅读量1.1k

点赞数 19

文章标签： python 笔记开发语言

于 2024-02-16 16:04:35 首次发布

本文链接：https://blog.csdn.net/m0_46403734/article/details/136129582

版权

Python二级考试笔记【源源老师】

01. 字符串

字符串的本质是：字符序列。Python 的字符串是不可变的，我们无法对原字符串做任何修改。但可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

1. 常规功能合集

字符串本身有一些功能，有些之前运用过，这里总结如下：

# 功能一：判断字符串类型
print(type("Hello"))
print(str(123))     # 转换

# 功能二：连接字符段片段
a = "hello"
b = "python!"
print(a + b)        # 没有空格
print(a, b)         # 包含一个空格 

# 功能三：重复字符
c = "^_^"
print(c * 3) #结果： ^_^^_^^_^

2. 字符串特性

# 将字符串理解为列表，可以使用切片，循环等功能
# 【但是注意】：列表中的方法和工具不一定都能用

d = "abcdefghijklmn"
print(d[2:8]) #cdefgh
print(d[2:8:2]) #ceg
print(len(d)) #14
for i in d:
    print(i, end="|") #a|b|c|d|e|f|g|h|i|j|k|l|m|n|

3. 格式化数据

之前已经学习过%d、%f、%s等格式化输出的方式：

name = "小明"
age = 3.33
height = 1.23456
print("我的名字叫%s，今年%d岁了，身高%.2f米"%(name, age, height)) #我的名字叫小明，今年3岁了，身高1.23米

#上面的输出也可以用f-string的写法，更加方便，即f"{变量}"的写法
print(f"我的名字叫{name}，今年{age}岁了，身高{height}米") #我的名字叫小明，今年3.33岁了，身高1.23456米

4. 字符串常用方法

方法名	返回值说明
.replace(s1, s2)	将字符串中的s1替换成s2后生成新的字符串
str.split(s)	通过字符串 s 来分割字符串，分割后形成一个字符串列表
s.join(str)	将字符串中的元素以指定字符s连接生成新的字符串
.lower()	将字符串全部转换为小写
.upper()	将字符串全部转换为大写
.find(s)	判断是否包含子字符串，存在返回下标索引，不存在返回-1
.index(s)	判断是否包含子字符串，存在返回下标索引，不存在直接报错
.count(s)	统计子字符串出现的次数
.format()	格式化匹配字符串

# replace替换
a = 'Hello Jack'
b = a.replace('Jack', 'Mike')
print(a) # Hello Jack
print(b) # Hello Mike

# split切割
a = 'Hello, Jack'
b = a.split(',')
print(a) # Hello, Jack
print(b) # ['Hello', ' Jack']

# join连接
a = 'Hello'
b = '-'.join(a)
print(a) # Hello
print(b) # H-e-l-l-o

# upper、lower大小写转换
a = 'Hello'
b = a.upper()
c = a.lower()
print(a) # Hello
print(b) # HELLO
print(c) # hello

# find查找
a = 'Happy'
b = a.find('p')
c = a.find('q')
print(b) # 2 【有多个相同的p字符串默认返回第一个的索引】
print(c) # -1

# index查找
a = 'Happy'
b = a.index('p')
print(b) # 2
c = a.index('q') # 报错

# count计数
a = 'Happy'
b = a.count('p')
c = a.count('p',3) #【有第二个参数，则表示从这个位置开始往后查找计数】
print(b) # 2
print(c) # 1 

# format格式化匹配字符串
s = '{} is a {}'.format('Mike', 'boy')
print(s) # Mike is a boy

a = 'Mike'
b = 'boy'
s = '{0} is a {1}'.format(a,b) #通过索引匹配,a对应前面0的位置，b对应1的位置
print(s) # Mike is a boy
s = '{1} is a {0}'.format(a,b) #通过索引匹配
print(s) # boy is a Mike

s = '{name} is a {sex}'.format(name='Mike',sex='boy') #通过参数名匹配
print(s) # Mike is a boy

02. 列表(list)

1. 创建列表

列表(list)是一种有序的容器，放入list中的元素，将会按照一定顺序排列。创建list的方式非常简单，使用中括号[]把需要放在容器里面的元素括起来，就定义了一个列表。

L = ['Alice', 66, 'Bob', True, 'False', 100]

2. 访问元素

列表中的元素既可以使用正向索引访问，也可以使用反向索引访问，正向索引从0开始，反向索引从-1开始。

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 访问元素
print(L[0]) #Alice
# print(L[6]) #错误：越界了
print(L[-1]) #100

3. 添加元素

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 添加元素
L.append('LiMing') #末尾追加
print(L) #['Alice', 66, 'Bob', True, 'False', 100, 'LiMing']
L.insert(3,99)
print(L) #['Alice', 66, 'Bob', 99, True, 'False', 100, 'LiMing']
L.extend(['False',33])
print(L) #['Alice', 66, 'Bob', 99, True, 'False', 100, 'LiMing', 'False', 33]

4. 删除元素

L = ['Alice', 66, 'Bob', 99, True, 'False', 100, 'LiMing', 'False', 33]

#### 删除元素
L.remove(99)
print(L) #['Alice', 66, 'Bob', True, 'False', 100, 'LiMing', 'False', 33]
del L[2]
print(L) #['Alice', 66, True, 'False', 100, 'LiMing', 'False', 33]
L.pop(2)
print(L) #['Alice', 66, 'False', 100, 'LiMing', 'False', 33]
L.clear()
print(L) #[]

5. 列表切片

list[start : end] 访问的是从索引start开始，一直到索引end的元素，但不包括索引end所在的元素
list[start: ] 访问的是从索引start开始，一直到列表结束的元素
list[: end] 访问的是从索引0开始，一直到索引end的元素，但不包括索引end所在的元素

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 列表切片
print(L[1:5]) #[66, 'Bob', True, 'False']
print(L[0:5:2]) #['Alice', 'Bob', 'False']
print(L[-5:-1:3]) #[66, 'False']

6. 元素个数

L = ['Alice', 66, 'Bob', True, 'False', 100]

#### 元素个数
print(len(L)) #6
print(L.count(100)) #1

7. 列表运算符

#### 列表运算符
L1 = ['Alice', 66, 'Bob']
L2 = [True, 'False', 100]
print(L1+L2) #['Alice', 66, 'Bob', True, 'False', 100]
print(L1*2) #['Alice', 66, 'Bob', 'Alice', 66, 'Bob']
print(100 in L2) #True
print(True not in L2) #False

8. 拷贝列表

#### 拷贝列表

#### 赋值操作
L1 = ['Alice', 66, 'Bob']
L2 = L1
L1.append('AA')
print(L1) #['Alice', 66, 'Bob', 'AA']
print(L2) #['Alice', 66, 'Bob', 'AA']
L2.append('BB')
print(L1) #['Alice', 66, 'Bob', 'AA', 'BB']
print(L2) #['Alice', 66, 'Bob', 'AA', 'BB']
##原因:L1和L2的地址一样
print(id(L1)) #1986677652992 [电脑随机生成的]
print(id(L2)) #1986677652992

#### copy操作
L1 = ['Alice', 66, 'Bob']
L2 = L1.copy()
L1.append('AA')
print(L1) #['Alice', 66, 'Bob', 'AA']
print(L2) #['Alice', 66, 'Bob']
L2.append('BB')
print(L1) #['Alice', 66, 'Bob', 'AA']
print(L2) #['Alice', 66, 'Bob', 'BB']

9. 列表排序

#### 列表排序

L1 = ['Alice', 66, 'Bob']
L1.reverse()
print(L1) #['Bob', 66, 'Alice']
# 切片反转
print(L1[::-1]) #['Alice', 66, 'Bob']

# 升序
L2 = [1, 66, 33, 16]
L2.sort()
print(L2) #[1, 16, 33, 66]

10. 列表转换

#### 列表转换【list函数】
a = 'python'
print(list(a)) #['p', 'y', 't', 'h', 'o', 'n']
b = 123
res = str(b)
print(res) #字符串123
L = list(res) 
print(L) #['1', '2', '3']

11. 遍历列表

列表的遍历，我们可以使用for in 循环，或者搭配range函数一起都可以。

#### 【range函数】

#### 遍历数字
for i in range(4):
    print(i) #0 1 2 3
for i in range(0, 4):
    print(i) #0 1 2 3
for i in range(0, 4, 2):
    print(i) #0 2
   
#### for in遍历列表
L = ['10', '20', '30']
for i in L:
    print(i) # #10 20 30
    
#### range遍历列表    
L = ['10', '20', '30']
for i in range(len(L)):
    print(L[i]) #10 20 30

12. 其他函数

### 其他函数
list = [1,2,3,4]
print(min(list)) #1
print(max(list)) #4
print(sum(list)) #10

list = ['aaa','bbb','ccc']
print(min(list)) #aaa
print(max(list)) #ccc
print(sum(list)) #报错

03. 元祖(tuple)

1. 创建元组

# 创建一个空元组
T = ()

# 创建单个元素的元组
T = (1,) #【注意】：如果不加逗号，会变为整数类型

# 创建多个元素的元组
T = (1, 2, 2, 3, 3)

T = 1, 2, 2, 3, 3 #不带括号也可以创建元组，但尽量不要这么写吧
print(type(T)) #<class 'tuple'>

2. 访问元素

和列表一样，元组中的元素既可以使用正向索引访问，也可以使用反向索引访问，正向索引从0开始，反向索引从-1开始。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

# 通过下标的方式访问元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena
print(T[-2]) # ==> David

# 切片访问(和列表一样)
print(T[1:3]) # ==> ('Bob', 'Candy')

3. 元组的特性(不可删除)

元组和列表不一样的是，元组中的每一个元素都不可被改变，无法修改删除或者添加，而列表是可以的。所以我们也可以称，元组是只读的列表。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

# 不允许替换元素
T[1] = 'Boby' # 报错

# 不允许删除元素
del T[1] # 报错

# 不允许添加元素
T[5] = 'Mike' # 报错

【扩展】：以上元组的特性，针对的是元组中仅包含基础数据类型（数字类型、布尔类型、字符串类型）的元素，对于组合数据类型的元素，我们是可以改变这个组合数据类型中的某个值的。

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

4. 元组运算符

元组的运算符和列表都是一样的

#### 列表运算符
T1 = ('Alice', 66, 'Bob')
T2 = (True, 'False', 100)
print(T1+T2) #('Alice', 66, 'Bob', True, 'False', 100)
print(T1*2) #('Alice', 66, 'Bob', 'Alice', 66, 'Bob')
print(100 in T2) #True
print((100) in T2) #True 
print(True not in T2) #False

5. 元组和列表相互转换

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
T = tuple(L)
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
L2 = list(T)
print(L2) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

6. 遍历元祖

元组的遍历和列表一致；

#### for in遍历元组
T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
for i in T:
    print(i, end="|") # Alice|Bob|Candy|David|Ellena|
    
#### range遍历元组    
T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
for i in range(len(T)):
    print(T[i], end="|") # Alice|Bob|Candy|David|Ellena|

7. 其他函数

count	用来统计元组中某个元素出现的次数
index	返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置，如果没有该元素，会直接报错
min	查找最小值
max	查找最大值
sum	求和

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1
print(T.count(10)) # ==> 0

print(T.index(9)) # ==> 10
print(T.index(5)) # ==> 8
print(T.index(1)) # ==> 0 # 多次出现，返回第一次出现的位置
# print(T.index(100)) # ==> 报错

print(min(T)) # ==> 1
print(max(T)) # ==> 9
print(sum(T)) # ==> 37

04. 字典(dict)

1. 创建元素

字典的核心就是：配对！即：键值对(key:value)！就是将列表中的下标索引进行自定义设计；

# 字典创建的语法，通过 花括号 以及 key:value 的方式构成：
字典变量 = {key:value,key:value...}

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49,
    'Gaven': 86
}
print(d['Bob']) # ==> 60
print(d['Alice']) # ==> 45
print(d['Dodo']) # 报错，不存在

# get方法读取【推荐】
# print(d.get('Dodo')) # ==> None 【dict本身提供get方法，把key当作参数传递给get方法，
# 就可以获取对应的value，当key不存在时，也不会报错，而是返回None】

2. 访问元素

方法名	说明
.get(key)	返回key对应的值，当key不存在时，返回None
dict[key]	返回key对应的值，当key不存在时，会报错

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49,
    'Gaven': 86
}

# get方法读取【推荐】
print(d['Bob']) # ==> 60
print(d.get('Dodo')) # ==> None

# 直接通过索引key读取
print(d['Bob']) # ==> 60
print(d['Alice']) # ==> 45
print(d['Dodo']) # 报错，不存在

3. 增加元素

增加字典元素只需要添加一个key，再写上对应的value值就可以；如果新增的key重复，value值会被替换。

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}

d['Dodo'] = 88
d['Alice'] = 100 # 因为Alice存在，所以它的值会被替换成100
print(d) # {'Alice': 100, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, 'Dodo': 88}

4. 删除元素

方法名	说明
.pop(key)	指定需要删除的元素的key，当key不存在时，会引起错误
.clear()	清除所有元素

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
#使用pop删除字典元素
d.pop('Alice')
print(d) #{'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}

#使用clear清除所有元素
d.clear()
print(d) #{}

5. 字典的特性

字典的一个重要特性：key不可变。key可以是数字、字符串、元组，但不能是列表，因为列表是可变的。

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
key = (1, 2, 3) # 以tuple作为key
d[key] = True
print(d) # {'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, (1, 2, 3): True}
key2 = [1, 2, 3]
d[key2] = True # 报错，列表不能作为key

6. 遍历字典

遍历dict有两种方法，第一种是遍历dict的所有key，并通过key获得对应的value。

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for key in d: 
    value = d[key]
    print(key, value)
    
#以上输出的结果：   
'''
Alice 45
Bob 60
Candy 75
David 86
Ellena 49
'''

第二种方法是通过dict提供的items()方法

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for key, value in d.items():
    print(key, value)
    
#以上输出的结果：   
'''
Alice 45
Bob 60
Candy 75
David 86
Ellena 49
'''

【注意】：如果只想遍历字典中的key，可以直接这么做：

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for x in d:
    print(x,end=' ') #Alice Bob Candy David Ellena

【注意】：如果只想遍历字典中的value，可以直接这么做：

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
for x in d.values():
    print(x,end=' ') #45 60 75 86 49

7. 其他函数

方法名	说明
len(dict)	计算字典元素的个数，即key的总数
str(dict)	输出字典的字符串表示
type(dict)	输入字典，会返回字典类型

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
print(len(d)) #5
print(str(d)) #转为字符串类型：{'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}
print(type(d)) #<class 'dict'>
{'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}

05. 集合(set)

1. 创建集合

集合的创建，大体上分为两种：

使用{}直接创建，将元素放在{}中，注意集合{}不能为空，否则会默认创建的是一个空字典；
使用set()函数来创建一个集合。

# 1.直接使用集合字面量  
my_set1 = {1, 2, 3, 4, 5, 1}
print(my_set1) #{1, 2, 3, 4, 5} #自动去掉重复元素,以下雷同
  
# 2.使用列表来初始化集合  
my_list = [1, 2, 3, 4, 5, 1]  
my_set2 = set(my_list)
print(my_set2) #{1, 2, 3, 4, 5}
  
# 4.使用元组来初始化集合  
my_tuple = (1, 2, 3, 4, 5, 1)  
my_set3 = set(my_tuple)
print(my_set3) #{1, 2, 3, 4, 5}
  
# 5.不必要的冗余写法，相当于集合中又套了一个{}  
my_set4 = set({1, 2, 3, 4, 5, 1})
print(my_set4) #{1, 2, 3, 4, 5}

2. 添加元素

方法名	返回值说明
.add()	往集合中逐个添加元素
.update()	往集合中批量添加元素

name_set = set(['Alice', 'Bob'])
name_set.add('Gina') #add：逐个添加
print(name_set) # ==> {'Bob', 'Alice', 'Gina'}

my_list = ['Hally', 'Isen']
name_set.update(my_list) #update：批量添加
print(name_set) # ==> {'Isen', 'Gina', 'Bob', 'Alice', 'Hally'}

3. 删除元素

方法名	返回值说明
.remove()	删除集合中的元素
.pop()	删除集合中的第一个元素
.clear()	清空集合中的元素

name_set = set(['Jenny', 'Ellena', 'Alice', 'Bob'])
name_set.remove('Jenny')
print(name_set) # {'Bob', 'Ellena', 'Alice'} 【注意】：删除Jenny这个元素后，集合中的元素是随机摆放的，所以后面使用pop删除首个元素，可能得到的结果是不一致的

name_set.pop()
print(name_set) # {'Ellena', 'Alice'}

name_set.clear()
print(name_set) #set()

4. 判断元素是否存在

由于set里面的元素是没有顺序的，因此我们不能像list那样通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中，这个时候我们可以使用in来判断某个元素是否在set中。

s = set([1, 4, 3, 2, 5, 4, 2, 3, 1])
print(1 in s) #True
print(6 in s) #False

5. 集合的特性

set里面的元素不允许重复。【如果重复了，会自动进行去重处理】
set里面的元素没有顺序。

06. 序列（总结篇）

在这里插入图片描述

07. if 条件判断

1. if…单一条件

假设你一周七天中只有周一才能穿新衣服，那么就需要 if语句 中 单一条件判断：

单一条件判断的if语句格式如下：

if 条件判断:
	条件满足时，执行

# 注意1：判断的数值需要转换为整数再判断
# 注意2：a == 1由于习惯或方式，可以加上括号(a == 1)
# 注意3：if条件判断内的语句，需要用Tab键缩进才能识别
a = int(input("请输入今天星期几，1-7之间："))
if a == 1:
    print("今天穿新衣")

2. if…else分支

单一if语句比较高冷，如果未满足条件，它就不理你了；而else分支则可爱许多；

else分支条件判断的if语句格式如下：

if 条件判断:
	条件满足时，执行
else:
	条件不满足时，执行

# 注意1：else后面有冒号，表示结束
# 注意2：else需要和if在同一垂直位对齐，否则报错
if a == 1:
    print("今天穿新衣")
else:
    print("今天无法穿新衣")

08. 多重嵌套

1. elif…多重分支

年龄决定一个人当前的状态，8岁到80岁，你都在干什么？此时需要elif多重分支：

if 条件判断:
	条件满足时，执行
elif 条件判断:
	条件满足时，执行
...

# 8-25之间：求学阶段
# 26-60之间：工作阶段
# 大于60：退休阶段
a= int(input("请输入你的年龄：8-80之间："))
if a >= 8 and a <=25:
    print("我在上学！")
elif a >=26 and a<=60:
    print("我在工作！")
elif a > 60:
    print("我在退休！")
else:
    print("这个年龄，尚未被统计！")

2. if…嵌套判断

难道大于60岁就真的可以退休了吗？真实情况显然不是这样的，我们还需要具体判断：

...
elif a > 60:
    # 如果爷爷有大伯，二伯和我爸
    # 且，我还有姐姐和弟弟
    # 再且，大伯、二伯每家还有三个
    # 为了存压岁钱，也无法退休呢！
    b = int(input("请输入子孙的数量，1-9之间："))
    if b >= 7 and b <=9:
        print("退休后打两份工")
    elif b >= 4 and b <=6:
        print("退休后打一份工")
    elif b <= 3:
        print("退休中！")
...

09. while循环

1. 认识while循环

（1）while循环简介

while循环是一种条件控制循环，只要给定的条件为真，循环就会持续执行。它通常用于重复执行一个任务，直到条件不再满足，跳出循环。

（2）while循环示意图

在这里插入图片描述

（3）while循环语法

2. while常规循环

需求：输出1~3之间所有的整数，并用“|”分隔开

i = 1 # 初始化变量1
while i <= 3: # 如果变量小于等于3，则执行下面的循环体
    print(i, end="|")
    i += 1  # 当执行完毕，自增1
# 以上循环最终结果：1|2|3|    

------------------------------------
这里我们依次拆解while循环的过程：
第一次循环：
	i = 1
    i <= 3 条件成立
    print(i, end="|") ---> 结果：输出1|
    i += 1，相当于 i = 2
第二次循环：
	i = 2 因为第一次循环结束后i已经变为2了
    i <= 3 条件成立
    print(i, end="|") ---> 结果：输出1|2|
    i += 1，相当于 i = 3
第三次循环：
	i = 3 
    i <= 3 条件成立
    print(i, end="|") ---> 结果：输出1|2|3|
    i += 1，相当于 i = 4 
第四次循环：
	i = 4 
    i <= 3 条件不成立，循环终止 
------------------------------------

需求：计算1到3之间所有整数的和

i = 1 # 初始化变量1
sum = 0 #初始化求和变量，用于统计最终的结果
while i <= 3: # 如果变量小于等于3，则执行下面的循环体
    sum += i # 累加
    i += 1  # i自增1
print(sum) # 6

------------------------------------
这里我们依次拆解while循环的过程：
第一次循环：
	i = 1
    sum = 0
    i <= 3 条件成立
    sum += i 相当于sum = sum+i = 0+1
    i += 1，相当于 i = 2
第二次循环：
	i = 2 
    sum = 0+1
    i <= 3 条件成立
    sum += i 相当于sum = sum+i = 0+1+2
    i += 1，相当于 i = 3
第三次循环：
	i = 3 
    sum = 0+1+2
    i <= 3 条件成立
    sum += i 相当于sum = sum+i = 0+1+2+3
    i += 1，相当于 i = 4 
第四次循环：
	i = 4 
    sum = 0+1+2+3
    i <= 3 条件不成立，循环终止,最终sum = 6 
------------------------------------

3. while死循环

while循环除了普通的循环，有时候也会出现死循环的情况，比如：

# 只要判断表达式永远为True，则不停的执行
while True:
    print(1)
# 以上代码会不停的输出1的值，因为条件始终是成立的，所以循环会一直执行，也就出现了所谓的死循环，这时候计算机会卡死，性能消耗太大了；但是，死循环也不是一无是处，我们可以利用死循环的特性，结合break语句，帮助我们做一些特殊的处理，后面我们会讲到。

10. for循环

1. 认识for循环

（1）for循环简介

在Python中，for循环是一种用于遍历序列（如列表、元组、字典、字符串）或其他可迭代对象（如range对象等）的控制流语句。

（2）for循环示意图

（3）for循环语法

for 变量 in 序列:
	循环体

【注】：在这个结构中，变量是一个临时变量，用于获取序列中的每一个元素。循环体会针对序列中的每个元素各执行一次。

2. for循环示例

需求：输出1~3之间所有的整数，并用“|”分隔开

for i in range(1,4): # 使用range函数生成一个从1到3的整数序列: [1,2,3]
    print(i, end="|")

# 结果：1|2|3|

------------------------------------
这里我们依次拆解for循环的过程：
第一次循环：
	i = 1 【range生成的第一个数】
    print(i, end="|") ---> 结果：输出1|
第二次循环：
	i = 2 【range生成的第二个数】
    print(i, end="|") ---> 结果：输出1|2|
第三次循环：
	i = 3 【range生成的第三个数】
    print(i, end="|") ---> 结果：输出1|2|3|
------------------------------------

需求：计算1到3之间所有整数的和

sum = 0 #初始化求和变量，用于统计最终的结果
for i in range(1,4):
    sum += i # 累加
print(sum) # 6

------------------------------------
这里我们依次拆解for循环的过程：
第一次循环：
	sum = 0 
	i = 1 【range生成的第一个数】
    sum += i，即sum = sum + i = 0+1
第二次循环：
	sum = 0+1
	i = 2 【range生成的第二个数】
    sum += i，即sum = sum + i = 0+1+2
第三次循环：
	sum = 0+1+2
	i = 3 【range生成的第三个数】
    sum += i，即sum = sum + i = 0+1+2+3 = 6
------------------------------------

11. 退出循环

1. break退出整体循环

break语句的作用：立即退出整个循环；

需求：输出1~10之间所有的整数，并用“|”分隔开

for i in range(1, 11):
    print(i, end="|") 
#最终结果：1|2|3|4|5|6|7|8|9|10|

假如我们给出的序列为range(1, 11) ，依旧是1_{11的序列，但是我们只想要输出1}3之间的整数，该怎么做呢？此时，我们就可以使用break语句了。

for i in range(1, 11):
    print(i, end="|")
    if i == 3:
        break
#最终结果：1|2|3|

------------------------------------
这里我们依次拆解for循环的过程：range范围[1,2,3,4,5,6,7,8,9,10]
第一次循环：
	i = 1 【range生成的第一个数】
    print(i, end="|") ---> 结果：输出1|
    if i == 3: 条件不成立，break语句不执行，循环继续
        break 
第二次循环：
	i = 2 【range生成的第二个数】
    print(i, end="|") ---> 结果：输出1|2|
    if i == 3: 条件不成立，break语句不执行，循环继续
        break 
第三次循环：
	i = 3 【range生成的第三个数】
    print(i, end="|") ---> 结果：输出1|2|3|
    if i == 3: 条件成立，进入下面的break语句，立即停止整个循环，所以最终结果为：1|2|3|
        break 
------------------------------------

2. continue退出当前循环

continue语句的作用：终止当前循环；

沿用上面的例子，假如我们给出的序列为range(1, 11) ，依旧是1_{11的序列，现在我们的需求是输出1}10之间所有的整数，但不想要3这个整数，该如何做呢？此时，我们就可以使用continue语句了。

for i in range(1, 11):
    # 注意：这里continue必须在输出语句前面执行，否则白搭
    if i == 3:
        continue
    print(i, end="|")
#最终结果：1|2|4|5|6|7|8|9|10|

------------------------------------
这里我们依次拆解for循环的过程：range范围[1,2,3,4,5,6,7,8,9,10]
第一次循环：
	i = 1 【range生成的第一个数】   
    if i == 3: 条件不成立，continue语句不执行，循环继续
        continue 
    print(i, end="|") ---> 结果：输出1|
第二次循环：
	i = 2 【range生成的第二个数】
    if i == 3: 条件不成立，continue语句不执行，循环继续
        continue 
    print(i, end="|") ---> 结果：输出1|2|
第三次循环：
	i = 3 【range生成的第三个数】  
    if i == 3: 条件成立，进入下面的continue语句，会跳过本次循环，但是下面的循环仍会继续
        continue 
    print(i, end="|") ---> 结果：输出1|2|
第四次循环：
	i = 4 【range生成的第四个数】  
    if i == 3: 条件不成立，continue语句不执行，循环继续
        continue 
    print(i, end="|") ---> 结果：输出1|2|4|
以下循环依次类推：......
	最终结果：结果：1|2|4|5|6|7|8|9|10|
------------------------------------