05-元组-字典-集合-迭代器

1. 元组

• 与列表非常相似，也是个有序的序列，但是元组是不可变的，不能修改的。

• 元组的定义：

  # 空元组
  tuple1 = ()
  
  # 一个元素的元组
  tuple2 = (1,)		#重要的逗号
  
  # 多个元素的元组
  tuple3 = (1,"2",True)
  
  # 二维元组
  tuple4 = ((1,2,3),(4,5,6))

• 元组的访问及错误的修改方式：

  # 访问元组中的数字3
  In [1]: tuple1 = (1,2,3,4)
  In [2]: tuple1[2]     #或tuple1[-2]
  Out[2]: 3
      
  # 元组的修改
  In [4]: tuple2 = (1,2,[3,4,5])
  In [5]: tuple2[1] = 3
  TypeError: 'tuple' object does not support item assignment   #报错，元组不能修改
      
  # 可以对元组中的可变类型修改
  In [6]: tuple2[2][1] = 9
  In [7]: tuple2
  Out[7]: (1, 2, [3, 9, 5])

• 元组的删除、组合、重复

  # 删除
  tuple1 = (1,2,3)
  del tuple1			#del删除
  
  # 组合
  In [8]: tuple2 = (1,2,3)
  In [9]: tuple3 = (4,5,6)
  In [10]: tuple2 + tuple3
  Out[10]: (1, 2, 3, 4, 5, 6)
      
  # 重复
  In [11]: tuple4 = (1,2,3)
  In [12]: tuple4 * 2
  Out[12]: (1, 2, 3, 1, 2, 3)

• 元组截取及成员运算符的运用

  # 截取：同列表、字符串格式
  In [17]: tuple1 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  In [18]: tuple1[2:5]
  Out[18]: (3, 4, 5)
  In [19]: tuple1[::-1]
  Out[19]: (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
      
  # 成员运算符的运用
  In [22]: 3 in tuple2
  Out[22]: True
  In [23]: 11 not in tuple2
  Out[23]: True

• 元组的方法

  方法名	描述
  len(tuple)	返回元素的个数
  max(tuple)	返回元组中最大的元素
  min(tuple)	返回元组中最小的元素
  count(obj)	统计obj在元组中的个数
  index(obj,start,stop)	查看obj在元组中的索引，可指定范围
  tuple(seq)	将序列转为元组

2. 字典

• 经典的key-value存储方式，一个key对应一个value，也称之为键值对

• 字典是无序和不可变的

• key-value的特性：

  1. 同一字典中的key是唯一的
  2. key必须是不可变类型
  3. value可以为任意类型

• 定义字典：

  # 格式：每个键值用":"分隔，多个键值对用","分割,总体被"{}"包含
  dict1 = {"name":"wss","age":18}			#普通写法
  dict2 = {"names":["wang","sense"],"ages":[18,18]}		#包含列表的写法
  dict3 = {"class":{"云18":{"第一组":"sense"}}}			 #包含字典的写法 
  dict4 = dict[("wss",123),("sense",456)]					# 使用dict函数创建字典

• 值的获取：

  # 值的获取： 获取键为age的值
  dict1 = {"name":"wss","age":18}
  In [6]: dict1 = {"name":"wss","age":18}
  In [7]: dict1["age"]
  Out[7]: 18
  In [8]: dict1["height"]
  KeyError: 'height'				#键不存在则抛错

• 键值对的添加及删除

  # 添加键值对
  In [9]: dict2 = {"name":"sense"}
  In [10]: dict2["age"] = 18
  In [11]: dict2
  Out[11]: {'name': 'sense', 'age': 18}
  In [12]: dict2["age"] = 19
  In [13]: dict2
  Out[13]: {'name': 'sense', 'age': 19}		# 添加字典中存在的键，旧的将会被覆盖
  
  # 删除键值对
  In [19]: dict2 = {"name":"sense","age":18}
  In [20]: dict2.pop("age")
  Out[20]: 18
  In [21]: dict2
  Out[21]: {'name': 'sense'}
  # 使用del删除
  In [23]: del dict2["name"]
  In [24]: dict2
  Out[24]: {'age': 18}

• 常用字典方法：

  # update：合并字典,但会修改和原字典中key相同的value
  In [3]: dict1 = {"name":"sense"}
  In [4]: dict2 = {"name":"wang","age":18}
  In [5]: dict1.update(dict2)
  In [6]: dict1
  Out[6]: {'name': 'wang', 'age': 18}
  
  # values：拿出字典中所有键对应的值
  In [7]: dict1 = {'name': 'wang', 'age': 18}
  In [8]: dict1.values()
  Out[8]: dict_values(['wang', 18])
  
  # item：将字典中的每个键值对，依次放到元组中
  In [11]: dict1.items()
  Out[11]: dict_items([('Google', 'www.google.com'), ('sense', 'www.sensewang.cn'), ('taobao', 'www.taobao.com')])
  
  # keys：将字典中的所有键返回成一个列表
  In [35]: dict1.keys()
  Out[35]: dict_keys(['Google', 'sense', 'taobao'])
  
  # get: 获取字典中键对应的值
  In [38]: dict1 = {'Google': 'www.google.com', 'sense': 'www.sensewang.cn', 'taobao': 'www.taobao.com'}
  In [39]: dict1.get("Google")
  Out[39]: 'www.google.com'
  In [40]: dict1.get("haha")			# 没有则返回None
      
  # clear: 清空字典
  In [41]: dict1 = {'Google': 'www.google.com', 'sense': 'www.sensewang.cn', 'taobao': 'www.taobao.com'}
  In [42]: dict1.clear()
  In [43]: dict1
  Out[43]: {}
  
  # copy：浅拷贝字典
  In [47]: dict1 = {'Google': 'www.google.com', 'sense': 'www.sensewang.cn', 'taobao': 'www.taobao.com'}
  In [48]: dict2 = dict1.copy()
  In [49]: dict2
  Out[49]: 
  {'Google': 'www.google.com',
   'sense': 'www.sensewang.cn',
   'taobao': 'www.taobao.com'}
  
  # pop修改key
  In [50]: dict1 = {'Google': 'www.google.com', 'sense': 'www.sensewang.cn', 'taobao': 'www.taobao.com'}
  In [51]: dict1.pop("Google")
  Out[51]: 'www.google.com'
  In [52]: dict1["wang"] = dict1.pop("sense")
  In [53]: dict1
  Out[53]: {'taobao': 'www.taobao.com', 'wang': 'www.sensewang.cn'}
      
  # 成员运算符判断键是否存在
  In [56]: dict1 = {'Google': 'www.google.com', 'sense': 'www.sensewang.cn', 'taobao': 'www.taobao.com'}
  In [57]: 'Google' in dict1
  Out[57]: True
  In [58]: 'Baidu' in dict1
  Out[58]: False

3. 集合

• 无序的不重复的序列，可以实现交集、并集、可以给数据去重使用等

• 集合的创建

  # 使用{}创建
  In [1]: set1 = {1,2,3,4,1}
  In [2]: set1
  Out[2]: {1, 2, 3, 4}		#集合的特性：不可重复
  In [3]: type(set1)
  Out[3]: set
  
  # 使用set创建			传入的可为list、tuple、dict、string
  In [5]: list1 = [1,2,3]
  In [6]: tuple1 = (1,2,3)
  In [7]: dict1 = {'name':"sense","height":175.5}
  In [8]: set(list1)
  Out[8]: {1, 2, 3}
  In [9]: set(tuple1)
  Out[9]: {1, 2, 3}
  In [10]: set(dict1)
  Out[10]: {'height', 'name'}
  
  # 空集合
  In [15]: set1 = set()
  In [16]: type(set1)
  Out[16]: set

• 集合的交集和并集

  In [21]: set1 = {1,2,3}
  In [22]: set2 = {2,3,4}
  In [23]: set1 & set2			# 交集,相当于函数intersection()
  Out[23]: {2, 3}
  In [24]: set1 | set2			# 并集,相当于函数union()
  Out[24]: {1, 2, 3, 4}

• 集合常见函数

  # add：向集合中添加元素，只能添加不可变类型
  In [45]: set1 = {1,2,3}
  In [46]: set1.add(4)
  In [47]: set1
  Out[47]: {1, 2, 3, 4}
  In [48]: set1.add("56")
  In [49]: set1
  Out[49]: {1, 2, 3, 4, '56'}
  In [50]: set1.add([1,2,3])        #添加list抛错
  TypeError: unhashable type: 'list'
       
  # update: 将插入的元素打碎后插入
  In [51]: set1 = {1,2,3}
  In [52]: set1.update([4,5,6])
  In [53]: set1
  Out[53]: {1, 2, 3, 4, 5, 6}
  In [54]: set1.update('789')
  In [55]: set1
  Out[55]: {1, 2, 3, 4, 5, 6, '7', '8', '9'}
      
  # remove：删除集合中的元素
  In [56]: set1 = {1,2,3}
  In [57]: set1.remove(2)
  In [58]: set1
  Out[58]: {1, 3}
  
  # pop: 随机删除一个集合中的元素
  In [97]: set1 = set([1,2,3,4,5,6])
  In [98]: set1.pop()
  Out[98]: 1
  In [99]: set1.pop()
  Out[99]: 2

4. 类型之间的转换及使用set去重

# list --> set
In [1]: list1 = [1,2,3,4,5,5]
In [2]: set(list1)
Out[2]: {1, 2, 3, 4, 5}

# tuple --> set
In [3]: tuple1 = (1,2,3,4,5,5)
In [4]: set(tuple1)
Out[4]: {1, 2, 3, 4, 5}

# set --> list
In [6]: set1 = {1,2,3,4,4}
In [7]: list2 = list(set1)
In [8]: list2
Out[8]: [1, 2, 3, 4]

# set --> tuple
In [9]: set2 = {1,2,3,4,4}
In [10]: tuple2 = tuple(set1)
In [11]: tuple2
Out[11]: (1, 2, 3, 4)

# 去重
In [12]: tuple3 = (1,2,3,3,4,5,5)
In [13]: list3 = [1,2,3,3,4,5,5]
In [14]: set(tuple3)
Out[14]: {1, 2, 3, 4, 5}
In [15]: set(list3)
Out[15]: {1, 2, 3, 4, 5}

5. 可迭代对象和迭代器

• 可迭代对象：

  • 可以直接被for循环使用
  • 可以使用isinstance判断
  • 列表生成器等也可作为可迭代对象

  In [1]: from collections import Iterable      #Iterable用于判断可迭代对象
  # 此函数只是判断前者的类型是不是可迭代对象
  # 也可判断前者是不是属于后者的类型
  In [2]: isinstance([1,2,3],Iterable)
  Out[2]: True
  In [3]: isinstance((),Iterable)			
  Out[3]: True
  In [4]: isinstance(123,Iterable)
  Out[4]: False
  In [5]: isinstance([x for x in range(10)],Iterable)
  Out[5]: True
  In [6]: isinstance("123",str)
  Out[6]: True
  In [7]: isinstance("123",(str,list))
  Out[7]: True

• 迭代器：

  • 不但可以被for循环，还可以被next ()函数获取下一个值

  # 判断
  In [8]: from collections import Iterator    #Iterable用于判断迭代器
  In [9]: isinstance([],Iterator)
  Out[9]: False
  In [10]: isinstance([1,2,3],Iterator)
  Out[10]: False
  In [11]: isinstance((x for i in range(10)),Iterator)
  Out[11]: True
  
  # next()函数演示
  In [20]: iter1 = (i for i in range(10))
  In [21]: iter2 = [1,2,3,4]
  In [22]: iter1
  Out[22]: <generator object <genexpr> at 0x000002261B381C50>		# 列表生成器，是个实例
  In [23]: iter2
  Out[23]: [1, 2, 3, 4]			# 单纯的列表
  In [29]: next(iter1)
  Out[29]: 0
  In [30]: next(iter1)			# 对于迭代器，正常获取值
  Out[30]: 1
  In [31]: next(iter2)			# 对于非迭代器，抛错
  TypeError: 'list' object is not an iterator
      
  # 将可迭代对象转为迭代器
  In [32]: list1 = [1,2,3]
  In [33]: iter1 = iter(list1)
  In [34]: type(iter1)
  Out[34]: list_iterator
  In [35]: iter1
  Out[35]: <list_iterator at 0x2261b2ab898>
  In [36]: isinstance(iter1,Iterator)
  Out[36]: True
  In [37]: next(iter1)
  Out[37]: 1
  In [38]: next(iter1)
  Out[38]: 2

---