python8_Python8--函数

1.什么是函数

我们在写程序的时候会多次使用重复的代码，函数就可以简化这种重复。我们在函数里写重复的内容， 然后等需要使用的时候直接调用就可以

Python函数定义的通常格式为：

def 函数名(参数列表):

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

函数体

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

2. 定义函数

先进入到python的命令行模式

➜ ~ source yiluo/bin/activate

(yiluo) ➜ ~ python3

Python 3.7.5 (default, Nov 29 2019, 14:32:46)

[Clang 9.0.0 (clang-900.0.39.2)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

>>>

创建一个输出任意范围内 Fibonacci数列的函数:

>>> def fib(n):

... a, b = 0, 1

... while a

... print(a, end=' ')

... a, b = b, a+b

... print()

...

>>> fib(2000)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

【1】.def 关键字定义函数

【2】.函数体的第一个语句可以(可选的)是字符串文字

【3】.函数的 执行 会引入一个用于函数局部变量的新符号表

【4】.在函数被调用时，实际参数(实参)会被引入被调用函数的本地符号表中

【5】.函数名称的值具有解释器将其识别为用户定义函数的类型。这个值可以分配给另一个名称

>>> fib

>>> f = fib

>>> f(100)

0 1 1 2 3 5 8 13 21 34 55 89

写一个返回斐波那契数列的列表(而不是把它打印出来)的函数

>>> def fib2(n):

... result = []

... a, b = 0, 1

... while a

... result.append(a)

... a, b =b ,a+b

... return result

...

>>> f100 = fib2(100)

>>> f100

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

>>>

3.内置函数

内置函数就是 Python解释器中不用引入任何包，一直可以使用的函数义和调用

图片来自官方文档

常用的len type abs来看一下

>>> a = 'hello'

>>> len(a)

5

>>> type(a)

>>> b = -1

>>> abs(b)

1

len获取来字符串的个数

type获取了类型是字符串

abs是绝对值函数 -1的绝对值是1

4.变量作用域

局部变量和全局变量

创建一个文件，然后vim进行编辑

(yiluo) ➜ Code touch a.py

(yiluo) ➜ Code vim a.py

#!/usr/bin/env python3

def demo():

n = 100

print(n)

n = 1

print("Before demo ", n)

print("Inside demo", end=' ')

demo()

print("After demo", n)

保存文件然后命令行执行看一下结果

(yiluo) ➜ Code python a.py

Before demo 1

Inside demo 100

After demo 1

以上 n=1 是全局变量， n=100是局部变量

例子2

#!/usr/bin/env python3

def test_local():

name = "Yiluo"

print(name)

name = 'Tom'

print('Before', name)

print('inside',end = ' ')

test_local()

print('After', name)

执行结果

➜ code python3 local.py

Before Tom

inside Yiluo

After Tom

5. global关键字

#!/usr/bin/env python3

def demo2():

global n

n = 100

print(n)

n = 1

print("Before demo2", n)

print("Inside demo2", end=' ')

demo2()

print("After demo2", n)

保存文件，然后在命令行模式下运行

(yiluo) ➜ Code python b.py

Before demo2 1

Inside demo2 100

After demo2 100

举例2

>>> name = 'Yiluo'

>>> def test_local():

... print(name)

... name = 'Tom'

...

>>> test_local()

Traceback (most recent call last):

File "", line 1, in

File "", line 2, in test_local

UnboundLocalError: local variable 'name' referenced before assignment

当执行到 print(name) 的时候会报错，因为 name作为函数局部变量是在 print(name)之后才定义的

现在我们使用 global 关键字，对函数中的 name 标志为全局变量，让函数内部使用全局变量的name，那么整个程序中出现的 name都将是这个

>>> name = 'Tom'

>>> def name_global():

... global name

... print(name)

... name = 'Yiluo'

...

>>> print(name)

Tom

>>> name_global()

Tom

>>> print(name)

Yiluo

关键字 global来告诉 name 的定义是全局的，因此在函数内部更改了 name的值，函数外 name 的值也实际上更改了

6.函数的参数

Python 常用参数有四种：必选参数、默认参数、可变参数和关键字参数，复合使用时各类参数的定义顺序须同上

1. 必选参数

>>> def student(name, age):

... print("NAME: ", name)

... print("AGE: ", age)

...

>>> student('yiluo', 18)

NAME: yiluo

AGE: 18

也可是使用参数名进行传参

>>> student(name='yiluo', age=18)

NAME: yiluo

AGE: 18

必选参数可以不写参数名，但必须对其赋值，参数赋值顺序是定义的时候指定的，所以必选参数又称为位置参数

>>> def info(student_id, student_name):

... print("Student ID: ", student_id)

... print("Student Name: ", student_name)

...

>>> info(1, 'Yiluo')

Student ID: 1

Student Name: Yiluo

>>> info('Yiluo', 2)

Student ID: Yiluo

Student Name: 2

>>> info(student_name='Yiluo', student_id=1)

Student ID: 1

Student Name: Yiluo

2. 默认参数

>>> def student(name, age=18):

... print("NAME: ", name)

... print("AGE: ", age)

...

>>> student('yiluo')

NAME: yiluo

AGE: 18

>>> student('yiluo', 20)

NAME: yiluo

AGE: 20

如果不传年龄会自动给出默认年龄值

例子2

>>> def info(student_name, student_id, city='深圳'):

... print("Student ID: ", student_id)

... print("Student Name: ", student_name)

... print('City: ', city)

...

>>> info('Yiluo', 1)

Student ID: 1

Student Name: Yiluo

City: 深圳

>>> info('Yiluo', 1, '上海')

Student ID: 1

Student Name: Yiluo

City: 上海

默认参数没有赋值，则会自动赋其默认值

默认参数后面不能再有必选参数，例如 f(a,b=90,c) 就是错误的

默认参数的默认值必须设为不可变的数据类型(如字符串、元组、数字、布尔值、None 等)

3. 可变参数

可变参数的定义格式是在参数名前面加上 * ，参数名可以自定义，通常写成 *args

>>> def student(name, age=19, *score):

... print("NAME: ", name)

... print("AGE: ", age)

... print("SCORE: ", score)

...

>>> student('yiluo',19,88,90,100)

NAME: yiluo

AGE: 19

SCORE: (88, 90, 100)

学生的得分分别是 88，90，100

4. 关键字参数

关键字参数的定义格式是在参数名前面加上 ** ，参数名可以自定义，通常写成 **kw

>>> def student(name, age, **score):

... print("NAME: ", name)

... print("AGE: ", age)

... print("SCORE: ", score)

>>> score = {'数学':'88', '语文':'90','英语':'100'}

>>> student('yiluo', 19, **score)

NAME: yiluo

AGE: 19

SCORE: {'数学': '88', '语文': '90', '英语': '100'}

(必选参数、默认参数、可变参数)在赋值时都可以不写参数名，而关键字参数允许传入零个或任意多个带参数名的参数，其中参数名可自定义

关键字参数会在函数内部自动生成一个字典

关键字参数的定义格式是在参数名前面加上 **

参数名可以自定义，通常写成 **kw

函数体内部使用该参数时，前面不要加 **

5. 命名关键字参数

前文提到，必选参数、默认参数、可变参数在赋值时都可以不写参数名，而命名关键字参数恰好相反， 赋值时必须写上参数名

>>> def student(*, name):

... print("Hello", name)

...

>>> student('yiluo')

Traceback (most recent call last):

File "", line 1, in

TypeError: student() takes 0 positional arguments but 1 was given

>>> student(name='yiluo')

Hello yiluo

赋值时必须写上参数名

此参数的特征就是前面有一个用逗号隔开的 *

用户调用函数时，每一个命名关键字参数都必须使用相应的参数名赋值，否则会抛出 TypeError

>>> def hi(*, name):

... print('hi ', name)

...

>>> hi('Yiluo')

Traceback (most recent call last):

File "", line 1, in

TypeError: hi() takes 0 positional arguments but 1 was given

>>> hi(name='Yiluo')

hi Yiluo

6. 函数中修改参数值

函数参数传值的意思是函数调用过程中，在函数内部使用到的参数只是一个局部变量，在函数执行结束后就销毁了。不影响调用该函数的外部参数变量的值

函数参数传引用的意思是传递给函数的参数就是外部使用的参数，函数执行过程中对该参数进行的任何修改都会保留，当函数调用结束后，这个参数被其他代码使用中都是函数修改过后的数据

Python 函数的参数是没有类型的，可以传递任意类型的对象作为参数。但不同类型的参数在函数中，有的可以修改(例如列表对象)，有的不可以修改(例如字符串对象)

>>> ipaddress = '192.168.1.168'

>>> ports = [11, 12, 13]

>>> def connect(ipaddress, ports):

... print("IP: ", ipaddress)

... print('Ports: ', ports)

... ipaddress = '10.10.10.1'

... ports.append(8000)

...

>>> print(ipaddress, ports)

192.168.1.168 [11, 12, 13]

>>> connect(ipaddress, ports)

IP: 192.168.1.168

Ports: [11, 12, 13]

>>> connect(ipaddress, ports)

IP: 192.168.1.168

Ports: [11, 12, 13, 8000]

>>> connect(ipaddress, ports)

IP: 192.168.1.168

Ports: [11, 12, 13, 8000, 8000]

>>> print(ipaddress, ports)

192.168.1.168 [11, 12, 13, 8000, 8000, 8000]

ipaddress 的值没有起到效果，但 ports 列表的值却改变了

Python 中的对象有不可变对象，指的是数值、字符串、元组等，和可变对象，指的是列表、字典等。如果是不可变对象作为参数，函数中对该参数的修改只能用等号赋值，实际上是创建了一个新的局部变量。如果是可变对象作为参数，函数中的修改会保留

欢迎下方【戳一下】【点赞】

Author：伊洛Yiluo

愿你享受每一天，Just Enjoy !