认识函数：
在一个完整的项目中，某些代码会被反复的使用
那么将某段代码封装成函数，当我们要使用功能的时候直接调用函数即可
本质：函数是对功能的封装。
优点：简化代码的结构，增加代码的复用度
定义函数：
def 函数名(参数列表):
语句
return 表达式
说明：
def: 函数代码块以def关键字开头
函数名：遵守标识符的规则
()：函数列表的开始和结束
参数列表: 是函数的调用者给函数的信息，多个信息之间用逗号分隔
没有信息那么小括号中什么都不用写，小括号不能省略。
冒号： 函数的内容以冒号起始，并且缩进
语句：函数封装的功能
return：一般结束函数并且返回给函数的调用者一些信息。如果不写return默认返回None
return中的表达式就是要返回的数据。
注意：
定义函数时，程序是不会执行函数的，当调用函数时才会执行函数。
"""
def buydrink(money):
return "水"
"""
使用函数
格式：
函数名（参数列表）
说明：
函数名： 要使用某个函数的名字
()： 参数列表的开始和结束
参数列表：调用者给函数的信息（实参）
函数调用的本质：实参给形参复制的过程
"""
print(buydrink(5))
"""
编写函数，实现打印功能
并调用
"""
def func():
print("hello_world")
func()
"""
函数的参数部分
编写函数，给函数一个名字，年龄，一些爱好，在函数中进行打印
"""
#这个参数是形参： 形参就是变量
def user(name, age, hobby):
print("%s,%s,%s,%s,%s"%(name,age,hobby[0],hobby[1],hobby[2]))
user("xiaoha",18,["xuexi","shuijiao","chifan"])
#函数在调用时，需要给函数传递数据按顺序，并且数量要对应。
#在调用是，成为实参，实参是值，可以是值，
#参数的数量理论上是无限的，但是实际中最好不要超过6、7个，参数的类型没有限制。
"""
函数的返回值：
编写函数实现计算两个数的和
#注意在定义的函数体中，尽量不要出现print和input
"""
def add(x, y):
return x+y #将结果返回到调用函数的位置,返回的数据可以是惹你诶性
res = add(1, 2) #将数据返回给res
print(add(1,2))
"""
传递参数：
值传递：不可变类型的数据
引用传递：传递的可变数据类型，本质还是值传递，不过传递的是地址。
"""
def func1(num):
num = 10
a=20
func1(a)
print(a)
def func2(arr):
arr.pop()
li = [1,2,3,4,5]
func2(li)
print(li)
"""
在之前：函数调用时参数的顺序要与定义是一致
关键字参数：允许函数调用时参数的顺序与定义是不一致
"""
def func4(name = "", age = ""):
pass
"""
默认参数：
在调用函数时，如果没有传递参数，就使用默认参数的值
在定义函数时，将默认参数写在最后
"""
def func3(name, age = 18):
print("%s,%s")
"""
不定长参数：
能处理比当初定义时更多的参数，
在变量前加了个星号，该变量会存放所有未命名的从变量的参数
如果在函数调用时没有指定函数，他就是空元组。
不定长参数在默认参数后面。
"""
def func5(name, age, *args):
pass
"""
**kwargs
**代表键值对字典，和*差不多
"""
def func8(*args, **kwargs):
print(args)
print(kwargs)
#可以接受任意的参数
"""
多个返回值
返回值可以一次性返回多个值
"""
def func9():
return 1,2 #返回的是元组类型
"""
函数也是 一种数据
"""
#f = add(1,2)
#print(f(1,2))
"""
匿名函数：
概念： 不再使用def语句这样标准的形式定义函数，使用lambda来创建匿名函数
特点：
1，lambda只是一个表达式，函数体比def简单的多
2.lambda主体是一个表达式而不是代码块，仅能在lambda表达式中封装有限的逻辑
3.lambda函数拥有自己的命名空间，且不能访问自有参数序列之外的，或全局命名空间里的参数
4.虽然lambda函数看起来只能写一行，却不同于c和c++的内联函数，后者的目的是调用小函数时
不占用栈内存而增加运行效率。
格式：
lambda [arg1[, arg2[,arg3,.....]]]: expression #前边是传参，后边是返回给前边的表达式
主要使用： 作为参数传递，实现回调，为了简化代码
"""
f1 = lambda x, y: x+y
print(f1(5, 6))
"""
map reduce
map：将所有的数据映射出来进行同步处理
map(fn, lsd)
参数：
fn: 是一个函数
lsd: 集合
功能： 将传入的函数Fn作用到lsd集合中的每个元素，并把结果作为一个新的iterator返回
"""
def char2int(char):
return {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9 }[char]
ret = map(char2int, "13586")
print(ret)
print(list(ret))
"""
reduce(fn, lsd)
参数：
fn：函数，必须有两个参数
lsd：集合
功能：将传入的fn函数作用在lsd集合中，这个fn函数必须接受两个参数，reduce把结果继续和lsd中的下一个元素作累计计算
"""
"""
filter函数
filter(fn, lsd)
参数：
fn：函数
lsd：集合
功能:用于过滤序列，把传入fn函数一次作用在lsd集合中的每个元素上，然后根据返回值是True还是Flase决定
是否保留该元素
"""
li1 = [1,2,3,4,5,6,7,8,9]
#去掉列表中所有的偶数
#过滤的逻辑
def func10(x):
if x % 2 == 0:
return False
return True
filter(func10, li1)#不改变li1 而是得到一个新的迭代
#删除列表中是空字符串的元素
def del_null_str(x):
if x.isspace() or x == "":
return False
return True
li2 = ["", "a", "", "c", "", " ","f"]
res = filter(del_null_str, li2)
print(list(res))
"""
sorted函数：
排序算法：冒泡、选择、快排、计数器、
"""
#对列表进行排序
li1 = [3, 4,2,1,6]
li2 = sorted(li1)
print(li2)
#可以按绝对值大小排序
li3 = [-4,5,-1,8,-2]
li4 = sorted(li3, key=abs)
print(li4)
#降序排列
li5 = [3,-4,1,-2,5]
li6 = sorted(li5, reverse=True)
print(li6)
###字符串大小比较问题
"""
原理：获取两个字符串第一个字符进行比较谁的ASCII值大，那么谁就大，如相同则获取下一位字符比较
"""
li7 = ["abc", "sdsfa", "acsd", "aba", "sfsaf"]
def func(x):
return len(x)
####后面的key值可以自己定义，可以自己写一个函数，可以进行其他运算，这个叫做自定义排序
li8 = sorted(li7, key= func)
print(li8)
"""
作用域：
变量可以使用的范围，程序的变量并不是在哪个位置都可以访问的访问的权限决定于这个变量是在哪里赋值的。
作用域的划分：
1.局部作用域(L)
2.闭包函数外的函数中(E)
3.全局作用域(G)
4.内建作用域(B)
变量查找规则：
L->E->G->B，首先在自身作用域中查找，找不到的话一次向上级作用域中查找，注意：不会向低级作用域中查找
Python中只有模块，类，以及函数中才会引入新的作用域，其他的代码块（if elif else for while
try except等）是不会引入新的作用域
"""
num = 5
if 1:
index = 10
print("num = %"%(num))#if不会引入新的作用域
print("index = %d"%index)
#这个是不会引入新的作用域
def func(x,y):
#取值的使用
print("func 中 num = %"%num)
#定义局部变量
temp = 100
return x+y
#print(temp)#在全局中使用局部变量报错，找不到局部中的变量。
print(func(1, 2))
# 在函数的内部可以直接获取全局变量的值，但是不能直接修改全局变量的值，直接修改相当于定义一个新的局部变量，没有修改全局变量的值
"""
修改全局变量
如果想在局部变量中修改全局变量，需要将定义的变量声明成全局变量 global
"""
"""
修改嵌套作用域中的变量
"""
a = 30
def func11():
#有global会在nonlocal里报错，声明为全局的后就没有嵌套里的了
a = 10
def f():
#想修改嵌套作用域中的变量，需要将它声明 nonlocal 这个不能修改全局变量
nonlocal a
a = 20
print("1------------a = %d"%a)
f()
print("2-----a = %d"%a)
func11()
print("3-----a = %d"%a)