Python:序列（衔接列表元组字符串知识）

参考：【python】什么是序列，Python序列详解_一个写湿的程序猿的博客-CSDN博客_python序列是什么意思

序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

在 Python 中，序列类型包括字符串、列表、元组、集合和字典；

【Ps:参考FishC的视频，顺序是先讲列表、字符串、元组后再讲集合和字典；经过查阅资料，他可能想要区分的是字符串、列表、元组这三类序列，他们是支持索引、切片、和运算符的操作的，而集合和字典则不行。】

下面是关于序列的不同形式，如下(使用type（）函数查询数据结构和数据类型):

#字典

字典的两个参数为键：值。字典通过键来读入，通过值输出。

字典是通过键和值的映射关系来存取数据。（其他的序列则是通过位置的偏移来存取数据（？存疑：何为数据偏移））(字典中的项是不可重复的，即一个键对应一个值得映射关系)

#字典的创建办法


y = {"A":"a","B":'b'}
y["C"] = 'c'
y
{'A': 'a', 'B': 'b', 'C': 'c'}

#使用dict()函数创建字典，注意键不需要引号
y = dict(A='a',B='b',C='c')
y
{'A': 'a', 'B': 'b', 'C': 'c'}

#使用列表中元组来包裹键值对，然后使用dict（）创建字典
y = dict([("A",'a'),("B","b"),('C','c')])
y
{'A': 'a', 'B': 'b', 'C': 'c'}

#将参数传入字典
y = dict ({"A":"a","B":'b'})
y
{'A': 'a', 'B': 'b'}

#混合办法
y = dict({"A":"a","B":'b'},C='c')
y
{'A': 'a', 'B': 'b', 'C': 'c'}

#使用dict（）+zip（）
y = dict(zip(["A","B",'C'],['a','b','c']))
y
{'A': 'a', 'B': 'b', 'C': 'c'}

#dict.fromkeys(seq[，value])创建空列表,[,value]可省略
d = dict.fromkeys('Crab',50)
d
{'C': 50, 'r': 50, 'a': 50, 'b': 50}

d= dict.fromkeys('Crab')
d
{'C': None, 'r': None, 'a': None, 'b': None}

#字典键值的删改和添加

对字典每一个键对应的值修改，以及添加一个新的键值对，可以用如下形式：

d[sep]=value

若要添加多个键值对，则需要运用ict.update（）函数

d.update({'f':100,'i':102})
d
{'C': None, 'r': None, 'a': None, 'b': None, 'f': 100, 'i': 102}
d.update(s='70',h='20')
d
{'C': None, 'r': None, 'a': None, 'b': None, 'f': 100, 'i': 102, 's': '70', 'h': '20'}
d.update(s=30,G=20)
d
{'C': None, 'r': None, 'a': None, 'b': None, 'f': 100, 'i': 102, 's': 30, 'h': '20', 'G': 20}

倘若要删除某一键值对，可供使用的有ict.pop(key[,default]), ict.popitem()形式，也可以用ict.clear()清空字典，语法如下：

ict.pop(key[,default])
ict.popitem()
ict.clear()


d = dict.fromkeys('Crab',50)
d
{'C': 50, 'r': 50, 'a': 50, 'b': 50}
d['C']=30
d
{'C': 30, 'r': 50, 'a': 50, 'b': 50}
d.pop('a')
50
d
{'C': 30, 'r': 50, 'b': 50}
d.pop('a','没有呀')
'没有呀'
d.popitem()
('b', 50)
d
{'C': 30, 'r': 50}
d.clear()
d
{}

#字典的查找

d[]可以用于查找键对应的值，ict.get()可以查找值和添加default参数，ict.setdefault()既可以查找值，也可以新建新的键值对。李子如下：

d = {'C': 30, 'r': 50, 'a': 50, 'b': 50}
d['C']
30
d.get('c','这儿没有c捏')
'这儿没有c捏'
d.setdefault('C','None')
30
d.setdefault('c','None')
'None'
d
{'C': 30, 'r': 50, 'a': 50, 'b': 50, 'c': 'None'}

#字典的视图对象

item（）【获取键值对】，keys（）【获取键】,values()【获取值】就是字典的三个视图对象（而一个显示键的简单窗口）。参考:

python 视图对象_什么是字典视图对象？_weixin_39705435的博客-CSDN博客

与copy（）不同，视图是动态的，它随着字典键值得改变而改变（属于深拷贝吗？）

d
{'C': 30, 'r': 50, 'a': 50, 'b': 50, 'c': 'None'}
keys=d.keys()
values = d.values()
items=d.items()
items
dict_items([('C', 30), ('r', 50), ('a', 50), ('b', 50), ('c', 'None')])
keys
dict_keys(['C', 'r', 'a', 'b', 'c'])
values
dict_values([30, 50, 50, 50, 'None'])
d['c']=10000  #改变一个键值对
d
{'C': 30, 'r': 50, 'a': 50, 'b': 50, 'c': 10000}
values
dict_values([30, 50, 50, 50, 10000])
keys
dict_keys(['C', 'r', 'a', 'b', 'c'])
items
dict_items([('C', 30), ('r', 50), ('a', 50), ('b', 50), ('c', 10000)])

迭代器

iter（）和next（）

e=iter(d)
next(e)
'C'
next(e)
'r'
next(e)
'a'
next(e)
'b'
next(e)
'c'

# 循环构建字典：


d
{'C': 30, 'r': 50, 'a': 50, 'b': 50, 'c': 10000}
b={x:y for y,x in d.items()}
b
{30: 'C', 50: 'b', 10000: 'c'}
c={v:k for k,v in d.items() if v>100}
c
{10000: 'c'}
d = {x:ord(x) for x in 'Crab'}
d
{'C': 67, 'r': 114, 'a': 97, 'b': 98}

#集合

集合有散列表的支持，执行效率很高，但代价就是占据存储空间会更大。

集合与字典都是用{}来表示的，不同的是，字典中键值之间用：表示映射关系，而集合没有

type({})
<class 'dict'>
type({'crab'})
<class 'set'>
type({'crab':1})
<class 'dict'>

#集合的无序性

{x for x in 'Crabfish'}
{'s', 'C', 'f', 'b', 'h', 'r', 'a', 'i'}
set('Crab')
{'r', 'C', 'a', 'b'}
s = set("Crab")
s
{'r', 'C', 'a', 'b'}

#集合的唯一性

集合中不允许有重复元素

set([1,2,3,4,5,5])
{1, 2, 3, 4, 5}
s = [1,2,3,4,5,5]
len(s) == len(set(s))
False

#集合的检索

set.isdisjoint（others）判断是否不相关，返回True或False值

a = set("Crab")
a
{'r', 'C', 'a', 'b'}
a.isdisjoint(set('Crack'))
False
a.isdisjoint(set('Crabfish'))
False
a.isdisjoint(set('Python'))
True

set.issubset（others）判断是否被包含

a.issubset('Crabfish')
True

set.issuperset(others)判断是否包含（超集）

a.issuperset('rab')
True

set.union（others）求并集

a.union({1,2,3,4,5})
{1, 2, 'C', 3, 4, 5, 'b', 'r', 'a'}

set.intersection(others)求交集

a.intersection('Crabfish')
{'r', 'C', 'a', 'b'}

set.difference(others)求差集

a.difference('Crabfish')
set()
a.difference('Cra')
{'b'}

set.a.symmetric_difference(others)求对称差集

a.symmetric_difference('Fish')
{'s', 'C', 'h', 'b', 'r', 'F', 'a', 'i'}

以上方法都支持多参数且序列均可

但如果是用比较运算符来对比的话，运算符两边就必须是同一类型了。

#添加

set.intersection_update(others)

set.difference_update(others)

set.add（）[将整个字符串作为元素]

都可以用来更新集合

a = {1,2,3,4,5,6}
a.intersection_update({2,4,5})
a
{2, 4, 5}
a.difference_update({2})
a
{4, 5}
a.symmetric_difference_update({4,5,6,7,8})
a
{6, 7, 8}
a.add('9')
a
{6, 7, 8, '9'}