一、元组

1、元组的定义：

元组, 英文为 **tuple**， Python的元组与列表类似，不同之处在于**元组的元素不能修改**。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。my_tuple = ('et', 77, 99.9, True)

2、访问元组元素

my_tuple = ('et', 77, 99.9, True)
print(my_tuple[0])

3、修改元组，元组不可以修改，会报错

my_tuple[0] = 'hello' —— 报错

4、 获取元素索引值和数量

count, index：index和count与字符串和列表中的用法相同

a = ('a', 'b', 'c', 'a', 'b')

ret1 = a.index('a', 1, 3)  # 注意是左闭右开区间，会报错，因为元祖的1:3位没有a

ret2 = a.index('a', 1, 4)

ret3 = a.count('b')

ret4 = a.count('d')

# 元组和列表相比: 列表是可变的, 元组是不可变的

# 定义一个空元组

my_tuple = ()

print(type(my_tuple))

# 特例:

# 如果元组中只有一个元素

# 如下写法是错误的:  <class 'int'>

my_tuple2 = (1)

print(type(my_tuple2))

# 如下写法才是正确的:  <class 'tuple'>

my_tuple3 = (1,)

print(type(my_tuple3))

# 元组也可以通过下标获取元组中的元素

my_tuple4 = (1, 3.14, True, 'Hello')

# 获取3.14

value = my_tuple4[1]

print(value)

# 因为元组是不可改变的 不可以修改元素 或者删除元素

# 我们是否可以根据index和count获取某个元素的位置和个数

index = my_tuple4.index(3.14)

print(index)

# 获取某个元素的个数

count = my_tuple4.count(3.14)

print(count)

# for循环遍历:

for value in my_tuple4:

    print(value)

# while循环遍历:

index = 0

length = len(my_tuple4)

while index < length:

    value = my_tuple4[index]

    print(value)

    index += 1

二、字典

python中的字典规定则是 一对一:my_dict = {'name':'班长'}

字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key  =>  value对  用冒号 : 分割；每个键值对之间用逗号 , 分割；整个字典包括在花括号 {} 中 ,格式如下所示：

字典的格式:d = {key1 : value1, key2 : value2, ... }

说明：

- 字典和列表一样，也能够存储多个数据, 且数据类型没有要求

- 列表中找某个元素时，是根据下标进行的

- 字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'）

- 字典的每个元素由2部分组成，键:值。例如 'name':'班长' ,'name'为键，'班长'为值

1、根据键--->访问值

my_dict = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
my_dict['name']

**需要注意**:：若访问不存在的键，则会报错

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
my_dict = {'name': '班长'}
age = my_dict.get('age') #使用get方法,如果没有当前的key,则返回None
print(age)

结果:
None

我们也可以设置一个默认值,如果没有当前的key值时,  则返回默认参数:
my_dict = {'name': '班长'}
age = my_dict.get('age','age值没有')
print(age)

结果:
age值没有

# 三个元素(键值对) ，则len()返回3
print(len(my_dict))

#定义一个特殊 (空字典)
my_dict1 = {}
print(len(my_dict1))
# <class 'dict'>
print(type(my_dict1))
my_dict2 = dict()
print(type(my_dict2))

# 键值1: 实值1 统称为 键值对 key value 也称之为元素

# 键值数据类型的选择: 必须是不可变的

# 键值 的名字不能重复(才能完成1对1 通过一个key 获取key 的value)，value可以重复

# 字典的key 一般都是使用字符串

# 字典的value 没有规定 (可以重复的)

2、 字典的常用操作01:

1)  修改元素

> 字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改，# 字典是无序的 可变的

my_dict = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

new_id = input('请输入新的学号:')

my_dict['id'] = int(new_id)

print('修改之后的id为: %d' % my_dict['id'])

 2) 添加元素

> 我们在修改一个字典时, 如果当前的key值不存在, 不会报错, 而是进行了增加,  会在原有的字典中再次增加一个.
my_dict[key] = value
# 如果使用上面的格式 如果这个key不存在 添加一组键值对
#如果使用上面的格式 如果这个key存在 会吧key原来的value的值进行覆盖

例如:

my_dict = {'name':'meihao'}

my_dict['age1'] = 101

print(my_dict)

3)  删除元素

> 对字典进行删除操作，有一下几种：

del删除指定的元素：# 删除键值对 格式: del 字典名[key]

my_dict = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

print('删除前: %s' % my_dict['name'])

del my_dict['name']

print('删除后: %s' % my_dict['name']) ——报错

clear清空整个字典，my_dict.clear()   等价于 my_dict = {} 或者 my_dict = dict()

my_dict = {'name':'monitor', 'sex':'f', 'address':'China'}

print('清空前: %s' % my_dict)

my_dict.clear()

print('清空后: %s' % my_dict)

结果:
清空前: {'name': 'monitor', 'sex': 'f', 'address': 'China'}
清空后: {}

3、字典的常用操作02:

1)  len(o)，o代表object，对象 

> 该方法为python内置方法,可以返回传入对象的长度

dict = {'name': 'zhangsan', 'sex': 'm'}

length = len(dict)

print(length)

结果: 2

2)  keys(self) ，self代表没有参数

> 返回一个包含字典所有key值的列表方法,  我们可以把该方法转为列表

例如:

my_dict = {'name':'monitor', 'sex':'f', 'address':'China'}

keys = my_dict.keys()

print(keys)

结果:dict_keys(['name', 'sex', 'address']) —— # dict_keys(['name', 'sex', 'address'])其实就是列表类型 dict_keys

把该方法转为列表:

my_dict = {'name':'monitor', 'sex':'f', 'address':'China'}

keys1 = list(my_dict.keys())

print(keys1)

结果:['name', 'sex', 'address']

3)  values(self)

>  返回一个包含字典所有value的列表方法, 该列表方法可以转换为列表

例如:

my_dict = {'name': 'zhangsan', 'sex': 'm'}

values = my_dict.values()

print(values)

结果:dict_values(['zhangsan', 'm'])

将列表方法转化为列表:

my_dict = {'name': 'zhangsan', 'sex': 'm'}

values1 = list(my_dict.values())

print(values1)

结果:['zhangsan', 'm']

4)  items(self)

> 返回一个列表,该列表由元组组成,元组又是由key ---> value的键值对组成

例如: 最外层是一个列表 每个元素是一个元组 (元素1(key), 元素2(value))

my_dict = {'name': 'zhangsan', 'sex': 'm'}

items = my_dict.items()

print(items)

items1 = list(items)

print(items1)

结果:dict_items([('name', 'zhangsan'), ('sex', 'm')])，[('name', 'zhangsan'), ('sex', 'm')]

5)  字典的遍历

> 通过for ... in ...

> 我们可以遍历字符串、列表、元组、字典等(**注意python语法的缩进**)

# 定义一个字典：my_dict = {"name": "小红", "age": 22, "no": "009"}

# 遍历-key
for key in my_dict.keys():
    print(key)

# 遍历value
for value in my_dict.values():
    print(value)

# 遍历items
for item in my_dict.items():
    print(item[0])
    print(item[1])

# 通过设置两个临时变量
for key, value in my_dict.items():
    print("key:", key)
    print("value:", value)

### 可以获取索引值的遍历形式:

# 如果想使用元素和下标索引 请使用enumerate(列表名)

# 定义一个列表

my_list = list("abcd")

# 不仅要获取列表中的元素 而且需要知道这个元素下标索引

for i, value in enumerate(my_list):

    print(i,value)

print('---------------------')

my_tuple = ('1234')

for i, value in enumerate(my_tuple):

    print(i,value)

print('----------------------')

my_dict = {'name':'meihao','age':'12345'}

for i, item in enumerate(my_dict.items()):

    print(i, item)

print('----------------------')

my_dict = {'name':'meihao','age':'12345'}

for i, key in enumerate(my_dict.keys()):

    print(i, key)

print('----------------------')

my_dict = {'name':'meihao','age':'12345'}

for i, value in enumerate(my_dict.values()):

    print(i, value)

print('----------------------')

三、公共方法和总结

1、关于开闭区间的总结

1）随机数

# 取值范围: [x,  y]
random.randint(x, y) 

2）范围

# 取值范围 [x, y)
range(x, y)

3）切片 --->  字符串中，列表，元组也可以切片

# 取值范围[x, y)
'a'[x: y: 步长]

2、数据类型是否可变:

不可变的:int  float  bool  str  元组

可变的:列表  字典

3、公共方法

运算符

| 运算符 | Python 表达式      | 结果                        | 描述          | 支持的数据类型          |

| +          | [1, 2] + [3, 4]         | [1, 2, 3, 4]                | 合并          | 字符串、列表、元组      |

| *           | ['Hi!'] * 4                | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 复制          | 字符串、列表、元组      |

| in         | 3 in (1, 2, 3)           | True                        | 元素是否存在  | 字符串、列表、元组、字典 |

| not in   | 4 not in (1, 2, 3)     | True                        | 元素是否不存在 | 字符串、列表、元组、字典 |

4、python内置函数

| 序号 | 方法      | 描述                |

| 1    | len(item) | 计算容器中元素个数  |

| 2    | max(item) | 返回容器中元素最大值 |

| 3    | min(item) | 返回容器中元素最小值 |

| 4    | del(item) | 删除变量            |

> **注意：len在操作字典数据时，返回的是键值对个数。**

max1 = max("hello itcast")  —— 结果是t，字母表里t这里最大

max3 = max({"a":1, "b":2}) —— 结果是b，对比的是键的大小，字母表里b比a大

max4 = max({"a":10, "b":2})—— 结果是b，对比的是键的大小 ，字母表里b比a大

max5 = max({"c":10, "b":12})—— 结果是c，对比的是键的大小 ，字母表里c比b大

> del有两种用法，一种是del加空格，另一种是del()
a = 1
del a

a = ['a', 'b']
del a[0]

a = ['a', 'b']
del(a)

# 列表
# 注意顺序
# my_list1 = [1, 2]
# my_list2 = [3, 5]
# ret1 = my_list2 + my_list1

# 字符串
# name = "小明"
# 占位符
# print("我叫%s" % name)
# ret = "我叫" + name
# ret1 = "我叫%s" % name
# print(ret1)
# 类型不统一 使用str()转类型
# name = "小明"
# age = 18
# ret2 = "我叫" + name + "年龄" + str(age)
# print(ret2)

# 元组
# ret3 = (1, 4) + (6, 9)
# print(ret3)

# 运算符 *
# 字符串
# my_str = "=="*20
# print(my_str)
# 列表
# my_list = ["hello", "world"]*10
# print(my_list)
# 元组
# my_tuple = (11,)*5
# print(my_tuple)

# in
#字符串
# my_name = "world"
# if "l" in my_name:
#    print("存在")
# 元组
# my_tuple = (1, 3, 5)
# if 1 in my_tuple:
#    print("存在")
# 字典
# my_dict = {"name": "小红", "age": 22, "no": "009"}
# 使用in 在字典中其实是判断的是key存不存在
# if "name" in my_dict:
#    print("存在")
# 就是想查看值到底有没有
# if "小红" in my_dict.values():
#    print("存在")

# del用法总结
# 可以配合列表使用
# my_list = [1, 2, 3]
# del my_list[1]
# 可以配合字典
# my_dict = {"name": "小红", "age": 22, "no": "009"}
# del my_dict["age"]
# 可以提前销毁一个对象
# 在程序没有结束的时候 程序员提前杀死了这个对象 提前释放内存
# num = 10
# del num
# print(num)
# NameError: name 'num' is not defined
# 监听当程序结束后 python会执行一个方法 del num 告知系统回收内存

## 练习1:- 统计字符串中，各个字符的个数- 比如："hello world"
# 字符串统计的结果为： h:1 e:1 l:3 o:2 d:1 r:1 w:1

str = 'hello world'
my_list = []
for c in str:
    if c != ' ' and c not in my_list:
        my_list.append(c)
        count = str.count(c)
        print('%s:%d' % (c,count),end=")

四、函数

1. 函数的了解,所有面向对象的语言都有三大特点：封装，继承，多态

>  函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

> 函数的好处: 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

针对经常重复使用,且代码段很长的程序,我们可以使用函数将代码段进行封装, 哪里需要,直接调用封装好的函数名即可,不用重复写代码.

* 函数的出现解决了多次重复书写某一部分代码的问题

* 函数往往是某个功能的集合

* 这里的函数不要和我们数学中的函数联系起来.

* 函数就是个代码块.具有对立的功能.也可以理解为一个对象.

2、 函数的定义和调用

1) 定义函数

函数定义的简单规则：

- 函数代码块以 **def** 关键词开头，后接函数标识符名称和小括号 **()**。

- 函数内容以冒号开始，并且必须要缩进。

一般格式如下:

def 函数名（）:

函数体

2) 调用函数

> 定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它

> 调用函数很简单，通过 **函数名()** 即可完成调用

- 每次调用某个函数时，该函数体都会从头开始执行

- 当这个函数中的代码执行完毕后，意味着调用结束

- 函数的定义一定要在函数调用之前.否则会找不到函数

3、函数的文档说明

> 给函数添加一些注释, 解释说明当前函数的主要功能, 参数作用, 返回值情况.

给函数添加文档说明:

def 函数名(a, b):
    """
    这里可以书写该函数的主要作用
    :param a: 第一个参数介绍
    :param b: 第二个参数介绍
    :return:  返回值的介绍
    """
如果我们使用python内置函数help() 就可以发现刚刚定义的函数文档内容了.  help(func_name) ——  里面的函数名不能加小括号，因为这里不是要调用函数

4、函数参数一:

> 定义一般函数的时候我们可能用不到函数的参数,  但是有些问题需要外部给内部的函数传值, 就需要函数能够接受参数

> 让函数能够接收参数是对函数进行的扩展.

定义一个带有参数的函数,格式如下:

def 函数名(参数1, 参数2, ...):

    函数体

# 调用带有参数的函数时，需要在小括号中，传递数据
#add2num是一个自定义函数
add2num(11, 22)

5、函数的返回值

“返回值”: 就是程序中的函数执行完成后，返回回来的数据.

* 其中:  一个函数可以有返回值也可以没有返回值,这个要看业务需求

* 返回值可以是多种多样的,  任何类型都有可能

* 函数返回数据的时候用的关键字是  return

* 函数调用后,如果有返回值, 我们可以定义一个变量来进行接收.

# 定义一个带有返回值的函数
def func():
    print('你好,这里是函数内部')
    return '函数调用完成'

也可以写成这样:
# 定义一个带有返回值的函数
def func(a, b):
    print('你好,这里是函数内部')
    return a + b

也可以写成这样:
def func():
    print('你好,这里是函数内部')
    return True

也可以写成这样: (下面的代码是函数的递归调用)
def deep(num):
     print(num)
     if num == 20:
         return
     num += 1
     return deep(num)
 deep(1)
结果是什么? 结果为 1 到 20 的所有数字

# return 当成跳出函数的方式来使用,而不是用它返回内容
def func(a):
    if a < 0:
         print('请传入正确的参数.')
         return
    return a + 1

总结:

* 函数可以有返回值,也可以没有

* 函数的返回值自定

* 程序读取到return 关键字后,  就会退出当前的函数体, 即 return之后的代码将不会执行

* 如果return 后面有内容, 则返回return后面的内容,  如果单独写一个return, 即 return后面没有写明返回内容,则返回None,  但是函数体的执行到此仍然结束, 不再往下执行.

* 有时候,我们会把 return 当成跳出当前函数的方式来使用,  而不是用它返回内容.

* 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束，因此后面的return是没什么用处的

* 一个函数中想要同时返回多个数据, 不能够靠写多个return来实现.  我们可以在函数的return 后面, 直接返回一个元组, 列表 或者 字典等.

如果return后面想要返回元组, 可以不用加 ( ) python返回多个值时, 默认就是元组格式:
def func():
    return 1, 2, 3 

result = func()
print(result)
print(type(result))

(1, 2, 3)
<class 'tuple'>

6. 四种类型的函数

1)  无参数，无返回值的函数

此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数

2) 无参数，有返回值的函数

 此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数

3) 有参数，无返回值的函数

此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

4) 有参数，有返回值的函数

此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数

7、函数的嵌套使用

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')

def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')

testA()

总结：

> 一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用

>  如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

> 一个函数中可以嵌套无数个函数.

> 函数可以连着进行嵌套,  即 a函数嵌套于 b函数, b函数又嵌套于 c函数, c函数又.......

8、局部变量

> 函数内部定义的变量,是局部变量，局部变量的作用域(使用范围)在函数的内部 函数的外部无法使用,形参也是局部变量

在函数内部定义的局部变量名可以和其他函数中的局部变量名相同 是不冲突的

- 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储

- 当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了

9、全局变量

> 如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

总结1:

- 在函数外边定义的变量叫做`全局变量`

- 全局变量能够在所有的函数中进行访问

相同名字的全局和局部变量
# 定义一个全局变量
a = 100

def func1():
    a = 300
    print('------func1----修改前---a = %d ' %  a)
    a = 200
    print('------func1----修改后---a = %d ' %  a)

def func2(): #函数内部的a首先在函数内部找，如果内部没有，就找函数外部的a
    print('------func2-----a = %d ' % a)

# 调用函数
func1()
func2()

结果:
------func1----修改前---a = 300
------func1----修改后---a = 200
------func2-----a = 100

总结2:
- 当函数内出现局部变量和全局变量相同名字时，函数内部中的 `变量名 = 数据` 此时理解为定义了一个局部变量，而不是修改全局变量的值

修改全局变量

>  函数中使用全局变量时可否进行修改呢？

# 定义一个全局变量
a = 100
def func1():
    global a # 把外部的a拿进来
    print('------func1----修改前---a = %d ' %  a)
    a = 200
    print('------func1----修改后---a = %d ' %  a)

def func2():
    print('------func2-----a = %d ' % a)

# 调用函数
func1()
func2()

结果:
------func1----修改前---a = 100
------func1----修改后---a = 200
------func2-----a = 200

总结3:

- 如果在函数中出现`global 全局变量的名字` 那么这个函数中即使出现和全局变量名相同的`变量名 = 数据` 也理解为对全局变量进行修改，而不是定义局部变量

- 如果在一个函数中需要对多个全局变量进行修改

# 可以使用一次global对多个全局变量进行声明

global a, b

# 还可以用多次global声明都是可以的

global a

global b

10、函数参数(二)

1)  位置参数

> 位置参数是指我们调用函数时传入的函数值和定义函数时的参数是一一对应的.

# 定义一个函数

def my_func1(a, b):

    print(a + b)

# 函数的调用 -> 位置参数调用函数

# 使用位置参数调用函数 需要注意实参的位置

# 实参的位置和形参的位置要一一对应

# TypeError: my_func1() missing 1 required positional argument: 'b'

# 如果实参传入的少一个实参 会报错

2)  关键字参数

> 我们调用函数的时候可以指定要传递的参数名称, 直接把实参传递给对应的形参.

# 通过指定形参名字的形式,把实参直接传递给对应的形参.
def func(a, b):
    result = a + b
    print(result)

# 可以这样调用关键字参数
func(a = 10, b = 20)

# 或者这样:
func(b = 20, a = 10)

结果:
30
30

def my_print(name, age, no):
    print("我的名字:%s" % name)
    print("我的年龄:%d" % age)
    print("学号:%s" % no)

# 调用-> 位置参数：my_print("小明", 20)
# 调用函数的时候使用的是函数的形参名： my_print(age=22, name="老王")
# 调用函数的时候 使用了位置和关键字参数混合
# 如果混合使用 需要叫位置参数在前 关键字参数再后
# 如果某个参数使用了关键字参数 后面的都需要使用关键字参数：my_print("小明", age=20, no="007")

3) 缺省参数

> 缺省参数就是指的默认值参数, 即如果我们调用函数的时候没有传入该参数, 那么就直接使用该缺省参数.

总结：

- 在形参中默认有值的参数，称之为缺省参数

- 注意：带有默认值的参数一定要位于参数列表的最后面, 否则报错

# 如果执行函数的时候提供实参 那么函数的形参使用实参

# 如果执行函数的时候没有提供实参 那么形参将使用默认值(缺省参数)

# 在定义函数的时候某个形参使用了缺省参数 那么后面的形参 都需要用缺省参数

def my_print(name, age=20, no="001")

4)  函数返回多个数据的方式

# 列表
def deal_name_age(name, age):
     # 处理后 姓名:小明  年龄:22
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    return [new_name, new_age]

# 变量为列表
ret = deal_name_age("小明", 22)
print(ret[0])
print(ret[1])

# 字典
def deal_name_age(name, age):
    # 处理后 姓名:小明  年龄:22
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    return {"name":new_name, "age":new_age}

my_dict = deal_name_age("小明", 22)
print(my_dict["name"])
print(my_dict["age"])

# 元组
def deal_name_age(name, age):
    # 处理后 姓名:小明  年龄:22
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    # 如果在函数内部 使用return 返回值1 返回值2,... 默认就是元组类型 不需要写小括号
    return new_name, new_age

my_tuple = deal_name_age("小明", 22)
print(type(my_tuple))
print(my_tuple[0])
print(my_tuple[1])

11、拆包

拆包:  对于函数中的多个返回数据, 去掉元组, 列表 或者字典 直接获取里面数据的过程.

1) 对列表进行拆包

my_list = [1, 3.14, "hello", True]
num, pi, my_str, my_bool = my_list

# 或者
num, pi, my_str, my_bool = [1, 3.14, "hello", True]

2) 对元组进行拆包

my_tuple = (1, 3.14, "hello", True)
num, pi, my_str, my_bool = my_tuple

3) 对字典进行拆包

my_dict = {"name":"老王", "age": 19}
ret1, ret2 = my_dict
# 得到的是key  字典是无序的

4)  用拆包的形式定义变量

# # 变量名和值是一一对应
num1, num2, num3, num4 = 10, 20, 30, 3.14

5)  函数返回元组时直接拆包

对元组拆包:
def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age
# 这一步叫做拆包:
my_high, my_weight, my_age = get_my_info()

也可以对列表或者元组拆包:
def function1():
    return [1, 2, 3]

def function2():
    return {"key1": 1, "key2": 2, "key3": 3}

# 调用函数,获取里面的数据
num1, num2, num3 = function1()
print(num1, num2, num3)

总结：

- 拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常

- 除了对元组拆包之外，还可以对列表、字典等拆包

- 对字典拆包后获取的是字典的key值, 而不是value值

交换两个变量的值:a = 1,  b = 2.      怎样把 a,  b 的值交换?

### 1)  方法一:> 定义一个变量c
a = 1
b = 2
c = 0
c = a
a = b
b = c

### 2) 方法二:> 加法运算:
a = 1
b = 2
a = a + b
b = a - b
a = a - b 

### 3) 方法三:> 异或运算，异或运算只能在二进制时进行，不能对十进制进行
# 异或运算就是相同的值得0，不同的值得1，如 1111 XOR 0101=1010。
# 两个二进制数进行逻辑或运算时，要是有一个为1，则结果为1，只有两个数全为0结果才为0 ，如 1010 OR 1101=1111
a = 1  #十进制的1是二进制的1，因为逢2进1的话，还没到2
b = 2 #十进制的2是二进制的10
a = a ^ b
b = a ^ b  # a^b = a^b^b=a^0=a
a = a ^ b  # a^b = a^a^b = 0^b = b

### 4) 方法四:> 拆包
a = 1
b = 2
a, b = b, a

### 5) 方法五:
a = 1
b = 2
if a > b:
    num = a-b
    a -= num
    b += num
else:
    num = b-a
    a += num
    b -= num

五、匿名函数

> 用lambda关键词能创建小型匿名函数。这种函数省略了用def声明函数的标准步骤。

> lambda表达式，通常是在**需要一个函数，但是又不想费神去命名一个函数**的场合下使用，也就是指**匿名函数**。

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

例如:
sum = lambda arg1, arg2: arg1 + arg2 —— arg1，arg2是形参

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

应用场合

1)  函数作为参数传递

例如:
def func(a, b, opt)
    print('a:%d' % a)
    print('b:%d' % b)
    print('result:%d' % opt(a, b))

func(1, 2, lambda x, y : x + y)

结果:
a:1
b:2
result:3

2)  作为内置函数的参数

list = [
    {"name": "zhangsan", "age": 18},
    {"name": "lisi", "age": 19},
    {"name": "wangwu", "age": 17}
    ]
# key:可选参数, 如果指定了该参数会使用该参数的方法进行排序。
list.sort(key = lambda x: x['name'])
print(list)
list.sort(key= lambda x: x['age'])
print(list)

按name排序:
[{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]

按 age 排序:
[{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]

add = lambda x, y : x+y
add(1,2)  # 结果为3

def func(a,b):
    return lambda x:ax+b
f = func(1,1)
f(1) # 结果为2

总结:

* lambda函数也叫匿名函数, 即  函数没有具体的名称.

* lambda  x, y : x + y 中:  lambda是关键字.  x, y 是函数的两个形参.    x + y是函数的返回值.

  * 上面的式子可以写成:

  * def  func( x,  y ):    return x + y

* 匿名函数的可以作为参数, 传递到另一个函数中.
def first(x, y):
    return  x + y

def second(x, y, opt):
    print(x)
    print(y)
    result = opt(x, y)
    print(result)
second(22, 33, first)

* 上面的代码可以用匿名函数实现:
def second(x, y, opt):
    print(x)
    print(y)
    result = opt(x, y)
    print(result)
second(22, 33, lambda x, y: x + y)