python教程學習

一、 ubuntu基本使用

1.簡介

勵志公式：
1.01^365 = 37.8
0.99^365 = 0.03
1.01^3 * 0.99 ^2 <1.01 三天打魚兩天曬網43
Python 終端驗證

python

1.01 ** 365 將會輸出 37.783

0.99 ** 365 將會輸出 0.0255

1.1. 目錄

Ubuntu 系統沒有盤符的概念，只有目錄

/
/ -> /etc /lib /bin /usr /home
/home -> /mayun /laowang /lvbu
/mayun -> /Desktop /python …

1.2. 常用命令基本使用

序號	命令	對應英文	作用
01	ls	list	查看當前文件下的內容
02	pwd	print work directory	查看當前文件夾
03	cd [目錄名]	change directory	切換文件夾
04	touch	touch	如果文件不存在則新建文件
05	mkdir [目錄名]	make directory	創建目錄
06	rm [目錄名]	remove	刪除指定文件
07	clear	clear	清屏

小技巧

ctrl + shift + = 放大終端中的字體顯示
ctrl + - 縮小終端窗口的字體顯示

自動補全
在敲出文件/目錄/命令的前幾個字母后，按下tab鍵
文件輸入沒有奇異，系統會自動補全

1.3 終端命令

command [-options] [parameter]
說明

command：命令名，相應的英文單詞或者縮寫
[-options]：選項，用來對命令進行控制，也可以省略
parameter ：傳給命令的參數，可以時零個、一個、或者多個

[] 代表可選

1.4 查閱命令幫助信息

–help
command --help

顯示 command 命令的幫助信息

man
man command

查閱command 命令的使用手冊
man 是 manual 的縮寫，Linux 提供的一個手冊，包含絕大部分的命令、函數的歇息使用說明

2. 文件目錄相關

2.1 通配符的使用

一些特殊的符號可以代替其他的字符

. 任意個數個字符

? 代表任意一個字符，至少一個

[] 表示可以匹配字符組中的任意一個

[abc] 匹配a、b、c中任意一個

[a-f] 匹配從a到f範圍內的任意一個

2.2查看 ls

-a 顯示指定目錄下所有目錄與文件，包括隱藏文件

-l 以列表方式顯示文件的詳細信息

-h 配合-l 以人性化的方式顯示文件大小

2.3切換 cd

cd 切換當前用戶的主目錄（/home）

cd ~ 切換當前目錄的主目錄

cd . 保持在當前目錄不變

cd … 切換到上一級目錄

cd - 可以在最近兩次工作目錄中切換
絕對、相對目錄最前面是否 /或者~ 開頭的目錄

2.4創建和刪除 touch rm mkdir

touch 文件不存在創建，存在修改創建時間
mkdir -p 遞歸創建目錄
rm 使用rm命令要小心，文件刪除後不能恢復

-f 強制刪除，忽略不存在的文件，無任何提示

-r 遞歸刪除目錄下的內容，刪除文件夾必須加此參數

2.5拷貝和移動文件 cp mv

cp拷貝

cp -f 已存在文件直接覆蓋，不會提示

cp -i 覆蓋文件前提醒

cp -r 目錄文件賦值，遞歸賦值

mv move的縮寫，移動文件+重命名

mv 源文件目標文件

mv -i 覆蓋時會有一個提示

2.6 文件內容相關cat more grep

cat 文件名，查看文件內容，創建文件，合併文件，追加文件內容等功能

會一次顯示所有的內容，適合查看內容缺少的文本文件

cat -b 對非空輸出行編號

cat -n 對輸出所有行編號

Linux中還有 nl 的命令和 cat -b 的效果等價

more 文件名，分屏顯示文件內容,每次只顯示一頁內容

適合於查看內容較多的文本文件

more的更多操作鍵：

空格鍵顯示手冊頁的下一屏

Enter鍵一次滾動手冊頁的一行

b 回滾一屏

f 前滾一屏

q 退出

/word 搜索world 字符串

grep 搜索文本文件名，搜索文本文件內容

-n 顯示匹配行及行號

-v 顯示不包含匹配文件的所有行（想當於求反）

-i 忽略大小寫

2.7.其他: echo 重定向>和>> 管道

echo 一般跟重定向一起使用

Linux 允許將命令執行結果重定向到一個文件

將文本顯示在終端的內容輸出/追加到指定文件中

其中：
1.> 表示輸出，會覆蓋文件原有的內容
2. >>表示追加，會將內容追加到已有文件的末尾
3. ls -lh > a 將當前目錄的文本信息寫到a文件中（重定向的一個例子）
管道 |

Linux 允許將一個命令的輸出可以通過管道作爲另一個命令的輸入

可以理解爲顯示生活中的管子，管子的一頭塞進東西進去，另一頭取出來，這裏 | 的左右分爲兩端，左端塞東西（寫），右端取東西（讀）

管道的常用管道命令有：
more：分屏顯示內容
grep：在命令執行結果的基礎上查詢指定的文本
例如： ls -lha | grep Do

tree命令
sudo apt-get install tree
tree [目錄]
樹型顯示文件夾形式

3. 遠程管理常用命令

3.1關機/重啓

3.1.1. 基本語法

序號	命令	對應英文	作用
01	shutdown 選項時間	shutdown	關機/重啓選項

3.1.2. shutdown

shutdown 命令可以安全關閉或者重新啓動系統
-r 重新啓動

提示：

不指定選項和參數；默認1分鐘之後關閉電腦
遠程維護服務器時，最好不要關閉系統，而應該重啓系統

3.1.3. 常用命令

# 重啓操作系統，其中now表示現在
$ shutdown -r now

# 立即關機，其中now表示現在
$ shutdown now

# 系統在今天20：25關機 
$ shutdown 20:25

# 系統在十分鐘後關機
$ shutdown +10

# 取消之前指定的關機計劃
$ shutdown -c

3.2. 查看或配置網卡信息

序號	命令	對應英文	作用
01	ifconfig	configure a network interface	查看/配置計算機當前的網卡配置信息
02	ping ip地址	ping	檢測到目標ip地址的鏈接時否正常

3.2.1 網卡和ip

網卡

網卡是一個專門負責網絡通訊的硬件設備
IP 地址是設置在網卡上的地址信息
我們可以把電腦比作電話，網卡相當於 SIM 卡，IP 地址相當於電話號碼。

IP 地址

每臺電腦上都有 IP 地址，是保證電腦之間正常通訊的重要設置
注：每臺電腦的IP 不能相同，否則會出現IP地址衝突，並且沒辦法保證正常通訊

3.2.2 ifconfig

可以查看/配置計算機當前的網卡配置信息

例如： ifconfig 查看網卡配置信息
ifconfig | grep inet 查看網卡對應的 IP 地址

提示：一個電腦可能有一個物理網卡和多個虛擬網卡，在Linux中物理網卡的名字通常以 ensXX表示

3.2.3 ping

ping IP地址檢測到目標主機是否連接正常
ping 127.0.0.1 檢測本地網卡工作正常

ping 一般用於檢測當前計算機到目標計算機之間的網絡是否暢通，數值越大，速度越慢

ping 的工作原理與潛水艇的聲納很相似，ping 這個命令曲子聲納的聲音
網絡管理員也常將ping 用作動詞， --ping 一下計算機X，看他是否開着

提示：在Linux中，想要終止一個終端，絕大多數都可以使用 ctrl+c

3.3 遠程登錄和賦值文件

序號	命令	對應英文	作用
01	ssh 用戶名@ip	secure shell	關機/重新啓動
02	scp 用戶名@ip:文件名或路徑用戶名@ip:文件名或路徑	secure copy	遠程複製文件

3.3.1 ssh 基礎（重點）

Linux 中SSH 是非常常用的公式，通過SSH客戶端我們可以連接運行SSH服務器的遠程機器上
數據是加密壓縮的，保證安全和高速。
域名和端口號
域名：

由一串用點分割的名族組成 www.itcase.cn
是IP的別名，方便用戶記憶

端口號：
1.IP地址：通過 IP地址找到網絡上的計算機
2.端口號：通過端口號可以找到計算機上運行的應用程序
3.常用服務端口號列表：

序號	服務	端口號
01	SSH 服務器	22
02	Web服務器	80
03	HTTPS	443
04	FTP服務器	21

提示：有關端號的詳細內容。
SSH 客戶端簡單使用

ssh [-p port] user@remote

user：遠程機器上的用戶名，如果不指定的話默認當前用戶名
remote：遠程機器的地址，可以是IP/域名，或者是後面提到的別名
prot：是SSH Server 接聽的端口，如果不指定，就是默認22

提示：使用 exit 退出當前用戶的登錄
注：

ssh 這個終端命令只能在Linux或者UNIX系統使用
如果在Windows系統中，可以用PuTTY，或者XShell 客戶端軟件即可
在工作中，SSH服務器的端口號可能不是22，需要-p指定，否則無法正確鏈接。

scp
Linux遠程拷貝文件的命令
他的地址格式與ssh基本相同，需要注意的是，指定端口時是大學的P -P

例如：

把本地01.py複製到遠程桌面下
scp -P port 01.py user@remote:Desktop/01.py

把遠程家目錄下的 Desktop/01.py 文件複製到本地當前目錄下的 01.py
scp -P user@remote:Desktop/01.py 01.py

-r 若給出的源文件是目錄文件，則scp 將遞歸複製該目錄下的所有子目錄和文件，文件必須是一個目錄名
-P 若遠程端口號不是22，則需要使用大些字母 -P 選項指定端口。

3.3.2 SSH高級

免密碼登錄
配置別名
提示：有關SSH配置信息都保存在用戶家目錄下的.ssh目錄下
免密碼登錄：
配置公鑰

執行 ssh-keygeb 即可生成鑰匙，一路回車即可

上傳公鑰到服務器

執行ssh-copy-id -p port user@remote，可以讓遠程服務器記錄我們的公鑰

配置別名
每次輸入 ssh -p port user@remote，時間久了會覺得麻煩
配置別名可以讓我們進一步偷懶，譬如用：ssh mac來代替上面這麼一長串，那麼就在 ~/.ssh/config 裏面追加一下內容：

Host mac
HostName ip地址
User user
Port 22

保存之後即可使用。

3.4 用戶權限基本概念

基本概念

用戶是Linux 系統工作中重要的一環，用戶管理包括用戶與組管理。
在Linux系統中，不論是本地還是遠程登錄系統，每個系統都有一個賬號，並且對於不同的系統擁有不同的使用權限
在Linux中可以指定每一個用戶針對不同文件或目錄的不同權限。
對文件的權限包括

序號	權限	英文	縮寫	數字代號
01	讀	read	r	4
02	寫	write	w	2
03	執行	excute	x	1

組
爲了方便管理用戶，提出組的概念
在實際應用中，可以預先針對組設置好權限，然後將不同用戶添加到對應的組中，從而不用依次爲每個瀛湖設置權限
chmod
chmod 可以修改用戶 /組對文件/目錄的權限
chmod +/-rwx 文件名|目錄
eg:chmod +x 01.py
目錄如果沒有可執行權限，將不能執行終端命令，例如ls cd 等。

3.4.1超級用戶

Linux系統中root賬號通常 用於系統的維護和管理，對象系統的所有資源具有所有訪問權限
在大多數版本的Linux中，都不推薦直接使用root賬號登錄系統。
在Linux安裝過程中，系統會自動創建一個用戶賬號，而這個默認的用戶就是標準用戶。
sudo
su 是substitute user的縮寫，表示使用另一個用戶的身份。
sudo 命令用來以其他身份來執行命令，預設的身份爲root
用戶使用sudo時，必須先輸入密碼，之後5分鐘的有效期限，超過期限時必須重新輸入密碼。
若其未經過授權的用戶企圖使用sudo，則會發出警告郵件給管理員。

3.4.2組管理終端令

提示，創建/刪除組的終端命令都是需要通過sudo執行

序號	命令	作用
01	groupadd 組名	添加組
02	groupdel 組名	刪除組
03	cat /etc/group	確認組信息
04	chgrp 組名文件/目錄名	修改文件/目錄的所屬組

提示：

組信息保存在/etc/group 文件中
/etc 目錄是專門用來保存系統配置信息的目錄
在實際應用中，可以預先針對組設置好權限，然後將不同的用戶添加到對應的組中，從而不用依次爲每一個用戶設置權限

mkdir Python學習   #創建 Python學習  目錄
sudo groupadd dev  #創建組dev
cat /etc/group  #查看確定組是否被創建
sudo chgrp -R dev Python學習   #將 目錄的組修改爲 dev。

3.4.3 用戶管理終端令

提示：創建用戶/刪除用戶/修改其他用戶的密碼的中斷命令都需要通過sudo執行。
創建用戶/設置密碼/刪除用戶

序號	命令	作用	說明
01	usered -m -g 組新建用戶名	添加新用戶	-m 自動創建用戶家目錄 -g指定用戶所在的組，否則會創建一個和同名的組
02	passwd 用戶名	設置用戶密碼	如果是普通用戶，直接用passwd可以修改自己的賬號密碼
03	userdel -r 用戶名	刪除用戶	-r 選項會自動刪除用戶的家目錄
04	cat /etc/passwd \| grep 用戶名	確認用戶信息	新建用戶後，用戶信息會保存在/etc/passwd 文件中

提示：

創建用戶時，如果忘記添加 -m 選項指定新用戶的家目錄–最簡單的方法是刪除用戶，重新創建
創建用戶時，默認會創建一個和用戶名同名的組名
用戶信息保存在/etc/passwd文件中

3.4.4 查看用戶id

序號	命令	作用
01	id [用戶名]	查看用戶UID和GID信息
02	who	查看當前所有登錄的用戶列表
03	whoami	查看當前登錄用戶的賬戶名

paswd文件
/etc/passwd 文件存放的是用戶的信息，由6個分號組成的7個信息，分別是：

用戶名
密碼（x，表示加密的密碼）
UID（用戶標識）
GID（組表示）
用戶全名或者本地賬號
家目錄
登錄使用的shell，就是登錄之後，使用的終端命令，ubuntu默認 dash

usermod

usermod 可以用來設置用戶的主組/附加組和登錄shell，命令合適如下：
主組：通常在創建用戶時指定，在 /etc/passwd的第4列GID對應的組
附加組：在etc/group中最後一列表示該組的用戶列表，用於指定用戶的附加權限

提示：設置了用戶的附加組之後，需要重新登錄才能生效!

# 修改用戶的主組 （passwd中的GID）
usermod -g 組 用戶名
# 修改用戶的附加組
usermod -G 組 用戶名
# 修改用戶登錄 Shell
usermod -s /bin/bash

**注意：**默認使用useradd添加的用戶是沒有全線使用sudo以root身份執行命令的，可以使用一下命令，將用戶添加到sudo附加組中

usermod -G sudo 用戶名

etc 目錄是專門用來保存與系統相關的目錄。
which（重要）

etc/passwd 是用於保存用戶信息的文件

/user/bin/passwd 是用於修改用戶密碼的程序

which命令可以查看執行命令所在的位置，例如：

which ls
# 輸出
# /bin/ls

which useradd 
# 輸出
# /user/sbin/useradd

bin和sbin

在Linux中，絕大多數可執行文件都保存在/bin、/sbin、/usr/bin、/usr/sbin
/bin（binary）是二進制執行文件目錄，主要用於具體應用
/sbin（system binary）是系統管理員專用的二進制代碼存放目錄，主要用於系統管理
/usr/bin 後期安裝的一些軟件
/usr/sbin 超級用戶的一些管理程序

提示：cd 這個終端命令是內置在系統內核中的，沒有獨立文件，which無法找

3.4.5切換用戶

序號	命令	作用	說明
01	su - 用戶名	切換用戶，並且切換目錄	-可以切換到用戶家目錄，否則保持位置不變
02	exit	退出當前登錄賬號

注su 不接用戶，可以切換到root，但不推薦使用，因爲不安全

3.4.6修改文件權限

序號	命令	作用
01	chown	修改擁有者
02	chgrp	修改組
03	chmod	修改權限

命令格式

# 修改文件|目錄的擁有者
chown 用戶名 文件名|目錄名
# 遞歸修改文件|目錄的組
chgrp -R 組名 文件名|目錄名
# 遞歸修改文件權限
chmod -R 755 文件名|目錄名

chmod在設置權限時，可以簡單地使用三個數字分別對應擁有者/組和其他用戶的權限
權限擁有者，組，其他

4.系統信息相關命令

系統日期和時間，磁盤佔用情況，程序執行情況。

#時間和日期
date cal
#磁盤和目錄空間
df du
#進程信息
ps top kill

4.1時間和日期

序號	命令	作用
01	cal	查看日曆，-y選項可以查看一年的日曆
02	date	查看系統時間

4.2磁盤信息

序號	命令	作用
01	df -h	disk free 顯示磁盤剩餘空間
02	du -h [目錄名]	disk usage 顯示目錄下的文件大小

選項說明：參數-h，以人性化的方式顯示文件大小

4.3進程信息

所謂進程，通俗地說就是當前正在執行的一個程序

序號	命令	作用
01	ps aux	process status 查看進程的詳細狀況
02	top	動態顯示運行中的進程並且排序
03	kill [-9] 進程代號	終止指定代號的進行，-9代表強制終止

注意： ps 默認只會顯示當前用戶通過終端啓動的應用程序

選項	含義
a	顯示終端上的所有進程，包括其他用戶的進程
u	顯示進程的詳細信息狀態
x	顯示沒有控制終端的進程

提示: 使用kill命令時，最好只終止由當前用戶開啓的進程，而不要終止root身份開啓的進程，否則可能導致系統崩潰。

1. top顯示 :進程代號，啓動命令代號，cpu，內存佔用率，時間，命令
2. 要退出 top 可以直接輸入q

4.4 其他命令

查找文件 find
軟連接 ln
打包和壓縮 tar
軟件安裝 apt-get

4.4.1 查找文件

find 命令是功能非常強大，通常用來在特定的目錄下所搜符合條件的文件

find [路徑] -name “.py” 查找指定路徑下擴展名爲.py的文件，包括子目錄

如果省略路徑，則在當前文件中查找
之前學習的通配符，在使用find命令時同時可用（* ？等）

4.4.2 軟鏈接

ln -s 被鏈接的源文件，鏈接文件

注意：

沒有 -s 選項建立的是一個硬鏈接文件
沒有文件佔用相同大小的硬盤空間，工作中幾乎不會建立文件的硬鏈接
源文件要使用絕對路徑，不能使用相對路徑，這樣可以方便移動鏈接文件後，仍然可以使用。

文件軟硬鏈接的示意圖

在Linux中，文件名和文件數據是分開存儲的。
刪除文件名後，軟鏈接不能訪問數據，硬鏈接可以。

1.在Linux中，只有文件的硬鏈接數==0 纔會被刪除
2.使用ls -l 可以查看一個文件的硬鏈接的數量
3.在日常工作中，幾乎不會建立文件的硬鏈接

4.4.3打包壓縮

在不同的操作系統中，打包壓縮的方式是不同的

windows 常用 rar
Mac 常用 zip
Linux 常用 tar.gz

打包/解包
tar 是Linux 中最常用的備份工具，此命令可以把一系列文件打包到一個大文件中，也可以把一個打包的大文件恢復成一系列文件
tar的命令格式如下：

# 打包文件
tar -cvf 打包文件.tar 被打包的文件/路徑...
# 解包文件
tar -xvf 打包文件.tar

tar選項說明：

選項	含義
c	生成檔案文件，創建打包文件
x	解開檔案文件
v	列出歸檔接檔的詳細過程，顯示進度
f	指定檔案文件名稱，f後面一定是 .tar 文件，所以必須放選項後面

注意：f 選項必須放在後面，其他選項順序可以隨意

4.4.4 壓縮/解壓縮

gzip
tar 與 gzip 命令結合可以實現文件打包和壓縮

tar只負責打包，但不負責壓縮
用gzip壓縮tar打包後的文件，其擴展名爲 xxx.tar.gz

在Linux中，最常見的壓縮文件格式就是 xxx.tar.gz
命令格式如下：

# 壓縮文件
tar -zcvf 打包文件.tar.gz 被壓縮的文件/路徑...

# 解壓縮文件
tar -zxvf 打包文件.tar.gz

# 解壓縮到指定路徑
tar -zxvf 打包文件.tar.gz -C 目標路徑

選項	含義
-C	解壓縮到指定目標，注意：要解壓縮的目錄必須存在

bzip2(two)

tar與bzip2命令結合可以使用實現文件打包和壓縮（用法和gzip一樣）

tar只負責打包文件，但不壓縮
用bzip2壓縮tar打包後的文件，其擴展名一般用 xxx.tar.bz2

在tar命令中有一個選項-j可以調用bzip2，從而可以方便的實現壓縮和解壓縮的功能

# 壓縮文件
tar -jcvf 打包文件.tar.bz2 被壓縮的文件/路徑...

#解壓縮文件
tar -jxvf 打包文件.tar.bz2

4.4.5 軟件安裝

通過apt安裝/卸載文件

apt是 Advanced Packaging Tool，是Linux下的一款安裝包管理工具
可以在終端中方便地安裝/卸載/更新軟件包

# 1.安裝軟件
sudo apt install 軟件包
# 2.卸載軟件
sudo apt remove 軟件包
# 3.更新已安裝的包
sudo apt upgrade

例如：

sudo apt install sl  #一個小火車提示

二、Python 簡介

1.Python 科普

python 是一個高層次的結合瞭解釋性、編譯性、互動性和麪向對象的腳本語言。
Python 的設計具有很強的可讀性，相比其他語言經常使用英文關鍵字，其他語言的一些標點符號，它具有比其他語言更有特色語法結構。
Python 是一種解釋型語言：這意味着開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
Python 是交互式語言：這意味着，您可以在一個 Python 提示符 >>> 後直接執行代碼。
Python 是面嚮對象語言: 這意味着Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python 是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發，從簡單的文字處理到 WWW 瀏覽器再到遊戲。

解釋型語言

編譯型語言->編譯器->最終可執行文件-》操作系統
解釋型語言->解釋器-》操作系統
編譯型語言：程序在執行之前需要一個專門的編譯過程，把程序編譯成爲機器語言的文件，運行時不需要重新翻譯，直接使用編譯的結果就行了。程序執行效率高，依賴編譯器，跨平臺性差，如C，c++。
解釋型語言：編寫時不進行預先編譯，以文本方式存儲程序代碼，會將代碼一句一句直接運行。在發佈程序時，看起來省了編譯工作，但運行程序的時候，必須先解釋在運行。
速度：編譯型語言塊
跨平臺：解釋型語言跨平臺好

Python 設計目標
簡單直觀的語言，開源，像純英語那樣容易理解，適用於短期開發的日常任務。
Python 設計哲學
優雅，明確，簡單
用一種方法，最好是隻有一種來做一件事
明確沒有或者很少有歧義的語法
爲什麼使用Python
代碼量比較少
Python 特點
面向對象的思維方式

Python是完全面向對象的語言

函數、模塊、數字、字符串都是對象，在Python中一切皆對象

完全支持繼承、重載、多重繼承

支持重載運算符，也支持泛型設計

Python擁有一個強大的標準庫，Python語言的核心只包含數字、字符串、列表、字典等常見類型和函數，而且由Python標準庫提供了系統管理、網絡通訊、文本處理、數據庫接口、圖形系統、XML處理等額外的功能。
Python社區提供了大量的第三方模塊，使用方式與標準庫類似，他們的功能是覆蓋科學計算、人工智能、機器人學習、Web開發、圖形系統等多個領域。

優缺點

簡單，易學，免費開源，高層語言，可移植性，解釋性，面向對象，可擴展性，豐富的庫，規範的代碼。

可擴展性：不公開打嗎可以用c,c++實現，然後在Python程序中使用他們。

缺點：運行速度，國內視場小，中文資料少，有速度要求改C++，架構選擇少。

2.第一個Python 程序

執行Python的三種方式：

解釋器–Python/Python3
交互式–ipython
集成開發環境–Pycharm

2.1第一個helloPython程序

Python源程序就是一個特殊格式的文本文件，可以使用任意文本編譯軟件做Python的開發
Python程序的文件擴展名通常用 .py
1.新建 01-helloPython.py文件
2.用gedit編輯，並輸入

print("hello python")
print("hello world")

3.執行

 python 01-helloPython.py

說明： print是的作用是把”“內部的內容輸出到屏幕上
bug：程序不能執行，執行結果不是我們期望的
常見錯誤：

1.手誤 print 寫成printf
報錯：NameError ：name ‘printf’ is not defined
2.將多條print寫到一行
報錯：SyntaxError:invalid syntax
每行代碼負責完成一個動作
3.縮進錯誤
報錯：IndentationError:unexpected indent
python是一個格式非常嚴格的程序設計語言

Python 2.x 默認不支持中文
目前市面上只有兩個Python的版本並存，分別爲Python 2.x 和Python 3.x

Python 2.x 默認不支持中文，
Python 2.x 的解釋器名稱爲 python
Python 3.x 的解釋器名稱爲 python3

ASCII 字符只包含256個字符，不支持中文
Python 3.x 支持中文，終點集中到3.0版本上

2.1.1 Python 中文編碼

#!/usr/bin/python
print "你好，世界";

Python中默認的編碼格式是 ASCII 格式，在沒修改編碼格式時無法正確打印漢字，所以在讀取中文時會報錯。
解決方法爲只要在文件開頭加入 # -- coding: UTF-8 -- 或者 #coding=utf-8 就行了
注意：#coding=utf-8 的 = 號兩邊不要空格。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
print("你好，世界");

注意：Python3.X 源碼文件默認使用utf-8編碼，所以可以正常解析中文，無需指定 UTF-8 編碼。如果你使用編輯器，同時需要設置 py 文件存儲的格式爲 UTF-8，否則會出現類似以下錯誤信息：

2.2 執行Python程序的三種方式

2.2.1解釋器

Python解釋器

# 使用 2.0
python xxx.py
# 使用 3.0
python3 xxx.py

其他解釋器
CPython – 官方版本的C語言實現
Jython – 可以運行在java 平臺

2.2.2 交互式Python程序

直接在終端中運行解釋器，而不輸入要執行的文件名
在Python的Shell 中直接輸入Python的代阿凱碼，會立即藍島程序執行的結果
交互式運行Python的優缺點

優：適合學習，驗證Python語法或者局部代碼
缺：代碼不能保存，不適合太大的程序

官方Python 2.x 3.x

打開交互式Python
終端輸入 python
退出官方的解釋器
1.直接輸入 exit()
2.直接使用快捷鍵 ctrl+d

IPython

IPython 是一個Python的交互式Shell，比默認的好的多
支持自動補全、自動鎖緊、支持bash shell命令、內置了很多有用的功能和函數
ipython、ipython3
退出輸入exit()
直接使用熱鍵 ctrl+d

2.2.3 Pycharm

pycharm中出現Process finished with exit code 0代表程序執行完成

PyCharm 是由 JetBrains 打造的一款 Python IDE，支持 macOS、 Windows、 Linux 系統。
PyCharm 功能 : 調試、語法高亮、Project管理、代碼跳轉、智能提示、自動完成、單元測試、版本控制……
PyCharm 下載地址
PyCharm 安裝地址

特點：

1.圖形用戶界面
2. 代碼編輯器（支持代碼補全與縮進）
3. 編輯器/解釋器
4. 調試器（斷電/單步執行）
…
執行 shift+F10
調試 shift+F9

2.3 Pycharm

在配置界面，可以通過 Editor colors and fonts 選擇編輯器的配色方案

2.3.1 Pycharm的初始設置

pycharm 的配置信息是保存在用戶目錄下的 .Pycharmxxx.x 目錄下的，xxx.x表示當前使用pycharm的版本號
如果要恢復pycharm的初始設置，可以按照以下步驟進行：

關閉正在運行的Pycharm
在終端中執行一下終端命令，刪除Pycharm的配置信息目錄
rm -r ~/.Pycharm2016.3
重啓Pycharm

2.3.2 打開新建一個Python項目

項目簡介

開發項目就是開發一個專門解決一個複雜業務功能的軟件
通常每一個項目就是一個獨立專屬的目錄，用於保存所有和項目相關的文件
一個項目通常會包含很多源文件

打開Python項目

直接點擊open按鈕，然後瀏覽到之前保存Python文件的目錄，即可以打開項目
打開之後，會在目錄下新建一個 .idea 的目錄，用於保存項目的相關信息，例如：解釋器版本，項目包含的文件等
第一次打開項目時，要耐心等待pycharm 對項目進行初始化
對.py文件右鍵，選擇執行按鈕，即可執行

設置項目使用的解釋器版本

1.打開的目錄不是有pycharm建立的項目目錄，有時候使用的解釋器時Python2.x的，需要單獨設置解釋器的版本
通過file->setting…可以打開設置窗口

設置字體等
通過file->setting->editor … Font可以設置字體的顯示
下載安裝

下載–官網有免費版本
安裝-- 將解壓後的目錄移動到/opt目錄下，方便其他用戶使用
/opt 目錄用戶存放給主機額外安裝的軟件
啓動–bin 目錄下的./pycharm.sh
卸載–刪除文件和配置
注意：/usr/share/applications/下的桌面快捷方式

設置專業版啓動圖標
在專業版中，選擇菜單Tool/create Desktop Entry …
注：設置圖標時，勾選 create the entry for all users

3. Python基礎

3.0 Python 基本信息

3.0.1 保留字符

下面的列表顯示了在Python中的保留字。這些保留字不能用作常數或變數，或任何其他標識符名稱。所有 Python 的關鍵字只包含小寫字母。

and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

3.0.2 Python多行語句

Python語句中一般以新行作爲語句的結束符。
但是我們可以使用斜槓（ \）將一行的語句分爲多行顯示，如下所示：

total = item_one + \
        item_two + \
        item_three

語句中包含 [], {} 或 () 括號就不需要使用多行連接符。如下實例：

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

3.0.3 Python 引號

Python 可以使用引號( ’ )、雙引號( " )、三引號( ‘’’ 或 “”" ) 來表示字符串，引號的開始與結束必須的相同類型的。
其中三引號可以由多行組成，編寫多行文本的快捷語法，常用於文檔字符串，在文件的特定地點，被當做註釋。

sentence = "這是一個句子。"
paragraph = """這是一個段落。
包含了多個語句"""

3.0.4 Python同一行顯示多條語句

Python可以在同一行中使用多條語句，語句之間使用分號(;)分割，以下是一個簡單的實例：

#!/usr/bin/python
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

3.1 多個文件

在該項目中建立新的Python文件，要想讓哪一個Python程序能夠執行，必須首先通過鼠標右鍵的方式執行一下
對於初學這而言，一個項目中多個執行文件很方便
對於商業項目而言，通常在一個項目中，只有一個可以直接執行的Python源程序

3.2.註釋

註釋的作用：使用用自己熟悉的語言，在程序中對某些代碼進行註釋說明，增強代碼的可讀性

3.2.1單行註釋

以 # 開頭，#右邊的所有東西都被當做說明，而不是真正要執行的程序，只起到輔助說明的作用。
爲保證代碼的可讀性，#後面建議先添加一個空格，然後再編寫相應的說文字
在代碼後面增加單行註釋
在程序開發時，同樣可以使用#在代碼的後面（旁邊）增加說明性文字，但是，需要注意的是，爲保證代碼的可靠性，註釋和代碼之間至少有兩個空格。

3.3.2多行註釋

如果希望編寫的註釋信息很多，一行無法顯示，就可以使用多行註釋
要在python程序中使用多行註釋，可以用一對連續的三個引號（單引號和雙引號都可以）
註釋不是越多越好

3.3 算術運算符

算術運算符是運算符的一種

運算符	描述	實例
+	加	2+2=4
-	減	4-2 =2
*	乘	2*2=4
/	除	4/2=2
//	取整除	9// 4 =2
%	取餘	9%2=1
**	冪	2 ** 3 =8

在Python中 * 運算符還可以用於字符串，計算結果就是字符串重複指定次數的結果

IN: "-" * 10
OUT: ----------

先乘除後加減，從左到右，（）提高優先級
高低順序爲：**，* / % // ，+ -

3.4 計算機中的三大件

CPU
中央處理器，超大規模的集成電路
負責處理數據/計算
內存
臨時存儲數據，斷電後數據會消失
速度塊，空間小（單價高）
硬盤
永久存儲數據，速度慢，空間大（價格低）

3.4.2 程序執行原理

程序運行前，程序是保存在硬盤中的
當要運行一個程序時
操作系統會首先讓CPU把程序複製到內存中
CPU執行內存中的程序代碼

程序執行前，首先要被加載到內存

3.4.3 Python程序的執行原理

1.操作系統首先讓CPU把 Python解釋器的程序複製到內存中
2.Python解釋器根據語法規則，從上向下讓CPU翻譯Python程序中的代碼
3.CPU負責執行翻譯完成的代碼

3.5 變量的基本使用

程序是用來處理數據的，而變量是用來存儲數據的

3.5.1 變量定義

在Python中，每個變量在使用前必須賦值，變量賦值以後纔會被創建
等號（=）用來給變量賦值

= 變量左邊是一個變量名
= 右邊是存儲在變量的值

變量 = 值
變量定義之後，後續就可以直接使用了
在交互式方式，如果要查看變量內容，直接輸入變量名即可，不需要使用print函數
使用解釋器執行，如果要輸出變量的內容，必須要使用print函數

變量名只有在第一次出現纔是定義變量
變量名再次出現時，不是定義變量而是直接使用前面使用過的變量
在程序開發中，可以修改之前定義變量中保存的值

3.5.2 變量的類型

在內存中創建一個變量包括：

1.變量的名稱
2.變量保存的數據
3.變量存儲數據的類型
4.變量的地址（標識）

類型

int 整形
bool 布爾
str 字符串
float 標識小數類型（浮點數）
complex 複數型科學計算
列表 [ ]
元組
字典

Python不需要指定類型，解釋器可以根據=右側的值，自動推斷出變量存儲數據的類型
使用type函數可以查看一個變量的類型

3.5.2 變量的計算

python 2.x中，整數根據保存數值的長度還分爲：int(整型)，long(長整型)
python 3.x中，只有int。

字符之間直接計算（bool True 1，False 0，可參與計算）
字符串之間 + 拼接生成新的字符串
可以和整數使用 * 重複拼接相同的字符串
數字型變量和字符串之間不能進行其他計算

3.5.4 變量的輸入

所謂的輸入，就是用代碼獲取用戶通過鍵盤輸入的信息
在Python中，如果要獲得用戶在鍵盤上的輸入信息，需要用到input函數
關於函數
一個提前準備好的功能（別人或自己寫的代碼），可以直接使用，而不用關心內部的細節
已經涉及到的函數：print(x) ，type(x)
intput 函數實現鍵盤輸入
用戶輸入的任何內容python都認爲是一個字符串
語法如下：
字符變量 = input(“提示信息：”)
類型轉換函數

函數	說明
int(x)	將x轉化爲一個整型
float(x)	將x轉化爲一個浮點數

3.5.5 變量的格式化輸出

在Python中可以使用print函數將信息輸出到控制檯上
如果希望輸出文字的同時一起輸出數量，就需要使用到格式化操作符
%被成爲格式化操作符，專門用於處理字符串的格式：
包含%的字符串，被稱爲格式化字符串
%和不同的字符連用，不同類型的數據需要使用不同的格式話字符

格式化字符	含義
%s	字符串
%d	有符號十進制整數，%06d表示輸出整數顯示的位數，不足的地方補零
%f	浮點數，%.02f表示小數點後面只顯示兩位
%%	輸出%

語法格式如下：
print(“格式化字符串” % 變量1)
print(“格式化字符串” % (變量1 變量2))

name = "大名11"
print("我的名字叫 %s,請多多關照"% name)

3.5.6 變量命名

3.5.6.1 標識符和關鍵字

標識符
標識符：就是程序員定義的變量名，函數名
名字需要有見名知意的作用
標識符可以有字母，下劃線和數字組成
不能以數字開頭，不能與關鍵字重名
關鍵字
關鍵字：就是Python內部已經使用的標識符
關鍵字具有特殊的功能和意義
開發者不允許定義和關鍵字相同名字的標識符
import 關鍵字可以導入一個工具包
在Python中不同的工具包，提供不同的工具

3.5.6.2變量的命名規則

命名規則可以視爲一種慣例，並無絕對和強制
目的是爲了增加代碼的識別和可讀性
注意：Python 中區分大小寫

在定義變量時，爲保證代碼的格式， = 的左右應該各保留一個空格
在Python中，如果變量名需要由兩個或者多個單詞組成，可以按照下列方式命名
每個單詞都使用小寫字母
單詞之間使用下劃線鏈接
還可以使用駝峯命名法
小駝峯：第一個單詞以小寫字母開始，後續單詞的首字母大些
大駝峯：每個單詞的首字母都大寫

3.6 語句

3.6.1 運算符

比較運算符

比較運算符	含義
==
！=
>
<
>=
<=

在Python 2.x中，不等於還可以使用 <> 運算符
邏輯運算符
邏輯運算符可以把多個條件按照邏輯進行連接，變成更復雜的條件
Python中邏輯運算符 與 and/ 或 or/ 非 not 三種
賦值運算符
賦值運算符中間不能有空格

空格	描述	實例
=
+=
-=
*=
/=
//=	整除等於
%=	取餘等於
**=	冪賦值等於

3.6.2 Python中計數方法

自然計數法：從1開始
程序計數法：從0開始
除非有特殊要求，一般計數都從0開始

3.6.3 判斷(if)語句

判斷的定義：
如果條件滿足，才做某件事
如果條件不滿足，就做另一件事或者什麼也不做
判斷語句又被稱爲分支語句

Python中，if語句用來進行判斷，格式如下：

if 條件1：
	條件1成立時，要做的事
	....
elif 條件2：
	條件2滿足時執行
	...
else:
	條件不滿足時，要做的事
	...

if 和 else 語句以及各自的縮進部分共同是一個完成的代碼塊
注意：代碼的縮進爲一個tab鍵，或者4個空格–建議使用空格
在Python中，tab和空格不要混用

3.6.4 循環 -while

程序的三大流程：

順序–自上而下
分之–條件判斷
循環–讓特定代碼重複執行

在Python中構造循環結構有兩種做法，一種是for-in循環，一種是while循環。

while 語句的基本語法：
初始條件設置–通常是重複執行的計數器

while 條件(判斷 計數 是否達到 目標次數)：
	條件滿足時，做事件1
	條件滿足時，做事件2
	....
	處理條件(計數器+1)

while語句以及縮進部分是一個完整的代碼塊
死循環：由於程序員的原因，忘記修改循環的判斷條件，導致循環持續執行，無法終止。
例如：

result = 0
i = 0
while i<=3：
	print(i)
	result += i
	i += 1

while循環嵌套
循環嵌套
while 嵌套就是：while裏面還有while

while 條件1：
	條件滿足時，做事件1
	條件滿足時，作條件2
	...
	while 條件2：
		條件滿足時，做事件1
		條件滿足時，做事件2
		...
		處理條件2
	處理條件1

3.6.4 循環 -for-in循環

如果明確的知道循環執行的次數或者要對一個容器進行迭代（後面會講到），那麼我們推薦使用for-in循環.
例如： 計算1~100求和的結果（ $\displaystyle \sum \limits_{n=1}^{100}n$ ）。

sum = 0
for x in range(101):
    sum += x
print(sum)

需要說明的是上面代碼中的range類型，range可以用來產生一個不變的數值序列，而且這個序列通常都是用在循環中的，例如：

range(101)可以產生一個0到100的整數序列。
range(1, 100)可以產生一個1到99的整數序列。
range(1, 100, 2)可以產生一個1到99的奇數序列，其中的2是步長，即數值序列的增量。

我們可以用下面的代碼來實現1~100之間的偶數求和。

sum = 0
for x in range(2, 101, 2):
    sum += x
print(sum)

3.6.5 break和continue

break和continue是專門在循環中使用的關鍵字
break第一條件滿足時，退出循環，不在執行後續重複的代碼
continue 第一條件滿足時，不執行後續重複的代碼
break和continue只針對當前所在循環有效

3.7 函數基礎

所謂函數，就是把具有獨立功能的代碼塊組織爲一個小模塊，在需要的時候調用
函數的使用包含兩個步驟：
1.定義函數 --封裝獨立的功能
2.調用函數 --享受封裝的成果
函數的作用，在開發程序時，使用函數可以提高編寫的效率以及代碼的重用
下面爲一個簡單案例：

# 在hm_01_九九乘法表.py文件中 函數定義
def multiple_table():
	...
	...

# 另一個.py文件導入
import hm_01_九九乘法表  #導入
hm_01_九九乘法表.multiple_table()  #調用

3.7.1 函數的定義

一般來說，可以通過定義一個函數來隱藏任何計算的細節。一個函數定義需要一個名稱、一組參數和一個函數體。

函數的定義格式如下：

def 函數名():
	函數封裝的代碼
	...

def是英文define的縮寫
函數名應該是能夠表達函數封裝的代碼的功能，方便後續的調用
函數名稱的命名應該符合標識符的命名規則
可以由字母，下劃線和數字組成
不能以數字開頭
不能與關鍵幀重名

3.7.2 函數的使用

調用函數很簡單，通過函數名() 即可完成對函數的調用
在使用函數名調用函數之前，必須保證Python已經知道函數的存在
定義好函數之後，只表示這個函數封裝了一段代碼而已
如果不主動調用函數，函數是不會執行的

3.7.3 pycharm的調試工具

F8 Step Over 可以單步執行代碼，會把函數調用看做是一行代碼直接執行
F7 Step Into 可以單步執行代碼，如果是函數，會進入函數內部

3.7.4 函數的文檔註釋

在開發中，如果希望給函數添加註釋，應該在定義函數的下方使用連續的三隊引號
在連續的三對引號之間編寫對函數的說明文字
在函數調用位置，使用快捷鍵CTRL+Q可以查看函數的說明信息
注意：因爲函數體相對比較獨立，函數定義的上方，應該和其他代碼（包括註釋）保留兩個空行
不要在函數定義的上方增加單行或者多行註釋

print("hello")

def sayHello():
	"""打招呼"""
	print("hello 1")
	print("hello 2")
	print("hello 3")

3.7.5 函數的參數

函數參數的使用
在函數名的後面的小括號內部填寫參數
多個參數之間使用，分割
參數的作用
函數，把具有獨立功能的代碼塊組織爲一個小模塊，在需要的時候調用
函數的參數，增加函數的通用性，針對相同的數據處理邏輯，能夠適應更多的數據

在函數的內部，把參數當做變量使用，進行需要的數據處理
函數調用時，按照函數定義的參數順序，把希望在函數內部出庫的數據，通過參數傳遞

形參和實參*
形參，定義函數時，小括號中的參數，是用來接收參數用的，在函數內部作爲變量使用
實參，調用函數時，小括號中的參數，是用來把數據傳遞到函數內部用的

3.7.6 函數的返回

返回值是函數完成工作就，最後給調用者的一個結果
在函數中使用return關鍵字可以返回結果
調用函數一方，可以使用變量來接收函數的返回結果
注：return表示返回，後續的代碼不會執行

def sum2Num(num1,num2):
	"""
	對兩個數字求和
	：param char：啊啊啊
	：param times: 啊啊啊
	"""
	return num1+num2
num1 = 10
num2 = 20
result = sum2Num(num1,num2)
print("%d 加 %d 結果爲： %d" % (num1,num2,result))

函數的嵌套調用
一個函數裏面，又調用另一個函數，這就是函數的嵌套調用

3.8 使用模塊中的函數

模塊是Python程序架構的一個核心概念

模塊就好比是工具包，要想使用這個工具包中的工具，就需要導入import這個模塊
每一個擴展名.py結尾的Python源代碼文件都是一個模塊
在模塊中定義的全局變量，函數都是模塊能夠提供給外界直接使用的工具

模塊可以讓曾經編寫過的代碼方便被複用

3.8.1 模塊名也是一個標識符

標識符可以由字母、下劃線和數字組成，不能以數字開頭，不能與關鍵字重名
注：如果在給Python文件起名時，以數字開頭是無法在pycharm中導入這個模塊的

3.8.2 pyc

C是complied 編譯過的意思
pyc文件是由Python解釋器將模塊的源碼轉換爲字節碼
Python這樣保存字節碼是作爲一種啓動速度的優化
字節碼

Python在解釋源程序時是分兩個步驟的
1.首先處理源代碼，編譯生成一個二進制字節碼
2.再對字節碼進行處理，纔會生成CPU能夠識別的機器碼
有了模塊的字節碼文件之後，下一次運行程序時，如果在上次保存字節碼之後沒有修改過源代碼，Python將會加載.pyc文件並跳過編譯這個步驟
當Python重編譯時，他會自動檢查源文件和字節碼文件的時間戳
如果你又修改了源代碼，下次程序運行時，字節碼將自動重新創建

3.9 高級變量類型

python中數據類型可分爲數字型和非數字型
數字型
整型 int
浮點型 float
布爾型 bool
複數型 complex（主要用於科學計算，如平面場，波動，電感電容）
非數字型
字符串，列表，元組，字典
在python中，所有非數組型變量都支持以下特點：
1.都是一個序列sequence，也可以理解爲容器
2.取值[]
3.遍歷 for in
4.計算長度，最大/最小值，比較，刪除
5.鏈接+和重複*
6.切片

3.9.1列表

List（列表）是python中使用最頻繁的數據結構，其他語言中叫數組
專門用於存儲一串信息
列表用[]定義，數據之間使用，分隔
列表索引從0開始
注意：從列表中取值時，如果超出索引範圍，程序會報錯

nameList = ["zhangsan","lisi","wangwu"]

列表的常用操作
在ipython3 中定義一個列表，例如：nameList = []
輸入nameList，按下tab鍵，ipython會提示列表所能使用的方法

序號	分類	關鍵字/函數/方法	說明
1	增加	列表.insert（索引，數據）	在指定位置插入數據
		列表.append（數據）	在末尾追加數據
		列表.extend（列表2）	將列表2的數據追加到列表
2	修改	列表[索引]=數據	修改指定索引的數據
3	刪除	del 列表（索引）	刪除指定索引的數據
		列表.remove(數據)	刪除第一個出現的指定數據
		列表.pop	刪除末尾數據
		列表.pop（索引）	刪除指定索引數據
		列表.clear	清空列表
4	統計	len（列表）	列表長度
			列表.count（數據）
5	排序	列表.sort（）	升序排序
		列表.sort(reverse=True)	降序排序
		列表.reverse()	逆序、反轉

關鍵字是python內置的、具有特殊意義的標識符，關鍵字後面不需要使用括號
函數方法區別
函數封裝了獨立的功能，可以直接調用 函數名（）
方法和函數類似，同樣封裝了獨立的功能，方法需要通過對象來調用，表示針對這個對象要做的操作

循環遍歷
遍歷是從頭到尾從列表中獲得數據，在循環體內部針對每一個元素，直行相同的操作
在python中爲提高列表的遍歷效率，專門提供的迭代iteration遍歷。
使用for就能夠實現迭代

nameList = ["zhangsan","lisi","wangwu"]
for name in nameList:
	print("我的名字叫  %s" % name)

range函數
通常與列表一起討論的一個常見的Python函數是range函數，range產生一個範圍對象，表示一些列的值。通過使用list函數，可以將range對象的值看做一個列表。eg:

>>> range(10)
range(0,10)
>>> list(range(10))
[0,1,2,3,4,5,6,7,8,9]

>>>range(5,10)
range(5,10)
>>>list(range(5,10))
[5,6,7,8,9]

>>>list(range(5,10,2))
[5,7,9]

>>>list(range(10,1,-1))
[10,9,8,7,6,5,4,3,2]

range 對象代表一個整數序列。默認情況下，它將從0開始。常用的參數有三個，在特定的點開始和結束，甚至可以跳過某項。

在第一個例子中，（10），序列從0開始，遞增到10但不包括10。

在第二個例子中，範圍（5,10）從5開始，遞增到10但不包括10。

在第三個例子中，範圍（5,10,2）類似的執行，但是跳過2（同樣，10不包括在內）。

3.9.2 元組

Tuple（元組）與列表類似，不同之處在於元組的元素不能修改

元組表示多個元素組成的序列
元組在python開發中，有特定的場景

任何元組都不能被改變。

用於存儲一串信息，數據之間用，分割
元組用（）定義
元組索引從0開始，

info_tuple = ("zhangsan",18,19,1.32)

構建元組 : tuple = ()

注意：元組只包含一個元素時，需要在元素後面添加逗號

>>> myTuple = (2,True,4.96)
>>> myTuple
(2, True, 4.96)
>>> len(myTuple)
3
>>> myTuple[0]
2
>>> myTuple * 3
(2, True, 4.96, 2, True, 4.96, 2, True, 4.96)
>>> myTuple[0:2]
(2, True)

但是，如果試圖改變元組中的一個項，將會得到一個錯誤。注意，錯誤消息提供了問題的位置和原因。

元組有兩個方法：count（元組的個數），index（元素在元組的索引）
元組變量的循環遍歷
在python中使用for循環可以遍歷所有非數字型類型的遍歷

nameList = ("zhangsan","lisi","wangwu")
for name in nameList:
	print("我的名字叫  %s" % name)

函數的參數和返回值，接收任意多個參數，返回多個數據
格式字符串，格式化字符串後面的（）本質是一個元組
讓列表不可以被修改，以保護數據安全

info_tuple = ("小明",21,1.85)
print("%s 年齡是 %d 身高是 %.2f" % info_tuple)
info_str = "%s 年齡是 %d 身高是 %.2f" % info_tuple
print(info_str)

元組列表之間的類型轉換

使用list函數可以把元組轉換成列表
list（元組）
使用tuple函數可以把列表轉換成元組
tuple（列表）

3.9.3 字典

dictionary（字典）是除列表以外python中靈活的數據類型
字典同一可以存儲多個數據，通常用於存儲描述一個物體的相關信息
列表：有序的對象集合
字典：是無序的對象集合
字典用{}定義
字典使用鍵值對存儲數據，健值對之間使用，分割

>>> capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'}
>>> capitals
{'Wisconsin': 'Madison', 'Iowa': 'DesMoines'}

Python集合是一個無序的結構，稱爲字典。字典是一組關聯項，其中每一項由一個鍵和一個值組成。這個鍵-值對通常被寫成 key：value。字典的鍵值對以逗號分隔並用花括號括起來。

鍵 key 是索引
值 value 是數據
鍵和值之間使用：分隔
鍵必須是唯一的
值可以取任何數據類型，但鍵只能使用字符串、數字、元組

xiaoming = {"name"，
			"gender":True,
			"height":1.75}

print(xiaoming["name"])
xiaoming[age] = 20  #新增
xiaoming[name] = "小小明"  #修改
xiaoming.pop("name") #刪除
print(len(xiaoming)) #統計健值對數量
tmp = {"weight":50,"age":18}
xiaoming.update(tmp)  #合併字典  年齡18
print(xiaoming)

字典的常用操作
統計：len(字典) 統計字典中健值對的數量
合併字典：字典.update(字典1)，如果被合併的字典中包含健值對，會覆蓋原來的健值對
清空字典：字典.clear() 清空所有的健值對
循環

xiaoming = {"name"，"gender":True,"height":1.75}
for k in xiaoming:
	print("%s ;%s" % (k,xiaoming[k]))

可以通過它的鍵來訪問它的值，或者通過添加另一個鍵-值對來操作字典。取值語法除了使用鍵值而不是使用項目的索引，看起來很像序列取值，添加新值類似。

>>> capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'}
>>> print(capitals['Iowa'])
DesMoines
>>> capitals['Utah']='SaltLakeCity'
>>> print(capitals)
{'Iowa': 'DesMoines', 'Wisconsin': 'Madison', 'Utah': 'SaltLakeCity'}
>>> capitals['California']='Sacramento'
>>> print(capitals)
{'Iowa': 'DesMoines', 'Wisconsin': 'Madison', 'Utah': 'SaltLakeCity', 'California': 'Sacramento'}
>>> print(len(capitals))
k = 4
>>> for k in capitals:
   		print(capitals[k]," is the capital of ", k)
#打印輸出
DesMoines  is the capital of  Iowa
Madison  is the capital of  Wisconsin
SaltLakeCity  is the capital of  Utah
Sacramento  is the capital of  California

字典既有方法又有操作符，下面兩個表格分別描述了它們：[] , in , del

>>> phoneext={'brad':1137,'david':1410,}
>>> phoneext
{'brad': 1137, 'david': 1410}
>>> phoneext.keys()
dict_keys(['brad', 'david'])
>>> list(phoneext.keys())
['brad', 'david']
>>> phoneext.values()
dict_values([1137, 1410])
>>> list(phoneext.values())
[1137, 1410]
>>> phoneext.items()
dict_items([('brad', 1137), ('david', 1410)])
>>> list(phoneext.items())
[('brad', 1137), ('david', 1410)]

keys、values 和 items 方法都返回包含感興趣的值的對象。而 get 方法有兩種變體，如果字典裏沒有對應鍵，get 將返回空。然而，第二個可選參數可以指定一個返回值。

In [0]: phoneext={'david':1410,'brad':1137}
In [1]: phoneext
Out[1]: {'david': 1410, 'brad': 1137}
In [2]: phoneext.get('kent')
# 返回空說明沒有對應的鍵
In [3]: phoneext.get('kent','NO ENTRY')
Out[3]: 'NO ENTRY'

3.9.4 字符串

字符串就是一串字符，是編程語言中表示文本的數據類型、
在python中使用使用一對雙引號或者一對單引號定義一個字符串

雖然可以使用 " 或者 ’ 做字符串的轉義，但是在實際開發中：

如果字符串內部需要使用 " ，可以使用 ’ 定義字符串

如果字符串內部需要使用 ’ ，可以使用 " 定義字符串

可以使用索引獲取一個字符串中指定位置的字符，索引計數從0開始
也可以使用for循環遍歷字符串中每一個字符
len(字符串)
字符串.count(字符串1) 小字符串出現的個數
字符串.index(字符串1) 小字符串出現的索引

判斷數字

space_str = "   \t\n\r"
print(space_str.isspace()) #輸出True "字符串中僅僅只包含空白字符"

num_str = "1"
# 三個方法都不能判斷使用小數
num_str = "一千零一"
print(num_str.isdecimal()) # 只能判斷數字 false
print(num_str.isdigit())  # 不僅判斷數字，還能判斷Unicode字符串 false
print(num_str.isnumeric()) # 判斷數字，unicode字符串，還能判斷中文數字 true

查找

hello_str = "hello world"

# 1.判斷是否已指定字符串開始  
print(hello_str.startswith(Hello))  # False 大小寫

# 2.判斷是否已指定字符串結束
print(hello_str.endswith(world))  #True

# 3.查找指定字符串 
# index 同樣可以查找指定字符串在大字符串中的索引
print(hello_str.find("llo")  # 2  返回索引
print(hello_str.find("abc")  # -1  無匹配，則返回-1，不會報錯，index會報錯

# 4.替換字符串
# replace方法執行完成之後，會返回一個新的字符串
## 注意：不會修改原有字符串的內容
hello_str.replace("world","Python")

字符串文本對齊方法

方法	說明
string.rjust(width)	返回左對齊字符串
string.rjust(width)	返回右對齊字符串
string.center(width)	返回原字符串居中

poem = ["登鸛雀樓"，
		"王之渙",
		"百日依山盡"]
for poem_str in poem:
	print(pose_str.center(10))
for poem_str in poem:
	print("|%s|" % pose_str.center(10))
for poem_str in poem:
	print("|%s|" % pose_str.center(10," "))

去除空白字符

方法	說明
string.lstrip()	截掉string左邊（開始）的空白字符
string.rstrip()	截掉string右邊（末尾）的空白字符
string.strip()	截掉string兩邊的空白字符

拆分與連接

方法	說明
string.partition(str)	把字符串string分成3元素的元組
string.split(str="",num)	以str爲分隔符拆分string，如果num有指定值，則僅分隔num+1個子字符串，str默認包含 ‘\r’ '\t\ ‘\n’ 和空格
string.splitlines()	按照行（’\r’,’\n’,’\r\n’）分隔，返回一個包含各行作爲元素的列表
string.join(seq)	以string作爲分隔符，將seq中所有的元素（的字符串表示）合併爲一個新的字符串

# 假設一下內容網上抓取，要求：
# 1.將字符串中的空白字符全部去掉
# 2.再使用“ ”作爲分隔符，拼接成一個整齊的字符串
poem_str = "登鸛全樓\t 王之渙\t 白日依山盡\t \n 黃河入海流\t \t"
print(poem_str)

# 1.拆分字符串
poem_list = poem_str.split()
print(poem_list)
# 2.合併字符串
result = " ".join(poem_list)
print(result)

字符串的切片
切片的方法適應於字符串、列表、元組
切片使用索引值來限定範圍，從一個大的字符串中切出小的字符串
列表和元組是有序集合，能夠通過索引值獲得對應的數據
字典是一個無序的集合，是使用鍵值對來保存數據

字符串[開始索引：結束索引：步長]

注意：

指定的區間屬於左閉右開
從頭開始，開始索引數字可以省略，冒號不能省略
到末尾結束，結束索引數字可以省略，冒號不能省略
步長默認爲1，如果連續切片，數組和冒號都可以省略

>>> m = list(range(100))#通過range函數創建一個0-99的數列，組成一個list賦值給m
>>> m
[0, 1, 2, 3, 4, 5, 6, ……,99]

>>> m[:10]#取前十個數
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> m[-10:]#取後十個數
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> m[10:20]#取前11-20個數
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> m[:10:2]#前十個數中，每2個數取一個
[0, 2, 4, 6, 8]
>>> m[5:15:3]#第6-15個數中，每3個數取一個
[5, 8, 11, 14]
>>> m[::10]#所有的數中，每10個數取一個
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> m[:]#什麼都不寫，可以原樣複製一個list
[0, 1, 2, 3, 4, 5, 6, 7,……,99]

3.9.10 集合

set是一個無序的，爲空或是更多不可變的Python數據對象集合。集合中的值不允許重複，寫在大括號中。空集合由 set() 表示。如下所示。

>>> {3,6,"cat",4.5,False}
{False, 4.5, 3, 6, 'cat'}
>>> mySet = {3,6,"cat",4.5,False}
>>> mySet
{False, 4.5, 3, 6, 'cat'}
>>>

儘管集合不被認爲是連續的，但是它們確實支持前面提到的一些熟悉的操作。
eg: in,len,|,&,-,<=

>>> mySet
{False, 4.5, 3, 6, 'cat'}
>>> len(mySet)
5
>>> False in mySet
True
>>> "dog" in mySet
False

集合支持許多方法，這些方法對於在數學集合中使用它們的人來說應該是熟悉的。請注意，聯合，交集，子集和差分都有可以使用的運算符。

>>> mySet
{False, 4.5, 3, 6, 'cat'}
>>> yourSet = {99,3,100}
>>> mySet.union(yourSet)
{False, 4.5, 3, 100, 6, 'cat', 99}
>>> mySet | yourSet
{False, 4.5, 3, 100, 6, 'cat', 99}
>>> mySet.intersection(yourSet)
{3}
>>> mySet & yourSet
{3}
>>> mySet.difference(yourSet)
{False, 4.5, 6, 'cat'}
>>> mySet - yourSet
{False, 4.5, 6, 'cat'}
>>> {3,100}.issubset(yourSet)
True
>>> {3,100}<=yourSet
True
>>> mySet.add("house")
>>> mySet
{False, 4.5, 3, 6, 'house', 'cat'}
>>> mySet.remove(4.5)
>>> mySet
{False, 3, 6, 'house', 'cat'}
>>> mySet.pop()
False
>>> mySet
{3, 6, 'house', 'cat'}
>>> mySet.clear()
>>> mySet
set()

3.10 公共方法

3.10.1 python內置函數

通過函數名直接調用的函數
python包含了以下內置函數：

函數	描述	備註
len(item)	計算容器中元素的個數
del(item)	刪除變量	del有兩種方式
max(item)	返回容器中元素最大值	如果是字典，只針對key比較
min(item)	返回容器中元素最小值	如果是字典，只針對key比較
cmp(item1,item2)	比較兩個值	python 3.x取消

注意：字符串比較符合規則：“0”<“A”<“a”

a = [1,2,3]
del a[1]   # 1  1與2結果一樣
del(a[1])   # 2

3.10.2 切片

描述	python表達	結果	支持的數據類型
切片	“0123456789”[::-2]	“97531”	字符串、列表、元組

切片使用索引值來限定範圍，從一個大的字符串中切出小的字符串
列表和元組都是有序的集合，都能夠通過索引值獲得對應的數據
字典是一個無序的集合，是使用健值對保存數據

3.10.3 運算符

運算符	python表達式	結果	描述	支持的數據類型
+	[1,2]+[3,4]	[1,2,3,4]	合併	字符串，列表，元組
*	[“Hi!”]*4	[“Hi!”,“Hi!”,“Hi!”,“Hi!”]	重複	字符串，列表，元組
in	3 in (1,2,3)	True	元素是否存在	字符串，列表，元組，字典
not in	4 not in (1,3,2)	True	元素不存在	字符串，列表，元組，字典
> >= == <= <	(1,2,3)<(2,2,3)	True	元素比較	字符串，列表，元組

注意

對字典操作時，判斷的是字典的鍵
in 和 not in 被稱爲成員運算符
* 字典不可以，因爲字典的健值是唯一的

3.10.3 完整的for循環語法

在python中完整的for循環的語法如下：

for 變量 in 集合：
	循環體代碼
else：
	沒有通過break退出循環，循環結束後，會執行的代碼

3.11框架搭建

搭建名片管理系統框架結構

準備文件，確保文件名，保證能夠在需要的位置編寫代碼
編寫主運行循環，實現基本的用戶輸入和判斷

3.11.1文件準備

新建cards_main.py保存主程序功能代碼
程序的入口
每一次啓動名片管理都通過這個main這個文件啓動
新建cards_tools.py保存所有名片功能函數
將對名片的新增，查詢，修改，刪除等功能封裝在不同的函數中

3.11.2 案例

cards_main.py中

import cards_tool
while True
	cards_tool.show_menu()

cards_tool.py中

def show_menu():
	"""顯示菜單"""
	print("*" * 50)

3.12 LINUX上的Shebang符號（#！）

#！這個符號叫 Shebang 或者 Sha-bang
Shebang 通常在 Unix系統腳本的中 第一行 使用
指明執行這個腳本文件的解釋程序

3.12.1 使用Shebang的步驟：

使用which 查詢python3解釋器所在路徑
which python3
修改要運行的主python文件，在第一行增加以下內容
#! /usr/bin/python3
修改主python文件的文件權限，增加執行權限
chmod +x cards_main.py
在需要時運行程序即可
./cards_main.py

4.變量進階

4.1 變量的引用

變量和數據都是保存在內存中的
在python中函數的參數傳遞以及返回值都是靠引用傳遞的

4.2 引用的概念

變量和數據是分開存儲的
數據保存在內存中的一個位置
變量中保存着數據在內存中的地址
變量中記錄數據的地址，叫做引用
使用 id() 函數可以查看變量中保存數據所在的內存地址

注意：如果變量已經被定義，當給一個變量賦值的時候，本質上是修改了數據的引用
變量不再對之前的數據引用
變量改爲對新賦值的數據引用

def test(num):
	print("在函數內部%d對應的內存地址是%d" % (num,id(num)))
	result = "hello"
	print("在函數對應的內存地址是%d" % (id(num)))
	return result
a = 10
# 數據的地址本質上就是一個數字
print("a 變量保存數據的內存地址是 % d", % id(a))
# python 中傳遞數值不會將10傳遞過去，只會將10保存的地址傳遞過去
# 調用test函數，本質上傳遞的是實參保存數據的引用，而不是實參保存的數據！
r = test(a)

4.3 可變和不可變類型

不可變類型，內存中的數據不允許被修改

數字類型，int，bool，float，complex，log(2.0)
字符串 str
元組 tuple

可變類型，內存中的數據可以被修改
列表 list
字典 dict 字典中的key 只能使用不可變類型的數據

可變類型的數據變化，是通過方法來實現的
如果給一個可變類型的變量，賦值一個新的數據，引用會修改
變量不再對之前的數據引用
變量改爲對新賦值的數據引用

4.4 局部變量和全局變量

局部變量是在函數內部定義的變量，只能在函數內部使用

全局變量是定義在函數外部定義的變量（沒定義在某一函數內），所有函數內部都可以使用這個變量
局部變量函數體執行後，函數內部的局部變量會被系統收回。作用：在函數體內使用，臨時保存函數內部需要使用的數據

生命週期，從變量被創建到系統回收的過程
注意：函數執行時，需要處理變量時會：

首先查找函數內部是否存在指定名稱的局部變量，如果有，直接使用。
如果沒有，查找函數外部是否存在指定名稱的全局變量，如果有，直接使用
如果沒有，程序報錯

函數不能直接修改全局變量的引用

在其他開發語言中，大多不推薦使用全局變量–可變範圍大沒導致程序崩潰。
爲保證所有的函數都能夠正確使用全局變量，應該將全局變量定義在其他函數的上方。
在函數內部，可以通過全局變量的引用獲取對應的數據
但是，不允許直接修改全局變量的引用–使用賦值語句修改全局變量的值

num = 10
def demo():
	num =999  #重新定義了一個局部變量num
print(num)  #10

調試過程中（debug），變量區域可顯示當前調試中輸出情況。
如何在函數中修改全局變量呢？

num = 10
def demo():
	#global關鍵字會告訴解釋器後面的變量是一個全局變量，在使用賦值語句時，就不會創建局部變量
	global num  
	num =999  #重新定義了一個局部變量num
print(num)  #1

在開發時，應該把模塊中的所有全局變量定義在函數上方，就可以保證所有的函數都能夠正常的訪問到每一個全局變量了。

代碼結構示意圖

shebang	import模塊	全局變量	函數定義	執行代碼

全局變量命名建議

爲了避免變量和全局變量出現混淆，在定義全局變量時，一般在全局變量名前面增加g_或者gl_的前綴
pycharm中修改某一全局變量的全部命名選中該對象，右鍵Refector->Rename

5.函數的高級話題

5.1 函數的參數和返回值的作用

當形參如*arg時表示傳入數組，當形參如**args時表示傳入字典。

def myprint(*commends,**map):   
  for comm in commends:   
  print comm   
  for key in map.keys():   
  print key,map[key]

函數：功能獨立的代碼封裝，通過函數名調用。
參數：外界希望在函數內部處理數據。
返回值：向外界報告函數的執行結果。
函數的返回值就是當函數執行完成後，最後給調用者一個結果。
return

def measure():
	temp =20
	wetness = 30
	#元組-可以包含多個數據，因此可以使用元組讓函數一個返回多個值
	#如果函數返回的類型是元組，小括號可以省略
	return (temp,wetness)
result = measure()
#可以使用多個變量，一次接受函數的返回結果
# 注意：使用多個變量接受結果時，變量的個數應該和元組中元素的個數保持一致
gl_temp,gl_wetness = measure()
print(result)
print(result[0])
print(result[1])

利用元組可以交換兩個數據

a,b = (b,a)
a,b = b,a
#------------------
a = a+b
b = a-b
a= a-b

5.2 不可變參數和可變參數

在函數內部，指針參數使用賦值語句，不會影響調函數時傳遞的實參變量

只要針對參數使用賦值語句，會在函數內部修改局部變量的引用，不會影響到外部變量的引用。
如果傳遞的參數是可變的，在函數內部，使用方法修改了數據的內容，同樣會影響到外部的數據。

def demo(num，num_list):
	num = 100
	# 列表變量使用 += 不會做相加再賦值的操作
	#本質上是在再調用列表的extend方法
	num_list = [1,2,3] 
	print(num)
g_num =99
g_num_list = [4,5,6]
demo(g_num,g_num_list)
print(g_num)    # 輸出 99 
print(num_list)  # 輸出 4,5,6  列表是可變的，但仍然沒改變值

+= 在python中，列表變量調用 += 本質上執行列表變量的 extend 方法，不會修改變量的引用

5.3 缺省參數

定義函數時，可以給某個參數指定一個默認值，具有默認值的參數叫做缺省參數
調用函數時，如果沒有傳入缺省參數，則默認執行默認值。
將常見的值設爲缺省值，可簡化函數的調用。

g_list = [6,3,9]
g_list.sort()  #升序，默認參數
print(g_list)
g_list.sort(reverse=True)  #降序，引入參數

缺省參數在參數列表的末尾
1. 缺省參數，需要使用最常見的值作爲默認值
1. 如果一個參數的值不能確定，則不應該設置默認值，具體的數值在調用函數時，由外界傳遞
調用帶有多個缺省參數的參數
1. 在調用函數時，如果有多個缺省參數，需要指定參數名，這樣解釋器才能夠知道參數的對應關係。

def print_info(name,tile="",gender=True):
	"""
	:param name:班上同學的名字
	:param tile:職位
	:param gender:True 男生 False 女生
	"""
	gender_txt = "男生"
	if not gender:
		gender_test="女生"
	print("%s 是 %s" % (name,gender_test))
#假設班上同學男生居多
print_info("小明")
print_info("老王")
print_info("小美",False)  #  False 直接賦值給第二個
print_info("小美",gender=False)

5.4 多值參數

定義支持多值參數的函數

有時可能需要一個函數能夠處理的參數格式是不確定的，這個時候，就可以使用多值參數
python中有兩種多值參數：
參數名前增加一個*可以接受元組
參數明前增加兩個*可以接受字典
一般在給多值參數命名時，習慣使用一下兩個名字：
*args --存放元組參數，前面一個*
kwarg --存放字典**參數，前面兩個 **
args 是 arguments 的縮寫，有變量的含義
kw是 keyword 的縮寫，kwargs 可以記憶 鍵值對參數

def demo(num,*nums,**person):
	print(num)
	print(nums)
	print(person)

#demo(1)
demo(1,2,3,4,5,name="小美",age=18)
#打印
#1
#(2,3,4,5)
#{name="小美",age=18}

提示： 多值參數 的應用會經常出現在網絡上大牛開發的框架中，知道多值參數，有利於我們讀懂大牛的代碼

def sum_num(*args):
	num = 0
	print(args)
	for n in args:
		num +=n
	return num
result = sum_num(1,2,4,5,6)
print(result)  # 18
# 不使用* 時，需要多指定一組括號
def sum_num(args):
	num = 0
	print(args)
	for n in args:
		num +=n
	return num
result = sum_num((1,2,4,5,6))
print(result)  # 18

5.5 元組和字典的拆包

在調用帶有多值參數的函數時，如果希望：
將一個元組變量，直接傳遞給 args
將一個字典變量，直接傳遞給 kwargs
就可使用拆包，簡化參數的傳遞，拆包的方式是：
在元組變量前面，增加一個 *
在字典變量的前面，增加兩個 *

def demo(*args,**kwargs):
	print(args)
	print(kwargs)
#元組變量/字典變量
g_num = (1,2,3)
g_dict = {"name":"小明","age":19}
demo(gl_num,gl_dict)
# ((1,2,3),{'age':18,'name':'小明'})
# {}
demo(*gl_nums,**gl_dict)
# (1,2,3)
# {'age':18,'name':'小明'}
demo(1,2,3,"name":"小明","age":19)

5.6 函數的遞歸

函數調用自身的編程技巧稱爲遞歸

特點
一個函數調用自己
函數內部可以調用其他函數，也可以調用自己
代碼特點
1.函數內部的代碼是相同的，只是針對參數不同，處理的結果不同
2.當參數滿足一個條件時，函數不再執行。這個非常重要，稱爲遞歸的出口，否則出現死循環

三、面向對象（OOP）

相比函數，面向對象是更大的封裝，根據職責在一個對象中封裝多個方法

1.類和對象

類是對一羣具有相同特徵或行爲的事物的一個統稱，是抽象的，不能直接使用
對象是由類創建出來的一個具體存在，可以直接使用
由哪一個類創建出來的對象，就擁有在哪一個類中定義的：屬性和方法

1.1類和對象的關係

類相當於圖紙，對象相當於用圖紙製造的飛機
類是模板，對象是根據類這個模板創建出來的，應該先有類，再有對象
類只有一個，而對象可能有很多個
類中定義了什麼屬性和方法，對象中就有什麼屬性和方法，不可能多，也不可能少

1.2 類設計

在使用對象開發前，首先應分析需求

類名這類事物的名字，滿足大駝峯命名法
屬性這類事物具有什麼樣的特徵
方法這類事物具有什麼樣的行爲

2 面向對象基礎語法

2.1 dir 內置函數

在python中對象幾乎是無處不在，變量，數據，函數都是對象
在python中可以使用兩個方法驗證：
1.在標識符或數據後面輸入一個 . ，按下tab鍵，ipython會提示該對象能夠調用的方法列表
2.在內置函數 dir 傳入標識符/數據，可查看對象內的所有屬性及方法

提示: 方法名 格式的方法是python提供的 內置方法/屬性

__new__ 創建對象是，會自動調用
__int__ 對象被初始化時，自動被調用
__del__ 對象從內存銷燬前，會被調用
__str__ 返回對象的描述信息，print函數輸出使用

提示：利用 dir() 函數，可查看類的內容

2.2 定義一個簡單類

面向對象是更大的封裝，在一個類中封裝多個方法，這樣通過這個可創建出來的對象，就可以直接調用這些方法了。

2.2.1 定義只包含方法的類

python中定義一個只包含方法的類，語法：

class 類名：
	def 方法1(self，參數)：
		pass
	def 方法2(self,參數)：
		pass

注意：類名的命名規則要符合大駝峯命名法

在Python中可以使用class關鍵字定義類，然後在類中通過之前學習過的函數來定義方法，這樣就可以將對象的動態特徵描述出來，

class Student(object):

    # __init__是一個特殊方法用於在創建對象時進行初始化操作
    # 通過這個方法我們可以爲學生對象綁定name和age兩個屬性
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self, course_name):
        print('%s正在學習%s.' % (self.name, course_name))

    # PEP 8要求標識符的名字用全小寫多個單詞用下劃線連接
    # 但是部分程序員和公司更傾向於使用駝峯命名法(駝峯標識)
    def watch_movie(self):
        if self.age < 18:
            print('%s只能觀看《熊出沒》.' % self.name)
        else:
            print('%s正在觀看島國愛情大電影.' % self.name)

2.2.2 創建對象

當一個類定義完以後，要使用這個類來創建對象，語法：

對象變量 = 類名()

在python 中，使用類創建對象之後，對象變量中仍然記錄的是 對象在內存中的地址
使用print輸出對象變量時，輸出的是這個變量的引用，是由哪個類創建的對象，以及在內存中的地址（十六進制表示） %d 十進制，%x十六進制

2.2.3 方法中的self 參數

在python 中，要給對象設置屬性，非常容易，但不推薦
因爲：對象屬性的封裝應該在類的內部
只需在類的外部的代碼中直接通過 . 設置一個屬性即可。
簡單，但不推薦使用

2.3 初始化方法

之前代碼存在的問題----類的外部給對象增加屬性

不推薦在類的外部給對象增加屬性
如果在運行時，沒有找到屬性，程序會報錯。

對象應該包含哪些屬性，應該封裝在類內部

當使用**類名()**創建對象時，會自動執行下操作
1.爲對象在內存中分配空間–創建對象
2.爲對象屬性初始化–初始化方法（init）
這個初始化方法，就是__init__ 是對象的內置方法
__init__(self,param,param):

2.4 內置方法和屬性

序號	方法名	類型	作用
1	__del__	方法	對象在內存中銷燬前，會自動調用
2	__str__	方法	返回對象的描述信息，print函數輸出使用

__str__ 默認，會輸出這個變量引用的對象是哪一個類創建的對象，以及內存中的地址(十六進制)
如果在開發中，希望用print輸出對象變量時，能夠打印自定義的內容，就可以利用__str__這個內置方法。
注意：__str__ 方法必須返回一個字符串

3 面向對象的支柱

面向對象有三大支柱：封裝、繼承和多態。

3.1 封裝

把數據和對數據的操作封裝起來了，在我們創建了對象之後，只需要給對象發送一個消息（調用方法）就可以執行方法中的代碼，也就是說我們只需要知道方法的名字和傳入的參數（方法的外部視圖），而不需要知道方法內部的實現細節（方法的內部視圖）。

3.1.1 簡單案例

例如：定義一個類描述數字時鐘

from time import sleep


class Clock(object):
    """數字時鐘"""

    def __init__(self, hour=0, minute=0, second=0):
        """初始化方法

        :param hour: 時
        :param minute: 分
        :param second: 秒
        """
        self._hour = hour
        self._minute = minute
        self._second = second

    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def show(self):
        """顯示時間"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)


def main():
    clock = Clock(23, 59, 58)
    while True:
        print(clock.show())
        sleep(1)
        clock.run()


if __name__ == '__main__':
    main()

3.1.2 對象屬性創建另一對象

一個對象的屬性可以是另外一個類創建的對象

class Gun:
	def __init__(self,model):
		self.model = model
		self.bullet_cout = 0
	def add_bullet(self,cout):
		self.bullet_cout +=count
	def shoot(self):
		if self.bullet_cout >0:
			print("fa she zi dan")
			self.bullet_cout -=1
			print("[%s] 突突突" % (self.model,self.bullet_cout))
		else:
			print("%s 沒有子彈了..." % self.model)
class Soldier:
	def __init__(self,name):
		self.name = name
		self.gun = None
AK47 = Gun("ak47")
xusanduo = Soldier("許三多")
xusanduo.gun = ak47

類參數未設置時，可以直接賦值 None

3.1.3 身份運算符

身份運算符用於比較兩個對象的內存地址是否一致，是否是同一對象的引用。

運算符	描述	實例
is	判斷兩個標識符是否是同一個對象	x is y 類似id(x)==id(y)
is not	判斷兩個標識符是不是引用不同對象	x is not y 類似id(x) != id(y)

is 與 == 區別
is 是判斷兩個變量是否一樣
== 判斷兩個值是否相同

3.1.4 私有屬性和私有方法

私有屬性：對象不希望公開屬性
私有方法：對象不希望公開方法

定義方式：

在定義屬性或方法時，在屬性名或方法名前增加兩個下劃線，定義的就是私有屬性或方法

class Women:
	def __init__(self,name):
		self.name = name
		self.__age = 18
	def __secret(self):
		print("我的年齡是 %s" % self.__age)
xiaohua = Women("小花")

僞私有屬性和私有方法
提示：在日常開發中不要使用這種方式，訪問對象的私有屬性或私有方法
python中，沒有真正意義的私有：

在給屬性、方法命名時，實際是對名稱做了一些特殊處理，使得外界無法訪問到
處理方式： 在名稱前面加上 _類名 -> __類名__名稱

class Women:
	def __init__(self,name):
		self.name = name
		self.__age = 18
	def __secret(self):
		print("我的年齡是 %s" % self.__age)
xiaohua = Women("小花")
print(xiaohua._age)  直接報錯
print(xiaohua._Women__age)  可以，但是不推薦

3.2 繼承

3.2.1 單繼承

繼承的語法：

class 類名(父類名):
	pass

子類繼承自父類，可以直接享受父類中已經封裝好的方法
子類應該根據職責，封裝子類特有的屬性和方法

專業術語：

子類父類類繼承
派生類基類類派生

繼承具有傳遞性

class Animal:
	def eat(self):
		print("喫")
	def drink(self):
		print("喝")
	def sleep(self):
		print("睡")

class Dog(Animal):
	def bark(self):
		print("汪汪叫")

class XiaoTiabQuan(Dog):
	def fly(self):
		print("我會飛")
	def bark(self):
		print("小天")

3.2.2 方法的重寫

當父類的方法實現不能滿足子類需求時，可以對方法進行重寫
重寫父類方法的兩種情況：

覆蓋父類的方法
對父類方法進行擴展

覆蓋父類的方法：

在子類中定義跟父類同名的方法，並自己實現
重寫後，在運行時，只會調用子類中重寫的方法，而不會調用父類封裝的方法

對父類方法進行擴展
如果開發中，子類的方法實現中子類方法的一部分
就可使用擴展的方式

在子類中重寫父類的方法
在需要的位置使用 super().父類方法，來調用父類方法的執行
代碼其他的位置針對子類的需求，編寫子類特有的代碼實現

關於super
-在python 中super是一個特殊的類

super() 就是使用super類創建出來的對象
最常使用的場景就是在重寫父類方法時，調用在父類中封裝的方法實現

class Animal:
	def eat(self):
		print("喫")
	def drink(self):
		print("喝")
	def sleep(self):
		print("睡")
	def bark(self):
		print("汪汪叫")

class XiaoTiabQuan(Animal):
	def fly(self):
		print("我會飛")
	def bark(self):
		print("神一樣的叫喚")
		super.bark()
		# Animal.bark(self)    python 2.0
		print("小天")
# input
# 神一樣的叫喚    汪汪叫   小天

3.2.3 私有公有

3.2.4 多繼承

子類可以擁有多個父類，並且具有所有父類的屬性和方法

class A:
class B:
class C(A,B):

父類間存在同名的屬性或方法時，應該避免多繼承
python 中的MRO --方法索索順序
python針對類提供一個內置屬性__mro__可以查看方法搜索順序
MRO 主要用於在多繼承時判斷方法、屬性的調用路徑

print(C.__mro__)

3.2.5 新式類

object 是 python 爲所有對象提供的基類，提供有一些內置的屬性和方法，可以使用dir函數變量
新式類：以object 爲基類的類，推薦使用
經典類：不以 object 爲基準的類，不推薦使用

在python3.x中定義類時，如果沒有指定父類，會默認使用object作爲該類的基類

新式類和經典類在多繼承時–會影響到方法的搜索順序
今後使用時，如果沒有父類，建議統一繼承自object

class 類名(object):
	pass

3.3多態

面向對象的三大特性：

封裝
繼承
實現代碼的重用，相同代碼不用重複寫
多態
不同的子類對象調用相同的父類方法，產生不同的結果。
1.多態增加代碼的林獲悉
2.以繼承和重寫父類方法爲前提
3.是調用方法的技巧，不會影響到類的內部繼承

class Dog(object):
	def __init(self,name)
		self.name = name
   def game(self):
   	print("%s 蹦跳玩耍" % self.name)
class XiaoTianDog(Dog):
   def game(self):
   	print("%s 飛到天上去玩" % self.name)
class Person(object):
   def __init__(self,name):
   	self.name =name
   def game_with_dog(self,dog):
   	print("%s 和 %s 快樂的玩耍" % (self.name,dog.name))
   	# 讓狗玩耍
   	dog.game()

#1.創建狗對象
一，wangcai = Dog("旺財")
二，wangcai = XiaoTianDog("飛天旺財")
#2.創建小明對象
xiaoming = Person("小明")
#3.讓小明調用狗方法
xiaoming.game_with_dog()
#ouput:旺財蹦跳玩耍
#二output: 飛天旺財飛到天上去玩

在每個對象都有自己獨立的內存空間，保存各自不同的屬性。
多個對象的方法，在內存中只有一份，在調用方法時，需要把對象的引用傳遞到方法內部

3.3.1類是一個特殊的對象

python中一切皆對象：

class AAA: 定義的類屬於 類對象
objec1 = AAA() 屬於 實例對象

在python中，類對象在內存中只有一份，使用一個類可以創建多個對象實例
除了封裝實例的屬性和方法外，類對象還可以擁有自己的屬性和方法

類屬性
類方法

class Tool():
	def __init__(self,name):
		self.name = name
		Tool.cout +=1
Tool1 = Tool("futou")
Tool2 = Tool("chuizi")
Tool3 = Tool("tiechui")

print(Tool.count)

對象名點訪問不推薦，可能創建一個新的屬性

3.3.2 定義類方法

# 類方法
@clasmethod
def 類方法名(cls):
	pass

# 類屬性
def __init__(self):
	類名.count +=1

也可通過cls. 訪問類屬性和類方法

3.3.3 靜態方法

在開發中，如果需要在類中封裝一個方法，這個方法：

既不需要訪問實例屬性或調用實例方法
也不需要訪問類屬性或調用類方法

調用語法

@staticmethod
def 靜態方法名():
	pass

通過類名. 可以調用靜態方法

3.3.4 new方法

使用類名() 創建對象時，python解釋器首先會調用 __new__ 方法爲對象分配空間
__new__是一個由object基類提供的內置的靜態方法，主要作用有：
1.在內存爲對象分配空間
2.返回對象的引用
python的解釋器獲得對象的引用後，將引用作爲第一個參數，傳遞給__init__ 方法
重寫__new__方法的代碼非常固定
重寫__new__方法一定要 return super().__new__(cls)
否則python 的解釋器得不到分配空間的對象引用，就不會調用對象的初始化方法
注意：__new__是一個靜態方法，在調用時需要主動傳遞cls參數

class MusicPlayer(object):
	def __new__(cls,*args,**kwargs):
		print("創建對象，分配空間")
		# 爲對象分配空間  2
		instance = super().__new__(cls)
		# 返回對象的引用  2
		return instance
	def __init__(self):
		print("播放器初始化")
#創建播放器對象
player =MusicPlayer()
print(player)
#爲加2 只有1的打印
#創建對象，分配空間  1
#None 1

#增加2 後打印正常
#<__main__.MusicPlayer object at 0x7f9511>

3.3.5單類設計

單例 – 讓類創建的對象，在系統中只有唯一的一個實例

方法

定義一個類屬性，初始值是None，用於記錄單例對象的引用
重寫__new__方法
如果類屬性是is None，調用父類方法分配空間，並在類屬性中記錄結果
返回雷屬性中記錄的對象引用

class MusicPlayer(object):
	#記錄第一個被創建對象的引用
	instance = None
	def __new__(cls,*args,**kwargs):
		#1.判斷類屬性是否是空對象
		if cls.instance is None:
			#2.調用父類的方法，爲一個對象分配空間
			cls.instace = super().__new__(cls)
		#3.返回屬性保存的引用對象
		return cls.instance
	def __init__(self):

		print("播放器初始化")
player1 = MusicPlay(）
print(player1)
player2 = MusicPlay()
print(player2)

# 輸出相同

3.3.5 只初始化一次

在每次使用類名() 創建對象時，python的解釋器都會自動調用兩個方法
1.__new__分配空間
1.__init__對象初始化
在上一節對__new__方法改造後，每次都會得到第一次被創建對象的引用
但是：初始化方法還是會被調用多次

需求：
讓初始化動作只執行一次
解決辦法：

定義一個類屬性init_flag，標記是否執行初始化動作，初始爲False
在__init__方法中，判斷init_flag，如果爲False就執行初始化條件
然後將init_flag設置爲True
這樣，再次自動使用__init__方法時，初始化動作就不會被再次執行了。

四、其他

1.異常

1.1.異常概念

在程序運行時，如果python解釋器遇到一個錯誤，會停止程序的執行，並且提示一些錯誤信息，這就是異常。
程序停止執行並提示錯誤信息這個動作，我們稱爲：跑出異常。
在程序開發中，很難將所有的特殊情況都處理的面面俱到，通過異常可以針對突發世界作出集中的處理，保證程序的穩定性和健壯性。

#提示用戶輸入一個整數
num = int(input("輸入整數:"))
# 輸入非整數時會報錯

1.2.捕獲異常

1.2.1 最簡單的捕獲異常

在程序開發中，如果對某些代碼不能確定是否正確，可以增加 try(嘗試) 來捕獲異常
捕獲異常最簡單的語法格式：

try:
	嘗試執行的代碼
except:
	出現錯誤的處理

try：下方編寫嘗試代碼，不確定是否能夠正常執行的代碼
except：如果不是，下方編寫嘗試失敗的代碼

1.2.2 捕獲未知錯誤：

在開發時，要預判斷到所有可能出現的錯誤，還是由一定的難度
如果希望程序無論出現任何錯誤，都不會因爲python解釋器跑出異常而終止，可以再增加一個except

語法如下：

except Exception as result:
	print("未知錯誤 %s" % result)

例如：

try:
	num = int(input("輸入整數:"))
	result = 8/num
except ValueError:
	print("請輸入正確的整數")
#輸入零時直接涼涼
except Exception as result:
	print("請輸入正確的整數")
#輸入0，輸出：未知錯誤，division by zero

所有錯誤捕獲後，在其後面增加

1.2.3 異常捕獲完整語法

異常捕獲完整語法如下：

try:
	# 嘗試執行的代碼
	pass
except 錯誤類型1：
	#針對錯誤類型1，對應的代碼處理
	pass
except 錯誤類型2：
	#針對錯誤類型2，對應的代碼處理
	pass
except (錯誤類型3,錯誤類型4)：
	#針對錯誤類型3和4，對應的代碼處理
	pass
except Exception as result:
	# 打印錯誤信息
	print(result)
else:
	#沒有異常纔會執行代碼
	pass
finally:
	# 無論有無異常，都會執行的代碼
	print("無論有無異常，都會執行的代碼")

1.3 異常傳遞

異常傳遞 – 當函數/方法執行出現異常時，會將異常傳遞給函數/方法的調用一方
如果傳遞到主程序，仍然沒有異常處理，程序纔會終止

def demo1():
	return int("輸入整數：")
def demo2():
	return demo1()
print(demo2())

提示：

在開發中，可以在主函數中增加異常捕獲
二組主函數調用的其他函數，只要出現異常，都會傳遞到主函數的異常捕獲中
這樣就不需要在代碼中，增加大量的**異常捕獲，能保證代碼的整潔

1.4 拋出 raise 異常

1.4.1 應用場景

在開發中除了代碼執行出錯python解釋器會拋出異常之外
還可以根據應用程序特有的業務需求，主動拋出異常

1.4.2 拋出異常

python 中提供一個Exception異常類
在開發時，如果滿足**特定業務需求時，希望拋出異常，可以：
1.創建一個Exception的對象
2.使用 raise 關鍵字 拋出 異常對象

def input_passward():
	#  1.提示用戶輸入綿綿
	pwd = input("請輸入密碼：")
	# 2. 如果密碼長度大於等於8，返回用戶輸入的密碼
	if len(pwd) >= 8:
		return pwd
	# 3. 如果 <8 主動拋出異常
	print("主動拋出異常")
	# 1>創建異常對象
	ex = Exception("密碼長度不夠")
	# 2>主動拋出異常
	raise ex
 # 提示用戶輸入密碼
 try:
 	print(input_passward())
except Exception as result:
	print(result)

2.模塊

2.1 模塊概念

模塊是python 程序架構的一個核心概念

每一個以py結尾的python 源代碼文件都是一個模塊
模塊名同樣是一個標識符，需要符合標識符的命名規則
在模塊中，定義的全局變量，函數，類都是提供給外界直接使用的工具
模塊好比工具包，要想使用這個工具，就需要先導入這個模塊

2.2 模塊的兩種導入方式

2.2.1 import導入

import 模塊名1，模塊名2

提示：在導入模塊是，每個導入應該獨佔一行

import 模塊名1
import 模塊名2

導入後

通過模塊名. 使用模塊提供的工具 --全局變量，函數，類

使用 as 指定模塊的別名
如果模塊的名字太長，可以使用 as 指定模塊的名稱，以方便在代碼中的使用

import 模塊1 as 模塊別名

注意：模塊別名符合大駝峯命名法

2.2.2 from … import 導入

如果希望從某一模塊中，導入部分工具，就可以使用 form … import 的方式
import 模塊名是一次性把模塊中所有工具全局導入，並且通過模塊名/別名 訪問

from 模塊名1 import 工具名

導入之後

不需要通過模塊名 .
可以直接使用模塊提供的工具 – 全局變量，函數，類

注意：如果兩個模塊，存在同名的函數，那麼後導入模塊的函數，會覆蓋掉先導入的函數

開發時，import 代碼應該統一寫在代碼的頂部，更容易及時發現衝突
一旦發現衝突，可以使用 as 關鍵字給其中一個工具起一個別名
from … import *(知道)

# 從模塊 導入所有工具
from 模塊名1 import *

這個方式不推薦，因爲函數重名並沒有任何提示，出現問題不好排查。

2.2.3 模塊的搜索順序[擴展]

python 的解釋器在導入模塊時，會：

搜索當前目錄指定模塊名的文件，如果有就直接導入
如果沒有，再搜索系統目錄

在開發時，給文件起名，不要和系統的模塊文件重名
python 中每一個模塊都有一個內置屬性__file__ 可以查看模塊的完整路徑

import random
print(random.__file__)
 # 生成一個0-10 的數字
 rand = random.randint(0,10)
 print(rand)

注意：如果當前目錄下，存在一個 random.py 的文件，程序就無法正常運行了

這個時候，python 的解釋器會加載當前目錄下的 random.py 而不會加載系統的 random 模塊

2.3 原則–每一個文件都應該是可以被導入的

一個獨立的 python文件就是一個模塊
在導入文件時，文件中所有沒有任何縮進的代碼都會被執行一遍
注意：全局變量、函數、類，直接執行的代碼不是外界提供的工具
文件被導入時，能夠直接執行的代碼不需要執行

實際開發場景：

在實際開發中，每一個模塊都是獨立開發的，大多都有專人負責
開發人員通常會在模塊下方增加一些測試代碼。

__name__屬性

__name__屬性可以做到，測試模塊的代碼只在測試情況下被運行，而在**被導入時不會執行。
__name__是python的一個內置屬性，記錄着一個字符串
如果是被其他文件導入時，__name__就是模塊名
如果是當前執行的程序，__name__是 __main__

在很多python文件中都會看到以下格式的代碼

#導入模塊
#定義全局變量
#定義類
#定義函數

#在代碼最下方
def main():
	#...
	pass
# 根據__name__判斷是否執行下方代碼
if __name__ =="__main__"
	main()

2.4 包

概念：

包時一個包含多個模塊的特殊目錄
目錄下有一個特殊的文件，__init__.py
包名命名方式和變量名一致，小寫字母+_

好處：

使用 import 包名可以一次性導入包中所有的模塊

__init__.py

要在外界使用包中的模塊，需要在__init__.py中指定對外界提供的模塊列表

 # 從 當前目錄:hh_msg 導入 模塊列表  init文件中導入
 from . import sendMessage
 from . import receiveMessage

外界導入當前包

import hh_msg
 # 測試調用一下 send() 函數在 send_message文件中定義
hh_msg.send_message.send("hello")

2.5 發佈模塊

如果希望自己開發的模塊，分享給他人，可以按照以下步驟操作：

2.5.1 只做發佈壓縮包步驟

1.創建setup.py文件

from distutils.core import setup
setup(name="hh_msg", #包名
	  version="1.0"  #版本
	  description="mayun msg manager 發送和接受模塊" #描述信息
	  long_description="完整的發送與接受模塊"  #完整錯誤信息
	  author="mayun"  #作者
	  author_email="www.mayun.com" #主頁
	  py_modules=["hh_msg.send_message",
	  			  "hh_msg.receive_message"]

2.構建陌路愛

python3 setup.py build

3.生成發佈壓縮包

python3 setup.py sdist

tree時，目錄多了dist目錄，目錄下多了 hh_msg-1.0.tar.gz

2.5.2 安裝模塊

$ tar -zxvf hh_msg-1.0.tar.gz
$ sudo python3 setup.py install

卸載模塊
直接從安裝目錄下，把安裝模塊的目錄刪除就可以了

$ cd /usr/local/lib/python3.5
$ sudo rm -rf hh_msg*

2.6 pip 安裝第三方模塊

第三方模塊通常是指由知名的三方團隊開發的，並且被程序員廣泛使用的python包/模塊。
例如：pygame就是一套非常成熟的遊戲開發模塊
pip是一個現代的，通用的python 包管理工具
提供了對python包的查找，下載，安裝，卸載等功能

安裝卸載命名如下：

#將模塊安裝到 python2.x 環境
sudo pip install pygame
sudo pip uninstall pygame
# 將模塊安裝到 python3.x 環境
sudo pip3 install pygame
sudo pip3 uninstall pygame

3 文件

文件的作用：將數據長期保存下來，在需要的時候使用

3.1 文件的存儲方式

在計算機，文件以二進制的方式保存在磁盤上
文本文件

可以使用文本編輯軟件查案
本質還是二進制文件
例如：python 的源程序

二進制文件

保存的內容不是給人直接閱讀的，而是提供給其他軟件使用的
例如：圖片文件，音頻文件，視頻文件等
二進制文件不能由文件編輯軟件打開

3.2 文件的基本操作

在計算機中操作文件的套路非常固定，一共三個步驟：

打開文件
讀寫文件
關閉文件

操作函數的方法
在python中要操作文件，記住1個函數和3個方法

序號	函數/方法	說明
01	open	打開文件，返回文件的操作對象
02	read	文件內容讀取到內存
03	write	指定內容寫入文件
04	close	關閉文件

如果忘記關閉文件，會造成系統資源消耗，而且會影響到後續對文件的訪問
方法執行後，會把文件指針移動到文件的末尾

file = open("README.mk")
text = file.read()
print(text)
file.close()

在開發中，通常會先編寫打開和關閉的代碼，再編寫中間針對文件的讀/寫操作

文件指針:

文件指針標記從哪個位置開始讀取數據
第一次打開文件時，通常，文件指針會指向文件的開始位置
當執行read方法後，文件指針會移動到讀取內容的末尾
第一次讀取後，文件指針移動到文件末尾，再次調用不會讀取到任何內容

3.3. 打開文件的方式

open函數默認以只讀方式打開文件，並且返回文件對象
語法：

f=open("文件名"，"訪問方式")

訪問方式	說明
r	只讀打開，文件指針會放到文件的開頭，默認模式，文件不存在拋出異常
w	只寫，文件存在會被覆蓋，文件不存在則創建
a	以追加方式打開，文件存在則追加，文件不存在創建新文件進行寫入
r+	以讀寫方式打開，文件指針會放到文件開頭，若未加不存在拋出異常
w+	以讀寫方式打開，文件存在會覆蓋，文件不存在，創建新文件
a+	以讀寫方式打開，文件存在，文件指針放末尾，文件不存在創建文件希爾

頻繁的移動文件指針，會影響文件的讀寫效率，開發中更多的時候會以只讀、只寫的方式來操作文件。

3.4 按行讀取文件內容

read 方法默認會把文件的所有內容一次性讀取到內存
如果內容太大，會對內存的佔用非常嚴重

readline方法

readline 方法可以一次讀取一行內容
方法執行後，會把文件指針移動到下一行，再準備讀取

讀取大文件的正確姿勢

# 打開文件
file = open("readme.txt")

while True:
	# 讀取一行
	text = file.readline()
	# 判斷是否讀到內容
	if not text:
		bread
	# 讀取每一行，末尾加 \n
	print(text,end=" ")
# 關閉文件
file.close()

3.5 文件/目錄的常用管理操作

在終端/文件瀏覽器中可以執行的文件/目錄管理操作，例如：
創建、重命名、刪除、改變路徑、查看目錄內容等。。。
在python中，如果希望通過程序實現上述功能，需要導入os 模塊

文件操作

序號	方法名	說明	示例
01	rename	重命名	os.rename(源文件名，目錄文件名)
02	remove	刪除文件	os.remove(文件名)

目錄操作

序號	方法名	說明	示例
01	listdir	目錄列表	os.listdir(目錄名)
02	mkdir	創建目錄	os.mkdir(目錄名)
03	rmdir	刪除目錄	os.rmdir(目錄名)
04	getcwd	獲取當前目錄	os.getcwd()
05	chdir	修改工作目錄	os.chdir(目標目錄)
06	path.isdir	判斷是否是文件	os.path.dir(文件路徑)

提示：文件或目錄操作都支持相對路徑和絕對路徑

3.6 文本文件的編碼格式

文本文件存儲的內容是基於字符編碼的文件，常用的編碼有ASCII編碼，UNICODE編碼
python 2.x 默認使用 ASCII 編碼
python 3.x 默認使用 UTF-8 編碼

python 2.x 中如何使用中文
在python 2.x 文件的第一行增加以下代碼，解釋器會以 utf-8編碼來處理 python 文件

# *-* coding:utf8 *-*

這是官方推薦的，也可使用

# coding=utf8

unicode 字符串

早python 2.x 中，即使定義了文件使用 UTF-8 的編碼格式，但是在遍歷字符串時，仍會以字節爲單位遍歷字符串
要能夠正確遍歷字符串，在定義字符串時，需要在字符串的引號前，增加一個小寫字母u，告訴解釋器這是一個unicode字符串，使用UTF-8編碼格式的字符串

# codeing=utf8
hello_str = u"hello 世界" #加u後，單獨遍歷會以utf8遍歷
print(hello_Str)
for c in hello_Str:
	print(c)

4 eval 函數

eval() 函數十分強大，–字符串當成有效的表達式來求值並返回計算結果。

# 基本的數據計算
In[0] ：eval("1+1")
out[0]：2

# 字符串重複
In[1] ：eval("'*' * 10")
out[1]：**********

# 字符串轉換成列表
In[2] ：type(eval("[1,2,3,4,5]"))
out[2]：list

# 將字符串轉換成字典
In[3] ：type(eval("{'name':'xiaoming','age':18}"))
out[3]：dict

不要濫用eval

在開發時，千萬不要使用eval 直接轉換 input 的結果

__inport__.('os').system('ls')

等價代碼

import os
os.system('ls')

執行成功，返回0
執行失敗，返回錯誤信息

vi 終端編輯器

1 學習 vi 的目的

工作中，對服務器上文件進行簡單修改，可以使用 ssh 遠程登錄到服務器，並使用vi 進行快速的編輯即可。

常見修改的文件包括

源程序配置文件，例如ssh 的配置文件 ~/.ssh/config
在沒有圖形界面環境下，要編輯文件，vi 是最佳的

2.vi 和 vim

vi 是 visual interface的簡稱，核心思想是 – 讓程序員的手指始終保存在鍵盤的核心，就能完成所有的編輯操作

2.1 打開文件並且定位

vi 文件名 +行數

如果只帶上 + 而不指定行號，會直接定位到文件末尾

2.2 異常處理

如果 vi 異常退出，在磁盤上可能會保存有交換文件
下次再使用vi 編輯該文件時，會看到屏幕信息，按下字母 d 可以 刪除交換文件。

提示：按下鍵盤時，注意關閉輸入法

2.3 三種模式

命令模式 --進行常規的編輯操作，如定位，翻頁，賦值，粘貼，刪除等
在其他圖形界面編輯器下，通過快捷鍵或鼠標實現的操作，都在命令模式下編輯
末行模式 --執行保存、退出等操作
編輯模式 --正常編輯

末行模式

命令	因爲	功能
命令	write	保存
q	quit	退出，如果沒有保存，不允許退出
q!	quit	強行退出，不保存
wq	write&quit	保存並退出
x		保存並退出

3.補充

3.1 3引號換行法

print('''我願意留在湯婆婆的澡堂裏工作兩年，
第一年在鍋爐房和鍋爐爺爺一起燒鍋爐水，
將在這個世界變成一頭豬。
''')

輸出：

我願意留在湯婆婆的澡堂裏工作兩年，
第一年在鍋爐房和鍋爐爺爺一起燒鍋爐水，
將在這個世界變成一頭豬。

變量命名規範：
1、只能是一個詞
2、只能包含字母、數字、下劃線
3、不能以數字開頭
4、儘量描述包含的數據內容
5、不要使用python函數名或關鍵字

五、Python技巧

5.1 創建一維二維數組

創建一維數組
lists = [1] * 3 #空數組創建一維數組每個元素都爲3
last_time1 = [0 for i in range(3)]
創建二維數組
lists = [[] for i in range(3)]
lists = [[]] * 3 #錯誤，[[]]是一個含有一個空列表元素的列表,所以[[]]*3表示3個指向這個空列表元素的引用,修改任何一個元素都會改變整個列表。

python教程學習

python教程學習

一、 ubuntu基本使用

1.簡介

1.1. 目錄

1.2. 常用命令基本使用

1.3 終端命令

1.4 查閱命令幫助信息

2. 文件目錄相關

2.1 通配符的使用

2.2查看 ls

2.3切換 cd

2.4創建和刪除 touch rm mkdir

2.5拷貝和移動文件 cp mv

2.6 文件內容相關cat more grep

2.7.其他: echo 重定向>和>> 管道

3. 遠程管理常用命令

3.1關機/重啓

3.1.1. 基本語法

3.1.2. shutdown

3.1.3. 常用命令

3.2. 查看或配置網卡信息

3.2.1 網卡和ip

3.2.2 ifconfig

3.2.3 ping

3.3 遠程登錄和賦值文件

3.3.1 ssh 基礎（重點）

3.3.2 SSH高級

3.4 用戶權限基本概念

3.4.1超級用戶

3.4.2組管理 終端令

3.4.3 用戶管理 終端令

3.4.4 查看用戶id

3.4.5切換用戶

3.4.6修改文件權限

4.系統信息相關命令

4.1時間和日期

4.2磁盤信息

4.3進程信息

4.4 其他命令

4.4.1 查找文件

4.4.2 軟鏈接

4.4.3打包壓縮

4.4.4 壓縮/解壓縮

4.4.5 軟件安裝

二、Python 簡介

1.Python 科普

2.第一個Python 程序

2.1第一個helloPython程序

2.1.1 Python 中文編碼

2.2 執行Python程序的三種方式

2.2.1解釋器

2.2.2 交互式Python程序

2.2.3 Pycharm

2.3 Pycharm

2.3.1 Pycharm的初始設置

2.3.2 打開新建一個Python項目

3. Python基礎

3.0 Python 基本信息

3.0.1 保留字符

3.0.2 Python多行語句

3.0.3 Python 引號

3.0.4 Python同一行顯示多條語句

3.1 多個文件

3.2.註釋

3.2.1單行註釋

3.3.2多行註釋

3.3 算術運算符

3.4 計算機中的三大件

3.4.2 程序執行原理

3.4.3 Python程序的執行原理

3.5 變量的基本使用

3.5.1 變量定義

3.5.2 變量的類型

3.5.2 變量的計算

3.5.4 變量的輸入

3.5.5 變量的格式化輸出

3.5.6 變量命名

3.5.6.1 標識符和關鍵字

3.5.6.2變量的命名規則

3.4.2組管理終端令

3.4.3 用戶管理終端令