python 小程式製作範例(課後小作業)

試利用模組設計一個可以選擇二種運算的python程式

(1)可以輸入二個整數四則運算的運算器

(2)可以輸入一個整數值,並計算它的階層乘積

(3)離開

解答:

# homework.py
# coding: utf-8

import re,math

def isValidFormula(strFormula):
    regexp =re.compile(r'\d{1,5}[+|-|*|/]\d{1,5}')
    if regexp.search(strFormula): return True
    return False

def getArithmeticResult(strFormula):
    try:
        if isValidFormula(strFormula): return eval(strFormula)
        else: return 'input error'
    except: return 'input error'

def getFactorialResult(strNum):
    if strNum.isdigit(): return math.factorial(int(strNum))
    else: return 'input error'

def main():
    while True:
        print u'''
請選擇
(1)可以輸入二個整數四則運算的運算器
(2)可以輸入一個整數值,並計算它的階層乘積
(3)離開
               '''
        strChoice=raw_input('Select:')
        if strChoice.strip()=='1':
            print u'請輸入運算式:'
            strFormula=raw_input()
            print u'%s=%s'%(strFormula,getArithmeticResult(strFormula))
        elif strChoice.strip()=='2':
            print u'請輸入階層數字:'
            strNum=raw_input()
            print u'%s!=%s'%(strNum,getFactorialResult(strNum))
        elif strChoice.strip()=='3': break
        else: print 'your choice is error'
        print '=========================================='

if __name__=='__main__':
    main()    

python 套件處理

python 套件處理

在python中，你可以將多個同類型或屬性的模組集中在同一個目錄中，並在目錄中加入 __init__.py的檔案，來組合成一個套件。

假設有個套件的目錄成員結構如下：
mylib/
       __init__.py
       myMathFun.py
       countNum.py


若要引入myMathFun模組，可以在檔案上方加入
from mylib import myMathFun

若要使用myMathFun中的類別物件或函式，可用
#main.py
from mylib import myMathFun
.....
.....
myMathFun.sumHierarchy(5)


在 __init__.py中所定義的物件類別或函式，可直接引入使用。
#mylib/__init__,py

def sayHello():
    print "hello')
   
#main.py
from mylib import sayHello
.....
.....
sayHello()
       

python 的模組設計

python 的模組設計

在應用程式開發的過程中，我們會將相關的函式或類別程式碼組合在同一支程式，這個我們稱之為模組，當這個模組需要被其它程式引用時，可以使用import 的指令來將模組引入，經常一個應用程式是必須要引用多個模組module才能完成應執行的任務。

對每一個python檔案而言，我們也可以將它視為一個模組，例如，我們在myMathFun.py檔案中設計一個可以計算階層加總的函式：

# myMathFun.py

def sumHierarchy(n):
    if n<2: return 1
    else: return n+sumHierarchy(n-1)



如果要在其它的程式中執行，就必須利用import 的語法或from xxx import xxx的語法將模組或模組中的函式引入：

# main.py
import myMathFun

def main():
    print '1+2+...5= %d'%myMathFun.sumHierarchy(5)

if __name__=='__main__':
    main()


當要引入特定物件類別或函式時：

# main.py
from myMathFun import sumHierarchy

def main():
    print '1+2+...5= %d'%sumHierarchy(5)

if __name__=='__main__':
    main()

執行結果為：

C:\Users\Administrator>python main.py
1+2+...5= 15


在上述例子中 __name__ 常數是每一個模組都有的內建常數，這個常數的值就是模組的名稱(也是檔案的名稱)，當python直譯器在執行一個python檔案時，它會將此常數__name__的值改成__main__也就是切入程式執行的點，所以在此 if 判斷式中所執行的函式或程式就會在程式一開始執行時被載入運作。

python 自訂例外處理

python 自訂例外處理

在程式碼中，若能預測會發生的例外情形，你就可以使用raise關鍵字來手動抛出一個例外物件。

def getDivisionResult(intNum1,intNum2):
    if not intNum2:
        raise ZeroDivisionError('Number 2 can not be zero')
    else:
        return intNum1/intNum2

try:
    getDivisionResult(10,0)
except ZeroDivisionError as err:
    print 'Error Message is %s'%err

...
Error Message is Number 2 can not be zero
>>>


try:
    getDivisionResult(10,5)
except ZeroDivisionError as err:
    print 'Error Message is %s'%err
...
2
>>>

各種型式的error 物件，可參考：https://docs.python.org/2/library/exceptions.html

另外，我們也可以自行定義例外物件，自行定義的物件，必須要繼承自Exception物件類別。
class DivisionErr(Exception):
    def __init__(self,msg):
        self.message=msg

def getDivisionResult(intNum1,intNum2):
    if not intNum2:
        raise DivisionErr('Number 2 can not be zero')
    else:
        return intNum1/intNum2

try:
    getDivisionResult(10,0)
except DivisionErr as err:
    print err.message


...
Number 2 can not be zero

若你想要讓你定義的物件實體像一般常見到的例外物件一樣，能夠直接透過物件實體來輸出時，你必須在物件中加入 __str__ 的物件方法。

class DivisionErr(Exception):
    def __init__(self,msg):
        self.message=msg
   
    def __str__(self):
        return self.message

def getDivisionResult(intNum1,intNum2):
    if not intNum2:
        raise DivisionErr('Number 2 can not be zero')
    else:
        return intNum1/intNum2

try:
    getDivisionResult(10,0)
except DivisionErr as err:
    print 'Error message is %s'%err

...
Error message is Number 2 can not be zero

python的例外處理

python的例外處理

當python的程式碼在執行時，若發生語法或程式運算錯誤時，系統就會丟出一個例外(Exception)錯誤，如：

>>> i=0

>>> 10/i

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

ZeroDivisionError: integer division or modulo by zero

>>> whild i<10: print i

  File "<stdin>", line 1

    whild i<10: print i

          ^

SyntaxError: invalid syntax

>>>

python 的檔案處理

python 的檔案處理

python 要開啟檔案時，可呼叫內建的函式  open(filename, mode)，mode有多種選擇：

'r' ： 開啟檔案為讀取模式，此為預設模式。

'w'：開啟檔案為可寫入模式，若檔案存在，則會被覆蓋內容。

'a'：開啟檔案為可進行尾端附加寫入模式。

' b'：檔案進行二進位資料處理

參考資料：https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files

• 檔案寫入模式

>>> f = open('workfile', 'w')

>>> f.write('This is the entire file.\n')

>>> print f

<open file 'workfile', mode 'w' at 0x020C4D88>

>>> f.close()

• 檔案讀取模式

>>> myfile=open('workfile')

>>> myfile.readline()

'This is the entire file.\n'

>>> myfile.readline()

''

python 的物件繼承

python 的物件繼承

物件的繼承關係( inheritance)，可簡化繁複設計的程式碼，讓物件保留母物件的屬性及方法，並可以加上或修改自己的屬性與方法，這種方式大大提高程式設計的效率，繼承的方法就是在物件類別名稱後的小括號中，放入要繼承的物件類別名稱(如Student物件類別繼承了object物件。

class Student(object):
    number=''
    def __init__(self,number):
        self.number=number
        self.__initSomething()
    def set_number(self,number):
        self.number=number
    def get_number(self):
        return self.number
    def __initSomething(self):
        print 'init something....'

class TimeWorker(Student):
    __name=''
    def __init__(self,number,name):
        self.number=number
        self.__name=name
    def set_name(self,name):
        self.__name=name
    def get_name(self):
        return self.__name

>>> tw=TimeWorker('N95050005','eric')
>>> tw.get_number()
'N95050005'
>>> tw.get_name()
'eric'

python 的物件設計

python 的物件設計

在python 中除了可以定義函式外，它也同樣有物件導向的設計，class關鍵字則是用來定義物件的類別，物件類別可以用來產生物件實體 ( instance) ，所以它也可以視為是一種資料型態。

class Student(object):
    number=''
    def __init__(self,number):
        self.number=number
    def set_number(self,number):
        self.number=number
    def get_number(self):
        return self.number

>>> std=Student('')
>>> print std.get_number()

>>> std=Student('N90000001')
>>> print std.get_number()
N90000001

>>> std.set_number('N00010001')
>>> print std.get_number()
N00010001
>>>

python 的流程控制

python 的流程控制

python 在執行程式時，都是依照程式碼的順序由上而下執行，若遇到程式需要做判斷、或需要反覆執行某幾行程式碼時，就需要改變程式執行的流程。

• if 條件判斷式

當需要做條件判斷時，就必須使用 if 的條件判斷，如：

 x=30

 if x>30:

    print 'x is more than 30.'

 elif x==30:

　print 'x is equal to 30.'

 else:

     print 'x is small than 30.'

...

x is equal to 30.

if 的條件判斷可搭配 elif 及 else 來判斷其它的條件。每一個符合條件的區塊以 "：" 開始，可以用縮排來區分，但同一區段的縮排方式要一致。

python 函式處理

python 函式處理

當有一段程式碼需要重覆執行時，我們可以將此段程式碼定義成一個函式(function)，以利作為後續呼叫使用。

• 函式的定義

我們可以透過def 的方式來定義函式名稱

def <name>(arg1,arg2,.....,argN):

    <statements>

若有回傳值，可定義為

def <name>(arg1,arg2,.....,argN):

    <statements>

    return <vaule1,value2,.....,valueN)

如：

def plusAndMulti(x,y):

     intPlus=x+y

     intMulti=x*y

     print 'x+y=%s'%intPlus

     print 'x*y=%s'%intMulti

>>> plusAndMulti(10,20)

x+y=30

x*y=200

>>>

def getPlusResult(x,y):

     return x+y

>>> getPlusResult(10,20)

30

 def getFirstAndLastElement(lst):

     if not len(lst)>0: return None,None

     return lst[0],lst[len(lst)-1]

>>> lst=[1,2,3,4,5]

>>> getFirstAndLastElement(lst)

(1, 5)

>>> lst=[5]

>>> getFirstAndLastElement(lst)

(5, 5)

>>> lst=[]

>>> getFirstAndLastElement(lst)

(None, None)

>>> lst=[1,2,3,4,5]

>>> b,c=getFirstAndLastElement(lst)

>>> print b,c

1 5

python 的布林資料型態

python 的布林資料型態與空值

• python 中要表示布林資料型態，可以使用True及False來表示，在控制流程中，會使用布林值來判斷是否進入迴圈。

>>> t=True

>>> type(t)

<type 'bool'>

>>> r=False

>>> r

False

• None表示變數是空值，其相當於Java的null。

>>> x
['name', 'phone', 'email']

>>> x=None
>>> x

python的dict資料型態

python的dict資料型態

• 在python的List的資料型態中，每個元素以它所在的位置序號作為索引值index來進行資料存取的key值，在dict的資料型態，則是可以自定key值來做為資料的索引值。
• dict資料型態是用左右大括號 ' { ' 、' } ' 將資料包含在其中，並用逗號 ' , ' 來作為區隔，每個key-value是以冒號 ' : ' 來進行配對，如：

>>> dic={'name':'eric','phone':'0900000000','email':'a@b.c.d'}

>>> dic

{'phone': '0900000000', 'name': 'eric', 'email': 'a@b.c.d'}

• dict資料型態的key值一定要是字串資料，value值則可以是任何資料型態。

• dict也可以由List的配對tuple資料轉換而來，其中tuple第一個元素會轉換為key，第二個元素會轉換成value

>>> x=[('name','eric'),('phone','0900000000'),('email','a@b.c.d')]

>>> y=dict(x)

>>> y

{'phone': '0900000000', 'name': 'eric', 'email': 'a@b.c.d'}

>>> y['phone']

'0900000000'

• 另外也可以用zip的方式將兩個同數量不同List轉換成一個dict資料型態，如：

>>> x=['name','phone','email']

>>> y=['eric','0900000000','a@b.c.d']

>>> z=zip(x,y)

>>> z

[('name', 'eric'), ('phone', '0900000000'), ('email', 'a@b.c.d')]

>>> dict(z)

{'phone': '0900000000', 'name': 'eric', 'email': 'a@b.c.d'}

>>> z

[('name', 'eric'), ('phone', '0900000000'), ('email', 'a@b.c.d')]

>>> r=dict(z)

>>> r

{'phone': '0900000000', 'name': 'eric', 'email': 'a@b.c.d'}

• 另外，我們也可以將dict轉換成List的資料型態。

>>> t=r.items()

>>> t

[('phone', '0900000000'), ('name', 'eric'), ('email', 'a@b.c.d')]

• 若我們要取出dict的key或value值時，可以使用keys( )及values( )兩個方法來取出，如

>>> r

{'phone': '0900000000', 'name': 'eric', 'email': 'a@b.c.d'}

>>> r.keys()

['phone', 'name', 'email']

>>> r.values()

['0900000000', 'eric', 'a@b.c.d']

• 若要刪除某一對key-value組合時，可以使用del指令，如：

>>> r

{'phone': '0900000000', 'name': 'eric', 'email': 'a@b.c.d'}

>>> del r['name']

>>> r

{'phone': '0900000000', 'email': 'a@b.c.d'}

>>>

python 的tuple資料型態

python 的tuple資料型態

python 的tuple資料型態與List非常類似，是用左右兩個括號 ' ( '與 ' ) '將元素包在其中，其與List最大的差別在於一但決定了元素的內容，就不可以變更，不像List一樣可以隨時修改。

>>> x=[1,2,3]

>>> y=(4,5,6)

>>> x[2]

3

>>> y[2]

6

>>> x

[1, 2, 3]

>>> x[2]=99

>>> x

[1, 2, 99]

>>> y[2]=99

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not support item assignment

python 的List資料型態

python 的List資料型態

• List資料型態可以用來表示任何python資料型態的有序集合，亦即將任何資料型態的資料串接在一起，可以是不同資料型態的組合，List中也可以包含另一個List，當要取出其中的資料時，可以用類似陣列的方式，指定要取出位置的資料或一個範圍的資料，如：

>>> lst=[1,2,'abc',3.4,5+6j]

>>> lst

[1, 2, 'abc', 3.4, (5+6j)]

>>> lst[4]

(5+6j)

>>> lst[3:]

[3.4, (5+6j)]

>>> lst[1:3]

[2, 'abc']

>>> lst[1:3]=[5,6]

>>> lst

[1, 5, 6, 3.4, (5+6j)]

• List可以透過( + )的符號來組合兩個不同的List，如果是要加到尾端，則可以利用append或extend兩種方法來達成，但此兩個方法是不一樣的，可參考下面例子，分辨它們的不同。

>>> x=[1,2,3]

>>> y=[4,5,6]

>>> z=[a,b,c]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'b' is not defined

>>> z=['a','b','c']

>>> x+y

[1, 2, 3, 4, 5, 6]

>>> x

[1, 2, 3]

>>> r=x+y

>>> r

[1, 2, 3, 4, 5, 6]

>>> x.append(y)

>>> x

[1, 2, 3, 'abc', [4, 5, 6]]

>>> x.extend(y)

>>> x

[1, 2, 3, 'abc', [4, 5, 6], 4, 5, 6]

• List的排序可以用reverse( )函數或是.sort(reverse=True)來達成

>>> x
[0, 1, 2, 3, 4, 5]

>>> x.sort(reverse=True)
>>> x
[5, 4, 3, 2, 1, 0]
>>> x
[5, 4, 3, 2, 1, 0]
>>> x.reverse()

>>> x
[0, 1, 2, 3, 4, 5]

• List Comprehension　表列解析，我們可以利用for 迴圈來逹成。

l=[x**2 for x in range(10)]
>>> l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

python 字串的Unicode編碼

python 字串的Unicode編碼

Unicode（中文：萬國碼、國際碼、統一碼、單一碼）是電腦科學領域裡的一項業界標準。它對世界上大部分的文字系統進行了整理、編碼，使得電腦可以用更為簡單的方式來呈現和處理文字。

在python 2.7版中，預設的字串格式為ASCII編碼，如果要以unicode的編碼格式來儲存字串，必須在字串的最前面加上 'u' 的前置字元，如：

>>> z='Hello, Eric'

>>> r=u'Hello, Eric'

>>> r

u'Hello, Eric'

>>> z

'Hello, Eric'

>>> chin=u'這是一個中文字串'

>>> chin

u'\u9019\u662f\u4e00\u500b\u4e2d\u6587\u5b57\u4e32'

>>> achin='這是一個中文字串'

>>> achin

'\xb3o\xacO\xa4@\xad\xd3\xa4\xa4\xa4\xe5\xa6r\xa6\xea'

>>> print chin

這是一個中文字串

>>> print achin

這是一個中文字串

• 對unicode編碼的字串而言，其型式如同 '\uXXXX' 的格式，各種特殊符號的unicode編碼，可參考http://www.tamasoft.co.jp/en/general-info/unicode.html　。

>>> a=u'\u0040'

>>> print a

@

python 字串資料型態

python 字串資料型態

• python中字串資料可以用半型的單引號 ( ' )或雙引號( " )來將字串內容包覆在其中，如果在其中有必要顯示單引號或雙引號時，可以用( \ )跳脫字元來將這兩個符號顯示出來。

>>> x='Hello Eric'

>>> print x

Hello Eric

>>> x='Hello, I\'m Eric'

>>> print x

Hello, I'm Eric

• 在執行環境中，無法利用Enter來直接換行，若要進行換行，可以用( \n )的字元來達成。

>>> x='Hello, \n I\'m Eric'

>>> print x

Hello,

 I'm Eric

• 若在程式碼中一次要輸入多行時，可使用( \ )符號來達成。

>>> x='Hello, \

... I\'m Eric'

>>> print x

Hello, I'm Eric

• 另外也可以使用三個單引號( ''' )或雙引號( """ )來完整保留字串資料的原始格式。

>>> x='''Hello,

... I\'m Eric'''

>>> x

"Hello,\nI'm Eric"

>>> print x

Hello,

I'm Eric

• 字串可以用( + )號或空白來達到字串的連結作用，另外可以用乘號( * )來達到倍數的作用

>>> x='Hello, '
>>> y='Eric'
>>> print x+y
Hello, Eric

>>> z='Hello, ' 'Eric'
>>> z
'Hello, Eric'

>>> print x*5+y*5
Hello, Hello, Hello, Hello, Hello, EricEricEricEricEric

• 但兩個字串變數則不行用空白來做組合運算，必須用( + )的符號來組合在一起，另外字串若要與其它非字串型態的變數相加，必須要先將非字串的變數利用str( )函數轉換為字串再進行運算。

>>> z=x y
  File "<stdin>", line 1
    z=x y
        ^
SyntaxError: invalid syntax

>>> z=x+y
>>> z
'Hello, Eric'

>>> i=9
>>> print i+x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

>>> print str(i)+x
9Hello,

• 若要取出字串中某些字元，可以將此字串的每一個字元當成陣列中的元素，起始的位置為０。

>>> z='Hello, Eric'

>>> z[3]
'l'

>>> z[0:4]
'Hell'

>>> z[:4]
'Hell'

>>> z[4:]
'o, Eric'

>>> z[-3]
'r'

>>> z[0:3]+z[5:]
'Hel, Eric'

• 要計算字串的長度，可用len( )函數來計算。

>>> z
'Hello, Eric'

>>> len(z)
11

• 字串的延伸切片運算，可以透過第三個限制值來取出相隔等距的字串字元。

>>> s='abcdefghijklmno'
>>> s[1:10:2]
'bdfhj'

python 數值資料型態

python 數值資料型態

• python 的數值資料型態有三種：整數(integer)、浮點數(float)及複數(complex number)。
• 整數及浮點數可以直接進行四則運算、餘數運算及指數運算，系統會自動轉換為範圍大的型態。

>>> 10+2

12

>>> 4.5+6

10.5

>>> 2**3

8

>>> 2^5

7

>>> 2.5/5

0.5

>>> 16**0.25

2.0

• 除法運算則依照您所要的結果來區分為整數除法與浮點數除法。
• 若除數與被除數皆為整數時，所得到的結果只有商的整數部份。
• 若除數或被除數其中一個為浮點數時，所得到的結果就會是帶有小數完整的商。

>>> 3/2

1

>>> 3.0/2

1.5

>>> 3/2.0

1.5

>>> 10.0/3

3.3333333333333335

• 對於浮點數而言，因數值呈現位數有限，表示法會將部份位數捨去，造成顯示上會有誤差，愈大量運算誤差會愈大，但對於實際結果顯示上可以利用轉換為整數int()或取浮點數有效位數round()來解決這個問題，如：

>>> x=0.1

>>> print x

0.1

>>> x**10

1.0000000000000006e-10

>>> x**50

1.0000000000000027e-50

•  整數與浮點數的轉換可以利用int( )與float( )兩個函數來完成。

>>> x=4.9

>>> int(x)

4

>>> y=5

>>> float(y)

5.0

>>> z=float(y)/x

>>> z

1.0204081632653061

>>> round(z,5)

1.02041

• 對於複數的資料型態，可以使用 x+yj 或 x+yJ 兩種(j或J)來表示，其中x表示實部，y表示虛部。

>>> x=1+4j

>>> print x

(1+4j)

>>> y=2+3j

>>> y

(2+3j)

>>> x+y

(3+7j)

>>> x*y

(-10+11j)

>>> x+6

(7+4j)

>>> x**2

(-15+8j)

>>> y**2

(-5+12j)

• 若要單獨取出複數的實部或虛部，可以使用real及imag兩個屬性。

>>> x.real

1.0

>>> x.imag

4.0

python 變數

python 變數

• python 中可以直接利用符號來儲存數值，字串或資料結構，也就是我們所謂的變數，當變數存放資料後，就可以直接拿來運算或作其它處理，不必進行宣告。

>>> x=6

>>> print x

6

>>> print x+2

8

>>> y='abc'

>>> print y+'def'

abcdef

>>> y=y+'def'

>>> print y

abcdef

>>> z=2.3

>>> print z+x

8.3

>>>

python 執行環境設定

python 執行環境設定

Python 可以在各種不同的作業系統上執行且都有不錯的效能表現,是一種易學易用的程式語言.由於python本身是一個直譯器,是不用經過編碼成執行檔就可以運作,故相當多的系統已內含有此種程式語言,如Mac OS,UNIX,LINUX等,因此直接打開終端機視窗,輸入python就可以直接使用.

在Microsoft Windows的作業系統中,需要先行安裝python套件,並設定環境變數.步驟如下:

1.點選電腦右鍵=>選擇[內容].

2.選擇[變更設定].(以windows8為例)

python 簡介

python 簡介

是一種物件導向、直譯式電腦程式語言，具有近二十年的發展歷史，成熟且穩定。它包含了一組完善而且容易理解的標準庫，能夠輕鬆完成很多常見的任務。它的語法簡捷和清晰，盡量使用無異義的英語單詞，與其它大多數程式設計語言使用大括弧不一樣，它使用縮進來定義語句塊。


與Scheme、Ruby、Perl、Tcl等動態語言一樣，Python具備垃圾回收功能，能夠自動管理記憶體使用。它經常被當作腳本語言用於處理系統管理任務和網路程式編寫，然而它也非常適合完成各種高階任務。Python虛擬機本身幾乎可以在所有的作業系統中運行。使用一些諸如py2exe、PyPy、PyInstaller之類的工具可以將Python原始碼轉換成可以脫離Python解釋器執行的程式。




(資料來源wiki)




目前Google GAE使用的是2.7版本

官方網址: https://www.python.org/

官方文件下載 https://www.python.org/downloads/