基本对象类型（一）

列表（list）

• 列表的定义与赋值     
• 列表的基本操作（增删改查）                                                                     

问题的引入：在对数据进行操作时，可能会遇到一组数据，如何对这些数据进行操作预处理？

1 name0='wuchao'
2 name1='jixin'
3 name2='xiaohu'
4 name3='sanpang'
5               

View Code

 这种方法繁琐且对于数据不方便操作。

1 names='wuchao jinxing xiaohu sanpangn‘’ 

这种存数据存在的问题：数据不存在关联并且不方便记忆。

在python语言中引入列表这种数据类型，方便用户对大量数据进行批量存储和操作。

列表可以存一组数据，并且数据之间的类型可以不一致，不同元素之间用逗号链接起来，用方括号进行定义。例如可以定义如下的列表a:

 a=['wuchao','jixin','xiaohu','sanpang']

此列表中含有四个元素（item）。某个列表确定之后下面就是要对列表进行一定的操作，可以对整个列表进行整体操作，也可以对列表中的某个元素进行操作，那么怎么确定列表中某个元素呢？

没错，根据某个元素（item）在列表中的位置。在python中这种位置叫作index（索引）。对于索引有两点需要注意 ①索引有正负②列表中第一个元素从0开始

列表中存入的元素可以是整型，字符型，也可以是列表，元组等。如果是列表中包含列表，就实现了列表的嵌套。如下：

View Code

下面就学习下，对列表的一些基本操作，具体包括（增删改查）：

1、 查询列表中的元素 

（1）可以通过索引查询列表中的元素：这里面涉及到一个概念叫作切片   （切片：就是选取列表中的部分元素或全部元素的一种操作）

   下面举例说明，定义的列表a如下：

a=['wuchao','jinxing','xiaohu','sanpang']

   切片（slice）的手法如下 a[ start:end:step]      start:表示开始的索引值   end：表示结束的索引值（实际并不包含） step:切片的步长，step为正数时从左往右；为负数时从右往左

  举例代码如下：

>>>a=['wuchao','jinxing','xiaohu','sanpang']
>>> a[1:4]  #第一个元素到第三个元素
    ['jinxing', 'xiaohu', 'sanpang']       

 >>> a[1:]    #从第一个元素到最后一个元素
      ['jinxing', 'xiaohu', 'sanpang']

 >>> a[1::2]  #从左到右，隔一个取一个
       ['jinxing', 'sanpang']

 >>> a[-1::-2]  #从右往左 步长为2
        ['sanpang', 'jinxing']

(2)当只知道元素的值，而不知道元素在列表中的索引值（index）的时候，可以使用index()获取元素的索引                                      

     array.index(x)          #返回元素在列表中第一次出现的索引值

    Return the smallest i such that i is the index of the first occurence of  x in the array.

 如何取第二次出现的值，先取第一次出现的索引值，然后切片

 >>> a.index('jinxing')
         1

(3)计算列表中某个元素出现的次数 count()
 array.count(x)        #计算列表中元素出现的次数,可以判断某个元素是否在列表中查次数

    Return the number of occurrences of x in the array.

 >>> a.count('zhou')
      0
>>> a.count('jinxing')
      1
>>

(4)判断某个元素x是否是列表中值得方法
   方法一：  查询元素x在列表中出现的次数，若不为零则该元素在列表中
   方法二：  x in a     #item in array 即可进行判断，如果返回值为True则为列表中的元素，否则不为列表中的元素    

 >>> a.count('zhou')
       0

 >>> 'zhou' in a
    False

  （5）遍历数组中的所有元素
      在学习语法的过程中，我们可以知道这应该是一种循环结构；循环包括while循环 和 for循环。for循环可以访问迭代式性质（itera）的对象，那么采用for循环实现对列表中元素的访问：

1 #其结构语法如下：
2   for x in list:  #其中list为列表的名称
3             pass

       举个例子如下：

>>> a=['zhou','jian',[1,2,3],(4,5,)]  #定义的列表有元素，有列表，有元组
>>> for x in a:                              #遍历列表
    print(x)

#输出的结果    
zhou
jian
[1, 2, 3]
(4, 5)

 2、修改列表中的元素 

修改列表中的方法直接对列表中的某个元素或切片直接赋值即可。

 >>> a[0]=1                #直接修改列表中某个元素的值
>>> a
       [1, 'jinxing', 'xiaohu', 'sanpang']
                    

3、删除列表中的元素
     删除列表中的元素有三种方法：remove(x)、pop(index)、del() 
(1)array.remove(x)        #直接删除内容，此种方法需要知道元素的具体值
     Remove the first occurrence of x from the array

>>> a.remove('zhou')       #删除zhou
>>> a
      [1, 'hua', 'sanpang']

  （2）array.pop([i]) #根据索引删除元素，索引可有可无，默认为-1，删除的元素返回一个

Removes the item with the index i from the array and returns it. （并返回一个值）

The optional argument defaults to -1, so that by default the last item is removed and returned.

>>> a.pop()    #默认删除最后一个元素
    ’sanpang'         #返回的删除值
>>> a          
    [1, 'hua']
>>> a.pop(1)   #删除第二个元素
    'hua'                #返回的删除值
>>> a
    [1]

 （3）del(）

4、增加列表中的元素
   增加列表中的元素有三种方法：append(x)  insert(i,x)   extend()

(1)array.append(x)     #在数组的最后插入一个元素

 Append a new item with value x to the end of the array.

>>> a
      [1]
>>> a.append('xuepeng')  #把xue添加到列表的末尾
>>> a
                                       [1, 'xuepeng']

(2)array.insert(i, x)   #在i的位置之前插入一个元素x
   Insert a new item with value x in the array before position i.
   Negative values are treated as being relative to the end of the array.

(3)array.extend(iterable)      #在列表的末尾添加一组 数组 extend:延伸

     Append items from iterable to the end of the array.

    If iterable is another array, it must have exactly the same type code; if not, TypeError will be raised. 
　If iterable is not an array,it must be iterable and its elements must be the right type to be appended to the array

 [1, 'xuepeng']
>>> b=[1,2]            #列表b
>>> a.extend(b)        #在列表a的末尾添加列表b
>>> a
  [1, 'xuepeng', 1, 2]
>>>a+b  #此种方法也可实现，但不返回值

 5、其它的操作（排序、逆转）                      

（1）逆转（reverse）

            array.reverse() #翻转列表中元素的顺序

        Reverse the order of the items in the array.

   >>> a
           [2, 1, 'xuepeng', 1]
 >>> a.reverse()#翻转列表
 >>> a
           [1, 'xuepeng', 1, 2]

（2）排序（sort）

    array.sort(*, key=None, reverse=False)  #排序,默认从小到大 问题如何从大到小,当reverse为真的时候从大到小排          
                                    
    This method sorts the list in place.using only < comparisons between items. Exceptions are not suppressed - if any comparison operations fail, 
    the entire sort operation will fail (and the list will likely be left in a partially modified state)

     everse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.

>>> c=[11,22,11,111,234]       #定义的列表
>>> c.sort()                            #对列表进行排序，默认从小到大
>>> c
   [11, 11, 22, 111, 234]              #排序完成

>>> c=[11,22,11,111,234]         #定义的列表
 >>> c                            
       [11, 22, 11, 111, 234]
>>> c.sort(reverse=True)         #对列表进行排序，注意从大到小
>>> c
      [234, 111, 22, 11, 11]

 小结：列表就是一系列元素的合集，要注意元素的索引值（index）,对部分元素进行操作，要注意切片（slice）的操作。

          一系列的内置函数要熟记，整理如下表格：

2、元组

　　在学习列表之后，介绍一下另外一种对象元组。（tuple）

　　元组又称不可改变的列表，其也是用来存储一组数据，和列表的区别是其中的数据不能修改，删除，增加。因此称为不可改变的列表。列表的切片操作同样适用于元组。

　　元组的定义：元组写在小括号里面（），元素之间用逗号隔开。（注意与列表中用中括号【】的区别）

　　构造包含0个或一个元素的元组比较特殊，所以有一些额外的语法规则：

                    tup1=() #空元组

                    tup2=(20,)  #一个元素，需要在元素后添加逗号

　　元组同列表一样支持切片查看，遍历元组：

1 >>> tup=((1,2,),(4,5),(6,7))  #定义的元组，注意元组的嵌套
2 >>> for x in tup:                   #遍历元组
3     print (x)
4     
5 (1, 2)
6 (4, 5)
7 (6, 7）

1 >>> for x,v in tup:  #用两个变量接收遍历得到的数据
2     print(x,v)
3     
4 1 2
5 4 5 

作用：    1、对于一些数据我们不想修改，可以使用
         2、另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用而列表则不行；
            元组作为很多内建函数和方法的返回值存在

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有