函数基础

Posted 2021-01-12 liuhongshuai

1，函数的定义，注释与调用

# 函数定义,注释,调用
# 自定义函数
# def my_len(s):
#     length=0
#     for k in s:
#         length+=1
#     print(length)
#     return length
# s=‘alexwusir‘
# li=[‘alex‘,‘wusir‘]
# res1=my_len(s)#函数的调用
# res2=my_len(li)
# print(res1,res2)

# 函数的注释
# def func():
#     ‘‘‘
#     函数实现了什么功能
#     参数1:
#     参数2：
#     :return:返回值
#     ‘‘‘
#     pass

View Code

2，函数的返回值

没有返回值
    不写return
    只写return 一旦遇到return 结束整个函数
    return None

# 没有返回值
# def func():
#     print(‘func‘)
#     # return
#     # return None
# print(func)#函数的内存地址
# print(func())

View Code

返回一个值 可以返回任意数据类型的值

# 有返回值
def func():
    return ‘Hello World‘
print(func())


def func():
    return [1,2,3,4]
print(func())

View Code

 返回多个值 以元组形式返回

# 返回多个值(成一元组)
# def func():
#     return 1,2,3,4,‘a‘,[‘alex‘],{‘name‘:‘alex‘},None
# print(func())

# def func():
#     return 1,2,3
# print(func())
# a,b,c=func()
# print(a,b,c)

View Code

3,函数的参数 形参与实参

位置参数 按位置传值 按关键字传值 混合使用(位置参数必须在关键字参数前)
默认参数 默认参数的陷阱(默认参数是一个可变数据类型的时候)
动态参数 *args **kwargs
顺序:位置参数、*args、默认参数、**kwargs顺序

# def my_sum(a,b):
#     return a+b
# 
# #位置参数
# print(my_sum(1,2))
# #关键字参数
# print(my_sum(a=1,b=2))
# #混合使用(位置参数必须在关键字参数前)
# print(my_sum(1,b=2))


#默认参数
# def student(name,sex=‘男‘):
#     print(‘%s:%s‘%(name,sex))
#
# student(‘alex‘)
# student(‘yuan‘,sex=‘女‘)

# 默认参数的陷阱
# 当默认参数是一个可变数据类型时,如果不传值，则公用这个数据类型的资源
# def func(s,li=[]):
#     li.append(s)
#     print(li)
#
# func(1)#[1]
# func(2)#[1,2]
# func(3,[])#[3]
# func(4)#[1,2,4]

# *args成一个元组
# def func(*args):
#     print(args)

# func(1,2,3,4)
# func(*[1,2,3,4])

# **kwargs成一个字典
# def func(**kwargs):
#     print(kwargs)
#
# func(a=1,b=2)
# func(**{‘a‘:1,‘b‘:2})

# def func(*args,**kwargs):
#     print(args,kwargs)
#
# func(1,2,a=4,b=6)

View Code

4,函数的命名空间和作用域，作用域链

命名空间 变量名与值的绑定关系  
 全局命名空间 代码运行时 
 局部命名空间 函数中运行时
 内置命名空间 解释器中
加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)
取值：
　　在局部调用：局部命名空间->全局命名空间->内置命名空间
　  在全局调用：全局命名空间->内置命名空间

作用域 
 全局作用域 内置名称空间 全局名称空间
 局部作用域 局部名称空间
 globals()  locals() global关键字  nonlocal关键字

# 命名空间与作用域
# a=1
# def func():
#     print(a)
# func()
#
# def func():
#     a = 1
# func()
# print(a)#报错

# a=1
# def func():
#    a=2
#    print(a)
#    print(locals())#局部作用域
#
# func()
# print(globals())#全局作用域

# global修改全局变量
# a=1
# def func():
#     global a
#     a=2
# func()
# print(a)

# a = 1
# def outer():
#     a = 2
#     def inner():
#         nonlocal a#改变离其最近的上层局部元素的值
#         a += 1
#         print(a)
#     inner()
#     print(a)
#
# outer()
# print(a)

View Code

5，函数的前项引用,嵌套调用

#前向引用
# def foo():
#     print(‘from foo‘)
#     bar()
# foo()
# def bar():
#     print(‘from bar‘)#报错

# def foo():
#     print(‘from foo‘)
#     bar()
# def bar():
#     print(‘from bar‘)
# foo()



# 函数的嵌套调用
# def my_max(a,b):
#     return a if a>b else b #三元运算符
#

# def the_max(x,y,z):
#     c=max(x,y)
#     return max(c,z)
#
# print(the_max(1,2,3))

View Code

6，函数名的本质

函数名的本质 
  函数的内存地址
  可以被引用
  可以作为容器类型的元素
  可以作为函数的参数和返回值

# def func():
#     print(‘in func‘)
#
# s=func  #函数名可以被引用
# s()


# li=[func,s]  #函数名可以作为容器类型的元素
# for i in li:
#     i()

# def func1():
#     print(‘in func1‘)
#
# def func2(f):
#     f()
#     return f    #函数名可以作为函数的返回值
#
# res=func2(func1)#函数名可以作为函数的参数
# res()

View Code

7，闭包函数及其嵌套

闭包
 内部函数包含对外部作用域而非全局作用域的引用-->闭包函数
 输出的__closure__有cell元素-->是闭包函数
 闭包的嵌套

# 闭包:嵌套函数 内部函数调用外部函数的变量
# def outer():
#     name=‘alex‘
#     def inner():
#         print(name)
#     print(inner.__closure__)#判断是否为闭包函数
#     return inner
#
# res=outer()
# res()

#闭包的嵌套
# def wrapper():
#     money=100
#     def func():
#         name=‘alex‘
#         def inner():
#             print(money,name)
#         return inner
#     return func
#
# wrapper()()()

View Code