python基础学习浅学函数

1.函数：
作用：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码。
（浅显理解：把具有独立功能的代码块，分装为一个小模块，在需要的时候调用)
可以把数据类型给到变量，可以把代码放到函数里面，后面在任何地方都可以调用。

函数能提高应用的模块性，和代码的重复利用率。

print()是python内建的许多函数的一种。

规则：
1.函数必须先定义后调用，否则报错 ###注意：程序在执行时，由上到下，遇到函数会直接跳过，如果遇到调用函数的代码，会返回到函数执行函数，再继续执行剩下代码
2.函数名命名规则同变量的命名规则
3.函数体内可以写任意代码，不受限制

python定义函数使用 def 关键字

小知识点：：：
（1）文档注释：
1.文档注释的格式和多行注释格式完全相同
2.文档注释书写的位置是函数体的第一行
3.查看函数的文档注释是按住键盘Ctrl键后，
鼠标放置在书写调用函数位置的函数名上
（2）函数调用过程分析：
DEBUG过程进入函数内部两种方式：
在函数内部打断点，配合F8进行（不会忘）
在进入函数执行时，使用快捷键F7（容易忘）
点按钮（巨LOW，太土，不专业，忘了吧）

重点来啦：：：
首先定义函数，然后才能调用函数：：：
定义某一个函数的公式：
定义函数

def 函数名(参数1，参数2，……)：
	____函数体
	      ……	
调用函数
	函数名(参数1，参数2，……)

-----（小知识点：如果没有写函数体，可以写个pass就不会报错）

知识点一：：： 参数
带有参数的函数：
1.函数外面的数据通过参数传递到函数中
2.一个函数在定义时，可以带有多个参数
3.函数定义多个参数时，参数之间使用，(逗号)分隔
4.调用带有参数的函数时，传入的数据之间使用，(逗号)分隔

带有参数的函数的注意事项：
1.参数的数量一定要一一对应，不然会报错
2.函数定义的位置，参数只能写变量，直接写数据会报错
3.函数调用的位置，参数可以写数据，也可以写变量

形参与实参：
1.形参是定义函数时规定的参数，仅在函数体内有效
2.实参是调用函数时使用的参数，该值将传递给函数的形参

参数分类：：：
（1）必备参数：
如果定义函数的时候有参数，则称之为必备参数。

（2）默认参数：
如果函数调用的时候，没有给默认参数传值，那么使用的就是默认值；如果给了。就使用给的值。

def  func(x, y=None):
	 print(x)
	 print(y)
#函数调用：
func(1)
func(1, 2)

注意：默认参数要位于必备参数
列表的后面

（3）不定长参数：
*args不定长参数，接收多个实参
*作用：把单个的值，化为整体；也可以把一个整体拆分出来。 代表元组。

def fun1(*args)：     
	print(*args)      #如果print里面只是args则把单个的值化为一个整体，变为元组的格式；如果里面是*args则把一个整体拆分为一个个的单个的值。
fun1(1,2,3,4,5,6,7,8)

# **kwargs 接收赋值的形式，把他变为字典。
def fun2(**kwargs):
	print(kwargs)
	#print(**kwargs)      不能这样写，会报错
fun2(name = '干干',age = 18,sex = 'NAN')

书面化的讲解：

def  func(*args, **kwargs):
	print(args)
	print(kwargs)
调用1：func(1, 2, 3, a=4, b=5, c=6)
调用2：func(*(1, 2, 3), **{'a': 4, 'b': 5, 'c': 6})

延伸讲解：
*接受多个值

a,*b = [1,2,3,4,5]
#a为1
#b为[2,3,4,5]

（4）关键字参数：

def  func(x):
	print(x)
#函数调用：
func(x=1)

小知识点：：：
（1）定义参数：
必备参数
默认参数
不定长参数

（2）参数的调用：
位置参数
关键字参数

（3）在python中参数 无类型，参数可以接受 任意对象，只有函数中代码才会对参数类型有限制

知识点二：：： return
1.函数将数据从函数内部输送到函数外部，需要使用关键字return
2.函数的运行结果可以使用变量接收，也可以不接收
3.如果一个函数没有设置返回值，使用变量接收时结果为None
4.同一个函数执行过程中能执行一次return语句，执行return
语句后，函数执行完毕，程序继续执行

例如：

定义函数                                          例子：计算面积。
	def 函数名(参数1，参数2，……)：                 def area(width,height):
	____函数体                                       	return width*height
	____return 函数运行结果返回值                  如何执行：print(area(3,4))   输出为：12
	      ……	
调用函数
	变量名 = 函数名(参数1，参数2，……)

重点：
1.return 后面可以返回任意表达式，但不能是赋值语句。
2.return是函数的返回值，返回值可以赋值给变量；但print只是打印出来。

知识点三：：：
作用域：
全局变量（全局作用域）与局部变量（局部作用域）
1.局部变量是定义在函数内部的，在函数内部有效
2.全局变量是定义在函数外部的，在整个文件中有效
注意：
1.局部变量只在定义的函数内部有效，函数间的局部变量不能共享使用
2.全局变量可以在函数内直接使用
3.函数内部和外部定义了同名的变量时，函数内部使用的是局部变量

升华：：：
4.函数内部和外部定义了同名的变量时，使用全局变量必须在函数内声
明，格式：global 全局变量名
声明局部变量 nonlocal
如果在函数内部声明了全局变量，那么在函数内部就可以更改全局变量，因为现在函数内部使用的就是全局变量，指向了同一片内存空间。

外部不能访问函数内部变量。
函数内部的变量能够访问函数外部的变量。
函数内部不可以修改函数外部的变量。
函数里面和函数外部变量名相同时：指向同一个地址；类型浅复制。

def zhangsan():
	x = 4         #内部变量赋值   局部变量

	def  wumou():
	     nonlocal x     #声明局部变量，如果不声明这个局部变量，就会报错，用不到这个局部变量x
	     x = x+1
		 print(x)
		 return x  

    return wumou()

知识点四：：：

常见函数：                   进制转换函数：                 高级内置函数：
len求长度                    bin转换为二进制                enumerate返回一个可以枚举的对象   dict(enumerate(序列类型))
min求最小值                   oct转换为八进制               eval取字符串中的内容，将字符串str当成有效的表达式来求指并返回计算结果，不能赋值。
max 求最大值                  hex转换为十六进制             exec    执行字符串编译过的字符串
sorted排序                    ord字符转ASCII码             filter 过滤器
reversed 反向                 char ASCII码转字符            map() 
sum 求和                                                   zip将对象逐一配对

举例讲解一些：
普通的：
之前列表里的sort和reverse会改变原来的值，没有返回值 列表的方法
sorted和reversed不会改变原来的值，有返回值 内置函数
例子：

li = [1,2,3,4]
print(sorted(li))                   	从小到大排序
print(sorted(li,reverse = True))		从大到小排序
print(list(reversed(li)))     

转化为二进制：

print(bin(3))  
#输出为ob11

转换为八进制：

print(oct(9))
#输出为0o11

转化为十六进制：

print(hex(15))
#输出为15

字符转化为ASCII码：

print(ord('寒'))
#ASCII转化为字符：
print(char('23565'))

高级的：
（1）枚举：会把索引值给拿出来

li = ['寒沙','剑来','低调']
a = enumerate(li)
print(tuple(a))      输出为：((0, '寒沙'), (1, '剑来'), (2, '低调'))
###tuple可换为dict，list等

（2）eval和exec

# eval 取出字符串的内容，将字符串当做有效的表达式来计算，返回结果。
a = eval('1+1')
print(a)    输出为2

#exec 将字符串当做代码执行
a = exec('aa = 1 + 1')
print(aa)    输出为2

（3）filter 过滤器

def aa(obj):   
	pass  
f = filter(aa,'adfsfaaf')
#用参数二过滤返回为true的元素
list(f)   ：类型转换的时候调用

例子：

def func(x):
	if x>3:
		return 	True
	else:
		return False

li = [1,2,3,4,5,6]

f = filter(func,li)		filter有两个参数，第一个参数是函数名字，第二个参数是可迭代对象（序列类型和散列类型）
						作用：把列表里面的每一个元素放到函数里面进行过滤。
						如果是True就保留下来；如果是False就不要。
print(list(f)

---

上为filter:::
filter 根据True或者是False过滤列表里面的东西，列表不变
map 把列表放到函数里面运算，返回结果
下为map:::

（4）map 跟filter差不多，它拿到的是放回值
对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回

例子：

li = [1,2,3,4,5,6]
def fun(x)：
	return x + x

m = map(fun,li)         #把列表里面每一个元素放到函数里面计算运算，返回运算的结果
print(list(m)

拓展：

list(map(abs,[-1,-2,0,1,2]))

把后面的列表里的所有数都经过函数abs。

（5）zip 将对象逐一配对

li1 = ['寒沙','罗汉'，'龙雨','剑威']
li2 = ['小姐姐','鳄鱼','大汉','剑来']
z = zip(li1,li2)         #zip可以配对多个，大于两个也可以。
print(list(z))
#输出为{'寒沙': '小姐姐', '罗汉': '鳄鱼', '龙雨': '大汉', '剑威': '剑来'}

函数再升级的骚操作啦：：：！！！
（1）闭包

小知识点：
函数引用：

def fun1():
	print('this is fun1')

fun1()      #这样可以调用
fun = fun1    #赋值   能够让fun和fun1指向同一片内存空间
fun()         #通过赋值之后的也可以调用函数

引入的话看这个例子：

def fun1():
	print('this is fun1')
	def fun2():
		print('this is fun2')
	fun2()        #如果要使用函数里嵌套的函数fun2，就要调用，这样在调用fun1的时候才会使用到内层函数fun2
fun1()     

#仔细看看，现在我要把这个例子变成闭包了：：：
def fun1():
	print('this is fun1')
	def fun2():
		print('this is fun2')
	return fun2     #在函数fun1下面返回里面函数的名字
fun1() ()

注意：：：
return fun2相当于fun1()里面有了fun2()
现在如果调用fun1()的时候直接fun1()，就相当于fun1() = fun2 。这样还是只执行了fun1()。
所以等号两边同时加个括号，看可以把fun2()函数也执行了:fun1()() = fun2()

升华一下啦：：：！！！
内嵌函数：
闭包是函数里面嵌套函数，外层函数返回里层函数的函数名，这种情况称为闭包。
闭包是概念，不是某种函数类型，和递归的概念类似，就是种特殊的函数调用
闭包可以得到外层函数的局部变量，是函数内部和函数外部沟通的桥梁

例子：

def zhangxinyi(x):
	x + 2000

	def  wuhan(y):
	     return y+x
    

	return wuhan

（2）递归：
函数自己调用自己，如果不做限制，就一直调用自己，直到超出最大的递归深度而报错。
引入例子：

def fun():
	print('this is fun')
	fun()

fun()

下面讲到正题：：：！！！

阶乘factorical：：： 5！ = 54321
例子：

def fun(n):
	if n == 1:
		return 1
	return n*fun(n-1)

print(fun(5))

#解释下：：：
#n*fun(n-1)
#fun(5)返回5*fun(4)
#fun(4)返回4*fun(3)
#fun(3)返回4*fun(2)
#fun(2)返回4*fun(1)
#fun(1)返回 1                    #如果不加限制，就会一直往下递归，所以应该加个限制，就是上面的if语句

在来个例子：：：

#递归求高斯求和
def sum(n):
    if n == 1:
        return 1
    return n + sum(n-1)
print(sum(100))

#n = 100  return 100 + sum(99)
#n = 99   return 99  + sum(98)
#n = 98   return 98  + sum(97)
#...
#n = 1    return 1

（3）回调

def funa():
	print('清水白石厦寒沙')

def funb(fun,flag):          #把funa给到fun
	if flag == 1:
		fun()                #这里fun加括号，相当于funa加括号，即fun() = funa()。在上面函数的引用有讲解哦
	else:
		print(111)

funb(funa,1)

关于那个加括号，深化结合理解下：：：
1.嵌套函数

def a():
	def b():
		print(111)
	return b()

a()

2.闭包

def a():
	def b():
		print(111)
	return b

a()()

（4）关键字传参

def wuhan(str):        #跟type的功能一样，如果直接传入一个关键字，会告诉python解释器输出他们的类型。
	print(str)
	return
wuhan(str)                 
#输出为：     

（5）匿名函数
python中使用lambda来创建匿名函数。
lambda函数的语法只包含一个语句。
语法规则：lambda 参数：表达式
例如：

函数体：                             lambda形式：
def wuhan(x):                       wuhan = lambda x:x+1  #第一个x是形参，后面x+1相当于return x+1
    #代码块
	return x+1                      print(wuhan(3))
print(wuhan(3))

优点：lambda只是一个表达式，函数体比def简单很多。
匿名函数的合理利用能够让那个代码更加简洁。
缺点：lambda表达式中封装有限的逻辑进去。

简单的函数就用lambda来操作。

类似于filter,map等函数里面可以使用匿名函数来处理。例如：filter(lambda x: x>10, li)

拓展个知识点：
函数或者方法调用过程中，一般放到if name == 'main’下面
成为主函数的入口；程序的窗口 规范一些
在导包的过程中 if name == 'main’下面的内容不会在导包的这个文件中显示。

if __name__ == '__main__':
	print(11)
#输出为：
#11