“Python語法”的版本間的差異

來自ALSROBOT WiKi
跳轉至： 導航、 搜索
（→?Python 字典）
（→?Python 函數）
 
第1,903行： 第1,903行：
  
 
==Python 函數==
 
==Python 函數==
 +
函數是組織好的，可重復使用的，用來實現單一，或相關聯(lián)功能的代碼段。<br/>
 +
函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創(chuàng)建函數，這被叫做用戶自定義函數。<br/>
 
===定義一個函數===
 
===定義一個函數===
 +
你可以定義一個由自己想要功能的函數，以下是簡單的規(guī)則：
 +
* 函數代碼塊以 def 關鍵詞開頭，后接函數標識符名稱和圓括號()。
 +
* 任何傳入參數和自變量必須放在圓括號中間。圓括號之間可以用于定義參數。
 +
* 函數的第一行語句可以選擇性地使用文檔字符串—用于存放函數說明。
 +
* 函數內容以冒號起始，并且縮進。
 +
* return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None。
 +
語法
 +
<pre style='color:blue'>def functionname( parameters ):
 +
  "函數_文檔字符串"
 +
  function_suite
 +
  return [expression]</pre>
 +
默認情況下，參數值和參數名稱是按函數聲明中定義的的順序匹配起來的。
 +
 +
實例
 +
<br/>
 +
以下為一個簡單的Python函數，它將一個字符串作為傳入參數，再打印到標準顯示設備上。
 +
 +
<pre style='color:blue'>def printme( str ):
 +
  "打印傳入的字符串到標準顯示設備上"
 +
  print str
 +
  return</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
===函數調用===
 
===函數調用===
 +
定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。<br/>
 +
這個函數的基本結構完成以后，你可以通過另一個函數調用執(zhí)行，也可以直接從Python提示符執(zhí)行。<br/>
 +
如下實例調用了printme（）函數：<br/>
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
# 定義函數
 +
def printme( str ):
 +
  "打印任何傳入的字符串"
 +
  print str;
 +
  return;
 +
 +
# 調用函數
 +
printme("我要調用用戶自定義函數!");
 +
printme("再次調用同一函數");</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>我要調用用戶自定義函數!
 +
再次調用同一函數</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
===按值傳遞參數和按引用傳遞參數===
 
===按值傳遞參數和按引用傳遞參數===
 +
所有參數（自變量）在Python里都是按引用傳遞。如果你在函數里修改了參數，那么在調用這個函數的函數里，原始的參數也被改變了。<br/>
 +
例如：<br/>
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
# 可寫函數說明
 +
def changeme( mylist ):
 +
  "修改傳入的列表"
 +
  mylist.append([1,2,3,4]);
 +
  print "函數內取值: ", mylist
 +
  return
 +
 +
# 調用changeme函數
 +
mylist = [10,20,30];
 +
changeme( mylist );
 +
print "函數外取值: ", mylist</pre>
 +
傳入函數的和在末尾添加新內容的對象用的是同一個引用。故輸出結果如下：
 +
<pre style='color:blue'>函數內取值:  [10, 20, 30, [1, 2, 3, 4]]
 +
函數外取值:  [10, 20, 30, [1, 2, 3, 4]]</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
===必備參數===
 
===必備參數===
 +
以下是調用函數時可使用的正式參數類型：
 +
* 必備參數
 +
* 關鍵字參數
 +
* 默認參數
 +
* 不定長參數
 +
必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。<br/>
 +
調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：<br/>
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
#可寫函數說明
 +
def printme( str ):
 +
  "打印任何傳入的字符串"
 +
  print str;
 +
  return;
 +
 +
#調用printme函數
 +
printme();</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>Traceback (most recent call last):
 +
  File "test.py", line 11, in <module>
 +
    printme();
 +
TypeError: printme() takes exactly 1 argument (0 given)</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
===關鍵字參數===
 
===關鍵字參數===
 +
關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。<br/>
 +
使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。<br/>
 +
以下實例在函數 printme() 調用時使用參數名：<br/>
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
#可寫函數說明
 +
def printme( str ):
 +
  "打印任何傳入的字符串"
 +
  print str;
 +
  return;
 +
 +
#調用printme函數
 +
printme( str = "My string");</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>My string</pre>
 +
下例能將關鍵字參數順序不重要展示得更清楚：
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
#可寫函數說明
 +
def printinfo( name, age ):
 +
  "打印任何傳入的字符串"
 +
  print "Name: ", name;
 +
  print "Age ", age;
 +
  return;
 +
 +
#調用printinfo函數
 +
printinfo( age=50, name="miki" );</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>Name:  miki
 +
Age  50</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 +
 
===缺省參數===
 
===缺省參數===
 +
調用函數時，缺省參數的值如果沒有傳入，則被認為是默認值。下例會打印默認的age，如果age沒有被傳入：
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
#可寫函數說明
 +
def printinfo( name, age = 35 ):
 +
  "打印任何傳入的字符串"
 +
  print "Name: ", name;
 +
  print "Age ", age;
 +
  return;
 +
 +
#調用printinfo函數
 +
printinfo( age=50, name="miki" );
 +
printinfo( name="miki" );</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>Name:  miki
 +
Age  50
 +
Name:  miki
 +
Age  35</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 +
 
===不定長參數===
 
===不定長參數===
 +
你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述2種參數不同，聲明時不會命名?；菊Z法如下：
 +
<pre style='color:blue'>def functionname([formal_args,] *var_args_tuple ):
 +
  "函數_文檔字符串"
 +
  function_suite
 +
  return [expression]</pre>
 +
加了星號（*）的變量名會存放所有未命名的變量參數。選擇不多傳參數也可。如下實例：
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
# 可寫函數說明
 +
def printinfo( arg1, *vartuple ):
 +
  "打印任何傳入的參數"
 +
  print "輸出: "
 +
  print arg1
 +
  for var in vartuple:
 +
      print var
 +
  return;
 +
 +
# 調用printinfo 函數
 +
printinfo( 10 );
 +
printinfo( 70, 60, 50 );</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>輸出:
 +
10
 +
輸出:
 +
70
 +
60
 +
50</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 +
 
===匿名函數===
 
===匿名函數===
 +
python 使用 lambda 來創(chuàng)建匿名函數。
 +
* lambda只是一個表達式，函數體比def簡單很多。
 +
* lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
 +
* lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。
 +
* 雖然lambda函數看起來只能寫一行，卻不等同于C或C++的內聯(lián)函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。
 +
語法<br/>
 +
lambda函數的語法只包含一個語句，如下：
 +
<pre style='color:blue'>lambda [arg1 [,arg2,.....argn]]:expression</pre>
 +
如下實例：
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
# 可寫函數說明
 +
sum = lambda arg1, arg2: arg1 + arg2;
 +
 +
# 調用sum函數
 +
print "相加后的值為 : ", sum( 10, 20 )
 +
print "相加后的值為 : ", sum( 20, 20 )</pre>
 +
以上實例輸出結果:
 +
<pre style='color:blue'>相加后的值為 :  30
 +
相加后的值為 :  40</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 +
 
===return語句===
 
===return語句===
 +
return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示范如何返回數值，下例便告訴你怎么做：
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
# 可寫函數說明
 +
def sum( arg1, arg2 ):
 +
  # 返回2個參數的和."
 +
  total = arg1 + arg2
 +
  print "函數內 : ", total
 +
  return total;
 +
 +
# 調用sum函數
 +
total = sum( 10, 20 );
 +
print "函數外 : ", total</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>函數內 :  30
 +
函數外 :  30</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]
 +
 
===全局變量和局部變量===
 
===全局變量和局部變量===
 +
變量作用域:<br/>
 +
一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權限決定于這個變量是在哪里賦值的。<br/>
 +
變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：<br/>
 +
*全局變量
 +
*局部變量
 +
全局變量和局部變量<br/>
 +
定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。<br/>
 +
局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。如下實例：<br/>
 +
<pre style='color:blue'>#!/usr/bin/python
 +
# -*- coding: UTF-8 -*-
 +
 +
total = 0; # 這是一個全局變量
 +
# 可寫函數說明
 +
def sum( arg1, arg2 ):
 +
  #返回2個參數的和."
 +
  total = arg1 + arg2; # total在這里是局部變量.
 +
  print "函數內是局部變量 : ", total
 +
  return total;
 +
 +
#調用sum函數
 +
sum( 10, 20 );
 +
print "函數外是全局變量 : ", total</pre>
 +
以上實例輸出結果：
 +
<pre style='color:blue'>函數內是局部變量 :  30
 +
函數外是全局變量 :  0</pre>
 
*[[#Python 基礎語法教程 | 返回頂部]]
 
*[[#Python 基礎語法教程 | 返回頂部]]

2016年6月20日 (一) 14:25的最后版本

Python 是一個高層次的結合了解釋性、編譯性、互動性和面向對象的腳本語言。
Python 的設計具有很強的可讀性，相比其他語言經常使用英文關鍵字，其他語言的一些標點符號，它具有比其他語言更有特色語法結構。
Python 是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
Python 是交互式語言： 這意味著，您可以在一個Python提示符，直接互動執(zhí)行寫你的程序。
Python 是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python 是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發(fā)，從簡單的文字處理到 WWW 瀏覽器再到游戲。

  1. 易于學習：Python有相對較少的關鍵字，結構簡單，和一個明確定義的語法，學習起來更加簡單。
  2. 易于閱讀：Python代碼定義的更清晰。
  3. 易于維護：Python的成功在于它的源代碼是相當容易維護的。
  4. 一個廣泛的標準庫：Python 的最大的優(yōu)勢之一是豐富的庫，跨平臺的，在 UNIX，Windows 和 Macintosh 兼容很好。
  5. 互動模式：互動模式的支持，您可以從終端輸入執(zhí)行代碼并獲得結果的語言，互動的測試和調試代碼片斷。
  6. 可移植：基于其開放源代碼的特性，Python已經被移植（也就是使其工作）到許多平臺。
  7. 可擴展：如果你需要一段運行很快的關鍵代碼，或者是想要編寫一些不愿開放的算法，你可以使用C或C++完成那部分程序，然后從你的Python程序中調用。
  8. 數據庫：Python提供所有主要的商業(yè)數據庫的接口。
  9. GUI編程：Python支持GUI可以創(chuàng)建和移植到許多系統(tǒng)調用。
  10. 可嵌入: 你可以將Python嵌入到C/C++程序，讓你的程序的用戶獲得"腳本化"的能力。


  • Raspberry Pi 的編程主要是使用 Python 語言，在Raspberry Pi系統(tǒng)升級過程中，系統(tǒng)中的Python編譯器也做出相應的升級，Raspberry Pi 還保持使用 2.7 版本的 Python 編譯器。
  • 系統(tǒng)版本：2015 - 05 - 27 RASPBIAN JESSIE （系統(tǒng)下載地址：https://www.raspberrypi.org/downloads/raspbian/）
  • 系統(tǒng)自帶 Python 版本：Python2.7.9



Python 基礎語法教程

Python 基礎語法
Python 標識符
Python 保留字符
行和縮進
多行語句
Python 引號
Python注釋
Python空行
等待用戶輸入
同一行顯示多條語句
多個語句構成代碼組
命令行參數
Python 變量類型
變量賦值
多個變量賦值
標準數據類型
Python數字
Python字符串
Python列表
Python元組
Python元字典
Python數據類型轉換
Python 運算符
算術運算符
比較（關系）運算符
賦值運算符
邏輯運算符
位運算符
成員運算符
身份運算符
運算符優(yōu)先級
Python 語句
if 條件語句
While 循環(huán)語句
for 循環(huán)語句
Python 循環(huán)嵌套
break 語句
continue 語句
pass 語句
Python Number(數字)
Python 數據類型
Python Number 類型轉換
Python數學函數
Python隨機數函數
Python三角函數
Python數學常量
Python 字符串
Python訪問字符串中的值
Python字符串更新
Python轉義字符
Python字符串運算符
Python字符串格式化
Python三引號
Python 列表
訪問列表中的值
更新列表
刪除列表元素
Python列表腳本操作符
Python列表截取
Python列表函數&方法
Python 元組
訪問元組
修改元組
刪除元組
元組運算符
元組索引，截取
無關閉分隔符
元組內置函數
Python 字典
訪問字典里的值
修改字典
刪除字典元素
字典鍵的特性
字典內置函數&方法
Python 函數
定義一個函數
函數調用
按值傳遞參數和按引用傳遞參數
必備參數
關鍵字參數
缺省參數
不定長參數
匿名函數
return語句
全局變量和局部變量


Python 基礎語法

Python 標識符

  • 在python里，標識符有字母、數字、下劃線組成。
  • 在python中，所有標識符可以包括英文、數字以及下劃線（_），但不能以數字開頭。
  • python中的標識符是區(qū)分大小寫的。
  • 以下劃線開頭的標識符是有特殊意義的。以單下劃線開頭（_foo）的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用"from xxx import *"而導入；
  • 以雙下劃線開頭的（__foo）代表類的私有成員；以雙下劃線開頭和結尾的（__foo__）代表python里特殊方法專用的標識，如__init__（）代表類的構造函數。


Python 保留字符


下面的列表顯示了在Python中的保留字。這些保留字不能用作常數或變數，或任何其他標識符名稱。
所有Python的關鍵字只包含小寫字母。

Python01.png


行和縮進


學習Python與其他語言最大的區(qū)別就是，Python的代碼塊不使用大括號（{}）來控制類，函數以及其他邏輯判斷。python最具特色的就是用縮進來寫模塊。
縮進的空白數量是可變的，但是所有代碼塊語句必須包含相同的縮進空白數量，這個必須嚴格執(zhí)行。如下所示：

if True:
    print "True"
else:
  print "False"
  • 以下代碼將會執(zhí)行錯誤： 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

 if True:
    print "Answer"
    print "True"
else:
    print "Answer"
    # 沒有嚴格縮進，在執(zhí)行時保持
  print "False"

執(zhí)行以上代碼，會出現如下錯誤提醒： 

$ python test.py  
  File "test.py", line 5
    if True:
    ^
IndentationError: unexpected indent

IndentationError: unexpected indent 錯誤是python編譯器是在告訴你"Hi，老兄，你的文件里格式不對了，可能是tab和空格沒對齊的問題"，所有python對格式要求非常嚴格。 如果是 IndentationError: unindent does not match any outer indentation level錯誤表明，你使用的縮進方式不一致，有的是 tab 鍵縮進，有的是空格縮進，改為一致即可。
因此，在Python的代碼塊中必須使用相同數目的行首縮進空格數。
建議你在每個縮進層次使用 單個制表符 或 兩個空格 或 四個空格 , 切記不能混用

多行語句


Python語句中一般以新行作為為語句的結束符。
但是我們可以使用斜杠（ \）將一行的語句分為多行顯示，如下所示：

total = item_one + \
        item_two + \
        item_three

語句中包含[], {} 或 () 括號就不需要使用多行連接符。如下實例： 

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']


Python 引號


Python 接收單引號(' )，雙引號(" )，三引號( """) 來表示字符串，引號的開始與結束必須的相同類型的。
 其中三引號可以由多行組成，編寫多行文本的快捷語法，常用語文檔字符串，在文件的特定地點，被當做注釋。

word = 'word'
sentence = "這是一個句子。"
paragraph = """這是一個段落。包含了多個語句"""


Python 注釋


python中單行注釋采用 # 開頭。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

# 第一個注釋
print "Hello, Python!";  # 第二個注釋

python 中多行注釋使用三個單引號或三個雙引號。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py


'''
這是多行注釋，使用單引號。
這是多行注釋，使用單引號。
這是多行注釋，使用單引號。
'''

"""
這是多行注釋，使用雙引號。
這是多行注釋，使用雙引號。
這是多行注釋，使用雙引號。
"""


Python 空行


函數之間或類的方法之間用空行分隔，表示一段新的代碼的開始。類和函數入口之間也用一行空行分隔，以突出函數入口的開始。
空行與代碼縮進不同，空行并不是Python語法的一部分。書寫時不插入空行，Python解釋器運行也不會出錯。但是空行的作用在于分隔兩段不同功能或含義的代碼，便于日后代碼的維護或重構。
記?。嚎招幸彩浅绦虼a的一部分。

等待用戶輸入


下面的程序在按回車鍵后就會等待用戶輸入：

#!/usr/bin/python

raw_input("\n\nPress the enter key to exit.")

以上代碼中 ，"\n\n"在結果輸出前會輸出兩個新的空行。一旦用戶按下鍵時，程序將退出

同一行顯示多條語句


Python可以在同一行中使用多條語句，語句之間使用分號(;)分割，以下是一個簡單的實例：

#!/usr/bin/python

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

執(zhí)行以上代碼，輸入結果為： 

$ python test.py
runoob


多個語句構成代碼組

縮進相同的一組語句構成一個代碼塊，我們稱之代碼組。
像if、while、def和class這樣的復合語句，首行以關鍵字開始，以冒號( : )結束，該行之后的一行或多行代碼構成代碼組。
我們將首行及后面的代碼組稱為一個子句(clause)。
如下實例： 

if expression : 
   suite 
elif expression :  
   suite  
else :  
   suite


命令行參數

很多程序可以執(zhí)行一些操作來查看一些基本信，Python可以使用-h參數查看各參數幫助信息：

$ python -h 
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... 
Options and arguments (and corresponding environment variables): 
-c cmd : program passed in as string (terminates option list) 
-d     : debug output from parser (also PYTHONDEBUG=x) 
-E     : ignore environment variables (such as PYTHONPATH) 
-h     : print this help message and exit 
 
[ etc. ]


Python 變量類型

變量賦值

Python中的變量不需要聲明，變量的賦值操作既是變量聲明和定義的過程。
每個變量在內存中創(chuàng)建，都包括變量的標識，名稱和數據這些信息。
每個變量在使用前都必須賦值，變量賦值以后該變量才會被創(chuàng)建。
等號（=）用來給變量賦值。
等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。例如：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
counter = 100 # 賦值整型變量
miles = 1000.0 # 浮點型
name = "John" # 字符串
print counter
print miles
print name


以上實例中，100，1000.0和"John"分別賦值給counter，miles，name變量。
執(zhí)行以上程序會輸出如下結果：

100
1000.0
John


多個變量賦值

Python允許你同時為多個變量賦值。例如：

a = b = c = 1


以上實例，創(chuàng)建一個整型對象，值為1，三個變量被分配到相同的內存空間上。
您也可以為多個對象指定多個變量。例如：

a, b, c = 1, 2, "john"

以上實例，兩個整型對象1和2的分配給變量a和b，字符串對象"john"分配給變量c。

標準數據類型

在內存中存儲的數據可以有多種類型。
例如，person.s年齡作為一個數值存儲和他或她的地址是字母數字字符存儲。
Python有一些標準類型用于定義操作上，他們和為他們每個人的存儲方法可能。
Python有五個標準的數據類型：

  • Numbers（數字）
  • String（字符串）
  • List（列表）
  • Tuple（元組）
  • Dictionary（字典）


Python數字

數字數據類型用于存儲數值。
他們是不可改變的數據類型，這意味著改變數字數據類型會分配一個新的對象。
當你指定一個值時，Number對象就會被創(chuàng)建：

var1 = 1
var2 = 10


您也可以使用del語句刪除一些對象引用。
del語句的語法是：

del var1[,var2[,var3[....,varN]]]]

您可以通過使用del語句刪除單個或多個對象。例如： 

del var
del var_a, var_b
  • Python支持四種不同的數字類型：

1、int（有符號整型）
2、long（長整型[也可以代表八進制和十六進制]）
3、float（浮點型）
4、complex（復數）
注意：Python 支持復數，復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 復數的實部a和虛部b都是浮點型

Python字符串

字符串或串(String)是由數字、字母、下劃線組成的一串字符。
一般記為 :

s="a1a2···an"(n>=0)

它是編程語言中表示文本的數據類型。 python的字串列表有2種取值順序:
從左到右索引默認0開始的，最大范圍是字符串長度少1
從右到左索引默認-1開始的，最大范圍是字符串開頭
如果你的實要取得一段子串的話，可以用到變量[頭下標:尾下標]，就可以截取相應的字符串，其中下標是從0開始算起，可以是正數或負數，下標可以為空表示取到頭或尾。
比如:

s = 'ilovepython'

s[1:5]的結果是love。
當使用以冒號分隔的字符串，python返回一個新的對象，結果包含了以這對偏移標識的連續(xù)的內容，左邊的開始是包含了下邊界。
上面的結果包含了s[1]的值l，而取到的最大范圍不包括上邊界，就是s[5]的值p。
加號（+）是字符串連接運算符，星號（*）是重復操作。如下實例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = 'Hello World!'
print str # 輸出完整字符串
print str[0] # 輸出字符串中的第一個字符
print str[2:5] # 輸出字符串中第三個至第五個之間的字符串
print str[2:] # 輸出從第三個字符開始的字符串
print str * 2 # 輸出字符串兩次
print str + "TEST" # 輸出連接的字符串

以上實例輸出結果： 

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

Python列表

List（列表） 是 Python 中使用最頻繁的數據類型。
列表可以完成大多數集合類的數據結構實現。它支持字符，數字，字符串甚至可以包含列表（所謂嵌套）。
列表用[ ]標識。是python最通用的復合數據類型?？催@段代碼就明白。
列表中的值得分割也可以用到變量[頭下標:尾下標]，就可以截取相應的列表，從左到右索引默認0開始的，從右到左索引默認-1開始，下標可以為空表示取到頭或尾。
加號（+）是列表連接運算符，星號（*）是重復操作。如下實例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print list # 輸出完整列表
print list[0] # 輸出列表的第一個元素
print list[1:3] # 輸出第二個至第三個的元素 
print list[2:] # 輸出從第三個開始至列表末尾的所有元素
print tinylist * 2 # 輸出列表兩次
print list + tinylist # 打印組合的列表

以上實例輸出結果： 

['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

Python元組

元組是另一個數據類型，類似于List（列表）。
元組用"()"標識。內部元素用逗號隔開。但是元組不能二次賦值，相當于只讀列表。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')

print tuple # 輸出完整元組
print tuple[0] # 輸出元組的第一個元素
print tuple[1:3] # 輸出第二個至第三個的元素 
print tuple[2:] # 輸出從第三個開始至列表末尾的所有元素
print tinytuple * 2 # 輸出元組兩次
print tuple + tinytuple # 打印組合的元組

以上實例輸出結果： 

('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

Python元字典

字典(dictionary)是除列表以外python之中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。
兩者之間的區(qū)別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典用"{ }"標識。字典由索引(key)和它對應的值value組成。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one'] # 輸出鍵為'one' 的值
print dict[2] # 輸出鍵為 2 的值
print tinydict # 輸出完整的字典
print tinydict.keys() # 輸出所有鍵
print tinydict.values() # 輸出所有值

以上實例輸出結果： 

This is one This is two {'dept': 'sales', 'code': 6734, 'name': 'john'} ['dept', 'code', 'name'] ['sales', 6734, 'john']

Python數據類型轉換

有時候，我們需要對數據內置的類型進行轉換，數據類型的轉換，你只需要將數據類型作為函數名即可。
以下幾個內置的函數可以執(zhí)行數據類型之間的轉換。這些函數返回一個新的對象，表示轉換的值。

Python02.png

Python 運算符

算術運算符

以下假設變量a為10，變量b為20：

Python03.png

以下實例演示了Python所有算術運算符的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 21
b = 10
c = 0
c = a + b
print "1 - c 的值為：", c
c = a - b
print "2 - c 的值為：", c 
c = a * b
print "3 - c 的值為：", c 
c = a / b
print "4 - c 的值為：", c 
c = a % b
print "5 - c 的值為：", c
# 修改變量 a 、b 、c
a = 2
b = 3
c = a**b 
print "6 - c 的值為：", c
a = 10
b = 5
c = a//b 
print "7 - c 的值為：", c

以上實例輸出結果： 

1 - c 的值為： 31
2 - c 的值為： 11
3 - c 的值為： 210
4 - c 的值為： 2
5 - c 的值為： 1
6 - c 的值為： 8
7 - c 的值為： 2

比較（關系）運算符

以下假設變量a為10，變量b為20：

Python04.png

以下實例演示了Python所有比較運算符的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 21
b = 10
c = 0
if ( a == b ):
   print "1 - a 等于 b"
else:
   print "1 - a 不等于 b"
if ( a != b ):
   print "2 - a 不等于 b"
else:
   print "2 - a 等于 b"
if ( a <> b ):
   print "3 - a 不等于 b"
else:
   print "3 - a 等于 b"
if ( a < b ):
   print "4 - a 小于 b" 
else:
   print "4 - a 大于等于 b"
if ( a > b ):
   print "5 - a 大于 b"
else:
   print "5 - a 小于等于 b"
# 修改變量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
   print "6 - a 小于等于 b"
else:
   print "6 - a 大于  b"
if ( b >= a ):
   print "7 - b 大于等于 b"
else:
   print "7 - b 小于 b"

以上實例輸出結果： 

1 - a 不等于 b
2 - a 不等于 b
3 - a 不等于 b
4 - a 大于等于 b
5 - a 大于 b
6 - a 小于等于 b
7 - b 大于等于 b

賦值運算符

以下假設變量a為10，變量b為20：

Python05.png

以下實例演示了Python所有賦值運算符的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 21
b = 10
c = 0
c = a + b
print "1 - c 的值為：", c
c += a
print "2 - c 的值為：", c 
c *= a
print "3 - c 的值為：", c 
c /= a 
print "4 - c 的值為：", c 
c = 2
c %= a
print "5 - c 的值為：", c
c **= a
print "6 - c 的值為：", c
c //= a
print "7 - c 的值為：", c

以上實例輸出結果： 

1 - c 的值為： 31
2 - c 的值為： 52
3 - c 的值為： 1092
4 - c 的值為： 52
5 - c 的值為： 2
6 - c 的值為： 2097152
7 - c 的值為： 99864

位運算符

按位運算符是把數字看作二進制來進行計算的。Python中的按位運算法則如下：
下表中變量 a 為 60，b 為 13。

Python06.png

以下實例演示了Python所有位運算符的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0

c = a & b;        # 12 = 0000 1100
print "1 - c 的值為：", c

c = a | b;        # 61 = 0011 1101 
print "2 - c 的值為：", c

c = a ^ b;        # 49 = 0011 0001
print "3 - c 的值為：", c

c = ~a;           # -61 = 1100 0011
print "4 - c 的值為：", c

c = a << 2;       # 240 = 1111 0000
print "5 - c 的值為：", c

c = a >> 2;       # 15 = 0000 1111
print "6 - c 的值為：", c

以上實例輸出結果： 

1 - c 的值為： 12
2 - c 的值為： 61
3 - c 的值為： 49
4 - c 的值為： -61
5 - c 的值為： 240
6 - c 的值為： 15

邏輯運算符

Python語言支持邏輯運算符，以下假設變量 a 為 10, b為 20:

Python07.png

以下實例演示了Python所有邏輯運算符的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 10
b = 20
if ( a and b ):
   print "1 - 變量 a 和 b 都為 true"
else:
   print "1 - 變量 a 和 b 有一個不為 true"
if ( a or b ):
   print "2 - 變量 a 和 b 都為 true，或其中一個變量為 true"
else:
   print "2 - 變量 a 和 b 都不為 true"
# 修改變量 a 的值
a = 0
if ( a and b ):
   print "3 - 變量 a 和 b 都為 true"
else:
   print "3 - 變量 a 和 b 有一個不為 true"

if ( a or b ):
   print "4 - 變量 a 和 b 都為 true，或其中一個變量為 true"
else:
   print "4 - 變量 a 和 b 都不為 true"
if not( a and b ):
   print "5 - 變量 a 和 b 都為 false，或其中一個變量為 false"
else:
   print "5 - 變量 a 和 b 都為 true"

以上實例輸出結果： 

1 - 變量 a 和 b 都為 true
2 - 變量 a 和 b 都為 true，或其中一個變量為 true
3 - 變量 a 和 b 有一個不為 true
4 - 變量 a 和 b 都為 true，或其中一個變量為 true
5 - 變量 a 和 b 都為 false，或其中一個變量為 false

成員運算符

除了以上的一些運算符之外，Python還支持成員運算符，測試實例中包含了一系列的成員，包括字符串，列表或元組。

Python08.png

以下實例演示了Python所有成員運算符的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
   print "1 - 變量 a 在給定的列表中 list 中"
else:
   print "1 - 變量 a 不在給定的列表中 list 中"
if ( b not in list ):
   print "2 - 變量 b 不在給定的列表中 list 中"
else:
   print "2 - 變量 b 在給定的列表中 list 中"
# 修改變量 a 的值
a = 2
if ( a in list ):
   print "3 - 變量 a 在給定的列表中 list 中"
else:
   print "3 - 變量 a 不在給定的列表中 list 中"

以上實例輸出結果： 

1 - 變量 a 不在給定的列表中 list 中
2 - 變量 b 不在給定的列表中 list 中
3 - 變量 a 在給定的列表中 list 中

身份運算符

身份運算符用于比較兩個對象的存儲單元。

Python09.png

以下實例演示了Python所有身份運算符的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 20
b = 20

if ( a is b ):
   print "1 - a 和 b 有相同的標識"
else:
   print "1 - a 和 b 沒有相同的標識"

if ( id(a) == id(b) ):
   print "2 - a 和 b 有相同的標識"
else:
   print "2 - a 和 b 沒有相同的標識"

# 修改變量 b 的值
b = 30
if ( a is b ):
   print "3 - a 和 b 有相同的標識"
else:
   print "3 - a 和 b 沒有相同的標識"

if ( a is not b ):
   print "4 - a 和 b 沒有相同的標識"
else:
   print "4 - a 和 b 有相同的標識"

以上實例輸出結果： 

1 - a 和 b 有相同的標識
2 - a 和 b 有相同的標識
3 - a 和 b 沒有相同的標識
4 - a 和 b 沒有相同的標識

運算符優(yōu)先級

以下表格列出了從最高到最低優(yōu)先級的所有運算符：

Python10.png

以下實例演示了Python所有運算符優(yōu)先級的操作： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 20
b = 10
c = 15
d = 5
e = 0

e = (a + b) * c / d       #( 30 * 15 ) / 5
print "(a + b) * c / d 運算結果為：",  e

e = ((a + b) * c) / d     # (30 * 15 ) / 5
print "((a + b) * c) / d 運算結果為：",  e

e = (a + b) * (c / d);    # (30) * (15/5)
print "(a + b) * (c / d) 運算結果為：",  e

e = a + (b * c) / d;      #  20 + (150/5)
print "a + (b * c) / d 運算結果為：",  e

以上實例輸出結果： 

(a + b) * c / d 運算結果為： 90
((a + b) * c) / d 運算結果為： 90
(a + b) * (c / d) 運算結果為： 90
a + (b * c) / d 運算結果為： 50

Python 語句

if 條件語句

Python 編程中 if 語句用于控制程序的執(zhí)行，基本形式為：

if 判斷條件：
    執(zhí)行語句……
else：
    執(zhí)行語句……

其中"判斷條件"成立時（非零），則執(zhí)行后面的語句，而執(zhí)行內容可以多行，以縮進來區(qū)分表示同一范圍。
else 為可選語句，當需要在條件不成立時執(zhí)行內容則可以執(zhí)行相關語句，具體例子如下：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 例1：if 基本用法

flag = False
name = 'luren'
if name == 'python':         # 判斷變量否為'python'
    flag = True          # 條件成立時設置標志為真
    print 'welcome boss'    # 并輸出歡迎信息
else:
    print name              # 條件不成立時輸出變量名稱

輸出結果為： 

>>> luren			# 輸出結果

由于 python 并不支持 switch 語句，所以多個條件判斷，只能用 elif 來實現，如果判斷需要多個條件需同時判斷時，可以使用 or （或），表示兩個條件有一個成立時判斷條件成功；使用 and （與）時，表示只有兩個條件同時成立的情況下，判斷條件才成功。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 例3：if語句多個條件

num = 9
if num >= 0 and num <= 10:    # 判斷值是否在0~10之間
    print 'hello'
>>> hello		# 輸出結果

num = 10
if num < 0 or num > 10:    # 判斷值是否在小于0或大于10
    print 'hello'
else:
	print 'undefine'
>>> undefine		# 輸出結果

num = 8
# 判斷值是否在0~5或者10~15之間
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print 'hello'
else:
    print 'undefine'
>>> undefine		# 輸出結果

當if有多個條件時可使用括號來區(qū)分判斷的先后順序，括號中的判斷優(yōu)先執(zhí)行，此外 and 和 or 的優(yōu)先級低于>（大于）、<（小于）等判斷符號，即大于和小于在沒有括號的情況下會比與或要優(yōu)先判斷。

  • 簡單的語句組

你也可以在同一行的位置上使用if條件判斷語句，如下實例：

#!/usr/bin/python 
# -*- coding: UTF-8 -*-
 
var = 100 
 
if ( var  == 100 ) : print "變量 var 的值為100" 
 
print "Good bye!"

以上代碼執(zhí)行輸出結果如下： 

變量 var 的值為100
Good bye!

While 循環(huán)語句

Python 編程中 while 語句用于循環(huán)執(zhí)行程序，即在某條件下，循環(huán)執(zhí)行某段程序，以處理需要重復處理的相同任務。其基本形式為： 

while 判斷條件：
    執(zhí)行語句……

執(zhí)行流程圖如下：

Python20.png

實例： 

#!/usr/bin/python

count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1

print "Good bye!"

以上代碼執(zhí)行輸出結果: 

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

while 語句時還有另外兩個重要的命令 continue，break 來跳過循環(huán)，continue 用于跳過該次循環(huán)，break 則是用于退出循環(huán)，此外"判斷條件"還可以是個常值，表示循環(huán)必定成立，具體用法如下： 

# continue 和 break 用法

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非雙數時跳過輸出
        continue
    print i         # 輸出雙數2、4、6、8、10

i = 1
while 1:            # 循環(huán)條件為1必定成立
    print i         # 輸出1~10
    i += 1
    if i > 10:     # 當i大于10時跳出循環(huán)
        break
  • 無限循環(huán)

如果條件判斷語句永遠為 true，循環(huán)將會無限的執(zhí)行下去，如下實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

var = 1
while var == 1 :  # 該條件永遠為true，循環(huán)將無限執(zhí)行下去
   num = raw_input("Enter a number  :")
   print "You entered: ", num

print "Good bye!"

以上實例輸出結果： 

Enter a number  :20
You entered:  20
Enter a number  :29
You entered:  29
Enter a number  :3
You entered:  3
Enter a number between :Traceback (most recent call last):
  File "test.py", line 5, in <module>
    num = raw_input("Enter a number :")
KeyboardInterrupt

注意：以上的無限循環(huán)你可以使用 CTRL+C 來中斷循環(huán)。

  • 循環(huán)使用 else 語句

在 python 中，for … else 表示這樣的意思，for 中的語句和普通的沒有區(qū)別，else 中的語句會在循環(huán)正常執(zhí)行完（即 for 不是通過 break 跳出而中斷的）的情況下執(zhí)行，while … else 也是一樣。 

#!/usr/bin/python

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"

以上實例輸出結果為： 

0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
  • 簡單語句組

類似if語句的語法，如果你的while循環(huán)體中只有一條語句，你可以將該語句與while寫在同一行中， 如下所示： 

#!/usr/bin/python

flag = 1

while (flag): print 'Given flag is really true!'

print "Good bye!"

注意：以上的無限循環(huán)你可以使用 CTRL+C 來中斷循環(huán)。

for 循環(huán)語句

Python for循環(huán)可以遍歷任何序列的項目，如一個列表或者一個字符串。 語法：
for循環(huán)的語法格式如下： 

for iterating_var in sequence:
   statements(s)

流程圖：

Python21.png

實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

for letter in 'Python':     # 第一個實例
   print '當前字母 :', letter

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二個實例
   print '當前字母 :', fruit

print "Good bye!"

以上實例輸出結果: 

當前字母 : P
當前字母 : y
當前字母 : t
當前字母 : h
當前字母 : o
當前字母 : n
當前字母 : banana
當前字母 : apple
當前字母 : mango
Good bye!
  • 通過序列索引迭代

另外一種執(zhí)行循環(huán)的遍歷方式是通過索引，如下實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print '當前水果 :', fruits[index]

print "Good bye!"

以上實例輸出結果： 

當前水果 : banana
當前水果 : apple
當前水果 : mango
Good bye!

以上實例我們使用了內置函數 len() 和 range(),函數 len() 返回列表的長度，即元素的個數。 range返回一個序列的數。

  • 循環(huán)使用 else 語句

在 python 中，for … else 表示這樣的意思，for 中的語句和普通的沒有區(qū)別，else 中的語句會在循環(huán)正常執(zhí)行完（即 for 不是通過 break 跳出而中斷的）的情況下執(zhí)行，while … else 也是一樣。
如下實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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

以上實例輸出結果： 

10 等于 2 * 5
11 是一個質數
12 等于 2 * 6
13 是一個質數
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一個質數
18 等于 2 * 9
19 是一個質數

Python 循環(huán)嵌套

Python 語言允許在一個循環(huán)體里面嵌入另一個循環(huán)。
Python for 循環(huán)嵌套語法： 


for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

Python while 循環(huán)嵌套語法： 

while expression:
   while expression:
      statement(s)
   statement(s)

你可以在循環(huán)體內嵌入其他的循環(huán)體，如在while循環(huán)中可以嵌入for循環(huán)， 反之，你可以在for循環(huán)中嵌入while循環(huán)。
實例：
以下實例使用了嵌套循環(huán)輸出2~100之間的素數： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

i = 2
while(i < 100):
   j = 2
   while(j <= (i/j)):
      if not(i%j): break
      j = j + 1
   if (j > i/j) : print i, " 是素數"
   i = i + 1

print "Good bye!"

以上實例輸出結果: 

2 是素數
3 是素數
5 是素數
7 是素數
11 是素數
13 是素數
17 是素數
19 是素數
23 是素數
29 是素數
31 是素數
37 是素數
41 是素數
43 是素數
47 是素數
53 是素數
59 是素數
61 是素數
67 是素數
71 是素數
73 是素數
79 是素數
83 是素數
89 是素數
97 是素數
Good bye!

break 語句

Python break語句，就像在C語言中，打破了最小封閉for或while循環(huán)。
break語句用來終止循環(huán)語句，即循環(huán)條件沒有False條件或者序列還沒被完全遞歸完，也會停止執(zhí)行循環(huán)語句。
break語句用在while和for循環(huán)中。
如果您使用嵌套循環(huán)，break語句將停止執(zhí)行最深層的循環(huán)，并開始執(zhí)行下一行代碼。
Python語言 break 語句語法： 

break

流程圖：

Python30.png

實例： 


#!/usr/bin/python

for letter in 'Python':     # First Example
   if letter == 'h':
      break
   print 'Current Letter :', letter
  
var = 10                    # Second Example
while var > 0:              
   print 'Current variable value :', var
   var = var -1
   if var == 5:
      break

print "Good bye!"

以上實例執(zhí)行結果： 

Current Letter : P
Current Letter : y
Current Letter : t
Current variable value : 10
Current variable value : 9
Current variable value : 8
Current variable value : 7
Current variable value : 6
Good bye!

continue 語句

Python continue 語句跳出本次循環(huán)，而break跳出整個循環(huán)。
continue 語句用來告訴Python跳過當前循環(huán)的剩余語句，然后繼續(xù)進行下一輪循環(huán)。
continue語句用在while和for循環(huán)中。
Python 語言 continue 語句語法格式如下： 

continue

流程圖：

Python31.png

實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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

var = 10                    # 第二個實例
while var > 0:              
   var = var -1
   if var == 5:
      continue
   print '當前變量值 :', var
print "Good bye!"

以上實例執(zhí)行結果： 

當前字母 : P
當前字母 : y
當前字母 : t
當前字母 : o
當前字母 : n
當前變量值 : 9
當前變量值 : 8
當前變量值 : 7
當前變量值 : 6
當前變量值 : 4
當前變量值 : 3
當前變量值 : 2
當前變量值 : 1
當前變量值 : 0
Good bye!

pass 語句

Python pass是空語句，是為了保持程序結構的完整性。
pass 不做任何事情，一般用做占位語句。
Python 語言 pass 語句語法格式如下： 

pass

實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*- 

# 輸出 Python 的每個字母
for letter in 'Python':
   if letter == 'h':
      pass
      print '這是 pass 塊'
   print '當前字母 :', letter

print "Good bye!"

以上實例執(zhí)行結果： 

當前字母 : P
當前字母 : y
當前字母 : t
這是 pass 塊
當前字母 : h
當前字母 : o
當前字母 : n
Good bye!

Python Number(數字)

Python 數據類型

Python Number 數據類型用于存儲數值。
數據類型是不允許改變的,這就意味著如果改變 Number 數據類型的值，將重新分配內存空間。


以下實例在變量賦值時 Number 對象將被創(chuàng)建： 

var1 = 1
var2 = 10

您也可以使用del語句刪除一些 Number 對象引用。 del語句的語法是： 

del var1[,var2[,var3[....,varN]]]]

您可以通過使用del語句刪除單個或多個對象，例如： 

del var
del var_a, var_b

Python 支持四種不同的數值類型：

  • 整型(Int) - 通常被稱為是整型或整數，是正或負整數，不帶小數點。
  • 長整型(long integers) - 無限大小的整數，整數最后是一個大寫或小寫的L。
  • 浮點型(floating point real values) - 浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
  • 復數( (complex numbers)) - 復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 復數的實部a和虛部b都是浮點型。
  • 返回頂部

Python Number 類型轉換

int(x [,base ])         將x轉換為一個整數  
long(x [,base ])        將x轉換為一個長整數  
float(x )               將x轉換到一個浮點數  
complex(real [,imag ])  創(chuàng)建一個復數  
str(x )                 將對象 x 轉換為字符串  
repr(x )                將對象 x 轉換為表達式字符串  
eval(str )              用來計算在字符串中的有效Python表達式,并返回一個對象  
tuple(s )               將序列 s 轉換為一個元組  
list(s )                將序列 s 轉換為一個列表  
chr(x )                 將一個整數轉換為一個字符  
unichr(x )              將一個整數轉換為Unicode字符  
ord(x )                 將一個字符轉換為它的整數值  
hex(x )                 將一個整數轉換為一個十六進制字符串  
oct(x )                 將一個整數轉換為一個八進制字符串

Python數學函數

Python40.png

Python隨機數函數

隨機數可以用于數學，游戲，安全等領域中，還經常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用隨機數函數：

Python41.png

Python三角函數

Python包括以下三角函數：

Python42.png

Python數學常量

Python43.png

Python 字符串

Python訪問字符串中的值

Python不支持單字符類型，單字符也在Python也是作為一個字符串使用。
Python訪問子字符串，可以使用方括號來截取字符串，如下實例： 

#!/usr/bin/python

var1 = 'Hello World!'
var2 = "Python Runoob"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

以上實例執(zhí)行結果： 

var1[0]:  H
var2[1:5]:  ytho

Python字符串更新

你可以對已存在的字符串進行修改，并賦值給另一個變量，如下實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

var1 = 'Hello World!'

print "更新字符串 :- ", var1[:6] + 'Runoob!'

以上實例執(zhí)行結果 

更新字符串 :-  Hello Runoob!

Python轉義字符

在需要在字符中使用特殊字符時，python用反斜杠(\)轉義字符。如下表：

Python44.png

Python字符串運算符

下表實例變量a值為字符串"Hello"，b變量值為"Python"：

Python45.png

實例如下： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

a = "Hello"
b = "Python"

print "a + b 輸出結果：", a + b 
print "a * 2 輸出結果：", a * 2 
print "a[1] 輸出結果：", a[1] 
print "a[1:4] 輸出結果：", a[1:4] 

if( "H" in a) :
    print "H 在變量 a 中" 
else :
	print "H 不在變量 a 中" 

if( "M" not in a) :
    print "M 不在變量 a 中" 
else :
	print "M 在變量 a 中"

print r'\n'
print R'\n'

以上程序執(zhí)行結果為： 

a + b 輸出結果： HelloPython
a * 2 輸出結果： HelloHello
a[1] 輸出結果： e
a[1:4] 輸出結果： ell
H 在變量 a 中
M 不在變量 a 中
\n
\n

Python字符串格式化

Python 支持格式化字符串的輸出 。盡管這樣可能會用到非常復雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用與 C 中 sprintf 函數一樣的語法。 

#!/usr/bin/python

print "My name is %s and weight is %d kg!" % ('Zara', 21)

以上實例輸出結果： 

My name is Zara and weight is 21 kg!

python字符串格式化符號:

Python46.png

格式化操作符輔助指令:

Python47.png

Python三引號

python中三引號可以將復雜的字符串進行復制:
python三引號允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符。
三引號的語法是一對連續(xù)的單引號或者雙引號（通常都是成對的用）。 

>>> hi = '''hi 
there'''
>>> hi   # repr()
'hi\nthere'
>>> print hi  # str()
hi 
there

三引號讓程序員從引號和特殊字符串的泥潭里面解脫出來，自始至終保持一小塊字符串的格式是所謂的WYSIWYG（所見即所得）格式的。
一個典型的用例是，當你需要一塊HTML或者SQL時，這時用字符串組合，特殊字符串轉義將會非常的繁瑣。 

errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')

Python 列表

序列是Python中最基本的數據結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
Python有6個序列的內置類型，但最常見的是列表和元組。
序列都可以進行的操作包括索引，切片，加，乘，檢查成員。
此外，Python已經內置確定序列的長度以及確定最大和最小的元素的方法。
列表是最常用的Python數據類型，它可以作為一個方括號內的逗號分隔值出現。
列表的數據項不需要具有相同的類型
創(chuàng)建一個列表，只要把逗號分隔的不同的數據項使用方括號括起來即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

與字符串的索引一樣，列表索引從0開始。列表可以進行截取、組合等。

訪問列表中的值

使用下標索引來訪問列表中的值，同樣你也可以使用方括號的形式截取字符，如下所示： 

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]

以上實例輸出結果： 

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

更新列表

你可以對列表的數據項進行修改或更新，你也可以使用append()方法來添加列表項，如下所示： 

#!/usr/bin/python

list = ['physics', 'chemistry', 1997, 2000];

print "Value available at index 2 : "
print list[2];
list[2] = 2001;
print "New value available at index 2 : "
print list[2];

以上實例輸出結果：

刪除列表元素

可以使用 del 語句來刪除列表的的元素，如下實例： 

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];

print list1;
del list1[2];
print "After deleting value at index 2 : "
print list1;

以上實例輸出結果： 

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

Python列表腳本操作符

列表對 + 和 * 的操作符與字符串相似。+ 號用于組合列表，* 號用于重復列表。
如下所示：

Python50.png

Python列表截取

Python的列表截取與字符串操作類型，如下所示：

L = ['spam', 'Spam', 'SPAM!']

操作：

Python51.png

Python列表函數&方法

Python包含以下函數:

Python52.png

Python包含以下方法:

Python53.png

Python 元組

Python的元組與列表類似，不同之處在于元組的元素不能修改。
元組使用小括號，列表使用方括號。
元組創(chuàng)建很簡單，只需要在括號中添加元素，并使用逗號隔開即可。
如下實例：

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

創(chuàng)建空元組 

tup1 = ();

元組中只包含一個元素時，需要在元素后面添加逗號 

tup1 = (50,);

元組與字符串類似，下標索引從0開始，可以進行截取，組合等。

訪問元組

元組可以使用下標索引來訪問元組中的值，如下實例: 

#!/usr/bin/python

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );

print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]

以上實例輸出結果： 

tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

修改元組

元組中的元素值是不允許修改的，但我們可以對元組進行連接組合，如下實例: 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# 以下修改元組元素操作是非法的。
# tup1[0] = 100;

# 創(chuàng)建一個新的元組
tup3 = tup1 + tup2;
print tup3;

以上實例輸出結果： 

(12, 34.56, 'abc', 'xyz')

刪除元組

元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組，如下實例: 

#!/usr/bin/python

tup = ('physics', 'chemistry', 1997, 2000);

print tup;
del tup;
print "After deleting tup : "
print tup;

以上實例元組被刪除后，輸出變量會有異常信息，輸出如下所示： 

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print tup;
NameError: name 'tup' is not defined

元組運算符

與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味著他們可以組合和復制，運算后會生成一個新的元組。

Python54.png

元組索引，截取

因為元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
元組： 

L = ('spam', 'Spam', 'SPAM!')
Python55.png

無關閉分隔符

任意無符號的對象，以逗號隔開，默認為元組，如下實例： 

#!/usr/bin/python

print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;

以上實例運行結果： 

abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

元組內置函數

Python元組包含了以下內置函數

Python56.png

Python 字典

字典是另一種可變容器模型，且可存儲任意類型對象。
字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

鍵必須是唯一的，但值則不必。
值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
一個簡單的字典實例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此創(chuàng)建字典： 

dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

訪問字典里的值

把相應的鍵放入熟悉的方括弧，如下實例: 

#!/usr/bin/python
 
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];

以上實例輸出結果： 

dict['Name']:  Zara
dict['Age']:  7

如果用字典里沒有的鍵訪問數據，會輸出錯誤如下： 

#!/usr/bin/python
 
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
print "dict['Alice']: ", dict['Alice'];

以上實例輸出結果： 

dict['Zara']:
Traceback (most recent call last):
  File "test.py", line 4, in <module>
    print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

修改字典

向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下實例: 

#!/usr/bin/python
 
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
 
 
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];

以上實例輸出結果： 

dict['Age']:  8
dict['School']:  DPS School

刪除字典元素

能刪單一的元素也能清空字典，清空只需一項操作。
顯示刪除一個字典用del命令，如下實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
del dict['Name']; # 刪除鍵是'Name'的條目
dict.clear();     # 清空詞典所有條目
del dict ;        # 刪除詞典
 
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];

但這會引發(fā)一個異常，因為用del后字典不再存在： 

dict['Age']:
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

字典鍵的特性

字典值可以沒有限制地取任何python對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記?。?br /> 1）不允許同一個鍵出現兩次。創(chuàng)建時如果同一個鍵被賦值兩次，后一個值會被記住，如下實例：

#!/usr/bin/python
 
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};
 
print "dict['Name']: ", dict['Name'];

以上實例輸出結果： 

dict['Name']:  Manni

2）鍵必須不可變，所以可以用數字，字符串或元組充當，所以用列表就不行，如下實例： 

#!/usr/bin/python
 
dict = {['Name']: 'Zara', 'Age': 7};
 
print "dict['Name']: ", dict['Name'];

以上實例輸出結果： 

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Zara', 'Age': 7};
TypeError: list objects are unhashable

字典內置函數&方法

Python字典包含了以下內置函數：

Python57.png

Python字典包含了以下內置方法：

Python58.png

Python 函數

函數是組織好的，可重復使用的，用來實現單一，或相關聯(lián)功能的代碼段。
函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創(chuàng)建函數，這被叫做用戶自定義函數。

定義一個函數

你可以定義一個由自己想要功能的函數，以下是簡單的規(guī)則：

  • 函數代碼塊以 def 關鍵詞開頭，后接函數標識符名稱和圓括號()。
  • 任何傳入參數和自變量必須放在圓括號中間。圓括號之間可以用于定義參數。
  • 函數的第一行語句可以選擇性地使用文檔字符串—用于存放函數說明。
  • 函數內容以冒號起始，并且縮進。
  • return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None。

語法 

def functionname( parameters ):
   "函數_文檔字符串"
   function_suite
   return [expression]

默認情況下，參數值和參數名稱是按函數聲明中定義的的順序匹配起來的。

實例
以下為一個簡單的Python函數，它將一個字符串作為傳入參數，再打印到標準顯示設備上。 

def printme( str ):
   "打印傳入的字符串到標準顯示設備上"
   print str
   return

函數調用

定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。
這個函數的基本結構完成以后，你可以通過另一個函數調用執(zhí)行，也可以直接從Python提示符執(zhí)行。
如下實例調用了printme（）函數：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 定義函數
def printme( str ):
   "打印任何傳入的字符串"
   print str;
   return;
 
# 調用函數
printme("我要調用用戶自定義函數!");
printme("再次調用同一函數");

以上實例輸出結果： 

我要調用用戶自定義函數!
再次調用同一函數

按值傳遞參數和按引用傳遞參數

所有參數（自變量）在Python里都是按引用傳遞。如果你在函數里修改了參數，那么在調用這個函數的函數里，原始的參數也被改變了。
例如：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可寫函數說明
def changeme( mylist ):
   "修改傳入的列表"
   mylist.append([1,2,3,4]);
   print "函數內取值: ", mylist
   return
 
# 調用changeme函數
mylist = [10,20,30];
changeme( mylist );
print "函數外取值: ", mylist

傳入函數的和在末尾添加新內容的對象用的是同一個引用。故輸出結果如下： 

函數內取值:  [10, 20, 30, [1, 2, 3, 4]]
函數外取值:  [10, 20, 30, [1, 2, 3, 4]]

必備參數

以下是調用函數時可使用的正式參數類型：

  • 必備參數
  • 關鍵字參數
  • 默認參數
  • 不定長參數

必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。
調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可寫函數說明
def printme( str ):
   "打印任何傳入的字符串"
   print str;
   return;
 
#調用printme函數
printme();

以上實例輸出結果： 

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme();
TypeError: printme() takes exactly 1 argument (0 given)

關鍵字參數

關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。
使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。
以下實例在函數 printme() 調用時使用參數名：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可寫函數說明
def printme( str ):
   "打印任何傳入的字符串"
   print str;
   return;
 
#調用printme函數
printme( str = "My string");

以上實例輸出結果： 

My string

下例能將關鍵字參數順序不重要展示得更清楚： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可寫函數說明
def printinfo( name, age ):
   "打印任何傳入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
 
#調用printinfo函數
printinfo( age=50, name="miki" );

以上實例輸出結果： 

Name:  miki
Age  50

缺省參數

調用函數時，缺省參數的值如果沒有傳入，則被認為是默認值。下例會打印默認的age，如果age沒有被傳入： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可寫函數說明
def printinfo( name, age = 35 ):
   "打印任何傳入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
 
#調用printinfo函數
printinfo( age=50, name="miki" );
printinfo( name="miki" );

以上實例輸出結果： 

Name:  miki
Age  50
Name:  miki
Age  35

不定長參數

你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述2種參數不同，聲明時不會命名?；菊Z法如下： 

def functionname([formal_args,] *var_args_tuple ):
   "函數_文檔字符串"
   function_suite
   return [expression]

加了星號（*）的變量名會存放所有未命名的變量參數。選擇不多傳參數也可。如下實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可寫函數說明
def printinfo( arg1, *vartuple ):
   "打印任何傳入的參數"
   print "輸出: "
   print arg1
   for var in vartuple:
      print var
   return;
 
# 調用printinfo 函數
printinfo( 10 );
printinfo( 70, 60, 50 );

以上實例輸出結果： 

輸出:
10
輸出:
70
60
50

匿名函數

python 使用 lambda 來創(chuàng)建匿名函數。

  • lambda只是一個表達式，函數體比def簡單很多。
  • lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
  • lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。
  • 雖然lambda函數看起來只能寫一行，卻不等同于C或C++的內聯(lián)函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。

語法
lambda函數的語法只包含一個語句，如下： 

lambda [arg1 [,arg2,.....argn]]:expression

如下實例： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2;
 
# 調用sum函數
print "相加后的值為 : ", sum( 10, 20 )
print "相加后的值為 : ", sum( 20, 20 )

以上實例輸出結果: 

相加后的值為 :  30
相加后的值為 :  40

return語句

return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示范如何返回數值，下例便告訴你怎么做： 

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可寫函數說明
def sum( arg1, arg2 ):
   # 返回2個參數的和."
   total = arg1 + arg2
   print "函數內 : ", total
   return total;
 
# 調用sum函數
total = sum( 10, 20 );
print "函數外 : ", total

以上實例輸出結果： 

函數內 :  30
函數外 :  30

全局變量和局部變量

變量作用域:
一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權限決定于這個變量是在哪里賦值的。
變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：

  • 全局變量
  • 局部變量

全局變量和局部變量
定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。
局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。如下實例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

total = 0; # 這是一個全局變量
# 可寫函數說明
def sum( arg1, arg2 ):
   #返回2個參數的和."
   total = arg1 + arg2; # total在這里是局部變量.
   print "函數內是局部變量 : ", total
   return total;
 
#調用sum函數
sum( 10, 20 );
print "函數外是全局變量 : ", total

以上實例輸出結果： 

函數內是局部變量 :  30
函數外是全局變量 :  0