python语法基础-函数-长期维护

###############    函数的定义调用，返回值和返回值接收    ##############

def mylen():
    s = "myname"
    i = 0
    for item in s:
        i += 1
    return i

def func():
    return {"name":"andy"},[1,2,3]

l = mylen()
print(func())

# 从这个例子可以学到几个：函数的定义，函数的调用，函数的返回值，

# 关于返回值有几种情况:
# 1是没有返回值，如果不写return，或者只写return，都是没有返回值的，只要执行了return就不会往后执行了，比如列表的append，没有返回值，
# 2是有一个返回值，可以返回一个列表，可以返回一个字典，return [1,2,3,4]   return {name : andy}
# 3是有多个返回值，return 1,2   多个参数使用逗号分隔，
# 接收的时候可以使用一个变量接收，这个时候是一个元组的类型，
# 也可以使用使用两个参数接收，但是不能使用三个变量接收，会报错

###############    函数参数，形参实参，无参数，默认参数，不定长参数，调用使用位置参数，关键字参数，    ##############

########################
# 这种没有参数
def hollo1():
    print(‘hello world‘)
hollo1()

###################
# 这是必需参数
def hollo2(name):
    print(‘hello world‘)
    print(name,‘在唱歌...‘)
hollo2(‘andy‘)

#######################
def hollo3(age,name):
    print(‘hello world‘)
    print(‘我今年%d岁了‘%age)
    print(name,‘在唱歌...‘)
hollo3(name=‘andy‘,age=18)
# 这种函数调用的时候就使用了关键字参数，这样就可以不用管参数的顺序了，默认是位置参数，
# 位置参数和关键字参数，可以混用，但是要注意位置，
##########################
# 有了默认参数之后，调用函数的时候，这个参数可以不写，则使用默认值，
def hollo3(age,name=‘andy‘):  # 定义参数的时候，必须先定义位置参数，最后定义默认参数，默认参数也叫做关键字参数，
    print(‘hello world‘)
    print(‘我今年%d岁了‘%age)
    print(name,‘在唱歌...‘)
hollo3(age=18)

#############################
# 不定长参数，或者叫做动态参数
# 1,加了星号 * 的参数会以元组(tuple)的形式导入，加了两个星号 ** 的参数会以字典的形式导入。然后就可以像处理元组和字典一样处理参数了，
# 2,为什么会有这两种，就是一种位置参数，一种关键字参数，**kwargs就是用来接收关键字参数的，*args就是接收位置参数的，
# 3,先后顺序：必须先定义args，然后定义kwargs，如果有关键字参数一定放在kwargs之前，
# 4,参数名加星就可以了，后面的args，不是必须是这个，但是星一定要有，一般使用args，这是一种编码习惯，
def hollo3(name,*args,**kwargs):
    print(‘hello world‘)
    print(name,‘在唱歌...‘)
    print(args)   # (60,70) # 这是返回一个元组
    print(kwargs)  # {‘a‘: 1, ‘b‘: 2} 这是一个字典，

hollo3(‘andy‘,60,70,a=1,b=2)
# 如果是把一个列表一个一个的传进入
list1=[1,2,3,4]
hollo3(*list1)
# 如果是把一个字典一个一个的传进入
dict1={"name":"andy","age":1}
hollo3(**dict1)

###############    函数的命名空间和作用域    ##############

"""

# 函数进阶

命名空间和作用域

命名空间
全局命名空间——我们自己写的非函数中的代码
    是在程序从上到下被执行的过程中依次加载进内存的，
    放置了我们设置的所有的变量名和函数名，

局部命名空间，——函数
    就是函数内部定义的名字
    在函数调用的时候才会产生这个命名空间，随着函数调用的结束，这个命名空间就消失了，

内置命名空间，——Python解释器，
    就是Python解释器一启动就可以使用的名字，存储在内置的命名空间中，比如print，input，list等，
    内置的名字，在启动解释器的时候就会加载进去内存中，

在全局我们可以使用内置的明明靠空间，但是不能使用局部的，
在局部我们可以使用全局的，内置的命名空间，
在内置的里面不能使用全局的和局部的，

所以就像是一个套娃一样，最外层是内置的，然后是全局的，然后是局部的，

如果我们定义在全局定义了和内置的函数同名的名字，会使用全局的，

"""

def input():
    print(123)

def func():
    # input=1
    print(input)

func()

"""
作用域

作用域和命名空间是分不开的，

作用域有两种，
1，全局作用域，内置和全局的命名空间，都是全局作用域，
2，局部作用域，我们现在就知道一个局部，就是函数，

对于不可变类型，你可以在局部查看全局的变量，但是不能修改，如果要修改，你就需要使用global进行声明，
自己的代码中应该尽量少使用global，这样会导致代码非常不安全，混乱，
"""

a =1

# def func():
#     global a
#     a += 1
# func()
# print(a)

def func(a):
    a += 1
    return a
# 不使用global，可以使用另一种方法
a = func(a)
print(a)  # 2

"""
globals
locals

"""
a =1
b = 2
def func():
    x = "aaa"
    y = "bbb"
    print(locals())  # 会打印出所有的局部变量的名字和值，  {‘y‘: ‘bbb‘, ‘x‘: ‘aaa‘}
    print(globals())  # 这个还是全局的，

func()
print(globals())  # 会打印出所有全局的名字，和内置的变量的名字，然后是函数名，
print(locals())  # print(globals()),这个打印出的本地和全局是一样的，

###############    函数的嵌套调用，函数的嵌套定义    ##############

# 函数的嵌套调用

# 两个数判断最大值
def max(a,b):
    return a if a>b else b  # 三元运算，a大于b，就是a，否则就是b，

# 三个数判断最大值，先判断两个，然后再判断和第三个，
def the_max(x,y,z):
    c = max(x,y)  # 这就是函数的嵌套调用，
    return max(c,z)

# 函数的嵌套定义，
# nonlocal 找离当前函数最近的一个局部变量，只会影响最近的一层，不能是全局变量，
def outer():
    a = 1
    def innner():
        print(123,)
        def innner2():
            nonlocal a
            a += 1
            print(a)
        innner2()
    innner()  # 一定要有这一句，否则内部定义的函数，不会生效，

outer()

# 函数名就是一个内存地址，
# 1，函数名可以赋值
# 2，函数名可以作为容器类型的元素，
# 3，函数可以作为参数调用，# 函数可以作为参数调用，
def func1():
    print(123)
func2=func1  # 函数名可以赋值

func2()

list1=[func1,func2]  # 函数名可以作为容器类型的元素，

def func3(func1):  # 函数可以作为参数调用，
    func1()
    return func1  # 函数名可以作为函数的返回值，

###############    函数的闭包    ##############

# 闭包

def outer():
    a = 1
    def inner():
        print(a)
    inner()
outer()
outer()
outer()
# 这种写法比较浪费资源，每次都要生成a变量，
# 闭包的定义，就是一个嵌套函数，并且内部函数调用外部函数的变量，如果你调用外部函数的变量，就不是一个闭包，

# 闭包最常用的形式是在函数中返回内部函数，

def outer():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)  # (<cell at 0x0000000009C68FA8: int object at 0x000000005EA960A0>,)，有cell就是一个闭包，
    return inner  # 在外部函数中返回内部函数的名字，这就是一个闭包最常用的方式，

inn = outer()
inn()
inn()
inn()
inn()  # 这种写法我调用这个函数100次，但是里面的a变量就只会生成一次了，不会反复生成了，节省资源，

###############    函数的定义及四种参数    ##############

###############    函数的定义及四种参数    ##############

###############    函数的定义及四种参数    ##############

###############    函数的定义及四种参数    ##############

###############    函数的定义及四种参数    ##############

原文地址：https://www.cnblogs.com/andy0816/p/12231985.html