python基础-函数

元组: 不可修改的容器 tuple

定义:

变量= ( 元素, 元素 , 元素)

要么是循环 要么是拆包

集合: 无序不重复 set

语法: 变量= {元素,元素,元素} 变量=set()

增加: add( 元素 ) 删除 remove ( 元素 ) 查: 循环in not in判断是否在集合中

字典: dict

语法: 变量= { key : value,key:value....} 变量={} 变量=dict()

增修改: 变量[key] = 值 如果有值的情况下 覆盖 没有值得情况下 添加

删除: del 变量[key]

列表: list

语法: 变量 = [元素,元素,元素] 变量 = []

增加: append (元素); extend (序列); insert(索引,元素)

删除: del 列表[索引]; pop (索引),没有索引,默认最后一个; remove(元素),移除列表中某个数据的第一个匹配项。

修改: 列表[索引] = 修改后的值 ; reverse () 反转; sort()排序

查找: index () 指定数据所在位置的下标 ;count () 统计指定数据在当前列表中出现的次数 ;in 判断指定数据在某个列表序列，如果在返回True，否则返回False ;not in判断指定数据不在某个列表序列，如果不在返回True，否则返回False

今日课程

【扩展】推导式

推导式 comprehensions（又称解析式 ），是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列（一个有规律的列表或控制一个有规律列表）的结构体。 共有三种推导：列表推导式、集合推导式、字典推导式。

什么时候可以使用推导式:

当需要遍历一个容器, 然后遍历后需要返回一个新容器的场景 , 但是代码不可以太复杂

列表推导式

变量名 = [表达式 for 变量 in 列表]
变量名 = [表达式 for 变量 in 列表 if 条件]
变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]

集合/字典推导式

变量名 = {表达式 for 变量 in 列表}
变量名 = {表达式 for 变量 in 列表 if 条件}
变量名 = {表达式 for 变量 in 列表 for 变量 in 列表}

列表推导式

# 列表推导式:
"""
    语法结构:
        变量名称 = [表达式 for 临时变量 in 序列]
        变量名称 = [表达式 for 临时变量 in 序列 if 条件]
        变量名称 = [表达式 for 临时变量 in 序列 for 临时变量 in 序列]
"""

my_list = [i for i in range(0, 10)]

print(my_list)

列表推导式 + if条件判断

变量 = [表达式 for 临时变量 in 序列 if 条件判断]

等价于

for 临时变量 in 序列:
    if 条件判断


# 推导式方式
my_list = [i for i in range(0, 10) if i % 2 == 0]

print(my_list)

for循环嵌套列表推导式

变量 = [表达式 for 临时变量 in 序列 for 临时变量 in 序列]

等价于

for 临时变量 in range(n):
    for 临时变量 in range(n):

# 案例：创建列表 => [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

# 推导式:
my_list = [ (i, j) for i in range(1, 3) for j in range(0, 3) ]

print(my_list)

Python中函数的作用与使用步骤

在Python实际开发中，我们使用函数的目的只有一个"让我们的代码可以被重复使用"

函数的作用

1. 代码重用（代码重复使用）

2. 模块化编程（模块化编程的核心就是函数，一般是把一个系统分解为若干个功能，每个功能就是一个函数） 在编程领域，编程可以分为两大类：① 模块化编程 ② 面向对象编程

什么是函数?

函数就是一个被命名的、独立的、完成特定功能的代码段（一段连续的代码），并可能给调用它的程序一个返回值。

被命名的 ：在Python中，函数大多数是有名函数（普通函数 ）。当然Python中也存在没有名字的函数叫做匿名函数(lambda表达式)

独立的、完成特定功能的代码段：在实际项目开发中，定义函数前一定要先思考一下，这个函数是为了完成某个操作或某个功能而定义的。（函数的功能一定要专一）

返回值 ：很多函数在执行完毕后，会通过return关键字返回一个结果给调用它的位置。

函数的定义

语法:

def 函数名称([参数1, 参数2, ...]):
    函数体
    ...
    [return 返回值]


注意: 语法中的中括号表示的可选的意思

函数的调用

在Python中，函数和变量一样，都是先定义后使用

# 定义函数
def 函数名称([参数1, 参数2, ...]):
    函数体
    ...
    [return 返回值]

# 调用函数
函数名称(参数1, 参数2, ...)

# 如何定义和调用函数:
"""
    语法结构:
        def 函数名称([参数1,参数2....]):
            # 函数体: 书写该函数核心功能代码

            [return 返回值]

    如何调用函数:
        函数(参数1,参数2)

    函数特性: 不调用 不执行
"""

# 需求: 假设 售票窗口 买票的过程

ticket = 100

# 无函数方案:
# 有一个人来买票
print("执行一遍卖票的逻辑代码....")

# 有一个人来买票
print("执行一遍卖票的逻辑代码....")

# 有一个人来买票
print("执行一遍卖票的逻辑代码....")

# 思考: 是否可以将买票的逻辑放置到一个函数中, 未来来一个人, 调用一次这个函数即可

print("-----------")


def pay_ticket1():
    print("函数中: 执行卖票逻辑代码.....")


# 来一个人
pay_ticket1()

# 来一个人
pay_ticket1()

# 来一个人
pay_ticket1()

print("-----------")


# 期望在卖票的时候, 知道是把票卖给了谁: 传入一个买票人的姓名
def pay_ticket2(name):
    print(f"函数中: 正在给{name}卖票, 执行卖票逻辑代码.....")


# 调用函数
pay_ticket2('张三')
pay_ticket2('李四')
pay_ticket2('王五')

print("-----------")
# 期望: 在卖票完成后, 告知我 是否卖票成功
def pay_ticket3(name):
    print(f"函数中: 正在给{name}卖票, 执行卖票逻辑代码.....")

    return 'success',


# 调用函数
status = pay_ticket3("赵六")

if status == 'success':
    print("卖票是成功的...")
else:
    print("卖票是失败的...")

return返回值

如果一个函数如些两个return (如下所示)，程序如何执行？

当执行到return 的时候 函数就结束了

只执行了第一个return，原因是因为return可以退出当前函数，导致return下方的代码不执行。

continu 终止本次循环 执行下次循环 break 终止循环 代码继续 return 终止函数 并返回结果

如果一个函数要有多个返回值，该如何书写代码？

在Python中，理论上一个函数只能返回一个结果。但是如果我们向让一个函数可以同时返回多个结果，我们可以使用**return 元组**的形式

def return_num():
    return 1, 2


result = return_num()
print(result)
print(type(result))  # <class 'tuple'>

函数的嵌套

什么是函数的嵌套?

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数。

函数嵌套的基本语法

变量的作用域

什么是变量的作用域?

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用），主要分为两类：全局作用域与局部作用域。

其实作用域的划分比较简单，在函数内部定义 范围就称之为局部作用域，在**函数外部（全局）**定义范围就是全局作用域

# 全局作用域
def func():
    # 局部作用域

变量作用域的作用范围

全局变量：在整个程序范围内都可以直接使用

局部变量：在函数的调用过程中，开始定义，函数运行过程中生效，函数执行完毕后，销毁

global关键字的应用场景

作用: 局部作用域中对全局变量进行修改

global关键字只是针对不可变数据类型 的变量进行修改操作（数值、字符串、布尔类型、元组类型），可变类型可以不加global关键字。

结论 : 不管是可变类型 还是不可变类型 只要在函数内部想操作全局变量 全部加上global关键字

不可变类型: 数值类型 字符串 元组 布尔类型

可变类型: 集合 列表 字典

函数的参数进阶

在函数定义与调用时，我们可以根据自己的需求来实现参数的传递。在Python中，函数的参数一共有两种形式：

① 形参 ② 实参

形参 ：在函数定义时，所编写的参数就称之为形式参数

实参 ：在函数调用时，所传递的参数就称之为实际参数

函数的参数类型(调用)

位置参数

理论上，在函数定义时，我们可以为其定义多个参数。但是在函数调用时，我们也应该传递多个参数，正常情况，其要一一对应

注意事项：位置参数强调的是参数传递的位置必须一一对应，不能颠倒

def user_info(name, age, address):
    print(f'我的名字{name}，今年{age}岁了，家里住在{address}')
    
# 调用函数
user_info('Tom', 23, '美国纽约')

关键词参数（Python特有）

函数调用，通过**"键=值"**形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

"""
    形参的内容 根据实参传递而来的  跟形参的名称本质没有联系
    fun2( 形参的变量名=值,形参的变量名=值,形参的变量名=值)  # 实参
    此时调用的时候 跟参数的位置 就没有关系了
"""
def fun2(name,address,age): # 形参
    print(f"名字为{name},地址为:{address},年龄为:{age}")

fun2( address='东莞',  age=48,name='颜京')  # 实参

函数定义时缺省参数（参数默认值）

缺省参数也叫默认参数 ，用于定义函数，为参数提供默认值 ，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

我们在定义缺省参数时，一定要把其写在参数列表的最后

"""
    希望 如果别人在调用方法的时候 没有传递参数 会使用默认值
    可以在列表形参上 进行赋值 ,  赋值表示默认值 (用户没有传递的时候使用)
    如果用户传递了 使用用户传递的值
    关键: 默认值参数 只能定义在参数列表的最后
    调用函数的时候 如果指明了关键词 尽量都用关键词
"""
def fun3(name,address,age=18): # 形参
    print(f"名字为{name},地址为:{address},年龄为:{age}")

fun3( '颜京','东莞',age=38)  # 实参

参数类型声明

username='xxx'
"""
    形参定义的时候 可以声明类型的()
        变量:类型
    声明类型的作用: 方法书写代码 否则连提示都没有
"""
def fun4(name:str,address:str,age:int):  # 形参本身是没有数据类型
    # 此处是可以对变量进行一定的操作的  会根据传递的变量操作
    print( name.upper() )

    print(f"名字为{name},地址为:{address},年龄为:{age}")

fun4( 'abcd','东莞',38)