python笔记09： 列表list

内置数据结构（变量类型）

• list(列表)
• set(集合)
• dict(字典)
• tuple(元组)

list(列表）

• 一组由顺序的数据的组合
• 创建列表
  • 空列表

# 1, 创建空列表
l1 = []
# type是内置函数，负责打印出变量的类型
print( type(l1) )
print(l1)

<class 'list'>
[]

# 2. 创建带值的列表
l2 = [100]
print(type(l2))
print(l2)

<class 'list'>
[100]

# 3. 创建列表，带多个值
l3 = [2, 3, 1, 4, 6, 4, 6]
print(type(l3))
print(l3)

<class 'list'>
[2, 3, 1, 4, 6, 4, 6]

# 4. 使用list()
# list() 方法用于将元组转换为列表。
# 元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
t1 = (1, 2, 3, 4, 5)
print(type(t1))
print(t1)

l4 = list(t1)
print(type(l4))
print(l4)

<class 'tuple'>
(1, 2, 3, 4, 5)
<class 'list'>
[1, 2, 3, 4, 5]

列表常用操作

访问

• 使用下标操作（索引）
• 列表的位置是从0开始

# 下标访问列表
l = [3,2,1,4,6,3,2]
print(l[0])
print(l[3])

3
4

分片操作

• 对列表进行任意一段的截取
• l[:]

# 分片操作
# 注意截取的范围，包含左边界的下标值，不包含右边界的下标值
print(l)
print(l[1:4])

# 下标值可以为空，如果不写，左边下标值默认为0， 右边下标值为最大数加一，即表示截取到最后一个数据
print(l[:])
print(l[:4])
print(l[2:])

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

print(l)

# 分片可以控制增长幅度，默认增长幅度为1
print(l[1:6])
print(l[1:6:1])

# 打印从下标1开始的数字，每次隔一个
print(l[1:6:2])

# 下标可以超出范围，超出后不在考虑多余下标内容
print(l[2:10])

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

# 下标值，增长幅度可以为负数
# 为负数，表明顺序是从右往左
# 规定： 数组最后一个数字的下标是-1
# 依然包含左不包含右
print(l)

print(l[::-1])

print(l[2::-1])

print(l[:-5:-1])

print(l[-5::-1])
#正常从右往左，左边值要大于右边，否则步长应为负
print(l[-2:-5])

print(l[-2:-5:-1])

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

分片操作是生成一个新的list

• 通过内置编号 id 显示一个数据或变量的唯一确定编号

a = 100
b = 200
c = a

print(id(a))
print(id(b))
print(id(c))
# c和a都指向100，id号相同

a = 200
print(a)
print(c)
print(id(a))
print(id(c))
# c依然指向100，a指向200了，a id号发生变化

140706935602016
140706935605216
140706935602016
200
100
140706935605216
140706935602016

list3 = [1,2,3,4,54,53,43]
llist3 = list3[:]
lllist3 = llist3
print(id(list3))
print(id(llist3))
print(id(lllist3))

# 不难看出分片操作生成的llist3生成了新的列表
# 赋值语句生成的lllist和llist拥有相同的id号

2362210390280
2362209545352
2362209545352

#更改list3元素不影响llist3，两者不是同一个列表
list3[0]=11
print(list3)
print(llist3)
print(id(list3))
print(id(llist3))

[11, 2, 3, 4, 54, 53, 43]
[1, 2, 3, 4, 54, 53, 43]
2362210390280
2362209545352

#更改list3列表整体也不影响llist3，两者不是同一个列表
list3 = []
print(list3)
print(llist3)
print(id(list3))
print(id(llist3))

[]
[1, 2, 3, 4, 54, 53, 43]
2362211019784
2362209545352

#更改llist3元素影响lllist3，两者是同一个列表
llist3[0]=22
print(llist3)
print(lllist3)
print(id(llist3))
print(id(lllist3))

[22, 2, 3, 4, 54, 53, 43]
[22, 2, 3, 4, 54, 53, 43]
2362209545352
2362209545352

#更改llist3列表整体，llist3列表id号发生变化，而lllist仍指向原列表
llist3=[1,2,3,4,5]
print(llist3)
print(lllist3)
print(id(llist3))
print(id(lllist3))

[1, 2, 3, 4, 5]
[22, 2, 3, 4, 54, 53, 43]
2362210391624
2362209545352

list1 = [1,2,3,4,5,6]
print(id(list1))

list2 = list1[2:5]
print(id(list2))

#再次证明分片操作生成了新的列表

2362209597192
2362210823304

del: 删除命令

a = [1,2,3,4,5,6]
del a[2]
print(a)

[1, 2, 4, 5, 6]

# 使用del之后，id的值和删除前一样，说明删除没有生成一个新的list
a = [1,2,3,4,5,6]
print( a )
print(id(a))

del a[2]
print( a )
print(id(a))

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

# del一个变量后不能在继续使用此变量
del  a
print(a)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-72-d5b7704126f9> in <module>()
      1 # del一个变量后不能在继续使用此变量
----> 2 del  a
      3 print(a)


NameError: name 'a' is not defined

使用加号链接两个列表

a = [1,2,3,4,5]
b = [5,6,7,8,9]
c = ['a', 'b', 'c']
d = a + b + c
print(d)

[1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 'a', 'b', 'c']

使用乘号操作列表

• 列表直接跟一个整数相乘
• 相当于把n个列表接在一起

a = [1,2,3,4,5]
b = a * 3
print(b)

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

成员资格运算

• 判断一个元素是否在list里边

a = [1,2,3,4,5,6]
b = 8

c = b in a
print(type(c))
#c 的值是一个布尔值
print(c)

b = 4
print(b in a)

<class 'bool'>
False
True

# not in 
a = [1,2,3,4,5]
b = 9

print(b not in a)

True

链表的遍历

• for
• while

# for in list
a = [1,2,3,4,5]

# 挨个打印a里边的元素
for i in a:
    print(i)

1
2
3
4
5

# java， c++ 程序员写的python代码是这样的
for i in range(0,len(a)):
    print(a[i])
    i += 1

1
2
3
4
5

b = ["I love muluyuan"]

for i in b:
    print(i)

I love muluyuan

# range
# in 后面的变量要求是可以可迭代的内容
for i in range(1,10):
    print(i)

print(type(range(1,10)))

1
2
3
4
5
6
7
8
9
<class 'range'>

# while循环访问list
# 一般不用while遍历list

a = [1,2,3,4,5,6]
length = len(a)
# indx表示的是list的下标
indx = 0
while indx < length:
    print(a[indx])
    indx += 1

1
2
3
4
5
6

# 双层列表循环

#a 为嵌套列表，或者叫双层列表
a = [["one", 1], ["two", 2], ["three", 3] ]

for k,v in a:
    print(k, "--", v)

one -- 1
two -- 2
three -- 3

# 双层列表循环变异

#a 为嵌套列表，或者叫双层列表
a = [["one", 1, "eins"], ["two", 2], ["three", 3,4,5,6,8] ]

for k,v in a:
    print(k, "--", v)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-19-792b9170ab7f> in <module>()
      4 a = [["one", 1, "eins"], ["two", 2], ["three", 3,4,5,6,8] ]
      5 
----> 6 for k,v in a:
      7     print(k, "--", v)


ValueError: too many values to unpack (expected 2)

# 双层列表循环变异

#a 为嵌套列表，或者叫双层列表
a = [["one", 1, "eins"], ["two", 2,"zwei"], ["three", 3,"drei"] ]
#这个例子说明，k，v,w的个数应该跟解包出来的变量个数一致
for k,v,w in a:
    print(k, "--", v, "--",w)

one -- 1 -- eins
two -- 2 -- zwei
three -- 3 -- drei

列表内涵: list content

• 通过简单方法创作列表

# for 创建
a = ['a', 'b', 'c']
# 用list a创建一个list b
# 下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
b = [i for i in a]
print(b)

['a', 'b', 'c']

# 对a中所有元素乘以10，生成一个新list
a = [1,2,3,4,5]
# 用list a创建一个list b
# 下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
b = [i*10 for i in a]
print(b)

[10, 20, 30, 40, 50]

# 还可以过滤原来list中的内容病放入新列表
# 比如原有列表a， 需要把所有a中的偶数生成新的列表b

a = [x for x in range(1,35)] #生成从1到34的一个列表
print(a)
# 把a中所有偶数生成一个新的列表 b
b = [m for m in a if m % 2 == 0]
print(b)

c = [m for m in a if m % 2 == 1 ]
print(c)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33]

# 列表生成式可以嵌套
# 由两个列表a，b
a = [i for i in range(1,4)] # 生成list a
print(a)

b = [i for i in range(100,400) if i % 100 == 0]
print(b)

# 列表生成是可以嵌套,此时等于两个for循环嵌套
c = [  m+n for m in a for n in b]
print(c)

d = [ m*n for m in a for n in b]
print(d)

# 上面代码跟下面代码等价
for m in a:
    for n in b:
        print(m+n, end="  ")
print()



# 嵌套的列表生城市也可以用条件表达式
e = [  m+n for m in a for n in b if m+n < 250]
print(e)

[1, 2, 3]
[100, 200, 300]
[101, 201, 301, 102, 202, 302, 103, 203, 303]
[100, 200, 300, 200, 400, 600, 300, 600, 900]
101  201  301  102  202  302  103  203  303  
[101, 201, 102, 202, 103, 203]

关于列表的常用函数

# len:求列表长度
a = [x for x in range(1,100)]
print(len(a))

# max:求列表中的最大值
# min： 同理
print(max(a))

# 字符串比较首字符ascii码大小
b = ['manwoman', 'film', 'yzzhon', 'yzyzz']
print(max(b))

99
99
yzzhon

# list：将其他格式的数据转换成list
a = [1,2,3]
print(list(a))

[1, 2, 3]

s = "I love maluyuan"
print(list(s))

['I', ' ', 'l', 'o', 'v', 'e', ' ', 'm', 'a', 'l', 'u', 'y', 'u', 'a', 'n']

# 把range产生的内容转换成list
print(list(range(12, 19)))

[12, 13, 14, 15, 16, 17, 18]

# 传值和传地址的区别
# 对于简单的数值，采用传值操作，即在函数内对参数的操作不影响外面的变量
# 对于复杂变量，采用传地址操作，此时函数内的参数和外部变量是同一份内容，
# 任何地方对此内容的更改都影响另外的变量或参数的使用

def a(n):
    n[2] = 300
    print(n)
    return None

def b(n):
    n += 100
    print(n)
    return None


an = [1,2,3,4,5,6]
bn = 9

# 传址操作,改变了数值
print(an)
a(an)
print(an)

# 传值操作，不改变数值
print(bn)
b(bn)
print(bn)

[1, 2, 3, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
9
109
9

l = ['a',"i love muluyuan", 45, 766, 5+4j]
print (l)

['a', 'i love muluyuan', 45, 766, (5+4j)]

# append 插入一个内容, 在末尾追加
a = [ i for i in range(1,5)]
print(a)
a.append(100)
print(a)

[1, 2, 3, 4]
[1, 2, 3, 4, 100]

# insert: 制定位置插入
# insert(index, data), 插入位置是index前面
print(a)
a.insert(3, 666)
print(a)

[1, 2, 3, 4, 100]
[1, 2, 3, 666, 4, 100]

# 删除
# del 删除
# pop，从对位拿出一个元素，即把最后一个元素取出来
print(a)
last_ele = a.pop()
print(last_ele)
print(a)

[1, 2, 3, 666, 4, 100]
100
[1, 2, 3, 666, 4]

# remove:在列表中删除指定的值的元素
# 如果被删除的值没在list中，则报错
# 即，删除list指定值的操作应该使用try。。。excepty语句，或者先行进行判断
# if x in list:
#    list.remove(x)
a.insert(4, 666)
print(a)
print(id(a))
a.remove(666)
print(a)
print(id(a))

# 输出两个id值一样，说明，remove操作是在原list直接操作

[1, 2, 3, 666, 666, 4]
2362211167752
[1, 2, 3, 666, 4]
2362211167752

# clear:清空
print(a)
print(id(a))
a.clear()
print(a)
print(id(a))

# 如果不需要列表地址保持不变，则清空列表可以使用以下方式
# a = list()
# a = []

[1, 2, 3, 666, 4]
2362211167752
[]
2362211167752

# reverse:翻转列表内容，原地翻转

a = [ 1,2,3,4,5]
print(a)
print(id(a))

a.reverse()

print(a)
print(id(a))

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

# extend:扩展列表，两个列表，把一个直接拼接到后一个上

a = [ 1,2,3,4,5]
b = [6,7,8,9,10]
print(a)
print(id(a))

a.extend(b)

print(a)
print(id(a))

[1, 2, 3, 4, 5]
2362209542344
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2362209542344

# count:查找列表中指定值或元素的个数
print(a)
a.append(8)
a.insert(4, 8)
print(a)
a_len = a.count(8)
print(a_len)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 8, 5, 6, 7, 8, 9, 10, 8]
3

# copy: 拷贝，此函数是浅拷贝，

# 列表类型变量赋值示例
a = [1,2,3,4,5,666]
print(a)
# list类型，简单赋值操作，是传地址
b = a
b[3] = 777
print(a)
print(id(a))
print(b)
print(id(b))

print("*" * 20)

# 为了解决以上问题，list赋值需要采用copy函数
b = a.copy()
print(a)
print(id(a))
print(b)
print(id(b))

print("*" * 30)


b[3] = 888
print(a)
print(b)

[1, 2, 3, 4, 5, 666]
[1, 2, 3, 777, 5, 666]
2362211051528
[1, 2, 3, 777, 5, 666]
2362211051528
********************
[1, 2, 3, 777, 5, 666]
2362211051528
[1, 2, 3, 777, 5, 666]
2362210823368
******************************
[1, 2, 3, 777, 5, 666]
[1, 2, 3, 888, 5, 666]

# 深拷贝跟浅拷贝的区别
# 出现下列问题的原因是，copy‘函数是个浅拷贝函数，即只拷贝一层内容
# 深拷贝需要使用特定工具
a = [1,2,3, [10, 20, 30]]
b = a.copy()
print(id(a))
print(id(b))
print(id(a[3]))
print(id(b[3]))
a[3][2] = 666
print(a)
print(b)

2362211114056
2362211116744
2362211113736
2362211113736
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 666]]