# 定义函数
def say_hei():
    print('hello world!!')

# 函数调用
say_hei()

def func(*args):
    print (args)

# 执行方式一
func(11,33,4,4454,5)

# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)

def func(**kwargs):

    print (args)


# 执行方式一
func(name＝'zhangsan',age=18)

# 执行方式二
li = {'name':'zhangsan', age:18, 'gender':'male'}
func(**li)

def func(*args, **kwargs):

    print(args)
    print(kwargs)

函数即“变量”，“变量”必须先定义后引用。未定义而直接引用函数，就相当于在引用一个不存在的变量名
#测试一
def test():
    print('from test')
    func()
test() #报错

#测试二
def func():
    print('from func')
def test():
    print('from test')
    func()
test() #正常

#测试三
def test():
    print('from test')
    func()
    
def func():
    print('from func')
test() #会报错吗?


#结论:函数的使用,必须遵循原则:先定义,后调用
#我们在使用函数时,一定要明确地区分定义阶段和调用阶段

#定义阶段
def test():
    print('from test')
    func()
def func():
    print('from func')
#调用阶段
test()

  def testB():
        print('---- testB start----')
        print('这里是testB函数执行的代码...(省略)...')
        print('---- testB end----')


    def testA():

        print('---- testA start----')

        testB()

        print('---- testA end----')

    testA()

  ---- testA start----
    ---- testB start----
    这里是testB函数执行的代码...(省略)...
    ---- testB end----
    ---- testA end----

# 求3个数的和
def sum3Number(a,b,c):
    return a+b+c # return 的后面可以是数值，也可是一个表达式

# 完成对3个数求平均值
def average3Number(a,b,c):

    # 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可
    # 即把接收到的3个数，当做实参传递即可
    sumResult = sum3Number(a,b,c)
    aveResult = sumResult/3.0
    return aveResult

# 调用函数，完成对3个数求平均值
result = average3Number(11,2,55)
print("average is %d"%result)

    # 定义全局变量
    a = 100

    def test1():
        print(a)

    def test2():
        print(a)

    # 调用函数
    test1()
    test2()

>>> a = 1
>>> def f():
...     a += 1
...     print a
...
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f
UnboundLocalError: local variable 'a' referenced before assignment
>>>
>>>
>>> li = [1,]
>>> def f2():
...     li.append(1)
...     print li
...
>>> f2()
[1, 1]
>>> li
[1, 1]

1! = 1
2! = 2 × 1 = 2 × 1!
3! = 3 × 2 × 1 = 3 × 2!
4! = 4 × 3 × 2 × 1 = 4 × 3!
...
n! = n × (n-1)!

 lambda [arg1 [,arg2,.....argn]]:expression

    sum = lambda arg1, arg2: arg1 + arg2

    #调用sum函数
    print ("Value of total : ", sum( 10, 20 ))
    print ("Value of total : ", sum( 20, 20 ))

# 匿名函数 关键字：lambda
l = lambda x: x + 1
print(l(5))
print("=================== map函数==============")
jia = lambda x: x + 1;
jian = lambda x: x - 1
chen = lambda x: x * 1
chu = lambda x: x / 1


def map_text(func, array):
    arr1 = []
    for i in array:
        f = func(i)
        arr1.append(f)
    return arr1


arr = [1, 2, 3, 4, 5]
new_array = map_text(lambda x: x - 1, arr)
print(new_array)
print("=================== filter函数==============")


def filter_text(func, array):
    new_array = []
    for i in array:
        if func(i):
            new_array.append(i)
    return new_array


str_array = ['zhangsan_sb', 'lisi_sb', 'wanger', 'mazi']
s = filter_text(lambda x: x.endswith('sb'), str_array)
print(s)
print("=================== reduce函数==============")


def reduce_text(func, array, init=None):
    if init is None:
        sum = array.pop(0)
    else:
        sum = init
    for i in array:
        sum = func(sum, i)
    return sum


int_array = [1, 2, 3, 4, 5, 6, 7, 8, 9]
su = reduce_text(lambda x, y: x + y, int_array)
print(su)

#内部函数包含对外部作用域而非全局作用域的引用

#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇

        def counter():
            n=0
            def incr():
                nonlocal n
                x=n
                n+=1
                return x
            return incr

        c=counter()
        print(c())
        print(c())
        print(c())
        print(c.__closure__[0].cell_contents) #查看闭包的元素

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们是包起来）
    from urllib.request import urlopen

    def index(url):
        def get():
            return urlopen(url).read()
        return get

    baidu=index('http://www.baidu.com')
    print(baidu().decode('utf-8'))