Python列表基礎操作彙總

1. 序列（sequence）

1.1 基本概念

序列是 Python語言中最基本的一種數據結構。數據結構是指計算機中數據存儲的方式，序列用於 保存一組有序的數據 。所有的數據在序列當中都有一個 唯一的位置（索引） ，並且序列中的數據會按照添加的順序來分配索引。
Python語言有6個序列的內置類型，但最常見的是列表和元組。
序列 都可以進行的操作包括索引，切片，加，乘，檢查成員。
此外，Python語言已經內置確定序列的長度以及確定最大和最小的元素的方法。

1.2 序列的分類

可變序列（序列中的元素可以改變）：例如列表（list）、字典(dict) …
不可變序列（序列中的元素不能改變）：例如字符串（str）、元組（tuple）…

2. 列表(list)

列表是最常用的 Python語言的數據類型，它可以作爲一個方括號內的逗號分隔值出現。
列表的數據項 不需要 具有相同的類型。
列表是 Python語言中的一個對象。
列表的作用：
1）列表中可以保存多個有序的數據；
2）列表是用來存儲對象的對象。

2.1 列表的使用

列表的創建：
通過 xxx = [ ] 來創建一個空列表。

參考案例：

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

2.2 切片（實操、面試必備的基礎技能）

切片是指從現有列表中獲得一個子列表。
通過切片來獲取指定的元素。

語法: 列表名[起始索引：結束索引：步長]

Python的列表截取切片與字符串操作類型，如下所示：

L=['Google', 'Runoob', 'Taobao']

Python的列表操作：

具體代碼：

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

列表還支持拼接操作：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

我們看一個稍微複雜點的參考案例：

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦','美國隊長','蟻人']
# 做切片操作時，每次獲取的都是初始列表，不是切過後的列表，不會影響原始列表

# 起始位置和結束位置的索引可以不寫
print(hero)
# ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦', '美國隊長', '蟻人']

# 切片時指定起始位置和結束位置的索引後獲取的結果
print(hero[1:3])
# ['鋼鐵俠', '綠巨人']

# 如果省略結束位置，則會從當前位置開始一直截取到最後；
print(hero[1:])
# ['鋼鐵俠', '綠巨人', '黑寡婦', '美國隊長', '蟻人']

# 如果省略開始位置，則會從第一個元素開始截取到結束位置的元素，但不包含結束位置的元素；
print(hero[:3])
# ['蜘蛛俠', '鋼鐵俠', '綠巨人']

# 如果省略開始和結束的位置，則會從第一個元素截取到最後一個元素
print(hero[:])
# ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦', '美國隊長', '蟻人']

# 步長：表示每次獲取元素的間隔  默認爲1  可以省略
print(hero[::2])
# ['蜘蛛俠', '綠巨人', '美國隊長']

# 步長不能爲 0  
print(hero[::0])
# ValueError: slice step cannot be zero

# 步長可以爲負數，
print(hero[::-1])
# ['蟻人', '美國隊長', '黑寡婦', '綠巨人', '鋼鐵俠', '蜘蛛俠']

通過切片獲取元素時，會包括起始位置的元素，不會包括結束位置的元素；
起始位置 和 結束位置 的索引可以不寫；
如果省略結束位置，則會 從當前的位置開始 一直截取到最後；
如果省略開始位置，則會從第一個元素截取到結束的元素，但是不包括結束的元素；
如果開始位置和結束位置都省略, 則會從第一個元素開始截取到最後一個元素。
步長表示每次獲取元素的間隔，默認是1(可以省略不寫)；
步長不能是0,但可以是是 負數（從後向前的獲取列表中的元素）。

3. 通用操作

+ 和 *
+ 可以將 兩個列表 拼接成 一個列表；
* 可以將 列表內的元素重複指定的次數 (注意：2個列表不能夠做乘法，要和整數做乘法運算。)

# + 表示  可以將兩個列表拼接成一個列表
lst = [1,2,3] + [4,5,6]
print(lst)
# [1, 2, 3, 4, 5, 6]

# * 表示將列表中的元素指定重複次數
lst = [1,2,3] * 2
print(lst)
# [1, 2, 3, 1, 2, 3]

# 列表和列表不能相乘   
lst = [1,2,3] * [4,5,6]
print(lst)
# TypeError: can't multiply sequence by non-int of type 'list'

in 和 not in
in 用來檢查指定元素是否在列表當中；
not in 用來檢查指定元素是否不在列表當中。

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦','美國隊長','蟻人','鋼鐵俠','鋼鐵俠','鋼鐵俠','鋼鐵俠']

print('雷聲' in hero)
# False

print('雷聲' not in hero)
# True

len() 獲取列表中元素的個數

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦','美國隊長','蟻人','鋼鐵俠','鋼鐵俠','鋼鐵俠','鋼鐵俠']
print(len(hero))
# 10

對 Python列表腳本操作符簡單彙總表：

max() 獲取列表中最大值
min() 獲取列表中最小值

lstt = [11,2,5,999,8,3333]

print(max(lstt))
# 3333

print(min(lstt))
# 11

list.index( x[, start[, end]] )
第一個參數獲取在列表中指定的元素
第二個參數表示查找的起始位置
第三個參數表示查找的結束位置

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦','美國隊長','蟻人','鋼鐵俠','鋼鐵俠','鋼鐵俠','鋼鐵俠']

print(hero.index('鋼鐵俠',4,9))
# 6

list.count(x) 統計指定元素在列表中出現的個數

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦','美國隊長','蟻人','鋼鐵俠','鋼鐵俠','鋼鐵俠','鋼鐵俠']

print(hero.count('鋼鐵俠'))
# 5

print(hero.count('蝙蝠俠'))
# 0

4. 嵌套列表

使用嵌套列表即在列表裏創建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

5. 修改列表

通過切片來修改(起始就是給切片的內容重新賦值，但是賦值的內容必須是一個序列)

當設置了步長時,序列中元素的個數必須和切片中元素的個數保持一致

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']

hero[6] = 'b'  
# IndexError: list assignment index out of range

通過切片來刪除列表中的元素
del list[元素索引] ：刪除列表裏元素索引指向的元素。

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print ("修改前", hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

del hero[2]
print ("刪除第三個元素", hero)
# 刪除第三個元素 ['蜘蛛俠', '鋼鐵俠', '黑寡婦']

list(seq) 方法用於將元組或字符串轉換爲列表。

aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
# 列表元素 :  [123, 'Google', 'Runoob', 'Taobao']

str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
# 列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

6. 對列表進行增·刪·改·查的幾種方法

6.1 增

1） append(obj) ：向列表的最後添加一個元素；

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print('修改前',hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

hero.append('滅霸')
print('修改後',hero)
# 修改後 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦', '滅霸']

2） insert(arg1,arg2) ：向列表指定位置插入一個元素；參數1:要插入的位置，參數2:要插入的元素；新插入的元素不會替換掉 原位置上的元素，而是將原位置上的元素 向後的擠 了一個位置。

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print('修改前',hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

hero.insert(2,'滅霸')
print('修改後',hero)
# 修改後 ['蜘蛛俠', '鋼鐵俠', '滅霸', '綠巨人', '黑寡婦']

3） extend(seq) ：使用一個新的序列來擴展 當前序列(它會將該序列的中元素添加到列表中) 參數需要傳遞一個序列。
參數 seq ：元素列表，可以是列表、元組、集合、字典，若爲字典,則僅會將鍵(key)作爲元素依次添加至原列表的末尾。

list1 = ['Google', 'Runoob', 'CSDN', 'Taobao']
list2=list(range(5)) # 創建 0-4 的列表
list1.extend(list2)  # 擴展列表
print ("擴展後的列表：", list1)
# 擴展後的列表： ['Google', 'Runoob', 'CSDN', 'Taobao', 0, 1, 2, 3, 4]

6.2 刪

1） del list[元素索引] ：刪除列表裏元素索引指向的元素。

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print ("修改前", hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

del hero[2]
print ("刪除第三個元素", hero)
# 刪除第三個元素 ['蜘蛛俠', '鋼鐵俠', '黑寡婦']

2） pop() ：根據索引刪除指定元素，並返回完成刪除後的序列 (在使用 pop()函數時沒有添加指定索引，默認刪除最後一個元素)；

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print ("修改前", hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

hero.pop()
print ("列表現在爲 : ", hero)
# 列表現在爲 :  ['蜘蛛俠','鋼鐵俠','綠巨人']

hero.pop(1)
print ("列表現在爲 : ", hero)
# 列表現在爲 :  ['蜘蛛俠', '綠巨人']

3） remove() ：刪除 指定元素 (如果與這 指定元素 相同值的元素有多個，只會刪除列表裏的第一個)；

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','綠巨人','黑寡婦','鋼鐵俠','鋼鐵俠']
print ("修改前", hero)
# 修改前 ['蜘蛛俠','鋼鐵俠','綠巨人','綠巨人','黑寡婦','鋼鐵俠','鋼鐵俠']

hero.remove('蜘蛛俠')
print ("列表現在爲 : ", hero)
# 列表現在爲 :  ['鋼鐵俠', '綠巨人', '綠巨人', '黑寡婦', '鋼鐵俠', '鋼鐵俠']

hero.remove('鋼鐵俠')
print ("列表現在爲 : ", hero)
# 列表現在爲 :  ['綠巨人', '綠巨人', '黑寡婦', '鋼鐵俠', '鋼鐵俠']

4） clear() ：函數用於 清空列表，類似於上面的 del a[:]。

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print('修改前',hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

hero.clear()
print ("列表清空後 : ", hero)
# 列表清空後 :  []

6.3 改

1） reverse() ：翻轉列表

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print('修改前',hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

hero.reverse()
print ("列表現在爲 : ", hero)
# 列表現在爲 :  ['黑寡婦', '綠巨人', '鋼鐵俠', '蜘蛛俠']

2） sort(key=None,reverse=False) ：用來對列表中的元素進行排序。reverse：True反序；False 正序

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
print('修改前',hero)
# 修改前 ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

hero.sort()
print ("列表現在爲 : ",hero)
# 列表現在爲 :  ['綠巨人', '蜘蛛俠', '鋼鐵俠', '黑寡婦']

#-----------------------------------------------------------

# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
vowels.sort(reverse=True)
 
# 輸出結果
print ( '降序輸出:', vowels )
# 降序輸出: ['u', 'o', 'i', 'e', 'a']

#-----------------------------------------------------------

# 獲取列表的第二個元素
def takeSecond(elem):
    return elem[1]
 
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二個元素排序
random.sort(key=takeSecond)
 
# 輸出類別
print ('新排序列表：', random)
# 新排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

3） copy() 函數用於 複製列表，類似於 a[:]。

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
hero2 = hero.copy()
print ("hero2 列表: ", hero2)
# hero2 列表:  ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

hero.append('滅霸')
print ("hero 列表: ", hero)
# hero 列表:  ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦', '滅霸']
print ("hero2 列表: ", hero2)
# hero2 列表:  ['蜘蛛俠', '鋼鐵俠', '綠巨人', '黑寡婦']

7. 遍歷列表

7.1 for循環

通過 for循環 來遍歷列表

for循環 語法
for 變量 in 序列(遍歷的規則):
    代碼塊

參考案例

heros = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦','美國隊長','蟻人','鋼鐵俠','鋼鐵俠','鋼鐵俠','滅霸','鋼鐵俠']
for hero in heros:
    if hero == '滅霸':
        print('滅霸--最後的BOSS')
        break
    print("登場英雄：",hero)
else:
    print("沒有循環數據!")
print("完成循環!")
# 登場英雄： 蜘蛛俠
# 登場英雄： 鋼鐵俠
# 登場英雄： 綠巨人
# 登場英雄： 黑寡婦
# 登場英雄： 美國隊長
# 登場英雄： 蟻人
# 登場英雄： 鋼鐵俠
# 登場英雄： 鋼鐵俠
# 登場英雄： 鋼鐵俠
# 滅霸--最後的BOSS
# 完成循環!

注意: for循環的代碼塊會執行多次，序列中有幾個元素就會執行幾次。每執行一次就會將序列中的一個元素賦值給變量，所以我們可以通過變量來獲取列表中的元素。

7.2 range(start, stop[, step])

參數說明：
start: 計數從 start 開始。默認是從 0 開始。例如range（5）等價於range（0， 5）;

>>>for i in range(5):
...     print(i)
...     
0
1
2
3
4

stop: 計數到 stop 結束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]沒有5

>>>for i in range(5,9) :
...     print(i)
...     
5
6
7
8
>>>

step：步長，默認爲1。例如：range（0， 5）等價於 range(0, 5, 1)

>>>for i in range(0, 10, 3) :
...     print(i)  
...     
0
3
6
9
>>>

start、stop、step 可以爲負數

>>>for i in range(-10, -100, -30) :
...     print(i)  
...     
-10
-40
-70
>>>

結合 range() 和 len() 函數以遍歷一個序列的索引，如下案例所示：

hero = ['蜘蛛俠','鋼鐵俠','綠巨人','黑寡婦']
>>> for i in range(len(hero)):
...     print(i, hero[i]) 
...    
0 蜘蛛俠
1 鋼鐵俠
2 綠巨人
3 黑寡婦

還可以使用 range() 函數來創建一個列表：

>>>list(range(5))
[0, 1, 2, 3, 4]
>>>

總結小便條

本篇文章主要講了以下幾點內容：

序列是 Python語言中最基本的一種數據結構。
序列分爲：可變序列（序列中的元素可以改變）和 不可變序列（序列中的元素不能改變）
2.1 可變序列：例如列表（list）、字典(dict) …
2.2.不可變序列：例如字符串（str）、元組（tuple）…
我們今天除了介紹 Python語言中的序列，更重要的講的是列表。那什麼是列表？
答：列表是最常用的 Python語言的數據類型，它可以作爲一個方括號內的逗號分隔值的形式出現。這個樣子： xxx = [ ]
即然知道什麼是列表了，那我們要怎麼 使用它 ？
答：第一個，毫無疑問：切片。（這是實操、面試必備的基礎技能）
列表切片的語法: 列表名[起始索引：結束索引：步長]
查看切出來的子元素的方式：print(列表名[起始索引：結束索引：步長])

第二個，作爲 “魔鬼” 的代名詞的列表怎麼會只有這一種簡單的操作。
多列表的合併 ( lst = [1,2,3] + [4,5,6] )
列表中的元素多次的重複 ( lst = [1,2,3] * 2 )
判斷元素x是否在列表中 ( print(‘x’ in/not in lst) )
列表中有多少元素 ( print(len(lst)) )
獲取列表中最大( max(lst) )/小( min(lst) )值
統計指定元素在列表中的指定區間出現的個數( list.index(‘x’,起始位置,結束位置) )
統計指定元素在列表中出現的個數( list.count(x) )

第三個，列表的 增·刪·改·查
我們單獨的拎出了兩大塊，分別在第4塊講解了列表的特殊“增”–嵌套列表 和第5塊列表的特殊“刪·改”–修改列表。
第4塊嵌套列表：將多個列表合併進一個大(父)列表裏。
第5塊修改列表：通過“切片”的步長和指向修改列表裏指定的值。
第6塊增：append(obj) ：向列表的最後添加一個元素；
insert(arg1,arg2) ：向列表指定位置插入一個元素，新插入的元素不會替換掉 原位置上的元素；
extend(seq) ：使用一個新的序列來擴展 當前序列；

刪：del list[元素索引] ：刪除列表裏元素索引指向的元素；
pop() ：根據索引刪除指定元素，並返回完成刪除後的序列 (在使用 pop()函數時沒有添加指定索引，默認刪除最後一個元素)；
remove() ：刪除 指定元素 (如果與這 指定元素 相同值的元素有多個，只會刪除列表裏的第一個)；
clear() ：函數用於 清空列表，類似於上面的 del a[:]；

改：reverse() ：翻轉列表；
sort(key=None,reverse=False) ：用來對列表中的元素進行排序；
copy() ：函數用於 複製列表，類似於 a[:] ；

查：最簡單，四個字 切片操作。

第四個，列表的循環遍歷 for 循環：

for循環的代碼塊會 執行多次，序列中有幾個元素就會執行幾次。每執行一次就會將序列中的一個元素賦值給變量一次，所以我們可以通過變量來獲取列表中的元素。具體怎麼個 for循環看案例裏的源代碼。

在用 for 循環遍歷列表時，使用 range()函數和 len()函數這兩個函數來輔助遍歷，打印出來的數據會更加的簡介明瞭，閱讀時會更加的方便。具體怎麼使用，回顧上面案例裏的源代碼。

本章回顧暫時就到這了，如果還有點暈，那就去完成作業吧。拜拜~

課程作業

1. 將本篇博客所講的所有內容自己練習多編；
2. 現在有 a = [1,2,3,4,5,6] 不通過函數的形式實現列表的反轉([6,5,4,3,2,1]) 並寫出推導過程。
3. 實現列表推導式 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4. 通過 for循環的循環嵌套實現 [9,6,7,3,2,1,5,8] 數列的排序。(面試必考：冒泡循環。最基礎的循環遍歷排序)
5. 現有兩個列表 i_1 = [11, 22, 33] 和 i_2 = [22, 33, 44]，獲取兩個列表當中相同的元素。

參考答案

# 作業 2
# 本題，與其說是計算機面試考題，不如說是是一道對語文·閱讀理解的考題；本題的核心考點是：面試者對 列表的“切片操作” 的理解。

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

# 考點 列表當中的切片

# 起始位置和結束位置的索引可以不寫
# 如果我省略結束位置，則會從當前的開始位置一直截取到最後；
print(a[1:])
# [2, 3, 4, 5, 6]

# 如果省略開始位置，則會從第一個元素截取到結束位置的元素，但是不包括結束的元素；
print(a[:3])
# [1, 2, 3]

#  如果開始位置和結束位置都省略，則會從第一個元素截取到最後一個元素。
print(a[:])
# [1,2,3,4,5,6]

# 語法  列表[起始:結束:步長]
print(a[0:5])
# [1, 2, 3, 4, 5]

print(a[0:5:1])
# [1, 2, 3, 4, 5]

print(a[::2])
# [1, 3, 5]

# 如果步長爲負從右往左取值
print(a[4:1:-1])
# [5, 4, 3]

# 最後，如果想不通過函數的形式實現列表 a = [1,2,3,4,5,6] 的反轉([6,5,4,3,2,1])。
print(a[::-1])
# [6, 5, 4, 3, 2, 1]

#-----------------------------------------------------------------------------------

# 3. 實現列表推導式 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
i = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

print([i for i in range(10)])
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print([i*i for i in range(10)])
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

#-----------------------------------------------------------------------------------

# 4. 通過 for循環 的循環嵌套實現 [9,6,7,3,2,1,5,8] 數列的排序。

# 對列表實現 [9,6,7,3,2,1,5,8] 數列的排序最簡單的方法當然是 函數 i.sort()。
# i = [9,6,7,3,2,1,5,8]
# i.sort()
# print(i)
# 但本題的考點表達是：通過 for循環 的循環嵌套，通過 “冒泡排序” 的方式實現 [9,6,7,3,2,1,5,8] 數列的排序。所以：

def fun(arr):
    n = len(arr)

    # 遍歷所有數組元素
    for a in range(n):
    	# print(a)

        # Last a elements are already in place
        for b in range(0, n-a-1):
        	# print(b,end='')
            if arr[b] > arr[b + 1]:
                arr[b], arr[b + 1] = arr[b + 1], arr[b]
                # print(arr[b], end='')

arr = [9,6,7,3,2,1,5,8]

fun(arr)

print(arr)
print("排序後的數組:")
for a in range(len(arr)):
    print("%d" % arr[a])
# 輸出結果你自己去測試吧。

#-----------------------------------------------------------------------------------

# 5. 現有兩個列表 i_1 = [11, 22, 33]  和  i_2 = [22, 33, 44]，獲取兩個列表當中相同的元素。

i1 = [11, 22, 33]
i2 = [22, 33, 44]

# 方案 1.

for l1 in i1:
    for l2 in i2:
        if l1 == l2:
            print(l1)



# 方案 2.

for l1 in i1:
    if l1 in i2:
        print(l1)

06. Python語言的核心編程 · 第六章 Python的列表基礎操作彙總

Python列表基礎操作彙總

1. 序列（sequence）

1.1 基本概念

1.2 序列的分類

2. 列表(list)

2.1 列表的使用

2.2 切片（實操、面試必備的基礎技能）

3. 通用操作

4. 嵌套列表

5. 修改列表

6. 對列表進行增·刪·改·查的幾種方法

6.1 增

6.2 刪

6.3 改

7. 遍歷列表

7.1 for循環

7.2 range(start, stop[, step])

總結小便條

課程作業

參考答案

容器中nginx無法使用同一個網絡下的容器域名

Python: SunMoonTimeCalculator

「Pygors跨平臺GUI」1：Pygors跨平臺GUI應用研究

NETCore中實現一個輕量無負擔的極簡任務調度ScheduleTask

docker使用特定的網絡

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

「Pygors跨平臺GUI」2：安裝MinGW-w64、MSYS2還是WSL2

nodejs學習07——API

避免DbContext同時在多個線程調用

GPT-4o 引領人機交互新風向，向量數據庫賽道沸騰了

04. Python語言的核心編程 · 第四章運算符細解

06. Python語言的核心編程 · 第六章 Python的列表基礎操作彙總

02. Python語言的核心編程 · 第二章 Python語言的基礎要點

05. Python語言的核心編程 · 第五章 Python語言的條件控制語句細解

01. Python語言的核心編程 · 第一章計算機的基本概念

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

06. Python語言的核心編程 · 第六章 Python的列表基礎操作彙總

Python列表基礎操作彙總

1. 序列（sequence）

1.1 基本概念

1.2 序列的分類

2. 列表(list)

2.1 列表的使用

2.2 切片（實操、面試 必備的基礎技能）

3. 通用操作

4. 嵌套列表

5. 修改列表

6. 對列表進行 增·刪·改·查 的幾種方法

6.1 增

6.2 刪

6.3 改

7. 遍歷列表

7.1 for循環

7.2 range(start, stop[, step])

總結小便條

課程作業

參考答案

2.2 切片（實操、面試必備的基礎技能）

6. 對列表進行增·刪·改·查的幾種方法