精华内容
下载资源
问答
  • python 列表特点及常用操作

    千次阅读 2018-03-20 10:14:09
    一、列表的特性1、有序的集合2、通过偏移来索引,从而读取数据3、支持嵌套4、可变的类型列表支持的方法12>>> dir(list)['__add__', '__class__', '__contains__', '__delattr__', '__...

    一、列表的特性

    1、有序的集合

    2、通过偏移来索引,从而读取数据

    3、支持嵌套

    4、可变的类型


    列表支持的方法

    1
    2
    >>>  dir ( list )
    [ '__add__' '__class__' '__contains__' '__delattr__' '__delitem__' '__delslice__' '__doc__' '__eq__' '__format__' '__ge__' '__getattribute__' '__getitem__' '__getslice__' '__gt__' '__hash__' '__iadd__' '__imul__' '__init__' '__iter__' '__le__' '__len__' '__lt__' '__mul__' '__ne__' '__new__' '__reduce__' '__reduce_ex__' '__repr__' '__reversed__' '__rmul__' '__setattr__' '__setitem__' '__setslice__' '__sizeof__' '__str__' '__subclasshook__' 'append' 'count' 'extend' 'index' 'insert' 'pop' 'remove' 'reverse' 'sort' ]
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    >>> a =  [ 1 , 2 , 3 ]
    >>> a[ - 1 ]
    3
    >>> b = [[ 1 , 2 , 3 ],[ 3 , 4 , 5 ]]  #列表可以嵌套
    >>> b[ 1 ]
    [ 3 4 5 ]
    >>> b[ 1 ][ 1 ]
    4
    >>> b[ 1 ] = 10  #原地修改列表
    >>> b
    [[ 1 2 3 ],  10 ]
    >>>  id (b)
    46944392836376
    >>> b[ 0 ] = 5
    >>> b
    [ 5 10 ]
    >>>  id (b)
    46944392836376


    二、列表的常用操作

    1、切片:正向索引、反向索引、默认索引

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    =  [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
    >>> a  =  [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
    >>> a
    [ 1 2 3 4 5 6 7 ]
    >>> a[ 0 : 4 : 1 ]
    [ 1 2 3 4 ]
    >>> a[ - 1 : - 4 : - 1 ]
    [ 7 6 5 ]
    >>> a[ 1 :]
    [ 2 3 4 5 6 7 ]
    >>> a[ 1 :: 2 ]
    [ 2 4 6 ]



    2、添加操作:

    +: 生成一个新的列表

    Extend  接受参数并将该参数的每个元素都添加到原有的列表中,原地修改列表而不是新建列表

    Append :添加任意对象到列表的末端

    Insert: 插入任意对象到列表中,可以控制插入位置。


     

    1
    2
    3
    4
    5
    >>> a  =  [ 1 , 2 , 3 ]
    >>> b = [ 4 , 5 , 6 ]
    >>> c = a + b
    >>>  print  #产生一个新的列表
    [ 1 2 3 4 5 6 ]
    1
    2
    3
    4
    5
    6
    7
    >>>  id (a)
    46944392835016
    >>> a.extend(b)   #原地修改列表
    >>>  print  a
    [ 1 2 3 4 5 6 ]
    >>>  id (a)
    46944392835016
    1
    2
    3
    4
    5
    6
    7
    >>> a = [ 1 , 2 , 3 ]
    >>> a.append( 4 #添加任意对象到列表的末段
    >>>  print  a
    [ 1 2 3 4 ]
    >>> a.insert( 1 , 'ab' )
    >>>  print  a
    [ 1 'ab' 2 3 4 ]


    3、修改,修改列表本身只需要直接赋值操作就行。

    1
    2
    3
    4
    >>> A  =  [ 1 , 2 , 3 ]
    >>> A[ 0 ] = 'python'
    >>>  print  A
    [ 'python' 2 3 ]

     


    4、删除操作:

    Del :我们通过索引删除指定位置的元素。

    Remove:移除列表中指定值的第一个匹配值。如果没找到的话,会抛异常。

    Pop:返回最后一个元素,并从list中删除它。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    >>> a
    [ 'python' 'ab' 2 3 4 ]
    >>> 
    >>>  del  a[ 0 ]
    >>> a
    [ 'ab' 2 3 4 ]
    >>> a.remove( 2 )   #删除的是给定的value
    >>> a
    [ 'ab' 3 4 ]
    >>> a.remove( 2 #如果没找到的话,会抛异常。
    Traceback (most recent call last):
       File  "<stdin>" , line  1 in  ?
    ValueError:  list .remove(x): x  not  in  list
    >>> a
    [ 'ab' 3 4 ]
    >>> a.pop()  #默认是删除最后一个元素,也可以跟一个具体的index
    4
    >>> a
    [ 'ab' 3 ]

     

    5、成员关系:

    in 、not in我们可以判断一个元素是否在列表里。 

    返回一个bool类型,元素在列表里返回true,否则返回fasle.

    1
    2
    3
    4
    5
    >>> a  =  [ 1 , 2 , 3 ]
    >>>  2  in  a
    True
    >>>  5  not  in  a
    True


    6、列表推导式:


    [expr for iter_var in iterable] 

    6.1 、首先迭代iterable里所有内容,每一次迭代,都把iterable里相应内容放到iter_var中,再在表达式中应用该iter_var的内容,最后用表达式的计算值生成一个列表。

    比如我们要生成一个包含1到10的列表

    1
    2
    3
    4
    >>> [x  for  in  range ( 1 , 11 )]
    [ 1 2 3 4 5 6 7 8 9 10 ]
    >>>  range ( 1 , 11 )
    [ 1 2 3 4 5 6 7 8 9 10 ]


    [expr for iter_var in iterable if cond_expr]


    6.2、加入了判断语句,只有满足条件的内容才把iterable里相应内容放到iter_var中,再在表达式中应用该iter_var的内容,最后用表达式的计算值生成一个列表。

    要生成包含1到10的所有奇数列表。

    1
    2
    3
    4
    >>>  range ( 1 , 11 , 2 )
    [ 1 3 5 7 9 ]
    >>> [x  for  in  range ( 1 , 11 if  %  2  = =  1 ]
    [ 1 3 5 7 9 ]



    6.3 取出1-100的所有值的平方。

    1
    [x * for  in  range ( 100 )]

    6.4 生成字符串 

    1
    [ 'the %s'  %  d   for  in  xrange ( 10 )]

    6.5 生成元组 

    1
    2
    >>> [(x,y)  for  in  range ( 2 for  in  range ( 2 )]
    [( 0 0 ), ( 0 1 ), ( 1 0 ), ( 1 1 )]

    6.6 生成字典  

    1
    2
    >>>  dict ([(x,y)  for  in  range ( 3 for  in  range ( 2 )])  #后面的键会覆盖前面的键
    { 0 1 1 1 2 1 }


     


    7、排序翻转:sort,reverse

    1
    2
    3
    4
    5
    6
    >>> a =  [ 33 , 11 , 22 , 44 ]
    >>> b = a.sort()  #直接修改原列表,返回的是一个None
    >>>  print  b
    None
    >>>  print  a
    [ 11 22 33 44 ]

    list的reverse函数:反转一个list, 直接修改原列表,它的返回值为none

    比如上面的列表a

    1
    2
    3
    4
    5
    =  a. reverse()
    print  b   #输出的内容是None
    >>> b = a.reverse()
    >>> a   #直接看a列表变量能看到翻转的效果。
    [ 44 33 22 11 ]


    8、内置list方法,返回一个列表,参数是可迭代对象。里面输出的内容还是保持了传入的可迭代对象的元素和顺序。如果参数为空,则返回一个空的列表

    1
    2
    3
    4
    5
    6
    7
    =  "asd"
    list (a)
    >>> a = "asd"
    >>>  list (a)
    [ 'a' 's' 'd' ]
    >>>  list (( 1 , 3 ))
    [ 1 3 ]


    9、xrange和range的具体区别。

    9.1 xrange的用法:

    xrange(开始,结束,步长)

    xrange 它生成一个xrange对象。

    比如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    >>> a  =  xrange ( 1 , 10 )
    >>>  print  type (a)
    < type  'xrange' >
    >>>  print  a[ 0 ]
    1
    >>> x  =  xrange ( 1 , 10 )   #返回的是一个生成器
    >>> x
    xrange ( 1 10 )
    >>> b  = range ( 1 , 10 #返回的是一个列表
    >>>  type (b)
    < type  'list' >
    >>> b
    [ 1 2 3 4 5 6 7 8 9 ]
    >>> x[ 0 ]
    1
    >>> b[ 0 ]
    1


    range: 直接生成一个列表对象。

    xrange: 它是生成一个xrange对象.

    xrange的用法:


    1、当我们需要操作一个非常大的数据,而且内存比较吃紧的时候,我们可以用xrange来操作省内存。xrange的数据是取的时候才生成,而range是一次性生成好

    2、xrange一般用在循环里面,比如我们只需要操作部分数据的话,而不是返回全部元素来完成操作,推荐用xrange,效率更高。


    比如:

    1
    2
    3
    4
    5
    6
    7
    8
    for  in  range ( 1000 ):   #[0-999]
         if  = =  10 :
             print  'sss'
             break
    for  in  xrange ( 1000 ):   #[0-10] 
         if  = =  10 :
             print  'sss'
             break



    10、列表的引用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> a  =  [ 'i' , 'am' , 'lilei' ]
    >>> b = a
    >>>  id (a)
    46944392840544
    >>>  id (b)
    46944392840544
    >>> a[ 2 ] = "hello"
    >>>  print  b[ 2 ]
    hello
    >>>  print  b
    [ 'i' 'am' 'hello' ]
    >>>  del  b
    >>> a  #删除了b的引用,a的引用还是在
    [ 'i' 'am' 'hello' ]



    小技巧之再议删除

    1、a = []

    2、del a 删除列表对象的引用

    3、del a[:] 清空列表对象里的元素,等价于a =[]

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> a  =  [ 'i' , 'am' , 'lilei' ]
    >>> b = a
    >>> a = []
    >>> b
    [ 'i' 'am' 'lilei' ]
    >>>  del  a[:]
    >>> a
    []
    >>> b
    [ 'i' 'am' 'lilei' ]
    >>> a = b
    >>>  del  a
    >>> b
    [ 'i' 'am' 'lilei' ]


    练习:


    1、下面列表:

    a = [1,2,3,4,5,333,11,44]

    输出下面的结果:

    [4,5,333]


    >>> a[3:6]  # 第一个参数是闭区间、第二个参数是开区间

    [4, 5, 333]

    >>> a[-5:-2]

    [4, 5, 333]



    2、有下面2个列表

    a = [1,2,3]

    b = [4,5,6]


    用2个方法输出下面结果:


    [1,2,3,4,5,6]

    1
    2
    3
    4
    5
    >>> a + b
    [ 1 2 3 4 5 6 ]
    >>> a.extend(b)  #将b的内容打散插入到a中
    >>> a
    [ 1 2 3 4 5 6 ]



    >>> a = [1,2,3]

    >>> a.append(b) #将b作为一个整体插入

    >>> a

    [1, 2, 3, [4, 5, 6]]


    >>> a.insert(3,b) #将b作为一个整体插入

    [1, 2, 3, [4, 5, 6]]


    三 有下面2个列表:


    a = [1,99,33,44,55,22]

    b= [11,33,54]

    输出结果:


    1:[1,2,99,33,44,55,22,(11,33,54)]


    2: [1,2,99,33,101,44,55,22]



    四:用列表推导式生成100内的大于20的偶数

    1
    2
    >>>[x  for  in  range ( 20 , 101 if  x % 2 = = 0 ]
    >>>  range ( 20 , 101 , 2 )


    五: 已知:元组 a = (1,2,3) 利用list方法,输出下面的结果:

    (1,2,4)

    1
    2
    3
    4
    5
    6
    >>> a  =  ( 1 , 2 , 3 )
    >>> a = list (a)
    >>> a[ 2 ] = 4
    >>> a = tuple (a)
    >>> a
    ( 1 2 4 )



    六: 利用列表推导完成下面习题:

    1 输出结果:[1 love python,2 love python,3 love python,.... 10 love python]

    1
    >>> [ "%s love python"   %   x   for  in  range ( 1 , 11 )]


    2 输出结果:[(0,0),(0,2),(2,0),(2,2)]

    1
    2
    >>> [(x,y)  for  in  range ( 0 , 3 , 2 for  in  range ( 0 , 3 , 2 )]
    [( 0 0 ), ( 0 2 ), ( 2 0 ), ( 2 2 )]


    七:

    a = [1,2,3]

    b = a[:]

    del a

    b的值是什么,为什么呢?

    1
    2
    3
    4
    5
    >>> a  =  [ 1 , 2 , 3 ]
    >>> b = a[:]
    >>>  del  a
    >>> b
    [ 1 2 3 ]

    因为b和a指向的是不同的对象地址


    文章转自:http://blog.51cto.com/395469372/1748120

    展开全文
  • python中的列表特点和用法

    千次阅读 2020-09-14 23:46:44
    列表特点 1.list(列表)是python中使用最频繁的数据类型,在其他的语言中通常叫做数组 2.专门用于存储一串信息 3.列表用[]定义,列表中的数据用“,”分割 4.列表的索引是从0开始 列表的操作 假设列表名为list ...

    列表的特点

    1.list(列表)是python中使用最频繁的数据类型,在其他的语言中通常叫做数组
    2.专门用于存储一串信息
    3.列表用[]定义,列表中的数据用“,”分割
    4.列表的索引是从0开始

    列表的操作

    假设列表名为list

    序号分类方法说明
    1增加list. insert(索引,数据)将数据插入到指定索引位置
    list.append(数据)把数据追加到列表的末尾
    list.extend(列表)把列表追加到另一个列表的末尾
    2修改list[索引]=数据修改指定索引位置的数据
    3删除del list.[索引]删除指定索引的数据
    list.remve[数据]删除列表中指定的数据
    list.pop删除列表末尾的数据
    list.pop(索引)删除指定索引的数据
    list.clear清空列表
    4统计len( list)统计列表的长度
    list.count(数据)统计指定数据在列表中出现的次数
    5排序list.sort()升序
    list.sort(reverse=True)j降序
    list.reverse()逆序,反转

    列表上机操作代码

    list1 = [“张三”,“李四”,“王五”,“麻子”]

    取值和取索引

    print(list1[2])
    print(list1.index(“王五”))

    修改指定位置的数据

    list1[0] = “张小三”
    print(list1[0])

    向列表中增加数据的三种方法

    #list1.append(“小马总”,“篱笆”)append中只能接受一个数据
    list1.append(“小马总”)
    print(list1)
    list1.insert(0, “张大三”)#向指定位置插入数据,0参数是插入位置的索引
    print(list1)
    #在列表的后面追加另一个列表
    list2 = [“孙悟空”,“朱尔迪”,“砂师兄”]
    list1.extend(list2)
    print(list1)

    #删除列表中的元素
    list1.remove(“张小三”)#删除第一次出现的指定的数据
    print(list1)
    list1.pop()#删除不加索引默认删除最后一个元素,并返回删除数据的索引
    print(list1)
    list1.pop(2)#删列表中索引为2的数据
    print(list1)
    list2.clear()#清除列表中的所有元素
    print(list2)
    del list1[0]#使用关键字del删除数据,del关键字在删数据时会清空数据占的内存,删除列表中的数据时建议使用列表自带的方法
    print(list1)在这里插入图片描述
    在这里插入图片描述

    展开全文
  • python 列表 & 元组

    万次阅读 2020-10-24 22:55:14
    1.1列表特点 1. 可存放多个值 2.按照从左到右的顺序定义列表元素,从0开始顺序访问,有序 3.可修改指定索引位置对应的值,可变 1.2列表的增加 >>> names ['nis', 'chaopeng'] >>> names....

    1.列表

    1.1列表特点

    1. 可存放多个值
    
    2.按照从左到右的顺序定义列表元素,从0开始顺序访问,有序
    
    3.可修改指定索引位置对应的值,可变

    1.2列表的增加

    >>> names
    ['nis', 'chaopeng']
    >>> names.append("rain")
    >>> names.append("eva")
    >>> names
    ['nis', 'chaopeng', 'rain', 'eva']
    
    >>> a 
    ['chaopeng', 'chaoyang', 'yongkang', 'xiaodong', 'rain']
    >>> a.insert(2,"nis")
    >>> a 
    ['chaopeng', 'chaoyang', 'nis', 'yongkang', 'xiaodong', 'rain']

    1.3列表的插入

    >>> names
    ['nis', 'chaopeng', 'rain', 'eva']
    >>> names.insert(2,"chaoyang")
    >>> names
    ['nis', 'chaopeng', 'chaoyang', 'rain', 'eva']
    

    1.4列表的合并(把另外一个列表的值合并进来)

    >>> names
    ['nis', 'chaopeng', 'chaoyang', 'rain', 'eva']
    >>> n1
    ['xiaodong', 'yongkang', 'penghui']
    >>> names.extend(n1)
    >>> names
    ['nis', 'chaopeng', 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang', 'penghui']
    

    1.5列表的嵌套

    >>> names
    ['nis', 'chaopeng', 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang', 'penghui']
    >>> names.insert(2,[1,2,3])
    >>> names
    ['nis', 'chaopeng', [1, 2, 3], 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang', 'penghui']
    >>> names[2][1]
    2
    

    1.6删除

    1.6.1 del直接删

    >>> names
    ['nis', 'chaopeng', [1, 2, 3], 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang', 
    >>> del names[2]
    >>> names
    ['nis', 'chaopeng', 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang', 'penghui']
    

    1.6.2 pop删

    >>> names
    ['nis', 'chaopeng', 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang', 'penghui']
    >>> names.pop() #默认删除最有一个元素并返回被删除的值
    'penghui'
    >>> names
    ['nis', 'chaopeng', 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang']
    >>> names.pop(1)
    'chaopeng'
    >>> names
    ['nis', 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang']

    若列表为空pop报错

    1.6.3 remove 删除

    >>> name
    ['EVA', 'EVA', 'eva']
    >>> name.remove("eva")
    >>> name.remove("EVA")    #删除从左到右匹配到的第一个
    >>> name
    ['EVA']

    1.6.4 clear 清空

    >>> n1
    ['xiaodong', 'yongkang', 'penghui']
    >>> n1.clear()
    >>> n1
    []

    1.7修改操作

    >>> names
    ['nis', 'chaoyang', 'rain', 'eva', 'xiaodong', 'yongkang']
    >>> names[0] = "chaopeng"
    >>> names[2] = "lichaoyang"
    >>> names
    ['chaopeng', 'chaoyang', 'lichaoyang', 'eva', 'xiaodong', 'yongkang']
    

    1.8查操作

    >>> names
    ['chaopeng', 'chaoyang', 'lichaoyang', 'eva', 'xiaodong', 'yongkang']
    >>> names.index("chaopeng")
    0
    >>> names.index("1")  #返回从左到右匹配到的第一个索引
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: '1' is not in list
    >>> names.count("chaopeng")  #返回chaopeng的个数
    1
    >>> "eva" in names   #直接查
    True
    

    1.9 切片

    可以同时取出多个值

    >>> names
    ['chaopeng', 'chaoyang', 'lichaoyang', 'eva', 'xiaodong', 'yongkang']
    >>> names[1:4]
    ['chaoyang', 'lichaoyang', 'eva']

    切片的特性是顾头不顾尾,即start的元素会被包含,end-1是实际取出的值

    1.9.1 列表切片

    >>> names
    ['chaopeng', 'chaoyang', 'lichaoyang', 'eva', 'xiaodong', 'yongkang']
    >>> names[1:4]
    ['chaoyang', 'lichaoyang', 'eva']
    >>> names[1:-2]
    ['chaoyang', 'lichaoyang', 'eva']
    >>> names[1:]  #从开始取到最后
    ['chaoyang', 'lichaoyang', 'eva', 'xiaodong', 'yongkang']
    >>> names[:3]
    ['chaopeng', 'chaoyang', 'lichaoyang']  #从开头取到第3个

    1.9.2 倒着切

    >>> a 
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui', 'eva']
    >>> a[-5:-1]
    ['chaoyang', 'nis', 'eva', 'penghui']
    >>> a[-5:]
    ['chaoyang', 'nis', 'eva', 'penghui', 'eva']
    

    1.9.3 步长

    >>> a
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui', 'eva']
    >>> a[0:-1]
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui']
    >>> a[0:-1:1]   #正反颠倒
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui']
    >>> a[0:-1:2]
    ['chaopeng', 'yongkang', 'nis', 'penghui']
    >>> a[0:-1:3]
    ['chaopeng', 'chaoyang', 'penghui']
    

    1.9.4倒着切 步长

    >>> a
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui', 'eva']
    >>> a[-1:-5:-1]
    ['eva', 'penghui', 'eva', 'nis']
    >>> a[:]
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui', 'eva']
    >>> a[0:-1:2]
    ['chaopeng', 'yongkang', 'nis', 'penghui']
    >>> a[::2]
    ['chaopeng', 'yongkang', 'nis', 'penghui']
    

    1.9.5 列表反转

    >>> n = "冯晓三"
    >>> n
    '冯晓三'
    >>> n[::-1]
    '三晓冯'
    >>> a
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui', 'eva']
    >>> a.reverse()
    >>> a
    ['eva', 'penghui', 'eva', 'nis', 'chaoyang', 'yongkang', 'xiaodong', 'chaopeng']
    >>>a[::-1]
    >>>a
    ['chaopeng', 'xiaodong', 'yongkang', 'chaoyang', 'nis', 'eva', 'penghui', 'eva']

    1.10排序&反转

    1.10.1 排序

    >>> b=[83,23,33,56,34,45,54,89]
    >>> b.sort()
    >>> b
    [23, 33, 34, 45, 54, 56, 83, 89]
    >>> a.insert(3,"超朋")
    >>> a
    ['!', '#', '12', '超朋', '@', 'chaopeng', 'chaoyang', 'eva', 'eva', 'nis', 'penghui', 'xiaodong', 'yongkang']
    >>> a.sort()
    >>> a
    ['!', '#', '12', '@', 'chaopeng', 'chaoyang', 'eva', 'eva', 'nis', 'penghui', 'xiaodong', 'yongkang', '超朋']

    2.元组

    元组不可修改     #用法同列表

    2.1 元组包含列表时

    >>> name
    (99, 98, 97, ['chaopeng', 'chaoyang'], 33)
    >>> name[3][1] = "xiaodong"
    >>> name
    (99, 98, 97, ['chaopeng', 'xiaodong'], 33)
    

    元组本身不可修改, 如果包含可修改的数据类型, 那被包含的数据类型可以修改。

    展开全文
  • 列表: 元组: 字典: 集合:

    列表:

    使用[]或者list()进行创建。

    1、可以创建空列表:empty_list=[]或者empty_list=list()

    2、列表中,具有相同值的元素允许出现多次

    3、列表可修改

    4、元素可以是任意python类型的对象。例如,列表中可以嵌套列表:

    list_a = ['1','2','3','4']
    list_b = ['5','6','7','8','9']
    list_ab  = [list_a,list_b,'merge']
    print(list_ab)
    [['1', '2', '3', '4'], ['5', '6', '7', '8', '9'], 'merge']

    元组:

    使用()创建空元组:empty_tuple=();创建包含一个或者多个元素的元组时,每个元素后要加逗号。(即使只有一个元素也要加,多个元素时,最后一个可省略):marx_tuple = 'pyhsical',

    1、元素可以是任意python类型的对象

    2、元组元素定义之后不可以修改

    3、可以创建空元组

    4、可以将元组作为字典的键

    5、函数的参数是以元组的形式传递的

    6、可以一次性将元组赋值给多个变量(元组解包):变量值须跟元组元素数目相同

    marx_tuple = 'qw','asd','asg','fad'
    a,c,f,e = marx_tuple

    字典:

    使用{}创建

    1、元素顺序不重要

    2、通过key访问元素,key可以是任意不可变类型:布尔型,整型,浮点型,元组,字符串等

    集合:

    使用set()创建集合

     

    注:图片摘自[1]。阅读方式:以第一行第一列为例,字符串可以作为列表的元素。以第二行第二列为例,列表不可以作为集合的元素。

    [1]https://blog.csdn.net/Jacgu/article/details/106483205

    展开全文
  • python中列表、字典、元组与集合的特点以及差异

    千次阅读 多人点赞 2020-05-15 23:53:12
    列表特点 1. 数据按顺序存储 2. 列表有正序、倒序两种索引 3. 列表可存储任意类型的数据,并且允许重复。 列表的遍历: lst = [1,2,3] for i in range(len(lst)): print(lst[i]) 列表的增删改操作 列表的缺点...
  • 列表 列表是一组任意类型的值,按照一定的顺序组合而成; 通过索引来标识元素,第一个索引为0;需要注意的是索引可以是负值; 列表中元素是任意类型的,包括列表类型; 可以进行合并,删除,索引,切片等操作...
  • 列表是一种空间换时间的存储结构,是在算法中提升效率的一种比较常用的方式,但是所需空间太大也会让人头疼,所以通常需要在二者之间权衡。我们会在之后的具体算法章节中得到更多的领悟。 什么是散列表 让我们想...
  • 前端虚拟列表,支持无限滚动

    万次阅读 2019-02-15 00:03:00
    前端虚拟列表,支持无限滚动定义特点原理支持环境和框架图片演示git地址 定义 vitural list Infinite Scrolling 虚拟列表,无限滚动,高性能列表 特点 高性能,可支持超长列表滚动 原理 只渲染可视范围内的dom,通过...
  • 【python学习笔记】08 列表最全总结

    千次阅读 2021-01-15 09:56:04
    列表特点 序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列就是一块用来存放多个值的连续的内存空间。比如一共整数序列[10,20,30,40]可以这样示意表示: 由于python3中一切皆对象,在内存中实际上是...
  • 列表最大的特点就是整齐、整洁、有序,它作为布局会更加的自由和方便。 列表可以分为三大类:无序列表、有序列表和自定义列表。 无序列表 <ul>标签标示HTML页面中项目的无序列表,一般会以项目符号呈现列表项...
  • 列表和元组

    2020-12-22 01:26:36
    列表元素的特点2.基本列表操作(1)创建函数list()(2)元素的增加(3)元素的删除(4)元素的修改(5)元素的查找(6)列表的反转(7)列表的排序四、元组1.元组的概述2.元组的特点五、总结、回顾1.列表形式及元素特点2.元组形式...
  • Python:列表 【全用法】

    万次阅读 多人点赞 2019-07-02 09:31:28
    python中有列表、元组、集合、字典这四种可以存放多个数据元素的集合,他们在总体功能上都起着存放数据的作用,却都有着各自的特点。本片文章中我们会对列表的用法做详细说明。 演示环境: python3.6 pycharm中的...
  • list列表: 1.可包含任意对象的有序集合 2.通过下标索引(位置偏移)访问元素 3.可变长度,异质,可任意嵌套 4.支持原位改变 5.对象引用数组 tuple元组: 1.可包含任意对象的有序集合 2.通过下标索引...
  • 无序列表 没有有序列表那样的排序数字,但是每个列表的前面有个圆点,这是无序列表特点; 自定义列表 什么样式都没有,就是普通的列表。 下面让我们来对比一下三种列表的写法: 有序列表 :是ol标签里面包着li标签...
  • 有序列表用ol标签,每个列表用li标签,有序列表特点是所输入的内容前有数字标记。如图 把内容放到li标签里面,在浏览器里显示出来的效果如下图: 无序列表用ul标签,每个列表用li标签,无序列表特点是所输入的...
  • Python列表简介

    千次阅读 多人点赞 2019-04-29 18:29:52
    前言 列表让你能够在一个地方存储成组的信息,其中可以只包含几个元素,也可以包含数百万个元素。...通常具备以下几个特点列表中元素顺序是有序的。比如,你将1,2,3一次存入列表,那个列表中元素顺序一定是1,...
  • 特点:用于存储任意数目,任意类型的数据集合,有序,元素可变。 格式:a = [12, 20, ‘abc’, True] 常用方法: list.append(x) :增加元素到尾部 list.extend(aList) :将aList中的元素加到list尾部 list....
  • 数据结构 - 双向列表与循环列表

    千次阅读 2015-04-28 17:23:31
    特点是最后一个结点的指针域指向链表的头结点,整个链表的指针域链接成一个环。 从循环链表的任意一个结点出发都可以找到链表中的其它结点,使得表处理更加方便灵活。 循环链表的操作 对于单循环链表,除链表的...
  • 列表

    千次阅读 2019-02-24 23:57:31
    列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组...
  • VLAN特点

    千次阅读 2019-05-21 10:01:15
    LAN的特征是所有节点都能相互直接...如果网络划分了VLAN,那么不同VLAN间的设备想要相互通信必须通过一个三层或三层以上的设备,这种情况下我们可以在三层设备上设置访问控制列表,组织部分业务在VLAN间的流动,从...
  • Python语言特点

    千次阅读 2019-01-10 18:47:11
    Python语言特点Python的显著特征:Python作为编程语言的一些特征: 整理自 https://wiki.python.org/moin/BeginnersGuide/Overview Python是一种简洁又强力的面向对象的计算机编程语言。简洁指其代码风格,Python的...
  • 有序列表和无序列表之间的区别是:前缀的不同,有序的是有大写字母和小写字母、数字、罗马数字等,而无序列表是实心圆、空心圆、实心正方形。 但是共同点是都有前缀。 而自定义列表与有序无序的区别是没有前缀,...
  • html5无序列表,有序列表,定义列表,组合标签,div分区标签
  • 顺序表特点

    千次阅读 2020-05-21 09:42:48
    最主要记住随机访问的特点
  • Python-列表学习笔记(完)

    万次阅读 多人点赞 2020-06-06 09:35:03
    列表推导式列表元素的增加列表元素的删除列表元素的访问列表元素出现的次数切片(slice)列表的排序列表元素的查找列表的其他方法列表相关的内置函数 列表 列表:用于存储任意数目、任意类型的数据集合。 列表的...
  • 列表数据类型

    千次阅读 2017-04-10 21:44:22
    列表数据类型“列表”是一个值,它包含多个字构成的序列。“列表值”指的是列表本身,而不是指列表中的值。列表中的值称为表项,表项用逗号隔开。列表用左括号开始,右括号结束,即[]。注意,[]是一个空列表,不包含...
  • 哈希表(散列表)原理详解

    万次阅读 多人点赞 2018-07-03 19:40:58
    哈希表(Hash table,也叫散列表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组...
  • 知识补充 for 循环 for循环一般会访问一个可迭代的对象(如序列或者是迭代器),并且在所有条目都处理过之后结束循环。   ...(1)通常用于遍历序列成员:字符串、列表、元组和字典; (2)会...
  • Zookeeper特点及理解

    千次阅读 2019-09-10 15:44:45
    ZooKeeper 特点 顺序一致性: 从同一客户端发起的事务请求,最终将会严格地按照顺序被应用到 ZooKeeper 中去。 原子性: 所有事务请求的处理结果在整个集群中所有机器上的应用情况是一致的,也就是说,要么整个集群...
  • 列表与元组

    千次阅读 2019-05-15 22:15:34
    3.特点: 成员关系操作符, 连接操作符, 重复操作符, 索引与切片操作符 列表的创建与删除 数组: 存储同一种数据类型的集和。scores=[12,95.5] 列表(打了激素的数组): 可以存储任意数据类型的集和。 定义一个空列表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 403,823
精华内容 161,529
关键字:

列表特点