Python二级考试笔记

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

01. 字符串

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
weight = 1.23456
print("我的名字叫%s，今年%d岁了，身高%.2f米"%(name, age, weight)) #我的名字叫小明，今年3岁了，身高1.23米

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 boya = 'Mike'
b = 'boy'
s = '{0} is a {1}'.format(a,b) #通过索引匹配
print(s) # Mike is a boys = '{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)) #10list = ['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)

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)) # ==> 0print(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
'''

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 = 1i <= 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 = 1sum = 0i <= 3 条件成立sum += i 相当于sum = sum+i = 0+1i += 1，相当于 i = 2
第二次循环：i = 2 sum = 0+1i <= 3 条件成立sum += i 相当于sum = sum+i = 0+1+2i += 1，相当于 i = 3
第三次循环：i = 3 sum = 0+1+2i <= 3 条件成立sum += i 相当于sum = sum+i = 0+1+2+3i += 1，相当于 i = 4 
第四次循环：i = 4 sum = 0+1+2+3i <= 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+1i = 2 【range生成的第二个数】sum += i，即sum = sum + i = 0+1+2
第三次循环：sum = 0+1+2i = 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) ，依旧是111的序列，但是我们只想要输出13之间的整数，该怎么做呢？此时，我们就可以使用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) ，依旧是111的序列，现在我们的需求是输出110之间所有的整数，但不想要3这个整数，该如何做呢？此时，我们就可以使用continue语句了。

for i in range(1, 11):# 注意：这里continue必须在输出语句前面执行，否则白搭if i == 3:continueprint(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|
------------------------------------

待补充：

12.for循环嵌套、while循环嵌套、条件和循环的嵌套

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/472307.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

c入门第十八篇——支持学生数的动态增长(链表，指针的典型应用)

c入门第十八篇——支持学生数的动态增长(链表，指针的典型应用)

数组最大的问题&#xff0c;就是不支持动态的扩缩容&#xff0c;它是静态内存分配的&#xff0c;一旦分配完成&#xff0c;其容量是固定的。为了支持学生的动态增长&#xff0c;这里可以引入链表。 链表 在C语言中&#xff0c;链表是一种常用的数据结构&#xff0c;它由一系列…
阅读更多...
“分布式透明化”在杭州银行核心系统上线之思考

“分布式透明化”在杭州银行核心系统上线之思考

导读 随着金融行业数字化转型的需求&#xff0c;银行核心系统的升级改造成为重要议题。杭州银行成功上线以 TiDB 为底层数据库的新一代核心业务系统&#xff0c;该实践采用应用与基础设施解耦、分布式透明化的设计开发理念&#xff0c;推动银行核心系统的整体升级。 本文聚焦…
阅读更多...
C语言从零实现贪吃蛇小游戏

C语言从零实现贪吃蛇小游戏

制作不易&#xff0c;点赞关注一下呗&#xff01;&#xff01;&#xff01; 文章目录 前言一. 技术要点二、WIN32API介绍三、贪吃蛇游戏设计与分析 1.游戏开始前的初始化 2.游戏运行的逻辑 总结 前言 当我们掌握链表这样的数据结构之后&#xff0c;我们就可以用它来…
阅读更多...
【数据结构】16 二叉树的定义，性质，存储结构（以及先序、后序、中序遍历）

【数据结构】16 二叉树的定义，性质，存储结构（以及先序、后序、中序遍历）

二叉树 一个二叉树是一个有穷的结点集合。 它是由根节点和称为其左子树和右子树的两个不相交的二叉树组成的。 二叉树可具有以下5种形态。 性质 一个二叉树第i层的最大结点数为 2 i − 1 2^{i-1} 2i−1, i ≥ 1 i \geq 1 i≥1 每层最大结点可以对应完美二叉树&#xff08;…
阅读更多...
Linux：docker搭建redis集群（3主3从扩容缩容 哈希槽分配）

Linux：docker搭建redis集群（3主3从扩容缩容 哈希槽分配）

操作系统&#xff1a;centos7 docker-ce版本&#xff1a;24.0.7 1.准备redis镜像 我这里使用redis 6.0.8 镜像进行操作&#xff0c;如果你也需要镜像&#xff0c;在网络正常情况下直接使用 docker pull redis:6.0.8 即可进行下载&#xff0c;如果你没配置国内加速器&#x…
阅读更多...
相机图像质量研究(22)常见问题总结：CMOS期间对成像的影响--光学串扰

相机图像质量研究(22)常见问题总结：CMOS期间对成像的影响--光学串扰

系列文章目录 相机图像质量研究(1)Camera成像流程介绍 相机图像质量研究(2)ISP专用平台调优介绍 相机图像质量研究(3)图像质量测试介绍 相机图像质量研究(4)常见问题总结&#xff1a;光学结构对成像的影响--焦距 相机图像质量研究(5)常见问题总结&#xff1a;光学结构对成…
阅读更多...
机器人专题：我国机器人产业园区发展现状、问题、经验及建议

机器人专题：我国机器人产业园区发展现状、问题、经验及建议

今天分享的是机器人系列深度研究报告&#xff1a;《机器人专题&#xff1a;我国机器人产业园区发展现状、问题、经验及建议》。 &#xff08;报告出品方&#xff1a;赛迪研究院&#xff09; 报告共计&#xff1a;26页 机器人作为推动工业化发展和数字中国建设的重要工具&…
阅读更多...
LEETCODE 69. x 的平方根

LEETCODE 69. x 的平方根

class Solution { public:int mySqrt(int x) {int left0;int rightx;int midleft(right-left)/2;int ans-1;while(left<right){midleft(right-left)/2;if((long long)mid*mid<x){ansmid;leftmid1;}else{rightmid-1;}}return ans;} };*(long long)
阅读更多...
js示例1（图片轮播）

js示例1（图片轮播）

<!DOCTYPE html> <html><head><meta charset"utf-8"><title>图片轮播</title><style>#box{ /*给图片盒子创建样式*/ width : 400px;height : 400px; margin: 0 auto; position: rela…
阅读更多...
Qlik Sense : 条形图

Qlik Sense : 条形图

条形图 “条形图适合比较多个值。维度轴显示所比较的类别条目&#xff0c;度量轴显示每个类别条目的值。” Qlik Sense中的条形图是一种数据可视化工具&#xff0c;用于展示不同类别或维度之间的比较。它通过水平或垂直的条形表示数据&#xff0c;并根据数值的大小进行排序。…
阅读更多...
JavaWeb之Servlet接口

JavaWeb之Servlet接口

Servlet接口 什么是Servlet&#xff1f; Servlet是一种基于Java技术的Web组件&#xff0c;用于生成动态内容&#xff0c;由容器管理&#xff0c;是平台无关的Java类组成&#xff0c;并且由Java Web服务器加载执行&#xff0c;是Web容器的最基本组成单元 什么是Servlet容器&…
阅读更多...
如何在电脑和 SD 卡上恢复已删除 MOV等视频文件

如何在电脑和 SD 卡上恢复已删除 MOV等视频文件

MOV 是 Apple 创建的多媒体容器。您可能已经意识到&#xff0c;用 macOS QuickTime Player 录制的视频是以 MOV 格式保存的&#xff0c;而且 MOV 在 Windows 上也兼容。我们可能已经保存了很多 MOV 格式的视频。但是&#xff0c;如果这些 MOV 文件丢失或被意外删除怎么办&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023