python基础学习——元组、字典、集合
python基础学习——元组、字典、集合
元组
基础概念
- 元组和列表类似，但属于不可变序列，元组一旦创建，不可以修改其元素。
- 元组的定义方式和列表相同，但定义时所有元素是放在一对圆括号“（）”中，而不是方括号中
元组构造
使用=直接赋值
>>>a=(3)
>>>type(a)
<class 'int'>
>>>a=(3,)
>>>type(a)
<class 'tuple'>
>>>len(a)
1
使用tuple函数将其他序列转换为元组
>>> tuple('abcdefg') #把字符串转换为元组
('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>> aList
[-1, -4, 6, 7.5, -2.3, 9, -11]
>>> tuple(aList) #把列表转换为元组
(-1, -4, 6, 7.5, -2.3, 9, -11)
>>> s = tuple() #空元组
>>> s
()
元组特点
- 元组一旦定义就不允许更改。
- 元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
- 元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元 组中删除元素。
- 从效果上看，tuple( )冻结列表，而list( )融化元组。
- 元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进 行遍历，那么一般使用元组而不用列表。
- 元组对不需要改变的数据进行“写保护”将使得代码更加安全。
- 元组可用作字典的键，也可以作为集合的元素。列表永远不能当做字典键使用，也不能作为集合的元素，因为列表不是不可变的。
字典
基础概念
- 字典是无序、可变序列。
- 定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。
- 字典中的键可以为任意不可变数据，比如整数、实数、复数、字符串、元组等等。
- 每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中
字典构造
使用=将一个字典赋值给一个变量
>>> a_dict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}
>>> a_dict
{'database': 'mysql', 'server': 'db.diveintopython3.org'}
>>> x = {} #空字典
>>> x
{}
使用dict利用已有数据创建字典
>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dictionary = dict(zip(keys, values)) # 可迭代对象方式来构造字典
>>> dictionary
{'a': 1, 'c': 3, 'b': 2, 'd': 4}
>>> x = dict() #空字典
>>> x
{}
以给定内容为键，创建值为空的字典
dict.fromkeys(列表）
>>> adict = dict.fromkeys(['name', 'age', 'sex'])
>>> adict
{'age': None, 'name': None, 'sex': None}
字典读取
以键作为下标可以读取字典元素，若键不存在则抛出异常
使用字典对象的get方法获取指定键对应的值，并且可以在键不存在的时候返回指定值（解决上一种方法的报错问题）
dict.get(key, default=None)
key – 字典中要查找的键。
default – 如果指定的键不存在时 ，返回该默认值，默认值就是none。
>>> aDict = {'name':'Dong', 'sex':'male', 'age':37}
>>> print(aDict.get('address'))
None
>>> print(aDict.get('address', 'SDIBT'))
SDIBT
>>>aDict['score'] = aDict.get('score',[])#同时做到字典的增加
[]
使用字典对象的setdefault方法获取指定键对应的值，并且可以在键不存在的时候返回指定值,添加键并将值设为默认值。（上一种方法的进阶版）
dict.setdefault(key, default=None)
key – 查找的键值。
default – 键不存在时，设置的默认键值。
aDict = {'Name': 'Runoob', 'Age': 7}
print ("Age 键的值为 : %s" % aDict.setdefault('Age', None))
print ("Sex 键的值为 : %s" % aDict.setdefault('Sex', None))
print ("新字典为：", dict)
>>>
Age 键的值为 : 7
Sex 键的值为 : None
新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}
字典对象的items()方法返回字典的键、值对
items() 函数以列表返回可遍历的(键, 值) 元组。将字典中的键值对以元组存储，并将众多元组存在列表中。
字典对象的keys()方法返回字典的键
字典对象的values()方法返回字典的值
>>>for key, value in aDict.items():
print(key, value)
name Dong
sex male
age 37
score []
>>>aDict.keys()
dict_keys(['name', 'sex', 'age', 'score'])
>>>print(aDict.keys())
>>>dict_keys(['name', 'sex', 'age', 'score'])
>>>for key in aDict.keys():
print(key)
name
sex
age
score
value同理
>>>for key in aDict:
print(key) #不加特殊说明，默认输出键
name
sex
age
score
字典的添加与修改
- 当以指定键为下标为字典赋值时：1）若键存在，则可以修改该键的值；2）若不存在，则表示添加一个键、值对。
- 使用字典对象的update()方法将另一个字典的键、值对添加到当前字典对象
>>>aDict.update({'a':'a','b':'b'})
>>>aDict
{'name': 'Dong', 'sex': 'male', 'age': 37, 'score': [], 'a': 'a', 'b': 'b'}
字典元素的删除
使用del删除整个字典，或者指定键的元素
del site['name']# 删除键是'name'的条目
del site #删除整个字典
使用字典对象的clear()方法来删除字典中所有元素，dict.clear()
dict.clear(); # 清空词典,但是不删除字典
使用字典对象的pop()方法删除并返回指定键的元素
>>>aDict.update({'a':'a','b':'b'})
>>>aDict
{'name': 'Dong', 'sex': 'male', 'age': 37, 'score': [], 'a': 'a', 'b': 'b'}
>>>pop_obj=aDict.pop('name')
>>>pop_obj
'Dong'
>>>aDict
{'sex': 'male', 'age': 37, 'score': [], 'a': 'a', 'b': 'b'}
使用字典对象的popitem()方法随机返回并删除字典中的一个元素（一般删除末尾对）
如果字典已经为空，却调用了此方法，就报出KeyError异常
>>>pop_obj=aDict.popitem() # 随机返回并删除一个键值对
首先生成包含1000个随机字符的字符串，然后统计每个字符的出现次数
import string
import random
x=string.ascii_letters+string.digits+string.punctuation
y=[random.choice(x) for i in range(1000)]
z=''.join(y)
d=dict()
for ch in z:
d[ch]=d.get(ch,0)+1
print(d)
String模块:
ascii_letters是生成所有字母，从a-z和A-Z, digits是生成所有数字0-9,punctuation #所有的标点字符.
random.choice( seq ) :
返回一个列表，元组或字符串seq的随机项。
str.join(sequence) :
返回通过指定字符str连接序列sequence中元素后生成的新字符串
collections模块和字典相结合
collections是Python内建的一个集合模块，使用时需要导入collections模块。其提供了许多其他数据类型。包括计数器（counter），有序字典（orderedDict），默认字典（defaultdict），可命名元组（namedtuple）和双向队列（deque）
字典推导式
{键表达式：值表达式for 可迭代对象 [if 条件表达式]}
举例：
>>> {i:str(i) for i in range(1, 5)}
{1: '1', 2: '2', 3: '3', 4: '4'}
>>> x = ['A', 'B', 'C', 'D']
>>> y = ['a', 'b', 'b', 'd']
>>> {i:j for i,j in zip(x,y)}
{'A': 'a', 'C': 'b', 'B': 'b', 'D': 'd'}
集合
基本概念
- 集合是无序、可变序列，使用一对大括号界定，元素不可重复，同一个集合中每个元素都是唯一的。
- 集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，而不能包含列表、字典、集合等可变类型的数据。
字典的创建
=直接赋值
举例
>>>a={1,2,3}
>>>type(a)
<class 'set'>
使用set将其他类型数据转换为集合
>>a=[1,2,3245,245,45,351,1]
>>>a=set(a) #自动删除重复的元素
>>>a
{1, 2, 45, 3245, 245, 351}
>>>type(a)
<class 'set'>
>>>a=set() #创建空集合
>>>a
set()
集合中增减元素
add操作
>>>a={1,2}
>>>a.add(3)
>>>a
{1, 2, 3}
当不再使用某个集合时，可以使用del命令删除整个集合。集合对象的pop()方法弹出并删除其中一个元素，remove()方法直接删除指定元素，clear()方法清空集合。
重点说一下pop操作，集合中使用pop和列表中使用pop是不一样的，因为集合是无序数据类型，所以索引没有意义
>>> a = {1, 4, 2, 3}
>>> a.pop() #不接受参数
1
集合的运算
>>> a_set = set([8, 9, 10, 11, 12, 13])
>>> b_set = {0, 1, 2, 3, 7, 8}
>>> a_set | b_set
>>>a_set.union(b_set)#并集，按位或运算符,两种表示方式
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set.union(b_set) #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set & b_set #交集，按位与运算符
{8}
>>> a_set.intersection(b_set) #交集
{8}
>>> a_set.difference(b_set) #差集
{9, 10, 11, 12, 13}
>>> a_set - b_set
{9, 10, 11, 12, 13}#两种表示方式
>>> a_set.symmetric_difference(b_set) #对称差集
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
>>> a_set ^ b_set #按位异或运算符
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
>>> x = {1, 2, 3}
>>> y = {1, 2, 5}
>>> z = {1, 2, 3, 4}
>>> x.issubset(y) #测试是否为子集
False
>>> x.issubset(z)
True
>>> {3} & {4}
set()
>>> {3}.isdisjoint({4}) #如果两个集合的交集为空，返回True
True
>>> x = {1, 2, 3}
>>> y = {1, 2, 5}
>>> z = {1, 2, 3, 4}
>>> x < y #比较集合大小/包含关系
False
>>> x < z #真子集
True
>>> y < z
False
>>> {1, 2, 3} <= {1, 2, 3} #子集
True
集合推导式
形式：{ 表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }
>>> s = {x.strip() for x in (' he ', 'she ', ' I')}
>>> s
{'I', 'she', 'he'}