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 "", line 1, in
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 {}".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 "", line 1, in 
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