函数二

最新推荐文章于 2024-11-26 18:47:11 发布

怀北_ZY

最新推荐文章于 2024-11-26 18:47:11 发布

阅读量209

点赞数

CC 4.0 BY-SA版权

分类专栏： python基础文章标签： python 基础函数

本文链接：https://blog.youkuaiyun.com/ZY3099492099/article/details/80933594

python基础专栏收录该内容

37 篇文章

订阅专栏

局部变量

<1>什么是局部变量

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

全局变量

<1>什么是全局变量

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

打个比方：有2个兄弟各自都有手机，各自有自己的小秘密在手机里，不让另外一方使用（可以理解为局部变量）；但是家里的电话是2个兄弟都可以随便使用的（可以理解为全局变量）

demo如下:


# 定义全局变量
a = 100

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

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

# 调用函数

test1()

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

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

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

如果在一个函数中需要对多个全局变量进行修改，那么可以使用

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

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

一般在实际开发过程中，一个程序往往由多个函数（后面知识中会讲解类）组成，并且多个函数共享某些数据，这种场景是经常出现的，因此下面来总结下，多个函数中共享数据的几种方式

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()

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


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

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

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

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

3. 函数嵌套调用


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

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

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

函数返回值(二)

在python中我们怎样返回多个值？

<1> 多个return?


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

总结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 divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu  #默认是元组

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

总结2：

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]:

函数参数(二)

<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)

说明：

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

拆包、交换变量的值

<1> 对返回的数据直接拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age


# result = get_my_info()
# print(result)

my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

总结：

拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常

除了对元组拆包之外，还可以对列表、字典等拆包

  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个变量的值

# 第1种方式
# a = 4
# b = 5
# c = 0
#
# c = a
# a = b
# b = c
#
# print(a)
# print(b)

# 第2种方式
# a = 4
# b = 5
# a = a+b  # a=9, b=5
# b = a-b  # a=9, b=4
# a = a-b  # a=5, b=4
# print(a)
# print(b)

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

print(a)
print(b)