第一部分 初識Python語言

第1章 程序設計基本方法

1.1 計算機的概念

• 計算機是根據指令操作數據的設備，具備功能性和可編程性兩個基本特性,。

• 計算機技術發(fā)展階段：

1. 第一階段：1946-1981年,，“計算機系統(tǒng)結構階段”。
2. 第二階段：1982-2007年,，“計算機網絡和視窗階段”,。
3. 第三階段：2008年至今，“復雜信息系統(tǒng)階段”,。
4. 第四階段：月20年后某個時期開始,，“人工智能階段”。

1.2程序設計語言

1.2.1程序設計語言概述

• 機器語言：直接使用二進制代碼表達指令,，可被計算機硬件直接識別和執(zhí)行,。不同計算機結構的機器指令不同。

• 匯編語言：使用助記符對應機器語言中的指令,，可直接操作計算機硬件,。不同計算機結構的匯編指令不同。

機器語言和匯編語言都直接操作計算機硬件并基于此設計,，統(tǒng)稱“低級語言”,。

• 高級語言：用更接近自然語言的方式描述計算問題。代碼只與編程語言有關,，與計算機結構無關,。

1.2.2編譯和解釋

高級語言按執(zhí)行方式可分為采用編譯執(zhí)行的靜態(tài)語言和采用解釋執(zhí)行的腳本語言。

• 編譯是將源代碼轉換成目標代碼的過程,。
• 解釋是將源代碼逐條轉換成目標代碼同時逐條運行目標代碼的過程,。

1.2.3計算機編程

• 我學習Python的原因：

1. 通過編程實現(xiàn)自動化，提高效率,。
2. 通過編程了解一個新的廣闊世界,。

• 學習一門編程語言（重點在于練習）

1. 掌握該語言的語法
2. 結合問題設計程序結構
3. 掌握解決問題的能力

1.3Python語言概述

1.3.1 Python語言的發(fā)展

Python語言是一個語法簡潔,、跨平臺、可擴展的開源通用腳本語言,。

• Python語言誕生于1990年,，創(chuàng)世人為Guido。
• 2000年10月,，Python 2.0正式發(fā)布,，2010年，Python 2.x系列發(fā)布最后一版（2.7）,。
• 2008年12月,，Python 3.0正式發(fā)布，解釋器內部采用完全面向對象的方式實現(xiàn),，代價是3.x系列版本無法向下兼容2.x系列的既有語法,。

Python 2.x已經是遺產，Python 3.x是這個語言的現(xiàn)在和未來,。

1.3.2編寫Hello程序

print("Hello World")

1.3.3 Python語言的特點

• 語法簡潔
• 可跨平臺
• 應用廣泛
• 支持中文
• 強制可讀：通過強制縮進體現(xiàn)語句間的邏輯關系提高了程序的可讀性
• 模式多樣：語法層面同時支持面向過程和面向對象兩種編程方式
• 粘性擴展：通過接口和函數集成其他語言編寫的代碼
• 開源理念
• 庫類豐富

1.4 Python語言開發(fā)環(huán)境配置

• Python解釋器
• IDLE開發(fā)環(huán)境
• 交互式啟動
• 文件式啟動
• Python語言集成開發(fā)環(huán)境——PyCharm

1.5 程序的基本編寫方法

1.5.1 IPO程序編寫方法

每個程序都有統(tǒng)一的運算模式：輸入數據,、處理數據和輸出數據。這種樸素的運算模式形成了基本的程序編寫方法：IPO（Input,Process,Output)方法,。

IPO不僅是程序設計的基本方法,，也是描述計算問題的方式。

1.5.2理解問題的計算部分

• 使用計算機解決問題的6個步驟：

1. 分析問題
2. 劃分邊界
3. 設計算法
4. 編寫程序
5. 調試測試
6. 升級維護

---

第2章 Python程序解析

2.1 Python程序語法元素分析

Python程序包括格式框架,、注釋,、變量、表達式,、分支語句,、循環(huán)語句、函數等語法元素,。

程序的格式框架

• Python語言采用嚴格的“縮進”來表明程序的格式框架,，縮進表達了所屬關系

• 在代碼編寫中縮進可通過Tab鍵實現(xiàn)，也可用多個空格實現(xiàn),，建議采用4個空格方式書寫代碼

注釋

• 注釋是輔助性文字,，不被執(zhí)行
• 單行注釋：以#開頭

#這是注釋

• 多行注釋：以'''(3個單引號)開頭和結尾

'''
這是注釋
這也是注釋
這還是注釋
'''

命名

• 命名是為變量關聯(lián)標識符的過程，用于確保程序元素的唯一性
• 標識符由字母,、數字,、下劃線（和漢字）等字符及其組合構成
• 標識符的首字符不能是數字 ，且中間不能出現(xiàn)空格
• 標識符對大小寫敏感

保留字

• 保留字（Keyword）也被稱為關鍵字,，是被編程語言內部定義并保留使用的標識符
• Python 的標準庫提供了一個 keyword 模塊,，可以輸出當前版本的所有關鍵字：

>>> import keyword
>>> ls=keyword.kwlist
>>> ls
>>>len(ls)
33

Python 3 有33個保留字

1. True
2. False
3. None
4. and
5. as
6. assert
7. break
8. class
9. continue
10. def
11. del
12. elif
13. else
14. except
15. finally
16. for
17. from
18. global
19. if
20. import
21. in
22. is
23. lambda
24. nonlocal
25. not
26. or
27. pass
28. raise
29. return
30. try
31. while
32. with
33. yield

字符串

• 字符串（string）類型在程序中表示文本
• 字符串是字符的序列，可以按照單個字符或字符片段進行索引
• 字符串包括兩種序號體系：正向遞增序號、反向遞減序號
• 正向遞增序號：0~L-1
• 反向遞減序號：-L~-1
• 區(qū)間訪問方式：[N：M]（不包含M）,，可以混合使用正向遞增序號和反向遞減序號
• 字符串比較本質上是字符串對應Unicode編碼的比較

賦值語句

• Python語言中,，“=”表示“賦值”，將右側的計算結果賦給左側變量
• 同步賦值語句：可同時給多個變量賦值

<變量1>,…,<變量N>=<表達式1>,…,<表達式N>

分支語句

• 分支語句的作用是根據判斷條件選擇程序執(zhí)行路徑

if<條件1>：
　　　　<語句塊1>

elif<條件2>：
　　　　<語句塊2>
…
else：
　　　　<語句塊N>

循環(huán)語句

• 循環(huán)語句的作用是根據判斷條件確定一段程序是否再執(zhí)行一次或多次

while (<條件>) ：
　　　　<語句塊1>
<語句塊2>

for i in range(<循環(huán)次數>)：
　　　　<語句塊1>

input()函數

• 使用input()函數從控制臺獲得用戶輸入
• input()函數以字符串類型返回結果

<> = input("提示性文字")

>>>input("請輸入：")

eval()函數

• eval(<字符串>)函數的作用是間輸入的字符串變成Python語句并執(zhí)行

x=eval(input("請輸入："))

Python語法允許在表達式內部標記之間增加空格,，適當增加空格有助于提高代碼可讀性,。但應注意，不能改變與縮進相關的空格數量,、不能再變量名等命名中間增加空格,。

print()函數

• print()函數可以輸出字符信息，也可以用字符的形式輸出變量
• 輸出字符信息時,，可以直接將待輸出內容傳遞給print()函數
• 輸出變量值時,，print()函數用槽格式和過format()方法將變量和字符串結合到一起輸出

函數

• 函數可以理解為對一組表達特定功能表達式的封裝，將特定功能代碼編寫在一個函數里,，使程序模塊化更好,，便于閱讀和復用
• 可通過保留字def自定義函數

2.2 對象（庫）的調用

• <a>.<b>()表示調用一個對象<a>的方法<b>()，或調用一個函數庫<a>中的函數<b>()

面向對象編程是一種基于對象的編程范式,。對象是事物的一種抽象,，是一個實體，包含屬性和方法兩部分,。屬性是對象中的變量，方法是對象能完成的操作,。

• 通過保留字import引用函數庫

1. import <庫名>：程序調用庫中所有函數,，使用庫中函數格式如下

<庫名>.<函數名>(<函數參數>)

import turtle
turtle.fd(100) #控制畫筆向當前行進方向前進100

2. from <庫名> import ：

from <庫名> import <函數名,函數名,…,函數名>
from <庫名> import *，“ * ”是通配符,，表示所有函數

• 調用庫中函數不再需要使用庫名,，格式如下

<函數名>(<函數參數>)

from turtle import *
fd(100)

2.3 turtle庫語法元素分析

tuetle庫是一個圖形繪制函數圖

繪圖坐標體系

• tuetle庫繪制圖形的基本框架是一個海龜在坐標系中爬行（前進、后退,、左轉,、右轉），其軌跡形成了繪制圖形,。
• 初始位置位于坐標（0,0）,，行進方向為水平右方。
• 使用turtle.setup()函數設置主窗體的大小和位置,。

turtle.setup(width,height,startx,stary)

• width,height分別表示窗口寬度和高度,，值是整數表示像素值，值時小數表示與屏幕的比例
• startx,stary分別表示窗口左側和頂部與屏幕左側和頂部的像素距離,，如果值是none,，窗口位于屏幕水平/垂直中央

turtle.setup（0.8,0.8）

畫筆控制函數

• turtle.penup()：抬起畫筆，之后移動畫筆不繪制形狀
  別名：turtle.pd()、turtle.down()
• turtle.pensize(width)：設置畫筆寬度,，width無參數或為None時返回當前畫筆寬度
  別名：turtle.width()
• turtle.pencolor()：設置畫筆顏色,，無參數輸入時返回當前畫筆顏色。

(colorstring)參數表示顏色的字符串,；(r,g,b)參數表示顏色對應的RGB值

顏色	顏色字符串	GRB	十六進制
黑色	black	0,0,0	#FFFFFF
白色	white	255,255,255	#000000
灰色	grey	190,190,190	#BEBEBE

形狀繪制函數

• turtle.fd(distance)：控制畫筆向當前行進方向前進distance,，值為負數表示向相反方向前進
  別名：turtle.forward(distance)
• turtle.seth(to_angle)：控制畫筆繪制方向，（to_angle）參數是絕對方向角度值（turtle庫的坐標體系以正東方向為絕對0度,、正北方向為絕對90度）
• turtle.circle(radius,extent=None)：根據半徑radius繪制extent角度的弧形
  radius值為正時,，半徑在畫筆左側，值為負時,，半徑在畫筆右側,；
  extent為正時，畫筆逆時針前進,，extent為負時,，畫筆順時針倒退，extent不設置參數或參數為None時,，繪制整圓,。

---

第二部分 深入Python語言

第3章 基本數據類型

3.1 數字類型

• Python語言提供整數、浮點數,、復數3種數字類型

整數類型

• 整數類型共有4種進制表示：十進制,、二進制、八進制和十六進制
• 默認情況整數采用十進制,，其他進制需要增加引導符號

進制種類	引導符號	描述
十進制	無	默認情況
二進制	0b或0B	由字符0和1組成
八進制	0o或0O	由字符0到7組成
十六進制	0x或0X	由字符0到9,、a到f、A到F組成

浮點數類型

• 浮點數類型與數學中實數的概念一致,，表示帶有小數的數值
• Python語言要求所有浮點數必須帶有小數部分（可以是0）,，一區(qū)分浮點數和證書類型
• 浮點數有2中表示方法：十進制表示和科學計數法表示

科學計數法使用字母e或E作為冪的符號，以10為基數,含義如下：

<a>e<b>=a*10b^2

• 由于計算機內部采用二進制運算,，浮點數進行超過15位數字計算會產生誤差

使用整數表達浮點數的方法是高精確度運算的基本方法之一,。

• 對于高精度科學計算外的絕大部分運算而言，浮點數類型已足夠可靠,，一般認為浮點數類型沒有范圍限制,，運算結果準確

復數類型

• 復數類型表示數學中的復數

復數可以看作是二元有序實數對(a,b),表示為a+bj，其中a是實數部分,，簡稱實部,，b是虛數部分，簡稱虛部,。

• Python 語言中,，復數的虛部通過后綴"j"或"J"表示

1.23e-4+5.67e+89j

• 復數類型中實數部分和虛數部分的數值都是浮點數類型,，對于實數z，可用z.real和z.imag分別獲得它的實部和虛部

(1.23e-4+5.67e+89j).real
(1.23e-4+5.67e+89j).imag

3.2 數字類型的操作

• Python 解釋器為數字類型提供數值運算操作符,、數值運算函數,、類型轉換函數等操作方法

內置的數值運算操作符（共9個）

操作符	描述
x+y	x與y之和
x-y	x與y之差
x*y	x與y之積
x/y	x與y之商
x//y	x與y之整數商，即不大于x與y之商的最大整數
x%y	x與y之商的余數,，也稱為模運算
-x	x的負值
+x	x本身
x**y	x的y次冪,，即x^y

• 操作符運算的結果可能會改變數字類型，3種數字類型之間存在一種逐漸擴展的關系：整數→浮點數→復數
• 上述9個二元數學操作符都有與之對應的增強賦值操作符

x+=y 等價于 x=x+y

• 模運算（%）在編程中主要應用于具有周期規(guī)律的場景

內置的數值運算函數（共6個）

函數	描述
abs(x)	x的絕對值
divmod(x,y)	(x//y,x%y),輸出為二元組形式（也稱為元組類型）
pow(x,y[,z])	(x**y)%z,[…]表示該參數可省略
round(x[,ndigits])	對x四舍五入,，保留ndigits位小數,，round(x)返回四舍五入的整數值
max(x1,x2,…,xn)	x1,x2,…,xn的最大值，n沒有限定
min(x1,x2,…,xn)	x1,x2,…,xn的最小值,，n沒有限定

內置的數字類型轉換函數（共3個）

函數	描述
int(x)	將x轉換為整數,，x可以是浮點數或字符串
float(x)	將x轉換為浮點數，x可以是整數或字符串
complex(re[,im])	生成一個復數,，實部為re,，虛部為im，re可以是整數,、浮點數或字符串,，im可以是整數或浮點數但不能為字符串

• int()函數將浮點數類型轉換為整數時，小數部分會直接被舍棄
• 復數不能直接轉換為其他數字類型,，可通過.real和.imag將復數的實部和虛部分別轉換

3.3 字符串類型及其操作

字符串類型的表示

• 字符串是字符的序列表示
• 單引號字符串：'單引號表示可以使用"雙引號"作為字符串的一部分'
• 雙引號字符串："雙引號表示可以使用'單引號'作為字符串的一部分"
• 三引號字符串：'''三引號表示可以使用"雙引號",、'單引號'作為字符串的一部分
  也可以換行
  '''
• Python 字符串提供區(qū)間訪問方式，采用[N:M]格式,。表示從字符串中從N到M（不包含M）的字符串,，可以混合使用正向遞增序號和反向遞減序號
• 反斜杠字符(\)在字符串中表示轉義

1. \n 表示換行
2. \\ 表示反斜杠
3. \' 表示單引號
4. \" 表示雙引號
5. \t 表示制表符(Tab)

基本的字符串操作符（共5個）

操作符	描述
x+y	連接兩個字符串x與y
x*n或n*x	復制n次字符串x
x in s	如果x是s的子字符串，返回Ture,，否則返回False
str[i]	索引,，返回第i個字符
str[N:M]	切片,，返回索引第N到第M個字符

內置的字符串處理函數（共6個）

函數	描述
len('x')	返回字符串x的長度,，也可返回其他組合數據類型元素個數
str('x')	返回任意類型x所對應的字符串形式
chr(x)	返回Unicode編碼x對應的單字符
ord('x')	返回單字符表示的Unicode編碼
hex(x)	返回整數x對應十六進制數的小寫形式字符串
oct(x)	返回整數x對應八進制數的小寫形式字符串

內置的字符串處理方法（共43個，常用16個）

• 在Python解釋器內部,，所有數據類型都采用面向對象的方式實現(xiàn),，封裝為一個類
• 字符串是一個類，具有類似<a>.<b>()形式的字符串處理函數,，稱為方法

方法	描述
str.lower()	返回字符串str的副本,，全部字符小寫
str.upper()	返回字符串str的副本，全部字符大寫
str.islower()	當str所有字符都是小寫時,，返回Ture,，否則返回False
str.isprintable()	當str所有字符都是可打印的,，返回Ture，否則返回False
str.isnumeric()	當str所有字符都是數字時,，返回Ture,，否則返回False
str.isspace()	當str所有字符都是空格，返回Ture,，否則返回Flase
str.endswith(suffix[,start[,end]])	str[start:end]以suffix結尾返回Ture,，否則返回Flase
str.srartswith(prefix[,start[,end]])	str[start:end]以prefix開始返回Ture，否則返回Flase
str.split(sep=None,maxsplit=-1)	返回一個列表,，由str根據sep被分割的部分構成
str.count(sub[,start[,end]]	返回str[start:end]中sub子串出現(xiàn)的次數
str.replace(old,new[,count])	返回字符串str的副本,，所有old子串被替換為new，如果count給出,，則前count次old出現(xiàn)被替換
str.center(width[,fillchar])	字符串居中函數
str.strip([chars])	返回字符串str的副本,，在其左側和右側去掉chars中列出的字符
str.zfill(width)	返回字符串str副本，長度為width,。不足部分在其左側添加0
str.format()	返回字符串str的一種排版格式
str.join(iterable)	返回一個新字符串,，由組合數據類型iterable變量的每個元素組成，元素間用str分隔

3.4 字符串類型的格式化

• 字符串通過format()方法進行格式化處理

字符串格式化用于解決字符串和變量同時輸出時的格式安排

format()方法的基本使用

• 字符串format()方法的基本使用格式：<字模板符串>.format(<逗號分隔的參數>)
• 模板字符串由一系列槽組成,，用來控制修改字符串中嵌入值出現(xiàn)的位置（槽用{}表示,，如果{}中沒有序號，則按照出現(xiàn)順序替換）
• 如需輸入{},，采用{{表示{,；}}表示}

"圓周率{{{1}{2}}}是{0}".format("無理數",3.1415926,"……")

format()方法的格式控制

• format()方法模板字符串的槽除了包括參數序號，還可包括格式控制信息,。槽內部樣式：{<參數序號>：<格式控制標記>}
• 格式控制標記用于控制參數顯示時的格式

:	<填充>	<對齊>	<寬度>	<,>	<.精度>	<類型>
引導符號	用于填充的單個字符	<左對齊,、>右對齊、^居中對齊	槽的設定輸出寬度	數字的千位分隔符 適用于整數和浮點數	浮點數小數部分的精度或字符串的最大輸出長度	整數類型b,c,d,o,x,X,；浮點數類型e,E,f,%

• <填充>指寬度內除了參數外的字符采用什么方式表示,，默認為空格
• <對齊>指參數在寬度內輸出時的對齊方式
• <寬度>指當前槽的設定輸出字符寬度，若實際參數長度比設定值大,，則使用參數實際長度
• <,>用于顯示數字類型的千分位分隔符
• <.精度>對于浮點數,，表示小數部分輸出的有效位數；對于字符串,，表示輸出的最大長度
• <類型>表示輸出整數好浮點數類型的格式規(guī)劃,。
  對于整數類型，

1. b：整數的二進制,；
2. c：整數對應的Unicode字符,；
3. d：整數的十進制；
4. o：整數的八進制
5. x：整數的小寫十六進制
6. X：整數的大寫十六進制
   對于浮點數類型,，
7. e：浮點數對應的小寫字母e的指數形式
8. E：浮點數對應的大寫字母E的指數形式
9. f：浮點數的標準浮點形式
10. %：浮點數的百分形式

第4章 程序的控制結構

4.1 程序的基本結構

程序流程圖

• 起止框表示一個程序的開始和結束
• 判斷框判斷一個條件是否成立,，并根據判斷結果不同選擇不同的執(zhí)行路徑
• 處理框表示一組處理過程
• 輸入/輸出框表示數據輸入或結果輸出
• 注釋框增加程序的解釋
• 流向線以帶箭頭的直線或曲線形式指示程序的執(zhí)行路徑
• 連接點將多個流程圖連接到一起

程序的基本結構

• 程序有3種基本結構組成：順序結構,、分支結構和循環(huán)結構
• 順序結構：程序按照線性順序依次執(zhí)行
• 分支結構：程序根據條件判斷結果而選擇不同向前執(zhí)行路徑的一種運行方式（分支結構包括單分支結構和二分支結構；p97）
• 循環(huán)結構：程序根據條件判斷結果向后反復執(zhí)行（根據觸發(fā)條件不同,，循環(huán)結構包括條件循環(huán)和遍歷循環(huán)）

4.2 程序的分支結構

單分支機構：if語句

if語句語法格式：

if <條件>：
    <語句塊>

• 語句塊是if條件滿足后執(zhí)行的一個或多個語句序列
• 語句塊中語句通過與if所在行形成縮進表達包含關系
• if語句首先評估條件的結果值,，若為Ture則執(zhí)行語句塊中的語句序列；若為False則跳過語句塊中的語句
• if語句中條件部分可以使用任何能夠產生Ture或False的語句或函數

形成判斷條件最常見的方式是采用關系操作符

關系操作符	數學符號	操作符含義
<	<	小于
>	>	大于
<=	≤	小于等于
>=	≥	大于等于
==	=	等于
!=	≠	不等于

• Python使用"="表示賦值語句,，使用"=="表示等于

二分支結構：if-else語句

if-else語句語法格式：

if <條件>:
    <語句塊1>
else <條件>:
    <語句塊2>

• 二分支語句用于區(qū)分條件的兩種可能
• if條件滿足時執(zhí)行語句塊1
• if條件不滿足時執(zhí)行語句塊2

二分支結構的簡潔表達（適合通過判斷返回特定值）

<表達式1> if <條件> else <表達式2>

• 表達式1/2一般是數字類型或字符串類型的一個值

多分支結構：if-elif-else語句

if-elif-else語句語法格式：

if <條件1>:
    <語句塊1>
elif <條件2>:
    <語句塊2>
...
else:
    <語句塊N>

• Python依次評估尋找第一個結果為Ture的條件,，執(zhí)行該條件下的語句并跳過整個if-elif-else結構，執(zhí)行后面的語句
• 如果沒有任何條件成立,，執(zhí)行else下面的語句塊
• else語句是可選的

4.3 程序的循環(huán)結構

遍歷循環(huán)：for語句

for語句語法格式

for <循環(huán)變量> in <遍歷結構>:
    <語句塊>

• 遍歷循環(huán)可以理解為從遍歷結構中中逐一提取元素,，放在循環(huán)變量中，對于所提取的每個元素執(zhí)行一次語句塊

循環(huán)N次：

for i in rang(N):
    <語句塊>

遍歷文件的每一行：

for line in fi:
    <語句塊>

遍歷字符串s

for c in s:
    <語句塊>

遍歷列表ls

for item in ls:
    <語句塊>

遍歷循環(huán)的擴展模式

for <循環(huán)變量> in <遍歷結構>:
    <語句塊1>
else:
    <語句塊2>

當for循環(huán)正常執(zhí)行后,，程序會繼續(xù)執(zhí)行else語句

遍歷循環(huán)：while語句

while語句語法格式

while <條件>:
    <語句塊>

• 當條件判斷為Ture時,，循環(huán)體重復執(zhí)行語句塊中的語句；當條件為Flase時,，循環(huán)終止,，執(zhí)行與while同級別縮進的后續(xù)語句

無限循環(huán)的擴展模式

while <條件>：
    <語句塊1>
else:
    <語句塊2>

• 當while循環(huán)正常執(zhí)行后，程序會繼續(xù)執(zhí)行else語句中的內容,，else語句只在循環(huán)正常執(zhí)行后才執(zhí)行

循環(huán)保留字：break和continue

• break用來跳出最內層for或while循環(huán),，脫離該循環(huán)后程序從循環(huán)代碼后繼續(xù)執(zhí)行
• continue用來結束當前當次循環(huán)，即跳出循環(huán)體中下面尚未執(zhí)行的語句,，但不跳出當前循環(huán)

for s in "BIT":
    for i in rang(2):
        print(s,end="")
        if s=="I":
            break
            
>>>BBTT

• break語句與continue語句的區(qū)別是,break語句結束整個循環(huán)過程,，不再判斷執(zhí)行循環(huán)的條件是否成立；continue語句只結束本次循環(huán),，而不終止整個循環(huán)的執(zhí)行

for循環(huán)和while循環(huán)中都有一個else擴展用法,。else語句僅在循環(huán)正常遍歷了所有內容或由于條件不成立而結束循環(huán)的條件下執(zhí)行。

for s in "PYTHON":
    if s =="T":
        continue
    print(s,end="")
else:
    print("正常退出")
>>>
PYHON 正常退出

for s in "PYTHON":
    if s =="T":
        break
    print(s,end="")
else:
    print("正常退出")
>>>
PY

4.4 random庫的使用

random庫采用梅森旋轉算法生成偽隨機數序列,，可用于除隨機性要求更高的加解密算法外的大多數工程應用

• Python內置的random庫主要用于產生各種分布的偽隨機數序列
• random庫提供9個常用函數

函數	描述
seed(a=None)	初始化隨機數種子,，默認值為當前系統(tǒng)時間
random()	生成一個[0.0,1.0]之間的隨機小數
randint(a,b)	生成一個[a,b]之間的整數
getrandbits(k)	生成一個k比特長度的隨機整數
randrange(start,stop[,step])	生成一個[start,stop]之間以step為步數的隨機整數
uniform(a,b)	生成一個[a,b]之間的隨機小數
choice(seq)	從序列類型，例如列表中隨機返回一個元素
shuffle(seq)	將序列類型中的元素隨機排列,，返回打亂后的序列
sample(pok,k)	從pop類型中隨機選取k個元素,，以列表類型返回

• 生成隨機數之前可通過seed()函數指定隨機數種子，隨機數種子一般是一個整數,，只要種子相同,，每次生成的隨機數序列也相同

4.5 程序的異常處理

Python通過try,、except等保留字提供異常處理功能

異常處理：try-except語句

• Python使用try-except語句實現(xiàn)異常處理

try:
    <語句塊1>
except <異常類型>:
    <語句塊2>

異常的高級用法

• try-except語句可以支持多個except語句

try:
    <語句塊1>
except <異常類型1>：
    <語句塊2>
...
except <異常類型N>:
    <語句塊N+1>
except <異常類型N+!>:
    <語句塊N+2>

• 異常語句還可以與else和finally保留字配合使用

try:
    <語句塊1>:
except <異常類型1>：
    <語句塊2>
else:
    <語句塊3>
finally：
    <語句塊4>

第5章 函數和代碼復用

5.1 函數的基本使用

函數的定義

• 函數是一段具有特定功能的,、可重用的語句組
• 使用函數主要有兩個目的：降低編程難度和代碼重用
• Python使用def保留字定義一個函數

def<函數名>(<參數列表>):
    <函數體>
    return<返回值列表>

• 函數名可以是任何有效的Python標識符
• 參數列表是調用該函數是傳遞給它的值，可以有零個（保留圓括號）,、一個或多個（用逗號分隔）
• 函數體是函數每次被調用是執(zhí)行的代碼
• 當需要返回值時使用保留字return和返回值劉表,，否則函數可以沒有return語句,，在函數體結束時將控制權返回給調用者

函數調用和執(zhí)行的一般形式

<函數名>(<參數列表>)

函數的調用過程

1. 調用程序在調用處暫停執(zhí)行
2. 在調用時將實參復制給形參
3. 執(zhí)行函數體語句
4. 函數調用結束給出返回值，程序回到調用前的暫停處繼續(xù)執(zhí)行

lambda函數

• lambda函數又稱匿名函數,，將函數名作為函數結果返回

<函數名>=lambda<參數列表>:<表達式>

lambda函數與正常函數一樣,，等價于下面表達式：

def<函數名>(<參數列表>):
    return<表達式>

• lambda函數用于定義簡單的、能夠在一行內表示的函數,，返回一個函數類型

f=lambda q,w,e,r:q+w+e+r
f(1,2,3,4)
10

• lambda函數用于需要函數對象的場景

5.2 函數的參數傳遞

函數可定義可選參數,，使用參數的位置或名稱傳遞參數值，根據函數中變量的不同作用域有不同的函數返回值方式

可選參數和可變數量參數

• 函數定義時部分參數可直接為存在默認值的參數指定默認值,，當函數被調用時如果沒有傳入對應的參數值則使用函數定義時的的默認值替代
• 默認參數必須指向不變對象
• 函數調用時需要按順序輸入參數,，可選參數必須定義在非可選參數后

dfe r(str,times=2):
    print(str*times)
r("T")
TT
r("T")
TTTT

• 函數定義時可設計可變數量參數，通過在參數前加星號(*)實現(xiàn)
• 帶有星號的可變參數只能出現(xiàn)在參數列表最后,，調用時這些參數被單指元組類型傳遞到函數中

def vfunc(a,*b)
    print(type(b)
    for n in b:
        a+=n
    return a
vfunc(1,2,3,4,5)
<class 'tuple'>
15 #1+2=3;3+3=6;6+4=10;10+5=15

參數的位置和名稱傳遞

• 函數定義時實參默認采用按照位置順序的方式傳遞給函數,，這種方式在參數很多的情況下可讀性較差
• Python提供了按照形參名稱輸入實參的方式，調用函數時指定參數名稱,，參數之間的順序可任意調整

函數的返回值

• return語句用來退出函數并將程序返回到函數被調用的位置繼續(xù)執(zhí)行
• return語句可同時將0個,、1個或多個函數運算后的結果返回給函數被調用的位置
• 函數可以沒有return，此時函數不返回值
• 函數也可以用return返回多個值,，多個值以元組類型保存

def func(a,b):
    return b,a
s=func("t",2)
print(s,type(s))
(2, 't') <class 'tuple'>

5.4 datetime庫的使用

Python時間處理的標準函數庫datetime提供里一批顯示日期和時間的格式化方法,。

datetime庫概述

datetime庫可以從系統(tǒng)中獲得時間，并以用戶選擇的格式輸出

• datetime庫以格林威治時間為基礎,，每天由3600*24秒精準定義
  datetime庫以類的方式提供多種日期和時間

1. datetime.date：日期表示類,，坑人表示年、月,、日等,。
2. datetime.time：時間表示類，可表示小時,、分鐘,、秒、毫秒等,。
3. datetime.datetime：日期和時間表示類,，功能覆蓋date和time類。
4. datetime.timedelta：與時間間隔有關的類,。
5. datetime.tzinfo：與時區(qū)有關的信息表示類,。

datetime庫解析（datetime類）

• datetime.datetime類的使用方式是首先創(chuàng)建一個datetime對象，然后通過對象的方法和屬性顯示時間
  創(chuàng)建datetime對象的3種方法：

1. datetime.now()：返回一個datetime類型,，表示當前日期和時間,，精確到毫秒

>>>from datetime import datetime
>>>now=datetime.now()
>>>now
datetime.datetime(2018, 5, 13, 16, 49, 38, 627464)

2. datetime.utcnow()：返回一個datetime類型，表示當前日期和時間的UTC（世界標準時間）表示,，精確到毫秒

>>>from datetime import datetime
>>>utcnow=datetime.now()
>>>utcnow
datetime.datetime(2018, 5, 13, 8, 53, 59, 788612)

3. 直接使用datetime()構造一個日期和時間對象：datetime(Y,M,D,hour=0,minute=0,second=0,microsecond=0)

>>>some=datetime(2018,5,13,17,0,0,0)
>>>some
datetime.datetime(2018, 5, 13, 17, 0)

-創(chuàng)建datetime對象后,，可利用該對象的屬性顯示時間
（以上述“some”為例）

• datetime類的常用屬性

屬性	描述
some.min	固定返回datetime的最小時間對象,，datetime(1,1,1,0,0)
some.max	固定返回datetime的最大時間對象，datetime(9999,12,31,23,59,59,999999)
some.year	返回some包含的年份
some.month	返回some包含的月份
some.day	返回some包含的日期
some.hour	返回some包含的小時
some.minute	返回some包含的分鐘
some.second	返回some包含的秒鐘
some.microsecond	返回some包含的毫秒

• datetime類的常用時間格式化方法

屬性	描述
some.isofomat()	采用ISO8601標準顯示時間
some.isoweekday()	根據日期計算星期
some.strftime()	根據格式化字符串format進行格式顯示的方法

• strftime()方法用于輸出特定格式時間

格式化字符串	對象	取值范圍
%Y	年	0001~9999
%m	月	1~12
%B	月名	January~December
%b	月名縮寫	Jan~Dec
%d	日期	01~31
%A	星期	Monday~Sunday
%a	星期縮寫	Mon~Sum
%H	小時（24h制）	00~23
%I	小時（12h制）	01~12
%p	上,、下午	AM/PM
%M	分鐘	00~59
%S	秒	00~59

>>>some=datetime(2018,5,13,17,0,0,0)
>>>some.strftime("%Y年%m月%d日,，%H時%M分%S秒")
'2018年05月13日，17時00分00秒'

>>>print('今天是{0:%Y}年{0:%m}月{0:%d}日'.format(some))
今天是2018年05月13日

5.5 代碼復用和模塊化設計

• 當代編程語言從代碼層面采用函數和對象兩種抽象方式,，分別對應面向過程和面向對象兩種編程思想
• 函數是程序的一種基本抽象方式,，它將一系列代碼組織起來通過命名提供其他程序使用，任何其他代碼只有輸入參數即可調用函數,，更新函數功能時,，所有被調用處的功能都被更新。
• 對象是程序的一中高級抽象方式,，它將程序代碼組織為更高級的類,。對象包括表征對象特征的屬性和代表對象操作的方法。
• 模塊化設計值通過函數或對象的封裝功能將程序劃分成主程序,、子程序和子程序間關系的表達,。
• 模塊化設計的兩個基本要求：

1. 緊耦合：盡可能合理劃分功能塊，功能塊內部耦合緊密
2. 松耦合：模塊間關系盡可能簡單,，功能塊之間耦合度低

5.6 函數的遞歸

遞歸的定義：函數定義中調用函數自身的方式稱為遞歸

• 數學經典遞歸案例——階乘

n!=n(n-1)(n-2)...(1)

n!=1 (n=0)
n!=n(n-1)! (otherwise)

• 遞歸的兩個關鍵特征

1. 存在一個或多個基例,，基例不需要再次遞歸，是確定的表達式
2. 所有遞歸鏈要以一個或多個基例結尾

遞歸的使用方法

def fact(n):
    if n==0:
        return 1
    else:
        return n*fact(n-1)
num=eval(input('請輸入一個整數：'))
print(fact(abs(int(num))))

• 使用遞歸一定要注意基例的構建,，否則遞歸無法返回

5.7 科赫曲線繪制

科赫曲線屬于分形幾何分支,，它的繪制過程體現(xiàn)了遞歸思想

from turtle import *
def koch(size,n):
    if n==0:
        fd(size)
    else:
        for angle in [0,60,-120,60]:
            left(angle)
            koch(size/3,n-1) # 遞歸
def main(size,level):
    setup(600,600) # 設置主窗體大小
    speed(0) # 設置畫筆速度，（1~10）
    hideturtle() # 隱藏turtle箭頭
    penup()
    goto(-150,50)
    pendown()
    pensize(1) # 設置畫筆尺寸
    koch(size,level)
    right(120)
    koch(size,level)
    right(120)
    koch(size,level)
main(300,3)

5.8 Python內置函數

Python提供68個內置函數

• abs()
• all()
• any()
• asci()
• bin()
• bool()
• chr()
• complex()
• dict()
• divmod()
• eval()
• float()
• hash()
• hex()
• id()
• input()
• int()
• len()
• list()
• max()
• min()
• oct()
• open()
• ord()
• pow()
• print()
• range()
• reversed()
• round()
• set()
• sorted()
• str()
• tuple()
• type()
• zip()

---

• bytes()
• delattr()
• bytearray()
• callable()
• classmethod()
• compile()
• dir()
• exec()
• enumerate()
• filter()
• format()
• frozenset()
• getattr()
• globals()
• hasattr()
• help()
• isinstance()
• issubclass()
• iter()
• locals()
• map()
• memoryview()
• next()
• object()
• properyty()
• repr()
• setattr()
• slice()
• staticmethod()
• sum()
• super()
• vars()
• _import()_

第6章 組合數據類型

6.1 組合數據類型概述

組合數據類型為多個類型或不同類型數據提供單一表示,，使數據操作更有序,、更容易。組合數據類型分為序列類型,、集合類型和映射類型3類,。

序列類型

序列類型是一維元素向量，元素間存在先后關系,，通過序號訪問,，元素之間不排他。

1. 字符串（str）可以看做是單一字符的有序組合,，屬于序列類型

• 字符串被看做基本數據類型

2. 元組（tuple）是包含零個或多個數據項的不可變序列類型

• 一個元組可作另一個元組的元素,，可采用多級索引獲取信息

>>>X=('a','b','c') #等同 X='a','b','c'
>>>Y=(1,2,3,X)
>>>Y[3][2] #多級索引
'c'

• Python中元組采用逗號和圓括號（可選）表示

3. 列表（list）是包含零個或多個對象引用的有序數列

• 列表的長度和內容都是可變的
• 列表用中括號([])表示，也可通過list()函數將元組或字符串轉化成列表
• 列表必須通過顯式賦值才能生成,，簡單將一個列表賦值給另一個列表不會生成新的列表對象

序列類型的通用操作符和函數

操作符或函數	描述
x in s	如果x是s的元素,，返回True，否則返回Flase
x not in s	如果x不是s的元素，返回True,，否則返回Flase
s+t	連接s和t
s*n或n*s	將序列s復制n次
s[i]	索引，返回序列s的第i個元素
s[i:j]	分片,，返回包含序列s第i到第j（不含）個元素的子序列
s[i:j:k]步驟分片,，返回包含序列s第i到第j（含）個元素以k為步長的子序列
len(s)	序列s的元素個數（長度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.index(x[,i[,j]])	序列s中從i開始到j位置第一次出現(xiàn)元素x的位置
s.count(x)	序列s中出現(xiàn)x的總次數

集合類型

集合類型是一個元素集合，元素之間無序,，相同元素在集合中唯一存在,。

• 集合的元素類型只能是固定數據類型（能夠進行哈希運算的類型都可以作為集合元素）

哈希運算可以將任意長度的二進制值映射為較短的固定長度的二進制值，哈希值是對數據的一種有損且緊湊的表示形式,，是數據在另一個數據維度的體現(xiàn),。

• 集合是無序組合，沒有索引和位置的概念,，不能分片
• 集合不包含重復元素,，可使用集合類型過濾重復元素
• 集合中元素可以動態(tài)增加或刪除
• 集合用大括號（{}）表示（直接使用大括號生成一個空的字典而不是集合）
• 生成空集合需要使用函數set()

集合類型的操作符（10個）

操作符	描述
S-T	差集：返回一個集合，包括在集合S中但不在集合T中的元素
s-=T	更新集合S,，包括在集合S中但不在集合T中的元素
S&T	交集：返回一個新集合,，包括同時在集合S和T中的元素
S&=T	更新集合S,包括同時在集合S和T中的元素
S^T	補集：返回一個新集合，包括集合S和T中的元素,，但不包括同時在其中的元素
S=^T	更新集合S,包括集合S和T中的元素,，但不包括同時在其中的元素
S|T	并集：返回一個新集合，包括集合S和T中的所有元素
S=|T	更新集合S,包括集合S和T中的所有元素
S<=T	判斷S是否是T的真子集
S>=T	判斷S是否是T的真超集

集合類型的操作函數或方法（10個）

操作函數或方法	描述
S.add.(x)	如果數據項x不在集合S中,，將x增加到S
S.clear()	移除S中的所有數據項
S.copy	返回集合S的一個副本
S.pop()	隨機返回集合S中的一個元素,，若S為空，產生KeyError異常
S.discard(x)	如果x在集合S中,，則移除x,；若不在也不報錯
S.remove(x)	如果x在集合S中，則移除x,；否則產生KeyError異常
S.isdisjoint(T)	如果集合S與T沒有相同元素,，則返回True
len(S)	返回集合S的元素個數
x in S	如果x是S的元素，返回True,，否則返回False
x not in S	如果x不是S的元素,，返回True，否則返回False

映射類型

映射類型是“鍵-值”數據項的組合,，每個元素是一個鍵值對,，表示為(key,value)。

列表類型的操作

列表類型特有的函數或方法（14個）

函數或方法	描述
ls[i]=x	替換列表ls第i個數據為x
ls[i:j]=lt	用列表lt替換列表ls中第i到第j（不含）項的數據
ls[i:j:k]=lt	用列表lt替換列表ls中第i到第j（不含）項以k為步數的數據
del ls[i:j]	刪除列表ls中第i到第j（不含）項的數據,，等價于ls[i:j]=[]
del ls[i:j:k]	刪除列表ls中第i到第j（不含）項以k為步數的數據
ls+=lt或ls.extend(lt)	將列表lt的元素增加到列表ls中
ls*=n	更新ls列表,，使其元素重復n次
ls.append(x)	在列表ls最后增加一個元素x
ls.clear()	刪除列表ls中的所有元素
ls.copy()	生成一個新列表，復制ls中的所有元素
ls.insert(i,x)	在列表ls的第i個位置增加元素x
ls.pop(i)	將列表ls中的元素取出并刪除該元素
ls.remove(x)	將列表ls中出現(xiàn)的第一個x元素刪除
ls.reverse()	將列表ls中的元素反轉

6.3 實例：基本統(tǒng)計值計算

from math import *
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 sqrt(sdev/(len(numbers)-1))
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)
print('平均值：{},方差：{},中位數：{}'.format(m,dev(n,m),median(n)))

• 列表是一個動態(tài)長度的數據結構，可以跟需求增減元素
• 列表的一系列方法或操作符為計算提供了簡單的元素運算手段
• 列表提供了對每個元素的簡單訪問方式及所有元素的遍歷方式

6.4 字典類型和操作

字典是包含零個或多個鍵值對的集合,，沒有長度限制,，可以根據減值索引內容

字典類型的概念

• 編程術語中，根據一個信息查找另一個信息的方式構成了“鍵值對”,，它表示索引用的鍵和對應的值構成的成對關系
• 通過任意鍵信息查找一組數據中值信息的過程叫映射
• Python語言中通過字典實現(xiàn)映射,，字典通過大括號({})建立，鍵和值通過冒號(:)連接,，不同鍵值對通過逗號(,)隔開

{<鍵1>:<值1>,<鍵2>:<值2>,...<鍵n>:<值n>}

• 字典是集合的延續(xù),，各個元素沒有順序之分
• 字典通過索引符號查找與特定鍵相對應的值

<值>=<字典變量>[<鍵>]

• 字典中對某個鍵值的修改可以通過中括號的訪問和賦值實現(xiàn)

字典類型的操作

• 使用大括號創(chuàng)建字典并指定初始值
• 使用中括號增加新的元素
• 鍵和值可以是任何數據類型？
• 采用固定數據類型的鍵數據作為索引

字典類型的函數和方法

函數和方法	描述
<d>.keys()	返回所有的鍵信息
<d>.values()	返回所有的值信息
<d>.items()	返回所有的鍵值對
<d>.get(<key>,<defaulf>)	鍵存在則返回相應值,，否則返回默認值
<d>.pop(<key>,<defaulf>)	鍵存在則返回相應值,，同時刪除鍵值對，否則返回默認值
<d>.popitem()	隨機從字典中取出一個鍵值對,，以元組(key,value)形式返回
<d>.clear()	刪除所有的鍵值對
del<d>[<key>]	刪除字典中某一個鍵值對
<key>in<d>	如果鍵在字典中則返回Ture,，否則返回False

6.5 jieba庫的使用

jieba庫概述

• 提取英文文本中的單詞，可使用字符串處理的split()方法
• jieba庫是Python中一個第三方中文分詞函數庫
• jieba庫的分詞原理是利用一個中文詞庫,，將待分詞的內容與分詞詞庫進行比對,，通過圖結構和動態(tài)規(guī)劃方法找到最大概率的詞組
• jieba庫支持3種分詞模式：精確模式、全模式,、搜索引擎模式

1. 精確模式：將句子最精確地切開,，適合文本分析
2. 全模式：把句子中所有可以成詞的詞語都掃描出來，速度快,，但不能消除歧義
3. 搜索引擎模式：在精確模式的基礎上,，對長詞再次切分，提高召回率,，適合用于搜索引擎分詞

jieba庫解析

• jieba庫主要提供分詞功能,，可以輔助自定義分詞詞典
  jieba庫常用的分詞函數
  |函數|描述|
  |---|---|
  |jieba.cut(s)|精確模式，返回一個可迭代的數據類型|
  |jieba.cut(s,cut_all=Ture)|全模式,，輸出文本s中所有可能的單詞|
  |jieba.cut_for_search(s)|搜索引擎模式,，適合搜索引擎建立索引的分詞結果|
  |jieba.lcut(s)|精確模式，返回一個列表類型,，建議使用|
  |jieba.lcut(s,，cut_all_=Ture)|全模式，返回一個列表類型,，建議使用|
  |jieba.lcut_for_search(s)|搜索引擎模式,，返回一個列表類型，建議使用|
  |jieba.add_word(w)|向分詞詞典中增加新詞w|

• jieba.lcut()函數返回精確模式,，輸出的分詞能夠完整且不多余地組成原始文本

• jieba.lcut(,True)函數返回全模式,，輸出原始文本中可能產生的所有問題,，冗余性最大

• jieba.lcut_for_search()函數返回搜索引擎模式，該模式首先執(zhí)行精確模式,，然后再對其中的長詞進一步分切得出結果

• 無識別的分詞,，可通過jieba.add_word()函數向分詞庫中添加

6.6文本詞頻統(tǒng)計

詞頻統(tǒng)計只是累加問題，即對文檔中每個詞設計一個計數器,，詞語每出現(xiàn)一次,，相關計數器加1.。如果以詞語為鍵,，計數器為值,，構成<單詞>:<出現(xiàn)次數>的鍵值對,，采用字典數據結構統(tǒng)計詞語出現(xiàn)的頻次,，將很好第解決問題

Hamlet英文詞頻統(tǒng)計

1. 分解并提取英文文章的單詞

• ①通過txt.lower()函數將字母變成小寫
• ②通過txt.repla()方法將特殊字符替換為空格以統(tǒng)一單詞分隔方式

2. 對每個單詞進行計數
3. 對單詞的統(tǒng)計值從高到低進行排序

• ①將字典類型轉換為有順序的列表類型
• ②使用sort()方法和lambda函數配合實現(xiàn)根據單詞出現(xiàn)的次數對元素進行排序

4. 采用集合類型構建一個排除詞匯庫（排除語法型詞匯）

excludes={'the','and','to','of','you','a','i','my','in','it','that','is','not','his','this','but','with'}#排除詞匯庫集合
def getText():
    txt = open("D:\\python\\fenci\\hamlet.txt","r").read()
    txt = txt.lower()
    for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
        txt = txt.replace(ch, " ")   #將文本中特殊字符替換為空格
    return txt
hamletTxt = getText()
words  = hamletTxt.split()
counts={}
for word in words:
    counts[word]=counts.get(word,0)+1
for word in excludes:
    del(counts[word])
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
print(items)
for i in range(20):
    word,count=items[i]
    print('{0:<10}{1:>5}'.format(word,count))

《三國演義》人物出場統(tǒng)計

中文文章需要分詞才能進行詞頻統(tǒng)計，需要用到jieba庫,。

import jieba
excludes={"將軍","卻說","荊州","二人","不可","不能","如此","商議","如何","主公",          "軍士","左右","軍馬","引兵","次日","大喜","天下","于是","東吳","今日",          "不敢","魏兵","陛下","人馬","不知","都督","一人","漢中"}          #與人名無關的詞匯庫集合
txt=open("D:\\python\\fenci\\三國演義.txt","r",encoding='utf-8').read()
words=jieba.lcut(txt)#jieba庫分詞
counts={}
for word in words:
    if len(word)==1:#排除單個字符的分詞結果
        continue
    elif word=="孔明" or word=="孔明曰":#同一人物不同名字的處理
        rword="諸葛亮"
    elif word== "關公" or word=="云長":
        rword="關羽"
    elif word=="玄德" or word=="玄德曰":
        rword="劉備"
    elif word== "孟德" or word=="丞相":
        rword="曹操"
    elif word== "子龍" or word=="趙子龍":
        rword="趙云"
    else:
        rword=word
    counts[rword]=counts.get(rword,0) + 1
for word in excludes:
    del(counts[word])
items=list(counts.items())
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))

6.7 Python之禪

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

s = """Gur Mra bs Clguba, ol Gvz Crgref

Ornhgvshy vf orggre guna htyl.
Rkcyvpvg vf orggre guna vzcyvpvg.
Fvzcyr vf orggre guna pbzcyrk.
Pbzcyrk vf orggre guna pbzcyvpngrq.
Syng vf orggre guna arfgrq.
Fcnefr vf orggre guna qrafr.
Ernqnovyvgl pbhagf.
Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf.
Nygubhtu cenpgvpnyvgl orngf chevgl.
Reebef fubhyq arire cnff fvyragyl.
Hayrff rkcyvpvgyl fvyraprq.
Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff.
Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg.
Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu.
Abj vf orggre guna arire.
Nygubhtu arire vf bsgra orggre guna *evtug* abj.
Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn.
Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn.
Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr!"""

d = {}
for c in (65, 97):#chr(65)~chr(97)為a~z,、A~Z
    for i in range(26):
        d[chr(i+c)] = chr((i+13) % 26 + c)#將循環(huán)編號增加了13，直接好處是原文和密文之間的相互轉換可以使用同一個程序

print("".join([d.get(c, c) for c in s]))

第7章 文件和數據格式化

7.1文件的使用

Python能夠以文本和二進制兩種方式處理

文件概述

• 文件是一個儲存在輔助存儲器上的數據序列,，可以包含任何數據內容
• 文件包括文本文件和二進制文件兩種類型
• 文本文件一般由單一特定編碼的字符組成,，可被看作是存儲在磁盤上的長字符串
• 二進制文件直接由比特0和比特1組成，由于沒有統(tǒng)一字符編碼,，職能當做字節(jié)流
  無論是創(chuàng)建為文本文件還是二進制文件,，都可以用“文本文件方式”和“二進制文件方式”打開，但打開后操作方式不同,。
• 采用文本方式讀入文件,，文件經過編碼形成字符串，打印出有含義的字符
• 采用二進制方式打開文件,，文件被解析為字節(jié)流

文件的打開關閉

• Python通過解釋器內置的open()函數打開一個文件,，并實現(xiàn)該文件與一個程序變量的關聯(lián)

<變量名>=open(<文件名>,<打開模式>)

• 文件名可以是文件的實際名字，也可以是包含完整路徑的名字
• 打開模式用于控制使用何種方式打開文件,，open()提供7種基本的打開模式

文件的打開模式

文件的打開模式	含義
‘r’	只讀模式,，如果文件不存在，返回異常FileNotFoundError,默認值
‘w’	覆蓋寫模式,，文件不存在則創(chuàng)建,，存在則完全覆蓋
‘x’	創(chuàng)建寫模式，文件不存在則創(chuàng)建,，存在則返回異常FileExistsError
‘a’	追加寫模式,，文件不存在則創(chuàng)建，存在則在文件最后追加內容
‘b’	二進制文件模式
‘t’	文本文件模式,，默認值
‘+’	與r/w/x/a一同使用,，在原功能基礎上增加同時讀寫功能

• 打開模式使用字符串方式表示
• 文件使用結束后要用close()方法關閉，釋放文件的使用授權

<變量名>.close()

文件的讀寫

• 當文件以文本文件方式打開時，讀寫按照字符串方式,，采用當前計算機使用的編碼或指定編碼
• 當文件以二進制文件方式打開時,，讀寫按照字節(jié)流方式

文件內容讀取方法

操作方法	含義
<file>.readall()	讀入整個文件內容，返回一個字符串或字節(jié)流
<file>.read(size=-1)	從文件中讀入整個文件內容,，如果給出參數,，讀入前size長度的字符串或字節(jié)流
<file>.readline(size=-1)	從文件中讀入一行內容，如果給出參數,，讀入該行前size長度的字符串或字節(jié)流
<file>.readlines(hint=-1)	從文件中讀入所有行,，以沒行為元素形成一個列表，如果給出參數,，讀入hint行

備注：返回字符串或字節(jié)流取決于文件打開模式

#逐行讀入內容到內存有利于優(yōu)化程序執(zhí)行速度
fname=input('請輸入要打開的文本文件')
fo=open(fname,'r')
for line in fo:#處理一行數據
    print(line)
fo.close

文件內容寫入方法

方法	含義
<file>.write(s)	向文件寫入一個字符串或字節(jié)流
<file>.writelines(lines)	將一個元素全為字符串的列表寫入文件
<file>.seek(offset)	改變當前文件操作指針的位置,，offset的值：0——文件開頭；1——當前位置,；2——文件結尾

7.4 一二維數據的格式化和處理

數據組織的維度

• 一維數據由對等關系的有序或無序數據構成,，采用線性方式組織，對應數學中的數組和集合等概念
  無論采用任何方式分隔和表示,，一維數據都具有線性特點
• 二維數據也稱表格數據,，由關聯(lián)關系數據構成，采用表格方式組織,，對應數學中的矩陣
• 高維數據由鍵值對類型的數據構成,，采用對象方式組織，屬于整合度更好的數據組織方式
  高維數據相比一維和二維數據能表達更加靈活和復雜的數據關系

---

對于數據處理,，需要考慮存儲格式以及表示和讀寫兩個問題

---

一二維數據的存儲格式

• 一維數據是最簡單的數據組織類型,，常用空格、逗號以及其他符號或符號組合分隔
• 二維數據由多條一維數據構成,，可以看做是一維數據的組合形式
  逗號分隔數值的存儲格式叫做CSV（Comma-Separated Values,逗號分隔值）格式,，它是一種通用的、相對簡單的文件格式,，尤其應用在程序之間轉移表格數據

CSV格式應用基本規(guī)則

1. 純文本格式,，通過單一編碼表示字符
2. 以行為單位，開頭不留空行,，行之間沒有空行
3. 每行表示一個一維數據,，多行表示二維數據
4. 以逗號（英文，半角）分隔每列數據,，數據列為空也要保留逗號
5. 對于表格數據,，可以包含或不包含列名，包含時列名放置在文件第一行

一二維數據的表示和讀寫

• CSV文件的每一行是一維數據,，可以使用Python中的列表類型表示
• 整個CSV文件是一個二維數據,，由表示每一行的列表類型作為元素,，組成一個二維列表

1.csv :
列1,列2,列3,列4,列5
1,1,1,1,1
2,2,2,2,2
3,3,3,3,3
4,4,4,4,4
5,5,5,5,5

---

導入CSV格式數據到列表

fo=open('1.csv','r')
ls=[]
for line in fo:
    line=line.replace('\n','')
    ls.append(line.split(','))  #  以split(',')方法從CSV文件中獲得內容時，每行最后一個元素后面包含了一個換行符('\n'),，應去掉,。
print(ls)
fo.close()
>>>
[ ['列1', '列2', '列3', '列4', '列5'], ['1', '1', '1', '1', '1'], ['2', '2', '2', '2', '2'], ['3', '3', '3', '3', '3'], ['4', '4', '4', '4', '4'], ['5', '5', '5', '5', '5'] ]

---

逐行處理CSV格式數據

fo=open('1.csv','r')
ls=[]
for line in fo:
    line=line.replace('\n','')
    ls=line.split(',')
    ins=''
    for s in ls:
        ins+='{}\t'.format(s)
    print(ins)
fo.close()
>>>
列1  列2  列3  列4  列5  
1   1   1   1   1   
2   2   2   2   2   
3   3   3   3   3   
4   4   4   4   4   
5   5   5   5   5

---

一維數據寫入CSV文件

• 對于Python列表變量保存一維數據結果，可以用字符串的join()方法組成逗號分隔形式在通過文件的write()方法存儲到CSV文件中

fo=open('1.csv','a')
ls=['6','6','6','6','6']
fo.write(','.join(ls)+'\n')
fo.close()

---

二維數據寫入CSV文件

fr=open('1.csv','r',encoding='UTF-8')
fw=open('2.csv','w',encoding='UTF-8')
ls=[]
for line in fr:  #將CSV文件中的二維數據讀入到列表變量
    line=line.replace('\n','')
    ls.append(line.split(','))
for i in range(len(ls)):  #遍歷列表變量
    if i==0:  #跳過第一行列名
        continue
    for j in range(len(ls[i])):
        ls[i][j]=str(int(ls[i][j])*2)
for row in ls:  #將列表變量輸出到CSV文件
    print(row)
    fw.write(','.join(row)+'\n')
fr.close()
fw.close()
'''注意事項
1.UnicodeDecodeError: 'gbk' codec can't decode byte...在open()最后添加“encoding='UTF-8'”
2.line.replace('\n',''),，換行符是“\n”而不是“n”——注意不要打錯符號
3.ls.append(line.split(',')),，split(',')而不是split('')——注意不要打錯符號
4.ls[i][j]=str(int(ls[i][j])*2)，注意列表中嵌套列表情況下的索引,；注意“l(fā)s[i][j]”類型為str
5.",".join(row)生成一個新的字符串,，它由字符串“,”分隔列表row中的元素形成
6.fr.close()，注意close()方法后要有括號“()”
'''

7.5 CSV格式的HTML展示

HTML（HyperText Markup Language）超文本標記語言,，本質上是鍵值對的標記,，它采用<key>value</key>的方式表達鍵key對應的值value。

將CSV文件轉換成HTML文件分3步驟：

1. 讀入CSV文件,，獲得文件數據
2. 對數據進行格式化處理和轉換
3. 輸出HTML格式文件

7.6 高維數據的格式化

鍵值對是高維數據的特征

• 高維數據能展示數據間更為復雜的組織關系,，為了保持靈活性,，高維數據不采用任何結構形式,，僅采用最基本的二元關系，即鍵值對
  JSON（JavaScript Objct Notation）是一種輕量級的數據交換格式,，可以對高維數據進行表達和存儲

JSON格式表達鍵值對的基本格式："key":"value"
多個鍵值對放在一起的規(guī)則

1. 數據保存在鍵值對中
2. 鍵值對之間由逗號分隔
3. 大括號用于保存鍵值對數據組成的對象
4. 中括號用于保存鍵值對數據組成的數組

• 采用對象,、數組方式組織起來的鍵值對可以表示任何結構的數據

7.7 json庫的使用

• json庫主要包括兩類函數，操作類函數和解析類函數
• 操作類函數主要完成外部JSON格式和程序內部數據類型之間的轉換功能
• 解析類函數主要用于解析鍵值對內容
• json格式包括對象和數組
• 對象用大括號({})表示,，對應鍵值對的組合關系（被json庫解析為字典）
• 數組用中括號({})表示,，對應鍵值對的對等關系（被json庫解析為列表）

json庫解析

• json庫包含編碼（encoding）和解碼（decoding）兩個過程
• 編碼將Python數據類型變換成JSON格式
• 解碼是從JSON格式中解析數據對應到Python數據類型的過程
  json庫的操作類函數

函數	描述
json.dumps(obj,sort_keys=Flase,indent=None)	將Python的數據類型轉換為JSON格式，編碼過程
json.loads(string)	將JSON格式字符串轉換為Python的數據類型,，解碼過程
json.dump(obj,fp,，sort_keys=Flase,indent=None)	與dumps()功能一致，輸出到文件fp
json.load(fp)	與loads()功能一致,，從文件fp讀入

• json.dumps()中的obj可以是Python的列表或字典類型,，當輸入字典類型時，dumps()函數將其變?yōu)镴SON格式字符串
• 默認生成的字符串是順序存放的,，sort_keys可以對字典元素按照key進行排序控制輸出結果
• indent參數用于增加數據縮進,，使得生成的JSON格式字符串更具可讀性

7.8 CSV和JSON格式相互轉換

將CSV格式轉換成JSON格式

import json
fr=open('1.csv','r',encoding='UTF-8')
ls=[]
for line in fr:
    line=line.replace('\n','')
    ls.append(line.split(','))
fr.close()
fw=open('1.json','w')
for i in range(1,len(ls)):
    ls[i]=dict(zip(ls[0],ls[i]))  #zip()將兩個長度相同的列表組合成一個關系對
json.dump(ls[1:],fw,sort_keys=True,indent=4,ensure_ascii=False)
fw.close()
'''
ls[1:] 表示列表第2項到最后一項
ensure_ascii=False 使json庫輸出中文呢字符
'''

將JSON格式轉換成CSV格式

import json
fr=open('1.json','r')
ls=json.load(fr)
data=[list(ls[0].keys())]  #ls[0].keys()返回所有的鍵信息
for item in ls:
    data.append(list(item.values()))  #item.values()返回所有的值信息
fr.close()
fw=open('1-1.csv','w')
for item in data:
    fw.write(','.join(item)+'\n')
fw.close()