六.Python3流程控制&&pass&&迭代器与生成器&&函数

一.流程控制

1.分类

选择结构:通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。
	if选择结构
	match...case
循环结构
	for循环
	while循环

(一)if选择结构

2.选择结构–if-else选择结构

2.1流程图

2.2 if-else执行过程

2.3 语法

if 条件:
	代码块
else:
  代码块

2.4案例

# 如果成年门票为50否则免费
age = int(input("请输入年龄"))
if age >= 18:
    print("请支付50元")
else:
    print("免费")

3.选择结构–if-elif-else选择结构

3.1流程图

3.2 语法

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
如果 “condition_1” 为False，将判断 “condition_2”
如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
如果 “condition_2” 为False，将执行"statement_block_3"块语句
Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意:

 - 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
 - 用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
 - 在 Python 中没有 switch...case 语句，但在 Python3.10 版本添加了 match...case，功能也类似

4.选择结构–if嵌套

4.1 流程图

4.2 语法

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句
	    

4.3 案例

run_time = float(input("请输入百米时间: "))
if run_time < 10:
    sex = input("请输入性别: ")
    if sex == "男":
        print("进入男子决胜组")
    else:
        print("进入女子决胜组")
else:
    print("很遗憾,没有进入决胜局")

5.选择结构–match-case

5.1 流程图

5.2 语法

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

说明

• Python 在 3.10 之前没有提供类似 switch case 一样的分支语句，虽然也能用 if elif else 或者字典来实现同样的逻辑。到 3.10 版本终于提供了 match case 结构化模式匹配，该语法比 switch case 更加灵活和强大。
• match 语句接受一个表达式并将其值与以一个或多个 case 语句块形式给出的一系列模式进行比较。和其他语言 switch case 语句很不同的一点是，match case 不用 break 进行退出，每个 case 是独立的逻辑。
• 其他 case 条件都不满足时，可以用 _ （下划线）通配符进行捕获（同其它语言 default 分支）
• 可使用 | （或）组合多个 case 条件，满足其中一项时就匹配（同其它语言多个 case 只有一个break 的情况）。

5.3 匹配字面值

def func(str):
    match str:
        case 'cpp':
            print('cpp')
        case 'java':
            print('java')
        case 'js' | 'python': #case不用break跳出，多个条件时用或连接
            print('js or python')
        case _: #通配符，类似c语系switch语句的default分支，其他case都不满足时进入
            print('other')
 
func('python') #js or python
func('cpp') #cpp
func('sql') #other

5.4带有字面值和变量的模式

# tuple变量
point = (1, 2)
match point:
    case (0, 0):
        print('1:0,0')
    case (x, 0):
        print(f'2:{x},0')
    case (0, y):
        print(f'3:0,{y}')
    case (x, y):
        print(f'4:{x},{y}')  # 4:1,2

(二)循环结构

1.for循环

1.1 流程图

1.2语法

for <variable> in <sequence>:
   <statements>
else:
   <statements>

1.3案例1-for循环

# 遍历range
for item in range(1, 11):
    if item == 10:
        print(item)
    else:
        print(item, end=",")
print()
# 遍历字符串
str1 = "sdfsdfsf"
for item in str1:
    print(item)
else:
    print("字符串遍历结束")

# 遍历列表
list1 = ["张三", "李四", "王五"]
for item in list1:
    print(item)
else:
    print("列表遍历结束")

# 遍历元组
tuple1 = (1, 2, 3, 4, 5, 6)
for item in tuple1:
    print(item)
else:
    print("元组遍历结束")

# 遍历set集合
set1 = {"人民的名义", "长相思", "好先生", "下半生"}
for item in set1:
    print(item)
else:
    print("集合遍历结束")

# 遍历字典
dict1 = {1: "檀健次", 2: "杨洋", 3: "肖战", 4: "魏大勋"}
for item in dict1.keys():
    print(item)
for item in dict1.values():
    print(item)
for item in dict1.items():
    print(item)

1.4 案例:for循环&&break&&continue

	break:结束整个for循环
	continue:结束本次循环,执行下一次循环

break流程图

continue流程图

# continue
for item in range(11):
    if item % 3 == 0:
        continue
    else:
        print(item, end=" ")  # 1 2 4 5 7 8 10
print()
# break
for item in range(11):
    if item == 3:
        break
    else:
        print(item, end=" ")  # 0 1 2

2.while循环

2.1 流程图

2.2语法

while 判断条件(condition)：
    执行语句(statements)……

2.3 案例

# while 循环
n = 1
while n <= 5:
    print("练习的第%d遍!" % n)
    n += 1

2.4while-else

# while-else 循环
n = 1
while n <= 5:
    print("练习的第%d遍!" % n)
    n += 1
else:
    print("练习结束!")

3.while循环—简单语句组

如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中

# while 简单语句组
n = 1
while n == 1: print(n)

二.pass语句

pass的中文含义是通过的意思,在Python3中是空语句,为了保证程序结构的完整性。
pass放在代码中就是啥都不做,就是一个站位语句

三.函数

1.为什么要使用函数

	在Python中函数分为两大类:
		内置函数(系统函数)
		自定义函数:我们自己定义的
	使用函数具有一种封装的思想,把重复的代码写一次放在一个函数中,可以解决代码冗余的问题,并且更好的维护代码

2.函数的定义

	def 函数名(参数列表):
		代码块
		return 返回值	

3.函数的分类

	分为四类:
		无参无返回值
		无参有返回值
		有参无返回值
		有参有返回值

4.调用函数

	无参无返回值 : 函数名()
	无参有返回值: res=函数名()
	有参无返回值: 函数名(实参)
	有参有返回值: res=函数(实参)

5.四类函数的简单案例

	# 定义四种函数
# 1.无参数无返回值
def hello():
    print("大家好,我是无参数无返回值的函数")


# 2.无参有返回值
def hi():
    return "胖虎和提莫打了招呼!"


# 3.有参无返回值
def add(a, b):
    print("%d+%d=%d" % (a, b, a + b))


# 4.有参有返回值
def sum(a, b):
    return "%d+%d=%d" % (a, b, a + b)


# 调用了无参数无返回值
hello()
# 调用了无参有返回值
res = hi()
print(res)
# 有参无返回值
add(1, 2)
# 有参有返回值
result = sum(1, 2)
print(result)

6.参数的深入讲解

6.1 函数参数的分类
 - 位置参数
 - 关键字参数
 - 缺省参数
 - 不定长参数/可变参数
 - 函数作为参数进行传递

6.2 位置参数
	位置参数调用函数时根据函数定义的参数位置来传递参数，传递的参数和定义的参数的顺序及个数必须一致
    形参的顺序就是实参的顺序要一一对应	 

# 1.位置参数  形参的顺序就是实参的顺序要一一对应
def show_stu_info(stu_name, stu_age, stu_major):
    """
        该函数的形参是位置参数,定义参数的顺序和实参的顺序要一一对应
    :param stu_name:
    :param stu_age:
    :param stu_major:
    :return:
    """
    print(f"大家好,我是{stu_name},今年{stu_age}岁,专业为{stu_major}!")


show_stu_info("美年达", 20, "英语")

6.3 关键字参数
	调用函数的时候,实参的语法为:键=值的方式
	形参名字是键
	实参是值
	传实参的时候可以不用按照顺序

# 1.关键字参数  传参的形式为键=值
def show_stu_info1(stu_name, stu_age, stu_major):
    """
        该函数的形参是未知参数,定义参数的顺序和实参的顺序随意 语法: 形参=值
    :param stu_name:
    :param stu_age:
    :param stu_major:
    :return:
    """
    print(f"大家好,我是{stu_name},今年{stu_age}岁,专业为{stu_major}!")


show_stu_info1(stu_age=30, stu_major="金融", stu_name="王亮")

6.4 既有位置参数也有关键字参数
	传实参的时候,位置参数在前,关键字参数在后,位置参数之间没有顺序

# 3.既有位置参数又有关键字参数
def flower_info(flower_name, flower_area, flower_price):
    print(f"产于{flower_area}的{flower_name},售价为{flower_price}¥!")


flower_info("玫瑰", flower_area="云南", flower_price=380)
flower_info("丁香花", flower_price=180, flower_area="湖北")

6.5 缺省参数
	缺省参数也叫做默认参数,该参数可传实参,可以不传实参
	如果传实参就使用默认值
	位置参数在前,缺省参数在后

# 缺省参数
def emp_info(emp_name, emp_position, emp_company="XXXX公司"):
    print(f"员工{emp_name},从事{emp_position}岗,入职{emp_company}")


emp_info("阿美", "后期维护", emp_company="画XXX饼公司")
emp_info("阿绿", "售前客服")

6.6不定长参数/可变参数
   愿意传就传,不传就不传
	位置传递:*args  所有的参数会被args统一管理,其实是元组类型
	关键字传递:**kwargs	 所有的参数贝贝kwargs统一管理,其实是字典类型

# 位置传递
def he(*args):
    print(args)
    sum1 = 0
    for item in args:
        sum1 += item
    print(sum1)


def he1(*args):
    print(args)


he(1, 2, 3, 4, 5)  # 15
he1("张三", "李四", "王五")  # ('张三', '李四', '王五')

# 关键字传递
def order_info(**kwargs):
    print(kwargs)
    for item in kwargs.keys():
        print(item, "\t", kwargs.get(item))


order_info(no=1101, name="香蕉", count=12, price=50)

6.7 函数作为参数传递
	传递的参数是函数名,其实传递的是计算逻辑

# 函数作为参数
def a(fun):
    print(fun(1, 2))


def b(num1, num2):
    return num1 + num2


a(b)

函数之间的互相调用
# 函数作为参数
def add_1(a, b):
    print(f"{a}+{b}={a + b}")


def subduction_1(a, b):
    print(f"{a}-{b}={a - b}")


def multiplication_1(a, b):
    print(f"{a}*{b}={a * b}")


def division_1(a, b):
    print(f"{a}/{b}={a / b}")


def compute(a, b):
    while True:
        type = input("请输入运算符号")
        match type:
            case "+":
                add_1(a, b)

            case "-":
                subduction_1(a, b)
            case "*":
                multiplication_1(a, b)
            case "/":
                subduction_1(a, b)
            case _:
                print("运算符号输入有误,请重新输入")
                continue
        break
    else:
        print("谢谢使用!")


compute(10, 2)

7.返回值的深入讲解

 7.1 函数返回值分类
 	没有返回值
 	一个返回值
 	多个返回值

7.2 没有返回值
 一个函数没有些return不是没哟返回值,而是返回值为None

# 无返回值
def user_info():
    print("用户信息")


user_return = user_info()
print(type(user_return))  # <class 'NoneType'> None是一种数据类型,代表无具体值
print(user_return)  # None

7.3 一个返回值

用一个变量接收即可

# 一个返回值
def dept_info():
    return "运维岗"


dept_return = dept_info()
print(dept_return)

7.4 多个返回值

return后台面可以返回多个不同数据类型的值,用逗号分隔
用多个变量接收函数的返回值,用逗号分隔

# 多个返回值
def animal_info():
    return "又", "鸟", True, 11


a, b, c, d = animal_info()
print(a, b, c, d)  # 又 鸟 True 11

8.函数的说明文档

在函数的内容使用三引号对函数进行说明
功能
参数
返回值

# 函数说明文档的使用
def waimai_info(name, produce):
    """
    输出外卖信息的一个函数
    :param name: 平台名称
    :param produce:  平台介绍
    :return: 平台信息
    """
    print(name, produce)

9.变量在函数中的作用域

9.1 分类
	局部变量/内部变量
	全局变量

9.2 局部变量
	- 由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。
    - 函数内部定义的变量为局部变量,在函数外无法访问

# 局部变量
def show():
    show_info = "hello" #局部变量
    print(show_info)


print(show_info)  #无访问权限 NameError: name 'show_info' is not defined. Did you mean: 'show_stu_info'?

9.3 全局变量
	- 全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用
	- 在函数内外都可以被访问到的变量

cat = "提莫"


def cat_info():
    print(cat)


cat_info()  # 提莫
print(cat)  # 提莫

9.4 global关键字
	- global中文含义是全球,全部,全局
	- global是Python中的全局变量关键字。
	- global关键字的作用是可以使得一个局部变量为全局变量
	- Python中定义函数时，若想在函数内部对函数外的变量进行操作，就需要在函数内部将其声明其为global 变量。添加了global关键字后，则可以在函数内部对函数外的对象进行操作了，也可以改变它的值。

没有添加global

#没有添加global
x = 4
def my():
    x = 8
    print("x = ", x)

my()
print("x = ", x)

# 结果是：# 内部的没有影响外部的的局部变量
x = 8
x = 4

添加global

# 添加global
# 在my函数中，在 x 前面加 global，my函数将 x 赋为8，此时全局变量中的 x 值改变。需要注意的是 global 需要在函数内部声明，若在函数外声明，则函数依然无法操作 x 。
x = 4


def my():
    global x
    x = 8
    print("x = ", x)


print("x = ", x)
my()
print("x = ", x)

# 结果是：
x = 4
x = 8
x = 8

global语句被用来声明 x 是全局的变量。
可以使用同一个 global 语句指定多个全局变量。
全局无法使用局部变量，只有对应的局部作用域可用

# global语句同时指定多个全局变量
# 全局无法使用局部变量
x = 4
y = 5
z = 6


def my():
    global x, y, z  # 一个global关键字定义多个全局变量
    x = 7
    y = 8
    z = 9
    k = 10
    print(f"x = {x},y = {y}, z = {z}, k = {k}")


print(f"x = {x},y = {y}, z = {z}")
my()
print(f"x = {x},y = {y}, z = {z}")
print(f"k = {k}")

# 结果是：
x = 4, y = 5, z = 6
x = 7, y = 8, z = 9, k = 10
x = 7, y = 8, z = 9
NameError: name
'k' is not defined  # 打印k时报错

10.lambda匿名函数

1.定义
	def关键字:定义带有名称的函数
	lambda关键字:定义匿名函数(没有名称)
2.区别
	语法不同
	有名称的函数可以多次使用
	没有名字的匿名函数只可以临时使用一次

3.匿名函数语法
	lambda 传入参数：函数体(函数体必须是一行代码)
		- lambda是关键字，表示定义匿名函数
		- 传入参数表示匿名函数的形式参数，如： x, y表示接收2个形式参数
		- 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码

# lambda匿名函数
def calc(add):
    result = add(1, 1)
    print(result)


calc(lambda x, y: x + y)  # 传入一个匿名函数

四.迭代器与生成器

(一).迭代器

 1.作用
 	迭代器的作用是访问集合元素的,可以遍历字符串,列表或者元组
 2.两个基本方式
 	iter() 创建迭代器对象的
 	next() 获取遍历到的每一个元素

遍历集合

	# 遍历集合
import sys

list1 = ["centos", "ubuntu", "Redhat"]
# 创建迭代器对象
it1 = iter(list1)
# 1.通过for循环遍历迭代器
for x in it1:
    print(x)

# 2.通过next()函数获取集合数据
while True:
    try:
        print(next(it1))
    except StopIteration:
        sys.exit()

遍历字符串

# 遍历字符串
str1 = "dfsdfsdfsdfs"
it2 = iter(str1)
while True:
    try:
        print(next(it2))
    except StopIteration:
        sys.exit()

(二).生成器

1.定义
	在Python中使用了yield关键字的函数被称为生成器
	yield是一个关键字,用于定义生成器函数,生成器函数是一种特殊函数,可以在迭代过程中逐步产生值,不是一次性返回所有的结果
2.普通函数和生成器函数的区别
	生成器是一个返回迭代器的函数,只能用于迭代曹操作,换句话说生成器就是一个迭代器
3.原理
	在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回.然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果

说明:调用一个生成器函数，返回的是一个迭代器对象

# 生成器
def show_stu_count(n):
    while n > 0:
        yield n
        n -= 1


it1 = show_stu_count(5)
while True:
    try:
        print(next(it1))
    except StopIteration:
        break
for val in it1:
    print(val)