Python學習筆記day1（簡介與入門）

Python 能作什麼？

Python 是一門綜合性的語言，你幾乎能在計算機上經過 Python 作任何事情，如下是 Python

應該最普遍的幾個方面： 

1.   網絡應用：包括 web 網站 、服務器後臺服務等，在這方面 Python 有優秀的 web 框架 如 Django\Tornado\Flask  等，網絡服務框架有著名的 Twisted,異步通訊有牛 X 的eventlet.

2.   科學運算：隨着 NumPy、SciPy、matplotlib、ETS 等衆多程序庫的開發，Python 越來 越適合於作科學計算。與科學計算領域最流行的商業軟件 MATLAB 相比，Python 是一 門真正的通用程序設計語言，比 MATLAB 所採用的腳本語言的應用範圍更普遍，有更 多程序庫的支持，適用於 Windows 和 Linux 等多種平臺，徹底免費而且開放源碼。雖 然 MATLAB 中的某些高級功能目前還沒法替代，可是對於基礎性、前瞻性的科研工做 和應用系統的開發，徹底能夠用 Python 來完成。

3.   GUI 程序：python 提供了多個圖形開發界面的庫，包括 PyQt,WxPython,自帶的有 Tkinter,

這些庫容許 Python 程序員很方便的建立完整的、功能健全的 GUI 用戶界面。

4.  系統管理工具：Python 能夠是作運維人員最喜歡用的語言了，能夠用它來輕鬆的開發 自動化管理工具、監控程序等，事實上如今不少開源軟件也都是用 Python 開發的，如 用於 IT 配置管理的 SaltStack\Ansible,  作虛擬化的 OpenStack,作備份用的 Bacula 等。 

5.  其它程序：你知道嗎？Python 用來寫爬蟲也是很拿手的，還有作遊戲，以前看社區裏 有個哥們花了不到 300 行代碼就實現了《憤怒的小鳥》的遊戲，還能夠用來作嵌入式開 發、作驅動程序等，總之，Python 能作的事情仍是很是多的，好好學吧，很快你就會

fall in love with this great language!

 

Python 的優缺點

先看優勢

1.      Python 的定位是「優雅」、「明確」、「簡單」，因此 Python 程序看上去老是簡單易懂，初 學者學 Python，不但入門容易，並且未來深刻下去，能夠編寫那些很是很是複雜的程 序。

2.      開發效率很是高，Python  有很是強大的第三方庫，基本上你想經過計算機實現任何功 能，Python 官方庫裏都有相應的模塊進行支持，直接下載調用後，在基礎庫的基礎上 再進行開發，大大下降開發週期，避免重複造輪子。

3.      高級語言————當你用 Python 語言編寫程序的時候，你無需考慮諸如如何管理你的 程序使用的內存一類的底層細節

4.   可移植性————因爲它的開源本質，Python 已經被移植在許多平臺上（通過改動使 它可以工 做在不一樣平臺上）。若是你當心地避免使用依賴於系統的特性，那麼你的所 有 Python 程序無需修改就幾乎能夠在市場上全部的系統平臺上運行

5.      可擴展性————若是你須要你的一段關鍵代碼運行得更快或者但願某些算法不公開， 你能夠把你的部分程序用 C 或 C++編寫，而後在你的 Python 程序中使用它們。

6.      可嵌入性————你能夠把 Python 嵌入你的 C/C++程序，從而向你的程序用戶提供 腳本功能。

 

再看缺點：

 

1.   速度慢，Python  的運行速度相比 C 語言確實慢不少，跟 JAVA 相比也要慢一些，所以 這也是不少所謂的大牛不屑於使用 Python 的主要緣由，但其實這裏所指的運行速度慢 在大多數狀況下用戶是沒法直接感知到的，必須藉助測試工具才能體現出來，好比你用 C 運一個程序花了 0.1s,用 Python 是 0.01s,這樣 C 語言直接比 Python 快了 10s,算是非 常誇張了，可是你是沒法直接經過肉眼感知的，由於一個正常人所能感知的時間最小單 位是 0.15-0.4s 左右，哈哈。其實在大多數狀況下 Python 已經徹底能夠知足你對程序速 度的要求，除非你要寫對速度要求極高的搜索引擎等，這種狀況下，固然仍是建議你用 C 去實現的。

2.   代碼不能加密，由於 PYTHON 是解釋性語言，它的源碼都是以名文形式存放的，不過 我不認爲這算是一個缺點，若是你的項目要求源代碼必須是加密的，那你一開始就不該 該用 Python 來去實現。

3.   線程不能利用多 CPU 問題，這是 Python 被人詬病最多的一個缺點，GIL 即全局解釋器 鎖（Global Interpreter Lock），是計算機程序設計語言解釋器用於同步線程的工具，使 得任什麼時候刻僅有一個線程在執行，Python 的線程是操做系統的原生線程。在 Linux 上爲 pthread，在 Windows 上爲 Win thread，徹底由操做系統調度線程的執行。一個 python 解釋器進程內有一條主線程，以及多條用戶程序的執行線程。即便在多核 CPU 平臺上， 因爲 GIL 的存在，因此禁止多線程的並行執行。關於這個問題的折衷解決方法，咱們在 之後線程和進程章節裏再進行詳細探討。

 

Python 解釋器

當咱們編寫 Python 代碼時，咱們獲得的是一個包含 Python 代碼的以 .py 爲擴展名的文本文件。要運行代碼，就須要 Python 解釋器去執行 .py 文件。因爲整個 Python 語言從規範到解釋器都是開源的，因此理論上，只要水平夠高，任何人均可以編寫 Python 解釋器來執行 Python 代碼（固然難度很大）。事實上，確實存在多種 Python解釋器。

 

Python2.x與3.x主要區別

1.    1/2變成了0.5

2.    print "Hello World"變成了print("Hello World")

3.    raw_input()沒了，變成了input()

4.    class Foo:寫法不能用了，只能class Foo(object)

5.    默認支持輸入中文，不用在代碼裏輸入# -*- coding: utf-8 -*-

 

Python安裝

下載地址：https://www.python.org/downloads/

python2.7及python3.x版本裝在centos6.5系統上後，交互模式的刪除鍵、返回鍵、上向左右箭頭鍵出現亂碼問題，解決方法是yum -y install readline-devel  （注意yum解釋器是系統python版本），安裝完成readline-devel後，再從新編譯安裝Python2.7便可解決問題

 

Python 的變量及數據類型 

數據類型 一個程序要運行，就要先描述其算法。描述一個算法應先說明算法中要用的數據，數據以變量或 常量的形式來描述。每一個變量或常量都有數據類型。Python 的基本數據類型有 5 種：整型(int), 浮點型(float), 字符型(string), 布爾型（bool）,空值(None).

1.整數

Python 可處理任意大小的整數，在程序中的表示方法和數學上的寫法徹底同樣。

2.浮點數

浮點數也就是小數，之因此稱爲浮點數，是由於按照科學記數法表示時，一個浮點數的小數點位置是可變的，好比，1.23x109 和 12.3x108  是相等的。浮點數能夠用數學寫法，如  1.23 ，3.14 ， -9.01 ，等等。可是對於很大或很小的浮點數，就必須用科學計數法表示，把 10用 e 替代，1.23x109 就是 1.23e9 ，或者 12.3e8 ，0.000012 能夠寫成 1.2e-5 ，等等。整數和浮點數在計算機內部存儲的方式是不一樣的，整數運算永遠是精確的（除法難道也是精確的？是的！），而浮點數運算則可能會有四捨五入的偏差。

3.字符串

字符串是以''或""括起來的任意文本，好比 'abc' ， "xyz" 等等。請注意，''或""自己只是一種表示方式，不是字符串的一部分，所以，字符串 'abc' 只有 a ， b ， c  這 3 個字符。若是 ' 自己也是一個字符，那就能夠用""括起來，好比 "I'm OK" 包含的字符是 I ， ' ， m ，空格， O ， K 這 6 個字符。'''...''' 的格式表示多行內容print '''line1 line2 line3'''。

4.布爾值

布爾值和布爾代數的表示徹底一致，一個布爾值只有 True 、False 兩種值，要麼是 True ，要麼是 False ，在 Python 中，能夠直接用 True 、 False 表示布爾值（請注意大小寫），也能夠經過布爾運算計算出來：

>>>  True True >>>  False False >>>  3  >  2  True >>>  3  >  5  False

布爾值能夠用 and 、 or 和 not 運算。

and  運算是與運算，只有全部都爲 True ， and  運算結果纔是 True ：

>>>  True and  True True >>>  True and  False False >>>  False and  False False

or 運算是或運算，只要其中有一個爲 True ， or 運算結果就是 True ：

>>>  True or True True >>>  True or False True >>>  False or False False

not 運算是非運算，它是一個單目運算符，把  True 變成 False ， False 變成 True ：

>>>  not True False >>>  not False True

布爾值常常用在條件判斷中，好比：

if age  >=  18:

    print 'adult'

else:

    print 'teenager'

5.空值

空值是 Python 裏一個特殊的值，用 None  表示。 None  不能理解爲 0 ，由於 0  是有意義的，而 None  是一個特殊的空值

 

條件判斷

valid_user = 'jack'

valid_passwd = 'jack111'

user_input = input("Your username:")

passwd = input("Your password:")

if user_input == valid_user and  passwd == valid_passwd:

    print(Welcome %s login  to our  system!" % user_input)

elif  user_input == 'guest':

    print(Welcome %s login  our system,but you only  have  read-only access,enjoy!)　　

else:

print  "invalid username! Byebye!"

這裏咱們用到了 elif,意思就是，若是不知足第一個 if 條件，那程序就會繼續往下走，再判斷 是否知足 elif 條件，若是不知足，就再繼續走（這裏你能夠加多個 elif 判斷），只要遇到有 知足的 elif 就停下來執行它後面的代碼，而後結束，若是最終沒有碰到知足的條件，就最終執 行 else 語法。另外真的能夠寫多行噢，以下：

if <條件判斷 1>:

<執行 1>

elif <條件判斷 2>:

<執行 2>

elif <條件判斷 3>:

<執行 3>

else:

<執行 4>

 

for循環

valid_user = 'jack'

valid_passwd = 'jack111'

for i in range(3):

    user_input = raw_input("Your username:")

    passwd = raw_input("Your password:")

    if user_input == valid_user and  passwd == valid_passwd:

        print （"Welcome %s login  to our  system!" % user_inpu) 

        break

    elif  user_input == 'guest':

        print ("Welcome %s login  our  system,but you  only  have read-only access,enjoy!" % user_inpu

　　  break

    else:

        print ("invalid username!")

這個代碼實現了，若是用戶名密碼錯誤後，最多讓用戶嘗試 3 次，注意這裏用到了 break,它是用來幫助跳出整個循環的，就是如今你的程序要循環 3 次，可是用 戶再嘗試了第 2  次時，就驗證成功了，這時候你還須要讓他再進行一次驗證嗎？固然不須要， 這時候須要讓程序在驗證成功後直接跳出整個循環，再也不須要進行下一次循環操做。

while循環

import time  #導入time模塊

count  = 0    #設置一個計數器，每循環一次加一次，這樣就知道循環多少次了。

while  True:   #只要爲真，就執行下面代碼，每循環一次就判斷一次

    count  += 1 #每循環一次就自加1

    print （"Loop  ", count）

    time.sleep(10) #每循環一次就 sleep  10s 再繼續運行

輸出：

Loop 1

Loop 2

Loop 3

...

上面的程序就是死循環了，只要進程沒被殺死，就會一直運行下去

continue VS break

跟 break 相對應的還有一個負責循環跳出的語法就是 continue，它跟 break 有什 麼區別呢？咱們都知道了 break 是負責跳出整個循環，但 continue 是跳出本次 循環，繼續下一次循環。就是說，循環過程當中，若是遇到 continue,那這一次循 環本應該執行的後面的代碼就不執行了，直接跳過了，直接進行下一次循環了。

注意：當遇到多層嵌套循環時，break只跳出當前嵌套裏的循環，不會跳出全部嵌套循環。

 

列表、元組和字典

列表(List)

列表是在編程中常常用到的一種數據類型，它跟其它語言中所指的數組基本是一 樣的，列表是指一組有序的數據集合，能夠將各類各樣的數據有序的存放在列表 中，而且能夠對其進行增刪改查，以及遍歷。列表的存在是爲了經過一個變量存 儲更多的信息，好比我想在一個變量裏存儲一張購物清單，而後程序只須要經過 我定義的這個變量就能夠找到購物清單中的任意一個或多個商品。以下：

>>> shopping_list = ['Iphone', 'Mac',  'Bike','Coffee','Car','Clothes','Food','Gift']

>>> shopping_list

['Iphone', 'Mac',  'Bike', 'Coffee', 'Car',  'Clothes', 'Food', 'Gift']

經過 len()內置函數可查看列表中元素的個數

>>> len(shopping_list)

8

你能夠經過索引來找到列表中每一個元素的位置，記住索引是從 0 開始的

>>> shopping_list[2] #找Bike

'Bike'

>>> shopping_list[0] #第一個元素取出來

'Iphone'

>>> shopping_list[-1] #-1表明取列表中最後一個元素

'Gift'

>>> shopping_list[-3] #取倒數第3位元素

'Clothes'

>>> shopping_list[-4] #取倒數第4個元素

'Car'

>>> shopping_list[8] #取索引爲8的元素

Traceback (most  recent  call last):

File "<stdin>", line 1, in <module> IndexError: list index  out of range

#最後一個shopping_list[8]報錯了，緣由是引用超出了索引範圍，不是有8 個元素嗎？取第8個怎麼會出錯呢？這裏要注意了，列表的索引是從0開始的， 你這裏寫的8實際上是取了列表中的第9個位置，但你列表中一共有8個元素，因此 確定取不到嘍。

切片(Slice)

你還能夠從列表中取出指定多個元素，這種操做叫作切片

>>> shopping_list

['Iphone', 'Mac',  'Bike', 'Coffee', 'Car',  'Clothes', 'Food', 'Gift']

>>> 

>>> shopping_list[0:3] #取0到第3個元素，不包括第4個

['Iphone', 'Mac',  'Bike']

>>> shopping_list[:3] #同上，取0到第3個元素，不包括第4個，0能夠不寫

['Iphone', 'Mac',  'Bike']

>>> shopping_list[2:5] #取第3至第5個元素

['Bike', 'Coffee', 'Car']

>>> shopping_list[:-3] #取從0至倒數第3個元素

['Iphone', 'Mac',  'Bike', 'Coffee', 'Car']

>>> shopping_list[-3:] #取最後3個元素

['Clothes', 'Food', 'Gift']

>>> shopping_list[1:8:2]    #從1至8隔一個取一個，後面的2是步長，即每隔幾個元素取一個

['Mac', 'Coffee', 'Clothes', 'Gift']

>>> shopping_list[::2] #從頭到位每隔一個取一個

['Iphone', 'Bike', 'Car',  'Food']

 

增刪改查

>>> shopping_list.append('MovieTicket') #向列表後面追加一個元素

>>> shopping_list

['Iphone', 'Mac',  'Bike', 'Coffee', 'Car',  'Clothes', 'Food', 'Gift', 'MovieTicket']

>>> shopping_list.pop() #刪除最後一個元素

'MovieTicket'

>>> shopping_list.remove('Mac') #刪除叫’Mac’的元素，若是有多個’Mac’,那會刪除從左邊數找到的第一 個

>>> shopping_list[2]

'Coffee'

>>> shopping_list[2] = 'COFFEE' #將索引爲2的元素改成」COFFEE」，原來是小寫

>>> shopping_list.insert(3,"Toy") #插入一個新元素，索引爲3

>>> shopping_list

 

['Iphone', 'Bike', 'COFFEE', 'Toy',  'Car',  'Clothes', 'Food', 'Gift']

>>> shopping_list.index('Toy') #返回’Toy’元素的索引值，若是有多個相同元素，則返回匹配的第一個

3

>>> shopping_list.append('Food')

>>> shopping_list.count('Food') #統計’Food’的元素的個數，剛添加了一個，因此如今是2個

2

>>> shopping_list

['Iphone', 'Bike', 'COFFEE', 'Toy',  'Car',  'Clothes', 'Food', 'Gift', 'Food']

>>> list2=  ['Banana','Apple'] #建立一個新列表

>>> shopping_list.extend(list2) #把上面的新列表合併到shopping_list中

>>> shopping_list

['Iphone', 'Bike', 'COFFEE', 'Toy',  'Car',  'Clothes', 'Food', 'Gift', 'Food', 'Banana',

'Apple']

>>> shopping_list.sort() #將列表排序

>>> shopping_list

['Apple', 'Banana', 'Bike', 'COFFEE', 'Car', 'Clothes', 'Food', 'Food', 'Gift', 'Iphone',

'Toy']

>>> shopping_list.reverse() #將列表反轉

>>> shopping_list

['Toy', 'Iphone', 'Gift', 'Food', 'Food', 'Clothes', 'Car',  'COFFEE', 'Bike', 'Banana',

'Apple']

>>> del shopping_list[3:8] #刪除索引3至8的元素，不包括8

>>> shopping_list

['Toy', 'Iphone', 'Gift', 'Bike', 'Banana', 'Apple']

>>> for i in shopping_list: #遍歷列表

...    print  i

元組（Tuple）

另外一種有序列表叫元組：tuple。tuple 和 list 很是相似，可是 tuple 一旦初始化就不能修改

字典（Dict）

列表容許你經過一個變量存儲大量的信息，但試想如下場景，用列表實現就可能 效率較低了：

1. 存儲的信息量愈來愈多，有的時候找一個數據可能要循環整個列表，耗時較 長。

2. 單個元素包含的信息量變多時，好比，以前只是存儲姓名列表，如今是要存 儲姓名、年齡、身份證號、地址、工做等這我的的不少信息，用列表去存儲 很費勁

3. 要求存儲的數據是不重複，咱們知道列表是容許的重複值的，固然想存儲時 就讓個人數據默認就是惟一的話，用列表就不能夠了

以上這些是列表不擅長的地方，卻偏偏是dict 所擅長的， dict 使用 key-­‐value 的形式存儲數據，dict 的 key  是惟一的，因此你能夠經過 key 來惟一的定位到你的數據。之因此叫字典(在其它語言中稱爲 map)，是由於 dict 的數據結構跟咱們生活中用的字典是同樣的，查英文字典時，輸入單詞，就能夠 定位到這個單詞意思的詳細解釋，其中這個單詞就是 key,對應的詞義解釋就是 value.字典有以下特色：

1.   key-­‐value 格式，key 是惟一的

2. 無序，與列表有序的特色不一樣，字典是無序的，列表只因此有序是由於你需 要經過索引來定位相應元素，而字典已經能夠經過 key 來定位相應 value,因 此爲了不浪費存儲空間，字典不會對數據的位置進行紀錄，固然若是你想 讓其變成有序的，也是有方法的，這個咱們之後再講。

3.   查詢速度很快，dict 是基於 hash 表的原理實現的，是根據關鍵字（Key value） 而直接訪問在內存存儲位置的數據結構。也就是說，它經過把鍵值經過一個 函數的計算，映射到表中一個位置來訪問記錄，這加快了查找速度。這個映 射函數稱作散列函數，存放記錄的數組稱作散列表。因爲經過一個 key 的索 引表就直接定位到了內存地址，因此查詢一個只有 100 條數據的字典和一個

100 萬條數據的字典的速度是查很少的。

 

好了，來看看 dict 的語法：

>>> info = {'name':'alex',

'job':'engineer',

'age':  29,

'company':'AUTOHOME'

}

>>> info

{'age': 29, 'job':  'engineer', 'company': 'AUTOHOME', 'name': 'alex'}

增刪改查

>>> info['name'] #查看key爲’name’的value

'alex'

>>> info['job'] = 'Boss'  #將key 的value 改成’Boss’

>>> info

{'age': 29, 'job':  'Boss', 'company': 'AUTOHOME', 'name': 'alex'}

>>> info['city'] = 'BJ' #若是dict中有key爲’city’,就將其值改成’BJ’,若是沒有這個key,就建立一條新 紀錄

>>> info

{'age': 29, 'job':  'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}

>>> info.pop('age') #刪除key爲’age’的數據，跟del info[‘age’] 同樣

29

>>> info

{'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}

>>> info.popitem() #隨機刪除一條數據，dict爲空時用此語法會報錯

 

('job', 'Boss')

>>> info.items() #將dict的key,value轉換成列表的形式顯示

[('company', 'AUTOHOME'), ('name', 'alex'), ('city', 'BJ')]

>>> info.has_key('name') #判斷字典中是否有個叫’name’的key

True　　

>>> info['age'] #查找一個不存在的key報錯，由於’age’剛纔已經刪除了，因此報錯

Traceback (most  recent  call last): File "<stdin>", line 1, in <module>

KeyError: 'age'

>>> info.get('age') #查找key,若是存在則返回其value,不然則返回None

>>> info.get('name')

'alex'

>>> info.clear() #清空dict

>>> info

{}

>>> info.fromkeys(['a','b','c'],'Test') #根據列表[‘a’,’b’,’c’]來建立dict裏的key,後面 的’Test’是默認value,若是不指定的話則爲None

{'a':  'Test', 'c': 'Test', 'b': 'Test'}

>>> info

{}

>>> info =info.fromkeys(['a','b','c'],'Test')

>>> info

{'a':  'Test', 'c': 'Test', 'b': 'Test'}

>>> info.setdefault('d','Alex') #找一個key爲’d’的紀錄，若是這個key不存在，那就建立一個叫’d’的key,

而且將其value設置爲’Alex’， 若是這個key存在，就直接返回這個key的value，見下一條

'Alex'

>>> info.setdefault('c','Alex')

'Test'

>>> info

{'a':  'Test', 'c': 'Test', 'b': 'Test', 'd': 'Alex'}

>>> dict2  = {'e':'fromDict2','a':'fromDict2'} #建立一個新字典

>>> info.update(dict2) #拿這個新字典去更新info,注意dict2中有一個key值’a’與dict info相沖突，這 時dict2的值會覆蓋info中的a,若是dict2的key在info中不存在，則建立相應的紀錄

>>> info

{'a':  'fromDict2', 'c': 'Test', 'b': 'Test', 'e': 'fromDict2', 'd': 'Alex'}

遍歷 dict 與遍歷列表差很少，只不過要記得 dict 是 key-­‐value 的結構，要想在遍 歷時同時打印這 key  和 value，須要這樣寫：

info = {

'name': 'Alex Li',

'age': 29,

'job': 'Engineer',

'phone': 1493335345

}

for item in info:

print(item, info[item]) #print item 只會打印 key,若是想同時打印 value,須要再經過 item 去取

還有一種遍歷的方式：

for key,val in info.items():

    print(key,val)