必选参数

函数的一种参数类型,在调用这个函数的时候必须传入数据的参数。

传递实参时的顺序

在传递必选参数时,形参会按照定义的顺序依次接收数据。

调用函数时第一个参数传递给name,第二个参数传递给pet。

缺少实参

在调用函数时,缺少或超出对必选参数的传递会导致程序错误。

也就是说,在函数中定义了多少个必选参数就要传递多少个实参。

关键字传递

当我们忘记了传递顺序时,可以利用“形参名=实参名”的方式传递实参。

这样以关键字传递实参的形式,简称为关键字实参。

小练习

定义一个函数getArea,设定参数width与height分别接收矩形的宽高,计算矩形的面积并返回。

调用该函数,用关键字的形式传递参数宽为5、高为3,并按照“矩形的面积为xx”的格式输出结果。

def getArea(width, height):
    return width*height

ret = getArea(width=5, height=3)
print(f"矩形的面积为{ret}")

若定义一个计算圆形面积的函数,设定参数为半径(radius)与圆周率(pi)。

多数情况下,圆周率都会近似为3.14。

若pi不是必选参数,设其默认为3.14。只在需要修改圆周率时传递数据,函数调用起来会方便很多。

必选参数定义起来虽然简单,在调用函数时经常会因为缺少实参造成程序错误。

接下来学习给形参设置默认值。

默认值参数

def getArea(radius, pi=3.14):
    ret = radius * radius * pi
    return ret

ret1 = getArea(2)
print(ret1)
ret2 = getArea(2, 3.14159)
print(ret2)

代码的作用

定义一个函数getArea,根据传递的半径与圆周率,计算圆的面积并输出。

在第1行,定义形参radius与pi,并为pi设定默认值为3.14。

在第5行,调用函数getArea,并传递数据2。

在第7行,调用函数getArea,并传递数据2与3.14159。

关键字

一个关键字,def函数定义的关键字,是define的缩写。

括号
括号与冒号,这是函数定义的固定格式。

逗号
一个逗号,用来分割多个参数。

必选参数
一串字母radius,必选参数。

必选参数要定义在默认值参数之前。

默认参数
一串字母pi,默认值参数。

默认参数可以有任意个,但必须定义在必选参数之后(若必选参数存在)。

等号
一个等号,赋值符号。

默认值
一组数据,为参数pi设置默认值。

若在调用函数时,没有为参数pi传递实参,参数pi默认为3.14。

传递一个实参
调用函数,只为必选参数传递整数2。

因为pi没有接收到参数,所以pi将使用默认值3.14。

传递两个实参
调用函数,传递参数2与3.14159。

此时pi接收到的实参数据3.14159会覆盖默认值3.14。

代码小结
当我们定义一个默认值参数时就需要这几个部分

目前学习了两种类型的参数,必选参数与默认值参数。这两种参数形式涵盖了80%以上的函数使用。
在定义不同的参数时,需要注意避免一些常见的错误。

1.定义参数的顺序

在定义函数时,定义形参的顺序是:1,必选参数;2,默认参数。
当有必选参数和默认参数的时候,必选参数必须写在默认参数的前面,否则程序会出错

2.参数名避免使用无意义的字母

在传递实参给函数时,若忘记定义顺序可以使用“形参名=实参”的方式。
但如果定义的形参名是诸如a,abc这样无意义的名字,会减少代码可读性,容易混淆。
所以设定参数名时,尽量使用有意义的名称。

最后,对这两种参数的差异性做一个总结。

初识函数

定义
函数是指封装了某一特定功能的代码块。

简单的讲,函数就是用来存储代码的“特殊变量”。

前面接触过的很多“功能”都是函数。

比如在屏幕上输出一些数据的print(),生成一个指定范围整数序列的range()等。

函数的功能是如何定义的呢?

定义函数

def sayWelcome():
    print("欢迎光临")
    print("商品一律九折")

代码的作用
这3行代码做的事情是定义了一个叫做“sayWelcome”的函数。

这个函数的功能是输出欢迎语内容。

def
一个关键字,def函数定义的关键字,是define的缩写。

sayWelcome
一个名称,函数名。
这里的名称其实就是变量名,只不过需要存储的不再是数据,而是代码,我们称为函数名。

括号
一对括号,是函数定义的标准格式。

冒号
一个冒号,表明接下来缩进的代码是属于这个函数的。

缩进
四个空格。

和判断、循环一样,函数内部的代码也需要缩进相应的空格。

函数体
几行代码组成的代码块。

实现该函数功能的代码块,称为函数体。

代码小结
当我们要定义函数时就需要这几个部分。

现在我们已经将输出欢迎语的代码打包,并为它贴上了sayWelcome的标签。当我们需要展示欢迎语时,只需要“打电话”(call)给电脑,让它在此处执行sayWelcome的代码。

在代码中使用我们已经定义好的函数,这个过程称为调用函数(Call Function)。

调用函数

def sayWelcome():
    print("欢迎光临")
    print("商品一律九折")

sayWelcome()
sayWelcome()

代码的作用
定义一个sayWelcome函数,实现输出欢迎语的功能。

第5、6行代码,调用了sayWelcome函数。

sayWelcome
一个名称,被调用的函数名。

程序通过函数名来定位函数体中的代码。

括号
一对括号,调用符号。

表示在此处执行该函数中的代码,是调用函数的标准格式。

代码小结
当我们要调用函数时就需要这几个部分。

代码执行顺序
函数体中的代码不是立刻执行的,而是等到该函数被调用时才执行。

我们可以理解为:函数的调用是一个迂回的路径。

当程序执行到第七行代码时,开始调用setWatermark函数时,并不会继续执行第八行代码,而是跳转到定义函数setWatermark()的内部

从第二行开始执行

直到第2,3,4行代码结束

再跳回到第7行代码,从而继续执行第8行代码

现在我们可以把需要重复使用的代码定义为一个函数,就像刚才的sayWelcome函数。

若我们希望修改函数中的内容怎么办呢?

若定义函数时预留一个位置接收数据。根据不同的情况传递不同的数据,就能更加灵活的解决刚才的问题。

这时候我们需要为函数“挖空”,并在调用函数时“填空”,即设置参数。

我们把提前挖好的“空”称为形参,把用来填空的数据称为实参。

形参与实参

定义
形参是形式参数的简称,指定义函数时设置的参数名称。

实参是实际参数的简称,指调用函数时实际传递的数据。

为函数设置参数

def sayWelcome(discount):
    print("欢迎光临")
    print(f"商品一律{discount}")

sayWelcome("九折")
sayWelcome("五折")

代码的作用
定义sayWelcome函数,并为它们设置一个参数discount。

第1行,定义sayWelcome函数并在括号中设置形参名称discount。

第3行,将discount形参放到函数体中使用,使discount中的数据按照指定的格式输出。

第5~6行,多次调用sayWelcome函数,并分别为discount形参传递实参数据“九折”、“五折”。

形参
定义一个形参,用来接收数据的参数名称。

形参
在代码中使用形参,接收到的数据会被传递到此处使用。

实参
实参,调用函数时传递给形参discount的数据。

代码小结
我们通过下面的代码为函数设置参数。

形参
形参是定义函数时设置的参数名称。

相当于我们定义了一个变量,但不需要给该变量赋值。

实参
实参是调用函数时传递给形参的数据。

相当于为形参变量赋值的数据。

参数可以定义多个,也可以不定义。

如果参数不止一个,多个参数之间可以用英文逗号“,”隔开。

根据函数的功能不同,我们可以传递不同类型的实参数据。

比如,我们可以把店铺名称与产品折扣都设置为参数。

小练习

计算BMI指数
请定义一个叫做“getBMI()”的函数,该函数包括2个参数height, weight,分别代表身高和体重。

这个函数的功能是通过一个人的身高和体重计算BMI指数,并用print输出结果。

BMI指数的计算公式为:BMI = 体重 /(身高X身高)

然后分两次调用这个函数:

第一次传入参数(1.83, 60)。

第二次传入参数(1.60, 50)。

def getBMI(height, weight):
    BMI = weight / (height * height)
    print(BMI)

getBMI(1.83, 60)
getBMI(1.60, 50)

请定义一个叫做“isOdd”的函数,该函数包括1个参数number,代表一个整数。

这个函数的功能是通过if语句判断number中的数字是否为奇数,并用print输出结果。

若此数为奇数,输出“奇数”,否则输出“偶数”。 然后分两次调用这个函数:

第一次传入参数25。

第二次传入参数10。

# 定义isOdd函数
def isOdd(number):
    # 判断number是否为奇数
    if number % 2 == 1 :
        print("奇数")
    else :
        print("偶数")

# 调用isOdd函数
isOdd(25)
isOdd(10)

函数结构

假设,一位农场主想要统计自己的圈地面积有多少,面对大大小小的多个圈地,用代码该如何实现呢?

可以设定⼀个计算⾯积的函数,多次调⽤。

农场主的圈地均为正方形,测量面积的函数编写好后,如代码所示。

第 1 到第 3 行代码,定义了一个名为 getArea 的函数,用于计算正方形面积并输出。
第 5 和第 6 行代码,调用这个函数,传入参数,就可以获得不同边长的正方形面积大小。

def getArea(length):
    area = length*length
    print(area)

getArea(13)
getArea(7)

计算好了圈地的⾯积,想要计算边长为 13 的圈地⾯积是不是大于 160,如果大于 160 就用来种⻄⽠。

如本例所示,程序虽然输出了⾯积大小,但是不能在函数外比较数据的大小。
这是因为函数内输出的数据,没有传递到函数外。这时候,我们就需要设置函数返回值。

函数返回值

def getArea(length):
    area = length*length
    return area

result = getArea(13)
print(result)

代码的作用:
在本例中,第 1 到第 3 行代码定义了一个名为 getArea 的函数,其功能为计算正方形面积,并将结果返回。

第 5 行调用函数 getArea() 传入参数,将返回值赋值给变量 result

第 6 行代码,输出变量 result

return
在函数中,使⽤关键字 return 设置要返回的数据。
return 位置一般都是在函数的末尾,这样才能停止函数内的代码运行并将 return 后的值返回。

返回值
return 后面是指定的返回值,返回值会返回到调用的地方。

变量
调用函数 getArea(),传入参数 13,函数将运算结果 169 返回,并赋值给变量 result

代码小结
要定义函数和调用函数就需要这几个部分

在函数中使用关键字 return 时,要注意它的位置。
函数内部程序按照从上到下的顺序执行,如本例所示,函数内部有 for 循环,程序会等 for 循环执行完毕后,再执行 return 语句。
这样就可以得到传入列表中全部元素的累加值。

如果 return 的位置在函数的循环内部,函数内的循环只会执行一次。
因为执行到 return 语句,函数就返回当时的值,并且停止此次调用。

函数经过内部代码的执⾏会产⽣⼀个结果,这个结果可以是⼀个具体的值也可以是多个值。
在本例中,函数计算出正⽅形的周长和面积,函数返回了两个值。
当函数同时返回多个值时,以逗号 "," 隔开,并且返回值以元组的格式返回。

再来看这个案例。如图所示,左边的函数计算出正方形的面积,但是函数中没有 return 语句
此时,函数运行结束会返回一个空值(也就是None),作为返回值。

小练习

定义了一个叫做 "getSize" 的函数,该函数包含 1 个参数 length。

这个函数的功能是计算正方形周长和面积,并将两个结果作为函数的返回值返回。

现在分两次调用这个函数:
第一次传入参数 6 并输出结果。
第二次传入参数 8 并输出结果。

正方形周长 = 4 边长 正方形面积 = 边长 边长

def getSize(length):
    perimeter = 4*length
    area = length*length
    return perimeter,area

result = getSize(6)
print(result)
result = getSize(8)
print(result)

刚才农场主在函数中使用了 print(),程序输出了圈地面积,但是不能在函数外比较数据的大小。
在函数内使用 print() 可以得到数据,但是这个数据不能在函数外使用。
在函数内使用 return 可以将数据传递到函数外。

学完了函数结构中的每个部分,总结⼀下函数的结构。

函数名
为函数取名是为了方便我们重复使用。在 Python 中,函数的命名规则和变量类似。

参数
参数可以理解为函数的输入。
形参指定义函数时设置的参数名称,实参指调用函数时实际传递的数据。在本例中,num 为形参,8 为实参。
参数可以定义多个,也可以不定义。如果参数不止一个,多个参数之间用英文逗号 “,” 隔开。

函数体
函数体是函数内部实现特定功能的代码。就像做菜之前需要先想好具体的烹饪方式,等到做菜的时候再使用一样。
在本例中,函数体是为了计算一个数的二次幂(平方)和三次幂(立方)。

返回值
返回值可以理解为函数的输出。
就像对做菜的原材料进行烹饪加工,最后会得到我们想要的菜品一样,函数经过内部代码的执行也会产生一个结果。
这个结果可以是具体的值,也可以是一项具体的操作。

调用函数
在代码中使用我们已经定义好的函数,这个过程称为调用函数。
调用函数获得的返回值,可以用一个变量存储下来,就可以在函数外使用这个数据了。

代码小结
函数的结构

学习了函数结构后,还有一类函数就不得不提。
既然函数的使用顺序是先定义后调用,之前使用的很多函数, 比如 print()range()append() 等等,它们没有被我们定义,为什么还能直接被使用呢?
是因为,在 Python 中还有一类函数叫内置函数。

内置函数

和其他编程语言一样,Python也会将一些经常使用的函数预先写好,内置在编程环境中,提供许多常用的基本功能。
这些函数不需要我们去定义,可以直接使用,也被称为内置函数。

程序中使用内置函数也就是在调用函数。
例如,调用 len() 函数,它可以返回字符、列表、元组等长度或元素个数。

如图所示:
len 为函数名;
() 为调用符号,在此处执行该函数中的代码;
列表 ["a","b","c","d"] 为实参。

程序将 len(["a","b","c","d"]) 的返回值 4 ,赋值给变量data;接着,输出变量data。

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

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

学习两个关键字:breakcontinue

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

这时候,就可以使用 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再次进入循环