函数返回值(二)

在python中我们怎样返回多个值？


<1> 多个return?

def create_nums():
    print("---1---")
    return 1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
    print("---2---")
    return 2
    print("---3---")

总结1：
· 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处
[size=10.0000pt]·
如果程序设计为如下，是可以的因为不同的场景下执行不同的return
[size=10.0000pt]·
      def create_nums(num):
          print("---1---")
          if num == 100:
              print("---2---")
              return num+1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
          else:
              print("---3---")
              return num+2
          print("---4---")

      result1 = create_nums(100)
      print(result1)  # 打印101
      result2 = create_nums(200)
      print(result2)  # 打印202
[size=10.0000pt]·


<2> 一个函数返回多个数据的方式


def divid(a, b):
    shang = a//b
    yushu = a%b
    return shang, yushu  #默认是元组

result = divid(5, 2)
print(result)  # 输出(2, 1)


总结2：
· return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据
      def function():
          # return [1, 2, 3]
          # return (1, 2, 3)
          return {"num1": 1, "num2": 2, "num3": 3}
[size=10.0000pt]·
[size=10.0000pt]·
如果return后面有多个数据，那么默认是元组
[size=10.0000pt]·
      In [1]: a = 1, 2
      In [2]: a
      Out[2]: (1, 2)

      In [3]:
      In [3]: b = (1, 2)
      In [4]: b
      Out[4]: (1, 2)

      In [5]:
[size=10.0000pt]·

函数参数(二)


<1>. 缺省参数


调用函数时，缺省参数的值如果没有传入，则取默认值。
下例会打印默认的age，如果age没有被传入：
def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)
   print("age %d" % age)
# 调用printinfo函数
printinfo(name="miki")  # 在函数执行过程中 age去默认值35
printinfo(age=9 ,name="miki")


以上实例输出结果：
name: miki
age: 35
name: miki
age: 9


总结1：
· 在形参中默认有值的参数，称之为缺省参数
· 注意：带有默认值的参数一定要位于参数列表的最后面
      >>> def printinfo(name, age=35, sex):
      ...     print name
      ...
        File "<stdin>", line 1
      SyntaxError: non-default argument follows default argument
[size=10.0000pt]·


<2>. 不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。


基本语法如下：
    def functionname([formal_args,] *args, **kwargs):
       """函数_文档字符串"""
       function_suite
       return [expression]


注意：
· 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
· 而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.
>>> def fun(a, b, *args, **kwargs):
...     """可变参数演示示例"""
...     print("a =%d" % a)
...     print("b =%d" % b)
...     print("args:")
...     print(args)
...     print("kwargs: ")
...     for key, value in kwargs.items():
...         print("key=%s" % value)
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
a = 1
b = 2
args:
(3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d)    # 注意元组与字典的传参方式
a = 1
b = 2
args:
(3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args:
((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>


<3>. 缺省参数在*args后面


def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)


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

拆包、交换变量的值


<1> 对返回的数据直接拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age

# result = get_my_info()# print(result)

my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

总结：
· 拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
[size=10.0000pt]· 除了对元组拆包之外，还可以对列表、字典等拆包

      In [17]: a, b = (11, 22)
      In [18]: a
      Out[18]: 11
      In [19]: b
      Out[19]: 22

      In [20]: a, b = [11, 22]
      In [21]: a
      Out[21]: 11
      In [22]: b
      Out[22]: 22

      In [23]: a, b = {"m":11, "n":22}  # 取出来的是key，而不是键值对
      In [24]: a
      Out[24]: 'm'
      In [25]: b
      Out[25]: 'n'



<2> 交换2个变量的值


# 第1种方式# a = 4# b = 5# c = 0## c = a# a = b# b = c## print(a)# print(b)
# 第2种方式# a = 4# b = 5# a = a+b  # a=9, b=5# b = a-b  # a=9, b=4# a = a-b  # a=5, b=4# print(a)# print(b)
# 第3种方式
a, b = 4, 5
a, b = b, a

print(a)
print(b)[size=11.3333px]


引用(一)


想一想

>>> a = 1
>>> b = a
>>> b
1
>>> a = 2
>>> a
2
请问此时b的值为多少？
>>> a = [1, 2]
>>> b = a
>>> b
[1, 2]
>>> a.append(3)
>>> a
[1, 2, 3]
请问此时b的值又是多少？

引用

在python中，值是靠引用来传递来的。
我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。
>>> a = 1
>>> b = a
>>> id(a)
13033816
>>> id(b)   # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a)   # 注意a的id值已经变了
13033792
>>> id(b)   # b的id值依旧
13033816
>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)       # 注意a与b始终指向同一个地址
139935018544808

总结：
· 之前为了更好的理解变量，咱们可以把a=100理解为变量a中存放了100，事实上变量a存储是100的引用（可理解为在内存中的一个编号）[size=21.3333px]

可变、不可变类型

总结
· 所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
· 可变类型有： 列表、字典、集合
· 不可变类型有： 数字、字符串、元组[size=21.3333px]

引用(二)

引用当做实参
· 可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
· Python有没有类似C语言中的指针传参呢？


def test1(b):  # 变量b一定是一个局部变量，就看它指向的是谁？可变还是不可变
    b += b  # += 是直接对b指向的空间进行修改,而不是让b指向一个新的
    # b = b+b  # xx = xx+yyy 先把=号右边的结果计算出来,然后让b指向这个新的地方,不管原来b指向谁
                # 现在b一定指向这个新的地方
# a = [11, 22]
a = 100
test1(a)
print(a)


总结：
· Python中函数参数是引用传递（注意不是值传递）
· 对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
· 而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量[size=21.3333px]



函数应用：学生管理系统

[Python] 纯文本查看 复制代码

import time
import os

# 定一个列表，用来存储所有的学生信息(每个学生是一个字典)
info_list = []


def print_menu():
    print("---------------------------")
    print("      学生管理系统 V1.0")
    print(" 1:添加学生")
    print(" 2:删除学生")
    print(" 3:修改学生")
    print(" 4:查询学生")
    print(" 5:显示所有学生")
    print(" 6:退出系统")
    print("---------------------------")


def add_new_info():
    """添加学生信息"""
    global info_list

    new_name = input("请输入姓名:")
    new_tel = input("请输入手机号:")
    new_qq = input("请输入QQ:")

    for temp_info in info_list:
        if temp_info['name'] == new_name:
            print("此用户名已经被占用,请重新输入")
            return  # 如果一个函数只有return就相当于让函数结束，没有返回值

    # 定义一个字典，用来存储用户的学生信息(这是一个字典)
    info = {}

    # 向字典中添加数据
    info["name"] = new_name
    info["tel"] = new_tel
    info["qq"] = new_qq

    # 向列表中添加这个字典
    info_list.append(info)


def del_info():
    """删除学生信息"""
    global info_list

    del_num = int(input("请输入要删除的序号:"))
    if 0 <= del_num < len(info_list):
        del_flag = input("你确定要删除么?yes or no")
        if del_flag == "yes":
            del info_list[del_num]
    else:
        print("输入序号有误,请重新输入")


def modify_info():
    """修改学生信息"""
    global info_list

    modify_num = int(input("请输入要修改的序号:"))
    if 0 <= modify_num < len(info_list):
        print("你要修改的信息是:")
        print("name:%s, tel:%s, QQ:%s" % (info_list[modify_num]['name'],
            info_list[modify_num]['tel'],info_list[modify_num]['qq']))
        info_list[modify_num]['name'] = input("请输入新的姓名:")
        info_list[modify_num]['tel'] = input("请输入新的手机号:")
        info_list[modify_num]['qq'] = input("请输入新QQ:")
    else:
        print("输入序号有误,请重新输入")


def search_info():
    """查询学生信息"""
    search_name = input("请输入要查询的学生姓名:")
    for temp_info in info_list:
        if temp_info['name'] == search_name:
            print("查询到的信息如下:")
            print("name:%s, tel:%s, QQ:%s" % (temp_info['name'],
                temp_info['tel'], temp_info['qq']))
            break
    else:
        print("没有您要找的信息....")


def print_all_info():
    """遍历学生信息"""
    print("序号\t姓名\t\t手机号\t\tQQ")
    i = 0
    for temp in info_list:
        # temp是一个字典
        print("%d\t%s\t\t%s\t\t%s" % (i, temp['name'], temp['tel'], temp['qq']))
        i += 1


def main():
    """用来控制整个流程"""
    while True:
        # 1. 打印功能
        print_menu()

        # 2. 获取用户的选择
        num = input("请输入要进行的操作(数字)")

        # 3. 根据用户选择,做相应的事情
        if num == "1":
            # 添加学生
            add_new_info()
        elif num == "2":
            # 删除学生
            del_info()
        elif num == "3":
            # 修改学生
            modify_info()
        elif num == "4":
            # 查询学生
            search_info()
        elif num == "5":
            # 遍历所有的信息
            print_all_info()
        elif num == "6":
            # 退出系统
            exit_flag = input("亲,你确定要退出么?~~~~(>_<)~~~~(yes or no) ")
            if exit_flag == "yes":
                break
        else:
            print("输入有误,请重新输入......")


        input("\n\n\n按回车键继续....")
        os.system("clear")  # 调用Linux命令clear完成清屏

# 程序的开始
main()

递归函数


<1>什么是递归函数

通过前面的学习知道一个函数可以调用其他函数。

如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

<2>递归函数的作用

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n

解决办法1:

看阶乘的规律

1! = 1

2! = 2 × 1 = 2 × 1!

3! = 3 × 2 × 1 = 3 × 2!

4! = 4 × 3 × 2 × 1 = 4 × 3!

...

n! = n × (n-1)!

解决办法2:

原理

匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下：
    lambda [arg1 [,arg2,.....argn]]:expression


如下实例：
    sum = lambda arg1, arg2: arg1 + arg2

    #调用sum函数
    print "Value of total : ", sum( 10, 20 )
    print "Value of total : ", sum( 20, 20 )


以上实例输出结果：
    Value of total :  30
    Value of total :  40


Lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print，因为lambda需要一个表达式

应用场合

函数作为参数传递

1. 自己定义函数
>>> def fun(a, b, opt):...     print "a =", a...     print "b =", b...     print "result =", opt(a, b)
...>>> fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3
2. 作为内置函数的参数


想一想，下面的数据如何指定按age或name排序？
stus = [
    {"name":"zhangsan", "age":18},
    {"name":"lisi", "age":19},
    {"name":"wangwu", "age":17}
]


按name排序：
>>> stus.sort(key = lambda x:x['name'])
>>> stus
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]


按age排序：
>>> stus.sort(key = lambda x:x['age'])
>>> stus
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]


函数使用注意事项

1. 自定义函数
<1>无参数、无返回值
    def 函数名():
        语句
<2> 无参数、有返回值
   def 函数名():
        语句
        return 需要返回的数值


注意:
· 一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据
· 在开发中往往根据需求来设计函数需不需要返回值
· 函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成


<3>有参数、无返回值
   def 函数名(形参列表):
        语句


注意：
· 在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收
· 参数列表中变量的个数根据实际传递的数据的多少来确定


<4>有参数、有返回值
    def 函数名(形参列表):
        语句
        return 需要返回的数值


<5>函数名不能重复



2. 调用函数
<1>调用的方式为：
    函数名([实参列表])


<2>调用时，到底写不写 实参
· 如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数

<3>调用时，实参的个数和先后顺序应该和定义函数中要求的一致
<4>如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值


3. 作用域


<1>在一个函数中定义的变量，只能在本函数中用(局部变量)

<2>在函数外定义的变量，可以在所有的函数中使用(全局变量)

函数返回值(二)

在python中我们怎样返回多个值？


<1> 多个return?

def create_nums():
    print("---1---")
    return 1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
    print("---2---")
    return 2
    print("---3---")

总结1：
· 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处
[size=10.0000pt]·
如果程序设计为如下，是可以的因为不同的场景下执行不同的return
[size=10.0000pt]·
      def create_nums(num):
          print("---1---")
          if num == 100:
              print("---2---")
              return num+1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
          else:
              print("---3---")
              return num+2
          print("---4---")

      result1 = create_nums(100)
      print(result1)  # 打印101
      result2 = create_nums(200)
      print(result2)  # 打印202
[size=10.0000pt]·


<2> 一个函数返回多个数据的方式


def divid(a, b):
    shang = a//b
    yushu = a%b
    return shang, yushu  #默认是元组

result = divid(5, 2)
print(result)  # 输出(2, 1)


总结2：
· return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据
      def function():
          # return [1, 2, 3]
          # return (1, 2, 3)
          return {"num1": 1, "num2": 2, "num3": 3}
[size=10.0000pt]·
[size=10.0000pt]·
如果return后面有多个数据，那么默认是元组
[size=10.0000pt]·
      In [1]: a = 1, 2
      In [2]: a
      Out[2]: (1, 2)

      In [3]:
      In [3]: b = (1, 2)
      In [4]: b
      Out[4]: (1, 2)

      In [5]:
[size=10.0000pt]·

函数参数(二)


<1>. 缺省参数


调用函数时，缺省参数的值如果没有传入，则取默认值。
下例会打印默认的age，如果age没有被传入：
def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)
   print("age %d" % age)
# 调用printinfo函数
printinfo(name="miki")  # 在函数执行过程中 age去默认值35
printinfo(age=9 ,name="miki")


以上实例输出结果：
name: miki
age: 35
name: miki
age: 9


总结1：
· 在形参中默认有值的参数，称之为缺省参数
· 注意：带有默认值的参数一定要位于参数列表的最后面
      >>> def printinfo(name, age=35, sex):
      ...     print name
      ...
        File "<stdin>", line 1
      SyntaxError: non-default argument follows default argument
[size=10.0000pt]·


<2>. 不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。


基本语法如下：
    def functionname([formal_args,] *args, **kwargs):
       """函数_文档字符串"""
       function_suite
       return [expression]


注意：
· 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
· 而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.
>>> def fun(a, b, *args, **kwargs):
...     """可变参数演示示例"""
...     print("a =%d" % a)
...     print("b =%d" % b)
...     print("args:")
...     print(args)
...     print("kwargs: ")
...     for key, value in kwargs.items():
...         print("key=%s" % value)
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
a = 1
b = 2
args:
(3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d)    # 注意元组与字典的传参方式
a = 1
b = 2
args:
(3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args:
((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>


<3>. 缺省参数在*args后面


def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)


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

拆包、交换变量的值


<1> 对返回的数据直接拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age

# result = get_my_info()# print(result)

my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

总结：
· 拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
[size=10.0000pt]· 除了对元组拆包之外，还可以对列表、字典等拆包

      In [17]: a, b = (11, 22)
      In [18]: a
      Out[18]: 11
      In [19]: b
      Out[19]: 22

      In [20]: a, b = [11, 22]
      In [21]: a
      Out[21]: 11
      In [22]: b
      Out[22]: 22

      In [23]: a, b = {"m":11, "n":22}  # 取出来的是key，而不是键值对
      In [24]: a
      Out[24]: 'm'
      In [25]: b
      Out[25]: 'n'



<2> 交换2个变量的值


# 第1种方式# a = 4# b = 5# c = 0## c = a# a = b# b = c## print(a)# print(b)
# 第2种方式# a = 4# b = 5# a = a+b  # a=9, b=5# b = a-b  # a=9, b=4# a = a-b  # a=5, b=4# print(a)# print(b)
# 第3种方式
a, b = 4, 5
a, b = b, a

print(a)
print(b)[size=11.3333px]


引用(一)


想一想

>>> a = 1
>>> b = a
>>> b
1
>>> a = 2
>>> a
2
请问此时b的值为多少？
>>> a = [1, 2]
>>> b = a
>>> b
[1, 2]
>>> a.append(3)
>>> a
[1, 2, 3]
请问此时b的值又是多少？

引用

在python中，值是靠引用来传递来的。
我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。
>>> a = 1
>>> b = a
>>> id(a)
13033816
>>> id(b)   # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a)   # 注意a的id值已经变了
13033792
>>> id(b)   # b的id值依旧
13033816
>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)       # 注意a与b始终指向同一个地址
139935018544808

总结：
· 之前为了更好的理解变量，咱们可以把a=100理解为变量a中存放了100，事实上变量a存储是100的引用（可理解为在内存中的一个编号）[size=21.3333px]

可变、不可变类型

总结
· 所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
· 可变类型有： 列表、字典、集合
· 不可变类型有： 数字、字符串、元组[size=21.3333px]

引用(二)

引用当做实参
· 可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
· Python有没有类似C语言中的指针传参呢？


def test1(b):  # 变量b一定是一个局部变量，就看它指向的是谁？可变还是不可变
    b += b  # += 是直接对b指向的空间进行修改,而不是让b指向一个新的
    # b = b+b  # xx = xx+yyy 先把=号右边的结果计算出来,然后让b指向这个新的地方,不管原来b指向谁
                # 现在b一定指向这个新的地方
# a = [11, 22]
a = 100
test1(a)
print(a)


总结：
· Python中函数参数是引用传递（注意不是值传递）
· 对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
· 而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量[size=21.3333px]



函数应用：学生管理系统

[Python] 纯文本查看 复制代码

import time
import os

# 定一个列表，用来存储所有的学生信息(每个学生是一个字典)
info_list = []


def print_menu():
    print("---------------------------")
    print("      学生管理系统 V1.0")
    print(" 1:添加学生")
    print(" 2:删除学生")
    print(" 3:修改学生")
    print(" 4:查询学生")
    print(" 5:显示所有学生")
    print(" 6:退出系统")
    print("---------------------------")


def add_new_info():
    """添加学生信息"""
    global info_list

    new_name = input("请输入姓名:")
    new_tel = input("请输入手机号:")
    new_qq = input("请输入QQ:")

    for temp_info in info_list:
        if temp_info['name'] == new_name:
            print("此用户名已经被占用,请重新输入")
            return  # 如果一个函数只有return就相当于让函数结束，没有返回值

    # 定义一个字典，用来存储用户的学生信息(这是一个字典)
    info = {}

    # 向字典中添加数据
    info["name"] = new_name
    info["tel"] = new_tel
    info["qq"] = new_qq

    # 向列表中添加这个字典
    info_list.append(info)


def del_info():
    """删除学生信息"""
    global info_list

    del_num = int(input("请输入要删除的序号:"))
    if 0 <= del_num < len(info_list):
        del_flag = input("你确定要删除么?yes or no")
        if del_flag == "yes":
            del info_list[del_num]
    else:
        print("输入序号有误,请重新输入")


def modify_info():
    """修改学生信息"""
    global info_list

    modify_num = int(input("请输入要修改的序号:"))
    if 0 <= modify_num < len(info_list):
        print("你要修改的信息是:")
        print("name:%s, tel:%s, QQ:%s" % (info_list[modify_num]['name'],
            info_list[modify_num]['tel'],info_list[modify_num]['qq']))
        info_list[modify_num]['name'] = input("请输入新的姓名:")
        info_list[modify_num]['tel'] = input("请输入新的手机号:")
        info_list[modify_num]['qq'] = input("请输入新QQ:")
    else:
        print("输入序号有误,请重新输入")


def search_info():
    """查询学生信息"""
    search_name = input("请输入要查询的学生姓名:")
    for temp_info in info_list:
        if temp_info['name'] == search_name:
            print("查询到的信息如下:")
            print("name:%s, tel:%s, QQ:%s" % (temp_info['name'],
                temp_info['tel'], temp_info['qq']))
            break
    else:
        print("没有您要找的信息....")


def print_all_info():
    """遍历学生信息"""
    print("序号\t姓名\t\t手机号\t\tQQ")
    i = 0
    for temp in info_list:
        # temp是一个字典
        print("%d\t%s\t\t%s\t\t%s" % (i, temp['name'], temp['tel'], temp['qq']))
        i += 1


def main():
    """用来控制整个流程"""
    while True:
        # 1. 打印功能
        print_menu()

        # 2. 获取用户的选择
        num = input("请输入要进行的操作(数字)")

        # 3. 根据用户选择,做相应的事情
        if num == "1":
            # 添加学生
            add_new_info()
        elif num == "2":
            # 删除学生
            del_info()
        elif num == "3":
            # 修改学生
            modify_info()
        elif num == "4":
            # 查询学生
            search_info()
        elif num == "5":
            # 遍历所有的信息
            print_all_info()
        elif num == "6":
            # 退出系统
            exit_flag = input("亲,你确定要退出么?~~~~(>_<)~~~~(yes or no) ")
            if exit_flag == "yes":
                break
        else:
            print("输入有误,请重新输入......")


        input("\n\n\n按回车键继续....")
        os.system("clear")  # 调用Linux命令clear完成清屏

# 程序的开始
main()

递归函数


<1>什么是递归函数

通过前面的学习知道一个函数可以调用其他函数。

如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

<2>递归函数的作用

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n

解决办法1:

看阶乘的规律

1! = 1

2! = 2 × 1 = 2 × 1!

3! = 3 × 2 × 1 = 3 × 2!

4! = 4 × 3 × 2 × 1 = 4 × 3!

...

n! = n × (n-1)!

解决办法2:

原理

匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下：
    lambda [arg1 [,arg2,.....argn]]:expression


如下实例：
    sum = lambda arg1, arg2: arg1 + arg2

    #调用sum函数
    print "Value of total : ", sum( 10, 20 )
    print "Value of total : ", sum( 20, 20 )


以上实例输出结果：
    Value of total :  30
    Value of total :  40


Lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print，因为lambda需要一个表达式

应用场合

函数作为参数传递

1. 自己定义函数
>>> def fun(a, b, opt):...     print "a =", a...     print "b =", b...     print "result =", opt(a, b)
...>>> fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3
2. 作为内置函数的参数


想一想，下面的数据如何指定按age或name排序？
stus = [
    {"name":"zhangsan", "age":18},
    {"name":"lisi", "age":19},
    {"name":"wangwu", "age":17}
]


按name排序：
>>> stus.sort(key = lambda x:x['name'])
>>> stus
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]


按age排序：
>>> stus.sort(key = lambda x:x['age'])
>>> stus
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]


函数使用注意事项

1. 自定义函数
<1>无参数、无返回值
    def 函数名():
        语句
<2> 无参数、有返回值
   def 函数名():
        语句
        return 需要返回的数值


注意:
· 一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据
· 在开发中往往根据需求来设计函数需不需要返回值
· 函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成


<3>有参数、无返回值
   def 函数名(形参列表):
        语句


注意：
· 在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收
· 参数列表中变量的个数根据实际传递的数据的多少来确定


<4>有参数、有返回值
    def 函数名(形参列表):
        语句
        return 需要返回的数值


<5>函数名不能重复



2. 调用函数
<1>调用的方式为：
    函数名([实参列表])


<2>调用时，到底写不写 实参
· 如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数

<3>调用时，实参的个数和先后顺序应该和定义函数中要求的一致
<4>如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值


3. 作用域


<1>在一个函数中定义的变量，只能在本函数中用(局部变量)

<2>在函数外定义的变量，可以在所有的函数中使用(全局变量)