一、元组
Python的元组与列表类似，不同职称在于元组的元素不能修改。元组使用（），列表使用[]。
'''
Python的元组与列表类似，不同之处在于元组的元素不能修改（增删改），
元组使用小括号()，列表使用方括号[]
list 列表
tuple 元组
定义：
名 = （）
注意：如果元组中只有一个元素，必须添加逗号('aa',),(1,)
可使用的方法：
count()
index()
可使用的关键字：
in ,not in
for ... in
while
list(tuple)--->元组转成列表
tuple(list)--->列表转元组
'''
t3 = ('a','b','c','d','e','f')
t2 = list(t3)
print(t2) # ['a', 'b', 'c', 'd', 'e', 'f']
t1 = tuple(t2)
print(t1) # ('a', 'b', 'c', 'd', 'e', 'f')
a = ('et',88,66)
print(a) # ('et', 88, 66)
print(type(a)) # <class 'tuple'>1、访问元组
atuple = ('hello',100,3.12)
print(atuple) # ('hello', 100, 3.12)
print(atuple[0]) # hello
print(atuple[1]) # 100
print(atuple[2]) # 3.122、修改元组
说明：python中不允许修改元组的数据，包括不能删除其中的元素。
3、count，index
index和count与字符串和列表中的用法相同
说明：注意是左闭右开区间
a = ('a','b','c','a','b')
print(a.index('a',1,4)) # 3
print(a.count('b')) # 2
print(a.count('d')) # 04、定义只有一个数据的元组
定义只有一个元素的元组，需要在唯一的元素后写一个逗号
a = (11)
print(a) # 11
print(type(a)) # <class 'int'>
a = (11,) # 只有一个元素的元组，必须要在元素后写一个逗号
print(a) # (11,)
print(type(a)) # <class 'tuple'>5、交换两个变量的值
#第1种方式，使用中间变量
a = 3
b = 6
c = 0
c = a
a = b
b = c
print(a) # 6
print(b) # 3
#第2种方式，直接交换
a,b = 4,5
a,b = b,a
print(a) # 5
print(b) # 4二、字典
1、列表的缺点
当存储的数据要动态添加、删除的时候，我们一般使用列表，但是列表有时会遇到一些麻烦。
#定义一个列表保存，姓名、性别、职业
nameList = ['xiaoZhang','男','木匠']
#当修改职业的时候，需要记忆元素的下标
nameList[2] = '铁匠'
#如果列表的顺序发生了变化，添加年龄
nameList = ['xiaoZhang',18,'男','铁匠']
#此时就需要记忆新的下标，才能完成名字的修改
nameList[3] = 'xiaoxiaoWang'
print(nameList) # ['xiaoZhang', 18, 'nan', 'xiaoxiaoWang']有没有方法，既能存储多个数据，还能在访问元素的时候很方便就能够定位到需要的那个元素呢？
字典
2、字典的使用
定义字典的格式：{键1 : 值1 , 键2 : 值2 , 键3 : 值3 , ..., 键n : 值n}
变量info为字典类型
info = {'name':'班长','id':100,'sex':'f','address':'湖南'}
print(info['name']) # 字典使用键来获取对应的值说明：
- 字典和列表一样，也能够存储多个数据
- 列表中找某个元素时，是根据下标进行的；字典中找某个元素时，是根据‘名字’（就是冒号：前面的那个值，例如上面代码中的‘name’、‘id’、‘sex’）
- 字典的每个元素由2部分组成，键：值。例如‘name’：'班长'，‘name’为键，‘班长’为值
- 键可以使用数字、字符串、布尔值、元组等不可变数据类型，但是一般会习惯使用字符串
- 每个字典里的key都是唯一的，如果出现了多个key，后面的value会覆盖前一个key对应的value。
在习惯上：
- 列表更适合保存多个商品、多个姓名、多个时间，这样的相似数据；
- 字典更适合保存一个商品的不同信息、一个人的不同信息，这样的不同数据。
3、字典的增删改查
3.1 查看元素
除了使用key查找数据，还可以使用get来获取数据
info={'name':'班长','age':18}
print(info['age'])# 获取年龄
#print(info['sex'])# 获取不存在的key，会发生异常
print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
print(info.get('sex','男')) # 获取不存在的key，可以提供一个默认值。注意：获取默认值不会修改字典内容。
3.2 修改元素
字典的每个元素中的数据都是可以修改的，只要通过key找到，即可修改
info = {'name':'班长', 'id':100}
print('修改之前的字典为 %s:',info)
# 修改之前的字典为 %s: {'name': '班长', 'id': 100}
info['id'] = 200 # 为已存在的键赋值就是修改
print('修改之后的字典为 %s:',info)
# 修改之后的字典为 %s: {'name': '班长', 'id': 200}3.3 添加元素
如果在使用 变量名['键'] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素
info = {'name':'班长'}
print('添加之前的字典为：%s' % info)
# 添加之前的字典为：{'name': '班长'}
info['id'] = 100 # 为不存在的键值赋值就是添加元素
print('添加之后的字典为：%s' % info)
# 添加之后的字典为：{'name': '班长', 'id': 100}
3.4 删除元素
对字典进行删除操作，有以下几种方法：
- del
- clear()
del删除指定的元素
info = {'name':'班长','id':100}
print('删除之前的字典为：%s' % info)
# 删除之前的字典为：{'name': '班长', 'id': 100}
del info['name'] # del 可以通过键删除字典里的指定元素
print('删除之后的字典为：%s' % info)
# 删除之后的字典为：{'id': 100}del删除整个字典
info = {'name':'班长','id':100}
print('删除前，%s'%info)
# 删除前，{'name': '班长', 'id': 100}
del info # del也可以直接删除变量
print('删除后，%s'%info)
# NameError: name 'info' is not definedclear清空整个字典
info = {'name':'monitor','id':100}
print('清空前，%s'%info)
# 清空前，{'name': 'monitor', 'id': 100}
info.clear()
print('清空后，%s'%info)
# 清空后，{}
4、字典遍历
4.1 遍历字典的key（键）
dic = {'name':'zhangsan','sex':'m'}
for key in dic.keys():
print(key)
# 输出结果
# name
# sex4.2 遍历字典的value（值）
dic = {'name':'zhangsan','sex':'m'}
for value in dic.values():
print(value)
# 输出结果
# zhangsan
# m4.3 遍历字典的项（元素）
dic = {'name':'zhangsan','sex':'m'}
for item in dic.items():
print(item)
# 输出结果
# ('name', 'zhangsan')
# ('sex', 'm')
4.4 遍历字典的key-value（键值对）
dic = {'name':'zhangsan','sex':'m'}
for key,value in dic.items():
print('key=%s,value=%s'%(key,value))
# 输出结果
# key=name,value=zhangsan
# key=sex,value=m4.5 练习
1、 有一个列表persons，保存的数据都是字典
persons = [{'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 20}, {'name': 'wangwu', 'age': 19},{'name': 'jerry', 'age': 21}]
要求让用户输入一个姓名，如果这个姓名在列表里存在，就提示用户名称已存在，添加失败；如果这个姓名在列表里不存在，提示让用户输入年龄，并将用户输入的姓名和年龄添加到这个列表里。
persons = [{'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 20}, {'name': 'wangwu', 'age': 19},{'name': 'jerry', 'age': 21}]
username = input('请输入一个名字：')
for person in persons:
if person['name'] == username:
print('名字已存在，添加失败')
break
else:
userage = input('请输入年龄:')
persons.append({'name':username,'age':int(userage)})
print(persons))2. 有一个字典dict1 = {"a":100,"b":200,"c":300}，使用代码，将字典的key和value互换，变成 {100:"a",200:"b",300:"c"}。
#使用字典推导式
dict1 = {'a':100,'b':200,'c':300}
dict2 = {v: k for k,v in dict1.items()}
print(dict2)三、集合的使用
1、set的使用
集合（set）是一个无序的不重复元素序列，可以使用大括号{}或者set()函数创建集合
注意：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。
创建格式：
parame = {value01，value02，...}
或者
set(value)
2、添加元素
创建格式：
s.add(x)
将元素x添加到集合s中，如果元素已存在，则不进行任何操作
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset) # {'Google', 'Runoob', 'Taobao', 'Facebook'}还有一个方法，也可以添加元素，且参数可以是列表、元组、字典等，语法格式如下：
s.update(x)
x可以有多个，用逗号分开。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({1,3})
print(thisset) # {1, 3, 'Google', 'Taobao', 'Runoob'}
thisset.update([1,4],[5,6])
print(thisset) # {1, 'Google', 3, 4, 5, 6, 'Runoob', 'Taobao'}3、移除元素
s.remove(x)
将元素x从集合s中移除，如果元素不存在，则会发生错误。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print(thisset) # {'Google', 'Runoob'}
thisset.remove("Facebook")
print(thisset) # KeyError: 'Facebook'此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard(x)
thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook") # 不存在也不会发生错误
print(thisset) # {'Taobao', 'Google', 'Runoob'}也可以设置随机删除集合中的一个元素，语法格式如下：
s.pop()
thisset = set(("Google", "Runoob", "Taobao"))
x = thisset.pop()
print(x) # Taobao
print(thisset) # {'Runoob', 'Google'}
4、set常见方法列表
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| union | 返回两个集合的并集 |
| update() | 给集合添加元素 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 删除集合中的元素，该元素在指定的集合中不存在。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
5、练习
有一个无序且元素数据重复的列表nums,
nums=[5,8,7,6,4,1,3,5,1,8,4],要求对这个列表里的元素去重，并进行降序排序。
nums=[5,8,7,6,4,1,3,5,1,8,4]
#方法一：调用列表的sort方法
num1 = list(set(nums))
num1.sort(reverse=True)
print(num1)
#方法二：使用sorted内置函数
print(sorted(list(set(nums)),reverse=True))四、转换相关
1、执行字符串
使用python内置的eval函数，可以执行字符串里的python代码。使用这种方式，可以将字符串转换成为其他类型的数据。
x = '1+1'
print(eval(x)) # 2
print(type(eval(x))) # <class 'int'>
y = '{"name":"zhangsan","age":18}'
print(eval(y))
print(type(eval(y))) # <class 'dict'>
print(eval('1 > 2')) # False
eval('input("请输入你的姓名：")')2、转换成为字符串
JSON（JavaScriptObjectNotation, JS对象简谱）是一种轻量级的数据交换格式，它基于ECMAScript的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。
JSON本质是一个字符串
JSON的功能强大，使用场景也非常广，这里只介绍如何使用Python的内置JSON模块，实现字典、列表或者元组与字符串之间的相互转换。
使用JSON的dumps方法，可以将字典、列表或者元组转换成为字符串。
import json
person = {'name': 'zhangsan', 'age': 18}
x = json.dumps(person)
print(x) # {"name": "zhangsan", "age": 18}
print(type(x)) # <class 'str'>
nums = [1, 9, 0, 4, 7]
y = json.dumps(nums)
print(y) # [1, 9, 0, 4, 7]
print(type(y)) # <class 'str'>
words = ('hello','good','yes')
z = json.dumps(words)
print(z) # ["hello", "good", "yes"]
print(type(z)) # <class 'str'>
使用json的loads方法，可以将格式正确的字符串转换成为字典、列表。
x = '{"name": "zhangsan", "age": 18}'
person = json.loads(x)
print(person) # {'name': 'zhangsan', 'age': 18}
print(type(person)) # <class 'dict'>
y = '[1, 9, 0, 4, 7]'
nums = json.loads(y)
print(nums) # [1, 9, 0, 4, 7]
print(type(nums)) # <class 'list'>
五、通用方法
字符串、列表、元组、字典和集合，它们有很多相同点，都是由多个元素组合成的一个可迭代对象，它们都有一些可以共同使用的方法。
1、算术运算符
在python里，常见的算数运算符，有一些可以使用于可迭代对象，它们执行的结果也稍有区别。
| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
| + | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
| - | {1,2,3,4} - {2,3} | {1,4} | 集合求差集 | 集合 |
| * | ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 复制 | 字符串、列表、元组 |
| in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
1.1 +
加法运算符可以用于字符串、列表和元组，用来拼接多个可迭代对象，不能用于字典和集合（思考：为什么字典和集合不能使用）。
print("hello" + "world") # helloworld
print([1,2] + [3,4]) # [1, 2, 3, 4]1.2 -
减法只能用于集合里，用来求两个集合的差集
print({1,6,9,10,12,3} - {4,8,2,1,3}) # {9, 10, 12, 6}1.3 *
乘法运算符可以用于字符串、列表和元组，用来将可迭代对象重复多次，同样不能用于字典和集合。
print('ab' * 4) # abababab
print([1,2]*4) # [1, 2, 1, 2, 1, 2, 1, 2]2、in
in和not in成员运算符可以用于所有的可迭代对象。但是需要注意的是，in和not in在对字典进行判断时，是查看指定的key是否存在，而不是value。
print('llo' in 'hello world') # True
print(3 in [1,2]) # False
print(4 in (1,2,3,4)) # True3、遍历
通过for...in ...我们可以遍历字符串、列表、元组、字典、集合等可迭代对象
3.1字符串遍历
a_str = "hello world"
for char in a_str:
print(char,end=' ') # h e l l o w o r l d
3.2列表遍历
a_list = [1,2,3,4,5]
for num in a_list:
print(num,end=' ') # 1 2 3 4 5
3.3元组遍历
a_turple = (1,2,3,4,5)
for num in a_turple:
print(num,end=" ") # 1 2 3 4 53.4带下标的遍历
可迭代对象都可以使用enumerate内置类进行包装成一个enumerate对象。对enumerate进行遍历，可以同时得到一个可迭代对象的下标和元素。
nums = [12,9,8,5,4,7,3,6]
#将列表nums包装成enumerate对象
for i,num in enumerate(nums): # i表示元素下标，num表示列表里的元素
print('第%d个元素是%d' %(i,num))
# 运行结果
# 第1个元素是9
# 第2个元素是8
# 第3个元素是5
# 第4个元素是4
# 第5个元素是7
# 第6个元素是3
# 第7个元素是6
