列表(list)

定义一个列表使用一对中(方)括号”[ ] “。

list[index]进行索引

lst_of_random_things = [1, 3.4, 'a string', True]

>>> lst_of_random_things[2] = 'bbb'

>>> lst_of_random_things[0]

>>> lst_of_random_things[-1]

>>>print(lst_of_random_things[2])

>>>print(lst_of_random_things[0])

>>>print(lst_of_random_things[-1])

分别输出bbb、1 和True

列表切片和切丁

使用切片功能从列表中提取多个值。在使用切片功能时，包含下限，不包含上限。

因此：

>>> lst_of_random_things = [1,3.4,'a string',True]

>>> lst_of_random_things[1:2]

[3.4]

仅返回列表中的 3.4。注意，这与单个元素索引依然不同，因为你通过这种索引获得了一个列表。冒号表示从冒号左侧的起始值开始，到右侧的元素（不含）结束。

从列表的开头开始，也可以省略起始值。

>>> lst_of_random_things[:2]

[1,3.4]

要返回到列表结尾的所有值，可以忽略最后一个元素。

>>> lst_of_random_things[1:]

[3.4,'a string',True]

这种索引和字符串索引完全一样，返回的值将是字符串。

判断是否存在于列表

使用 in 和 not in 返回一个布尔值，表示某个元素是否存在于列表中，也能判断某个字符串是否存在于另一个字符串

>>> 'this'in'this is a string'

True

>>> 'in'in'this is a string'

True

>>> 'isa'in'this is a string'

False

>>> 5notin[1,2,3,4,6]

True

>>> 5in[1,2,3,4,6]

False

可变性和顺序

>>> my_lst = [1,2,3,4,5]

>>> my_lst[0] ='one'

>>> print(my_lst)

['one',2,3,4,5]

将列表中的 1 替换为 'one。这是因为，列表是可变的。

但是，以下代码不可行：

>>> greeting ="Hello there"

>>> greeting[0] ='M'

这是因为，字符串是不可变的。意味着如果要更改该字符串，你需要创建一个全新的字符串。

对于你要使用的每种数据类型，你都有必要理解如何设定索引，可变吗，有序吗。了解数据结构的这些信息很有用！此外，为什么使用一种数据类型在很大程度上取决于这个类型的特性，以及如何轻松地利用这些特性！

列表的常用方法

1.可以使用len()函数获得列表的长度（字典中的元素的个数）； 

2.可以使用索引来引用列表中的元素，注意：列表中的索引是从０开始的，并且在列表中还支持负索引； 

3.list是一个可以变的有序列表，因此可以往你自己的列表中添加和删除元素：在末尾添加元素用的是append()方法，在指定的位置插入元素使用的是insert()方法； 

4.在列表中删除元素：删除末尾的元素使用的是pop()方法，删除指定位置的元素使用pop(i),其中i是索引下标； 

5.若想替换list中的某个元素，可以直接把该元素赋值给对应的元素下标即可； 

6.在一个list中可以有不同的数据类型，可以有字符串类型，整型，或者bool等，并且list的元素中也可以有另外一个list，就相当于一个循环的嵌套一样。

L.append(var)      #追加元素

L.insert(index,var)     #插入var到index的位置

L.pop(var)              #返回最后一个元素，并从list中删除之

L.remove(var)            #删除第一次出现的该元素

L.count(var)            #该元素在列表中出现的个数

L.index(var)            #该元素的位置,无则抛异常

L.extend(list6)        #追加list６，即合并list到L上,这里注意，使用extend函数可以一次在一个列表中插入任意多个值，而不必须每次只使用append()一次一值的插入

L.sort()        #排序

L.reverse()    #倒序

del L[1]        #删除指定下标的元素del 

L[1:3]      #删除指定下标范围的元素

#复制list:

L1 = L      #L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。

L1 = L[:]  #L1为L的克隆，即另一个拷贝。

元组(tuple)

元组是另一个实用容器。它是一种不可变有序元素数据类型。定义一个元组使用一对小(圆)括号"( )"。

location = (13.4125,103.866667)

元组和列表相似，它们都存储一个有序的对象集合，并且可以通过索引访问这些对象。但是与列表不同的是，元组不可变，你无法向元组中添加或删除项目，或者直接对元组排序。元组还可以用来以紧凑的方式为多个变量赋值。

dimensions =52,40,100    #在定义元组时，小括号是可选的

length, width, height = dimensions

print("The dimensions are {} x {} x {}".format(length, width, height))

在第二行，我们根据元组 dimensions 的内容为三个变量赋了值。这叫做元组解包。你可以通过元组解包将元组中的信息赋值给多个变量，而不用逐个访问这些信息，并创建多个赋值语句。

也可以一次性为三个变量赋值：

length, width, height =52,40,100

print("The dimensions are {} x {} x {}".format(length, width, height))

tuple的陷阱： 

1.当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来； 

2.定义只有一个元素的Tuple的时候，需要这样: 

tuple1 = (123,) 

后面要加上一个逗号，这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义。 

tuple2 = (123) ＃如果你这样定义你定义的将是１２３这个元素，而不是一个元组。 

元组不可变，但是可以组合：

 t1 = ('wuyanl','luoting','aimeiyu')>>> t2 = (1,2,3,4,5,6,7,8,9,0)>>> t1

('wuyanl', 'luoting', 'aimeiyu')>>> t2

(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)>>> t3 = t1 +t2>>> t3

('wuyanl', 'luoting', 'aimeiyu', 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

常用方法：

1.比较两个元组元素：cmp(tuple1,tuple2)相等的话返回0，不相等返回1； 

2.计算元组的长度：len(tuple 

3.返回元组中的最大值最小值：max(tuple),min(tuple)； 

4.将列表转换成元组：Tuple = tuple(list)。

集合

集合是一个包含唯一元素的可变无序集合数据类型。集合的一个用途是快速删除列表中的重复项。

numbers = [1,2,6,3,1,1,6]

unique_nums = set(numbers)

print(unique_nums)

输出为：

{1, 2, 3, 6}

集合和列表一样支持 in 运算符。和列表相似，你可以使用 add 方法将元素添加到集合中，并使用 pop 方法删除元素。注意和列表不同，集合是无序的，因此没有“最后一个元素”。

fruit = {"apple","banana","orange","grapefruit"}    # define a set

print("watermelon" in fruit)    # check for element

fruit.add("watermelon")    # add an element

print(fruit)

print(fruit.pop())    # remove a random element

print(fruit)

输出结果为：

False

{'grapefruit', 'orange', 'watermelon', 'banana', 'apple'}

grapefruit

{'orange', 'watermelon', 'banana', 'apple'}

常用方法

 set1 = {1, 2, 3, 4, 5}        #定义一个集合

# 或者使用 set 函数        

list1 = [6, 7, 7, 8, 8, 9]

set2 = set(list1)

set2.add(10)         # 添加新元素

set([8, 9, 6, 7])  #去掉重复内容,而且是无序的

set3 = frozenset(list1)    #固定集合

set3.add(10) # 固定集合不能添加元素

#方法（所有的集合方法）：

s.issubset(t)         #如果s是t的子集,返回True，否则返回False

s.issuperset(t)         #如果s是t的超集,返回True，否则返回False

s.union(t)         #返回一个新集合, 该集合是s和t的并集

s.intersection(t)         #返回一个新集合, 该集合是s和t的交集

s.difference(t)         #返回一个新集合, 该集合是s的成员, 但不是t的成员, 即返回s不同于t的元素

s.symmetric_defference(t)         #返回所有s和t独有的(非共同拥有)元素集合

s.copy()         #返回一个s的浅拷贝, 效率比工厂要好

#方法（仅适用于可变集合）:

以下方法参数必须是可哈希的

s.update(t)         #用t中的元素 修改s，即s现在包含s或t的成员

s.intersection_update(t)         #s中的成员是共同属于s和t的元素

s.difference_update(t)         #s中的成员是属于s但不包含在t中的元素

s.symmetric_difference_update(t)         #s中的成员更新为那些包含在s或t中，但不是s和t共有的元素

s.add(obj)         #在集合s中添加对象

objs.remove(obj)         #从集合s中删除对象obj，如果obj不是集合s中的元素（obj not in s）,将引发keyError错误

s.discard(obj)         #如果obj是集合s中的元素，从集合s中删除对象obj

s.pop()         #删除集合s中得任意一个对象，并返回它

s.clear()         #删除集合s中的所有元素

## 集合有并集，交集，求差操作

## 并集：intersection() 方法返回一个新集合，包含在两个集合中同时出现的所有元素。

## 交集：union() 方法返回一个新集合，包含在两个 集合中出现的元素。

## 差集：difference() 方法返回的新集合中，包含所有在 集合A出现但未在集合B中的元素。

## symmetric_difference() 方法返回一个新集合，包含所有只在其中一个集合中出现的元素。

# 删除元素

set2.discard(6)         # 当元素不存在时,不会引发异常

set2.remove(6)         # 与discard的区别在于，如果没有要删除的元素，remove会引发一个异常

set2.pop()         # 因为set是无序的，所以pop会随机的从set中删除一个元素

字典

字典是可变数据类型，其中存储的是唯一键到值的映射。下面是存储元素和相应原子序数的字典。

定义 Dictionary 使用一对大(花)括号” { } ”。 

elements = {"hydrogen":1,"helium":2,"carbon":6}

字典的键可以是任何不可变类型，例如整数或元组，而不仅仅是字符串。甚至每个键都不一定要是相同的类型！我们可以使用方括号并在括号里放入键，查询字典中的值或向字典中插入新值。

print(elements["helium"])     

elements["lithium"] =3      

使用关键字 in 可以检查值是否在字典中。get() 会在字典中查询值，但是和方括号不同，如果没有找到键，get 会返回 None（或者你所选的默认值）。

print("carbon"inelements)

print(elements.get("dilithium"))

输出结果为：

True

None

恒等运算符

is        #检查两边是否恒等

is not        #检查两边是否不恒等

你可以使用运算符 is 检查某个键是否返回了 None。或者使用 is not 检查是否没有返回 None。

n = elements.get("dilithium")

print(nisNone)

print(nisnotNone)

会输出：

True

False

常用方法

dic.clear()        #清空字典 

dic.keys()        #获得键的列表 

dic.values()        #获得值的列表 

dic.copy()        #复制字典 

dic.pop(k)       # 删除键k 

dic.get(k)        #获得键k的值 

dic.update()        #更新成员，若成员不存在，相当于加入 

dic.items()            #获得由键和值组成的列表

dict.get(key, default=None)         #根据key获取值，若不存在则返回None

小结

    列表：可变、可重复、可索引、有序、类型可不同

    元组：不可变、可重复、可索引、有序、类型可不同

    集合：可变、不可重复、不可索引、随便有无序、类型可不同

    字典：可变、key不可重复、可索引、随便有无序、类型可不同