列表	元祖	字典	集合
标记	list	tuple	dict	set
符号	[1, 2]	(1, 2)	{key:value}	{set1, set2}
长度	动态，可变	静态，不可变	动态，可变	动态，可变
增加	append	/	dict[key]=value	add
删除	remove	/	pop	remove
更新	list[index] = value	/	dict[key]=value	set[index]=value
切片	list[1:3]	tuple[1:3]	/	/
reversed	倒序	倒序	/	/
sorted	支持	支持	支持	支持
迭代	可迭代	可迭代	可迭代	可迭代

列表list：

l = [1, 2, '3']

• 概念：一个可以存放任意数据类型的有序集合
• 列表是动态，长度不固定，可以随意增加（append），删除(remove)或者改变元素
• 支持切片操作 + 负数索引
• 列表基本操作

if __name__ == '__main__':
    l1 = [1, 2, 3, 4, 5]
    # append
    l1.append(6)
    print('append rs = {}'.format(l1))

    # remove
    l1.remove(2)
    print('remove rs = {}'.format(l1))

    # update
    l1[0] = 111
    print('update rs = {}\n'.format(l1))

    # reversed
    l2 = ['a', '1', 'b', 'aa']
    l2rs = reversed(l2)
    print('reversed l2 = {}'.format(l2))
    print('reversed rs = {} \n'.format(list(l2rs)))

    l3 = ['a', '1', 'b', 'aa']
    print('reverse l3 = {}'.format(l3))
    l3.reverse()
    print('reverse rs = {}'.format(list(l3)))

    # sorted
    l4 = ['a', '1', 'b', 'aa']
    l4rs = sorted(l4)
    print('sorted l4 = {}'.format(l4))
    print('sorted rs = {} \n'.format(list(l4rs)))

    l5 = ['a', '1', 'b', 'aa']
    l5.sort()
    print('sort l4 = {}'.format(l5))
    print('sort rs = {} \n'.format(list(l5)))

元组

tuple：

t = (1, 2, '3')

• 概念：一个可以存放任意数据类型的有序集合
• 元组是静态，长度大小固定，无法随机增，删，改元素
• 支持切片操作 + 负数索引
• 基本操作

if __name__ == '__main__':
    tup1 = (1, 22, 3, 22, 4, 5)
    print('tup1 is {}, id is {}'.format(tup1, id(tup1)))

    tup2 = tup1 + (6,)
    print('tup2 is {}, id is {}'.format(tup2, id(tup2)))

    # reserved
    tup3 = reversed(tup2)
    print('tup3 is {}, id is {}'.format(tuple(tup3), id(tup3)))

    # sorted
    tup4 = sorted(tup2)
    print('tup4 is {}, id is {}'.format(tuple(tup4), id(tup4)))

    # count
    print('tup2 22 count is {}'.format(tup1.count(22)))

字典Dict

• key/value键值对，python 3.6以前字典无序， python3.7字典为有序
• 基本数据格式：{key:value}
• 字典的原理：存放哈希值（hash（key）），key，value
• dict.get(key, default)，字典取值，若无则default作为返回值
• 基本操作

d = {'name': 'jason', 'age': 20}
# 增加
d['gender'] = 'man'
print(d)

# 删除
d.pop('gender')
print(d)

# 更新
d['age'] = 22
print(d)

# 获取
print(d.get('age'))
print(d.get('gender', 'femail'))

d2 = {'b': 1, 'a': 2, 'c': 10}
# key排序,返回新的字典
sorted_by_key = sorted(d2.items(), key=lambda x:x[0])
print(sorted_by_key)

# value排序,返回新的字典
sorted_by_value = sorted(d2.items(), key=lambda x:x[1])
print(sorted_by_value)

# key排序,返回新的字典
sorted_by_key_list = sorted(d2.keys())
print(sorted_by_key_list)

# key排序,返回新的字典
sorted_by_value_list = sorted(d2.values())
print(sorted_by_value_list)

集合

• 基本数据格式：`{1, 3, 4}
• 集合set的工作原理：存储哈希值和元素
• 基本操作

s = {1, 5, 2, 3}
# 增加元素4到集合
s.add(4)

# 从集合中删除元素4
s.remove(4)

s1 = sorted(s)
print(s1)