通過上班閑暇時間開始學習一門腳本語言--python，很早前就有老同學建議學習一門腳本語言對未開開發會很有幫助，最初考慮選擇哪門語言的時候在python和ruby中糾結了一下，最后選擇python主要是感覺它的使用用戶更廣。

?

• 開發環境

我是在windows平臺下開發的，python版本官方推薦的是2.7和3.3，我選擇了后者，附上 下載地址 。

事實上，對于新手來說，2.x和3.x確實有一些改變，如果你用2.x的幫助文檔在3.x下開發可能會遇到一些麻煩（比如print由命令變成了函數）。

在windows下安裝完成后可以在開始菜單看到python目錄，打開python(command line)輸入：print("hello world")回車，如果沒有報錯說明安裝成功了。

?

• 編輯器

python官方自帶了IDLE(Python GUI)編輯器（見上圖），當然很多老手都推薦使用這款編輯器，希望新手從0開始，使用這種編輯器沒有太多智能提示，很多代碼都必須自己編寫，這樣能提升新手的熟練度。但我覺得這個太麻煩了，所以用了一段時候就放棄了。

隨后選擇的是python-eclipse插件，在eclipse下開發，這個插件比IDLE更好了一步，但是還是不算完美，要安裝pydev可以在eclipse下 下載這個插件

最后在ITEye無意看到一個python編輯器的宣傳--jetbrains pycharm，下載了社區版試用了一下感覺非常不錯，提示健全，反應迅速，一直用到現在。

當然我從老王python也看到一些推薦，因為沒試用過就不發表評論了。

?

• 學習文檔

對于新手，有一本好的入門書籍無疑會讓你學習效率事半功倍，我看的是《python基礎教程（第二版）》，里面內容非常豐富，跟著文檔邊看邊練，很快就會了。而ITEye的python群組共享了另外兩本python入門電子書《python先入為主》和《簡明Python教程》，前者是老王python給新手的，但是內容相當淺顯，對我幫助不大，而后者對python的數據結構、語法等都做了一些總結，建議新手在看了《python基礎教程》之后再去看《簡明python教程》的基礎知識復習一下，但是簡明教程中的例子大多跑不起來。

?

• 代碼筆記

好記性不如爛筆頭，下面就是在學習python中做的筆記，內容也不多，每隔幾天花半個小時溫習一下，很快就熟悉了。

      #coding=gbk

#input()用戶獲取用戶輸入
name=input('what is your name?')
#print()用于輸出數據給用戶
print ('My name is '+name+'!')

#repr()和str()都可以轉換為字符串
#repr()輸出對Python比較友好，而str()的輸出對用戶比較友好
inta = 111
print('repr='+repr(inta)+'  str='+str(inta))

#通過三個雙引號或者單引號可創建換行的長字符串
print("""kaka
xi
laoshi
a""")
#通過\n也可以達到換行的效果
print("hello\nworld")
#原始字符串r 作用是讓后面的字符串內容不轉義，類似于XML中的CDATA
print(r"C:\nnd"); #注意：原始字符串不能以\結尾，即print(r"C:\nnd\")是錯誤的

#常規序列，java中成為數組
array1 = ['kakaxi',30]
array2 = ['nanuto',15]
array12 = array1 + array2
print(array12)

#索引，通過索引可以獲取指定數據
index = "這是一個索引"
print("第一個字："+index[0])    #從左到右，從0、1、2...
print("最后一個字："+index[-1]) #從右到左，從-1、-2、-3...
#17*['th']表示連續17個'th'，\在最后可以讓代碼換行
arraya = ['st','nd','rd'] + 17*['th']\
         +['st','nd','rd'] + 7*['th']\
         +['st']
print(arraya)

#分片，可以截取指定的數組片段
numbers = [1,2,3,4,5,6,7,8,9,10]
#1,2默認為數字，則必須轉為字符串才能輸出repr()
print("取3~6個:"+repr(numbers[3:6]));
print("取最后3個:"+repr(numbers[-3:]));
#[start:end:step]格式前兩個是分片，最后一個是步長
#步長為1表示取全部值
print("步長為1:"+repr(numbers[0::1]))
#步長為2表示每隔1個字取值，依次類推
print("步長為2:"+repr(numbers[0::2]))
#步長不能為0但可以為負數可以倒著取值
print("步長為-1:"+repr(numbers[::-1]))
#這種方式可以復制一個新數組
numbersCopy = numbers[:]
numbersCopy = numbersCopy[:3]
#numbersCopy改變了，不影響numbers的值
print(repr(numbersCopy));
print(repr(numbers))

#序列相加 這樣會將兩個序列合并到一起
array_add = ['a','b','c'] + ['d','e','f']
#序列相乘 用數字x乘以一個序列會生成新的序列，而新序列中原來的序列被重復x次
array_multiply = 5*['demo','test']
#下面是生成一個具有10個空間的空序列,None是內置值，類似于java的null
array_none = [None]*10
array_none[0] = '1'
array_none[1] = 2
#分片賦值，可以理解為在索引1前面添加一個序列
array_none[1:1] = [2,3,4]
#del刪除指定序列 del還可以刪除其他類型
del array_none[6:]
print('array_none:'+repr(array_none))

#in判斷是否有指定數據，返回true，false
inboolean = 'a' in array_add
print(inboolean)

#len()返回序列總共多少個值
print(len(array_add))
#min()返回序列第一個值
print(min(array_add))
#max()返回序列最后一個值
print(max(array_add))

#list()可以將字符串轉換為list
print("list()方法："+repr(list('hello')))

lst = [1,2,3]
#在list后面追加對象
lst.append(4)
print("lst.append():"+repr(lst))

lsta = [1,2,3]
lstb = [4,5,6]
lsta.extend(lstb);
#extend()將序列合并到一起，比+性能要高
print("lst.extend():"+repr(lsta));
#返回第一個匹配的序列索引
print("lst.index():"+repr(lsta.index(2)))
#insert()在指定索引位置新增一個數據
lsta.insert(2,'aaa');
#pop()彈出序列最后一位并且返回原值
print("lst.pop()"+repr(lsta.pop()))
#remove()移出列表中第一個匹配項
lsta.remove(1)
#reverse列表反轉
lsta.reverse()
#sort列表重新排序
#lsta.sort()

#前面的列表是可變可修改的，下面介紹的元組是不能修改的
tuple1 = (1,2,3)
#一個元組一定要有逗號結束
tuple2 = (1,)
#創建一個具有3個1的元組
tuple3 = 3*(1,)
#tuple()能將指定數據轉換成元組
tuple([1,2,3])
tuple('abc')
#元組的索引訪問也很簡單
print("元組[1]:"+str(tuple1[1]))
#元組可以用于map映射中的key，而序列是不行的

#字符串格式化，類似于java的占位符，可以將元組中的數據依次填入字符串中補充
str1 = '你%s中%s'
#好像只能是元組才能格式
lstStr1 = ('好','國')
print(str1%lstStr1);
#更多格式化參考：http://www.cnblogs.com/JerySpace/archive/2010/12/17/1909621.html

string = 'This is a string!'
#find返回字符串第一個匹配的索引，沒有匹配返回-1
print("string.find():"+ repr(string.find('is')) )
#join()是split的逆方法，用于將數組轉換為字符串
seq = ['1','2','3','4','5']
sep = '+'
print("join():"+sep.join(seq))
#lower()字符串全部小寫 注:lower會返回一個小寫的字符串，string值不變
print('replace:'+string.lower())
#replace()全部替換匹配的字符串 注:replace會返回一個被替換的字符串，string值不變
print('replace:'+string.replace('is','kaka'))
#split()分割字符串并轉換成list
print('split:'+repr( string.split(' ') ))
#strip()去字符串兩頭的空格，類似于java的trim
print(string.strip())

#數據結構“字典”，類似于java的map，有key和value之分，每一組值由逗號分隔
map1 = {'kaka':'30','nanuto':'15','sasiki':'15'}
#len()返回字典的總個數
print("len(d):"+str(len(map1)))
#d[key]直接返回指定key的值
print("d[key]:"+map1['kaka'])
#d[key] = value給指定key賦值
map1['kaka'] = 31
#根據key刪除指定map
del map1['sasiki']
#判斷是否包含指定key
print("str in map:"+str('nanuto' in map1))
#從map中提取指定key到占位符中
print("map格式化："+"kaka's age is %(kaka)s" %map1)

map2 = {'A1':'123','A2':'456','A3':'789'}
#copy一份全新的map對象 deepcopy深度復制
map3 = map2.copy()
#clear清空map
map2.clear();
#get()也是根據key獲取指定值，比map[index]好的地方是key不存在不會報錯
map2.get('A6')
#items將map分解成一個個對象
map2.items()
#items將map轉換成迭代器，依次迭代，比items性能高
#map2.iteritems()
#keys和iterkeys與前面類似，只是迭代map中的key
#values和itervalues迭代獲取map的值
#pop(key)根據key刪除指定數據
map3.pop('A1');
#update利用一個字典更新另一個字段
map3.update(map2);

#import的幾種方式
#import math  調用math.sqrt(4)
#import math as foobar 調用foobar.sqrt(4)
#from somemodule import math 調用somemodule.sqrt(4) 前提：somemodule不能有sqrt方法

stringif = 'abcdefg'
#常規的if...else...
if stringif.startswith("abc"):
    print("stringif.startswith abc")
else:
    print("stringif.startswith !abc")

#if...elif...else...
if 1==1:
    print("1==1")
elif 2==2:
    #pass關鍵字不執行任何邏輯，開發人員可能未完成該片段代碼，可以用pass代替防止編譯報錯
    pass
else:
    print("else")

#while循環只有滿足表達式才會退出
printstr = input("print 'a'")
whileCount = 0
while printstr != "a":
    #輸入錯誤超過3次則跳出循環
    if whileCount == 3:
        #break跳出while循環  continue跳出本次邏輯，執行下一次邏輯
        break
    whileCount += 1
    printstr = input("print 'a'")
print("input right!")

forList = ["a","b","c","d","e"]
#for循環
for for_ in forList:
    print("forList:"+for_)
    
forMap = {"a":"1","b":"2","c":"3"}
#for循環Map 獲得的是key
for for_ in forMap:
    print("forMap key:"+for_+" value:"+forMap[for_])

#del只能刪除變量名，而變量值是不能(也不需要)被開發刪除的
delStr = ["刪","除"]
copyDelStr = delStr
del delStr
print("del delStr:"+str(copyDelStr))

#exec方法用于運行字符串類型的python語句
exec("print('exec()')")

    

?

      # coding=gbk

#使用def定義一個新方法
def method1(str):
    return "Your parm is:"+str
print(method1("china"))

#help中傳入方法名就能夠獲得該方法的注釋信息
help(method1)

def combine(parameter):
    #使用globals()['全局變量']的形式可以獲得全局變量名
    print(parameter + globals()['parameter'])
parameter = ' time'
combine('begin')

def combine_():
    #使用global可以在方法內修改全局變量y的值
    global y
    y = y + 1
y = 1
combine_()
print("y's value:"+str(y))

#python支持方法中嵌套方法，這種行為可以稱作“閉包”
def multiplier(factory):
    def multiplyByFactory(number):
        return factory*number
    return multiplyByFactory

double = multiplier(2)  #此時獲得的是multiplyByFactory方法
print(repr(double(5)))  #此時獲得的是multiplyByFactory執行的返回值

#另一種調用嵌套方法
print(repr(multiplier(2)(5)))

    

?

      # coding=gbk

#使用def定義一個新方法
def method1(str):
    return "Your parm is:"+str
print(method1("china"))

#help中傳入方法名就能夠獲得該方法的注釋信息
help(method1)

def combine(parameter):
    #使用globals()['全局變量']的形式可以獲得全局變量名
    print(parameter + globals()['parameter'])
parameter = ' time'
combine('begin')

def combine_():
    #使用global可以在方法內修改全局變量y的值
    global y
    y = y + 1
y = 1
combine_()
print("y's value:"+str(y))

#python支持方法中嵌套方法，這種行為可以稱作“閉包”
def multiplier(factory):
    def multiplyByFactory(number):
        return factory*number
    return multiplyByFactory

double = multiplier(2)  #此時獲得的是multiplyByFactory方法
print(repr(double(5)))  #此時獲得的是multiplyByFactory執行的返回值

#另一種調用嵌套方法
print(repr(multiplier(2)(5)))

#創建類
class Person:
    def setName(self,name):
        self.name = name
    def getName(self):
        return self.name
    def printName(self):
        print("Your name is:"+self.name)

kaka = Person()
lami = Person()
kaka.setName("kaka")
lami.name = "lami"
kaka.printName()
lami.printName()

class SecurityClass:
    def publicMethod(self):
        print("This is publicMethod")
        self.__privateMethod()
    def __privateMethod(self):#雙下劃線表示對外隱藏的方法
        print("This is privateMethod")

security = SecurityClass()
security.publicMethod()

#繼承父類，通過Class(父類)的形式即可繼承父類
class ChlildClass(SecurityClass):
    def publicMethod(self):
        print("This is  childClass's publicMethod")
chlildClass = ChlildClass()
chlildClass.publicMethod()

#可繼承多個父類
class ChildsClass(SecurityClass,Person):
    pass

#issubclass(子類,父類)用于判斷子類是否繼承父類
print("是否繼承父類："+repr(issubclass(ChlildClass,SecurityClass)))
print("是否繼承父類："+repr(issubclass(SecurityClass,ChlildClass)))
#通過Class.__bases__可獲得該類繼承的所有子類
print("基類集合："+repr(ChlildClass.__bases__))
print("判斷對象是否有該方法："+repr(hasattr(ChlildClass,'publicMethod')))

#自定義異常
class BusinessException(Exception):
    pass

#try...except...捕獲異常
try:
    print(repr(3/0))
except ZeroDivisionError:
    if 1==1:
        print("3/0異常！")
    else:
        raise  #拋出異常

try:
    print(repr(3/0))
except (ZeroDivisionError,Exception):#可以通過園組的形式監聽多種異常
        print("3/0異常！")

try:
    print(repr(3/0))
except (ZeroDivisionError,Exception) as e:#通過Exception as e獲取異常信息
        print("異常e:"+repr(e))

#except...else...finally...三者可以混用
try:
    print(repr(3/0))
except (ZeroDivisionError,Exception) as e:#通過Exception as e獲取異常信息
    print("異常e:"+repr(e))
else:
    print("無異常")
finally:
    print("finally代碼塊！")

class Demo(SecurityClass):
    #__init__構造方法用于對象創建時使用，__del__析構方法用于對象銷毀時調用
    def __init__(self,name='demo'):
        SecurityClass.__init__(self) #可以調用父類的構造方法
        self.name = name

demo = Demo()
print(demo.name)

demo2 = Demo('demo...')
print(demo2.name)

#靜態方法
class StaticClass:
    @staticmethod
    def sMethod():
        print("This is static method!")

    @classmethod
    def cMethod(cls):
        print("This is class method!",cls)

StaticClass.sMethod()
StaticClass.cMethod()

nested = [[1,2],[3,4],[5]]
def demoMethod(nested):
    for lst1 in nested:
        for lst2 in lst1:
            yield lst2 #簡單生成器，可當做迭代器使用

for number in demoMethod(nested):
    print(number)

#遞歸生成器，可處理無限層數的列表
def yieldMethod(nested):
    for lst1 in nested:
        for lst2 in yieldMethod(lst1):
            yield lst2


    

?

      __author__ = 'Administrator'
#coding=gbk

#讀寫文件
source = "C:\\copy\\alibaba.txt"

newWord = '''
大家好

才是真的

好！
'''
#第一種寫文件
f = open(source,'w') #w寫
f.write(newWord)
f.close()


#第一種讀全部內容
f = open(source) #默認只讀
try:
    print(f.read())
finally:
    f.close()

#第二種在文件末尾追加
f = open(source,'a')
f.write("你好python!")
f.close()

#第二種一行一行讀
print("====第二種====")
f = open(source,'r') #r為只讀
while True:
    line = f.readline()
    if not line:
        break
    print(line)#奇怪的是每一行都會換行
f.close()

#注：在大文件下使用readlines(sizehint)比使用read性能要好，原因是前者可以定義緩沖區最大閥值，而后者會占用全部緩沖區.writelines同理!
#更多文件讀寫，參考http://www.cnblogs.com/allenblogs/archive/2010/09/13/1824842.html
    

?

      __author__ = 'Administrator'
#coding=gbk

import sqlite3
import time

#使用sqlLite進行數據庫操作
#sqlLite在高版本python已經成為內置包，所以可以不用引入任何第三方插件使用

#connect傳入參數是數據庫文件，可以是絕對路徑，也可以是相對路徑，如果已存在則直接使用，不存在則創建一個新庫
conn = sqlite3.connect("testDB.db")
curs = conn.cursor()
conn.commit()
conn.close()

def executeSQL():
    createStr = '''
    CREATE TABLE food(
    id    TEXT PRIMARY KEY,
    name  TEXT,
    price FLOAT
    )
    '''
    conn = sqlite3.connect("testDB.db")
    curs = conn.cursor()

    #①執行表添加操作
    try:
        curs.execute(createStr)
    except sqlite3.OperationalError as e:
        conn.rollback()
        print(repr(e))

    #②執行數據添加操作
    insert = "INSERT INTO food VALUES(?,?,?)"
    values = [time.strftime("%Y%m%d%H%M%S"),'面包',5]
    try:
        curs.execute(insert,values)
        conn.commit()
        print("insert success!")
    except sqlite3.ProgrammingError:
        conn.rollback()
        raise

    #③執行數據查詢操作
    query = "SELECT * FROM food"
    curs.execute(query)
    for row in curs.fetchall():
        valueStr = ""
        for value in row:
            #因為price字段是float，所以要str()，如果用repr又是另一種景象，自己嘗試
            valueStr = valueStr + str(value) + "  "
        print(valueStr)
    conn.close()

executeSQL()
    

?