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]]

?

?