Python学习八—— 函数上

1. 函数简介

• 1.1 函数也是一个对象
• 1.2 函数的特点
  • 函数用来保存一些可以执行的代码，并且在需要的时候，可以多次去调用
  • 函数中保存的代码不会立即执行，需要调用的时候代码才会执行
• 1.3 定义一个函数: def fn( )
• 1.4 补充知识点：对于函数中有return和没有的区别，如果函数中没有return返回值，则当调用此函数，并且print函数的时候，则会打印None值，切记！！！

2. 函数参数

• 2.1 形参参数：在定义函数的时候，可以在函数后面的括号里定义数量不等的形参，形参就是形式上的参数，多个参数之间必须用逗号间隔

• 2.2 实参参数：是会赋值给对应的形参的参数，有几个形参就需要几个实参
  例子1： 形参和实参的数量对应

  def kyle(a, b):
      print(a + b)
      # return
  kyle(1, 3)
  

  打印结果为：

  4

  例子2：当实参中少写一个值的情况下，会报错kyle() missing 1 required positional argument: ‘b’

  def kyle(a, b):
      print(a + b)
      # return
  kyle(1)
  
  

  打印结果为：

  Traceback (most recent call last):
  File “D:/pythonKYLE/logic_homework/Day8_函数作业.py”, line 4, in <module>
  kyle(1)
  TypeError: kyle() missing 1 required positional argument: ‘b’

3. 函数的参数传递方式

• 3.1 形参可以指定一个默认值，当指定默认值后，实参对应值可以不用指定
  例子：

  def kyle(a, b, c = 100):
      print('a = ', a)
      print('b = ', b)
      print('c = ', c)
      num = a + b + c
      print('num = ', num)
      # return
  kyle(1, 2)
  

  打印记过为：

  a = 1
  b = 2
  c = 100
  num = 103

• 3.2 位置传参，将对应位置上的实参赋值给对应位置上的形参

• 3.3 关键字传参，可以不按照定义的顺序传递实参，根据参数名去传递参数
  例子1：

  def kyle(a, b, c = 100):
      print('a = ', a)
      print('b = ', b)
      print('c = ', c)
      num = a + b + c
      print('num = ', num)
      # return
  kyle(b=10, a=2, c=1)
  

  打印结果为：

  a = 2
  b = 10
  c = 1
  num = 13

  例子2：关键字传参，如果形参也指定一个默认值的话，实参也是可以对应不写值的

  def kyle(a, b, c = 100):
      print('a = ', a)
      print('b = ', b)
      print('c = ', c)
      num = a + b + c
      print('num = ', num)
      # return
  kyle(b=10, a=2)
  

  打印结果为：

  a = 2
  b = 10
  c = 100
  num = 112

• 3.3 混合使用的时候，必须将位置参数放到最前面，关键字参数放到后面
  例子：

  def kyle(a, b, c):
      print('a = ', a)
      print('b = ', b)
      print('c = ', c)
      num = a + b + c
      print('num = ', num)
      # return
  kyle(10, b=10, c=1)
  
  

  打印结果为：

  a = 10
  b = 10
  c = 1
  num = 21

• 3.4 实参的类型，可以传递任意类型的参数
  例子：

  def fn(a):
      print('a = ', a)
  def fn1(b):
      print('b = ', b)
  def fn2(c):
      print('c = ', c)
  a = 1
  b = True
  c = dict(a=1, b=2)
  fn(a), fn1(b), fn2(c)
  

  打印结果为：

  a = 1
  b = True
  c = {‘a’: 1, ‘b’: 2}

4. 不定长参数

• 4.1 使用*args接收不定长参数，a的对应数据是一个元组，可以和其他的参数配合使用，但是注意*a要放到后面，且带星号的参数有且只有一个
  例子：

  def fn(a, *a1):
      list1 = []
      print('a = ', a)
      # print('b = ', b)
      print('c = ', a1)
      for i in a1:
          i += 10
          list1.append(i)
      print(list1)
  fn(1, 2, 3)
  

  打印结果为：

  a = 1
  c = (2, 3)
  [12, 13]

• 4.2 对于*a只能接收位置参数，不能接收关键字参数，可以用**a来接收关键字参数，a的对应数据是一个字典
  例子1：

  def fn(*a1, **a2):
      list1 = []
      # print('a = ', a)
      print('b = ', a1)
      print('c = ', a2)
      for i in a1:
          i += 10
          list1.append(i)
      print(list1)
      for v in a2.values():
          v -= 10
          list1.append(v)
      print(list1)
  fn(1, 2, 3,a=11,b=12,c=13)
  

  打印结果为：

  b = (1, 2, 3)
  c = {‘a’: 11, ‘b’: 12, ‘c’: 13}
  [11, 12, 13]
  [11, 12, 13, 1, 2, 3]

• 4.3 总结不定长参数

  • 位置形参在前，关键字形参在后，对于不定长形参，也按此规则，*args在前，**kwargs在后。
  • *args传递的是元组，**kwargs传递的是字典
  • *args接收的是位置参数，**kwargs接收的是关键字参数
  • 在形参中不可有两个*args 或者 两个 **kwargs

5. 参数的拆包

• 元组实参的拆包

  def fn(a, b, c):
      print('a = ', a)
      print('b = ', b)
      print('c = ', c)
  tuple1 = (1, 2, 3)
  fn(*tuple1)
  

  打印结果为：

  a = 1
  b = 2
  c = 3

• 字典实参的拆包
  字典里面的键值对可以表示为key=values，这就和关键字传参的格式相同，因此对于字典的拆包参考以下的例子

  def fn(a, b, c):
      print('a = ', a)
      print('b = ', b)
      print('c = ', c)
  dict1  = dict(a=1, b=2, c=3)
  fn(*dict1) #因为是关键字传参，所以用*args作为实参，只能传递字典的Key
  print('-' * 50)
  fn(**dict1)  #只有通过**kwargs来传递字典的values
  

  打印结果为：

  a = a
  b = b
  c = c

  ---

  a = 1
  b = 2
  c = 3

• 可变类型与不可变类型: 个人总结就是有pop函数的数据类型就是可变类型，否则是不可变类型，可以想象内存中数据的增加与删除，只是值的长度在变化，数据ID不会改变

  • 可变类型是value变的时候，Id不变

    • list,dict,set
      例子：

      Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
      list1 = [1, 2, 3]
      id(list1),list1
      (2189576885704, [1, 2, 3])
      list1[0] = 10
      id(list1), list1
      (2189576885704, [10, 2, 3])
      

  • 不可变类型，value变的话，ID也变

    • str ,tuple

      例子：

      str1 = 'python'
      id(str1),str1
      (2189568630888, 'python')
      str1 = str1.upper()
      id(str1),str1
      (2189572247600, 'PYTHON')