Python基礎筆記(二)
1. List和Tuple
List和Tuple是Python的內置的數(shù)據(jù)類型，區(qū)別在于可變和不可變，List用[]表示，Tuple用()表示，它們之間可以相互轉換：
# List to Tuple
myList = [1, 2, 3, 4]
myTuple = tuple(myList)
# Tuple to List
myTuple = ("A", "B", "C")
myList = list(myTuple)
可以使用len()函數(shù)計算長度：
myList = [1, 2, 3, 4]
myTuple = ("A", "B", "C")
print(len(myList))
print(len(myTuple))
# 4 3
由于Tuple是用小括號來聲明，當只有一個元素時，為了避免歧義，需要加入一個逗號：
myTuple = (100)
print(myTuple)
# 100
myTuple = (100,)
print(myTuple)
# (100,)
Python通過索引獲取列表內單一元素，并且支持索引值為負數(shù)，即從數(shù)組的末尾開始計數(shù)：
myList = [1, 2, 3, 4, 5]
print(myList[1])
# 2
print(myList[-1])
# 5
從上面的例子可以看出，索引值為正數(shù)時從索引0開始，索引值為負數(shù)時從索引-1開始，索引-1代表最后一個元素myList[len(myList)-1]。
下面是List的常用增刪改操作：
(1) 添加
myList = [1, 2, 3, "A", "B", "C"]
myList.append(4)
# 向列表末尾添加'4'
# [1, 2, 3, 'A', 'B', 'C', 4]
myList.extend(["X", "Y", "Z"])
# 向列表末尾添加新列表
# [1, 2, 3, 'A', 'B', 'C', 4, 'X', 'Y', 'Z']
myList.insert(2, "apple")
# 在索引2處插入'apple'
# [1, 2, 'apple', 3, 'A', 'B', 'C', 4, 'X', 'Y', 'Z']
(2) 刪除
myList = [1, 2, 3, "A", "B", "C"]
delItem = myList.pop()
# 刪除列表末尾元素，將返回被刪除的元素
# [1, 2, 3, 'A', 'B'], delItem = 'C'
delItem = myList.pop(1)
# 刪除索引1處的元素
# [1, 3, 'A', 'B'], delItem = 2
del myList[2]
# 刪除索引2處的元素
# [1, 3, 'B']
del myList[0:2]
# 刪除索引0到索引2(不包括索引2)的所有元素
# ['B']
myList.remove('B')
# 刪除元素'B'
# []
(3) 獲取
myList = [1, 2, 3, 4, "A", "B", "C", "X", "Y", "Z"]
print(myList[3])
# '4'
newList = myList[:3]
# 從索引0開始，取到索引3(不包括索引3)
# [1, 2, 3]
newList = myList[4:]
# 從索引4開始，取到最后一個元素
# ['A', 'B', 'C', 'X', 'Y', 'Z']
newList = myList[4:6]
# 從索引4開始，取到索引6(不包括索引6)，[m:n]可以理解為從m開始，取n-m個元素
# ['A', 'B']
newList = myList[-3:-1]
# 從索引-3開始，取到索引-1(不包括索引-1)
# ['X', 'Y']
newList = myList[:-5]
# 從索引0開始，取到索引-5(不包括索引-5)
# [1, 2, 3, 4, 'A']
newList = myList[1:8:4]
# 從索引1開始，取到索引8(不包括索引8)，每2個元素取1個
# [2, 4, 'B', 'X']
newList = myList[:]
# 原樣復制一個List，等效于newList = myList
# [1, 2, 3, 4, 'A', 'B', 'C', 'X', 'Y', 'Z']
newList = myList[::-1]
# 將當前List倒序輸出，得到一個新List(不影響原List)
# ['Z', 'Y', 'X', 'C', 'B', 'A', 4, 3, 2, 1]
myStr = "ABCDEFGHIJKL"[3:6]
# 字符串也是一個List，從第3個字符取到第6個字符(不包括第6個字符)
# 'DEF'
myStr = "ABCDEFGHIJKL"[::2]
# 整個字符串每2個字符取1個字符，生成新字符串
# 'ACEGIK'
for k, v in enumerate(myList):
print(k, v)
# 遍歷myList，同時列出數(shù)據(jù)和數(shù)據(jù)下標
# 0 1
# ...
# 9 Z
myList = [1, 2, 3, 4, 5]
newList = [i*i for i in myList]
# 將List里的每個元素取平方，得到新List
# [1, 4, 9, 16, 25]
對純數(shù)字的列表，可以通過min(),max(),sum()來進行科學計算
myList = [1, 2, 3, 4, 5]
minItem = min(myList)
# 1
maxItem = max(myList)
# 5
sumResult = sum(myList)
# 15
(4) 判斷
myList = ["A", 1, 2, 3, "A", "B", "C", "X", "Y", "Z", "A"]
myStr = "What can I do for you?"
result = "what" in myStr.lower()
result = "WHAT" in myStr.upper()
# 判斷"what"是否在字符串內出現(xiàn)過，返回True或False；
# Python是大小寫敏感的，可以全部轉換成大寫或小寫來比較，此處返回True
result = "X" not in myList
# 判斷"X"是否不在當前列表，此處返回False
result = myList.count("A")
# 判斷元素"A"在列表里出現(xiàn)的次數(shù)，此處得到3
result = myStr.count("a")
# 判斷字符"a"在字符串里出現(xiàn)的次數(shù)，此處得到2
index = myList.index("A")
# 獲取元素"A"在列表里的索引，此處得到0
index = myList.index("A",3)
# 在列表索引3(包括索引3)開始獲取元素"A"在列表里的索引，此處得到4
try:
index = myList.index("A",5,100)
except ValueError:
print("該元素不在List內")
else:
print(index)
# 當index的參數(shù)在列表或字符串并不存在，會拋異常，這里需要捕獲異常再處理，此處得到10
(5) 排序
myList1 = [8, 2, 100, 23]
myList2 = ["W", "A", "X", "T"]
myList1.reverse()
# 反轉列表
# [23, 100, 2, 8]
myList1.sort()
# 按升序排列
# [2, 8, 23, 100]
myList2.sort()
# 按升序排列
# ['A', 'T', 'W', 'X']
myList1.sort(reverse=True)
# 按倒序排列
# [100, 23, 8, 2]
2. 數(shù)組
Python也有array模塊，array中的類型必須全部相同，并且在聲明時就要明確指定元素的類型，只支持一維數(shù)組：
import array
myArray = array.array('i', [1, 3, 5])
print(myArray)
# array('i', [1, 3, 5])
print(myArray[1])
# 3
另一個更好的選擇是NumPy庫的數(shù)組，它是Python數(shù)組的一個擴展，Python3.4以后的版本可以使用以下命令安裝NumPy庫：
pip3 install numpy
(1) 創(chuàng)建
import numpy as np
myArray = np.array([44, 88, 22, "ABC"])
# 直接按指定元素創(chuàng)建數(shù)組，當同時存在數(shù)字和字符串，會把數(shù)字當做字符串處理
# ['44' '88' '22' 'ABC']
myArray = np.arange(1, 10, 2, dtype=np.int16)
# 以1為起點，10為終點(不包括10)，間隔為2，數(shù)據(jù)類型為Int16方式創(chuàng)建數(shù)組
# [1 3 5 7 9]
myArray = np.ones((2,3), dtype=np.int16, order="C")
# # 創(chuàng)建一個2*3的二維數(shù)組，數(shù)組的每個元素都為"1"，數(shù)據(jù)類型是Int16，存儲方式按C語言的按行存儲
# [[1 1 1]
# [1 1 1]]
myArray = np.zeros(8, dtype=np.float, order="F")
# 創(chuàng)建一個長度為8的一維數(shù)組，數(shù)組元素都為"0"，數(shù)據(jù)類型是Float，存儲方式按Fortran語言的按列存儲
# [0. 0. 0. 0. 0. 0. 0. 0.]
myArray = np.empty(8, np.str, order="C")
# 創(chuàng)建一個長度為8的一維字符串數(shù)組，數(shù)組的每個元素都為空
# ['' '' '' '' '' '' '' '']
myArray = np.linspace(20, 100, 50, endpoint=False, retstep=False)
# 在20-100之間，取50個點
# endpoint：如果為True，則一定包括stop；如果為False，一定不包括stop
# retstep：如果為True，則返回數(shù)組和步長；如果為False，只返回數(shù)組
myRandInt = np.random.randint(5)
# 在0-5之間取一個隨機數(shù)，數(shù)組中可能有"0"，但不會有"5"
myArray = np.random.randint(1,100,10)
# 在1-100之間生成包含10個隨機數(shù)的數(shù)組，數(shù)組中可能有"1"，但不會有"100"
# [41 58 55 1 94 58 36 17 84 47]
myArray = np.random.randint(1,100,(2,3))
# 在1-100之間取隨機數(shù)生成一個2*3的數(shù)組
# [[89 86 7]
# [67 39 58]]
(2) 添加
NumPy的數(shù)組不能動態(tài)改變大小，numpy.append()函數(shù)會新建數(shù)組，不會影響原數(shù)組。
import numpy as np
myArray1 = np.array([1, 2, 3, 4, 5])
myArray2 = np.array(["A", "B", "C"])
myList1 = [6, 7, 8]
myList2 = ["X", "Y", "Z"]
print(np.append(myArray1, myArray2))
# 將myArray1和myArray2合并為一個新數(shù)組
# ['1' '2' '3' '4' '5' 'A' 'B' 'C']
newArray = np.array([], dtype=np.int16)
for i in myList1:
newArray = np.append(newArray, i)
print(newArray)
# 循環(huán)訪問myList1，將每個元素添加到newArray末尾
# [6 7 8]
print(np.append(myArray1, 9))
# 在myArray1末尾單獨添加一個數(shù)字9
# [1 2 3 4 5 9]
print(np.append(myArray2, myList2))
# 將myList2添加到myArray2末尾
# ['A' 'B' 'C' 'X' 'Y' 'Z']
print(np.concatenate((myArray1, myList1, myArray2),axis=0))
# 將兩個數(shù)組，一個列表拼接起來
# ['1' '2' '3' '4' '5' '6' '7' '8' 'A' 'B' 'C']
myArray1 = np.array([[1, 2, 3], [4, 5, 6]])
myArray2 = np.array([["A", "B", "C"],["X", "Y", "Z"]])
myArray3 = np.array([["一", "二", "三"],["四", "五", "六"]])
newArray1 = np.concatenate((myArray1, myArray2, myArray3), axis=0)
print(newArray1)
# 按順序添加三個數(shù)組的所有元素，axis=0可以省略，axis對于一維數(shù)組無效
# [['1' '2' '3']
# ['4' '5' '6']
# ['A' 'B' 'C']
# ['X' 'Y' 'Z']
# ['一' '二' '三']
# ['四' '五' '六']]
newArray2 = np.concatenate((myArray1, myArray2, myArray3), axis=1)
print(newArray2)
# 依次添加三個數(shù)組的索引0的元素，然后添加索引1的元素(直到添加到最大索引處的元素)
# [['1' '2' '3' 'A' 'B' 'C' '一' '二' '三']
# ['4' '5' '6' 'X' 'Y' 'Z' '四' '五' '六']]
其它操作大致與List相同，可參考List的示例。
3. 字典
myDict = {"name":"wayne", "age":25, "skills":["java", "python", "ruby"]}
myDict["name"] = "tom"
# 新增一個元素，如果key已存在，則修改對應的value
# if not myDict.get("nickname"):
if not "nickname" in myDict:
myDict["nickname"] = "mario"
# 如果字典里沒有"nickname"這個key，則用指定值添加
print(myDict.keys())
# 輸出所有key
# dict_keys(['name', 'age', 'skills'])
print(myDict.values())
# 輸出所有value
# dict_values(['tom', 25, ['java', 'python', 'ruby']])
print(myDict.items())
# 輸出所有items
# dict_items([('name', 'tom'), ('age', 25), ('skills', ['java', 'python', 'ruby'])])
for k in myDict:
v = myDict.get(k)
print(k,":",v)
# 遍歷整個字典
# name : tom
# age : 25
# skills : ['java', 'python', 'ruby']
newDict = myDict.copy()
# 拷貝字典
# {'name': 'tom', 'age': 25, 'skills': ['java', 'python', 'ruby']}
myDict.pop("age")
# 移除key為"age"的元素
# {'name': 'tom', 'skills': ['java', 'python', 'ruby']}
myDict.popitem()
# 移除最后一個元素
# {'name': 'tom'}
myDict.clear()
# 清空字典
# {}
4. 集合
集合(set)里的元素是無序的，它最大的特點是沒有重復元素，如果嘗試添加重復元素則會被自動過濾。
mySet = set([1, 1, "A", "A", 3, 3])
print(mySet)
# {1, 'A', 3}
mySet1 = set([1, 2, 3])
mySet2 = set([2, 3, 4])
# 取交集
mySet = mySet1 & mySet2
print(mySet)
# {2, 3}
# 取并集
mySet = mySet1 | mySet2
print(mySet)
# {1, 2, 3, 4}
浙公網安備 33010602011771號