python中list简介及实现

list为python中的常用数据类型，其为python中内建类，继承自object。接下来全面介绍list的常见方法及自己实现类list功能的类

创建空list

list1 = []

list2 = list()

创建并初始化list

list1 = ['a','b','c',123] #比较常用，类型可以不一致

list2 = list(list1) #传入的为可迭代对象，如set，tuple，generator

list3 = [i for i in range(10)] # 列表生成器

list4 = [x for x in range(10) if x % 2 == 0] # 生成偶数

list5 = [0] * 5 # 生成 [0, 0, 0, 0, 0]

常见方法

• append

append(p_object) # 向list末尾添加数据

list1 = []

list1.append('456')

• len

len(list1) # 返回list1中元素个数

• insert

insert(index, p_object) # 向list指定位置(index)插入数据

list1.insert(3,'abc') # 当index 大于等于 list长度，向末尾插入

list1.insert(-2,'abc') # 负数为从后往前数 当index < len(list1) * -1，则为在头部插入数据

• pop

pop(index=None) 弹出指定位置(index)的数据,当index >= len(list1) or index < len(list1) * -1，抛出异常

list1.pop(1)

list1.pop() #弹出末尾数据

• remove

remove(value) 移除list中的指定元素，如果list为空或者指定元素在列表中不存在，抛出异常

list1.remove('abc')

• clear

列表清空

• index

index( value, start=None, stop=None) # 查找指定元素

• sort

对list中元素进行排序

• count

count(value) 统计元素出现的次数，较复杂的统计建议通过 from collections import Counter 进行统计

• extend

extend(iterable) 对list进行扩展

ist1.extend(list2) # lis2中内容添加至list1后，也可以使用list1 + list2

• reverse

对list数据进行反转

list.reverse() # 从['A','B','C'] 变成 ['C','B','A']

• copy

对原始list进行拷贝，生成新的list

• 遍历

list1 = [x for x in range(0,10,2)]
  
   # 方法一
   for i in range(len(list1)):
       print(list1[i], end=' ')
   
   # 方法二
   for x in list1:
       print(x, end=' ')
   
   # 方法三
   for ind,value in enumerate(list1):
       print(ind, value, sep='=', end = ' ')

实现list类

这里采用链表进行实现。LinkedList包含size,start,end等属性和Node类，其中size表示包含Node节点的个数，start为开始节点，end为结束节点。Node类包含pre,next,data属性，pre的值为前一个Node节点,next的值为后一个节点，data中为放入的数据信息

#!/usr/bin python3
# -*- coding:utf-8 -*-

class LinkedList(object):
    # 节点类
    class __Node(object):
        def __init__(self, data, pre, next):
            self.pre = pre  # 向前节点
            self.next = next  # 向后节点
            self.data = data  # 数据

    # 初始化 size，开始、结束节点属性
    def __init__(self):
        self.__size = 0
        self.__start = None
        self.__end = None

    # 添加数据
    def append(self, data):
        last_node = self.__end
        node = self.__Node(data, last_node, None)
        if self.__size == 0:
            self.__start = node
        else:
            last_node.next = node
        self.__end = node
        self.__size += 1

    # 插入数据
    def insert(self, index, data):
        if index >= self.__size:  # 末尾添加
            self.append(data)
            return
        elif index <= self.__size * -1 or index == 0:  # 开头添加
            next_node = self.__start
            node = self.__Node(data, None, next_node)
            next_node.pre = node
            self.__start = node
        else:  # 中间添加
            next_node = self.__get_node(index)
            pre_node = next_node.pre
            node = self.__Node(data, pre_node, next_node)
            pre_node.next = node
            next_node.pre = node
        self.__size += 1

    # 弹出数据
    def pop(self, index=None):
        if index is None:
            index = self.__size - 1
        if self.__size == 0:
            raise IndexError('pop from empty list')
        if index >= self.__size or index < self.__size * -1:
            raise IndexError('pop index out of range')
        pop_node = self.__get_node(index)
        pre_node = pop_node.pre
        next_node = pop_node.next
        if pre_node is None:  # 弹出的为 开头节点
            next_node.pre = None
            self.__start = next_node
            pop_node.next = None
        elif next_node is None:  # 弹出的为 末尾节点
            pre_node.next = None
            self.__end = pre_node
            pop_node.pre = None
        else:
            pop_node.pre = None
            pop_node.next = None
            pre_node.next = next_node
            next_node.pre = pre_node
        self.__size -= 1

    # 删除元素
    def remove(self, obj):
        pos = None
        for ind, value in enumerate(self):
            if value == obj:
                pos = ind
                break
        if pos is None:
            raise ValueError("list.remove(x): x not in list")
        else:
            self.pop(pos)

    # 得到第index位置的node  index以0开始
    def __get_node(self, index):
        if index < self.__size * -1 or index >= self.__size:
            return None
        if index < 0:
            pos = self.__size - (index * -1)
        else:
            pos = index
        if pos <= (self.__size - 1) // 2:
            node = self.__start
            for ind in range(pos):
                node = node.next
            return node
        else:
            node = self.__end
            for ind in range(self.__size - 1, pos, -1):
                node = node.pre
            return node

    # 返回迭代器,自己为迭代器
    def __iter__(self):
        self.__iter_node = None  # 遍历当前节点
        self.__iter_size = 1  # 遍历对应的size
        return self

    # next方法  遍历LinkedList
    def __next__(self):
        iter_node = self.__iter_node  # self.__iter_node
        iter_size = self.__iter_size  # self.__iter_size
        if self.__size == 0 or iter_size > self.__size:
            raise StopIteration()
        elif iter_node is None:
            self.__iter_node = self.__start.next
            self.__iter_size = iter_size + 1
            return self.__start.data
        else:
            node = self.__iter_node
            self.__iter_node = node.next
            self.__iter_size += 1
            return node.data

    # 查询元素
    def __getitem__(self, item):
        if isinstance(item, int):
            start = item
            stop = item + 1
            step = 1
        elif isinstance(item, slice):
            start = item.start
            stop = item.stop
            step = item.step
            if start is None:
                start = 0
            if stop is None:
                stop = self.__size - 1
            if step is None:
                step = 1
        else:
            message = 'list indices must be integers or slices, not %s' % (type(item))
            raise TypeError(message)
        res = LinkedList()
        for ind in range(start, stop, step):
            node = self.__get_node(ind)
            res.append(node.data)
        return res

    # len方法
    def __len__(self):
        return self.__size

    # 清除元素
    def clear(self):
        self.__init__()

    # 将self.__start 和 self.__end 互换即可
    def reversed(self):
        pass

    # 将可迭代对象中每个数据放入node中
    def extend(self, iterable):
        pass

    # 将data进行拼接，这里实现比较粗糙
    def __str__(self):
        res = "["
        for obj in self:
            if res == '[':
                res = "%s'%s'" % (res, str(obj))
            else:
                res = "%s, '%s'" % (res, str(obj))
        return '%s]' % res


if __name__ == '__main__':
    l = LinkedList()
    l.append("abc")
    l.append("def")
    l.append(123)
    l.append(True)
    l.insert(2, 'insert')
    print(l)
    l.pop()
    l.pop(0)
    print(l)
    print(l[-2:-1])
    l.clear()

以上为个人理解，如有误解或错误，请指正 !