7、Python3 函数学习记录

Python 3 函数

1、函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

2、函数能提高应用的模块性，和代码的重复利用率。我们知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

一、定义一个函数

定义函数规则如下：

1、函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

2、任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

3、函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

4、函数内容以冒号起始，并且缩进。

5、return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

二、语法

def 函数名（参数列表）:

    函数体

三、实例1：

def sayhello(name):
print("hello {}".format(name))

if __name__ == '__main__':
sayhello("storm")

运行结果：

C:\Python36\python.exe E:/python/test1/second/myfun.py

hello storm

Process finished with exit code 0

四、函数调用

1、在函数所在文件内调用函数

文件myfun1.py

def sayhello(name):
print("hello {}".format(name))

sayhello("storm")
sayhello("lina")

如上，在文件内部调用函数，直接写上函数名字，传入必要的参数即可。上面调用了两次函数。

2、在其它文件调用这个函数

在myfun2.py中想跳动myfun1.py 中的sayhello()函数，怎么办呢？

（1）引入myfun1 文件

from second import myfun1

myfun1.sayhello("Tom")

（2）引入sayhello() 函数

from second.myfun1 import sayhello

sayhello("Tom")

五、参数传递

原文说Python中，类型属于对象，变量没有类型。比如

a = [1,2,3]

b = "storm"

上面 [1,2,3] 是list，而“storm” 是string类型，变量a和b没有类型，仅仅是对象的一个引用（一个指针），学习过C的朋友可能好理解一些。

1、那不管怎么样。我们可以简单区分一下变量值：不可变类型和可变类型。如果这个类型没有子元素，或者子元素不能修改，就是不可变类型。

Python中，string，tuples，numbers 是不可更改类型，而list，dict则是可变类型

string 和 numbers没有子元素，所以是不可变类型，tuple有子元素，但是子元素不能修改，所以也是不可变类型。

尝试修改下tuple 子元素，看看Python给我们什么提示

>>> a = (1,2,3)

>>> a[0]

1

>>> a[0] = 1

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not support item assignment

对于list和dict，大家可以试试

好，清楚了可变类型和不可变类型，我们来看一看对于Python 函数的参数传递，二者有什么区别

2、函数传不可变类型

3、函数传可变类型

六、参数

参数有很多种，我们一一来介绍下：

1、必需参数，如果函数有必需参数。调用的时候必须和声明时传入一样多的参数。

def sayhello1(name):
print("hello {}".format(name))

def sayhello2(name,age):
print("hello {},你的年龄是{}吗？".format(name,age))

if __name__ == '__main__':
sayhello1("storm")
sayhello2("lina",30)

运行结果：

C:\Python36\python.exe E:/python/test1/second/myfun1.py

hello storm

hello lina,你的年龄是30吗？

Process finished with exit code 0

上面的sayhello1(name) 在定义的时候有一个形参，在调用的时候也必须传一个参数
sayhello2(name,age) 在定义的时候有2个形参，在调用的时候也必须传二个参数，且按照顺序传

2、关键字参数

如果不想按顺序传怎么办？使用关键字参数

def sayhello1(name):
print("hello {}"[/b].format(name))

def sayhello2(name,age):
print("hello {},你的年龄是{}吗？".format(name,age))

if __name__ == '__main__':
sayhello1("storm")
sayhello2("lina",30)
sayhello2(age=30,name="shadow")  #关键字传参

3、默认参数

如果传了，就使用传的；如果没传，就是用默认的

def sayhello2(name,age=30):
print("hello {},你的年龄是{}吗？".format(name,age))

if __name__ == '__main__':
sayhello2("lina",20)
sayhello2("luna")

运行结果：

hello lina,你的年龄是20吗？

hello luna,你的年龄是30吗？

分析：

lina 传了20岁，打印20岁
luna 没传年龄，打印默认值30岁

4、不定长参数

def myfun1(*args):
for arg in args:
print(arg)

if __name__ == '__main__':
myfun1("storm")
print("="*50)
myfun1("lina","shadow","ES")

运行结果：

storm

==================================================

lina

shadow

ES

5、匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法：

lambda [arg1 [,arg2,.....argn]]:expression

mysum = lambda x,y:x + y

print(mysum(1,2))

七、return 语句

def mysum(x,y):
return x + y

if __name__ == '__main__':
a = mysum(1,2)
print(a)

运行结果：3

对比

def mysum(x,y):
print(x + y)

if __name__ == '__main__':
a = mysum(1,2)
print(a)

运行结果：

3

None

分析：

上面第一个函数，函数体中，并没有打印语句，只是在调用的时候，返回两个数的和。main中，我们调用函数并把他返回（return）的值赋给a，然后打印出a=3

第二个函数，函数体本身有个打印（print），所以在main中调用的时候就自动打印了两个数的和，但是并没有return，所以函数并没有返回值给变量a，所以打印a是none

八、变量作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

L （Local） 局部作用域

E （Enclosing） 闭包函数外的函数中

G （Global） 全局作用域

B （Built-in） 内建作用域

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

x = int(2.9)  # 内建作用域

g_count = 0  # 全局作用域
def outer():
o_count = 1  # 闭包函数外的函数中
def inner():
i_count = 2  # 局部作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问，如下代码：

>>> if True:
...  msg = 'I am from Runoob'
...
>>> msg
'I am from Runoob'
>>>

实例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。

如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：

>>> def test():
...     msg_inner = 'I am from Runoob'
...
>>> msg_inner
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'msg_inner' is not defined
>>>

从报错的信息上看，说明了 msg_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。

2、全局变量和局部变量

x = 0 #全局变量

def myprint():
x = 2   #局部变量
print("函数内：{}".format(x))

print("函数外：{}".format(x))

if __name__ == '__main__':
myprint()

运行结果：

C:\Python36\python.exe E:/python/test1/second/myfun1.py

函数外：0

函数内：2

x = 0 #全局变量

def myprint():
global x #强制全局变量
x = 2
print("函数内：{}".format(x))

myprint() #调用一次函数，函数才会运行，变量x的值才会变为2
print("函数外：{}".format(x))

运行结果：

C:\Python36\python.exe E:/python/test1/second/myfun1.py

函数内：2

函数外：2