列表與for循環

一、list列表

1.概述

變量：使用變量存儲數據，但是，有一個缺點：一個變量每次只能存儲一個數據

#需求：存儲5個人的年齡，求他們的平均年齡
age1 = 29
age2 = 36
age3 = 37
age4 = 47
age5 = 10
​
average = (age1 + age2 + age3 + age4 + age5) / 5

解決方案：從內存的角度上分析，優化內存，使用列表存儲數據

偽代碼：列表 = [100個人的年齡]

num = 10

作用：列表相當於一個容器，可以同時存儲多個數據

本質：列表是一個有序的集合

說明：有序指的是有順序，並不是排序【數據在內存中的存儲的順序和存放的順序是相同的】

注意：列表中實際上存儲的仍然是變量

2.創建列表

創建列表其實就相當於定義一個列表類型的變量

語法：

​ 變量名 = 初始值

​ 列表名 = 列表 =====》列表名 = [數據1，數據2。。。。]

說明：

​ a.Python中使用[]表示列表

​ b.列表中存儲的數據被稱為元素

​ c.列表中的元素默認從頭到尾進行編號，編號從0開始，編號的取值范圍：0~元素的個數 -1，這些編號被稱為索引，下標，角標

​ d.注意：索引的作用就是方便獲取或者操作數據，如果在獲取數據的過程中，超出索引的范圍，則代碼會報錯【下標越界，索引越界】

代碼演示：

#1.創建一個空列表
#list()
#注意：列表的命名一般使用listxxx，盡量不要直接使用list
list1 = []
print(list1)
​
​
#2.創建一個非空的列表
#有序的：列表中的元素是有序的【存放和在內存中的存儲順序相同】
list2 = [34,5,4,6,765,76]
print(list2)
​
#3.列表中可以存儲重復數據
list3 = [34,34,5,5,6,7]
print(list3)
​
#4.列表中可以同時存儲不同類型的數據【Python的特點：Python是動態類型的語言】
list4 = [23,"hello",True]
print(list4)
​
#注意：將需要存儲的數據存儲到列表中，不需要考慮列表的大小，
#如果數據量大的情況下，在運行代碼的過程中，列表會進行自動的擴容
​
#list，tuple，dict，set被稱為數據結構，最常用list和dict

 

3.列表元素的訪問

通過索引進行訪問列表中的元素

3.1獲取值

語法：列表名[索引]

代碼演示：

#1.獲取元素
list1 = [3,54,5,45]   #索引：0~3
#列表中存儲的實際上是變量，是變量的引用
num1 = list1[3]
print(num1)
print(list1[3])
print(id(num1) == id(list1[3]))  #True
print(num1 is list1[3])#True
​
"""
num1 = 10
num2 = num1
print(id(num1) == id(num2))  #True
"""
​
#注意：如果超過了索引的范圍，則出現索引越界問題
#print(list1[5])   #IndexError: list index out of range
​
#列表的下標可以是正數【從前向后訪問】，也可以是負數【從后向前訪問】
#索引的取值范圍：0~元素個數 - 1    或者    -1~ -（元素個數）
#print(list1[-5])

3.2替換值或者修改值

語法：列表名[索引] = 新的值

代碼演示：

#2.替換或者修改
print(list1[3])
list1[3] = 100
print(list1[3])
​
#列表是可變的【一個列表一旦被定義之后，在代碼運行的過程中，可以隨時更改元素的值，也可以隨時向列表中增加元素或者刪除元素】

4.列表的操作

4.1列表組合

代碼演示：


#1.列表組合：將兩個或者兩個以上的列表合並為一個列表 ：+
list1 = [3,4,5]
list2 = [34,6,56]
#注意：列表出現的順序決定了組合之后的列表中元素的順序
#注意：列表組合之后生成一個新的列表，原列表不受任何影響
list3 = list2 + list1
print(list3)
print(list1)

4.2列表元素的重復

代碼演示：


#2.列表元素的重復
print("hello" * 3)
list4 = [34,5,56]
print(list4 * 3)

4.3判斷元素是否在列表中

代碼演示：


#3.判斷元素是否在列表中
#成員運算符：in   not in
#語法：元素  in/not  in   列表
print(5 in list4)
print(100 in list4)
#使用場景：一般應用在if判斷中
if 43 in list4:
    print("yes")

 

4.4切片【截取】【掌握】

獲取字列表的過程

語法：列表名[start:end:step]
說明：start和end表示截取元素的下標的區間
 step表示步長
 
舉例：0~6
start=2
end=5
step=2

代碼演示：

list1 = [54,6,5,65,6,"aa","bb"]
​
​
#列表名[start:end:step]
​
​
#指定區間
#包頭不包尾，step如果不書寫，則默認為1
print(list1[2:5])
print(list1[2:5:1])
​
#從指定下標到結尾,包括最后一個元素
print(list1[2:])  #[5, 65, 6, 'aa', 'bb']
print(list1[2:6]) #[5, 65, 6, 'aa']
​
#從開頭獲取到指定下標，包括開頭，不包括指定下標
print(list1[:5])  #[54, 6, 5, 65, 6]
print(list1[0:5])  #[54, 6, 5, 65, 6]
​
#特殊情況1:如果end超出了下標的范圍，則默認獲取從指定下標開始到最后一個元素
#print(list1[100])
print(list1[2:100])
​
#特殊情況二：step可以是正數，也可以是負數
#下標的范圍：0~6  或者   -7~ -1
print(list1[2:6:2])  #2 4
print(list1[0:5:-1]) #[]
​
print(list1[-1:-6])  #[]
print(list1[-1:-6:-1])
​
#需求;將指定的列表倒序輸出
print(list1[-1::-1])
print(list1[::-1])

"""
結論：
1.不管start和end為正還是為負，如果省略step此時的step默認都是1
2.如果start和end都為正，step必須為正，否則獲取出來的子列表為空
3.如果start和end都為負，step必須為負，否則獲取出來的子列表為空
4.不管start和end為正還是為負，永遠都包含start，不包含end
5.如果為正，則表示從前往后進行獲取，如果為負，則表示從后向前獲取
"""
​
#需求：按照要求完成下面的操作
"""
1.list2[:3]   abc aaa def
2.list2[2:]    def bbb
3.list2[::-1]   bbb def  aaa abc
4.list2[-1::-2]   bbb  aaa
5.list2[1::2]    aaa bbb
"""
list2 = ["abc","aaa","def","bbb"]

 

4.5簡單遍歷

遍歷：將列表中的元素挨個訪問出來

代碼演示：

list1 = [2,34,35,5,45]
"""
num1 = list1[0]
num2 = list1[1]
num3 = list1[2]
"""
​
#0~4
index = 0
while index < 5:
    num = list1[index]
    print(num)
    index += 1
​
#需求：倒序輸出列表中的元素
#方式一
print(list1[::-1])
​
#方式二
index = 4
while index >= 0:
    num = list1[index]
    print(num)
    index -= 1

5.列表的功能【重點掌握】

系統內置的功能

語法：

​ 列表名.功能名(xx)

​ 功能名(xx)

5.1添加元素

代碼演示：

#一、添加元素 列表名.功能名（xx）
#1.append（）：追加,在列表的末尾添加元素
list11 = [11,22,33,44]
print(list11)
#1.1添加單個元素
list11.append(55)
print(list11)
#1.2添加多個元素
#注意：append中每次只能添加一個數據,如果要追加多個數據，可以采用列表的方式進行追加，但是，整個列表會被當做一個整體添加進去
list11.append([66,77,88])
print(list11)
print(list11[5])
​
print("***************")
​
#2.extend（）：擴展,在列表的末尾添加元素
list12 = [11,22,33,44]
print(list12)
#2.1添加單個元素
#注意：extend中添加的元素必須是可迭代的【可以使用for循環和while循環遍歷的數據：list,tuple,dict,set】
#在extend中添加元素，目前只能添加列表
#工作原理：並沒有將整個列表添加到原列表中，而是新的列表打碎，只將其中的元素添加到原列表中
list12.extend([55])
print(list12)
#2.2添加多個元素
list12.extend([66,77])
print(list12)
​
print("***************")
​
#3.insert（）：插入,在列表的任意索引處插入元素   列表名.insert(index,element)
list13 = [11,22,33,44]
print(list13)
#3.1添加單個元素
#在指定的位置插入指定的元素，原來的元素依次向后順延
list13.insert(2,100)
print(list13)
​
#3.2添加多個元素
#和append類似，將整個列表插入到指定位置
list13.insert(2,[55,66])
print(list13)
​
#append相對而言使用最多

5.2刪除元素

代碼演示：

#二、刪除元素   列表名。功能名(xx)
#1.pop() 彈出，移除列表中的指定位置的元素【通過索引移除元素】
list21 = [11,22,33,44,55]
print(list21)
#1.1pop如果不寫索引，則默認刪除最后一個元素
list21.pop()
print(list21)
#1.2刪除指定下標的元素
list21.pop(2)
print(list21)
#1.3pop返回被刪除的元素
num = list21.pop(2)
print(num)
​
#list21.pop(10)   #IndexError: pop index out of range
​
print("*******************")
​
#2.remove() 移除,移除列表中的指定元素
list22 = [11,22,33,44,55]
print(list22)
list22.remove(33)
print(list22)
​
#list22.remove(100)   #ValueError: list.remove(x): x not in list
​
#注意：remove只能刪除列表中從左往右查找到的第一個元素
list222 = [11,22,33,44,55,33,44,55,44,44]
print(list222)  #[11, 22, 33, 44, 55, 33, 44, 55]
list222.remove(44)
print(list222)   #[11, 22, 33, 55, 33, 44, 55]
list222.remove(44)
print(list222)   #[11, 22, 33, 55, 33, 55]
​
​
#3.clear()  清除，將列表中的元素全部清空
list23 = [4,54,65,66]
list23.clear()
print(list23)
​
​
#需求：刪除指定列表中指定的重復元素

5.3獲取

代碼演示：

#三、獲取
#1.len():長度，length，獲取列表的長度或者獲取列表中元素的個數   功能名（列表名）
#索引的取值范圍：0~len(列表) - 1
list31 = [43,54,5,454]
print(len(list31))
​
#2.max()，功能名（列表名），獲取列表中的最大值
print(max(list31))
​
#3.min()，功能名（列表名），獲取列表中的最小值
print(min(list31))
​
#需求：從控制台獲取三個數，獲取最大值
"""
n1 = int(input())
n2 = int(input())
n3 = int(input())
l1 = [n1,n2,n3]
print(max(l1))
"""
​
#4.index():索引，從列表中獲取匹配到的第一個元素的下標   列表名.功能名(元素)  \
#查找指定元素在指定列表中的位置
list32 = [2,54,5,2,46,6,2]
index1 = list32.index(2)
print(index1)
​
#5.count()：個數，統計指定元素在指定列表中出現的次數
print(list32.count(2))
​
#需求：自己實現統計某個元素在列表中出現的次數
#記錄次數
c = 0
#表示下標
i = 0
while i < len(list32):
    if list32[i] == 2:
        c += 1
    i += 1
print(c)
​
#優化需求：刪除列表中的重復元素
"""
list3 = [11,22,33,44,55,33,44,55,44,44]
c = 0
while c < 4:
    list3.remove(44)
    c += 1
print(list3)
"""
​
list33 = [11,22,33,44,55,33,44,55,44,44]
num = 44
c = 0
all = list33.count(num)
while c < all:
    list33.remove(num)
    c += 1
print(list33)

5.4其他

代碼演示：

#四、其他用法
#1.reverse(),反轉，將列表中的元素倒序輸出
list41 = [3,54,4,6]
print(list41)
list41.reverse()
print(list41)
print(list41[::-1])
​
#2.sort(),排序  列表名.sort(),默認為升序排序
#注意：在原列表中進行排序
list42 = [34,5,4,54,6,56]
#升序
#list42.sort()
#print(list42)
​
#降序
#方式一：sort(),reverse()
#方式二
list42.sort(reverse=True)
print(list42)
​
​
#3.sorted()，排序   sorted(列表),默認升序
#注意：排序之后生成一個新的列表
list43 = [34,5,4,54,6,56]
​
#升序
newList = sorted(list43)
print(newList)
print(list43)
​
#降序
newList1 = sorted(list43,reverse=True)
print(newList1)
​
#key:自定義排序規則:按照字符串的長度進行排序
list44 = ["abc","gh","sghjghjahg","hello"]
newList2 = sorted(list44,key=len,reverse=True)
print(newList2)

 

5.5拷貝【面試題】

淺拷貝，深拷貝

代碼演示：

import  copy
​
#五、拷貝
"""
淺拷貝：拷貝了最外圍的實體本身，內部的元素只是拷貝了一個引用，也就是說，把實體拷貝一遍，但是該實體中的其他實體不拷貝
深拷貝：外圍和內部的實體都會被拷貝，拷貝是實體本身，而不是引用
"""
​
"""
變量  num = 10
引用  num
不可變實體:一旦創建就不能發生改變，包括數字，字符串，元組
可變實體：可以進行修改的實體，包括列表，字典
"""
​
#深淺拷貝的作用：減少內存的使用【以后做數據的清洗，修改或者其他操作的時候，對原數據拷貝一份，以防數據被修改之后，找不到原數據】
​
#一、對於不可變實體的深淺拷貝
a = (1,2,3)
#1.淺拷貝
#1.1淺拷貝：=
print("淺拷貝：=的拷貝")
b = a
print(a)
print(b)
print(id(a))
print(id(b))
​
#1.2淺拷貝：copy（）
#第一步：導入模塊  import copy
print("淺拷貝：copy的拷貝")
c = copy.copy(a)
print(a)
print(c)
print(id(a))
print(id(c))
​
#2.深拷貝
#deepcopy()
d = copy.deepcopy(a)
print(a)
print(d)
print(id(a))
print(id(d))
​
print("**********************")
​
#二、可變實體的深淺拷貝
a = [1,2,3]
#1.淺拷貝
#1.1=
print("淺拷貝：=的拷貝")
b = a
print(a)
print(b)
print(id(a))
print(id(b))
​
#1.2copy
print("淺拷貝：copy的拷貝")
c = copy.copy(a)
print(a)
print(c)
print(id(a))
print(id(c))
​
#2.深拷貝
#deepcopy()
d = copy.deepcopy(a)
print(a)
print(d)
print(id(a))
print(id(d))
​
"""
總結：
a.深淺拷貝都是對原實體的拷貝，區別在於是 實體的拷貝還是引用的拷貝【堆空間還是棧空間】
b.不可變的實體：對於深淺拷貝毫無影響，最終的地址和值都是相等的
c.可變的實體：
    =淺拷貝：值相等，地址相等
    copy淺拷貝：值相等，地址不相等
    deepcopy深拷貝：值相等，地址不相等
"""

6.二維列表

實質上還是一個一維列表，只不過該列表中的元素仍然是一個列表

變量----》一維列表-------》二維列表

舉例：

沒錢 零買 1根 一個變量

稍微有錢 一包 一維列表 存儲了20個變量

有錢 一條 二維列表 存儲了10個一維列表

代碼演示：

#二維列表
list1 = [[23,4,3,5],[34,54],[100,200]]
​
#二維列表中元素的訪問
print(list1[2])   #[100,200]
​
subList1 = list1[1]
print(subList1)
num1 = subList1[1]
print(num1)
​
print(list1[1][1])
​
#二維列表的遍歷：嵌套循環
#外層循環：遍歷外層列表
i = 0
while i < len(list1):
​
    print(list1[i])
    #內層循環：遍歷內層列表
    j = 0
    while j < len(list1[i]):
        print(list1[i][j])
        j += 1
​
    i += 1

二、循環語句之for循環

1.基本用法

while語句

初始化表達式

while 條件表達式：

​ 循環體

​ 循環之后的操作表達式

for語句

for 變量名 成員運算符 列表名：

​ 循環體

說明:for主要用來遍歷可迭代實體【list，string，tuple，dict，set】

​ 成員運算符一般使用in

工作原理：按照順序獲取列表中的元素，賦值給變量，再執行循環體，如此循環往復，直到將列表中的所有元素遍歷完成

代碼演示：

list1= [23,35,43,54,54]
​
#1.遍歷列表
#while:通過索引遍歷列表
i = 0
while i < len(list1):
    print(list1[i])
​
    i += 1
​
​
#for:直接獲取元素
"""
for  變量名 in  列表名：
​
    循環體
"""
for j in list1:
    print(j)
​
#2.else分支
#for循環遍歷完列表中的元素之后，會執行else分支
for num in [23,5,6,5,66,7]:
    print(num)
else:
    print("else被執行了")
​
​
#需求：已知列表，list1 = [3,35,45,4,56,4],將其中的偶數元素輸出
list1 = [3,35,45,4,56,4]
i1 = 0
while i1 < len(list1):
    if list1[i1] % 2 == 0:
        print(list1[i1])
    i1 += 1
​
for i2 in list1:
    if i2 % 2 == 0:
        print(i2)
​
#需求：已知列表，list1 = [3,35,45,4,56,4],將下標為偶數的元素輸出
i1 = 0
while i1 < len(list1):
    if i1 % 2 == 0:
        print(list1[i1])
    i1 += 1

2.列表生成器

range(start,end,step),注意：start和step可以省略，如果省略，start默認為0，step默認為1

start:開始數字

end：結束數字

step：步長

作用：生成具有一定規律的列表 【list(range())】

代碼演示：

"""
range(100):其中的元素是0~99之間的所有的整數
range(1,100):其中的元素是1~99之間的所有的整數
range(1,100,2):其中的元素是1~99之間的所有的奇數
"""
#需求：已知列表，list1 = [3,35,45,4,56,4],將下標為偶數的元素輸出
#0~len(list1) - 1
list1 = [3,35,45,4,56,4]
​
#操作索引
for i in range(0,len(list1)):
    print(list1[i])
#操作元素
for i2 in list1:
    print(i2)
​
​
#需求：求1~100之間所有偶數的和
#方式一
sum1 = 0
num1 = 0
while num1 <= 100:
    sum1 += num1
    num1 += 2
​
​
#方式二
sum2 = 0
num2 = 1
while num2 <= 100:
    if num2 % 2 == 0:
        sum2 += num2
    num2 += 1
​
#方式三
sum3 = 0
for num3 in range(1,101):
    if num3 % 2 == 0:
        sum3 += num3
​
#方式四
sum4 = 0
for num4 in range(0,101,2):
    sum4 += num4
​
​
#注意：for循環遍歷列表，如果列表已經存在，則直接遍歷，如果不存在，則通過range生成

3.列表的遍歷方式

代碼演示：

#使用for循環遍歷列表
list1 = [2,5,5,4,545]
#1.操作元素
for num in list1:
    print(num)
​
​
#2.操作索引
for i in range(0,len(list1)):
    print(i,list1[i])
​
​
#3.同時遍歷元素和索引
#借助於枚舉enumerate【仍然是一個容器，存儲是列表中的索引和元素】
for i,num  in enumerate(list1):
    print(i,num)
​

 

4.嵌套for循環

代碼演示：

#嵌套for循環
#需求：打印九九乘法表
for i in range(1,10):
    for j in range(1,i + 1):
        print("%dx%d=%d" % (j,i,i * j),end=" ")
​
    print("")
​
​
#需求：遍歷二維列表
list1 = [[23,4,3,5],[34,54],[100,200]]
​
for subList in list1:
    for num in subList:
        print(num)
​

5.break、continue、pass的用法

break:跳出當前循環

continue：結束當前正在進行的循環，繼續下一次循環

pass：空語句，是為保證程序的完整性，占位的作用【if，while，for,函數】

代碼演示：

　　

i = 0
while i < 5:
    print(i)
    if i == 2:
        break
    i += 1

print("*************")

for j in range(0,5):
    print(j)
    if j == 2:
        break

#在while和for中，都表示直接跳出當前循環
#continue:結束當前正在進行的循環，繼續下一次循環
#和brak類似，可以單獨使用，后面的代碼沒有執行的機會，在實際的項目開發中，常用break

i = 0
while i < 5:

    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

print("*************")


for j in range(0,5):

    if j == 2:
        continue

    print(j)



#pass
if True:
    pass

print("hello")