python的函数参数传递都是引用，所以在函数内部会改变原来的参数值。 

  1. def desc_pet(names):
  2.     names[0] = "what?"
  4. names = ["dog", "cat", "eagle"]
  5. desc_pet(names)
  6. print(names)
  7. --
  8. ['what?', 'cat', 'eagle']

函数参数：5种

必选参数和默认参数就不用多说了，主要介绍可变参数和关键字参数以及命名关键字参数。

  1. def desc_pet(animal_type, animal_name):
  2.     print("\n I have a " + animal_type + ".")
  3.     print("it's name is " + animal_name + ".")
  5. desc_pet("dog", "wangwang")
  6. desc_pet(animal_name="miaomiao", animal_type="cat")
  7. --
  8.  I have a dog.
  9. it's name is wangwang.
  11.  I have a cat.
  12. it's name is miaomiao.

可变参数

  1. ###### *作为形参 ######
  2. # *numbers中的星号让python创建一个名为nubmers的空元组，
  3. # 并将收到的所有值都封装到这个元组中
  4. def calc(*numbers):
  5.     """caculate number"""
  6.     print("numbers:", numbers)
  7.     sum = 0
  8.     for n in numbers:
  9.         sum = sum + n * n
  10.     return sum
  12. >>> calc()
  13. numbers: ()
  14. 0
  16. >>> calc(1,2)
  17. numbers: (1, 2)
  18. 5
  20. # 同样，我们可以传一个list或tuple
  21. >>> nums=[1,2,3]
  22. >>> calc(*nums)
  23. numbers: (1, 2, 3)
  24. 14
  26. >>> calc(nums)
  27. numbers: ([1, 2, 3],)
  28. Traceback (most recent call last):
  29.   File "<stdin>", line 1, in <module>
  30.   File "<stdin>", line 6, in calc
  31. TypeError: can't multiply sequence by non-int of type 'list'
  33. # 也可以与其他参数混用
  34. >>> def test(a, b, *arg):
  35. ...   print(a,b, arg)
  36. ...
  37. >>> test(1, 2, 3, 4)
  38. (1, 2, (3, 4))
  39. >>> test(1, 2, 3)
  40. (1, 2, (3,))
  42. ###### *作为实参 ######
  43. >>> def f(a, b, c):
  44. ...   print(a, b, c)
  45. ...
  47. >>> f(1, 2, 3)
  48. 1 2 3
  49. >>> l = [1, 2, 3]
  51. >>> f(*l)
  52. 1 2 3
  54. # 再看几种情况
  55. # 1. l是list时，*l是错误语法
  56. >>> *l
  57.   File "<stdin>", line 1
  58. SyntaxError: can't use starred expression here
  60. # 2. 这样是直接传递一个参数，该参数是一个list
  61. >>> f(l)
  62. Traceback (most recent call last):
  63.   File "<stdin>", line 1, in <module>
  64. TypeError: f() missing 2 required positional arguments: 'b' and 'c'
  66. # 3. 参数传多了
  67. >>> f(*[1,2,3,4])
  68. Traceback (most recent call last):
  69.   File "<stdin>", line 1, in <module>
  70. TypeError: f() takes 3 positional arguments but 4 were given

关键字参数

  1. # **kw中的星号让python创建一个名为kw的空字典，
  2. # 并将收到的所有key-value对都封装到这个字典中。
  3. def person(name, age, **kw):
  4.     print('name:', name, 'age:', age, 'other:', kw)
  6. >>> person('Michael', 30)
  7. name: Michael age: 30 other: {}
  9. >>> person('Adam', 45, gender='M', job='Engineer')
  10. name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
  12. >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
  13. >>> person('Jack', 24, **extra)
  14. name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
  16. ###### ** 作为实参 ######
  17. >>> def f(a, b, c):
  18. ...   print(a, b, c)
  19. ...
  21. >>> d={'b':2, 'c':3}
  22. >>> f(1, **d)
  23. 1 2 3
  25. >>> e = {'b':2, 'd':4}
  26. >>> f(1, e)
  27. Traceback (most recent call last):
  28.   File "<stdin>", line 1, in <module>
  29. TypeError: f() missing 1 required positional argument: 'c'

命名关键字参数

  1. # 只接收city 和 job 作为关键字参数
  2. def person(name, age, *, city, job):
  3.     print(name, age, city, job)
  5. >>> person('Jack', 24, city='Beijing', job='Engineer')
  6. Jack 24 Beijing Engineer
  7. >>> person(age=24, name='Jack', city='Beijing', job='Engineer')
  8. Jack 24 Beijing Engineer
  9. >>> person('Jack', 24, 'Beijing', 'Engineer')
  10. Traceback (most recent call last):
  11.   File "<stdin>", line 1, in <module>
  12. TypeError: person() takes 2 positional arguments but 4 were given
  14. # 第二种方式，可变参数后的参数，默认为命名关键字参数
  15. def person(name, age, *args, city, job):
  16.     print(name, age, args, city, job)
  18. >>> person('Jack', 24, 'Beijing', 'Engineer')
  19. Traceback (most recent call last):
  20.   File "<stdin>", line 1, in <module>
  21. TypeError: person() takes 2 positional arguments but 4 were given

回调函数

例如A是一个函数，他自身作为一个参数，传递给B，在B里被调用，那么A就叫做回调函数，B叫做中间函数。
简单示例如下：

  1. # 回调函数1
  2. def f1(x):
  3.     return x+2
  5. # 回调函数2
  6. def f2(x):
  7.     return x+1
  9. # 中间函数，接受一个函数作为参数
  10. def addANumber(f, x):
  11.     return 1 + f(x)
  13. # main成为起始函数，也就是调用中间函数的函数
  14. def main():    
  15.     i = addANumber(f1, 1)
  16.     i = addANumber(f2, 1)
  18. if __name__ == "__main__":
  19.     main()

内置函数

map

map需要两个参数，一个函数，一个列表，map会把函数依次作用在列表上，并返回一个列表。

  1. >>> def f(x):
  2. ...     return x * x
  3. ...
  4. >>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
  5. [1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3…]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。

  1. reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
  1. >>> def add(x, y):
  2. ...     return x + y
  3. ...
  4. >>> reduce(add, [1, 3, 5, 7, 9])
  5. 25

getattr

顾名思义，这个函数的作用是用来获取类A中的属性值。

  1. # encoding:utf-8
  3. class A(object):
  4.     c = 3
  5.     def __init__(self, a, b):
  6.         self.a = a
  7.         self.b = b
  9. a = A(1, 2)
  10. print(getattr(a, 'a'))
  11. print(getattr(a, 'c'))
  12. -- output
  13. 1
  14. 3

迭代器

  1. class test():
  2.     def __init__(self,data=1):
  3.         print("====init===")
  4.         self.data = data
  6.     def __iter__(self):
  7.         print("====iter===")
  8.         return self
  9.     def __next__(self):
  10.         print("====next===")
  11.         if self.data > 5:
  12.             raise StopIteration
  13.         else:
  14.             self.data+=1
  15.             return self.data
  16. for item in test():
  17.     print(item)

断言 assert

Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况

  1. assert expression
  2. 等价于
  3. if not expression:
  4.     raise AssertionError
  6. 同时，assert后可以跟参数：
  7. >>> assert 1==2, '1 不等于 2'
  8. Traceback (most recent call last):
  9.   File "<stdin>", line 1, in <module>
  10. AssertionError: 1 不等于 2

python3 新特性

变量赋值时指定类型 python 3.6

变量赋值在python3.6以后，可以用 var: type = value ，本质是 var = value ，type是var期望的类型，但是类型注释只是一种提示，并非强制的，Python解释器不会去校验value的类型是否真的是type。

  1. >>> a:int="good"
  2. >>> a
  3. 'good'
  4. >>> type(a)
  5. <class 'str'>

dataclass python3.7