精华内容
下载资源
问答
  • 列表集合元组字典符号
    千次阅读
    2019-07-24 18:29:36

    1、列表(list)
    列表中的数据类型可以包含多种,包含数字、字符串、字典、布尔型等,并且列表中还可以嵌套列表

    print(type([1, 2, 3, 4, 5, 6]))
    print(type(['Hello', 'World', 1, 6]))
    print(type(['Hello', 1, 2, True, 'a']))
    print(type([['Hello', 1, 2, 3], [True, 1]]))
    # 列表中嵌套列表
    print(type([['Hello', 'World'], [1, 2, 3], [True, False]]))
    print(type([['Hello', 'World'], [1, 2, 3], [True, False], {'name': 'alex', 'age': 18}]))
    

    结果为:
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>

    • 列表的访问
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][3])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0:2])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1:])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1])
    

    结果为:

    新月打击
    月神冲刺
    [‘新月打击’, ‘苍白之瀑’]
    [‘月神冲刺’]
    月神冲刺

    可以发现,单一数字的索引来访问的时候,得到的是一个元素;用冒号的方式来访问,得到的是一个列表,哪怕这个列表只有一个元素

    • 列表的操作
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"] + ["点燃", "打击"])
    print(["点燃", "打击"]*3)
    

    结果为:

    [‘新月打击’, ‘苍白之瀑’, ‘月之降临’, ‘月神冲刺’, ‘点燃’, ‘打击’]
    [‘点燃’, ‘打击’, ‘点燃’, ‘打击’, ‘点燃’, ‘打击’]

    注意: print([“点燃”, “打击”]-[“点燃”]) # 输出错误


    2、元组(tuple)

    元组中的数据类型也可以包含多种

    print((1, 2, 3, 4, 5))
    print((1, '-1', True, 'morning', {'name': 'alex', 'age': 18}, [1, 'Hello', '1']))
    

    结果为:

    (1, 2, 3, 4, 5)
    (1, ‘-1’, True, ‘morning’, {‘name’: ‘alex’, ‘age’: 18}, [1, ‘Hello’, ‘1’])

    • 元组的访问
    print((1, 2, 3, 4, 5)[0])
    print((1, 2, 'morning', 4, True)[0:3])
    print((1, 2, 'morning', 4, True)[-1:])
    print((1, 2, 'morning', 4, True)[-1])
    print((1, 2, 3) + (4, 5, 6))
    print((1, 2, 3) * 3)
    print((1, 2)[-1:])
    

    结果为:

    1
    (1, 2, 'morning')
    (True,)
    True
    (1, 2, 3, 4, 5, 6)
    (1, 2, 3, 1, 2, 3, 1, 2, 3)
    (2,)
    

    注意:单一数字的索引来访问的时候,得到的是一个元素;用冒号的方式来访问,得到的是一个元组,哪怕这个元组只有一个元素

    • 类型的判断1
    print(type((1, 2, 3)))
    print(type(1))
    print(type((1)))  # 小括号代表运算符号时,比如(1+1)*2,和元组的括号有冲突,Python当括号里面只有一个元素时,规定为运算符号
    # 定义只有一个元素的元组
    print(type((1,)))
    # 表示一个空的元组
    print(type(()))
    

    结果为:

    <class 'tuple'>
    <class 'int'>
    <class 'int'>
    <class 'tuple'>
    <class 'tuple'>
    
    • 类型的判断2
    print(type("Hello"))
    print(type(("Hello")))
    print(type([1, 2, 3]))
    print(type([1]))
    

    结果为:

    <class 'str'>
    <class 'str'>
    <class 'list'>
    <class 'list'>
    

    3、str list tuple ---->序列

    • 每个元素都被分配一个序号
    print((1, 2, 3)[2])
    print('hello world'[2])
    

    结果为:

    3
    l
    
    • 都可以进行切片操作
    print([1, 2, 3, 4, 5][0:3])
    print([1, 2, 3, 4, 5][-1:])
    print("Hello world"[0:8:2])
    

    结果为:

    [1, 2, 3]
    [5]
    Hlow
    
    • 都可进行 + 和 *
    • 判断元素是否在序列中
    print(3 in [1, 2, 3, 4, 5])
    print(3 not in [1, 2, 3, 4, 5])
    

    结果为:

    True
    False

    • 都可以求取序列的长度、元素的最大最小值
    print(len([1, 2, 3, 4, 5, 6]))
    print(len("Hello world"))
    
    print(max([1, 2, 3, 4, 5, 6]))
    print(min([1, 2, 3, 4, 5, 6]))
    
    print(max("Hello world"))
    print(min("Helloworld"))
    

    结果为:

    6
    11
    6
    1
    w
    H
    

    求取ASCII 的求取

    print(ord('H'))
    print(ord('w'))
    print(ord(' '))
    

    结果为:

    72
    119
    32


    4、 集合

    • 无序
    print(type({1, 2, 3, 4, 5, 6}))
    # print({1, 2, 3, 4, 5, 6}[0])  # 错误
    

    结果为:

    <class 'set'>
    
    • 不重复
    print({1, 1, 2, 3, 6, 6})
    

    结果为:

    {1, 2, 3, 6}
    
    • 长度
    print(len({1, 2, 3}))
    

    结果为:

    3
    
    • 剔除3,4,求集合的差集
    print({1, 2, 3, 4, 5, 6}-{3, 4})
    

    {1, 2, 5, 6}

    • 求集合的交集
    print({1, 2, 3, 4, 5, 6} & {3, 4})
    

    结果为:

    {3, 4}
    
    • 两个合并成一个,不出现相同的元素,合集或并集
    print({1, 2, 3, 4, 5, 6} | {3, 4, 7})
    

    结果为:

    {1, 2, 3, 4, 5, 6, 7}
    
    • 定义一个空的集合
    print(type({}))
    print(type(set()))
    

    结果为:

    <class 'dict'>
    <class 'set'>}
    

    约个拓展练习可好:

    快乐的LeetCode — 14. 最长公共前缀 方法2中包含了集合的巧妙使用


    5、字典(dict)
    形式:{key1:value1,key2:value2,key3:value3,} 。 可以有很多个key和value,属于集合类型(set),不是序列类型

    • 访问
    print({'Q': "新月打击", 'W': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q'])
    
    # 相同的key情况,尽管有结果输出
    print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q'])
    
    # 验证发现,已经存在丢失
    print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
    
    

    结果为:

    新月打击
    苍白之瀑
    {'Q': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}
    
    • 可以有数字类型的key
    print({1: "新月打击", '1': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
    
    # key必须是不可变的类型, 数字1,字符串"1"
    # 反例 print({[1, 2]: "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
    

    结果为:

    {1: '新月打击', '1': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}
    
    • value 本身可以是 int float str set dict list…
    print({1: "新月打击", '1': "苍白之瀑", 'R': {1, 2, 3}, 'E': "月神冲刺"})
    

    结果为:

    {1: '新月打击', '1': '苍白之瀑', 'R': {1, 2, 3}, 'E': '月神冲刺'}
    
    • 定义空的字典
    print(type({}))
    

    结果为:

    <class 'dict'>
    

    大家加油!
    第4章 Python中表示“组”的概念与定义.mp4

    更多相关内容
  • python系列之:列表元组集合字典的区别一、列表元组集合字典的区别二、for循环遍历列表元组字典集合1.遍历列表2.遍历元组3.遍历字典4.遍历集合三、列表元组集合字典相互转换1.列表元组转化...

    一、列表、元组、集合、字典的区别

    • 列表:长度可变有序的数据存储容器,可以通过下标索引取到相应的数据。
    • 元组:固定长度不可变的顺序容器,访问效率高,适合存储一些常量数据,可以作为字典的键使用。
    • 集合:无序,元素只出现一次,可以自动去重。
    • 字典:长度可变的hash字典容器。存储的方式为键值对,可以通过相应的键获取相应的值。key支持多种类型,key必须是不可变类型且唯一。

    列表和元组的主要区别如下:

    • 列表上可以修改的,而元组不能修改。如果要增添和删除元素,只能用列表。元组被称为只读列表,即数据可以被查询,但不能被修改。若元组一旦被定义,长度和内容都是固定的,不能被修改,即不能对元组进行更新、增加和删除的操作。
    • 列表用’[]'表示,元组用()表示
    • 列表不能作为字典的可以,元组可以
    • 如果元组中仅有一个元素,需要在元素后加上逗号。

    二、for循环遍历列表、元组、字典和集合

    1.遍历列表

    testList = [4,2,3,1,4]
    
    print("遍历list:",end='')
    for items in testList:
        print(items,end=' ')
    

    2.遍历元组

    print()
    print("遍历tuple:",end='')
    testTuple = (5,2,1,3,4)
    for items in testTuple:
        print(items,end=' ')
    

    3.遍历字典

    print()
    print("遍历dict:",end='')
    testDict = {'a':1,'b':2}
    for key,value in testDict.items():
        print(key,value,end=' ')
    

    4.遍历集合

    print()
    print('遍历set:',end='')
    testSet = {12,4,6,5}
    for items in testSet:
        print(items,end=' ')
    

    输出如下所示:

    遍历list:4 2 3 1 4 
    遍历tuple:5 2 1 3 4 
    遍历dict:a 1 b 2 
    遍历set:4 12 5 6
    

    三、列表、元组、集合和字典相互转换

    1.列表元组转化为集合(去重)

    #两个列表转集合,去重
    list1 = [6,7,7,8,8,9]
    set1 = set(list1)
    print(set1)
    

    输出如下所示:

    {8, 9, 6, 7}
    

    2.两个列表转字典

    #两个列表转字典
    list1 = ["key1","key2","key3"]
    list2 = ["1","2","3"]
    dict1 = dict(zip(list1,list2))
    print(dict1)
    

    输出如下所示:

    {'key1': '1', 'key2': '2', 'key3': '3'}
    

    3.嵌套列表转字典

    #嵌套列表转字典
    list3 = [["key1","valu1"],["key2",'value2'],['key3','value3']]
    dict1 = dict(list3)
    print(dict1)
    

    输出如下所示:

    {'key1': 'valu1', 'key2': 'value2', 'key3': 'value3'}
    

    4.列表、元组转字符串

    #列表、元组转字符串
    list1 = ['s','a','b']
    str1 = " ".join(list1)
    print(str1)
    
    tup1 = ('b','t','u')
    str2 = "-".join(tup1)
    print(str2)
    

    输出如下所示:

    s a b
    b-t-u
    

    5.字典转化为字符串

    dic1 = {'a':1,"b":2}
    str1 = str(dic1)
    print(type(str1))
    print(str1)
    

    输出如下所示:

    <class 'str'>
    {'a': 1, 'b': 2}
    

    6.字典key和value互相转换

    #字典key和value互相转换
    
    dic2 = {"a":1,"b":2}
    
    dic3 = {value:key for key,value in dic2.items()}
    print(dic3)
    

    输出如下所示:

    {1: 'a', 2: 'b'}
    

    7.字符串转换为列表

    #字符串转换为列表
    s = 'dstewsg'
    list1 = list(s)
    print(list1)
    

    输出如下所示:

    ['d', 's', 't', 'e', 'w', 's', 'g']
    

    8.字符串转元组

    #字符串转元组
    s = "ugjhaga;w"
    tu1 = tuple(s)
    print(tu1)
    

    输出如下所示:

    ('u', 'g', 'j', 'h', 'a', 'g', 'a', ';', 'w')
    

    9.字符串转集合

    #字符串转集合
    dic2 = eval("{'a':1,'age':2}")
    print(dic2)
    

    输出如下所示:

    {'a': 1, 'age': 2}
    

    10.切分字符串

    #切分字符串
    a = 'a b c'
    a = a.split(' ')
    print(a)
    

    输出如下所示:

    ['a', 'b', 'c']
    

    四、删除一个列表重复元素

    1.使用集合set方式

    #利用set中的元素不可重复性来去重
    elements = ['a','b','e','c','b','d','a','c','f']
    
    e = list(set(elements))
    print(e)
    

    输出如下所示:

    ['d', 'c', 'b', 'a', 'f', 'e']
    

    要保持列表元素的原来顺序,可以利用list类的sort方法

    #利用list的sort方法保持列表原来顺序
    e.sort(key=elements.index)
    print(e)
    

    输出如下所示:

    ['a', 'b', 'e', 'c', 'd', 'f']
    

    2.使用字典的方式,利用字典key的唯一性

    #使用字典的方式
    #利用了字典的键的唯一性
    elements = ['a','b','e','c','b','d','a','c','f']
    e = list({}.fromkeys(elements).keys())
    print(e)
    

    python函数dict.fromkey(seq,[,value])用于创建一个新字典以序列seq中元素做字典的键,value为字典所有键对应的初始值

    #python函数dict.fromkey(seq,[,value])用于创建一个新字典
    #以序列seq中元素做字典的键,value为字典所有键对应的初始值
    seq = ['a','b','c']
    dict1 = dict.fromkeys(seq,[9,4,3])
    print(dict1)
    

    输出如下所示:

    {'a': [9, 4, 3], 'b': [9, 4, 3], 'c': [9, 4, 3]}
    

    3.列表推导的方式

    #方式三:列表推导的方式
    elements = ['a','b','e','c','b','d','a','c','f']
    e = []
    for i in elements:
        if not i in e:
            e.append(i)
    print(e)
    

    以上代码也可以使用列表生成式简写成

    #以上代码也可以使用列表生成式简写成
    elements = ['a','b','e','c','b','d','a','c','f']
    e = []
    [e.append(i) for i in elements if i not in e]
    print(e)
    

    4.reduce函数

    • reduce函数的定义:
    • reduce(function, sequence[, initial]) -> value
    • function参数是一个有两个参数的函数,reduce依次从sequence中取一个元素,和上一次调用function的结果做参数再次调用function。
    #reduce函数
    from functools import reduce
    
    # reduce函数的定义:
    # reduce(function, sequence[, initial]) -> value
    # function参数是一个有两个参数的函数,reduce依次从sequence中取一个元素,和上一次调用function的结果做参数再次调用function。
    
    elements = ['a','b','e','c','b','d','a','c','f']
    print([[]]+elements)  #[[], 'a', 'b', 'e', 'c', 'b', 'd', 'a', 'c', 'f']
    v = reduce(lambda x,y:x if y in x else x+[y],[[]]+elements)
    print(v)
    

    输出如下所示:

    [[], 'a', 'b', 'e', 'c', 'b', 'd', 'a', 'c', 'f']
    ['a', 'b', 'e', 'c', 'd', 'f']
    

    五、求两个列表的交集、差集或并集

    1.for循环

    a = [1,2,3,4,5]
    b = [2,4,5,6,7]
    
    #交集
    result = [i for i in a if i in b]
    print('a与b的交集:',result)
    
    #差集,在a中但不在b中
    
    result = [i for i in a if i not in b]
    print('a与b的差集:',result)
    
    #并集
    result = a
    for r in b:
        if r not in result:
            result.append(r)
    print('a与b的并集:',result)
    

    输出如下所示:

    a与b的交集: [2, 4, 5]
    a与b的差集: [1, 3]
    a与b的并集: [1, 2, 3, 4, 5, 6, 7]
    

    2.用set操作

    #用set操作
    a = [1,2,3,4,5]
    b = [2,4,5,6,7]
    
    #交集
    result = list(set(a).intersection(set(b)))
    print('a与b的交集:',result)
    
    #差集 在a中但不在b中
    result = list(set(a).difference(set(b)))
    print("a与b的差集:",result)
    
    #并集
    result = list(set(a).union(set(b)))
    print('a与b的交集:',result)
    

    输出如下所示:

    a与b的交集: [2, 4, 5]
    a与b的差集: [1, 3]
    a与b的交集: [1, 2, 3, 4, 5, 6, 7]
    

    六、反序地迭代一个序列

    对序列反序,可以利用内置函数reversed()或range()来实现,也可以用扩展切片[::-1]的形式实现。序列是列表,还可以使用列表自带的reverse()方法。

    1. reversed()是python内置函数,参数可以是字符串、列表或元组等序列

    2. 利用range()方法生成序列宕反序索引,然后从最后的元素遍历到开始的元素,就可以反序输出序列的元素。range(start,stop[,step])方法的参数说明

      • start:计数从start开始,默认是从0开始
      • end:计数到end结束,但不包括end
      • step:步长,默认为1
    3. sea[::-1]扩展切片方法是利用粱序列宕切片操作,切片是序列的高级特性。seq[::-1]表示反向获取seq中的所有元素,并且每次取一个。-1表示从序列宕最后一个元素反向遍历获取。

    4. 如果是列表序列,还可以直接用列表的reverse()方法

    1.reversed()内置的函数方法

    seq = "Hello World"
    
    #reversed()内置的函数方法
    for s in reversed(seq):
        print(s,end='')
    
    #输出换行
    print()
    

    输出如下所示:

    dlroW olleH
    

    2.range()函数方法

    #range()函数方法
    for i in range(len(seq)-1,-1,-1):
        s = seq[i]
        print(s,end='')
    #输出换行
    print()
    

    3.[::-1]扩展切片方法

    #[::-1]扩展切片方法
    for s in seq[::-1]:
        print(s,end='')
    #输出换行
    print()
    

    4.list自带的reverse()方法

    #list自带的reverse()方法
    seq = [1,2,3,4,5,6]
    seq.reverse()
    for s in seq:
        print(s,end='')
    print()
    

    输出如下所示:

    654321
    

    七、列表的sort方法和sorted方法

    • sort是列表方法,只可用来对列表进行排序,是在原序列上进行修改,不会产生新的序列
    • 内置的sorted方法可以用于任何迭代的对象(字符串、列表、元组、字典等)会产生一个新的序列,旧的对象依然存在,不需要旧的序列可以采用sort方法

    1.sort()方法

    seq = [1,3,5,4,2,6]
    seq.sort()
    print(seq)
    

    输出如下所示:

    [1, 2, 3, 4, 5, 6]
    

    2.sorted()方法

    seq = [1,3,5,4,2,6]
    s = sorted(seq)
    print(s)
    

    输出如下所示:

    [1, 2, 3, 4, 5, 6]
    

    3.按列表a1中字典元素的键age由大到小排序

    a1 = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
    
    print(sorted(a1,key=lambda x:x['age'],reverse=True))
    

    输出如下所示:

    [{'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}, {'name': 'a', 'age': 20}]
    

    八、列表中常用的方法

    方法描述
    list.append(x)把一个元素添加到列表的结尾
    list.extend(L)通过添加指定列表的所有元素来扩充列表
    list.insert(i,x)在指定位置插入一个元素,第一个参数是准备插入到其前面的那个元素的索引。例如a.insert(0,x)会插入到整个列表之前
    list.remove(x)删除列表中值为x的第一个元素。没有这样元素,就会返回一个错误
    list.pop([i])从列表的指定位置移除元素,并将其返回。没有指定索引,a.pop()返回最后一个元素。
    list.clear()移除列表中的所有项,等于del a[:]
    list.index(x)返回列表中第一个值为x的元素的索引。没有匹配的元素就返回一个错误
    list.count(x)返回x在列表中出现的次数
    list.sort()对列表中的元素进行排序
    list.reverse()倒排列表中的元素
    list.copy()返回列表的浅复制,等于a[:]
    • list可以看作一个对象,对象有很多中方法,调用方法是:对象.方法,append是这个对象的方法
    • 对象可以理解为人,方法append类似这个人可以跑步、吃饭、打球
    #list可以看作一个对象,append是这个对象的方法
    # 对象可以理解为人,方法append类似这个人可以跑步、吃饭、打球
    list1 = ['a','b','c']
    
    list1.append('d')
    
    print(list1)
    
    list1.extend(['1','2','3'])
    print(list1)
    

    输出如下所示:

    ['a', 'b', 'c', 'd']
    ['a', 'b', 'c', 'd', '1', '2', '3']
    

    九、列表生成式

    用来创建列表的表达式就是列表生成式,也被称为列表推导式。

    • 每个列表生成式都在for之后跟一个表达式,然后有零到多个for或if子句。返回结果是一个根据表达从其后的for和if上下文环境中生成出来的列表。
    • 列表生成式的语法:[表达式 for 循环]
    list1 = [x+1 for x in range(1,8)]
    print(list1)
    

    输出如下所示:

    [2, 3, 4, 5, 6, 7, 8]
    

    十、字典内置函数

    函数及描述描述
    len(dict)计算字典中的元素个数,键的总数
    str(dict)输出字典,以可打印的字符串表示
    type(variable)返回输入变量类型,如果变量是字典就返回字典类型
    radiansdict.clear()删除字典内所有元素
    radiansdict.copy()返回一个字典的浅复制
    radiansdict.fromkeys()创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
    key in dict键在字典dict里返回True,否则返回False
    radiansdict.items()以列表返回可遍历的(键、值)元组数组
    radiansdict.keys()返回一个迭代器,可以使用list()转换为列表
    radiansdict.setdefault(key,default=None)和get类似,键不存在字典中,将会添加键并将值设为default
    radiansdict.update(dict2)把字典dict2的键/值对更新到dict里
    radiansdict.values()返回一个迭代器,可以使用list()转换为列表
    pop(key[,default])删除字典给定键key所对应的值,返回值为被删除的值。key值必须给出,否则,返回default值
    popitem()随机返回并删除字典中的一对键和值(一般删除末尾对)

    使用pop和del删除字典中的name字段

    dic = {"name":"刘备","age":19}
    dic.pop("name")
    print(dic)
    
    dic = {"name":"刘备","age":19}
    del dic["name"]
    print(dic)
    

    输出如下所示:

    {'age': 19}
    {'age': 19}
    

    合并两个字典

    dic1 = {"name":"刘备","age":19}
    
    dic2 = {"hobby":"足球","money":100}
    
    dic1.update(dic2)
    print(dic1)
    

    输出如下所示:

    {'name': '刘备', 'age': 19, 'hobby': '足球', 'money': 100}
    

    十一、集合常见内置方法

    集合常见内置方法如下表所示:

    方法描述
    add()为集合添加元素
    clear()移除集合中的所有元素
    copy()复制一个集合
    difference()返回多个集合的差集
    discard()删除集合中指定的元素
    intersection()返回集合的交集
    isdisjoint()判断两个集合是否包含相同的元素,没有则返回True,否则返回False
    issubset()判断指定集合是否为该方法参数集合的子集
    issuperset()判断该方法的参数集合是否为指定集合的子集
    pop()随机移除元素
    remove()移除指定元素
    symmetric_difference()返回两个集合中不重复的元素集合
    union()返回两个集合的并集
    update()给集合添加元素

    给定两个列表找出相同的元素和不同的元素

    list1 = [1,2,3]
    list2 = [3,4,5]
    
    set1 = set(list1)
    set2 = set(list2)
    
    print(set1&set2)
    print(set1^set2)
    

    输出如下所示:

    {3}
    {1, 2, 4, 5}
    
    展开全文
  • Python:列表元组字典集合

    千次阅读 2019-03-26 17:38:39
    1,列表元组字典集合 1.1,概念 列表(list):是长度可变有序的数据存储器,可通过下标索引取到相应的数据。 元组(tuple):固定长度不可变的顺序容器,访问效率高,适合存储一些长常量数据,可以作为...

    1, 列表,元组,字典,集合

    1.1,概念

    列表(list):是长度可变有序的数据存储器,可通过下标索引取到相应的数据。

    元组(tuple):固定长度不可变的顺序容器,访问效率高,适合存储一些长常量数据,可以作为字典的键使用。

    集合(set):无序,元素只出现一次,可以自动去重。

    字典(dict):长度可变的hash字典容器。存储方式为键值对,可以通过相应的键获取相应的值,key支持多种类型。key必须是不可变类型且唯一。

    属性\数据类型列表元组集合字典
    英文listtuplesetdict
    是否可读写读写只读读写读写
    是否可重复
    存储方式键(不可重复)键值对(键不能重复)
    是否有序有序有序无序无序,自动正序
    初始化[1,‘a’]('a',1)set([1,2])或{1,2}{"a":1,'b':2}
    添加append只读addd['key']='value'
    读元素I[2:]t[0]d['a']
    test_list = [4, 2, 3, 1, 4]
    test_tuple = (5, 2, 1, 3, 4)
    test_dict = {"a": 1, "b": 2}
    test_set = {12, 4, 6, 5}
    for items in test_list:
        print(items, end=" ")
    print()
    for items in test_tuple:
        print(items, end=" ")
    print()
    for key, value in test_dict.items():
        print(key, value, end=" ")
    print()
    for items in test_set:
        print(items, end=" ")
    =============================
    4 2 3 1 4 
    5 2 1 3 4 
    a 1 b 2 
    5 12 4 6 

    1.2,列表,元组,集合,字典间的相互转换

    列表元组转化为其他类型

    # 列表转换集合
    list = [6, 7, 7, 8, 9, 9]
    print(set(list))
    
    # 两个列表转换为字典
    list1 = ["key1", "key2", "key3"]
    list2 = [1, 2, 3]
    print(dict(zip(list1, list2)))
    
    #嵌套列表转字典
    list3 = [["key1","value1"],["key2","value2"],["key3","value3"]]
    print(dict(list3))
    
    #列表、元组转字符串
    list = ["燕","双","嘤"]
    tuple = ("燕","双","嘤")
    print("".join(list))
    print("".join(tuple))
    ==========================
    {8, 9, 6, 7}
    {'key1': 1, 'key2': 2, 'key3': 3}
    {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
    燕双嘤
    燕双嘤

    字典转换为其他类型

    #字典转换为字符串
    dict = {"a":1,"b":2}
    print(str(dict))
    
    #字典key和value转换
    dict = {"a":1,"b":2}
    print({value:key for key,value in dict.items()})
    ================================================
    {'a': 1, 'b': 2}
    {1: 'a', 2: 'b'}

    字符串转换为其他类型

    # 字符串转列表
    s = "燕双嘤"
    print(list(s))
    
    # 字符串转元组
    print(tuple(s))
    
    # 字符串转集合
    print(set(s))
    
    # 字符串转字典
    print(eval("{'name':'燕双嘤','school':'NUDT'}"))
    ===============================================
    ['燕', '双', '嘤']
    ('燕', '双', '嘤')
    {'燕', '双', '嘤'}
    {'name': '燕双嘤', 'school': 'NUDT'}

    2,序列

    2.1,概述

    所谓序列,指的是一种包含多项数据的数据结构,序列包含的多个数据项按顺序排列,可通过索引来访问。

    Python的常见序列包括:列表、元组、字符串、Unicode字符串、buffer对象、range对象。其中列表元组非常相似,最主要的区别在于:

    • 列表是可以修改的,而元组却不能修改。如果要添加和删除元素,只能用列表。元组被称为只读列表,即数据可以被查询,但不能被修改。若元组一旦被定义,则其长度和内容都是固定的,不能被修改,即不能对元组进行更新、增加和删除的操作。
    • 列表用‘[]’表示,元组用‘()’表示。
    • 列表不能作为字典的key,而元组可以,key不可变原因。
    • 如果元组中仅有一个元素,那么需要在元素后加上逗号。

    总结:如果只是固定地保存多个数据项,则不需要修改它们,此时就应该使用元组;反之,就应该使用列表。此外,在某些时候,程序需要使用不可变的对象,比如Python要求字典的key必须是不可变的,此时程序就只能使用元组。

    2.2,索引

    序列对象一般由多个成员组成,每个成员通常称为元素,每个元素都可以通过索引进行访问。索引使用方括号[]表示。

    2.3,通用操作

    切片:要访问一个序列,不仅可以通过单个的索引值来索引单个序列元素,还可以通过切片操作访问某个范围的多个元素。切片操作是通过指定元素的索引值范围来实现的。

    sequence[startindex:endindex]
    str = '0123456789′
    str[0:3] #截取第一位到第三位的字符
    str[:] #截取字符串的全部字符
    str[6:] #截取第七个字符到结尾
    str[:-3] #截取从头开始到倒数第三个字符之前
    str[2] #截取第三个字符
    str[-1] #截取倒数第一个字符
    str[::-1] #创造一个与原字符串顺序相反的字符串
    str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
    str[-3:] #截取倒数第三位到结尾
    str[:-5:-3] #逆序截取

    重复(*)

    如果需要获得一个序列的多个副本,可以使用重复运算符实现,其形式为:sequence*copies

    a = "123"
    print(a * 2)
    ============
    123123

    连接(+)

    连接是指将两个相同类型的逆序进行连接,运算符为“+”,形式为:sequence1+sequence2但操作必须保证参与连接运算的两个序列是同一种类型。

    print((1, 2, 3) + (4, 5, 6))
    ============================
    (1, 2, 3, 4, 5, 6)

    判断成员(in,not in)

    判断一个元素是否属于一个序列的操作使用in和not in这两个成员运算符。

    print("燕" in ("燕", "双", "嘤"))

    2.4,通用函数

    序列类型转换内建函数

    序列类型有list()、tuple()、str()这三个类型转换的内建函数。

    • list(iter):将可迭代对象iter转换成列表。
    • tuple(iter):将可迭代对象iter转换成元组。
    • str(obj):将对象obj转换成字符串。

    list()tuple()函数比较常用,常用于列表和元组数据的类型转换,参数不仅可以是序列对象,还可以是一切可迭代对象。

    print(list("Hello Shuangying Yan"))
    print(tuple("Ying"))
    print(list((1, 2, 3)))
    print(tuple([1, 2, 3]))
    ===========================
    ['H', 'e', 'l', 'l', 'o', ' ', 'S', 'h', 'u', 'a', 'n', 'g', 'y', 'i', 'n', 'g', ' ', 'Y', 'a', 'n']
    ('Y', 'i', 'n', 'g')
    [1, 2, 3]
    (1, 2, 3)

    str()可以把括号中的参数转换成字符串类型。

    print(str(1))
    print(str((1, 2, 3)), type(str((1, 2, 3))))
    print(str([1, 2, 3]), type(str([1, 2, 3])))
    ===========================================
    1
    (1, 2, 3) <class 'str'>
    [1, 2, 3] <class 'str'>

    序列类型其他内建函数

    函数功能
    len(sequence)返回sequence的长度,为int类型。
    sorted(iter,key,reverse)返回可迭代对象iter排序后的列表,key用来指定排序的规则,reverse代表指定顺序还是逆序排列。
    reversed(sequence)返回序列sequence逆序排列后的迭代器。
    sum(iter,start)将可迭代对象iter中的数值和start参数的值想加,返回float类型数值,start默认为0。
    max(iter)返回可迭代对象iter中的最大值。
    min(iter)返回可迭代对象iter中的最小值。
    enumerate(iter[,start])返回一个enumerate对象,是一个迭代器,该迭代器的元素是由参数iter元素的索引和值组成的元组,起始索引由start确定,默认为0。
    zip(iter1[,iter2[...]])返回一个zip对象,是一个迭代器,该迭代器的第n个元素是由每个可迭代对象的第n个元素组成的元组。
    print(list(zip("燕双嘤", "驴驴")))
    =================================
    [('燕', '驴'), ('双', '驴')]

    3,列表:方括号[ ]

    3.1,简介

    特点:顺序、可添加、可修改、可删除。

    # 创建列表
    x = [1, 2, 3, 4, 5]
    y = list('12345')
    m = [0] * 5
    n = list()
    n.append(1)
    s = list(range(0, 10, 2))
    print(x, y, m, n, s)
    ===============
    [1, 2, 3, 4, 5] ['1', '2', '3', '4', '5'] [0, 0, 0, 0, 0] [1] [0, 2, 4, 6, 8]

    常用方法:

    • append(x):把一个元组添加到列表的结尾。
    • extend(x):通过添加指定列表的所有元素来扩充列表。
    • insert(i, x):在指定添加位置插入一个元素。
    • remove(x):删除列表中值为x的元素,如果没有,报错。
    • pop([i]):从列表指定位置或末尾将其返回。
    • clear():移出列表的所有项,等于del a[:]。
    • index(x):返回列表中第一个值为x的元素的索引,如果没有,报错。
    • count(x):返回x在列表中出现的次数。
    • sort():对列表中的元素进行排序。
    • reverse():倒排列表中的元素。
    • copy():返回列表的浅拷贝。

    3.2,列表的引用、浅拷贝、原地拷贝

    假设A和B是两个列表:

    • 引用:A = B

    A = [1, 2, 3, 4, 5]
    B = ['a', 'b', 'c','d']
    A = B
    A[1] = 'x'
    print(A, B)
    =========================================
    ['a', 'x', 'c', 'd'] ['a', 'x', 'c', 'd']
    • 浅拷贝:A = B[ : ]

    A = [1, 2, 3, 4, 5]
    B = ['a', 'b', 'c','d']
    A = B[:]
    A[1] = 'x'
    print(A, B)
    =========================================
    ['a', 'x', 'c', 'd'] ['a', 'b', 'c', 'd']
    • 原地拷贝:A[ : ] = B[ : ],A[ : ] = B

    A = [1, 2, 3, 4, 5]
    B = ['a', 'b', 'c','d']
    A[:] = B[:]
    A[1] = 'x' #or A[:]=B
    print(A, B)
    =========================================
    ['a', 'x', 'c', 'd'] ['a', 'b', 'c', 'd']

    3.3,增加列表元素

    append()方法会把传入的参数追加到列表的最后面。append()方法既可接受单个值,也可接收元组、列表等,但该方法只是把元组、列表当成单个元素,这样就会形成在列表中嵌套列表、嵌套元组的情形。

    a = [1, 2, 3]
    b = (4, 5)
    a.append(b)
    print(a)
    ==============
    [1, 2, 3, (4, 5)]

    如果希望不将被追加的列表当成一个整体,而只是追加列表中的元素,则可使用列表的extend()方法。

    a = [1, 2, 3]
    b = (4, 5)
    a.extend(b)
    print(a)
    =============
    [1, 2, 3, 4, 5]

    如果希望在列表中间增加元素,则可使用列表的insert()方法,使用insert()方法时要指定将元素插入列表的哪个位置。

    a = list(range(1,6))
    a.insert(3,"燕双嘤")
    print(a)
    ====================
    [1, 2, 3, '燕双嘤', 4, 5]

    3.4,删除列表元素

    删除列表元素使用del语句。del语句是Python的一种语句,专门用于执行删除操作,不仅用于删除列表的元素,也可用于删除变量等。

    list = ["燕双嘤", 'I am a trash', 22, (9, 9), [1, 1]]
    print(list)
    del list[1]
    print(list)
    del list[:2]
    print(list)
    ======================
    ['燕双嘤', 'I am a trash', 22, (9, 9), [1, 1]]
    ['燕双嘤', 22, (9, 9), [1, 1]]
    [(9, 9), [1, 1]]

    使用del不仅可以删除列表元素,还可以删除普通变量。

    a = "燕双嘤"
    del a
    print(a)
    ================
    Traceback (most recent call last):
      File "E:/Pycharm/WorkSpace/Study/main.py", line 3, in <module>
        print(a)
    NameError: name 'a' is not defined

    除使用del语句之外,Python还提供了remove()方法来删除列表元素,该方法并不是根据索引来删除缘故的,而是根据元素本身来执行删除操作的。该方法只删除第一个找到的元素,如果找不到该元素,该方法将会引发ValueError错误。

    a = [1,2,3,4,5]
    a.remove(6)
    ===============
    Traceback (most recent call last):
      File "E:/Pycharm/WorkSpace/Study/main.py", line 2, in <module>
        a.remove(6)
    ValueError: list.remove(x): x not in list

    3.5,修改列表元素

    列表的元素相当于变量,因此程序可以对列表的元素赋值,这样即可修改列表的元素。

    a = [1, 2, 3, 4, 5]
    a[0] = 0

    此外,程序也可通过slice语法对列表其中一部分赋值,在执行这个操作时并不要求新赋值的元素个数与原来的元素个数相等。这意味着通过这种方式既可为列表增加元素,也可为列表删除元素。

    a = [1, 2, 3, 4, 5]
    a[0:2] = [0]
    print(a)
    a[0:1] = [1, 2]
    print(a)
    ===================
    [0, 3, 4, 5]
    [1, 2, 3, 4, 5]

    如果对列表中空的slice赋值,就变成了为列表插入元素。可以解决插入多个数据的问题(insert无法做到)。

    a = [1, 2, 3, 4, 5]
    a[0:0] = [1, 2, 3]
    print(a)
    ===================
    [1, 2, 3, 1, 2, 3, 4, 5]
    
    
    a = [1, 2, 3, 4, 5]
    a[0] = [1, 2, 3]
    print(a)
    ===================
    [[1, 2, 3], 2, 3, 4, 5]

    如果将列表其中一段赋值为空列表,就变成了从列表中删除元素。

    a = [1, 2, 3, 4, 5]
    a[0:2] = []
    print(a)
    ==================
    [3, 4, 5]

    PS:对列表使用slice语法赋值时,不能使用单个值;如果使用字符串赋值,Python会自动把字符串当成序列处理,其中每个字符都是一个元素。

    a = [1, 2, 3, 4, 5]
    a[5:6] = "燕双嘤"
    print(a)
    ==================
    [1, 2, 3, 4, 5, '燕', '双', '嘤']

    在使用slice语法赋值时,也可指定step参数。但如果指定了step参数,则要求所赋值的列表元素个数大于所替换的列表元素个数。

    a = [1, 2, 3, 4, 5]
    a[5:8:1] = ["燕","双","嘤"]
    print(a)
    ==================
    [1, 2, 3, 4, 5, '燕', '双', '嘤']
    
    a = [1, 2, 3, 4, 5]
    a[5:8:2] = ["燕","双","嘤"]
    print(a)
    =================
    Traceback (most recent call last):
      File "E:/Pycharm/WorkSpace/Study/main.py", line 2, in <module>
        a[5:8:2] = ["燕","双","嘤"]
    ValueError: attempt to assign sequence of size 3 to extended slice of size 0

    3.6,列表的其他常用方法

    列表还包括一些常用方法:

    • count():用于统计列表中某个元素出现的次数。
    • index():用于判断某个元素在列表中出现的位置。
    • pop():用于将列表当成“栈”使用,实现元素出栈。
    • reverse():用于将列表中的元素反向存放。
    • sort():用于对列表元素进行排序。

    需要注意的是sort()方法除支持默认排序之外,还可传入key和reverse两个参数,而且这两个参数必须通过参数名指定。key参数用于为每个元素都生成一个比较大小的“键”;reverse参数则用于执行是否反转排序——默认是从小到大排序;如果将该参数设为True,将会改变从大到小排序。

    a = ["11","1","010","0000"]
    a.sort(key=len)
    print(a)

    sort方法sorted方法的区别:sort是列表方法,只可用来对列表进行排序,是在原序列上进行修改,不会产生新的序列。内置的sorted方法可以用于任何可迭代对象(字符串,列表,元组,字典等),它会产生一个新的序列,旧的对象依然存在。如果不需要旧的列表序列,那么可以采用sort方法。 

    4,元组:括号( )

    4.1,简介

    特点:顺序、不可增加、不可删除、可修改。读取速度比列表快

    #创建方法
    x = (1,2,3,4,5,6)
    y = tuple('Tom', 'Jack', 'Lisa', 'Alice')
    n = tuple(range(10))

    元组中如果只有一个元素,则必须后面加上逗号(,) 

    a = (1,)
    b = (1)
    c = ("1")
    print(type(a), type(b), type(c))
    ===============================
    <class 'tuple'> <class 'int'> <class 'str'>

    4.2,元组的不可变性

    a=(1,2)
    a[1]=3
    =======
    Traceback (most recent call last):
      File "E:/Pycharm/WorkSpace/Study/main.py", line 2, in <module>
        a[1]=3
    TypeError: 'tuple' object does not support item assignment

    如果元组套列表:

    a=([1,1],[2,2])
    a[1][1]=3
    print(a)
    ===============
    ([1, 1], [2, 3])

    其实元组并没有改变,改变的只是列表。

    a=([1,1],[2,2])
    print(id(a[1]))
    a[1][1]=[3]
    print(id(a[1]))
    ===============
    1877164949128
    1877164949128

    因此,元组是不可变的。

    4.3,序列封包和序列解包

    Python还提供了序列封包和解包的功能。简单来说,Python允许支持一下两种方式赋值:

    • 序列封包:程序把多个值赋给一个变量时,Python会自动将多个值封装成元组。
    x = 1, 2, 1, 3, 8
    print(x)
    print(type(x))
    print(x[2])
    ===================
    (1, 2, 1, 3, 8)
    <class 'tuple'>
    1
    • 序列解包:程序允许将序列(元组或列表)直接赋值给多个变量,此时序列的各元素会被依次赋值给每个变量。
    x = tuple(range(1, 10, 2))
    a, b, c, d, e = x
    print(a, b, c, d, e)
    ==========================
    1 3 5 7 9

    序列解包时也可以只解出部分变量,剩下的依然使用列表变量保存。 

    a, *b = 1,2,3
    print(a, b)
    =============
    1 [2, 3]

    如果在赋值中同时运用了序列封包和序列解包机制,就可以让赋值运算符支持同时将多个值赋给多个变量。

    a, b, c = 1, 2, 3
    print(a, b, c)
    ================
    1 2 3

    实际上,相当于如下过程:

    abc = 1,2,3
    a,b,c = abc

    5,字典:花括号{ }

    比如某些有关联的数据,需要使用key-value的形式保存(Java的Map),就需要用到Python中的字典。

    特点:依靠键值对读取,无序(输出不唯一),键不可变,值可变。

    5.1,字典的创建

    程序既可以用花括号语法来创建字典,也可使用dict()函数来创建字典。实际上,dict是一种类型,就是Python中的字典类型。

    在使用花括号语法创建字典时,花括号中应包含多个key-value对,key与value之间用英文冒号隔开;多个key-value对之间用英文逗号隔开。

    #一般字典
    x = {
        "姓名": "燕双嘤",
        "性别": "男",
        "年龄": "22"
    }
    #使用元组作为key的字典
    x = {
        ("姓", "名"): "燕双嘤",
        "性别": "男",
        "年龄": "22"
    }

    由于字典的key不可变,因此只能使用元组作为key,而不能使用列表作为key值。

    a = {}
    b = {3: 4}
    c = {[11, 23]: 5}
    d = {(11, 23): 5}
    =================
    Traceback (most recent call last):
      File "E:/Pycharm/WorkSpace/Study/main.py", line 3, in <module>
        c = {[11, 23]: 5}
    TypeError: unhashable type: 'list'

    在使用dict()函数创建字典时,可以传入多个列表或元组参数作为key-value对,每个列表或元组将被当成一个key-value对,因此这些列表或元素都只能包含两个元素。

    a = [("姓名","燕双嘤"),("性别","男"),("年龄","22")]
    b = dict(a)
    print(b)
    c = [["姓名","燕双嘤"],["性别","男"],["年龄","22"]]
    d = dict(c)
    print(d)
    =================================================
    {'姓名': '燕双嘤', '性别': '男', '年龄': '22'}
    {'姓名': '燕双嘤', '性别': '男', '年龄': '22'}

    还可以通过为dict指定关键字参数创建字典,此时字典的key不允许使用表达式。

    a = dict(name="燕双嘤",sex="男")
    print(a)
    ===============================
    {'name': '燕双嘤', 'sex': '男'}

    5.2,字典基本用法

    对字典的操作都是基于key的:

    • 通过key访问value。
    • 通过key添加key-value对。
    • 通过key删除key-value对。
    • 通过key修改key-value对。
    • 通过key判断指定key-value对是否存在。

    通过key访问value使用的也是方括号语法,就像列表和元组一样,只是此时括号中放的是key。

    a = dict(name="燕双嘤",sex="男")
    print(a["sex"])

    如果需要为dict添加key-value对,只需为不存在的key赋值即可。

    a = dict(name="燕双嘤",sex="男")
    print(a)
    a["age"] = 22
    print(a)

    如果要删除字典的key-value对,则可使用del语句。

    a = dict(name="燕双嘤",sex="男")
    print(a)
    del a["sex"]
    print(a)

    如果对dict中存在的key-value对赋值,新赋的value就会覆盖原有的value,这样便可修改字典中的key-value对。

    a = dict(name="燕双嘤", sex="男")
    a["name"] = "杜马"
    print(a)

    如果要判断字典是否包含指定的key,则可以使用in或not in运算符。需要指出的是,对dict而言,in或not in运算符都是基于key来判断的。

    a = dict(name="燕双嘤", sex="男")
    print("name" in a)

    5.3,字典的常用方法

    clear():用于清空字典中所有的key-value对,对一个字典执行clear()方法之后,该字典就会变成一个空字典。

    a = dict(name="燕双嘤", sex="男")
    a.clear()

    get():根据key来获取value。当使用括号语法访问不存在的key时,字典会引发KeyError错误;但如果使用get()方法访问不存在的key,该方法会简单地返回None。

    a = dict(name="燕双嘤", sex="男")
    a.get("name")

    update():使用一个字典所包含的key-value对来更新已有的字典。在执行update()方法时,如果被更新的字典中已包含对应的key-value对,那么原value会被覆盖。如果被更新的字典中不包含对应的key-value对,则该key-value对被添加进去

    a = dict(name="燕双嘤", sex="男")
    a.update({"name": "杜马", "职位": "军统总教官"})

    items()、keys()、values():分别用于获取字典中的所有key-value对、所有key、所有value。这三个方法依次返回dict_items、dict_keys和dict_values对象,Python不希望用户直接操作这几个方法,但可通过list()函数把他们转换成列表。

    a = dict(name="燕双嘤", sex="男")
    print(list(a.items()))
    print(list(a.keys()))
    print(list(a.values()))

    pop():用于获取指定key对应的value,并删除这个key-value对。

    a = dict(name="燕双嘤", sex="男")
    print(a.pop("name"))

    setdefault():根据key来获取对应value的值。但该方法有一个额外的功能——当程序要获取的key在字典中不存在时,该方法会先为这个不存在的key设置一个默认的value,然后返回该key对应的value。

    a = dict(name="燕双嘤", sex="男")
    print(a.setdefault("age",22))
    ================================
    22

    fromkeys():使用给定的多个key创建字典,这些key对应的value默认都是None;也可以额外传入一个参数作为默认的value。但该方法一般不会使用字典对象调用(毫无意义),通常会使用dict类直接调用。

    a = dict.fromkeys(["name","sex","age"])
    print(a)
    =======================================
    {'name': None, 'sex': None, 'age': None}
    b = ("name","age")
    c = ("燕双嘤",22)
    a = dict.fromkeys(b,c)
    print(a)
    ======================
    {'name': ('燕双嘤', 22), 'age': ('燕双嘤', 22)}
    
    b = ("name","age")
    c = 22
    a = dict.fromkeys(b,c)
    print(a)
    ======================
    {'name': 22, 'age': 22}

    5.4,使用字典格式化字符串

    在格式化字符串时(链接),如果要格式化的字符串模板包含多个变量,后面就需要按顺序给出多个变量,这种方式对于字符串模板中包含少量变量的情形是合适的,但如果字符串模板中包含大量变量,这种按顺序提供变量的方式则有些不合适。可改为在字符串模板中按key指定变量,然后通过字典为字符串模板中的key设置值。

    temp = "书名是:%(name)s,价格是:%(price)010.2f,出版社是:%(publish)s"
    book = {"name":"盗墓笔记","price":20,"publish":"南派泛娱"}
    print(temp%book)
    ===================================================================
    书名是:盗墓笔记,价格是:0000020.00,出版社是:南派泛娱

    6,集合:花括号{}

    6.1,创建集合

    可用{}创建集合

    set = {1,2,3,3}
    print(set)
    ===============
    {1, 2, 3}

    通过set()函数和frozenset()函数分别创建可变集合和不可变集合。

    a = set("燕双嘤")
    print(a)
    b = frozenset("杜马")
    print(b)
    ===================
    {'双', '燕', '嘤'}
    frozenset({'马', '杜'})

    PS:不可变集合是可哈希的,而可变集合中的元素是可以修改的,所以是不可哈希的。

    6.2,集合运算

    Python中的集合也具有一些数学上集合的用法:

    Python符号功能
    in是否是集合的的成员
    not是否不是集合的成员
    ==判断集合是否相等
    !=判断集合是否相等
    <判断是否是集合的真子集
    <=判断是否是集合的子集
    >判断是否是集合的真超集
    >=判断是否是集合的超集
    &交集
    |合集
    -差补或相对补集
    ^对称拆分
    a = set("燕双嘤")
    b = set("杜马")
    print("燕" in a)
    print(a == b)
    print(set("燕") < a)
    print(a & b, a | b, a - b, a ^ b)
    =================================
    True
    False
    True
    set() {'嘤', '马', '燕', '杜', '双'} {'嘤', '双', '燕'} {'嘤', '马', '杜', '双', '燕'}

    6.3,集合方法

    面向所有集合的方法:

    • issubset(t):判断s是否是t的子集。
    • issuperset(t):判断s是否是t的超集。
    • union(t):返回新集合,是s和t的并集。
    • intersection(t):返回新集合,是s和t的交集。
    • difference(t):返回新集合,差补操作。
    • symmeric_difference(t):对称拆分操作。
    • copy():返回集合s的副本。

    面向可变集合的方法:

    • update(t):修改s集合,使s中包含s和t并集的成员。
    • intersection_update(t):修改s集合,使s中包含s和t交集的成员。
    • difference_update(t):修改s集合,使s中包含只属于集合s但不属于集合t的成员。
    • symmetric_difference_update(t):修改s集合,使s中包含只属于s或只属于t但不同时属于s和t的成员。
    • add(obj):将对象obj添加到集合s中去。
    • remove(obj):从s中删除对象obj,如果obj不属于s,则产生KeyError异常。
    • discard(obj):从s中删除对象obj,如果不存在,则没有任何操作。
    • pop():从s中删除任意一个成员,并返回这个成员。
    • clear():将s中的成员清空。
    展开全文
  • 本篇主要介绍Python里的数据结构,包括列表元组字典集合、字符串的使用,学习这些序列的方法以及性质。

            前面一篇简单介绍了Python的数据类型与运算符,这一节主要学习Python中5种常用序列结构:列表、元组、集合、字典和字符串的详细使用和一些技巧,下图概括了本篇的主要内容。

    1 序列

            在数学上,序列也称数列,按一定顺序排列的数。程序设计中序列是一种数据存储方式,如C,C++中的数组。Python中序列是最基本的数据结构,是一块用于存放多个值的连续内存空间,这些值按一定顺序排列,可通过每个值所在位置的编号(称为索引)访问它们。Python中内置了5种常用序列结构:列表、元组、集合、字典和字符串。这些序列支持以下几种通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。

    1.1 索引

            序列中,每个元素都有属于自己的编号(索引)。从左向右,索引值从 0 开始递增,同时支持索引值是负数,此类索引是从右向左计数,换句话说,从最后一个元素开始计数,从索引值 -1 开始,如下图所示。

    >>> str = "Python"
    >>> print(str[-1] = str[5])
    True
    

    1.2 切片

            切片操作是访问序列中元素的另一种方法,它可以访问一定范围内的元素,通过切片操作,可以生成一个新的序列。序列实现切片的语法格式如下:
            序列名称[头下标:尾下标:步长],其中头下标可以指定开始索引的位置(包括该位置),可以是正数或负数,若不指定,则默认为0,从序列的开头进行切片;尾下标表示结束索引位置(不包括该位置),如果不指定,则默认为序列的长度;步长表示隔几个存储位置(包含当前位置)取一次元素,也就是说,如果步长的值大于 1,则在进行切片去序列元素时,会“跳跃式”的取元素。如果省略设置步长的值,则最后一个冒号就可以省略。
            下面用切片操作实现倒序:

    >>> str = "python"
    >>> print(str[::-1])
    nohtyp
    

    1.3 相加

            Python中,支持两种类型相同的序列使用“+”运算符做相加操作,它会将两个序列进行连接,但不会去除重复的元素。

    >>> print("人生苦短"+","+"我用"+"python")
    人生苦短,我用python
    >>> num = [1, 2, 3]
    >>> word = ['python', 'php', 'java', 'C++']
    >>> print(num + word)
    [1, 2, 3, 'python', 'php', 'java', 'C++']
    

            温馨提示: 序列相加时,相同类型序列指同为列表、元组、集合等,序列中的元素类型可以不同。

    1.4 相乘

            Python中,使用数字n乘以一个序列会生成新的序列,其内容为原来序列被重复n次的结果。例如:

    >>> str = "Python"
    >>> print(str*3)
    PythonPythonPython
    

    1.5 检察元素

            Python中使用in关键字检查某元素是否为序列的成员,用not in关键字用来检查某个元素是否不包含在指定的序列中,其语法格式为:

    >>> str = "python"
    >>> print('p' in str)
    True
    >>> print('p' not in str)
    False
    

    1.6 内置函数

    表 1 序列相关的内置函数
    函数功能
    len()计算序列的长度,即返回序列中包含多少个元素。
    max()找出序列中的最大元素。注意,对序列使用 sum() 函数时,做加和操作的必须都是数字,不能是字符或字符串,否则该函数将抛出异常,因为解释器无法判定是要做连接操作(+ 运算符可以连接两个序列),还是做加和操作。
    min()找出序列中的最小元素。
    list()将序列转换为列表。
    str()将序列转换为字符串。
    sum()计算元素和。
    sorted()对元素进行排序。
    reversed()反向序列中的元素。
    enumerate()将序列组合为一个索引序列,多用在 for 循环中。

    2 列表 list

            Python中没有数组,但是加入了更加强大的列表。如果把数组看做是一个集装箱,那么Python的列表就是一个工厂的仓库。列表会将所有元素都放在一对中括号[ ]里面,相邻元素之间用逗号,分隔。列表的元素可以是整数、小数、字符串、列表、元组等任何类型的数据,并且同一个列表中元素的类型也可以不同。

            温馨提示: 在使用列表时,虽然可以将不同类型的数据放入到同一个列表中,但通常情况下不这么做,同一列表中只放入同一类型的数据,这样可以提高程序的可读性。

    2.1 创建、删除列表

    1. 使用[ ]直接创建列表

            使用此方式创建列表时,列表中元素可以有多个,也可以一个都没有,例如:

    >>> name = ["jack", "jane", "marry"]
    >>> age = [16, 18, 15]
    >>> emptylist = []
    
    1. 使用list()函数创建列表

            内置函数list()可以将其它数据类型转换为列表类型

    >>> print(list("hello")
    ['h', 'e', 'l', 'l', 'o']
    >>> print(list({'a':1, 'b':2, 'c':3}))
    ['a', 'b', 'c']
    
    1. 拼接列表

            使用+运算符可以将多个序列连接起来;列表是序列的一种,所以也可以使用+进行连接,这样就相当于在第一个列表的末尾添加了另一个列表。使用+会生成一个新的列表,原有的列表不会被改变。

    >>> language = ["Python", "C++", "Java"]
    >>> date = [1991, 1998, 1995]
    >>> info = language + date
    >>> print(info)
    ['Python', 'C++', 'Java', 1991, 1998, 1995]
    

            对于已经创建的列表,如果不再使用,可以使用del关键字将其删除。在实际开发中并不经常使用del来删除列表,因为Python自带的垃圾回收机制会自动销毁无用的列表,即使开发者不手动删除,Python也会自动将其回收。语法格式为:del listname

    2.2 访问元素

            列表是顺序存储,可以使用索引(Index)访问列表中的某个元素(得到的是一个元素的值),也可以使用切片访问列表中的一组元素(得到的是一个新的子列表)。

    >>> numberlist = [1, 2, 3, 4]
    >>> print(numberlist[::2])
    [1, 3]
    

    2.3 添加元素

            在C++学习列表时,添加和删除元素,需要通过指针的方式实现,而Python里面提供了更加简单的方式对列表的元素进行增删。
    1. append()

            append()方法用于在列表的末尾追加元素,语法格式如下:

    listname.append(obj)
    listname表示要添加元素的列表;obj表示到添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等。

    program = ["Python", "C++", "Java"]
    # 追加元素
    program.append("PHP")
    print(program)
    
    # 追加元组,整个元组被当成一个元素
    other = ("JavaScript", "C#", "Go")
    program.append(other)
    print(program)
    
    # 追加列表,整个列表也被当成一个元素
    data = ["Ruby", "SQL"]
    program.append(data)
    print(program)
    

            输出结果为:

    [‘Python’, ‘C++’, ‘Java’, ‘PHP’]
    [‘Python’, ‘C++’, ‘Java’, ‘PHP’, (‘JavaScript’, ‘C#’, ‘Go’)]
    [‘Python’, ‘C++’, ‘Java’, ‘PHP’, (‘JavaScript’, ‘C#’, ‘Go’), [‘Ruby’, ‘SQL’]]

            温馨提示: 当给append()方法传递列表或者元组时,会将它们视为一个整体,作为一个元素添加到列表中,从而形成包含列表和元组的新列表。

    2. extend()

            extend()不会把列表或者元祖视为一个整体,而是把它们包含的元素逐个添加到列表中。语法格式如下:

    listname.extend(obj)
    listname指的是要添加元素的列表;obj表示到添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等,但不能是单个的数字。

    program = ["Python", "C++", "Java"]
    # 追加元素
    program.extend("C")
    print(program)
    
    # 追加元组,元祖被拆分成多个元素
    other = ("JavaScript", "C#", "Go")
    program.extend(other)
    print(program)
    
    # 追加列表,列表也被拆分成多个元素
    data = ["Ruby", "SQL"]
    program.extend(data)
    print(program)
    

    输出结果为:

    [‘Python’, ‘C++’, ‘Java’, ‘C’]
    [‘Python’, ‘C++’, ‘Java’, ‘C’, ‘JavaScript’, ‘C#’, ‘Go’]
    [‘Python’, ‘C++’, ‘Java’, ‘C’, ‘JavaScript’, ‘C#’, ‘Go’, ‘Ruby’, ‘SQL’]

    3. insert()

            如果希望在列表中间某个位置插入元素,那么可以使用insert()方法。语法格式如下:

    listname.insert(index, obj)
    其中,index表示指定位置的索引值。insert()会将obj插入到listname列表第index个元素的位置。

            当插入列表或者元组时,insert()也会将它们视为一个整体,作为一个元素插入到列表中,这一点和append()是一样的。

    program = ["Python", "C++", "Java"]
    # 追加元素
    program.insert(1, "C")
    print(program)
    
    # 追加元组,整个元组被当成一个元素
    other = ("JavaScript", "C#", "Go")
    program.insert(0, other)
    print(program)
    
    # 追加列表,整个列表也被当成一个元素
    data = ["Ruby", "SQL"]
    program.insert(2, data)
    print(program)
    

            输出结果为:

    [‘Python’, ‘C’, ‘C++’, ‘Java’]
    [(‘JavaScript’, ‘C#’, ‘Go’), ‘Python’, ‘C’, ‘C++’, ‘Java’]
    [(‘JavaScript’, ‘C#’, ‘Go’), ‘Python’, [‘Ruby’, ‘SQL’], ‘C’, ‘C++’, ‘Java’]

            温馨提示: insert()主要用来在列表的中间位置插入元素,如果仅仅希望在列表的末尾追加元素,更建议使用 append()extend()

    2.4 删除元素

            在Python列表中删除元素主要分为以下 3 种场景:

    • 根据目标元素所在位置的索引进行删除,可以使用del关键字或者pop()方法;
    • 根据元素本身的值进行删除,可使用列表(list类型)提供的remove()方法;
    • 将列表中所有元素全部删除,可使用列表(list类型)提供的clear()方法。

    1. del()

            delPython中的关键字,专门用来执行删除操作,它不仅可以删除整个列表,还可以删除列表中的某些元素。

    >>> language = ["Python", "C++", "Java", "PHP"]
    >>> del laguage[-1]
    >>> print(laguage)
    ["Python", "C++", "Java"]
    >>> del laguage[-3:-1]
    >>> print(laguage)
    ["Java"]
    

    2. pop()

            pop()方法用来删除列表中指定索引处的元素,具体格式如下:

    listname.pop(index)
    listname表示列表名称,index表示索引值。如果不写index参数,默认会删除列表中的最后一个元素,类似于数据结构中的“出栈”操作。

    >>> numbers = [12, 15, 16, 18]
    >>> numbers.pop(2)
    >>> print(numbers)
    [12, 15, 18]
    >>> numbers.pop()
    [12, 15]
    

    3. remove()

            remove()方法会根据元素本身的值来进行删除操作。但remove()方法只会删除第一个和指定值相同的元素,而且必须保证该元素是存在的,否则会引发 ValueError错误。

    >>> numbers = [12, 15, 16, 18]
    >>> numbers.remove(18)
    >>> print(numbers)
    [12, 15, 16]
    

    4. clear()

            clear()用来删除列表的所有元素,也即清空列表。例如:listname.clear()

    2.5 修改元素

            修改单个元素可以直接对元素赋值即可,Python支持通过切片语法给一组元素赋值。在进行这种操作时,如果不指定步长(step 参数),Python 就不要求新赋值的元素个数与原来的元素个数相同;这意味,该操作既可以为列表添加元素,也可以为列表删除元素。使用切片语法时也可以指定步长(step 参数),但这个时候就要求所赋值的新元素的个数与原有元素的个数相同。

    program = ["Python", "C++", "Java"]
    
    # 修改单个元素
    program[1] = "C"
    print(program)
    
    # 修改后两个元素,对空切片(slice)赋值,就相当于插入一组新的元素:
    other = ("JavaScript", "C#", "Go")
    program[1:3] = other
    print(program)
    
    # 使用步长
    program[::2] = ["Ruby", "SQL"]
    print(program)
    
    ['Python', 'C', 'Java']
    ['Python', 'JavaScript', 'C#', 'Go']
    ['Ruby', 'JavaScript', 'SQL', 'Go']
    

    2.6 查找元素

    1. index()

            index()方法用来查找某个元素在列表中出现的位置(也就是索引),如果该元素不存在,则会导致ValueError错误,所以在查找之前最好使用count()方法判断一下。语法格式为:

    listname.index(obj, start, end)
    listname表示列表名称,obj表示要查找的元素,start表示起始位置,end表示结束位置。

    >>> numbers = [12, 16, 20, 25]
    >>> print(numbers.index(20))
    2
    >>> print(numbers.index(12,2))
    ValueError
    

    2. count()

            count()方法用来统计某个元素在列表中出现的次数,如果count()返回 0,就表示列表中不存在该元素,所以count()也可以用来判断列表中的某个元素是否存在。

    >>> numbers = [1, 2, 3, 2, 4, 6, 8]
    >>> print(numbers.count(2))
    2
    

    2.7 遍历列表

            直接使用for循环遍历列表,只能输出元素值。

    for item in listname:
    	# 输出item
    

            使用for循环和enumerate()函数实现同时输出索引值和元素内容。

    for index,item in enumerate(listname):
    	# index:用于保存元素的索引
    	# item:用于保存获取到的元素值,要输出元素内容时,直接输出该变量即可
    	# listname:列表名称
    

    2.8 列表推导式

    使用列表推导式可以快速生成一个列表,或者根据某个列表生成满足指定需求的列表。
    (1)生成指定范围的数值列表

    list = [Expression for var in range]
    list:表示生成的列表名称;Expression:表达式,用于计算新列表的元素;var:循环变量;range:采用range()函数生成的range对象。

    (2)根据列表生成指定需求的列表

    newlist = [Expression for var in list]
    newlist:表示新生成的列表名称;Expression:表达式,用于计算新列表的元素;var:变量,值为后面列表的每个元素值;list:用于生成新列表的原列表。

    (3)从列表中选择符合条件的元素组成新的列表

    newlist = [Expression for var in list if condition]
    newlist:表示新生成的列表名称;Expression:表达式,用于计算新列表的元素;var:变量,值为后面列表的每个元素值;list:用于生成新列表的原列表;conditon:条件表达式,用于指定筛选条件

    表 2 Python 列表包含的方法
    序号方法描述
    1list.append(obj)在列表末尾添加新的对象
    2list.count(obj)统计某个元素在列表中出现的次数
    3list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    4list.index(obj)从列表中找出某个值第一个匹配项的索引位置
    5list.insert(index, obj)将对象插入列表
    6list.pop([index=-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    7list.remove(obj)移除列表中某个值的第一个匹配项
    8list.reverse()反向列表中元素
    9 list.sort( key=None, reverse=False)对原列表进行排序
    10list.clear()清空列表
    11list.copy()复制列表

    3 元组 tuple

            元组可以看做不可变的列表,通常情况下,元组用于保存无需修改的内容。从存储内容上看,元组可以存储整数、实数、字符串、列表、元组等任何类型的数据,并且在同一个元组中,元素的类型可以不同。
    1. 创建元组

            使用()直接创建元组,元组通常都是使用一对小括号将所有元素包围起来的,但小括号不是必须的,只要将各元素用逗号隔开,Python就会将其视为元组,如下:

    >>> content = ("math", 90, [1, 2], ('c', 2)) 
    >>> course = "C++", "Matlab"
    >>> print(course)
    ('C++', 'Matlab')
    >>> tuple1 = ("python")
    >>> type(tuple1)
    <class 'str'>
    >>> tuple2("python",)
    >>> type(tuple2)
    <class 'tuple'>
    

            温馨提示: 当创建的元组中只有一个字符串类型的元素时,该元素后面必须要加一个逗号,否则Python解释器会将它视为字符串。当使用多个字符串,没有()时,如course = "C++", "Matlab",若中间没有逗号,Python会将其视为字符串,反之视为元组。

            也可以使用内置的函数tuple()将其它数据类型转换为元组类型,语法格式:tuple(data),其中,data 表示可以转化为元组的数据,包括字符串、元组、range 对象等。

    2. 访问元素

            和列表一样,我们可以使用索引(Index)访问元组中的某个元素(得到的是一个元素的值),也可以使用切片访问元组中的一组元素(得到的是一个新的子元组)。

    >>> program = tuple("python")
    >>> print(program[-2])
    o
    >>> print(program[::2])
    ('p', 't', 'o')
    

    3. 修改元组

            元组是不可变序列,元组中的元素不能被修改,所以只能创建一个新的元组去替代旧的元组。

    4. 删除元组

            当创建的元组不再使用时,可以通过del关键字将其删除。Python自带垃圾回收功能,会自动销毁不用的元组,所以一般不需要通过del来手动删除。

            使用元组推导式可以快速生成元组。其形式与列表推导式类似,只是将[]修改为()。元组推导式的结果并不是一个元组,而是一个生成器对象。要使用该生成器对象,可以将其转换为元组或者列表。

    表 3 Python 字典特征
    主要特征 解释
    通过键而不是通过索引来读取元素 字典类型有时也称为关联数组或者散列表(hash)。它是通过键将一系列的值联系起来的,这样就可以通过键从字典中获取指定项,但不能通过索引来获取。
    字典是任意数据类型的无序集合 和列表、元组不同,通常会将索引值 0 对应的元素称为第一个元素,而字典中的元素是无序的。
    字典是可变的,并且可以任意嵌套 字典可以在原处增长或者缩短(无需生成一个副本),并且它支持任意深度的嵌套,即字典存储的值也可以是列表或其它的字典。
    字典中的键必须唯一 字典中,不支持同一个键出现多次,否则只会保留最后一个键值对。
    字典中的键必须不可变 字典中每个键值对的键是不可变的,只能使用数字、字符串或者元组,不能使用列表。

            列表(list)和元组(tuple)比较相似,它们都按顺序保存元素,所有的元素占用一块连续的内存,每个元素都有自己的索引,因此列表和元组的元素都可以通过索引(index)来访问。它们的区别在于:列表是可以修改的,而元组是不可修改的。字典(dict)和集合(set)存储的数据都是无序的,每份元素占用不同的内存,其中字典元素以key-value的形式保存。

    4 字典 dict

            字典(dict)是一种无序的、可变的序列,它的元素以“键值对(key-value)”的形式存储。字典中的键是惟一的(其他类型的映射也是如此),但值并不唯一。键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行。字典是支持无限极嵌套的。

    4.1 基本操作

    1. 使用{}创建字典

            每个键和它的值之间用冒号(:) 隔开,项之间用逗号(,)隔开,而整个字典是由一对大括号括起来。空字典(不包括任何项)由大括号组成,像这样: {}。语法格式如下:

    dictname = {“key”:“value1”, ‘key2’:‘value2’, …, ‘keyn’:valuen}
    dictname 表示字典变量名,keyn : valuen 表示各个元素的键值对。需要注意的是,同一字典中的各个键必须唯一,不能重复。

    1. 通过fromkeys()方法创建字典

            字典类型提供的fromkeys()方法创建带有默认值的字典,具体格式为:

    dictname = dict.fromkeys(list, value=None)
    list参数表示字典中所有键的列表(list);value参数表示默认值,如果不写,则为空值None

    1. 通过dict()映射函数创建字典
    # 创建空字典
    emptyDict = {} # empythDict = dict()
    # str 表示字符串类型的键,value 表示键对应的值。使用此方式创建字典时,字符串不能带引号
    newdict1 = dict(str1=value1, str2=value2, str3=value3)
    
    # 向 dict() 函数传入列表或元组,而它们中的元素又各自是包含 2 个元素的列表或元组,其中第一个元素作为键,第二个元素作为值
    demo1 = [('a',97), ('b',98), ('c',99)]
    demo2 = [['a',97], ['b',98], ['c',99]]
    demo3 = (('a',97), ('b',98), ('c',99))
    demo4 = (['a',97], ['b',98], ['c',99])
    newdict2 = dict(demo)
    
    # 通过应用 dict() 函数和 zip() 函数,可将前两个列表转换为对应的字典
    keys = ['a', 'b', 'c']
    values = [87, 98, 99]
    newdict3 = dict(zip(keys, values))
    

            温馨提示: 无论采用以上哪种方式创建字典,字典中各元素的键都只能是字符串、元组或数字,不能是列表。列表是可变的,不能作为键。

    1. 访问字典

            列表和元组是通过下标来访问元素的,而字典不同,它通过键来访问对应的值。因为字典中的元素是无序的,每个元素的位置都不固定,所以字典也不能像列表和元组那样,采用切片的方式一次性访问多个元素。可以通过键名(key)访问,该键是必须存在的,否则会抛出异常。

    >>> letter_code = {"A":65, "B":66, "C":67}
    >>> print(letter_code['A'])
    65
    

            除了上面这种方式外,Python更推荐使用dict类型提供的get()方法来获取指定键对应的值。当指定的键不存在时,get()方法不会抛出异常,默认返回None

    >>> letter_code = {"A":65, "B":66, "C":67}
    >>> print(letter_code.get('D'))
    None
    >>> print(letter_code.get('D', "此键不存在"))
    此键不存在
    
    1. 删除字典

            和删除列表、元组一样,手动删除字典也可以使用del关键字,Python自带垃圾回收功能,会自动销毁不用的字典,所以一般不需要通过del来手动删除。

    letter_code = {"A":65, "B":66, "C":67}
    del letter_code['B']  # 删除键"B"
    letter_code.clear()	  # 清空字典
    del letter_code  	  # 删除字典 
    
    1. 添加键值对

            为字典添加新的键值对很简单,直接给不存在的 key 赋值即可。

    1. 修改键值对

            Python字典中键(key)的名字不能被修改,只能修改值(value)。字典中各元素的键必须是唯一的,因此,如果新添加元素的键与已存在元素的键相同,那么键所对应的值就会被新的值替换掉,以此达到修改元素值的目的。

            如果要删除字典中的键值对,还是可以使用del语句。如果要判断字典中是否存在指定键值对,首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键,可以使用innot in运算符。

    4.2 常用方法

    keys()、values()、items()

    • keys()方法用于返回字典中的所有键(key);
    • values()方法用于返回字典中所有键对应的值(value);
    • items()用于返回字典中所有的键值对(key-value)。
    >>> letter_code = {"A":65, "B":66, "C":67}
    >>> print(letter_code.keys())
    dict_keys(['A', 'B', 'C'])
    >>> print(letter_code.values())
    dict_values([65, 66, 67])
    >>> print(letter_code.items()) 
    dict_items([('A', 65), ('B', 66), ('C', 67)])
    

            keys()values()items()返回值的类型分别为dict_keysdict_valuesdict_items。为了操作这些返回值,我们可以使用list()函数,将返回的数据转换成列表,也可以使用for...in...循环遍历返回值。

            同样可以使用字典推导式可以快速生成字典。

            Python字典包含的其他内置方法如下表所示:

    表 4 Python 字典包含的方法
    序号函数描述
    1radiansdict.clear()删除字典内所有元素
    2radiansdict.copy()返回一个字典的浅复制
    3radiansdict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
    4radiansdict.get(key, default=None)返回指定键的值,如果键不在字典中返回 default 设置的默认值
    5key in dict如果键在字典dict里返回true,否则返回false
    6radiansdict.items()以列表返回一个视图对象
    7radiansdict.keys()返回一个视图对象
    8radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
    9radiansdict.update(dict2)把字典dict2的键/值对更新到dict里
    10radiansdict.values()返回一个视图对象
    11radiansdict.pop(key[,default])删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
    12 radiansdict.popitem()随机返回并删除字典中的最后一对键和值。

    5 集合 set

            Python 中的集合,和数学中的集合概念一样,用来保存不重复的元素,即集合中的元素都是唯一的,互不相同。从形式上看,和字典类似,Python 集合会将所有元素放在一对大括号{}中,相邻元素之间用“,”分隔。从内容上看,同一集合中,只能存储不可变的数据类型,包括整形、浮点型、字符串、元组,无法存储列表、字典、集合这些可变的数据类型,否则Python解释器会抛出TypeError错误。

            温馨提示: 集合对于每种数据元素,只会保留一份。在Python中集合是无序的,每次输出时元素的排序顺序可能都不相同。

            Python中有两种集合类型,一种是set类型的集合,另一种是frozenset类型的集合,它们唯一的区别是,set类型集合可以做添加、删除元素的操作,而forzenset类型集合不行。

    5.1 基本操作

    1. 创建集合
            使用{}创建,直接将集合赋值给变量,也可以使用内置函数set(),其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。

    >>> newSet = {1, 'a', (1, 2, 3), [1, 2]}
    >>> set1 = set("python")
    >>> set2 = set([1, 2, 3, 4])
    >>> set3 = set((1, 2, 3, 4))
    

            温馨提示: 如果要创建空集合,只能使用set()函数实现。因为直接使用一对{}Python解释器会将其视为一个空字典。
    2. 访问元素

            由于集合中的元素是无序的,因此无法向列表那样使用下标访问元素。Python中,访问集合元素最常用的方法是使用循环结构,将集合中的数据逐一读取出来。

    setNew = {1, 2, 'a', (1, 2, 3), [1, 2]}
    for element in setNew:
    	print(element, end=' ')
    

    3. 删除集合

            和其他序列类型一样,也可以使用del()语句。

    4. 添加元素

            s.add(x)将元素 x x x 添加到集合 s s s 中,如果元素已存在,则不进行任何操作。s.update(x)也可以添加元素,且参数可以是列表,元组,字典等。

    >>> set1 = set(("Python", "C++", "PHP"))
    >>> set1.add("SQL")
    >>> print(set1)
    {'C++', 'PHP', 'SQL', 'Python'}
    >>> set1.update(["C#", "Go"], ["Java'])
    >>>print(set1)
    {'Go', 'PHP', 'SQL', 'C#', 'C++', 'Java', 'Python'}
    

    5. 删除元素

            s.remove(x)将元素 x x x 从集合 s s s 中移除,如果元素不存在,则会发生错误。s.discard(x)也可以移除集合中的元素,且如果元素不存在,不会发生错误。s.pop()可以设置随机删除集合中的一个元素。

    >>> program_set = {"Python", "Java", "C++", "PHP"}
    >>> program_set.remove("C++")
    >>> print(program_set)
    {'PHP', 'Java', 'Python'}
    >>> program_set.discard("C++")
    >>> program_set.pop()
    'PHP'
    

    6. 集合运算

            集合最常做的操作就是进行交集、并集、差集以及对称差集运算。

    操作符及应用描述
    set1 | set2并,返回一个新集合,包括在集合set1set2中的所有元素
    set1 - set2差,返回一个新集合,包括在集合set1但不在set2中的元素
    set1 & set2交,返回一个新集合,包括同时在集合set1set2中的元素
    set1 ^ set2补,返回一个新集合,包括集合set1set2中的非相同元素
    set1<=set2set1 < set2返回True/False,判断set1set2的子集关系
    set1 >= set2set1>set2返回True/False,判断set1set2的包含关系
    set1 |= set2并,更新集合set1,包括在集合set1set2中的所有元素
    set1 -= set2差,更新集合set1,包括在集合set1但不在set2中的元素
    set1 &= set2交,更新集合set1,包括同时在集合set1set2中的元素
    set1 ^= set2补,更新集合set1,包括集合set1set2中的非相同元素

    5.2 常用方法

    表 5 Python 集合包含的方法
    方法描述
    add()为集合添加元素
    clear()移除集合中的所有元素
    copy()拷贝一个集合
    difference()返回多个集合的差集
    difference_update()移除集合中的元素,该元素在指定的集合也存在。
    discard()删除集合中指定的元素
    intersection()返回集合的交集
    intersection_update() 返回集合的交集。
    isdisjoint()判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。
    issubset()判断指定集合是否为该方法参数集合的子集。
    issuperset()判断该方法的参数集合是否为指定集合的子集
    pop()随机移除元素
    remove()移除指定元素
    symmetric_difference()返回两个集合中不重复的元素集合。
    symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。
    union()返回两个集合的并集
    update()给集合添加元素

            温馨提示: set集合是可变序列,程序可以改变序列中的元素;frozenset集合是不可变序列,程序不能改变序列中的元素。当集合的元素不需要改变时,我们可以使用fronzenset替代set,这样更加安全。有时候程序要求必须是不可变对象,这个时候也要使用fronzenset替代set。比如,字典(dict)的键(key)就要求是不可变对象。

    6 字符串 str

            字符串是Python中最常用的数据类型。我们可以使用引号('")来创建字符串。Python不支持单字符类型,单字符在Python中也是作为一个字符串使用。

    6.1 拼接

            在Python中拼接(连接)字符串很简单,可以直接将两个字符串紧挨着写在一起,会自动将两个字符串拼接在一起。具体格式为:

    >>> word = "Hello" "World"
    >>> print(word)
    HelloWorld
    

            上面的写法主要针对字符串常量,如果需要使用变量,就得借助+运算符来拼接。在很多应用场景中,我们需要将字符串和数字拼接在一起,而Python不允许直接拼接数字和字符串,所以我们必须先将数字转换成字符串。可以借助str()repr()函数将数字转换为字符串。

    • str(): 函数返回一个用户易读的表达形式。
    • repr(): 产生一个解释器易读的表达形式。
    >>>  name = "python"
    >>> str(name)
    'python'
    >>> repr(name)
    "'python'"
    

    6.2 切片

            字符串是由多个字符构成的,字符之间是有顺序的,这个顺序号就称为索引(index)。Python允许通过索引来操作字符串中的单个或者多个字符,比如获取指定索引处的字符,返回指定字符的索引值等。可以参考第一部分序列的切片。

    >>> var1 = "Hello World!"
    >>> print("var1[0]:", var1[0])
    var1[0]:H
    >>> var2 = "no"
    >>> print("reverse order:", var2[::-1])
    on
    

    6.3 常用函数

    1. len()

            想知道一个字符串有多少个字符(获得字符串长度),或者一个字符串占用多少个字节,可以使用len()函数。

            在实际开发中,除了常常要获取字符串的长度外,有时还要获取字符串的字节数。

            在Python中,不同的字符所占的字节数不同,数字、英文字母、小数点、下划线以及空格,各占一个字节,而一个汉字可能占2~4个字节,具体占多少个,取决于采用的编码方式。例如,汉字在GBK/GB2312编码中占用 2 个字节,而在UTF-8编码中一般占用 3 个字节。

    2. split()

            split()方法可以实现将一个字符串按照指定的分隔符切分成多个子串,这些子串会被保存到列表中(不包含分隔符),作为方法的返回值反馈回来。该方法的基本语法格式如下:

    str.split(seq, maxsplit)

    • str: 表示要进行分割的字符串;
    • sep:用于指定分隔符,可以包含多个字符。此参数默认为None,表示所有空字符,包括空格、换行符“\n”、制表符“\t”等。
    • maxsplit:可选参数,用于指定分割的次数,最后列表中子串的个数最多为maxsplit+1。如果不指定或者指定为 -1,则表示分割次数没有限制。
    >>> string = " I $ love $ Python"
    >>> print(string.split())
    ['I', '$', 'love', '$', 'Python']
    >>> print(string.split('$'))
    [' I ', ' love ', ' Python']
    

            温馨提示: 在未指定sep参数时,也不能指定maxsplit参数,split()方法默认采用空字符进行分割,但当字符串中有连续的空格或其他空字符时,都会被视为一个分隔符对字符串进行分割。
    3. jion()

            join()方法也是非常重要的字符串方法,它是split()方法的逆方法,用来将列表(或元组)中多个字符串采用固定的分隔符连接在一起。语法格式如下:

    newstr = str.join(iterable)

    • newstr:表示合并后生成的新字符串;
    • str:用于指定合并时的分隔符;
    • iterable:做合并操作的源字符串数据,允许以列表、元组等形式提供。
    >>> list = ["www", "baidu", "com"]
    >>> print('.'.join(list))
    www.baidu.com
    >>> dir = '', 'usr', 'bin', 'env'
    >>> type(dir)
    <class 'tuple'>
    >>> print('/'.join(dir))
    /usr/bin/env
    

    4. count()

            count()方法用于检索指定字符串在另一字符串中出现的次数,如果检索的字符串不存在,则返回 0,否则返回出现的次数。语法格式如下:

    str.count(sub[,start[,end]])

    • str:表示原字符串;
    • sub:表示要检索的字符串;
    • start:指定检索的起始位置,也就是从什么位置开始检测。如果不指定,默认从头开始检索;
    • end:指定检索的终止位置,如果不指定,则表示一直检索到结尾。
    >>> var1 = "/usr/bin/env"
    >>> var1.count('/')
    3
    

    5. find()

            find()方法用于检索字符串中是否包含目标字符串,如果包含,则返回第一次出现该字符串的索引;反之,则返回 -1。语法格式如下:

    sr.find(sub[,start[,end]])`

    • str:表示原字符串;
    • sub:表示要检索的目标字符串;
    • start:表示开始检索的起始位置。如果不指定,则默认从头开始检索;
    • end:表示结束检索的结束位置。如果不指定,则默认一直检索到结尾。
    >>> var1 = "python"
    >>> var1.find('n')
    5
    

            温馨提示: Python还提供了rfind()方法,与find()方法最大的不同在于,rfind()是从字符串右边开始检索。

    6. index()

            同find()方法类似,index()方法也可以用于检索是否包含指定的字符串,不同之处在于,当指定的字符串不存在时,index()方法会抛出异常。语法格式如下:

    str.index(sub[,start[,end]])

    • str:表示原字符串;
    • sub:表示要检索的子字符串;
    • start:表示检索开始的起始位置,如果不指定,默认从头开始检索;
    • end:表示检索的结束位置,如果不指定,默认一直检索到结尾。

            温馨提示:find()rfind()一样,字符串变量还具有rindex()方法,其作用和index()方法类似,不同之处在于它是从右边开始检索。

    7. ljust()

            ljust()方法的功能是向指定字符串的右侧填充指定字符,从而达到左对齐文本的目的。基本格式如下:

    str.ljust(width[,fillchar])

    • str:表示要进行填充的字符串;
    • width:表示包括str本身长度在内,字符串要占的总长度;
    • fillchar:作为可选参数,用来指定填充字符串时所用的字符,默认情况使用空格。
      rjust()ljust()方法类似,唯一的不同在于,rjust()方法是向字符串的左侧填充指定字符,从而达到右对齐文本的目的。center()字符串方法与ljust()rjust()的用法类似,但它让文本居中,而不是左对齐或右对齐。
    >>> var1 = "python"
    >>> print(var1.rjust(10, '-'))
    ----python
    >>> print(var1.ljust(10, '-'))
    python----
    >>> print(var1.center(10, '-'))
    --python--
    

    8. 格式检查

            startswith()方法用于检索字符串是否以指定字符串开头,如果是返回True;反之返回Falseendswith()方法用于检索字符串是否以指定字符串结尾,如果是则返回True;反之则返回False。语法格式如下:

    str.startswith(sub[,start[,end]])

    • str:表示原字符串;
    • sub:要检索的子串;
    • start:指定检索开始的起始位置索引,如果不指定,则默认从头开始检索;
    • end:指定检索的结束位置索引,如果不指定,则默认一直检索在结束。
    >>> var1 = "www.baidu.com"
    >>> var1.startswith("http")
    False
    >>> var1.endswith("com")
    True
    

    9. 大小写转换

            为了方便对字符串中的字母进行大小写转换,字符串变量提供了 3 种方法,分别是title()lower()upper()

    • title()方法用于将字符串中每个单词的首字母转为大写,其他字母全部转为小写,转换完成后,此方法会返回转换得到的字符串。如果字符串中没有需要被转换的字符,此方法会将字符串原封不动地返回。
    • lower()方法用于将字符串中的所有大写字母转换为小写字母,转换完成后,该方法会返回新得到的字符串。如果字符串中原本就都是小写字母,则该方法会返回原字符串。
    • upper()的功能和lower()方法恰好相反,它用于将字符串中的所有小写字母转换为大写字母,和以上两种方法的返回方式相同,即如果转换成功,则返回新字符串;反之,则返回原字符串。
    >>> var1 = "l like python"
    >>> var1.title()
    'L Like Python'
    >>> var1.lower()
    'l like python'
    >>> var1.upper()
    'L LIKE PYTHON'
    

            温馨提示: 以上 3 个方法都仅.限于将转换后的新字符串返回,而不会修改原字符串。

    10. 去空格

            用户输入数据时,很有可能会无意中输入多余的空格,或者在一些场景中,字符串前后不允许出现空格和特殊字符,此时就需要去除字符串中的空格和特殊字符。(特殊字符,指的是制表符(\t)、回车符(\r)、换行符(\n)等)

            字符串变量提供了 3 种方法来删除字符串中多余的空格和特殊字符,它们分别是:

    • strip():删除字符串前后(左右两侧)的空格或特殊字符。
    • lstrip():删除字符串前面(左边)的空格或特殊字符。
    • rstrip():删除字符串后面(右边)的空格或特殊字符。
    >>> var1 = "\r python \t is so easy \n"
    >>> var1.strip()
    'python \t is so easy'
    >>> var1.lstrip()
    'python \t is so easy \n'
    >>> var1.rstrip()
    '\r python \t is so easy'
    >>> var1.strip('\r')
    ' python \t is so easy \n'
    

            温馨提示: 注意,Pythonstr是不可变的(不可变的意思是指,字符串一旦形成,它所包含的字符序列就不能发生任何改变),因此这三个方法只是返回字符串前面或后面空白被删除之后的副本,并不会改变字符串本身。

            在python3.6之后版本添加了f-string,称之为字面量格式化字符串,是新的格式化字符串的语法。f-string格式化字符串以f开头,后面跟着字符串,字符串中的表达式用大括号{}包起来,它会将变量或表达式计算后的值替换进去,实例如下:

    >>> name = "python"
    >>> f'hello {name}'
    'hello python'
    >>> x = 1 
    >>> print(f'{x+1=}')
    x+1=2
    

    Python 的字符串常用内建函数如下:

    表 6 Python 字符串包含的方法
    序号方法描述
    1

    capitalize()

    将字符串的第一个字符转换为大写
    2

    center(width, fillchar)

    返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。
    3

    count(str, beg= 0,end=len(string))

    返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
    4

    bytes.decode(encoding="utf-8", errors="strict")

    Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。
    5

    encode(encoding='UTF-8',errors='strict')

    以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace'
    6

    endswith(suffix, beg=0, end=len(string))

    检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.
    7

    expandtabs(tabsize=8)

    把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。
    8

    find(str, beg=0, end=len(string))

    检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1
    9

    index(str, beg=0, end=len(string))

    跟find()方法一样,只不过如果str不在字符串中会报一个异常。
    10

    isalnum()

    如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
    11

    isalpha()

    如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
    12

    isdigit()

    如果字符串只包含数字则返回 True 否则返回 False..
    13

    islower()

    如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False
    14

    isnumeric()

    如果字符串中只包含数字字符,则返回 True,否则返回 False
    15

    isspace()

    如果字符串中只包含空白,则返回 True,否则返回 False.
    16

    istitle()

    如果字符串是标题化的(见 title())则返回 True,否则返回 False
    17

    isupper()

    如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False
    18

    join(seq)

    以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
    19

    len(string)

    返回字符串长度
    20

    ljust(width[, fillchar])

    返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。
    21

    lower()

    转换字符串中所有大写字符为小写.
    22

    lstrip()

    截掉字符串左边的空格或指定字符。
    23

    maketrans()

    创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。
    24

    max(str)

    返回字符串 str 中最大的字母。
    25

    min(str)

    返回字符串 str 中最小的字母。
    26

    replace(old, new [, max])

    把 将字符串中的 old 替换成 new,如果 max 指定,则替换不超过 max 次。
    27

    rfind(str, beg=0,end=len(string))

    类似于 find()函数,不过是从右边开始查找.
    28

    rindex( str, beg=0, end=len(string))

    类似于 index(),不过是从右边开始.
    29

    rjust(width,[, fillchar])

    返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
    30

    rstrip()

    删除字符串末尾的空格或指定字符。
    31

    split(str="", num=string.count(str))

    以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串
    32

    splitlines([keepends])

    按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
    33

    startswith(substr, beg=0,end=len(string))

    检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。
    34

    strip([chars])

    在字符串上执行 lstrip()和 rstrip()
    35

    swapcase()

    将字符串中大写转换为小写,小写转换为大写
    36

    title()

    返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
    37

    translate(table, deletechars="")

    根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 deletechars 参数中
    38

    upper()

    转换字符串中的小写字母为大写
    39

    zfill (width)

    返回长度为 width 的字符串,原字符串右对齐,前面填充0
    40

    isdecimal()

    检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。

            对于上面这么多函数记不住怎么办,可以使用dir()函数用来列出某个类或者某个模块中的全部内容,包括变量、方法、函数和类等;help()函数用来查看某个函数或者模块的帮助文档。用dir(str)查看字符串类型(str)支持的所有方法,用help(str.lower)查看str类型中lower()函数的用法,注意使用help()查看某个函数的用法时,函数名后边不能带括号。

            对于上面序列的操作,了解各个函数的时间复杂度,可以参考:https://wiki.python.org/moin/TimeComplexity

    表7 列表、元组、字典、集合和字符串的区别
    数据结构是否可变是否重复是否有序定义符号
    列表(list)可变可重复有序[]
    元组(tuple)不可变可重复有序()
    字典(dictionary)可变可重复无序{key:value}
    集合(set)可变不可重复无序{}
    字符串(string)不可变可重复有序""
    展开全文
  • 1.1 列表(list): 1.2 元组(tuple): 1.3 字典(dict ): 1.4 集合(set): 2.创建 2.1 创建列表 2.2 创建元组 2.2 创建字典 2.4 创建集合 3.查找 3.1 查找列表元素 3.2 查找元组元素 3.3 查找...
  • python中的复合数据类型-----列表 元组 集合 字典shu 在复合数据类型中可以存储多种数据类型 一.列表 列表的定义: 全局函数:list() a = list() 符号: a = [ ] 列表种常用的方法: append() -------- 向...
  • 列表list定义符号:[]创建:[]直接创建 , list()可变性:可变是否有序:有序元素是否重复:可以重复切片:支持切片索引:支持索引访问:索引访问删除:del()list.remove(value)list.pop()修改插入:list[]=append()...
  • 1.列表元组字典是有顺序的,而集合是没顺序的 2.列表是以方括号形式表示,元组是以圆括号表示,字典以花括号表示,集合则是以[()]的形式表示 3.列表是可变对象,它支持在原处修改的操作.也可以通过指定的索引和分...
  • 列表list:[1,2,3] [a,b,c] [‘myss’,{2},(1,3),[‘c’,2],{65:‘A’}] 【所有元素放在一对方括号中,元素之间使用逗号分隔,其中的元素可以是任意类型】 元组tuple:(1,2,3) (1,) 【所有元素放在一对圆括号中,...
  • 列表_元组_集合_字典_增 ''' 列表: append(ele):在最后边添加一个元素 extend(list):在最后边添加一个列表 insert(index,ele):在指定位置处添加一个元素 集合: add(ele):由于它无序不重复,在随机位置添加一个...
  • 列表元组字典集合的异同 1.list: (1)可以用list()函数或者方括号[]创建,元素之间用逗号’,‘’分隔; (2)列表的元素不需要具有相同的类型,可以是多种类型; (3)使用索引来访问元素; (4)可...
  • python(列表元组字典)详解

    千次阅读 2021-08-10 16:53:06
    列表的定义in、max、min在列表中的使用初识元组元组定义列表元组的区别初识字典字典的结构与创建方法字典支持的数据类型 什么是列表列表就是队列 是各种数据类型的集合,也是一种数据结构! 列表是一种有序的...
  • 列表元组字典集合,都用于存放数据,它们区别总结如下: 项目 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 ...
  • Python中字符串、列表元组字典

    千次阅读 2021-02-03 10:58:35
    1.字符串字符串四种定义方式:' ' " " ''' ''' """ """字符串的下标和切片:如: name = abcdef从最左边数是从0下标开始,从最右边数是从-1开始...列表定义列表语法:变量名 = [元素1,元素2,元素3……]列表的增删改...
  • 1、列表 列表:使用方括号将用逗号分隔不同的数据项括起来。 可以存储不同类型的数据。 list = [1,‘a’,[1,2 ],“python”] 创建列表 list = [obj0,obj1] list1 = [1,2,3] list2 = ["C","python","java"] list3 = ...
  • 本文主要介绍Python中的几种常见数据结构。其中包括序列、元组列表集合字典
  • 一文看懂系列:元组列表字典集合究竟怎么学 一、数据结构 1、元组 含义:元组是一种固定长度、不可变的Python对象序列。虽然对象元组中存储的对象其自身是可变的,但是元组一旦创建,各个位置上的对象是...
  • 一、集合 1.定义: 集合是多个元素的无序组合,它和数学中的集合概念一致。用大括号:{}表示,元素之间使用逗号分隔。 注: (1).集合各个元素之间是没有顺序的,每个元素...但是列表是可变的。 (3). 建立集合...
  • 定义符号 列表(list) 可变 可以重复 有序 [ ] 元组(tuple) 不可变 可以重复 有序 ( ) 字典(dictionary) 可变 可重复 无序 {key:value} 集合 可变 不可重复...
  • ----列表集合字典排序sorted ----字符串、列表集合元组字典比较集合求差集、交集、并集并集交集差集数据转换:字典格式的字符串/ json对象转为字典两个列表/元组/集合 转为字典字典转为列表/元组/集合嵌套...
  • 列表元组字典集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。1.列表(List)什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周...
  • 列表元组字典

    2020-12-12 13:42:23
    列表元组字典 1. 通用序列操作 Pyhton中有六种内置序列:列表元组、字符串、Unicode字符串、buffer对象和xrange对象,其中列表元组和字符串这三种序列是最常见的。 Python中的大部分序列都可以进行通用操作...
  • Python_基础语法_组合数据类型_列表_元组_字典_集合
  • Python 列表/元组/字典总结

    千次阅读 2020-11-28 18:31:08
    Python有6个序列的内置类型,但最常见的是列表元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型...
  • 列表内的每一个数据,称为元素。列表以[]作为标识,其中的元素之间用,隔开。#字面量 [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] #定义变量 变量名称 = [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] #定义空...
  • 列表是处理一组有序的数据结构,可以读写,添加和删除,或者搜索列表里的元素。因为可以添加和删除,所以称为可变的数据类型,即这种类型是可以被改变的,并且列表可以嵌套。 res = [1,2,'yihang'] #增加元素:...
  • PYTHON:列表元组字典、字符串的详细笔记(超详细)
  • l = ['Michael','Bob','Tracy'] l.append('Bob') l.pop() print(1) t = ('Michael','Bob','Tracy') scores = [85,65,55] d = {'Michael':85,'Bob':65,'Tracy':55} d['Bob'] = 82 ......
  • 列表元组字典集合的区别 数据结构 是否可变 是否重复 是否有序 定义符号 列表(list) 可变 可重复 有序 [ ] 元组(tuple) 不可变 可重复 有序 ( ) 字典...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,697
精华内容 7,878
关键字:

列表集合元组字典符号