1. 函数简介

  • 函数也是一个对象
  • 函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用
    1. 语法
    2. def 函数名([形参1,形参2,形参3....]):
    3.   代码块
    注意：
    函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
    print是函数对象 print()是调用函数 ```python def fun(): # def 函数名（）： 就是定义函数 print(‘这是我的第一个函数’)

调用函数 函数对象（） fun() fun是函数对象 fun() 是调用函数

fun()

  1. <a name="ENh6R"></a>
  2. ## 2. 函数的参数
  3. <a name="uVdUZ"></a>
  4. ### 2.1 形参和实参
  6. - 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
  7. - 实参(实际参数)指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参
  8. ```python
  9. # 需求： 定义一个函数求任意2个数的和
  10. # 在函数中定义形参，相当于在函数内声明了变量
  11. def fun(a, b):  # a, b  是形参  就是形式上的参数  ，你如果定义了形参，那么就必须在调用的时候传递实参
  12.     print(a + b)
  15. fun(1, 2)  # 1, 2 是实参，也就是实际参数

2.2 函数的参数传递方式

  • 定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效
  • 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
  • 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
  • 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去 ```python def fun(a, b, c=20): # 参数可以再设置形参的时候，直接给他设置一个默认值, 如果实参没有传递参数，那么直接使用默认值，如果实参传递了，那么就是用实参 print(a) print(b) print(c)

fun(1, 2, 3)

1 2 3 =====================================0

位置传参 就是讲对应位置上的实参赋予给对应位置上的形参

def fun1(a, b, c): print(a) print(b) print(c)

fun1(1, 2, 3)

1 2

3

关键字传参 可以不按照定义的顺序去进行参数的传递，根据参数名去传递实参

def fun2(a, b, c): print(a) print(b) print(c)

fun2(b=1, a=2, c=3)

2 1 3

===================================================

混合使用 位置传参必须放到关键字传参的前面

def fun2(a, b, c): print(a) print(b) print(c)

fun2(2, c=1, b=2)

2 2 1

===========================================

任意类型的参数都是可以传递的

def fun1(): pass

def fun(a): print(a)

b = 12 b = ‘12’ b = None b = True b = [1, 2, 3] b = fun1 fun(b)

  1. <a name="V6eJK"></a>
  2. ## 3. 不定长参数
  4. - 定义函数时，可以在形参前面加一个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中
  5. - 带*号的形参只能有一个，可以和其他参数配合使用
  6. - *形参只能接受位置参数，不能接受关键字参数
  7. - **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值
  8. - **形参只有一个，并且必须写在所有参数的后面
  9. ```python
  10. # 需求： 求任意个数的和
  11. # *不定长参数必须放到位置参数后面, 放到关键字参数的前面
  12. def fun(*a):
  13.     r = 0
  14.     print(a)
  15.     for i in a:
  16.         r += i
  17.     print(r)
  19. fun(1,2,3,4,5)
  20. --------------------
  21. (1, 2, 3, 4, 5)
  22. 15
  23. ============================
  24. def fun(b, *a, c):
  25.     r = 0
  26.     for i in a:
  27.         r += i
  28.     print('a = ', a)
  29.     print('b = ', b)
  30.     print('c = ', c)
  31.     print('和: ', r)
  32. ---------------------------
  33. a =  (2, 3, 4)
  34. b =  1
  35. c =  5
  36. 和:  9
  38. =================================================
  39. # **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。**不定长参数必须放到位置参数和关键字参数的后面
  40. # 不定长参数在一个函数中不管是*还是**都只能存在一个，而且*必须要在**之前
  41. # (*args , **kwargs)
  42. def fun(*y, a, **f):
  43.     r = 0
  44.     for i in f.values():
  45.         r += i
  46.     print('y = ',y)
  47.     print('a = ', a)
  48.     print('f = ', f)
  49.     print('sum =', r)
  51. fun(2, 1, a=1, b=2, c=3, d=4, e=5)
  52. ---------------------------------
  53. y =  (2, 1)
  54. a =  1
  55. f =  {'b': 2, 'c': 3, 'd': 4, 'e': 5}
  56. sum = 14

4. 参数的解包

  • 传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递
  • 要求序列中的元素的个数必须和形参的个数一致 ```python def fun(a, b, c): print(a) print(b) print(c)

t = (4, 5, 6)

fun(*t)

4 5

6

def fun(a, b, c): print(a) print(b) print(c)

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

fun(*t)

a b

c

def fun(a, b, c): print(a) print(b) print(c) t = (4, 5, 6) fun(t[0], t[1], t[2])

fun(*t)

4 5 6 4 5

6

def fun(a, b, c): print(a) print(b) print(c)

t = {‘a’: 1, ‘b’: 2, ‘c’: 3} fun(*t)

fun(**t)

a b c 1 2 3

  1. <a name="nbM9n"></a>
  2. ### 作业
  4. 1. 打印名片程序:输入姓名，电话号码，性别，最后打印出来名片
  5.    - 控制姓名长度为6-20
  6.    - 电话号码长度11
  7.    - 性别只能允许输入男或女
  8.    - 每一样信息不允许为空
  9. ```python
  10. def namecard(name, phone, sex):
  11.     print('姓名: ', name)
  12.     print('电话号码: ', phone)
  13.     print('性别: ', sex)
  15. name = input('请输入姓名：')
  16. while (len(name) > 20) | (len(name) < 6):
  17.     name = input('姓名长度不对，必须是6-20, 请重新输入:')
  18. phone = input('请输入电话号码：')
  19. while len(phone) != 11:
  20.     phone = input('电话号码长度不是11位，请重新输入: ')
  21. sex = input('请输入性别：')
  22. while sex not in {'男', '女'}:
  23.     sex = input('性别必须是男或女，请重新输入：')
  24. namecard(name, phone, sex)
  25. -------------------------------------
  26. 请输入姓名：zhang
  27. 姓名长度不对，必须是6-20, 请重新输入:
  28. 姓名长度不对，必须是6-20, 请重新输入:Zhang Shan
  29. 请输入电话号码：123456789
  30. 电话号码长度不是11位，请重新输入: 1234567890234
  31. 电话号码长度不是11位，请重新输入: 12345678900
  32. 请输入性别：中
  33. 性别必须是男或女，请重新输入：男
  34. 姓名:  Zhang Shan
  35. 电话号码:  12345678900
  36. 性别:  男
  1. 使用函数求前20个斐波那契数列斐波那契数列：1,1,2,3,5,8,13,21…即: 起始两项均为1，此后的项分别为前两项之和 ```python

    1

    i = 1 j = 1 while i <1000: print(i, end = ‘ ‘) i, j = j, i + j

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

2

def fib(i, j, m): k = 0 while i < m: print(i, end=’ ‘) i, j = j, i +j

fib(1, 1, 1000) # 1, 1 初始值，1000为范围

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 

  3. 2. 编写一段代码，定义一个函数求1-100之间所有整数的和，并调用该函数打印出结果
  4. ```python
  5. def sum(a, b):
  6.     sum = 0
  7.     i = a
  8.     for i in range(b):
  9.         sum = sum + i
  10.     print('sum = ', sum)
  12. sum(1, 100)
  14. -----------------
  15. sum =  4950