while循环的基础运用#

1
whie 条件(布尔类型)：
2
    条件满足时候，做事情1
3
    条件满足时候，做事情2
4
    ......(只要条件满足，会无限循环执行)

注意事项

• 条件需要提供布尔类型，True继续，Flase停止
• 空格缩进不能忘
• 请规划好循环终止条件，否则会无限循环

1
i=0
2
j=0
3
while i<101:
4
    j=j+i
5
    i=i+1
6
print(j)

1
5050

while循环的基础案例#

猜数字游戏实现

设置一个范围 1-100 的随机整数变量，通过 while 循环，配合 input 语句，判断输入的数字是否等于随机数。

功能要求

• 无限次机会，直到猜中为止
• 每一次猜不中，会提示大了或小了
• 猜完数字后，提示猜了几次

1
import random
2
num = random.randint(1, 100)

1
import random
2
num =random.randint(1,100)
3
ci=0
4
guess=int(input("cai"))
5
while guess!=num:
6
    if guess>num:
7
        print("dale")
8
    else:
9
        print("xiaole")
10
    ci+=1
11
    guess=int(input("zaicai"))
12
print(ci)
13
print(guess)

while循环的嵌套#

• 注意首行空格缩进
• 注意条件的设置，避免出现无限循环

1
print("hello",end='')
2
print("world")

1
helloworld

1
print("itzhong\tbest")
2
print("hello\tworld")

1
itzhong  best
2
hello  world

1
i=1
2
while i<10:
3
    j=1
4
    while j<=i:
5
        print(f"{j}*{i}={j*i} \t",end='')
6
        j=j+1
7
    i=i+1
8
    print()

1
1*1=1
2
1*2=2   2*2=4
3
1*3=3   2*3=6   3*3=9
4
1*4=4   2*4=8   3*4=12   4*4=16
5
1*5=5   2*5=10   3*5=15   4*5=20   5*5=25
6
1*6=6   2*6=12   3*6=18   4*6=24   5*6=30   6*6=36
7
1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49
8
1*8=8   2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64
9
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

For循环#

1
for x in i:# x是临时变量，i是待处理的数据集
2
    执行的代码

1
name="zcw"
2
for x in name:
3
    print(x)

1
z
2
c
3
w

1
name="zhongchongwang"
2
y=0
3
for x in name:
4
    if x=="g":
5
        y=y+1
6
print(y)

1
3

1
for x in range(10):
2
    print(x,end="")

1
0123456789

1
for x in range(5,10):
2
    print(x,end="")

1
56789

1
for x in range(0,10,2):
2
    print(x,end="")

1
02468

1
for i in range(1,10):
2
    for j in range(1,i+1):
3
        print(f"{j}*{i}={j*i} \t",end='')
4
    print()

1
1*1=1
2
1*2=2   2*2=4
3
1*3=3   2*3=6   3*3=9
4
1*4=4   2*4=8   3*4=12   4*4=16
5
1*5=5   2*5=10   3*5=15   4*5=20   5*5=25
6
1*6=6   2*6=12   3*6=18   4*6=24   5*6=30   6*6=36
7
1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49
8
1*8=8   2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64
9
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

break和continue#

continue的作用：中断所在循环的当前执行，直接进入下一次 break的作用：直接结束所在循环 注意： coutinue和break，在for和while循环一致 coutinue和break,在嵌套循环中，只能作用所在循环上，无法对上层循环起作用

1
j=0
2
for i in range(1,21):
3
    import random
4
    num = random.randint(1, 10)
5
    if num>=5:
6
        j+=1
7
        print(f"员工{i}，发工资1000，账户余额还有{10000-1000*j}")
8
        if 10000-1000*j==0:
9
            print("工资发完了")
10
            break
11
    else:
12
        print(f"员工{i}，绩效{num}低于5不发工资")

1
员工1，发工资1000，账户余额还有9000
2
员工2，发工资1000，账户余额还有8000
3
员工3，发工资1000，账户余额还有7000
4
员工4，发工资1000，账户余额还有6000
5
员工5，绩效1低于5不发工资
6
员工6，发工资1000，账户余额还有5000
7
员工7，发工资1000，账户余额还有4000
8
员工8，发工资1000，账户余额还有3000
9
员工9，发工资1000，账户余额还有2000
10
员工10，绩效4低于5不发工资
11
员工11，绩效1低于5不发工资
12
员工12，绩效3低于5不发工资
13
员工13，发工资1000，账户余额还有1000
14
员工14，绩效2低于5不发工资
15
员工15，发工资1000，账户余额还有0
16
工资发完了

函数的初体验#

函数是:组织好的，可重复使用的，用来实现特定功能的代码块 使用函数的好处：

• 将功能封装到代码内，可供随时随地的重复利用它
• 提高代码复用率，减少重复代码，开发效力提高

函数的定义#

函数的定义：

1
def 函数名(传入参数)：
2
    函数体(要做的事)
3
    return 返回值

函数使用步骤：

• 先定义函数
• 后调用函数

注意事项：

• 参数不需要，可以省略
• 返回值不需要，可以省略

实例：

1
def nihao():
2
    print("hello world")
3
nihao()

1
hello world

函数的传入参数#

函数传入参数的作用是：在函数运行时，接受外部传入的数据 使用方法：

1
def add(a,b):
2
    result = a+b
3
    print(f"{a} + {b} = {result}")

注意事项：

• 函数定义的参数叫做形式参数
• 函数调用的参数叫做实际参数
• 函数的参数数量不限，但是要用逗号隔开
• 传入参数时候，要和形式参数一一对应，且用逗号隔开

案例：

1
def care(a):
2
    if a>37.5:
3
        print(f"高烧{a}")
4
    else:
5
        print(f"正常{a}")
6
care(float(input("输入你的温度")))

1
输入你的温度36.4
2
正常36.4

函数的返回值#

函数返回值：函数执行完成后，返回给调用者的结果 返回值的应用语法：使用关键字return来返回结果 注意：函数体遇到return就结束，所以写在return后的代码都不执行

1
def 函数（参数,...）:
2
    函数体
3
    return 返回值
4
变量=函数（参数，....)

函数返回值之None类型#

None：None是类型‘NoneType’的字面量，用来表示空的，无意义的 函数如何返回None：

• 不使用return语句即返回None

  1
  def add(a,b):
  2
      result = a+b
  3
  print(add(1,3),type(add(1,3)))
  

  1
  None <class 'NoneType'>
  

• 主动return None

  1
  def add(a,b):
  2
      result = a+b
  3
      return None
  4
  print(add(1,3),type(add(1,3)))
  

  1
  None <class 'NoneType'>
  

使用场景：

• 函数的返回值

• if判断

  1
  def check(a):
  2
      return None
  3
  if not check(15):
  4
      print("未满18岁")
  

  1
  未满18岁
  

• 有的变量在定义时候，不想给其初始值，可以用None代替一下

函数的说明文档#

函数的说明文档的作用：对函数进行说明，便于更好理解函数的功能和作用 定义语法：

1
def add(x, y):
2
    """
3

4
    :param x: 参数x的说明
5
    :param y: 参数y的说明
6
    :return: return返回值的说明
7
    """
8
    result = x + y# 函数体
9
    return  result#返回值

函数的嵌套调用#

嵌套调用是在一个函数中，调用另外一个函数

执行流程：函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容

变量正函数中的作用域#

1. 什么是局部变量：

作用范围在函数内部，在函数外部无法使用

1
def nihao():
2
    a=10
3
print(a)
4
nihao()

1
File "D:\PythonProject\test.py", line 3, in <module>
2
    print(a)
3
          ^
4
NameError: name 'a' is not defined

2. 什么是全局变量：

在函数内部和外部均可使用

1
a=0
2
def nihao():
3
    a=10
4
print(a)
5
nihao()

1
0(此时局部变量不会影响全局变量)

3. 如何将函数内定义的变量声明为全局变量：

使用 global 关键字，global 变量

1
a=0
2
def nihao():
3
    global a
4
    a=10
5
nihao()
6
print(a)

1
10

注意：

1
a=0
2
def nihao():
3
    global a
4
    a=10
5
print(a)

1
0

结果是0为什么呢？

函数 nihao() 虽然定义了，但从未被调用。

因此，尽管函数内部有 global a 和 a = 10，但由于函数没有执行，全局变量 a 的值仍然是初始的 0。

所以 print(a) 输出的是 0。