python函数的基础教程

1.函数：

函数的定义：自定义函数的语法格式如下所示

        def 函数名(参数列表):

            函数体

            return 返回值  #return语句可选，如果函数没有返回值，则可以省略此语句,没有return语句，则默认返回None值

   

函数的调用：调用函数的语法格式如下所示

        函数名(参数列表)

1.1什么是形式参数？

我们知道，在函数定义的时候，参数并不是实际的数据，而是函数在运行的时候才会用到的数据信息，就像一个接口一样，当函数被调用的时候，形式参数用来接收调用的时候传入的实际的的参数数据（实际参数）。形式参数的作用就是用来接收调用函数时实际的参数数据，这就是形式参数，也叫做形参。

1.2什么是实际参数？

实际参数就是调用函数时传入的参数数据，实际参数的作用就是用来传递函数需要的数据，当你调用函数的时候，实际参数被形式参数接收，函数收到这些数据后，便可以通过这些数据来执行函数的功能 函数执行完后，如果有返回值便返回到到调用处，然后程序接着执行后续代码 如果没有返回值 程序执行回到调用处继续执行接下来的代码

总结：函数调用的时候的参数就是实际参数，函数定义的时候的参数就是形式参数

1.3函数的定义和调用

# 函数的定义和调用
# 定义函数
def rect_area(width, height):   # 定义函数名为rect_area，形式参数为width和height
    """ 函数功能：接收调用方传进来的矩形的宽和高，计算矩形的面积并返回面积 """
    area = width * height   # 计算矩形的面积
    return area   # 返回矩形的面积

# 调用函数
Area=rect_area(5,10)# 调用函数rect_area，传入矩形的宽为5，高为10，返回矩形的面积,把面积放到变量area中
print(Area) # 输出面积

1.3.1.函数调用

  当我们定义好啦函数之后，调用就变得给格外的简单，只需要在函数名后面加上括号，并传入相应的参数即可

1.3.2使用位置参数调用函数

  在调用函数的时候的传入的参数(实际参数)就两种：位置参数和关键字参数。位置参数就是按照函数定义时的顺序传入参数，关键字参数则是通过参数名字传入参数。

上述的例子中我们定义好啦一个名叫rect_area的函数，然后我们在调用函数的时候，分别传了两个实际参数5和10，此时按照位置关系把5和10分别传递给形式参数width和height，函数执行完毕后，返回值就是50，即矩形的面积。把50赋给变量area，然后把面积area打印出来（形参列表要和实参列表一一对应）。

1.3.2使用关键词参数调用函数

使用关键字参数调用函数形式：函数名(参数名=参数值,参数名=参数值,...)

  

def my_func(name, age, city):
       print("姓名：", name)
       print("年龄：", age)
       print("城市：", city)
   
my_func( age=25, name="张三", city="北京")

1.3.3默认值参数

在函数定义时，可以给参数设置默认值，这样在调用函数时，可以省略这个参数，函数会使用默认值，如果在调用函数时指定了这个参数，则会覆盖默认值

def greet(name, msg="Hello"):
    print(msg, name)

greet("Alice")  # Output: Hello Alice
greet("Bob", "Hi")  # Output: Hi Bob

在上面的例子中，`greet()`函数定义了两个参数，`name`和`msg`，其中`msg`参数有默认值`Hello`。在调用`greet()`函数时，可以只传入`name`参数，函数会使用默认值`Hello`；也可以传入`name`和`msg`参数，函数会使用指定的`msg`参数。

1.4不定长参数

不定长参数也叫可变参数，它允许你传入0个或任意个参数，这些参数在函数调用时自动组装为一个tuple以及一个dict

1.4.1 动态位置传参

def my_func(*args): #定义函数，参数名为*args，表示可变参数,接收0个和多个的位置参数并给封装（合并）成tuple
         print(args)
         print(type(args))
list1 = [1,2,3,4,5]
my_func(*list1)    #把list1传进去，依次的把这个列表元素打散作为位置参数
my_func(1,2,3,4,5) # (1, 2, 3, 4, 5) <class 'tuple'>

1.4.2动态关键字传参

def my_func(**kwargs):    #定义函数，参数名为**kwargs，表示可变参数,接收0个或多个的关键字参数并给封装为字典
        print(kwargs)
        print(type(kwargs))
dict1 = {'name':'tom','age':20,'gender':'male'}
my_func(**dict1)    #把dict1传进去，把字典里面的键值对打散依次的作为关键字参数

分析：我们是不是在传递实际参数的时候，我们是不是先定义了一个列表和字典，然后把这些参数放到了一个列表序列中和一个字典中，然后把这个序列和字典传出函数的实际参数里面，这一步做的就是打散，解包工作，把他们打散后分别传进去作为函数的位置参数和关键字参数

对于列表来说，打散成一个个一个个的位置参数按照先后顺序 ，然后这些个位置参数被*args接收，然后把这些给位置参数打包（合并）成一个元组，我们通过打印arg得知是元组类型 

对于字典来说，打散成一个个的关键字参数按照顺序，以键值对的形式，然后把这些个位置参数传到**kwargs中，是重新把这些关键字参数打包成一个字典放到形式参数kwargs中，我们通过打印kwargs可以知道是字典类型的对象

1.5函数中变量的作用域

变量可以在模块中创建，作用域（变量的有效范围）是整个模块，被称为全局变量。变量也可以在函数中创建，在默认情况下作用域是整个函数，被称为局部变量。打个比方，我们写了一个python脚本文件,在这个脚本文件中定义了函数变量，类，最外面的变量就是全局变量，作用域就是整个模块 在函数里面我们又定义了一些变量，便是局部变量，生命周期在函数执行的时候被创建，执行完便被销毁 其作用域就是整个函数范围里，

在函数里面可以进行访问修改 即使名字和全局变量一样，创建的也只是不同的内存空间 他们的内存地址不同，名字一样不一样完全没有影响的 ，局部变量可以访问全局变量，进行读操作 但我们无法修改其全局变量的值，进行写操作  总之，内层的可以访问外层的，外层的不能访问内层的 

所以局部变量是不是比较安全呀，不容易被访问到，而全局变量不是那么的安全，因为可以被里面的和外边的访问 函数的作用域就是整个函数上下从定义函数到执行函数体那一大坨 问题来了但是我们要偏要在里边（局部)，修改全局变量那可咋办呀，我知道我可以访问全局变量，谁都可以访问嘛全局变量，但是不能修改里面的内容  。同样的我俩都是局部变量我要内层的修改外层的变量应该怎么做呢？

python中为我们提供了两个关键字 global和nonlocal这俩关键字了具体用法，在局部中修改全局变量，我们要用global 对变量声明，这样系统便知道我们要修改的就是全局变量在内层想要修改外出的变量数据，我们便需要用到nolocal关键字进行声明，这样便可以进行修改了 注意nonlocal 只能修改外层函数的变量而不能修改外层函数所引用的全局变量

如下为变量的作用域demo

#全局变量
x=10
def print_value():
    x=20
    print("函数中的变量x值为:{}".format(x))
print_value()
print("全局变量x值为:{}".format(x))

1.5.1使用global关键字demo

#全局变量
x=10
def print_value():
    global x #把x声明为全局变量
    x=20 #修改全局变量的值
    print("函数中的变量x值为:{}".format(x)) 
print_value()
print("全局变量x值为:{}".format(x))

1.5.2使用global关键字demo

# 定义外部函数
def outer_function():
    x = 10

    # 定义内部函数
    def inner_function():
        nonlocal x
        x = 20
        print("Inner function:", x)

    # 调用内部函数
    inner_function()
    print("Outer function:", x)

# 调用外部函数
outer_function()

分析：

这段代码定义了两个函数：`outer_function` 和 `inner_function`。

1. `outer_function` 函数中：

   - 变量 `x` 被赋值为 10。

   - 紧接着定义了内部函数 `inner_function`。

   - `inner_function` 使用 `nonlocal` 关键字来声明 `x` 变量是来自外部函数的局部变量。

   - 在 `inner_function` 中，`x` 被重新赋值为 20，然后打印出 "Inner function: 20"。

   - 最后，在 `outer_function` 中打印出 "Outer function: 20"。

2. 执行 `outer_function`，这将触发内部的 `inner_function` 被调用，并打印出内部和外部函数中 `x` 变量的值。

总结：这段代码的主要功能是演示了 Python 中的内部函数和 `nonlocal` 关键字的用法。内部函数 `inner_function` 可以访问外部函数 `outer_function` 中的变量 `x`，并且通过使用 `nonlocal` 关键字，`inner_function` 可以修改外部函数中的变量值。

1.6函数的类型

Python中的任意一个函数都有数据类型，这种数据类型是function，被称为函数类型。

1.6.1理解函数类型

函数类型的数据与其他类型的数据是一样的，任意类型的数据都可以作为函数返回值使用，还可以作为函数参数使用。因此，一个函数可以作为另一个函数返回值使用，也可以作为另一个函数参数使用。

实例代码图下：

#定义加法函数
def add(a, b):
    return a + b
#定义减法函数
def sub(a, b):
    return a - b
#定义计算函数
def calculate( op):
    if op == '+':
        return add
    else:
        return sub
f1=calculate('+')#返回的是add函数，f1就是实际上就是add()函数
f2=calculate('-')#返回的是sub函数，f2就是实际上就是sub()函数
print("3+4={}".format(f1(3,4)))#f1指向add函数，所以可以直接调用add(3,4)
print("5-2={}".format(f2(5,2)))#f2指向sub函数，所以可以直接调用sub(5,2)

1.6.2过滤函数filter()

在Python中定义了一些用于数据处理的函数，如filter()和map()等,先讲解filter()函数,filter()函数用于对容器中的元素进行过滤处理

filter（）函数的作用是对一个序列进行过滤，返回一个新的序列，该序列中的元素满足条件。

filter()函数的第一个参数是函数，第二个参数是序列。函数参数为一个元素，函数返回True或False，True表示保留该元素，False表示过滤掉该元素。filter()函数会对序列中的每个元素调用函数，如果函数返回True，则保留该元素，否则过滤掉该元素。filter()函数返回一个迭代器对象，需要返回列表类型的数据，还得用list()函数转换成列表才行。

代码示例：

#filter()函数的使用
def is_odd(n):
    """ 判断一个数是否为奇数"""
    return n % 2!= 0
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# 定义一个列表
result = filter(is_odd, numbers)# 过滤出列表中所有奇数
print(list(result))# 输出结果
#输出：[1, 3, 5, 7, 9]

1.6.3映射函数map()

map()函数用于对容器中的元素进行映射（或变换）例如：我想将列表中的所有元素都乘以2，返回新的列表

`map()`函数是Python中的内置函数，它可以对可迭代对象（如列表）中的每个元素应用一个函数，然后返回一个包含结果的迭代器。该函数的基本语法如下所示：

```python

map(function, iterable, ...)

```

其中，`function`是用来处理每个元素的函数，`iterable`是一个或多个可迭代对象，它们的每个元素会作为参数传递给`function`。

下面是一个简单的示例，演示了`map()`函数的用法：

def square(x):
    # 定义一个函数用于计算输入数的平方
    return x**2

numbers = [1, 2, 3, 4, 5]
# 使用map函数将square函数应用到numbers列表的每个元素上
squared_numbers = map(square, numbers)
# 将map对象转换为列表并打印出来
print(list(squared_numbers))

 

在这个示例中，我们定义了一个`square()`函数，然后将它传递给`map()`函数，同时传入了一个包含整数的列表。`map()`函数将`square()`函数应用于列表中的每个元素，返回一个包含平方值的迭代器。最后，我们通过`list()`函数将迭代器转换为列表进行输出。这就是`map()`函数的基本用法。你可以使用不同的函数和可迭代对象来实现各种不同的映射操作。

1.6.4lambda()函数

我们也可以定义匿名函数，匿名函数就是没有名称的函数，Python中使用lambda关键字定义匿名函数，lambda关键字定义的函数也被称为lambda()函数,返回值是一个函数

代码实现：

# 定义加法函数
# def add(a, b):#lambda a,b:a+b也可以定义加法函数
#    return a + b
# 定义减法函数
# def sub(a, b):#lambda a,b:a-b也可以定义减法函数
#     return a - b
#定义计算函数
def calculate( op):
    if op == '+':
        #return add
        return lambda a,b:a+b 
    else:
        #return sub
        return lambda a,b:a-b 
f1=calculate('+')#返回的是add函数，f1就是实际上就是add()函数
f2=calculate('-')#返回的是sub函数，f2就是实际上就是sub()函数
print("3+4={}".format(f1(3,4)))#f1指向add函数，所以可以直接调用add(3,4)
print("5-2={}".format(f2(5,2)))#f2指向sub函数，所以可以直接调用sub(5,2)

使用lambada函数修改filter（）函数中的案例，代码如下：

#filter()函数的使用
# def is_odd(n):#等价于lamba x:x%2!=0
#     """ 判断一个数是否为奇数"""
#     return n % 2!= 0
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# 定义一个列表
result = filter(lambda x: x % 2!= 0, numbers)# 过滤出列表中所有奇数
print(list(result))# 输出结果
#输出：[1, 3, 5, 7, 9]

1.7简单练一练

1 通过以下函数sum（）定义代码，调用语句正确的是（）。def sum(*numbers):

total=0.0

for number in numbers:

total+=number

return total

A.print(sum(100.0,20.0,30.0))

B.print(sum(30.0,80.0))

C.print(sum(30.0,'80'))

D.print(sum(30.0,80.0,'80'))

2 通过以下函数area（）定义代码，调用语句正确的是（） 。def area(width,height):

return width*height

A.area(320.0,480.0)

B.area(width=320.0,height=480.0)

C.area(height=480.0,width=320.0)

D.area(320.0,'480')

3 填空题：请在以下代码横线处填写一些代码，使之获得期望的输出结果。

x=200

def print_value():

____x

x=100

print（＂函数中x={0}＂.format（x））print_value()

print（＂全局变量x={0}＂.format（x））

输出结果：

函数中x=100

全局变量x=100

4 判断对错：（请在括号内打√或×，√表示正确，×表示错误）。

1）Python支持函数重载。（）

2）map（）函数用于对容器中的元素进行变换。（）

。