【Python】列表和字典

List（列表）

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
加号 + 是列表连接运算符，星号 * 是重复操作。

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表 ['abcd', 786, 2.23, 'runoob', 70.2]
print (list[0])         # 输出列表第一个元素 abcd
print (list[1:3])       # 从第二个开始输出到第三个元素 [786, 2.23]
print (list[2:])        # 输出从第三个元素开始的所有元素 [2.23, 'runoob', 70.2]
print (tinylist * 2)    # 输出两次列表 [123, 'runoob', 123, 'runoob']
print (list + tinylist) # 连接列表 ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

列表中的元素是可以改变
Python 列表截取可以接收第三个参数，参数作用是截取的步长
如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串:

def reverseWords(input):
     
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")
 
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1]
 
    # 重新组合字符串
    output = ' '.join(inputWords)
     
    return output
 
if __name__ == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw) #输出结果 runoob like I

使用 append() 方法来添加列表项

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1) # 更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

使用 del 语句来删除列表的的元素

list = ['Google', 'Runoob', 1997, 2000]
del list[2]
print ("删除第三个元素 : ", list) # 删除第三个元素 :  ['Google', 'Runoob', 2000]

Tuple（元组）

元组基础
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：

tuple1 ='a','b','c','d','e' # tuple可以不用带括号，但一般带括号
tuple2 = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取

元祖的构造方法

1. 一个元素，需要在元素后添加逗号

tup2 = (20,) # 一个元素，需要在元素后添加逗号

2. 使用tuple()创建空元祖

t = tuple()

修改元祖元素
直接修改元祖的元素会导致报错

t[O] = 'A'

但是可以通过+来替换元祖的元素，例如：

t = ('b','c','d','e')
t = ('A',) + t[1:]
print(t) # 输出 ('A', 'c', 'd', 'e')

比较
元祖之间的比较，每个元素都进行比较，如果两个元素相同就接着比较下一个位置上的元素，直到两个元祖的元素不同，找到不同的元素后，后面元素的大小比较就不考虑了

(0，1，2) < (0，3，4) # True
(0,4,20000) < (0,3,4) # False

使用元祖交换变量的值

a = 1,2,3
b = 3,2,1
a, b = b, a
print(a) # 输出 3,2,1
print(b) # 输出 1,2,3

列表和元祖
zip这个方法可以将两个或两个以上的列表整合成一个
看下面的例子，zip将字符串和列表结合：

s = 'abc'
t = [0,1,2]
print(zip(s,t)) # 输出 <zip object at 0x000001E543E84600>

输出的结果是zip对象，zip对象最常用于遍历中
看下面的例子：

s = 'abc'
t = [0,1,2]
print(zip(s,t))
for pair in zip(s,t):
    print(pair)

输出

('a', 0)
('b', 1)
('c', 2)

zip对象算是一种迭代器，某方面和列表很相似，但是与列表不同的是，不能使用索引来选取元素
如果要使用列表的操作符和方法，可以用zip对象来创建一个列表

list(zip(s,t))

输出结果 [('a', 0), ('b', 1), ('c', 2)]
这里输出的结果是包含元祖的列表，

如果前后两个参数的长度不一致，依据长度短的一方输出结果

list(zip('Anne'，Elk'))  # 输出结果 [('A'，'E')，('n', '1')，('n'，'k')]

可以使用元祖在for循环来遍历列表

t= [('a'，0)，('b'，1),('c'，2)]
for letter, number in t:
	print(number,letter)

0 a
1 b
2 c

列表最常用，但是在有些地方可能更需要使用元祖

1. return语句，返回元祖比返回列表更简洁
2. 使用序列作为字典的键，最好用不可改变的类型如元祖和字符串
3. 作为参数传递给方法，使用元祖更安全

又因为元祖不可改变，所以不能用sort和reverse方法。但是python提供了内置的sorted和reversed方法，可以用于任意序列

t = 3,2,123,23
print(sorted(t)) #输出结果 [2, 3, 23, 123]

print([x for x in reversed([1,2,3,4,5])])  #输出结果 [5, 4, 3, 2, 1]

Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行去重。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)   # 输出集合，重复的元素被自动去掉 
# {'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

Dictionary（字典）

字典是无序的对象集合
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
键(key)必须使用不可变类型
在同一个字典中，键(key)必须是唯一的

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值  输出结果： 1 - 菜鸟教程
print (dict[2])           # 输出键为 2 的值  输出结果： 2 - 菜鸟工具
print (tinydict)          # 输出完整的字典 输出结果：{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print (tinydict.keys())   # 输出所有键  输出结果：dict_keys(['name', 'code', 'site'])
print (tinydict.values()) # 输出所有值  输出结果：dict_values(['runoob', 1, 'www.runoob.com'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)} # 推导式
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

修改字典
向字典添加新内容的方法是增加新的键/值对

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息

删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

Counter
Counter 是 dict 字典的子类，Counter 拥有类似字典的 key 键和 value 值，只不过 Counter 中的key值为待计数的元素，而 value 值为对应元素出现的次数 count。看下面的例子：

>>> from collections import Counter
>>> count = Counter('parrot')
>>> count
Counter({'r': 2,'t': 1,'o': 1,'p': 1,'a': 1})

Counter在很多方面和字典很像，不同的是如果返回的键不存在不会报错而是返回0

defaultdict
defaultdict是Python内建dict类的一个子类，第一个参数为default_factory属性提供初始值，默认为None。它覆盖一个方法并添加一个可写实例变量。
defaultdict其他功能与dict相同，但会为一个不存在的键提供默认值，如int,set,str,list函数等，从而避免KeyError异常。

from collections import defaultdict
bag = {'apple', 'orange', 'cherry', 'apple', 'apple', 'cherry', 'blueberry'}
count = defaultdict(int)
for fruit in bag:
    count[fruit] += 1
print(count)