作业一：

元组（tuple）：

用圆括号括起来的是元组。
元组也是序列结构，但是是一种不可变序列，你可以简单的理解为内容不可变的列表。除了在内部元素不可修改的区别外，元组和列表的用法差不多。

元组与列表相同的操作

使用方括号加下标访问元素

  1. >>> tu = (1,2,3,4,5)
  2. >>> tu[1]
  3. 2

切片（形成新元组对象）

  1. >>> tu
  2. (1, 2, 3, 4, 5)
  3. >>> tu[2:4]
  4. (3, 4)

tuple.count()/tuple.index()

  1. >>> tu1 = (1,2,3,4,5,5,5,4)
  2. >>> tu1.count(5)
  3. 3
  4. >>> tu1.index(5)
  5. 4

列表中还有list.reverse()与list.sort(),但是元组没有，但是要实现反转与排序可以使用python中的内置函数:reversed()，sorted()

  1. >>> tu1
  2. (1, 2, 3, 4, 5, 5, 5, 4)
  3. >>> reversed(tu1)
  4. <reversed object at 0x000001B9FE543C88>
  5. >>> tuple(reversed(tu1))
  6. (4, 5, 5, 5, 4, 3, 2, 1)
  8. >>> tu = (1,2,3,5,4,3)
  9. >>> sorted(tu)            # 升序
  10. [1, 2, 3, 3, 4, 5]

len()/max()/min()/tuple()

元组中不允许的操作——不允许修改、新增元素

  1. >>> tup = (1,2,3)
  2. >>> tup[2] = 5
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in <module>
  5. TypeError: 'tuple' object does not support item assignment

一旦想改变该元组,就只能重新开辟一块内存,创建新的元组

  1. >>> tup = (1,2,3)
  2. >>> new_tup = tup+(4,)
  3. >>> new_tup
  4. (1, 2, 3, 4)

注意：元组只保证它的一级子元素不可变，对于嵌套的元素内部，不保证不可变
如下：

  1. >>> tup = (1,2,3,['qianan',5])            # 将'qianan'改为4
  2. >>> tup[3][0] = 4
  3. >>> tup
  4. (1, 2, 3, [4, 5])
  6. >>> tup1 = (1,2,3,('qianan',5))        # 将'qianan'改为4
  7. >>> tup1[3][0] = 4
  8. Traceback (most recent call last):
  9.   File "<stdin>", line 1, in <module>
  10. TypeError: 'tuple' object does not support item assignment

不允许删除某个元素（但可以删除整个元组）

实际上，所有会对元组内部元素发生修改动作的方法。例如，元组没有remove，append，pop等方法

列表和元组的转换

元组转为列表

>>> tu = (1,2,3)
>>> list(tu)
[1, 2, 3]

列表转为元组

>>> li = [1,2,3]
>>> tuple(li)
(1, 2, 3)

字典（dict）：

字典是采用键值对(key:value)的形式，根据key的值计算value的地址，具有非常快的查取和插入速度。但它是无序的，包含的元素个数不限，值的类型也可以是其它任何数据类型！

字典的key必须是不可变的对象，例如整数、字符串、bytes和元组，但使用最多的还是字符串。 列表、字典、集合等就不可以作为key。同时，同一个字典内的key必须是唯一的，但值则不必。

简而言之，字典可精确描述为不定长、可变、无序、散列的集合类型
字典的每个键值对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。
例如：

d = {key1 : value1, key2 : value2 }

创建字典

创建空字典

>>> dic = {}
>>> dic
{}
>>> type(dic)
<class 'dict'>

>>> dict()
{}

创建字典三种方式

>>> dic1 = {'name':'qianan','age':'18'}
>>> type(dic1)
<class 'dict'>

>>> dic2 = dict(name="qianan",age='18')
>>> type(dic2)
<class 'dict'>

>>> dic3 = dict([('name','qianan'),('age','18')])
>>> type(dic3)
<class 'dict'>

>>> dic1 == dic2 == dic3    # ==比较数值
True

访问字典

字典是集合类型，不是序列类型，因此没有索引下标的概念，更没有切片的说法。但是，与list类似，字典采用把相应的键放入方括号内获取对应值的方式取值。

>>> dic1 = {'name':'qianan','age':18}
>>> dic1['name']
'qianan'

>>> dic1['gender']                    # 当key值不存在时，则报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'gender'

增加和修改

增加就是往字典插入新的键值对，修改就是给原有的键赋予新的值。由于一个key只能对应一个值，所以，多次对一个key赋值，后面的值会把前面的值冲掉。

>>> dic1 = {'name':'qianan','age':18}
>>> dic1['gender'] = "female"                    # 增加key值为"gender",value值为"female"的元素
>>> dic1
{'name': 'qianan', 'age': 18, 'gender': 'female'}

>>> dic1['gender'] = 'male'                        # 当有该key:value值时,取出来重新赋值则进行了修改
>>> dic1
{'name': 'qianan', 'age': 18, 'gender': 'male'}

删除字典元素、清空字典和删除字典

使用del关键字删除字典元素或者字典本身，使用字典的clear()方法清空字典

>>> dic1
{'name': 'qianan', 'age': 18, 'gender': 'male'}
>>> del dic1['name']            # 删除某key:value元素

>>> dic1
{'age': 18, 'gender': 'male'}

>>> dic1
{'age': 18, 'gender': 'male'}
>>> dic1.clear()                # 清空字典
>>> dic1
{}

>>> del dic1                    # 删除整个字典
>>> dic1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dic1' is not defined

字典的方法

  • get(key) 返回指定键的值，如果值不在字典中，则返回default值
  • items() 以列表返回可遍历的(键, 值) 元组对
  • keys() 以列表返回字典所有的键
  • values() 以列表返回字典所有的值

代码如下：

>>> dic1 = {'name':'qianan','age':18}
>>> dic1.get('name')        
'qianan'
>>> dic1.get('gender')    # 当key:value不存在时,返回None

>>> dic1.items()
dict_items([('name', 'qianan'), ('age', 18)])
>>> for k,v in dic1.items():
...     print(k,v)
...
name amy
age 18

>>> dic1.keys()
dict_keys(['name', 'age'])
>>> dic1.values()
dict_values(['qianan', 18])

作业二：

将li1和li2两个列表以键值对方式呈现：
li1 = [‘name’,’age’,’address’]
li2 = [‘moumou’,18,’hunan’]
print(dict(zip(li1,li2))) #zip方法

li1 = [‘name’,’age’,’address’] #map方法
li2 = [‘moumou’,18,’hunan’]
dic = dict(map(lambda x,y:[x,y],li1,li2))
print(dic)

‘’’
匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。
要点：
1，lambda 函数不能包含命令，
2，包含的表达式不能超过一个。
说明：一定非要使用lambda函数；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。我将它们用在需要封装特殊的、非重用代码上，避免令我的代码充斥着大量单行函数。
lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。其实lambda返回值是一个函数的地址，也就是函数对象。
‘’’

作业三：

li = {‘name’:’qianan’,’age’:18,’address’:’hunan’}
#打印li列表的key与value值
print(li.keys())
print(li.values())
————》
dict_keys([‘name’, ‘age’, ‘address’])
dict_values([‘qianan’, 18, ‘hunan’])

拓展作业

一：


month = int(input(‘请输入月份：’))
if month >12 or month <1:
print(month,’月份不存在’)
elif 3 <= month <= 5:
print(month,’春季’)
elif 6 <= month <= 8:
print(month,’夏季’)
elif 9 <= month <= 11:
print(month,’秋季’)
else:
print(month, ‘冬季’)

二：

li = [1,2,3,4,5,6,7,8,9,0]
li.remove(1)
li.append(1)
print(li)
》》》》
[2, 3, 4, 5, 6, 7, 8, 9, 0, 1]

三：

百度的没看懂
content = input(‘’).strip()
con1 = content.split(‘+’) #分割成列表
num = 0
for i in con1:
num += int(i)
print(num)

5+9 、 5+ 9 、5 + 9

四：

dic = {‘a’:’1’,’b’:’2’}
key = input(“输入要查找的键:”)
if key in dic.keys():
print(key, ‘的值为:’, dic[key])
else:
print(‘字典中没有这个键’)