python组合数据数据类型(列表,元组,集合,字典)_python中的（）数据类型有字典和列表

python中的数据类型

目录

python中的数据类型

列表

元组

集合

字典

Python的组合数据类型有四种，分别是：列表(list)、元组(tuple)、集合(set)、字典(dict)
这里就简单介绍一下

列表

什么是列表
     列表是python中可以存储多个数据的数据类型。
1.列表的声明
    变量=list（)
    变量=[ ]      
这两种都可以声明一个空的列表

>>> s=list()
>>> type(s)
<class 'list'>
>>>jobs=[]
>>> type(jobs)
<class 'list'>

2.list的操作：
(1). 增加数据
            list.append()   默认在list末尾添加一个数据
            list.insert() 插入，可指定位置
            list.extend() 在末尾添加，可追加多个数据，也可以实现两个列表的组合
(2). 删除数据
            del list[index] 直接删除
            list.clear() 清空所有数据
(3). 修改数据
            list[index]=数据
(4). 查询
           通过index（下标）查询
(5). 其它操作
           list.copy()  列表的拷贝，结果是一个列表
           list.count()  统计元素出现的次数
           list.index()  查看元素的下标/索引
           list.reverse  反转 
           list.sort   按自然数排列，只能排列纯数字或者纯字符的列表，不能排列各种数据类型混合的列表

g1=[1000,'可口可乐（罐装）',2.5,100]
>>> print(g1)
[1000, '可口可乐（罐装）', 2.5, 100]
>>> g1.append("密封")    #添加一个数据，在最后添加
>>> print(g1)
[1000, '可口可乐（罐装）', 2.5, 100, '密封']
>>> g1.insert(1,'美国')    #指定位置的添加
>>> print(g1)
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封']
>>> g2=[1001,'可口可乐（瓶装）',3.0,100]
>>> g1.append(g2)     #把g2当做有个数据添加到最后
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', [1001, '可口可乐（瓶装）', 3.0, 100]]
>>> g1.extend(g2)    #添加多个数据
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', [1001, '可口可乐（瓶装）', 3.0, 100], 1001, '可口可乐（瓶装）', 3.0, 100]
>>> del g1[6]      #删除指定的数据
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]
g1[0]=1
>>> g1
[g1[2]
'可口可乐（罐装）'
>>> g3=g1.copy()      #拷贝
>>> g3
[1, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]1, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]
g1.count(2.5)      #统计一个元素出现的次数
1
>>> g1.reverse()    #翻转列表
>>> g1
[100, 3.0, '可口可乐（瓶装）', 1001, '密封', 100, 2.5, '可口可乐（罐装）', '美国', 1]

元组

1.什么是元组
        Python的元组与列表类似，不同之处在于元组的元素不能修改。
2.元组的声明
        元组使用小括号，元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
        t=tuple()
        t1=()
        t2=(1,2,3,4,)
        但是t3=('hello')  ->type(t3)->str
        可以t4=('hello',) 在后面加一个逗号
元组的方法：count，index
    元组中的操作类型只有这两个方法 
 

>>> t=tuple()
>>> type(t)
<class 'tuple'>
>>> t1=()
>>> type(t1)
<class 'tuple'>
>>> t3=('hello')
>>> type(t3)
<class 'str'>
>>> t4=("hello",)
>>> type(t4)
<class 'tuple'>

其中tuple.count() 是统计一个元素出现的次数
tuple.index() 是查看一个元素在元组中的下标

集合

1.什么是集合
       需求场景：我们需要存放一组数据，但是不希望存放重复的数据！用户的账号！
       集合：通过哈希(hash)算法在一个容器中存放多个没有顺序的不可以重复的数据
2.声明集合：
      s1 = set()        <class ‘set’>
      s2 = {“a”}         <class ‘set’>
      s3 = {}             <class ‘dict’>
应为集合和字典都是使用{}表示，但是s3={}声明的是一个字典
3.集合的操作
          set.add   增加
          set.clear   清空
          set.copy   复制
          set.difference   两个集合之间求差集
          set.difference_update   求差集并且用不一样的数据重新给自己赋值
          set.discard    移除元素
          set.intersection     求交集
          set.intersection_updat      求交集并给自己赋值
          set.pop     随机删除一个
          set.remove     指定删除某个数据
          set.union     求并集
          set.update     求并集并给自己赋值

>>> s1={1,2,3,4,5,6}
>>> s2={4,5,6,7,8,9}
>>> s1
{1, 2, 3, 4, 5, 6}
>>> s2
{4, 5, 6, 7, 8, 9}
>>> s1.add(0)   #添加一个元素
>>> s1
{0, 1, 2, 3, 4, 5, 6}
>>> s1.difference(s2)   #s1与s2求差集
{0, 1, 2, 3}
>>> s1.difference_update(s2)   #s1与s2求差集，并把自己等于所得差集
>>> s1
{0, 1, 2, 3}
s1.discard(0)      #删除一个指定元素，若元素不存在，则不报错
>>> s1
{1, 2, 3}
>>>s1
{1, 2, 3, 4, 5, 6}
>>> s1.intersection(s2)  #s1与s2取交集
{4, 5, 6}
>>> s1.intersection_update(s2)    #s1与s2取交集，并把自己等于交集
>>> s1
{4, 5, 6}
>>> s1.pop()    #随机删除一个元素
4
>>> s1
{5, 6}
>>> s1.remove(5)    #删除一个指定元素，若元素不存在，则报错
>>> s1
{6}
>>> s1={2,3,4,5,6}
>>> s1
{2, 3, 4, 5, 6}
>>> s1.union(s2)      #s1与s2取并集
{2, 3, 4, 5, 6, 7, 8, 9}
>>> s1
{2, 3, 4, 5, 6}
>>> s2
{4, 5, 6, 7, 8, 9}
>>> s1.update(s2)    #s1与s2取并集，并把自己等于并集
>>> s1
{2, 3, 4, 5, 6, 7, 8, 9}

 

字典

1.什么是字典
      可以存储多个key:value 键值对数据的组合数据类型
2.字典的声明
      d1  = dict()    # 空字典
      d2 = {}         # 空字典
 

>>> d1  = dict()    # 空字典
>>> d2 = {}
>>> type(d1)    # 空字典
<class 'dict'>
>>> type(d2)
<class 'dict'>
>>> d1
{}
>>> d2
{}

3.字典的操作
      doct.clear    清空
      doct.copy    复制
      doct.fromkeys    通过制定的key生成一个值为None的字典
      doct.get     根据key获取对应的值
      doct.items   获取所有的k:v键值对
      doct.keys     获取所有的键
      doct.pop    根据key值删除一个键值对
      doct.popitem    随机删除一个键值对
      doct.setdefault      增加一个数据，如果数据存在~修改
      doct.update     把字典dict2的键/值对更新到dict里
      doct.values     获取所有的值
字典中，增加数据
     f[key] = value
     f.setdefault(key, value)
     f.update(key, value)
删除数据:删除一个键值对
       f.pop(key)      删除制定的key:value键值对
       f.popitem()      随机删除一个键值对
       def f[key]      删除制定的key:value键值对
 修改数据
f[key] = value
f.update({key, value})
查询数据
v = f[key]
v = f.get(key)
 

>>> d1={1:'a',2:'b',3:'c','dict':'字典','list':'列表','tuple':'元组',}
>>> d1
{1: 'a', 2: 'b', 3: 'c', 'dict': '字典', 'list': '列表', 'tuple': '元组'}
>>> d2={1:100,2:200,3:300,4:400,5:500,6:600}
>>> d2
{1: 100, 2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
>>> d3=dict.fromkeys('1,2,3,4,5,6')    #通过制定的key生成一个值为None的字典
>>> d3
{'1': None, ',': None, '2': None, '3': None, '4': None, '5': None, '6': None}
>>> d1.get('dict')    #t通过键查找值
'字典'
>>> d1.items()      #返回所有键值对
dict_items([(1, 'a'), (2, 'b'), (3, 'c'), ('dict', '字典'), ('list', '列表'), ('tuple', '元组')])
>>> d1.keys()    #返回所有键
dict_keys([1, 2, 3, 'dict', 'list', 'tuple'])
>>> d1.values()    返回所有值
dict_values(['a', 'b', 'c', '字典', '列表', '元组'])
>>> d2
{1: 100, 2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
 d2.pop(1)      #删除指定键的键值对
100
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
 d2.popitem()    #随机删除键值对
(6, 600)
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500}
>>>d2.setdefault(7)    #增加一个数据，如果数据存在~修改
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 7: None}
d1
{1: 'a', 2: 'b', 3: 'c', 'dict': '字典', 'list': '列表', 'tuple': '元组'}
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 7: None}
>>> d1.update(d2)     #把字典2整合到字典1中
>>> d1
{1: 'a', 2: 200, 3: 300, 'dict': '字典', 'list': '列表', 'tuple': '元组', 4: 400, 5: 500, 7: None}

 

遍历字典

for k in f.keys():    # 直接循环字典中的key数据
    print(k, f.get(k))     # value数据通过key数据获取

for k, v in f.items():   # 直接循环字典中的key和value数据
    print(k, v)

---