第六章:python中的函数详解

文章目录

  • 函数
    • 一、函数介绍
      • (一) 什么是函数
      • (二) 为何要有函数
      • (三) 如何使用函数
      • (四) 实例
      • (五) 定义函数的三种形式
      • (六) 调用函数的三种形式
      • (七) 函数返回值return
    • 二、函数中的参数
      • (一) 函数中的参数分为形参与实参
      • (二) 形参与实参详细介绍
        • 一、位置参数
        • 二、关键字实参
        • 三、默认形参
        • 四 关键字实参
        • 五 可变长参数
        • 六 了解
    • 三、函数对象
        • 应用
    • 四、函数嵌套
    • 五、名称空间与作用域
      • (一) 名称空间
      • (二) 作用域
      • (三) global、nonlocal
      • (四) LEG
    • 六、闭包函数
    • 七、装饰器
      • (一) 什么是装饰器
      • (二) 为何要用装饰器
      • (三) 如何使用装饰器
        • 例1
        • 例2
        • 例3
        • 例4:直接通过参数为函数体传参
        • 例5:直接通过参数为函数体传参
        • 例6
        • 例7:语法糖
        • 例8
      • (四) 有参装饰器
      • (五) 叠加多个装饰器
    • 八、迭代器
      • (一) 什么是迭代器
      • (二) 为甚要用迭代器
      • (三) 如何使用迭代器
        • 例1
        • 例2
        • for循环的底层工作原理
    • 九、生成器
    • 十、递归
      • 例1
      • 例2
      • 应用实例1
      • 应用实例2:二分法
    • 十一、匿名函数
    • 十二、面向过程编程
    • 十三、三元表达式
    • 十四、生成器
      • 案例
      • 了解:map、filter、reduce
    • 作业
    • 答案

函数

一、函数介绍

(一) 什么是函数

    函数就是一个盛放代码的容器
    具备某一功能的工具----》函数
    事先准备工具的过程====》函数的定义
    遇到应用场景拿来就用==》函数的调用

(二) 为何要有函数

1)、程序的组织结构不清晰、可读性差
    (2)、代码冗余
    (3)、程序的可维护性差

(三) 如何使用函数

    使用基本原则:先定义,后调用

    定义函数的语法:
        def 函数名(参数1,参数2,参数3,...):  # 先定义
            """文档注释"""
            代码1
            代码2
            代码3
            ...
            return 返回值

    调用函数
        函数名(1,2,3,...)  # 后调用
# 一:先定义
def func(n,msg):  # func=函数的内存地址
    print('-'*n)
    print(msg)
    print('-'*n)


# 二:后调用
func(10,'hello')
func(5,'world')


# 三:
# 定义阶段:只检测语法,不执行代码
def func():
    xxx


# 调用阶段:根据函数名找到函数的内存地址,然后配合()触发函数体代码的运行
func()


(四) 实例

# 示例1
def bar():
    print('from bar')

def foo():
    print('from foo')
    bar()

foo()

# 示例2
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')

foo()

(五) 定义函数的三种形式

#(1):无参函数
def login():
    name= input('username>>>: ').strip()
    pwd = input('username>>>: ').strip()
    if name == 'egon' and pwd == "123":
        print('login successful')
    else:
        print('username or password error')

login()

#(2):有参函数
def max2(x,y):
    # x = 10
    # y = 20
    if x > y:
        print(x)
    else:
        print(y)

max2(10,20)
max2(111,222)

#(3):空函数
def func():
    pass

(六) 调用函数的三种形式

# (1) 语句形式
input("please input your name: ")

def max2(x,y):
    # x = 10
    # y = 20
    if x > y:
        print(x)
    else:
        print(y)

max2(11,22)


# (2) 表达形式
name = input("please input your name: ")

def max2(x,y):
    if x > y:
        return x
    else:
        return y

res=max2(111,222) * 12




# (3) 当作参数传给另外一个函数
def max2(x,y):
    if x > y:
        return x
    else:
        return y

print(max2(111,222))

print(max2(max2(111,222),333))

(七) 函数返回值return

# (1) return是函数结束的标志,函数内可以有多个return,但只要执行一次整个函数就会立即终止,并且会将return后的结果当作本次调用的返回值返回
def func():
    print('hello1')
    return 111
    print('hello2')
    return 222
    print('hello3')
    return 333

func()


# (2) return可以返回的值的个数
#   return 值:返回一个值
#   return 值1,值2,值3: 把多个值放到一个元组内返回
def func():
    return 1,33.3,[1,2,3]

res=func()
print(res)

 # 没有return或者就一个单独的return:默认返回的是None
def func():
    pass

res=func()
print(res)

二、函数中的参数

(一) 函数中的参数分为形参与实参

# (1) 形参: 在函数定义阶段,括号内定义的参数(变量名),称之为形式参数,简称形参
def func(x,y):
    print(x,y)
# (2) 实参: 在函数调用阶段,括号内传入的值(变量值),称之为实际参数,简称实参
func(1,2)

(二) 形参与实参详细介绍

一、位置参数
# (1) 位置形参:在函数定义阶段,按照从左到右的顺序依次定义的形参
#       特点: 必须被传值
def func(x,y):
    print(x,y)

func(1,2)
func(1,2,3)
func(1)


# (2) 位置实参:在函数调用阶段,按照从左到右的顺序依次传入的值
#       特点:按照位置与形参一一对应
def func(x, y):
    print(x, y)
func(1,2) 
二、关键字实参
# 2 关键字实参: 在函数调用阶段,按照key=value的形式传值
#       特点: 可以打破传值的顺序,但仍能指名道姓地为形参赋值
def func(y=2,x=1)

#       注意:可以混用位置实参与关键字实参,但是
#              (1)位置实参必须放在前面
#              (2)不能为同一个形参重复赋值
func(111,y=2)
func(y=2,111)
func(111,x=222,y=333)
三、默认形参
# 在定义函数时,就已经为某个形参赋值了,该形参称之为默认形参
# 特点:定义时已经赋值了,意味着调用时可以不用为其赋值


def func(x, y=222):
    print(x)
    print(y)

func(111)
func(111, 333)

def register(name, age, gender="male"):
    print(name, age, gender)

register('tom', 18)
register('jack',29)
register('wuchangwen',19)
register('lili',19,"female")
# 注意:
# 1、可以混用位置形参与关键字形参,但是位置的肯定要在前
# 2、默认形参的值只在函数定义阶段赋值一次,拿到的是值的内存地址
# 3、默认形参的值通常应该是不可变类型


m=100
def func(x,y=m):  # y=100的内存地址
    print(x)
    print(y)
m=200
func(1)


m=[1,2,3]
def func(x,y=m):  # y=[1,2,3]的内存地址
    print(x)
    print(y)
m=200
func(1)

m.append(444)
func(1)


def register(name,hobby,hobbies=None):  # hobbies = None
    if hobbies is None:
        hobbies = []
    hobbies.append(hobby)
    print("%s 的爱好是 %s" %(name,hobbies))

register('egon','read')
register('jack','music')
register('lili','play')
四 关键字实参
# 在调用函数时,按照key=value的形式定义的实参,称之为关键字实参
# 特点:
#    1 可以打乱顺序,但是仍然能够为指定的形参赋值
def func(x,y):
    print(x,y)

func(y=222,x=111)

# 可以混用位置实参与关键字实参,但是
#    1 但是位置实参必须在关键字参数前
#    2 不能对一个形参重复赋值
func(111,y=222)
func(y=222,111)
func(1111,222,y=333)
func(x=111,y=222,x=333)
五 可变长参数
# 在函数调用时,传入的参数个数不固定,而调用函数时实参形式无非两种:位置实参
# 与关键字实参
# 实参一定是为形参赋值的,实参的个数不固定,对应着必须有特殊格式的形参来专门
# 接收溢出的位置实参与关键字实参


# 5.1 在形参中出现*: *会将溢出的位置实参汇总成元组然后赋值给紧跟其后的那个变量名
def func(x,y,*args):
    print(x)
    print(y)
    print(args)

func(1,2,3,4,5)

def my_sum(*args):
    res = 0
    for v in args:
        res+=v
    return res

print(my_sum(1,2,3,4))


# 5.2 在形参中出现**: **会将溢出的关键字实参汇总成字典然后赋值给紧跟其后的那个变量名
def func(x,y,**kwargs):
    print(x)
    print(y)
    print(kwargs)

func(1,y=2,a=1,b=2,c=3)

# 总结:*与**出现在形参中,是一种汇总操作


# 5.3 在实参中出现*:*后跟的必须是一个可以被for循环循环的类型,*会将其打散成位置实参
def func(x,y):
    print(x)
    print(y)

func(*[111,222])  # func(111,222)
func(*"he")  # func("h","e")
func(*"hel")  # func("h","e","l")
func(*{
   "k1":1111,"k2":2222})  # func("k1","k2")


# 5.4 在实参中出现**:**后跟的必须是一个字典,**会将其打散成关键字实参

func(**{
   "y":111,"x":2222})  # func(y=111,x=2222)

# 总结:*与**出现在实参中,是一种打撒操作

def index(x,y,z):
    print(x)
    print(y)
    print(z)

def wrapper(*args,**kwargs):  # args=(1,2,3,4,5)  kwargs={'a':1,"b":2,"c":3}
    # print(args)
    # print(kwargs)
    index(*args,**kwargs)  # index(*(1,2,3,4,5),**{'a':1,"b":2,"c":3})
                           # index(1,2,3,4,5,a=1,b=2,c=3)

wrapper(1,2,3,4,5,a=1,b=2,c=3)
wrapper(1,z=3,y=2)


# 非常重要的一种格式
def index(x,y):
    print('index===>',x,y)

def wrapper(*args,**kwargs):  # args=(1,2,3)  kwargs={"a":1,'b':2,'c':3}
    index(*args,**kwargs)  # index(*(1,2,3).**{"a":1,'b':2,'c':3})
                          #  index(1,2,3,a=1,b=2,c=3)

    # index(1,y=2)

wrapper(1,y=2)
六 了解
def func(x,y=666,*args,m=777,n,**kwargs):
    print(x)
    print(y)
    print(args)
    print(m)
    print(n)
    print(kwargs)

# func(1,2,3,4,5,6,n=3,m=4,a=1,b=2)


# def func(*args,x):
#     print(args)
#     print(x)
#
# func(1,2,3,4,5)

三、函数对象

# 函数是第一个等公民:可以把函数当变量去用
def func():  # func=函数的内存地址
    print('from func')

x=10 # x=10的内地址
#1、可以被赋值
# f=func
# f()

#2、可以当作参数传给另外一个函数
# def foo(f):
#     print(f)
#     f()
#
# foo(func)

#3、可以当作函数的返回值
# def foo(f):
#     return f
# res=foo(func)
# print(res)

#4、可以当作容器类型的元素
# l=[func,]
# print(l)
# l[0]()


应用
def login():
    print('登录...')

def register():
    print('注册...')

def tranfer():
    print('转账...')

def withdraw():
    print("提现功能。。。")

func_dic={
   
    "1":["登录",login],
    "2":["注册",register],
    "3":["转账",tranfer],
    "4":["提现",withdraw]
}

while True:
    for k,v in func_dic.items():
        print(k,v[0])
    choice = input("请输入您的命令编号,输入0退出:").strip()
    if choice == "0":
        break
    if choice in func_dic:
        func_dic

你可能感兴趣的:(Python,python)