函数定义

---恢复内容开始---

def 函数名称（）：

    函数体

    return 返回值

函数名称（） //调用函数

colse  释放内存

 

返回值：

一：无返回值

def ru_nane():
    return 3
ru_nane()

 

  里面有return 但是没有返回值。

2.单个返回值，多个返回值

def ru_nane():
    return 3
print(ru_nane())

 

  1. 直接打印，只是打印的时候会显示return里面的返回值，

 

def ru_nane():
    return 3
v=ru_nane()
print(v)

 2. 这样才是实际有返回值，因为要有一个参数去接收函数的返回值，

 

def ru_nane():
    return 3,4,5
v=ru_nane()
print(v)

 

3.这样是返回多个返回值，可以用一个参数去接收，返回的是一个元祖

二：参数

    1.形参

     就是定义函数的时候括号里面的穿的参数，形参就是相当于没有实际的参数，软件没有实际给出内存来存储的参数

    2.实参

     就是实际传的参数，在内存中实际有的

 

   例子：

def ru_nan(a, b):  ---形参
    return a+b
v = ru_nan(2, 3)  ----实参
print(v)

 

二：函数命名空间和作用域

      命名空间：

      1)内置命名空间：-----python解释器

      #就是python一启动的时候就可以使用的名字储存在内置空间

      #内置的名字在启动解释器的时候被加载到内存

      2) 全局命名空间-------自己写的代码。不是函数中的代码

      #程序依次向下执行的时候被执行的过程储存在内存中

      #放置的是我们定义的函数和变量

      局部命名空间：---------函数

      #就是定义函数内部的名字

      #当调用这个函数的时候被加载到内存，函数执行结束后，内存也随之消失

     #在局部:可以使用全局、内置命名空间中的名字

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

 

   作用域

  作用域两种

# 全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域 ——globals()

a = 1
def funck()
   globals a
    a +=1
funck()
print(a)

# 局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——locals()

a = 1
 b = 2
 def func():
     x = 'aaa'
     y = 'bbb'
     print(locals())
    print(globals())

 func()
 print(globals())
 print(locals()) #本地的

#globals 永远打印全局的名字
#locals 输出什么 根据locals所在的位置

 

三：函数的嵌套和作用域链

   函数嵌套 

def 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))

#函数的嵌套定义
#内部函数可以使用外部函数的变量

a = 1
def outer():
    a = 1
   def inner():
         a = 2
         def inner2():
           nonlocal a  #声明了一个上面第一层局部变量
           a += 1   #不可变数据类型的修改
          inner2()
        print('##a## : ', a)
    inner()
     print('**a** : ',a)

outer()
print('全局 ：',a)

#nonlocal 只能用于局部变量 找上层中离当前函数最近一层的局部变量
#声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量
# 对全局无效
# 对局部 也只是对 最近的 一层 有影响

 def func():
     print(123)

  func()  #函数名就是内存地址
 func2 = func  #函数名可以赋值
 func2()

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

def func():
    print(123)

def wahaha(f):
    f()
    return f           #函数名可以作为函数的返回值

qqxing = wahaha(func)   # 函数名可以作为函数的参数
qqxing()

 

四：闭包

 闭包：嵌套函数，内部函数调用外部函数的变量

 

# def outer():
#     a = 1
#     def inner():
#         print(a) 调用了a
#     inner()
# outer()

 

 

def outer():
    a = 1
    def inner():
        print(a)
    return inner 因为函数也可以作为返回值
inn = outer() 那么用inn来接受inner的地址，所有后面可以每次去调用这个返回值
inn()

 

 

# import urllib  #模块
from urllib.request import urlopen  ----------专门调用网址的一个文件包
# ret = urlopen('http://www.xiaohua100.cn/index.html').read()
# print(ret)
# def get_url():
#     url = 'http://www.xiaohua100.cn/index.html'
#     ret = urlopen(url).read()
#     print(ret)
#
# get_url()

def get_url():
    url = 'http://www.xiaohua100.cn/index.html'
    def get():
        ret = urlopen(url).read()
        print(ret)
    return get

get_func = get_url()
get_func()

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

---恢复内容结束---