Python基础之数据类型和运算—— 列表

Posted 有点黑的小白

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python基础之数据类型和运算—— 列表相关的知识,希望对你有一定的参考价值。

列表

Python 有几个 复合数据类型,用于表示其它的值。最通用的是 list (列表) ,它可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型:

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

 

索引:

names = [Alex,"Tenglan",Eric]
>>> names[0]
Alex
>>> names[2]
Eric
>>> names[-1]
Eric
>>> names[-2] #还可以倒着取
Tenglan

切片:

print(name_list[1:4])#取下标1至下标4之间的值,包括1,不包括4
print(name_list[1:-1])#取下标1至下标-1的值,不包括-1(-1为最右边的值) print(name_list[1:])#从1开始取直到最后一个,不能写-1,只能这么写 print(name_list[1:len(name_list)])#同上 print(name_list[0:3])#从头开始取,取3个值 print(name_list[:3])#如果是从头开始取,0可以忽略,跟上句效果一样 print(name_list[0::2])#后面的2表示每隔一个元素,取一个 print(name_list[::2])#效果同上 print(name_list[-3:-1])#从右边数第3个到最后一个,不包括最后第一个
print(name_list[-3:])#从右边数第3个到最后一个

 

所有的切片操作都会返回一个包含请求的元素的新列表。这意味着下面的切片操作返回列表一个新的(浅)拷贝副本:

print(name_list[:])

修改:

>>> names
[Alex, Tenglan, 强行从Eric前面插入, Eric, Rain, 从eric后面插入试试新姿势, Tom, Amy, 我是新来的]
>>> names[2] = "该换人了"
>>> names
[Alex, Tenglan, 该换人了, Eric, Rain, 从eric后面插入试试新姿势, Tom, Amy, 我是新来的]

也可以对切片赋值,此操作可以改变列表的尺寸,或清空它:

>>> letters = [a, b, c, d, e, f, g]
>>> letters
[a, b, c, d, e, f, g]
>>> # replace some values
>>> letters[2:5] = [C, D, E]
>>> letters
[a, b, C, D, E, f, g]
>>> # now remove them
>>> letters[2:5] = []
>>> letters
[a, b, f, g]
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

追加:

>>> names
[Alex, Tenglan, Eric, Rain, Tom, Amy]
>>> names.append("我是新来的")
>>> names
[Alex, Tenglan, Eric, Rain, Tom, Amy, 我是新来的]

扩展:

>>> names
[Alex, Tenglan, Rain, Tom, Amy]
>>> b = [1,2,3]
>>> names.extend(b)
>>> names
[Alex, Tenglan, Rain, Tom, Amy, 1, 2, 3]

列表也支持连接这样的操作:

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

插入:

>>> names
[Alex, Tenglan, Eric, Rain, Tom, Amy, 我是新来的]
>>> names.insert(2,"强行从Eric前面插入")
>>> names
[Alex, Tenglan, 强行从Eric前面插入, Eric, Rain, Tom, Amy, 我是新来的]

>>> names.insert(5,"从eric后面插入试试新姿势")
>>> names
[Alex, Tenglan, 强行从Eric前面插入, Eric, Rain, 从eric后面插入试试新姿势, Tom, Amy, 我是新来的]

删除:

>>> del names[2] 
>>> names
[Alex, Tenglan, Eric, Rain, 从eric后面插入试试新姿势, Tom, Amy, 我是新来的]
>>> del names[4]
>>> names
[Alex, Tenglan, Eric, Rain, Tom, Amy, 我是新来的]
>>> 
>>> names.remove("Eric") #删除指定元素,只能删一个
>>> names
[Alex, Tenglan, Rain, Tom, Amy, 我是新来的]
>>> names.pop() #删除列表最后一个值 
我是新来的
>>> names
[Alex, Tenglan, Rain, Tom, Amy]

拷贝:

>>> names
[Alex, Tenglan, Rain, Tom, Amy, 1, 2, 3]

>>> name_copy = names.copy()
>>> name_copy
[Alex, Tenglan, Rain, Tom, Amy, 1, 2, 3]

此处的copy只能浅拷贝,即只能拷贝一层,例如:

>>> text = [a,b,c,d,[A,B,C],e,f]>>> text_copy = text.copy()
>>> text_copy
[a, b, c, d, [A, B, C], e, f]
>>> text[4][1] = ZZZ
>>> text
[a, b, c, d, [A, ZZZ, C], e, f]
>>> text_copy     #并没有修改text_copy的内容,但是却被更改。证明这个copy 是浅拷贝
[a, b, c, d, [A, ZZZ, C], e, f]

 在列表嵌套列表的存储中,实际存的是子列表的指针,浅拷贝拷贝的也是相应子列表指针,所以更改子列表元素原列表和复制列表都会改变。

>>> text_copy[4][0] = Yang
>>> text
[a, b, c, d, [Yang, ZZZ, C], e, f]
>>> text_copy
[a, b, c, d, [Yang, ZZZ, C], e, f]

 深层拷贝:

import copy  #拷贝模块
text
= [a,b,c,d,[A,B,C],e,f] print(" text=",text) text_copy = copy.deepcopy(text) #深层拷贝 print("text_copy=",text_copy) text[4][1] = "ZZZ" print("Chang text: text=",text) print("Chang text: text_copy=",text_copy) text_copy[4][0] = "Yang" print("Chang text_copy: text=",text) print("Chang text_copy: text_copy=",text_copy) 输出: text= [a, b, c, d, [A, B, C], e, f] text_copy= [a, b, c, d, [A, B, C], e, f] Chang text: text= [a, b, c, d, [A, ZZZ, C], e, f] Chang text: text_copy= [a, b, c, d, [A, B, C], e, f] Chang text_copy: text= [a, b, c, d, [A, ZZZ, C], e, f] Chang text_copy: text_copy= [a, b, c, d, [Yang, B, C], e, f]

深拷贝是完全拷贝,子列表也重新保存。

浅拷贝三种:

p1 = copy.copy(person)
p2 = person[:]
p3 = list(person)

 

 

统计:

>>> names
[Alex, Tenglan, Amy, Tom, Amy, 1, 2, 3]
>>> names.count("Amy")
2

排序&翻转:

>>> names
[Alex, Tenglan, Amy, Tom, Amy, 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了,擦
>>> names[-3] = 1
>>> names[-2] = 2
>>> names[-1] = 3
>>> names
[Alex, Amy, Amy, Tenglan, Tom, 1, 2, 3]
>>> names.sort()
>>> names
[1, 2, 3, Alex, Amy, Amy, Tenglan, Tom]

>>> names.reverse() #反转
>>> names
[Tom, Tenglan, Amy, Amy, Alex, 3, 2, 1]

获取下标:

>>> names
[Tom, Tenglan, Amy, Amy, Alex, 3, 2, 1]
>>> names.index("Amy")
2 #只返回找到的第一个下标

 

 

技术分享图片
class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable‘s items
    """
    def append(self, p_object): # real signature unknown; restored from __doc__
        """ L.append(object) -- append object to end """
        pass

    def count(self, value): # real signature unknown; restored from __doc__
        """ L.count(value) -> integer -- return number of occurrences of value """
        return 0

    def extend(self, iterable): # real signature unknown; restored from __doc__
        """ L.extend(iterable) -- extend list by appending elements from the iterable """
        pass

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """
        L.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """ L.insert(index, object) -- insert object before index """
        pass

    def pop(self, index=None): # real signature unknown; restored from __doc__
        """
        L.pop([index]) -> item -- remove and return item at index (default last).
        Raises IndexError if list is empty or index is out of range.
        """
        pass

    def remove(self, value): # real signature unknown; restored from __doc__
        """
        L.remove(value) -- remove first occurrence of value.
        Raises ValueError if the value is not present.
        """
        pass

    def reverse(self): # real signature unknown; restored from __doc__
        """ L.reverse() -- reverse *IN PLACE* """
        pass

    def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
        """
        L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
        cmp(x, y) -> -1, 0, 1
        """
        pass

    def __add__(self, y): # real signature unknown; restored from __doc__
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, y): # real signature unknown; restored from __doc__
        """ x.__contains__(y) <==> y in x """
        pass

    def __delitem__(self, y): # real signature unknown; restored from __doc__
        """ x.__delitem__(y) <==> del x[y] """
        pass

    def __delslice__(self, i, j): # real signature unknown; restored from __doc__
        """
        x.__delslice__(i, j) <==> del x[i:j]
                   
                   Use of negative indices is not supported.
        """
        pass

    def __eq__(self, y): # real signature unknown; restored from __doc__
        """ x.__eq__(y) <==> x==y """
        pass

    def __getattribute__(self, name): # real signature unknown; restored from __doc__
        """ x.__getattribute__(‘name‘) <==> x.name """
        pass

    def __getitem__(self, y): # real signature unknown; restored from __doc__
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __getslice__(self, i, j): # real signature unknown; restored from __doc__
        """
        x.__getslice__(i, j) <==> x[i:j]
                   
                   Use of negative indices is not supported.
        """
        pass

    def __ge__(self, y): # real signature unknown; restored from __doc__
        """ x.__ge__(y) <==> x>=y """
        pass

    def __gt__(self, y): # real signature unknown; restored from __doc__
        """ x.__gt__(y) <==> x>y """
        pass

    def __iadd__(self, y): # real signature unknown; restored from __doc__
        """ x.__iadd__(y) <==> x+=y """
        pass

    def __imul__(self, y): # real signature unknown; restored from __doc__
        """ x.__imul__(y) <==> x*=y """
        pass

    def __init__(self, seq=()): # known special case of list.__init__
        """
        list() -> new empty list
        list(iterable) -> new list initialized from iterable‘s items
        # (copied from class doc)
        """
        pass

    def __iter__(self): # real signature unknown; restored from __doc__
        """ x.__iter__() <==> iter(x) """
        pass

    def __len__(self): # real signature unknown; restored from __doc__
        """ x.__len__() <==> len(x) """
        pass

    def __le__(self, y): # real signature unknown; restored from __doc__
        """ x.__le__(y) <==> x<=y """
        pass

    def __lt__(self, y): # real signature unknown; restored from __doc__
        """ x.__lt__(y) <==> x<y """
        pass

    def __mul__(self, n): # real signature unknown; restored from __doc__
        """ x.__mul__(n) <==> x*n """
        pass

    @staticmethod # known case of __new__
    def __new__(S, *more): # real signature unknown; restored from __doc__
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
        pass

    def __ne__(self, y): # real signature unknown; restored from __doc__
        """ x.__ne__(y) <==> x!=y """
        pass

    def __repr__(self): # real signature unknown; restored from __doc__
        """ x.__repr__() <==> repr(x) """
        pass

    def __reversed__(self): # real signature unknown; restored from __doc__
        """ L.__reversed__() -- return a reverse iterator over the list """
        pass

    def __rmul__(self, n): # real signature unknown; restored from __doc__
        """ x.__rmul__(n) <==> n*x """
        pass

    def __setitem__(self, i, y): # real signature unknown; restored from __doc__
        """ x.__setitem__(i, y) <==> x[i]=y """
        pass

    def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
        """
        x.__setslice__(i, j, y) <==> x[i:j]=y
                   
                   Use  of negative indices is not supported.
        """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ L.__sizeof__() -- size of L in memory, in bytes """
        pass

    __hash__ = None

list
功能源码

 





以上是关于Python基础之数据类型和运算—— 列表的主要内容,如果未能解决你的问题,请参考以下文章

Python基础之数据类型和运算——集合

Python学习:基本数据类型与变量(中)与基础之条件及循环(上)

python基础数据类型之字典+集合

Python基础教程之数据类型

Python基础之数据类型和运算——数字

Python基础之数据类型和运算——字符串