Python基礎筆記(二)

1. List和Tuple

List和Tuple是Python的內置的數據類型，區別在於可變和不可變，List用[]表示，Tuple用()表示，它們之間能夠相互轉換：

# List to Tuple
myList = [1, 2, 3, 4]
myTuple = tuple(myList)

# Tuple to List
myTuple = ("A", "B", "C")
myList = list(myTuple)

可使用len()函數計算長度：

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經過索引獲取列表內單一元素，而且支持索引值爲負數，即從數組的末尾開始計數：

myList = [1, 2, 3, 4, 5]
print(myList[1])
# 2
print(myList[-1])
# 5

從上面的例子能夠看出，索引值爲正數時從索引0開始，索引值爲負數時從索引-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，同時列出數據和數據下標
# 0 1
# ...
# 9 Z

myList = [1, 2, 3, 4, 5]
newList = [i*i for i in myList]
# 將List裏的每一個元素取平方，獲得新List
# [1, 4, 9, 16, 25]

對純數字的列表，能夠經過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"是否在字符串內出現過，返回True或False；
# Python是大小寫敏感的，能夠所有轉換成大寫或小寫來比較，此處返回True

result = "X" not in myList
# 判斷"X"是否不在當前列表，此處返回False

result = myList.count("A")
# 判斷元素"A"在列表裏出現的次數，此處獲得3

result = myStr.count("a")
# 判斷字符"a"在字符串裏出現的次數，此處獲得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的參數在列表或字符串並不存在，會拋異常，這裏須要捕獲異常再處理，此處獲得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. 數組

Python也有array模塊，array中的類型必須所有相同，而且在聲明時就要明確指定元素的類型，只支持一維數組：

import array

myArray = array.array('i', [1, 3, 5])

print(myArray)
# array('i', [1, 3, 5])

print(myArray[1])
# 3

另外一個更好的選擇是NumPy庫的數組，它是Python數組的一個擴展，Python3.4之後的版本可使用如下命令安裝NumPy庫：

pip3 install numpy

(1) 建立

import numpy as np

myArray = np.array([44, 88, 22, "ABC"])
# 直接按指定元素建立數組，當同時存在數字和字符串，會把數字當作字符串處理
# ['44' '88' '22' 'ABC']

myArray = np.arange(1, 10, 2, dtype=np.int16)
# 以1爲起點，10爲終點(不包括10)，間隔爲2，數據類型爲Int16方式建立數組
# [1 3 5 7 9]

myArray = np.ones((2,3), dtype=np.int16, order="C")
# # 建立一個2*3的二維數組，數組的每一個元素都爲"1"，數據類型是Int16，存儲方式按C語言的按行存儲
# [[1 1 1]
#  [1 1 1]]

myArray = np.zeros(8, dtype=np.float, order="F")
# 建立一個長度爲8的一維數組，數組元素都爲"0"，數據類型是Float，存儲方式按Fortran語言的按列存儲
# [0. 0. 0. 0. 0. 0. 0. 0.]

myArray = np.empty(8, np.str, order="C")
# 建立一個長度爲8的一維字符串數組，數組的每一個元素都爲空
# ['' '' '' '' '' '' '' '']

myArray = np.linspace(20, 100, 50, endpoint=False, retstep=False)
# 在20-100之間，取50個點
# endpoint：若是爲True，則必定包括stop；若是爲False，必定不包括stop
# retstep：若是爲True，則返回數組和步長；若是爲False，只返回數組

myRandInt = np.random.randint(5)
# 在0-5之間取一個隨機數，數組中可能有"0"，但不會有"5"

myArray = np.random.randint(1,100,10)
# 在1-100之間生成包含10個隨機數的數組，數組中可能有"1"，但不會有"100"
# [41 58 55  1 94 58 36 17 84 47]

myArray = np.random.randint(1,100,(2,3))
# 在1-100之間取隨機數生成一個2*3的數組
# [[89 86  7]
#  [67 39 58]]

(2) 添加
NumPy的數組不能動態改變大小，numpy.append()函數會新建數組，不會影響原數組。

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合併爲一個新數組
# ['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)
# 循環訪問myList1，將每一個元素添加到newArray末尾
# [6 7 8]

print(np.append(myArray1, 9))
# 在myArray1末尾單獨添加一個數字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))
# 將兩個數組，一個列表拼接起來
# ['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)
# 按順序添加三個數組的全部元素，axis=0能夠省略，axis對於一維數組無效
# [['1' '2' '3']
#  ['4' '5' '6']
#  ['A' 'B' 'C']
#  ['X' 'Y' 'Z']
#  ['一' '二' '三']
#  ['四' '五' '六']]

newArray2 = np.concatenate((myArray1, myArray2, myArray3), axis=1)
print(newArray2)
# 依次添加三個數組的索引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}