(笔记)-Python进阶

Python进阶

官方文档：https://docs.python.org/3.9/

一、函数

• 内置函数

  		内置函数3.9.2
  abs()	delattr()	hash()	memoryview()	set()
  all()	dict()	help()	min()	setattr()
  any()	dir()	hex()	next()	slice()
  ascii()	divmod()	id()	object()	sorted()
  bin()	enumerate()	input()	oct()	staticmethod()
  bool()	eval()	int()	open()	str()
  breakpoint()	exec()	isinstance()	ord()	sum()
  bytearray()	filter()	issubclass()	pow()	super()
  bytes()	float()	iter()	print()	tuple()
  callable()	format()	len()	property()	type()
  chr()	frozenset()	list()	range()	vars()
  classmethod()	getattr()	locals()	repr()	zip()
  compile()	globals()	map()	reversed()	__import__()
  complex()	hasattr()	max()	round()

• 定义函数

  ​ 在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

  def my_abs(x):
      if x >= 0:
          return x
      else:
          return -x
  

• 空函数

  ​ 如果想定义一个什么事也不做的空函数，可以用pass语句：

  def nop():
      pass
  

• 返回多个值

  ​ 比如坐标：

  import math #math包中包含sin,cos等函数
  
  def move(x, y, step, angle=0):
      nx = x + step * math.cos(angle)
      ny = y - step * math.sin(angle)
      return nx, ny
  

  ​ 然后，我们就可以同时获得返回值：

  >>> x, y = move(100, 100, 60, math.pi / 6)
  >>> print(x, y)
  151.96152422706632 70.0
  

  ​ 但其实这只是一种假象，Python函数返回的仍然是单一值：

  >>> r = move(100, 100, 60, math.pi / 6)
  >>> print(r)
  (151.96152422706632, 70.0)
  

  ​ 返回值是一个tuple,但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

  """
  练习：
  请定义一个函数quadratic(a, b, c)，
  接收3个参数，返回一元二次方程 
  ax^2+bx+c=0的两个解。
  """
  import math 
  
  def quadratic(a, b, c):
  
      d = b**2-4*a*c
  
      if d >= 0:
  
          d = math.sqrt(d)
  
          return (-b+d)/(2*a), (-b-d)/(2*a)
  
      else:
  
          return'无解'
  
  
  print(quadratic(int(input()), int(input()), int(input())))
  
  
  

• 函数的默认参数

  ​ 必选参数在前，默认参数在后，否则Python的解释器会报错，当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

  ​ 我们可以把年龄和城市设为默认参数：

  def enroll(name, gender, age=6, city='Beijing'):
      print('name:', name)
      print('gender:', gender)
      print('age:', age)
      print('city:', city)
  
  

  ​ 这样，大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数：

  >>> enroll('Sarah', 'F')
  name: Sarah
  gender: F
  age: 6
  city: Beijing
  

  ​ 只有与默认参数不符的学生才需要提供额外的信息：

  enroll('Bob', 'M', 7)
  enroll('Adam', 'M', city='Tianjin')
  

  ​ 默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑，演示如下：

  #先定义一个函数，传入一个list，添加一个`END`再返回：
  def add_end(L=[]):
      L.append('END')
      return L
  

  ​ 当你正常调用时，结果似乎不错：

  >>> add_end([1, 2, 3])
  [1, 2, 3, 'END']
  >>> add_end(['x', 'y', 'z'])
  ['x', 'y', 'z', 'END']
  

  ​ 当你使用默认参数调用时，一开始结果也是对的：

  >>> add_end()
  ['END']
  

  ​ 但是，再次调用add_end()时，结果就不对了：

  >>> add_end()
  ['END', 'END']
  >>> add_end()
  ['END', 'END', 'END']
  

  ​ 原因解释如下：Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

    *定义默认参数要牢记一点：默认参数必须指向不变对象！*
  

  ​ 要修改上面的例子，我们可以用None这个不变对象来实现：

  def add_end(L=None):
      if L is None:
          L = []
      L.append('END')
      return L
  

  ​ 现在，无论调用多少次，都不会有问题：

  >>> add_end()
  ['END']
  >>> add_end()
  ['END']
  

  ​ 为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

• 可变参数

  ​ 在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

  #定义一个需要多个参数进行计算的函数
  def calc(numbers):
      sum = 0
      for n in numbers:
          sum = sum + n
      return sum
  #但是调用的时候，需要先组装出一个list或tuple：
  >>> calc([1, 2, 3])
  6
  

  ​ 我们把函数的参数改为可变参数：

  def calc(*numbers):
      sum = 0
      for n in numbers:
          sum = sum + n
      return sum
  #如果利用可变参数，调用函数的方式可以简化成这样：
  >>> calc(1, 2, 3)
  6
  

  ​ 定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

  >>> calc(1, 2)
  5
  >>> calc()
  0
  

  ​ 如果已经有一个list或者tuple，要调用一个可变参数怎么办？所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

  >>> nums = [1, 2, 3]
  >>> calc(*nums)
  6
  

  ​ *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

• 关键字参数

  ​ 可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

  def person(name, age, **kw):
      print('name:', name, 'age:', age, 'other:', kw)
  

  ​ 函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数：

  >>> person('Michael', 30)
  name: Michael age: 30 other: {}
  

  ​ 也可以传入任意个数的关键字参数：

  >>> person('Bob', 35, city='Beijing')
  name: Bob age: 35 other: {'city': 'Beijing'}
  >>> person('Adam', 45, gender='M', job='Engineer')
  name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
  

  ​ 关键字参数可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

  ​ 和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

  >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
  >>> person('Jack', 24, city=extra['city'], job=extra['job'])
  name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
  

  ​ 当然，上面复杂的调用可以用简化的写法：

  >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
  >>> person('Jack', 24, **extra)
  name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
  

  ​ **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

• 命名关键字参数

  ​ 对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。

  仍以person()函数为例，我们希望检查是否有city和job参数：

  def person(name, age, **kw):
      if 'city' in kw:
          # 有city参数
          pass
      if 'job' in kw:
          # 有job参数
          pass
      print('name:', name, 'age:', age, 'other:', kw)
  

  ​ 但是调用者仍可以传入不受限制的关键字参数：

  >>> person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)
  

  ​ 如果要限制关键字参数的名字，就可以用命名关键字参数，例如只接收city和job作为关键字参数。

  def person(name, age, *, city, job):
      print(name, age, city, job)
  

  ​ 和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

  ​ 调用方式如下：

  >>> person('Jack', 24, city='Beijing', job='Engineer')
  Jack 24 Beijing Engineer
  

  ​ 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

  def person(name, age, *args, city, job):
      print(name, age, args, city, job)
  

  ​ 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

  >>> person('Jack', 24, 'Beijing', 'Engineer')
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: person() takes 2 positional arguments but 4 were given
  

  ​ 由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。

  ​ 命名关键字参数可以有缺省值，从而简化调用：

  def person(name, age, *, city='Beijing', job):
      print(name, age, city, job)
  

  ​ 由于命名关键字参数city具有默认值，调用时，可不传入city参数：

  >>> person('Jack', 24, job='Engineer')
  Jack 24 Beijing Engineer
  

  ​ 使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：

  def person(name, age, city, job):
      # 缺少 *，city和job被视为位置参数
      pass
  

• 参数组合

  ​ 在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

  ​ 比如定义一个函数，包含上述若干种参数：

  def f1(a, b, c=0, *args, **kw):
      print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
  
  def f2(a, b, c=0, *, d, **kw):
      print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
  

  ​ 在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

  >>> f1(1, 2)
  a = 1 b = 2 c = 0 args = () kw = {}
  >>> f1(1, 2, c=3)
  a = 1 b = 2 c = 3 args = () kw = {}
  >>> f1(1, 2, 3, 'a', 'b')
  a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
  >>> f1(1, 2, 3, 'a', 'b', x=99)
  a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
  >>> f2(1, 2, d=99, ext=None)
  a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
  

  ​ 最神奇的是通过一个tuple和dict，你也可以调用上述函数：

  >>> args = (1, 2, 3, 4)
  >>> kw = {'d': 99, 'x': '#'}
  >>> f1(*args, **kw)
  a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
  >>> args = (1, 2, 3)
  >>> kw = {'d': 88, 'x': '#'}
  >>> f2(*args, **kw)
  a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
  

  ​ 所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。