Python基础之 4. 函数

最新推荐文章于 2021-12-15 09:51:04 发布

程序员老五

最新推荐文章于 2021-12-15 09:51:04 发布

阅读量659

点赞数

分类专栏： Python基础文章标签： python 编程语言

本文链接：https://blog.csdn.net/weixin_45579026/article/details/110351796

版权

Python基础专栏收录该内容

10 篇文章 2 订阅

订阅专栏

一、函数（一）

1. 函数介绍

函数就是一个具有独立功能的代码块，可以提高代码的复用性。

2. 函数定义和调用

1. 定义函数

定义函数的格式如下：

def 函数名():
    代码

demo:

# 定义一个函数，能够完成打印信息的功能
def printInfo():
    print('------------------------------------')
    print('         人生苦短，我用Python')
    print('------------------------------------')

2. 调用函数

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它。
调用函数很简单的，通过 函数名() 即可完成调用

demo:

# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()

3. 注意:

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

3. 函数参数(一)

为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是函数的参数

1. 定义带有参数的函数

示例如下：

def add2num(a, b):
    c = a+b
    print c

2. 调用带有参数的函数

以调用上面的add2num(a, b)函数为例:

def add2num(a, b):
    c = a+b
    print c

add2num(11, 22) # 调用带有参数的函数时，需要在小括号中，传递数据

3. 调用函数时参数的顺序

>>> def test(a,b):
...     print(a,b)
... 
>>> test(1,2)
1 2
>>> test(b=1,a=2)
2 1
>>> 
>>> test(b=1,2)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

4. 小总结

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

4. 函数返回值(一)

1. “返回值”介绍

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

2. 带有返回值的函数

想要在函数中把结果返回给调用者，需要在函数中使用return

如下示例:

def add2num(a, b):
    c = a+b
    return c

或者

def add2num(a, b):
    return a+b

3. 保存函数的返回值

示例如下:

#定义函数
def add2num(a, b):
    return a+b

#调用函数，顺便保存函数的返回值
result = add2num(100,98)

#因为result已经保存了add2num的返回值，所以接下来就可以使用了
print(result)

结果:

5. 函数的嵌套调用

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')

def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')

testA()

结果：

---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----

小总结：
函数嵌套

一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用 函数嵌套调用。
如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置。

6. 函数应用：打印图形和数学计算

思考&实现1

写一个函数打印一条横线
打印自定义行数的横线

参考代码1

# 打印一条横线
def printOneLine():
    print("-"*30)

# 打印多条横线
def printNumLine(num):
    i=0

    # 因为printOneLine函数已经完成了打印横线的功能，
    # 只需要多次调用此函数即可
    while i<num:
        printOneLine()
        i+=1

printNumLine(3)

思考&实现2

写一个函数求三个数的和
写一个函数求三个数的平均值

参考代码2

# 求3个数的和
def sum3Number(a,b,c):
    return a+b+c # return 的后面可以是数值，也可是一个表达式

# 完成对3个数求平均值
def average3Number(a,b,c):

    # 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可
    # 即把接收到的3个数，当做实参传递即可
    sumResult = sum3Number(a,b,c)
    aveResult = sumResult/3.0
    return aveResult

# 调用函数，完成对3个数求平均值
result = average3Number(11,2,55)
print("average is %d"%result)

二、函数（二）

1. 局部变量

1. 什么是局部变量

如下实例所示:

def func1():
    a = 3
    print('test1----修改前：a=%d' % a)
    a = 2
    print('test2----修改后：a=%d' % a)


def func2():
    a = 4
    print('test3---：a=%d' % a)

# 调用函数
func1()
func2()

结果：

test1----修改前：a=3
test2----修改后：a=2
test3---：a=4

2. 小总结

局部变量，就是在函数内部定义的变量
其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的。因为其作用范围只是在自己的函数内部，所以不同的函数可以定义相同名字的局部变量（打个比方，把你、我是当做成函数，把局部变量理解为每个人手里的手机，你可有个iPhone12，我当然也可以有个iPhone12了，互不相关）
局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储
当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了

2. 全局变量

1. 什么是全局变量

demo如下:

# 定义全局变量
a = 100
def test1():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据

def test2():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据

# 调用函数
test1()
test2()

结果：

100
200

小总结:

在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问

2. 全局变量和局部变量名字相同问题

如下实例：

a = 5  # 全局变量
def func1():
    a = 3
    print('test1----修改前：a=%d' % a)
    a = 2
    print('test2----修改后：a=%d' % a)


def func2():
    print('test3---：a=%d' % a)

# 调用函数
func1()
func2()

结果：

test1----修改前：a=3
test2----修改后：a=2
test3---：a=5

小总结

当函数内出现局部变量和全局变量相同名字时，函数内部中的 变量名 = 数据 此时理解为定义了一个局部变量，而不是修改全局变量的值。

3. 修改全局变量

函数中使用全局变量时进行修改：

a = 5  # 全局变量
def func1():
    global a
    print('test1----修改前：a=%d' % a)
    a = 2
    print('test2----修改后：a=%d' % a)


def func2():
    print('test3---：a=%d' % a)

# 调用函数
func1()
func2()

结果：

test1----修改前：a=5
test2----修改后：a=2
test3---：a=5

小总结:

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

# 可以使用一次global对多个全局变量进行声明
global a, b
# 还可以用多次global声明都是可以的
global a
global b

3. 多函数程序的基本使用流程

1. 使用全局变量

g_num = 0

def test1():
    global g_num
    # 将处理结果存储到全局变量g_num中.....
    g_num = 100

def test2():
    # 通过获取全局变量g_num的值, 从而获取test1函数处理之后的结果
    print(g_num)

# 1. 先调用test1得到数据并且存到全局变量中
test1()

# 2. 再调用test2，处理test1函数执行之后的这个值
test2()  # 返回 50

2. 使用函数的返回值、参数

def test1():
     # 通过return将一个数据结果返回
     return 50

def test2(num):
    # 通过形参的方式保存传递过来的数据，就可以处理了
    print(num)

# 1. 先调用test1得到数据并且存到变量result中
result = test1()
print(result)  # 将变量result打印出来

# 2. 调用test2时，将result的值传递到test2中，从而让这个函数对其进行处理
test2(result)

3. 函数嵌套调用

def test1():
    # 通过return将一个数据结果返回
    return 20

def test2():
    # 1. 先调用test1并且把结果返回来
    result = test1()
    # 2. 对result进行处理
    print(result)

# 调用test2时，完成所有的处理
test2()

4. 函数返回值(二)

1. 说明

一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处。
如果程序设计为如下，是可以的因为不同的场景下执行不同的return：

def create_nums(num):
      print("---1---")
      if num == 100:
          print("---2---")
          return num+1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
      else:
          print("---3---")
          return num+2
      print("---4---")

  result1 = create_nums(100)
  print(result1)  # 打印101
  result2 = create_nums(200)
  print(result2)  # 打印202

2. 一个函数返回多个数据的方式

def calc_num(a, b):
    num1 = a//b
    num2 = a%b 
    return num1, num2  #默认是元组

result = calc_num(5, 2)
print(result)  # 输出(2, 1)

总结

return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据

def function():
    # return [1, 2, 3]
    # return (1, 2, 3)
    return {"num1": 1, "num2": 2, "num3": 3}

如果return后面有多个数据，那么默认是元组

In [1]: a = 1, 2
In [2]: a
Out[2]: (1, 2)

In [3]:
In [3]: b = (1, 2)
In [4]: b
Out[4]: (1, 2)

In [5]:

5. 函数参数(二)

1. 缺省参数

调用函数时，缺省参数的值如果没有传入，则取默认值。

下例会打印默认的age，如果age没有被传入：

def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)
   print("age %d" % age)

# 调用printinfo函数
printinfo(name="miki")  # 在函数执行过程中 age去默认值35
printinfo(age=9 ,name="miki")

以上实例输出结果：

name: miki
age: 35
name: miki
age: 9

总结：

在形参中默认有值的参数，称之为缺省参数
注意：带有默认值的参数一定要位于参数列表的最后面。

  >>> def printinfo(name, age=35, sex):
  ...     print name
  ...
    File "<stdin>", line 1
  SyntaxError: non-default argument follows default argument

2. 不定长参数

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

基本语法如下：

def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]

注意：

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

>>> def fun(a, b, *args, **kwargs):
...     """不定长参数演示示例"""
...     print("a =%d" % a)
...     print("b =%d" % b)
...     print("args:")
...     print(args)
...     print("kwargs: ")
...     for key, value in kwargs.items():
...         print("key=%s" % value)
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
a = 1
b = 2
args:
(3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d)    # 注意元组与字典的传参方式
a = 1
b = 2
args:
(3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args:
((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>

3. 缺省参数在*args后面

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)
# a = 100, b = 1, c = 2, *args = 200, 300, 400, 500, 600, 700, **kwargs = mm=800,  nn=900
# *args 为元组类型；**kwargs 为字典类型

结果：

100
1
2
(200, 300, 400, 500, 600, 700)
{'mm': 800, 'nn': 900}

说明：

如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到 *args的后面，但如果有**kwargs的话，**kwargs必须是最后的。

6. 拆包、交换变量的值

1. 对返回的数据直接拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age
result = get_my_info()
print(result)
print('***********')
my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

结果：

(178, 100, 18)
***********
178
100
18

总结：

拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常；
除了对元组拆包之外，还可以对列表、字典等拆包。

  In [17]: a, b = (11, 22)
  In [18]: a
  Out[18]: 11
  In [19]: b
  Out[19]: 22

  In [20]: a, b = [11, 22]
  In [21]: a
  Out[21]: 11
  In [22]: b
  Out[22]: 22

  In [23]: a, b = {"m":11, "n":22}  # 取出来的是key，而不是键值对
  In [24]: a
  Out[24]: 'm'
  In [25]: b
  Out[25]: 'n'

2. 交换2个变量的值

# 第3种方式
a = 4
b = 5
a, b = b, a

print(a)  # 5
print(b)  # 4

7. 引用

1. 引用介绍

在python中，值是靠引用来传递来的。

我们可以用id()来判断两个变量是否为同一个值的引用。我们可以将id值理解为那块内存的地址标示。

>>> a = 1
>>> b = a
>>> id(a) 
13033816
>>> id(b)   # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a)   # 注意a的id值已经变了
13033792
>>> id(b)   # b的id值依旧
13033816

>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)       # 注意a与b始终指向同一个地址
139935018544808

总结：

之前为了更好的理解变量，咱们可以把a=100理解为变量a中存放了100，事实上变量a存储是100的引用（可理解为在内存中的一个编号）

2. 引用当做实参

def test1(b):  	# 变量b一定是一个局部变量，就看它指向的是谁？可变还是不可变
    b += b  	# += 是直接对b指向的空间进行修改,而不是让b指向一个新的
    # b = b+b  	# xx = xx+yyy 先把=号右边的结果计算出来,然后让b指向这个新的地方,不管原来b指向谁，现在b一定指向这个新的地方

# a = [11, 22]
a = 100
test1(a)
print(a)

总结：

Python中函数参数是引用传递（注意不是值传递）
对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量

8. 可变、不可变类型

](https://img-blog.csdnimg.cn/20201130153414445.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTU3OTAyNg==,size_16,color_FFFFFF,t_70)
总结