python---[列表]lsit

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

　　-list

　　-set

　　-dict

　　-tuple

　　　　-list（列表）

　　　　　　-一组又顺序的数据组合

　　　　　　-创建列表

　　　　　　　　-空列表

　　　　　　　　list1 = []
　　　　　　　　print(type(list1))
　　　　　　　　print(list1)

　　　　　　　　list2 = [100]
　　　　　　　　print(type(list2))
　　　　　　　　print(list2)

　　　　　　　　list3 = [2, 3, 1, 4, 6, 5, 6]
　　　　　　　　print(type(list3))
　　　　　　　　print(list3)

　　　　　　　　list4 = list()
　　　　　　　　print(type(list4))
　　　　　　　　print(list4)

　　　　　　　　运行结果：
　　　　　　　　<class 'list'>
　　　　　　　　[]
　　　　　　　　<class 'list'>
　　　　　　　　[100]
　　　　　　　　<class 'list'>
　　　　　　　　[2, 3, 1, 4, 6, 5, 6]
　　　　　　　　<class 'list'>
　　　　　　　　[]

　　　　-列表常用操作

　　　　　　-访问

　　　　　　　　-使用下表操作

　　　　　　　　-列表的位置是从0开始

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

　　　　　　　　print(list1[0])

　　　　　　　　

　　　　　　　　运行结果：

　　　　　　　　4

　　　　　　　　2

　　　　-分片操作

　　　　-注意截取的范围， 包含左边的下标值，不包含右边的下标值

　　　　-下标值可以为空，如果不写左边下标值默认为0，右边下标值最大数加一，即表示截取最后一个数据

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

　　　　　　运行结果：

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

　　　　　　

　　　　　　-分片可以控制增长幅度，默认增长幅度为1

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

　　　　　　运行结果：

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

　　　　　　

　　　　　　-下标可以超出范围，超出后不在考虑多余下表内容

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

　　　　　　运行结果：

　　　　　　[1, 4, 6, 5, 6]

　　　　　　-下标值， 增长幅度可以为负数

　　　　　　-为负数，表明顺序是从右往左

　　　　　　-规定：数组最后一个数字的下标是-1

　　　　　　

　　　　　　-分片之负数下标

　　　　　　-默认分片总是从左往右截取

　　　　　　-即正常情况，分片左边的值一定小于右边的值

　　　　　　list1 = [2, 3, 1, 4, 6, 5, 7]
　　　　　　print(list1[-2:-4])
　　　　　　print(list1[-4:-2])
　　　　　　print(list1[-2:-4:-1])
　　　　　　print(list1[-3:-5:-1])

　　　　　　运行结果：

　　　　　　[]
　　　　　　[4, 6]
　　　　　　[5, 6]
　　　　　　[6, 4]

　　　　　　-分片操作是生成要给新的list

　　　　　　　　-内置函数id，负责显示一个变量或者数据的唯一确定编号

　　　　　　　　a = 100
　　　　　　　　b = 200
　　　　　　　　print(id(a))
　　　　　　　　print(id(b))
　　　　　　　　c = a
　　　　　　　　print(id(c))

　　　　　　　　运行结果：

　　　　　　　　1967290496
　　　　　　　　1967293696
　　　　　　　　1967290496
　　　　　　　　100

　　　　　　　　-通过id可以直接判断出分片是从新生成了一份数据还是使用的同一份数据

　　　　　　　　

　　　　　　　　-如果两个id之一样，则表明分片产生的列表是使用的同一地址同一份数据

　　　　　　　　-否则，则表明分片是重新生成了一份数据，即一个新的列表，然后把数据拷贝到新列表中

　　　　　　　　　　-通过id知道，list2和list3是同一份数据，验证代码如下：

　　　　　　　　　　list1 = [2, 3, 1, 4, 6, 5, 7]
　　　　　　　　　　list2 = list1[:]
　　　　　　　　　　list3 = list2
　　　　　　　　　　print(id(list1))
　　　　　　　　　　print(id(list2))
　　　　　　　　　　print(id(list3))

　　　　　　　　　　list1[0] = 100
　　　　　　　　　　print(list1)
　　　　　　　　　　print(list2)
　　　　　　　　　　list2[1] = 100
　　　　　　　　　　print(list2)
　　　　　　　　　　print(list3)

　　　　　　　　　　运行结果：

　　　　　　　　　　2252262765960
　　　　　　　　　　2252261913544
　　　　　　　　　　2252261913544
　　　　　　　　　　[100, 3, 1, 4, 6, 5, 7]
　　　　　　　　　　[2, 3, 1, 4, 6, 5, 7]
　　　　　　　　　　[2, 100, 1, 4, 6, 5, 7]
　　　　　　　　　　[2, 100, 1, 4, 6, 5, 7]

- List（列表）

 1 # del删除
 2 # 如果使用del之后， id的值和删除钱不一样， 则说明删除生成一个新的list
 3 b = [1, 2, 3, 4, 5, 6]
 4 print(id(b))
 5 del b[2]
 6 print(id(b))
 7 print(b)
 8 # del 一个变量之后不能在继续使用此变量
 9 del b
10 print(b)

运行结果：
2429916837256
2429916837256
[1, 2, 4, 5, 6]
NameError: name 'b' is not defined

# 列表相加
# 使用加号连接两个列表
a = [1, 2, 3, 4]
b = [5, 6, 7, 8, 9]
c = ['a', 'b', 'c']
d = a + b + c
print(d)

运行结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c']

# 使用乘号操作列表
# 列表直接跟一个整数相乘
# 相当于把n个列表连接在一起
a = [1, 2, 3, 4]
b = a * 3
print(b)

运行结果：
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

# 成员资格运算
# 就是判断一个元素是否在list里面
a = [1, 2, 3, 4, 5, 6, 7]
b = 8
c = 5
# 返回一个布尔值
print(b in a)
print(c in a)
运行结果：
False
True

# 成员资格运算
# 就是判断一个元素是否在list里面
a = [1, 2, 3, 4, 5, 6, 7]
b = 8
c = 5
# 返回一个布尔值
print(b in a)
print(c in a)
print(c not in a)

运行结果：
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
False
True
False

# for i in list
a = [1, 2, 3, 4, 5]
for i in a:
    print(i, end=" ")
print()

b = ["a", "b", "c", "d"]
for i in b:
    print(i, end=" ")
print()

for i in range(1,10):
    print(i, end=" ")

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

# while 循环访问list
# 一般不使用while遍历list
c = [1, 2, 3, 4, 5, 6, 7]
lenth = len(c)
indx = 0
while indx < lenth:
    print(c[indx], end=" ")
    indx += 1



运行结果
1 2 3 4 5 
a b c d 
1 2 3 4 5 6 7 8 9 <class 'range'>
1 2 3 4 5 6 7 

# 双层列表循环
# a 为嵌套列表， 或者叫双层列表
a = [["one", 1], ["two", 2], ["tree", 3]]
for k, v in a:
    print(k, "--", v)

# b = [["one", 1, "eins"], ["two", 2], ["tree", 3, 4, 5, 6]]
# for k, v in b:
#     print(k, "--", v)
# # 不能这么使用

c = [["one", 1, "eins"], ["two", 2, "zwei"], ["tree", 3, "drei"]]
for k, v, w in c:
    print(k, "--", v, "--", w)

# 列表内涵：list content
# 通过简单的方法创作列表
# for 创建
a = ['a', 'b', 'c']
#用list a创建一个list b 、
# 下面代码的含义是， 对于所有a中的元素， 逐个放入新列表b中
b = [i for i in a]
print(b)

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

# 还可以过滤原来list中的内容并放入新列表
# 比如有列表e， 需要把所有e中的偶数生成新的列表f
e = [x for x in range(1, 31)]#生成也1，30 的列表
# 把f中所以偶数生成一个新列表f
f = [m for m in e if m % 2 == 0]
print(f)

# 列表生成式可以嵌套
# 有两个列表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)

# 上面代码类似下面代码
for m in a:
    for n in b:
        print(m+n, end="  ")
print()
# len：求列表长度
a = [x for x in range(1, 100)]
print(len(a))
# max：求列表中的最大值
print(max(a))
b = ['man', 'film', 'python']
print(max(b))

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

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

# 关于列表的函数

# 关于列表的函数

list1 = ['a', 'i love xj', 45, 766, 5+4j]
print(list1)
# append插入一个内容
a = [i for i in range(1,5)]
print(a)
a.append(100)
print(a)
# insert：指定位置插入
# insert(index, data), 插入位置是insert前面(完成后处于什么位置)
a.insert(3, 200)
print(a)
# del：删除
# pop, 从对应位拿出一个元素， 即把最后一个元素取出来
last_ele = a.pop()
print(last_ele)
print(a)

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

运行结果：
['a', 'i love xj', 45, 766, (5+4j)]
[1, 2, 3, 4]
[1, 2, 3, 4, 100]
[1, 2, 3, 200, 4, 100]
100
[1, 2, 3, 200, 4]
2354949945480
[1, 2, 3, 4]
2354949945480

# clear：清空
a = [1, 2, 3, 4, 5]

print(a)
print(id(a))
a.clear()
print(a)
print(id(a))
print("--------------")
# 如果不需要列表地址保持不变， 则清空列表可以使用以下方式
b = [1, 2, 3]
print(b)
print(id(b))
b = list()
b = []
print(b)
print(id(b))

运行结果：
[1, 2, 3, 4, 5]
1834734417288
[]
1834734417288
--------------
[1, 2, 3]
1834734417160
[]
1834734417160　　#加上b = list()地址还是保持不变


# 如果不需要列表地址保持不变， 则清空列表可以使用以下方式
b = [1, 2, 3]
print(b)
print(id(b))
# b = list()
b = []
print(b)
print(id(b))

运行结果：
[1, 2, 3]
2191356032264
[]
2191355209608　　#不加上b = list()地址会发生改变

# reverse：翻转列表内容，原地翻转
a = [1, 2, 3, 4, 5]
print(a)
print(id(a))
a.reverse()
print(a)
print(id(a))

运行结果：
[1, 2, 3, 4, 5]
1986270295432
[5, 4, 3, 2, 1]
1986270295432

# 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]
1657976485256
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1657976485256

# count：返查找列表中指定值或元素的个数
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
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[-1] = 777
print(a)
print(id(a))
print(b)
print(id(b))

print("*" * 20)
b = a.copy()
print(a)
print(id(a))
print(b)
print(id(b))

print("*" * 30)
b[-1] = 888
print(a)
print(b)

运行结果：
[1, 2, 3, 4, 5, 666]
[1, 2, 3, 4, 5, 777]
28 2546992182664
[1, 2, 3, 4, 5, 777]
30 2546992182664
********************
[1, 2, 3, 4, 5, 777]
33 2546992182664
[1, 2, 3, 4, 5, 777]
35 2546992182536
******************************
[1, 2, 3, 4, 5, 777]
[1, 2, 3, 4, 5, 888]

 
1 # cpoy：拷贝，浅拷贝和深拷贝区别
# 出现下面问题是，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)

运行结果：
2337052980168　　#a和b的id不一样
16 2337053832456　　
2337053832584　　#a和b内部深一层的id是一样的
18 2337053832584　　
[1, 2, 3, [10, 20, 666]]　
[1, 2, 3, [10, 20, 666]]