数据类型----元组、字典、集合

1元组

1.1 元组基本介绍

• 元组表现形式tuple
• 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
• 使用()创建元素
• 元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略
• 元组解包指将元组当中的每一个元素都赋值给一个变量
• 例如： （1，2）、（‘a’,‘b’,‘abc’）

1.2 元组的特点

• 可包含任意类型的对象
• 有序性。元组中的对象可以通过位置进行索引和分片
• 大小不能改变，既不能为元组添加对象，也不能删除元组中的对象
• 元组中的对象也不能改变
• 与列表类似，元组存储的是对象的引用，而不是对象的本身

1.3 元组的基本操作

• 创建元组
  • 可用常量或 tuple()方法来创建元组

>>>()
()
>>>tuple()	#创建空的元组对象
()
>>>(2,)	#包含一个对象的元组，这里的逗号不能少
(2,)
>>>(1,2,5,'abcde',[1,2])	#包含不同类型对象的元组
(1,2,5,'abcde',[1,2])
>>>1,2,5,'abcde',[1,2]	#元组常量可以省略括号
(1,2,5,'abcde',[1,2])
>>>(1,2,('a',b))	#元组中可以嵌套元组
(1,2,('a',b))
>>>tuple('abcde')	用字符串创建元组，可迭代对象均可创建元组
('a','b','c','d','e')
>>>tuple([1,2,3])	#用列表创建元组
(1,2,3)
>>>tuple(x*2 for x in range(5))	#用解析结构创建元组
(0,2,4,6,8)

• 求长度
  • len() 函数可用于获取元组的长度

>>>len((1,2,3,4,5))
5

• 合并
  • 加法运算可以合并多个元组

>>>(1,2)+('abc','def')+(2.445,)
(1,2,'abc','def',2,445)

• 重复
  • 乘法运算可用于合并多个重复的元组

>>>(1,2,3)*2
(1,2,3,1,2,3)

• 迭代
  • 可用迭代遍历元组中的各个对象

>>>for x in (1,2,'abcd',[4,5]):print(x)

1
2
abcd
[4,5]

• 关系判断
  • in 操作符可用于判断对象是否属于元组
  • not in

>>>2 in (1,2,3)
True
>>>4 in (1,2,3)
False

• 索引和分片
  • 可以通过位置对元组进行索引和分片

>>>x = tuple(range(10))
>>>x
(0,1,2,3,4,5,6,7,8,9)
>>>x[1]
1
>>>x[-1]
9
>>>x[2:6]
(2,3,4,5)
>>>x[2:]
(2,3,4,5,6,7,8,9)
>>>x[:5]
(0,1,2,3,4)
>>>x[1:7:2]
(1,3,5)
>>>x[7:1:-2]
（7，5，3）

• 矩阵
  • 与列表相似，可以通过嵌套的方式用元组来表示不可变的矩阵

>>>x=((1,2,3),(4,5,6),(7,8,9))
>>>len(x)
3
>>>x[0]
(1,2,3)
>>>x[2][2]
9

1.4 元组方法

• count()方法
  • 用于返回指定值在元组中出现的次数

>>>x=(1,2)*3
>>>x
(1,2,1,2,1,2)
>>>x.count(2)
3
>>>x.count(1)
3
>>>x.count(4)
0

• index(value,[start,[end]])方法
  • 用于在元组中查找指定值
  • 未用 start 和 end 指定范围时，返回指定值在元组中第一次出现的位置
  • 指定范围时，返回在指定范围内第一次出现的次数

>>>x=(1,2,3,4)*3
>>>x
(1,2,3,4,1,2,3,4,1,2,3,4)
>>>x.index(2)
1
>>>x.index(2,2)	#从偏移量2至末尾查找指定值第一次出现的位置
5
>>>x.inddex(2,6,10)	#在范围[6:10]内查找
9
>>>x.index(5) #如果元组不包含指定的值，则报错
………………………

2 可变对象

• Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。而列表list、字典dict、集合set是可变类型
• 可变对象中都保存了三个数据
  • id(标识)
  • type(类型)
  • value(值)

3 字典

• 字典是一种无序的映射的集合，包含一系列的“键:值”对。
• 字典常用 { } 表示，如{‘name’:‘John’,‘age’:25}。其中字符串 name、age 为键，John、25为值

3.1字典的特点

• 字典的键通常采用字符串，但也可以用数字、元组等不可变类型
• 字典值可以是任意类型
• 又称 关联数组、散列表，它通过键映射到。字典是无序的，他通过键来索引映射的值，而不是通过位置来索引
• 字典属于可变映射，通过索引来修改键映射的值
• 字典长度可变，可为字典添加或删除”键:值“对
• 字典可以任意嵌套，即键映射的值可以是一个字典
• 字典存储的是对象的引用，而不是对象本身

3.2 字典的基本操作

• 创建字典

>>> {}
{}
>>> dict()
{}
>>> {'name':'John','age':25,'sex':'male'}
{'name': 'John', 'age': 25, 'sex': 'male'}
>>> {'book':{'Python编程':100,'Java':99}}
{'book': {'Python编程': 100, 'Java': 99}}
>>> {1:'one',2:'two'}
{1: 'one', 2: 'two'}
>>> dict(name='John',age=25)
{'name': 'John', 'age': 25}
>>> dict([('name','John'),('age',25)])
{'name': 'John', 'age': 25}
>>> dict.fromkeys(['name','age'])
{'name': None, 'age': None}
>>> dict.fromkeys(['name','age'],0)
{'name': 0, 'age': 0}
>>> dict.fromkeys('abc')
{'a': None, 'b': None, 'c': None}
>>> dict.fromkeys('abc',10)
{'a': 10, 'b': 10, 'c': 10}
>>> dict(zip(['name','age'],['John',25]))
{'name': 'John', 'age': 25}
>>> x = {}
>>> x['name'] = 'John'
>>> x['age'] = 25
>>> x
{'name': 'John', 'age': 25}

• 求长度

>>> x = dict(zip(['name','age'],['John',25]))
>>> len(x)
2

• 关系判断
  • in 操作符用于判断字典是否包含某个键
  • not in

x = dict(zip(['name','age'],['John',25]))
>>> 'name' in x
True
>>> 25 in x
False
>>> 'sex' not in x
True

• 索引
  • 通过键来索引映射的值
  • 通过索引修改映射的值
  • 通过索引删除键值对

>>> x ={'book':{'Python编程':100,'Java':99},'publish':'人民邮电出版社'}
>>> x['book']	#通过键索引映射的值
{'Python编程': 100, 'Java': 99}
>>> x['book']['Python编程']	#通过两个键来索引嵌套的字典
100
>>> x['publish'] = '北京大学出版社'	#修改
>>> x
{'book':{'Python编程':100,'Java':99},'publish':'北京大学出版社'}
>>> del x['book']	#删除
>>> x
{'publish':'北京大学出版社'}

3.3 字典的常用方法

• clear()

>>> x = {'name':'John','age':25
>>>> x.clear()
>>> x
{}

• copy()

>>> x = {'name':'John','age':25}
>>> y = x	#直接赋值，x,y引用同一个字典
>>> x,y
({'name': 'John', 'age': 25}, {'name': 'John', 'age': 25})
>>> y['name'] = 'Curry'
>>> x,y
({'name': 'Curry', 'age': 25}, {'name': 'Curry', 'age': 25})
>>> y is x	#判断是否引用相同对象（id()查看）
True
>>> y = x.copy()	# y 引用复制的字典
>>> x,y
({'name': 'Curry', 'age': 25}, {'name': 'Curry', 'age': 25})
>>> y['name'] = 'Python'
>>> x,y
({'name': 'Curry', 'age': 25}, {'name': 'Python', 'age': 25})
>>> y is x	##判断是否引用相同对象（id()查看）
False

• get(key[,default])
• pop(key[,default])
• popitem()
• setdefault(key[,default])
• update(other)

3.4 字典视图 (遍历字典)

• 字典的 items()、keys()、values() 方法用于返回字典键值对的视图对象
• 视图对象支持迭代操作，并可反应未来对字典的修改
• 视图对象不是列表，不支持索引
• 通常用 list() 方法将视图对象转换为列表

3.4.1 items()

• 返回键值对视图

>>> x = {'name':'John','age':25}
>>> y = x.items()	#返回键值对视图
>>> y
dict_items([('name', 'John'), ('age', 25)])
>>> for a in y:print(a)	#迭代键值对视图

('name', 'John')
('age', 25)
>>> x['age'] = 30	#修改字典
>>> x
{'name': 'John', 'age': 30}
>>> y	#从显示结果可以看出视图反映了字典的修改内容
dict_items([('name', 'John'), ('age', 30)])
>>> list(y)	#将键值对视图转换为列表
[('name', 'John'), ('age', 30)]

3.4.2 keys()

• 返回字典中去全部键的视图

>>> x = {'name': 'John', 'age': 30}
>>> y = x.keys()
>>> y
dict_keys(['name', 'age'])
>>> x['sex'] = 'male'
>>> x
{'name': 'John', 'age': 30, 'sex': 'male'}
>>> y
dict_keys(['name', 'age', 'sex'])
>>> list(y)
['name', 'age', 'sex']
>>> 

3.4.3 values()

• 返回字典中去全部值的视图

>>> x
{'name': 'John', 'age': 30, 'sex': 'male'}
>>> y = x.values()
>>> y
dict_values(['John', 30, 'male'])

3.4.4 键视图的集合操作

• 键视图支持各种集合运算，键值对视图和值视图不支持集合运算。

>>> x = {'a':1,'b':2}
>>> kx = x.keys()
>>> kx
dict_keys(['a', 'b'])
>>> y = {'b':3,'c':4}
>>> ky = y.keys()
>>> ky
dict_keys(['b', 'c'])
>>> kx - ky	#求差集
{'a'}
>>> kx | ky	#求并集
{'b', 'a', 'c'}
>>> kx & ky	#求交集
{'b'}
>>> kx ^ ky	#求对称差集
{'a', 'c'}

4 集合

4.1 集合简介

• 集合表现形式 set
• 集合和列表非常相似
• 不同点
  • 集合只能存储不可变对象
  • 集合中存储的对象是无序的
  • 集合不能出现重复元素
• 使用{}来创建集合
• 可以通过set()来将序列和字典转换成集合
• len() 使用len()来获取集合中元素的数量
• add()像集合中添加元素
• update()将一个集合中的元素添加到另一个集合当中
• pop()随机删除集合中的一个元素一般是删除最后一个元素
• remove() 删除集合中指定的元素
• clear() 清空集合

4.2 集合的运算

符号	解释
&	交集运算
|	并集运算
-	差集运算
^	异或集
<=	检查一个集合是否是另一个集合的子集
<	检查一个集合是否是另一个集合的真子集
>=	检查一个集合是否是另一个集合的超集
>	检查一个集合是否是另一个集合的真超集

5 习题:统计–优美子数组

• 问题：

给你一个整数数组 nums 和一个整数 k。
如果某个 连续 子数组中恰好有 k 个奇数数字，我们就认为这个子数组是「优美子数组」。
请返回这个数组中「优美子数组」的数目。
示例 1：
输入：nums = [1,1,2,1,1], k = 3
输出：2
解释：包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。
示例 2：
输入：nums = [2,4,6], k = 1
输出：0
解释：数列中不包含任何奇数，所以不存在优美子数组。
示例 3：
输入：nums = [2,2,2,1,2,2,1,2,2,2], k = 2
输出：16
提示：
1 <= nums.length <= 50000
1 <= nums[i] <= 10^5
1 <= k <= nums.length
题目来源：力扣

• 解题思想 ——1：
  
• 代码——1

def numberOfSubarrays_1(sums,k):
	odd = [-1] #设定头部边界
	for i in range(len(nums)):
		if nums[i] % 2 != 0:
			odd.append(i) #将奇数坐标添加到坐标位数组
	odd.append(len(nums))	#添加尾部边界
	n = 0 
	for i in range(1,len(odd)-k):	#避免越界
		n += (odd[i]-odd[i-1]) * (odd[i+k]-odd[i+k-1])
	return n
if __name__ == '__main__':
    nums = [2,2,2,1,2,2,1,2,2,2]
    k = 2
    print(numberOfSubarrays_1(nums,2))

• 解题思想——2：
  
• 代码——2：

class Solution:
    def numberOfSubarrays(nums,k):
        cnt = [0] * (len(nums) + 1)
        cnt[0] = 1
        odd, ans = 0, 0
        for num in nums:
            if num % 2 == 1:
                odd += 1
            if odd >= k:
                ans += cnt[odd - k]
            cnt[odd] += 1
        return ans
if __name__ == '__main__':
    nums = [2,2,2,1,2,2,1,2,2,2]
    k = 2
    print(Solution.numberOfSubarrays(nums,k))