Python簡(jiǎn)介

Python歷史

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷蘭國家數(shù)學(xué)和計(jì)算機(jī)科學(xué)研究所設(shè)計(jì)出來的。
Python 本身也是由諸多其他語言發(fā)展而來的,這包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的腳本語言等等。
像 Perl 語言一樣，Python 源代碼同樣遵循 GPL(GNU General Public License)協(xié)議。
現(xiàn)在 Python 是由一個(gè)核心開發(fā)團(tuán)隊(duì)在維護(hù)，Guido van Rossum 仍然占據(jù)著至關(guān)重要的作用，指導(dǎo)其進(jìn)展。

目前流行的是Python2.x，最新的Python目前是Python3.x。

Python特征

1. 易于學(xué)習(xí)：Python有相對(duì)較少的關(guān)鍵字，結(jié)構(gòu)簡(jiǎn)單，和一個(gè)明確定義的語法，學(xué)習(xí)起來更加簡(jiǎn)單。
2. 易于閱讀：Python代碼定義的更清晰。
3. 易于維護(hù)：Python的成功在于它的源代碼是相當(dāng)容易維護(hù)的。
4. 一個(gè)廣泛的標(biāo)準(zhǔn)庫：Python的最大的優(yōu)勢(shì)之一是豐富的庫，跨平臺(tái)的，在UNIX，Windows和Macintosh兼容很好。
5. 互動(dòng)模式：互動(dòng)模式的支持，您可以從終端輸入執(zhí)行代碼并獲得結(jié)果的語言，互動(dòng)的測(cè)試和調(diào)試代碼片斷。
6. 可移植：基于其開放源代碼的特性，Python已經(jīng)被移植（也就是使其工作）到許多平臺(tái)。
7. 可擴(kuò)展：如果你需要一段運(yùn)行很快的關(guān)鍵代碼，或者是想要編寫一些不愿開放的算法，你可以使用C或C++完成那部分程序，然后從你的Python程序中調(diào)用。
8. 數(shù)據(jù)庫：Python提供所有主要的商業(yè)數(shù)據(jù)庫的接口。
9. GUI編程：Python支持GUI可以創(chuàng)建和移植到許多系統(tǒng)調(diào)用。
10. 可嵌入: 你可以將Python嵌入到C/C++程序，讓你的程序的用戶獲得"腳本化"的能力。
11. 解釋性和編譯性：Python語言寫的程序不需要編譯成二進(jìn)制代碼，可以直接運(yùn)從源代碼運(yùn)行程序，但是需要解釋器。這點(diǎn)類似于Java，或者M(jìn)atlab。Python也可以編譯后執(zhí)行程序，這樣速度優(yōu)于直接從源代碼執(zhí)行的速度。
12. 面向?qū)ο缶幊蹋篜ython支持面向過程的編程也支持面向?qū)ο蟮木幊獭Ｅc其他的語言如C++和Java相比，Python以一種非常強(qiáng)大而又簡(jiǎn)單的方式實(shí)現(xiàn)面向?qū)ο缶幊獭?/li>
13. 高級(jí)語言：使用Python語言編寫程序，無需考慮諸如管理內(nèi)存一類的底層。
14. 豐富的庫：

Python應(yīng)用場(chǎng)景

國外：

• Google：實(shí)現(xiàn)Web爬蟲和搜索引擎中的很多組件
• YaHoo： 管理討論組以及其他技術(shù)
• NASA：NASA在他的幾個(gè)系統(tǒng)中既實(shí)用Python開發(fā)，又作為腳本語言
• YouTube： 視頻分享服務(wù)大部分都是由Python編寫的

國內(nèi)：

• 豆瓣：前后臺(tái)使用Python
• 還有其他很多的現(xiàn)在也是用Python作為前后臺(tái)開發(fā)的

Python安裝

Linux下Python環(huán)境搭建

大多數(shù)Linux發(fā)行版都默認(rèn)自帶Python，一般都是Python2.x
如果沒有安裝可以通過源碼進(jìn)行安裝：

# ./configure --prefix=/usr/local
# make && make install
# make clean 
# make distclean

然后命令行直接輸入python，打開python解釋器，如圖：

說明：因?yàn)楫?dāng)前沒有l(wèi)inux環(huán)境，就使用cywin演示了一下，效果是跟linux的一樣的。

Windows下Python環(huán)境搭建

Windows下安裝很方便，根據(jù)系統(tǒng)版本可下載相對(duì)應(yīng)的Python MSI的安裝包，按照步驟點(diǎn)擊下一步，即可，默認(rèn)安裝在c:\Python2.x目錄，不建議更改它的安裝目錄。

注意：在安裝的過程最好勾選path那個(gè)選項(xiàng)，這樣Python在安裝完畢會(huì)自動(dòng)建立系統(tǒng)環(huán)境變量，這樣直接通過cmd窗口就可以輸入python，打開Python解釋器。

安裝完畢通過cmd窗口打開python，如圖：

Python的文件類型

• 源代碼：Python的源代碼文件以"py"為擴(kuò)展名，由Python程序解釋，不需要編譯，可直接運(yùn)行，特點(diǎn)：可直接運(yùn)行，方便修改源代碼
• 字節(jié)代碼：Python源文件經(jīng)過編譯后生成的擴(kuò)展名為"pyc"的文件，特點(diǎn)：運(yùn)行速度快
  編譯方法：
  import py_compile
  py_compile("hello.py")
• 優(yōu)化代碼：經(jīng)過優(yōu)化后的源文件擴(kuò)展名為".pyo"，特點(diǎn)：運(yùn)行速度快
  優(yōu)化方法：
  python -O -m py_compile hello.py
• 以上三種均可以直接運(yùn)行

Python變量

變量就是給數(shù)據(jù)起一個(gè)名字，寫過shell腳本的，應(yīng)該知道其中的變量，跟他類似。
變量是計(jì)算機(jī)內(nèi)存中的一塊區(qū)域，變量可以存儲(chǔ)規(guī)定范圍內(nèi)的值，而且值可以改變。

變量的命名：

• 變量名可由字母、數(shù)字、下劃線組成
• 數(shù)字不能開頭
• 不可以使用關(guān)鍵字

變量的賦值：

• 是變量聲明和定義的過程

實(shí)例演示：

  >>>a = 1
  >>>a
  1

說明：給變量a賦值為1，并顯示變量a的賦值結(jié)果，相當(dāng)于我有個(gè)同學(xué)叫1，但是我先麻煩，所以我就給他另起了一個(gè)名稱a，這樣我直接叫a就可以了，當(dāng)然叫1也行。變量賦值中間的等號(hào)嚴(yán)格意義上需要前后有空格，當(dāng)然沒有空格也行，推薦加空格。

設(shè)定變量的好處：

方便在腳本或者程序中，簡(jiǎn)化數(shù)據(jù)長(zhǎng)度或者便于一次性修改腳本或者程序中多次使用的值。
舉個(gè)簡(jiǎn)單的例子，如下：
# coding=utf-8
#!/bin/bash/env python
#設(shè)定變量a并賦值為50
a = 50

  print "我買本Python學(xué)習(xí)書籍價(jià)格"， a
  print "我喝的可樂價(jià)格"， a
  print "我買的車價(jià)格是"，  a

在上述的腳本中，如果價(jià)格發(fā)生變化，你是不是得每行去修改，如果內(nèi)容多，那是不是更麻煩，為了減少這種不必要的操作浪費(fèi)時(shí)間，就在開頭設(shè)定變量a，然后賦值價(jià)格，這樣，如果價(jià)格發(fā)生變化我們只需要修改變量a的值即可。簡(jiǎn)化數(shù)據(jù)這個(gè)有點(diǎn)跟這個(gè)相似，就是如果值的的數(shù)據(jù)很長(zhǎng)，這樣會(huì)增加代碼的可讀性難度，設(shè)定變量就容易多了。

運(yùn)算符和表達(dá)式

賦值運(yùn)算符：

• 賦值運(yùn)算符符號(hào)：=
• 最常見的就是對(duì)于變量賦值，如： a = 1

算數(shù)運(yùn)算符：

算術(shù)運(yùn)算符的優(yōu)先級(jí)跟往常的算數(shù)運(yùn)算符優(yōu)先級(jí)一樣，遇到其他特殊的網(wǎng)上再查下，后面再整理。

• 加法： +,例如： x+y
• 加等于: +=,例如：x += 2相當(dāng)于x = x+2
• 減法： -,例如： x -y
• 減等于: -=,例如：x -= 2相當(dāng)于x = x-2
• 乘法： *,例如： x*y
• 乘等于: *=,例如：x = 2相當(dāng)于x = x2
• 實(shí)數(shù)除法： /,例如： 3/2,3.0/2
• 整除法： //,例如： 5.6/2，5.6//2
• 除等于: /=,例如：x /= 2相當(dāng)于x = x/2
• 求余數(shù)： %,例如： 17%8余1
• 求余等于： %=，例如：x %= 2相當(dāng)于x = x%2
• 求冪運(yùn)算: **,例如： 2**3 = 8

注意：使用除法的時(shí)候默認(rèn)是整除，如果想帶小數(shù)點(diǎn)，后面必須添加小數(shù)點(diǎn)（例如：3.0/2）運(yùn)算符號(hào)只適合在數(shù)值中使用，如果放在字符串中就另有其意，后面遇到再說。

關(guān)系運(yùn)算符：

• 小于號(hào)： <,例如： 1 < 2
• 大于號(hào)： >,例如： 2 > 1
• 小于等于號(hào)： <=,例如： 1 <= 1,1小于等于1
• 大于等于號(hào)： >=,例如： 2 >= 2,2大于等于2
• 不等于號(hào)： !=,例如： 1 != 2，1不等于2
• 完全等于號(hào)： ==,例如： 2 == 2，2等于2

注意：運(yùn)算符號(hào)前后建議留出一個(gè)空格。

邏輯運(yùn)算符：

• 邏輯與： and，例如：1 and 2，判斷結(jié)果必須同時(shí)滿足1和2，否則不成立

  • 舉個(gè)小例子：
    # coding=utf-8
    #!/bin/bash/env python

    if 1 == 1 and 1 < 2 :
       print "OK"
    else:
    print "Failed"
    

  • 運(yùn)行上面的腳本，返回值如下：

    
    

  • 將上面的1 < 2改為 1 == 2，再次運(yùn)行腳本，返回值如下：

    
    

  通過以上實(shí)例得知邏輯與（and）必須同時(shí)滿足and前后兩個(gè)條件，才會(huì)成立，否則不成立。

• 邏輯或： or,例如：1 or 2，判斷結(jié)果只要滿足其中一個(gè)就成立

  • 將上面例子中的腳本的and改為or：
    # coding=utf-8
    #!/bin/bash/env python

    if 1 == 1 or 1 == 2 :
       print "OK"
    else:
    print "Failed"
    

  • 再次運(yùn)行一下，返回值如下：

    
    

  通過以上實(shí)例得知邏輯或（or）只要滿足其中一個(gè)條件即可成立。

• 邏輯非： not,例如： not 0，非0，取反

  • 在上面例子中的腳本的or 后面再添加一個(gè)邏輯非（not）：
    # coding=utf-8
    #!/bin/bash/env python

    if 1 == 1 and  not 1 == 2 :
       print "OK"
    else:
    print "Failed"
    

  • 運(yùn)行返回結(jié)果如下：

    
    

  在未添加邏輯非（not）時(shí)，這個(gè)條件是不成立的，因?yàn)?不會(huì)等于2的，添加邏輯非（not）后，告訴1就是不等于2，所以判斷成立，返回OK。

表達(dá)式：

是將不同數(shù)據(jù)（包括變量、函數(shù)）用運(yùn)算符號(hào)按照一定規(guī)則連接起來的一種方式。

• 加號(hào)表達(dá)式： +，用于字符串拼接
  • 如下分別定義一個(gè)變量a = "Hello"，b = "World"，想讓Hello和World變成一句話，可以使用+進(jìn)行拼接：
    >>> a = "Hello"
    >>> b = "World"
    >>> a+b
    'HelloWorld'
• 乘號(hào)表達(dá)式：*，用于字符串重復(fù)出現(xiàn)，*后面跟重復(fù)的次數(shù)
  • 如下定義一個(gè)變量a = "Hello"，我想讓它重復(fù)5次，可以使用a5，如下：
    >>> a = "Hello"
    >>> a5
    'HelloHelloHelloHelloHello'

注意：使用運(yùn)算符號(hào)作為表達(dá)式，進(jìn)行拼接或者重復(fù)出現(xiàn)時(shí)，變量的賦值必須是字符串（也就是等號(hào)后面的值必須用雙引號(hào)""或者單引號(hào)''包起來）

Python數(shù)據(jù)類型

數(shù)字

整型

• 整型int表示的范圍-2，147，483，648到2，147，483，648
  • 例如：1，100，200，-100，-200
• 實(shí)例演示，通過給num賦值123，可以通過type()查看當(dāng)前變量的屬性：
  >>> num=123
  >>> type(num)
  <type 'int'>

長(zhǎng)整型

• 長(zhǎng)整型（long）的范圍很大，幾乎可以說任意大的整數(shù)都可以存儲(chǔ)，當(dāng)定義的數(shù)值超過整型（int）的范圍時(shí)，就會(huì)使用長(zhǎng)整型（long）
• 為了區(qū)分普通整型和長(zhǎng)整型，需要在整數(shù)的后面加大寫L或者小寫l
  • 例如：5145677888L, -0x45677532L,建議使用大寫L，避免數(shù)字1與小寫l混合，造成不必要的麻煩
• 實(shí)例演示,定義給一個(gè)變量num賦值1L，可以通過type()查看當(dāng)前變量的屬性：
  >>> num=1L
  >>> type(num)
  <type 'long'>
  也可以直接給num賦值一個(gè)超過整型(int)范圍的數(shù)值：
  >>> num=99999999999999999999999999999999999999999
  >>> type(num)
  <type 'long'>

浮點(diǎn)型

• 浮點(diǎn)型（float）也就是常說的小數(shù)點(diǎn)類型，例如：3.7.-1.8. 3e+8等等
• 實(shí)例演示，通過定義變量num賦值2.3，可以通過type()查看當(dāng)前變量的屬性：
  >>> num=1.2
  >>> type(num)
  <type 'float'>

復(fù)數(shù)型

• Python對(duì)復(fù)數(shù)（complex）提供內(nèi)嵌支持，這是其他大部分軟件所沒有的,使用拋物線經(jīng)常用到
• 復(fù)數(shù)類型（complex）通過給數(shù)值后面添加j來實(shí)現(xiàn)，如：3.4j,5.67j,32e-56j
• 實(shí)例演示，通過定義變量num賦值2.3j，可以通過type()查看當(dāng)前變量的屬性：
  >>> num=1.2j
  >>> type(num)
  <type 'complex'>

字符串

• 使用引號(hào)（雙引號(hào)""或者單引號(hào)'')定義的一組可以包含數(shù)字，字母，符號(hào)（非特殊符號(hào)）的集合
  • 例如：
    Name = 'My name is Tom'
    Pay = "This is pay"
    Car = """this is a car"""

    • 三重引號(hào)（docstring)""" """通常用來制作字符串后面再詳說。
    • 如果字符串中存在單引號(hào)''時(shí)可以使用雙引號(hào)""``，或者通過轉(zhuǎn)義符`來進(jìn)行轉(zhuǎn)義

序列

• 列表、元組和字符串都是序列
• 序列的兩個(gè)主要特點(diǎn)：索引操作和貼片操作符
  • 索引操作符讓我們可以從哪個(gè)序列中抓取一個(gè)特定的項(xiàng)目
  • 切片操作符讓我嫩能夠獲取序列的一個(gè)切片，即一部分序列

索引

• 索引操作符是序列后跟一個(gè)方括號(hào)[]，方括號(hào)中有一對(duì)可選的數(shù)字
• 索引同樣可是負(fù)數(shù)，位置是從序列尾部開始計(jì)算的
  • 例如，當(dāng)我們想取出a="12345678"中的8，可以這樣做：
    >>> a = "12345678"
    >>> a[7]
    '8'
  • 因?yàn)樗饕梢允秦?fù)數(shù)，也可以這樣取值：
    >>> a[-1]
    '8'

    索引位置從左往右是：01234567，從右往左就是：-1，-2，-3，-4，-5，-6，-7，0

例如：shop[-1]便是序列的最后一個(gè)元素，而shop[-2]抓取到的是序列的倒數(shù)第二個(gè)元素

切片

• 切片操作符是序列后跟一個(gè)方括號(hào)[]，方括號(hào)中有一對(duì)可選的數(shù)字，并用冒號(hào)分割
  • 這與索引操作符很相似，不過需要使用:，并卻是必須的
  • 切片操作符中的第一個(gè)數(shù)（冒號(hào):之前）表示切片開始的位置，第二個(gè)數(shù)（冒號(hào):之后）表示切片到哪里結(jié)束（不包含這個(gè)位置的元素）。如果不指定第一個(gè)數(shù)，Python就從序列的首位開始。如果沒有指定第二個(gè)數(shù)，Python則會(huì)停止在序列的尾部。
    • 例如，定義變量a賦值字符串'12345678'，然后切取23456：
      >>> a = "12345678"
      >>> a[1:6]
      '23456'

      說明：計(jì)算機(jī)中0是默認(rèn)開始位置，所以上述12345678對(duì)應(yīng)的位置就是01234567，當(dāng)我們要切取23456的字符串時(shí)，就得從1開始，按照切片取值定義想取到字符串6就得定位到6（這里的6不是字符串6，是7的位置）
      - 從位置1開始取值，不指定第二個(gè)位置，將會(huì)取到2345678：
      >>> a = "12345678"
      >>> a[1:]
      '2345678'
      - 如果只有[:]將會(huì)打印出所有的值：
      >>> a = "12345678"
      >>> a[:]
      '12345678'
      - 當(dāng)出現(xiàn)[::]時(shí)，后面沒有步長(zhǎng)值，默認(rèn)位置為1，打印效果：
      >>> a = "12345678"
      >>> a[:：]
      '12345678'
      - 當(dāng)[::]里面設(shè)定步長(zhǎng)值后，如設(shè)置步長(zhǎng)值為2：[::2]，打印效果：
      >>> a = "12345678"
      >>> a[:：2]
      '1357'
      >[::2]其實(shí)就是起到步長(zhǎng)值得作用，后面的數(shù)字2就是走兩步取后面一個(gè)值，上述的例子中，從位置1開始取值，然后從1位置走兩步（也就是到位置3）取后面值3，然后從位置3走兩步（也就是位置5）取后面值5，然后從位置5走兩步（也就是位置7）取后面值7，最后取出來為1357.這里所說的走2步就是從位置1開始走到位置2算一步，然后到位置3就是第二步。

序列的基本操作

• len():求序列長(zhǎng)度

  • 例如求a = "12345678"的長(zhǎng)度：
    >>>a = "12345678"
    >>> len(a)
    8

• +:連接2個(gè)序列：

  • 例如：
    >>> a = "Hello"
    >>> b = "World"
    >>> a + b
    'HelloWorld'

• *:重復(fù)序列：

  • 例如將hello重復(fù)5次：
    >>> a = "Hello"
    >>> a*5
    'HelloHelloHelloHelloHello'

• in：判斷元素是否在序列中

  • 例如判斷c是否在a = "Hello"中：
    >>> a = "Hello"
    >>> 'c' in a
    False

    返回Fasle說明不存在

• max():返回最大值

  • 例如查看a = "12345678"中的最大值：
    >>> a = "12345678"
    >>> max(a)
    '8'

• min():返回最小值

  • 例如查看a = "12345678"中的最小值：
    >>> a = "12345678"
    >>> min(a)
    '1'

• cmp(tuple1, tuple2):比較2個(gè)序列的值是否相等

  • 例如判斷a = "3"與b = "4",返回結(jié)果：
    >>> a = "3"
    >>> b = "4"
    >>> cmp(a, b)
    -1
  • 如果a與b換個(gè)位置在進(jìn)行比較一下看下返回結(jié)果：
    >>> cmp(b, a)
    1
  • 如果a和b的值相等，看下返回值：
    >>> a = "3"
    >>> b = "3"
    >>> cmp(b, a)
    0

  通過以上例子可以看出，當(dāng)使用cmp（tuple1，tuple2）進(jìn)行比較的時(shí)候，如果前面的數(shù)值大于后面的會(huì)返回1，小于時(shí)會(huì)返回-1，等于時(shí)會(huì)返回0，另外如果字符串是字母的時(shí)候它一般會(huì)按照英文字母的順序進(jìn)行比對(duì)，通常是后面的字母大于前面的，如：
  >>> a = "c" >>> b = "d" >>> cmp(b, a) 1

元組

• 元組和列表十分相似，只不過元組和字符串一樣是不可變得，即你不能修改元組
• 元組通過圓括號(hào)()和其中的逗號(hào),來分割項(xiàng)目，例如：（1，2，3，4）
• 元組通常用在使語句和用戶定義的函數(shù)能夠安全的采用一組固定（這里的固定式說這組的值不能隨意更改）的值得時(shí)候使用。
• 定義元組可以包含字符串、列表、數(shù)字等，通過逗號(hào),分隔。
• 元組的好處，定義范圍廣
• 元組是不可變類型的數(shù)據(jù)
• 創(chuàng)建元組:

  • 一個(gè)空元組由一對(duì)空的圓括號(hào)( )組成，例如： a = ()

  • 含有單個(gè)元素的元組，如：

    • a = (2,)

    注意：定義一個(gè)單個(gè)元組，元素后面必須有一個(gè)逗號(hào),這個(gè)比較特殊一些。

  • 一般元組, 如：

    • name = ('Tom','Joy','jack')
    • user_pay = ('Tom','egg',20)

  • 可以通過type()函數(shù)來當(dāng)前變量的屬性：
    >>> a = (2,)
    >>> type(a)
    <type 'tuple'>

    • 看到tuple就說明此變量為元組

• 元組操作：
  • 元組和字符串類型一樣都是屬于序列類型，可以通過索引和切片操作
  • 定義好的元組，值不能改變
• 實(shí)例演示，定義一個(gè)元組a = ('Tom',30,'male')

  • 試圖更改元組里面的元素，這里試圖修改一個(gè)值：
    >>> a = ('Tom',30,'male')
    >>> a[1] = 31
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment

    修改其中一個(gè)元素報(bào)錯(cuò)：告訴我們?cè)M是不支持組分配指定的，也就說不能修改。

  • 拆分元組操作：
    >>> a = ('Tom',30,'male')
    >>> name
    'Tom'
    >>> age
    30
    >>> sex
    'male'
    >>> name,age,sex
    ('Tom', 30, 'male')

列表

• 列表(List)是處理一組有序項(xiàng)目的數(shù)據(jù)結(jié)構(gòu)，即你可以在一個(gè)列表中存儲(chǔ)一個(gè)序列的項(xiàng)目
• 列表是可變類型的數(shù)據(jù)
• 列表跟元組一樣，定義范圍廣，元素可以是字符串、數(shù)字，其中也可以有列表和元組，不過元組不能修改
• 列表的組成：用方括號(hào)[]表示列表，包含多個(gè)元素以逗號(hào),分隔，如：
  • List1 = ['Tom','列表',1]
  • List2 = [1,2,3,4,5]
  • List3 = ["python","Linux","wiondows"]
  • List4 = [1]

    列表不像元組，單個(gè)元素的的列表后面需要添加逗號(hào),

  • 以上實(shí)例可以通過type()函數(shù)查看器屬性，返回結(jié)果如下：

    >>> List1 = ['Tom','列表',1]
    >>> type(List1)
    <type 'list'>
    

    >>> List2 = [1,2,3,4,5]
    >>> type(List2)
    <type 'list'>
    

    >>> List3 = ["python","Linux","wiondows"]
    >>> type(List3)
    <type 'list'>
    

    >>> List4 = [1]
    >>> type(List4)
    <type 'list'>
    

• 列表操作方法：
  • 取值：
    • 索引取值：
      定義一個(gè)列表：a = [1,2,3,4,5],通過索引取值：

      >>> a = [1,2,3,4,5]
      >>> a[0]
      1
      >>> a[1]
      2
      >>> a[4]
      5
      

    • 切片取值：
      定義一個(gè)列表：a = [1,2,3,4,5],通過切片取值：
      • 從位置1開始取值，到列表位置結(jié)束：

        >>> a = [1,2,3,4,5]
        >>> a[1:]
        [2, 3, 4, 5]
        

    • 從位置1取值，到位置4：

      >>> a = [1,2,3,4,5]
      >>> a[1:4]
      [2, 3, 4]
      

    • 從位置4結(jié)束取值:

      >>> a = [1,2,3,4,5]
      >>> a[:4]
      [1, 2, 3, 4]
      

    • 使用[::]設(shè)定步長(zhǎng)值取值，此處設(shè)定步長(zhǎng)值為2：

      >>> a = [1,2,3,4,5]
      >>> a[::2]
      [1, 3, 5]
      

      說明：從位置1開始取值（設(shè)定步長(zhǎng)值后，起始位置為1），然后走2步到位置3取值3（位置3的值），然后從位置3開始走2步取值5（位置5的值），這里所說的走2步就是從位置1開始走到位置2算一步，然后到位置3就是第二步。
      - 添加值，使用屬性append來實(shí)現(xiàn)：
      - 定義一個(gè)列表a = [1,2,3,4,5],然后通過append屬性添加值：
      python >>> a = [1,2,3,4,5] >>> a.append(6) >>> a [1, 2, 3, 4, 5, 6]
      >說明：屬性append屬于給列表結(jié)尾追加值，存儲(chǔ)空間會(huì)變化，可通過id來確認(rèn)
      - 刪除值：
      - 使用del刪除列表中的元素：
      python >>> a = [1,2,3,4,5,6] >>> del(a[5]) >>> a [1, 2, 3, 4, 5]
      >del()通過列表索引刪除指定的元素，好處在于如果列表元素太長(zhǎng)，使用del()能快速刪除指定的元素，簡(jiǎn)單明了。而且可以直接刪除整個(gè)列表。
      - 使用remove刪除列表中的元素：
      python >>> a = [1,2,3,4,5] >>> a.remove(5) >>> a [1, 2, 3, 4]
      >remove直接指定列表的元素就可以刪除
      - 修改值：
      - 通過list[] = x來對(duì)列表中的元素進(jìn)行修改：
      python >>> a = [1,2,3,4] >>> a[3] = 5 >>> a [1, 2, 3, 5]
      >通過索引重新賦值即可

  • 修改列表中的元素列表的存儲(chǔ)空間不變（擴(kuò)展說明），例：
    • 定義一個(gè)列表a = [1,2,3,4,5]
    • 首先查看列表a的存儲(chǔ)空間id:

      >>> a = [1,2,3,4,5]
      >>> id(a)
      7696579682248
      

    • 通過索引重新賦值修改其中一個(gè)元素的值：

      >>> a = [1,2,3,4,5]
      >>> a[1] = 6
      >>> a
      [1, 6, 3, 4, 5]
      

    • 再次通過id()來查看列表a的存儲(chǔ)空間id值：

      >>> a = [1,6,3,4,5]
      >>> id(a)
      7696579682248
      

      此時(shí)發(fā)現(xiàn)修改列表a的值后，通過id()查看存儲(chǔ)空間id，未變化
      - 查找值：
      - 通過var in list來查找列表中是否有這個(gè)值：
      Python >>> a = [1,2,3,5] >>> a in a False >>> 5 in a True
      >說明：在列表中查找a，a不存在返回False，查找5存在則返回True

字典

• 字典是python中唯一的映射類型{哈希表}

• 字典對(duì)象是可變的，但是字典的鍵必須使用不可變對(duì)象，并且一個(gè)字典中可以使用不同類型的鍵值

• keys()或者`values()·返回列表或者值列表

• items()返回包含鍵值對(duì)的元組

• 創(chuàng)建字典：

  • 使用花括號(hào){},例如： a = {0:'id',1:'name',2:age'}，執(zhí)行結(jié)果：

    >>> a = {0:'id',1:'name',2:'age'}
    >>> a
    {0: 'id', 1: 'name', 2: 'age'}
    

  • 使用工廠方法dict()，這種方法慢，例如：fdict = dict((['x',1],['y',2])),執(zhí)行結(jié)果：

    >>> fdict = dict((['x',1],['y',2]))
    >>> fdict
    {'y': 2, 'x': 1}
    

    注意：dict()圓括號(hào)里面是映射對(duì)象的(key,value)對(duì)中初始化新字典

    當(dāng)然了也可以在關(guān)鍵列表中使用name=value對(duì)初始化新字典，例如：a = dict(one=1,two=2),執(zhí)行結(jié)果如下：

    >>> a = dict(one=1,two=2)
    >>> a
    {'two': 2, 'one': 1}
    

  • 內(nèi)建方法：fromkeys(),字典中的元素具有相同的值，默認(rèn)為None，例如：num = {}.fromkeys(('x','y'),-1),執(zhí)行結(jié)果：

    >>> num = {}.fromkeys(('x','y'),-1)
    >>> num
    {'y': -1, 'x': -1}
    

• 訪問字典中的值：

  • 直接使用key：key不存在會(huì)報(bào)錯(cuò)，可以使用has_key()或者in和not in判斷，has_key()方法即將被棄用,如判斷字典 a = {'age': 23, 'name': 'guo', 'sex': 'm'}中是否存在鍵值name，執(zhí)行結(jié)果如下：

    >>> a.has_key('name')
    True
    

    當(dāng)然了也可以通過in和not in判斷，判斷鍵值name和aa是否存在在字典a中，執(zhí)行結(jié)果如下：

    >>> 'name' in a
    True
    >>> 'aa' not in a
    True
    

    說明：返回值為True代表存在，Fasle代表不存在

  • 循環(huán)遍歷,；例如：

    for key in dict1.keys():
    

    實(shí)例：

    >>> a = {'name':'guo','age':23,'sex':'m'}
    >>> a
    {'age': 23, 'name': 'guo', 'sex': 'm'}
    >>> a = {'name':'guo','age':23,'sex':'m'}
    >>> a
    {'age': 23, 'name': 'guo', 'sex': 'm'}
    

    打印key值：

    >>> for key in a:
    ...     print key
    ...
    age
    name
    sex
    

    打印value值：

    >>> for key in a:
    ...     a[key]
    ...
    23
    'guo'
    'm'
    

  • 使用迭代器，例如：

    for key in dict1:
    

• 更新和刪除：

  • 直接使用鍵值訪問更新，內(nèi)建的update()方法可以將整個(gè)字典的內(nèi)容拷貝到另一個(gè)字典中，例如將字典b = {'room': 1, 'service': 220, 'number': 202}拷貝到字典a = {'age': 23, 'name': 'guo', 'sex': 'm'}中，執(zhí)行結(jié)果如下：

    >>> a = {'age': 23, 'name': 'guo', 'sex': 'm'}
    >>> b = {'room': 1, 'service': 220, 'number': 202}
    >>> a.update(b)
    >>> a
    {'name': 'guo', 'service': 220, 'room': 1, 'age': 23, 'number': 202, 'sex': 'm'}
    

    說明：字典當(dāng)中是無序排列，所以不管你添加還是修改，最后的輸出都會(huì)與之前的序列不一致

  • del dict1['a']刪除字典中鍵值為a的元素，例如刪除字典d = {'car':'baoma','color':'blue'}中的color鍵和對(duì)應(yīng)的值，執(zhí)行結(jié)果如下：

    >>> d = {'car':'baoma','color':'blue'}
    >>> d
    {'color': 'blue', 'car': 'baoma'}
    >>> del d['color']
    >>> d
    {'car': 'baoma'}
    

    • dict11.pop('a')刪除并返回鍵為'a'的元素，例如刪除字典a = {'car': 'baoma'},執(zhí)行結(jié)果如下：

      >>> a = {'car': 'baoma'}
      >>> d.pop('car')
      'baoma'
      >>> d
      {}
      

    >說明：字典內(nèi)建方法`dict.pop()`與其他內(nèi)建`pop()`有區(qū)別的，具體需要查看help手冊(cè)(`help(object.pop))`
    - `dict1.clear()`刪除字典所有的元素,例如刪除字典d = {'car':'baoma','color':'blue'}中所有的元素，執(zhí)行結(jié)果如下：
     ```python
     >>> d = {'car':'baoma','color':'blue'}
     >>> d
     {'color': 'blue', 'car': 'baoma'}
     >>> d.clear()
     >>> d
     {}
    

    • del dict1刪除整個(gè)字典，例如刪除字典d = {'car':'baoma','color':'blue'}，執(zhí)行結(jié)果如下：

      >>> d = {'car':'baoma','color':'blue'}
      >>> d
      {'color': 'blue', 'car': 'baoma'}
      >>> del d
      >>> d
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      NameError: name 'd' is not defined
      

    >說明：底下報(bào)錯(cuò)d沒有被定義，說明字典d已經(jīng)不存在了
    

  • dict1['a] = 'string'添加一對(duì)鍵值，例如給c = {'id':1,'class':23,'location':345}添加一對(duì)鍵值'pay':45，執(zhí)行結(jié)果如下：

    >>> c = {'id':1,'class':23,'location':345}
    >>> c['pay'] = 45
    >>> c
    {'pay': 45, 'location': 345, 'id': 1, 'class': 23}
    

• 字典相關(guān)的內(nèi)建函數(shù)：

  • type()、str()、cmp()（cmp很少用于字典比較，
    比較依次是字典的大小、鍵、值）。
  • 工廠函數(shù)dict()，例如：a = dict((['x','y'],[1,2]))，b = (one=1,two=2),執(zhí)行結(jié)果如下：

    >>> a = dict((['x','y'],[1,2]))
    >>> a
    {'x': 'y', 1: 2}
    

    >>> b = dict(one=1,two=2)
    >>> b
    {'two': 2, 'one': 1}
    

  • 使用dict()生成字典比用copy慢，因此這種情況下推薦使用copy()`，例如：將字典 t = {'x':1,'y':2}的元素拷貝給新的字典c，使其擁有字典t一樣的鍵值，執(zhí)行結(jié)果如下：

    >>> t = {'x':1,'y':2}
    >>> c = t.copy()
    >>> c
    {'y': 2, 'x': 1}
    

  說明：copy()屬于字典內(nèi)建函數(shù)，所以直接使用help(copy)是無法查看其幫助信息的，應(yīng)該是help(t.copy)才能查看其幫助信息，這個(gè)與python中import copy有區(qū)別的，雖然用法差不多一樣，簡(jiǎn)單說，查看字典內(nèi)建函數(shù)的幫助信息用法help(t.copy)其中的t是字典的對(duì)象，copy是其內(nèi)建方法（也就是內(nèi)建函數(shù)）

  • 具體事例如下，首先得創(chuàng)建一個(gè)字典，如：a = {'x':1,'y':2}

  • 先查看字典a對(duì)象的所有的幫助信息，執(zhí)行以下步驟：

    >>> help(a)
    Help on dict object:
    
    class dict(object)
    

  | dict() -> new empty dictionary
  | dict(mapping) -> new dictionary initialized from a mapping object's
  | (key, value) pairs
  | dict(iterable) -> new dictionary initialized as if via:
  | d = {}
  | for k, v in iterable:
  | d[k] = v
  | dict(**kwargs) -> new dictionary initialized with the name=value pairs
  | in the keyword argument list. For example: dict(one=1, two=2)
  |
  | Methods defined here:
  |
  | cmp(...)
  | x.cmp(y) <==> cmp(x,y)
  |
  | contains(...)
  | D.contains(k) -> True if D has a key k, else False
  |
  | delitem(...)
  | x.delitem(y) <==> del x[y]

  ......

  | clear(...)
  | D.clear() -> None. Remove all items from D.
  |
  | copy(...)
  | D.copy() -> a shallow copy of D
  |
  | fromkeys(...)
  | dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
  | v defaults to None.

  >說明：這就顯示當(dāng)前字典`a`所有的類和方法的幫助信息
  
  - 查看字典中`copy()`的幫助信息，執(zhí)行一下步驟：
  ```python
  >>> help(a.copy)
  Help on built-in function copy:
  
  copy(...)
      D.copy() -> a shallow copy of D
  (END)
  

  說明：這里面就是字典內(nèi)建函數(shù)copy()的查看幫助信息，其他的也是這樣弄得，執(zhí)行命令就得字典對(duì)象.內(nèi)建函數(shù)(),例：a.copy()

• 字典內(nèi)建函數(shù)方法小結(jié)：

  • len()，輸出字典長(zhǎng)度，其實(shí)也是系統(tǒng)內(nèi)建函數(shù),列表、元組變量都能使用，使用方法：len(object)，例如：

    >>> a = {'x':1,'y':2}
    >>>  len(a)
    2
    

    說明：len()輸出的長(zhǎng)度在字典中是按一對(duì)鍵值來輸出的，在列表、元組】變量中是按照里面的元素計(jì)算輸出的，也就是說一對(duì)鍵值就是一個(gè)長(zhǎng)度

  • hash,系統(tǒng)內(nèi)建函數(shù)，用于判斷某個(gè)對(duì)象是否可以做一個(gè)字典的建，非哈希類型的報(bào)TypeError錯(cuò)誤，使用方法hash(object),例如：

    >>> a = {'x':1,'y':2}
    >>> hash(a)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'dict'
    

    >>> a = {'x':1,'y':2}
    >>> hash(3)
    3
    

    備注簡(jiǎn)單說只要hash的對(duì)象結(jié)果有返回值，并且不報(bào)錯(cuò)就可以最為一個(gè)字典的鍵值使用，hash(object)也可用配合關(guān)系運(yùn)算符判斷兩個(gè)對(duì)象是否相等（對(duì)于兩對(duì)象使用這個(gè)，感覺有點(diǎn)多次一舉，具體的后面研究了再說把）

  • dict.has_key(key)判斷字典中是否存在key（建議使用in和not in代替）,他屬于字典內(nèi)建函數(shù)方法，使用方法：

    >>> a = {'x':1,'y':2}
    >>> a.has_key(2)
    False
    >>> a.has_key('x')
    True
    >>> a.has_key('y')
    True
    

    備注：其實(shí)這個(gè)前面已經(jīng)說過的，這個(gè)后續(xù)會(huì)擯棄這個(gè)方法的

  • dict.items()返回鍵值對(duì)元組的列表，屬于字典內(nèi)建函數(shù)方法，例如：

    >>> a = {'x':1,'y':2}
    >>> a.items()
    [('y', 2), ('x', 1)]
    

    說明：也就是說將字典里面的鍵值對(duì)組成元組，最后以一個(gè)列表的形式輸出

  • dict.iter*()（里面的星號(hào)代表后面有個(gè)方法名稱），返回迭代子而不是列表，使用方法：
    • dict.iteritems()：

      >>> a = {'x':1,'y':2}
      >>> a.iteritems()
      <dictionary-itemiterator object at 0x6ffffbb8f70>
      

    • dict.iterkeys():

      >>> a = {'x':1,'y':2}
      >>> a.iterkeys()
      <dictionary-keyiterator object at 0x6ffffbb8fc8>
      

    • dict.itervalues():

      >>> a = {'x':1,'y':2}
      >>> a.itervalues()
      <dictionary-valueiterator object at 0x6ffffbb8f70>
      

      備注：這個(gè)有點(diǎn)高大上了，這個(gè)迭代子目前不知道具體是干嘛用的，

  • dict.get(key[,default=none]),返回key的值，如果不存在返回default指定的值（命令中幫助參數(shù)中的[]代表可選，可有可無），這里的default指定是說當(dāng)key不存在的時(shí)候，你可以任意指定一個(gè)返回值，例如：

    >>> a = {'x':1,'y':2}
    >>> a.get('x')
    1
    >>> a.get('z', 'z is not exist')
    'z is not exist'
    

    說明：第一次get x鍵值，因?yàn)榇嬖冢苑祷豿鍵的值1，第二次get z，不存在，默認(rèn)是返回none，也就是返回結(jié)果不會(huì)有任何提示，為了友好點(diǎn)，我們就指定一個(gè)不存在的提示語，執(zhí)行后悔看到我們指定的提示語：'z is not exist'

  • 其他字典內(nèi)建的函數(shù)方法，就不再說了，可以使用help(object)（這里的object就是字典的對(duì)象，如：a = {'x':1,'y':2}，對(duì)象就是a）查看所有的類和方法，英文的不明白，推薦去RUNOOB.COM看下，這里講的可比我總結(jié)的詳細(xì)，我這是自己學(xué)習(xí)總結(jié)為了加深學(xué)習(xí)記憶而已。

流程控制

• if語句：

  • Python的if語句類似于其他語言，if語句包含一個(gè)邏輯表達(dá)式，使用表達(dá)式比較，在比較的結(jié)果的基礎(chǔ)上做出決定。
  • 語法格式：

    if expression: 如果表達(dá)式(等于、不等于、大于、小于、存在、不存在等)滿足條件
        statement(s) 聲明（執(zhí)行代碼或者顯示需要顯示的結(jié)果)
    

    說明：Python語言使用縮進(jìn)作為其語句（代碼塊）分組的方法，建議使用4個(gè)空格代替其他縮進(jìn)格式（這也是官方推薦的，主要是為了兼容跨平臺(tái)），縮進(jìn)相同的被認(rèn)為是一個(gè)代碼塊。

  • 實(shí)例，判斷1>2：如下：

    >>> if 1 < 2:
    ...     print "1 小于 2正確"
    ...
    1 小于 2正確
    

    注意：python當(dāng)中的if語句跟其他語言的格式可能有點(diǎn)區(qū)別的，比如shell當(dāng)中是這樣的：
    if expression; then statement(s) fi

• if語句常用的邏輯值表達(dá)式（bool）：

  • 邏輯值（bool）用來表示諸如：對(duì)與錯(cuò)、真與假、空與非空等概念
  • 邏輯值包含了兩個(gè)值：
    • True：表示非空的量（string，tuple，list，set，dictonary等），所有非空零數(shù)
    • False：表示0，None，空的量等
  • 作用：主要用在判斷語句中進(jìn)行判斷：
    • 一個(gè)字符串是否空的
    • 一個(gè)運(yùn)算是否為零
    • 一個(gè)表達(dá)式是否可用

  說明：True就是真實(shí)存在的，比如：判斷1<2，本來1肯定小于2，所以結(jié)果肯定是True了，F(xiàn)alse就是不存在，例如：1>2，根本不可能的，所以結(jié)果是False

  • 實(shí)例：
    • 判斷條件為True，查看返回結(jié)果：

      # vi python.py
      #!/bin/env python
      
      if True:
          print "True is ok"
      print "Fasle and True"
      

      # python python.py
      True is ok
      Fasle and True
      

    >備注：當(dāng)條件為True時(shí)，所有的print都返回,這里寫在3腳本是為直觀
    

  • 判斷條件為False，查看返回結(jié)果：

    # vi python
    #!/bin/env python
    
     if True:
         print "True is ok"
     print "Fasle and True"
    

    # python python
    Fasle and True
    

  備注：此時(shí)，當(dāng)條件為False時(shí)，返回結(jié)果只print "Fasle and True"，之所以這里還會(huì)仍舊顯示這個(gè)，是因?yàn)?code>print "Fasle and True"跟if同級(jí)別的，不在if的判斷里面

• else語句：

  • else語句不能單獨(dú)使用，必須配合if使用
  • 語法格式：

    if expression:   如果表達(dá)式成立
        statement(s) 執(zhí)行代碼
    else:            否則 
        statement(s) 執(zhí)行這個(gè)代碼
    

  備注：else是個(gè)可選的語句，并且一個(gè)if語句中只能使用一個(gè)else語句

  • 實(shí)例：
    判斷如果用戶輸入一個(gè)數(shù)字1返回ok，否則返回error：

    # cat p.py
    #!/bin/env python
    
    a = raw_input("please input number: ")
    
    if a == "1":
        print "your input is ok"
    else:
        print "your input is Error"
    

    # python p.py
    please input number: 1
    your input is ok
    

  python p.py

  please input number: 2
  your input is ok

• elif語句：

  • elif語句存在的意義，當(dāng)需要多個(gè)表達(dá)式為真值時(shí)執(zhí)行一段代碼，elif可以存在多個(gè)，并且它也是可選的，比如說,當(dāng)用戶輸入1-5的數(shù)字時(shí)，執(zhí)行一段代碼告訴他相對(duì)應(yīng)的結(jié)果，否則就告訴他失敗

  • 語法格式：

    if expression:     如果滿足條件
        statement(s)   執(zhí)行這個(gè)代碼
    elif expression2:  如果也滿足這個(gè)條件
        statement(s)   執(zhí)行這個(gè)代碼
    elif expression3:
        statement(s)
    ......
    else:              否則
        statement(s)   執(zhí)行這個(gè)代碼
    

  • 實(shí)例：：
    判斷如果用戶輸入1-5就返回相應(yīng)的結(jié)果，否則就返回error：

    # vi p.py
    #!/bin/env python
    
    a = int(raw_input("pleae your number: "))
    
    if a == 1:
        print "your input number is 1 ok"
    elif a == 2:
        print "your input number is 2 ok"
    elif a == 3:
        print "your input number is 3 ok"
    elif a == 4:
        print "your input number is 4 ok"
    elif a == 5:
        print "your input number is 5 ok"
    else:
        print "your input number is %s error" % a
    

    # python p.py
    pleae your number: 1
    your input number is 1 ok
    

    # python p.py
    pleae your number: 6
    your input number is 6 error
    

    備注：就演示一下輸入1和輸入6就可以達(dá)到目的了,這里面的%s和%輸出格式化的字符串和格式化字符串