无论是for循环还是while循环，默认的终止条件都是边界条件。在触发边界条件之前，代码会一直循环执行。

那有没有可以改变这种“默认循环执行”的方法呢？答案是肯定的。

学习两个关键字：break、continue。

某些场景里，需要在特定的条件出现时强行终止循环，并执行循环之后的代码。

这时候，就可以使用 break 这个关键字来完成。

break

定义：break用于跳出当前的循环语句的执行。

break语句既可以用在for循环中也可以用在while循环中。

它一般和if语句搭配在一起使用，表示如果满足了某种特定条件，就直接终止当前的循环结构。

break的具体用法。

numberList = [10, 4, 1, 20, 6]
for i in numberList:
    print(i)
    if i > 15:
        break
print(numberList)

# output
# 10
# 4
# 1
# 20
# [10, 4, 1, 20, 6]

代码的作用
这六行代码遍历了一个列表numberList，并依次输出其中的元素。

第2-5行是一个完整的for循环结构。如果列表中有大于15的元素，就终止循环结构。

for循环外，输出了完整的numberList。

遍历列表
使用 for...in... 的结构，依次遍历numberList中的元素。

输出元素
for循环内的代码块，依次输出列表中的元素。

按理来说，列表一共有五个元素，print(i)会执行 5 次。

但在本例中，print(i)只运行了 4 次，依次输出了列表中10、4、1和20这四个元素。

稍后详细解释这里只运行了四次的原因。

if语句
使用if语句判断变量i是否大于15。

如果判断条件成立，就执行下面的缩进代码：break；
如果判断条件不成立，则进入下一次循环。

break
一个关键字break，执行它时将结束整个循环结构。

本例中，在遍历到列表的第四个元素时，由于20大于15，判断条件成立，执行缩进代码break，程序跳出该循环。
因此，print(i)只执行了四次。

for循环外
执行break后，程序不会进入下一次循环继续遍历列表的第五个元素，而是从循环外的第一行开始执行：输出列表numberList。

代码小结
通过如下格式在代码中使用break

while循环里break的用法和在for循环中类似。

示例中，n的初始值为0，我们使用while循环依次输出小于10的整型。

当n小于10时，输出n。

第4-5行使用if语句判断了n是否等于5。

如果n等于5，执行break，跳出整个while循环；
如果n不等于5，则将n加一，继续进入下一次while循环。

因此，运行结果中依次输出了0、1、2、3、4和5。

因为当n等于5时，就执行break，跳出整个循环了。

小思考

（一）运行以下代码，最后输出的结果是什么：

num_list = [30, 2, 0, 1]
total = 0
for num in num_list:
    if num == 0:
        break
    total = total + num
print(total)

解析
total在for循环外，初始化为0。

第一次遍历：num是30，不等于0，所以total=0+30=30。
第二次遍历：num是2，不等于0，所以total=30+2=32。
第三次遍历：num等于0，执行break，跳出当前循环，运行for循环外的第一行代码。

因此，最后输出的值为32。

（二）运行以下代码，最后输出的结果是什么：

i = 5
while i < 20:
    if i > 7:
        break
    print(i)
    i = i + 1

解析
本题中，i的起始值为5，使用while循环依次输出小于20的整型。

如果i大于7，就执行break，结束整个循环结构；如果小于等于7，则i等于i+1，继续进入下一次while循环。

在while循环遍历到第4次的时候（i等于8时），程序会跳出整个while循环，不会再执行print(i)。因此，最后只有前三次print(i)的运行结果。依次是5,6,7

上面学习了，即使在边界条件保持为True时，也可以通过使用break来终止整个循环结构。

但是，如果只想跳过循环内某些语句，接着返回到循环的开头，继续进入下一次循环，该怎么办？

这时候，就需要用到另一个关键字：continue 。

continue

定义：continue会“跳过”本次循环内的剩余代码。

注意，continue是跳过本次循环，而break跳出整个循环结构。

continue的具体用法。

drinks = ["water", "coke", "tea", "milk"]
for item in drinks:
    if item == "coke":
        continue
    print(item)

代码的作用
这5行代码遍历了一个列表drinks。

第2-5行是一个完整的循环结构。在循环内，通过if语句判断该列表中是否有元素是"coke"。

如果有，则跳过本次循环中的剩余代码，也就是第5行的print(item)，直接进入到下一次循环。

如果没有，就执行print(item)，然后进入下一次循环，直到列表drinks中所有元素都被取完为止。

遍历列表
使用 for...in... 的结构，依次遍历drinks中的元素。

if语句
使用if语句判断item是否等于"coke"。

如果等于，就执行continue语句；
如果不等于，则执行print(item)。

continue
一个关键字continue，它会跳过本次循环中后面的剩余代码，直接进入下一次循环。

本例中，在遍历到列表的第二个元素时，item是"coke"，判断条件成立，执行缩进代码continue，程序跳出本次循环，进入下一次循环。

因此，print(item)没有输出coke。

代码小结
通过如下格式在代码中使用continue

while循环里continue的用法和在for循环中类似。

示例中，n的初始值为0，我们使用while循环依次输出小于10，但不包含5的整型。

第4-5行使用if语句判断了n是否等于5。

如果n等于5，执行continue，跳过当前的while循环，进入下一次while循环；
如果不等于5，则将n输出。

因此，运行结果中依次输出了1-10里，除了5以外的所有整型。

continue是可以被if语句替代的，比如刚才的例子就有两种写法。

对比单纯地使用if语句，continue的优势在于它能加快程序的运行时间。

在实际应用中可以根据自己的需要来进行选择。

break与continue的区别

最后，再来通过两段代码来感受一下break和continue的区别～

当执行break时，会跳出整个循环结构，并运行循环外的第一行代码。

执行continue时，会“跳过”本次循环内的剩余代码，返回到循环的开头，继续执行下一次循环。

总结一下：

break直接终止整个循环结构；
continue是跳过当前循环中剩下的代码，继续进入下一次循环。

循环的综合应用

回顾

学习了for计数循环；while条件循环；以及跳出循环的两种方法break，continue。

现在通过一些真实的案例来更进一步体会循环的妙处。

女生节马上要到啦，夜曲的行政小A在准备礼物时，发现了一大堆需要重复做的事情，咱们用循环大法来帮助她吧。

小A需要在大屏幕上显示出夜曲每一位女性员工的名字+女生节快乐！

女性员工姓名列表为girls = ["Max","Sunny","Chris","Sissi","May","Ann"]

for循环遍历列表
没错，我们可以用for循环遍历列表girls，并用格式化输出的方式，输出每个女员工的姓名+祝福语。

for循环进行累加/累乘的计算
除了遍历列表，for循环经常应用在多个数累加/累乘的计算中。

例如：我有一个列表，里面是自己京东账户购物车里的5件商品的价格，然后需要计算清空购物车花多少钱。

我们可以定义一个变量sum用来存储总金额，遍历列表jdList中的每个金额，依次累加到sum中。

除了累加和计数，for循环还可以和if条件判断结合，做复杂的条件判断。

例如：leader提出，如果女生们所选的礼品金额大于200的就可以晋级下一轮的终极女神PK！

要实现这个需求，就需要在for循环遍历列表的同时，判断礼品金额是否大于200，如果大于200就筛选出这位幸运儿。

经过一轮PK，本次女生节最幸运的女神是Ann～
她将获得老板特批的“清空护肤品愿望清单特权”一次。

OMG！也就是说老板会为她购买愿望清单里每一个品牌的每一种单品哦！！

猜猜看这用程序应该如何做呢？

嵌套
可以使用嵌套循环来实现这个功能，在了解嵌套循环之前，我们先来回顾一下嵌套。

在if判断语句中，我们学习过if语句的相互嵌套。

嵌套的if条件判断：就是在一个条件判断中之下再叠加一层条件判断。

嵌套循环
同理，嵌套循环就是一个循环出现在另一个循环里。

嵌套循环的特征是：对于外循环的每次迭代，内循环都要完成它的所有迭代。

嵌套循环

brandList = ["Ja mer","Cbp","SK3"]
itemList = ["精华","面霜","眼霜","爽肤水"]
for brand in brandList:
    for item in itemList:
        print(f"恭喜你将获得{brand}品牌的{item}一份")

代码的作用
这5行代码的意思是使用for循环遍历列表brandList中的元素，之后进入内循环遍历itemList中的所有元素，使用print输出每一种组合。

定义列表
第一行定义列表brandList，列表中有3个数据。

第二行定义列表itemList，列表中有4个数据。

接下来要进入外循环遍历brandList中的数据。

遍历列表-外循环
第三行，用for...in...结构遍历列表brandList，依次取出列表中的元素。

每取出一个元素就进入到下一个for循环结构中。

缩进
缩进的代码是一个代码块，也就是嵌套循环中的内循环，在每次外循环中都要执行。

在这里，建议缩进四个空格，和其他语句类型的缩进保持一致。

遍历列表-内循环
第四行，用for...in...结构遍历列表itemList，依次取出列表中的元素。

每取出一个元素，就进行一次格式化输出。

缩进
缩进的代码是一个代码块，表示内循环每遍历一个元素就要进行一次格式化输出。

这8个空格实际上是由外层循环代码块的4个空格加上内层循环代码块的4个空格组成的。

结果
用格式化字符串的形式输出结果。

输出的结果是"恭喜你将获得{brand}品牌的{item}一份"

代码小结
当我们要用嵌套for循环输出所有组合时就需要这几个部分

（嵌套循环执行过程）

第一行和第二行分别是brandList品牌列表和itemList单品列表

第四行代码进入外循环，对brandList列表里的元素进行遍历，遍历得到第一个元素“Ja mer“后

程序进入第五行代码开始内循环，对itemList列表里的元素进行遍历，遍历得到第一个元素”精华“

此时第一次内循环结束，输出 ”恭喜你将获得Ja mer品牌的精华一份“

接下来继续剩下三次的内循环

分别完成三次itemList列表的遍历及输出

完成内循环后，此时程序回到外循环，开始遍历brandList列表的第二个元素Cbp

之后进入内循环，重复刚才的过程，直到itemList列表遍历完成

就这样每次内循环迭代完成后，再进入外循环迭代，直到外循环迭代完成，整个嵌套循环虎牙完毕了

lucky的亮亮，获得了9个奖品。

不过他打算告诉女朋友，自己只获得了列表中的前5个礼物，密谋着要把剩下的礼物卖掉换成私房钱～嘿嘿。

接下来我们试着用while循环帮助亮亮在公屏上输出前5个礼物的名字，截屏给亮亮的女朋友看。

while循环解决此问题的思路：

1. 定义列表present存储9个礼物的名称，定义一个用于计数的变量count，并将其赋值为0

2. 使用while循环进行判断，count是否小于等于4

3. 如果是就格式化输出"恭喜你获得了{present[count]}一份"

4. 每循环一次将count计数加1

present = ['苹果新款手机', '苹果平板电脑', '苹果智能手表', '华为新款手机', '华为平板电脑', '华为智能手表', '小米新款手机', '小米平板电脑', '小米智能手表']

count = 0

while count <= 4 :
    print(f"恭喜你获得了{present[count]}一份")
    count = count + 1

for循环
除了while循环，我们还可以使用for循环来实现刚刚的效果。

例如：创建一个列表aList = [0,1,2,3,4]，使用用for循环遍历礼物列表中前五项的礼物并打印出来。

上面的遍历了5个数字的列表，我们可以通过创建列表的方式完成。

可是如果我们要遍历100个整数，或者1000个整数呢？

难道需要手动创建非常冗长的列表吗？no,no,no！

学习一种更高效的方法～

遍历整数列表

for i in range(5):
    print(i)

代码的作用
for i in range()的功能是：遍历一个整数列表。

其中range()的功能是：创建一个整数列表。

例如：range(5)可以生成一个从0 开始到5结束但不包括5的整数列表[0,1,2,3,4]。

for…in…
第一行，用for...in...结构遍历range()功能生成的列表中的每一个值。

range(5)
使用range()功能，填入数字5，可以生成一个从0 开始到5结束但不包括5的整数列表[0,1,2,3,4]。

结果
for循环遍历range(5)生成的列表[0,1,2,3,4]
每赋值给i一次，就执行一次print(i)。
直到全部赋值完为止，循环才结束。

代码小结
当我们要遍历一个整数列表就需要这几个部分

range(5)可以生成从0到4的整数列表。
如果我们需要生成从1到4的整数列表，只需要在range(5)中添加一个初始计数值1，改成range(1,5)就可以啦。

range()功能中可以填写2个内容,range(a,b)。
a: 计数从 a 开始。默认是从 0 开始，可省略。
b: 计数到 b 结束，但不包括 b，不可省略。

for i in range(1,9)
用for循环遍历range()生成的列表中每一个数据。

range(1,9)
1表示从1开始
9表示到9为止不包含9

小练习

使用for循环，遍历5到99的整数，并输出结果。

# 使用for循环遍历5到99的整数列表
for i in range(5,100):
    # 输出结果i
    print(i)

请使用for循环和range()函数的知识点。
计算50以内，不包括50的正整数之和，并输出最终结果。

number = 0
for i in range(50) :
    number = number + i
print(number)

for循环回顾

学习了如何利用for语句实现代码重复执行的循环结构。

通过遍历列表，输出其中的每一个元素。

for循环就像是排队办事，一个个进入，轮流办理，每个人经历的流程都一样。

在for循环，一次遍历就是一次循环，因此我们知道会经历过几次循环。

在另一种情况下，我们并不关心循环几次，只在意循环什么时候结束。

这样的循环逻辑，就对应Python中的条件循环（也叫while循环）。

条件循环

条件循环，又称while循环，以判断条件是否成立，来决定是否执行循环内的代码。

当判断为真时，代码会循环执行，当判断为假时则终止循环。

while循环中，有一个判断条件，来决定是否执行循环内的代码。

判断为True，则继续执行循环；
判断为False，就会中止循环。

这样的判断条件，我们称为——边界条件。

边界条件

while循环的边界条件，是指终止循环的那个判断条件。
边界条件为False，则中止循环。

（隐喻：跑圈的时候，条件为小于10圈就一直跑。直到跑到10圈，教练吹哨，就停止跑圈。）

理解了while循环的概念，来看看代码的语法格式。

同样是输出一个列表里面的所有元素，如何使用while循环来完成

while循环

nameList = ["Max","Tom","Jim","Ken","Kim"]
counter = 0
while counter < 5:
    print(nameList[counter])
    counter = counter + 1

代码的作用
这5行代码使用了while循环把列表的元素全部输出出来。

第3行使用while循环，判断Counter是否小于5。若是，就进入循环；若不是，程序就终止。

第4行，条件为True时，输出列表nameList中索引为Counter的元素；

第5行，在条件为True时，用Counter计数，继续回到第3行代码，不断循环，直到while循环判断为False，程序结束。

counter初始化
变量counter赋值0，进行初始化。

while
使用关键词while，表明我们要在这里开始执行“while循环”的代码结构。

边界条件
边界条件，如果该条件成立（True=真），就执行下面的缩进代码；

如果该条件不成立（False=假），就终止循环。

英文冒号:
一个冒号，循环语句的固定格式，表明接下来缩进的代码块，在每次边界条件为True的时候，都要执行。

四个空格
四个空格，循环缩进的固定格式，表明同样缩进的代码在每次边界条件为True的时候，都要执行。

循环内代码
缩进后的代码，是一个代码块，是循环中要执行的部分。

（while循环运行流程）

while标志着开始进入条件循环，判断这时的counter是否小于5，由于上面定义了counter初始化赋值为0，小于5满足条件，因此进入循环

在第一次循环中，输出了列表索引为0的元素Max

然后counter + 1 ，重新赋值给counter，也就是0+1 变为1

重新又判断一次，此时的counter是否小于5，由于counter刚刚修改为1，小于5满足条件，依旧进入循环，输出

列表索引为1的元素Tom

然后counter +1 重新赋值给counter，就变成了1+1 变为 2

重新又一次进行判断，满足条件后，继续进入循环，输出此时索引是counter的元素 Jim

然后counter + 1，再一次进入判断看是否满足条件

直到counter +1 之后，值变为5，进行判断时，5 < 5 不成立，返回False，就终止了这个循环，这就是while循环过程。

代码小结

通过如下格式在代码中使用while循环

小练习

（一）

sum= 0
counter= 0
while counter < 5:
    sum = sum + counter
    counter = counter + 1
    print(sum)

一段累加代码，输出的结果依次是0 1 3 6 10
sum是累加器，counter是计数器，都初始化为0，
然后进入while循环，sum和counter的值相加赋值给sum，
counter+1，输出sum的值，本次循环结束，进入下一循环。
直到counter小于5不成立，循环结束。

（二）

sum= 0
counter= 0
while counter < 5:
    sum = sum + counter
    counter = counter + 1
print(sum)

和上一段代码唯一不同之处在于print()语句所在的位置不一样。

上一段，在循环中输出，所以循环进行五次，就输出了五个值。

而本段代码中，print()在while循环之外，并且和while循环处于同一层级，循环结束以后才会执行print，输出最终的值。

（三）

sum= 0
counter= 0
while counter < 5:
    counter = counter + 1
    sum = sum + counter
print(sum)

本段（三）和上段（二）的不同之处，在于累加器sum和计数器counter的位置。

本段代码中，counter先+1，sum再被赋值，所以在每一次循环中，counter都是先+1以后再与sum累加计算的，
当循环执行到第五次的时候，counter等于4，进入循环以后，counter自增等于5 ，sum等于15（1+2+3+4+5），不满足条件，循环结束，
输出sum的值为15。

for循环是有天然的边界条件——完成遍历。
但while循环是有可能一直运行的。只要边界条件为真，它就会一直执行下去。
比如图中代码就会永远执行，这种循环我们又叫做”死循环”。

死循环

死循环是一种循环类型， 当一个循环永远无法终止的时候，我们就说它是一个死循环。

死循环会一直运行下去。

如图，由于边界条件永远为True，因此，循环会一直进行下去，永远不会停止。

一般来说“死循环”是一个bug，它会导致程序一直无意义运行，我们在写代码的时候一定要尽量去避免。

图中，我们修改一下之前的代码，就不会进入死循环了。因为在执行完print()以后我们给tag变量赋值了False，此时while的判断条件为False，循环就结束了。

for循环和while循环区别

总结一下，从代码的执行结果来看，for循环和while循环，都可以实现相同的功能。

但他们的区别在哪呢？

第一个区别：
for循环是在每一次循环的时候，按照从头到尾的顺序自动遍历，给变量name赋值列表中的元素；

而while循环是用一个计数器来索引列表，分别访问这个列表里面的每个元素。

第二个区别：
循环的终止条件不一样。

for循环的终止条件是遍历完这个列表；

while循环的终止条件是边界条件，counter < 5，当边界条件为True的时候继续执行代码，为False的时候就终止执行。

简而言之，需要记住三条。

1. for循环常用于处理列表内的每个元素。

2. for循环有天然的边界条件，while循环没有，需要我们精心设计边界条件。

3. 大多数时候，for循环和while循环可以互换使用。

小练习

number  = 100
while number >= 0:
    print(number)
    number = number - 1

这段代码实现了输出100以下的非负整数。
第1行给number赋值100；
第2行，执行while循环，判断number是否>=0，如果是，就执行循环内的语句。
第3行输出了当前的number。
第4行，number-1再赋值给number，得到新的number再次进入循环

for循环的基础操作

循环是计算机程序的三大语句结构之一。

它是在满足条件的情况下，反复执行某一段代码的计算过程。

假设，现在我们需要输出以下列表中的每个元素，你会怎么做呢？

numberList = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

可以通过索引，将列表中的元素一个一个的输出。

如果列表中的元素不止五项，而是几十项，甚至是几百项，我们还要大量重复编写print() 和列表索引么？这可太麻烦了。

接下来，我们试着用【循环】简化这段代码。

numberList = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
for number in numberList:
    print(number)

原本需要编写 10 行的代码，现在使用【循环】后，编写方便了很多。

在 Python 中，循环语句有两类：
for 循环和 while 循环

for 循环的结构

numberList = [10, 20, 30, 40, 50, 60]

for number in numberList:
    print(number)

代码的作用
这三行代码使用了 for 循环将列表 numberList 里面的所有元素全部输出出来。

for
使用关键字 for，表明要在这里开始执行“for循环”的代码结构。

in
使用关键词 in，和 for 搭配，表明我们要把 in 后面的列表里面的数据元素赋值给前面的变量。

变量
表示一个变量，在 for 循环里面用来存储列表中的元素。
在本例代码中，列表 numberList 中有 6 个元素，变量 number 会被赋值 6 次。

列表
列表中里面的元素会被分别赋值给变量，直到最后一个元素完成赋值，循环才结束。

冒号
循环语句的固定格式，表明接下来缩进的代码是每次循环都要执行的。

缩进
同样缩进的代码就是一个代码块，在每次循环中都要执行。
在这里，建议缩进四个空格，和 if 语句类型的缩进一样，保持同一种代码风格。

循环内
循环内的代码块，直到列表 numberList 中的元素被全部赋值完，循环才结束。
在本例中，由于列表 numberList 中的元素有 6 个，print()就要执行 6 次。

代码小结
通过如下格式在代码中使用for循环

# TODO 定义列表fruitList
fruitList = ["apple", "grape","cherry"]

# TODO for循环列表fruitList，将元素赋值给变量fruit
for fruit in fruitList :
    # TODO 输出变量fruit
    print(fruit)

# 使用 for 循环，利用切片获取列表中的第二项到第六项元素，分别赋值给一个变量 number，然后使用 print() 输出这个变量。

# 定义列表numberList
numberList = [10, 20, 30, 40, 50, 60]

# TODO for循环列表中的第二项到第六项元素
for number in numberList[1:] :
    # TODO 输出列表的元素
    print(number)

for 循环的运行流程

当程序执行完 for 循环后，如果同一层级（缩进一致）还有代码未执行，则按照顺序，继续自上而下执行。

本例中，第2行和第3行的循环，执行 6 次以后，列表 numberList 中所有元素都被访问完了，for 循环结束。
变量 number 被赋值 6 次，循环结束后，变量 number 的值为 60。

程序继续执行下面和 for 循环处于同一层级代码，输出变量 number，在运行结果中就输出了 60。

for 循环的灵活之处在于，它会根据列表中的元素个数，自动调节循环的次数。
也就是说，for 循环能自动遍历一个列表里面的所有元素。

遍历

遍历是指通过某种顺序对一个数据结构中的所有元素进行访问。

for循环不仅可以遍历列，还可以遍历字典、元组、甚至字符串等数据结构。
遍历元组和字符串与遍历列表的代码几乎一样，也是逐个获取元组或字符串的每个字符。

for 循环遍历字典稍微有一些区别。
字典是键值对的组合，那么对字典的遍历就包含【键，值，键和值】三种情况。

遍历字典的键
for 循环遍历字典的键，有两种方法可以使用：

1. for 循环遍历字典；
   这个方法和 for 循环遍历列表的格式类似。

2. for循环遍历字典中的所有键；
   使用 for 循环遍历 dict.keys()，将字典中的键赋值给变量，再通过 print() 输出变量。
   

   
   

遍历字典的值
遍历字典的值，可以通过查字典的方式，也就是通过字典的键找到对应指定的值。
首先使用 for 循环遍历字典，将键赋值给变量，通过dict[键]的方式找到对应的值，并赋值给新的变量。

接着使用 print()输出这个变量，即可遍历字典的值。

遍历字典的键和值
上面演示的是使用 for 循环遍历字典的键和字典的值，如果想要同时输出字典的键和值，该怎么办呢？
这时，可以在循环内部分别输出字典的键和对应的值。

注意，在 for 循环中，一次循环会把循环内的代码全部执行完后，再开始下一次循环。

在本例中，for 循环遍历字典productItems，在第一次循环中，变量 key 被赋值为"口香糖"。
进入循环中，第3行代码获取到"口香糖"对应的值 15，并赋值给变量 value，在第4行和第5行分别输出"口香糖"和15。
接着进入第二次循环，变量 key 被赋值为"可乐"，就这样执行完循环内的代码，再开始下一次循环，直到循环结束。

# 修改年龄
# 刘老师在录入学生年龄时，不小心输入错了学生年龄，现在她想要把学生的年龄批量修改，这该如何操作呢？
# 1. 首先定义一个叫作 studentAge 的字典，{"Gary": 14, "Adam": 13, "Jack": 15, "Max":13, "Tim":14}。
# 2. for 循环遍历字典 studentAge，将字典的键赋值给变量key；
# 2.1 利用字典键查找值的方法，将字典中全部的值修改为 16。
# 3. for 循环结束后，输出字典studentAge。

# TODO 定义字典studentAge
studentAge = {"Gary": 14, "Adam": 13, "Jack": 15, "Max":13, "Tim":14}

# TODO for循环字典studentAge
for key in studentAge :
    # TODO 修改字典的值为16
    studentAge[key] = 16

# TODO 输出字典studentAge
print(studentAge)

studentAge = {"Gary": 14, "Adam": 13, "Jack": 15, "Max":13, "Tim":14}
for key in studentAge :
    print(key)
    print(studentAge[key])

for循环的复杂应用

学习了 for 循环遍历列表、字典等数据的方式。

了解学习下for 循环与“累加” 、if 判断和“计数器”的结合运用。

学过运用四则运算，计算 a 和 b 的和。

如果，要计算列表 jdList 中所有元素的和，该怎么操作呢？

这种情况下，了解下"累加"的概念。

什么是“累加”呢？

例如，往瓶子里不断地放硬币的过程，就是“累加”。

for 循环与“累加”

jdList = [3, 1.5, 4, 2]
total = 0
for price in jdList:
    total = total + price
print(total)

代码的作用
这5行代码的功能就是，计算列表中的所有元素的总和并输出。

定义列表

第1行定义了列表 jdList ，列表中的四个元素都是可计算的数值（整型或浮点型）。

初始值

我们需要用一个变量来存储总和，第2行定义变量 total ，将0赋值给变量，这个过程就是设置初始值。

注意：这里的初始值需要定义在 for 循环的外侧，若定义在 for 循环中，每次循环变量都会重新赋值。

遍历列表

第3行使用for...in... 结构遍历列表 jdList ，依次取出每个元素。

累加

第4行使用加法，计算 total 和 price 的和，再赋值给 total。

注意：根据四则运算规则，先计算等号("=")右边内容，再将计算结果赋值给左边变量。

（累加计算过程）
for循环第一次取出的元素price的值为3

然后第一次对列表中的元素进行累加，total的初始值为0，price的值为3，两者相加和为3，赋值给total

第二次循环时，price的值为1.5

total的值为3，两者相加和为4.5，再赋值给total

第三次循环时，price的值为4

total的值为4.5，两者相加为8.5

最后一次循环，price的值为2

total的值为8.5，两者相加的结果为10.5

循环结束后，print输出的total就是10.5

结果

当 for 循环遍历结束后，此时，total 的值为最后一次计算的结果。

第5行，使用 print() 输出的就是列表中四个数据的总和。

代码小结

当使用累加来计算时，就需要这几部分

以上就是一个“累加”的应用演示。

但在列表的操作中，不仅有总和的计算。接下来，学习记录元素在列表中位置的方法。

计数器的应用

例如：班主任有一个学生名单，需要按照顺序输出，第1名是xx，第2名是xx。

一般我们会使用索引，一行行输出，点击「run」直接运行即可。

names = ["Tom", "Tim", "Amy", "Eva"]
print(f"第1名是{names[0]}")
print(f"第2名是{names[1]}")
print(f"第3名是{names[2]}")
print(f"第4名是{names[3]}")

但是这样一行行的输出太繁琐了。

为了解决这个问题，可以使用“计数器”来记录当前的遍历位置。

（什么是“计数器”？ “计数器”与“累加”的用法类似，在日常生活中，用来统计当前项目的进度）

因此，班主任输出学生排名，可以在遍历姓名的同时，使用“计数器”统计当前位置。

（计数器计算过程）

for循环第一次遍历列表，

然后使用count进行计数，此时count的值为0，+1，赋值给count，于是count的值为1.

同时数出那names列表里的第一个元素是Tom，于是输出"第一名是Tom"

第二次继续遍历

每次遍历count的值就加1

直到遍历完成。

if判断的复杂应用

学习了“累加”和“计数器”的用法后，但是部分情况下，我们不一定会对列表中的每个元素都进行累加，如果只取部分，该怎么处理呢？

如图所示，列表中已售罄商品使用"-"表示，想要剔除"-"，统计剩余商品总价，该怎样计算呢？

这时，需要使用 if 语句，先判断再计算。

如图所示，逐个取出列表中的元素，使用 if 判断，元素不等于"-"时，再进行累加。

整理前面的思路，剔除"-"计算列表 jdList 的商品总价代码如图。

第4行，if 判断 price 不等于 "-" 时，使用累加计算总价。

在 for 循环中使用 if 语句时，需要注意缩进。

第一个缩进，上节课学过 for 循环中的代码需要增加缩进，表明是一个代码块。

第二个缩进，使用 if 语句时，语句里面的内容也需要增加缩进。

使用 for 循环和 if 语句时，需要注意 print() 的位置。

1. 当 print() 在 for 循环中缩进四个空格时，按照代码执行顺序，遍历每个元素后再输出。

2. 当 print() 位置在 if 语句的代码中时，表明 print() 是 if 代码块中的内容。
   只有在 if 判断的情况成立时，才会执行 print() 。

3. 当 print() 位置与 if 语句缩进相同，按照代码执行的顺序，先执行 if 语句块，然后执行 print() 。
   因此，这里输出的内容也是列表中所有的元素。

4. 当 print() 位置与 for 循环缩进相同时，按照代码执行顺序，循环结束后，再执行 print() 语句。
   因此，输出的内容为最终结果。

小练习 - 奇数的个数

要求：

1. 定义变量 count ，初始值为0，用于计算奇数的个数；

2. 使用 for 循环遍历列表，在循环中使用 if 语句判断，当元素为奇数时，将计数器 count 的值加一。

3. 循环结束后，使用 print() 输出 count 。

# 定义numbers存储
numbers = [33.2, 4, 5, 7, 1, 2.8, 7, 5]

# 定义count初始值为0
count = 0

# 遍历列表，使用 if 判断num取模等于1时
# count计数加1，输出最终个数
for num in numbers:
    if num % 2 == 1:
        count = count + 1
print(count)

小练习 - 奇数的和

要求：

1. 定义变量 result ，初始值为0，用于存储所有奇数的和；

2. 使用 for 循环遍历列表，在循环中使用 if 语句判断，当元素为奇数时，将元素进行累加。

3. 循环结束后，使用 print() 输出 result 。

# 定义列表numbers
numbers = [33.2, 4, 5, 7, 1, 2.8, 7, 5]

# 定义变量result，初始值为0
result = 0

# for循环遍历列表
for num in numbers:
    # 使用if判断，num取模的值等于1时
    if num % 2 == 1:
        # result和num相加，赋值给result
        result = result + num
# 使用print()输出结果
print(result)

一对一的字典

在Python中，将两种数据关联在一起形成一个元素， 由多个这样的元素组成的数据类型称为字典，又称为dict。
字典中的元素是不考虑排列顺序的。

组成字典元素（item）的两个数据一一对应，分别被称为键（key） 与值（value），所以字典的元素又称为键值对（key-value）。
字典的元素只能通过键来查找对应的值，所以一个键只能对应一个值。

就像在通讯录中，我们通过联系人（键）来查找联系方式（值）。

在Python中，字典的键值对由冒号分割。冒号左边的数据为键，冒号右边的数据为值。
将多个这样的数据以逗号分割，存储到一个大括号中，就形成了一个字典类型。

products = {"口香糖": 15, "可乐": 5.5, "薯片": 45}
print(products)

代码的作用
创建一个字典“products”来存储商品信息，然后为他存储三个元素：
"15元的口香糖"，"5.5元的可乐"，"45元的薯片"。
使用print输出了整个字典。

products
一串字母，字典的变量名。

{ }
一对花括号，是字典存储数据的固定格式。

字典的键
三个字符串分别作为字典的三个键。
字典中的键可以由任意不可修改的数据类型组成（数字，字符串，元组）。
字典的键是唯一的，即一个字典不会有两个相同的键。

字典的值
三个数字分别作为字典的三个值。字典中的值可以是任意数据类型。

:
三个冒号，用来连接键与值。

,
两个逗号，分割字典中的多个元素。

代码小结
当我们要定义一个dict操作时，可以使用下面的格式

作为一种数据结构，字典和列表一样，也会有查找、删除、添加、修改等功能。
但由于字典的元素，是由键值对（key-value）组成，并且字典是没有顺序的结构，因此在功能的使用上，有所不同。

查找元素
从列表中查找一个元素时，我们通过这个元素的索引，来进行查找。

但字典是没有顺序的，也就没有索引，所以只能通过字典的键（key）来查找对应的值（value）。

删除元素
从列表中删除一个元素时，我们使用pop()功能，通过这个元素的索引，来进行删除。
在字典中，我们依旧使用pop()功能，通过这个元素的键，来进行删除。

列表是可变的，可以通过索引修改元素，也可以通过append添加内容。
事实上，字典也是一种可变的数据类型。这意味着除了查找与删除，我们也可以对字典进行添加与修改。
但是字典的添加与修改过程与列表不同。

字典的添加与修改

products = {"name": "可乐", "type": "饮品", "price": 5}
products["other"] = "七折"
print(products)

代码的作用
创建一个字典“products”来存储选择的商品信息，然后为它存储三个键值对：
“商品的名字为可乐”，“商品的类型为饮品”，“商品的价格为5”。
第2行：为字典添加一个元素：“其它优惠活动为七折”。

字典名
要修改的字典变量名

中括号
中括号，设置要添加的键

添加的键
指定一个新的键。
字典的键可以是任何不可改变的数据类型（字符串，数字，元组等）。

=
等号=，赋值符号。

添加的值
一个字符串，表示要添加的值

修改元素
字典的键是不能重复的。当我们尝试添加一个已经存在的键时，就会将该元素覆盖。
所以对字典的修改，就是对字典的某个已经存在的键重新赋值。

代码小结
当我们要为字典添加或者修改一个元素时

以上就是对字典的查找、删除、添加与修改操作。
目前为止的两种可以修改的数据类型，即字典与列表。现在我们来比较一下这两种数据类型在操作上的不同之处。

若我们不知道字典有哪些键怎么办？
在字典中，我们还可以通过"keys()"功能获取这个字典所有的键。
keys()是字典的一个功能，它能够提取一个字典所有的键，并存储在一个类似于列表的名为dict_keys的数据中，方便我们查看该字典的键。
需要注意，keys的右边有一对空的括号。

除了使用“keys()”以外，我们也可以通过in运算来检查字典是否包含某个键。

灵活多变的列表

列表又叫List，与元组的结构类似，也可以用于存储多个类型的数据。

friendName = ["Kevin", "Tony", "Asum"]
print(friendName)

代码的作用
这2行代码定义了一个叫做“friendName”的列表，并输出了列表中的内容。

第1行代码给这个列表friendName赋值，包含三个字符串数据：Kevin，Tony，Asum。
第2行代码输出了整个列表。

friendName
变量名，用来存储这个列表。

[]
一对中括号，是定义列表的固定格式。

,
逗号，列表内部数据之间使用逗号分隔开。

空格
两个空格，这里的空格不是必须的。
但为了代码美观，建议在逗号后面加一个空格。

字符串
三个字符串，是friendName这个列表里面包含的具体数据。

代码小结
我们可以使用图中的格式输出列表中的内容。

我们知道元组中可以存储多种类型的数据。
列表与元组一样，列表中的数据元素可以是任何一种类型，如图所示，整型、浮点型、布尔数等。

除此之外，列表中的数据也可以是整型，浮点型，字符串或布尔数的任意组合。
如图所示，列表mixedList中，包含整型、浮点型和字符串三种数据类型。

取单个元素
上节学过，使用索引能够获取元组中的元素，列表与元组类似，也可以使用索引。
如图所示，取第一个元素，使用players[0]，取第四个元素，就使用players[3]（索引从0开始）。

players = ["小叮当", "qian", "Tang", "Max", "杰老板", "飞飞"]
print(players[2])
print(players[5])

我们知道索引用于取单个元素，如果要提取列表中的多个连续的元素，该怎么操作呢？
先学习切片的概念。

切片

编程中的切片能对元组、列表等有序数据结构进行处理，以截取数据中连续的片段，方便使用。

someLetters = ["a", "b", "c", "d", "e"]
print(someLetters[1:3])

代码的作用
这段代码做的事情是定义了一个叫做"someLetters"的列表。

第2行代码截取了列表中的第二个和第三个元素。

定义列表
第1行两侧的一对中括号[]，表明数据类型为列表，列表中的每个元素都是字符串。
将列表赋值给变量名someLetters，因此，列表名称为someLetters，列表内容为["a", "b", "c", "d", "e"]。

[]
第2行中列表+中括号（[]），括号中既有数字也有冒号（:），表明要对列表进行切片。

:
利用切片取元素时，需要使用冒号，用于分隔切片开始的位置和切片终止的位置。

数字
切片要遵循“左闭右开”原则，就是取左边的数据，不取右边的数据，与数学中的区间类似[1, 3)，取左不取右。

注意：切片与索引类似，也是从0开始，即第一个元素的索引为0。

例如，第2行中的someLetters[1:3]，索引从0开始，这里就是取第2个元素到第4个元素。

又需要遵循“左闭右开”原则，则取第2个到第3个元素，输出['b', 'c']。

代码小结
当我们想要使用切片的时候，我们可以使用这样的格式

切片时，开始位置和结束位置的数字，还有三种填写情况。

1. 只填写结束位置的数字；

2. 只填写开始位置的数字；

3. 两侧数字都不填写。

   
   

4. 开始位置数字不填，默认从第一个元素开始切片。根据“左闭右开”原则，如图，从第一个元素（含）开始，取到第三个元素（含）。

   
   

5. 结束位置数字不填，默认从开始位置切片，取到最后一个元素。

注意：不填写结束位置的数字时，列表中最后一个元素也会被提取。如图，表示从第二个元素（含）开始，到最后一个元素（含）结束。

3. 开始位置和结束位置都不填写时，就是取列表中的所有元素。如图，[:]直接取出所有元素，但这种用法不常见，了解即可。
   

学习了列表的切片方法后，元组也可以使用切片来截取一段数据，如图所示。

学习了索引和切片访问列表中数据的方式后，如果，某个列表中的数据定义错误了，想要进行修改，该怎样操作呢？

列表的修改

friendName = ["Kevin", "Tony", "Asum"]
print(friendName)
print(friendName[0])
friendName[0] = "Jessica"
print(friendName)

# output

# ['Kevin', 'Tony', 'Asum']
# Kevin
# ['Jessica', 'Tony', 'Asum']

代码的作用
这5行代码定义了一个叫做“friendName”的列表，并输出了不同的结果。

第1行给列表friendName赋值了三个数据：Kevin，Tony，Asum。
第2行输出整个列表。
第3行输出列表中的第一个数据，也就是字符串"Kevin"。
第4行通过代码friendName[0]修改了列表的第一个数据，给它赋值字符串"Jessica"。
第5行输出了列表friendName。

friendName
变量名，用来存储这个列表。

[ ]
一对中括号，用来表示一个列表。

[0]
中括号加数字，作为索引，用来定位列表中的某个数据。
本例中，索引0表示第一个数据。

Jessica
一个字符串，重新给friendName这个列表中的第一个数据赋值。

代码小结
当我们要对列表中的数据进行修改时，可以使用图中格式

列表和元组有很多相似点，但列表的修改不能应用于元组中，元组具有不可变的特性。
元组的内容定义完成后，里面的内容就不能修改。

由于，元组是不可修改的，强行修改会出现以下 bug：
类型错误：
当对元组进行修改时，就会提示元组类型数据更改（TypeError: 'tuple' object does not support item assignment）。

了解以上知识点后，我们需要对元组和列表进行区分：

相同点：

1. 可以使用索引定位到某个元素；
2. 可以使用切片取一个片段；
3. 可以存储不同的数据，如，字符串、整型、浮点型、布尔数等。

不同点：元组内容是不可修改的。

例如：程序员在编写程序时，也会犯错，因此像元组这样不可变的数据结构可以有效防止写代码的人因为自己的错误，误修改了里面的数据。

列表的便捷操作

学习如何在列表中追加元素、插入元素和删除元素。

列表的追加

追加(Append)：追加一般用于描述在列表的末尾添加元素的行为。

Python 提供了给列表追加元素的功能。
当我们想在列表的尾部追加一个元素的时候，可以在列表名后使用 append() 语句。

friendName = ["Max", "Jeremy", "Christina"]

friendName.append("Vane")

print(friendName)

代码的作用
这三行代码定义了一个名为 friendName 的列表，并给这个列表追加了一个元素，最后输出了这个列表。

列表名
friendName 是一个列表名，用来表示先前定义的列表。

句点
一个句点，表明将会使用列表的某个内置功能。
这是一个固定的搭配格式，只能使用英文句号，不能替换成其他符号。

append
append，类似print，表明我们要在这个列表的尾部添加新的元素。

( )
一对英文括号，这是 append 功能的固定格式。括号内是具体要添加到列表末尾的元素。

追加元素
在列表 friendName 中追加一个元素，使用 append() 一次只能追加一个元素。

使用 append() 可以追加不同数据类型，包括：字符串、整型、浮点型、元组以及列表等。
在第 4 行代码中，虽然追加的是列表，但是也看作一个元素

代码小结
当在列表尾部追加一个数据时，使用如下格式：

列表的插入

在 Python 中，可以使用 insert() 语句来执行插入元素的操作。

rank = ["Max", "Jeremy", "Christina"]

rank.insert(1,"May")

print(rank)

代码的作用
在这段代码中，定义了一个名为 rank 的列表，在这个列表中间插入了一个字符串"May"，并在最后输出了这个列表。

列表名
rank 是一个列表名，用来表示先前定义的列表。

句点
句点，表明将会使用列表的某个内置功能。

insert
insert，类似print。表明我们要在这个列表的某个位置插入新的元素。

( )
一对括号，这是insert功能的固定格式。括号内是插入的元素位置以及要插入的元素。

两项内容
我们需要在 insert() 的括号中填入两项内容：
第一项是元素插入的位置；
第二项是插入的具体数据。

索引
第一个数字位置表示索引，也就是这个元素要插入到列表中的位置。
索引是从 0 开始。
本例中索引 1 表示插入到第二的位置。

逗号
一个逗号，用来分隔插入的位置以及插入的具体数据。

插入元素
插入的元素可以是不同数据类型，包括：字符串、整型、浮点型、元组以及列表等。
在本例中，我们向列表中插入一个字符串"May"。

插入元素以后，排在此元素之后的原有元素自动后移一位。
在本例中，"May"插入到列表rank中的第二项中，原有的"Jeremy"和"Christina"就自动后移一位。

代码小结
当在列表中插入一个数据时，使用如下格式：

列表删除元素

学习的两个列表内置语句：append() 和 insert()，这两个语句都可以往列表中添加新元素。
如果列表中存在不需要的元素，想要删除它，可以使用 pop()，删除列表中的元素。

primeNumber = [1, 3, 5, 7, 9, 10]

primeNumber.pop()

print(primeNumber)

代码的作用
这段代码定义了一个名为 primeNumber的列表，并且删除了这个列表中最末尾的一个元素，最后输出了这个列表。

列表名
primeNumber 是一个列表名，用来表示先前定义的列表。

句点
一个句点，表明将会使用列表的某个内置功能。

pop( )
pop()，作用是删除列表中指定索引处的元素。
括号内的数字表示要删除数据的索引，不填写数字则表示默认删除列表中的最后一个数据。

pop() 括号内的数字表示要删除数据的索引，在本例中索引值为1，就删除了列表primeNumber中的第二项元素。

代码小结
当我们需要从列表中删除一个数据，使用如下格式：

pop()在删除列表指定的元素后，可以赋值给变量存储下来。
本例中，删除的是列表primeNumber中最后一项元素 10，将整型 10 赋值给变量lastData，接着通过print()输出变量lastData。

我们前面的例子在定义一个列表时，都是使用的常量来作为列表中的元素。
变量也同样可以作为定义列表的元素，并且列表的各种操作也同样适用于变量数据。
图例中展示了变量作为列表元素时，代码的使用方式。