18-Python常用数据类型操作2

作者: 撩课学院 | 来源:发表于2018-12-01 16:51 被阅读9次

    1.列表

    概念
        有序的可变的元素集合
    定义
        方式1
            [元素1, 元素2...]
            例如: nums = [1,2,3,4,5]
        方式2
            列表生成式
                快速生成list
                语法
                    range(stop)
                        [0, 1, 2 ... , stop - 1]
                    range(start, stop[, step])
                        [start, start + step, start + 2*step ... <stop]
                        step默认值是1
                注意
                    为了防止生成的列表没有被使用,python3做了一些改变,不会立即生成列表
            列表推导式
                从一个list, 推导出另外一个list
                    概念
                        映射解析
                            一对一变更
                        过滤
                            从多到少
                    语法
                        [表达式 for 变量 in 列表]
                        [表达式 for 变量 in 列表 if 条件]
                    案例
                        [1, 2, 3, 4]
                            获取此列表每个元素的平方, 再次组成一个新的列表
                        [1, 2, 3, 4]
                            获取此列表每个元素(不能是偶数)的平方, 再次组成一个新的列表
        列表的嵌套
            列表中的元素, 还可以是列表
        注意和C语言中数组的区别
            是否可以存放不同的数据类型
            c
                int nums[] = {1,2,3,4,5}
    常用操作
        增
            append
                作用
                    往列表中, 追加一个新的元素
                    在列表的最后
                语法
                    l.append(object)
                参数
                    object
                        想要添加的元素
                返回值
                    None
                注意
                    会直接修改原数组
            insert
                作用
                    往列表中, 追加一个新的元素
                    在指定索引前面
                语法
                    l.insert(index, object)
                参数
                    index
                        索引, 到时会插入到这个索引之前
                    object
                        想要添加的元素
                返回值
                    None
                注意
                    会直接修改原数组
            extend
                作用
                    往列表中, 扩展另外一个可迭代序列
                语法
                    l.extend(iterable)
                参数
                    iterable
                        可迭代集合
                            字符串
                            列表
                            元组
                            ...
                返回值
                    None
                注意
                    会直接修改原数组
                    和append之间的区别
                        extend可以算是两个集合的拼接
                        append是把一个元素, 追加到一个集合中
            乘法运算
                ["a"] * 3
                    =
                        ['a', 'a', 'a']
            加法运算
                ["a"] + ["b", "c"]
                    =
                        ["a", "b", "c"]
                和extend区别
                    只能列表类型和列表类型相加
        删
            del 语句
                作用
                    可以删除一个指定元素(对象)
                语法
                    del 指定元素
                注意
                    可以删除整个列表
                        删除一个变量
                    也可以删除某个元素
            pop
                作用
                    移除并返回列表中指定索引对应元素
                语法
                    l.pop(index=-1)
                参数
                    index
                        需要被删除返回的元素索引
                        默认是-1
                            也就对应着列表最后一个元素
                返回值
                    被删除的元素
                注意
                    会直接修改原数组
                    注意索引越界
            remove
                作用
                    移除列表中指定元素
                语法
                    l.remove(object)
                参数
                    object
                        需要被删除的元素
                返回值
                    None
                注意
                    会直接修改原数组
                    如果元素不存在
                        会报错
                    若果存在多个元素
                        则只会删除最左边一个
                    注意循环内删除列表元素带来的坑
        改
            names[index] = 666
        查
            获取单个元素
                items[index]
                    注意负索引
            获取元素索引
                index()
            获取指定元素个数
                count()
            获取多个元素
                切片
                    items[start:end:step]
            遍历
                方式1
                    根据元素进行遍历
                        for item in list:
    print(item)
                方式2
                    根据索引进行遍历
                        for index in range(len(list)):
    print(index, list[index])
                方式3(了解)
                    创建对应的枚举对象
                        概念
                            通过枚举函数, 生成的一个新的对象
                        作用
                            函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
                            同时列出数据下标和数据
                        语法
                            enumerate(sequence, [start=0])
                                    sequence -- 一个序列、迭代器或其他支持迭代对象。
                                    start -- 下标起始位置。
                        举例
                            l = ["a", "b", "c"]
                            enumerate(l, 1)
                                一个待枚举的对象
                                转换成为list之后, 具体数据如下
                                    [(1, 'a'), (2, 'b'), (3, 'c')]
                    遍历枚举对象
                        for index, value in 枚举对象:
    print(index, value)
                方式4(了解)
                    使用迭代器进行遍历
                        iterL = iter(list)
                        for item in iterL:
    print(item)
        额外操作
            判定
                元素 in  列表
                元素 not in 列表
            比较
                cmp()
                    内建函数
                    如果比较的是列表, 则针对每个元素, 从左到右逐一比较
                        左 > 右
                            1
                        左 == 右
                            0
                        左 < 右
                            -1
                    Python3.x不支持
                比较运算符
                    ==
                    >
                    <
                    ...
                    针对每个元素, 从左到右逐一比较
            排序
                方式1
                    内建函数
                        可以对所有可迭代对象进行排序
                    语法
                        sorted(itrearble, key=None, reverse=False)
                    参数
                        itrearble
                            可迭代对象
                        key
                            排序关键字
                            值为一个函数,此函数只有一个参数且返回一个值用来进行比较
                        reverse
                            控制升序降序
                            默认False
                                升序
                    返回值
                        一个已经排好序的列表
                        列表类型
                方式2
                    列表对象方法
                    语法
                        list.sort(key=None, reverse=False)
                    参数
                        key
                            排序关键字
                            值为一个函数,此函数只有一个参数且返回一个值用来进行比较
                        reverse
                            控制升序降序
                            默认False
                                升序
            乱序
                可以随机打乱一个列表
                    导入random模块
                        import random
                    random.shuffle(list)
            反转
                l.reverse()
                切片反转
                    l[::-1]
    

    2.元组

    概念
        有序的不可变的元素集合
        和列表的区别就是, 元组元素不能修改
    定义
        一个元素的写法
            (666,)
        多个元素的写法
            (1,2,3)
        多个对象,以逗号隔开,默认为元组
            tuple = 1, 2, 3, "sz"
        从列表转换成元组
            tuple(seq)
                将列表转化为元组
            内建函数
        补充: 元组嵌套
            元组的中元素可以是元组
                (1, 2, ("a", "b"))
    常用操作
        增
            
        删
            
        改
            
        查
            获取单个元素
                tuple[index]
                index 为索引
                    可以为负
            获取多个元素
                切片
                tuple[start: end: step]
        额外操作
            获取
                tuple.count(item)
                    统计元组中指定元素的个数
                tuple.index(item)
                    获取元组中指定元素的索引
                len(tup)
                    返回元组中元素的个数
                max(tup)
                    返回元组中元素最大的值
                min(tup)
                    返回元组中元素最小的值
            判定
                元素 in  元组
                元素 not in 元组
            比较
                cmp()
                    内建函数
                    如果比较的是元组, 则针对每个元素, 从左到右逐一比较
                        左 > 右
                            1
                        左 == 右
                            0
                        左 < 右
                            -1
                    Python3.x不支持
                比较运算符
                    ==
                    >
                    <
                    ...
                    针对每个元素, 从左到右逐一比较
            拼接
                乘法
                    (元素1, 元素2...) * int类型数值
                        =
                            (元素1, 元素2..., 元素1, 元素2..., ...)
                加法
                    (元素1, 元素2) + (元素a, 元素b)
                        = 
                            (元素1, 元素2, 元素a, 元素b)
            拆包
                a, b = (1, 2)
                    a = 1
                    b = 2
    

    学习地址:

    撩课-Python大数据+人工智能1
    撩课-Python大数据+人工智能2
    撩课-Python大数据+人工智能3
    撩课-Python大数据+人工智能4
    撩课-Python大数据+人工智能5
    撩课-Python大数据+人工智能6
    撩课-Python-GUI编程-PyQt5

    相关文章

      网友评论

        本文标题:18-Python常用数据类型操作2

        本文链接:https://www.haomeiwen.com/subject/xgfxqqtx.html