厨之梦进口食品网站谁做的免费b站推广网站有哪些

序列

序列是一种数据存储方式，用方括号标注，逗号分隔的一组值。在内存中，序列就是一块用来存放多个值的连续的内存空间。

常见序列结构有：字符串、列表、元组、字典、集合

列表

用于存储任意数目，任意类型的数据集合

[]创建

a = [10,20,'www','ggg']
a = []     #创建一个空的列表对象

list()创建

使用list()可以将任意可迭代的数据转化为列表。

a = list()  #创建一个空的列表对象
a  = list(range(10))   #range返回的是一个range对象，而不是列表
a
[0,1,2,3,4,5,6,7,8,10]a = list("wwwwww")
a
['w','w','w','w','w','w']

推导式生成列表

a = [x*2 for x in range(5)]
a
[0,2,4,6,8]

切片操作会返回新的对象

rgba = ["Red", "Green", "Blue","Alph"]
correct_rgba = rgba[:]
correct_rgba[-1] = "Alpha"
correct_rgba
["Red", "Green", "Blue", "Alpha"]
rgba
["Red", "Green", "Blue", "Alph"]

append()

原地修改列表对象，在列表尾部添加新的元素。不创建新的列表对象。

a = [10,20]
a.append(30)
a
[10,20,30]

+运算符

并不是真正在尾部添加元素，而是创建新的列表对象，将原列表的元素和新列表的元素依次复制到新的列表对象中。这样会设计大量的复制操作，对于操作大量元素不建议使用。创建了新的列表对象。

extend()

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

a = [20,40]
a.extend([60,80])
a
[20,40,60,80]

insert()

将指定元素插入到列表对象的任意指定位置。这样会让插入位置后的所有元素移动。

乘法扩展

a = ['www',666]
b = a*3
a
['www',666,'www',666,'www',666]

del

删除列表指定位置的元素

a = [1,2,3,40]
del a[1]
a
[1,3,40]

pop()

删除并返回指定位置的元素，如果未指定位置则默认操作列表最后一个元素。

a = [10,20,30,40,50]
a.pop()
50
a
[10,20,30,40]

remove()

删除首次出现的指定元素，若不存在该元素，抛出 ValueError 异常。

clear()

移除列表中的所有项。 类似于 del a[:]。

copy()

返回列表的浅拷贝。 类似于 a[:]。

列表也可以用作队列，然而，列表作为队列的效率很低。因为，在列表末尾添加和删除元素非常快，但在列表开头插入或移除元素却很慢（因为所有其他元素都必须移动一位）。

实现队列最好用 collections.deque，可以快速从两端添加或删除元素。

from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")           # Terry 到了
queue.append("Graham")          # Graham 到了
queue.popleft()                 # 第一个到的现在走了
'Eric'
queue.popleft()                 # 第二个到的现在走了
'John'
queue                           # 按到达顺序排列的剩余队列
deque(['Michael', 'Terry', 'Graham'])

元组tuple

元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。

()创建，小括号可以省略

a = (1,2,3)   # 或a = 1,2,3

**如果元组只有一个元素，则必须后面加逗号。**解释器会把(1)解释为整数1，(1,)才被解释为元组。

# 元组可以嵌套：
t = (5,4,3,2,1)
u = t, (1, 2, 3, 4, 5)
u
((5,4,3,2,1), (1, 2, 3, 4, 5))# 但它们可以包含可变对象：
v = ([1, 2, 3], [3, 2, 1])
v
([1, 2, 3], [3, 2, 1])

zip

zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个zip对象。

a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
d = zip(a,b,c)
list(d)
[(1,2,3),(4,5,6),(7,8,9)]

特点

• 不可变序列
• 元组的访问和处理速度比列表快
• 整数、字符串和元组可以作为字典的键，列表可变不能作为字典的键使用。

字典

字典是键值对的无序可变序列，字典中的每个元素都是一个“键值对”。字典是以 键 来索引的，键可以是任何不可变类型；字符串和数字总是可以作为键。 元组在其仅包含字符串、数字或元组时也可以作为键；如果一个元组直接或间接地包含了任何可变对象，则不可以用作键。字典的键必须是唯一的。

{}，dict()创建字典对象

花括号 {} 用于创建空字典。

a = {'name':'www','age':18,'job':'student'}   #花括号
b = dict(name='www',age=18,job='student')	
c = dict([('name','www'),('age',18),('job','student')])  #键值对序列
d = {}
e = dict()

zip()

k = ['name','age','job']
v = ['www',18,'student']
d = dict(zip(k,v))
d
{'name':'www','age':18,'job':'student'}

字典元素的访问

• 通过键访问值

a['name']
'www'

• 通过get()获取值

a.get('name')
'www'

• 通过items()列出所有键值对
• 通过keys()列出所有键
• 通过values()列出所有值

字典核心底层原理

集合

集合是无序可变，元素不能重复。底层是字典实现，集合的所有元素都是字典的键对象，因此是不能重复的且唯一的。

使用{}创建集合对象

创建空集合只能用set()，不能用{},{}创建的是空字典。

a = {3,5,7}
a
{3,5,7}
a.add(9)
a
{9,3,5,7}

使用set()，将列表、元组等可迭代对象转成结合。

a = ['a','b','c','b']
b = set(a)
b
{'a','b'},'c'