精华内容
下载资源
问答
  • 内置序列类型概览按照可否存储不同数据类型来分,可以分为容序列和扁平序列。容器序列list, tuple, collections.deque 这些序列类型可以容纳不同类型数据。扁平序列str, bytes, bytearray, memoryview, array....

    内置序列类型概览

    按照可否存储不同数据类型来分,可以分为容序列和扁平序列。

    容器序列

    list, tuple, collections.deque 这些序列类型可以容纳不同类型的数据。

    扁平序列

    str, bytes, bytearray, memoryview, array.array 这类序列只能容纳一种类型的数据

    按照是否可变可以分为可变序列和不可变序列。

    可变序列

    list, bytesarray, array.array, collections.deque, memoryview

    不可变序列

    tuple, str, bytes

    列表推导式和生成器表达式

    列表推导是构建列表的快捷方式。而生成器表达式则可以用来创建其他的任何序列。

    善于使用列表推导式1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21from pprint import pprint

    a=[1,2,3]

    b=["a","b","c"]

    c=[(d,e) for d,e in zip(a,b)]

    print(c)

    g=[(i,j) for i in a for j in b]

    pprint(g)

    """注意比较c,g两个列表推导式的区别"""

    h=[i+i for i in range(10) if i % 2==0]

    print(h)

    #生成器表达式

    #把列表推导式的中括号改为圆括号就得到了生成器表达式

    a=(i for i in range(10))

    print(a)

    print(a.__next__())

    print(a.__next__())

    print(a.__next__())

    print(a.__next__())

    print(a.__next__())

    #当生成器表达式作为函数调用过程中的唯一

    #参数的时候不需要再用圆括号括起来

    输出:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17[(1, 'a'), (2, 'b'), (3, 'c')]

    [(1, 'a'),

    (1, 'b'),

    (1, 'c'),

    (2, 'a'),

    (2, 'b'),

    (2, 'c'),

    (3, 'a'),

    (3, 'b'),

    (3, 'c')]

    [0, 4, 8, 12, 16]

    at 0x7f28a9f3fc50>

    0

    1

    2

    3

    4

    元组不仅仅是不可变列表

    如果仅仅是把元组理解为不可变的列表,那其他的信息——他所含有的元素的总数和他们的位置似乎就变得可有可无了。但是这样并没有发挥元组本来所有的力量。元组的特点就是它所记录数据的数量和位置。

    元组拆包1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23#拆包

    a=(1,2,3)

    n1,n2,n3=a

    print(n1)

    print(n2)

    print(n3)

    #用*处理剩下的元素

    b=("aaa","bbb","ccc","ddd")

    b1,b2,*rest=b

    print(b1)

    print(b2)

    print(rest)

    #变量的值

    m=1

    n=2

    print(m,n)

    m,n=n,m

    print(m,n)

    #用*运算符把一个可迭代对象拆开作为函数的参数

    c=(5,6)

    def myadd(a,b):

    return a+b

    print(myadd(*c))

    输出:

    1

    2

    3

    4

    5

    6

    7

    8

    91

    2

    3

    aaa

    bbb

    ['ccc', 'ddd']

    1 2

    2 1

    11

    具名元组

    collctions.namedtuple()是一个工厂函数,它可以用来构建一个带字段名的元组和一个有名字的类。

    基本使用1

    2

    3

    4

    5

    6

    7from collections import namedtuple

    City=namedtuple("City",["name","country","population"])

    Beijing=City("Beijing","China",100)

    Tokyo=City("Tokyo","Japan",96)

    print(Beijing.country)

    print(Tokyo.population)

    print(Tokyo[1])

    输出:

    1

    2

    3China

    96

    Japan

    创建一个具名元组需要两个参数,一个是类名,另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象,或者是由空格分隔开的字段名组成的字符串。存放在对应字段里的数据要以一串参数的形式传入到构造函数中。可以通过字段名或者位置来获取一个字段的信息。

    具名元组的属性和方法1

    2

    3

    4

    5

    6print(City._fields)#获得所有的字段名

    cityMsg=("Shanghai","China",99)

    shanghai=City._make(cityMsg)#创建对象的一种方式,和City(*cityMsg)一样

    print(shanghai._asdict())

    for key,value in shanghai._asdict().items():

    print(key,":",value)

    输出:

    1

    2

    3

    4

    5('name', 'country', 'population')

    OrderedDict([('name', 'Shanghai'), ('country', 'China'), ('population', 99)])

    name : Shanghai

    country : China

    population : 99

    序列排序

    在这里我们用list这一个序列来作为例子讲解python中序列的排序,其他的可排序序列和list是一致。这里主要讨论list.sort()和sorted()。前者是对列表就地排序,它会返回None,将list改变为有序的list.而后者则不会改变传入的list,只是复制了一个新的list,将新的list调整顺序之后返回。无论是list.sort()还是sorted()都有两个可选的关键字参数:key,reverse。他们分别决定排序的标准和升降序。

    用bisect来管理已排序的序列

    bisect模块包含两个主要的函数,bisect和insort两个函数都是利用二分查找算法来在有序序列中查找或插入元素。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10import bisect

    a=[1,2,38,85]

    b=bisect.bisect(a,39)

    #返回39插入已升序排序序列a中后仍然满足升序规则的下标值

    a.insert(b,39)

    print(a)

    #上面两步操作可以直接用下面的替代

    c=[1,2,38,85]

    d=bisect.insort(c,39)#直接插入并且保持升序

    print(c)

    输出:

    1

    2[1, 2, 38, 39, 85]

    [1, 2, 38, 39, 85]

    当列表不是首选时

    有时候因为列表实在太方便了,所以python程序员会过度使用它。但是,如果你只需要处理数字列表的话,数组可能是个更好的选择,下面我们就来探讨一下可以替换列表的数据结构。

    数组

    数组(array)可以紧凑盛放基本的变量,如:字符,整数,浮点数。他是一个序列类型,在表现上和list非常想,但是它存储的数据类型受到了限制,它只能存储相同的基本类型的数据。所存储的数据的类型由array对象初始化时传入的typecode指定。以下的为所支持的typecode:

    Typecode

    C Type

    Python Type

    Minimum size in bytes

    b

    signed char

    int

    1

    B

    unsigned char

    int

    1

    u

    Py_UNICODE

    Unicode character

    2

    h

    signed short

    int

    2

    H

    unsigned char

    int

    2

    i

    signed int

    int

    2

    I

    unsigned int

    int

    2

    l

    signed long

    int

    4

    L

    unsigned long

    int

    4

    q

    signed long long

    int

    8

    Q

    unsigned long long

    int

    8

    f

    float

    float

    4

    d

    double

    float

    8

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15from array import array

    from random import random

    a1=array('q',(i for i in range(100)))

    #其基本上和list具备相同的行为

    print(a1.typecode)

    print(a1[2])

    print(a1.count(55))

    print(a1.pop())

    a3=array('d',(random() for i in range(10**3)))

    with open("float.bin","wb") as f:

    a3.tofile(f)

    a2=array("d")

    with open("float.bin","rb") as f2:

    a2.fromfile(f2,10**3)

    print(a2[3])

    内存视图

    memoryview是一个内置类,他能让用户在不复制内容的情况下操作同一个数组的不同切片,在数据结构之间共享内存。

    1

    2

    3

    4

    5

    6

    7

    8from array import array

    a=array('h',[1,2,3])

    print(a)

    m1=memoryview(a)

    print(len((m1)))

    m1[0]=15

    print(m1)

    print(a)

    输出:

    1

    2

    3

    4array('h', [1, 2, 3])

    3

    array('h', [15, 2, 3])

    双向队列和其他形式的队列1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19from collections import deque

    dq=deque(range(10),maxlen=10)

    print(dq)

    dq.rotate(3)

    print(dq)

    dq.rotate(-3)

    print(dq)

    dq.append(100)

    print(dq)

    dq.appendleft(-100)

    print(dq)

    dq.extend([111,222,333])

    print(dq)

    dq.extendleft([-111,-222,-333])

    print(dq)

    print(dq.pop())

    print(dq)

    print(dq.popleft())

    print(dq)

    输出:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)

    deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)

    deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)

    deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 100], maxlen=10)

    deque([-100, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)

    deque([3, 4, 5, 6, 7, 8, 9, 111, 222, 333], maxlen=10)

    deque([-333, -222, -111, 3, 4, 5, 6, 7, 8, 9], maxlen=10)

    9

    deque([-333, -222, -111, 3, 4, 5, 6, 7, 8], maxlen=10)

    -333

    deque([-222, -111, 3, 4, 5, 6, 7, 8], maxlen=10)

    展开全文
  • Python的内置序列类型

    2020-09-27 22:37:57
    Python的内置序列类型 容器序列 list、tuple、collections.deque 能存放不同类型的数据 扁平序列 str、bytes、 bytesarray、 memoryview(内存视图)和array.array,这种序列只能容纳一种类型。 容器序列存放是它们...

    Python的内置序列类型

    容器序列

    list、tuple、collections.deque 能存放不同类型的数据

    扁平序列

    str、bytes、 bytesarray、 memoryview(内存视图)和array.array,这种序列只能容纳一种类型。

    容器序列存放的是它们所包含的任意类型的对象的引用,而扁平序列里存放的是值而不是引用。换句话说,扁平序列其实是一段连续的内存空间。由此可见扁平序列其实更加紧凑,但是它里面只能存放诸如字符、字节和数值这种基础类型。

    memoryview
    用途:(处理大型数据)
    函数返回给定参数的内存查看对象(memoryview)。
    所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问
    语法: memoryview(object)
    1)类似C语言指针,通过memory访问内部数据;无内存拷贝 ;
    2)是泛化和去数学化的Numpy数组,不复制内容前提下在数据结构之间共享内存;
       数据结构可是任何形式,如PIL图片,SQLite数据库,Numpy的数组等
    3)将内存视图转为新格式或形状(底层对象可写支持一维切片;禁调大小)
    3.1)零维内存视图可以使用空元组索引。
    3.2)一维记忆体视图可以用一个整数或一个整数元组索引。
    3.3)多维内存视图可以用精确ndim整数的元组索引,其中ndim是维数。
    
    array.array
    计算机为数组分配一段连续的内存,从而支持对数组随机访问;
    由于项的地址在编号上是连续的,数组某一项的地址可以通过将两个值相加得出,即将数组的基本地址和项的偏移地址相加。
    数组的基本地址就是数组的第一项的机器地址。一个项的偏移地址就等于它的索引乘以数组的一个项所需要的内存单元数目的一个常量表示(在python中,这个值总是1)
    

    序列类型还能按照能否被修改分类

    可变序列

    list,bytearray, array.array, collections.deque 和 memoryview。

    不可变序列

    tuple、str 和 bytes。

    set, dict 无序所以不算序列
    tuple某些情况下是可变的。比如嵌套dict或者list

    可变数据类型是允许同一对象的内容,即值可以变化,但是地址是不会变化的。但是需要注意一点,对可变数据类型的操作不能是直接进行新的赋值操作,比如说a = [1, 2, 3, 4, 5, 6, 7],这样的操作就不是改变值了,而是新建了一个新的对象,这里的可变只是对于类似于append、+=等这种操作。

    python中的不可变数据类型,不允许变量的值发生变化,如果改变了变量的值,相当于是新建了一个对象,而对于相同的值的对象,在内存中则只有一个对象,内部会有一个引用计数来记录有多少个变量引用这个对象;可变数据类型,允许变量的值发生变化,即如果对变量进行append、+=等这种操作后,只是改变了变量的值,而不会新建一个对象,变量引用的对象的地址也不会变化,不过对于相同的值的不同对象,在内存中则会存在不同的对象,即每个对象都有自己的地址,相当于内存中对于同值的对象保存了多份,这里不存在引用计数,是实实在在的对象。

    展开全文
  • Python内置数据类型

    千次阅读 2018-03-28 15:14:33
    Python内置数据类型python中数据类型并不需要显示定义,它会根据初始化赋值情况来分析其类型,并在内部对其进行跟踪python内置数据类型Booleans:[布尔型]或为True或为FalseNumbers : 可以是Intgers[整数]、...
    Python内置数据类型




    python中数据类型并不需要显示的定义,它会根据初始化赋值的情况来分析其类型,并在内部对其进行跟踪


    python内置数据类型


    Booleans:[布尔型]或为True或为False


    Numbers : 可以是Intgers[整数]、Floats[浮点数]、Fractions[分数]甚至是Complex Number[复数]。


    Strings:[字符串型] 是Unicode字符序列


    Byte:[字节]和Byte Array[字节数组]


    Lists[列表]是值得有序序列


    Tuples[元组]是有序而不可变的值序列


    Sets[集合]是装满无序值得包裹


    Dictionaries[字典]是键值对的无序包裹




    math模块下的函数:
    math.pi :代表一个π的常量,表示圆周率
    三角函数
    math.sin() 
    math.cos()
    math.tan()




    列表、元组、集合、字典


    列表是Python的助理数据类型。


    列表常用函数:


    格式:
    a_list = ['a', 'b', 'new', 'mpilgrim']


    append() 在列表末尾最佳元素,可以是任何数据类型,但是都是以一个元素添加到列表
    extend() 方法值接受一个参数,而该参数总是一个列表
    insert() 接受两个参数,第一个参数为列表索引,第二个参数为列表插入列表的值


    count()方法返回列表中某个特定值出现的次数


    'a' in a_list: in 运算符用来判断某个值是否出现在列表中,in运算符总是返回True或False;


    index()方法将查找某个值在列表中第一次出现。并返回出现位置的索引值。如果没有值,index()方法将会引发一个例外


    del a_list[1] 可使用del语句从列表中删除某个特定元素


    删除索引1之后再访问索引1 将不会导致错误。被删除元素后的所有元素将移动他们的位置以'填补'被删除元素所产生的'缝隙'


    a_list.remove('列表里的值'):还可以通过remove()方法从列表中删除某个元素。remove()方法接受一个value参数,并删除列表中改值得第一次出现。同样,被删除元素之后的所有元素将会将索引位置下移,以填补缝隙


    a_list.pop():如果不带参数调用,pop()列表方法将删除列表中最后的元素,并返回所删除的值。 可以从列表中pop[弹出]任何元素。只需要给pop()方法一个位置索引值。他将删除该元素,将其后所有元素移位以'填补'缝隙,
    然后返回它删除的值。
    对空列表调用pop()将会引发一个例外




    元组:
    元组是不可变的列表。一旦创建之后,没有任何途径可以改变列表元素,除非把元组转换为列表


    格式:
    a_tuple = ("a", "b", "mpilgrim", "z", "example")


    元组的定义和李彪相同, 除了整个元素的集合都用圆括号,而不是方括号闭合
    和列表一样,元组的元素都有确定的顺序。元组的索引页是以零为基点的,和列表一样,因此非空元组的第一个元素总是a_tuple[0].
    负的索引从元组的尾部开始计算,这和列表也是一样的。
    元组也可以进行切片操作。对列表切片可以得到新的列表;对元组切片可以得到新的元组。


    元组和列表的主要区别是元组不能进行修改。用技术术语来说,元组是不可变的。从实践的角度来说,没有可用于修改元组的方法。


    元组的优势:
    元组的速度比列表快。如果定义了一系列常量值,而所需做的仅是对它进行遍历,那么请使用元组替代列表。
    对不需要改变的数据进行'写保护'将使得代码更安全。使用元组替代列表就像是有一条隐含的assert语句显示该数据是常量特别的想法必须重写。
    一些元组可用做字典键(特别是包含字符串,数值和其它元组这样的不可变数据的元组)。列表永远不能当做字典键使用,应为列表不是不可变的。


    集合:
    集合set是装有独特值得无序'袋子'。一个简单的集合可以包含任何数据类型的值。如果有两个结合,则可以执行像联合、交集以及集合求差等标准集合运算


    格式:
    a_set = {1}


    创建一个集合,只要将值放置于花括号之间({})
    实际上,集合以类的形式实现,但目前还无须考虑这一点
    要创建多只集合,请将值用逗号分开,并用花括号将所有值包裹起来。




    要从列表创建集合,可使用set()函数。(懂得如果实现集合的学究可能指出这实际上并不是调用某个函数,而是对某个类进行实例化。我保证在本书稍后的地方将会学到其中的区别。目前而言,仅需知道set()行为与函数类似
    以及它返回一个集合


    正如我之前提到的,简单的集合可以包括任何数据类型的值。而且,如我之前所提到的,结合是无序的。该集合并不记得用于创建它的列表中元素的最初顺序。如果向结合中添加元素,他也不会记得添加的顺序


    初始的列表并不会发生变化




    修改集合:
    有两种方法可向现有集合中添加值:add()方法和update()方法


    add()方法接受单个可以是任何数据类型的参数,并将该值添加到集合之中
    集合是装唯一值得袋子,如果试图添加一个结合中已有的值,将不会发生任何事情。


    update()方法仅接受一个集合作为参数,并将其所有成员添加到初始列表中。其行为方式就像是对参数集合中的每个成员调用add方法
    由于集合不能包含重复的值,因此重复的值将会被忽略
    实际上,可以带任何数量的参数调用update()方法。如果调用时传递了两个结合,update()将会被每个集合中的每个成员添加到初始的集合当中(丢弃重复值)
    update()方法还可以接收一些其它的数据类型的对象作为参数,包括列表。如果调用时传入列表,update()将会把列表中所有的元素添加到初始结合中。


    从集合中删除元素


    有三种方法可以用了从集合中删除某个值。discard()、remove()、pop()


    discard()接受一个单值作为参数,并从集合中删除改值
    如果针对一个集合不存在的值调用discard()方法,它不进行任何操作。不产生错误;只是一条命令
    remove()方法也接受一个单值作为参数,也从集合中将其删除
    区别在于:如果该值不在集合中,remove()方法引发一个keyError例外


    pop()方法从集合中删除某个值,并返回该值。然而,由于集合是无序的,并没有最后一个值得概念,因此无法控制删除的是哪一个值。他基本上是随机的。
    clear()方法删除集合中所有的值,留下一个空集合。他等价于a_set=set(),改语句创建一个新的空结合,并用之覆盖a_set变量的之前的值。
    试图从空结合中弹出某值将会引发KeyError例外


    要检测某个值是否是集合的成员,可使用in运算符。其工作原理和列表一样
    union()方法返回一个新集合,其中装着在两个集合中出现的元素。
    intersection()方法返回一个新集合,其中装着同时在两个集合中出现的所有元素
    differenct()方法返回的新集合中,装着所有在a_set出现但未在b_set中的元素
    symmetric_difference()方法返回一个新集合,其中装着所有只在其中一个集合中出现的元素 
    展开全文
  • Python内置数据类型

    2020-04-06 00:39:51
    Python内置的数值数据类型和序列数据类型 Python的数据类型包括内置的数据类型、模块中定义的数据类型和用户自定义数据类型 数值数据类型:int、float、bool、complex 序列数据类型:不可变(str、tuple、bytes)和...

    Python内置的数值数据类型和序列数据类型

    Python的数据类型包括内置的数据类型、模块中定义的数据类型和用户自定义数据类型
    数值数据类型:int、float、bool、complex
    序列数据类型:不可变(str、tuple、bytes)和可变(list、bytearray)

    一、数值数据类型

    1.int类型(任意精度整数)

    创建int对象
    在这里插入图片描述

    >>> int(),int(123),int('456'),int(1.98)
    #输出:(0,123,456,1)
    >>> int('100',2),int('17',8),int('17',16)
    #输出:(4,15,23)
    

    int类型的运算
    算术运算、位运算、内置函数、math模块中的数学运算函数

    2.float类型(有限精度浮点数)

    创建float对象

    >>> float(123),float('4.56')
    #输出:(123.0,4.56)
    

    foat类型的运算
    算术运算,math模块中浮点数运算的函数

    3.complex类型

    创建complex对象
    在这里插入图片描述

    >>> x = complex(4,5)
    >>> x
    #输出:(4+5j)
    

    complex类型的运算
    在这里插入图片描述

    4.bool类型

    bool数据类型包含两个值:True(真)或False(假)

    >>> True,False		
    #输出:(True,False)
    >>> bool(0),bool('abc')
    #输出:(False, True)
    

    注:(1)Python的任意表达式都可以评价为布尔逻辑值,故均可以参与逻辑运算。
    (2)C = A or B。如果A不为0或者不为空或者为True,则返回A;否则返回B。仅在必要时才计算第二个操作数,即如果A不为0或者不为空或为True,则不用计算B。“短路”计算。
    (3)C = A and B。如果A为0或者为空或者为False,则返回A;否则返回B。仅在必要时才计算第二个操作数,即如果A为0或者为空或者为False,则不用计算B。即“短路”计算。

    >>> not 0	  #输出:True
    >>> not 'a'	  #输出:False
    >>> 2 or 1	  #输出:2
    >>> 0 or 2	  #输出:2
    >>> False or True	  #输出:True
    >>> True or False	  #输出:False
    

    二、序列数据类型

    1.str数据类型(字符串)

    创建str对象
    在这里插入图片描述

    >>> str(123)		#输出:'123'
    >>> str(3.14)		#输出:'3.14'
    >>> c = 5/2
    >>> str(c)		#输出:'2.5'
    >>> str(True)		#输出:'True'
    >>> str(abc)		#错误!
    >>> str('abc')		#输出:'abc'
    

    在这里插入图片描述

    >>> 'abc'	    #输出:'abc'
    >>> "hhh"	    #输出:'hhh'
    >>> 'py''thon'	    #输出:'python'
    

    字符串编码
    使用内置函数ord()可以把字符转换为对应的Unicode码,使用内置函数chr()可以把十进制数转换为对应的字符

    >>> ord('A')	     #输出:65
    >>> chr(65)	     #输出:'A'
    >>> ord('好')	     #输出:22909
    >>> chr(22909)	     #输出:'好'
    

    str类型的运算
    索引访问、切片操作、连接操作、重复操作、成员关系操作、以及求字符串长度、最大值、最小值等。

    字符串的格式化
    在这里插入图片描述

    >>> "年龄{0},身高{1}".format(20,165.5)
    #输出:'年龄20,身高165.5'
    >>> str.format("年龄{0},身高{1:2.2f}",20,165)
    #输出:'年龄20,身高165.00'
    >>> format(3.14,"0.5f")
    #输出:'3.14000'
    >>> "年龄%d,身高%.2f"%(20,165)
    #输出:'年龄20,身高165.00'
    
    >>> print("1".rjust(20,"*"))	    #输出:*******************1
    >>> print(format("121","*>20"))	    #输出:*****************121
    >>> print(format("121","*<20"))	    #输出:121*****************
    
    >>> name = "hhh"
    >>> f"He said his name is {name}."
    #输出:'He said his name is hhh.'
    
    

    2.元组(tuple)

    元组也称之为定值表,用于存储值固定不变的值表。

    创建元组对象

    >>> t1 = 1,2,3		   #输出:(1,2,3)
    >>> t2 = 1,		   #输出:(1,)
    >>> t3 = (1)		   #输出:1
    >>> t4 = ()		   #输出:()
    >>> t5 = 'a','b','c'	   #输出:('a', 'b', 'c')
    

    在这里插入图片描述

    >>> t1 = tuple()		#输出:()
    >>> t2 = tuple("abc")		#输出:('a','b','c')
    >>> t3 = tuple([1,2,3])		#输出:(1,2,3)
    >>> t4 = tuple(range(3))	#输出:(0,1,2)
    

    元组的基本操作
    索引访问、切片操作、连接操作、重复操作、成员关系操作、比较运算操作,以及求元组长度、最大值、最小值等

    3.列表(list)

    列表也称之为表,用于存储其值可变的表。

    创建list对象

    >>> l1 = [1,2,3]	    #输出:[1, 2, 3]
    >>> l2 = [1,]		    #输出:[1]
    >>> l3 = []		    #输出:[]
    >>> l4 = [1]		    #输出:[1]
    >>> l5 = ["a","b","c"] 	    #输出:['a', 'b', 'c']
    

    在这里插入图片描述

    >>> l1 = list()			#输出:[]
    >>> l2 = list("abc")		#输出:['a', 'b', 'c']
    >>> l3 = list([1,2,3])		#输出:[1, 2, 3]
    >>> l4 = list(range(3))		#输出:[0, 1, 2]
    

    列表的基本操作
    索引访问、切片操作、连接操作、重复操作、成员关系操作、比较运算操作,以及求列表长度、最大值、最小值等
    在这里插入图片描述

    list对象的方法
    在这里插入图片描述

    展开全文
  • 序列数据类型(bytes、bytearray、list、str和tuple)是Python内置的组合数据类型,可以实现复杂数据的处理。 Python 序列数据概述 数组 数组是一种数据结构,用于存储 和处理大量的数据。将所有的数据存储在一个或多...
  • 004.Python基础语法(三)——内置数据类型(二)——字符串 字符串类型表示 Python语言中并没有真正提供多行注释表示方式,三单引号构成就是字符串 但是当该字符串没有被赋值给一个变量时,也可以当作注释来...
  • Python数据结构篇中介绍了Python的序列类型数据结构,这次继续深入的学习序列和String类型对象的内建方法。 软件环境 系统 UbuntuKylin 14.04 软件 Python 2.7.3 IPython 4.0.0 序列类型 序列类型,即由整数...
  • Python 数据结构——序列构成的数据 一、内置序列类型 序列类型按照存放内容来分类: 容器序列——容器序列存放是它们所包含任意类型的对象引用;主要包括 list、tuple 和 collections.deque 扁平序列——...
  • Python语言中,文本数据由str对象或strings进行处理。字符串是不可变Unicode码点序列。字符串字面值写法有多种方式,例如: 单引号('):在单引号中允许嵌入一对双引号。 双引号("):允许嵌入一对单...
  • 序列数据的基本操作 文章目录序列数据的基本操作1. 序列长度、最大值、最小值、求和2. 序列索引访问操作3. 序列切片操作4. 序列连接和重复操作5. 序列成员关系操作6. 序列比较运算操作 1. 序列长度、...
  • 数据类型分类 数值型:int、float、complex、bool 序列对象:字符串 str、列表 list 、tuple 键值对:集合set、字典dict 数值型: int、float、complex、bool都是class int float complex bool python 3中...
  • 文章目录一、序列类型定义二、字符串类型str1.字符串类型的表示2.字符串引号表示问题3.转义符\4.字符串序号5.字符串使用6.eval()函数7.字符串操作符8.字符串处理函数9.字符串处理方法三、元组类型tuple四、...
  • 序列和字符串真很常用
  • 列表是python内置序列之一,不可哈希,可修改。下面是本人复习《Python基础教程》(Magnus Lie Hetland)第二章总结笔记。     方法 运用例子 注意事项 增 在末尾增加一个值 append x....
  • (1)元组是序列类型的一种扩展,一旦创建就不能被修改 (2)使用小括号()或tuple()创建,元素间用逗号,分隔 (3)可以使用或不使用小括号 #例1: def func() return 1,2 #这个1,2就是一种不使用小括号元组类型...
  • Python中有以下几种标准的内置数据类型: 1.NoneType: The Null object--空对象2.Numerics(数值): int-整数, long-长整数, float-浮点数, complex-复数, and bool--布尔值 (The subclass of int with True or ...
  • Python的序列类型

    2019-02-28 17:29:00
    Python的序列类型非常丰富,包括了列表(list),元组(tuple),字符串(str), 字节数组(bytes),队列(deque),今天我们就着重了解下python中的这些内置序列类型内置序列类型介绍 python标准库中的序列类型使用...
  • Python中为我们提供了大量功能丰富的数据类型,在开发过程中,我们推荐使用Python内置核心数据类型,主要原因如下: ①程序编写更加容易 ②很多扩展程序组件是基于Python内置数据类型来开发和扩展 ③使用...
  •  每个对象都有类型,Python 中最基本的内置数据类型:  1. 整数  整数,2345 ,10 ,50  2. 浮点型  小数,3.14 或者科学计数法3143-2  3. 布尔型  表示真假,仅包含:True,False  4. 字符串型  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,441
精华内容 576
关键字:

python内置的序列数据类型

python 订阅