1匿名函数
匿名函数的本质还是函数，之前函数的所有的内容都适用于它
1.匿名函数的声明
函数名 = lambda 参数列表：返回值
2.说明：
函数名：变量名
lambda：声明匿名函数的关键字
参数列表：参数1，参数2，....
冒号：固定写法
返回值：表达式，表达式的值就是返回值
3.调用
匿名函数的调用和普通函数一样
函数名（实参列表）
例如：写一个匿名函数计算两个数的和
#声明一个匿名函数
my_sum = lambda x,y:x+y
print(type(my_sum))
print(type(my_sum))
#调用匿名函数
result = my_sum(10,20)
print(result)
输出:
30
练习1：写一个匿名函数，获取指定的数字列表指定下标的值得1/2
#匿名函数的参数可以设默认值
get_value = lambda list1,index=0:list1[index]/2
#位置参数
print(get_value([1,2,3,4,5],3))
print(get_value([1,2,3,4,5]))
#关键字参数
print(get_value(index=1,list1 = [10,78,29,8]))
输出：
2.0
0.5
39.0
练习2: 获取一个列表的所有的元素的和和平均值(sum函数可以计算一个序列的和)
list_operation = lambda list1: (sum(list1), sum(list1)/len(list1))
sum1, average = list_operation([1, 2, 3, 4, 5, 6])
print(sum1, average)
输出：
21 3.5
补充：python中的函数可以有多个返回值的，就是在一个return后返回多个值，多个值之间用逗号隔开
def list_operation2(list1):
return sum(list1),sum(list1)/len(list1)
print(list_operation2([1,2,3,4,5,6]))
输出:
(21 3.5)
2.变量的作用域
1.函数的调用过程是一个压栈的过程：
每次调用一个函数，系统就会在内存区域中的栈区间去开辟空间，保存函数调用过程中产生的数据。
函数调用完成后，对应的栈区间会自动销毁
函数调用时产生的栈区间中保存的数据有：形参，在函数中声明的变量
def func1():
c = 100
print(a,b,c)
func1(20,30)
func1(100,200)
输出：
20 30 100
100 200 100
2.什么是作用域
指的是一个变量能够使用的范围
3.全局变量和局部变量
a.全局变量：就是声明在函数和类的外面的变量都是全局变量
全局变量的作用域：从声明开始到文件结束（从声明开始到文件结束，任何地方都可以用）
a = 10 #全局变量
if a > 10:
b = 20 #全局变量
for x in range(10): #x也是全局变量
print(x)
for y in range(10):
print(y)
b.局部变量：声明在函数中或者类中的变量就是局部变量
局部变量的作用域:从声明开始到函数结束或者是从声明开始到类结束
注意:函数的参数是声明在函数中的局部变量
def func3():
z = 'abc'
print(x1,y1,z)
func3('a','b')
输出：
a b abc
c.global关键字：实在函数中声明一个全局变量
global 变量名
变量名 = 值
#全局变量
num1 = 100
#全局变量
num2 = 10
def func4():
#局部变量
num1 = 200
print(num1) #如果全局变量和局部变量同名，那局部变量的作用域内使用的是局部变量的值
#想要在局部区域内修改全局变量的值
global num2 # 说明从这句开始后面的num2都是全局变量
num2 = 199
print(num2)
global num3 # 直接在函数中声明一个全局变量。这个变量在外面只有函数调用后才能使用
num3 = 'aaa'
func4()
print(num1)
print(num2)
print(num3)
输出:
200
199
100
199
aaa
nonlocal 不声明局部变量
def func5():
# 局部变量
nn = 10
# 函数中可以声明函数
def func6():
nonlocal nn # 在局部的局部中修改局部变量的值
nn = 20
print('func6',nn)
func6()
print('func5', nn)
func5()
输出：
func6 20
func5 20
3.递归函数
什么是递归函数：就是在函数的函数体中调用函数本身，这样的函数就是递归函数
递归函数的特点：while循环能做的事情，递归都能做
#func1就是递归函数
def func1():
print('asd')
func1()
func1
怎么写递归函数:
a.找临界值（找到让循环结束的值/找到能够确定函数的值）
b.假设函数的功能已经实现的前提下，找关系（找f(n)和f(n-1)当次循环和上次循环的关系）
c.根据f(n)和f(n-1)的关系，来通过f(n-1)实现f(n)的效果
例如：用递归实现1+2+3+....+n
def my_sum(n):
#1.找临界值（在临界值的位置一定要让循环结束）
if n==1:
return 1
#2.找关系
#3.使用f(n-1)实现f(n)的效果
return my_sum(n-1) + n
print(my_sum(5))
输出:
15
使用递归计算斐波那契数列1,1,2，3,5,8,13,21，.....第n个数
def fei(n):
if n == 1 or n ==2:
return 1
return fei(n-1) + fei(n-2)
print(fei(3))
输出:
2
使用递归完成以下的效果
def star(n):
if n == 1:
print('*')
return
print('*'*n)
star(n-1)
star(3)
在实际开发中，递归能不使用就不用
模块和包的使用
封装：
函数：对实现某一特定功能的代码段的封装
模块：对变量，函数，类进行封装
模块：一个py文件就是一个模块
def multipy(*numbers):
sum1 = 1
for item in numbers:
sum1 *= item
return sum1
print(multipy(1,2,5))
输出：
10
1.怎么使用其他模块的内容
a. import 模块
通过模块.内容的形式去使用模块中的内容（能够使用的是全局变量，函数，类）
b. from 模块 import 模块中的内容
可以直接使用模块中的内容
c.from 模块 import * ---->
#导入自定义的my_list模块
import my_list
#使用模块中的全局变量
print(my_list.empty)
num = my_list.count([1,2,3,4,3,1,3],3)
print(num)
from my_list import count
print(count([1,2,3,4,3,1,3],3))
或者是
from math import *
print(pi)
print(sqrt(4))
输出:
3
3.141592653589793
2.0
重命名
import 模块 as 新名字
from 模块 import 内容 as 新名字
import random as RAN
print(RAN.randint(1,10))
from datetime import date as DateClass
print(DateClass.today())
输出:
10
2018-08-30
每个模块都有一个name属性，这个属性的值默认就是当前模块的文件名
当当前模块正在被执行（直接在当前这个模块中点了run）的时候name属性的值是'main'
在一个模块中将不希望被其他模块导入的代码写在if name=='main'中
建议：函数的声明，类的声明一般写在if的外面，其他的写在if 的里面（想要被外部使用的全局变量也可以写在外面）