列表

列表

定义:

列表使用方括号括起来[],每个元素以逗号分割;

可以储存不同的数据类型

特点:

• 是一个有序的
• 可以重复的
• 可变类型

创建:

• 创建空列表

li = []
print(type(li))

<class 'list'>

• 创建多元素列表

li = [1, 2, 3, "abcd", "City", "College", ["I", "Love", "Python"]]
print(li,type(li))

[1, 2, 3, 'abcd', 'City', 'College', ['I', 'Love', 'Python']] <class 'list'>

• 强转

sr = "abcd"
list1 = list(sr)
print((list1, type(list1)))

(['a', 'b', 'c', 'd'], <class 'list'>)

列表常用操作:

(1)拼接:

li1 = ["I"]
li2 = ["Love"]
li3 = ["Python"]
print(li1 + li2 + li3)

['I', 'Love', 'Python']

(2)重复

li1 = ["I"]
print(li1 * 3)

['I', 'I', 'I']

(3)索引(偏移)[],切片[:],[::]

li1 = [1, 2, 3, '4']
print(li1[0], li1[3])

1 4

print(len(li1))
print(li1[0], li1[-4])
print(li1[:3])
print(li1[::-1])

4
1 1
[1, 2, 3]
['4', 3, 2, 1]

li = [1, 2, 3, '4', [1, 2, 3, '4ds']]
print(li[4][3][1])

d

(4)列表的常见操作(增删改查)

1.增

.append()# 所有元素作为整体添加
li = ["City", "liyue"]
li1 = ["a", "b", "c", "d"]
print(id(li))
li.append(li1)
print((li, id(li)))
li = ["a", "b"]
print(id(li))

3206680913864
(['City', 'liyue', ['a', 'b', 'c', 'd']], 3206680913864)
3206681332360

sr = "城市学院"
li = []
for i in sr:
    li.append(ord(i))
print(li)

[22478, 24066, 23398, 38498]

.extend()# 取出所有元素再依次添加
li = ["City", "liyue"]
li1 = ["a", "b", "c", "d"]
li.extend(li1)
print(li)

['City', 'liyue', 'a', 'b', 'c', 'd']

.insert()# 按照索引添加
li = ["City", "liyue"]
li1 = ["a", "b", "c", "d"]
li.insert(1, li1)
print(li)

['City', ['a', 'b', 'c', 'd'], 'liyue']

sr = "abc"
sr[3] = "D"

Traceback (most recent call last):
  File "D:/python/test1/day03.py", line 59, in <module>
    sr[3] = "D"
TypeError: 'str' object does not support item assignment
    
li = ["City", "liyue"]
li[6] = 666
print(li)

Traceback (most recent call last):
  File "D:/python/test1/day03.py", line 62, in <module>
    li[6] = 666
IndexError: list assignment index out of range

li1 = ["a", "b", "c", "d"]
li1[1:3] = ["x", "y", "z"]
print(li1)

['a', 'x', 'y', 'z', 'd']

li1 = ["a", "b", "c", "d"]
li1[1:4] = ["x", "y", "z"]
print(li1)

['a', 'x', 'y', 'z']

2.删

.pop()# 如果不指定索引，默认删除最后一个，返回被删除的元素(出栈)
li = ["a", "b", "c", "d", "e"]
print(li.pop())
print(li)
print(li.pop(2))
print(li)

e
['a', 'b', 'c', 'd']
c
['a', 'b', 'd']

.remove()# 删除第一次遇到的指定元素，无返回值
li = ["a", "b", "c", "d", "e", "e"]
print(li.remove("e"))
print(li)

None
['a', 'b', 'c', 'd', 'e']

del# python中带的方法,可用来删除整个列表
li = ["a", "b", "c", "d", "e"]
del li[3]
print(li)
del li
print(li)

['a', 'b', 'c', 'e']
Traceback (most recent call last):
  File "D:/python/test1/day03.py", line 79, in <module>
    print(li)
NameError: name 'li' is not defined# 列表已经被完全删除

.clear()# 清空列表的所有元素,无返回值
li = ["a", "b", "c", "d", "e"]
print(li.clear())
print(li)

None
[]

3.改

利用索引直接修改

4.查

索引，切片

遍历
(1)元素遍历
li = ["a", "b", "c", "d", "e"]
for i in li:
    print(i,end=" ")
    
a b c d e 

(2)索引遍历
li = ["a", "b", "c", "d", "e"]
for i in range(len(li)):
    print(li[i],end='')
    
abcde
(3)枚举遍历
enumerate() # 对于一个可迭代的/可遍历的对象(如列表、字符串等),enumerate()会将其组成一个索引序列，利用他，我们可以同时获得索引和值
li = ["a", "b", "c", "d", "e"]
for i in enumerate(li):
    print(i, end=' ')
print()
for i in enumerate(li, 2):# 第二个参数为初始索引值
    print(i, end=' ')
print()
for index, value in enumerate(li):# 用双参数分别取出索引和值，再输出
    print(index, value, end=' ')

(0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e') 
(2, 'a') (3, 'b') (4, 'c') (5, 'd') (6, 'e') 
0 a 1 b 2 c 3 d 4 e 

5.其他操作

.count()# 计数
.reverse()# 反转
.sort(key=None, reverse=False)# 排序,若元素为序列，则依次取出每个序列的元素依次进行比较，字符串无法与列表比较
# 参数key=，指定可迭代对象中的一个元素进行排序
li = ["a", "b", "c", "d", "e"]
li.reverse()
print(li)
li.sort()
print(li)
li.sort(reverse=True)# 参数reverse=True/False 反向/正向，默认为False 
print(li)

['e', 'd', 'c', 'b', 'a']
['a', 'b', 'c', 'd', 'e']
['e', 'd', 'c', 'b', 'a']

列表取交集

li = ["a", "b", "c", "d"]
li2 = ["c", "d", "e", "f"]
for i in li:
    if i in li2:
        print(i)
li3 = [i for i in li if i in li2]
print(li3)

c
d
['c', 'd']

用列表堆栈实现

class stacklist:
    def __init__(self):
        self.list1 = []
        self.flag = -1

    def stack_in(self, str):
        self.list1.append(str)
        self.flag += 1

    def stack_out(self):
        if self.flag == -1:
            print("空栈")
            return
        self.flag -= 1
        return print(self.list1.pop())

    def runout(self):
        print(self.list1[::-1])


a = stacklist()
a.stack_out()
a.stack_in(9)
a.stack_in("55")
a.stack_out()
a.stack_in(5)
a.runout()


空栈
55
[5, 9]

赋值与深浅拷贝

赋值

赋值是对对象的引用

la = [1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
lb = la
la.pop()
print((la,lb))#两个变量指向同一个对象，改变其中一个，另一个也会随着改变
([1, 2, 3, 4, 5, 'a'], [1, 2, 3, 4, 5, 'a'])

深浅拷贝

浅拷贝会创建新对象，内容是原对象的引用

三种实现方法:

• 切片操作[:]
• 工厂函数 list(li)
• copy模块内的copy函数

import copy
la = [1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
lb = la
lb2 = la[:]
lb_copy = copy.copy(la)
print(id(la), id(lb_copy))
print(id(la), id(lb2))
la.append('test')  # 添加原子类型，不会影响lb_copy
la[6][0] = 'bbb'  # 
print(la)
print(lb)
print(lb2)
print(lb_copy)

2084394830408 2084394829448
2084394830408 2084394830472
[1, 2, 3, 4, 5, 'a', ['bbb', 'b2'], 'test']
[1, 2, 3, 4, 5, 'a', ['bbb', 'b2'], 'test']
[1, 2, 3, 4, 5, 'a', ['bbb', 'b2']]
[1, 2, 3, 4, 5, 'a', ['bbb', 'b2']]

深拷贝

import copy
la = [1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
lb_deepcopy = copy.deepcopy(la)
print(id(la), id(lb_deepcopy))
# 2114121894472 2114121894536
la[5] = 'aaa'
print(la)
print(lb_deepcopy)
#[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]
#[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
la[6][1] = 'aaa'
print(la)
print(lb_deepcopy)
#[1, 2, 3, 4, 5, 'aaa', ['b1', 'aaa']]
#[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]

浅拷贝相当于只拷贝了一层，修改外层元素，就会修改引用，让他们指向另一个位置。而修改嵌套列表中的元素，列表地址没有发生变化，指向的还是同一个位置

深拷贝拷贝对象的所有元素，包括多层嵌套的元素。因此，是开辟了一个新的内存储区，和数据源没有关系了。

列表解析式

li = []
for x in range(10):
    li.append(x)
print(li)
print([x for x in range(10)])
print([x for x in range(10) if x % 2 == 0])

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

列表生成式

用来生成列表的特定的语法形式

sr = "城市学院"
print([ord(x) for x in sr])

[22478, 24066, 23398, 38498]

格式:

[exp for iter_val in iter]
[exp for iter_val in iter if if_condtion]  # 带过滤格式

name = ["Tom", "Jack", "Luck"]
subject = ["Python", "Java", "C", "C++"]
print([[x, y] for x in name for y in subject])

[['Tom', 'Python'], ['Tom', 'Java'], ['Tom', 'C'], ['Tom', 'C++'], ['Jack', 'Python'], ['Jack', 'Java'], ['Jack', 'C'], ['Jack', 'C++'], ['Luck', 'Python'], ['Luck', 'Java'], ['Luck', 'C'], ['Luck', 'C++']]

实现原理:

• 迭代[可迭代对象]中的每一个元素
• 每迭代一次的结果赋值给对应的迭代元素，再通过表达式运算得到一个新的值
• 最后所有通过表达式计算的值以一个列表的形式返回。

三目运算符

y = 12
x = y + 1 if y > 10 else y - 1
print(x)

13

练习

# input()函数实现往空列表中添加元素，当输入"q"时，结束输入，并返回列表
li = []
while True:
    sr = input("请输入元素，输入q结束")
    if sr == 'q':
        print(li)
        break
    li.append(sr)
# 随机生成30个0-10的随机整数，并统计每个数出现的次数，返回的结果形式为[[0,3],[1,4],...,[10,5]]
import random
li = []
li2 = []
for i in range(30):
    li.append(random.randint(0, 10))
for i in range(11):
    li2.append([i, li.count(i)])
print(li2)
[[0, 2], [1, 6], [2, 5], [3, 1], [4, 3], [5, 3], [6, 1], [7, 3], [8, 1], [9, 2], [10, 3]]

#