精华内容
下载资源
问答
  • Python的序列类型

    2020-06-18 08:36:40
    序列包括列表、元组、字符串、Bytes四种数据类型,因为它们都是按特定顺序排列一组数据,并且下节再补充说明字典和Set集合 列表 列表中元素可以增删改,并且元素的类型可以是Python允许数据类型,元素与元素...

    在编程中,可以给一个变量保存一份数据,也可以给一个变量保存大量数据 。在Python中保存大量数据需要用到列表、元组、字符串、Bytes、字典、Set集合
    序列包括列表、元组、字符串、Bytes四种数据类型,因为它们都是按特定顺序排列的一组数据,并且下节再补充说明字典和Set集合

    1、列表

    列表中的元素可以增删改,并且元素的类型可以是Python允许的数据类型,元素与元素之间的类型也允许不相同

    • 创建列表

      list_name=[]

      list_name=list()

    • 删除列表

      del list_name

    • 操作列表元素

      增:+、append、extend、insert

      append: 把新增的元素当作整体追加到列表末尾。假设新增元素是个列表,这个列表会以一个元素添加到末尾
      extend: 把新增的元素不当做一个整体追加到列表末尾,刚好与append相反
      +: 实现效果跟extend方法一样,只是+会创建一个新变量,而extend不会
      insert: 在指定位置插入元素

      删:del、pop、remove、clear

      del和pop: 删除指定位置的元素,pop会返回删除的元素值,del不会
      remove: 删除指定值第一次出现的元素
      clear: 清空列表

      改:索引或切片

      查:index、count

      index(element_value,start,end): 在start~end的范围内查找element_value元素值,返回第一次出现的索引值。
      count: 统计指定元素在列表中出现的次数

    2、字符串

    字符串是不可变序列。序列的共用方法也适用于字符串

    3、Bytes

    4、元组

    元组是不可变序列。不可变序列就是变量初始化后,不可以更改其中的元素

    • 创建元组

      tuple_name=()

      tuple_name=tuple

    • 删除元组

      del tuple_name

    • 操作元组元素

      tupleName=newTupleName

    5、总结

    • 查看源码可知道,元组的性能比列表好,常用于函数的返回值
    • 如果一组数据初始化不再修改,请使用元组
    • 字典的Key值就是用元组存储
    展开全文
  • Python的序列类型进行操作是我们的必要需求。尤其是切片,以及从列表中建立一个新的列表等操作尤其需求的多。阅读这一部分,我收获很多。PS: 这篇博客有点长,一下看完就请收藏吧。。。 切片 list, tuple, ...

    对 Python 中的序列类型进行操作是我们的必要需求。尤其是切片,以及从列表中建立一个新的列表等操作尤其需求的多。阅读这一部分,我收获很多。PS: 这篇博客有点长,一下看不完就请收藏吧。。。

    切片

    list, tuple, str 以及 Python 中的所有序列类型都支持切片操作,但是他们实际能做的事情比我们想象的多很多

    为什么切片和 range 函数都不包括最后一个元素

    Pythonic 的惯例是不包含切片中的最后一个元素的,这和 Python, C 语言中的用 0 作为位置索引的第一位是相吻合的。这些惯例包括:

    • 当只给了切片上限的时候,可以很容易的看出切片和 range 函数的长度。无论是函数 range(3) 还是 list[:3] 所得到的内容长度均为 3
    • 当切片上下限都给了的时候,内容长度也很容易得到 stop - start ,即上限减去下限
    • 把序列按照索引 x 分开而不发生重叠的方法很简单, list[:x]list[x:] :例如
    l = [10, 20, 30, 40, 50, 60]
    l[:2] # [10, 20]
    l[2:] # [30, 40, 50, 60]复制代码

    切片对象

    s[a:b:c] 可以用来指明切片的步长 c ,使得目标切片跳过相应的元素。切片的步长也可以为负,这将导致切片的方向为负方向。

    s = 'bicycle'
    s[::3] # 'bye'
    s[::-1] # 'elcycib'
    s[::-2] # 'eccb'复制代码

    a:b:c 只有位于 [] 内才生效,用来产生一个切片对象。当执行 seq[start:stop:step] 的时候, Python 会调用 seq.__getitem__(slice(start, stop, step)) 。即使你没有在你自定义的序列类型中实现这个方法,知道切片对象是怎么产生作用,也是很有用的。

    如果需要处理偏平的数据 (flat-like data),如例子2-11所示的那样,为了处理的更加明确,可以直接将对应的切片命名。这对于可读性来说,是很有帮助的。

    # 例子2-11,处理偏平数据
    invoice = """
    ... 0.....6.................................40........52...55........
    ... 1909 Pimoroni PiBrella $17.50 3 $52.50
    ... 1489 6mm Tactile Switch x20 $4.95 2 $9.90
    ... 1510 Panavise Jr. - PV-201 $28.00 1 $28.00
    ... 1601 PiTFT Mini Kit 320x240 $34.95 1 $34.95
    ... """
    SKU = slice(0, 6)
    DESCRIPTION = slice(6, 60)
    UNIT_PRICE = slice(40, 52)
    QUANTITY = slice(52, 55)
    ITEM_TOTAL = slice(55, None)
    line_items = invoice.split('\n')[2:]
    for item in line_items:
        print item[UNIT_PRICE], item[DESCRIPTION]复制代码

    将对应的切片命名,可以便于我们阅读,找到我们需要提取的信息。

    多维切片和省略号

    在第三方包 NumPy 中,可以使用 [] 操作符操作用逗号分隔的多个索引值或者切片来获取元素。最简单的操作便是 a[i, j] ,其中 a 的类型为 numpy.ndarray 。二维的切片操作为 a[m:n, k:l]__getitem____setitem__ 特殊方法就是用来处理 [] 的。为了执行 a[i, j] ,实际的 Python 调用为 a.__getitem__((i, j)) 。里面的多维索引被封装成了元组传给了对应的特殊函数。但是 Python 内置的序列类型只是一维的,并不支持多维操作,sad。

    Python 使用省略号来作为多维切片的简写,例如 x[i, ...] 等同于 x[i, :, :, :, ] 。此处 x 为四维数组。

    对切片赋值

    可变的序列类型可以用切片进行直接操作。

    l = list(range(10))
    l # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    l[2:5] = [20, 30]
    l # [0, 1, 20, 30, 5, 6, 7, 8, 9]
    del l[5:7]
    l # [0, 1, 20, 30, 5, 8, 9]
    l[3::2] = [11, 22]
    l # [0, 1, 20, 11, 5, 22, 9]
    l[2:5] = 100
    # Traceback (most recent call last):
    # File "<stdin>", line 1, in <module>
    # TypeError: can only assign an iterable
    l[2:5] = [100]
    l # [0, 1, 100, 22, 9]复制代码

    对切片进行赋值时,右侧的对象必须得是可遍历对象,即使只有一个元素。

    使用 +* 来操作序列

    程序员都期待序列类型支持 +* 。当使用 + 操作的时候,两边的对象必须是相同的序列类型,而且两个对象都不能被改变,但是会产生一个相同类型的对象作为结果。

    当把一个序列对象乘以一个整数的时候,一个新的序列会被创建,原序列不变。

    l = [1, 2, 3]
    l * 5 # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
    5 * 'abc' # 'abcdabcdabcdabcdabcd'复制代码

    +* 都不会改变其操作数,但是会产生一个新的对象。

    小建议:

    当进行 a * n 的操作时,而 a 又是一个包含可变元素的序列时,结果可能会很有趣。

    a = [[1]]
    b = a * 3 # [[1], [1], [1]]
    a[0][0] = 2
    a # [[2]]
    b # [[2], [2], [2]]复制代码

    这里面的传递是引用传递,所以进行修改时,会影响到很多。这方面切记!

    建立一个列表的列表

    有时我们需要建立一个包含嵌套列表的列表,实现这个的最好办法就是列表解析。

    # 例子2-12,包含三个长度为3列表的列表,可以用来表示一个一字棋
    border = [['_'] * 3 for i in range(3)] # 注释1
    print border # [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
    border[1][2] = 'X' # 注释2
    print border # [['_', '_', '_'], ['_', '_', 'X'], ['_', '_', '_']]复制代码
    1. 创建一个包含3个元素的列表,每个元素包含三个元素。注意查看其结构
    2. 在第一行第二列出放一个标记,查看结果

    对比看来,例子2-13是一个错误的例子

    # 例子2-13,同样的例子,但是是错的
    weird_board = [['_'] * 3] * 3 # 注释1
    print weird_board
    weird_board[1][2] = '0' # 注释2
    print weird_board复制代码
    1. 最外层列表有三个指向相同引用的列表组成。不改变的时候,看起来没毛病
    2. 在第一行第二列放置一个标记,可以发现每一行都指向了相同的元素

    例子2-13其实相当于

    row = ['_'] * 3
    board = []
    for i in range(3):
        board.append(row) # 注释1复制代码
    1. 被添加到 board 里面的列表都是同一个

    而对应的,例子2-12和以下代码是等同的。

    board = []
    for i in range(3):
        row = ['_'] * 3 # 注释1
        board.append(row)
    print board # [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
    board[2][0] = 'X'
    print board # 注释2
    # [['_', '_', '_'], ['_', '_', '_'], ['X', '_', '_']]复制代码
    1. 每次迭代都新建立了一个列表,并添加到了 board 后面
    2. 只有对应的第二列改变了,如我们所期待的那样

    增广的序列赋值

    +=*= 可以和正常的运算非常不同。此处只讨论 += ,其思想概念完全适用于 *= 。让其工作的特殊函数为 __iadd__ 。如果这个特殊函数没有被实现, Python 会调用 __add__ 作为备用。

    a += b复制代码

    如果 __iadd__ 被实现了就会被调用。对于可变序列(如 list, bytearray, array.array),a 会在原地被改变。而如果 __iadd__ 没有被实现,那么表达式 a += b 就和 a = a + b 完全一样了。同样的,*= 对应特殊函数 __imul__ ,一下是一些简单例子。

    l = [1, 2, 3]
    id(l) # 4311953800 注释1
    l *= 2 
    l # [1, 2, 3, 1, 2, 3]
    id(l) # 4311953800 注释2
    t = (1, 2, 3)
    id(t) # 4312681568 注释3
    t *= 2
    id(t) # 4301348296 注释4复制代码
    1. 初始列表的id
    2. 做了运算之后,l 还是其本身,只是在最后面添加上了新的元素
    3. 初始元组的id
    4. 做了运算之后,元组被改变

    重复进行不可变序列的连结是效率很低的,因为除了将需要的元素添加到目标元素的后面之外,解释器还得把得到的整个序列复制到新的内存中。

    一个有趣的 += 赋值难题

    # 例子2-14,一个谜题
    t = (1, 2, [30, 40])
    t[2] += [50, 60]复制代码

    会发生什么呢?t 是一个不可变的元组,是不能做修改的,而 t[2] 又是一个可变的列表。结果可能会让人吃惊

    # 例子2-15,例子2-14的输出
    # Traceback (most recent call last):
    # File "<stdin>", line 1, in <module>
    # TypeError: 'tuple' object does not support item assignment
    print t # (1, 2, [30, 40, 50, 60])复制代码

    也就是说 Python 一边报错,一边输出了正确的结果。(傲娇的 Python )

    这里安利一下一个网站 Online Python Tutor ,在这里可以看出程序运行期间具体都发生了什么,有兴趣就自己去看运行时吧。具体不介绍,但是谁用谁知道。

    小建议:

    值得指出的是,使用 t[2].extend([50, 60]) 就不会出错。这里只是指出 += 的怪异行为。

    总结上面的例子:

    1. 把可变元素放在元组之中不是什么好主意
    2. 增广赋值操作并不是原子操作

    list.sort 和内置的 sorted 函数

    list.sort 函数会对 list 进行原地排序,函数的返回值为 None 来告知我们 list 本身已经被修改了,同时也不会产生新的 list 。这是 Python Api 的一个重要惯例:函数或者方法如果原地修改了一个对象,应该返回一个 None ,来让人清楚的知道对象本身被改变了,以及没有新的对象被创建。

    与之形成对比的,Python 的内置函数 sorted 创建了一个新的 list 并将其返回。sorted 函数接受任何可遍历对象作为输入参数,包括不可变序列和生成器。无论输入参数是什么类型,sorted 函数总会创建一个新的 list ,并将其返回。

    list.sortsorted 函数接收两个可选的,只接受关键词的参数

    • reverse 如果为 True ,元素会以逆序的形式返回,默认为 False
    • key 决定每个元素被排序时的排序依据。例如 key=str.lower 会进行大小写无关的排序,key=len 会把字符串按照长度排序。

    具体的例子省略,但是没有任何难度。

    通过 bisect 函数来操作排序的序列

    bisect(haystack, needle)会对 haystack 做二分查找来搜寻 needle,这自然必须要求 haystack 是一个排序后的序列。

    bisect 来搜索

    # 例子2-17,bisect 找到元素的插入位置
    import bisect
    import sys
    
    HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
    NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]
    
    ROW_FMT = '{0:2} @ {1:2}         {2}{0:<2}'
    
    def demo(bisect_fn):
        for needle in reversed(NEEDLES):
            position = bisect_fn(HAYSTACK, needle) # 注释1
            offset = position * '  |' # 注释2
            print ROW_FMT.format(needle, position, offset) # 注释3
    
    if __name__ == '__main__':
    
        if sys.argv[-1] == 'left': # 注释4
            bisect_fn = bisect.bisect_left
        else:
            bisect_fn = bisect.bisect
        print('DEMO:', bisect_fn.__name__) # 注释5
        print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))
        demo(bisect_fn)复制代码
    1. 使用 bisect 函数来获得插入点
    2. 根据偏移量来画分割线
    3. 格式化输出
    4. 通过命令行参数来选择对应的 bisect 函数
    5. 在表头打印函数名称
    ('DEMO:', 'bisect')
    ('haystack ->', ' 1  4  5  6  8 12 15 20 21 23 23 26 29 30')
    31 @ 14           |  |  |  |  |  |  |  |  |  |  |  |  |  |31
    30 @ 14           |  |  |  |  |  |  |  |  |  |  |  |  |  |30
    29 @ 13           |  |  |  |  |  |  |  |  |  |  |  |  |29
    23 @ 11           |  |  |  |  |  |  |  |  |  |  |23
    22 @  9           |  |  |  |  |  |  |  |  |22
    10 @  5           |  |  |  |  |10
     8 @  5           |  |  |  |  |8 
     5 @  3           |  |  |5 
     2 @  1           |2 
     1 @  1           |1 
     0 @  0         0复制代码

    这张图展示了 bisect 函数的具体工作过程。和函数 bisect_left 的比较就是,当遇到相同元素时,bisect (也就是 bisect_right),把元素插入了右边,而 bisect_left 插到了左边。例子2-18是一个简单应用。

    # 例子2-18,给定分数,输入对应的成绩分区
    def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
        i = bisect.bisect(breakpoints, score)
        return grades[i]
    
    print [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]复制代码

    bisect.insort 来插入

    对序列排序是很耗时的操作,所以一旦一个序列已经排好序,我们希望后续的操作依旧可以保持排序状态。

    # 例子2-19,Insort函数保持排序状态
    import bisect
    import random
    SIZE = 7
    random.seed(1729)
    my_list = []
    for i in range(SIZE):
        new_item = random.randrange(SIZE*2)
        bisect.insort(my_list, new_item)
        print('%2d ->' % new_item, my_list)复制代码

    输出结果为:

    ('13 ->', [13])
    ('12 ->', [12, 13])
    (' 5 ->', [5, 12, 13])
    (' 6 ->', [5, 6, 12, 13])
    (' 9 ->', [5, 6, 9, 12, 13])
    (' 2 ->', [2, 5, 6, 9, 12, 13])
    (' 4 ->', [2, 4, 5, 6, 9, 12, 13])复制代码

    也许有时 List 不是最好的选择

    list 是那么的好用,以至于我们选择使用 list 几乎不需要做多余的思考。但有时,例如我们需要存储一个一千万的浮点数列表,使用 array 是更高效的选择,因为 array 并不是把 float 对象完全的存贮下来,而只是存下来了打包的字节。如果我们需要不断的添加或者删除元素,这是 deque 是更好的选择。如果你需要做大量的 in 操作,那么 set 是更好的选择。

    Arrays

    如果序列中只有数, array.array 是一个更高效的选择。和 list 一样,它也支持所有的可变序列的操作,包括 pop, insert, extend。它还支持快速加载和保存的 frombytestofile 方法。

    和 C 语言中的 array 一样,创建 array 需要指明存储类型。array('b') 表明每个元素都是一个字节,被解释为从 -128 到 127 的整数。对于体积很大的序列来说,这个很节省空间。同时 array 会检查你的输入,不会允许你把类型不对的元素放进去。

    # 例子2-20,创建,保存,加载一个大的数组
    from array import array # 注释1
    from random import random
    floats = array('d', (random() for i in range(10**7))) # 注释2
    print floats[-1] # 注释3
    fp = open('floats.bin', 'wb')
    floats.tofile(fp) # 注释4
    fp.close()
    floats2 = array('d') # 注释5
    fp = open('floats.bin', 'rb')
    floats2.fromfile(fp, 10**7) # 注释6
    fp.close()
    print floats2[-1] # 注释7
    print floats2 == floats # 注释8复制代码
    1. 创建一个数组类型
    2. 从一个可遍历对象中,创建一个双精度浮点数的数组(关键字为 d)。此处的可遍历对象为生成器
    3. 查看一下最后一个元素
    4. 把 array 存储为二进制文件
    5. 创建一个双精度浮点数的空数组
    6. 从二进制文件中读取一千万个浮点数
    7. 检查数组中的最后一个数
    8. 比较两个数组

    重点是,这些操作相当迅速。我自己曾经试着用 list 来操作数据,写文件然后读文件,相当慢。对于数组来说 array.fromfile 只需要 0.1 秒的时间从二进制文件中来加载一千万个双精度浮点数的数组,这个几乎比从文本文件中读取要快 60 倍。同样的,array.tofile 也比一个个往每一行中写浮点数要快差不多 7 倍。更重要的是,存储一千万个浮点数的二进制文件只有差不多 80 M,而写文本文件则差不多要 180 M。

    小建议:

    在 Python 3.4 中,array 并没有像 list.sort() 那样的原地排序操作,如果需要的话,可以进行如下操作

    a = array.array('d', sorted(a))复制代码

    源码的github地址

    源代码
    以上源代码均来自于 fluent python 一书,仅为方便阅读之用。如侵删。

    转载于:https://juejin.im/post/58ea3cac570c350057d8d878

    展开全文
  • 所谓序列,指是一块可存放多个值连续...在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持以下几种通用操作,但比较特殊是,集合和字典支持索引、切片、相加和相乘操作。 字符串也是

    所谓序列,指的是一块可存放多个值的连续内存空间,这些值按一定顺序排列,可通过每个值所在位置的编号(称为索引)访问它们。

    为了更形象的认识序列,可以将它看做是一家旅店,那么店中的每个房间就如同序列存储数据的一个个内存空间,每个房间所特有的房间号就相当于索引值。也就是说,通过房间号(索引)我们可以找到这家旅店(序列)中的每个房间(内存空间)。

    在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持以下几种通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。

    字符串也是一种常见的序列,它也可以直接通过索引访问字符串内的字符。

    序列索引 append() list. insert(0,“a”).

    序列中,每个元素都有属于自己的编号(索引)。从起始元素开始,索引值从 0 开始递增,如图 1 所示。

    img
    图 1 序列索引值示意图

    除此之外,Python 还支持索引值是负数,此类索引是从右向左计数,换句话说,从最后一个元素开始计数,从索引值 -1 开始,如图 2 所示。

    img
    图 2 负值索引示意图

    注意,在使用负值作为列序中各元素的索引值时,是从 -1 开始,而不是从 0 开始。

    无论是采用正索引值,还是负索引值,都可以访问序列中的任何元素。以字符串为例,访问“C语言中文网”的首元素和尾元素,可以使用如下的代码:

    str="C语言中文网"
    print(str[0],"==",str[-6])
    print(str[5],"==",str[-1])
    

    输出结果为:

    C == C
    网 == 网

    序列切片

    切片操作是访问序列中元素的另一种方法,它可以访问一定范围内的元素,通过切片操作,可以生成一个新的序列。

    序列实现切片操作的语法格式如下:

    sname[start : end : step]

    其中,各个参数的含义分别是:

    • sname:表示序列的名称;
    • start:表示切片的开始索引位置(包括该位置),此参数也可以不指定,会默认为 0,也就是从序列的开头进行切片;
    • end:表示切片的结束索引位置(不包括该位置),如果不指定,则默认为序列的长度;
    • step:表示在切片过程中,隔几个存储位置(包含当前位置)取一次元素,也就是说,如果 step 的值大于 1,则在进行切片去序列元素时,会“跳跃式”的取元素。如果省略设置 step 的值,则最后一个冒号就可以省略。

    例如,对字符串“C语言中文网”进行切片:

    str="C语言中文网"
    #取索引区间为[0,2]之间(不包括索引2处的字符)的字符串
    print(str[:2])
    #隔 1 个字符取一个字符,区间是整个字符串
    print(str[::2])
    #取整个字符串,此时 [] 中只需一个冒号即可
    print(str[:])
    

    运行结果为:

    C语
    C言文
    C语言中文网

    序列相加

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

    这里所说的“类型相同”,指的是“+”运算符的两侧序列要么都是列表类型,要么都是元组类型,要么都是字符串。

    例如,前面章节中我们已经实现用“+”运算符连接 2 个(甚至多个)字符串,如下所示:

    str="www.baidu.com"
    print("C语言"+"中文网:"+str)
    

    输出结果为:

    C语言中文网:www.baidu.com

    序列相乘

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

    str="C语言中文网"
    print(str*3)
    

    输出结果为:

    ‘C语言中文网C语言中文网C语言中文网’

    比较特殊的是,列表类型在进行乘法运算时,还可以实现初始化指定长度列表的功能。例如如下的代码,将创建一个长度为 5 的列表,列表中的每个元素都是 None,表示什么都没有。

    #列表的创建用 [],后续讲解列表时会详细介绍
    list = [None]*5
    print(list)
    

    输出结果为:

    [None, None, None, None, None]

    检查元素是否包含在序列中

    Python 中,可以使用 in 关键字检查某元素是否为序列的成员,其语法格式为:

    value in sequence

    其中,value 表示要检查的元素,sequence 表示指定的序列。

    例如,检查字符‘c’是否包含在字符串“www.baidu.com”中,可以执行如下代码:

    str="www.baidu.com"
    print('b'in str)
    

    运行结果为:

    True

    和 in 关键字用法相同,但功能恰好相反的,还有 not in 关键字,它用来检查某个元素是否不包含在指定的序列中,比如说:

    str="www.baidu.com"
    print('e' not in str)
    

    输出结果为:

    False

    和序列相关的内置函数

    Python提供了几个内置函数(表 3 所示),可用于实现与序列相关的一些常用操作。

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

    这里给大家给几个例子:

    str="www.baidu.com"
    #找出最大的字符
    print(max(str))
    #找出最小的字符
    print(min(str))
    #对字符串中的元素进行排序
    print(sorted(str))
    

    输出结果为:

    w
    .
    [’.’, ‘.’, ‘a’, ‘b’, ‘c’, ‘d’, ‘i’, ‘m’, ‘o’, ‘u’, ‘w’, ‘w’, ‘w’]

    展开全文
  • Python 序列类型

    2021-02-18 18:07:12
    序列类型 容器序列 list、tuple、collections.de’que 以上三种可以存放不同类型数据,混搭; 扁平序列 str:字符串类型; bytes:以二进制形式来存储数据; bytearray:返回一个新字节数组,数组里元素是可变...

    序列类型

    容器序列
    list、tuple、collections.de’que
    以上三种可以存放不同类型的数据,混搭;
    扁平序列
    str:字符串类型;
    bytes:以二进制的形式来存储数据;
    在这里插入图片描述

    bytearray:返回一个新字节数组,数组里的元素是可变的;
    在这里插入图片描述

    memoryview:返回指定参数的内存查看对象,即不需要复制对象的基础上对数据进行访问;
    在这里插入图片描述

    容器序列存放的是任意类型对象的引用;
    扁平序列存放的是值;

    可变序列与不可变序列
    可变序列包括list、bytearray、collections.deque、memoryview等;
    不可变序列包括tuple、str、bytes;
    序列类共有特性
    在这里插入图片描述
    列表推导和生成器表达式
    利用列表推导返回字符串中字符对应的Unicode码位;
    在这里插入图片描述
    列表推导式直接生成数据对象;
    生成器表达式逐个产生元素从而避免产生额外的内存占用;
    在这里插入图片描述
    元组
    元组可以理解为对数据的记录,每个位置可以理解为是对特定字段的存储;
    元组拆包,对每个位置数据给予特定意义;
    在这里插入图片描述
    用*来处理剩下元素;
    在这里插入图片描述

    嵌套元组拆包;
    在这里插入图片描述

    可以调用collections.namedtuple来构建一个带字段名的元组和带名字的类,就像数据库里建表一样;
    在这里插入图片描述
    切片
    在这里插入图片描述

    可以通过切片对序列进行间隔、逆序、跳着取数等操作;
    +和*操作
    在这里插入图片描述
    +和*都不改变原有序列而是生成新的序列;

    展开全文
  • Python的序列

    2021-03-21 20:14:08
    Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持以下几种通用的操作,但比较特殊的是,集合和字典支持索引、切片、相加和相乘操作。 序列索引是支持两种类型相同的序列使用“+”运算符做...
  • Python-序列

    2020-09-30 18:08:17
    Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持一些通用操作,但比较特殊是,集合和字典支持索引、切片、相加和相乘操作。 1. 针对序列内置函数 list(sub) 把一个可迭代对象转换...
  • 学习python的序列(列表List) 前言 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。 Python有6个序列的内置类型,但最常见的是...
  • 本篇内容涉及字符串、列表、元组、Python报错,以及变量本质,包括引用计数技术 该篇只为抛砖引玉,其内容来自Python学习中总结,另外感谢李老师教导和Python班同学们帮助 首先解释:序列数据和变量 1....
  • 序列类型 — list, tuple, range ...大多数序列类型包括可变类型和可变类型都支持下表中操作。 collections.abc.Sequence ABC 被提供用来更容易地在自定义序列类型上正确地实现这些操作。 此表...
  • python序列

    2019-11-20 19:48:17
    PYthon中,序列类型包括字符串、列表list、元组tuple、集合和字典dic,这些序列支持以下几种通用操作,但比较特殊是,集合和字典支持索引、切片、相加和相乘操作。 序列中,每个元素都有属于自己编号(索引...
  • Python中的组合数据类型包括序列类型、字典和集合。所有的这些类型对象都是可迭代(iterable)的。 序列 Python的序列包括字符串,列表,元组。序列中每一个元素都有一个跟位置相关的序号称为索引。 字符串 Python...
  • python 序列

    2019-10-12 05:59:56
    字符串是单个字符的字符串的序列,其他类型的序列包括列表和元组。 序列支持获取长度、索引(正向和反向)、分片、合并、重复的功能。 获取长度:len() 索引:[]方括号中可使用任意表达式,而仅仅是使用数字常量...
  • Python核心数据类型之序列类型及其运算(列表、元组运算及其拷贝)序列:序列表示索引为非负整数有序对象集合,包括字符串、列表和元组,所有序列都支持迭代;序列类型:字符串(strings):字符串也属于序列类型...
  • 这种方法并限于列表和元组,而是适用于任意序列类型(甚至包括字符串和字节序列)。只要赋值运算符左边变量数目与序列中元素数目相等,你都可以用这种方法将元素序列解包到另一组变量中。 解包使用还可以更...
  • Python 中有很多很实用语法糖,这些语法糖可以帮助我们...先看一个例子:>>> a, b, c = 1, 2, 3>>> a1>>> b2>>> c3>>>这种方法并限于列表和元组,而是适用于任意序列类型(甚至包括字符串和字节序列)。只要赋...
  • Python序列详解

    2020-10-14 15:35:56
    Python序列详解 所谓序列,指是一块可存放多个值连续内存...在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持以下几种通用操作,但比较特殊是,集合和字典支持索引、切片、相加和
  • Python的数值类型 在python中,数字并不是一个真正的对象类型,而是一组类似类型的分类。这些主要包括整数,浮点数,布尔类型和复数。这些是相对来说比较常用的,复数一般都用在比较精密的科学计算中,还是主要看...
  • Python3包含6中内建的序列:即列表、元组、字符串、Unicode字符串、buffer对象和 xrange 对象。 序列通用的操作包括:索引、长度、组合(序列相加)、重复(乘法)、分片、检查成员、遍历、最小值和最大值。 列表和...
  • Python的数字类型

    千次阅读 2018-04-14 16:23:50
    Python数字类型是 非序列对象,可迭代对象,可变性Python数字类型包括:整数和浮点数复数固定精度十进制有理分数集合布尔类型无穷整数精度各种数字内置函数和模块数字常量基本数字常量 表格数字常量1234,...
  • python的序列使用

    2020-07-10 10:20:13
    step] name:表示序列的名字 start:表示序列的开始元素,包括该位置,默认0 end:表示结束位置,不包括该值。 step:表示步长,每次递增几个 3.序列相加,只有相同类型序列的可以连接,内容可以不同。 4.检查某个...
  • marshal marshal使用的是与Python语言相关但与机器无关的二进制来读写Python对象的。...marshal一般用于Python内部对象的序列化。 一般地包括: 基本类型 booleans, integers,floating point numbers,complex n...
  • {} 中相邻元素之间用“,”分隔,从内容上看,同一集合中,只能存储可变数据类型包括整形、浮点型、布尔型、字符串、元组,无法存储列表、字典、集合这些可变数据类型,否则 Python 解释器会抛出 TypeError ...
  • 集合由可变数据类型元素组成,如整数、浮点数、复数,字符串、元组类型等 集合用大括号{}组成,元素之间用逗号隔开 每个元素唯一,存在相同元素 一、集合间操作 并(S|T) S-T S&T S^T 返回一个新...
  • 1.marshal ...marshal一般用于Python内部对象的序列化。 一般地包括: 基本类型 booleans, integers,floating point numbers,complex numbers 序列集合类型 strings, bytes, bytearray, tuple, list,
  • 只包含可打包对象集合,包括 tuple、list、set 和 dict 定义在模块顶层函数(使用 def 定义,lambda 函数则可以) 定义在模块顶层内置函数 定义在模块顶层类 某些类实例,这些类 _...
  • Python基础之序列

    2020-07-30 16:36:14
    Python中,序列类型包括字符串,列表,元组,集合,字典,这些序列支持一些通用操作,比较特殊是集合和字典,它们支持索引,切片,相加相乘操作。 1.序列内置函数 list():把一个可迭代对象转换成列表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 568
精华内容 227
关键字:

python的序列类型不包括

python 订阅