一、recode

1.函数就是对实现某一特定的功能的代码块的封装
2.函数声明

def 函数名(形参列表）
    函数的说明文档
    函数体

3.函数的函数体只有在调用的时候才会执行
4.函数的调用
函数名（实参列表）
5.函数调用的过程

• a.回到函数声明的位置
• b.用实参给形参赋值(传参-一定要保证每个参数都要有值
• c.执行函数体
• d.将返回值返回
• e.回到函数调用的位置（这个时候函数调用表达式的结果就是返回值）
  6.位置参数和关键字参数
  7.参数可以有默认值（可以对参数的类型进行说明）
  要求别人在使用这个函数的时候必须传参就不要给默认值
  （这个时候再额外的通过冒号进行类型说明）
  8.不定个数的参数，在参数名前加*
  9.返回值
• python中所有的函数都有返回值
  看一个函数的返回值：看函数体在执行的过程中，有没有执行到return语句，如果有函数的返回值就是return后面的值,没有就是None
• return关键字：确定返回值；结束函数

10.只要函数的功能产生了新的数据，就把新的数据返回。

def download(ID):
    """
    通过地址下载    （函数功能的描述）
    :param ID:str,下载数据的地址
    :return: None/下载到的数据
    """
    pass
    # 判断是否有网
    #     # 如果没有网络：
    #     #     return
    #     # 下载数据
    #     # 解析数据
    #     # 存储数据

二、匿名函数

匿名函数本质还是函数，之前函数所有的内容都适用于它
1.匿名函数的声明
函数名=lambda 参数列表：返回值
2.说明
函数名 = 变量名
lambda:声明匿名函数的关键字
参数列表：参数名1，参数名2，参数名3....
冒号：固定写法
返回值：表达式，表达式的值就是返回值
3.调用
匿名函数的调用和普通函数一样
函数名（实参列表）

写一个匿名函数，计算两个数的和

# 声明一个匿名函数
my_sum = lambda x,y: x + y
# 匿名函数
result = my_sum(10,20)
print(result)

下面这个函数和my_sum = lambda x,y: x + y等价的

def my_sum(x,y):
    result = x+ y
print(result)

练习：写一个匿名函数，获取指定数字列表指定下标的值的1/2

匿名函数的参数可以设默认值

figure = lambda list1,index1=0:list1[index1]/2

位置参数

print(figure([1,2,3,4,5,6],3))
print(figure([1,2,3,4,5,6]))
print(figure(list1 = [1,2,3,4,5,6],index1=1))
# result = list1[index]

获取一个列表的所有元素的和和平均值

list_operation = lambda list2:(sum(list2),sum(list2)/len(list2))

sum1,average = list_operation([1,2,3,4,5,6])
print(sum1,average)

• 补充：Python中的函数可以有多个返回值，就是在return返回多个值，多个值之间用逗号隔开

def list_operation2(list2):
    return sum(list2),sum(list2)/len(list2)          # 最终是多个返回值放到一个元组中返回
print(list_operation([1,2,3,4,5,6]))

变量名 = lamdba 参数列表：返回值 function

三、变量的作用域

1.函数的调用过程是一个压栈的过程：
每次调用一个函数，系统就会在内存区域中的栈区间，保存函数调用过程中产生的数据。
当函数调用完成后，对应的栈区间会自动销毁
函数调用时产生的栈区间中保存的数据：形参、在函数中声明的变量

def func1(a,b):
    '''
    赋值
    :param a: 20
    :param b: 30
    :return: 20，30，100
    '''
    # 调用完后会被销毁
    c = 100
    print(a,b,c)

func1(20,30)

2.什么是作用域：
指的是一个变量能够使用的范围
3.全局变量和局部变量
a.全局变量：声明在函数和类的外面的变量都是全局变量
全局变量的作用域：从声明开始到文件结束（任何地方都可以使用）

a = 100       # 全局变量
if a > 10:
    b = 20   #  全局变量
# x 也是全局变量
for x in range(10):
    print(x)

b.局部变量：声明在函数中或者类中的变量就是局部变量
局部变量的作用域：从声明开始到函数结束或者是从声明开始到类结束

• 注意：函数的参数是声明在函数中的局部变量

def func3(x1,y1):
    z = 'abc'
    print(x1,y1,z)

func3('a','b')

——局部变量只能在声明的那个函数中使用，不能在函数外面使用

• print(z) NameError: name 'z' is not defined

c.global关键字：是在函数中声明一个全局变量
nonlocal 不声明局部变量

num1 = 1   # 全局变量
def func4():
    # 局部变量
    num1 = 200
    print(num1)   # 如果全局变量和局部变量的同名，那局部变量的作用域内是使用的局部变量的值
    # 想要在局部变量区域内修改全局变量的值
    global num2        # 说明从这句开始后面num2都是全局变量
    global num3        # 直接在局部区域声明一个全局变量
    anum3 = 'aaa'

    num2 = 199
    print(num2)

func4()
print(num1)

def func5():
    # 局部变量
    nn = 10
    print('func5',nn )
    # 函数中可以声明函数
    def func6 ():
        nonlocal nn  # 在局部的局部中修改局部变量的值
        nn = 20
        print('func6',nn)
    func6()

    print('func5',nn)
func5()


def func():
    a = []
    for i in range(5):
        a.append(lambda x:x*i)
    return a
aa = func()
print(aa[0](2),aa[2](2),aa[3](2))

四、递归函数

1.什么是递归函数？
就是在函数的函数体中调用函数本身，这样的函数就是递归函数
2.递归的特点
while循环能做的事情，递归都可以做

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

# func1()

3.怎么写递归函数
第一步：找临界值（找到让循环结束的值/找到能够确定函数结果的值）
第二步：假设函数的功能已经实现的前提下，找关系（找f(n)和f(n-1)/当次循环和上次循环的关系）
第三步：根据f(n)和f(n-1）的关系，来f(n-1)实现f(n)的效果

# 1+2+3+4+...+100
sum1 = 0
for x in range(101):
    sum1 += x
print(sum1)
# 用递归实现1+2+3+。。。+n
def sum2(n):
    # 1.找临界值（在临界值的位置一定要让函数结束）
    if n == 1:
        return 1
    # 找关系f(n)和f(n-1)
    # sum2(n):sum2(n-1)+n
    # 3.使用f(n-1)实现f(n)的效果
    return sum2(n-1) + n

print(sum2(5))

过程：
sum2(5) n = 5 return sum2(4) + 5 0+1+2+3+4+5
sum2(4) n = 4 return sum2(3) + 4 0+1+2+3+4
sum2(3) n = 3 return sum2(2) + 3 0+1+2+3
sum2(2) n = 2 return sum2(1) + 2 0+1+2
sum2(1) n = 1 return sum2(0) + 1 0+1
sum2(0) n = 0 return 0

• 练习：使用递归计算1，1，2，3，5，8，。。。

def number(n):
    # 临界值
    if n == 1 or n == 2:
        return 1
    # 循环规律
    return number(n-2) + number(n-1)

print(number(6))

+  练习：
'''
n = 3
***
**
*

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

star(5)

4.实际开发中，递归是能不用就不要用，递归消耗大量资源是循环的n倍
递归需要不断调用函数，开辟空间，消耗内存

五、模块和包的使用

封装：
1.函数：对实现某一特定功能的代码段的封装
2.模块：将多个变量、函数和类进行封装
模块：一个py文件就是一个模块

def multiply(*numbers):
    sum1 = 1
    # 取出numbers中的每一个元素
    for item in numbers:
        sum1 *= item
    return sum1

print(multiply(1,2,5))

1.怎么使用其他模块中的内容
a.import 模块
b.from 模块 import 模块中的内容
可以直接使用模块中的内容
c.from 模块 import * ---->将模块中的所有的内容都导入

my_list

empty = []

def count(list1,item):
    '''
    统计指定列表中指定元素的个数
    :param list1: 指定的列表
    :param item: 指定元素
    :return: 个数
    '''
    count = 0
    for x in list1:
        if x == item:
            count += 1
    return count

my_model

a = 10

def func1():
    print('good!')

for x in range(10):
    print('!!',a)
# 将不希望被别的模块导入（执行）的代码放到模块的这个if语句中
if __name__=='__main__':
    print('!!',a)
    for x in range(10):
        print('!!',x)

a.
# # 导入系统模块
# import math
# print(math.pi)
# #导入自定模块my_list
# import my_list
# print(my_list.empty)
# number = my_list.count([1, 2, 3, 4, 1, 1, 5],1)
# print(number)
# b.
from my_list import count
print(count([23,12,42,52,1,5,2,1,12,12,12],12))

# c.
from math import *
print(pi)
print(sqrt(4))

2.重命名
import 模块 as 新名字
from 模块 import 内容 as 新名字

import random as RAN
print(RAN.randint(1,10))
from datetime import date as Date,datetime as TIME
print(Date.today())
print(TIME.now())

每一个模块都有一个name属性，这个属性的默认就是当前模块的文件名。
当前模块正在被执行（直接在当前这个模块中点了run）的时候，name属性的值就是'main'

在一个模块中，将不希望被其他模块导入的代码写在if name 'main'中，
希望被导入的放到这个if外面

建议：函数的声明，类的声明一般写在if的外面，其他的写在if里面。（想要被外部使用的全局变量也可以写在外面）

import my_model
# from my_model import func1
# print(func1())