JB的Python之旅-基礎篇-簡明Python教程

須要說明下，此處會以小白角色把知識點列出，但遇到不太瞭解的信息，不會過太多研究，先留個印象~
正文開始，滴滴滴~~~

1.Python的介紹

關於Python
Python是一種極少數能聲言兼具簡單與功能強大的編程語言

Python的特點
簡單、易於學習、自由且開放、高級語言、跨平臺性、解釋性、面向對象、可擴展性、可嵌入性、豐富的庫

2.如何安裝Python

在Windows中安裝
訪問 https://www.python.org/downloads/ 並下載最新版本的 Python，當時看 文檔時最新的版本是Python 3.6.5。安裝過程跟其餘Windows軟件安裝過程無異；

因樓主是win10，因此打開官網的連接默認就是Windows下的文件，若是須要下載Linux或者Mac的話，在上圖紅框那點擊須要的系統後，選擇對應的Python版本下載便可；

在官網下載這個軟件花了快半個小時，爲了節省其餘同窗的時間，須要的同窗能夠點擊下方的連接進行下載（只有Windows的）：

連接：https://pan.baidu.com/s/1RHJil0gv4S66jAufOqLdqg 密碼：oogi

下載完成後打開文件，界面以下，此時有個小細節注意下：

把Add Python 3.6 to PATH 這個選項勾上（默認是不勾的），勾上後，就不須要手動配置環境變量了； 若是須要更換安裝目錄，點擊 Customize installation 選項，點擊 Next 後在安裝位置中輸入自定義目錄，好比D:\python35 。

而後就安裝，安裝完成後看到以下的顯示，就說明安裝成功了；

既然安裝成功了，就來試試吧~ 鍵盤裏安裝win鍵+R，會彈出一個運行框，輸入cmd，點擊回車，就會打開命令行窗口，手動輸入python，只要不報錯，就說明安裝成功了，裏面能看到安裝的Python信息，這樣就說明安裝成功啦~

安裝成功圖

若是沒有安裝Python，而在命令行窗口輸入python的話，就會報下面的錯誤信息：

萬一在安裝時忘記勾上呢？不要緊，手動配置下環境變量便可；這裏假設Python安裝目錄爲C:\Python； 在桌面右擊計算機並選擇屬性或點擊開始並選擇控制面板-系統與安全-系統 。 點擊左側的高級系統設置並選擇高級標籤。點擊底部系統變量下的環境變量，找到 PATH屬性，將其選中並點擊編輯，前往變量值的最後一行並添加 ;C:\Python 便可； 而後重複上面的驗證便可； 這裏有個小細節，安裝完Python後須要從新打開新的命令行窗口才行，不然會報錯；

在 Mac OS 下安裝

對於Mac用戶，你可使用Homebrew並經過命令brew install python3進行安裝。 要想驗證安裝是否成功，你能夠經過按鍵 [Command + Space] （以啓動 Spotlight 搜索），輸 入 Terminal 並按下 [enter] 鍵來啓動終端程序。如今，試着運行 python3 來確保其沒有 任何錯誤。

在 GNU/Linux 下安裝

對於 GNU/Linux 用戶，你可使用發行版的包管理器來安裝 Python 3，例如在 Debian 與 Ubuntu 平臺下，你能夠輸入命令： sudo apt-get update && sudo apt-get install python3 。 要想驗證安裝是否成功，你能夠經過打開 Terminal 應用或經過按下 Alt + F2 組合鍵並輸 入 gnome-terminal 來啓動終端程序。若是這不起做用，請查閱你所使用的的 GNU/Linux 發 行版的文檔。如今，運行 python3 命令來確保其沒有任何錯誤。 你會看到在運行命令後 Python 的版本信息顯示在屏幕上：

$ python3 -V
Python 3.6.5
複製代碼

3.第一個項目及編譯器選擇

hello world
在命令行中輸入python進行到解釋器提示符，而後輸入print("hello world")

怎麼退出解釋器提示符？ 直接輸入exit() 便可~

小知識點：python3.X的print是須要括號，而2.X是不須要括號的

編譯器的選擇-pycharm
pycharm有免費版跟收費版，通常而言，免費版足以~
官網下載連接：http://www.jetbrains.com/pycharm/download/#section=windows 或者度娘找也能夠
下載完畢安裝便可，沒有太特別的點，能夠全默認；安裝完畢就點擊打開~

使用pycharm建立第一個項目
安裝完畢後打開pycharm，會顯示圖1的界面，此時須要點擊「Create New Project"，點擊後會彈出選擇框選擇項目的路徑，可默承認修改，這裏就修改爲jbtest的目錄，而後點擊create~

建立完項目後，對着項目點擊右鍵，選擇NEW，此時會發現能夠建立不少東西，好比目錄，文件，package等，這裏就選擇Python File便可，
點擊後會要求填寫文件名，這裏就能夠自定義輸入啦，這邊輸入的是jb_helloworld，點擊OK後，會自動打開這個文件，而後在文件裏輸入print("jb_hello_world"),
而後在這個文件裏點擊右鍵，選擇RUN文件名，點擊後會發現下方會顯示print裏面的內容，那就恭喜你，第一個項目已經完成啦~
雖然只是幾步，但要記住，之後要建立文件時，就是在對應的項目裏點擊右鍵->New->Python File->輸入文件名就能夠建立啦~

在命令行窗口執行Python文件
剛剛在使用pycharm建立了一個文件，那這個文件在不使用pycharm時是怎麼運行的呢？
通常這種狀況會在命令行窗口執行，直接輸入python 對應文件的絕對路徑，好比python D:\jbtest\jb_helloworld.py,這樣就能在命令行窗口看到這個文件裏的輸出內容啦~

總結：
應該懂的如何編寫、打開Python程序，那接下來，來學習更多的基礎知識吧~

4.Python基礎

1)註釋
註釋是任何存在於#號右側的文案，其做用是給讀者提供信息； 舉個例子：

print("jbtest") #print是一個函數
複製代碼

而通常# 用於單行註釋，而三引號用於多行註釋，以下：

'''這
是
一個
多行註釋
'''
複製代碼

2)字面常量
好比一、二、334這樣的數字或者這是一串文本、This is a string這樣的文本，都成爲字面常量，特色是值不能改變；

3)數字
數字分爲兩種類型：
整數(integers)和浮點數(floats)，好比2是整數，2.123是屬於浮點數；

4)字符串
字符串就是一串詞彙，好比'This is JBtest!'

5)單引號
單引號用於來指定字符串，好比'This is JBtest!'
全部引號內的內容，都會被保留，好比空格、符號等，都會原數保留；

6)雙引號
被雙引號包括的字符串和被單引號包括的字符串的工做機制是同樣的，好比'This is JBtest!' 跟"This is JBtest!"是同樣的內容；

7)三引號
上面講註釋有說起到，三引號(""" or ''')主要用於多行註釋，以下：

'''這個一個多行的字符串，這是它的第一行。
This is second line.
"What is your name?," he asked.
'My name is jb'.
'''
複製代碼

這裏能夠留意，三引號裏面是能夠隨意使用單引號跟雙引號的~

8)字符串是不可變的
記住，字符串一旦被創造了，是沒法改變的。

9)格式化方法
格式化經常使用有兩種方法，好比百分號方法、format方法;
百分號方法：

print("我叫%s，今年%d歲了" % ("jb", 2))
複製代碼

format方法--正常使用：

print("我叫{}，今年{}歲了".format("jb", 2)")
我叫jb，今年2歲了
複製代碼

format方法--經過在括號裏填寫數字，修改格式化的順序：

print("我叫{1}，今年{0}歲了".format("jb", 2))
我叫2歲，今年jb歲了
複製代碼

format方法--經過key取變量：

print("我叫{name}，今年{age}歲了".format(name="jb", age=2))
我叫jb，今年2歲了
複製代碼

10)轉義序列
當須要多行字符串的時候，須要怎麼辦？除了上面說起到的使用三引號以外，可使用\n 這個新一行的轉義序列~

This is first line \n This is second line.
複製代碼

而在這裏，\n就是換行的意思，更多轉義字符信息以下：

轉義字符	做用
行尾的\	續行符
\a	響鈴
\000	空
\t	橫向製表符
\o	八進制數表明字符
\\	反斜槓
\b	退格
\n	換行
\r	回車
\x	十六進制數表明字符
\'	單引號
\e	轉義
\v	縱向製表符
\f	換頁

11)原始字符串
若是須要指定一些未經處理的字符串，好比轉義序列，那就須要在字符串前面增長r或R來指定一個原始(Raw)字符串；

r"Newlines ar indicated by \n"
複製代碼

舒適提示：在處理正則表達式時應全程使用原始字符串，不然將會有大量的Backwhacking須要處理。

12)變量
因常量是不可變的，因此沒法知足更多需求，所以變量就誕生了，變量是能夠儲存任何東西，所以須要爲變量命名。

13)標識符命名
變量是標識符的一個例子。標識符（Identifiers） 是爲 某些東西 提供的給定名稱。在你命名標識符時，你須要遵照如下規則： 第一個字符必須是字母表中的字母（大寫 ASCII 字符或小寫 ASCII 字符或 Unicode 字符）或下劃線（ _ ）。

標識符的其它部分能夠由字符（大寫 ASCII 字符或小寫 ASCII 字符或 Unicode 字符）、下劃線（ _ ）、數字（0~9）組成。

標識符名稱區分大小寫。例如， myname 和 myName 並不等同。要注意到前者是小寫字母 n 然後者是大寫字母 N 。

彙總下：
由字母，數字和下劃線組成，且首字符必須爲字母或下劃線；
Python對大小寫敏感，區分大小寫；

附上網上找的一個命名規則：

1.項目名：首字母大寫，其他小寫，用下劃線增長可讀性，如：Ui_test；
2.包名與模塊名：所有小寫字母；
3.類名：首字母大寫，其他小寫，多個單詞駝峯命名法；
4.方法(函數)名：所有小寫，多個單詞用下劃線分隔；
5.參數名：小寫單詞，若是與關鍵詞衝突，參數名前加上下劃線，好比_print;
6.變量：小寫，多個單詞用下劃線分隔；
7.常量：所有大寫，多個單詞用下劃線分隔
複製代碼

14)數據類型
共6個，分別爲數字、字符串、列表、元組、集合、字典；
其中不可變數據（四個）：
Number（數字）、String（字符串）、Tuple（元組）、Sets（集合）；

可變數據（兩個）：
List（列表）、Dictionary（字典）。

15)對象概念
Python 將程序中的任何內容統稱爲 對象（Object）;
Python 是強（Strongly）面向對象的，由於全部的一切都是對象， 包括數字、字符串與函數。

16)邏輯行與物理行
物理行是你在編寫程序時，你所看到的內容。
邏輯行是Python所看到的單個語句。
Python會假定每一物理行會對應一個邏輯行。

舉個例子：
i = 5
print i
i = i + 5;print 5;
這個例子裏面是有三個物理行，四個邏輯行

例子2
i = i + 5;print 5;
這個例子裏面有一個物理行，2個邏輯行
複製代碼

這裏有個小建議，在Python裏，建議一個物理行對應一個邏輯行，儘可能少用分號~

17)縮進
在Python裏面，縮進是很是很是重要的！！！錯誤的縮進，會走不少彎路，因此不要用記事本寫代碼！！用專業的IDE！
放置在一塊兒的語句必須擁有相同的縮進，舉個例子：

i = 5
#下面將發生錯誤，注意行首有一個空格
 print(i)
print(i+1)

執行後會報錯：
 File "E:/PyCharm Community Edition 2017.2.1/PycharmProjecst/jbtest/jbtest1.py", line 2
 print(i)
 ^
IndentationError: unexpected indent   #縮進錯誤：意外縮進
複製代碼

那怎麼避免因縮進致使沒必要要的問題？
官方的建議是，使用4個空格來縮進，而通常好的編輯器都會自動搞定這一步，無需操做，又或者使用TAB鍵也能夠~

18)運算符
運算符是進行某些操做，而且能夠用諸如 + 等符號或特殊關鍵詞加以表達的功能；

下面是可用運算符的速覽：
+ （加）
    兩個對象相加。
    3+5	則輸出  8 。 
    'a' + 'b'  則輸出  'ab' 。

- （減）
    從一個數中減去另外一個數，若是第一個操做數不存在，則假定爲零。
    -5.2，將輸出一個負數， 
    50 - 24，輸出26。

* （乘）
    給出兩個數的乘積，或返回字符串重複指定次數後的結果。
    2 * 3，輸出6。 
    'la' * 3，輸出'lalala'。

**	（乘方）
    返回 x 的y次方。
    3 ** ，輸出81（即  3 * 3 * 3 * 3 ）。

/	（除）
    x 除以 y
    13 / 3，輸出4.333333333333333。

//	（整除）
    x 除以y並對結果向下取整至最接近的整數。
    13 // 3，輸出4。
    -13 // 3，輸出-5。

%	（取模）
    返回除法運算後的餘數。
    13 % 3，輸出1。
    -25.5 % 2.25，輸出1.5。

<<	（左移）
    將數字的位向左移動指定的位數。（每一個數字在內存中以二進制數表示，即 0 和1） 2 << 2 輸出 8 。 2 用二進制數表示爲10。
    向左移2位會獲得1000,這一結果，表示十進制中的8。

>>	（右移）
    將數字的位向右移動指定的位數。
    11 >> 1	,輸出5 。
    11在二進制中表示爲1011，右移一位後輸101,這一結果，表示十進制中的5。

&	（按位與）
    對數字進行按位與操做。
    5 & 3,輸出1。

|	（按位或）
    對數字進行按位或操做。
    5 | 3,輸出7。

^	（按位異或）
    對數字進行按位異或操做。
    5 ^ 3，輸出6。

~	（按位取反）
    x 的按位取反結果爲 -(x+1)。
    ~5輸出-6 。

<	（小於）
    返回x是否小於y。全部的比較運算符返回的結果均爲 True 或 False 。請注意這些名稱之中的大寫字母。
    5 < 3，輸出False ， 3 < 6 ，輸出True。
    比較能夠任意組成組成連接：3 < 5 < 7，返回  True 。

>	（大於）
    返回x是否大於y。
    5 > 3返回True。若是兩個操做數均爲數字，它們首先將會被轉換至一種共同的類型。不然，它將老是返回False。

<=	（小於等於）
    返回 x 是否小於或等於 y。
    x = 3; y = 6; x<=y，返回True。

>=	（大於等於）
    返回x是否大於或等於y。
    x = 4; y = 3; x>=3，返回True。

==	（等於）
    比較兩個對象是否相等。
    x = 2; y = 2; x == y，返回True。
    x = 'str'; y = 'stR'; x == y，返回False。
    x = 'str'; y = 'str'; x == y，返回True。

!=	（不等於）
    比較兩個對象是否不相等。
    x = 2; y = 3; x != y，返回True。

not	（布爾「非」）
    若是x是True，則返回False 。若是x是False，則返回True 。
    x = True; not x，返回False。

and	（布爾「與」）
    若是x是False，則x and y	返回False，不然返回y的計算值。
    當x是False時，x = False; y = True; x and y將返回False。
    在這一情境中，Python 將不會計算 y，由於它已經瞭解 and 表達式的左側是 False ，這意味着整個表達式都將是 False 而不會是別的值。

or （布爾「或」）
    若是x是True，則返回True，不然它將返回 y 的計算值。
    x = Ture; y = False; x or y將返回Ture。
複製代碼

19)求值順序
在給定的表達式中，Python 將優先計算表中位列於後的較高優先級的運算符與表達式。

優先級	轉義字符	做用
1	lambda	Lambda 表達式
2	if - else	條件表達式
3	or	布爾「或」
4	and	布爾「與」
5	not x	布爾「非」
6	in, not in	成員測試
7	is, is not	統一性測試
8	<, <=, >, >=, !=, ==	比較
9	|	按位或
10	^	按位異或
11	&	按位與
12	<<, >>	移動
13	+, -	加與減
14	*, /, //, %	乘、除、整除、取餘
15	+x, -x, ~x	正、負、按位取反
16	**	求冪
17	x.attribute	屬性參考
18	x[index]	下標
19	x[index:index]	尋址段
20	x(arguments...)	函數調用
21	(expressions...)	綁定或元組顯示
22	[expressions...]	列表顯示
23	{key: value...}	字典顯示
24	{expressions...}	字符串轉換

20)改變運算順序
括號除了能讓表達式更加易懂外，還能改變表達式的運算順序；

2 + 3 * 4，先算乘法再算加法 
(2 + 3) * 4 ，先算加法再算乘法
複製代碼

21)控制流
像這樣的狀況：你須要程序做出一些決定，並依據不一樣的狀況去完成不一樣的事情，例如依據天天時間的不一樣打印出 '早上好' 'Good Morning' 或 '晚上好' 'Good Evening'？
這時候就須要控制流來改變工做順序.
在 Python 中有三種控制流語句—— if、for和while 。

22)if語句
if 語句用以檢查條件：
若是 條件爲真（True），咱們將運行一塊語句（稱做 if-block 或 if 塊），不然 咱們將運行另外一塊語句（稱做 else-block 或 else 塊）。其中 else 從句是可選的。

int_score = int(input("請輸入你的分數")) #input函數是從鍵盤讀入一個字符串,int是爲了把輸入的字符串強轉int類型
if(int_score > 90):
    print("優")
elif 80 <= int_score <= 90:
    print("良")
elif 60 <= int_score < 80:
    print("中")
else:
    if int_score < 60 :
        print("差")
        
輸出結果：
請輸入你的分數：20
差
複製代碼

而elif語句將兩個相連的 if else-if else 語句合併成一句 if-elif-else 語句。這可以使程序更加簡便。

若是在if裏面命中了條件，但內部又不想處理，能夠輸入pass便可，pass是個空語句，不作任何事情

23)while
while語句可以在條件爲真的前提下重複執行某塊語句。
while 語句一樣能夠擁有 else 子句做爲可選選項。

i = 8;
while i < 10:
    print(i);
    i = i + 1;
else:
    print("end of while");  
    
輸出結果：
8
9
end of while 
複製代碼

小提醒：在while/for的循環裏面，若是想中斷循環有2種方式：break跟continue~
二者區別在於，break是跳出整個循環，而continue是跳出本次循環，後面會說明~

24)for
for...in 語句是另外一種循環語句，其特色是會在一系列對象上進行迭代，意思是會遍歷序列中的每個項目。

for i in range(1, 5):   #range返回的是一個整數列表
    print(i)
else:
    print('The for loop is over')
    
輸出的結果：
1
2
3
4
The for loop is over
複製代碼

for循環裏也能夠用break跟continue跳出循環哦~

25)break語句
break 語句用以中斷循環語句，也就是停止循環語句的執行，即 else 塊都將不會被執行；

for letter in 'Python':  # 第一個實例
if letter == 'h':
    break
print('當前字母 :', letter)

輸出結果：
當前字母 : P
當前字母 : y
當前字母 : t
複製代碼

26)continue語句
continue 語句用以告訴 Python 跳過當前循環塊中的剩餘語句，並繼續該循環的下一次迭代；

for letter in 'Python':  
if letter == 'h':
    continue
print('當前字母 :', letter)

輸出結果：
當前字母 : P
當前字母 : y
當前字母 : t
當前字母 : o
當前字母 : n
複製代碼

27)函數
函數是指可重複使用的程序片斷，容許爲某個代碼塊賦予名字，容許經過這一特殊的名字在你的程序任何地方來運行代碼塊，並可重複任何次數。上面的學習也用到不少內置函數，好比len、range。
函數能夠經過關鍵字 def 來定義。
這一關鍵字後跟一個函數的標識符名稱，再跟一對圓括號，其中能夠包括一些變量的名稱，再以冒號結尾，結束這一行。

def say_hello():#	該塊屬於這一函數
    print('hello world')
#	函數結束
say_hello()	# 調用函數

輸出的結果是：
hello world
複製代碼

28)函數參數
函數中的參數經過將其放置在用以定義函數的一對圓括號中指定，並經過逗號予以分隔。
在定義函數時給定的名稱稱做形參，在調用函數時你所提供給函數的值稱做實參。

def print_max(a, b):
    if a > b:
        print(a, 'is maximum')
    elif a == b:
        print(a, 'is equal to', b)
    else:
        print(b, 'is maximum')
#	直接傳遞字面值
print_max(3, 4)
x = 5
y = 7
#	以參數的形式傳遞變量
print_max(x, y)

輸出的結果：
4 is maximum
7 is maximum
複製代碼

29)局部變量
你在一個函數的定義中聲明變量時，它們不會以任何方式與身處函數以外但具備相同名稱的變量產生關係。
也就是說，這些變量名只存在於函數這一局部。這被稱爲變量的做用域。
全部變量的做用域是它們被定義的塊，從定義它們的名字的定義點開始。

x = 50
def func(x):
    print('x is', x)
    x = 2
    print('Changed local x to', x)
func(x)
print('x is still', x)

輸出的結果：
x is 50
Changed local x to 2
x is still 50
複製代碼

30)global 變量
若是想給一個在程序頂層的變量賦值，而且不受其餘做用域的影響，那可使用global來告訴程序是全局變量；

x = 50
def func(x):
    global x
    print('x is', x)
    x = 2
    print('Changed local x to', x)
func(x)
print('x is still', x)

輸出的結果：
x is 50
Changed local x to 2
x is still 2
複製代碼

31)默認參數值
對於一些函數來講，可能會但願使一些參數可選並使用默認的值，以免用戶不想爲他們提供值的狀況。
默認參數值能夠有效幫助解決這一狀況。

def say(message,times=1):
    print(message*times)
say('Hello')
say('World',5)

輸出的結果：
Hello
WorldWorldWorldWorldWorld
複製代碼

32)關鍵字參數
若是有較多的函數，又但願只對其中的一些進行指定，那麼能夠經過命名它們來給這些參數賦值——這就是關鍵字參數
好處時：
再也不須要考慮參數的順序，函數的使用將更加容易。
能夠只對那些但願賦予的參數以賦值，只要其它的參數都具備默認參數值。

def func(a,b=5,c=10):
    print('a is ',a,' and b is ',b,' and c ic ',c)
func(3,7)
func(25,c=24)
func(c=50,a=100)    

輸出的結果：
a is  3  and b is  7  and c ic  10
a is  25  and b is  5  and c ic  24
a is  100  and b is  5  and c ic  50
複製代碼

33)可變參數
可變參數就是傳入的參數個數是可變的，能夠是1個、2個到任意個，還能夠是0個；
在Python裏，帶*的參數就是用來接受可變數量參數的。

def funcD(a, b, *c):
  print(a)
  print(b)
  print("length of c is: %d " % len(c))
  print(c)
funcD(1,2,3,4,5,6,7,8,9)    
    
輸出的結果：
1
2
length of c is: 7 
(3, 4, 5, 6, 7, 8, 9)
複製代碼

前面兩個參數被a、b接受了，剩下的7個參數，所有被c接受了，c在這裏是一個tuple（元組）。
在調用funcD的時候，至少要傳遞2個參數，2個以上的參數，都放到c裏了，若是隻有兩個參數，那c就是empty tuple。

若是一個函數定義中的最後一個形參有 **（雙星號）前綴,全部正常形參以外的其餘的關鍵字參數都將被放置在一個字典中傳遞給函數

def func(a,**b):
    print(a)
    for x in b:
        print(x+':'+str(b[x]))
func(100,c='你好',b=200)    

輸出的結果：
100
c:你好
b:200
複製代碼

b是一個dict對象實例，它接受了關鍵字參數b和c

34)return語句
return 語句用於從函數中返回，也就是中斷函數。
咱們也能夠選擇在中斷函數時從函數中返回一個值。

def maximum(x,y):
    if x>y:
        return x
    elif x == y:
        return  'The numbers are equal'
    else:
        return y
print(max(2,3))

輸出的結果：
3
複製代碼

35)DocStrings
Python有一個很奇妙的特性，稱爲 文檔字符串 ，它一般被簡稱爲 docstrings。
DocStrings是一個重要的工具，因爲它幫助你的程序文檔更加簡單易懂，應該儘可能使用它。
甚至能夠在程序運行的時候，從函數恢復文檔字符串！

def print_max(x,y):
    '''打印兩個數值中的最大數。

    這兩個數都應該是整數'''
    # 若是可能，將其轉換至整數類型
    x = int(x)
    y = int(y)

    if x > y:
        print(x,'is maximum')
    else:
        print(y,'is maximum')
print_max(3,5)
print(print_max.__doc__)

輸出的結果：
5 is maximum
打印兩個數值中的最大數。

這兩個數都應該是整數
複製代碼

36)模塊
Python 模塊，是一個 Python 文件，以 .py 結尾，包含了 Python 對象定義和Python語句。
模塊讓你可以有邏輯地組織你的 Python 代碼段。
把相關的代碼分配到一個模塊裏能讓你的代碼更好用，更易懂。
模塊能定義函數，類和變量，模塊裏也能包含可執行的代碼。

support.py 模塊：
def print_func( par ):
    print "Hello : ", par
    return
複製代碼

37)import語句
塊定義好後，咱們可使用 import 語句來引入模塊，語法以下：

import module1[, module2[,... moduleN]
複製代碼

好比要引用模塊 math，就能夠在文件最開始的地方用 import math 來引入。

# 導入模塊
import support

# 如今能夠調用模塊裏包含的函數了
support.print_func("Runoob")

輸出的結果：
Hello : Runoob
複製代碼

38)from..import語句
Python 的 from 語句讓你從模塊中導入一個指定的部分到當前命名空間中。語法以下：

from modname import name1[, name2[, ... nameN]]
複製代碼

例如，要導入模塊 fib 的 fibonacci 函數，使用以下語句：

from fib import fibonacci
複製代碼

這個聲明不會把整個 fib 模塊導入到當前的命名空間中，它只會將 fib 裏的 fibonacci 單個引入到執行這個聲明的模塊的全局符號表。

39)模塊的 name
每一個模塊都有一個名稱，而模塊中的語句能夠找到它們所處的模塊的名稱。
這對於肯定模塊是獨立運行的仍是被導入進來運行的這一特定目的來講大爲有用。

if __name__ == '__main__':
    print('This program is being run by itself')
else:
    print('I am being imported from another module')

輸出的結果：
$ python module_using_name.py
This program is being run by itself

$ python
>>> import module_using_name
I am being imported from another module
複製代碼

40)包
包是指一個包含模塊與一個特殊的 init.py 文件的文件夾，包是一種可以方便地分層組織模塊的方式。

41)dir函數
Python中內置的dir函數用於顯示模塊中定義的標識符的， 包括函數、變量、類等;
dir()函數的參數能夠是模塊，也能夠是類、函數等

dir() 函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；
帶參數時，返回參數的屬性、方法列表。若是參數包含方法__dir__()，該方法將被調用。

>>> dir(sys)
['__displayhook__', '__doc__','argv', 'builtin_module_names','version', 'version_info']

#	此處只展現部分條目

#	給出當前模塊的屬性名稱

>>> dir()

['__builtins__', '__doc__','__name__', '__package__','sys']
複製代碼

42)數據結構
數據結構是一種結構，可以將一些數據聚合在一塊兒。換句話說，它們是用來存儲一系列相關數據的集合。
Python 中有四種內置的數據結構——列表（List）、元組（Tuple）、字典（Dictionary）和集合（Set）。

43)列表
列表是一種用於保存一系列有序項目的集合
列表能夠修改，而字符串和元組不能

下面是一些關於列表的方法介紹：

方法	描述
list.append(x)	把一個元素添加到列表的結尾，至關於 a[len(a):] = [x]
list.extend(L)	經過添加指定列表的全部元素來擴充列表，至關於 a[len(a):] = L
list.insert(i, x)	在指定位置插入一個元素。第一個參數是準備插入到其前面的那個元素的索引，例如 a.insert(0, x) 會插入到整個列表以前，而 a.insert(len(a), x) 至關於 a.append(x)
list.remove(x)	刪除列表中值爲 x 的第一個元素。若是沒有這樣的元素，就會返回一個錯誤
list.pop([i])	從列表的指定位置刪除元素，並將其返回。若是沒有指定索引，a.pop()返回最後一個元素。元素隨即從列表中被刪除
list.clear()	移除列表中的全部項，等於del a[:]
list.index(x)	返回列表中第一個值爲 x 的元素的索引。若是沒有匹配的元素就會返回一個錯誤
list.count(x)	返回 x 在列表中出現的次數
list.sort()	對列表中的元素進行排序
list.reverse()	倒排列表中的元素
list.copy()	返回列表的淺複製，等於a[:]

44)有關對象與類的快速介紹
列表是使用對象與類的實例。
當啓用一個變量 i 並將整數 5 賦值給它時，能夠認爲這是在建立一個 int 類（即類型）之下的對象（即實例）i 。

45)元組
元組（Tuple）用於將多個對象保存到一塊兒。
元組的一大特徵相似於字符串，它們是不可變的，也就是說，你不能編輯或更改元組。

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
複製代碼

元組在輸出時老是有括號的，以便於正確表達嵌套結構。

元組是經過特別指定項目來定義的，在指定項目時，你能夠給它們加上括號，並在括號內部用逗號進行分隔。
元組一般用於保證某一語句或某一用戶定義的函數能夠安全地採用一組數值，意即元組內的數值不會改變。

46)字典
字典以關鍵字爲索引，關鍵字能夠是任意不可變類型，一般用字符串或數值。
理解字典的最佳方式是把它看作無序的鍵=>值對集合。在同一個字典以內，關鍵字必須是互不相同。
一對大括號建立一個空的字典：{}。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
複製代碼

構造函數 dict() 直接從鍵值對元組列表中構建字典。若是有固定的模式，列表推導式指定特定的鍵值對：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
複製代碼

47)序列
序列的主要功能是資格測試（也就是 in 與 not in 表達式）和索引操做，它們可以容許咱們直接獲取序列中的特定項目

48)集合
集合是一個無序不重複元素的集。基本功能包括關係測試和消除重複元素。
能夠用大括號({})建立集合。
注意：若是要建立一個空集合，你必須用 set() 而不是 {} ；後者建立一個空的字典，下一節咱們會介紹這個數據結構。 如下是一個簡單的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 刪除重複的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 檢測成員
True
>>> 'crabgrass' in basket
False

>>> # 如下演示了兩個集合的操做
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 中惟一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 在 a 中的字母，但不在 b 中
{'r', 'd', 'b'}
>>> a | b                              # 在 a 或 b 中的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 在 a 和 b 中都有的字母
{'a', 'c'}
>>> a ^ b                              # 在 a 或 b 中的字母，但不一樣時在 a 和 b 中
{'r', 'd', 'b', 'm', 'z', 'l'}
複製代碼

49)面向對象編程
在至今編寫的全部程序中，曾圍繞函數設計的程序，也就是那些可以處理數據的代碼塊。這被稱做面向過程的編程方式。
類與對象是面向對象編程的兩個主要方面。

簡介	描述
類	用來描述具備相同的屬性和方法的對象的集合。它定義了該集合中每一個對象所共有的屬性和方法。對象是類的實例。
類變量	類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體以外。類變量一般不做爲實例變量使用。
數據成員	類變量或者實例變量, 用於處理類及其實例對象的相關的數據。
方法重寫	若是從父類繼承的方法不能知足子類的需求，能夠對其進行改寫，這個過程叫方法的覆蓋（override），也稱爲方法的重寫。
實例變量	定義在方法中的變量，只做用於當前實例的類。
繼承	即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也容許把一個派生類的對象做爲一個基類對象對待。
實例化	建立一個類的實例，類的具體對象。
方法	類中定義的函數。
對象	經過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

50)self
類的方法與普通的函數只有一個特別的區別——它們必須有一個額外的第一個參數名稱, 按照慣例它的名稱是 self。
self 表明的是類的實例，表明當前對象的地址，而 self.class 則指向類。
self 不是 python 關鍵字。

51)類
使用 class 語句來建立一個新類，class 以後爲類的名稱並以冒號結尾:

class Person:
    pass	# 一個空的代碼塊
p = Person()
print(p)
複製代碼

52)方法
類與對象一如函數那般均可以帶有方法（Method），惟一的不一樣在於咱們還擁有一個額外的 self 變量。

class Person:
    def say_hi(self):
        print('Hello, how are you?')
p = Person()
p.say_hi()
複製代碼

53)__init__方法
__init__ 方法會在類的對象被實例化時當即運行。
這一方法能夠對任何你想進行操做的目標對象進行初始化操做。
這裏你要注意在 init 先後加上的雙下劃線。

class Person:
    def __init__(self, name):
        self.name = name
    def say_hi(self):
        print('Hello, my name is', self.name)
p = Person('Swaroop')
p.say_hi()
複製代碼

54)類變量與對象變量
字段有兩種類型——類變量與對象變量。
類變量在整個實例化的對象中是公用的。<br 對象變量由類的每個獨立的對象或實例所擁有。

55)繼承
面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是經過繼承機制。
繼承徹底能夠理解成類之間的類型和子類型關係。
須要注意的地方：繼承語法 class 派生類名（基類名）：//...
基類名寫在括號裏，基本類是在類定義的時候，在元組之中指明的。
在python中繼承中的一些特色：
1：在繼承中基類的構造（__init__()方法）不會被自動調用，它須要在其派生類的構造中親自專門調用。
2：在調用基類的方法時，須要加上基類的類名前綴，且須要帶上self參數變量。區別在於類中調用普通函數時並不須要帶上self參數
3：Python老是首先查找對應類型的方法，若是它不能在派生類中找到對應的方法，它纔開始到基類中逐個查找。（先在本類中查找調用的方法，找不到纔去基類中找）。
若是在繼承元組中列了一個以上的類，那麼它就被稱做"多重繼承" 。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Parent:  # 定義父類
    parentAttr = 100

    def __init__(self):
        print("調用父類構造函數")

    def parentMethod(self):
        print('調用父類方法')

    def setAttr(self, attr):
        Parent.parentAttr = attr

    def getAttr(self):
        print("父類屬性 :", Parent.parentAttr)


class Child(Parent):  # 定義子類
    def __init__(self):
        print("調用子類構造方法")

    def childMethod(self):
        print('調用子類方法')


c = Child()  # 實例化子類
c.childMethod()  # 調用子類的方法
c.parentMethod()  # 調用父類方法
c.setAttr(200)  # 再次調用父類的方法 - 設置屬性值
c.getAttr()  # 再次調用父類的方法 - 獲取屬性值

輸出的結果：
調用子類構造方法
調用子類方法
調用父類方法
父類屬性 : 200
複製代碼

56)輸入與輸出
但願獲取用戶的輸入內容，並向用戶打印出一些返回的結果，能夠分別經過 input() 函數與 print 函數來實現這一需求。
對於輸入，還可使用str（String，字符串）類的各類方法。
另外一個常見的輸入輸出類型是處理文件。建立、讀取與寫入文件對於不少程序來講是必不可少的功能。

57)用戶輸入內容

#把輸入的文本進行翻轉，若是翻轉先後都一致，則認爲是迴文
def reverse(text):
    return text[::-1]
def is_palindrome(text):
    return text == reverse(text)

something = input("Enter text: ")
if is_palindrome(something):
    print("Yes, it is a palindrome")
else:
    print("No, it is not a palindrome")

輸出的結果：
Enter text: jbj
Yes, it is a palindrome
複製代碼

58)文件
能夠經過建立一個屬於 file 類的對象並適當使用它的read 、 readline 、 write 方法來打開或使用文件，並對它們進行讀取或寫入。
當完成了文件，能夠調用 close 方法來告訴 Python 已經完成了對該文件的使用。

jb = "if you make your work also fun: use python~"
#打開文件編輯
f = open("jb.txt",'w')
#向文件中編寫文本
f.write(jb)
#關閉文件
f.close()

#若是沒有特別指定，
#將假定啓用默認的閱讀（'r'ead）模式
f = open("jb.txt")
while True:
    line = f.readline()
    #長度爲零，就中斷
    if len(line) == 0:
        break
    print(line,end='')
f.close()

輸出的結果：
if you make your work also fun: use python~
複製代碼

打開模式能夠是閱讀模式（ 'r' ），寫入模式（ 'w' ）和追加模式（ 'a' ）

59)Pickle2
Python 提供了一個叫做 Pickle 的標準模塊，經過它你能夠將任何純 Python 對象存儲到一個文件中，並在稍後將其取回。
在機器學習中，經常須要把訓練好的模型存儲起來，也是能夠用Pickle這個模塊把數據存儲~

import pickle

jb = 'jb'
jblist = ['apple','mango','carrot']

f = open(jb,'wb')
#存入已經打開的file中
pickle.dump(jblist,f)
f.close()

del jblist

f = open(jb,'rb')
#將file中的對象序列化讀出
storedlist = pickle.load(f)
print(storedlist)

輸出的結果：
['apple', 'mango', 'carrot']
複製代碼

60)Unicode
當咱們閱讀或寫入某一文件或當咱們但願與互聯網上的其它計算機通訊時，咱們須要將咱們的 Unicode 字符串轉換至一個可以被髮送和接收的格式，這個格式叫做「UTF-8」。

#	encoding=utf-8 import io
f = io.open("abc.txt", "wt", encoding="utf-8")
f.write(u"Imagine non-English language here")
f.close()
text = io.open("abc.txt", encoding="utf-8").read()
print(text)
複製代碼

61)異常
當想要讀取一個文件時，而那個文件卻不存在，怎麼辦？
又或者在程序執行時不當心刪除了，怎麼辦？
這些經過使用異常來進行處理。

62)錯誤
能夠想象一個簡單的 print 函數調用。
若是把 print 誤拼成 Print 會怎樣？
會注意到它的首字母是大寫。
在這一例子中，Python 會拋出（Raise）一個語法錯誤。

>>>	Print("Hello World") Traceback (most recent call last):
File "<stdin>", line 1, in <module> NameError: name 'Print' is not defined
>>>	print("Hello World")
Hello World
複製代碼

會注意到一個 NameError 錯誤被拋出，同時 Python 還會打印出檢測到的錯誤發生的位置。
這就是一個錯誤處理器 爲這個錯誤所作的事情。

63)處理異常
能夠經過使用 try..except 來處理異常情況。
通常來講會把一般的語句放在 try 代碼塊中，將錯誤處理器代碼放置在 except 代碼塊中。

try:
    text = input('Enter something --> ')
except EOFError:
    print('Why did you do an EOF on me?')
except KeyboardInterrupt:
    print('You cancelled the operation.')
else:
    print('You entered {}'.format(text))
複製代碼

64)拋出異常
能夠經過 raise 語句來引起一次異常，具體方法是提供錯誤名或異常名以及要拋出（Thrown）異常的對象。
可以引起的錯誤或異常必須是直接或間接從屬於 Exception （異常） 類的派生類。

import traceback
 
def throw_error():
  raise Exception("拋出一個異常")#異常被拋出，print函數沒法執行
  print("jb")
   
throw_error()

輸出的結果：
    Traceback (most recent call last):
  File "E:/PyCharm Community Edition 2017.2.1/PycharmProjecst/jbtest/jbtest1.py", line 9, in <module>
    throw_error()
  File "E:/PyCharm Community Edition 2017.2.1/PycharmProjecst/jbtest/jbtest1.py", line 5, in throw_error
    raise Exception("拋出一個異常")  # 異常被拋出，print函數沒法執行
Exception: 拋出一個異常
複製代碼

65)Try ... Finally
假設正在讀取一份文件。應該如何確保文件對象被正確關閉，不管是否會發生異常？這能夠經過 finally 塊來完成。

import sys
import time

f = None
try:
    f = open("poem.txt")
    #	咱們經常使用的文件閱讀風格
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print(line, end='')
        sys.stdout.flush()
        print("Press ctrl+c now")
        #	爲了確保它能運行一段時間
        time.sleep(2)
except IOError:
    print("Could not find file poem.txt")
except KeyboardInterrupt:
    print("!! You cancelled the reading from the file.")
finally:
    if f:
        f.close()
    print("(Cleaning up: Closed the file)")
複製代碼

66)with語句
使用with後無論with中的代碼出現什麼錯誤，都會進行對當前對象進行清理工做。

with open("jb.txt") as f:
for line in f:
    print(line, end='')
複製代碼

67)標準庫
Python標準庫中包含了大量有用的模塊，同時也是每一個標準的 Python 安裝包中的一部分.
熟悉 Python 標準庫十分重要，由於只要你熟知這些庫能夠作到什麼事，許多問題都可以輕易解決。

68)sys模塊
sys模塊包括了一組很是實用的服務，內含不少函數方法和變量，用來處理Python運行時配置以及資源;

函數	描述
sys.argv	命令行參數List，第一個元素是程序自己路徑
sys.modules.keys()	返回全部已經導入的模塊列表
sys.exc_info()	獲取當前正在處理的異常類,exc_type、exc_value、ext_traceback當前處理的異常詳細信息
sys.exit(n)	退出程序，正常退出時exit(0)
sys.hexversion	獲取Python解釋程序的版本值，16進制格式如：0x020403F0
sys.version	獲取Python解釋程序的版本信息
sys.maxint	最大的Int值
sys.maxunicode	最大的Unicode值
sys.modules	返回系統導入的模塊字段，key是模塊名，value是模塊
sys.path	返回模塊的搜索路徑，初始化時使用Pythonpath環境變量的值
sys.platform	返回操做系統平臺名稱
sys.stdout	標準輸出
sys.stdin	標準輸入
sys.stderr	錯誤輸出
sys.exc_clear()	用來清除當前線程所出現的當前的或最近的錯誤信息
sys.exec_prefix	返回平臺獨立的Python文件安裝的位置
sys.byteorder	本地字節規則的指示器，big-endian平臺的值是'big'，little-endian平臺的值是'little'
sys.copyrighte	記錄Python版權相關的東西
sys.api_version	解釋器的C的API版本
sys.getdefaultencoding()	返回當前所用的默認字符編碼格式
sys.getfilesystemencoding()	返回將Unicode文件名轉換成系統文件名的編碼的名字
sys.setdefaultencoding(name)	用來設置當前默認的字符編碼
sys.builtin_module_names	Python解釋器導入的模塊列表
sys.executable	python解釋程序路徑
sys.getwindowsversion()	獲取Windows的版本
sys.stdin.readline()	從標準輸入讀一行，
sys.stdout.write("a")	屏幕輸出a

69)日誌模塊
若是想將一些調試信息或一些重要的信息儲存在某個地方，以即可以檢查程序是否如所指望那般運行，應該怎麼作？
應該如何將這些信息「儲存在某個地方」？這能夠經過 logging 模塊來實現。

import logging

logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')

輸出的結果：
WARNING:root:This is warning message
複製代碼

70)傳遞元組
只需使用一個元組，就能達到從一個函數返回兩個不一樣的值

def get_error_details():
    return (2, 'details')
errnum, errstr = get_error_details()
print(errnum)
print(errstr)

輸出的結果：
2
details
複製代碼

Python 中交換兩個變量的最快方法是

a=5;b=6
a,b = b,a
print(a)
print(b)

輸出的結果：
6
5
複製代碼

71)特殊方法

方法	描述
__init__(self, ...)	這一方法在新建立的對象被返回準備使用時被調用
__del__(self)	這一方法在對象被刪除以前調用（它的使用時機不可預測，因此避免使用它）
__str__(self)	當咱們使用 print 函數時，或 str() 被使用時就會被調用
__lt__(self, other)	當小於運算符（<）被使用時被調用。相似地，使用其它全部運算符（+、> 等等）時都會有特殊方法被調用
__getitem__(self, key)	使用 x[key] 索引操做時會被調用
__len__(self)	當針對序列對象使用內置 len() 函數時會被調用

72)單語句塊
若是語句塊只包括單獨的一句語句，那麼能夠在同一行指定它

flag = True
if flag: print('Yes')
複製代碼

73)Lambda表格
lambda語句能夠建立一個新的函數對象,是一個匿名函數;
從本質上說， lambda 須要一個參數，後跟一個表達式做爲函數體，這一表達式執行的值將做爲這個新函數的返回值。

g = lambda x : x ** 2
print g(3)

輸出的結果：
9
複製代碼

74)列表推導
列表推導用於從一份現有的列表中獲得一份新列表;
例子：如今已經有了一份數字列表，想獲得一個相應的列表，其中的數字在大於 2 的狀況下將乘以2。列表推導就是這類狀況的理想選擇。

listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2]
print(listtwo)

輸出的結果：
[6,8]
複製代碼

75)assert語句
assert 語句用以斷言某事是真的
例如說很是肯定正在使用的列表中至少包含一個元素，並想確認這一點，若是其不是真的，就拋出一個錯誤， assert 語句就是這種狀況下的理想選擇。
當語句斷言失敗時，將會拋出 AssertionError 。

mylist = ['item']
assert len(mylist) >= 1
mylist.pop()
assert len(mylist) >= 1

輸出的結果：
Traceback (most recent call last):
  File "C:/Users/jb/PycharmProjects/jbtestprojects/testplay.py", line 4, in <module>
    assert len(mylist) >= 1
AssertionError
複製代碼

76)裝飾器
裝飾器是應用包裝函數的快捷方式~
舉個例子：

def cal(x, y):
    result = x + y
    return result
複製代碼

這裏有個函數，假若有N個這樣的函數，若是想每一個函數執行時順帶執行下Log操做，就變成這樣了

def cal(x, y):
        logging.info("111")
        result = x + y
        return result
        
    def cal1(x, y):
        logging.info("2222")
        result = x + y
        return result
複製代碼

這樣暴露一個問題，假若有N個函數，那個都在裏面加一個print()，不須要時再手動刪除，是很是痛苦的事情，這時候，裝飾器就有用了；

def log(func):
    def wrapper(*arg,**kw):
        logging.warn("%s " % func.__name__)
        return
    return wrapper()

@log
def cal(x, y):
    result = x + y
    return result
    
@log
def cal1(x, y):
    result = x + y
    return result  
複製代碼

之後只須要在執行前輸入@函數名便可，大體就是這樣啦~

77)小貼士
在使用python過程，須要用到各類各樣第三方庫，以前樓主是每一個手動安裝，各類環境（windows\linux）等，痛不欲生！可是，出現轉折啦~

在使用pycharm發現能夠快速安裝所須要的庫，不須要本身額外安裝，很是方便！
File->Settings>Projects Interpreter，右側有個+號，點擊後輸入對應須要的庫，點擊install便可，是否是很是方便啊啊！！！

結語
陸陸續續的，花了2周多的時間把這書啃完而後再回頭整理出來，回頭看，感受算是比較適合新手閱讀，講的點不算特別深，固然也不太詳細，只能留個印象，後面確定是要深刻了解的~
可是，這本書講的順序很是亂，所以筆記也跟着一塊兒亂了。。。跳躍式閱讀。。

後續計劃
按照以前定的計劃，接下來會看笨方法學python、廖雪峯3.0教程、Python核心編程第三篇，可是因爲時間的關係，會作下調整，下一步會的目標是2個：
爬蟲跟利用python作接口自動化
而上面說起到的3本書也會閱讀而且輸出，但不會像這篇同樣講太多基礎的內容，還請各位見諒~

文章連接以下：
簡明python教程

最後，整理了下腦圖，供參考，射射你們~