Python基础之基本数据类型二《列表，元祖，字典及集合》

一. 列表

　　list  类，列表

　　li = [1,2,"age",["sb",{"name":1}],True]

　　1. 列表：用中括号括起来的内容称之为列表，用逗号分割每个元素，列表中的元素可以是 数字，字符串列表，布尔值。。所有都能放进去。

　　2. 列表中可以嵌套任何类型

　　3. 可以通过索引取值

　　　　pring(li[1])

　　4. 切片，切片的结果也是列表

　　　　print(li[1:3])

　　5. 可以通过for 和 while循环

　　　　for i in li:

　　　　　　print(i)

　　6. 通过索引方式修改列表中的元素

　　　　li[1] = 120    

　　　　print(i)

　　　　li[2] = [11,22,33,44]    #可以将元素修改为任意数据类型

　　　　print(i)

　　    通过索引删除列表中的元素

　　　　del li[1]

　　　　print(li)

　　7. 通过切片方式修改列表元素

　　　　li[1:3] = [120,90]

　　　　print(li)

　　　 通过切片删除列表中的元素

　　　　del li [2:4]

　　　　print(li)

　　8. in操作，判断元素是否再列表中

　　　　v = "age" in li

　　　　print(v)

                                    *** list中的操作***

　　li = [11,22,33,22,44]

　　1. 追加到列表最后

　　　　li.append(5)   #可以添加任何数据类型

　　　　print

　　2. 清空列表

　　　　li.clear()

　　　　print(li)

　　3. 拷贝，浅拷贝

　　　　v = li.copy()

　　　　print(v)

　　4. 计算元素出现的次数

　　　　v = li.count(22)

　　　　print(li)

　　5. 扩展原列表，参数：可迭代对象

　　　　li.extend("厉害呀")

　　　　print(li)

　　　　[11, 22, 33, 44, '厉', '害', '呀']

　　6. 根据值获取当前值索引位置（左边优先）

　　　　v = li.index(22)

　　　　print(v)

　　7. 在指定索引位置插入元素

　　　　li.insert(0,99)

　　　　print(li)

　　8. 删除某个值（可指定索引，如不指定默认删除最后一个）

　　　　v = li.pop()

　　　　print(li)    #删除后的列表

　　　　print(v)   # 获取删除的值

　　9. 删除列表中的指定值（左边优先）

　　　　li.remove(22)

　　　　print(li)

　　10. 将当前列表进行翻转

　　　　li.reverse()

　　　　print(li)

　　11. 将列表排序

　　　　li.sort()

　　　　print(li)

二. 元祖

　　tu = (111,"alex",(11,22),[(33,44)].true,33,44)

　　1. 元祖的一级元素不可被修改/删除/增加。元祖是有序的

　　2. 可以通过索引修改，删除，增加非一级元祖元素中其他数据类型。

　　　 tu = [3][0] = 567

　　    print（tu）

三. 字典

　　1. 基本结构

　　　　dic = {“name”:"xue","age":18}

　　　　通过一个个键值对组成，前面的是key，后面的是value

　　2. 字典中的value可以是任意数据类型

　　　　

info = {
    "k1": 19,
    "k2": True,
    3: [
        11,
        [0],
        (9),
        22,
        33,
        {
            "kk1": 87,
            "kk2": 44,
            "kk3": (11, 22)
        }
    ],
    True: "DASDA",
    "k4": (11, 22, 33)
}

　　3. 布尔值，列表，字典不能作为字典的key

info = {
    1:"asdf",
    "k1":"sdaa",
    (11,22):123,
    # True:"3331"
    # {"k1":"v1"
    # [11,22]:123
}
print(info)

　　4. 字典是无序的

　　5. 可以通过索引的方式找到指定元素

info = {
    "k1": 19,
    "k2": True,
    3: [
        11,
        [0],
        (9),
        22,
        33,
        {
            "kk1": 87,
            "kk2": 44,
            "kk3": (11, 22)
        }
    ],
    True: "DASDA",
    "k4": (11, 22, 33)
}
v = info[3][5]["kk3"][0]  #索引
print(v)

　　6. 字典支持 del 删除

info = {
    "k1": 19,
    "k2": True,
    3: [
        11,
        [0],
        (9),
        22,
        33,
        {
            "kk1": 87,
            "kk2": 44,
            "kk3": (11, 22)
        }
    ],
    True: "DASDA",
    "k4": (11, 22, 33)
}
del info[3][5]["kk1"]  # 删除
print(info)

　　7. for 循环

for k,v in info.items(): # 循环key,value值
    print(k,v)

for i in info.keys():   #循环key,value值
    print(i,info[i])

for i in info.values() : #只循环value值
    print(i)

for i in info.keys():    #只循环key值
    print(i,info[i])

for item in info:   # 不指定默认循环key值
    print(item)

四. 集合

　　集合的元素是不允许重复且无序的集合，集合就像是字典舍弃了值一样。

　　主要作用：

　　　　去重，把一个列表变成集合就自动去重了

　　常用操作：

　　　　s = {1,2,3,4,5,"123"}

　　　　1. s.add((1,2))   添加

　　　　2. s.clear()    清空集合

　　　　3. v = s.copy()  复制集合

　　　　4. s.discard()  指定删除，若元素没有不报错

　　　　    s.remove(111)  指定删除，若元素没有报错

　　　　5. s.pop()  随机删除

　　　　

　　　　p_s = {"liu","xue","li"}

　　　　l_s = {"liu","xue","666"}

　　　　6. 交集（取两个集合中都有的元素）

print(p_s.intersection(l_s))
print(p_s&l_s)

　　　　7. 并集（将两个集合中的所有元素集合到一起，并去重）

print(p_s.union(l_s))
print(p_s|l_s)

　　　　8. 差集（只保留p_s中有l_s中没有的元素）

print(p_s.difference(l_s))
print(p_s-l_s)

　　　　9. 交叉补集（两个集合中去掉都有的，只留下互相都没有的元素）

print(p_s.symmetric_difference(l_s))
print(p_s^l_s)