【Python 学习记录2】

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

---

十二、函数

1、函数的定义和调用

函数定义：
如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。
函数格式：

def 函数名():
    代码

Python 使用def 开始函数定义，紧接着是函数名，括号内部为函数的参数，内部为函数的具体功能实现代码，调用函数只需要使用 函数名() 即可。

>>> def func():
    for i in range(3):
        print("I love lxy forever")

        
>>> func()
I love lxy forever
I love lxy forever
I love lxy forever

>>> def xiaoheizi():
        print('你干嘛~哎哟')
     
>>> xiaoheizi()
你干嘛~哎哟

每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了。
当然了如果函数中执行到了return也会结束函数。

2、函数参数

(1)
定义时小括号中的参数，用来接收参数用的，称为 “形参”。
调用时小括号中的参数，用来传递给函数用的，称为 “实参”。

>>> def func(name):
...     for i in range(3):
...         print(f"I love {name} forever")
... 
...         
>>> func("Python")
I love Python forever
I love Python forever
I love Python forever

>>> def sum(a,b):
...     c = a + b
...     print(c)
... 
>>> sum(2,4)## 调用带有参数的函数时，需要在小括号中，传递数据
6

>>> def func(s,vt,o):
...     return "".join((o,vt,s))
... 
>>> func('a','b','c')
'cba'
>>> func(s='b',vt='c',o='a')#实参按照形参的位置进行传递。
'acb'

(2)缺省参数
调用函数时，缺省参数的值如果没有传入，则取默认值。
注意：带有默认值的参数一定要位于参数列表的最后面。

• 语句：help(函数)，可以查看函数参数。

>>> def printinfo(name, age=35):
...    print("name: %s" % name)
...    print("age %d" % age)
>>> printinfo(name="miki")
name: miki
age 35
>>> printinfo(name="miki",age=9)
name: miki
age 9

(3)不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。

基本语法如下：
def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]

注意：
加了星号（*）的变量args会存放所有未命名的变量参数，args为元组。
而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

>>> def myfunc(a,b,*args,**kwargs):
...     print("a = {}".format(a))
...     print("b = %d" %b)
...     print("args的长度为{}".format(len(args)))
...     print("args的第二个元素为{}".format(args[1]))
...     for key,value in kwargs.items():
...         print("key = %s" %value)
... 
...         
>>> myfunc(1,2,3,4,5,6,m=7,n=8,q=9,z=10)
a = 1
b = 2
args的长度为4
args的第二个元素为4
key = 7
key = 8
key = 9
key = 10

3、函数返回值

所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果。

>>> def add2num(a,b):
        return a + b
>>> add2num(1,100)
101

>>> def div(a,b):
...     if b != 0:
...         return a / b
...     else:
...         print("除数不能为零")
... 
...         
>>> div(2,0)
除数不能为零
>>> div(2,1)
2.0

如果一个函数没有返回值，当执行完后会返回一个None值。例如：

>>> def func():
...     pass
... 
>>> print(func())
None

一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处。

>>> def add2num(a,b):
...     return a + b
...     return a * b
... 
>>> add2num(3,6)
9

4、局部变量

局部变量，就是在函数内部定义的变量，其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的。
局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储
当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了。
5、全局变量
如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量。

>>> x = 880
>>> def myfunc():
...     x = 520
...     print(x)
... 
...     
>>> myfunc()
520
>>> print(x)
880

如果在函数中出现global 全局变量的名字 那么这个函数中即使出现和全局变量名相同的变量名 = 数据 也理解为对全局变量进行修改，而不是定义局部变量。

>>> x = 880
>>> def myfunc():
...     global x
...     x = 520
...     print(x)
... 
...     
>>> myfunc()
520
>>> print(x)
520

6、嵌套函数

>>> def funA():
...     x = 520
...     def funB():
...         x = 880
...         print("In funB,x =",x)
...     funB()
...     print("In funA,x =",x)
... 
...     
>>> funA()
In funB,x = 880
In funA,x = 520

7、LEGB规则
当各个作用域覆盖范围重复，出现冲突的时候，按此规格执行。L最高，B最低。
L：Local，局部作用域
E：Enclosed，嵌套函数的外层函数作用域
G：Global，全局作用域
B：Build-In，内置作用域（内置函数，内置方法）

8、闭包
1、利用嵌套函数的外层作用域具有记忆能力这个特性让数据保存在外层函数的参数或者变量中。
2、将内层函数作为返回值，就可以从外部间接的调用到内层的函数。

>>> def funa():
	x = 123
	def funb():
		print(x)
	funb()
	
>>> funa()
123
>>> def funa():
	x = 123
	def funb():
		print(x)
	return funb
 
>>> funa()
<function funa.<locals>.funb at 0x000001E978DB5040>
>>> funa()()
123
>>> fun = funa()
>>> fun()
123

闭包：工厂函数

>>> def power(exp):
	def exp_of(base):
		return exp ** base
	return exp_of
 
>>> square = power(2)
>>> cube = power(3)
>>> square(2)
4
>>> square(3)
8
>>> cube(2)
9
>>> cube(3)
27

9、lambda表达式
匿名函数

lambda arg1, arg2, arg3, …argN : expression

相当于：def (arg1, arg2, arg3, …argN):
return expression

因为lambda是一个表达式，所以它可以做一些常规函数不能做到的事
例如将lambda表达式作为元素放到列表中；将lambda用到map、filter函数中。

>>> func = lambda x:x*x
>>> func(4)
16

y = [lambda x:x*x,1,2,3]
y[0](y[2])
4

>>> mapped = map(lambda x: ord(x) + 10,"FishC")
>>> list(mapped)
[80, 115, 125, 114, 77]

10、递归

递归就是函数调用自身的过程，要让递归进行正常工作，必须设置一个结束条件，并且在运行过程中需要向这个条件推进。

>>> def funA(i):
	if i > 0:
		print('Love')
		i -= 1
		funA(i)
		
>>> funA(5)
Love
Love
Love
Love
Love

>>> def fact(i):
	if i == 1:
		return 1
	else:
		return i * fact(i-1)
	
>>> fact(5)
120

十三、永久存储

1、open()函数创建并打开文件

open()函数用于打开一个文件并返回其对应的文件对象。
open(file, mode= 'r ’ , buffering=-1， encoding=None，errors=None，newline=None，closefd=True，opener=None)

>>> f = open("E:/fishC.txt","w")
>>> f.write("I love python.")
14
>>> f.writelines(["I love python.\n","I love my wife."])
>>> f.close()

随后在E:/目录下创建一个新文件fishC.txt，若未指定文件夹路径，则直接在python安装目录中创建文件，随后在该文件夹中可以看见新创建的文件。成功创建之后会返回文件对象，将文件对象赋值给变量f。
2、文件对象的各种使用方法

将字符串写入到文件中，使用write()、writeline()方法。
执行写入代码之后马上打开文件，并不能立即看见写入的内容，因为写入的内容还在文件的对象的缓冲区，只有将文件对象关闭之后，数据才能写入文件中。
使用flush()方法可以在不关闭文件的情况下将缓存区的内容写入文件。

f = open("E:/fishC.txt","w")
f.write("i Love WIFI.")
12
f.flush()