Python学习记录4-列表、元祖和集合

list列表

• 一组由有序数据组成的序列
  • 数据有先后顺序
  • 数据可以不是一类数据
• list的创建
  • 直接创建，用中括号创建，内容直接用英文逗号隔开
  • 使用list创建
  • 列表包含单个字符串的时候是一个特例

    # 直接赋值创建列表
    >>> L1 = [1,2,3,4,5]
    # list内的数据可以不是一个类型
    >>> L2 = [1,2,3,"China","小明"]

    # 创建列表的第二种方式
    >>> L3 = list()
    >>> print(L1)
    >>> print(L2)
    >>> print(L3) #L3是一个空的列表
    >>> print(type(L3))#内置函数 type() 显示变量的类型b

    输出：
    [1, 2, 3, 4, 5]
    [1, 2, 3, 'China', '小明']
    []
    <class 'list'>

    ---------------------------------------------------------------------------------------------------

    # list创建的特例
    >>> s = "Ha ha"

    #想创建就包含s一个字符串的列表
    >>> L1 = list(s)
    # 此种情况用 L1 = [s]
    >>> print(L1)
    >>> print(type(L1))

    输出：
    ['H', 'a', ' ', 'h', 'a']
    <class 'list'>

列表的常见操作

• 访问
  • 使用下标操作，也叫索引
  • 列表的元素索引是从0开始
• 切片操作
  • 对列表进行任意一段的截取
  • 截取之后，创建一个新的列表

    >>> L1 = [22,23,45,65,342,545]
    #使用下标访问
    >>> print(L1[0])
    #如果下标超标 会报错 list index out of range
    
    输出：
    22

    ---------------------------------------------------------------------------------------------------

    # 切片操作需要注意取值范围，左包括右不包括
    >>> L1 = [1,2,3,4,5,6,7,8,9,10]

    >>> print(L1[1:7])

    # 下面结果说明切片后生成的是一个全新的列表
    # 通过内置函数id可以判断出切片是否生成了全新的列表
    # id的作用是用来判断两个变量是否是一个变量
    >>> L2 = L1[0:10] #把L1的值全部赋给 L2变量 
    >>> print(id(L1)) #通过id比较发现内存地址不同
    >>> print(id(L2)) #这说明切片后是生成了全新的列表

    # 切片下标可以为空
    >>> print(L1[:4]) #从开头截取到下标3 因为右不包括 所以取不到下标4
    >>> print(L1[2:]) #从下标2开始截取到结尾
    >>> print(L1[:]) #从开头到结尾 即全部

    输出：
    [2, 3, 4, 5, 6, 7]
    4543225360
    4542443760
    [1, 2, 3, 4]
    [3, 4, 5, 6, 7, 8, 9, 10]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


    # 分片可以控制增长幅度，默认增长幅度为1
    >>> print(L1[::1]) # 等于print(L1[:])
    >>> print(L1[::2])
    
    输出：
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    [1, 3, 5, 7, 9]

    # 下标可以超出范围，超出后不再考虑多余下标内容
    >>> print(L1[:100])

    输出：
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    ---------------------------------------------------------------------------------------------------

    # 下标值，增长幅度可以为负数
    # 如果下标值为负数，表明顺序是从右往左
    # 规定：数组最后一个数字的下标是-1

    # 这样子输出的为空，这是因为默认是从左向右移动
    >>> print(L1[-2:-5])

    # 如果想利用负数下标打印7,8,9 则
    >>> print(L1[-2:-5:-1]) #此时虽然打印出来了但是顺序是 9 8 7是反着的

    # 调整打印的顺序
    >>> print(L1[-5:-2:1]) #此时顺序虽然对了 但是下标不对了 这是由于左包括 右不包括

    #最终调整
    >>> print(L1[-4:-1:1])

    输出：
    []
    [9, 8, 7]
    [6, 7, 8]
    [7, 8, 9]

tuple（元祖）

• 可以理解成一个不允许更改的列表

    # tuple的创建

    # 1. 直接用小括号创建
    >>> ta = ()
    >>> print(type(ta))

    # 特殊情况：当用小括号创建一个元素的tuple的时候
    >>> tb = (100)  # 这种情况下 只有一个元素 并不识别这是一个tuple 因为可能是数学中的小括号 所以不识别 这是特例 需要加逗号表示这是一个tuple
    >>> print(type(tb)) 

    >>> tc = (100,)
    >>> print(type(tc))

    # 2.直接用逗号
    >>> ta = 100,
    >>> print(type(ta))

    >>> ta = 100, 200, 300, #多个元素时 后面可以跟 也可以不跟
    >>> print(type(ta))

    # 3.使用tuple定义
    >>> ta = tuple()
    >>> print(ta)

    >>> li = [1,2,3,"hahah ha"]
    >>> tb = tuple(li) # 这种创建方式必须要求tuple的参数是可迭代的 例如一个数字就不行
    >>> print(tb)
    >>> print(li)

    输出：
    <class 'tuple'>
    <class 'int'>
    <class 'tuple'>
    <class 'tuple'>
    <class 'tuple'>
    ()
    (1, 2, 3, 'hahah ha')
    [1, 2, 3, 'hahah ha']

tuple其余特征跟list基本一致

• 有序
• 可以访问不可以被修改
• 元素可以是任意类型

    # tuple索引操作
    >>> la = ["i","love","China"]
    >>> print(la)
    >>> ta = tuple(la)
    >>> print(ta[2])
    
    输出：
    ['i', 'love', 'China']
    China

    # tuple分片操作
    >>> print(ta[:])
    >>> print(ta[:2])
    >>> print(ta[-1::-1])

    输出：
    ('i', 'love', 'China')
    ('i', 'love')
    ('China', 'love', 'i')

    ---------------------------------------------------------------------------------------------------

    # 元祖的相加
    >>> ta = 100,200,300
    >>> tb = ("I","love","China")
    >>> tc = ta + tb
    >>> print(tc)
    
    输出：
    (100, 200, 300, 'I', 'love', 'China')

    # tuple 乘法

    >>> tc = tb * 2
    >>> print(tc)

    输出：
    ('I', 'love', 'China', 'I', 'love', 'China')

    ---------------------------------------------------------------------------------------------------

    # tuple 成员检测
    print(tb)
    >>> if "China" in tb:
            print("在的")
    
    >>> if "I" not in tb:
            print("不在")
  
    输出：
    ('I', 'love', 'China')
    在的


    # 元祖遍历
    >>> for i in tb:
            print(i)

    输出：
    I
    love
    China

    ---------------------------------------------------------------------------------------------------

    ta = ((10,20,30),("i","love","China"),(100,200,300))
    # 嵌套元祖的 访问
    # 1. 双层循环访问  每个元素都是一个元祖  再遍历每一个元祖即可取出
    >>> for i in ta:
            print(i)
            for j in i:
                print(j)
        
    >>> print("------分割线-------")        
        
    # 单层循环  此种方式 i,j,k要跟元祖的元素个数对应
    >>> for i,j,k in  ta:
            print(i,j,k)

    输出：
    (10, 20, 30)
    10
    20
    30
    ('i', 'love', 'China')
    i
    love
    China
    (100, 200, 300)
    100
    200
    300
    ------分割线-------
    10 20 30
    i love China
    100 200 300

    ---------------------------------------------------------------------------------------------------

    # 常用元祖函数
    >>> ta = (123,232,45,34)
    # len：长度
    >>> print(len(ta))
    # max/min：最大值/ 最小值     
    >>> print(max(ta))
      
    >>> tb = (1,2,3,"love") #会报错 int和str类型不能比较
    >>> print(max(tb))

    输出：
    4
    232
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-29-e86ab84987e6> in <module>
          7 
          8 tb = (1,2,3,"love")
    ----> 9 print(max(tb))

    TypeError: '>' not supported between instances of 'str' and 'int'


    # count：对某一元素计数
    >>> ta = (1,2,3,34,2,2,2,2)
    >>> print(ta.count(2))
    #index：某一元素所在的位置
    >>> print(ta.index(1))

    输出：
    5
    0

    ---------------------------------------------------------------------------------------------------

    # tuple的特殊用法
    >>> a = 100
    >>> b = "I hahah"
    # 要求对a,b值进行互换
    # 此种用法是python的特殊用法  在其他语言中一般是借助一个中间变量
    >>> print(a,b)
    >>> a,b = b,a
    >>> print(a,b)

    输出：
    100 I hahah
    I hahah 100

集合

• 跟数学中集合的概念一致
• 内容无序 + 内容不重复

    # 集合的定义

    # 1.通过set关键字
    >>> sa = set()
    >>> print(sa)
    >>> print(type(sa))

    # 2. 使用list创建
    >>> li = [1,2,3,4,45,54,34,1,2]
    >>> sb = set(li)
    >>> print(sb)

    # 3. 使用大括号 注意是大括号 用小括号会报错
    >>> sc = {1,2,3,4,45,54,34,1,2,4545,6757,345}
    >>> print(sc)

    输出：
    set()
    <class 'set'>
    {1, 2, 3, 4, 34, 45, 54}
    {1, 2, 3, 4, 34, 4545, 6757, 45, 54, 345}

    ---------------------------------------------------------------------------------------------------

    # in 操作
    >>> if 2 in sc:
            print(22222)

    >>> if 23 in sc:
            print(1111)
    
    >>> for i in sc:  #通过循环可以看出 set确实是无序的
            print(i)

    输出：
    22222
    1
    2
    3
    4
    34
    4545
    6757
    45
    54
    345

    ---------------------------------------------------------------------------------------------------

    # 集合的另一种遍历
    >>> sa = {(1,2,3),(4,5,6),("I","love","China")}

    >>> for i,j,k in sa:
            print(i,j,k)

    输出：
    I love China
    4 5 6
    1 2 3


    # 集合的生成式
    >>> sa = {1,2,3,4,5,6,7,8,9,10}
    # 利用sa生成一个sb
    >>> sb = {i for i in sa}
    >>> print(sb)

    >>> sc = {i for i in sa if i % 2 == 0}
    >>> print(sc)

    # 双重for循环
    # 把sa中的每一个元素的平方生成一个新的集合
    # 1. 用一个for
    >>> sd = {i**2 for i in sa}
    >>> print(sd)

    # 2.使用  enumerate
    >>> for index, every in enumerate(sa):
            print (index , every)
    
    # 3.使用 iter() 迭代器    
    >>> for every in iter(sa):
            print (every)

    输出：
    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    {2, 4, 6, 8, 10}
    {64, 1, 4, 36, 100, 9, 16, 49, 81, 25}
    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, 28, 30, 32, 35, 36, 40, 42, 45, 48, 49, 50, 54, 56, 60, 63, 64, 70, 72, 80, 81, 90, 100}
    0 1
    1 2
    2 3
    3 4
    4 5
    5 6
    6 7
    7 8
    8 9
    9 10
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    ---------------------------------------------------------------------------------------------------
    
    # 集合的内置函数
    # len：长度
    >>> print(len(se))
    # max/min :最值
    # add：向集合中添加元素
    >>> sa = {1,2,3,4,5,6,7,3,2,1}
    >>> print(sa)

    #使用add添加元素打印的结果却是None

    >>> print(sa.add(0))
    >>> sb = sa
    >>> print(sb)
    >>> sb.update({8,9,10})
    >>> print(sb)

    # clear：清空    

    输出：
    42
    {1, 2, 3, 4, 5, 6, 7}
    None
    {0, 1, 2, 3, 4, 5, 6, 7}
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    ---------------------------------------------------------------------------------------------------

    # 删除操作
    # remove 和 discard的区别
    >>> sa = {1,2,3,4,5,6,7}
    >>> print(sa)
    >>> sa.remove(5)
    >>> print(sa)
    #使用discard和remove都可以删除set当中的元素，
    #区别就是remove的元素在set当中没有的话会报错，而discard不会。

    #像上面的sa 集合 如果我执行remove(5)两次就会报错 因为第一次已经删除了
    #第二次sa集合中已经没有了 而用discard(5) 执行几次都不会报错    

    输出：
    {1, 2, 3, 4, 5, 6, 7}
    {1, 2, 3, 4, 6, 7}

    # pop弹出集合的一个内容
    # 删除的内容是随机的
    # 删除的内容没什么规律 随机
    >>> sa = {1,2,3,4,5,6,7}
    >>> print(sa)
    >>> sa.pop()
    >>> print(sa)
    >>> sa.pop()
    >>> print(sa)
    >>> sa.pop()
    >>> print(sa)

    输出：
    {1, 2, 3, 4, 5, 6, 7}
    {2, 3, 4, 5, 6, 7}
    {3, 4, 5, 6, 7}
    {4, 5, 6, 7}

    ---------------------------------------------------------------------------------------------------
    
    # 集合的数学操作
    # intersection：交集
    >>> sa = {1,2,3,4,5,6}
    >>> sb = {4,5,6,7,8,9}
    #sa 和 sb的交集
    >>> print(sa.intersection(sb))

    #difference: 差集
    >>> print(sa.difference(sb))

    #差集的另一种表示
    >>> print(sa - sb)

    #union:并集 注意 并集是无法用+计算的
    >>> print(sa.union(sb))

    输出：
    {4, 5, 6}
    {1, 2, 3}
    {1, 2, 3}
    {1, 2, 3, 4, 5, 6, 7, 8, 9}

frozenset冰冻集合

• 不允许修改的集合

    # 冰冻集合
    >>> print(sa)
    >>> sb= frozenset(sa)
    >>> print(sb)

    输出：
    {1, 2, 3, 4, 5, 6}
    frozenset({1, 2, 3, 4, 5, 6})

总结

数据结构是重点，以上只是总结了一部分，还需要多加练习和思考，彻底弄懂。