Python基礎入門筆記（一）

時間  2019-11-16
標籤 python 基礎 入門 筆記 欄目 Python 简体版
原文   原文鏈接

前言（認識Python）

既然學習 Python，那麼至少得了解下這門語言，知道 Python 代碼執行過程吧。Python 的歷史有興趣的百度百科下就有，這個很少說了。html

一、咱們先來了解下什麼是解釋型語言和編譯型語言？java

計算機是不可以識別高級語言的，因此當咱們運行一個高級語言程序的時候，就須要一個「翻譯機」來從事把高級語言轉變成計算機能讀懂的機器語言的過程。這個過程分紅兩類，第一種是編譯，第二種是解釋。python

編譯型語言在程序執行以前，先會經過編譯器對程序執行一個編譯的過程，把程序轉變成機器語言。運行時就不須要翻譯，而直接執行就能夠了。最典型的例子就是 C 語言。git

解釋型語言就沒有這個編譯的過程，而是在程序運行的時候，經過解釋器對程序逐行做出解釋，而後直接運行，最典型的例子是 Ruby。程序員

經過以上的例子，咱們能夠來總結一下解釋型語言和編譯型語言的優缺點，由於編譯型語言在程序運行以前就已經對程序作出了「翻譯」，因此在運行時就少掉了「翻譯」的過程，因此效率比較高。可是咱們也不能一律而論，一些解釋型語言也能夠經過解釋器的優化來在對程序作出翻譯時對整個程序作出優化，從而在效率上超過編譯型語言。web

此外，隨着 Java 等基於虛擬機的語言的興起，咱們又不能把語言純粹地分紅解釋型和編譯型這兩種。用 Java 來舉例，Java 首先是經過編譯器編譯成字節碼文件，而後在運行時經過解釋器給解釋成機器文件。因此咱們說 Java 是一種先編譯後解釋的語言。再換成 C#，C# 首先是經過編譯器將 C# 文件編譯成 IL 文件，而後在經過 CLR 將 IL 文件編譯成機器文件。因此咱們說 C# 是一門純編譯語言，可是 C# 是一門須要二次編譯的語言。同理也可等效運用到基於 .NET 平臺上的其餘語言。express

二、那麼 Python 究竟是什麼？編程

其實 Python 和 Java、C# 同樣，也是一門基於虛擬機的語言，咱們先來從表面上簡單地瞭解一下 Python 程序的運行過程。flask

當咱們在命令行中輸入 python hello.py 時，實際上是激活了 Python 的「解釋器」，告訴「解釋器」：你要開始工做了。但是在「解釋」以前，其實執行的第一項工做和 Java 同樣，是編譯。vim

熟悉 Java 的讀者能夠想一下咱們在命令行中如何執行一個 Java 的程序：

javac hello.java
java hello
複製代碼

只是咱們在用 Eclipse 之類的 IDE 時，將這兩部給融合成了一部而已。其實 Python 也同樣，當咱們執行python hello.py時，它也同樣執行了這麼一個過程，因此咱們應該這樣來描述 Python，Python 是一門先編譯後解釋的語言。

三、簡述 Python 的運行過程

在說這個問題以前，咱們先來講兩個概念，PyCodeObject 和 pyc 文件。

咱們在硬盤上看到的 pyc 天然沒必要多說，而其實 PyCodeObject 則是 Python 編譯器真正編譯成的結果。咱們先簡單知道就能夠了，繼續向下看。

當 Python 程序運行時，編譯的結果則是保存在位於內存中的 PyCodeObject 中，當 Python 程序運行結束時，Python 解釋器則將 PyCodeObject 寫回到 pyc 文件中。

當 Python 程序第二次運行時，首先程序會在硬盤中尋找 pyc 文件，若是找到，則直接載入，不然就重複上面的過程。

因此咱們應該這樣來定位 PyCodeObject 和 pyc 文件，咱們說 pyc 文件實際上是 PyCodeObject 的一種持久化保存方式。

更詳細內容參考：說說Python程序的執行過程

最後：

  • 「人生苦短，我用Python」

  • Python 的設計哲學是「優雅」、「明確」、「簡單」。

1、變量和字符串

首先：Python 每一個語句結束能夠不寫分號 ;， 如 print('hello') 打印 hello

1.1 變量

有過編程基礎的話，變量就不用多說了。

變量的命名法：

  • 駝峯式命名法
  • 帕斯卡命名法

1.2 字符串

一、基本介紹

單引號 ' '或者雙引號 " " 均可以，再或者 ''' ''' 三個引號，其中三個引號被用於過於長段的文字或者是說明，只要是三引號不完你就能夠隨意換行寫下文字。

①字符串直接能相加，如：

str1 = 'hi'
str2 = 'hello'
print(str1 + str2)
複製代碼

運行結果：

hi jaybo
複製代碼

②字符串相乘，如：

string = 'bang!'
total = string * 3 
複製代碼

打印 total 結果：

bang!bang!bang!
複製代碼

二、字符串的分片與索引

字符串能夠經過 string[x] 的方式進行索引、分片。

字符串的分片實際能夠看做是從字符串中找出來你要截取的東西，複製出來一小段你要的長度，存儲在另外一個地方，而不會對字符串這個源文件改動。分片得到的每一個字符串能夠看做是原字符串的一個副本。

先看下面這段代碼：

name = 'My name is Mike'
print(name[0])
'M'
print(name[-4])
'M'
print(name[11:14]) # from 11th to 14th, 14th one is excluded
'Mik'
print(name[11:15]) # from 11th to 15th, 15th one is excluded
'Mike'
print(name[5:])
'me is Mike'
print(name[:5])
'My na'
複製代碼

若是感到困惑話，能夠對照以下表格理解和分析：

:兩邊分別表明着字符串的分割從哪裏開始，併到哪裏結束。

以name[11:14]爲例，截取的編號從第11個字符開始，到位置爲14但不包含第14個字符結束。而像name[5:]這樣的寫法表明着從編號爲5的字符到結束的字符串分片。相反，name[:5]則表明着從編號爲0的字符開始到編號爲5但包含第5個字符分片。可能容易搞混，能夠想象成第一種是從5到最後面，程序員懶得數有多少個因此就省略地寫，第二種是從最前面到5，一樣懶得寫0，因此就寫成了[:5]。

三、字符串的方法

  • replace 方法：第一個參數表示被替代部分，第二個參數表示替代成怎樣的字符串。

  • 字符串填空，如：

    city = input("write the name of city:"")
url = "http://apistore.baidu.com/mri.../weather?citypiny={}.format(city)
複製代碼

四、問題

問題1：

num = 1
string = '1'
print(num + string)
複製代碼

上面代碼將出錯？

解釋：整數型不能和字符串直接相加。能夠先把該字符串轉爲整數型，再相加，即 int(string)

num = 1
string = '1'
print(num + int(string))
複製代碼

2、函數

舉些你可能已經使用過的函數例子：

判斷數據類型：type(str) 
字符串類型數據轉爲整數型：int(str)
...
複製代碼

經過觀察規律不難發現，Python 中所謂的使用函數就是把你要處理的對象放到一個名字後面的括號就能夠了。簡單的來講，函數就是這麼使用，能夠往裏面塞東西獲得處理結果。這樣的函數在 Python 中還有這些：

以 Python3.5 版本爲例，一個有 68 個這樣的函數，它們被稱爲內建函數。這裏內建的是指這些函數爲安裝好了 Python 就可使用。

2.1 函數格式

定義函數的格式：

其中，def 和 return 爲關鍵字。

注意： 函數縮進後面的語句被稱爲是語句塊，縮進是爲了表名語句的邏輯與從屬關係。縮進這個問題不能忽視，不然會致使代碼沒法成功運行，這裏須要特別注意。

2.2 函數參數

①位置參數，舉例，看代碼：

def trapezoid_area(base_up, base_down, height):
    return 1/2 * (base_up + base_down) * height
複製代碼

接下來咱們開始調用該函數：

trapezoid_area(1,2,3)
複製代碼

不難看出，填入的參數1，2，3分別對應着參數 base_up，base_down 和 height。這種傳入參數的方式被稱做爲位置參數。

②關鍵詞參數：在函數調用的時候，將每一個參數名稱後面賦予一個咱們想要傳入的值，如調用 fun1 函數時候：fun1(a=1, b=2, c=3)。

看下圖：

  • 第一行的函數參數按照反序傳入，由於是關鍵詞參數，因此並不影響函數正常運做；
  • 第二行的函數參數反序傳入，可是到了第三個卻變成了位置函數，遺憾的是這種方式是錯誤的語法，由於若是按照位置來傳入，最後一個應該是參數 height 的位置。可是前面 height 已經按照名稱傳入了值3，因此是衝突的。
  • 第三行的函數參數正序傳入，前兩個是以關鍵字的方式傳入，最後一個以位置參數傳入，可是位置參數不能再關鍵詞參數後面，因此是錯誤的。
  • 第四行的函數參數正序傳入，前兩個是以位置的方式傳入，最後一個以關鍵字參數傳入，這個函數是能夠正常運行的。

③不定長參數

有時咱們在設計函數接口的時候，可會須要可變長的參數。也就是說，咱們事先沒法肯定傳入的參數個數。

Python 提供了一種元組的方式來接受沒有直接定義的參數。這種方式在參數前邊加星號 * 。若是在函數調用時沒有指定參數，它就是一個空元組。咱們也能夠不向函數傳遞未命名的變量。例如：

def print_user_info( name , age , sex = '男' , * hobby):
    # 打印用戶信息
    print('暱稱：{}'.format(name) , end = ' ')
    print('年齡：{}'.format(age) , end = ' ')
    print('性別：{}'.format(sex) ,end = ' ' )
    print('愛好：{}'.format(hobby))
    return;

# 調用 print_user_info 函數
print_user_info( '小明' , 25, '男', '打籃球','打羽毛球','跑步')
複製代碼

輸出的結果：

暱稱：小明 年齡：25 性別：男 愛好：('打籃球', '打羽毛球', '跑步')
複製代碼

經過輸出的結果能夠知道，* hobby 是可變參數，且 hobby 其實就是一個 tuple （元祖）。

可變長參數也支持關鍵參數，沒有被定義的關鍵參數會被放到一個字典裏。這種方式便是在參數前邊加 **，更改上面的示例以下：

def print_user_info( name , age , sex = '男' , ** hobby ):
    # 打印用戶信息
    print('暱稱：{}'.format(name) , end = ' ')
    print('年齡：{}'.format(age) , end = ' ')
    print('性別：{}'.format(sex) ,end = ' ' )
    print('愛好：{}'.format(hobby))
    return;

# 調用 print_user_info 函數
print_user_info( name = '小明' , age = 25 , sex = '男', hobby = ('打籃球','打羽毛球','跑步'))
複製代碼

輸出的結果：

暱稱：小明 年齡：24 性別：男 愛好：{'hobby': ('打籃球', '打羽毛球', '跑步')}
複製代碼

經過對比上面的例子和這個例子，能夠知道，* hobby 是可變參數，且 hobby 其實就是一個 tuple （元祖），** hobby是關鍵字參數，且 hobby 就是一個 dict （字典）。

④ 只接受關鍵字參數

關鍵字參數使用起來簡單，不容易參數出錯，那麼有些時候，咱們定義的函數但願某些參數強制使用關鍵字參數傳遞，這時候該怎麼辦呢？將強制關鍵字參數放到某個*參數或者單個*後面就能達到這種效果,好比：

def print_user_info( name , *, age, sex = '男' ):
    # 打印用戶信息
    print('暱稱：{}'.format(name) , end = ' ')
    print('年齡：{}'.format(age) , end = ' ')
    print('性別：{}'.format(sex))
    return;

# 調用 print_user_info 函數
print_user_info( name = '小明' ,age = 25 , sex = '男' )

# 這種寫法會報錯，由於 age ，sex 這兩個參數強制使用關鍵字參數
#print_user_info( '小明' , 25 , '男' )
print_user_info('小明',age='22',sex='男')
複製代碼

經過例子能夠看，若是 age , sex 不適用關鍵字參數是會報錯的。

2.3 匿名函數

有沒有想過定義一個很短的回調函數，但又不想用 def 的形式去寫一個那麼長的函數，那麼有沒有快捷方式呢？

——答案是有的。

Python 使用 lambda 來建立匿名函數，也就是再也不使用 def 語句這樣標準的形式定義一個函數。

匿名函數主要有如下特色：

  • lambda 只是一個表達式，函數體比 def 簡單不少。
  • lambda 的主體是一個表達式，而不是一個代碼塊。僅僅能在 lambda 表達式中封裝有限的邏輯進去。
  • lambda 函數擁有本身的命名空間，且不能訪問自有參數列表以外或全局命名空間裏的參數。

基本語法：lambda [arg1 [,arg2,.....argn]]:expression

示例：

sum = lambda num1 , num2 : num1 + num2;
print( sum( 1 , 2 ) )
複製代碼

輸出的結果： 3

注意：儘管 lambda 表達式容許你定義簡單函數，可是它的使用是有限制的。 你只能指定單個表達式，它的值就是最後的返回值。也就是說不能包含其餘的語言特性了， 包括多個語句、條件表達式、迭代以及異常處理等等。

匿名函數中，有一個特別須要注意的問題，好比，把上面的例子改一下：

num2 = 100
sum1 = lambda num1 : num1 + num2 ;

num2 = 10000
sum2 = lambda num1 : num1 + num2 ;

print( sum1( 1 ) )
print( sum2( 1 ) )
複製代碼

你會認爲輸出什麼呢？第一個輸出是 101，第二個是 10001，結果不是的，輸出的結果是這樣：

10001
10001
複製代碼

這主要在於 lambda 表達式中的 num2 是一個自由變量，在運行時綁定值，而不是定義時就綁定，這跟函數的默認值參數定義是不一樣的。因此建議仍是遇到這種狀況仍是使用第一種解法。

3、循環與判斷

3.1 布爾表達式和判斷

Python 中的布爾類型值：True 和 Flase 其中，注意這兩個都是首字母大寫。

但凡可以產生一個布爾值的表達式爲布爾表達式：

1 > 2 # False
1 < 2 <3 # True
42 != '42' # True
'Name' == 'name' # False
'M' in 'Magic' # True
number = 12
number is 12 # True
複製代碼

注1：不一樣類型的對象不能使用<、>、<=、=>進行比較，卻可使用==和!=。

注2：浮點類型和整數類型雖然是不一樣類型，但不影響比較運算。還有，不等於!= 能夠寫做<> 。

話說，布爾類型能夠比較嗎？如：True > Flase，回答是能夠的，Ture 和 Flase 對於計算機就像是 1 和 0 同樣，因此結果是真，即True。

3.2 條件控制

定義格式：

用一句話該結構做用：若是...條件是成立的，就作...；反之，就作...

所謂條件成立，指的是返回值爲True的布爾表達式。

3.3 循環

①for 循環

把 for 循環所的事情歸納成一句話就是：於...其中的每個元素，作...事情。

打印九九乘法表：

for i in range(1, 10):
    for j in range(1, i+1):
        print('{}x{}={}\t'.format(i, j, i*j), end='')
    print()
複製代碼

運行結果：

1x1=1
2x1=2   2x2=4
3x1=3   3x2=6   3x3=9
4x1=4   4x2=8   4x3=12  4x4=16
5x1=5   5x2=10  5x3=15  5x4=20  5x5=25
6x1=6   6x2=12  6x3=18  6x4=24  6x5=30  6x6=36
7x1=7   7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49
8x1=8   8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64
9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81
複製代碼

②while 循環

總結：只要...條件一成立，就一直作...

在循環過程當中，可使用 break 跳過循環，使用 continue 跳過該次循環。

在 Python 的 while 循環中，可使用 else 語句，while … else 在循環條件爲 false 時執行 else 語句塊。如：

count = 0
while count < 3:
   print (count)
   count = count + 1
else:
   print (count)
複製代碼

運行結果：

0
1
2
3
複製代碼

有 while … else 語句，固然也有 for … else 語句，for 中的語句和普通的沒有區別，else 中的語句會在循環正常執行完（即 for 不是經過 break 跳出而中斷的）的狀況下執行，while … else 也是同樣。如：

for num in range(10,20):  # 迭代 10 到 20 之間的數字
   for i in range(2,num): # 根據因子迭代
      if num%i == 0:      # 肯定第一個因子
         j=num/i          # 計算第二個因子
         print ('%d 是一個合數' % num)
         break            # 跳出當前循環
   else:                  # 循環的 else 部分
      print ('%d 是一個質數' % num)
複製代碼

運行結果：

10 是一個合數
11 是一個質數
12 是一個合數
13 是一個質數
14 是一個合數
15 是一個合數
16 是一個合數
17 是一個質數
18 是一個合數
19 是一個質數
複製代碼

4、數據結構

Python 有四種數據結構，分別是：列表、字典、元組、集合。咱們先從總體上認識一下這四種數據結構：

list = [val1,val2,val3,val4] #列表
dict = {key1:val1,key2:val2} #字典
tuple = (val1,val2,val3,val4) #元組
set = {val1,val2,val3,val4}	#集合
複製代碼

4.1 列表（List）

  1. 列表中的每一個元素都是可變的；

  2. 列表中的元素是有序的，也就是說每一個元素都有一個位置；

  3. 列表中能夠容納 Python 中的任何對象。以下：

    all_in_list = [
    1, #整數
    1.0, #浮點數
    'a word', #字符串
    print(1), #函數
    True, #布爾值
    [1,2], #列表中套列表
    (1,2), #元祖
    {'key':'value'} #字典
]
複製代碼

另外，對於數據的操做，最多見的爲增刪改查。在此就省略了，網上找下相應函數練習下便可。

4.2 字典（Dict）

  1. 字典中數據必須是以鍵值對的形式出現的；

  2. 邏輯上講，鍵是不能重複的；

  3. 字典中的鍵（key）是不可變的，也就是沒法修改的，而值（value）是可變的，可修改的，能夠是任何對象。

    下面是個例子：

    NASDAQ_code = {
    'BIDU':'Baidu',
    'SINA':'Sina',
    'YOKU':'Youku'
}
複製代碼

一個字典中鍵與值並不能脫離對方而存在，若是你寫成了 {'BIDU':} 會引起一個語法錯誤：invalid syntax。

若是試着將一個可變（mutable）的元素做爲 key 來構建字典，好比列表：key_test = {[]:'a Test'} ，則會報一個錯：unhashable type:'list'。

同時字典中的鍵值不會重複，即使你這麼作，相同的鍵值也只能出現一次：a = {'key':123,'key':123} 。

增刪改查操做，在此省略了。

備註：

  • 列表中用來添加多個元素的方法爲extend，在字典中添加多個元素的方法爲update()
  • 字典是不能切片的，即這樣的寫法是錯誤的：chart[1:4]

4.3 元組（Tuple）

元組能夠理解爲一個穩固版的列表，由於元組是不能夠修改的，所以在列表中的存在的方法均不可使用在元組上，可是元組是能夠被查看索引的，方式和列表同樣。

letters = ('a, 'b', 'c', 'd')
letters[0]
複製代碼

相關的操做找代碼練習下便可。

4.4 集合（Set）

集合則更接近數學上集合的概念。每個集合中是的元素是無序的、不重複的任意對象，咱們能夠經過集合去判斷數據的從屬關係，有時還能夠經過集合把數據結構中重複的元素減掉。

集合不能被切片也不能被索引，除了作集合運算以外，集合元素能夠被添加還有刪除：

a_set = {1,2,3,4}
a_set.add(5)
a_set.discard(5)
複製代碼

4.5 數據結構的一些技巧

4.5.1 多重循環

以下：

代碼演示：

for a, b in zip(num, str):
    print(b, 'is', a)
複製代碼

4.5.2 推導式

列表推導式的用法很好理解，能夠簡單地當作兩部分。以下圖：

紅色虛線後面的是咱們熟悉的 for 循環的表達式，而虛線前面的能夠認爲是咱們想要放在列表中的元素。

代碼演示：

a = []
for i in range(1, 11):
    a.append(i)
複製代碼

能夠換成列表解析的方式來寫：

b = [i for i in range(1, 11)]
複製代碼

列表解析式不只方便，而且在執行效率上要遠遠賽過前者。

5、類的理解

5.1 類的介紹

類的定義：

class CocaCola:
    formula = ['caffeine','sugar','water','soda']
複製代碼

使用 class 來定義一個類，就如同建立函數時使用的 def 定義一個函數同樣簡單。如上你能夠看到定義了名爲 CocaCola 的類，接着在縮進的地方有一個裝載着列表的變量的 formula，這個在類裏面定義的變量就是類的變量，而類的變量有一個專有的術語，咱們稱之爲類的屬性。

類的屬性：

  • 類變量
  • 方法

①類的實例化：

coke_for_me = CocaCola()
coke_for_you = CocaCola()
複製代碼

②類變量屬性的引用：CocaCola.formula、coke_for_me.formula

類方法的使用：

class CocaCola:
    formula = ['caffeine','sugar','water','soda']
    def drink(self):
        print('Energy!')
coke = CocaCola()
coke.drink()
複製代碼

結果：

Energy!
複製代碼

5.2 self

我想不少人會有關注到這個奇怪的地方——彷佛沒有派上任何用場的self參數。咱們來講明下原理，其實很簡單，咱們修改下上面的代碼：

class CocaCola:
    formula = ['caffeine','sugar','water','soda']
    def drink(coke):	# 把self改成coke
        print('Energy!')
coke = CocaCola()
coke.drink()
複製代碼

結果：

Energy!
複製代碼

怎麼樣，有些頭緒了吧！這個參數其實就是被建立的實例自己。也就是將一個個對象做爲參數放入函數括號內，再進一步說，一旦一個類被實例化，那麼咱們其實可使用和與咱們使用函數類似的方式：

coke = CocaCola
coke.drink() == CocaCola.drink(coke) #左右兩邊的寫法徹底一致
複製代碼

被實例化的對象會被編譯器默默地傳入後面方法的括號中，做爲第一個參數。上面兩個方法是同樣的，但咱們更多地會寫成前面那種形式。其實self這個參數名稱是能夠隨意修改的（編譯器並不會所以而報錯）。

和函數同樣，類的方法也能有屬於本身的參數，以下：

class CocaCola:
    formula = ['caffeine','sugar','water','soda']
    def drink(self,how_much):
    
    if how_much == 'a sip':
        print('Cool~')
    elif how_much == 'whole bottle’:
        print('Headache!')
ice_coke = CocaCola()
ice_coke.drink('a sip')
複製代碼

結果：

Cool~
複製代碼

5.3 魔術方法

Python 的類中存在一些方法，被稱爲「魔術方法」，_init_()就是其中之一。

class CocaCola():
    formula = ['caffeine','sugar','water','soda']
    def __init__(self):
        self.local_logo = '可口可樂'
    def drink(self): 
        print('Energy!')
coke = CocaCola()
print(coke.local_logo)
複製代碼

做用：在建立實例以前，它作了不少事情。說直白點，意味着即便你在建立實例的時候不去引用 init_() 方法，其中的語句也會先被自動的執行。這給類的使用提供了極大的靈活性。

class CocaCola:
    formula = ['caffeine','sugar','water','soda']
    def __init__(self,logo_name):
        self.local_logo = logo_name
    def drink(self):
        print('Energy!')
coke = CocaCola('ݢݗݢԔ')
coke.local_logo
>>> 可口可樂
複製代碼

有過面向對象編程經驗很好理解了，也就是不少面嚮對象語言中的「構造函數」。

5.4 類的繼承

以下代碼：

class CaffeineFree(CocaCola):
    caffeine = 0
    ingredients = [
        'High Fructose Corn Syrup',
        'Carbonated Water',
        'Phosphoric Acid',
        'Natural Flavors',
        'Caramel Color',
    ]
coke_a = CaffeineFree('Cocacola-FREE')
coke_a.drink()
複製代碼

表示 CaffeineFree 繼承了 CocaCola 類。

類中的變量和方法能夠被子類繼承，但如需有特殊的改動也能夠進行覆蓋。

Q1：類屬性若是被從新賦值，是否會影響到類屬性的引用？

class TestA():
    attr = 1
obj_a = TestA()

TestA.attr = 24
print(obj_a.attr)

>>> 結果：24
複製代碼

A1：會影響。

Q2：實例屬性若是被從新賦值，是否會影響到類屬性的引用？

class TestA:
    attr = 1
obj_a = TestA()
obj_b = TestA()

obj_a.attr = 42
print(obj_b.attr)

>>> 結果：1
複製代碼

A2：不會影響。

Q3：類屬性實例屬性具備相同的名稱，那麼.後面引用的將會是什麼？

class TestA():
    attr =1
    def __init__(self):
        self.attr = 24

obj_a = TestA()

print(obj_a.attr)

>>> 結果：24
複製代碼

A3：類屬性賦值後的值。

總結：如圖所示，Python 中屬性的引用機制是自外而內的，當你建立了一個實例以後，準備開始引用屬性，這時候編譯器會先搜索該實例是否擁有該屬性，若是有，則引用；若是沒有，將搜索這個實例所屬的類是否有這個屬性，若是有，則引用，沒有那就只能報錯了。

6、使用第三方庫

6.1 安裝本身的庫

咱們通常使用 pip 來進行第三方庫的安裝，那麼本身的庫要怎麼安裝呢？固然能夠把本身的庫提交到 pip 上，可是還要添加必定量的代碼和必要的文件才行，在這裏咱們使用一個更簡單的方法：

  1. 找到你的 Python 安裝目錄，找到下面的 site-packages 文件夾；
  2. 記住你的文件名，由於它將做爲引用時的名稱，而後將你寫的 py 文件放進去。

這個文件夾應該有你所安裝的全部第三方庫。若是你並不清楚你的安裝路徑，能夠嘗試使用以下方式搞清楚它究竟在哪裏：

import sys
print(sys.path)
複製代碼

打印出來的會是一個列表，列表中的第四個將是你的庫安裝路徑所在，所以你也能夠直接這麼作：

import sys
print(sys.path[3])
複製代碼

6.2 安裝第三方庫

使人驚歎的第三方庫

若是用手機來比喻編程語言，那麼 Python 是一款智能機。正如含量的手機應用出如今 iOS、Android 平臺上，一樣有各類各樣的第三方庫爲 Python 開發者提供了極大的便利。

當你想要搭建網站時，能夠選擇功能全面的 Django、輕量的 Flask 等 web 框架；當你想寫一個小遊戲的時候，可使用 PyGame 框架；當你想作一個 爬蟲時，可使用 Scrapy 框架；當你想作數據統計分析時，可使用 Pandas 數據框架......這麼多豐富的資源能夠幫助咱們高效快捷地作到想作的事，就不須要再重複造輪子了。

那麼如何根據本身的需求找到相應的庫呢？能夠到 awesome-python.com 這個網站上按照分類去尋找，上面收錄了比較全的第三方庫。好比想要找爬出方面的庫時，查看 Web Crawling 這個分類，就能看到相應的第三方庫的網站與簡介，能夠進入庫的網站查看更詳細的介紹，並確認這個庫支持的是 Python 2 仍是 Python 3，不過絕大多數經常使用庫已經都支持了這二者。另外，你也能夠直接經過搜索引擎尋找。

安裝第三方庫方式：

①最簡單的方式：在 PyCharm 中安裝

  1. 在 PyCharm 的菜單中選擇：File --> Default Setting
  2. 搜索 project interpreter，選擇當前 python 版本，點擊「+」添加庫
  3. 輸入庫的名稱，勾選，並點擊 Install Package

在安裝成功後， PyCharm 會有成功提示。也能夠在 project interpreter 這個界面中查看安裝了哪些庫，點「-」號就能夠卸載再也不須要的庫。

②最直接的方式：在終端/命令行中安裝

PyPI（Python Package Index）是 Python 官方的第三方庫的倉庫，PyPI 推薦使用 pip 包管理器來下載第三方庫。

  1. 安裝 pip

    在 Python 3.4 以後，安裝好 Python 環境就能夠直接支持 pip，你能夠在終端/命令行裏輸入這句檢查一下：pip --version （前提電腦 path 路徑已經配置好了），若是顯示 pip 版本，就說明 pip 已經成功安裝了；若是發現沒有安裝，則根據不一樣系統以下方式安裝：

  2. 使用 pip 安裝庫

    在安裝好了 pip 以後，之後安裝庫，只須要在命令行裏面輸入：pip3 install PackageName（注：若是你想要安裝到 Python 2 中，須要把 pip3 換成 pip）。補充：

    pip和pip3都在Python36\Scripts\目錄下，若是同時裝有 python2 和 python3，pip 默認給python2 用，pip3指定給 python3 用。若是隻裝有 python3，則pip和pip3是等價的。

    若是你安裝了 Python 2 和 3 兩種版本，可能會遇到安裝目錄的問題，能夠換成：python3 -m pip install PackageName （注：若是你想安裝到 Python2 中，須要把 Python3 換成 Python）

    若是遇到權限問題，能夠輸入：sudo pip install PackageName

    安裝成功以後會提示：Successfully insyalled PackageName

    一些經常使用的 pip 指令：

    # pip 使用格式：pip <command> [options] package_name

pip install package_name==1.9.2	# 安裝指定版本的包
pip install --upgrade package_name	# 更新指定的包
pip uninstall package_name	# 卸載指定的包
pip show package_name	# 查看所安裝包的詳細信息
pip list	# 查看全部安裝的包
pip --help	# 查看幫助
複製代碼

補充：若是下載很慢，能夠考慮更改 pip 下載源。國內鏡像有：

# 國內經常使用的鏡像
http://pypi.douban.com/simple/            # 豆瓣
http://mirrors.aliyun.com/pypi/simple/    # 阿里
https://pypi.tuna.tsinghua.edu.cn/simple  # 清華
http://pypi.mirrors.ustc.edu.cn/simple/   # 中國科學技術大學
http://pypi.hustunique.com/simple/        # 華中理工大學
複製代碼

更改方法：

  1. 臨時使用，添加 -i 或 --index 參數：pip install -i http://pypi.douban.com/simple/ flask

  2. Linux下永久生效的配置方法

    cd $HOME  
mkdir .pip  
cd .pip
sudo vim pip.conf  

# 在裏面添加，trusted-host 選項爲了不麻煩是必須的，不然使用的時候會提示不受信任  
[global]
index-url=https://pypi.tuna.tsinghua.edu.cn/simple

[install]
trusted-host=pypi.tuna.tsinghua.edu.cn 
disable-pip-version-check=true
timeout = 6000 
複製代碼

  3. Windows 下永久生效的配置方法

    # a、進入以下目錄（沒有此目錄或文件就本身建立下）
C:\Users\username\AppData\Local\pip
或
C:\Users\username\pip

# b、建立 「pip.ini」 文件（注意：以UTF-8 無BOM格式編碼），添加以下內容
[global]
index-url=https://pypi.tuna.tsinghua.edu.cn/simple

[install]
trusted-host=pypi.tuna.tsinghua.edu.cn 
disable-pip-version-check=true
timeout = 6000 
複製代碼

③最原始的方式：手動安裝

進入 pypi.python.org，搜索你要安裝的庫的名字，這時候有 3 種可能：

  1. 第一種是 exe 文件，這種最方便，下載知足你的電腦系統和 Python 環境的對應的 exe，再一路點擊 next 就能夠安裝。

  2. 第二種是 .whl 類文件，好處在於能夠自動安裝依賴的包。

    1. 到命令行輸入pip3 install whell 等待執行完成，不能報錯（Python 2 中要換成 pip）
    2. 從資源管理器中確認你下載的 .whl 類文件的路徑，而後在命令行繼續輸入：cd C:\download，此處須要改成你的路徑，路徑的含義是文件所在的文件夾，不包含這個文件名字自己，而後再命令行繼續輸入：pip3 install xxx.whl，xxx.whl 是你下載的文件的完整文件名。

  3. 第三種是源碼，大概都是 zip、tar.zip、tar.bz2 格式的壓縮包，這個方法要求用戶已經安裝了這個包所依賴的其餘包。例如 pandas 依賴於 numpy，你若是不安裝 numpy，這個方法是沒法成功安裝 pandas 的。

    1. 解壓包，進入解壓好的文件夾，一般會看見一個 setup.py 的文件，從資源管理器中確認你下載的文件的路徑，打開命令行，輸入：cd C:\download 此處須要改成你的路徑，路徑的含義是文件所在的文件夾，不包含這個文件名字自己
    2. 而後在命令行中繼續輸入：python3 setup.py install 這個命令，就能把這個第三方庫安裝到系統裏，也就是你的 Python路徑，windows 大概是在 C:\Python3.5\Lib\site-packages。

    注：想要卸庫的時候，找到 Python 路徑，進入 site-packages 文件夾，在裏面刪掉庫文件就能夠了。

本文內容大部分來源：

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程