函数复习模糊问题

# 1.一旦遇到return 结束整个函数
def demo():
    print(1111)
    return
    print(222)
ret = demo()
ret
# 如果函数有返回值，还应该定义“变量”接收返回值


# 2.--------多个值接收返回值
def demo2():
    return 1,[1,2],3,4
# print(demo2())
# a,b,c,d= demo2()
# print(a,b,c,d)

# 3.-------
a,b ={'name':'haiyan','age':18}
# print(a,b)

# 4.----按照关键字传参
# 站在实参的角度上
def mymax(x,y):
    the_max = x if x>y else y
    return  the_max
# print(mymax(x=10,y=20))
# print(mymax(10,y=20))  #位置参数必须放在关键字参数的前面

# 站在形参的角度上：位置参数必须传参

# 5.---------默认参数
# 用默认参数的目的：将变化小的值设置成默认参数
# 比如一个班就那么几个女生，大多数都是男生，这样就可以
# 设置成默认参数

# 6.------动态参数
# 按位置传参，多余的参数都由args统一接收，保存成一个元组的形式
def func(*args,**kwargs):
    print(args,kwargs)
    print(args[0])
    print(kwargs['a'],kwargs['b'])
func([1,2,3],a=3,b=4)

# 传参数需要注意的：
# 参数有很多种，如果涉及到多种参数的定义，
# 应遵循位置参数，*args,默认参数，**kwargs顺序定义
def 函数名(参数1,参数2,位置参数,*args,默认参数,**kwargs):
    '''注释：函数功能和参数说明'''
    '函数体'
    return '返回值'

# 7.----命名空间--------
# 命名空间的本质：存放名字与值得绑定关系
# 命名空间一般分为三种：
#     1.全局命名空间：代码在运行时，创建的存储'变量名与值得关系'的空间
#     2.局部命名空间：在函数的运行中开辟的临时的空间
#     3.内置命名空间：内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...
#                  它们都是我们熟悉的，拿过来就可以用的方法
# 三种命名空间之间的加载与取值顺序：
# 1.加载顺序：内置命名空间（程序运行前加载）-->全局命名空间(程序运行中：从上到下加载)-->局部命名空间（程序运行中:调用时才加载）
# 2.取值顺序：
#     在全局调用：全局命名空间-->内置命名空间
#     在局部调用：局部命名空间-->全局命名空间-->内置命名空间

# 8.-------作用域
# 作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。
# 全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
# 局部作用域：局部名称空间，只能在局部范围内生效
x = 1
def f(x):
    print(x)
f(10)
print(x)

# 9.--------函数嵌套
def anmial():
    def inner():
        return 'hello'
    ret = inner()  #谁调用就给谁返回值
    print(ret)
anmial()

# 10-------函数的作用域链
x= 1
def heihei():
    x=2
    def inner():
        # x=3
        def inner2():
            # x = 4
            print(x)
        inner2()
    inner()
heihei()

# 11.----------函数名可以作为参数
def func1():
    print('func1')
def func2(f):
    print('==========')
    f()
func2(func1)
func1()

# 12.-----------函数名还可以做返回值
def func():
    def func3():
        print('heelo')
    return func3
ret = func()
ret()

# 13.----------闭包
# 闭包：1.闭：内部的函数
#       2.包：包含了对外部函数作用域中的变量的引用
def func():
    x= 10
    def inner():
        print(x)
    print(inner.__closure__) #判断是不是闭包函数的方法
    return inner
func()()
# 闭包函数的应用
from urllib.request import urlopen
def index(url):
    def inner():
        return urlopen(url).read()
    print(inner.__closure__)  #也是一个闭包函数
    return inner
ret=index('http://www.baidu.com')
print(ret())

# 14------装饰器
# 装饰器的功能：再不修改原函数及其调用方式的情况下对原函数的扩展
# 装饰器的本质：就是一个闭包函数
def func(func):
    def inner(*args,**kwargs):
        print('before')
        ret = func(*args,**kwargs)
        print('after')
        return ret
    return inner
@func
def aaa():
    print('aaaaaaaaaa')
aaa()

# 15.-------开放封闭原则
# 对扩展是开放的
# 对修改是封闭的

# 16.多个装饰器装饰一个函数
def qqqxing(fun):
    def inner(*args,**kwargs):
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')
        return ret
    return inner
def pipixia(fun):
    def inner(*args,**kwargs):
        print('in pipixia: before')
        ret = fun(*args,**kwargs)
        print('in pipixia: after')
        return ret
    return inner
@qqqxing
@pipixia
def dapangxie():
    print('饿了吗')
dapangxie()
# 插入一个内置函数
# print(callable(dapangxie))  #如果是可调
# # 用的对象就返回True，否则就返回False
# print(chr(98))#主要用来表示ascii码对应的字符


# ------用类缓存网页
from urllib.request import urlopen
class Web_page:
    def __init__(self,url):
        self.url = url
        self.__content = None
    @property
    def get_url(self):
        if self.__content:
            return self.__content
        else:
            self.__content =urlopen(self.url).read()
            return self.__content
mypage = Web_page('http://www.baidu.com')
print(mypage.get_url)
print(mypage.get_url)
print(mypage.get_url)

# ----------shelve
import shelve
f = shelve.open('a')
f['key'] = {'a':1,'b':2}
print(f['key'],type(f['key']))