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

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

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

Python 是一個(gè)高層次的結(jié)合了解釋性、編譯性、互動(dòng)性和面向?qū)ο蟮哪_本語言。
Python 的設(shè)計(jì)具有很強(qiáng)的可讀性，相比其他語言經(jīng)常使用英文關(guān)鍵字，其他語言的一些標(biāo)點(diǎn)符號(hào)，它具有比其他語言更有特色語法結(jié)構(gòu)。
Python 是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個(gè)環(huán)節(jié)。類似于PHP和Perl語言。
Python 是交互式語言： 這意味著，您可以在一個(gè)Python提示符，直接互動(dòng)執(zhí)行寫你的程序。
Python 是面向?qū)ο笳Z言: 這意味著Python支持面向?qū)ο蟮娘L(fēng)格或代碼封裝在對(duì)象的編程技術(shù)。
Python 是初學(xué)者的語言：Python 對(duì)初級(jí)程序員而言，是一種偉大的語言，它支持廣泛的應(yīng)用程序開發(fā)，從簡(jiǎn)單的文字處理到 WWW 瀏覽器再到游戲。

  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++程序，讓你的程序的用戶獲得"腳本化"的能力。


  • Raspberry Pi 的編程主要是使用 Python 語言，在Raspberry Pi系統(tǒng)升級(jí)過程中，系統(tǒng)中的Python編譯器也做出相應(yīng)的升級(jí)，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 基礎(chǔ)語法教程

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


Python 基礎(chǔ)語法

Python 標(biāo)識(shí)符

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


Python 保留字符


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

Python01.png


行和縮進(jìn)


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

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

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

執(zhí)行以上代碼，會(huì)出現(xiàn)如下錯(cuò)誤提醒： 

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

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

多行語句


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

total = item_one + \
        item_two + \
        item_three

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

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


Python 引號(hào)


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

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


Python 注釋


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

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

# 第一個(gè)注釋
print "Hello, Python!";  # 第二個(gè)注釋

python 中多行注釋使用三個(gè)單引號(hào)或三個(gè)雙引號(hào)。

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


'''
這是多行注釋，使用單引號(hào)。
這是多行注釋，使用單引號(hào)。
這是多行注釋，使用單引號(hào)。
'''

"""
這是多行注釋，使用雙引號(hào)。
這是多行注釋，使用雙引號(hào)。
這是多行注釋，使用雙引號(hào)。
"""


Python 空行


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

等待用戶輸入


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

#!/usr/bin/python

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

以上代碼中 ，"\n\n"在結(jié)果輸出前會(huì)輸出兩個(gè)新的空行。一旦用戶按下鍵時(shí)，程序?qū)⑼顺?

同一行顯示多條語句


Python可以在同一行中使用多條語句，語句之間使用分號(hào)(;)分割，以下是一個(gè)簡(jiǎn)單的實(shí)例：

#!/usr/bin/python

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

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

$ python test.py
runoob


多個(gè)語句構(gòu)成代碼組

縮進(jìn)相同的一組語句構(gòu)成一個(gè)代碼塊，我們稱之代碼組。
像if、while、def和class這樣的復(fù)合語句，首行以關(guān)鍵字開始，以冒號(hào)( : )結(jié)束，該行之后的一行或多行代碼構(gòu)成代碼組。
我們將首行及后面的代碼組稱為一個(gè)子句(clause)。
如下實(shí)例： 

if expression : 
   suite 
elif expression :  
   suite  
else :  
   suite


命令行參數(shù)

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

$ 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中的變量不需要聲明，變量的賦值操作既是變量聲明和定義的過程。
每個(gè)變量在內(nèi)存中創(chuàng)建，都包括變量的標(biāo)識(shí)，名稱和數(shù)據(jù)這些信息。
每個(gè)變量在使用前都必須賦值，變量賦值以后該變量才會(huì)被創(chuàng)建。
等號(hào)（=）用來給變量賦值。
等號(hào)（=）運(yùn)算符左邊是一個(gè)變量名,等號(hào)（=）運(yùn)算符右邊是存儲(chǔ)在變量中的值。例如：

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


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

100
1000.0
John


多個(gè)變量賦值

Python允許你同時(shí)為多個(gè)變量賦值。例如：

a = b = c = 1


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

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

以上實(shí)例，兩個(gè)整型對(duì)象1和2的分配給變量a和b，字符串對(duì)象"john"分配給變量c。

標(biāo)準(zhǔn)數(shù)據(jù)類型

在內(nèi)存中存儲(chǔ)的數(shù)據(jù)可以有多種類型。
例如，person.s年齡作為一個(gè)數(shù)值存儲(chǔ)和他或她的地址是字母數(shù)字字符存儲(chǔ)。
Python有一些標(biāo)準(zhǔn)類型用于定義操作上，他們和為他們每個(gè)人的存儲(chǔ)方法可能。
Python有五個(gè)標(biāo)準(zhǔn)的數(shù)據(jù)類型：

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


Python數(shù)字

數(shù)字?jǐn)?shù)據(jù)類型用于存儲(chǔ)數(shù)值。
他們是不可改變的數(shù)據(jù)類型，這意味著改變數(shù)字?jǐn)?shù)據(jù)類型會(huì)分配一個(gè)新的對(duì)象。
當(dāng)你指定一個(gè)值時(shí)，Number對(duì)象就會(huì)被創(chuàng)建：

var1 = 1
var2 = 10


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

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

您可以通過使用del語句刪除單個(gè)或多個(gè)對(duì)象。例如： 

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

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

Python字符串

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

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

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

s = 'ilovepython'

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

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

以上實(shí)例輸出結(jié)果： 

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

Python列表

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

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

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

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

以上實(shí)例輸出結(jié)果： 

['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元組

元組是另一個(gè)數(shù)據(jù)類型，類似于List（列表）。
元組用"()"標(biāo)識(shí)。內(nèi)部元素用逗號(hào)隔開。但是元組不能二次賦值，相當(dāng)于只讀列表。

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

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

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

以上實(shí)例輸出結(jié)果： 

('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之中最靈活的內(nèi)置數(shù)據(jù)結(jié)構(gòu)類型。列表是有序的對(duì)象結(jié)合，字典是無序的對(duì)象集合。
兩者之間的區(qū)別在于：字典當(dāng)中的元素是通過鍵來存取的，而不是通過偏移存取。
字典用"{ }"標(biāo)識(shí)。字典由索引(key)和它對(duì)應(yīng)的值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() # 輸出所有值

以上實(shí)例輸出結(jié)果： 

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

Python數(shù)據(jù)類型轉(zhuǎn)換

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

Python02.png

Python 運(yùn)算符

算術(shù)運(yùn)算符

以下假設(shè)變量a為10，變量b為20：

Python03.png

以下實(shí)例演示了Python所有算術(shù)運(yùn)算符的操作： 

#!/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

以上實(shí)例輸出結(jié)果： 

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

比較（關(guān)系）運(yùn)算符

以下假設(shè)變量a為10，變量b為20：

Python04.png

以下實(shí)例演示了Python所有比較運(yùn)算符的操作： 

#!/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"

以上實(shí)例輸出結(jié)果： 

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

賦值運(yùn)算符

以下假設(shè)變量a為10，變量b為20：

Python05.png

以下實(shí)例演示了Python所有賦值運(yùn)算符的操作： 

#!/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

以上實(shí)例輸出結(jié)果： 

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

位運(yùn)算符

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

Python06.png

以下實(shí)例演示了Python所有位運(yùn)算符的操作： 

#!/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

以上實(shí)例輸出結(jié)果： 

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

邏輯運(yùn)算符

Python語言支持邏輯運(yùn)算符，以下假設(shè)變量 a 為 10, b為 20:

Python07.png

以下實(shí)例演示了Python所有邏輯運(yùn)算符的操作： 

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

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

以上實(shí)例輸出結(jié)果： 

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

成員運(yùn)算符

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

Python08.png

以下實(shí)例演示了Python所有成員運(yùn)算符的操作： 

#!/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 中"

以上實(shí)例輸出結(jié)果： 

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

身份運(yùn)算符

身份運(yùn)算符用于比較兩個(gè)對(duì)象的存儲(chǔ)單元。

Python09.png

以下實(shí)例演示了Python所有身份運(yùn)算符的操作： 

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

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

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

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

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

以上實(shí)例輸出結(jié)果： 

1 - a 和 b 有相同的標(biāo)識(shí)
2 - a 和 b 有相同的標(biāo)識(shí)
3 - a 和 b 沒有相同的標(biāo)識(shí)
4 - a 和 b 沒有相同的標(biāo)識(shí)

運(yùn)算符優(yōu)先級(jí)

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

Python10.png

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

#!/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 運(yùn)算結(jié)果為：",  e

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

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

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

以上實(shí)例輸出結(jié)果： 

(a + b) * c / d 運(yùn)算結(jié)果為： 90
((a + b) * c) / d 運(yùn)算結(jié)果為： 90
(a + b) * (c / d) 運(yùn)算結(jié)果為： 90
a + (b * c) / d 運(yùn)算結(jié)果為： 50

Python 語句

if 條件語句

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

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

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

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

# 例1：if 基本用法

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

輸出結(jié)果為： 

>>> luren			# 輸出結(jié)果

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

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

# 例3：if語句多個(gè)條件

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

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

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

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

  • 簡(jiǎn)單的語句組

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

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

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

變量 var 的值為100
Good bye!

While 循環(huán)語句

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

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

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

Python20.png

實(shí)例： 

#!/usr/bin/python

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

print "Good bye!"

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

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

# continue 和 break 用法

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

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

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

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

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

print "Good bye!"

以上實(shí)例輸出結(jié)果： 

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ì)在循環(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"

以上實(shí)例輸出結(jié)果為： 

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
  • 簡(jiǎn)單語句組

類似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)可以遍歷任何序列的項(xiàng)目，如一個(gè)列表或者一個(gè)字符串。 語法：
for循環(huán)的語法格式如下： 

for iterating_var in sequence:
   statements(s)

流程圖：

Python21.png

實(shí)例： 

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

for letter in 'Python':     # 第一個(gè)實(shí)例
   print '當(dāng)前字母 :', letter

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二個(gè)實(shí)例
   print '當(dāng)前字母 :', fruit

print "Good bye!"

以上實(shí)例輸出結(jié)果: 

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

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

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

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

print "Good bye!"

以上實(shí)例輸出結(jié)果： 

當(dāng)前水果 : banana
當(dāng)前水果 : apple
當(dāng)前水果 : mango
Good bye!

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

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

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

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

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

以上實(shí)例輸出結(jié)果： 

10 等于 2 * 5
11 是一個(gè)質(zhì)數(shù)
12 等于 2 * 6
13 是一個(gè)質(zhì)數(shù)
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一個(gè)質(zhì)數(shù)
18 等于 2 * 9
19 是一個(gè)質(zhì)數(shù)

Python 循環(huán)嵌套

Python 語言允許在一個(gè)循環(huán)體里面嵌入另一個(gè)循環(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)體內(nèi)嵌入其他的循環(huán)體，如在while循環(huán)中可以嵌入for循環(huán)， 反之，你可以在for循環(huán)中嵌入while循環(huán)。
實(shí)例：
以下實(shí)例使用了嵌套循環(huán)輸出2~100之間的素?cái)?shù)： 

#!/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, " 是素?cái)?shù)"
   i = i + 1

print "Good bye!"

以上實(shí)例輸出結(jié)果: 

2 是素?cái)?shù)
3 是素?cái)?shù)
5 是素?cái)?shù)
7 是素?cái)?shù)
11 是素?cái)?shù)
13 是素?cái)?shù)
17 是素?cái)?shù)
19 是素?cái)?shù)
23 是素?cái)?shù)
29 是素?cái)?shù)
31 是素?cái)?shù)
37 是素?cái)?shù)
41 是素?cái)?shù)
43 是素?cái)?shù)
47 是素?cái)?shù)
53 是素?cái)?shù)
59 是素?cái)?shù)
61 是素?cái)?shù)
67 是素?cái)?shù)
71 是素?cái)?shù)
73 是素?cái)?shù)
79 是素?cái)?shù)
83 是素?cái)?shù)
89 是素?cái)?shù)
97 是素?cái)?shù)
Good bye!

break 語句

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

break

流程圖：

Python30.png

實(shí)例： 


#!/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!"

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

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跳出整個(gè)循環(huán)。
continue 語句用來告訴Python跳過當(dāng)前循環(huán)的剩余語句，然后繼續(xù)進(jìn)行下一輪循環(huán)。
continue語句用在while和for循環(huán)中。
Python 語言 continue 語句語法格式如下： 

continue

流程圖：

Python31.png

實(shí)例： 

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

for letter in 'Python':     # 第一個(gè)實(shí)例
   if letter == 'h':
      continue
   print '當(dāng)前字母 :', letter

var = 10                    # 第二個(gè)實(shí)例
while var > 0:              
   var = var -1
   if var == 5:
      continue
   print '當(dāng)前變量值 :', var
print "Good bye!"

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

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

pass 語句

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

pass

實(shí)例： 

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

# 輸出 Python 的每個(gè)字母
for letter in 'Python':
   if letter == 'h':
      pass
      print '這是 pass 塊'
   print '當(dāng)前字母 :', letter

print "Good bye!"

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

當(dāng)前字母 : P
當(dāng)前字母 : y
當(dāng)前字母 : t
這是 pass 塊
當(dāng)前字母 : h
當(dāng)前字母 : o
當(dāng)前字母 : n
Good bye!

Python Number(數(shù)字)

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

Python Number 數(shù)據(jù)類型用于存儲(chǔ)數(shù)值。
數(shù)據(jù)類型是不允許改變的,這就意味著如果改變 Number 數(shù)據(jù)類型的值，將重新分配內(nèi)存空間。


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

var1 = 1
var2 = 10

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

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

您可以通過使用del語句刪除單個(gè)或多個(gè)對(duì)象，例如： 

del var
del var_a, var_b

Python 支持四種不同的數(shù)值類型：

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

Python Number 類型轉(zhuǎn)換

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

Python數(shù)學(xué)函數(shù)

Python40.png

Python隨機(jī)數(shù)函數(shù)

隨機(jī)數(shù)可以用于數(shù)學(xué)，游戲，安全等領(lǐng)域中，還經(jīng)常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用隨機(jī)數(shù)函數(shù)：

Python41.png

Python三角函數(shù)

Python包括以下三角函數(shù)：

Python42.png

Python數(shù)學(xué)常量

Python43.png

Python 字符串

Python訪問字符串中的值

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

#!/usr/bin/python

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

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

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

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

Python字符串更新

你可以對(duì)已存在的字符串進(jìn)行修改，并賦值給另一個(gè)變量，如下實(shí)例： 

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

var1 = 'Hello World!'

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

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

更新字符串 :-  Hello Runoob!

Python轉(zhuǎn)義字符

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

Python44.png

Python字符串運(yùn)算符

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

Python45.png

實(shí)例如下： 

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

a = "Hello"
b = "Python"

print "a + b 輸出結(jié)果：", a + b 
print "a * 2 輸出結(jié)果：", a * 2 
print "a[1] 輸出結(jié)果：", a[1] 
print "a[1:4] 輸出結(jié)果：", 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í)行結(jié)果為： 

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

Python字符串格式化

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

#!/usr/bin/python

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

以上實(shí)例輸出結(jié)果： 

My name is Zara and weight is 21 kg!

python字符串格式化符號(hào):

Python46.png

格式化操作符輔助指令:

Python47.png

Python三引號(hào)

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

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

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

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

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

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

訪問列表中的值

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

#!/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]

以上實(shí)例輸出結(jié)果： 

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

更新列表

你可以對(duì)列表的數(shù)據(jù)項(xiàng)進(jìn)行修改或更新，你也可以使用append()方法來添加列表項(xiàng)，如下所示： 

#!/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];

以上實(shí)例輸出結(jié)果：

刪除列表元素

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

#!/usr/bin/python

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

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

以上實(shí)例輸出結(jié)果： 

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

Python列表腳本操作符

列表對(duì) + 和 * 的操作符與字符串相似。+ 號(hào)用于組合列表，* 號(hào)用于重復(fù)列表。
如下所示：

Python50.png

Python列表截取

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

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

操作：

Python51.png

Python列表函數(shù)&方法

Python包含以下函數(shù):

Python52.png

Python包含以下方法:

Python53.png

Python 元組

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

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

創(chuàng)建空元組 

tup1 = ();

元組中只包含一個(gè)元素時(shí)，需要在元素后面添加逗號(hào) 

tup1 = (50,);

元組與字符串類似，下標(biāo)索引從0開始，可以進(jìn)行截取，組合等。

訪問元組

元組可以使用下標(biāo)索引來訪問元組中的值，如下實(shí)例: 

#!/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]

以上實(shí)例輸出結(jié)果： 

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

修改元組

元組中的元素值是不允許修改的，但我們可以對(duì)元組進(jìn)行連接組合，如下實(shí)例: 

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

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

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

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

以上實(shí)例輸出結(jié)果： 

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

刪除元組

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

#!/usr/bin/python

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

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

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

('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

元組運(yùn)算符

與字符串一樣，元組之間可以使用 + 號(hào)和 * 號(hào)進(jìn)行運(yùn)算。這就意味著他們可以組合和復(fù)制，運(yùn)算后會(huì)生成一個(gè)新的元組。

Python54.png

元組索引，截取

因?yàn)樵M也是一個(gè)序列，所以我們可以訪問元組中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
元組： 

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

無關(guān)閉分隔符

任意無符號(hào)的對(duì)象，以逗號(hào)隔開，默認(rèn)為元組，如下實(shí)例： 

#!/usr/bin/python

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

以上實(shí)例運(yùn)行結(jié)果： 

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

元組內(nèi)置函數(shù)

Python元組包含了以下內(nèi)置函數(shù)

Python56.png

Python 字典

字典是另一種可變?nèi)萜髂Ｐ?，且可存?chǔ)任意類型對(duì)象。
字典的每個(gè)鍵值(key=>value)對(duì)用冒號(hào)(:)分割，每個(gè)對(duì)之間用逗號(hào)(,)分割，整個(gè)字典包括在花括號(hào)({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

鍵必須是唯一的，但值則不必。
值可以取任何數(shù)據(jù)類型，但鍵必須是不可變的，如字符串，數(shù)字或元組。
一個(gè)簡(jiǎn)單的字典實(shí)例：

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

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

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

訪問字典里的值

把相應(yīng)的鍵放入熟悉的方括弧，如下實(shí)例: 

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

以上實(shí)例輸出結(jié)果： 

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

如果用字典里沒有的鍵訪問數(shù)據(jù)，會(huì)輸出錯(cuò)誤如下： 

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

以上實(shí)例輸出結(jié)果： 

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

修改字典

向字典添加新內(nèi)容的方法是增加新的鍵/值對(duì)，修改或刪除已有鍵/值對(duì)如下實(shí)例: 

#!/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'];

以上實(shí)例輸出結(jié)果： 

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

刪除字典元素

能刪單一的元素也能清空字典，清空只需一項(xiàng)操作。
顯示刪除一個(gè)字典用del命令，如下實(shí)例： 

#!/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'];

但這會(huì)引發(fā)一個(gè)異常，因?yàn)橛胐el后字典不再存在： 

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對(duì)象，既可以是標(biāo)準(zhǔn)的對(duì)象，也可以是用戶定義的，但鍵不行。
兩個(gè)重要的點(diǎn)需要記?。?br /> 1）不允許同一個(gè)鍵出現(xiàn)兩次。創(chuàng)建時(shí)如果同一個(gè)鍵被賦值兩次，后一個(gè)值會(huì)被記住，如下實(shí)例：

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

以上實(shí)例輸出結(jié)果： 

dict['Name']:  Manni

2）鍵必須不可變，所以可以用數(shù)字，字符串或元組充當(dāng)，所以用列表就不行，如下實(shí)例： 

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

以上實(shí)例輸出結(jié)果： 

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

字典內(nèi)置函數(shù)&方法

Python字典包含了以下內(nèi)置函數(shù)：

Python57.png

Python字典包含了以下內(nèi)置方法：

Python58.png

Python 函數(shù)

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

定義一個(gè)函數(shù)

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

  • 函數(shù)代碼塊以 def 關(guān)鍵詞開頭，后接函數(shù)標(biāo)識(shí)符名稱和圓括號(hào)()。
  • 任何傳入?yún)?shù)和自變量必須放在圓括號(hào)中間。圓括號(hào)之間可以用于定義參數(shù)。
  • 函數(shù)的第一行語句可以選擇性地使用文檔字符串—用于存放函數(shù)說明。
  • 函數(shù)內(nèi)容以冒號(hào)起始，并且縮進(jìn)。
  • return [表達(dá)式] 結(jié)束函數(shù)，選擇性地返回一個(gè)值給調(diào)用方。不帶表達(dá)式的return相當(dāng)于返回 None。

語法 

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

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

實(shí)例
以下為一個(gè)簡(jiǎn)單的Python函數(shù)，它將一個(gè)字符串作為傳入?yún)?shù)，再打印到標(biāo)準(zhǔn)顯示設(shè)備上。 

def printme( str ):
   "打印傳入的字符串到標(biāo)準(zhǔn)顯示設(shè)備上"
   print str
   return

函數(shù)調(diào)用

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

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

以上實(shí)例輸出結(jié)果： 

我要調(diào)用用戶自定義函數(shù)!
再次調(diào)用同一函數(shù)

按值傳遞參數(shù)和按引用傳遞參數(shù)

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

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

傳入函數(shù)的和在末尾添加新內(nèi)容的對(duì)象用的是同一個(gè)引用。故輸出結(jié)果如下： 

函數(shù)內(nèi)取值:  [10, 20, 30, [1, 2, 3, 4]]
函數(shù)外取值:  [10, 20, 30, [1, 2, 3, 4]]

必備參數(shù)

以下是調(diào)用函數(shù)時(shí)可使用的正式參數(shù)類型：

  • 必備參數(shù)
  • 關(guān)鍵字參數(shù)
  • 默認(rèn)參數(shù)
  • 不定長參數(shù)

必備參數(shù)須以正確的順序傳入函數(shù)。調(diào)用時(shí)的數(shù)量必須和聲明時(shí)的一樣。
調(diào)用printme()函數(shù)，你必須傳入一個(gè)參數(shù)，不然會(huì)出現(xiàn)語法錯(cuò)誤：

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

以上實(shí)例輸出結(jié)果： 

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

關(guān)鍵字參數(shù)

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

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

以上實(shí)例輸出結(jié)果： 

My string

下例能將關(guān)鍵字參數(shù)順序不重要展示得更清楚： 

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

以上實(shí)例輸出結(jié)果： 

Name:  miki
Age  50

缺省參數(shù)

調(diào)用函數(shù)時(shí)，缺省參數(shù)的值如果沒有傳入，則被認(rèn)為是默認(rèn)值。下例會(huì)打印默認(rèn)的age，如果age沒有被傳入： 

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

以上實(shí)例輸出結(jié)果： 

Name:  miki
Age  50
Name:  miki
Age  35

不定長參數(shù)

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

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

加了星號(hào)（*）的變量名會(huì)存放所有未命名的變量參數(shù)。選擇不多傳參數(shù)也可。如下實(shí)例： 

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

以上實(shí)例輸出結(jié)果： 

輸出:
10
輸出:
70
60
50

匿名函數(shù)

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

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

語法
lambda函數(shù)的語法只包含一個(gè)語句，如下： 

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

如下實(shí)例： 

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

以上實(shí)例輸出結(jié)果: 

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

return語句

return語句[表達(dá)式]退出函數(shù)，選擇性地向調(diào)用方返回一個(gè)表達(dá)式。不帶參數(shù)值的return語句返回None。之前的例子都沒有示范如何返回?cái)?shù)值，下例便告訴你怎么做： 

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

以上實(shí)例輸出結(jié)果： 

函數(shù)內(nèi) :  30
函數(shù)外 :  30

全局變量和局部變量

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

  • 全局變量
  • 局部變量

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

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

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

以上實(shí)例輸出結(jié)果： 

函數(shù)內(nèi)是局部變量 :  30
函數(shù)外是全局變量 :  0