python中的列表、元组、集合、字典

# 查询变量所指的对象类型
x = 1
type(x)
#判断变量所指类型是否是某类型
isinstance(x, int)
#删除变量
del x

列表的一般用法：

list1 = ["python", 1, 6, [2, "book"], "code"] #list内元素的数据类型可以不同,也可以是另外一个list
print (list1)

#使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
print (list1[:])  #访问全部
print (list1[0],list1[1])  #访问第0个元素和第一个元素
print (list1[-1],list1[-2]) # 打印出序列的最后一个元素和倒数第二个元素

print (list1[0:3]) #切片,此操作左闭右开
print (list1[:3])  #切片,从头开始，取出索引值0，1，2的元素，不包含索引值为3的元素
print (list1[-3:]) #切片，从后向前数索引，也只能从左往右切片
print (list1[0:-1:2]) #按步长切片,从第一个开始，步长为2，不包含最后一个元素
print (list1[::2]) #按步长切片，从第一个开始，步长为2，包含最后一个元素

#更新
list[1] = 14  # 列表list1 中第1个元素的值更新为14

#添加元素  append()  extend()
list1.append('bar')  # 在列表的最后加一个新元素
list1 = list1 + ["apple"]  #直接相加法

#在指定位置添加元素 insert()
list1.insert(1, 'hello')  #在列表第1个位置(0为起始位置)添加元素

#删除元素 pop()
x = list1.pop()      # 移除列表的最后一个元素，同时将这个元素返回到一个变量中
y = list1.pop(1)    #删除列表第1个位置(0为起始位置)的元素
del list1[2]  #删除第2个(0为起始位置)元素

你可以找到更多的列表使用方法，在以下文档中。

切片
除了一次访问列表中的一个元素，Python还提供了一种更高效的使用方式叫做切片。下面我们举几个例子。

nums = [0, 1, 2, 3, 4]
print(nums)
print(nums[2:4]) # 得到一个切片，下标从2到4，但是不包括4
print(nums[2:]) # 得到一个切片，下标从2到列表结束
print(nums[:2]) # 得到一个切片，下标从开始到2，不包括2
print(nums[:]) # 得到整个列表的元素
print(nums[:-1]) # 得到一个切片，下标从开始到最后一个元素，不包括最后一个元素
nums[2:4] = [8, 9] # 将列表中下标从2到4(不包括4)的切片替换成新的元素
print(nums)

如果想取得每个元素的下标，可以通过调用内置函数enumerate来实现。

#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
#enumerate(sequence, [start=0])  sequence:一个序列、迭代器或其他支持迭代对象。start:下标起始位置。
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
    print('#{}: {}'.format(idx + 1, animal))

一种更高级的列表循环方法,可以避免我们创建一个空列表进行元素的添加

nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)

嵌套列表

list1 = [["a","b","c"],[1,2,3]]
#访问成员b
list1[0][1]

#返回列表元素的个数 len()
count = len(list1)  #返回的是 list1 最外层的元素个数
print(count)  # 2

#移除列表中的元素，并且返回这个值 pop()
l = list1.pop(1)

#对列表中的元素进行排序 sort()
l.sort()
print(l)  # [1, 2, 3]

#查找列表中第一个匹配的元素的索引值 index()
list1 = [12,11,13,11]
i = list1.index(11)
print(i)  # 1

集合(set)
集合里面的元素没有顺序关系，同时里面也没有重复的元素。
两种声明方法：1.使用{ }；2. set( )

animals = {'cat', 'dog'}
print('cat' in animals)   # 验证该元素是否在集合中 in
print('fish' in animals)
animals.add('fish')       # 在集合里面添加元素 add()
print('fish' in animals)
print(len(animals))       # 打印出集合的元素个数 len()
animals.add('cat')         
print(len(animals)) 
animals.remove('cat')     # 从集合里面移除某个元素  remove()
print(len(animals))

#两个集合间的运算
a = {"a","b","c","d","e","f"}
b = {"a","b","c","x","y","z"}

print(a & b)  #交 {'a', 'b', 'c'}
print(a | b)  #并 {'e', 'd', 'a', 'b', 'z', 'x', 'y', 'c', 'f'}
print(a ^ b)  #集合 a,b 中不同时存在的 {'z', 'e', 'y', 'x', 'd', 'f'}

#集合添加元素 add()
my_set = {"a","b","c"}
my_set.add("d")
print(my_set)

#移除指定元素  remove()
my_set.remove("a")
print(my_set)

#随机移除一个元素 pop()
pop_param = my_set.pop()
print(pop_param)
print(my_set)

#计算集合的个数 len()
print(len(my_set))

#清空集合 clear()
my_set.clear()
print(my_set)

#判断 a 是否在集合里 in / not in
print("a" in my_set)  
print("a" not in my_set)

可以在以下文档查看关于集合的所有信息。

字典(dict)
字典是一种可变容器类型，也是可以存储任意类型的对象。
字典里面存在的都是数据对，这些数据都是以(key, value)的形式存在，且存在映射关系。

d = {'cat': 'cute', 'dog': 'furry'}  # 创造一个字典
print(d['cat'])       # 取得字典中的某个元素
print('cat' in d)     # 判断字典中key是否有该元素

d['fish'] = 'wet'     # 字典中添加一个新元素
print(d['fish'])      # 打印出字典中的元素
print(d.get('monkey', 'N/A'))  # 如果元素在字典的key中，返回其对应的值，否则返回get中的值
print(d.get('fish', 'N/A'))

del d['fish']         # 从字典中移除某个元素
print(d.get('fish', 'N/A')) # fish被移除之后，不能显示出'wet'
print(d['pig'])

d = {"a":12, "b":13, "c":14}

#访问
keys = d.keys()  #keys()函数以列表返回一个字典所有的键
values = d.values() #values()函数以列表返回字典中的所有值
print(keys)    # 输出结果为dict_keys(['a', 'b', 'c'])
print(values)  # 输出结果为dict_values([12, 13, 14])

print(d["a"])  # 输出结果为 12

#增加
d["d"] = 15

#更新
d["a"] = 20

#删除 del
del d["b"]

#判断键是否在字典中 in / not in
i = "c" in d
print(i)

#清空字典 clear()
d.clear()
print(d)

参考：python 字典操作提取key,value

元组(Tuple)
元组和列表类似，但是元组是无法改变的。同时一个最大的不同是元组可以作为字典中的key，而列表不可以。
元组(Tuple)中只有一个元素时，t = (1, ) 写一个逗号，消除歧义

d = {(x, x + 1): x for x in range(10)} # 使用元组创造一个字典
t = (5, 6)        # 创造一个元组
print(type(t))    # 打印出元组的类型
print(d[t])       # 打印出字典中对应于(5, 6)的元素
print(d[(1, 2)])  # 打印出字典中对应于(1, 2)的元素

下面的文档有更多关于元素的信息。