DAY10 Python基础：function 2018-06-23

01-parameter of function 函数变量

02-anonymous function 匿名函数

03-recursive function 递归函数

04-function call procedure 函数的调用过程

05-use module management function 使用模块管理函数

---

01-parameter of function 函数变量

def 函数名(参数列表)：
    函数体

我们在声明函数的时候，其实就是在声明一个函数类型（function）的变量
普通变量能做的事情，函数变量都能做

1.1.函数名就是函数类型变量(类型名：function)，存的是函数入口的地址

def func1():
    print('aaa')

print(type(func1))  # 

num = 10
print(type(num))    # 

1.2.可以用一个变量给另外一个变量赋值

a = func1() # 这样赋值，是将函数func1的返回值赋给a
a = func1 # 将函数变量func1赋给a，a就会变成一个函数
a() # 现在就可以用函数变量a，去调用函数func1()

print('--',a)   # value：--  输出该变量的地址
print('==',a())     #value:None 输出的是表达式的值

def func2(num):
    return num*2

b = func2
print(func2(7))
print(b(20))

3.3.函数变量作为函数的参数

def calculate(num1,num2,fn):
    # 如果num1不是int或者float数字
    if not (isinstance(num1,int) or isinstance(num1,float)):
        print('num1不是数据')
        return None #在这儿让函数结束
    if not (isinstance(num2,int) or isinstance(num2,float)):
        print('num2不是数据')
        return None #在这儿让函数结束
    return fn(num1,num2) #return func_add(10,20)  return 30

def func_add(m,n):
    return m + n
def func_subtract(m,n):
    return m - n

result = calculate('a',20,func_add)
print(result)

1.4.函数作为返回值

写一个函数，func3('+')-->返回求和的功能；func3('*')-->返回求乘积的功能

python中，是可以在函数中声明函数

def func(char):
    if char == '+':
        def fn(*nums):
            sum1 = 0
            for x in nums:
                sum1 += x
            return sum1
        return fn
    if char == '*':
        def fn1(*nums):
            sum1 = 1
            for x in nums:
                sum1 *= x
            return sum1
        return fn1

result = func('+') #result是一个求和功能函数的函数变量,包含函数的地址
print(result) # value:.fn at 0x01E0B810>
print('4.====',result(1, 3, 4))

result2 = func('*')(10, 20) #result2 是一个值 200
print(result2)

列表作为返回(对象变量作为返回值)

def func4():
    list1 = [1, 2, 3]
    return list1

result = func4()
print(result)

print(func4()[0])

02-anonymous function 匿名函数

python中使用lambda关键字来声明一个匿名函数

格式：
lambda 参数列表：返回值
参数列表:多个参数之间用逗号隔开

作用：快速的实现简单的函数功能

使用函数实现求两个数的和

def func1(num1, num2):
    return num1 + num2
print(func1(10, 20))

使用匿名函数实现求两个数的和

func2 = lambda num1, num2 :num1 + num2
print(func2(10, 25))


func3 = lambda list1, index1, index2 : list1[index1] +list1[index2]
list1 = [1, 2, 3, 4]
print(func3(list1, 1, 3))

使用指定的功能去计算num1和num2

def calculate(num1,num2,fn):
    return fn(num1,num2)

sum1 = calculate(10, 20, lambda a, b: a+b)
print(sum1)

03-recursive function 递归函数

1.递归函数：在函数里调用函数本身

# 这儿的func1就是一个递归函数
def func1()
    print('aaa')
    func1()

func1()

2.递归作用：理论上循环能够做到的事情递归都可以做（但实际除非是非用不可的情况，一般不用递归）

3.步骤：
递归函数：f(n)
a.确定临界值（结束函数的时刻）
b.假设函数的功能已经实现，然后找到f(n)和f(n-1)关系
c.使用f(n-1)与f(n)的关系去实现f(n)的功能

计算1+2+3+4
方法1.使用循环

def func1(n):
    sum1 = 0
    for x in range(1, n+1):
        sum1 += x
    return sum1
print(func1(100))

方法2：使用递归函数

def func2(n):
    # 1.确定临界值
    if n == 1:
        return 1
    # 2.假设func2功能实现了，遭到func2(n-1),func2(n)的关系
    # func2(n) = func2(n-1) + n
    # 3.通过func2(n-1) 去实现func2(n)的功能
    return func2(n-1) + n
print(func2(100))

用递归实现：246。。。n(n是偶数)

def func3(n):
    if n % 2 != 0:
        return '%d不是偶数'%(n)
    if n == 2:
        return 2
    return func3(n-2)*n
print(func3(9))

递归函数里的语句是按顺序执行的，注意顺序对结果的影响

n = 5
*****
****
***
**
*

'''
def func4(n):
    if n == 1:
        return print('*')
    print('*'*n)
    func4(n-1)
func4(5)


'''
*
**
***
****
*****
'''

def print_star(n):
    if n == 1:
        print('*')
        return

    print_star(n-1)
    print('*'*n)
print_star(5)

使用递归打印：

n = 3
的时候


    @
  @ @ @
@ @ @ @ @


n = 4
的时候:


      @
    @ @ @
  @ @ @ @ @
@ @ @ @ @ @ @ 

'''
# method 1
def func3(n):
    a = n
    def func4(n):
        if n == 1:
            print(' '*(a-1)+'@')
            return

        func4(n-1)
        print(' '*(a-n)+'@'*(2*n-1))
    func4(n)
    return a

func3(4)

#method 2
def func5(m, n):
    if n == 1:
        print(' ' * (m - 1) + '@')
        return

    func5(m,n - 1)
    print(' ' * (m - n) + '@' * (2 * n - 1))

func5(4, 4)

04-function call procedure 函数的调用过程

函数调用的过程是一个压栈的过程：

a.函数调用的时候，首先会在栈中开辟一块内存空间，用来保存
函数调用过程中产生的数据（包括函数的参数和在函数中声明的变量）
b.当函数执行完成后，被调用函数对应的内存空间会被回收(释放)

栈Frames：是内存中的一块特殊的区域。数字和字符串的值是存在栈里面的

堆Objects：对象是存在堆里面的

总结：递归要慎用！（能用循环做的，就不要用递归。递归消耗内存也消耗CPU资源）

05-use module management function 使用模块管理函数

模块就是指一个.py文件（一个.py文件就是一个模块）;可以在一个模块中使用其他模块的函数和类

怎么使用其他模块中的函数
1.通过import关键字导入模块，然后通过“模块名.函数”的方法去使用模块中的函数
注意：当我们导入其他的模块的时候，会将其他模块中的所有的内容都会导入到当前文件中,通过__name__来解决
2.通过from-import直接导入指定的函数。导入后就可以直接调用函数
格式：
from 模块名 import 函数名
3.通过 as关键字给导入模块或者函数重命名

关于__name__属性：
__name__是每个模块都有的属性，作用是用来存储模块的名字。
当模块不是正在执行的模块，__name__属性的值是模块对应的文件的文件名；
当模块正在执行的时候，__name__的值就是一个固定值'__main__'

print('05', __name__)

5.1通过 import 模块名

# 导入qf_math模块
# import qf_math
# result = qf_math.sum(1, 3, 5)
# print(result)
# print('05')

5.2form 模块名 import 函数名

# result = sum(12, 2)
# print(result)

5.3通过as给模块重新命名

import qf_math as my_math

重命名后可以使用新的模块名去调用函数

print(my_math.sum(1, 3, 6))

重命名后使用新的函数名调用函数

from qf_math import sum as my_sum
print(my_sum(21, 4))

以下是模块：qf_math.py

def sum(*nums):
    sum1 = 0
    print('----')
    for x in nums:
        sum1 += x
    return sum1
# 判断模块的内置属性__name__的值是否是'__main__',
# 将不需要被其他模块导入的代码写到这个if语句中,
if __name__ == '__main__':

    print('aaaa')
    print(sum(10, 20))
    a = 10
print(__name__)