python 函数

函数的定义及使用

def 函数名 ():
    """
    这里写函数的注释
    """
    这里写代码，如果是空的函数，用pass来占位结构

# 调用函数
函数名()    

带参函数

• 定义时，函数小括号里的参数称为是形参
• 调用函数时，小括号里参数是实参

def p(a, b):
    print(a, b)

# 传参时，如果不传key，只给数据，就只和位置有关
p(3,4)  

# 传参时带上形参名字做为key，则必须都使用key，接收参数和位置无关，与key有关
p(b=3, a=4)  

函数的返回值

# 定义函数
def add2num(a, b):
    return a+b
    
# 调用函数，顺便保存函数的返回值
result = add2num(100,98)

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

函数的四种类型

无参 无返回值

def printMenu():
    print('--------------------------')
    print('      xx涮涮锅 点菜系统')
    print('')
    print('  1.  羊肉涮涮锅')
    print('  2.  牛肉涮涮锅')
    print('  3.  猪肉涮涮锅')
    print('--------------------------')

printMenu()

无参 有返回值

# 获取温度
def getTemperature():
    # 这里是获取温度的一些处理过程
    # 为了简单起见，先模拟返回一个数据
    return 24

temperature = getTemperature()
print('当前的温度为:%d'%temperature)

有参 无返回值

def qiuhe(a, b):
    """
    接收两个参数，然后计算它们的和输出
    :return: a+b
    """
    print(a + b)

qiuhe(1, 5)

有参 有返回值

def qiuhe(a, b):
    """
    接收两个参数，然后计算它们的和返回
    :return: a+b
    """
    return a + b

result = qiuhe(1, 5)
print(result)

函数的嵌套使用

def test_b():
    print('---- test_b start ----')
    print('这里是test_b函数执行的代码')
    print('---- test_b end ----')


def test_a():
    print('---- test_a start ----')
    test_b()
    print('---- test_a end ----')


test_a()

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

局部变量与全局变量

• 局部变量就是函数内部定义的变量

• 全局变量就是函数外部定义的变量，多个函数都可以调用
  在函数内部使用变量，函数内部没有，去函数外部找变量，此时的变量被称为全局变量

  函数优先调用自己内部的局部变量，如果没有，去找全局变量
  函数外部调用变量，直接查找全局变量是否存在

  a = 10  # 全局变量
  
  def sum():
      a = 20  # 局部变量
      print("内部a: %d" % a) # 优先查找局部变量
  
  
  sum()
  print("外部a %d" % a)  # 只能查找全局变量
  

• global修改全局变量

  a = 10
  
  def sum():
      # a = 20
      global a  # 为了修改全局变量
      a += 10
      print("内部a: %d" % a)
  
  
  sum()
  print("外部a %d" % a)
  

拆包和交换变量值

将包含多个值的变量，按照元素个数和顺序去获取每个值

a = (1, 2)
c, d = a

拆包时要注意,需要拆的数据的个数需要和变量的个数相一致

交换变量值

#  1.定义函数
#  2. 函数内部定义一个列表，包含两个元素
#  3. 函数内部实现列表的第一个元素和第二个元素交换位置
#  4. 输出新列表
#  5. 函数调用

def s():  # 定义函数
   b = [1, 2]   # b[0] b[1] 创建局部变量：列表
   b[0], b[1] = b[1],b[0]  # 交换列表中的两个元素b[0]、b[1]

   print(b)

s()

返回值

• 返回多个值

  1. 有return语句,不一定有返回值
  2. 有返回值，一定是通过return返回
  3. 返回多个值，可以把多个值放在列表、元祖、字典、集合等整体返回
  4. 也可以在return后面直接跟多个值，默认按元组返回

  def s():
     a = 20 	# a,b 局部变量
     b = 10
     return a, b   # 函数已经结束
  
  c = s()      # 此时返回的是元组
  a, b = s()   # 此时把元组拆包分别给a和b， 此时的a,b 全局变量，和函数内部不是一回事
  
  print(c)   #  输出的是元组
  print(a, b)   # 输出的是两个int类型的数字
  

• 多个return语句

  1. 一般在不同情况选择其中一种时，使用多个return语句
  2. 直接写多个return语句，执行第一个return语句，然后直接结束函数

  在函数执行过程中,默认由上而下执行,遇见return直接结束函数

参数

• 缺省参数

  1. 传参时，不指明，第一个实参传给第一个形参，…
  2. 指明实参传递给哪个形参，需要把这个实参放在参数列表的最后面

  #此时已经设置好缺省参数，如果函数调用时，不传参，默认a=3， b=4
  def sum(a=3, b=4): 
      return a +b 
  
  # 函数调用时，会覆盖默认参数， 指明实参传递给哪个形参，需要把这个实参放在参数列表的最后面
  c= sum(7, b=9)  
  print(c)
  

• 不定长参数

  args

  # 把多个值直接接收，放在变量args
  def sum(*args):  
      print(args)
      
  # 传递的多个值直接按照不定长参数传给函数
  sum(1, 2, 3) 
  

  def sum(a, b, *args):
  print(a, b , args)
  sum(1, 2, 3, 4)   #  a 1 b 2 args (3, 4)
  sum(1, 2)   # a 1  b 2   args ()
  

  kwargs

  def sum(**kwargs):
  	print(kwargs)
  
  sum(a=1, b=2)  # 此时kwargs接收的数据类型是字典，{'a': 1, 'b': 2}
  sum()   # {}
  

  *args默认用来传递不定长的值，args接收的数据类型是元组，可以为空
  **kwargs默认用来传递不定长的键和值，kwargs接收的数据类型是字典，可以为空

最后再演示一下所有参数的使用

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

def sum(a, b, *args, c=3, d=4, **kwargs):
   print(a, b, args, c, d, kwargs)

sum(1, 2, 3, 4,c=3,d=4) 
#   a, b, args,   c,  d,  kwargs
#   1  2  (3, 4)  3   4   {}

sum(1, 2, 3, 4,e=3,f=4)
#  a, b, args,   c,  d,  kwargs
#  1  2  (3, 4)  3   4   {'e': 3, 'f': 4}

sum(1, 2, 3, 4,c=5,d=7)
#  a,  b,  args,   c,  d,  kwargs
#  1   2   (3, 4)  5   7   {}