Python

標(biāo)簽（空格分隔）： python flask

[TOC]

導(dǎo)入模塊

導(dǎo)入文件main.py，可以用import main慢宗，這個文件就相當(dāng)于一個模塊。
也可以用from main import main_fun導(dǎo)入main文件中的具體函數(shù),class,或者變量import pac.main還可以從pac中導(dǎo)入具體模塊，包下面還可以有包import pac.pac_sub，當(dāng)然也可以這么寫from pac.pac_sub import xx
或者用

注意：導(dǎo)入沒辦法通過from或者import指定文件夾碗短。
只能用sys.path.append('xx')來附加路徑，然后再import
from .表示當(dāng)前包

import math

獲得一個名為match的模塊對象题涨。該模塊對象包括類似pi的敞亮以及類似sin和exp的函數(shù)偎谁。

print math.pi #使用math里的對象

from math import pi

從一個模塊中導(dǎo)入一個對象

print pi #可以直接訪問pi

from math import *

使用*導(dǎo)入模塊中的所有東西

包

docstring 文檔字符串

一個文檔字符串是位于函數(shù)開始的字符串，其解釋函數(shù)的接口纲堵。此文檔字符串是一個三引號字符串巡雨，也被稱為多行字符串。

def ployline(t, n, l, a):
    """Draws n line segments with the given lenght 
    and angle between them. t is a turtle. 
    """
    for i in range(n):
        fd(t, l)
        lt(t, a)

鍵盤輸入

python2提供了一個被稱為raw_input的內(nèi)建函數(shù)席函，從鍵盤獲得輸入铐望。python3中稱為input

>>> input = raw_input()
What are you waiting for?
>>> print input
What are you waiting for?
#提示用戶輸入什么
>>> input = raw_input('What...is your name?\n')
What...is your name?
Arthur, King of the Britons!
>>> print name
Arthur, King of the Britons!
#\n是為了換行

字符串

索引[x]或者[-x]

>>>fruit = 'banana'
>>>letter = fruit[1]
>>>print letter
a
>>>len(fruit)
6
>>>letter = fruit[-1]
>>>print letter
a

切片

[n:m]返回從第n個字符到第m個字符的部分字符串，包括n但不包括m茂附，[:m] == [0:m] [n:] == [n:len(string_xx)]

>>> fruit = 'banana'
>>> fruit[:3]
'ban'
>>> fruit[3:]
'ana'

不可賦值

>>>fruit[2] = 'x'
TypeError: object does not support item assignment

find

循環(huán)

count = 0
for letter in word:
    if letter == 'a'
        count = count + 1
print count

upper()轉(zhuǎn)換成大寫字母

in 運(yùn)算符

>>>'a' in 'banana'
True

list

list是值得序列正蛙，字符串也是一種列表（應(yīng)該元組吧，因?yàn)樽址闹挡豢筛模┯凳亲址Ａ斜淼闹悼梢允侨我庵怠?/p>

#雖然看起來很亂，但卻是允許的
[20,10,'ab',[3,5,[2,"100"]]]
#空列表
empty = []

列表是可變的

可以支持in運(yùn)算

>>> cheeses = ['Cheddar', 'Edam', 'Gouda']
>>> 'Edam' in cheeses
True
>>> 'Brie' in cheeses
False

遍歷列表

for cheese in cheeses:
    print cheese
#如果想寫或者更新元素溶推，那么就需要索引。
for i in range(len(numbers)):
    numbers[i] = number[i]*2

列表運(yùn)算

疊加

#沒有把重復(fù)的去掉
>>> a = [1,2,3]
>>> b = [4,2,5,6]
>>> c = a + b
>>> print c
[1,2,3,4,2,5,6]

*運(yùn)算

[0]*4
[0,0,0,0]

切片

和字符串切片一樣

方法

*　append

    t = ['a','b']
    t.append['c']
    print t
['a','b','c']

*　extend
將兩個列表拼接到一起

    t1 = [1,2,3]
    t2 = [4,5]
    t1.axtend(t2)
[1,2,3,4,5]

• sort
  sort從低到高排序列表
• sum
  只支持?jǐn)?shù)值類型的值相加

刪除元素

value = pop(i)或者不需要被刪除的值奸攻，就用del t[i],如果不知道索引蒜危，只知道值，可以用t.remove('a')睹耐。
del支持del t[1:5]

字符串和列表

字符串轉(zhuǎn)化為列表 lists

t = lists(s)

字符串分割成單詞 split

    s = 'pining for the fjorbs'
    t = s.split()
    print t
['pining', 'for', 'the', 'fjorbs']

split的相反操作join

    t = ['pining', 'for', 'the', 'fjorbs']
    s = t.join()
    print s
'pining for the fjorbs'

is運(yùn)算符

用來檢查兩個變量是否引用了同一個對象
字符串值相等辐赞，那么is返回的就是True
list及時內(nèi)容相同也返回False

列表作為參數(shù)傳遞時，是按照引用方式傳遞的

def delete_head(t):
    del t[0]
letters = ['a','b','c']
delete_head(letters)
print letters
['b','c']

字典

字典由Key:value組成硝训，列表就是一個特殊的字典key就是索引响委。

遍歷

    for k in d:
        v = d[k]

空字典

    d = dict()

字典的兼職必須是可哈希的(hashable)

長整數(shù)1258689025L

• 表示：
  結(jié)尾L表明是一個長整數(shù)新思，也就是long類型。在pyhon3中l(wèi)ong已經(jīng)不存在了赘风，所有的整數(shù)都是int類型夹囚。
• 任意大
  int烈性有一個取值范圍，長整數(shù)可以任意大邀窃，但是隨著它們變大荸哟，它們消耗了更多的空間和時間。
• 數(shù)學(xué)運(yùn)算和math模塊中的函數(shù)都可以用long在進(jìn)行運(yùn)算

Tuples元組

元組是不可變的

t = (12,3,324,54)

元組作為返回值

    def min_max(t):
        return min(t), max(t)
    t = min_max((1,23,3,5,57,9))
    print t
(1,57)
    #或者
    min,max = min_max((1,23,3,5,57,9))
    print min,max
1 57

變長實(shí)參元組

就像C語言的(char* arg,...)瞬捕。python以*開頭的形參名匯集

    def printall(*args)
        print args
    printall(1,2.9,'3')
(1,2.9,'3')

列表和元組

zip是一個內(nèi)建函數(shù)鞍历，其接受兩個或者更多序列并把它們zip到一個元組列表中

    zip('Anne','Elk')
[('A', 'E'),('n','l'),('n','k')]
    t = [('a', 0), ('b', 1), ('c', 2)]
    for letter, number in t:
        print number, letter
0 a
1 b
2 c

字典和元組

字典有一個items方法，返回一個元組列表

>>> d = {'a':0, 'b':1, 'c':2}
>>> t = d.items()
>>> print t
[('a', 0), ('c', 2), ('b', 1)]

相反肪虎，也可以從一個元組列表初始化一個新的字典

>>> t = [('a', 0), ('c', 2), ('b', 1)]
>>> d = dict(t)
>>> print d
{'a': 0, 'c': 2, 'b': 1}

所以要打印字典里的key和value:

for k, v in d.items()
    print k, v

使用元組作為字典的鍵
例如姓名對應(yīng)電話號碼{'kevin','wu':180998980}

d[last, first] = number
for last, first in d:
    print first, last, d[last,first]

關(guān)系運(yùn)算

關(guān)系運(yùn)算符可用于元組和其它的序列劣砍；python開始比較每個序列的前一個元素。如果相等就繼續(xù)下一個元素扇救，以此類推刑枝。

>>> (0,1,2) < (0,3,4)
True

cmp函數(shù)

比較兩個元組的內(nèi)容，依次比較爵政。發(fā)現(xiàn)不相等的就返回數(shù)/負(fù)數(shù)/0

t1 = c1.suit, c1.name
t2 = c2.suit, c2.name
cmp(t1,t2)

格式化輸出

%g格式化輸出浮點(diǎn)數(shù)

`%d %g %s` %(3, 0.1, 'string')
'In %d years I have spotted %g %s' %(3, 0.1, 'camels')

文件

文件操作

open('file','w')

f.write(string)

f.read

f.close()

絕對路徑 abspath

os.path.abspath('memo.txt')

當(dāng)前路徑 getcwd

os.getcwd()

檢測文件或者目錄是否存在

os.path.exists('memo.txt')
os.path.isdir('xx')
os.path.isfile('xx.xx')

返回目錄列表

os.listdir(cwd)

異常處理

try:
    fin = open('bad_file')
    for line in fin:
        print line
    fin.close()
except:
    print 'Something went wrong.'

管道pipe

大多數(shù)操作系統(tǒng)提供了命令行接口仅讽，也被稱為shell，任何可以在shell中運(yùn)行的命令钾挟，都可以在Python中的管道(pipe)中運(yùn)行洁灵。

cmd = 'ls -l'
#popen參數(shù)是包含shell命令的字符串。返回值相當(dāng)于被打開的文件對象掺出。
fp = os.popen(cmd)
#可以像讀取文件那樣徽千，讀取命令返回結(jié)果
res = fp.read()
#操作完成后需要關(guān)閉管道
fp.close()

____name____

__name__是一個內(nèi)置變量，當(dāng)腳本作為程序執(zhí)行的時候汤锨，__name__的值是__main__双抽。如果腳本被作為模塊導(dǎo)入的時候，__name__就不會被賦值成__main__

面向?qū)ο?/h2>

示例作為返回值

def find_center(rect):
    #Point對象實(shí)例
    p = Point() 
    p.x = rect.corner.x + rect.width/2.0
    p.y = rect.corner.y + rect.height/2.0
    return p

Copying

copy模塊提供了一個copy函數(shù)闲礼，可以用來復(fù)制任何對象

p1 = Point()
p1.x = 3
p1.y = 4

import copy
p2 = copy.copy(p1)
#p1和p2擁有相同的數(shù)據(jù)牍汹，但是他們并不是同一個Point對象
>>> p1 is p2
False
#正如預(yù)期，is運(yùn)算符顯示了p1和p2并非同一個對象柬泽。不過我們可能認(rèn)為==運(yùn)算結(jié)果應(yīng)該是Ture慎菲，因?yàn)檫@兩個點(diǎn)的數(shù)據(jù)是相同的。
#然而結(jié)果并非如此锨并，因?yàn)?=運(yùn)算符默認(rèn)行為和is運(yùn)算符相同露该。
>>> p1 == p2
False

復(fù)制操作默認(rèn)是淺復(fù)制的

并沒有復(fù)制實(shí)例中嵌套的對象，也就是說如果實(shí)例中還有嵌套其他對象實(shí)例第煮，那么這個復(fù)制就只是引用了該嵌套對象解幼，并沒有對其復(fù)制抑党。
也就是在運(yùn)行is運(yùn)算符的時候，嵌套對象會返回True撵摆。

深復(fù)制(deepcopy)

深復(fù)制解決了淺復(fù)制的問題底靠。

__init__方法

__str__方法

__str__方法是一個和__init__方法類似的特殊方法，用來返回一個對象的字符串表達(dá)台汇。

class Time：
    def __init__(self, h=0, m=0, s=0):
        self.hour = h
        self.min = m
        self.sec = s
    def __str__(self):
        return '%.2d:%.2d:%.2d' %(self.hour, self.min, self.sec)
        
>>> t = Time(9,45)
>>> print t
09:45:00

運(yùn)算符重載

__add__重載

__add__重載就能在對象上使用+運(yùn)算苛骨。

# inside class Time:
    def __add__(self, other):
        sec = self.time_to_int() + other.time_to_int()
        return int_to_time(sec)
#然后這么使用
>>> start = Time(9,45)
>>> duration = Time(1, 35)
>>> print start + duration
11:20:00

__radd__

__cmp__

__cmp__函數(shù)有兩個參數(shù)self和other，返回正數(shù)/0/負(fù)數(shù)苟呐。

#inside class Time:
    def __cmp__(self, other):

isinstance判斷一個值是否是對象

    #如果是這個類的實(shí)例就返回True
    isinstance(other, Time)

多態(tài)

可以在多個類上工作的函數(shù)叫多態(tài)

#由于Time類實(shí)現(xiàn)了__add__方法痒芝，所以sum方法同樣可以工作
>>> t1 = Time(7, 43)
>>> t2 = Time(7, 41)
>>> t3 = Time(7, 37)
>>> total = sum([t1, t2, t3])
>>> print total
23:01:00
#這個太NB了

類屬性

變量定義在一個類的內(nèi)部，但是在方法之外牵素，稱之為類屬性

#inside class Card:
    suit_name = ['Clubs', 'Diamonds', 'Hearts']
    rank_name = [None, 'Ace', '2', '3']
    def __str__(self):
        return '%s of %s' %(rank_name[self.rank], suit_name[self.suit])

實(shí)例屬性

被關(guān)聯(lián)到實(shí)例的屬性稱為實(shí)例屬性

@裝飾符

裝飾器也就是一個函數(shù)

裝飾器也就是一個函數(shù)严衬，一個用來包裝函數(shù)的函數(shù)，返回一個修改后的函數(shù)對象笆呆，將其重新復(fù)制原來的標(biāo)識符请琳，并永久喪失對原函數(shù)對象的訪問。

import os
import test

def deco_fun(f):
    print 'decorator function'
    #如果沒有這個返回就無法調(diào)用fun函數(shù)了赠幕，因?yàn)閒un變成了None
    return f

@deco_fun
def fun():
    print 'after decorator fun() do something'
    
print os.getcwd()    
fun()


----------
#輸出結(jié)果
test module for import
decorator function
F:\svn\tool\python_decorator
after decrator fun() do something

從上面的輸出結(jié)果看俄精，裝飾器在import之后就執(zhí)行了，也就是說@也是需要解釋器去執(zhí)行的榕堰，執(zhí)行的過程就是fun=deco_fun(fun())將fun函數(shù)通過deco_fun裝飾一下竖慧，然后再返回給fun。

帶參數(shù)的裝飾器

帶參數(shù)的裝飾器函數(shù)由于接受的是裝飾器參數(shù)逆屡，所以在其內(nèi)部必須還要定義個真正的裝飾器函數(shù)圾旨，解析過程foo=decomaker(arg)(foo)

def decomaker(arg):
    '''由于有參數(shù)的decorator函數(shù)在調(diào)用時只會使用應(yīng)用是的參數(shù)，而
    不是接受被裝飾的函數(shù)作為參數(shù)魏蔗，所以必須在其內(nèi)部再創(chuàng)建一個函數(shù)
    '''
    def newDeco(func):
        print func, arg
        return func
    return newDeco

@decomaker("i'm decorator arg")
def fun():
    print 'after decorator fun do something'

fun()


#輸出
-------------
test module for import
<function fun at 0x02A76530> i'm decorator arg
after decorator fun do something

@staticmethod

經(jīng)常有一些跟類有關(guān)系的功能但在運(yùn)行時又不需要實(shí)例和類參與的情況下需要用到靜態(tài)方法砍的。

IND = 'ON'
class Kls(object):
    def __init__(self, data):
        self.data = data
    @staticmethod
    def checkind():
        return (IND == 'ON')
    def do_reset(self):
        if self.checkind():
            print('Reset done for:', self.data)
    def set_db(self):
        if self.checkind():
            self.db = 'New db connection'
        print('DB connection made for: ', self.data)
ik1 = Kls(12)
ik1.do_reset()
ik1.set_db()

#輸出
---------------------
Reset done for: 12
DB connection made for: 12

@classmethod

在用@classmethod修飾函數(shù)時，必須有一個class參數(shù)莺治，python會默認(rèn)將類作為參數(shù)傳進(jìn)來廓鞠。

class Kls(object):
    no_inst = 0
    def __init__(self):
        Kls.no_inst = Kls.no_inst + 1
    @classmethod
    def get_no_of_instance(cls_obj):
        return cls_obj.no_inst
ik1 = Kls()
ik2 = Kls()
print ik1.get_no_of_instance()
print Kls.get_no_of_instance()

classmethod/staticmethod 運(yùn)行過程圖解

文件開頭的注釋

#!usr/bin/env python
# -*- coding:utf-8 -*-