Python元组、列表、字典、集合

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 3.1k 阅读时长 ≈ 3 分钟

  1. 元组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # 元组和列表很像，用来保存多个数据
    # 使用一对小括号(),来表示一个元组
    # 元组是不可变数据类型,因此只能进行查，不能进行增删改
    # 元组是一个有序的存储数据的容器，可以通过下标来获取元素
    # 元组也可以遍历

    index # 通过下标获取元素
    count # 用来统计指定元素的个数
    x=(1,)  #表示只有一个元素的元组
    tuple   # 实现可迭代对象转化为元组(列表list也可以这样用)

  2. 列表

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    1. 当我们保存多个数据时可以使用列表(列表近似于C语言的数组)

    2. 使用[]表示一个列表，列表里的每一个数据表示元素，中间用逗号隔开
    ['xiaoming',18,'河南'] # 即表示一个列表，数据类型可以不同

    3. 可以使用list(可迭代对象),将可迭代对象转换成一个列表
    eg：
    x=list(('张三','李四','王五'))
    print(x) # 打印结果：['张三', '李四', '王五']

    4. 可以通过下标获取修改列表即对列表进行切片
    注：A[m:n] # 例如在对a进行切片时,从下标m开始,不包含下标为n的

    5. 增加列表元素
    append # 在列表末尾加一个元素
    insert # 在指定位置插入元素
    extend # 将可迭代对象添加到末尾

    6. 删除列表元素
    remove # 删除列表指定元素
    clear # 清空列表
    del #删除一个列表元素
    pop #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

    7. 查询列表元素
    index # 返回指定元素下标,不存在会报错
    count # 返回指定元素的个数

    8. 修改元素
    用下标定位到元素,直接赋值

    9. 调用列表的sort方法进行排序
    顺序排序:默认循序排序
    逆序排序:x.sort(reverse=True)

    10. 内置函数sorted排序
    新生成一个列表
    # 注：sort排序是改变原列表的序列,sorted新生成一个列表

    11. 列表逆序
    reverse:用函数
    x.[::-1]:用切片法

    12. 复制列表
    y=x # x,y指向了同一个内存地址,会相互影响
    copy # 新列表和原列表数据相同,内存地址不同,不会相互影响

    13. 使用for...in对列表进行循环遍历时,尽量不要对列表进行删除操作

    14. 列表的嵌套
    [1,2,[3,4],[4,5,6]] # 列表可以嵌套使用

    15. 带下标进行for...in循环(一般用while)
    for i,room in enumerate(rooms) # enumerate是关键字

    16. 列表推导式
    # 用列表推导式创建一个列表,产生列表条件简单的时候使用
    nums=[i for i in range(10)] # 产生0-9,这10个数据的列表

    17. 列表合并
    extend # 将两个列表合并成一个列表

  3. 字典

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    # 字典里的数据都是以键值对的形式保存的
    # key,value之间使用冒号连接，多个键值对之间使用逗号连接
    # key是不允许重复的,重复了后一个会覆盖前一个
    # key只能是不可变数据类型，而value可以是任意数据类型

    # 1.查找数据(因为字典是无序的数据类型,所以只能用key来查找值)
    x['key'] # 查找不到会报错
    x.get['key'] # 查找不到会默认返回None
    x.get['key',default] # 查找不到返回default

    # 2.修改和删除(若存在key则修改,不存在则删除)
    x['key']=value

    # 3.删除
    pop('key') # 删除并返回,否则返回默认值
    pop('key',default) # 删除并返回,否则返回default
    popitem() # 返回并删除字典中的最后一对键和值
    clear() # 清空字典
    del x['key'] # 直接删除,无返回值

    4.合并
    A.update(B) # A,B合并成一个字典,并赋值给A

    5.循环
    方法一:直接for...in循环遍历字典
    for k in x: # for...in循环遍历获取的是key
        print(x,'=',x[k])

    方法二:获取所有的key,再由key获取value
    for k in x.keys(): 
        print(x,'=',x[k])
    # 一般不用这种方法,和方法一几乎相同,多此一举

    方法三:获取所有的value
    for v in x.values():
        print(v)

    方法四:拆包获取key,value
    for k,v in x.items():
        print(k,'=',v)
    # 常用方法一和四

    6. 交换key和value的位置
    方法一:
    x1={'name':'xiaoming'}
    x2={}
    for k,v in x1.items():
        x2[v]=k
    方法二:字典推导式
    x={'name':'xiaoming'}
    x1={v:k for k,v in x.items() }
    print(x1)

    7.字典推导式
    x1={v:k for k,v in x.items() }

  4. 集合

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    # 集合是一个不重复的无序的数据类型
    # 集合可以用{}或set表示
    # {}有两种意思:字典、集合;当里面的数据不是键值对时表示字典
    # 字典中不允许有重复元素,当有重复元素时会自动去重

    1.增加元素
    add() # 增加一个元素

    2.清空集合
    clear() # 清空集合
    set() #表示空集合
    {} # 表示空列表

    3. 删除元素
    pop # 随机删除一个
    remove # 指定删除一个,若删除的元素不存在则会报错

    4. 合并
    union # 两个集合合并在一起,生成一个新的集合
    A.update(B) # 将B拼接在A里
    # 被合并的那个是可迭代对象即可

    5. 集合支持很多运算符(但不支持加法)
    A-B # A与B的差集,就是去掉A中,B中有的元素
    A&b # A与B的交集
    A|B #A与B的并集
    A^B #A和B差集的并集(即去掉AB中共有的元素,把其余的合并在一起)

    6. 特殊情况
    # 当列表转化为集合,如果是数字会去重且自动按升序排序

  5. 元组、列表、字典的区别

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    1.元组(Tuple)
    # (),有序，元素任意，元素不可变

    2.列表(List)
    # [],有序，元素任意，元素可变
    # 与C语言的数组相似，不同的是C语言的数据类型要相同，list可以不同

    3.字典(Dictionary)
    # {}，无序，元素任意，元素可变
    # 元素键值对存在

    # 列表用extend合并,字典用update合并
    # 元组和列表可以用加号使两个元组和列表合并成一个，字典不可以