Python基础07_推导式函数

目录

一、推导式

1、列表推导式

2、字典推导式

3、集合推导式

4、元组推导式

二、函数

1、定义函数

1.1 def语句

1.2 函数的调用

1.3 return语句

2、函数参数

3、返回值

4、匿名函数

5、变量作用域

6、函数的内存分配

7、函数自调用（递归）

一、推导式

 Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

• 列表(list)推导式

• 字典(dict)推导式

• 集合(set)推导式

• 元组(tuple)推导式

1、列表推导式

基本格式

'''
[ 表达式 for 自定义变量 in 可迭代对象 ]
[ 表达式 for 自定义变量 in 可迭代对象 if 真值表达式 ]
'''

 举例

'''
 生成1—10之间的数字，将其平方存入list01中。
    将list01中所有奇数存入list02中。
    将list01中所有大于5的偶数增加1后存入list03中。
    要求都用列表推导式
'''

list01 = [x**2 for x in range(1,11)]
print(list01)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
list02 = [x for x in list01 if x%2 == 1]
print(list02)  # [1, 9, 25, 49, 81]
list03 = [x+1 for x in list01 if x%2 == 0 and x>5]
print(list03)  # [17, 37, 65, 101]

2、字典推导式

基本格式

'''
{ 键表达式: 值表达式 for 元素 in 集合 }

{ 键表达式: 值表达式 for 元素 in 集合 if 条件 }
'''

举例

'''
以三个数字为键，三个数字的平方为值创建字典
'''
number = [2, 4, 6]

dict01 = {x:x**2 for x in number}
print(dict01)  # {2: 4, 4: 16, 6: 36}

3、集合推导式

基本格式

'''
{ 表达式 for 元素 in 序列 }
{ 表达式 for 元素 in 序列 if 条件 }
'''

举例

set00 = tuple(range(6))

set01 = {i**2 for i in set00}
print(set01)  # {0, 1, 4, 9, 16, 25}

4、元组推导式

基本格式

'''
( 表达式 for 元素 in 序列 )
( 表达式 for 元素 in 序列 if 条件 )
'''

举例

#生成一个包含数字 1~9 的元组
a = (x for x in range(1,10))
print(a)  # 返回的是生成器对象
print(tuple(a))  # 使用 tuple() 函数，可以直接将生成器对象转换成元组
# (1, 2, 3, 4, 5, 6, 7, 8, 9)

二、函数

1、定义函数

• 什么是函数

  函数是可以重复执行的语句块，可以重复调用，是函数是面向过程编程的最小单位。

• 作用

  用于封装语句块, 提高代码的重用性。

1.1 def语句

用来定义（创建）函数

def 函数名(形式参数列表):
    语句块

说明

1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()

2. 函数名是一个变量，不要轻易对其赋值

3. 函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数内部可以访问函数外部的变量，但不能轻易对其改变

4. 函数的形参列表如果不需要传入参数，形式参数列表可以为空

5. 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

6. 函数内容以冒号 : 起始，并且缩进。

7. return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

1.2 函数的调用

函数名(实际调用传递参数)

说明

• 函数调用是一个表达式

• 如果函数内没有return 语句，函数执行完毕后返回 None 对象

1.3 return语句

return [表达式]
#[] 代表 内部的内容可以省略

 说明

1. return 语句后面的表达式可以省略，省略后相当于 return None

2. 如果函数内部没有 return 语句, 则函数执行完毕后返回None, 相当于在最后一条语句后有一条return None

实例

def fun01():
    print("hello!")
    return 1

re = fun01()  # hello!
print(re)  # 1

2、函数参数

'''
  函数参数
     实际参数（调用参数）
        位置传参
           序列实参
        关键字传参
           字典实参

    形式参数
        默认参数
        位置形参
           星号元组形参
        命名关键字形参
           双星号字典形参
'''

2.1 函数的调用传参

• 位置传参

  实际参数传递时，实参和形参按位置来依次对应

• 关键字传参

  实际参数传递时，实参和形参 按名称依次对应

注：位置传参要先于关键字传参

def myfun1(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)

## 位置传参
myfun1(1, 2, 3)
## 关键字传参
myfun1(c=33, a=11, b=22)
## 位置传参要先于关键字传参
myfun1(111, c=333, b=222)   # 正确

# 序列实参：使用星号将序列拆分后，与形参进行对应
# 星号序列传参  *序列/元组 拆分后按照位置依次传给函数
list01 = [7,8,9]
myfun01(*list01)

# 字典实参：使用双星号将字典拆分后，依次与形参对应
# 星号字典传参  **字典
dict01 = {"c":3,"b":2,"a":1}
myfun01(**dict01)

2.2 默认参数

def 函数名(形参名1=默认实参1, 形参名2=默认实参2, ... ):
     语句块

 2.3 位置形参和关键字形参

• 位置形参

• 星号元组形参(*args)

• 命名关键字形参

• 双星号字典形参（**kwargs）

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

fun01(1,2,3)  # 位置形参
fun01(a=5, b=6, c=7)  # 关键字形参
fun01(1, c=5, b=8)  # 混合使用（位置形参要放在关键字之前）

2.4 可更改与不可更改对象 

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：值传递: 如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

• 可变类型：引用传递: 如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

3、返回值

函数可以使用return语句来返回一个或多个值。

如果没有明确的return语句，函数将默认返回None。

4、匿名函数

在Python中，匿名函数通常使用lambda关键字来创建。匿名函数也被称为lambda函数，它是一种简单的、一行的函数，常用于临时需要一个小函数的地方。

lambda  [函数的参数列表]: 表达式

作用

• 创建一个匿名函数对象

• lambda是关键字，表示你正在定义一个匿名函数。

• 同 def 类似，但不提供函数名

• [函数的参数列表]是函数的参数，可以有零个或多个参数，参数之间用逗号分隔。

• : 表达式是函数的返回值，通常是一个表达式，匿名函数会计算这个表达式并返回结果。

说明

• lambda 表达式 的创建函数只能包含一个表达式

def myadd(x, y):
    return x+y

re = myadd(3,4)
print(re)  # 7

number = lambda x,y: x+y
print(number(5,7))  # 12

5、变量作用域

5.1 局部变量和全局变量

局部变量

• 定义在函数内部的变量称为局部变量(函数的形参也是局部变量)

• 函数内部的变量只能在函数内部或者函数内部的函数内部访问 ，函数外部不能访问

• 局部变量在函数调用时才能够被创建，在函数调用之后会自动销毁

全局变量

• 定义在函数外部，模块内部的变量称为全局变量

• 全局变量, 所有的函数都可以直接访问(取值,但函数内部不能直接将其赋值改变)

# 全局变量
a = 100

def fun01():
    a = 20
    def fun02():
        # 局部作用域
        a = 10
        print(a)

    fun02()

fun01()  # 10

5.2 global关键字

在函数内部修改全局变量

def fun03():
    global a
    a = 200
    print(a)

fun03()  # 200
print(a)  # 200

5.3 nonlocal关键字

 修改外部嵌套变量

def fun04():
    # 外部嵌套作用域
    a = 500
    def fun05():
        # 局部作用域
        nonlocal a
        a = 50

    fun05()
    print(a)

fun04()  # 50

5.4 LEGB顺序

'''
LEGB顺序(访问数据)
L:本地作用域，指当前函数内部的变量
E:闭包函数外的函数作用域，指嵌套函数的外部函数中定义的变量
G:全局作用域，指模块级别定义的变量
B:内建作用域，指 Python 预定义的变量、函数等，如 `len`、`sum` 等
'''

6、函数的内存分配

1、将函数的代码存储到代码区，函数体中的代码不执行。

2、调用函数时，在内存中开辟空间（栈帧），存储函数内部定义的变量。

3、函数调用后，栈帧立即被释放。

若传入的是不可变的类型，则函数内部变量不能直接改变；

若传入的是可变的类型，则函数内部可以直接修改。

'''
不可变类型参数有:
- 数值型(整数，浮点数)
- 布尔值bool
- None 空值
- 字符串str
- 元组tuple

可变类型参数有:
- 列表 list
- 字典 dict
- 集合 set
'''

a = 20
b = [1, 2, 3]
def fun01(data1, data2):
    data1 = 1
    data2[0] = 100

fun01(a,b)
print(a)  # 20
print(b)  # [100, 2, 3]

7、函数自调用（递归）

函数直接或间接的调用自身

说明：

• 递归一定要控制递归的层数，当符合某一条件时要终止递归调用（递归边界）

• 几乎所有的递归都能用while循环来代替

递归的实现方法：

• 先假设此函数已经实现

递归优缺点：

优点：

• 递归可以把问题简单化，让思路更为清晰,代码更简洁

缺点：

• 递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

# 阶乘
# 迭代思想
def fun01(n):
    re = 1
    i = 1
    while i <= n:
        re *= i
        i += 1
    return re

re = fun01(5)
print(re)  # 120

# 递归思想
def fun02(n):
    # 递归边界：返回条件
    if n == 1:
        return 1
    # 递归，调用自己
    re = n * fun02(n-1)
    return re

re = fun02(5)
print(re)  # 120