Day 7.9 前七天總複習

時隔10天，我終於又再次拾起了我的狗屎python，今天主要是把前七天（當然我學的可不止七天）進行了一個總複習，最後是欠了個猜年齡遊戲plus版，先欠著吧，下次再說，剛剛在圖書館無意間看到一本書，看書去了，繼續努力！！！

目錄

• 一 計算機之程式設計
  • 1 什麼是程式語言
  • 2 什麼是程式設計
  • 3 為什麼要程式設計
• 二 計算機組成原理
  • 1 計算機五大組成
    • 1. CPU
    • 2. 記憶體
    • 3. 外存
    • 4. 輸入裝置
    • 5. 輸出裝置
    • 6.I/O裝置
  • 2 32位和64位
  • 3 多核cpu
  • 4 硬碟的工作原理
    • 1. 機械硬碟工作原理
    • 2. 固態硬碟工作原理
• 三 計算機作業系統
  • 1 檔案是什麼
  • 2 應用程式是什麼
  • 作業系統能幹什麼
  • 3 計算機三大組成
    • 1.應用程式
    • 2.作業系統
    • 3.硬體
    • 3 應用程式的啟動和作業系統的啟動
      • 1.應用程式的啟動
      • 2.作業系統的啟動
• 四 程式語言分類
  • 1 機器語言
  • 2 組合語言
  • 3 高階語言
    • 1.解釋性語言
    • 2 編譯型語言
• 五 執行python的兩種方式
  • 1 互動式
  • 2 命令式
• 六 執行python程式的兩種IDE
  • 1 pycharm
  • 2 jupyter
• 七 變數
  • 1 什麼是變數？
  • 2 變數的組成
  • 3 變數的定義規範
  • 4 定義變數的兩種方式
  • 5 常量
  • 6.註釋
    • 1.單行註釋
• +註釋的語句，#後面的字元不執行語法，即為普通字元，一般用於解釋某一段程式碼
  • • 2.多行註釋
  • 7 引用計數
  • 8 垃圾回收機制
  • 9 小整數池
• 八 與使用者互動
  • input
• 九 格式化輸出
  • 1 佔位符
  • 2 format格式化
  • 3 f-string格式化
• 十 基本運算子
  • 1 算術運算子
  • 2 邏輯運算子
  • 3 比較運算子
  • 4 賦值運算子
  • 5 身份運算子
  • 6 運算子優先順序（略）
  • 7 鏈式賦值
  • 8 交叉賦值
  • 9 解壓縮
• 十一 控制
  • 1 流程控制之if判斷
    • 1.if
    • 2.if else
    • 3.if ... elif ... elif... else
  • 2 流程控制之while迴圈
    • 1.while
    • 2.while + break
    • 3.while + continue
    • 4.while + else
  • 3 流程控制之for迴圈
    • 1.for
    • 2.for + break
    • 3.for + continue
    • 4.for + else
• 十二 資料型別內建方法
  • 1 數字型別內建方法
    • 1.整形
    • 2.浮點型
  • 2 字串型別內建方法
  • 3 列表型別內建方法
  • 4 元組型別內建方法
  • 5 字典型別內建方法
  • 6 集合型別內建方法
  • 7 布林型別
  • 8 資料型別總結
  • 9 複製
  • 10 淺複製
  • 11 深複製

一 計算機之程式設計

1 什麼是程式語言

程式語言是人與計算機交流的介質

2 什麼是程式設計

透過使用程式語言編寫的一個個的檔案

3 為什麼要程式設計

為了奴隸計算機，解放勞動力，為人們完成一個個具體的任務

二 計算機組成原理

1 計算機五大組成

1. CPU

• 控制器：控制硬體

• 運算器：進行邏輯運算+算術運算

2. 記憶體

臨時儲存資料的硬體

• 優點：速度快
• 缺點：臨時儲存，斷電即消失

3. 外存

永久儲存資料的硬體

• 優點：永久儲存
• 缺點：速度慢

4. 輸入裝置

輸入資訊的硬體，如鍵盤/滑鼠/u盤

5. 輸出裝置

輸出資訊的硬體，如顯示器/印表機/u盤

6.I/O裝置

既可輸入資訊，又可以輸出資訊的硬體，即為I/O裝置

2 32位和64位

• 32位：一次效能夠讀取32個二進位制位的作業系統

• 64位：一次效能夠讀取64個二進位制位的作業系統

3 多核cpu

可以同時完成多件事的CPU，如4核CPU，一個大CPU整合了4個小的CPU

4 硬碟的工作原理

1. 機械硬碟工作原理

• 機械手臂：尋找資料

• 磁軌：儲存資料

• 扇區：劃分磁軌

• 平均尋道時間：由於工業水平的限制，為5ms

• 平均延遲時間：以7200r/min的硬碟為例，為4.15ms

  • 7200r/min / 60 = 120r/s
  • 1/120r/s = 0.0083s = 8.3ms
  • 8.3ms / 2 = 4.15ms

• 平均尋找資料的時間：5+4.15 = 9.15ms

2. 固態硬碟工作原理

基於演算法和電儲存的外存

三 計算機作業系統

1 檔案是什麼

作業系統提供的一個虛擬的單位

2 應用程式是什麼

應用程式其實是一堆檔案組成的，用於完成具體的某個任務

作業系統能幹什麼

接受應用程式/外部指令，然後控制硬體

3 計算機三大組成

1.應用程式

應用程式其實是一堆檔案組成的，用於完成具體的某個任務，與人和作業系統互動

2.作業系統

接受應用程式/外部指令，然後控制硬體，與人/應用程式/硬體互動

3.硬體

最終的目的是用來儲存資料的，與作業系統互動

3 應用程式的啟動和作業系統的啟動

1.應用程式的啟動

1. 雙擊qq（傳送指令給作業系統）
2. 作業系統接受指令，將指令轉化為0和1傳送給CPU
3. CPU接受指令，傳送給記憶體
4. 記憶體從硬碟中取出qq的程式，執行，開啟qq

2.作業系統的啟動

1. 按下開機鍵（啟動一個臨時作業系統）
2. 臨時作業系統喚醒真正的作業系統

四 程式語言分類

1 機器語言

• 優點（較於組合語言）：執行效率高
• 缺點（較於組合語言）：開發效率低

2 組合語言

• 優點（較於機器語言）：開發效率高
• 缺點（較於機器語言）：執行效率低

3 高階語言

1.解釋性語言

類似於同聲傳譯，寫一句翻譯一句

• 優點（編譯性語言）：開發效率高
• 缺點（編譯型語言）：執行效率低

2 編譯型語言

類似於谷歌翻譯，寫完所有的程式碼，編譯後得到結果，並且結果可以儲存，無法得到及時的報錯反饋

• 優點（解釋性語言）：執行效率高
• 缺點（解釋性語言）：開發效率低

五 執行python的兩種方式

1 互動式

在終端內（cmd）內輸入python3，然後輸入python程式碼

2 命令式

在終端內（cmd）輸入python3的文字檔案路徑

六 執行python程式的兩種IDE

1 pycharm

2 jupyter

七 變數

1 什麼是變數？

用來描述世間萬物變化的狀態

2 變數的組成

變數名 = 變數值 變數名是用來接受變數值的

3 變數的定義規範

• 具有某種意義
• 由數字，字母，下劃線組成，且不能由數字開頭（也不能用下劃線開頭）
• 不能用python關鍵字

4 定義變數的兩種方式

• 駝峰體：‘name of nick’
• 下劃線：‘name_of_nick'（推薦)

5 常量

常量是約定俗成的一種規範，常量名定義方式為全大寫，實際上可以被修改

6.註釋

1.單行註釋

+註釋的語句，#後面的字元不執行語法，即為普通字元，一般用於解釋某一段程式碼

2.多行註釋

三引號’‘’ 或三雙引號”“”

7 引用計數

變數值的引用次數，

x = 257  # 257的引用計數為1
y = 257  # 257的引用計數為2
del x    # 257的引用計數為1

8 垃圾回收機制

當變數值的引用計數為0的時候，該變數值會被python自動回收他的記憶體佔用

9 小整數池

[-5,256]之間的整數會在python直譯器啟動的時候，自動開闢一塊記憶體存入這些整數，也就是說這些整數不會因為引用計數為0而被刪除

八 與使用者互動

input

input輸入的都是字串形式

九 格式化輸出

1 佔位符

• %s 接受任意資料型別的資料
• %d 接受數字型別的資料

name = 'sun'
'name is %s'%name

2 format格式化

{}接受任意資料型別的資料

name = 'sun'
'name is {}'.format(name)

3 f-string格式化

在字串前面加上f或F，然後使用{}接受任意型別的資料

name = 'sun'
f'name is {name}'

十 基本運算子

1 算術運算子

+ - * / % //

2 邏輯運算子

and or not

3 比較運算子

> >= < <= == !=

4 賦值運算子

= += -= *= /= //= %=

5 身份運算子

is or is not

id相同的值一定相同，值相同的id不一定相同

6 運算子優先順序（略）

如果需要某個運算子優先運算，則加個括號，

7 鏈式賦值

x = y = z = 10

8 交叉賦值

x = 10
y = 20
x,y = y,x
# or使用臨時變數
x = 10
y = 20
temp = x
x = y
y = temp

9 解壓縮

hobby_list = ['read','run','sleep','fishing','playing']
# 如果取第2，3，5個愛好
_,hobby2,hobby3,_,hobby5 = hobby_list
print(hobby2,hobby3,hobby5)

十一 控制

1 流程控制之if判斷

1.if

if 條件：
	程式碼塊

2.if else

if 條件:
	程式碼塊
else:
	程式碼塊

3.if ... elif ... elif... else

if 條件：
	程式碼塊
elif 條件：
	程式碼塊
elif 條件：
	程式碼塊
...（可以寫任意個） 
else：
	程式碼塊

2 流程控制之while迴圈

1.while

while 條件：
	程式碼塊

2.while + break

while 條件：
	程式碼塊
	break #結束本層迴圈，跳出迴圈

3.while + continue

while 條件：
	程式碼塊
  if 條件：
  	程式碼塊
		continue #結束本層迴圈，不執行下面程式碼。繼續迴圈
  程式碼塊

4.while + else

while 條件：
	程式碼塊
else：
	print（'如果我沒有被break，我就會被列印出來'

3 流程控制之for迴圈

1.for

for i in range/list/tuple/str/dict/set(可迭代物件):
	print(i)

2.for + break

for i in range/list/tuple/str/dict/set(可迭代物件):
	print(i)
	break # 結束本層迴圈

3.for + continue

for i in range/list/tuple/str/dict/set(可迭代物件):
	print(i)
  if 條件：
		continue  # 結束本次迴圈，不執行下面程式碼
	程式碼塊

4.for + else

for i in range/list/tuple/str/dict/set(可迭代物件):
	print(i)
else:
  print（'如果我沒有被break，我就會被列印出來'

十二 資料型別內建方法

1 數字型別內建方法

1.整形

• 作用：定義年齡/身高/id號
• 定義方式： age = 18 or age = int('18')
• 方法： + - * / % //
• 多個值or一個值：一個值
• 有序or無序：壓根沒有有序無序這一說
• 可變or不可變：不可變
  • 可變：值變id不變
  • 不可變：值變if也變

2.浮點型

• 作用：定義薪資/價格
• 定義方式：salary = 3.2 or salary = float('3.2')
• 方法： + - * / % //
• 多個值or一個值：一個值
• 有序or無序：壓根沒有有序無序這一說
• 可變or不可變：不可變

2 字串型別內建方法

• 作用： 姓名
• 定義方式： name = 'sun' name = "sun" name = '''sun''' (三引號可換行)
• 方法：
  • 優先掌握
    • 索引取值
    • 切片
    • 長度
    • 切分 split
    • 除兩端空白 strip
    • 成員元素 in not in
    • for迴圈
  • 需要掌握
    • lstrip rstrip
    • rsplit
    • upper/lower
    • join
    • replace
    • indigit
  • 瞭解
    • find/rfind/index/rindex/count
    • center/ljust/rjust/zfill
    • expantabs
    • capitalize/swapcase/title
    • is系列
• 多個值or一個值：一個值
• 有序or無序：有序
• 可變or不可變：不可變

3 列表型別內建方法

• 作用：多個女朋友
• 定義方式：[]內用逗號隔開多個任意資料型別的元素
  • friends_list = ['sun','cheng','hao']
• 方法：
  • 優先掌握：
    • 索引取值（即可取又可改）
    • 切片
    • 長度
    • append
    • 成員運算
    • for迴圈
  • 需要掌握
    • count
    • remove
    • reverse
    • pop
    • insert
    • sort
    • index
    • del
    • extend
    • clear
• 多個值or一個值：多個值
• 有序or無序：無序
• 可變or不可變：可變

4 元組型別內建方法

• 作用：類似於列表，可以取但不可以存
• 定義方式：()內用逗號隔開多個任意資料型別的元素
  • friends_tuple = ('sun','cheng','hao')
  • tup = tuple('sunchenghao')
• 方法：
  • 優先掌握
    • 索引取值（無法更改）
    • 切片
    • 長度
    • 成員運算
    • for迴圈
    • count
    • index
• 多個值or一個值：多個值
• 有序or無序：有序
• 可變or不可變：無可變不可變這一說

5 字典型別內建方法

• 作用：值太多列表存容易取麻煩時使用字典

• 定義方式：

  • sun_dict = {
    'name':'sun',
    'height':'190',
    'weight':'200',
    'hobby_list':['playing','run','sleep','money']
    }
    for k,v in sun_dict.items():
      print(k,v)
    

• 方法：

  • 優先掌握
    • 按鍵取值
    • 長度
    • keys/values/items
    • for 迴圈
    • 成員運算
  • 需要掌握
    • pop
    • fromkeys
    • setdefault
    • get
    • update
    • del

• 多個值or一個值：多個值

• 有序or無序：無序

• 可變or不可變：可變

6 集合型別內建方法

• 作用：存多個值，為了集合之間做運算

• 定義方式：

  • s = set()  #定義空集合
    set = {1,2,3,4,5,2}
    

• 方法：

  • 優先掌握
    • 去重
    • 並集 |
    • 交集 &
    • 差集 -
    • 對稱差集 ^
    • 父集 > >=
    • 子集 < <=
    • ==
  • 需要掌握
    • add
    • difference_update
    • isdisjoint
    • remove #值不存在會報錯
    • discard #不會報錯

• 多個值or一個值：多個值

• 有序or無序：無序

• 可變or不可變：可變

7 布林型別

• 作用：一般用於判斷，除了 0/None/空/False 自帶布林值為false，其他資料型別自帶布林值為True

8 資料型別總結

一個值	多個值
整形/浮點型/字串	列表/元組/字典/集合

有序	無序
字串/列表/元組	字典/集合

可變	不可變
列表/字典/集合	整形/浮點型/字串

9 複製

複製/淺複製/深複製都是針對可變資料型別而言的

l1 = ['a','b','c',['d','e','f']]
l2 = l1
l1.append('g')
print(l1)  #['a','b','c',['d','e','f'],'g']
print(l2)  #['a','b','c',['d','e','f'],'g']

如何l2是l1的複製物件，則l1內部的任何資料型別的元素變化，則l2內部的元素也會跟著改變，因為可變型別值變id不變

10 淺複製

import copy
l1 = ['a','b','c',['d','e','f']]
l2 = copy.copy(l1)
l1.append('g')
print(l1)  #['a','b','c',['d','e','f'],'g']
print(l2)  #['a','b','c',['d','e','f']]
l1[3].append('g')
print(l1)  #['a','b','c',['d','e','f','g'],'g']
print(l2)  #['a','b','c',['d','e','f','g']]

如果l2是l1的淺複製物件，則l1內的不可變元素髮生了改變，l2不變；如果l1內的可變元素髮生了改變，則l2會跟著改變

11 深複製

import copy
l1 = ['a','b','c',['d','e','f']]
l2 = copy.deepcopy(l1)
l1.append('g')
print(l1)  #['a','b','c',['d','e','f'],'g']
print(l2)  #['a','b','c',['d','e','f']]
l1[3].append('g')
print(l1)  #['a','b','c',['d','e','f','g'],'g']
print(l2)  #['a','b','c',['d','e','f']]

如果l2是l1的深複製對像，則l1內的不可變元素髮生了改變，l2不變；如果l1內的可變元素髮生了改變，l2也不會變；即無論l2永遠不會因為l1的改變而改變