python 内置数据结构list

列表简介

列表是是一个有序队列，列表元素可以包涵任意对象如，数字，字符，对象，列表等等数据类型，是线性结构，不可hash的，是可变的。

列表定义方式

lst=list() #定义空列表
lst=[]　　#定义空列表
lst=[1,2,'3'] #定义内容列表
lst=list(range(10)) #可以迭代对象

列表索引

列表索引有两种：

正向索引：索引从0开始，从头开始
反向索引：索引从-1开始，从列表尾部开始

列表访问

In [6]: lst=[1,2,4,3]

In [7]: lst[0]
Out[7]: 1

In [8]: lst[1]
Out[8]: 2

In [9]: lst[-1]
Out[9]: 3

index方法：列表索引，通过值查找在列表中的索引位置，有多个相同值时仅返回找到的第一个值的索引，可以定义查找的起始和结束位置

使用方式：lst.index(value,start,[stop]) stop的值可以超出列表长度起始位置为负数则是倒序查询

In [24]: lst=[2,3,4,6,2,8,3,1,2]
#默认返回第一次查询结果
In [25]: lst.index(2)
Out[25]: 0
#设置起始位置
In [26]: lst.index(2,3)
Out[26]: 4

In [27]: lst.index(2,6)
Out[27]: 8
#设置结束位置和结束位置，结束位置比起始位置大就ok
In [28]: lst.index(2,6,100)
Out[28]: 8

In [29]: lst.index(2,2,100)
Out[29]: 4
#倒序查找
In [30]: lst.index(2,-1)
Out[30]: 8

count方法：查找列表中值的个数

In [38]: lst=[2,3,4,6,2,8,3,1,2]

In [39]: lst.count(3)
Out[39]: 2

In [40]: lst.count(2)
Out[40]: 3

In [41]: lst.count(1)
Out[41]: 1

len计算数据类型的长度：属于内置函数，它可以计算元组，列表，字符串等数据类型的长度

In [43]: t1='12345677'

In [44]: s1=(1,2,5,3)

In [45]: len(lst)
Out[45]: 9

In [46]: len(t1)
Out[46]: 8

In [47]: len(s1)
Out[47]: 4

列表修改：根据索引进行赋值，索引不能超界

In [51]: lst=[2,3,4,6,2,8,3,1,2]

In [52]: lst[0]=1

In [53]: lst
Out[53]: [1, 3, 4, 6, 2, 8, 3, 1, 2]

append：列表追加元素，从列表尾部追加，速度快，O(1)

In [56]: lst=[]

In [57]: lst.append(1)

In [58]: lst.append(2)

In [59]: lst
Out[59]: [1, 2]

inster:指定索引处插入元素（对象）

In [63]: lst.insert(10,1)
#没有边界限制，超出边界后追加到列表尾部
In [64]: lst
Out[64]: [1]


In [65]: lst=[1,2,4,4]

In [66]: lst.insert(0,0)
#插入其它类型的对象元素
In [67]: lst.insert(2,('do','you','kown'))

In [68]: lst
Out[68]: [0, 1, ('do', 'you', 'kown'), 2, 4, 4]

extend：扩展可迭代对象

In [69]: lst1=[1,2,3]

In [70]: lst2=[4,5]

In [71]: lst1.extend(lst2)

In [72]: lst1
Out[72]: [1, 2, 3, 4, 5]
#扩展元组
In [73]: lst1.extend((1,2,3))

In [74]: lst1
Out[74]: [1, 2, 3, 4, 5, 1, 2, 3]
#扩展字符串
In [75]: lst1.extend('string')

In [77]: lst1
Out[77]: [1, 2, 3, 4, 5, 1, 2, 3, 's', 't', 'r', 'i', 'n', 'g']

remove:根据值删除元素，一次删除一个值，多个值是要删除多次

In [82]: lst=[1,2,4,1,2]

In [83]: lst.remove(1)

In [84]: lst
Out[84]: [2, 4, 1, 2]

In [85]: lst.remove(1)

In [86]: lst
Out[86]: [2, 4, 2]

pop:通过指定索引删除值并返回删除的值，不指定索引则是删除列表的最后一个元素

In [96]: lst
Out[96]: [1, 4, 1, 2]

In [97]: lst.pop()
Out[97]: 2

In [98]: lst.pop(2)
Out[98]: 1

In [99]: lst
Out[99]: [1, 4]

clear：清空整个列表元素

In [99]: lst
Out[99]: [1, 4]

In [101]: lst.clear()

In [102]: lst
Out[102]: []

sort：排序

In [103]: lst=[9,3,7,5,0,8]
#默认升序排列 隐含参数reverse=False
In [104]: lst.sort()

In [105]: lst
Out[105]: [0, 3, 5, 7, 8, 9]

#reverse参数为True时则降序
In [106]: lst=[9,3,7,5,0,8]

In [107]: lst.sort(reverse=True)

In [108]: lst
Out[108]: [9, 8, 7, 5, 3, 0]

#升序排列reverse=False
In [109]: lst=[9,3,7,5,0,8]

In [110]: lst.sort(reverse=False)

In [111]: lst
Out[111]: [0, 3, 5, 7, 8, 9]

#对字符串排序，根据ASCII码排序
In [117]: lst=['g','t','a','1','2','4','6']

In [118]: lst.sort()

In [119]: lst
Out[119]: ['1', '2', '4', '6', 'a', 'g', 't']

in：成员运算

In [127]: lst
Out[127]: ['g', 't', 'a', '1', '2', '4', '6']

In [128]: 1 in lst
Out[128]: False

In [129]: '1' in lst
Out[129]: True

列表的地址引用

#列表地址引用 指的是两个对象指向同一个内存地址 可以使用id()内置函数查看变量是否指向同一内存地址，指向同一个内存地址,如果几个变量指向同一个可变的数据类型时，一改则全改
如果是不可变类型则将变量赋值改变则引用改变

#两个变量指向同一个列表
In [130]: lst1=lst2=[1,2,3]

In [139]: id(lst1),id(lst2)
Out[139]: (1619330668552, 1619330668552)

In [132]: lst1[1]=10

In [133]: lst1
Out[133]: [1, 10, 3]

In [134]: lst2
Out[134]: [1, 10, 3]

#不可变类型引用
In [140]: t=c=2

In [141]: id(t),id(c)
Out[141]: (1484349696, 1484349696)

In [142]: t=10

In [143]: t,c
Out[143]: (10, 2)

In [144]: id(t),id(c)
Out[144]: (1484349952, 1484349696)

copy：列表的复制，浅复制又叫影子copy，shadow copy，列表中嵌套可变数据类型（如列表）时该列表是添加了子列表的地址引用（子列表分配了独立的内存空间）而非正在的列表数据

In [145]: lst1=[2,4,[4,5,6],1,0]

In [146]: lst2=lst1.copy()
#两个不同的对象地址
In [147]: id(lst1),id(lst2)
Out[147]: (1619332970696, 1619333490376)

In [148]: lst1[0]=50

In [149]: lst1[2][1]=00
#对象内部 更深层次的可变数据类型会跟着改变
In [150]: lst2
Out[150]: [2, 4, [4, 0, 6], 1, 0]

In [151]: lst1
Out[151]: [50, 4, [4, 0, 6], 1, 0]

深复制需要import copy模块 copy模块提供了deepcopy方法，该方法会去递归复制可变对象的每一个的值

In [153]: import copy

In [154]: lst1
Out[154]: [50, 4, [4, 0, 6], 1, 0]

In [155]: lst2=copy.deepcopy(lst1)

In [156]: id(lst1),id(lst2)
Out[156]: (1619332970696, 1619330577864)
#修改后有变化
In [157]: lst1[2][1]=100

In [158]: lst1
Out[158]: [50, 4, [4, 100, 6], 1, 0]

In [159]: lst2
Out[159]: [50, 4, [4, 0, 6], 1, 0]

求100以内的素数

方法一
lst=[]
n=100
for i in range(2,n):
    for j in range(2,i):
        if i % j==0:
            break

    else:
        lst.append(i)
print(lst)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

方法二

lst=[2]
n=1000
flag=True
for  i in range(3,n,2):
    for  j in lst:
        if i % j == 0:
            flag=False
            break
        if j > i ** 0.5:
            flag=True
            break
    if flag:
        lst.append(i)
print(lst)
#结果
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

打印6行杨辉三角

方法一

lst=[[1],[1,1]]
n=6
for i in range(2,n):
    curt=[1]
    prev=lst[i-1]
    for j in range(0,i-1):
        curt.append(prev[j]+prev[j+1])
    curt.append(1)
    lst.append(curt)
print(lst)

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

方法二

lst=[]
n=6
for i in range(n):
    row=[1]
    #此处用到了 列表的对象引用（地址引用）
    lst.append(row)
    if i == 0:
        continue
    for j in range(i-1):
        row.append(lst[i-1][j]+lst[i-1][j+1])
    row.append(1)
print(lst)

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

posted @ 2018-04-07 22:11 mictiger 阅读(800) 评论(0) 收藏举报

刷新页面返回顶部

mictiger

python 内置数据结构list

列表简介

列表定义方式

列表索引

公告