Python day8

#三元运算
# a = 20
# b = 10
# if a > b:
#     c = 5
# else:
#     c = 10

#if条件成立的结果 if 条件 else else条件成立的结果
# a = 20
# b = 10
# c = 5 if a>b else 10
# print(c)

#命名空间
#局部命名空间
#全局命名空间
#内置命名空间
def my_max(a,b):
    c = a if a > b else b
    return c

m = my_max(5,8)

#加载顺序  硬盘上——内存里
#内置-->全局(从上到下顺序加载进来的)-->局部（调用的时候加载）

a = 5
b = 8
def my_max():
    c = a if a > b else b
    return c

# m = my_max()
# print(m)

#作用域
#命名空间+作用域是分不开的
#两种
#全局作用域：全局命名空间、内置命名空间
#局部作用域：局部命名空间
def func():
    return max(1,2,3)
# print(func())

def max(a,b,c):
    return 2
# print(max(1,2,3))

#站在全局看：
#使用名字:
# 如果全局有：用全局的
# 如果全局没有：用内置的

#为什么要有作用域的概念：
#为了函数内的变量不会影响到全局
# def max():
#     a = 10
#     b = 20
#
# a = 2
# b = 3
# my_max(30,50)
#函数的嵌套调用
def f1():
    print('f1')

def f2():
    a = 10
    f1()

#函数的嵌套
#为了保护内部函数，确定内部函数只能在外部函数中被调用
def animal():
    def tiger():
        print('bark')
    print('eat')
    tiger()
# animal()

#函数名的本质
def func():
    print('func')
print(func)
# print(func)
# f = func
# print(f)
# f()
#
# l = [f]
# print(l)
# #l[0] == f
# l[0]()

#可以用作函数的参数
def func():
    print('func')

def func2(f):
    print(f)
    f()
    print('func2')

# func2(func)

#可以作为函数的返回值
def func():
    print('func')

def func2(f):
    print('func2')
    return f

fu = func2(func)
# print(fu)
# fu() #==>func()
# print(fu)
# print(func)
#如果我想在全局使用内部的函数


def func():
    print('func')

# print(func)
# f = func
# l = [f]
# f1 = l[0] #== f
# print(f1)
# print(f)
# print(func)
# func()
# f()
#f1()
#函数名做参数
# def func():
#     print('func')
# def func2(f):
#     f()
# func2(func)

#函数的名字可以做返回值
def func():
    def func2():
        print('hello')
    return func2

# f2 = func()
# f2()
# f = func

def heiheihei():
    ha = 10
    heng = 20
    def inner():
        print(ha)
        print(heng)
    inner()

# heiheihei()

#作用域：
#小范围的可以用大范围的
#但是大范围的不能用小范围的
#范围从大到小（图）
#在小范围内，如果要用一个变量，是当前这个小范围有的，就用自己的
#如果在小范围内没有，就用上一级的，上一级没有就用上上一级的，以此类推。
#如果都没有，报错

#作用域链
x = 1
def heihei():
    # x = 'h'
    def inner1():
        # x = 'i1'
        def inner2():
            print(x)
        inner2()
    inner1()

# heihei()

#闭包函数：内部函数，包含了对外部作用域中变量的引用
def hei():
    x = 20
    def inner():
        '''
        闭包函数
        '''
        print(x)


#闭包
#1.闭 内部的函数
#2.包 包含了对外部函数作用域中变量的引用

#闭包的常用形式
def hei():
    x = 20
    def inner():
        print(x)  #局部的
    return inner

# i = hei()
# i()  #全局

from urllib.request import urlopen
# def index():
#     url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
#     return urlopen(url).read()
# index()

def index():
    url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
    def inner():
        return urlopen(url).read()
    print(inner.__closure__)
    return inner
# u = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
get = index()
print(get())


#作用域：
#小范围的可以用大范围的
#但是大范围的不能用小范围的
#范围从大到小（图）
#在小范围内，如果要用一个变量，是当前这个小范围有的，就用自己的
#如果在小范围内没有，就用上一级的，上一级没有就用上上一级的，以此类推。
#如果都没有，报错
a = 20
b = 50
def haha():
    x = 1
    y = 2
    print(globals())  #全局作用域中的名字
    print(locals())   #局部作用域中的名字

# haha()
# print(globals())  #全局作用域中的名字
# print(locals())   #全局的局部还是全局


a = 10
def heiheihei():
    global a
    a = 20

# heiheihei()
# print(a)
def f():
    a = 3
    def f1():
        a = 1
        def f2():
            nonlocal a
            # 1.外部必须有这个变量
            # 2.在内部函数声明nonlocal变量之前不能再出现同名变量
            # 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

            a = 2
        f2()
        print('a in f1 : ', a)
    f1()
    print('a in f : ',a)

f()
# def f1(a):
#     print(a)
#     def f():
#         print(11111)
#         a = 2
# f1(None)

def f():
    a = 3
    def f1():
        a = 1
        def f2():
            nonlocal a
            a = 2
        f2()
        print('a in f1 : ', a)
    f1()
    print('a in f : ',a)

f()
print(1)