精华内容
下载资源
问答
  • 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后 一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 python 常见序列对比: 比较项 列表 元组 字典 集合 类型...

    Python序列类似于其他语言中的数组,但功能要强大很多。

    Python中常用的序列结构有列表、元组、字符串,字典、集合以及range等对象也支持很多类似的操作。

    列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后 一个元素下标为-1,倒数第二个元素下标为-2,以此类推。

    python 常见序列对比:

    比较项 列表 元组 字典 集合
    类型名称 list tuple dict set
    定界符 方括号[] 圆括号() 大括号{} 大括号 {}
    是否可变
    是否有序
    是否支持下标 是(使用序号作为 下标) 是(使用序号作 为下标) 是(使用“键”作为下标)
    元素分隔符 逗号 逗号 逗号 逗号
    对元素形式的要求 键:值 必须可哈希
    对元素值的要求 必须可哈希 必须可哈希
    元素是否可重复 “键”不允许重 复,“值”可以重复
    元素查找速度 非常慢 很慢 非常快 非常快
    新增和删除元素速度 尾部操作快,其他位置慢 不允许

    列表

    • 列表是Python中内置有序、可变序列,列表的所有元素放在一对中括号“[]”中,并使用逗号分 隔开;
    • 当列表元素增加或删除时,列表对象自动进行扩展或收缩内存,保证元素之间没有缝隙;
    • 在Python中,一个列表中的数据类型可以各不相同,可以同时分别为整数、实数、字符串等基 本类型,甚至是列表、元组、字典、集合以及其他自定义类型的对象。

    列表常用方法:

    方法 说明
    lst.append(x) 将元素x添加至列表lst尾部
    lst.extend(L) 将列表L中所有元素添加至列表lst尾部
    lst.insert(index, x) 在列表lst指定位置index处添加元素x,该位置后面的所有元素后移 一个位置
    lst.remove(x) 在列表lst中删除首次出现的指定元素,该元素之后的所有元素前移一 个位置
    lst.pop([index]) 删除并返回列表lst中下标为index(默认为-1)的元素
    lst.clear() 删除列表lst中所有元素,但保留列表对象
    lst.index(x) 返回列表lst中第一个值为x的元素的下标,若不存在值为x的元素则 抛出异常
    lst.count(x) 返回指定元素x在列表lst中的出现次数
    lst.reverse() 对列表lst所有元素进行逆序
    lst.sort(key=None, reverse=False) 对列表lst中的元素进行排序,key用来指定排序依据,reverse决定 升序(False)还是降序(True)
    lst.copy() 返回列表lst的浅复制
    • lst.reverse(),lst.sort()

      >>> arr = list(range(10))
      >>> arr
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> arr.reverse()					#逆序
      >>> arr 	
      [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
      >>> arr.sort()						#排序
      >>> arr
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      

    浅复制,浅层次的复制,深复制

    >>> arr = [1,2,3]
    >>> arr = [1,2,3]
    >>> arr1 = arr                   # 直接赋值 arr 和 arr1 共用内存  也就是说他们还是一个
    >>> id(arr),id(arr1)
    (2909054945928, 2909054945928)
    >>> arr1[0] = 123
    >>> arr                          #修改一个另一个也会改变
    [123, 2, 3]
    >>> arr2 = arr.copy()            #浅复制,
    >>> id(arr),id(arr2)             #不共用内存了
    (2909054945928, 2909053356424)   
    >>> arr2[0]=321					#修改一个另一个不会改变
    >>> arr
    [123, 2, 3]
    >>> arr = [[1],2,3]				#但是列表里面有可变序列时,可变序列改变 原来的也会改变
    >>> arr2 = arr.copy()
    >>> arr2[0].append(2)
    >>> arr							#在arr2里添加,arr里面也有了
    [[1, 2], 2, 3]
    >>> import copy					#标准库copy
    >>> arr
    [[1, 2], 2, 3]
    >>> arr3 = copy.deepcopy(arr)    #深复制
    >>> arr3
    [[1, 2], 2, 3]          
    >>> arr3[0].pop() 					#arr3内层序列改变  arr不受影响
    2
    >>> arr								
    [[1, 2], 2, 3]
    

    列表的索引:

    • 下标索引
    >>> arr = list(range(20))
    >>> arr
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    >>> arr[2]
    2
    >>> arr[0]
    0
    >>> arr[-2]   #可以双向来
    18
    
    • 切片
      • 切片适用于列表、元组、字符串、range对象等类型,但作用于列表时功能强大。可以使用切片来截取列表中的任何部分,得到一个新列表,也可以通过切片来修改和删除列表中部分元素,甚至可以通过切片操作为列表对象增加元素。
      • 切片使用2个冒号分隔的3个数字来完成:[start: end: step]
        1. 第一个数字表示切片开始位置(默认为0)。
        2. 第二个数字表示切片截止(但不包含)位置(默认为列表长度)。
        3. 第三个数字表示切片的步长(默认为1),当步长省略时可以顺便省略后一个冒号
      • 切片操作不会因为下标越界而抛出异常,而是简单地在列表尾部截断或者返回一个空列表,代码具有更强的健壮性。
    >>> lit = list(range(5))
    >>> lit
    [0, 1, 2, 3, 4]
    >>> lit[1:]
    [1, 2, 3, 4]
    >>> lit[:3]
    [0, 1, 2]
    >>> lit[:-3]
    [0, 1]
    >>> lit[1::2]
    [1, 3]
    >>> lit[:3:2]
    [0, 2]
    >>> lit[1::2]=[111,111]
    >>> lit							#可以使用切片来原地修改列表内容
    [0, 111, 2, 111, 4]
    
    >>> lit2 = lit[::]              #切片返回的是列表元素的浅复制
    >>> lit2
    [0, 111, 2, 111, 4]
    >>> lit2[1]=222
    >>> lit
    [0, 111, 2, 111, 4]
    >>> lit2
    [0, 222, 2, 111, 4]
    

    列表推导式

    列表推导式使用非常简洁的方式来快速生成满足特定需求的列表,代码具有非常强的可读性。

    列表推导式语法形式为:
    [expression for expr1 in sequence1 if condition1
                for expr2 in sequence2 if condition2
                for expr3 in sequence3 if condition3
                ...
                for exprN in sequenceN if conditionN]
    

    列表推导式在内部实际上是一个循环结构,只是形式更加简洁,例如:

    >>> aList = [x*x for x in range(10)]
    >>> aList
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    使用列表推导式实现嵌套列表的平铺:

    >>> vec = [[1,2,3], [4,5,6], [7,8,9]] 
    >>> [num for elem in vec for num in elem] 
    [1, 2, 3, 4, 5, 6, 7, 8, 9] 
    

    再如取偶数:

    >>> arr = list(range(10))
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> [i for i in arr if i%2==0]
    [0, 2, 4, 6, 8]
    >>> [i for i in range(30) if i%2==0]
    [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
    

    元组

    • 元组和列表类似,但属于不可变序列,元组一旦创建,用任何方法都不可以修改其元素。

    • 元组的定义方式和列表相同,但定义时所有元素是放在一对圆括号“()”中,而不是方括号中。

      列表和元组的区别

      1. 列表是动态数组,他们可变且可以重设长度(改变其内部元素的个数)。
      2. 元组是静态数组,他们不可变,且其内部数据一旦创建便无法改变。
      3. 元组缓存与Python运行时环境,这意味着我们每次使用元组时无须动态访问内核去分配内存。

      列表和元组都可以接受混合类型。

      >>> t = tuple(range(5))
      >>> t
      (0, 1, 2, 3, 4)
      >>> t[1]=22
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: 'tuple' object does not support item assignment
      

    生成器推导式

    生成器推导式的结果是一个生成器对象。使用生成器对象的元素时,可以根据需要将其转化为列表或元组,也可以使用生成器对象__next__()方法或内置函数next()进行遍历,或者直接将其作为迭代器对象来使用。

    生成器对象具有惰性求值的特点,只在需要时生成新元素,比列表推导式具有更高的效率,空间占用非常少,尤其适合大数据处理的场合。

    不管用哪种方法访问生成器对象,都无法再次访问已访问过的元素。

    >>> g = (i for i in range(10))
    >>> next(g)
    0
    >>> next(g)
    1
    >>> g.__next__()
    2
    >>> list(g)
    [3, 4, 5, 6, 7, 8, 9]
    >>> g = (i for i in range(10))
    >>> 5 in g    #找到5时 3已经遍历过了  所以 下面找不到3
    True
    >>> 3 in g    #但会继续往下找  直到遍历了所有的元素
    False
    >>> 6 in g    #所有6也在上次查找时被遍历了
    False
    >>> g = (i for i in range(10))
    >>> 3 in g
    True
    >>> 5 in g
    True
    

    补充序列解包

    序列解包是Python中非常重要和常用的一个功能,可以使用非常简洁的形式完成复杂的功能,提高了代码可读性,减少了代码输入量。

    • 可以使用序列解包功能对多个变量同时赋值
    >>> x, y, z = 1, 2, 3
    >>> print(x,y,z)
    1 2 3
    >>> v_tuple = (4, 5, 6)
    >>> x, y, z = v_tuple
    >>> print(x,y,z)
    4 5 6
    >>> x, y, z = range(7,10)
    >>> print(x,y,z)
    7 8 9
    
    • 更多的使用
    >>> x, y, z = range(3)            #可以对range对象进行序列解包
    >>> x, y, z = iter([1, 2, 3])     #使用迭代器对象进行序列解包
    >>> x, y, z = map(str, range(3))  #使用可迭代的map对象进行序列解包
    >>> a, b = b, a                   #交换两个变量的值
    >>> x, y, z = sorted([1, 3, 2])   #sorted()函数返回排序后的列表
    >>> a, b, c = 'ABC'               #字符串也支持序列解包
    >>> x = [1, 2, 3, 4, 5, 6]
    >>> x[:3] = map(str,range(5))     #切片也支持序列解包
    >>> x
    ['0', '1', '2', '3', '4', 4, 5, 6]
    
    • 序列解包遍历多个序列
    >>> keys = ['a', 'b', 'c', 'd']
    >>> values = [1, 2, 3, 4]
    >>> for k, v in zip(keys, values):
    	  print((k, v), end=' ')
    
    ('a', 1) ('b', 2) ('c', 3) ('d', 4) 
    
    • 对字典也适用
    >>> s = {'a':1, 'b':2, 'c':3}
    >>> b, c, d = s.items()
    >>> b
    ('c', 3)
    >>> b, c, d = s
    >>> b
    'c'
    >>> b, c, d = s.values()
    >>> print(b, c, d)
    1 3 2
    

    字典

    • 字典是无序、可变序列。

    • 定义字典时,每个元素的键和值用冒号分隔,元素之间用逗号分隔,所有的元素放在一对大括号“{}”中。

    • 字典中的键可以为任意不可变数据,比如整数、实数、复数、字符串、元组等等。

      • globals()返回包含当前作用域内所有全局变量和值的字典
      • locals()返回包含当前作用域内所有局部变量和值的字典

      创建:

      >>> a_dict = {'one':1,'two':2,'three':3}
      >>> a_dict
      {'one': 1, 'two': 2, 'three': 3}
      >>> keys = list('abcde')
      >>> values = list(range(4))
      >>> dictionary = dict(zip(keys,values))
      >>> dictionary
      {'a': 0, 'b': 1, 'c': 2, 'd': 3}
      >>> x = dict()
      >>> x          #空字典
      {}
      >>> d = dict(name='Dong', age=37)    #使用键值创建字典
      >>> d
      {'name': 'Dong', 'age': 37}
      >>> adict = dict.fromkeys(['name','age','sex'])   #给定内容创建字典,值为空
      >>> adict
      {'name': None, 'age': None, 'sex': None}
      

      读取:

      >>> a_dict = {'one':1,'two':2,'three':3}
      >>> a_dict['one']     #根据键获取值
      1
      >>> a_dict['name']
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      KeyError: 'name'
      

      使用字典对象的get方法获取指定键对应的值,并且可以在键不存在的时候返回指定值

      >>> a_dict.get('one')
      1
      >>> a_dict.get('name','None')  #如果不存在 返回给定值
      'None'
      

      使用字典对象的items()方法可以返回字典的键、值对

      使用字典对象的keys()方法可以返回字典的键

      使用字典对象的values()方法可以返回字典的值

      >>> for k,g in a_dict.items():  #序列解包 
      ...     print(k)
      ...     print(g)
      ...
      one
      1
      two
      2
      three
      3
      >>> a_dict.keys()
      dict_keys(['one', 'two', 'three'])
      

      添加,修改

      当以指定键为下标为字典赋值时:

      1)若键存在,则可以修改该键的值;

      2)若不存在,则表示添加一个键、值对。

      >>> a_dict
      {'one': 1, 'two': 2, 'three': 3}
      >>> a_dict['one'] = 11     #修改
      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3}
      >>> a_dict['four'] = 4     #添加
      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3, 'four': 4}
      

      使用字典对象的update()方法将另一个字典的键、值对添加到当前字典对象。

      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3, 'four': 4}
      >>> b_dict = {'five': 5}
      >>> a_dict.update(b_dict)  #将b_dict加到a_dict中
      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
      
      • 使用del删除字典中指定键的元素
      • 使用字典对象的clear()方法来删除字典中所有元素
      • 使用字典对象的pop()方法删除并返回指定键的元素
      • 使用字典对象的popitem()方法删除并返回字典中的一个元素

      字典推导式

      >>> s = {str(x):x for x in range(4)}
      >>> s
      {'0': 0, '1': 1, '2': 2, '3': 3}
      

      注意 : 字典的键是可以哈希的,且键都是唯一的。不能为可变元素,如:列表。

    集合

    • 集合是无序、可变序列,使用一对大括号界定,元素不可重复,同一个集合中每个元素都是唯一的。

    • 集合中只能包含数字、字符串、元组等不可变类型(或者说可哈希)的数据,而不能包含列表、字典、集合等可变类型的数据。

      简单说集合就是没有值的字典。

      >>> a = {3, 5}
      >>> a
      {3, 5}
      >>> a.add(4)
      >>> a
      {3, 4, 5}
      >>> a = {3,3,2,4,4}
      >>> a
      {2, 3, 4}
      >>> set(range(3,8))
      {3, 4, 5, 6, 7}
      >>> set()
      set()
      
      • 当不再使用某个集合时,可以使用

        del命令删除整个集合。集合对象的

        pop()方法弹出并删除其中一个元素

        remove()方法直接删除指定元素,

        clear()方法清空集合。

        >>> a = {1,2,3,4}
        >>> a.pop()
        1
        >>> a.pop()
        2
        >>> a
        {3, 4}
        >>> a.add(2)
        >>> a
        {2, 3, 4}
        >>> a.remove(3)
        >>> a
        {2, 4}
        >>> a.clear()
        >>> a
        set()
        >>> del a
        >>> a
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        NameError: name 'a' is not defined
        

        Python集合支持交集,并集,差集等运算

        >>> a_set = set(range(8,14))
        >>> b_set = set(range(9))
        >>> a_set | b_set						#并集
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
        >>> a_set.union(b_set)
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
        >>> a_set & b_set						#交集
        {8}
        >>> a_set.intersection(b_set)
        {8}
        >>> a_set - b_set						#差集
        {9, 10, 11, 12, 13}
        >>> a_set.difference(b_set)
        {9, 10, 11, 12, 13}
        >>> {3} & {4}
        set()
        >>> {3}.isdisjoint({4})                #如果两个集合的交集为空,返回True
        True
        >>> x^y								#对称差
        {3, 5}
        >>> x.symmetric_difference(y)
        {3, 5}
        

        子集,真子集,包含

        >>> x = {1, 2, 3}
        >>> y = {1, 2, 5}
        >>> z = {1, 2, 3, 4}
        >>> x.issubset(y)                      #测试是否为子集
        False
        >>> x.issubset(z)
        True
        >>> x < y                                #比较集合大小/包含关系
        False
        >>> x < z                                #真子集
        True
        >>> y < z
        False
        >>> {1, 2, 3} <= {1, 2, 3}               #子集
        True
        
    展开全文
  • 除了字典和集合属于无序序列之外,列表、元组、字符串等序列都支持双向索引。 注意,序列的第一个元素下标都是“0”。(和C语言中数组一样) 还有,就是Python竟然可以用“负数”作为序列下标!最后一个元素下标为...

    在第二课中我们初步认识了列表、元祖和字典。这节课我们来系统地深入学习一下。


    一.Python序列简介

    通俗地讲,序列就是一块用来存放多个值的连续内存空间。

    Python中常用的序列有“列表”、“元组”、“字典”、“字符串”、“集合”等等。
    除了字典和集合属于无序序列之外,列表、元组、字符串等序列都支持双向索引。

    注意,序列的第一个元素下标都是“0”。(和C语言中数组一样)

    还有,就是Python竟然可以用“负数”作为序列下标!最后一个元素下标为-1,倒数第二个为-2,以此类推。


    二.[列表]

    1.Python的列表可以存放不同数据类型的数据,非常自由。
    (列表可以直接用下标访问元素)

    2.当列表删除或添加元素时,列表会自动扩展或收缩内存,始终保证列表元素所占的内存空间是连续的。

    3.列表常用内置函数:
    在这里插入图片描述

    4.列表元素的加入:
    ①直接用“+”运算符:[x]+[y]两个链表无缝连接。
    ②x.append(k)方法:在列表最后加一个元素k。
    ③x.insert(index,obj)方法:在index位置插入obj元素。此时index号元素是插入的obj,其原位置上的数全部往后移一位,index号之前的元素不移动。
    ④x.extend([y])方法:将列表y无缝衔接到列表x的尾部。
    (注:x,y的地址均不变,属于原地操作)

    5.列表元素的删除:
    ①deal x[k]方法:直接删除指定x[k]元素。
    ②x.pop(k)方法:删除指定k位置上的元素,并且可以返回这个弹出的元素。
    ③x.remove(m)方法:删除首次出现指定元素值m的元素。

    6.列表排序:
    ①x.sort()方法:直接将列表元素“升序排列”。
    另外:x.sorted()方法:返回升序排列的列表,不改变原列表。
    ②x.reverse()方法:直接将列表元素“降序排列”。
    另外:x.reverse()方法:返回降序排列的列表

    7.其他操作:
    ①for循环遍历列表:

    x=[1,2,3,4,5,6,7]
    for i in range(0,len(x),1):    #循环语句遍历列表
        print(x[i])
    

    ②复合列表全展开:x=[num for elem in x for num in elem]

    x=[(1,2,3),[4,5,6],{7:'a',8:'b',9:'c'},"lwcsb"]  
    x=[num for elem in x for num in elem]
    print(x)
    

    ※补充:切片操作

    切片操作适用于列表,元素,字符串等。
    切片的意思是从序列中切出一部分出来,进行一些操作。

    切片操作的语法:x[a : b : c]。【由三个数字和两个冒号组成】
    a代表切片开始位置(算入),不写默认从0开始;
    b代表切片结束位置(不算入),不写默认为表尾;
    c代表步长,不写默认为1。

    切片内可以简写:
    比如x[::2]就是从头到尾以步长为2切片。
    比如x[:3]就是从头以步长1一直切到3号元素。
    再比如x[3:7]就是从3号以步长1切到7号。
    (但是保险起见,增加可读性,还是写全吧~~)

    灵活运用切片可以完成一些比较好的操作:

    ①把整个序列倒着输出一遍:x[::-1]

    x=[1,2,3,4,5,6,7]
    print(x[::-1])
    

    ②append方法在中间插入:(不太推荐,没啥意思,纯整活)

    x=[1,2,3,4,5,6,7]
    x[3:4]=[x[3],9]
    print(x)
    

    ③原地修改列表,原地改动列表:

    x=[1,2,3,4,5,6,7]
    x[:3]=[8,8,8]   #切出[1,2,3],暂时调用并修改成[8,8,8]
    print(x)
    
    x=[1,2,3,4,5,6,7]
    x[len(x):]=[8]  #从表尾开始切(其实就是没切),在最后填上[8],相当于append
    print(x)
    
    x=[1,2,3,4,5,6,7]
    del x[:3]     #切出[1,2,3],删除之
    print(x)
    

    三.(元组)

    1.元组是不可变序列:其形式是x=(1,2,3,…,n),可以存放各种数据类型的数。

    元组一旦创建,用任何方法都不能改变其中元素值,也无法添加或删除元素。

    2.切片适用于元组,但只能用切片访问元组的元素,不能改变。

    3.元组的不可变性只适用于元组自身顶层,而非其内容。运行下面的代码,你就会知道:

    x=[[1,2],3,4,5]
    x[0][0]=8
    print(x)   #打印结果是[[8,2],3,4,5]
    

    4.列表和元组的互化:【!!!重要!!!】

    list()方法可以使元组变为列表;tuple()方法可以使列表变为元组。
    由于列表是可变的,元组是不可变的,所以利用这两个方法,相当于对序列内的数据进行“冻结”和“解冻”,改变序列的可改写性。

    x=(1,2,3)
    #x(1)=8   报错,元组是不可变序列
    x=list(x)  #x变为列表
    x[1]=8
    print(x)
    x=tuple(x) #x变为元组
    print(x)
    

    四.{字:典}

    1.字典是无序可变序列,由一个个“键值对”组成。所谓“键值对”,即一个关键字+一个数据域。其形式如下:

    x={a:b} 其中a是键,b是值。用花括号集中多个键值对形成字典。
    键a:不能是列表、集合、字典,其他数据类型均可。(元组、数字、字符串…)

    2.字典的创建:
    ①直接赋值写出。
    ②运用dict( )方法复合zip( )方法对两个列表(键列表、值列表)进行打包:

    keys=[1,2,3,4,5]
    values=["Midway","Iowa","NorthCarolina","SouthCarolina","Alaska"]
    x=dict(zip(keys,values))
    print(x)
    

    3.字典元素的获取:
    ①直接使用“键”索引,获取对应“值”。
    ②使用get( )方法,但仍然是“键”索引获取对应“值”。

    x={1:'a',2:'b',3:[1,2],"4":5,5:"LWCSB"}
    print(x[5])
    print(x.get("4"))
    

    【注意:get()方法不只是如此:

    get(key,default):键key存在则返回相应的值,否则返回default。

    这个延伸的get方法在后面会用到!】

    ③items( )方法遍历“键值对”。
    ④values( )方法遍历“值”。
    ⑤keys( )方法遍历“键”。
    以上三种用法需要借助for循环实现:

    x={1:'a',2:'b',3:[1,2],"4":5,5:"LWCSB"}
    
    for k in x.items():   #遍历键值对
        print(k)
    for k in x.values():  #遍历值
        print(k)
    for k in x.keys():    #遍历键
        print(k)
    

    4.字典元素的添加:
    ①直接对指定“键”的值赋值修改。如果找不到对应键,直接在字典里添加该键值对。

    c
    x[1]="Kongo"
    x[9]="Zao"    #找不到要修改的键值对,自动添加该键值对
    print(x)
    

    ②运用update( )方法:
    直接将新的字典融合进原字典。如果两个字典有“键”冲突,则这个“键”对应新的字典的值。(不然怎么叫“更新”对吧~)

    x={1:'a',2:'b',3:[1,2],"4":5,5:"LWCSB"}
    x.update({1:'k',(6,7):"Yamato",8:"Fubuki"})
    print(x)
    

    5.字典元素的修改:
    ①del命令:删除指定“键”对应的元素。
    ②clear( )方法:清除字典中的所有元素。
    ③pop( )方法:删除指定键对应的元素,但只返回“值”。
    ④popitem( )方法:删除最后一个元素,返回键值对。(不接收参数)

    x={1:'a',2:'b',3:[1,2],"4":5,5:"LWCSB"}
    print(x.pop(1))
    print(x.popitem())
    print(x)
    

    五.{集合}

    1.集合的定义不用我多说了吧。其形式是:{1,2,3,4}
    2.set( )方法:将其他可迭代对象转化为集合。(如:列表、元组)

    list=[1,2,3,4,5]
    x=set(list)
    print(x)
    y=set()   #创建一个空集
    print(y)
    

    3.add( )方法:添加元素。
    4.pop( )方法:弹出第一个元素。(不接收参数)

    x={1,2,34}
    x.add(5)
    print(x)
    x.pop()
    print(x)
    

    5.集合操作:
    ①交集& 并集 | 差集-
    ②比较集合大小:> < >= <= ==
    ③测试是否为子集:issubset( )方法。

    x={1,2,3,4,5}
    y={1,2,3,6,7}
    z={1,2,3,4}
    
    print(x&y)
    print(x|y)
    print(x-y)
    
    print(x>y)
    print(x<y)
    
    print(z.issubset(x))  #测试z是否为x的子集
    

    六.序列应用实例

    1.用“字典”统计文本中不同字符出现的个数:

    text=input("输入一串字符:")
    x=dict()                #创建一个空字典
    
    for i in text:
        x[i]=x.get(i,0)+1
    #用i遍历text的每一个字符。(i即text中的每一个字符)
    #x[i]表示生成或调用 键为字符‘i’的字典元素,并将要为其赋值。
    #x.get(i,0)+1:首先获取字典x中键为‘i’的元素的值,如果找不到则为0。
    #然后进行+1统计操作,得到的值就是当前字符i的个数,重新赋给x[i]。
    
    print(x)
    

    2.用列表处理大量数据:
    比如这个题目↓【感谢顾同学提供的题目!】
    在这里插入图片描述
    我们想要的效果是这样的:
    在这里插入图片描述
    我们要达到的效果是对数据进行集合处理,并且排序。

    这是代码:

    data=input()
    x=data.split("\\n")
    y=[]
    
    for i in x:
        i=i.split(",")
        
        a1=i[0]       #a1代表年份(每一项的第一个)
        a2=int(i[1])  #a2代表后面的数字
        A=[a1,a2]     #A代表嵌套列表中的每一项
        
        y.append(A)   #逐一添加A
    #print(y) 检查y的正确性
    
    z=sorted(y,key=lambda y:y[-1])    
    #sorted条件排序。sorted(目标列表,key=lambda 形参(代表列表中的元素):条件)
    z=z[::-1]   #列表反向
    #print(z) 检查z的正确性
    
    for i in range(0,len(z),1):    #遍历输出
        print(z[i])
        
    """测试数据:
    2020年,87\n2019年,96\n2018年,99\n2017年,99\n2016年,76\n2015年,87\n2014年,100\n2013年,86\n2012年,63\n2011年,66\n2010年,59\n2009年,81\n2008年,63\n2007年,74\n2006年,81\n2005年,79\n2004年,59
    """
    

    这里面要素过多,我会分一期出来讲解。(可以先看我写的注释)

    展开全文
  • 一、列表 1、创建列表 方式一,用中括号[]直接定义。例如:x=[1,2,3,4,5,6] 方式二,用list()将元组、字符...Python支持双向索引,即除了常见的用正整数做下标,还可以用负整数做下标,[-1]表示最后一个元素,[-2]表...

    一、列表
    1、创建列表
    方式一,用中括号[]直接定义。例如:x=[1,2,3,4,5,6]

    方式二,用list()将元组、字符串、字典、集合range对象等其它可迭代对象转换成列表。例如:
    x=list((1,2,3,3,4,5,6))

    2、访问
    用下标的方法可以访问列表中的每一个元素。Python支持双向索引,即除了常见的用正整数做下标,还可以用负整数做下标,[-1]表示最后一个元素,[-2]表示倒数第二个元素,以些类推。例如:
    x=[1,2,3,4,5,6]
    print([x[0],x[1],x[-1],x[-2]]) # [1,2,6,5]

    3、常用操作
    lst.append(x) ———— 将单个元素x添加至列表lst的尾部,返回None
    lst.extend(Lst) ———— 列表Lst列表到列表lst的尾部,返回None
    lst.insert(ind,x) ———— 在下标ind处插入单个x,原下标为ind的元素及其后的元素依序后移一位,返回None
    lst.pop(ind) ———— 删除并返回下标为ind的元素,ind缺省为-1,取缺省删除并返回最后一个元素
    lst.remove(x) ———— 将第一个与x相等的元素,其后的元素依序前移一位,返回None
    lst.index(x) ———— 返回第一个与x相等的元素的下标,没有与x相等的元素将抛出异常
    lst.count(x) ———— 返回与x相等的元素的个数
    lst.reverse() ———— 逆序
    lst.sort() ———— 排序
    lst.copy() ———— 复制
    lst.clear() ———— 清空所有元素,保留列表对象(空列表),返回None

    举例:
    lst=[1,2,3,4,5,6]

    print(lst.append(77),lst) # None [1, 2, 3, 4, 5, 6, 77]

    print(lst.extend([8,9,10]),lst) # None [1, 2, 3, 4, 5, 6, 77, 8, 9, 10]

    print(lst.insert(3,33),lst) # None [1, 2, 3, 33, 4, 5, 6, 77, 8, 9, 10]

    print(lst.pop(5),lst) # 5 [1, 2, 3, 33, 4, 6, 77, 8, 9, 10]

    print(lst.remove(33),lst) # None [1, 2, 3, 4, 6, 77, 8, 9, 10]

    print(lst.index(8),lst) # 6 [1, 2, 3, 4, 6, 77, 8, 9, 10]

    print(lst.count(9),lst) # 1 [1, 2, 3, 4, 6, 77, 8, 9, 10]

    print(lst.reverse(),lst) # None [10, 9, 8, 77, 6, 4, 3, 2, 1]

    print(lst.sort(),lst) # None [1, 2, 3, 4, 6, 8, 9, 10, 77]

    print(exec(‘lst2=lst.copy()’),lst.clear(),lst,lst2) # None None [] [1, 2, 3, 4, 6, 8, 9, 10, 77]

    4、切片
    切片就是从列表中取出一段小列表。

    lst2 = lst[start🔚step]

    以上就是从列表lst中的下标为start元素开始(从0开始数,含下标为start元素),取到下标为end元素为止(不含下标为end元素),步长为step。start、end、step的缺省值分别为:0、len(lst)、1。例如:

    lst=[1,2,3,4,5,6,7,8,9,10]
    print(exec(‘lst2 = lst[::]’),lst2) # None [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(exec(‘lst2 = lst[5::]’),lst2) # None [6, 7, 8, 9, 10]
    print(exec(‘lst2 = lst[:5:]’),lst2) # None [1, 2, 3, 4, 5]
    print(exec(‘lst2 = lst[::3]’),lst2) # None [1, 4, 7, 10]
    print(exec(‘lst2 = lst[:len(lst):3]’),len(lst),lst2) # None 10 [1, 4, 7, 10]

    二、元组
    1、创建元组
    方式一,用小括号()直接定义。例如:x=(1,2,3,4,5,6)
    如果元组中仅有一个元素,则必须在后面多加一个逗号。例如:
    x = (3) # 赋给x的不是元组,而是整数3
    x = (3,) # 赋给x的是一个仅一个元素3的元组

    方式二,用tuple()将列表等转变成元组。例如:
    x=tuple((1,2,3,3,4,5,6))

    2、访问
    元组支持用下标访问元素,也支持双向索引。例如:
    x=(1,2,3,4,5,6)
    print([x[0],x[1],x[-1],x[-2]]) # [1,2,6,5]

    3、常用操作
    元组一旦创建就不可修改,即不可添加、修改、删除元素,也不可以清空和copy。

    tpl.index(x) ———— 返回第一个与x相等的元素的下标,没有与x相等的元素将抛出异常
    tpl.count(x) ———— 返回与x相等的元素的个数

    举例:
    tpl=(1,2,3,3,3,3,5,6,7)
    print(tpl.index(3)) # 2
    print(tpl.count(3)) # 4

    4、元组支持切片

    三、字典
    1、创建元组
    方式一,用大括号{}直接定义。例如:
    print(exec(“dct={1:61, 2:62, 5:65}”),dct) # None {1: 61, 2: 62, 5: 65}

    print(exec(“dct={‘a’:1, ‘b’:2, ‘c’:3, ‘d’:4, ‘e’:5, ‘f’:6}”),dct) # None {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

    方式二,用dict()将zip对象等转变成字典。例如:
    print(exec(“dct=dict(zip([‘a’,‘b’,‘c’],[1,2,3]))”),dct) # None {‘a’: 1, ‘b’: 2, ‘c’: 3}

    方式三,用赋值的方式创建字典。例如:
    print(exec(“dct=dict(a=1,b=2,c=‘three’)”),dct) # None {‘a’: 1, ‘b’: 2, ‘c’: ‘three’}

    方式四,用dict.fromkeys(lst),依据给定的键名列表,建立一个空字典,例如:
    print(dict.fromkeys([11, 12,‘ax’, ‘bx’])) # {11: None, 12: None, ‘ax’: None, ‘bx’: None}

    2、访问,访问字典一般都是通过以键值为下标访问相应的值。例如:
    x={1:61, 2:62, 5:65,‘a’:71, ‘b’:72, ‘c’:73}
    print([x[1],x[2],x[5],x[‘a’],x[‘b’]]) # [61, 62, 65, 71, 72]

    特别要注意的是,当使用的键值不存在时,会抛出异常“KeyError”。

    3、常用操作
    dct.copy() ———— 复制
    dct.clear() ———— 清空

    dct.update(dct2) ———— 将dct2合并到dct中去,合并过程会已有键名则更新、没有键名则添加,返回None
    dct.get(k,def) ———— 返回键名为k的元素的值,没有键名为k的元素则返回def(缺省为None)
    dct.setdefault(k,v) ———— 如果有键名为k的元素的值,则返回该值(这时v不起任何作用),如果没有键名为k的元素就添加一个键名为k、值为v的新元素,返回v

    dct.pop(k) ———— 弹出(删除)键名为k的元素,返回弹出元素的值
    dct.popitem() ———— 随机弹出(删除)一个元素,返回弹出元素的键值对,通常是弹出最后一个,但字典是无序序列,所以不能确保每次都是弹出最后一个。

    dct.items() ———— 返回由字典所有键值对组成的列表构成的dict_items对象
    dct.keys() ———— 返回由字典所有键名组成的列表构成的dict_keys对象
    dct.values() ———— 返回由字典所有值组成的列表构成的dict_values对象

    举例:
    dct={1:61, 2:62, 5:65,‘a’:71}
    dct.update({2:88, ‘a’:100, ‘c’:73})

    print(dct) # {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73}

    print(dct.get(‘a’)) # 100
    print(dct.get(‘b’,200)) # 200

    print(dct.setdefault(1,77),dct) # 61 {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73}
    print(dct.setdefault(11,99),dct) # 99 {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73, 11: 99}

    print(dct.popitem(),dct) # (11, 99) {1: 61, 2: 88, 5: 65, ‘a’: 100, ‘c’: 73}
    print(dct.pop(5),dct) # 65 {1: 61, 2: 88, ‘a’: 100, ‘c’: 73}

    print(list(dct.items())) # [(1, 61), (2, 88), (‘a’, 100), (‘c’, 73)]
    print(list(dct.keys())) # [1, 2, ‘a’, ‘c’]
    print(list(dct.values())) # [61, 88, 100, 73]

    四、集合
    1、创建元组
    方式一,用大括号{}直接定义,集合中的元素不允许重复,定义时的重复元素在实际生成集合时会被删除。例如:
    x = {1,2,3,3,3,‘a’,‘ab’,‘cc’}
    print(x) # {‘a’, 1, 2, 3, ‘ab’, ‘cc’}

    方式二,用set()函数,将列表、元组、字典等转换为集合,转换过程中,重复的元素会被删除。例如:
    print(set([1,2,3,3,3,3,5])) # {1, 2, 3, 5}

    print(set((1,2,3,3,3,3,5))) # {1, 2, 3, 5}

    print(set({11:61, 22:62, ‘dd’:65, ‘aa’:66})) # {‘aa’, ‘dd’, 11, 22}

    2、访问
    因为集合是无序的且其中的元素没有键名,无法能用下标来访问集合中的元素,唯一的方法只能是用循环语句来遍历集合中的所有元素。
    x = {1,2,3,3,3,‘a’,‘ab’,‘cc’}
    for i in x:print(i,end=’ ') # 1 2 3 ab cc a

    3、常用操作
    s.copy() ———— 复制
    s.clear() ———— 清空
    s.pop() ———— 随机弹出(删除)集合中的一个元素,返回被弹出的元素
    s.remove(x) ———— 删除集合中值为x的元素,x不存在,则抛出异常,返回None
    s.discard(x) ———— 删除集合中值为x的元素,x不存在,则忽略该操作,返回None
    s.update(s2) ———— 将s2合并到s中去,重复的元素会被删除,返回None

    s.isdisjoint(s2) ———— 两个集合有没有相同的元素,没有,返回 True,有,返回 False
    s.issubset(s2) ———— s是不是s2的子集(s中的元素s2中都有么),是,返回 True,不是,返回 False
    s.issuperset(s2) ———— s是不是s2的超集(s2中的元素s中都有么),是,返回 True,不是,返回 False

    s.add(x) ———— 添加一个元素x到集合中,返回None

    s.union(s2) ———— 将s2合并到s,返回合并后的s

    s.intersection(s2) ———— 返回s和s2中的交集(共同的元素)

    s.difference(s2) ———— 返回s和s2的差集(s有、s2没有的元素)

    s.symmetric_difference(s2) ———— 返回s和s2的对称差集,即在s和s2的并集中,去除s和s2中都有元素,比普通的差集多了s没有、s2有的元素。在这一操作中s与s2互换,结果一样,所以是对称的。

    s.intersection_update(s2) ———— 在s中去除s2中没有的元素,只留下s2中也有的元素。也就是说,更新后的s变成了s和s2的交集

    s.difference_update(s2) ———— 在s中去除s2中也有的元素。也就是说,更新后的s变成了s和s2的差集

    s.symmetric_difference_update(s2) ———— 在s中去除s2中也有的元素,并把s2有、s中没有的元素也添加到s中。也就是说,更新后的s变成了s和s2的对称差集

    举例:
    s = {1,2,3,5,6,8,9,‘a’,‘ab’,‘cc’}
    s2 = {30,50,60}
    s3 = {3,5,30,50,60}

    print(s.isdisjoint(s2),s,s2) # True {1, 2, 3, 5, 6, ‘ab’, 8, 9, ‘a’, ‘cc’} {50, 60, 30}
    print(s.isdisjoint(s3),s3) # False {3, 5, 50, 60, 30}

    print(s3.issubset(s),s3) # False {3, 5, 50, 60, 30}
    print(s.issuperset(s3),s3) # False {3, 5, 50, 60, 30}

    s4 = {3,5,6}
    print(s4.issubset(s),s4) # True {3, 5, 6}
    print(s.issuperset(s4),s4) # True {3, 5, 6}

    s5 = {5,6,7,‘ab’,‘dd’}
    print(s.add(88),s) # None {‘a’, 1, 2, 3, ‘cc’, 5, 6, 8, 9, 88, ‘ab’}

    print(s.union(s5),s5) # {1,2,3,‘cc’,5,6,7,8,9,‘dd’,‘ab’,‘a’,88} {5,6,7,‘dd’,‘ab’}
    print(s.intersection(s5),s5) # {‘ab’, 5, 6} {5, 6, 7, ‘dd’, ‘ab’}

    print(s.difference(s5),s5) # {‘a’,1,2,3,‘cc’,8,9,88} {5,6,7,‘dd’,‘ab’}
    print(s.symmetric_difference(s5),s5) # {1,2,3,7,8,9,‘dd’,‘cc’,88,‘a’} {5,6,7,‘dd’,‘ab’}

    s1=s.copy()
    s11=s.copy()
    print(s.intersection_update(s5),s,s5) # None {5, 6, ‘ab’} {5, 6, 7, ‘dd’, ‘ab’}
    print(s1.difference_update(s5),s1,s5) # None {1,2,3,8,9,‘a’,88,‘cc’} {5,6,7,‘dd’,‘ab’}
    print(s11.symmetric_difference_update(s5),s11,s5) # None {1,2,3,7,8,9,‘a’,‘dd’,88,‘cc’} {5,6,7,‘dd’,‘ab’}

    ———————————————— 本篇完 ————————————————

    看完之后,麻烦您顺手点击下方 “点赞” 两个字给我点个赞吧 ^-^ , 谢谢您了。

    如果您还能像我小学一年级班主任好老师那样,给我随心写上几句表扬或批评的话语,那真是感激不尽!

    在我人生的道路上,有了您的鼓励和指导,我一定成长快快。

    展开全文
  • ​本章引言 ...列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 定义列表 语法:list1=[元素1...

    ​本章引言

            python中常用容器数据类型主要有列表、元组、字典和集合,本章将深入浅出的对每个类型进行详细说明。

     

    列表

            Python序列类似于其他语言中的数组,但功能要强大很多。Python中常用的序列结构有列表、元组、字符串,字典、集合以及range等对象也支持很多类似的操作。列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。

    定义列表

    语法:list1=[元素1,元素2,元素3.....]

    示例:如果需要在列表中声明1-100个值的话则可以使用range函数完成;通过list对象进行强制转换range对象即可
    >>>list1=list(range(1,101))
    

    访问列表中的值

    使用下标索引来访问列表中的值,同样你也可以使用方括号的形式截取字符,如下所示:

    >>>list1 = ['tom', 'jack', 2020, 2019]
    >>>list2 = [1, 2, 3, 4, 5, 6, 7 ]
    >>>print("list1[0]: ", list1[0])
    >>>print("list2[1:5]: ", list2[1:5])
    

    以上实例输出结果:

    list1[0]: tom
    list2[1:5]:  [2, 3, 4, 5]
    

    更新列表

    你可以对列表的数据项进行修改或更新,你也可以使用append()方法来添加列表项,如下所示:

    >>>list3 = [] ## 空列表
    >>>list3.append('tom') ## 使用 append() 添加元素
    >>>list3.append('jack')
    print(list3)
    

    以上实例输出结果:

    ['tom', 'jack']
    

    删除列表元素

    可以使用 del 语句来删除列表的元素,如下实例:

    >>>list4 = ['chinese', 'english', 2010, 2020]
    >>>print(list4)
    >>>del list4[2]
    >>>print("After deleting value at index 2 : ")
    >>>print(list4)
    

    以上实例输出结果:

    ['chinese', 'english', 2010, 2020]
    After deleting value at index 2 :
    ['chinese', 'english', 2020]
    

    列表符号操作

    *: 表示的是列表元素进行重复

    例如:
    >>>list1=[1,2,3]
    >>>list1*3
    [1,2,3,1,2,3,1,2,3]
    

    +: 表示的是实现两个list的拼接操作;

    >>>list1=[1,2]
    >>>list2=[2,3]
    >>>list1+list2
    [1,2,2,3]
    

    列表截取

    Python 的列表截取实例如下:

    >>>L = ['Google', 'Baidu', 'Taobao']
    >>> L[2] '
    Taobao'
    >>> L[-2]
    'Baidu'
    >>> L[1:]
    ['Baidu', 'Taobao']
    

     

    列表函数及方法

    函数:

    序号 函数
    1 cmp(list1, list2)比较两个列表的元素
    2 len(list)列表元素个数
    3 max(list)返回列表元素最大值
    4 min(list)返回列表元素最小值
    5 list(seq)将元组转换为列表

    方法:

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

    思考

    Q:[::-1]和reverse方法实现列表反转的两者区别?

    R:[::-1]反转后返回一个新的列表,不会修改原有列表对象值(会开辟内存空间进行存在);reverse方法没有返回值,直接在原有对象上进行元素的反转操作(在原有列表内存空间上进行元素值的反转);

    元组

          表示的是使用小括号进行描述一组数据的集合,数据与数据之间使用逗号隔开;

    定义元组

    语法:tuple1=(元素1,元素2,元素3......)

    >>>tuple1=(1,2,3)
    >>>type(tuple1)
    <type 'tuple'>
    

    元组特点与操作

    1. 获取元组中的元素的方式与列表相同;

    2. 支持多个元组重复输出以及元组之间的拼接操作(+ * )

    元组的作用

    • a.对数据起到保护作用(数据不需要被重新赋值修改的操作都可以定义为元组)

    • b.在函数中返回值,如果返回多个值的话,实际返回的就是一个元组

    • c.针对多个变量操作,可以实现数据的封包和解包的操作;

    元组的注意事项

    • a.元组中的元素都是不可变的,不能够被重新赋值;

    • b.如果在元组中需要只声明一个元素的话,则表示形式必须是(元素1,);如果省略逗号则表示的是与之元素所对应的类型;

    • c.列表与元组之间可以实现相互转换;

    思考

    Q1:如何实现创建空元组以及元组中只有一个元素情况?
    R1:空元组:tuple1=() 元组一个元素:tuple2=(30,)单个元素必须在元素后面添加逗号


    Q2:元组与列表的区别?
    R2:元组中的数据一旦定义就不允许更改。
    元组没有append()、extend()和insert()等方法,无法向元组中添加元素。
    元组没有remove()或pop()方法,也无法对元组元素进行del操作,不能从元组中删除元素。
    从效果上看,tuple( )冻结列表,而list( )融化元组。

     

    字典

            使用大括号进行描述的一组键值对的数据称之为字典,键名与键值之间使用冒号隔开,键值对之间使用逗号隔开;

    定义字典

    语法:dict1={键名1:键值1,键名2:键值2........} --->{key:value,key:value}
    键一般是唯一的,如果重复最后的一个键值对会替换前面的,值不需要唯一。

    >>>dict1 = {'a': 1, 'b': 2, 'b': '3'}
    >>>dict1['b']
    '3'
    >>>dict1
    {'a': 1, 'b': '3'}
    

    访问字典里的值

    把相应的键放入熟悉的方括弧,如下实例:

    >>>dict2 = {'Name': 'Zemu', 'Age': 18, 'Class': 'First'}
    >>>print("dict2['Name']: ", dict2['Name'])
    >>>print("dict2['Age']: ", dict2['Age'])
    

    以上实例输出结果:

    dict2['Name']:  Zemu
    dict2['Age']:  18
    

    修改字典

    向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:

    >>>dict3 = {'Name': 'Zemu', 'Age': 18, 'Class': 'First'}
    >>>dict3['Age'] = 28 # 更新
    >>>dict3['School'] = "Zelin" # 添加
    >>>print("dict3['Age']: ", dict3['Age'])
    >>>print("dict3['School']: ", dict3['School'])
    

    以上实例输出结果:

    dict['Age']:  28
    dict['School']:  Zelin
    

    删除字典

    元素能删单一的元素也能清空字典,清空只需一项操作。显示删除一个字典用del命令,如下实例:

    >>>dict4 = {'Name': 'Zemu', 'Age': 18, 'Class': 'First'}
    >>>del dict4['Name'] # 删除键是'Name'的条目
    >>>dict4
    {'Age': 18, 'Class': 'First'}
    >>>dict4.clear() # 清空字典所有条目
    >>>dict4
    {}
    

     

    字典内置函数和方法

    函数:

    序号 函数及描述
    1 cmp(dict1, dict2)比较两个字典元素
    2 len(dict)计算字典元素个数,即键的总数
    3 str(dict)输出字典可打印的字符串表示
    4 type(variable)返回输入的变量类型,如果变量是字典就返回字典类型

    方法:

    序号 方法及描述
    1 dict.clear()删除字典内所有元素
    2 dict.copy()返回一个字典的浅复制
    3 dict.fromkeys(seq[, val])创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值
    4 dict.get(key, default=None)返回指定键的值,如果值不在字典中返回default值
    5 dict.items()以列表返回可遍历的(键, 值) 元组数组
    6 dict.keys()以列表返回一个字典所有的键
    7 dict.update(dict2)把字典dict2的键/值对更新到dict里
    8 dict.values()以列表返回字典中的所有值
    9 pop(key[,default])删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。否则,返回default值
    10 popitem()返回并删除字典中的最后一对键和值

     

    思考

    Q1:如果用字典里没有的键访问数据,则结果是?
    R1:会提示当前字典中不存在该键,即KeyError错误

     

    集合

           集合是无序可变序列,使用一对大括号界定,元素不可重复,同一个集合中每个元素都是唯一的。集合中只能包含数字、字符串、元组等不可变类型(或者说可哈希)的数据,而不能包含列表、字典、集合等可变类型的数据。

    集合创建与删除

    直接将集合赋值给变量

    >>> a = {3, 5}
    >>> a.add(7)      #向集合中添加元素
    >>> a
    {3, 5, 7}
    #使用set将其他类型数据转换为集合
    >>> a_set = set(range(8,14))
    >>> a_set
    {8, 9, 10, 11, 12, 13}
    >>> b_set = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8])     #自动去除重复
    >>> b_set
    {0, 1, 2, 3, 7, 8}
    >>> c_set = set()      #空集合
    set()  
    

    集合操作

    1.并集操作:使用union、| ;表示的是将两个集合不同的数据进行使用一个新的集合进行返回,相同的数据会去重

    例如:
    >>>set1={1,2,3,4,5}
    >>>set2={2,3,4,5,6}
    >>>set1.union(set2)   #等价操作表示方式:set1|set2
    {1,2,3,4,5,6}
    

    2.交集操作:使用intersection 、& ;表示的是取两个集合的相同部分的数据并生成新的集合进行返回;

    例如:
    >>>set1={1,2,3,4,5}
    >>>set2={2,3,4,5,6}
    >>>set1.intersection(set2)  #等价操作表示方式:set1&set2
    {2,3,4,5}
    

    3.差集操作:使用difference 、-;表示的是 被减集合中元素不在减的集合中的所有元素返回一个新的集合;

    例如:
    >>>set1={1,2,3,4,5}
    >>>set2={2,3,4,5,6}
    >>>set1.difference(set2) #等价操作表示方式:set1-set2
    {1}
    

    4.全集减交集(异操作):symmetric_difference、^ ;表示的是取两个集合的全集然后去除两个集合的交集部分并返回新的集合

    例如:
    >>>set1={1,2,3,4,5}
    >>>set2={2,3,4,5,6}
    >>>set1.symmetric_difference(set2)  #等价操作表示方式:set1^set2
    {1,6}
    

     

    思考

    Q1:因为集合和字典都是使用{}进行表示的,所以问空集合和空字典的表示形式?
    R1:dict1={} 此种形式表示的是空字典,如果需要表示空集合的话,则必须使用set()

    限时抢购对应文章视频课程红包:

    课后练习

    1. x 的 y 次方(Xy) 以下表达式正确的是?•    
      A、x^y
      B、x** y
      C、x^^y
      D、Python 没有提到

    2. 22 % 3 表达式输出结果为?
      A、7
      B、1
      C、0
      D、5

    3. 3*1**3 表达式输出结果为?
      A、27
      B、9
      C、3
      D、1

    4. 9//2 表达式输出结果为?
      A、1
      B、2
      C、3
      D、4

    5. 如果表达式的操作符有相同的优先级,则运算规则是?
      A、左到右
      B、右到左
      C、看心情

     

    展开全文
  • 支持双向索引,索引范围 [ -L, L-1 ] ,L – 表示列表、元组和字符串的长度(分正向索引和反向索引)。 正向索引:0 表示第 1 个元素,1 表示第 2 个元素,2 表示第 3 个元素… 一、列表: 放在一对方括号...
  • python2.0

    2021-03-21 17:10:44
    1.索引:除字典和集合属于无序序列外,列表,元组,字符串,等序列类型均支持双向索引。 2。本章主要介绍几种基本数据类型的用法,以及通过实际应用来介绍列表的推导式,切片操作和生成器的推导式。 3.列表是python的...
  • Python序列概述 ...§ 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 Python序列分类示意图 ​   2.1 ...
  • python学习心得

    2021-03-28 22:48:47
    列表,字符串,元祖属于有序序列,支持双向索引,支持使用附属数作为下标来访问其中的元素,-1表示最后一个元素位置,-2表示倒数第二个元素位置。 在Python中,同一个列表中元素的数据类型可以各不相同,可以同时...
  • python自学笔记

    2020-03-14 00:26:37
    列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推,最后一个元素小标为-1,倒数第二个元素下标为-2, 列表 列表是python中内置有序、可变序列,列表的所有元素放在一对中括号 ...
  • 列表、元组、字符串等有序列以及range对象均支持双向索引 Python采用基于值的自动内存管理模式,变量并不直接存储值,而是存储值的引用或内存地址 同理,Python列表中的元素也是值的引用 尽量避免过多使用列表 ...
  • 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 1.1列表 列表是Python中内置有序可变序列,列表中所...
  • Python第二章

    2021-03-21 20:36:00
    字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;如果使用复数作为索引,则最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推...
  • Python学习笔记2

    2021-03-23 13:41:25
    列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 列表的创建与删除 创建列表 创建列表之后,可以使用整数作为...
  • Python入门基础(2)

    2021-05-18 12:01:45
    Python入门欢迎来到梁老湿课堂Python序列的概述多练多学多坚持,我们下期...列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此
  • 第2章 Python序列

    2018-03-06 19:40:00
    Python序列类似于C或Basic中的一维、多维数组等,但功能要强大很多,使用也更加灵活、方便,...列表、元组、字符串等序列类型以及range对象均支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推。可以...
  • Python3常用数据结构

    2020-03-28 18:16:44
    Python3中有三种组合...支持双向索引。第一个元素为0,最后一个元素为-1 列表 内置可变序列,所有元素放在一对中括号中,并用逗号分隔。当列表元素增加或者删除时,列表对象自动进行扩展或者收缩内存,保证元素之...
  • Invoke:用于管理面向 shell 的子进程,同时支持将可执行的 Python 代码组织成命令行可调用的状态。 tmuxp: tmux 会话管理器。 高级 CLI httpie:一个命令行 HTTP 客户端,cURL 的替代品,易用性更好。 i...
  • 2、Python列表和元组

    2018-01-11 12:13:00
     Python中常用的序列结构有列表、元组、字典、字符串、集合等,字典和集合是无序的,其他三个都支持双向索引。一般0为第一个序列,但是python可以用负数做下标序列,最后一个下标为-1,之前的为-2,以此类推。 ...
  • 序列是一块用来存放多个值的内存空间,Python中常用的序列结构有列表、元组、字典、字符串、集合等,除字典和集合属于无序序列之外,列表、元组、字符串等类型都支持双向索引。 2.分类 2.1 列表 定义:列表是...
  • 有序序列:列表、元组、字符串,支持双向索引(第一个元素下标为0,最后一个元素下标为-1) 不可变序列:字符串、元组 可变序列:列表、集合、字典 列表 尽量从列表尾增加或删除元素,可以大幅度提高处理速度 ...
  • Python一周小记(六)

    2021-05-05 18:58:58
    列表,元组,字符串是有序序列,支持双向索引(从左往右查找[ 1: ],从右往左查找([ :-1]) 列表的一些要点 列表中元素的类型 同一个列表中元素的类型可以不相同,可以同时包含整数、实数、字符串、等基本类型,也...
  • 字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下表为1,以此类推;如果使用负数作为索引,则最后一个元素下表为-1,倒数第二个元素下表为-2...
  • 基于 python 自带的 multiprocessing 模块,目前暂不支持 Windows 用法: jieba.enable_parallel(4) # 开启并行分词模式,参数为并行进程数 jieba.disable_parallel() # 关闭并行分词模式 例子:...
  • 常见概念梳理 ...列表、元组、字符串支持双向索引字典支持使用"键"作为下标、集合不支持任何索引 关键字in可以用于列表和其它可迭代对象,包括元组、字典、range、字符串、集合 Python中的for循...
  • 2021-03-21

    2021-03-21 21:06:27
    ③列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 列表list 用中括号“[ ]”表示 1.任意对象的有序集合 列表是一组...
  • 本包提供了对JSON的基本支持,比如从一个对象序列化为JSON字符串,或者从JSON字符串反序列化出一个具体的对象等。 http 通过http包,只需要数行代码,即可实现一个爬虫或者一个Web服务器,这在传统语言中是无法...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

python字典支持双向索引

python 订阅