提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：
本文综合我现阶段学习Python的一些小感受，综合写了这一篇学习Python小总结，由于内容有点小多，分三篇来撰写~~

---

提示：以下是本篇文章正文内容，下面案例可供参考

1、Python中的语句

1.1 顺序语句

• 默认情况下python 中执行代码的顺序都是从上倒下的顺序依次执行

print('1')
print('2')
print('3')

运行结果：

执行结果一定为 “123”, 而不会出现 “321” 或者 “132” 等. 这种按照顺序执行的代码, 我们称为 顺序语句.

• 我们要清楚的是代码的运行顺序是很关键的，编程是一件明确无歧义的事情，安排好任务执行的顺序，计算机才能够正确的进行执行。
• 就好像人生的顺序, 是上学, 工作, 结婚, 生子. 一旦这里的顺序乱了, 就很麻烦.

1.2 条件语句

• 条件语句是构成计算机中基础的逻辑判定，他能够表达“如果…否则…”故而此语句又叫做分支语句，表示接下来的逻辑的可能走向。
• 我们生活中有很多现实的例子：

1. 那么金兵不会死在郭, 杨两家手上

2. 郭, 杨两家就不会流亡北方

3. 郭夫人就不会去到大漠, 完颜洪烈就不会遇到包惜弱

4. 郭靖就不会和江南七怪救了铁木真

5. 蒙古就不会统一

6. 蒙古铁骑就不会西征

7. 欧洲就不会出现火药, 也就不会出现文艺复兴, 大航海.

8. 大炮就不会从欧洲传到日本, 日本得不到统一

9. 完颜洪烈就不会全力战, 金国内乱

10. 宋朝不会灭亡, 并诞生出资本主义. 中国成为最发达的国家.

• 在python中条件语句主要有三种格式：
  （1）.if语句：

if expression:
 do_something1
 do_something2
next_something

在这里如果 expression 值为 True, 则执行 do_something1, do_something2, next_something；
如果 expression 值为 False, 则只执行 next_something, 不执行 do_something1, do_something2。
相应的条件都有运行的语句。如果条件下没有语句的话记得用空语句pass来替代。

if expression:
 pass
next_something

(2).if-else语句

if expression:
 do_something1
else:
 do_something2

在这里如果 expression 值为 True, 则执行 do_something1

如果 expression 值为 False, 则执行 do_something2

相应的条件都有运行的语句。如果条件下没有语句的话记得用空语句pass来替代。

if expression:
 pass
else:
 do_something2
			

(3).if-elif-else

if expression1:
 do_something1

elif expression2:
 do_something2

else:
 do_something3

在这里如果 expression1 值为 True, 则执行 do_something1
如果 expression1 值为 False, 并且 expression2 为 True 则执行 do_something2

如果 expression1 值为 False, 并且 expression2 为 False 则执行 do_something3

相应的条件都有运行的语句。如果条件下没有语句的话记得用空语句pass来替代。

if expression1:
 pass

elif expression2:
 do_something2

else:
 do_something3

• 综上的几种格式，python中条件语句的写法与很多编程语言的不太一样：
  （1）.if后面的条件表达式没有用（）表示，而是实用:（冒号）作为结果
  （2）.if/else条件后执行的语句块，要使用缩进（通常是4个空格或者一个tab），而不是用{}（大括号）来表示
  （3）.对于多条件分支，不是写作 else if ,而是elif（合体状态）

1.3 循环语句

• 在编程的过程中有些操作是需要反复执行的，这种就需要使用循环，这里介绍在python中的两种循环形式：for循环和while循环。

1.3.1 while循环

• 语法格式;

while 条件 :
	循环体

如果条件为真，则循环执行循环体代码
如果条件为假，则结束循环。在这里格式里面冒号后面有缩进（四个空格或者一个tab）

• while循环的小练习：
  (1).计算1-100的和

sum = 0 
num = 1 
while num <= 100:    
	sum += num
    num += 1 
print(sum)

(2).计算5的阶乘

result = 1 
n = 1 
while n <= 5:    
	result *= n
    n += 1 
print(result)

(3)while循环的嵌套，计算1！+2！+3！+4！+5！

num = 1

sum = 0

while num <= 5:
    factorResult = 1

    i = 1

    while i <= num:
        factorResult *= i

        i += 1

    sum += factorResult

    num += 1

print(sum)

1.3.2 for循环

• 语法格式：

for 循环变量 in 可迭代对象:
    循环体

在这里要注意python 的 for 和其他语言不同, 没有 “初始化语句”, “循环条件判定语句”, “循环变量更新语句”, 而是更加简单；所谓的 “可迭代对象”, 指的是 “内部包含多个元素, 能一个一个把元素取出来的特殊变量”（是一个集合类的结构，如后面介绍的列表，元组等或者一个区间）

• for循环的小练习：
  （1）.打印1-10的内容：

for i in range(1,11):
	print(i)

注意这里可迭代的对象是由range函数生成的，生成的范围是‘[1,11),左闭右开区间，即为[1,10]
（2）.打印 2,4,6,8,10

for i in range(2, 12, 2):
    print(i)

![在这里插入
对于range函数其实是有三个参数的，最后一个参数是步长，前两个参数分别是生成数据的左右范围，如果最后一个步长没有输入，则默认为1，在本题中显然我们要将步长设置为2
（3）.打印10到1

for i in range(10, 0, -1):
    print(i)

显然我们range的步长参数也可以设置为负数

1.3.3 break与continue语句

• continue 表示结束这次循环，进入下一次循环
  我们举一个小案例，我们一共吃5个包子，但是吃到第三个包子的时候发现有个小虫子，我们肯定要跳过这个包子，继续吃下一个包子，用代码描述出来

for i in range(1, 6):
    if i == 3:
        continue

    print(f"吃完第 {i} 个包子")

在这里我们用了continue语句，直接没有运行第三次循环，跳过后直接运行下面的循环

• break语句代表结束整个循环
  还是刚才吃包子的例子，由于上一顿饭吃的有点多，本次饭原本准备了5个包子，但是吃完第三个包子发现吃饱了，不能继续吃了。用代表表示出吃的包子情况

for i in range(1, 6):
    if i == 4:
        break

    print(f"吃完第 {i} 个包子")

另一个小练习：输入若干个数字, 求平均值. 使用 “分号” 作为结尾.

sum = 0

count = 0

while True:
    num = input("请输入数字:")
    if num == ';':
        break

    num = float(num)
    sum += num

    count += 1

print(sum / count)

1.4 综合三大语句制作小游戏–人生重开模拟器（简易版）

实现 “人生重开模拟器”

这是一款之前很火的文字类小游戏. 玩家输入角色的初始属性之后, 就可以开启不同的人生经历.

大家可以在网上搜索 “人生重开模拟器”, 就可以玩到这个游戏的各种版本.

完整的程序代码较多, 此处我们只实现其中的一部分逻辑. （后面大家可以自行发挥想象设计属于自己的人生重开模拟器）

1.4.1 思路分析

1.4.1.1 设置初始属性

• 在游戏中我们设定四个属性.

（1）.颜值 (face)

（2）.体质 (strong)

（3）.智力 (iq)

（4）.家境 (home)

我们约定每个属性的范围为 [1, 10], 并且总和不能超过 20.

如果玩家输入的初始属性不合理, 就提示输入有误, 重新输入.
这部分代码如下：

#欢迎界面
print('+-------------------------+')
print('|        花有重开日         |')
print('|        人无再少年         |')
print('+-------------------------+')
print("欢迎来到人生重开模拟器小游戏设计端~~")

#设置初定属性
while True:
    print("请设定初始属性（可用总点数 20）")
    face=int(input("请输入颜值属性（1~10）："))
    strong=int(input("请输入体制属性（1~10）："))
    iq = int(input("请输入智力属性（1~10）："))
    home = int(input("请输入家境属性（1~10）："))
    if face>10 or face<1:
        print("颜值属性输入错误~")
        continue
    if strong > 10 or strong < 1:
        print("体制属性输入错误~")
        continue
    if iq > 10 or iq < 1:
        print("智力属性输入错误~")
        continue
    if home > 10 or home < 1:
        print("家境属性输入错误~")
        continue
    if face+strong+iq+home>20:
        print("总点数超过了20！")
        continue
    print("初始属性设定完成~~")
    break

1.4.1.2 设置性别

• 通过 random.randint(1, 6) 生成一个 [1, 6] 的随机整数, 类似于掷色子.
  有两种情况便于我们定义男女孩子：
  如果是单数, 则性别设为男孩
  如果是双数, 则性别设为女孩.

男孩和女孩会遇到不同的事件.

• 这部分代码实现：

inport random
point = random.randint(1, 6) # 掷色子

if point % 2 == 1:
    gender = 'boy'

    print("你是个男孩")

else:
    gender = 'girl'

    print("你是个女孩")

1.4.1.3 设置出生点

• 首先按照家境(home), 分成四个档位.
  10 是第一档. 加成最高

[7, 9] 是第二档. 也有一些加成

[4, 6] 是第三档. 加成较少

[1, 3] 是第四档. 会扣掉属性.

再扔一次色子, 生成 [1, 3] 的随机数, 用来表示每一种细分情况.

• 这部分代码实现

point = random.randint(1, 3) # 掷色子

if home == 10:
    print('你出生在帝都, 你的父母是高官政要')
    home += 1

    iq += 1

    face += 1

elif 7 <= home <= 9:
    if point == 1:
        print('你出生在大城市, 你的父母是公务员')
        face += 2

    elif point == 2:
        print('你出生在大城市, 你的父母是大企业高管')
        home += 2

    else:
        print('你出生在大城市, 你的父母是大学教授')
        iq += 2

elif 4 <= home <= 6:
    if point == 1:
        print('你出生在三线城市, 你的父母是教师')
        iq += 1

    elif point == 2:
        print('你出生在镇上, 你的父母是医生')
        strong += 1

    else:
        print("你出生在镇上, 你的父母是个体户")
        home += 1

else:
    if 1 <= point <= 2:
        print('你出生在村里, 你的父母是辛苦劳作的农民')
        strong += 1

        face -= 2

    elif 3 <= point <= 4:
        print('你出生在穷乡僻壤, 你的父母是无业游民')
        home -= 1

    else:
        print('你出生在镇上, 你父母感情不和')
        strong -= 1

1.4.1.4 针对每一岁，生成人生经历

• 按照年龄, 把人生经历分成四个阶段:

幼年阶段 [1, 10]

青年阶段 [11, 20]

壮年阶段 [20, 50]

老年阶段 50 岁以上.

每个阶段都会有不同的精力和事件发生.

幼年阶段可塑性强, 体质, 颜值, 智力都会有较快变化
青年阶段主要是求学, 同时父母一辈会有明显变化, 智力和家境会有明显变化.

壮年阶段相对平稳, 属性变化不大, 主要是一些随机事件影响到属性.

老年阶段体质, 颜值, 智力都会显著退化, 并且随着年龄的上升, 疾病/死亡的风险逐渐升高.
由于每个年龄都实现的话代码过多，在这里以幼年为例来实现，后面几个年龄段放给大家想象，这里我开个头。

• 此处我们以幼年为例, 简单实现一下这里的处理逻辑.

使用 for 循环, 按照年龄循环起来.

针对每一年, 先掷一次 [1, 3] 的色子, 根据不同的随机数值, 来触发不同的事件.

根据性别, 年龄, 各种属性, 来触发不同的事件. 这里都使用 if - else 的方式来组织.

不同的事件可能会对属性有正面/负面的影响.

在每一年的最后, 打印这一年遇到的事情.

如果夭折, 则直接 sys.exit(0) 退出程序.

使用 time.sleep(1) 使程序暂停执行 1s, 方便观察程序结果.

• 部分代码实现：

import sys
import time
for age in range(1, 11):
    info = f'你今年 {age} 岁, '

    point = random.randint(1, 3)
    # 性别触发事件

    if gender == 'girl' and home <= 3 and point == 1:
        info += '你家里人重男轻女思想非常严重, 你被遗弃了!'

        print(info)
        print("游戏结束!")
        sys.exit(0)
    # 体质触发的事件

    elif strong < 6 and point != 3:
        info += '你生了一场病, '

        if home >= 5:
            info += '在父母的精心照料下恢复了健康'

            strong += 1

            home -= 1

        else:
            info += '你的父母没精力管你, 你的身体状况更糟糕了'

            strong -= 1

    # 颜值触发的事件

    elif face < 4 and age >= 7:
        info += '你因为长的太丑, 别的小朋友不喜欢你, '

        if iq > 5:
            info += '你决定用学习填充自己'

            iq += 1

        else:
            if gender == 'boy':
                info += '你和别的小朋友经常打架'

                iq -= 1

                strong += 1

            else:
                info += '你经常被别的小朋友欺负'

                strong -= 1

    # 智商触发的事件

    elif iq < 5:
        info += '你看起来傻傻的, '

        if home >= 8 and age >= 6: 
            info += '你的父母给你送到更好的学校学习'

        elif 4 <= home <= 7:
            if gender == 'boy':
                info += '你的父母鼓励你多运动, 加强身体素质'

                strong += 1

            else:
                info += '你的父母鼓励你多打扮自己'

                face += 1

        else:
            info += '你的父母为此经常吵架'

            if point == 1:
                strong -= 1

            elif point == 2:
                iq -= 1

    # 健康成长

    else:
        info += '你健康成长, '

        if point == 1:
        	info += '看起来更聪明了'

            iq += 1

        elif point == 2:
            info += '看起来更好看了'

            face += 1

        else:
            info += '看起来更结实了'

            strong += 1

    print('-------------------------------------------')
    print(info)
    print(f'strong={strong}, face={face}, iq={iq}, home={home}')
    time.sleep(1)

1.4.2总体代码实现

import random
import sys
import time
#欢迎界面
print('+-------------------------+')
print('|        花有重开日         |')
print('|        人无再少年         |')
print('+-------------------------+')
print("欢迎来到人生重开模拟器小游戏设计端~~")

#设置初定属性
while True:
    print("请设定初始属性（可用总点数 20）")
    face=int(input("请输入颜值属性（1~10）："))
    strong=int(input("请输入体制属性（1~10）："))
    iq = int(input("请输入智力属性（1~10）："))
    home = int(input("请输入家境属性（1~10）："))
    if face>10 or face<1:
        print("颜值属性输入错误~")
        continue
    if strong > 10 or strong < 1:
        print("体制属性输入错误~")
        continue
    if iq > 10 or iq < 1:
        print("智力属性输入错误~")
        continue
    if home > 10 or home < 1:
        print("家境属性输入错误~")
        continue
    if face+strong+iq+home>20:
        print("总点数超过了20！")
        continue
    print("初始属性设定完成~~")
    break
#设置性别：我们通过随机数来随机生成
point = random.randint(1,6)
if point %2==1:
    gender = 'boy'
    print("你是一个男孩")
else :
    gender='girl'
    print("你是一个女孩")
# 设置出生点
point = random.randint(1, 3) # 掷色子

if home == 10:
    print('你出生在帝都, 你的父母是高官政要')
    home += 1
    iq += 1
    face += 1

elif 7 <= home <= 9:
    if point == 1:
        print('你出生在大城市, 你的父母是公务员')
        face += 2

    elif point == 2:
        print('你出生在大城市, 你的父母是大企业高管')
        home += 2

    else:
        print('你出生在大城市，你的父母是大学教授')
        iq += 2
elif 4 <= home <= 6:
    if point == 1:
        print('你出生在三线城市, 你的父母是教师')
        iq += 1

    elif point == 2:
        print('你出生在镇上, 你的父母是医生')
        strong += 1

    else:
        print("你出生在镇上, 你的父母是个体户")
        home += 1

else:
    if point == 1:
        print('你出生在村里, 你的父母是辛苦劳作的农民')
        strong += 1

        face -= 2

    elif point == 2:
        print('你出生在穷乡僻壤, 你的父母是无业游民')
        home -= 1

    else:
        print('你出生在镇上, 你父母感情不和')
        strong -= 1

#针对每一岁，生成人生经历
#幼年阶段：[1~10]:每年只触发一个事件
for age in range(1,11):
    info = f"你今年{age}岁，"
    point = random.randint(1,3)
    #性别触发事件
    if gender=='girl'and home <=3 and point == 1:
        info+='你的家里人重男思想严重，你被抛弃了！'
        print(info)
        print("游戏结束")
        sys.exit(0)
    #体制触发事件：
    elif strong <6 and point !=3:
        info+='你生了一场病，'
        if home >=5:
            info+='在父母的精心照料下恢复了健康'
            strong+=1
            home-=1
        else:
            info+='你的父母没有精力管你，你的身体状况更糟糕了'
            strong-=1
    #颜值触发事件：
    elif face<4 and age>7:
        info+='你因为长得太丑了，别的小朋友不喜欢你，'
        if iq>5:
            info+='你决定用学习来填充自己'
            iq+=1
        else:
            if gender=='boy':
                info+='你和别的小朋友经常打架'
                iq-=1
                strong+=1
            else:
                info+='你经常被别的小朋友欺负'
                strong-=1
    #智商触发事件：
    elif iq<5:
        info+='你看起来傻傻的，'
        if home>=8 and age>=6:
            info+='你的父母会把你送到更好的学校学习'
            iq+=1
        elif 4<=home<=7:
            if gender=='boy':
                info+='你的父母会鼓励你多运动，加强身体素质'
                strong+=1
            else:
                info+='你的父母会鼓励你多打扮自己'
                face+=1
        else:
            info+='你的父母为此吵架'
            if point ==1:
                strong-=1
            elif point==2:
                iq-=1
            else:
                pass
    #健康成长：
    else:
        info+='你健康成长，'
        if point==1:
            info+='看起来更加聪明了'
            iq+=1
        elif point==2:
            info+='看起来更好看了'
            face+=1
        else:
            info+='看起来更强壮了'
            strong+=1
    print("----------------------")
    #打印这一年发生的变化
    print(info)
    print(f"strong={strong},face={face},iq={iq},home={home}")
    #让程序暂停一秒
    time.sleep(1)

运行结果如下：

2、函数

2.1 函数是什么？

• 编程中的函数和数学中类似：
  数学上的函数, 比如 y = sin x , x 取不同的值, y 就会得到不同的结果.而编程中的函数是一段被重复使用的代码片段
• 为了进一步理解函数的便利，我们看一下下面的代码：

#1. 求 1 - 100 的和
sum = 0
for i in range(1, 101):
    sum += i
print(sum)
 # 2. 求 300 - 400 的和
sum = 0
for i in range(300, 401):
    sum += i
print(sum)
 # 3. 求 1 - 1000 的和
sum = 0
for i in range(1, 1001):
    sum += i
print(sum)

可以发现, 这几组代码基本是相似的, 只有一点点差异. 可以把重复代码提取出来, 做成一个函数
实际开发中, 复制粘贴是一种不太好的策略. 实际开发的重复代码可能存在几十份甚至上百份.
一旦这个重复的代码需要被修改，那就得修改几十次，非常不利于维护
而我们此时便可以定义一个求和函数来解决这个问题

# 定义函数
def calcSum(beg, end):
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    print(sum)
 # 调用函数
calcSum(1,100)
calcSum(300,400)
calcSum(1,1000)

得到了同样的效果，但是运用函数明显方便了很多

---

2.2 函数的语法格式

• 创建函数/定义函数

def 函数名(形参列表):
	函数体
	return 返回值

这里关键字为def，而且定义函数后要注意缩进格式

• 调用/使用函数

#函数名(实参列表)           # 不考虑返回值
#返回值 = 函数名(实参列表)   # 考虑返回值

• 注意函数定义并不会执行函数体内容，必须调用后才会执行，调用几次，就会执行几次
• 函数必须先定义才能使用，要不然会报错

test3()          # 还没有执行到定义, 就先执行调用了, 此时就会报错. 
def test3():
	print('hello')

此时就会报错

2.3 函数的参数

• 在函数定义的时候, 可以在 ( ) 中指定 “形式参数” (简称 形参), 然后在调用的时候, 由调用者把 “实际参数” (简称 实参) 传递进去. 这样就可以做到一份函数, 针对不同的数据进行计算处理
• 以下面代码为例来说明形参与实参：

def calcSum(beg, end):
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    print(sum)
 # 调用函数
calcSum(1,100)
calcSum(300,400)
calcSum(1,1000)

上面的代码中, beg, end 就是函数的形参. 1, 100 / 300, 400 就是函数的实参.

在执行 sum(1, 100) 的时候, 就相当于 beg = 1, end = 100 , 然后在函数内部就可以针对 1-
100 进行运算.

在执行 sum(300, 400) 的时候, 就相当于 beg = 300, end = 400 , 然后在函数内部就可以针对
300-400 进行运算.

形象点来说的话实参和形参之间的关系, 就像签合同一样.

• 注意：
  一个函数可以有一个形参，也可以有多个形参，也可以没有形参；
  一个函数的形参有几个, 那么传递实参的时候也得传几个. 保证个数要匹配；

def test(a, b, c):
    print(a, b, c)

test(10)

以上就没处理好对应关系，才到导致的报错

这里和C++/Java不用，Python是动态类型的编程语言，函数的形参不必指定参数的类型，换句话说函数可以支持多种不同的类型的参数。

def test(a):
    print(a)

test(10)

test('hello')

test(True)

这里编译都是通过的

2.4 函数的返回值

• 函数的参数可以视为是函数的 “输入”, 则函数的返回值, 就可以视为是函数的 “输出” .
  此处的 “输入”, “输出” 是更广义的输入输出, 不是单纯指通过控制台输入输出.

这里我们可以把函数想象成一个 “工厂”. 工厂需要买入原材料, 进行加工, 并生产出产品.

更加形象的来说函数的参数就是原材料, 函数的返回值就是生产出的产品.

我们可以通过以下代码来理解返回值：

def calcSum(beg, end):
    sum = 0

    for i in range(beg, end + 1):
        sum += i

    print(sum)
    

calcSum(1, 100)

与上面代码等价的代码：

def calcSum(beg, end):
    sum = 0

    for i in range(beg, end + 1):
        sum += i

    return sum

result = calcSum(1, 100)

print(result)

这两个代码的区别就在于, 前者直接在函数内部进行了打印, 后者则使用 return 语句把结果返回给函数
调用者, 再由调用者负责打印.

而我们现实生活中一般倾向于第二种写法.

因为实际开发中我们的一个通常的编程原则, 是 “逻辑和用户交互分离”. 而第一种写法的函数中, 既包含
了计算逻辑, 又包含了和用户交互(打印到控制台上). 这种写法是不太好的, 如果后续我们需要的是
把计算结果保存到文件中, 或者通过网络发送, 或者展示到图形化界面里, 那么第一种写法的函数, 就难以胜任了.

而第二种写法则专注于做计算逻辑, 不负责和用户交互. 那么就很容易把这个逻辑搭配不同的用户
交互代码, 来实现不同的效果.

• 对于返回值应该注意以下几点：
  （1）.一个函数可以有多个return语句

# 判定是否是奇数

def isOdd(num):
    if num % 2 == 0:
        return False

    else:
        return True

  

result = isOdd(10)

print(result)

（2）.执行到return 语句，函数就会立即执行结束，回到调用位置

# 判定是否是奇数

def isOdd(num):
    if num % 2 == 0:
        return False

    return True

result = isOdd(10)

print(result)

（3）.一个函数是可以一次返回多个返回值的. 使用 , 来分割多个返回值.

def getPoint():
    x = 10

    y = 20

    return x, y
a, b = getPoint()

（4）.如果只想关注其中的部分返回值, 可以使用 _ 来忽略不想要的返回值.

def getPoint():
    x = 10

    y = 20

    return x, y
_, b = getPoint()

2.5 函数的变量和作用域

• 变量只能在所在的函数内部生效
  以下面代码为例来阐述：

def getPoint():
    x = 10

    y = 20

    return x, y
x, y = getPoint()
print(x,y)

注意：在函数 getPoint() 内部定义的 x, y 只是在函数内部生效. 一旦出了函数的范围, 这两个变量就不再生效了.

• 在不同的作用域中，允许存在不同名的变量

x = 20

def test():
    x = 10

    print(f'函数内部 x = {x}')

test()

print(f'函数外部 x = {x}')

注意：在函数内部的变量，也称为“局部变量”
不在任何函数内部的变量，也称为“全局变量”

• 如果函数内部尝试访问的变量在局部不存在，就会尝试去全局域中查找

x = 20

def test():
    print(f'x = {x}')

test()

• 如果是想在函数内部, 修改全局变量的值, 需要使用 global 关键字声明

x = 20

def test():
    global x

    x = 10

    print(f'函数内部 x = {x}')

test()

print(f'函数外部 x = {x}')

这里注意如果此处没有 global , 则函数内部的 x = 10 就会被视为是创建一个局部变量 x, 这样就和全局
变量 x 不相关了

··············

• 与函数的变量的作用域对比，if / while / for 等语句块不会影响到变量作用域，换而言之, 在 if / while / for 中定义的变量, 在语句外面也可以正常使用.

for i in range(1, 10):
    print(f'函数内部 i = {i}')

print(f'函数外部 i = {i}')

2.6 函数的链式调用与嵌套调用

2.6.1 链式调用

• 观察以下代码：

# 判定是否是奇数

def isOdd(num):
    if num % 2 == 0:
        return False

    else:
        return True

  

result = isOdd(10)

print(result)

我们其实可以简化处理成

# 判定是否是奇数

def isOdd(num):
    if num % 2 == 0:
        return False

    else:
        return True

print(isOdd(10))

效果是一致的，而下面的简化版的就是函数的链式访问形式即把一个函数的返回值, 作为另一个函数的参数, 这种操作称为 链式调用。显然这里把isOdd(10)的返回值当作另一个函数的参数，这种操作称为 链式调用

2.6.2 嵌套调用

• 函数内部还可以调用其他的函数, 这个动作称为 “嵌套调用” .

def test():
    print("执行函数内部代码")
    print("执行函数内部代码")
    print("执行函数内部代码")

test 函数内部调用了 print 函数, 这里就属于嵌套调用.

• 一个函数里面可以嵌套调用任意多个函数

def a():
    print("函数 a")

def b():
    print("函数 b")
    a()

def c():
    print("函数 c")
    b()

def d():
    print("函数 d")
    c()

d()

而我们要注意调用是从最里面的函数开始，这就意味这我们把代码稍微调整一下。打印结果则可能发生很大的变化

def a():
    print("函数 a")

def b():
    a()
    print("函数 b")

def c():
    b()
    print("函数 c")

def d():
    c()
    print("函数 d")

d()

2.7函数递归

• 递归是 嵌套调用 中的一种特殊情况, 即一个函数嵌套调用自己.
• 以下面代码为例-计算5的阶乘

def factor(n):
    if n == 1:
        return 1

    return n * factor(n - 1)

result = factor(5)

print(result)

上述代码中, 就属于典型的递归操作. 在 factor 函数内部, 又调用了 factor 自身.

• 这里要注意递归存在的两个条件：
  （1）.存在递归结束条件. 比如上述代码 if n == 1 就是结束条件. 当 n 为 1 的时候, 递归就结束了.
  （2）.每次递归的时候, 要保证函数的实参是逐渐逼近结束条件的.
  如果上述条件不能满足就会出现“无限递归”，俗称“死递归”，这是一种典型的错误

def factor(n):
    return n * factor(n - 1)

result = factor(5)

print(result)

• 递归的优点：
  递归类似于 “数学归纳法” , 明确初始条件, 和递推公式, 就可以解决一系列的问题.；
  递归代码往往代码量非常少。
• 递归的缺点：
  递归代码往往难以理解, 很容易超出掌控范围；
  递归代码容易出现栈溢出的情况；
  递归代码往往可以转换成等价的循环代码. 并且通常来说循环版本的代码执行效率要略高于递归版本，故而在实际开发中往往要慎重使用递归。

2.7 参数的默认值与关键字参数

2.7.1 参数的默认值

• Python 中的函数, 可以给形参指定默认值.
  带有默认值的参数, 可以在调用的时候不传参.
  以下面一段代码为例：

def add(x, y, debug=False):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y

print(add(10, 20))

print(add(10, 20, True))

此处 debug=False 即为参数默认值. 当我们不指定第三个参数的时候, 默认 debug 的取值即为 False.

• 注意带有参数的默认值要放到没有默认值参数的后面

def add(x, debug=False, y):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y

print(add(10, 20))

会出现典型的报错现象

2.7.2 关键字参数

• 在调用函数的时候, 需要给函数指定实参. 一般默认情况下是按照形参的顺序, 来依次传递实参的.

但是我们也可以通过 关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参. 依靠这部操作，可以是我们传参的顺序更加灵活

def test(x, y):
    print(f'x = {x}')
    print(f'y = {y}')

test(x=10, y=20)

test(y=100, x=200)

形如上述 test(x=10, y=20) 这样的操作, 即为 关键字参数.

总结

本文主要讲述了python中语句以及函数的相关概念，如有不足，请批评指正。