精华内容
下载资源
问答
  • 列表用括号表示。 (2)将一组值打包到一个对象,称为元组。元组括号表示。元组和列表的大部分操作相同。但是,列表是不固定的,可以随时插入,删除;而元组一旦确认就不能够再更改。所以,系统为了列表的...

     

    Python主要有三种数据类型:字典、列表、元组。其分别由花括号,中括号,小括号表示。

     列表/元组/集合/字典的理解

    (1)列表是任意对象的序列。列表用方括号表示。

    (2)将一组值打包到一个对象中,称为元组。元组用小括号表示。元组和列表的大部分操作相同。但是,列表是不固定的,可以随时插入,删除;而元组一旦确认就不能够再更改。所以,系统为了列表的灵活性,就需要牺牲掉一些内存;而元组就更为紧凑。(注意,元组在定义过程中,字符串必须用单引号‘扩起来。)

    (3)与列表和元组不同,集合是无序的,也不能通过索引进行访问。此外,集合中的元素不能重复。

    (4)字典就是一个关联数组或散列表,其中包含通过关键字索引的对象。用大括号表示。与集合相比,通过关键字索引,所以比集合访问方便。字典是Python解释器中最完善的数据类型。

    • 元组(tuple):

      元组常用小括号表示,即:(),元素加逗号,是元组的标识。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    #定义一个元组

     

    #tuple = 'a',

     

    tuple = ('a','b','c','d','e','f','g')

     

    #常规来说,定义了一个元组之后就无法再添加或修改元组的元素,但对元组切片可以添加会修改元组的元素。

     

    print tuple[1:5]

     

    tuple = tuple[:2]+('h')+temp[2:]

     

    print(tuple)

     

    #使用for循环进行遍历元组

     

    for each in tuple:

     

        print each

     

    #通过range()函数和for循环获取元组内元素的序号

     

    for index in range(len(tuple)):

     

        print tuple[index]

      

    •  列表(list):

      列表常用方括号表示,即:[];

      创建一个列表,只要把用逗号分隔的不同的数据项使用方括号括起来即可。

      例如:

    1 list1 = ['a','b','c',1,3,5]
    2 list2 = [1,2,3,4,5,6]
    3 list3 = ["abc","bcd","cde"]

      遍历列表:(len(each):表示每个迭代变量的长度,each:表示每个迭代的变量)

    1 list1 = ['a','b','c',1,3,5]
    2 for each in list1
    3     print(each,len(each))

      列表中常用的函数:

      cmp(list1,list2):比较两个列表的元素

      len(list):返回列表元素个数

      max(list):返回列表元素最大值

      min(list):返回列表元素最小值

      list(tuple):将元组转换为列表

      列表中常用的9个方法:

      list.append(obj):在列表的末尾添加新的对象

      list.count(obj):统计某个元素在列表中出现的次数

      list.extend(list):在列表末尾添加包含多个值的另一个序列,有扩展列表的作用

      list.insert(index,obj):将对象插入列表中的第index元素之前

      list.pop(obj=list[-1]):默认移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 

      list.remove(obj):移除列表中某个值

      list.reverse():将列表中的元素反向排列

      list.sort(function()):将列表进行排序

    •  字典(dict)

      字典是由花括号{}来包含其数据的,花括号内包含键(key)和其对应的值(value),一对键和值成为一个项,键和值用冒号:隔开,项和项之间用逗号,隔开,空字典就是不包含任何项的字典,也可理解为空字典就是花括号内不包含任何内容,直接使用花括号{}表示。

      创建一个字典:

      dict = {'name':'john','age':20,'sex':male}

      备注:键是一个不可变的数据类型

      访问字典:

      由于字典是无序的,访问字典不能通过索引的方式;通过变量名[键名]来访问。

      字典添加项:

      变量名:[新添加的键名] = 新添加的键对应的值

      字典修改项的值:

      变量名:[要修改的键名] = 新值

      字典删除项或值:

      del方法:删除键对应的值,del 变量名[键名];

           删除字典,del 变量名。

      clear方法:清空字典内容。

            变量名.clear()

      pop方法:删除键对应的值,但是它会把对应的值输出后再删除

    Python 双引号 单引号 多引号区别

    先说1双引号与3个双引号的区别,双引号所表示的字符串通常要写成一行 
    如: 
    s1 = "hello,world" 
    如果要写成多行,那么就要使用/ (“连行符”)吧,如 
    s2 = "hello,/ 
    world" 
    s2与s1是一样的。如果你用3个双引号的话,就可以直接写了,如下: 
    s3 = """hello, 
    world, 
    hahaha.""",那么s3实际上就是"hello,/nworld,/nhahaha.", 注意“/n”,所以, 
    如果你的字符串里/n很多,你又不想在字符串中用/n的话,那么就可以使用3个双 
    引号。而且使用3个双引号还可以在字符串中增加注释,如下: 
    s3 = """hello,  #hoho, this is hello, 在3个双引号的字符串内可以有注释哦 
    world,          #hoho, this is world 
    hahaha."""

    这里我试过一下,确实可以加注释,不过在print s3的时候连注释内容会一起给打印出来 
    这就是3个双引号和1个双引号表示字符串的区别了,3个双引号与1个单引号的区别也 
    是和这个一样的,实际上python支持单引号是有原因的,下面我来比较1个单引号和 
    1个双引号的区别。 

    当我用单引号来表示一个字符串时,如果要表示 Let's go 这个字符串,必须这样: 
    s4 = 'Let/'s go',注意没有,字符串中有一个',而字符串又是用'来表示,所以 
    这个时候就要使用转义符 / (/,转义符应该知道吧), 如果你的字符串中有一大堆 
    的转义符,看起来肯定不舒服,python也很好的解决了这个问题,如下: 
    s5 = "Let's go" 
    这时,我们看,python知道你是用 " 来表示字符串,所以python就把字符串中的那 
    个单引号 ' , 当成普通的字符处理了,是不是很简单。 
    对于双引号,也是一样的,下面举个例子 
    s6 = 'I realy like "python"!' 
    这就是单引号和双引号都可以表示字符串的原因了。

    展开全文
  • 前言 本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。...列表类型用中括号([ ])表示,也可以通过list(x)函数将集合或字符串类型转换成列表类型。l

    前言

    本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。

    PS:如有需要Python学习资料的小伙伴可以点击下方链接自行获取

    Python免费学习资料、代码以及交流解答点击即可加入


    1.列表类型

    列表是包含0个或多个元素的有序序列,属于序列类型。列表可以进行元素增加、删除、替换、查找等操作。列表没有长度限制,元素类型也可以是不同的,不需要预定义长度。

    列表类型用中括号([ ])表示,也可以通过list(x)函数将集合或字符串类型转换成列表类型。list()函数可生成空列表。

    
    >>> li = [1,2,3,[4,5,6],7]#列表的元素可以是列表
    >>> li
    [1, 2, 3, [4, 5, 6], 7]
    >>> list("一个字符串")#将字符串转换为列表
    ['一', '个', '字', '符', '串']
    

    用于列表属于序列类型,所以其适用于所有序列类型的函数,使用方法如上一小节所述。

    列表类型通过索引访问特定的元素,索引序号不能超过列表的元素范围,否则会IndexError报错。可以使用遍历循环对列表类型的元素进行遍历操作。

    列表中还有一个重要的操作,即切片,用于获得列表的一个片段,即获得零个或多个元素。切片后的结果也是列表类型,切片有两种使用方式:

       <列表或列表变量>[N:M]
    

       <列表或列表变量>[N:M:K]
    

    在Python语言中,[ ]表示区间时需要冒号(:),表示枚举使用逗号(,)。

    切片获取列表类型从N到M(不包含M)的元素组成新的列表,其中,N和M为列表类型的索引序号,可以混合使用正向递增序号和反向递减序号,一般要求N所指的元素位置小于M所指的即可。当N大于等于M时,返回空列表。当K存在时,切片获取列表类型从N到M(不包括M)以K为步长所对应元素组成的列表。

    2.列表类型的操作

    列表类型存在一些操作方法,使用语法如下:

       <列表变量>.<方法名称>(<方法参数>)
    

    下表给出一些常用的操作方法,其中使用ls作为列表变量的通用表示:

     

    
    >>> ls = [1,2,3,[4,5,6],7]
    >>> ls.append(8) #末尾增加元素8
    >>> ls
    [1, 2, 3, [4, 5, 6], 7, 8]
    >>> ls.insert(2,2.5)#位置2插入元素2.5,其余元素索引后延
    >>> ls
    [1, 2, 2.5, 3, [4, 5, 6], 7, 8]
    >>> ls.pop(2)#弹出2号元素
    2.5
    >>> ls
    [1, 2, 3, [4, 5, 6], 7, 8]#弹出后该元素会被删除
    >>> ls.remove(8)#删除索引号较小的元素8
    >>> ls
    [1, 2, 3, [4, 5, 6], 7]
    >>> ls.reverse()#元素索引反转
    >>> ls
    [7, [4, 5, 6], 3, 2, 1]
    >>> li = ls.copy()#拷贝复制
    >>> li
    [7, [4, 5, 6], 3, 2, 1]
    >>> li.clear()#清空
    >>> li
    []
    

    需要注意,对于基本的数据类型,如整数或字符串,可以通过等号实现元素赋值。但对于列表类型,使用等号无法实现真正的赋值。例如li = ls并不是拷贝ls中的元素给变量li,而是新关联的一个引用,即ls和li所指向的是同一套内容。

    使用索引号配合等号(=)可以直接修改特定的元素,使用切片配合索引号可以直接修改列表片段,修改内容可以不等长,如:

    
    >>> ls = [1,2,3,4,5]
    >>> ls
    [1, 2, 3, 4, 5]
    >>> ls[2] = 0
    >>> ls
    [1, 2, 0, 4, 5]
    >>> ls[1:4]=[6,7]
    >>> ls
    [1, 6, 7, 5]
    

    3.字典类型

    “键值对”是组织数据的一种重要方式,广泛应用在当代大型信息系统中,如Web系统。键值对的基本思想是将“值”信息关联一个“键”信息,进而通过键信息查找对应的值信息,这个过程叫映射。Python语言中通过字典类型实现映射。

    Python语言中的字典字典使用大括号({ })建立,每一个元素是一个键值对,使用方式如下:

       {<键1>:<值1>,<键2>:<值2>,……<键n>:<值n>}
    

    其中,键和值通过冒号(:)配对,不同键值对之间通过逗号(,)隔开。从Python设计角度考虑,由于大括号{ }可以表示集合,所以字典类型也具有和集合类似的性质,即键值对之间没有顺序且不能重复。可以简单把字典看成元素是键值对的集合。注意,尽管都使用大括号,但集合与字典是不同的类型。

    注意,字典类型和集合类型形式上都采用大括号表示,但如果直接使用大括号,则生成字典类型,而不是集合类型。

    
    >>> d = {"202001":"小米","202002":"红米","202003":"华为","202004":"OV"}
    >>> d["202002"]#键索引值
    '红米'
    >>> d["202002"] = "redmi"#键修改值
    >>> d["202002"]
    'redmi'
    

    键和值可以是任意数据类型,通过键索引值,并可以通过键修改值。

    4.字典的操作方法

    字典类型存在一些操作方法,使用语法形式如下:

       <字典变量>.<方法名称>(<方法参数>)
    

    下表给出了字典类型的一些常用操作方法,使用d代表字典变量。

     

    
    >>> d = {"202001":"小米","202002":"华为","202003":"OV"}
    >>> d.keys()
    dict_keys(['202003', '202001', '202002'])
    >>> d.values()
    dict_values(['OV', '小米', '华为'])
    >>> d.items()
    dict_items([('202003', 'OV'), ('202001', '小米'), ('202002', '华为')])
    >>> d.get("202002")
    '华为'
    >>> d.get("202004")
    >>> d.pop("202002")
    '华为'
    >>> d
    {'202003': 'OV', '202001': '小米'}
    >>> d["202002"] = "华为"
    >>> d
    {'202003': 'OV', '202001': '小米', '202002': '华为'}
    >>> d.popitem()
    ('202003', 'OV')
    >>> d
    {'202001': '小米', '202002': '华为'}
    >>> d.clear()
    >>> d
    {}
    

    字典类型也支持保留字in,用来判断一个键是否在字典中,如果在,就返回True,否则返回False。

    字典类型支持遍历循环。注意,由于键值对中的键相当于索引,所以,for循环返回的变量名是字典的索引。如果需要得到键对应的值,可以使用get()方法。

    展开全文
  • python有6个序列的内置类型,但最常见的是列表和元组。列表(List):列表是最常见的python数据类型,它可以作为一个方括号内的逗号分隔值出现。注:列表的数据项不需要具有相同的类型。创建一个列表,只要把逗号...

    序列是Python中最基本的数据类型,序列中每个元素都分配一个数字,即它的索引。

    python中有6个序列的内置类型,但最常见的是列表和元组。

    列表(List):

    列表是最常见的python数据类型,它可以作为一个方括号内的逗号分隔值出现。

    注:列表的数据项不需要具有相同的类型。创建一个列表,只要把逗号分隔的不同数据项使用方括号括起来即可。

    列表的访问可以通过索引,如:list2[1:5]。

    列表里的数据项可以进行删除(del)也可以使用append()方法来添加列表项。

    元组(tuple):

    python的元组(tuple)和列表类似,不同之处在于元组的元素不能修改。

    元组使用小括号,列表使用方括号。

    元组的创建很简单,只需要在括号中添加元素,并使用逗号隔开。

    元组可以使用下标索引来访问元组中的值,下标索引从0开始。tup2[1:5]

    元组中的元素值是不允许修改的,但可以进行连接操作。tup3 = tup1 + tup2

    元组之间可以使用+号和*号,即可以组合和复制。

    注:任意无符号的对象,以逗号隔开,默认为元组。

    矩阵和列表的相互转化:

    range(10)给出一个正整数列表。用list命令可以显示里面的元素:

    print(list(range(0, 10)))

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    np.array(a)把列表a转化为矩阵:a=range(10)   b= np.array(a)

    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

    用list反过来把矩阵转化为列表。  c=list(b)

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    注:

    (1)如果b是矩阵,那么b*10表示对b里面的每一个元素乘以10。

    而c是列表,c*10表示把c里面的元素复制10次。

    (2)b**3表示对b里面的每一个元素计算3次方。

    而c**3则没有意义,因为c是列表,不能进行幂运算。

    例子:

    把c*10转化为10*10的矩阵:

    np.reshape(np.array(c*10),(10,10))

    Out[42]:

    array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

    展开全文
  • Python——列表类型

    2020-10-31 13:28:17
    1.列表基本概念 列表是包含0个或多个对象引用的有序序列,属于序列类型列表长度和内容可变,没有...列表用中括号[]表示,也可通过list()函数将元组或字符串转化成列表。 直接使用list()函数会返回一个空列表 ls = ['a

    1.列表基本概念
    列表是包含0个或多个对象引用的有序序列,属于序列类型,列表长度和内容可变,没有长度限制,可自由增删元素。
    列表支持成员关系操作符(in),长度计算函数(len()),分片([]).
    列表还可同时使用正向递增序号,和反向递减序号。
    列表还可使用比较操作符(<,<=,==,!=,>=,>)进行比较
    列表的比较实际上是单个数据项的逐个比较。
    列表用中括号[]表示,也可通过list()函数将元组或字符串转化成列表。
    直接使用list()函数会返回一个空列表

    ls = ['asas',12,[10,'asd'],'da']
    print(ls) 输出结果 ['asas', 12, [10, 'asda'], 'da']
    print(ls[2][-1][-1]) 输出 [10,'asd']中的 d 
    lsA = list("我们都会好好的")
    print(lsA) 输出结果 ['我', '们', '都', '会', '好', '好', '的']
    
    ls = ['asas',12,[10,'asd'],'da'] 定义列表ls
    lt = ls           lt是ls所对应数据的引用,lt并不包含真实数据
    ls[0] = 'a'
    print(ls) 输出['a', 12, [10, 'asd'], 'da'] 
    print(lt) 输出 ['a', 12, [10, 'asd'], 'da']
    
    lt和ls都是对实际数据 ['asas',12,[10,'asd'],'da'] 的表示或引用,真实数据之存储一份。
    因此修改了ls的同时也是修改了lt
    

    2.列表类型的操作

    ls = ['asas',12,[10,'asd'],'da']
    ls[i] = x 替换列表ls的第[i]数据项为x
    ls[i:j] = lt 用列表lt替换列表ls中第i到第j项数据(不含第j项)
    ls[i:j:k] = lt 用列表lt替换列表ls中第i到第j项以k为步数的数据(不含第j项)
    del ls[i:j] 删除列表ls中第i到第j项数据,等价于 ls[i:j] = []
    del ls[i:j:k] 删除列表ls中第i到第j项以K为步数的数据
    ls += lt 或 ls.extend(lt) 将列表lt元素增加到列表ls中
    ls*=n 更新列表ls,将ls元素重读n次
    ls.append(x) 在列表ls最后增加一个元素x
    ls.clear() 删除ls中的所有元素
    ls.copy() 生成一个新列表,复制ls中的所有元素。
    ls.insert(i,x) 在列表ls中第i位置新增元素x
    ls.pop(i) 将列表ls中的第i项元素取出并删除该元素。
    ls.remove(x) 将列表中出现的第一个x元素删除。
    ls.reverse() 将列表ls中的元素反转
    ls.sort() 从小到大排序
    ls.sort(reverse=True)   从大到小排序
    
    ls = ['1','2','3','4','5','6','7','8','9']
    python中的"多增少减"原则
    ls[1:3] = ['a','b','c','d','e']
    print(ls) 输出['1', 'a', 'b', 'c', 'd', 'e', '4', '5', '6', '7', '8', '9']
    ls[1:3]包含两个元素,在赋值 ls[1:3] = ['a','b','c','d','e']对其赋值了五个元素,Pyhon接受这种方法,而且不会报错
    输出的ls结果中也包含了赋值在ls[1:3]中的多余元素
    在使用ls[1:3] = ['a'],即包含更少元素赋值列表时,原列表元素也会相应减少.
    

    3.Python列表拓展
    与元组一样,列表也支持 for - in 语句对其元素进行遍历
    语法结构 for <任意变量名> in <列表名>:
    <语法块>

    import copy
    A = [1,2,3,4]
    B = A[:]                                    #浅拷贝
    C = copy.deepcopy(A)                        #深拷贝
    浅拷贝A列表给B, B中内容为,[1,2,3,4]
    深拷贝A列表给C, C中内容为,[1,2,3,4]
    

    两者的结果看起来是一样的,但是,浅拷贝,没有拷贝子对象,所以原始数据改变,子对象也会改变,
    深拷贝,包含对象里面的子对象的拷贝,所以原始对象的改变不会造成深拷贝里任何子元素的改变

    展开全文
  • 文章目录集合类型集合定义集合操作符集合函数集合类型应用场景序列类型序列类型定义序列操作符序列函数序列类型应用场景元组类型列表类型列表定义列表操作符列表函数字典类型字典定义字典操作符字典函数字典应用场景...
  • 在Python括号([ ])来表示列表,并用逗号来分隔其中的元素。如下面这个列表:这个列表中有四种编程语言,如果让Python将这个列表打印出来,Python将打印列表的内部表示,包括方括号:这是打印了列表的全部...
  • 例如,下面的列表包含了几种字符串表示的水果:列表中的项和项之间的数据类型也可以不同。例如,下面的列表包含了数字和字符串:列表还可以为空,空列表可以使用空的方括号创建:二、索引列表是有序的,可以通过...
  • 1、 列表是什么 列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表所有字母、数字0~9或字母与数字...在Python括号([])来表示列表,并用逗号来分隔其中的元素。 2、创建列表 创...
  • Python数据类型列表

    2017-11-09 23:22:53
    数据类型列表 python的数据可以分为下面四个类型 集合:几何的元素无需、不可变。 ...数字:整数、浮点数、负数、复数...列表常量括号表示,例如:[1,2,'abc']。列表对象是一种有序序列,其主要特点如下。
  • 除了列表用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗?看起来除了元组不可变之外,列表完全可以取代元组,为什么要多此一举创造出元组...
  • 列表是什么 列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表所有字母、数字0~9 或所有家庭成员...在Python括号([ ])来表示列表,并用都好来分隔期中的元素。下面是一个简单的列表示例,这...
  • 数据类型列表

    2017-10-05 05:01:00
    列表用括号表示,不同的元素之间逗号隔开,可包含任意数据类型列表中的元素可以被修改,可以重新赋值,这是list月tuple的主要区别。 索引编号: 0,1,2 ... n-1 -n ... -3,-2,-1 内置函数 >>> ...
  • Python组合数据类型知识整理——列表Python中的组合数据类型包括序列类型、字典和集合。...(1)、列表列表用中括号[ ]表示。可直接赋值或者利用list( )函数创建。列表也有很多常用方法,其格式和字符串方法一...
  • 除了列表用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗? a = [1, 3, 5, 7, 'a'] b = (1, 3, 5, 7, 'b') # 现在改变b中的值 b[2] = 4 ...
  • 除了列表用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗?a = [1, 3, 5, 7, "a"]b = (1, 3, 5, 7, "b")# 现在改变b中...
  • 除了列表用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗?a = [1, 3, 5, 7, 'a']b = (1, 3, 5, 7, 'b')# 现在改变b中的值b[2] = 4TypeError...
  • 文章目录集合类型集合定义集合操作符集合函数集合类型应用...集合括号{}表示,元素间逗号分隔 集合元素之间无序,每个元素唯一,不存在相同元素 集合元素不可更改,不能是可变数据类型 举例: A = {"pytho...
  • 在Python列表是基本的...列表表示方式如下:['dog', 'cat', 'pig', 'duck']列表数据类型列表用左方括号开始,右方括号结束。列表中的值也称为元素,元素间逗号隔开。在已经安装Python环境下(现在的开发环境...
  • python数据类型之"列表

    2018-08-10 23:28:46
    在python括号([ ])来表示列表,并且逗号分隔其中的元素。 注:列表里面也是可以潜逃列表的; 2.列表的特性 1.索引 下标是从0开始计算,比如list[0]读取的是列表的第1个元素 services = ['http',...
  • python数据类型列表

    2018-03-27 16:16:00
    在python括号([])来表示,并用逗号来分隔其中的元素。 names = ['Alex',"Tenglan",'Eric'] 列表访问 列表元素的访问从索引0开始,而不是索引1开始。 列表的索引可以是从负数开始。这种语法...
  • 集合类型及操作集合类型定义集合处理函数及方法集合类型应用场景序列类型及操作序列类型定义序列处理函数及方法序列类型应用场景(元组与列表)元组类型及操作元组类型定义元组类型操作列表类型及操作列表类型定义列表...
  • 用中括号表示[num1,num2,num3] 元组——tuple:和列表功能相似,但不能改变其元素的值,即不可以进行增删改的操作,只能执行查询操作。用小括号表示(num1,num2,num3) 字典——dictionary:类型不同的元素,由键值对...
  • 用中括号表示[num1,num2,num3] 元组——tuple:和列表功能相似,但不能改变其元素的值,即不可以进行增删改的操作,只能执行查询操作。用小括号表示(num1,num2,num3) 字典——infor:类型不同的元素,由键值对...
  • Python列表

    2020-09-18 17:40:48
    在Python,我们[ ]来表示列表,并用逗号来分隔其中的元素。 1.1.1如何访问列表中的元素 与Java,C数组元素的访问方式类似,只需要将该元素的索引位置告诉Python即可。要访问列表元素,可指出列表的名称,再...
  • 一、序列类型1)字符串(str):单引号('),双引号("),三引号(三单引号'''或三双引号""")来表示2)列表(list):[ ]中括号表示3)元组(tuple):()小括号表示二、字符串str1.定义字符串定义:单引号、双引号、三引号...

空空如也

空空如也

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

列表类型用中括号表示