#range()函数，区间
range(1,11) #1..10，不包括11
range(11) #0..10，不包括11
range(1,15,5) # 1,6,11,间隔5，不包括15

# 定义一个打印三角形的函数，有默认值的参数必须放在后面
def printTriangle(char, height = 5) :
    for i in range(1, height + 1) :
        # 先打印一排空格
        for j in range(height - i) :
            print(' ', end = '')
        # 再打印一排特殊字符
        for j in range(2 * i - 1) :
            print(char, end = '')
        print()
printTriangle('@', 6)
printTriangle('#', height=7)
printTriangle('*')

#局部变量 全局变量   global声明：我访问一个全局变量
def text():
    global demo
    demo = "C语言中文网"
    print("函数体内访问：",demo)
text()
print('函数体外访问：',demo)

def test ():
    age = 20    # 定义一个局部变量
    print(age)  # 输出age
    print(locals())    # {'age': 20} 访问函数局部范围的“变量字典”
    print(locals()['age'])  # 通过函数局部范围的“变量字典”访问age变量
    locals()['age'] = 12    # 通过locals函数局部范围的“变量字典”改变age变量的值
    print('xxx', age)       # 再次访问age变量的值，依然输出20
    globals()['x'] = 19     # 通过globals函数修改x全局变量
x = 5
y = 20
print(globals()) # {..., 'x': 5, 'y': 20}
print(locals())  # {..., 'x': 5, 'y': 20}在全局访问内使用locals函数，访问的是全局变量的“变量字典”
print(x)         # 5
print(globals()['x']) # 5
globals()['x'] = 39  # 通过全局变量的“变量数组”对x全局变量赋值
print(x) # 输出39，修改成功
locals()['x'] = 99 # 在全局范围内使用locals函数对x全局变量赋值
print(x) # 输出99，修改成功
test()
print("调用函数后，x的值在函数中被globals修改",x) # 调用函数后，查看x的值

#局部函数，nonlocal声明：我访问局部函数调用外层函数内的局部变量
def foo ():
    # 局部变量name
    name = 'Charlie'
    def bar ():
        nonlocal name  # 访问bar函数所在的foo函数的name局部变量
        print(name)    # Charlie
        name = '孙悟空'
    bar()
    print(name)  # 孙悟空
foo()

def foo ():
    # 局部变量name
    name = 'Charlie'
    def bar ():
        name = '孙悟空 ' # 在局部函数中重新定义一个局部变量,该变量在局部函数结束时释放，不影响外层的局部变量和全局变量
        print(name)      # 孙悟空
    bar()
    print(name)  # Charlie
foo()

#闭包 函数返回值是一个函数
#闭包函数，其中 exponent 称为*变量
def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方
print(square(2))  # 计算 2 的平方
print(cube(2)) # 计算 2 的立方
print(square.__closure__) #闭包函数 square、cube 比普通函数多一个属性，记录*变量的地址，此处*变量为exponent


#lambda表达式简化局部函数
# 局部函数
def get_math_func(type) :
    '''
    定义三个局部函数
    定义三个局部函数
    定义三个局部函数
    '''
    if type == "square" :
        return square
    if type == "cube" :
        return cube
    else:
        return factorial
#lambda表达式，lambda关键字定义lambda表达式，单行表达式，返回和定义一起写，等于返回一个单行的函数
def get_math_func(type) :
    result=1
    if type == 'square':
        return lambda n: n * n  # ①             # 该函数返回的是Lambda表达式
    elif type == 'cube':
        return lambda n: n * n * n  # ②         # 该函数返回的是Lambda表达式
    else:
        return lambda n: (1 + n) * n / 2 # ③    # 该函数返回的是Lambda表达式
# 调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube")
print(math_func(5)) # 输出125
math_func = get_math_func("square")
print(math_func(5)) # 输出25
math_func = get_math_func("other")
print(math_func(5)) # 输出15.0
#map结合,map返回迭代器，需要用list(x)转换，或者用print([i for i in x])
x = map(lambda x: x*x , range(8)) # 传入计算平方的lambda表达式作为function参数
# print(list(x))
print([e for e in x]) # [0, 1, 4, 9, 16, 25, 36, 49]
y = map(lambda x: x*x if x % 2 == 0 else 0, range(8)) # 传入计算平方的lambda表达式作为参数
print([e for e in y]) # [0, 0, 4, 0, 16, 0, 36, 0]
print(y)

#exec()在某个作用域中执行，无返回
#eval()在某个作用域中执行，有返回值
a=10
b=20
c=30
g={'a':6, 'b':8} #定义一个字典
t={'b':100, 'c':10} #定义一个字典
print(eval('a+b+c', g, t)) # 116 6+100+10
print(type(eval('a+b+c', g, t)))