Python簡介
Python歷史
Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷蘭國家數學和計算機科學研究所設計出來的。
Python 本身也是由諸多其他語言發展而來的,這包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的腳本語言等等。
像 Perl 語言一樣，Python 源代碼同樣遵循 GPL(GNU General Public License)協議。
現在 Python 是由一個核心開發團隊在維護，Guido van Rossum 仍然占據著至關重要的作用，指導其進展。
目前流行的是Python2.x，最新的Python目前是Python3.x。
Python特征
- 易于學習：Python有相對較少的關鍵字，結構簡單，和一個明確定義的語法，學習起來更加簡單。
- 易于閱讀：Python代碼定義的更清晰。
- 易于維護：Python的成功在于它的源代碼是相當容易維護的。
- 一個廣泛的標準庫：Python的最大的優勢之一是豐富的庫，跨平臺的，在UNIX，Windows和Macintosh兼容很好。
- 互動模式：互動模式的支持，您可以從終端輸入執行代碼并獲得結果的語言，互動的測試和調試代碼片斷。
- 可移植：基于其開放源代碼的特性，Python已經被移植（也就是使其工作）到許多平臺。
- 可擴展：如果你需要一段運行很快的關鍵代碼，或者是想要編寫一些不愿開放的算法，你可以使用C或C++完成那部分程序，然后從你的Python程序中調用。
- 數據庫：Python提供所有主要的商業數據庫的接口。
- GUI編程：Python支持GUI可以創建和移植到許多系統調用。
- 可嵌入: 你可以將Python嵌入到C/C++程序，讓你的程序的用戶獲得"腳本化"的能力。
- 解釋性和編譯性：Python語言寫的程序不需要編譯成二進制代碼，可以直接運從源代碼運行程序，但是需要解釋器。這點類似于Java，或者Matlab。Python也可以編譯后執行程序，這樣速度優于直接從源代碼執行的速度。
- 面向對象編程：Python支持面向過程的編程也支持面向對象的編程。與其他的語言如C++和Java相比，Python以一種非常強大而又簡單的方式實現面向對象編程。
- 高級語言：使用Python語言編寫程序，無需考慮諸如管理內存一類的底層。
- 豐富的庫：
Python應用場景
國外：
- Google：實現Web爬蟲和搜索引擎中的很多組件
- YaHoo： 管理討論組以及其他技術
- NASA：NASA在他的幾個系統中既實用Python開發，又作為腳本語言
- YouTube： 視頻分享服務大部分都是由Python編寫的
國內：
- 豆瓣：前后臺使用Python
- 還有其他很多的現在也是用Python作為前后臺開發的
Python安裝
Linux下Python環境搭建
大多數Linux發行版都默認自帶Python，一般都是Python2.x
如果沒有安裝可以通過源碼進行安裝：
# ./configure --prefix=/usr/local
# make && make install
# make clean
# make distclean
然后命令行直接輸入python，打開python解釋器，如圖：
說明：因為當前沒有linux環境，就使用cywin演示了一下，效果是跟linux的一樣的。
Windows下Python環境搭建
Windows下安裝很方便，根據系統版本可下載相對應的Python MSI的安裝包，按照步驟點擊下一步，即可，默認安裝在c:\Python2.x目錄，不建議更改它的安裝目錄。
注意：在安裝的過程最好勾選path那個選項，這樣Python在安裝完畢會自動建立系統環境變量，這樣直接通過cmd窗口就可以輸入python，打開Python解釋器。
安裝完畢通過cmd窗口打開python，如圖：
Python的文件類型
- 源代碼：Python的源代碼文件以"py"為擴展名，由Python程序解釋，不需要編譯，可直接運行，特點：可直接運行，方便修改源代碼
- 字節代碼：Python源文件經過編譯后生成的擴展名為"pyc"的文件，特點：運行速度快
編譯方法：
import py_compile
py_compile("hello.py") - 優化代碼：經過優化后的源文件擴展名為".pyo"，特點：運行速度快
優化方法：
python -O -m py_compile hello.py - 以上三種均可以直接運行
Python變量
變量就是給數據起一個名字，寫過shell腳本的，應該知道其中的變量，跟他類似。
變量是計算機內存中的一塊區域，變量可以存儲規定范圍內的值，而且值可以改變。
變量的命名：
- 變量名可由字母、數字、下劃線組成
- 數字不能開頭
- 不可以使用關鍵字
變量的賦值：
- 是變量聲明和定義的過程
實例演示：
>>>a = 1
>>>a
1
說明：給變量a賦值為1，并顯示變量a的賦值結果，相當于我有個同學叫1，但是我先麻煩，所以我就給他另起了一個名稱a，這樣我直接叫a就可以了，當然叫1也行。變量賦值中間的等號嚴格意義上需要前后有空格，當然沒有空格也行，推薦加空格。
設定變量的好處：
方便在腳本或者程序中，簡化數據長度或者便于一次性修改腳本或者程序中多次使用的值。
舉個簡單的例子，如下：
# coding=utf-8
#!/bin/bash/env python
#設定變量a并賦值為50
a = 50
print "我買本Python學習書籍價格"， a
print "我喝的可樂價格"， a
print "我買的車價格是"， a
在上述的腳本中，如果價格發生變化，你是不是得每行去修改，如果內容多，那是不是更麻煩，為了減少這種不必要的操作浪費時間，就在開頭設定變量a，然后賦值價格，這樣，如果價格發生變化我們只需要修改變量a的值即可。簡化數據這個有點跟這個相似，就是如果值的的數據很長，這樣會增加代碼的可讀性難度，設定變量就容易多了。
運算符和表達式
賦值運算符：
- 賦值運算符符號：
= - 最常見的就是對于變量賦值，如： a = 1
算數運算符：
算術運算符的優先級跟往常的算數運算符優先級一樣，遇到其他特殊的網上再查下，后面再整理。
- 加法：
+,例如： x+y - 加等于:
+=,例如：x += 2相當于x = x+2 - 減法：
-,例如： x -y - 減等于:
-=,例如：x -= 2相當于x = x-2 - 乘法：
*,例如： x*y - 乘等于:
*=,例如：x = 2相當于x = x2 - 實數除法：
/,例如： 3/2,3.0/2 - 整除法：
//,例如： 5.6/2，5.6//2 - 除等于:
/=,例如：x /= 2相當于x = x/2 - 求余數：
%,例如： 17%8余1 - 求余等于：
%=，例如：x %= 2相當于x = x%2 - 求冪運算:
**,例如： 2**3 = 8
注意：使用除法的時候默認是整除，如果想帶小數點，后面必須添加小數點（例如：3.0/2）運算符號只適合在數值中使用，如果放在字符串中就另有其意，后面遇到再說。
關系運算符：
- 小于號：
<,例如： 1 < 2 - 大于號：
>,例如： 2 > 1 - 小于等于號：
<=,例如： 1 <= 1,1小于等于1 - 大于等于號：
>=,例如： 2 >= 2,2大于等于2 - 不等于號：
!=,例如： 1 != 2，1不等于2 - 完全等于號：
==,例如： 2 == 2，2等于2
注意：運算符號前后建議留出一個空格。
邏輯運算符：
- 邏輯與：
and，例如：1 and 2，判斷結果必須同時滿足1和2，否則不成立-
舉個小例子：
# coding=utf-8
#!/bin/bash/env pythonif 1 == 1 and 1 < 2 : print "OK" else: print "Failed" -
運行上面的腳本，返回值如下：
-
將上面的1 < 2改為 1 == 2，再次運行腳本，返回值如下：
通過以上實例得知邏輯與（and）必須同時滿足and前后兩個條件，才會成立，否則不成立。
-
- 邏輯或：
or,例如：1 or 2，判斷結果只要滿足其中一個就成立-
將上面例子中的腳本的and改為or：
# coding=utf-8
#!/bin/bash/env pythonif 1 == 1 or 1 == 2 : print "OK" else: print "Failed" -
再次運行一下，返回值如下：
通過以上實例得知邏輯或（or）只要滿足其中一個條件即可成立。
-
- 邏輯非：
not,例如： not 0，非0，取反-
在上面例子中的腳本的or 后面再添加一個邏輯非（not）：
# coding=utf-8
#!/bin/bash/env pythonif 1 == 1 and not 1 == 2 : print "OK" else: print "Failed" -
運行返回結果如下：
在未添加邏輯非（not）時，這個條件是不成立的，因為1不會等于2的，添加邏輯非（not）后，告訴1就是不等于2，所以判斷成立，返回OK。
-
表達式：
是將不同數據（包括變量、函數）用運算符號按照一定規則連接起來的一種方式。
- 加號表達式：
+，用于字符串拼接- 如下分別定義一個變量a = "Hello"，b = "World"，想讓Hello和World變成一句話，可以使用
+進行拼接：
>>> a = "Hello"
>>> b = "World"
>>> a+b
'HelloWorld'
- 如下分別定義一個變量a = "Hello"，b = "World"，想讓Hello和World變成一句話，可以使用
- 乘號表達式：
*，用于字符串重復出現，*后面跟重復的次數- 如下定義一個變量a = "Hello"，我想讓它重復5次，可以使用a5，如下：
>>> a = "Hello"
>>> a5
'HelloHelloHelloHelloHello'
- 如下定義一個變量a = "Hello"，我想讓它重復5次，可以使用a5，如下：
注意：使用運算符號作為表達式，進行拼接或者重復出現時，變量的賦值必須是字符串（也就是等號后面的值必須用雙引號
""或者單引號''包起來）
Python數據類型
數字
整型
- 整型
int表示的范圍-2，147，483，648到2，147，483，648- 例如：1，100，200，-100，-200
- 實例演示，通過給num賦值123，可以通過
type()查看當前變量的屬性：
>>> num=123
>>> type(num)
<type 'int'>
長整型
- 長整型（long）的范圍很大，幾乎可以說任意大的整數都可以存儲，當定義的數值超過整型（int）的范圍時，就會使用長整型（long）
- 為了區分普通整型和長整型，需要在整數的后面加大寫
L或者小寫l- 例如：5145677888L, -0x45677532L,建議使用大寫
L，避免數字1與小寫l混合，造成不必要的麻煩
- 例如：5145677888L, -0x45677532L,建議使用大寫
- 實例演示,定義給一個變量num賦值1L，可以通過type()查看當前變量的屬性：
>>> num=1L
>>> type(num)
<type 'long'>
也可以直接給num賦值一個超過整型(int)范圍的數值：
>>> num=99999999999999999999999999999999999999999
>>> type(num)
<type 'long'>
浮點型
- 浮點型（float）也就是常說的小數點類型，例如：3.7.-1.8. 3e+8等等
- 實例演示，通過定義變量num賦值2.3，可以通過type()查看當前變量的屬性：
>>> num=1.2
>>> type(num)
<type 'float'>
復數型
- Python對復數（complex）提供內嵌支持，這是其他大部分軟件所沒有的,使用拋物線經常用到
- 復數類型（complex）通過給數值后面添加
j來實現，如：3.4j,5.67j,32e-56j - 實例演示，通過定義變量num賦值2.3j，可以通過type()查看當前變量的屬性：
>>> num=1.2j
>>> type(num)
<type 'complex'>
字符串
- 使用引號（雙引號
""或者單引號'')定義的一組可以包含數字，字母，符號（非特殊符號）的集合- 例如：
Name = 'My name is Tom'
Pay = "This is pay"
Car = """this is a car"""- 三重引號（docstring)
""" """通常用來制作字符串后面再詳說。 - 如果字符串中存在單引號
''時可以使用雙引號""``，或者通過轉義符`來進行轉義
- 三重引號（docstring)
- 例如：
序列
- 列表、元組和字符串都是序列
- 序列的兩個主要特點：索引操作和貼片操作符
- 索引操作符讓我們可以從哪個序列中抓取一個特定的項目
- 切片操作符讓我嫩能夠獲取序列的一個切片，即一部分序列
索引
- 索引操作符是序列后跟一個方括號
[]，方括號中有一對可選的數字 - 索引同樣可是負數，位置是從序列尾部開始計算的
- 例如，當我們想取出a="12345678"中的8，可以這樣做：
>>> a = "12345678"
>>> a[7]
'8' - 因為索引可以是負數，也可以這樣取值：
>>> a[-1]
'8'索引位置從左往右是：01234567，從右往左就是：-1，-2，-3，-4，-5，-6，-7，0
- 例如，當我們想取出a="12345678"中的8，可以這樣做：
例如：shop[-1]便是序列的最后一個元素，而shop[-2]抓取到的是序列的倒數第二個元素
切片
- 切片操作符是序列后跟一個方括號
[]，方括號中有一對可選的數字，并用冒號分割- 這與索引操作符很相似，不過需要使用
:，并卻是必須的 - 切片操作符中的第一個數（冒號
:之前）表示切片開始的位置，第二個數（冒號:之后）表示切片到哪里結束（不包含這個位置的元素）。如果不指定第一個數，Python就從序列的首位開始。如果沒有指定第二個數，Python則會停止在序列的尾部。- 例如，定義變量a賦值字符串'12345678'，然后切取23456：
>>> a = "12345678"
>>> a[1:6]
'23456'說明：計算機中
0是默認開始位置，所以上述12345678對應的位置就是01234567，當我們要切取23456的字符串時，就得從1開始，按照切片取值定義想取到字符串6就得定位到6（這里的6不是字符串6，是7的位置）
- 從位置1開始取值，不指定第二個位置，將會取到2345678：
>>> a = "12345678"
>>> a[1:]
'2345678'
- 如果只有[:]將會打印出所有的值：
>>> a = "12345678"
>>> a[:]
'12345678'
- 當出現[::]時，后面沒有步長值，默認位置為1，打印效果：
>>> a = "12345678"
>>> a[:：]
'12345678'
- 當[::]里面設定步長值后，如設置步長值為2：[::2]，打印效果：
>>> a = "12345678"
>>> a[:：2]
'1357'
>[::2]其實就是起到步長值得作用，后面的數字2就是走兩步取后面一個值，上述的例子中，從位置1開始取值，然后從1位置走兩步（也就是到位置3）取后面值3，然后從位置3走兩步（也就是位置5）取后面值5，然后從位置5走兩步（也就是位置7）取后面值7，最后取出來為1357.這里所說的走2步就是從位置1開始走到位置2算一步，然后到位置3就是第二步。
- 例如，定義變量a賦值字符串'12345678'，然后切取23456：
- 這與索引操作符很相似，不過需要使用
序列的基本操作
-
len():求序列長度- 例如求a = "12345678"的長度：
>>>a = "12345678"
>>> len(a)
8
- 例如求a = "12345678"的長度：
-
+:連接2個序列：- 例如：
>>> a = "Hello"
>>> b = "World"
>>> a + b
'HelloWorld'
- 例如：
-
*:重復序列：- 例如將hello重復5次：
>>> a = "Hello"
>>> a*5
'HelloHelloHelloHelloHello'
- 例如將hello重復5次：
-
in：判斷元素是否在序列中- 例如判斷c是否在a = "Hello"中：
>>> a = "Hello"
>>> 'c' in a
False返回Fasle說明不存在
- 例如判斷c是否在a = "Hello"中：
-
max():返回最大值- 例如查看a = "12345678"中的最大值：
>>> a = "12345678"
>>> max(a)
'8'
- 例如查看a = "12345678"中的最大值：
-
min():返回最小值- 例如查看a = "12345678"中的最小值：
>>> a = "12345678"
>>> min(a)
'1'
- 例如查看a = "12345678"中的最小值：
-
cmp(tuple1, tuple2):比較2個序列的值是否相等- 例如判斷a = "3"與b = "4",返回結果：
>>> a = "3"
>>> b = "4"
>>> cmp(a, b)
-1 - 如果a與b換個位置在進行比較一下看下返回結果：
>>> cmp(b, a)
1 - 如果a和b的值相等，看下返回值：
>>> a = "3"
>>> b = "3"
>>> cmp(b, a)
0
通過以上例子可以看出，當使用
cmp（tuple1，tuple2）進行比較的時候，如果前面的數值大于后面的會返回1，小于時會返回-1，等于時會返回0，另外如果字符串是字母的時候它一般會按照英文字母的順序進行比對，通常是后面的字母大于前面的，如：
>>> a = "c" >>> b = "d" >>> cmp(b, a) 1 - 例如判斷a = "3"與b = "4",返回結果：
元組
- 元組和列表十分相似，只不過元組和字符串一樣是不可變得，即你不能修改元組
- 元組通過圓括號
()和其中的逗號,來分割項目，例如：（1，2，3，4） - 元組通常用在使語句和用戶定義的函數能夠安全的采用一組固定（這里的固定式說這組的值不能隨意更改）的值得時候使用。
- 定義元組可以包含字符串、列表、數字等，通過逗號
,分隔。 - 元組的好處，定義范圍廣
- 元組是不可變類型的數據
- 創建元組:
一個空元組由一對空的圓括號
( )組成，例如： a = ()-
含有單個元素的元組，如：
- a = (2
,)
注意：定義一個單個元組，元素后面必須有一個逗號
,這個比較特殊一些。 - a = (2
-
一般元組, 如：
- name = ('Tom','Joy','jack')
- user_pay = ('Tom','egg',20)
-
可以通過type()函數來當前變量的屬性：
>>> a = (2,)
>>> type(a)
<type 'tuple'>- 看到tuple就說明此變量為元組
- 元組操作：
- 元組和字符串類型一樣都是屬于序列類型，可以通過索引和切片操作
- 定義好的元組，值不能改變
- 實例演示，定義一個元組a = ('Tom',30,'male')
-
試圖更改元組里面的元素，這里試圖修改一個值：
>>> 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修改其中一個元素報錯：告訴我們元組是不支持組分配指定的，也就說不能修改。
拆分元組操作：
>>> a = ('Tom',30,'male')
>>> name
'Tom'
>>> age
30
>>> sex
'male'
>>> name,age,sex
('Tom', 30, 'male')
-
列表
- 列表(List)是處理一組有序項目的數據結構，即你可以在一個列表中存儲一個序列的項目
- 列表是可變類型的數據
- 列表跟元組一樣，定義范圍廣，元素可以是字符串、數字，其中也可以有列表和元組，不過元組不能修改
- 列表的組成：用方括號
[]表示列表，包含多個元素以逗號,分隔，如：- List1 = ['Tom','列表',1]
- List2 = [1,2,3,4,5]
- List3 = ["python","Linux","wiondows"]
- List4 = [1]
列表不像元組，單個元素的的列表后面需要添加逗號
, - 以上實例可以通過
type()函數查看器屬性，返回結果如下：>>> 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'>
- 列表操作方法：
- 取值：
- 索引取值：
定義一個列表：a = [1,2,3,4,5],通過索引取值：>>> a = [1,2,3,4,5] >>> a[0] 1 >>> a[1] 2 >>> a[4] 5 - 切片取值：
定義一個列表：a = [1,2,3,4,5],通過切片取值：- 從位置1開始取值，到列表位置結束：
>>> a = [1,2,3,4,5] >>> a[1:] [2, 3, 4, 5]
- 從位置1開始取值，到列表位置結束：
- 從位置1取值，到位置4：
>>> a = [1,2,3,4,5] >>> a[1:4] [2, 3, 4] - 從位置4結束取值:
>>> a = [1,2,3,4,5] >>> a[:4] [1, 2, 3, 4] - 使用
[::]設定步長值取值，此處設定步長值為2：>>> a = [1,2,3,4,5] >>> a[::2] [1, 3, 5]說明：從位置1開始取值（設定步長值后，起始位置為1），然后走2步到位置3取值3（位置3的值），然后從位置3開始走2步取值5（位置5的值），這里所說的走2步就是從位置1開始走到位置2算一步，然后到位置3就是第二步。
- 添加值，使用屬性append來實現：
- 定義一個列表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屬于給列表結尾追加值，存儲空間會變化，可通過id來確認
- 刪除值：
- 使用del刪除列表中的元素：
python >>> a = [1,2,3,4,5,6] >>> del(a[5]) >>> a [1, 2, 3, 4, 5]
>del()通過列表索引刪除指定的元素，好處在于如果列表元素太長，使用del()能快速刪除指定的元素，簡單明了。而且可以直接刪除整個列表。
- 使用remove刪除列表中的元素：
python >>> a = [1,2,3,4,5] >>> a.remove(5) >>> a [1, 2, 3, 4]
>remove直接指定列表的元素就可以刪除
- 修改值：
- 通過list[] = x來對列表中的元素進行修改：
python >>> a = [1,2,3,4] >>> a[3] = 5 >>> a [1, 2, 3, 5]
>通過索引重新賦值即可
- 索引取值：
- 修改列表中的元素列表的存儲空間不變（擴展說明），例：
- 定義一個列表a = [1,2,3,4,5]
- 首先查看列表a的存儲空間id:
>>> a = [1,2,3,4,5] >>> id(a) 7696579682248 - 通過索引重新賦值修改其中一個元素的值：
>>> a = [1,2,3,4,5] >>> a[1] = 6 >>> a [1, 6, 3, 4, 5] - 再次通過
id()來查看列表a的存儲空間id值：>>> a = [1,6,3,4,5] >>> id(a) 7696579682248此時發現修改列表a的值后，通過
id()查看存儲空間id，未變化
- 查找值：
- 通過var in list來查找列表中是否有這個值：
Python >>> a = [1,2,3,5] >>> a in a False >>> 5 in a True
>說明：在列表中查找a，a不存在返回False，查找5存在則返回True
- 取值：
字典
字典是python中唯一的映射類型
{哈希表}字典對象是可變的，但是字典的鍵必須使用不可變對象，并且一個字典中可以使用不同類型的鍵值
keys()或者`values()·返回列表或者值列表items()返回包含鍵值對的元組-
創建字典：
-
使用花括號
{},例如： a = {0:'id',1:'name',2:age'}，執行結果：>>> a = {0:'id',1:'name',2:'age'} >>> a {0: 'id', 1: 'name', 2: 'age'} -
使用工廠方法
dict()，這種方法慢，例如：fdict = dict((['x',1],['y',2])),執行結果：>>> fdict = dict((['x',1],['y',2])) >>> fdict {'y': 2, 'x': 1}注意：
dict()圓括號里面是映射對象的(key,value)對中初始化新字典當然了也可以在關鍵列表中使用
name=value對初始化新字典，例如：a = dict(one=1,two=2),執行結果如下：>>> a = dict(one=1,two=2) >>> a {'two': 2, 'one': 1} -
內建方法：
fromkeys(),字典中的元素具有相同的值，默認為None，例如：num = {}.fromkeys(('x','y'),-1),執行結果：>>> num = {}.fromkeys(('x','y'),-1) >>> num {'y': -1, 'x': -1}
-
-
訪問字典中的值：
- 直接使用
key：key不存在會報錯，可以使用has_key()或者in和not in判斷，has_key()方法即將被棄用,如判斷字典 a = {'age': 23, 'name': 'guo', 'sex': 'm'}中是否存在鍵值name，執行結果如下：
當然了也可以通過>>> a.has_key('name') Truein和not in判斷，判斷鍵值name和aa是否存在在字典a中，執行結果如下：>>> 'name' in a True >>> 'aa' not in a True說明：返回值為
True代表存在，Fasle代表不存在 - 循環遍歷,；例如：
實例：for key in dict1.keys():
打印key值：>>> 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'}
打印value值：>>> for key in a: ... print key ... age name sex>>> for key in a: ... a[key] ... 23 'guo' 'm' - 使用迭代器，例如：
for key in dict1:
- 直接使用
-
更新和刪除：
- 直接使用鍵值訪問更新，內建的
update()方法可以將整個字典的內容拷貝到另一個字典中，例如將字典b = {'room': 1, 'service': 220, 'number': 202}拷貝到字典a = {'age': 23, 'name': 'guo', 'sex': 'm'}中，執行結果如下：>>> 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'}說明：字典當中是無序排列，所以不管你添加還是修改，最后的輸出都會與之前的序列不一致
-
del dict1['a']刪除字典中鍵值為a的元素，例如刪除字典d = {'car':'baoma','color':'blue'}中的color鍵和對應的值，執行結果如下：>>> d = {'car':'baoma','color':'blue'} >>> d {'color': 'blue', 'car': 'baoma'} >>> del d['color'] >>> d {'car': 'baoma'}-
dict11.pop('a')刪除并返回鍵為'a'的元素，例如刪除字典a = {'car': 'baoma'},執行結果如下：>>> a = {'car': 'baoma'} >>> d.pop('car') 'baoma' >>> d {}
>說明：字典內建方法`dict.pop()`與其他內建`pop()`有區別的，具體需要查看help手冊(`help(object.pop))` - `dict1.clear()`刪除字典所有的元素,例如刪除字典d = {'car':'baoma','color':'blue'}中所有的元素，執行結果如下： ```python >>> d = {'car':'baoma','color':'blue'} >>> d {'color': 'blue', 'car': 'baoma'} >>> d.clear() >>> d {}-
del dict1刪除整個字典，例如刪除字典d = {'car':'baoma','color':'blue'}，執行結果如下：>>> 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
>說明：底下報錯d沒有被定義，說明字典d已經不存在了 -
-
dict1['a] = 'string'添加一對鍵值，例如給c = {'id':1,'class':23,'location':345}添加一對鍵值'pay':45，執行結果如下：>>> c = {'id':1,'class':23,'location':345} >>> c['pay'] = 45 >>> c {'pay': 45, 'location': 345, 'id': 1, 'class': 23}
- 直接使用鍵值訪問更新，內建的
-
字典相關的內建函數：
-
type()、str()、cmp()（cmp很少用于字典比較，
比較依次是字典的大小、鍵、值）。 - 工廠函數
dict()，例如：a = dict((['x','y'],[1,2]))，b = (one=1,two=2),執行結果如下：>>> 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一樣的鍵值，執行結果如下：>>> t = {'x':1,'y':2} >>> c = t.copy() >>> c {'y': 2, 'x': 1}
說明：
copy()屬于字典內建函數，所以直接使用help(copy)是無法查看其幫助信息的，應該是help(t.copy)才能查看其幫助信息，這個與python中import copy有區別的，雖然用法差不多一樣，簡單說，查看字典內建函數的幫助信息用法help(t.copy)其中的t是字典的對象，copy是其內建方法（也就是內建函數）具體事例如下，首先得創建一個字典，如：a = {'x':1,'y':2}
-
先查看字典
a對象的所有的幫助信息，執行以下步驟：>>> 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.>說明：這就顯示當前字典`a`所有的類和方法的幫助信息 - 查看字典中`copy()`的幫助信息，執行一下步驟： ```python >>> help(a.copy) Help on built-in function copy: copy(...) D.copy() -> a shallow copy of D (END)說明：這里面就是字典內建函數
copy()的查看幫助信息，其他的也是這樣弄得，執行命令就得字典對象.內建函數(),例：a.copy() -
-
字典內建函數方法小結：
-
len()，輸出字典長度，其實也是系統內建函數,列表、元組變量都能使用，使用方法：len(object)，例如：>>> a = {'x':1,'y':2} >>> len(a) 2說明：
len()輸出的長度在字典中是按一對鍵值來輸出的，在列表、元組】變量中是按照里面的元素計算輸出的，也就是說一對鍵值就是一個長度 -
hash,系統內建函數，用于判斷某個對象是否可以做一個字典的建，非哈希類型的報TypeError錯誤，使用方法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備注簡單說只要hash的對象結果有返回值，并且不報錯就可以最為一個字典的鍵值使用，
hash(object)也可用配合關系運算符判斷兩個對象是否相等（對于兩對象使用這個，感覺有點多次一舉，具體的后面研究了再說把） -
dict.has_key(key)判斷字典中是否存在key（建議使用in和not in代替）,他屬于字典內建函數方法，使用方法：>>> a = {'x':1,'y':2} >>> a.has_key(2) False >>> a.has_key('x') True >>> a.has_key('y') True備注：其實這個前面已經說過的，這個后續會擯棄這個方法的
-
dict.items()返回鍵值對元組的列表，屬于字典內建函數方法，例如：>>> a = {'x':1,'y':2} >>> a.items() [('y', 2), ('x', 1)]說明：也就是說將字典里面的鍵值對組成元組，最后以一個列表的形式輸出
-
dict.iter*()（里面的星號代表后面有個方法名稱），返回迭代子而不是列表，使用方法：-
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>備注：這個有點高大上了，這個迭代子目前不知道具體是干嘛用的，
-
-
dict.get(key[,default=none]),返回key的值，如果不存在返回default指定的值（命令中幫助參數中的[]代表可選，可有可無），這里的default指定是說當key不存在的時候，你可以任意指定一個返回值，例如：>>> a = {'x':1,'y':2} >>> a.get('x') 1 >>> a.get('z', 'z is not exist') 'z is not exist'說明：第一次get x鍵值，因為存在，所以返回x鍵的值1，第二次get z，不存在，默認是返回none，也就是返回結果不會有任何提示，為了友好點，我們就指定一個不存在的提示語，執行后悔看到我們指定的提示語：'z is not exist'
- 其他字典內建的函數方法，就不再說了，可以使用
help(object)（這里的object就是字典的對象，如：a = {'x':1,'y':2}，對象就是a）查看所有的類和方法，英文的不明白，推薦去RUNOOB.COM看下，這里講的可比我總結的詳細，我這是自己學習總結為了加深學習記憶而已。
-
流程控制
-
if語句：- Python的
if語句類似于其他語言，if語句包含一個邏輯表達式，使用表達式比較，在比較的結果的基礎上做出決定。 - 語法格式：
if expression: 如果表達式(等于、不等于、大于、小于、存在、不存在等)滿足條件 statement(s) 聲明（執行代碼或者顯示需要顯示的結果)說明：Python語言使用縮進作為其語句（代碼塊）分組的方法，建議使用4個空格代替其他縮進格式（這也是官方推薦的，主要是為了兼容跨平臺），縮進相同的被認為是一個代碼塊。
- 實例，判斷1>2：如下：
>>> if 1 < 2: ... print "1 小于 2正確" ... 1 小于 2正確注意：python當中的
if語句跟其他語言的格式可能有點區別的，比如shell當中是這樣的：
if expression; then statement(s) fi
- Python的
-
if語句常用的邏輯值表達式（bool）：- 邏輯值（bool）用來表示諸如：對與錯、真與假、空與非空等概念
- 邏輯值包含了兩個值：
- True：表示非空的量（string，tuple，list，set，dictonary等），所有非空零數
- False：表示0，None，空的量等
- 作用：主要用在判斷語句中進行判斷：
- 一個字符串是否空的
- 一個運算是否為零
- 一個表達式是否可用
說明：True就是真實存在的，比如：判斷1<2，本來1肯定小于2，所以結果肯定是True了，False就是不存在，例如：1>2，根本不可能的，所以結果是False
- 實例：
- 判斷條件為True，查看返回結果：
# 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
>備注：當條件為True時，所有的print都返回,這里寫在3腳本是為直觀 - 判斷條件為True，查看返回結果：
- 判斷條件為False，查看返回結果：
# vi python #!/bin/env python if True: print "True is ok" print "Fasle and True"# python python Fasle and True
備注：此時，當條件為
False時，返回結果只print "Fasle and True"，之所以這里還會仍舊顯示這個，是因為print "Fasle and True"跟if同級別的，不在if的判斷里面 -
else語句：
- else語句不能單獨使用，必須配合if使用
- 語法格式：
if expression: 如果表達式成立 statement(s) 執行代碼 else: 否則 statement(s) 執行這個代碼
備注：
else是個可選的語句，并且一個if語句中只能使用一個else語句- 實例：
判斷如果用戶輸入一個數字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語句存在的意義，當需要多個表達式為真值時執行一段代碼，elif可以存在多個，并且它也是可選的，比如說,當用戶輸入1-5的數字時，執行一段代碼告訴他相對應的結果，否則就告訴他失敗-
語法格式：
if expression: 如果滿足條件 statement(s) 執行這個代碼 elif expression2: 如果也滿足這個條件 statement(s) 執行這個代碼 elif expression3: statement(s) ...... else: 否則 statement(s) 執行這個代碼 -
實例：：
判斷如果用戶輸入1-5就返回相應的結果，否則就返回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就可以達到目的了,這里面的
%s和%輸出格式化的字符串和格式化字符串
