python入门第十一节--深入浅出函数基础

函数的重要性

函数在Python中的重要性体现在以下几个方面：

1. 代码重用：函数允许我们编写一次代码，然后在需要的时候多次调用。这避免了代码的重复，使得代码更加简洁和易于维护。

2. 模块化：通过将代码分割成多个函数，我们可以将复杂的问题分解成更小、更易于管理的部分。每个函数负责完成一个特定的任务，这样有助于组织代码结构。

3. 抽象化：函数提供了一种抽象层，使得我们不必关心函数内部的实现细节，只需知道如何使用它。这有助于简化问题解决过程，使得代码更易于理解。

4. 可读性：良好的函数命名和结构可以提高代码的可读性。通过函数名，我们可以大致了解函数的功能，而不需要深入到函数内部。

5. 调试和维护：当程序出现问题时，如果代码被组织成多个函数，那么调试起来会更加容易。我们可以单独测试每个函数，而不必从头到尾运行整个程序。

6. 扩展性：使用函数可以更容易地扩展程序。如果需要添加新功能，只需编写新的函数或修改现有函数，而不是重写整个程序。

7. 代码共享：函数可以很容易地在不同的程序之间共享。Python的标准库就是一系列预先编写好的函数，可以供所有Python程序员使用。

8. 性能优化：在某些情况下，函数可以用来优化性能。例如，通过将计算密集型的操作放在函数中，并使用缓存（如functools.lru_cache）来存储结果，可以避免重复计算。

以下是函数重要性的具体例子：

- 内置函数：Python提供了大量的内置函数，如`print()`, `len()`, `sum()`等，这些函数极大地简化了编程任务。

- 自定义函数：通过编写自定义函数，我们可以创建个性化的工具来满足特定的需求，这对于解决复杂问题至关重要。

- 高阶函数：Python支持高阶函数，即可以接受其他函数作为参数或返回函数的函数。这为编写更灵活和强大的代码提供了可能。

- 装饰器：装饰器是一种特殊的高阶函数，它允许我们在不修改函数内部代码的情况下，增加函数的功能。

函数是Python编程的核心组成部分，它们使得编程更加高效、有序和强大。掌握函数的使用对于成为一名优秀的Python程序员至关重要。

函数定义

def+空格+函数名+括号+冒号

tab缩进+代码体

#示例：
def fac():
    print('函数定义')#不调用不能执行

函数的调用

函数名+括号

fac()

函数功能

函数体里有代码，函数就有功能。

def fac():
	print('有我就有功能')
fac()

无代码，只是用来测试或者先做好项目需求，代码体可用pass代替 避免报错

 

def fac():
	pass  # pass占位，避免报错
fac()

函数的参数 

函数可分为有参函数和无参函数。

参数分为形参和实参

形参：函数定义阶段括号内指定的变量名

实参：函数调用阶段括号内传入的值

形参和实参的关系：再调用函数时，会将实参（值）赋值（绑定）给形参（变量名）

形参分为  位置形参 、 默认形参 、不定长形参

实参分为  位置实参、 关键字实参

位置形参

只有变量名 没有赋值

def fac(a,b):  #a,b 是位置形参
    print('这是位置形参')

位置实参

就是给位置形参传值

fac(1, 2)

传入的1 2是位置实参，位置实参个数必须与位置形参的个数一致，可以是任意数据类型。

关键字实参

函数调用阶段，按照key=value的形式给指定的形参传值

注意：

1.可以打乱顺序传值，但必须指名道姓的为形参传值

def fac(a,b):
    print('关键字实参')
fac(a=1,b=2)

2.可以混合使用位置实参和关键字实参，但必须注意：

2.1位置实参必须在关键字实参前面

def fac(a,b):
    print('关键字实参')
fac(1,b=2)
fac(b=2,1)  # 不可以

2.2不能对一个形参重复赋值

def fac(a,b):
    print('关键字实参')
fac(1,a=2)#这是不对的 位置形参默认传给a，后面关键字实参又给a传值 不可
fac(1,b=2)#可以

默认形参

就是又默认值的形参。定义函数时，使用key=value为形参赋值了

注意：

1.在定义阶段就已经被赋值，意味着在调用阶段可以不为默认形参赋值

2.位置形参放在默认形参前面

def fac(a,b=2):
    print('b是默认形参')
fac(1)  # 正确的可以不再给b传值
fac(1,5)  # 正确，5会替换掉2，最终b=5

不定长参数

args

形参中带*

会将调用函数时溢出位置实参保存成元组的形式然后赋值给*后的变量名

def foo(x,y,*z)
	print(x)#x拿走第一个1
    print(y)#y拿走第二个2
    print(z)#剩下的都给z  以元组的形式
    print(*z)#*z是将元组z打散
foo(1,2,3,4,5,6,7)

kwargs

形参中带**

会将调用函数时溢出的关键字实参保存成字典的形式，赋值给**后面的变量名

def foo(x,y,**z)
	print(x)
    print(y)
    print(z)
    print(**z)
foo(1,2,3,4,5,6,7)
#这是不对的，**只能接受关键字实参

def foo(x,y,**z)
	print(x)#x拿走第一个1
    print(y)#y拿走第二个2
    print(z)#剩下的都给z  以字典的形式
    #print(**z)字典不能这样打散
foo(1,2,a=3,b=4,c=5,d=6,e=7)

如果字典做实参，可以打散成关键字实参

def foo(x,y,**z)
	print(x)#x拿走第一个1
    print(y)#y拿走第二个2
    print(z)#z实际就是字典a
a = {'a':1,'b':2,'c':3}
foo(1,2,**a)#这是可以的

返回值

返回值是一个函数的处理结果  return

注意：（重点）

1.return是一个函数结束的标志，函数内可以有多个return，但只要执行一次整个函数就会结束运行 默认return None

2.return的返回值无类型限制，可以是任意数据类型

3.return的返回值无个数限制，可以用逗号隔开多个任意类型的值

返回0个：返回None （不写return默认会在函数的最后一行添加return None

返回1个：返回的值是该值本身

返回多个：返回值是元组

4.return关键字：return是函数结束的标志 利用这一点可以结束循环

def factory(a, b):
    return True
#factory(1,2)#这样什么也不会输出，return将True返回出来，factory接收返回值
print(factory(1,2))  # 这样可以
a=factory(1,2)
print(a)#这样也可以  a只是一个变量名，把返回值赋值给它而已，和形参无关  可以随意命名

局部变量与全局变量

外部不能访问函数内部的变量

def fun1():
    x=1
print(x)
fun1()#会报错

函数内部可以访问外部的变量

x=1
def fun1():
    print(x)
fun1()#可以

函数内部不能修改函数外部的变量

x=1
def fun1():
    print(x)
    #x=x+1#不行   可用不可改
fun1()

global 能让我们在函数里面取修改全局变量的值

x=1
def fun1():
    global x:
        x=x+1
    print(x)
fun1()#这就可以改了

nonlocal 让嵌套函数能够修改嵌套函数之外的值

def func1():
    a=3
    def func2():
        nonlocal b
        b=b+1#b本来是不能修改的，nonlocal声明之后就可以了
    func2
func1