基础数据类型-list

序列是python中的基础数据结构，序列里每一个元素都有一个下标，从0开始，依次递增.

list,tuple,dictionary是使用最频繁的三类数据结构。

（1）序列都有的方法包括：索引，切片，检查成员，加，乘：

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#索引
list_name = ['Paul', 'John', 'James']
print(list_name[1])

#切片
list_number = [1, 1, 2, 3, 4, 5]
print(list_number[1:5])

#检查成员
if 'Joshua' in list_name:
    print("Joshua is in list_name")
else:
    print("Joshua is not in list_name")

#加
print(list_name + list_number)

#乘
print(list_name * 2)

John
[1, 2, 3, 4]
Joshua is not in list_name
['Paul', 'John', 'James', 1, 1, 2, 3, 4, 5]
['Paul', 'John', 'James', 'Paul', 'John', 'James']

(2)遍历列表：

#遍历列表
for number in list_number:
    print(number)

(3)list的函数有len(),max(),min(),list()

#函数
print(len(list_number))
print(max(list_number))
print(min(list_number))
tuple_number = (1, 3, 5, 7)
print(type(tuple_number), type(list(tuple_number)))#list()强制将序列转化为list类型

6
5
1
<class 'tuple'> <class 'list'>

(4)list的常用方法有

-append(), extend(),insert();

#append(), extend(),insert();
list_number = [1, 1, 2, 3, 4, 5]
list_number.append(7) #在列表末尾添加新的对象
print(list_number)
list_number.extend([10, 11, 12]) #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
print(list_number)
list_number.insert(1, 99) #list.insert(index, obj)将对象插入列表中index位置
print(list_number)

[1, 1, 2, 3, 4, 5, 7]
[1, 1, 2, 3, 4, 5, 7, 10, 11, 12]
[1, 99, 1, 2, 3, 4, 5, 7, 10, 11, 12]

-remove(),pop(),clear();

#remove(),pop(),clear();
list_number = [1, 1, 2, 3, 4, 5]
list_number.remove(1)#移除列表中某个值的第一个匹配项
print(list_number)
pop_number = list_number.pop(4)#list.pop(obj=list[-1]) 移除列表中的索引位置元素（默认最后一个元素），并且返回该元素的值
print("pop number:", pop_number)
print(list_number)
list_number.clear()#清空列表
print(list_number)

[1, 2, 3, 4, 5]
pop number: 5
[1, 2, 3, 4]
[]

-sort(),reverse();

#sort(),reverse();
list_number = [4, 2, 5, 7, 1, 3]
print(list_number)
list_number.sort() #对原列表进行排序
print(list_number)
list_number.reverse() #反向原列表中元素
print(list_number)

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

-count(),index(),copy()

#count(),index(),copy()
list_number = [1, 1, 2, 2, 2, 3, 3, 3, 3]
print(list_number.count(3)) #统计某个元素在列表中出现的次数
print(list_number.index(2)) #从列表中找出某个值第一个匹配项的索引位置
print("address of list_number:", id(list_number))
copy_list_number = list_number.copy() #复制列表
print(copy_list_number)
print("address of copy_list_number:", id(copy_list_number))

4
2
address of list_number: 35406832
[1, 1, 2, 2, 2, 3, 3, 3, 3]
address of copy_list_number: 35421720

最后来看下list类的定义：

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