Python-常用容器总结

Python-常用容器总结 一、列表

# 1. 创建列表
x1 = [1, 2, "aa"]
x2 = list(range(1, 10, 2))
x3 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
x4 = []


# 2. 访问列表元素
print(x1[2])
print(x1[-1]) # 倒数第一个元素；最后一个元素
print(x1[-2]) # 倒数第二个元素
print(x3[2][0])


# 3. 添加元素
l1 = [1, 2]
l1.append(3) # 追加
l1.append(4) # 追加
l1.extend([1, 2, 3]) # 扩展，将 新的列表对象 里面的元素扩展到list1中
l1.insert(0, 0) # 在 index=0 的前面插入元素


# 4. 删除元素
l2 = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
l2.remove(5)    # 移除 某个值的第一个匹配项
l2.pop()        # 移除 最后一个 元素
l2.pop(-1)      # 移除 最后一个 元素
l2.pop(1)       # 移除 index=1 的元素


# 5. 切片 [start:stop:step] == [)
ls = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(ls[0:])   # [start:] 从start到最后
print(ls[:3])   # [:stop] 从头到stop
print(ls[1:2])  # [start:stop] 从start到stop
print(ls[0::2]) # [start:stop:step] 以步长为step，从编号 start 往编号 stop 切片


# 6. 常用 *** 作符
# (1) '==' ：只有成员、成员位置都相同时才返回True
print([1, 2] == [1, 2])
# (2) '+'  ：两个列表合并成一个新的列表，将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存
print([1, 2] + [2, 2, 6, 8])
# (3) '*'  ：将列表复制 n 遍，生产新的列表
print([1, 2, 3] * 2)
# (4) 'in' ：判断元素是否在列表中
print(123 in [1, 2, 123])
# (5) 'not in' ： 判断元素是否不在列表中
print(123 not in [1, 2, 123])


# 7. 其他方法
lx = [1, 1, 2, 3, 3, 2, 5, 5, 5]
# (1) list.count(obj) 统计某个元素在列表中出现的次数
print(lx.count(5))
# (2) list.index(x]) 从列表中找出某个值第一个匹配项的索引位置
print(lx.index(2))
# (3) list.reverse() 反转列表，改变的是列表本身，无返回值
lx.reverse()
# (4) list.sort(key=None, reverse=False) 对列表排序，无返回值
#   -- reverse=False 升序
#   -- reverse=True  降序
lx.sort(reverse=False)

二、元组

# 1. 创建元组
# (1) tuple被创建后就不能对其进行修改，类似字符串
# (2) 元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()
# (3) 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
temp1 = (1,) # 需要加括号，否则括号会被当作运算符使用
temp2 = (1, 2, 3)
temp3 = ((1, 2, 3), (1, 2, 3), (1, 2, 3))


# 2. 元组访问元素与切片 [start, stop)
tu = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, (1, 2, 3))
print(tu[0])
print(tu[0::2])
print(tu[-1][0:1])


# 3. 元组元素的更新
# 元组有不可更改 的性质，因此不能直接给元组的元素赋值
# 但是只要元组中的元素可更改，那么就可以直接更改其元素
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])


# 4.  *** 作符
print((1, 2) + (5, ))
print((1, 2) * 5)
print(1 in (1, 2))
print("aa" not in (1, 5))


# 6. 内置方法：元组大小和内容都不可更改，因此只有 count 和 index 两种方法
tus = (1, 2, 1, 2, 'puuu')
print(tus.count('puuu'))
print(tus.index(1)) # 如果不存在，则抛异常ValueError

三、集合

# 1. 创建集合
# 在创建空集合的时候只能使用 s = set() ，因为 s = {} 创建的是空字典
s1 = set()
s2 = {'aa', 'bb', 'aa'}



# 2. 集合
#   -- 无序 和 唯一
#   -- 重复元素在 set 中会被自动被过滤
#   -- 由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice) *** 作
#   -- 可以判断一个元素是否在集合中



# 3. 常见的方法
# (1) 使用 len() 得到集合大小
print(len({1, 2, 3, 4, 5}))

# (2) 使用 for 把集合中的数据读取出来
for i in {'Google', 'Baidu', 'Taobao'}:
    print(i)

# (3) 可以通过 in 或 not in 判断一个元素是否在集合中
print('a' in {'a', 5, 'ss'})
print('a' not in {'a', 5, 'ss'})

# (4) set.add(elmnt) 用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何 *** 作
d = {1, 2, 3}
d.add("dddd")
print(d)

# (5) set.remove(item) 移除集合中的指定元素。如果元素不存在，则会发生错误
d = {1, 9, 2, 3}
d.remove(9)
print(d)

# (6) set.discard(value) 移除集合中的指定元素。如果元素不存在，则不做任何 *** 作，不报错
d.discard(9)
print(d)

# (7) set.pop() 随机移除一个元素

# (8) set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False
print({1, 2}.isdisjoint({2, 3}))
print({1, 2}.isdisjoint({6, 3}))

# (9) 返回两个集合的交集
#   -- set.intersection(set1, set2 ...)
#   -- set1 & set2 返回两个集合的交集
print({1, 2, 3}.intersection({5, 6, 7}))
print({1, 2, 3}&{5, 6, 7})

# (10) 返回两个集合的并集
#   -- set.union(set1, set2...)
#   -- set1 | set2
print({1, 2, 3}.union({"aaa", 1}))
print({1, 2, 3} | {"aaa", 1})

# (11) 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False
#   -- set.issubset(set)
#   -- set1 <= set2
print({1, 2, 3}.issubset({1, 2, 3}))
print({1, 2, 3} <= {1, 2, 3})

# (12) 用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False
#   -- set.issuperset(set)
#   -- set1 >= set2
print({1, 2, 3}.issuperset({1, 2, 3}))
print({1, 2, 3, 4} >= {1, 2, 3} >= {1, 2, 3})
print({1, 2, 3, 4} >= {1, 2, 9, 3} >= {1, 2, 3})

四、字典

# 1. 字典
# 字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值
# 字典 是无序的 键值对集合
# 键必须是互不相同的
# 内部存放的顺序和 key 放入的顺序是没有关系的
# 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存



# 2. 创建字典
dic0 = {}
dic1 = {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}
dic2 = dict()



# 3. 添加元素
dic2['a'] = 1
dic2['b'] = 2
dic2['b'] = 3 # 后面的值会把前面的值冲掉



# 4. 常用方法
dic = dict()
dic["aa"] = 11
dic["bb"] = 22
dic["cc"] = 33
dic["dd"] = 44

# (1) dict.get(key) 返回指定键的值
print(dic.get('aa'))
print(dic['aa'])

# (2) dict.clear() 用于删除字典内所有元素
dic.clear()

# (3) 删除指定键的 键值对
dic.pop("aa")

# (4) dict.keys() 返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键
print(list(dic.keys()))

# (5) dict.values() 返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有值
print(list(dic.values()))

# (6) dict.items() 返回用键值对构成的元组构成的列表
print(dic.items())

# (7) "key in dict" 用于判断键是否存在于字典中，如果键在字典 dict 里返回 true ，否则返回 false

# (8) "key not in dict"  如果键在字典 dict 里返回 false ，否则返回 true

五、序列

# 容器的互相转换
'''
集合
se = set([1, 2, 3, 4, 4, 5, 5, 6, 6, 6]) # 列表-->集合
se = set((1, 2, 3, 4, 4, 5, 5, 6, 6, 6)) # 元组-->集合

列表
li = list({1， 2， 3， 4}) # 集合-->列表
li = list((1， 2， 3， 4)) # 元组-->列表

元组
tu = tuple({1， 2， 3， 4}) # 集合-->元组
tu = tuple([1， 2， 3， 4]) # 列表-->元组

字典
d1 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098))) # 元组-->字典
d2 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)]) # 列表-->字典

'''



'''
1. list(sub)    把一个可迭代对象转换为列表
2. tuple(sub)   把一个可迭代对象转换为元组
3. str(obj)     把obj对象转换为字符串
4. len(s)       返回对象（字符、列表、元组等）长度或元素个数
5. max(sub)     返回序列或者参数集合中的最大值
6. min(sub)     返回序列或参数集合中的最小值
7. sum(iterable[, start=0]) 返回序列 iterable 与可选参数 start 的总和
8. sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序 *** 作
    a. iterable -- 可迭代对象。
    b. key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代
    对象中的一个元素来进行排序。
    c. reverse -- 排序规则， reverse = True 降序 ， reverse = False 升序（默认）
    d. 返回重新排序的列表。
9. reversed(seq) 函数返回一个反转的迭代器。
    -- seq：要转换的序列，可以是 tuple, string, list 或 range
'''