function_day1

#--------------------1不同导入的区别----------------

# [当从某个文件夹或文件导入所有方法或类或变量，这时可以直接调用文件里面的所有对象]
from time import *
time()\locatime()

# [当仅仅是导入某个文件，这时候并不知道文件里面有什么对象，需要通过文件.对象，来调用对象]
import time
time.time()

#[遍历字典]
for i in kw:

　　print(i，end='')  # 输出字典所有键，有点不明白？

#--------------------2传参顺序的规则----------------------

def add(*ages, **kw):

　　add(1, 2, 3, va1=23, va2='234'）
　　#1、2、3等未命名参数给ages,va1\2,命名参数给kw

# 参数在有顺序的前提条件下（python参数规则-位置参数-默认参数-可变参数-关键字参数）
# 加了*号的变量参数会存放所有未命名的参数，加了**的参数变量，会存放所有命名的参数，即关键字参数

#--------------------3传参顺序注意----------------------

def max(a='23', *agg, **kw):
    print(a,agg,kw)

max('click', 234234,2,3,4, b=2)

#按照默认顺序，第一个传参给了默认参数a,后面的所有未命名参数给了元组agg
#当遇到命名参数时直接传给关键字参数kw

def max1(*agg,a=100, **kw):
    print(agg,a,kw)

max1('click1', 5,2,3,4, b=2)

#按照默认顺序对应，前面的未命名参数传给了元组,a默认为100
#当遇到命名参数，直接传给关键字参数变量kw

------------直接返回值可变参数、关键字参数的的小技巧-----------

def function_e(*age):
    return age
print('age:',function_e(*[1,2,3]))  #想要函数直接返回元组，不需要切换


def function_f(**kw):
    return kw
print('kw:',function_f(**{'a':4,'b':5}))   #想要函数直接返回字典，不需要切换

[-------------4学习方法 ------------]
# 对象为何产生，怎么使用，有何作用
# 如 函数的return ,为了被其他对象调用的产生背景
# 使用：函数结束的地方写return
# 作用： 一个是结束函数的运行，二个是返回函数产生的结果,return多个结果以元组返回，因为函数默认传多个值是元组类型
def fun2(va):
    print(va)
    return va,va,None
s=fun2(2)
print(s)

'''-------------5  LEGB（local-encloser-gloabl-Built）规则作用域 
搜索variable的顺序：从局部》嵌套局部》当前模块的全部》python内置的作用域------------'''

x=int(3.9)  # 最外层作用域 built
x=1             # 全局作用域 global
def outer():    #
    x=2         # 嵌套局部作用域  encloser
    def inner():
        # x=3         # 局部本地作用域   local
        print(x)
    inner()
outer()

'''--------------5.1作用域的变量使用和修改-------------'''
variable_a = 1
def functiion_a():
    '''
    作用域修改
    在局部内加 global  局部改嵌套用nonlocal
    局部作用域变量能引用全局的变量，但是不能修改（后面在介绍如何才能修改）
    对于一个变量，内部作用域先声明就会覆盖外部的，不声明就直接使用外部的

    :return:
    '''

    # variable_a = 5  # 在这之前，并没有引用全局的va_a，局部作用域第一次va_a赋值，这里的va_a域外面的va_a其实是两个不同的变量值，
    print(variable_a)   # 应用局部的va_a的值

    # print(variable_a) # 第一次应用全局的va_a
    # 当在局部作用域引用了全局vari_a后，局部就认定这个va_a=1，后续都不能对va_a进行修改,如下例子都是错误的

    # 例子1
    # print(variable_a)  # 这里认定va_a=1,但是下面va_a=5,重新修改了va_a的值，错误
    # variable_a=5

    # 例子2
    # variable_a+=1       # va_a=va_a+1  这里右边的va_a已经应用了全局的va_a=1,左边有对其赋值修改va_a，错误
    def function_ab():
        # variable_a=6
        print(variable_a)
    function_ab()

functiion_a()
print('\n-------------------------------')

variable_b=2
def function_b():
    # global variable_b   # 加上后，变量可以修改赋值
    # print(variable_b)
    variable_b=5
    print(variable_b)
    def function_b2():
        nonlocal variable_b    # 加上后，变量可以修改赋值
        print(variable_b)
        variable_b=6
        print(variable_b)
    function_b2()
function_b()
print(variable_b)

# -----------------高阶函数---------------

# 1：函数内有嵌套函数  2：函数作为函数入参，3：函数内部调用函数本身（递归函数）

# 复习下，存放内存值时的指针指向问题
# 函数即变量，变量即对象，
# def foo3():
#     def inner():
#         return 4
#     return inner
# ret = foo3()
# print(ret)  # 执行了return inner 输出inner函数的名字和内存地址
# print(ret())    # 相当于执行了return inner()  输出4

def f():
    # print(3)
    return 3
def function_sa(f):
    f_rezalt=f()+f()
    def x():
        return 8
    return f_rezalt,function_sa,x(),x
    # return x
    # print(function_sa(f)())
print(function_sa(f))

 #下面是一个报错例子

# def function_a(x):
#     if x>1:
#         def inneer():
#             return inneer(),1
#     else:
#         def inner2():
#             return inner2()
#          # inner（）相对域return 是局部变量，外层无法应用局部变量,
# print(function_a(2))
# error: local a not de......# 报错，因为作用域
# print('\n-------------------------------')

# 递归函数

def function_b(x):
    '''
    计算一个数的阶层例子，普通计算方式
    :return:
    '''
    for i in range(1,x):
        x=x*i   # 从x乘到1，因为5*1,5已经用过了，所有最后x取的是4的值
    return x

def function_c(x):
    '''
    递归函数特点:1 自己调用自己，2 要有结束条件（否则无限递归下去）
    利用递归来优化上面的function_b()计算阶层的方法
    :return:
    '''
    # 5*4*3*2*function_c(1)   # 当x=1时，我们要停下来，不然会一直递归下去，我们这里返回一个1
    if x==1:
        return 1
    return x*function_c(x-1)
print(function_c(5))