Python 04-认识函数

函数

什么是函数？
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数的定义与调用

def my_len(s):
	length = 0
	for i in s:
		length = length + 1
		print(length)
my_len("hello world")

定义：def关键字开头。空格之后接函数名称和圆括号()，最后还有一个"："
def是固定，不能变，他就是定义函数的关键字。
为了将def关键字和函数名分开，要用空格隔开。
函数名：函数名只能包含字符串，下划线和数字且不能以数字开头。尽量简短。
注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。
调用：就是 函数名() 要记得加上括号。

函数的返回值

def my_len():
	s = 'hello world'
	length = 0
	for i in s:
		length = length + 1
	return length
str_len = my_len()
print(str_len

return关键字的作用：

• return是一个关键字，这个词翻译过来就是"返回"，所以我们管写在return后面的值叫“返回值”。
• 不写return的情况下，结束整个函数
• 一旦遇到return，结束整个函数
• 返回多个值会被组织成元祖被返回，也可以用多个值来接收。

def ret_demo():
	return 1,2,'a',['hello','world']
ret = ret_demo()
print(ret)

函数的参数

带参数的函数

• 实际的要交给函数的内容，简称实参。
  在定义函数的时候它只是一个形式，表示这里有一个参数，简称形参。

def my_len(s):
	length = 0
	for i in s:
		length += 1
	return length
ret = my_len('hello world!')
print(ret)

1.位置参数

def maxnumber(x,y):
	the_max = x if x > y else y
	return the_max
ret = maxnumber(10,20)
print(ret)

2. .关键字参数
   位置参数必须在关键字参数的前面
   对于一个形参只能赋值一次

def maxnumber(x,y):
	the_max = x if x > y else y
	return the_max
ret = maxnumber(y = 10,x = 20)
print(ret)

3. 位置、关键字形式混着用：混合传参。

def maxnumber(x,y):
	the_max = x if x > y else y
	return the_max
ret = maxnumber(10,y = 20)
print(ret)

4. 默认参数。

def stu_info(name,age = 18):
	print(name,age)
stu_info('aaron')
stu_info('song',50)

5. 默认参数是一个可变数据类型

def demo(a,l = []):
	l.append(a)
	print(l)
demo('abc')
demo('123')

6. 动态参数

def demo(*args,**kwargs):
	print(args,type(args))
	print(kwargs,type(kwargs))
demo('aaron',1,3,[1,3,2,2],{'a':123,'b':321},country='china',b=1)
#动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数
#*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

命名空间和作用域

代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
在函数的运行中开辟的临时的空间叫做局部命名空间。
命名空间分为三种：

• 全局命名空间

• 局部命名空间

• 内置命名空间
  取值顺序：

• 在局部调用:局部命名空间>全局命名空间>内置命名空间

• 在全局调用：全局命名空间>内置命名空间
  作用域：

• 全局作用域：包含内置名称空间，全局名称空间，在整个文件的任意位置都能被引用，全局有效

• 局部作用域:局部名称空间，只能在局部范围内生效。

globals和locals方法

print(globals())
print(locals())
def func():
    a = 12
    b = 20
    print(globals())
    print(locals())
func()

global关键字

• 声明一个全局变量
• 在局部作用域想要对全局作用域的全局变量进行修改时，需要用到global(限于字符串，数字)
• 对可变数据类型（list，dict，set）可以直接引用不用通过global

def func():
    global a
    a=3
func()
print(a)

count=1
def search():
    global count
    count=2
search()
print(count)

li=[1,2,3,4]
dic={"name":"salted"}
def fun():
    li.append(5)
    dic["age"] = 18
    print(dic)
    print(li)
fun()
print(li)
print(dic)

nonlocal

• 不能修改全局变量
• 在局部作用域中，对父级作用域(或者更外层非全局作用域)的变量进行引用和修改，并且引用的那层，从那层及以下此变量全部发生改变

def fun():
    b = 1
    def do_global():
        b=10
        print(b)
        def d_nonlocal():
            nonlocal b #引用了上一层的变量b
            b = b+ 20
            print(b) #b发生了改变
        d_nonlocal() #调用函数，导致do_global的命名空间b也改变了
        print(b)
    do_global()
    print(b)
fun() #最上面一层没有变化

函数的嵌套和作用域链

def mymax(x,y):
    m = x if x > y else y
    return m
def maxx(a,b,c,d):
    res1 = mymax(a,b) #值为453
    res2 = mymax(res1,c) #值为453
    res3 = mymax(res2,d) #值为453
    return res3
ret = maxx(23,453,12,-13)
print(ret)

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

函数名的本质

• 函数名的本质就是函数的内存地址
  1.可以被引用

def func():
    print('in func')
f = func
print(f)
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]()
d['f2']()

3.可以当作函数的参数和返回值

def f1():
    print('f1')
def func(argv):
    argv()
    return argv
f = func(f1)
f()

闭包

• 内部函数包含对外部作用域而非全剧作用域变量的引用，该内部函数称为闭包函数

def func():
    name = 'aaron'
    def inner():
        print(name)
    return inner
f = func()
f()

判断闭包函数的方法closure

def func():
    name = 'aaron'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner
f = func()
f()
#最后运行结果里面有cell就是闭包

name = "arron"
def func():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner
f = func()
f()
# 输出结果为None，说明不是闭包

案例

def wrapper():
    money = 1000
    def func():
        name = "apple"
        def inner():
            print(name, money)
        print(inner.__closure__)
        return inner
    return func

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

def func(a, b):
    def inner(x):
        return a*x + b
    return inner

func1 = func(2, 3)
print(func1(2))

from urllib.request import urlopen
def func():
    content = urlopen('http://myip.ipip.net').read()
    def get_content():
        return content
    return get_content
code = func()
content1 = code()
print(content1.decode('utf-8'))

content2 = code()
print(content2.decode('utf-8'))