day05-while与for循环

莫西莫西，python小精灵来喽

已于 2023-08-05 20:58:53 修改

阅读量104

点赞数

文章标签： python 前端

于 2023-07-27 21:29:00 首次发布

本文链接：https://blog.csdn.net/zhx13469781541/article/details/131968721

版权

本文介绍了Python中的循环结构，包括while和for循环，以及循环控制语句break和continue的使用。同时详细讲解了字符串的常见操作，如查找、替换、连接和格式化输出等，并给出了实际编程示例。

摘要由CSDN通过智能技术生成

作业

print()
"""
1、学习成绩大于等于90为优秀 60到89分为及格 低于60分为不及格
if...elif..elif
if...elif..else
"""
grade = int(input('请输入你的成绩(0-100之间):'))

if grade >= 90:
    print('优秀')
elif 80 <= grade <= 89:
    print('良好')
elif 70 <= grade <= 79:
    print('一般')
elif 60 <= grade <= 69:
    print('及格')
else:
    print('不及格')

请输入你的成绩(0-100之间):90
优秀

进程已结束,退出代码0

占位符

"""
获取数据 ----都是要写逻辑代码的   pass

解析数据

保存数据

"""
def getsource():
    pass

def analysisdata():
    pass

def savedata():
    pass

while循环嵌套

"""一天"""
# i = 0
# while i <= 10:
#     print("媳妇儿，我错了")
#     i += 1

"""三天"""
j = 1
while j <= 3:
    i = 0
    while i <= 10:
        print("媳妇，我错了")
        i += 1
    print(f"做第{j}天的家务")
    j += 1
"""循环嵌套 先确定内循环的工作  再确定外循环的工作 
程序的执行流程也是 先等内循环执行完再去执行外循环  对应可以看课件中的执行流程  
"""
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
做第1天的家务
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
做第2天的家务
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
媳妇，我错了
做第3天的家务

进程已结束,退出代码0

while-else

# i = 1
# while i <= 5:
#     if i == 3:
#         print('这遍道歉说的不真诚')
#         break
#     print('媳妇，我错了')
#     i += 1
# else:
#     print('媳妇原谅我了,哈哈哈')

# 总结： 所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，
# else下方缩进的代码将不执行。

# i = 1
# while i <= 5:
#     if i == 3:
#         i += 1  # 当用到continue时，计数器一定要加上，不然会出现死循环
#         continue
#     print('媳妇，我错了')
#     i += 1
# else:
#     print('媳妇原谅我了,哈哈哈')

# 总结：因为continue是退出当前你一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，
# 当循环结束后，则执行了else缩进的代码。
# flag = 5
# while flag:
#     print(1)
#     while True:
#         print(2)
#         break
#     print(3)
#     flag -= 1
#     # print(flag)
#     break
# else:
#     print(888)

range()函数

print()
"""
range()函数用来生成一组整数序列的  
左闭右开的  
range(start, stop[, step]) -> range object
start  起始值 
stop   终止值 
step   步长   只有整型 没有浮点型 
函数   
print()
input()
len()
range()
def xxx():
    pass




"""
# print(list(range(1, 101)))
for i in range(1, 101, 2):
    print(i/2)
0.5
1.5
2.5
3.5
4.5
5.5
6.5
7.5
8.5
9.5
10.5
11.5
12.5
13.5
14.5
15.5
16.5
17.5
18.5
19.5
20.5
21.5
22.5
23.5
24.5
25.5
26.5
27.5
28.5
29.5
30.5
31.5
32.5
33.5
34.5
35.5
36.5
37.5
38.5
39.5
40.5
41.5
42.5
43.5
44.5
45.5
46.5
47.5
48.5
49.5

进程已结束,退出代码0

for循环语法

print()
"""
可迭代对象
能够使用for循环遍历的对象

li = [1,2,3,4]
for ...(指的是可迭代对象中的每一个值 临时变量 变量名(符合命名规则)可以随便去取 )  in ...(可迭代对象)   


for i in li:  
"""

# li = [1, 2, 3, 4]
# for i in li:
#     print(i)

# 遍历字符串
# for i in 'Python':     # 第一个实例
#     print(i)


# 字符串 name = "hello world python i love you"
# 通过for循环遍历所有的o
name = "hello world python i love you"
for i in name:
    if i == "a":
        print(i)

for循环嵌套使用

print()
"""
可迭代对象
能够使用for循环遍历的对象

li = [1,2,3,4]
for ...(指的是可迭代对象中的每一个值 临时变量 变量名(符合命名规则)可以随便去取 )  in ...(可迭代对象)   


for i in li:  
"""

# li = [1, 2, 3, 4]
# for i in li:
#     print(i)

# 遍历字符串
# for i in 'Python':     # 第一个实例
#     print(i)


# 字符串 name = "hello world python i love you"
# 通过for循环遍历所有的o
name = "hello world python i love you"
for i in name:
    if i == "a":
        print(i)
1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12   4*4=16
1*5=5   2*5=10   3*5=15   4*5=20   5*5=25
1*6=6   2*6=12   3*6=18   4*6=24   5*6=30   6*6=36
1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49
1*8=8   2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64
1*9=9   2*9=18   3*9=27   4*9=36   5*9=45   6*9=54   7*9=63   8*9=72   9*9=81

进程已结束,退出代码0

break与continue语句

"""break"""
# i = 1
# while i <= 10:
#     if i == 5:
#         print('完成今天的任务')
#         break   # 终止掉整个循环
#     print(f'今天刷了{i}辆车')
#     # print(i)
#     i += 1
import time

"""continue"""
i = 1
while i<=100:
    if i == 4:
        print(f"第{i}辆车是劳斯莱斯，跳过")
        i += 1
        continue
    # time.sleep(2)   # 让程序休眠2秒钟
    print(f"今天刷了{i}辆车")
    i+=1
今天刷了1辆车
今天刷了2辆车
今天刷了3辆车
第4辆车是劳斯莱斯，跳过
今天刷了5辆车
今天刷了6辆车
今天刷了7辆车
今天刷了8辆车
今天刷了9辆车
今天刷了10辆车
今天刷了11辆车
今天刷了12辆车
今天刷了13辆车
今天刷了14辆车
今天刷了15辆车
今天刷了16辆车
今天刷了17辆车
今天刷了18辆车
今天刷了19辆车
今天刷了20辆车
今天刷了21辆车
今天刷了22辆车
今天刷了23辆车
今天刷了24辆车
今天刷了25辆车
今天刷了26辆车
今天刷了27辆车
今天刷了28辆车
今天刷了29辆车
今天刷了30辆车
今天刷了31辆车
今天刷了32辆车
今天刷了33辆车
今天刷了34辆车
今天刷了35辆车
今天刷了36辆车
今天刷了37辆车
今天刷了38辆车
今天刷了39辆车
今天刷了40辆车
今天刷了41辆车
今天刷了42辆车
今天刷了43辆车
今天刷了44辆车
今天刷了45辆车
今天刷了46辆车
今天刷了47辆车
今天刷了48辆车
今天刷了49辆车
今天刷了50辆车
今天刷了51辆车
今天刷了52辆车
今天刷了53辆车
今天刷了54辆车
今天刷了55辆车
今天刷了56辆车
今天刷了57辆车
今天刷了58辆车
今天刷了59辆车
今天刷了60辆车
今天刷了61辆车
今天刷了62辆车
今天刷了63辆车
今天刷了64辆车
今天刷了65辆车
今天刷了66辆车
今天刷了67辆车
今天刷了68辆车
今天刷了69辆车
今天刷了70辆车
今天刷了71辆车
今天刷了72辆车
今天刷了73辆车
今天刷了74辆车
今天刷了75辆车
今天刷了76辆车
今天刷了77辆车
今天刷了78辆车
今天刷了79辆车
今天刷了80辆车
今天刷了81辆车
今天刷了82辆车
今天刷了83辆车
今天刷了84辆车
今天刷了85辆车
今天刷了86辆车
今天刷了87辆车
今天刷了88辆车
今天刷了89辆车
今天刷了90辆车
今天刷了91辆车
今天刷了92辆车
今天刷了93辆车
今天刷了94辆车
今天刷了95辆车
今天刷了96辆车
今天刷了97辆车
今天刷了98辆车
今天刷了99辆车
今天刷了100辆车

进程已结束,退出代码0

字符串操作

<a name="cc4dd1da"></a>
# 字符串
**字符串是 Python 中最常用的数据类型。我们可以使用引号 ( ' 或 " ) 来创建字符串。创建字符串很简单，只要为变量分配一个值即可**
```python
# 单引号
var1 = 'Hello World!'
# 双引号
var2 = "Python Runoob"
# 三引号
var3 = """hello world
      i love you """
```
<a name="12f01ba6"></a>
# 字符串的输入输出
**格式化输出**
```python
name = "TOM"
age = 18
heigth = 180.5

print("我的名字是%s"%name)
print("我今年%d岁了"%age)
print("我的身高是%.2f"%heigth)
print("大家好，我叫{},我今年{}岁，我的升高是{}".format(name,age,heigth))
print(f"大家好，我叫{name},我今年{age}岁，我的升高是{heigth}")
```
**输入input()**
```python
>>>name = input("请输入你的名字：")
>>>"tom"
>>>print(type(name))

>>>age = input("请输入你的年龄：")
>>>18
>>>print(type(age))
```

---

<a name="zYNaI"></a>
# 访问字符串中的值
**下标**⼜叫 **索引**,就是编号。⽐如⽕⻋座位号，座位号的作⽤：按照编号快速找到对应的座位。<br />注意点：下标从0开始进行计算 
```python
var1 = "hello python"
print(var1[1])
print(var1[2])
print(var1[4])

# 输出结果
>>>e
>>>l
>>>o
```

---

<a name="261b8a9f"></a>
# 字符串中的切片
> **切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作**

- 不包含结束位置下标对应的数据， 正负整数均可；
- 步⻓是选取间隔，正负整数均可，默认步⻓为1。
```python
name = "hellopython"
print(name[2:5])    # 从2开始，到5结束(不会拿到5本身)
print(name[2:5:1])  # 从2开始，到5结束，步长为1(不会拿到5本身)
print(name[:5])     # 从0开始，下表为5结束(不会拿到本身)
print(name[1:])     # 从1开始，一直到结束
print(name[:])      # 拿取所有
print(name[::2])    # 从0开始，步长为2，拿取所有
print(name[:-1])    # 从0开始，到最后一个数结束(-1代表最后一个数，不包含-1本身)
print(name[-4:-1])  # 从倒数第四个开始，到倒数第一个结束(不包含-1本身)
print(name[::-1])   # 从-1开始，倒着打印字符串，步长为1
print(name[::-2])   # 从-1开始，倒着打印字符串，步长为2
```
<a name="iNY8t"></a>
# 字符串常用操作方法
**Python**3 的**字符串操作方法**包括 string 替换、复制、连接、比较、查找、大小写转换、分割 、判断等。
<a name="UBBf0"></a>
## 查找
**含义: 所谓字符串查找⽅法即是查找⼦串在字符串中的位置或出现的次数。**
<a name="orcKD"></a>
#### find()：检测某个字符串是否包含在这个字符串中，如果在，返回这个字符串开始的位置下标，否则则返回-1。

- **语法**
```python
lstr.find(str, start=0, end=len(lstr))

开始和结束位置下标可以省略，表示在整个字符串序列中查找。
```

- **实例**
```python
# 字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
var = "hello and python and hello world"

print(var.find("and"))          # 查找到and首字母下标
print(var.find("and",8,20))     # 查找到下标为8-20，and首字母下标
print(var.find("ors"))          # 查找ors，如果没有，则返回-1
```
<a name="JQSo9"></a>
#### index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。

- **语法**
```python
lstr.index(str, start=0, end=len(lstr))

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
```

- **实例**
```python
# 字符串序列.index(⼦串, 开始位置下标, 结束位置下标)

var = "hello and python and hello world"
print(var.index("and"))          # 查找到and首字母下标
print(var.index("and",8,20))     # 查找到下标为8-20，and首字母下标
print(var.index("ors"))          # 查找ors，如果没有，则报错
```
<a name="wXo1i"></a>
#### count()：返回某个⼦串在字符串中出现的次数

- **语法**
```python
lstr.count(str, start=0, end=len(lstr))
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
```

- **实例**
```python
# 字符串序列.count(⼦串, 开始位置下标, 结束位置下标) 

var = "hello and python and hello world"

print(var.count("and"))         # 查看在字符串var中，and出现了多少次
print(var.count("ands"))        # 如果没有，则返回0次
print(var.count("and",8,20))    # 在一个区间内查找and出现的次数
```
<a name="PUnWJ"></a>
#### 拓展(了解即可)
```python
var = "hello and python and hello world"

# rfind()： 和find()功能相同，但查找⽅向为右侧开始。
print(var.rfind("and"))

# rindex()：和index()功能相同，但查找⽅向为右侧开始。
print(var.rindex("and"))
```
<a name="8347a927"></a>
## 修改
**含义:对字符串当中的内容进行修改**
<a name="QWBNC"></a>
### replace():替换内容

- **语法**
```python
1str.replace(str1, str2,  1str.count(str1))

```

- **实例**
```python
# 字符串序列.replace(旧⼦串, 新⼦串, 替换次数) 
var = "hello and python and hello world"
print(var.replace("and","和"))       # 将里面所有的and替换为和
print(var.replace("and","和",1))     # 将and替换为和，只替换一次
注意：替换次数如果超出⼦串出现次数，则替换次数为该⼦串出现次数。
```
**注意：数据按照是否能直接修改分为可变类型和不可变类型两种。**<br />**字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。**
<a name="kpMFG"></a>
### split()：按照指定字符分割字符串。

- **语法**
```python
1str.split(str=" ", maxspilt='')
注意：maxspilt表示的是分割字符出现的最大次数
```

- **实例**
```python

var = "hello and python and hello world"
print(var.split("and"))         # 以and为界，分隔开其他字符串，返回一个列表
print(var.split("and",1))       # 以and为界，分隔开其他字符串，只分割一次，返回一个列表
```
<a name="HwUfZ"></a>
## 连接
<a name="gaUNi"></a>
### join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。

- **语法**
```python
语法：  'sep'.join(iterable)
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
```

- **实例**
```python
# 字符或⼦串.join(多字符串组成的序列)

list1 = ["hello", "python", "i", "love", "you"]
t1 = ("hello", "python", "i", "love", "you")
set1 = {"hello", "python", "i", "love", "you"}

print("__".join(list1))     # 将列表转化为字符串，并且使用指定符号隔开
print(",".join(t1))         # 将元组转化为字符串，并且使用指定符号隔开
print("|".join(set1))       # 将集合转化为字符串，并且使用指定符号隔开
```
<a name="XdeFi"></a>
## 删除
<a name="eSEet"></a>
#### lstrip()：删除字符串左侧空⽩字符。
```python
var = "    hello and python and hello world      "

print(var.lstrip())             # 删除左侧空格
```
<a name="OyeWl"></a>
#### rstrip()：删除字符串右侧空⽩字符。
```python
var = "    hello and python and hello world      "

print(var.rstrip())             # 删除右侧空格
```
<a name="lzL0j"></a>
#### strip()：删除字符串两侧空⽩字符。
```python
var = "    hello and python and hello world      "

print(var.strip())          # 删除两侧空格
```
<a name="lIK0H"></a>
## 判断
<a name="nz2wv"></a>
#### isalpha()：如果字符串所有字符都是字⺟则返回 True, 否则返回 False。
**语法**
```python
mystr1 = 'hello'
mystr2 = 'hello12345'

print(mystr1.isalpha())       # 结果：True
print(mystr2.isalpha())       # 结果：False
```
<a name="XGAWB"></a>
#### isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
**语法**
```python
mystr1 = 'aaa12345'
mystr2 = '12345'

print(mystr1.isdigit())       # 结果： False
print(mystr2.isdigit())       # 结果：False
```
<a name="eNj6w"></a>
#### isalnum()：如果字符串所有字符都是字⺟或数字则返 回 True,否则返回False。
**语法**
```python
mystr1 = 'aaa12345'
mystr2 = '12345-'

print(mystr1.isalnum())       # 结果：True
print(mystr2.isalnum())       # 结果：False
```
<a name="WRAhw"></a>
#### isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。
**语法**
```python
mystr1 = '1 2 3 4 5'
mystr2 = ' '

print(mystr1.isspace())       # 结果：False
print(mystr2.isspace())       # 结果：True
```
<a name="KF456"></a>
## 其他方法
<a name="EI2r3"></a>
#### startswith()：检查字符串是否是以指定⼦串开头
**语法**
```python
# 字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标) 
var = "hello and python and hello world"

print(var.startswith("hello"))       # 开头是hello，返回True
print(var.startswith("and"))         # 开头不是and，返回False
print(var.startswith("and",6,20))     # 在索引6-20，开头是and，返回True
```
<a name="SaZCq"></a>
#### endswith()：检查字符串是否是以指定⼦串结尾
**语法**
```python
var = "hello and python and hello world"

print(var.endswith("and"))          # 结尾不是and，返回False
print(var.endswith("world"))         # 结尾时world，返回True
print(var.endswith("and",0,9))       # 在0到9的索引范围，是and结尾，返回True
```
<a name="FnGdN"></a>
#### capitalize()：将字符串第⼀个字符转换成⼤写。
```python
var = "hello and python and hello world"

print(var.capitalize())          # 将字符串第⼀个字符转换成⼤写。
```
<a name="vIPqM"></a>
#### title()：将字符串每个单词⾸字⺟转换成⼤写。
```python
var = "hello and python and hello world"

print(var.title())          # 将字符串每个单词⾸字⺟转换成⼤写。
```
<a name="OIOuG"></a>
#### upper()：将字符串中⼩写转⼤写。
```python
var = "hello and python and hello world"

print(var.upper())          # 将字符串中⼩写转⼤写。
```
<a name="hwpcN"></a>
#### lower()：将字符串中⼤写转⼩写。
```python
var = "hello and python and hello world"

print(var.lower())          # 将字符串中⼤写转⼩写。
```
<a name="n8mLO"></a>
#### ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
<a name="NjEbF"></a>
#### rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
<a name="SQ7Sf"></a>
#### center()：返回⼀个原字符串居中,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串

<a name="4d6b1389"></a>
# 字符串运算
a = "Hello",b = "Python"

| + | 字符串连接 | >>>a + b | 'HelloPython' |
| --- | --- | --- | --- |
| [] | 通过索引获取字符串中字符 | >>>a[1] | 'e' |
| [ : ] | 截取字符串中的一部分 | >>>a[1:4] | 'ell' |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | >>>"H" in a | True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | >>>"M" not in a | True |
| r | 取消转义 | >>>r“你\\n好” | 你\\n好 |
| % | 格式字符串 |  |  |

循环1之while循环

<a name="69bdc66b"></a>
# 循环
> 将事物循环执行

**作用**<br />思考：假如我有个⼥朋友，有⼀天我们闹⽭盾⽣⽓了，⼥朋友说：道歉，说100遍“媳妇⼉，我错了”。这个时候程序员会怎么做？<br />答：100遍 print('媳妇⼉，我错了')<br />思考：复制粘贴100次吗？<br />答：重复执⾏100次⼀样的代码，程序中循环即可
<a name="a6317b46"></a>
## 循环的分类
> Python 提供了 for 循环和 while 循环

| 循环类型 | 描述 |
| --- | --- |
| while | 在给定的判断条件为 true 时执行循环体，否则退出循环体。 |
| for | 重复执行语句 |

<a name="f5684dce"></a>
### 循环控制语句
| 控制语句 | 描述 |
| --- | --- |
| break 语句 | 在语句块执行过程中终止循环，并且跳出整个循环 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass 语句 | pass是空语句，是为了保持程序结构的完整性。 |

<a name="9861eb98"></a>
## while循环
> Python 编程中 while语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务

**语法**
```python
while 判断条件：
     执行语句
```
<a name="98656ea0"></a>
### 应用一：输出100次媳妇，我错了
```python
# 循环的计数器
i = 1
while i < 100:
    print('媳妇⼉，我错了')
    i += 1
print('任务结束')
```
<a name="d71f5036"></a>
### 应用二：计算1-100的和
```python
num = 1
result = 0
while num <= 100:
    result += num
    num+=1
print(result)
```
<a name="394ae44b"></a>
### 应用三：计算1-100偶数和
> **2+4+6+8+10+......**

> **偶数即是和2取余结果为0的数字，可以加⼊条件语句判断是否为偶数，为偶数则累加**

**方法一**
```python
num = 1
result = 0
while inum <= 100:
    # 判断num是否能整除2，如果可以，则和result相加
    if num % 2 == 0:
        result += num
    num += 1
print(result)
```
**方法二**
```python
num = 0
result = 0
while num <= 100:
    result += num
    num += 2
print(result)
```
<a name="534f738b"></a>
## break和continue语句
> **案例：**有100辆汽车需要刷漆，一辆一辆刷，就相当于循环过程
> **break：**当刷到第50辆，完成了当天的任务，刷漆的动作就要停止，**这⾥就是break控制循环流程，即终⽌此循环**
> **continue：**我拿的是马自达的油漆，结果第20辆车是劳斯劳斯，所以直接跳过这辆，继续刷马自达，**这⾥就是continue控制循环流程，即退出当前⼀次循环继⽽执⾏下⼀次循环代码**

<a name="27c0a78c"></a>
### 应用一：刷漆-break
```python
i = 1
while i <= 100:
    if i == 51:
        print('完成今天的任务')
        break
    print(f'今天刷了{i}辆车')
    i += 1
```
<a name="1037d86d"></a>
### 应用二：刷漆-continue
```python
i = 1
while i<=100:
    if i == 33:
        print(f"第{i}辆车是劳斯莱斯，跳过")
        i += 1
        continue
    print(f"今天刷了{i}辆车")
    i+=1
```

---

<a name="e5d67abc"></a>
## while循环嵌套
> 思考：和⼥朋友闹⽭盾⽣⽓了，⼥朋友说：道歉，说10遍“媳妇⼉，我错了”，还不够，还要做家务，而且持续三天，这个程序该怎么写？

**一天**
```python
i = 0
while i <= 10:
    print("媳妇儿，我错了")
    i += 1
```
**三天**
```python
j = 1
while j<=3:
    i = 0
    while i<=10:
        print("媳妇，我错了")
        i+=1
    print(f"做第{j}天的家务")
    j += 1
```
<a name="a94b229e"></a>
### 执行流程
> 当内部循环执⾏完成之后，再执⾏下⼀次外部循环的条件判断。

![嵌套循环.png](https://cdn.nlark.com/yuque/0/2023/png/25414438/1675338226224-1a88fb8a-8ab6-4c2e-829c-22585f585743.png#averageHue=%23f8f5f5&clientId=u8e0c10e8-461c-4&from=ui&id=u446ca702&originHeight=615&originWidth=846&originalType=binary&ratio=1&rotation=0&showTitle=false&size=32673&status=done&style=none&taskId=u002e0f53-a9f3-45e9-bb3c-6f6224162db&title=)

九九乘法口诀表
```python
j = 1
while j <= 9:
    i = 1
    while i<=j:
        print(f'{i}*{j}={i*j}',end='\t')
        i += 1
    print()
    j += 1
```

循环2之for循环

# 缩进补充
在 Python 中，对于类定义、函数定义、**流程控制语句**、异常处理语句等，行尾的冒号和下一行的缩进，表示下一个代码块的开始，而缩进的结束则表示此代码块的结束。
   注意，Python 中实现对代码的缩进，可以使用空格或者 Tab 键实现。但无论是手动敲空格，还是使用 Tab 键，通常情况下都是采用 4 个空格长度作为一个缩进量（默认情况下，一个 Tab 键就表示 4 个空格）。
```python
dream = int(input('请输入你的愿望选项:'))
if dream == 1:
    print('有钱')
elif dream == 2:
    print('时光倒流')
elif dream == 3:
    print('和岳岳结婚')
elif dream == 4:
    print('长生')
elif dream == 5:
    print('钢铁的肾')
else:
    print('你在做梦！')

```
Python 对代码的缩进要求非常严格，同一个级别代码块的缩进量必须一样，否则解释器会报 SyntaxError 异常错误。
# 语句与代码块补充
语句由关键字、标识符、表达式组成。
```python
a = 1
print(a)
print(1)
```
而代码块由若干条语句组成。通常Python中的代码块是通过缩进来创建的。
```python
age = 18
if age>=18:
    print('你已经成年了！')

```
在Python中，使用冒号:指出接下来是一个代码块，并将该代码块中的每行代码都缩进相同的程度。发现缩进量与之前相同时，你就知道当前代码块到此结束了。
使用缩进来表示新的代码块是Python语言的特色之一。
# pass占位符补充
python3中的pass语句是一个空语句，什么都不做，执行它时什么也没有发生，是一个空操作。
      pass语句通常用作占位符(place-holder)，即当用户不知道要编写什么代码时，用户只需在那行上放置pass。
      在语法上需要有条语句但是确不希望执行任何命令或代码时可以使用pass。用户可以简单地将pass放置在不允许空代码的地方，例如函数定义、类定义(通常用于创建最小类)、循环或if语句中。用户使用pass语句可以避免这个错误。
# while...else
Python中的循环可以和else配合使用，else下方缩进的代码指的是**当循环正常结束之后要执行的代码**。
### 语法规则
```python
while 条件:
    条件成立重复执行的代码
else:
    循环正常结束之后要执行的代码
```
### while...else之终止与退出循环 
```python
i = 1
while i <= 5:
    if i == 3:
        print('这遍道歉说的不真诚')
        break
    print('媳妇，我错了')
    i += 1
else:
    print('媳妇原谅我了,哈哈哈')

总结： 所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，
else下方缩进的代码将不执行。

i = 1
while i <= 5:
    if i == 3:
        i += 1  # 当用到continue时，计数器一定要加上，不然会出现死循环
        continue
    print('媳妇，我错了')
    i += 1
else:
    print('媳妇原谅我了,哈哈哈')

总结：因为continue是退出当前你一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，
当循环结束后，则执行了else缩进的代码。
```
# for...in...循环
> **Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。**
> for-in遍历的对象必须是**可迭代**对象。

### 语法规则
```python
for 临时变量 in 待处理数据集:
   重复执行代码
```
> 理论上来讲，for循环无法构建无限循环(待处理的数据集不可能无限大)

**实例**
```python
# 遍历字符串
for i in 'Python':     # 第一个实例
    print(i)
```
> 可以看出for循环是将字符串的内容**依次取出**，所以for循环也被称之为**遍历循环**

**练习**
```python
# 字符串 name = "hello world python i love you"
# 通过for循环遍历所有的o
name = "hello world python i love you"
for i in name:
    if i == "o":
        print(i)
```

---

# range()函数
> for循环本质上是遍历**“序列类型”**，但是，使用**range**函数，可以获得一个简单的**数字序列**

**语法：**
```python
range(num)
# 获得一个从0开始，到num结束的数字序列(不含num本身)
# 例如range(5),获得的数据是[0,1,2,3,4]

range(num1,num2)
# 获取一个从num1开始，到num2结束的数字序列(不含num2本身)
# 例如range(2,8)，获得的数据是[2,3,4,5,6,7]
 
range(num1,num2,step)
# 获取一个从num1开始，到num2结束的数字序列(不含num2本身)
# step 为步长，默认为1
# 例如range(1,10,2)，获取到的数据是[1,3,5,7,9]

num1 = 10
num2 = 0
range(num1,num2,-1)
# 从10到1,依次打印,（不含num2本身）
# range(10,0,-1),获取到的数据是[10,9,8,7,6,5,4,3,2,1]
```
## 实例
```python
# 输出0~9
for i in range(10):
    print(i)
    
# 输出1~100
for i in range(1,101)

# 输出1~100，每次跳过一个数字
for i in range(1,101,2):
    print(i)
```
# for循环的嵌套应用
**生活中的嵌套**
> 和女朋友吵架，每天道歉10遍，持续5天

```python
for 临时变量 in 待处理数据集:
    重复执行代码一
    重复执行代码二
    重复执行代码三
   for 临时变量 in 待处理数据集:
        重复执行代码三
        重复执行代码三
        重复执行代码三
```

- **坚持道歉5天**
- **每天道歉10遍**
```python
for i in range(1,6):
    print(f"这是我第{i}天的道歉")
    for j in range(1,11):
        print(f"老婆，我错了，这是我今天的第{j}次道歉")
    print(f"老婆，第{i}天的道歉结束。。。")

print(f"我已经道歉了{i}天了，老婆不生气了")
```
**for循环和while循环配合使用**
```python
for i in range(1,6):
    print(f"这是我第{i}天的道歉")
    j = 1
    while j<=10:
        print(f"老婆，我错了，这是我今天的第{j}次道歉")
        j+=1
    print(f"老婆，第{i}天的道歉结束。。。")
```

---

# break和continue
while循环和for循环都是重复性的执行特定的操作，在这个过程中，会出现一些其他情况，让我们不得不

-  跳过这次循环，进入下一次循环 
-  终止当前循环  
## continue
> 中断本次循环，进入下一次循环

```python
# 碰见7的倍数直接跳过
for i in range(100):   # 遍历出0~99
    if i % 7 == 0:    # 判断i是7的倍数
        continue      # 满足条件直接跳过
    print(i)         # 打印出其余的数字
```
## break
> 终止循环，结束当前循环

```python
# 当马自达刷完后直接停止，因为后面是劳斯莱斯
li = ["马自达","马自达","马自达","劳斯莱斯","劳斯莱斯","劳斯莱斯","劳斯莱斯"]
for i in li:
    if i == "劳斯莱斯":
        print("碰见劳斯莱斯了")
        break
    print("正在刷马自达。。。")
```

---

# 练习
## 1~100偶数的和
## 求5的阶乘！
## 9*9乘法表

练习1

# num = 0
# for i in range(1, 101):
#     # print(i)
#     if i % 2 == 0:
#         # print(i)
#         num += i
# print(num)

# num2 = 0
# for i in range(2, 101, 2):
#     print(i)
#     num2 += i
# print(num2)

"""sum() 求和 """

# li = list(range(2,101,2))
# print(li)
# print(sum(li))

"""5的阶乘
5！ = 5*4*3*2*1

"""
result = 1
for i in range(1, 5):  # 1 2 3 4 5
    result *= i
print(result)

进程已结束,退出代码0