複習：

今日內容：組合資料型別

集合型別及操作：

集合型別的定義：

非可變的資料型別：整數、浮點、元組、負數、字串型別

可變的資料型別：列表list和字典dict。所以看不到集合中有列表、{[ ]} 

就算是set([12,33])，輸出看到的也是{12,33}

重點：

這裡是指會把原集合資料改變。而非增強操作符則會生成新的集合且賦值給新集合變數

A = {'p', 'y', 123}
print(A)
B = set("pypy123")
print(B)
print(A-B)
print(B-A)
print(A&B)#交
print(A^B) #補（把大家都沒有的打印出來）
print(A|B) #並
 

 

集合的處理方法：（10個記下來！！！）

集合型別應用場景：

資料去重、包含關係比較

我的做法：

ls = ["p", "p", "y", "y", 123]
l =[]

for i in range(len(ls)):
    if ls[i] not in ls[i+1:-1]:
        l.append(ls[i])
print(l)

這個說超過了range但是明顯沒有呀..怎麼破？應該ls在變化，所以不能這樣，可能取不到某個值

總結：

序列型別及操作

ls = ["python", ".io", 123]
print(ls[::-1])

s = "python123.io"
print(s[::-1])
 

序列型別通用方法和函式（5個函式）

ls = ["python", ".io", 123]
print(ls[::-1])

s = "python123.io"
print(s[::-1])

print(len(ls))

print(max(s))
print(s.count("o"))
print(s.index("o"))

元組型別

      所以上面的圖片可以告訴我們，元組一旦建立是不能被修改的，儘管creature[::-1]操作後，creature還是沒有變化，依舊是可以通過color[-1][2]找到tiger、

列表型別及操作：

使用記憶體和指標......沒有使用[]相當於沒有申請記憶體，只是重新命名了而已。ls和lt都指向同一段記憶體空間

列表型別操作函式和方法：

ls = ["cat", "dog", "tiger", 1024]
ls[1:2] = [1, 2, 3, 4]
print(ls)
print(ls[1:2])

del ls[::3] #刪除以步長為3的數
print(ls)
print(ls*2)

修改列表就是增刪減除

但是列表就可以用ls.pop("2")

#列表型別操作
ls = ["cat", "dog", "tiger", 1024]
print(ls)
ls.append(1234)
print(ls)
ls.insert(3, "human")
print(ls)
ls.reverse()
print(ls)

做個小測試，看你能完成幾個？

#列表型別操作
#


lt = []
for i in range(5):
    lt.append(eval(input()))
print(lt)

lt[2] = 5
print(lt)

lt.insert(2, 3)
print(lt)

del lt[0]
print(lt)

del lt[1:4]
print(lt)


if 0 in lt:
    print("是的,0在lt列表中")

lt.append(0) #千萬別是"0" 後面沒有辦法去計算sum
print(lt)

lt.index(0)
print(lt.index(0))

len(lt)
print(lt)

#注意哈  lt.max()
print(max(lt))

lt.clear()
print(lt)

、

序列型別的應用場景

當程式不是一個人寫的，可以用元組作介面進行傳遞。

例子：基本統計值計算

def getNum():
    nums =[]
    iNumStr = input("請輸入數字（回車退出）：")
    while iNumStr !="":
        nums.append(eval(iNumStr))
        iNumStr = input("請輸入數字（回車退出）：")

    return nums


def mean(numbers):
    s = 0.0
    for num in numbers:
        s = s + num
    return s/len(numbers)


def dev(numbers, mean):
    sdev = 0.0
    for num in numbers:
        sdev = sdev+(num - mean)**2
    return sdev / len(numbers), pow(sdev / len(numbers), 0.5)


def median(numbers):
    sorted(numbers)
    size = len(numbers)
    if size % 2 == 0:
        med = (numbers[size//2 - 1]+numbers[size//2])/2
    else:
        med = numbers[size//2]
    return med


n = getNum()
m = mean(n)
f, j = dev(n, m)
print("陣列個數：{},平均值：{},方差：{:.2f},均方差：{:.2f},中位數：{}".format(len(n), m, f, j, median(n)))

題目需要掌握：

1.如何獲取多個數據

2、將功能模組化 函式化

python內建函式幾十個，需要記熟，才能好好的用python。

字典型別以及操作

字典型別操作函式和方法

d.keys 和d.values 返回的型別可用 for in來遍歷 但是不能當做事列表來操作

做個測試：

zd = {}
zd = {"中國": "北京", "city": "beijing"}
zd['city'] = " Beijing"
if "c" in zd:
    print("Ture")
len(zd)
zd.clear()

   字典型別的應用場景

總結：

jieba庫

提示：需要你聯網。

常用的庫：！！！

文字詞頻統計：

例項講解：

文字噪音處理 歸一化

#CalHamletV1.py

def getText():
    txt = open("hamlet.txt","r").read()
    txt = txt.lower()
    for ch in '!"#$%()*+,-./:<=>[email protected][\\]^_"''{|}~':
        txt = txt.replace(ch, "")
    return txt


hameletTxt = getText()
words = hameletTxt.split()
counts = {}
for word in words:
    counts[word] = counts.get(word, 0)+1
items = list(counts.items())
# print(items.sort(key=lambda x: x[1], reverse=True))
items.sort(key=lambda x: x[1], reverse=True)
for i in range(10):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

知識點：

1、type(items.sort(key=lambda x: x[1], reverse=True))

輸出的是：<class 'NoneType'>

所以：print(items.sort(key=lambda x: x[1], reverse=True))不能這麼用

但是：

listC = [('e', 4), ('o', 2), ('!', 5), ('v', 3), ('l', 1)]
print(sorted(listC,key=lambda x: x[1], reverse=True))

輸出是：[('!', 5), ('e', 4), ('v', 3), ('o', 2), ('l', 1)]

2、print("{0:<10}{0:>5}".format(word, count))

輸出：

可見這個{1:>5}還不是耐得....

出現UnicodeDecodeError: 'utf-8' codec can't decode byte 0xd0 in position 0: invalid con

#CalThreeKingdomsV1.py
import jieba
txt = open("threeKingdoms.txt", "r", encoding="utf-8").read()
words = jieba.lcut(txt)
print(words)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    else:
        counts[word] = counts.get(word, 0) + 1 #鍵word存在則返回相應值，不存在則返回0
items = list(counts.items())
# 固定用法，在對應列進行排序，從小到大的排序與sorted(listC,key=lambda x: x[1], reverse=True)相反這是從大到小
items.sort(key=lambda x: x[1], reverse=True)
for i in range(15):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

卻說、孔明日 =孔明 玄德日 = 玄德

所以哈.....改進：

集合、序列、字典很好的例項。

      之所以稱為不可變資料型別，這裡的不可變可以理解為x引用的地址處的值是不能被改變的，也就是31106520地址處的值在沒被垃圾回收之前一直都是1，不能改變，如果要把x賦值為2，那麼只能將x引用的地址從31106520變為31106508，相當於x = 2這個賦值又建立了一個物件，即2這個物件，然後x、y、z都引用了這個物件，所以int這個資料型別是不可變的，如果想對int型別的變數再次賦值，在記憶體中相當於又建立了一個新的物件，而不再是之前的物件。

      可變資料型別是允許同一物件的內容，即值可以變化，但是地址是不會變化的。但是需要注意一點，對可變資料型別的操作不能是直接進行新的賦值操作，比如說a = [1, 2, 3, 4, 5, 6, 7]，這樣的操作就不是改變值了，而是新建了一個新的物件，這裡的可變只是對於類似於append、+=等這種操作。

總結

      用一句話來概括上述過程就是：“python中的不可變資料型別，不允許變數的值發生變化，如果改變了變數的值，相當於是新建了一個物件，而對於相同的值的物件，在記憶體中則只有一個物件，內部會有一個引用計數來記錄有多少個變數引用這個物件；可變資料型別，允許變數的值發生變化，即如果對變數進行append、+=等這種操作後，只是改變了變數的值，而不會新建一個物件，變數引用的物件的地址也不會變化，不過對於相同的值的不同物件，在記憶體中則會存在不同的物件，即每個物件都有自己的地址，相當於記憶體中對於同值的物件儲存了多份，這裡不存在引用計數，是實實在在的物件。”