Python函数详解_def func:

函数

一 什么是函数？

​ 函数就是用来实现一些特定的小程序或方法

优点：

1. 增加了代码的重复使用率
2. 减少了代码量
3. 提高了代码的维护

主体结构:

def 函数名([参数1[,参数2…]]):

​ 函数体

函数的调用:

函数名([参数1[,参数2…])

函数名:

​ 遵循变量的命名规则

注意:

1. 函数严格区分大小写
2. 函数会被覆盖

二 函数参数的问题

**参数**1

1. 形参(再定义函数的时候 括号内的变量)
2. 实参(在函数调用的时候 传入的参数)

参数2

​ 关键字参数

关键字就是你的形参名 在调用的时候 使用形参名=值

例如:

def demo(a,b,c):
    pass
demo(c=10,b=20,a=30)
1
2
3

默认值的操作

def 函数名(参数名=值…):

实例

def func(a=10,b=10): #正确给形参默认值的操作
def func(a,b=10): #正确给形参默认值的操作
#def func(a=10,b): #错误给形参默认值的操作
    pass
1
2
3
4

注意:

1. 函数在定义的时候 如果有形参 且没有默认值 则必须传实参
2. 如果没有形参则不能传实参
3. 如果形参没有默认值 那么实参的个数必须和形参的个数相同
4. 如果形参有默认值 那么可以不用传实参
5. 形参和实参 一一对应
6. 当给形参的默认值时 必须遵循 默认值的规则

三 函数返回值

return 值

注意：

1. return 会把值返回给调用处(就是 函数名()的位置)
2. 函数执行遇到return 就认为执行完毕 下面代码不在执行

return 返回多个值

四 不定长参数

也就是传入的参数的个数不固定

(1) 以元组的形式去接收 *参数名

主体结构:

def 函数名(*args):

​ pass

实例

def demo(*args):
    print(args)
    print(type(args))
    #(1, 2, 3, 4, 5)
    #<class 'tuple'>
demo(1,2,3,4,5)
demo(1)
demo()
1
2
3
4
5
6
7
8

(2) 以字典的形式去接收 不确定实参 **kwargs

主体结构

def 函数名(**kwargs):

​ pass

函数名(x=1,y=2,z=3)

实例

def demo(**kwargs):
    print(kwargs)
demo(x=1,y=2)
1
2
3

(3) 将参数为字典的值 变成 关键字参数 **实参名

主体结构:

def 函数名(**kwargs):

​ pass

myDict = {‘x’:1,’y’:2}

函数名(**myDict)

实例

def func(**kwargs):
    print(kwargs)

myDict = {'x': 1, 'y': 2}
func(**myDict)
1
2
3
4
5

(4) *args 和 **kwargs的组合

主体结构:

def 函数名(*args,**kwargs):

​ pass

注意:

1. *args 和 **kwargs的实参可传可不传 不传的话 为空元祖 空字典
2. *args和**kwargs的实参 可以对某个不进行传参 某个不传参数的为 空元祖或空字典

实例

def func4(*args,**kwargs):
    print(args)
    print(kwargs)
func4(x=1,y=2)
1
2
3
4

五 可变类型 和不可变类型

可变类型:如 列表 字典 在函数内修改变量的值 外部也会发生改变 可变类型

不可变类型: 如 整数 字符串 元组 在函数内部对其进行修改的时候 其实是创建一个一个同名的局部变量

可变类型实例

myDict = {'name':"张三",'age':18}
def updateType():
    print(myDict) #myDict = {'name':"张三",'age':18}
    myDict['name'] = '李四'
    print(myDict) #myDict = {'name':"李四",'age':18}

updateType()
print(myDict)  ##myDict = {'name':"李四",'age':18}
1
2
3
4
5
6
7
8

不可变类型实例

def demo():
    myStr = 'a'  #创建了一个局部变量 myStr
    print(myStr) #打印局部变量
    print(id(myStr)) #打印局部变量 myStr的存储地址
demo()
print(id(myStr)) #打印全局变量 myStr的存储地址
print(myStr)
1
2
3
4
5
6
7
8

六 变量的作用域

全局变量: 在函数外部定义的变量 称为全局变量

局部变量: 在函数内部定义的变量 称为 局部变量

注意:

1. 在函数内部可以获取到 函数外部定义的全局变量
2. 在函数外部不能获取到 函数内部定义的局部变量
3. 我们所学过的 if else while for 定义的变量 都为全局变量

(1) 在函数外部定义的全局变量 函数内外都可以获取到 全局变量

实例

myStr = 'abcd'
def demo():
    print(myStr)
demo()
1
2
3
4

(2) 在函数内部定义的变量称为 局部变量 函数外部不能获取到

实例

def demo():
    myStr = 'abcd'
    print(myStr)
demo()
print(myStr) #NameError
1
2
3
4
5

(3) global 关键字 将变量声明为函数内外使用同一个 可以对变量的值进行整体修改

实例

myInt = 10
def demo():
    global myInt
    myInt = 20
demo()
print(myInt) #20
1
2
3
4
5
6

将局部变量声明为全局变量

实例

def func1():
    global age
    age = 18
    print(age) #18
func1()
print(age) #18
1
2
3
4
5
6

(4) nonlocal 当函数发生嵌套 时候 将函数外层和里面的变量 声明为同一个变量

实例

name = '张三'
def A():
    name = '李四'
    def B():
        nonlocal name
        name = '王五'
        # global name #将全局变量 name声明为函数内外使用同一个
        def C():
            # global name #将全局变量 name声明为函数内外使用同一个
            print("我是C的函数",name)
        C()
        print("我是函数b",name) #张三
    B()
    print("我是函数A",name)
A()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

七 lambda匿名函数

关键字 lambda

主体结构:

变量名 = lambda [形参]:代码

注意:

1. lambda只是一个表达式 函数结构比 def定义的函数 结构体简单很多
2. lambda主体是表达式 而不是代码块 只能封装有限的逻辑

(1) 没有任何参数的lambda表达式

实例

func = lambda:print('我是一个lambda表达式')
func()
1
2

(2) 返回值

实例

a = 10
func1 = lambda:a
print(func1())
1
2
3

(3) 形参

实例

func = lambda x,y:x+y
func(1,2)
1
2

(4) 形参默认值

实例

func = lambda x=1,y=2:x+y
print(func(y=3,x=1))
1
2

(5) 定义并调用(自调用)

实例

(lambda x,y:x+y)(1,2)
1

八 函数的导入

from 库名 import 包名

from 库名 import 包名 as 别名

from 库名.包名 import 方法名[,方法名…]

import 包名 as 别名

__name__ :系统属性 可以在包被引入的时候 可以判断当前程序 是否 在主文件里 在主文件 值为 __main__

注意：

不要将包或者库的名字 中存在数字 起一个规范的有意义的字母的名字

九 装饰器

概念: 在代码运行期间 动态的添加功能 称之为装饰器

def demo(arg):
    def inner(age):
        if age<=10:
            myStr = "儿童"
        elif age<=20:
            myStr = "青年"
        elif age<=50:
            myStr = '中年'
        else:
            myStr = "老年人"
        arg(myStr)
    return inner
@demo #  = mySpeak = demo(mySpeak)
def mySpeak(pserson):
    print("你是一个{}年龄段的人".format(pserson))
# mySpeak = demo(mySpeak)
mySpeak(40)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

十 列表推导式

概念: 提供了一种快速生成列表的方式