Python

标签（空格分隔）： python flask

[TOC]

导入模块

导入文件main.py，可以用import main，这个文件就相当于一个模块。
也可以用from main import main_fun导入main文件中的具体函数,class,或者变量import pac.main还可以从pac中导入具体模块，包下面还可以有包import pac.pac_sub，当然也可以这么写from pac.pac_sub import xx
或者用

注意：导入没办法通过from或者import指定文件夹。
只能用sys.path.append('xx')来附加路径，然后再import
from .表示当前包

import math

获得一个名为match的模块对象。该模块对象包括类似pi的敞亮以及类似sin和exp的函数。

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

from math import pi

从一个模块中导入一个对象

print pi #可以直接访问pi

from math import *

使用*导入模块中的所有东西

包

docstring 文档字符串

一个文档字符串是位于函数开始的字符串，其解释函数的接口。此文档字符串是一个三引号字符串，也被称为多行字符串。

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的内建函数，从键盘获得输入。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

循环

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

upper()转换成大写字母

in 运算符

>>>'a' in 'banana'
True

list

list是值得序列，字符串也是一种列表（应该元组吧，因为字符串的值不可更改），值是字符。列表的值可以是任意值。

#虽然看起来很乱，但却是允许的
[20,10,'ab',[3,5,[2,"100"]]]
#空列表
empty = []

列表是可变的

可以支持in运算

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

列表运算

叠加

#没有把重复的去掉
>>> a = [1,2,3]
>>> b = [4,2,5,6]
>>> c = a + b
>>> print c
[1,2,3,4,2,5,6]

*运算

[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
只支持数值类型的值相加

删除元素

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

字符串和列表

字符串转化为列表 `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运算符

用来检查两个变量是否引用了同一个对象
字符串值相等，那么is返回的就是True
list及时内容相同也返回False

列表作为参数传递时，是按照引用方式传递的

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)

长整数`1258689025L`

表示：
结尾L表明是一个长整数，也就是long类型。在pyhon3中long已经不存在了，所有的整数都是int类型。
任意大
int烈性有一个取值范围，长整数可以任意大，但是随着它们变大，它们消耗了更多的空间和时间。
数学运算和math模块中的函数都可以用long在进行运算

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

变长实参元组

就像C语言的(char* arg,...)。python以*开头的形参名汇集

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

列表和元组

zip是一个内建函数，其接受两个或者更多序列并把它们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

使用元组作为字典的键
例如姓名对应电话号码{'kevin','wu':180998980}

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

关系运算

关系运算符可用于元组和其它的序列；python开始比较每个序列的前一个元素。如果相等就继续下一个元素，以此类推。

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

cmp函数

比较两个元组的内容，依次比较。发现不相等的就返回数/负数/0

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

格式化输出

%g格式化输出浮点数

`%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')

当前路径 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

大多数操作系统提供了命令行接口，也被称为shell，任何可以在shell中运行的命令，都可以在Python中的管道(pipe)中运行。

cmd = 'ls -l'
#popen参数是包含shell命令的字符串。返回值相当于被打开的文件对象。
fp = os.popen(cmd)
#可以像读取文件那样，读取命令返回结果
res = fp.read()
#操作完成后需要关闭管道
fp.close()

name

__name__是一个内置变量，当脚本作为程序执行的时候，__name__的值是__main__。如果脚本被作为模块导入的时候，__name__就不会被赋值成__main__

面向对象

示例作为返回值

def find_center(rect):
    #Point对象实例
    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函数，可以用来复制任何对象

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

import copy
p2 = copy.copy(p1)
#p1和p2拥有相同的数据，但是他们并不是同一个Point对象
>>> p1 is p2
False
#正如预期，is运算符显示了p1和p2并非同一个对象。不过我们可能认为==运算结果应该是Ture，因为这两个点的数据是相同的。
#然而结果并非如此，因为==运算符默认行为和is运算符相同。
>>> p1 == p2
False

复制操作默认是浅复制的

并没有复制实例中嵌套的对象，也就是说如果实例中还有嵌套其他对象实例，那么这个复制就只是引用了该嵌套对象，并没有对其复制。
也就是在运行is运算符的时候，嵌套对象会返回True。

深复制(deepcopy)

深复制解决了浅复制的问题。

`init`方法

`str`方法

__str__方法是一个和__init__方法类似的特殊方法，用来返回一个对象的字符串表达。

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

运算符重载

`add`重载

__add__重载就能在对象上使用+运算。

# 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__函数有两个参数self和other，返回正数/0/负数。

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

isinstance判断一个值是否是对象

    #如果是这个类的实例就返回True
    isinstance(other, Time)

多态

可以在多个类上工作的函数叫多态

#由于Time类实现了__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了

类属性

变量定义在一个类的内部，但是在方法之外，称之为类属性

#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])

实例属性

被关联到实例的属性称为实例属性

@装饰符

装饰器也就是一个函数

装饰器也就是一个函数，一个用来包装函数的函数，返回一个修改后的函数对象，将其重新复制原来的标识符，并永久丧失对原函数对象的访问。

import os
import test

def deco_fun(f):
    print 'decorator function'
    #如果没有这个返回就无法调用fun函数了，因为fun变成了None
    return f

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


----------
#输出结果
test module for import
decorator function
F:\svn\tool\python_decorator
after decrator fun() do something

从上面的输出结果看，装饰器在import之后就执行了，也就是说@也是需要解释器去执行的，执行的过程就是fun=deco_fun(fun())将fun函数通过deco_fun装饰一下，然后再返回给fun。

带参数的装饰器

带参数的装饰器函数由于接受的是装饰器参数，所以在其内部必须还要定义个真正的装饰器函数，解析过程foo=decomaker(arg)(foo)

def decomaker(arg):
    '''由于有参数的decorator函数在调用时只会使用应用是的参数，而
    不是接受被装饰的函数作为参数，所以必须在其内部再创建一个函数
    '''
    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
 i'm decorator arg
after decorator fun do something

@staticmethod

经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法。

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修饰函数时，必须有一个class参数，python会默认将类作为参数传进来。

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 运行过程图解

文件开头的注释

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

Python

Python

导入模块

import math

from math import pi

from math import *

包

docstring 文档字符串

键盘输入

字符串

索引[x]或者[-x]

切片

不可赋值

find

循环

upper()转换成大写字母

in 运算符

list

列表是可变的

可以支持in运算

遍历列表

列表运算

叠加

*运算

切片

方法

删除元素

字符串和列表

字符串转化为列表 lists

字符串分割成单词 split

split的相反操作join

is运算符

列表作为参数传递时，是按照引用方式传递的

字典

遍历

空字典

字典的兼职必须是可哈希的(hashable)

长整数1258689025L

Tuples元组

元组是不可变的

元组作为返回值

变长实参元组

列表和元组

字典和元组

关系运算

cmp函数

格式化输出

文件

文件操作

open('file','w')

f.write(string)

f.read

f.close()

绝对路径 abspath

当前路径 getcwd

检测文件或者目录是否存在

返回目录列表

异常处理

管道pipe

____name____

面向对象

示例作为返回值

Copying

复制操作默认是浅复制的

深复制(deepcopy)

__init__方法

__str__方法

运算符重载

__add__重载

__radd__

__cmp__

isinstance判断一个值是否是对象

多态

类属性

实例属性

@装饰符

装饰器也就是一个函数

带参数的装饰器

@staticmethod

@classmethod

字符串转化为列表 `lists`

split的相反操作`join`

长整数`1258689025L`

name

`init`方法

`str`方法

`add`重载

`radd`

`cmp`