【python】 数据结构：元组 列表 字典 的区分和使用

元组 tuple

---

    def tuple_c(self):
        a = (1,)    # 元组与字符串类似但元组只包含一个元素时，需要在元素后面添加逗号
        b = (1, 2, 4, 3, 8)
        print(f"a的数据类型：{type(a)}")
        print(f"输出a = {a}")
        print(f"查找数值在元组中第一次出现的索引位置：{b.index(1)}")
        print(f"查找数值在元组中一共出现的次数：{b.count(1)}")
        print(f"根据索引获取元组值：{b[2]}")
        print(f"分段截取元组：{b[2:]}")
        print(f"删除前元组b = {b}")
        print(f"计算元组个数：{len(b)}")
        print(f"拼接元组：{a + b}")
        print(f"获取元组中元素最小值(仅针对int)：{min(b)}")
        print(f"获取元组中元素最大值(仅针对int)：{max(b)}")
        print(f"元素是否存在元组中：{5 in b}")
        for i in b:
            if i == 1:
                print(f"元组中单个元素：{i}")

        del b   # 元组中的元素值是不允许删除的，但del语句可以删除整个元组
        try:
            print(f"删除元组后b不存在，{b} 运行异常")
        except Exception as e:
            print(f"删除元组后b不存在，运行报错:{e}")

 

执行结果：

 

 

 

列表 list

---

 

    def list_b(self):
        a = [1] * 6 # 初始化数组
        print(f"初始化数组a:{a}")
        b = [i for i in range(10)]  # 初始化数组
        print(f"初始化数组b：{b}")
        a.append(5)
        print(f"在a尾部添加数据 = {a}")
        print(f"查找对象5在a中的索引位置，多个对象返回首位，没有则抛出异常：{a.index(5)}")
        a.insert(0, 3)  # 在a的0位插入3
        print(f"插入后的a = {a}")
        a.sort()    # 对原列表进行排序，仅支持int
        print(f"排序后的列表a = {a}")
        a.extend("123456")  # 迭代插入数据
        print(f"将字符串迭代(int不可迭代)插入数组a中，a ={a}")
        print(f"计算值出现在列表中的次数：{a.count(5)}")
        a.reverse() # 颠倒顺序
        print(f"列表顺序翻转：{a}")
        a.remove(1) # 按顺序移除1次value值
        print(f"删除1后a = {a}")
        d = a.copy()    # 浅复制a
        print(f"浅复制a, d = {d}")

 

执行结果：

 

    a = ["a", "b", "c", "b", "hello", "vi", "3", 5]
    print("hello 在列表a中的索引：", a.index("hello"))
    print("5 的索引值:", a.index(5))
    print("第一个b的索引值：", a.index("b"))
    print("第二个b的索引值：", a.index("b", a.index("b")+1))

 

执行结果

 

 

 

字典 dict

---

 

    def dict_a(self):
        a = {"name": "zhangsan", "phone": "13212345678"}
        b = {"name": "lisi", "phone": "13412345678", "backup": ""}
        print(f"a的数据类型：{type(a)}")
        print(f"字典a的长度：{len(a)}")
        print(f"将字典b转换为字符串：{str(b)}")
        c = a.copy()  # 浅复制字典
        print(f"复制a赋值给c = {c}")
        a.clear()   # 删除字典中全部元素
        c.update({"name": {"zhangsan": "28", "lisi": "18"}})    # 更新字典c
        print(f"删除全部元素后 a = {a}")
        print(f"元素更新后 c = {c}")
        print(f"获取指定元素name的值：{b.get('name')}")
        print(f"以列表返回可遍历的键值对(元组/数组)：{b.items()}")
        print(f"以列表返回字典全部的键：{c.keys()}")
        print(f"以列表返回字典全部的值：{c.values()}")
        print(f"删除字典给定key对应的值,并返回被删除的值：{b.pop('name')}")
        print(f"获取key的值，若key不在字典中，则添加key并将值设为default：{b.setdefault('phone')}")
        print(f"随机返回并删除字典中的一对值：{c.popitem()}")
        print(f"删除字典给定key对应的值,并返回被删除的值：{c}")

 

执行结果：

 

 

# 修改key名
d[new_key] = d.pop(key)

 

 

 

set 集合

---

 

 def jihe(self):
        se = {"apple", "banana", "cherry"}
        es = {"apple", "banana", "cherry", "add", "diff"}
        ses = {"app", "add", "diff"}
        # se.clear()
        # print("移除集合中的所有元素 :", se)
        # se.difference_update(es)
        # print("移除集合中的元素，该元素在指定的集合也存在。 :", se)
        sc = se.copy()
        print("拷贝一个集合 :", sc)
        se.add("orange")
        print("为集合添加元素 :", se)
        es.discard("add")
        print("删除集合中指定的元素 :", es)
        a = es.difference(se)
        print("返回多个集合的差集 :", a)
        se.intersection_update(es)
        print("返回集合的交集 :", se)
        b = se.isdisjoint(es)
        print("判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 :", b)
        c = se.issubset(es)
        print("判断指定集合是否为该方法参数集合的子集 :", c)
        d = se.issuperset(es)
        print("判断该方法的参数集合是否为指定集合的子集 :", d)
        sc.pop()
        print("随机移除元素 :", sc)
        # sc.remove("cherry")
        # print("移除指定元素 :", sc)
        e = sc.symmetric_difference(es)
        print("返回两个集合中不重复的元素集合 :", e)
        es.symmetric_difference_update(ses)
        print("移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中 :", es)
        f = es.union(se)
        print("返回两个集合的并集 :", f)
        se.update(ses)
        print("给集合添加元素 :", se)

拷贝一个集合 : {'banana', 'cherry', 'apple'}
为集合添加元素 : {'orange', 'banana', 'cherry', 'apple'}
删除集合中指定的元素 : {'apple', 'diff', 'banana', 'cherry'}
返回多个集合的差集 : {'diff'}
返回集合的交集 : {'banana', 'cherry', 'apple'}
判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 : False
判断指定集合是否为该方法参数集合的子集 : True
判断该方法的参数集合是否为指定集合的子集 : False
随机移除元素 : {'cherry', 'apple'}
返回两个集合中不重复的元素集合 : {'diff', 'banana'}
移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中 : {'apple', 'app', 'banana', 'add', 'cherry'}
返回两个集合的并集 : {'apple', 'banana', 'app', 'add', 'cherry'}
给集合添加元素 : {'add', 'banana', 'apple', 'diff', 'app', 'cherry'}

进程已结束，退出代码为 0

 

 删除列表中的重复元素

a = [1, 2, 6, 2, 6, 1, 6, 8, 9, 11, 1, 2, 108]
b = list(set(a))
print(b)

 

执行结果： 

 

 

 

 

 

了解

---

 

　　1、list列表只是单纯顺序存储数据的列表，而array（数组）是用于数学计算

　　2、元组：不可变序列类型（固定长度不可修改）；可嵌套

　　3、列表：可变序列类型（任意类型可修改）；支持索引，切片，合并、删除等操作 ；可嵌套

　　4、字典：可变映射类型 ；key不能为list且不可变，可嵌套

　　5、集合： 无序，无索引；元素不重复，元素可不同类型【空集合：a=set()】

 

#list 可变
list=[] #是一种有序的集合，可以随时添加和删除其中的元素
list.append("") #追加元素到列表末尾
list.extend(["1","2"])
list.insert(1, '') #将元素插入到指定的位置
list.pop() #删除list末尾的元素
list.pop(1) #删除指定位置的元素
list[1]='' #将元素替换成别的元素，可以直接赋值给对应的索引位置
#列表的元素数据类型可以不同，其中的元素也可以是另一个列表，称二维数组
list.sort() #整理，排序

#tuple 不可变
tuple=() #是有序列表叫元组和list非常类似，但是tuple一旦初始化就不能修改
tuple=(1,) #只有1个元素的tuple定义时必须加一个逗号

#dict 空间换取时间，可变
dict = {'': , ''} #全称dictionary是python中内置的字典，使用键-值（key-value）存储，在其他语言中也称为map
dict[''] = 
dict.get('',value) #不存在天剑
dict.pop('') #删除

#set 不可变 
set = ([,]) #重复元素在set中自动被过滤
add(key) #方法可以添加元素到set中，可以重复添加，但不会有效果remove(key)#方法可以删除元素 

 

区别

---

 

dict、tuple、list ：

　　相同点：　　对象引用的数组/表；当把一个对象赋值给一个变量名时，总会存储对象的引用而不是拷贝 [即 变量跟随对象的改变而改变]

 

tuple和list相比 

　　 相同点：

　　　　任意对象的有序集合 ，并且通过偏移读取 [即索引从0开始] 

　　不同点：

　　　　1.元组比列表操作速度快 

　　　　2.元组对数据“写保护“ 

　　　　3.元组可用于字符串格式化中 

 

　　　　4.元组可作为字典的key，列表不可以作为字典的key

 

dict和list相比　　【dict是用空间来换取时间】　　　

　　相同点：

　　　　列表属于普通的数组。字典属于关联数组　

　　不同点：

　　 　　1、字典 dict 属于任意对象的无序集合，通过键读取[关键字索引]

　　2、dict 查找和插入的速度极快，不会随着key的增加而增加 

　　3、dict 需要占用大量的内存，内存浪费多

　　　　 4、list 查找和插入的时间随着元素的增加而增加；

　　　　 5、list 占用空间小，浪费内存很少

 

set和dict类似

　　也是一组key的集合，但不存储value。

　　由于key不能重复，所以，在set中，没有重复的key

　　set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作

 

拓展

---

 

NumPy(Numerical Python)

　　是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库

decimal

　　十进制浮点运算　，科学计数

　　注意：

　　　　可以传递给Decimal整型或者字符串参数，但不能是浮点数据，因为浮点数据本身就不准确

　　　　要从浮点数据转换为Decimal类型

getcontext().prec  设定有效数字
quantize 设置小数位数