python学习（一) 列表，元组，字典，集合的区别

常用的数据结构类型

	列表	元组	字典	集合
符号	[]	（）	{}	{}
特点	可增删改查(可类比数组理解)	不可变，无增删改	key-value格式,key:必须是字符串、数值等。value：任意值	元素不重复且无序
推导式格式	[表达式 循环体 if 判断条件]	(表达式 循环体 if 判断条件)	{key-value表达式 循环体 if 判断表达式}	{表达式 循环体 if 判断条件}
互转	可与元组互转	可与列表互转

• 前言

1. python是一门动态语言，无需在新建变量时先声明类型
2. python的一切都是对象，变量是对象的引用

• 列表

1. 简述 

         类似数组,del方法和切片需注意，其他与数组使用方法大致相同

      2.创建

# 创建列表
# 方法一 创建一个list实例，继而用append将元素添加至尾部
phone = list()
phone.append("")
# 方法二 在创建时赋值
phone2 = ["", "", ""]

      3.查看元素

# 从列表下标从0开始计数
phone[index] #print(phone[0])

# 找某个值在数组哪里，index方法
phone.index("value")

# 查看列表有几个值为x,count方法
phone.count("x")

# 查看列表一共有几个值
len(list)

        4.增加元素

    # 将元素x加在最后一个位置,append
    list.append("x")

    # 将元素x插入在列表的指定位置,insert(index,str)
    list.insert(1, "x")

    # 将一个新的列表直接连接在旧的列表后面,extend()
    list1.extend(list2)

        5.修改元素

  # 修改元素，直接赋值修改，
    list[index] = "x"

        6.删除元素

    # 删除指定位置的元素，默认删除最后一个元素，并返回，pop方法
    list.pop() #删除最后一个
    list.pop(5) #删除第5个

    # 删除第一个值为x的元素,remove()
    list.remove("x")

    # 把所有元素清空clear()
    list.clear()

    # 把所有元素清空del
    del list[:]  # 清所有

    phone = ['Huawei', 'OPPO', 'Apple', 'Xiaomi', 'LG', 'Huawei', 'VIVO', 'Xiaomi']
    del phone[1:3] # 删除索引在[1：3）区间内元素，注意是左闭右开区间

        7.列表反转

    # 方法一和方法二的区别：reverse方法是原地反转，作用在原对象上
    #                  切片反转是返回一个新对象，原对象不变
    # 方法一：reverse()
    list.reverse()

    # 方法二：切片方法
    list[::-1]

        8.列表排序

    # 列表排序（数值和数值可比较，字符串和字符串可比较，数值和字符串不可比较)
    # 第一种方法：列表内置了sort方法(改变自生)
    list.sort()

    # 第二种方法：sorted函数，不仅可作用于列表的排序，字典等数据结构也能用上（不改变自身，新建立了对象)
    phone2 = ['Xiaomi', 'VIVO', 'Huawei', 'LG', 'Xiaomi', 'Huawei']
    print(sorted(phone2))

• 元组

1. 简述

        类似于上述列表，但不可变，因此只有查看无增删改功能，可以与列表互转

      2.创建

# 第一种方法，直接用圆括号将所有元素进行包围（列表是中括号）
atuple = (1, 2, 3, 4)
print(atuple)
# 第二种方法，圆括号不要也行
btuple = 1, 2, 3, 4
print(btuple)

# 只包含一个元素的元组后面要加逗号
ctuple = (1,)
print(type(ctuple))

# 创建空元组
a = tuple()  # 法一
print(type(a))
b = ()  # 法二
print(type(b))

     3.查看

 # 查看元素，直接查看某个下标，下标从0开始
    print(tuple[index])

      4.与列表互转

 # 元组转为列表
 list(tuple)
 #列表转为元组
 tuple(list)

• 字典

1. 简述

（类似于hashmap）key-value格式,key:必须是字符串、数值等。value：任意值

      2.创建

# 方法一：先用dict()创建空字典实例，再往实例中添加元素
profile = dict()
profile["key"] = "val"
profile["key2"] = "val2"

# 第二种方法：直接使用{}定义字典，并填充元素
profile2 = {"name": "liu", "b": 1, "c": "3"}

# 第三种方法:使用dict()构造函数可以直接从键值对序列里创建字典
info = [('name', 'liuliuliu'), ('b', 1), ('c', 'lll')]
dict(info)

      3.查看元素

# 查看元素
# 方法一：直接使用dict[key]这个方式就可以,key无会报错
print(profile["name"])
# 方法二：get(),key不存在时返回默认值(推荐使用)
print(profile.get("age", 20))

      4.新增元素

# 直接使用dict[key]=value
profile3 = dict()
print(profile3)
profile3["aaa"] = "aaa"
profile3["bbb"] = "bbb"
profile3["ccc"] = "ccc"
print(profile3)

# 给key设默认值
profile.setdefault("gender", "male")

      5.修改元素

#ditc[key]="修改的值"
profile3["aaa"] = "ddd"

      6.删除元素

 # 删除元素
 # 第一种：pop函数
 profile3.pop("key")
 # 第二种：使用del函数
 del profile3["key"]

      7.判断字典里有没有某个key

# 判断key是不是存在in和not in
print("key" in dict)

•    集合

1. 简述

元素不重复且无序，因此无查看修改功能

      2.创建

# 创建集合
# 第一种：使用花括号{}直接创建，创建的时候，{}可以包含有重要的元素，但是创建完后，集合会去重，只留第一个
aset = {"apple", "xiaomi", "huawei", "vivo", "huawei"}
print(aset)

# 第二种：使用set()方法进行创建，当set()函数不接任何参数时，创建的是空集合，如果不创建空集合，可以传入一个列表
bset = set()  # 空集合
cset = set(["apple", "xiaomi", "huawei", "vivo", "huawei"])
print(cset)

      3.增加元素

# 增加元素
# 第一种方法：add()
aset.add("LG")
print(aset)

# 第二种方法：update（）后可接集合，列表，元组，字典等
aset.update({"oppo"})  # 集合
print(aset)
aset.update(["tcl"])  # 列表
print(aset)
aset.update(("t+",))  # 元组
print(aset)
aset.update({"sam": "xxx"})  # 字典
print(aset)

      4.删除元素

# 删除元素
# 第一种：remove(),指定删除，不存在时会报错
aset.remove("val")

# 第二种:discard(),指定删除("推荐")
aset.discard("val")

# 第三种：pop，不允许带参，随机删除元素
aset.pop()

# 第四种：clear(),清除所有
cset.clear()

      5.查看集合长度

 # 查看集合长度len()函数
  print(len(aset))

      6.集合运算

# 求合集
# 第一种：用union
aset = {"apple", "xiaomi", "huawei", "vivo", "huawei"}
bset = {"xiaomi", "redmi"}
print(aset.union(bset))
# 第二种：用|
print(aset | bset)

# 求差集（在a中存在，b中不存在的)
# 第一种：用difference
print(aset.difference(bset))
#第二种：用 - （类似a-b）
print(aset - bset)

# 求交集
# 第一种：用intersection
print(aset.intersection(bset))
# intersection_update,会原地更新在x.的x上，而不是返回新对象
bset.intersection_update(aset)
print(bset)
bset.add("remi")
print(bset)
# 第二种：用&
print(aset & bset)

# 求不重合集
# symmetric_difference
print(aset.symmetric_difference(bset))
# symmetric_difference_update原地更新在bset
bset.symmetric_difference_update(aset)
print(bset)

# 集合判断
# 判断是否有某元素
print("apple" in aset)
# 判断两集合是否有相同元素isdisjoint()
print(aset.isdisjoint(bset))
# 判断是否是子集issubset
print(bset.issubset(aset))