python3 自定义函数

定义函数

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def test(a):
    a=a+1
    return a
test(1)

函数返回值

函数返回值有多个的时候，
1.可以不接收
2.用一个值接收，收到的值是元组类型

3.可以用跟返回值数量一样多的变量接收

def test():
    return 1,2,3

test()
a=test()
print(a)        #(1, 2, 3)
a1,a2,a3=test()
print(a1,a2,a3) #1 2 3

函数传递参数

位置传参和关键字传参

以下两种都是合法的

def test(a,b):
    print(a)
    print(b)
test(b=1,a=2)	        #按照关键字传递参数
test(1,2)		#按照位置传递参数

默认参数

函数传递参数的默认值。

def test(a,b=0):	#第二个参数为默认参数，如果不传，就是使用默认的参数
    print(a)
    print(b)
test(1)	#不输入第二个变量也是可以的
test(1,2)
test(a=10)

默认参数陷阱

如果默认参数的值是一个可变数据类型，
那么每一次调用函数的时候，

如果不传值就公用这个数据类型的资源

def test(a=[]):
    a.append(1)
    print(a)

test()
test()
test()

输出
[1]
[1, 1]
[1, 1, 1]

 

动态参数

 

可以接收任意个参数
动态参数有两种 *args和**kwargs ，*args必须在**kwargs之前

顺序：位置参数，*args，默认参数，**kwargs 

*args：接收的是按照位置传参的值，组织成一个元组

**kwargs：接受的是按照关键字传参的值，组成一个字典

def test(*args):
    print(args)#输出一个元组
    b=0
    for i in args:
        b=b+i
    print(b)
test()
test(1)
test(1,2)
test(1,2,3)

输出
()
0
(1,)
1
(1, 2)
3
(1, 2, 3)
6

 

def test(**kwargs):
    print(kwargs)

test()
test(a=1)
test(a=1,b=2)

输出
{}
{'a': 1}
{'a': 1, 'b': 2}

动态参数的另一种传参方式

这种就是把输入变量前加上星号，把输入变量打散。

 

def func(*args):#站在形参的角度上，给变量加上*，就是组合所有传来的值。
    print(args)

l = [1,2,3,4,5]
func(1,2,3,4,5)
func(*l)  #站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散
func(l)

输出
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
([1, 2, 3, 4, 5],)

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

func(a=1,b=2)
d = {'a':1,'b':2} #定义一个字典d
func(**d)

星号的作用，就是把输入变量打散

print([1,2,3])  #[1, 2, 3]
print(*[1,2,3]) #1 2 3

可更改与不可更改对象在函数的参数传递中的区别

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

 

 

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

 

 

python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

def test(a):
    a[0]='a'

ss=[1,2,3]
test(ss[:]) #不会改变ss
print(ss)   #[1, 2, 3]
test(ss)    #会改变ss
print(ss)   #['a', 2, 3]

 

命名空间和作用域 

命名空间

有三种

内置命名空间 —— python解释器
    就是python解释器一启动就可以使用的名字存储在内置命名空间中
    内置的名字在启动解释器的时候被加载进内存里
全局命名空间 —— 我们写的代码但不是函数中的代码
    是在程序从上到下被执行的过程中依次加载进内存的
    放置了我们设置的所有变量名和函数名
局部命名空间 —— 函数
    就是函数内部定义的名字
    当调用函数的时候 才会产生这个名称空间 随着函数执行的结束 这个命名空间就又消失了

在局部:可以使用全局、内置命名空间中的名字
在全局:可以使用内置命名空间中的名字，但是不能用局部中使用

 

在内置:不能使用局部和全局的名字的

在正常情况下，直接使用内置的名字
当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字
当我自己有的时候 我就不找我的上级要了
如果自己没有 就找上一级要 上一级没有再找上一级 如果内置的名字空间都没有 就报错

 

 

多个函数应该拥有多个独立的局部名字空间，不互相共享

 

作用域

作用域两种
全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域  ——globals()
局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——locals()

globals() 永远打印全局的全部名字

locals() 输出局部作用域的全部，输出什么，根据locals所在的位置

全局操作

在局部可查看全局作用域中的变量
但是不能直接修改
如果想要修改，需要在程序的一开始添加global声明

如果在一个局部（函数）内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效

a=[1,2,3]
def test():
    print(a)
test()	#输出[1,2,3]

 

a=[1,2,3]
def test():
    global  a
    a[0]=2
    print(a)
test()	#输出[2,2,3]

 

 

 

函数的嵌套和作用域链

函数的嵌套调用

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

def max4(a,b,c,d):
    res1 = max2(a,b)
    res2 = max2(res1,c)
    res3 = max2(res2,d)
    return res3

函数的嵌套定义(层数不限)

def f1():
    print("in f1")
    def f2():
        print("in f2")

    f2()
f1()

函数的作用域链

def f1():
    a = 1
    def f2():
        print(a)
    f2()

f1()    #打印1

 

def f1():
    a = 1
    def f2():
        def f3():
            print(a)
        f3()
    f2()

f1()        #打印1

def f1():
    a = 1
    def f2():
        a = 2
    f2()
    print(a)

f1()        #打印1

 

nonlocal关键字

他只能用于局部变量 找上层中离当前函数最近一层的局部变量
1.外部必须有这个变量
2.在内部函数声明nonlocal变量之前不能再出现同名变量

 

 

3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

 

def f1():
    a = 1
    def f2():
        nonlocal a
        a = 2
    f2()
    print(a)

f1()        #打印2

 

函数名的本质

 

函数名本质上就是函数的内存地址

1.可以被引用

def func():
    print('in func')

f = func
print(f)    #

2.可以被当作容器类型的元素

def f1():
    print('f1')

def f2():
    print('f2')

def f3():
    print('f3')

l = [f1,f2,f3]
d = {'f1':f1,'f2':f2,'f3':f3}
#调用
l[0]()  #打印f1
d['f2']()   #打印f2

3.可以当作函数的参数和返回值
就当普通变量用
第一类对象（first-class object）指
1.可在运行期创建
2.可用作函数参数或返回值

3.可存入变量的实体。

闭包

闭包函数：
内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数
ps：函数内部定义的函数称为内部函数
由于有了作用域的关系，我们就不能拿到函数内部的变量和函数了。如果我们就是想拿怎么办呢？返回呀！
我们都知道函数内的变量我们要想在函数外部用，可以直接返回这个变量，那么如果我们想在函数外部调用函数内部的函数呢？
是不是直接就把这个函数的名字返回就好了？
这才是闭包函数最常用的用法

简单地说就是保护了一些变量的生存周期，

def test():
    a=1
    def inner():
        nonlocal a
        a=a+1
        print(a)
    return  inner
inn=test()

inn()   #打印2
inn()   #打印3
inn()   #打印4

判断闭包函数的方法__closure__

#输出的__closure__有cell元素 ：是闭包函数

def func():
    name = 'eva'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()

#输出的__closure__为None ：不是闭包函数
name = 'egon'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()

闭包嵌套

def wrapper():
    money = 1000
    def func():
        name = 'eva'
        def inner():
            print(name,money)
        return inner
    return func

f = wrapper()
i = f()
i()

闭包函数获取网络应用

from urllib.request import urlopen

def index():
    url = "http://www.xiaohua100.cn/index.html"
    def get():
        return urlopen(url).read()
    return get

xiaohua = index()
content = xiaohua()
print(content)