python四 list tuple set dict(列表，元组，集合，字典)-优快云博客

list1 = [1, 2, 3, 4]
list1 = ['a', 'bb', 'china']
# 不需要有相同的数据类型
list1 = [1, 2, 'aab', True]

# 列表推导式
[表达式 for 变量 in 列表]
或者
[表达式 for 变量 in 列表 if 条件]

list1 = [i**4 for i in range(20)]

# 修改列表内的元素
# 指定index
li[0] = '女神'

# 通过切片
# 将切片的那部分列表，直接替换为指定的列表
li[0:3] = [1, 2]
print(li)

列表索引，切片

list1 = [1, 2, 'a', 'china', True]

list[m:n:step] # m开始索引，n结束索引， step索引步长
list1[0] # 1
list1[:] # [1, 2, 'a', 'china', True]
list1[0:] # [1, 2, 'a', 'china', True]
list1[:-1] # [1, 2, 'a', 'china']
list1[2:4] # ['a', 'china'] 取出的元素是不包括最后一个索引值的

列表操作

list1 = [1, 2]
list2 = ['a', 'b']

# 连接两个列表
list1 + list2

# 检测元素是否在列表中
1 in list1 # True

# 列表迭代
# 在对列表进行迭代时不能进行改变列表长度的操作
for i in list1:
    print(i)
    
len(list1)  # 列表长度

max([1, 2, 4, 8, 9, 11]) # 求列表的最大值
min([1, 2, 4, 8, 9, 11]) # 求列表的最小值

# 在列表尾追加元素， 它只能有一个参数，且传入什么参数就插入什么样的参数
list1.append(1)
list1.append([1, 2, 4]) # [1, 2, 1, [1, 2, 4]]

# 传入的参数是序列或者说是iterable的，，将序列的单个元素依次插入
list1.extend([1, 2, 4]) # [1, 2, 1, [1, 2, 4], 1, 2, 4]
 
# 指定位置插入元素
list1.insert(0, [1, 4, 9]) # [[1, 4, 9], 1, 2, 1, [1, 2, 4], 1, 2, 4]
list1.insert(0, 4)  # ['aa', [1, 4, 9], 1, 2, 1, [1, 2, 4], 1, 2, 4]

# 移除列表中第一个元素，默认是最后一个
list1.pop()  # 4

# 移除匹配项,如果没有匹配项会报错
list1.remove(1)

# 统计列表中某个元素的个数
list1.count(1) # 2

# 定位元素第一次在列表中出现的位置，如果该元素没有在列表内，会报错
list1.index(1)

# 列表排序 ,元素类型要相同
list1 = [1, 4, 11, 9, 8, 6, 5, 8]
list1.sort() # [1, 4, 5, 6, 8, 8, 9, 11]

# 列表元素反序
list1.reverse() # [11, 9, 8, 8, 6, 5, 4, 1]

# 列表拷贝, 这是浅拷贝
list1 = [['a', 'b'], 1, 2]
list2 = list1.copy()
list2[0][1] = 'cc'
list1

# 列表转换为字符串
join: 要注意列表元素不是字符串时的情况
str: 直接将列表转换为字符串

Python 元组

与列表类似，不同之处在于元组一经创建，就不能在对元组进行增册操作，里面的第一级元素也不可改变

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

可以使用与列表相同的方式访问元组的元素

tuple1 = (1, 2, 4)
tuple1 = ('a', 1)

# tuple1[0] = 'a' # 报错

tuple1 = ([1, 2], 1, 2)

# 可以修改二级元素
tuple1[0][1] = 44

字典：dict

字典是可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,

其中键值(key)必须是唯一的不可变的因为它需要可以哈希，值(value)没有要求

如果有重复的key，value以最后的更新的那个为准

字典是无序存储，可以嵌套，在查询时使用十分查找的方式

字典定义

# 构建空字典
dict1 = {}
dict2 = dict()

# 传入可迭代对象，构建字典
dict1 = dict(zip(['china', 'jpan', 'india'], ['中国', '日本', '印度']))

# 如果有重复的key，value以最后的那个为准
dict2 = dict([('中国', 'china'), ('日本', 'jpan'), ('日本', 'riben')])

dict2 = dict({'cat':'猫', 'dog':'狗'})

字典操作

dict1['china'] # 中国

# 成员运算符
for key in dict1:
    print(dict1[key])
    
# 修改值
dict1['china'] = "the people's republic of china"

#删除字典元素
del dict1['jpan']  # {'china': "the people's republic of china", 'india': '印度'}

# 更新字典
dict1.update({'mouse':'鼠标'})

# 字典按key排序, x[0] 表示key
sorted(dict1.items(), key=lambda x:x[0])

dict1 = {"age1":25, "age2": 33, "age3":21, "age4":19}
# 字典按value排序, x[1] 表示value
dict2 = sorted(dict1.items(), key=lambda x:x[1])

dict1 = {"age1":25, "age2": 33, "age3":21, "age4":19}
dict2 = {"name":"peiqi", "age": 21, "sex":"male", "address":"china"}
dict3 = {"name":"mouse", "age": 19, "sex":"female", "address":"china"}

# 内置方法操作字典
len(dict1) # 计算字典kv的个数
str(dict1) # 将字典转换为字符串
type(dict1) # 测试变量的类型

# 字典自己的方法
dict1.clear() # 清空字典
dict4 = dict2.copy() # 复制一个字典，这是浅复制
dict5 = dict.fromkeys([1, 2, 3, 4]) # 按给定的Seq序列为键，键的默认值为value创建一个字典
dict4.get("name")  # 获取指定键的value, 如果没有该键不会报错
"name" in dict4    # 如果key在字典里有，返回Ture, 否则返回False
dict4.items()     #以列表形式返回kv元组
dict4.keys()      #以列表形式返回所有的key
dict4.values()    # 以列表形式返回所有value
dict4.update({1:2})  # 将键值对更新到字典里
dict4.popitem()   # 随机返回一个kv，并在字典中删除，一般是最后一个

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }

插入集合中的值，是不可变的

s1 = {"china", "china", "jpan", "america", "german"}  # 创建集合
s2 = set()  # 创建一个空集合
s3 = {"123", "china", "45", "america", "german"}

# 支持列表推导式
s4 = {x * 4 for x in 'abracadabra' if x not in 'abc'}

# 集合的运算
# 集合差， 包含在集合s1中，不包含在集合s3中
s4 = s1 - s3

# 集合的并, 包含集合s1,s3中的所有元素
s4 = s1 | s3  

# 集合的交， 包含集合s1, s3 中都有的元素
s4 = s1 & s3

# 集合的异或, 包含不同时在s1, s3中的元素
s4 = s1 ^ s3


# 集合内置方法，操作
s4.add("hello")  # 给集合添加元素
s4.update("abc")  # 给集合添加元素，传入的是Seq类型数据
s2.clear()  # 移除集合中所有元素
s4 = s1.copy() # 拷贝一个集合
s4 = s1.difference(s3)  # 同集合运算差集
s1.discard("chinaa")  # 删除集合中指定的元素，不存在该元素时，不会报错
#s4.remove("ccc")   #删除集合中指定的元素，不存在该元素时，报错
s4 = s1.intersection(s3) # 同集合运算交集
s4 = s1.union(s3)  # 同集合运算并集
s4.pop()  #随机移除元素
s4.issuperset(s2) # 判断集合是否为传入集合的父集
s2.issubset(s4)   # 判断集合是否为传入集合的子集