安装python+flask的博客系统blog_mini

根据指引安装出了点问题。我的环境是mac+python3.5。参考博客
1. 报错,name reload not defined。

这个好解决。增加from importlib import reload(其实没有必要)

2.报错.sys has no attribute setdefaultencodeing。

这个是因为python3.5默认是utf-8了。这个函数干掉了。。所以直接把这行代码干掉。并且之前的reload也是python2.x中为了setdefaultencodeing服务的。所以from importlib import reload 和 reload(sys)也可以干掉了。

3.报错 ImportError: No module named ‘MySQLdb’。

这个其实也没有必要了。python3.中用pymysql替代了。
解决办法时，修改DATABASE_URL=mysql+pymysql://root@127.0.0.1/blog_mini。
增加’+pymysql’后就会用pymysql的api。不过你得安装pymysql,pip install pymysql。
这个比MySQLdb容易安装多了。那个不能通过pip安装。

我fork了一个。修改后的版本：https://github.com/bjmayor/Blog_mini
因为安装了两个项目。把DATABASE_URL改成BLOG_DATABASE_URL了。
另外我搞了个fab发布。可以参考修改下。fab主要是参考的廖雪峰的python教程。

我安装完成的网站： python.go2live.cn

感觉主要是参考的Flask Web开发 基于Python的Web应用开发实战
我会根据这本书的代码对这个代码再做些优化，譬如加上用户权限，加上测试用例,去掉bootstrap的文件，直接引用flask_bootstrap。

同时也会参考wordpress的数据库结构做些优化，再加上图片上传什么的。

慢慢优化吧。懒得从头搞起，就以这个blog_mini为起点了。

1. 个人喜欢用markdonw语法。。所以第一个要把这个改掉。得支持markdown。

转载自演道,想查看更及时的互联网产品技术热点文章请点击http://go2live.cn

枚举类型可以看作是一种标签或是一系列常量的集合，通常用于表示某些特定的有限集合，例如星期、月份、状态等。Python 的原生类型（Built-in types）里并没有专门的枚举类型，但是我们可以通过很多方法来实现它，例如字典、类等：

WEEKDAY = {
    'MON': 1,
    'TUS': 2,
    'WEN': 3,
    'THU': 4,
    'FRI': 5
}
class Color:
    RED   = 0
    GREEN = 1
    BLUE  = 2

上面两种方法可以看做是简单的枚举类型的实现，如果只在局部范围内用到了这样的枚举变量是没有问题的，但问题在于它们都是可变的（mutable），也就是说可以在其它地方被修改从而影响其正常使用：

WEEKDAY['MON'] = WEEKDAY['FRI']
print(WEEKDAY)

{‘FRI’: 5, ‘TUS’: 2, ‘MON’: 5, ‘WEN’: 3, ‘THU’: 4}

通过类定义的枚举甚至可以实例化，变得不伦不类：

c = Color()
print(c.RED)
Color.RED = 2
print(c.RED)

0
2

当然也可以使用不可变类型（immutable），例如元组，但是这样就失去了枚举类型的本意，将标签退化为无意义的变量：

COLOR = ('R', 'G', 'B')
print(COLOR[0], COLOR[1], COLOR[2])

R G B

为了提供更好的解决方案，Python 通过PEP 435 在 3.4 版本中添加了 enum标准库，3.4 之前的版本也可以通过 pip install enum 下载兼容支持的库。enum 提供了 Enum,IntEnum,unique三个工具，用法也非常简单，可以通过继承 Enum/IntEnum 定义枚举类型，其中 IntEnum 限定枚举成员必须为（或可以转化为）整数类型，而 unique 方法可以作为修饰器限定枚举成员的值不可重复：

from enum import Enum, IntEnum, unique
 
try:
    @unique
    class WEEKDAY(Enum):
        MON = 1
        TUS = 2
        WEN = 3
        THU = 4
        FRI = 1
except ValueError as e:
    print(e)

duplicate values found in : FRI -> MON

try:
    class Color(IntEnum):
        RED   = 0
        GREEN = 1
        BLUE  = 'b'
except ValueError as e:
    print(e)

invalid literal for int() with base 10: ‘b’

更有趣的是 Enum的成员均为单例（Singleton），并且不可实例化，不可更改：

class Color(Enum):
    R = 0
    G = 1
    B = 2

try:
    Color.R = 2
except AttributeError as e:
    print(e)

Cannot reassign members.

虽然不可实例化，但可以将枚举成员赋值给变量：

red = Color(0)
green = Color(1)
blue = Color(2)
print(red, green, blue)

Color.R Color.G Color.B

也可以进行比较判断：

print(red is Color.R)
print(red == Color.R)
print(red is blue)
print(green != Color.B)
print(red == 0) # 不等于任何非本枚举类的值

True
True
False
True
False

最后一点，由于枚举成员本身也是枚举类型，因此也可以通过枚举成员找到其它成员：

print(red.B)
print(red.B.G.R)

Color.B
Color.R

但是要谨慎使用这一特性，因为可能与成员原有的命名空间中的名称相冲突：

print(red.name, ':', red.value)
 
class Attr(Enum):
    name  = 'NAME'
    value = 'VALUE'
print(Attr.name.value, Attr.value.name)

R : 0
NAME value

总结
enum 模块的用法很简单，功能也很明确，但是其实现方式却非常值得学习。如果你想更深入了解更多 Python 中关于 Class 和 Metaclass的黑魔法，又不知道如何入手，那么不妨阅读一下 enum的源码，或者关注接下来后面几篇的内容！

Python元类

从某种意义上讲，元类只是扩展了装饰器的代码插入模式。
元类主要是针对那些构建API和工具供他人使用的程序员。

Python构建工具：

1. 内省属性。如__class__、__dict__
2. 运算符重载方法。如__str__、__add__
3. 属性拦截方法。如__getattr__、__setattr__、__getattribute__。
4. 类特性。内置函数property。拦截特定的属性。
5. 类属性描述符。拦截特定的属性。特定只是定义根据访问自动运行函数的属性描述符的一种简洁方式。
6. 函数和类装饰器。
7. 元类。

元类允许我们在在一条class语句的末尾，插入当创建一个类对象的时候自动运行的逻辑。
这个逻辑不会把类名重新绑定到一个装饰器可调用对象，而是把类自身的创建指向特定的逻辑。

和类装饰器不同，它通常是添加实例创建时运行的逻辑，元类在类创建时运行。
同样的，它们都是通常用来管理或扩展类的钩子，而不是管理其实例。

通过声明一个元类，我们告诉Python把类对象的创建路由到我们所提供的另一个类：

由于创建类的时候，Python在class语句的末尾自动调用元类，因此它可以根据需要扩展、注册或管理类。

类也是某物的实例：

• 在Python3.0中，用户定义的类对象是名为type的对象的实例，type本身是一个类。
• 在Python2.6中，新式类继承自object,它是type的一个子类；传统类是type的一个实例，并且并不创建自一个类。
  实例创建自类，而类创建自type。
  类是类型，类型也是类
• 类型由派生自type的类定义。
• 用户定义的类是类型类的实例。
• 用户定义的类是产生它们自己的实例的类型。

类根本不是一个独立的概念：它们就是用户定义的类型，并且type自身也是由一个类定义的。

由于类实际上是type类的实例，从type的定制的子类创建类允许我们实现各种定制的类。
在Python3.0中以及在Python2.6的新式类中：

• type是产生用户定义的类的一个类。
• 元类是type类的一个子类。
• 类对象是type类的一个实例，或一个子类。
• 实例对象产生自一个类。

换句话说，为了控制创建类以及扩展其行为的方式，我们所需要做的只是指定个用户定义的类创建自一个用户定义的元类，而不是常规的type类。

从技术上讲，Python遵从一个标准的协议来使这发生：在一条class语句的末尾，并且在运行了一个命名控件词典中的所有嵌套代码之后，它调用type对象来创建class对象：

class = type(classname, superclasses,attrbuteddict)

type对象反过来定义了一个__call__运算符重载方法，当调用type对象的时候，该方法运行两个其他方法：

type.__new__(typeclass, classname,superclasses,attributeddict)
type.__init__(class,classname,superclasses,attributedict)

__new__方法创建并返回了新的class对象，并且随后__init__方法初始化了新创建的对象。
这是type的元类子类通常用来定制类的钩子。

尽管重新定义type超类的__new__和__init__方法是元类向类对象创建过程插入逻辑的最常见方法，其他方案也是可能的。
实际上任何可调用对象都可以用作一个元类，只要它接收传递的参数并且返回与目标类兼容的一个对象。

另外，我们也可以重定义元类的__call__， 以拦截创建调用。

making class
In SuperMeta.call:
…Spam
…(<class ‘__main__.Eggs’>,)
…{‘meth’: , ‘data’: 1, ‘__new__’: , ‘__module__’: ‘__main__’, ‘__qualname__’: ‘Spam’, ‘__init__’: }
In SubMeta.new:
…Spam
…(<class ‘__main__.Eggs’>,)
…{‘meth’: , ‘data’: 1, ‘__new__’: , ‘__module__’: ‘__main__’, ‘__qualname__’: ‘Spam’, ‘__init__’: }
In SubMeta init:
…Spam
…(<class ‘__main__.Eggs’>,)
…{‘meth’: , ‘data’: 1, ‘__new__’: , ‘__module__’: ‘__main__’, ‘__qualname__’: ‘Spam’, ‘__init__’: }
…init class object: [‘meth’, ‘data’, ‘__new__’, ‘__doc__’, ‘__module__’, ‘__init__’]
making instance
data: 1

调用顺序是：
1. 调用元类的__call__。只调用一次。
2. 调用元类的__new__。创建一个type实例，只调用一次。
3. 调用元类的__init__。初始化type实例，只调用一次。
4. 调用自定义类的__new__。调用多次，每创建一个自定义实例，调用一次。
5. 调用自定义类的__init__。调用多次，每创建一个自定义实例，调用一次。

实例与继承的关系

• 元类继承自type类。
• 元类声明由子类继承。在用户定义的类中,metaclass=M声明由该类的子类继承，因此，对于在超类链中继承了这一声明的每个类的构建，该元类都将运行。
• 元类属性没有由类实例继承。元类声明指定了一个实例关系，它和继承不同。由于类是元类的实例，所以元类中定义的行为应用于类，而不是类随后的实例。实例从它们的类和超类获取行为，但是，不是从任何元类获取行为。从技术上讲，实例属性查找通过只是搜索实例及期所有类的__dict__字典；元类不包含在实例查找中。

元类与类装饰器在功能上有重合。

• 在class语句末尾，类装饰器把类名重新绑定到一个函数的结果。
• 元类通过在一条class语句的末尾把类对象创建过程路由到一个对象来工作。

学习元类可参考Enum源码

1. _EnumDict通过继承dict,并重写__setitem__,来实现枚举的name不重复。
2. 通过重写元类EnumMeta的__delattr__和__setattr__来限制删除和修改枚举成员。

python之logging模块

• python之logging模块
• 介绍
• logging.basicConfig(**kwargs)
• logging.handlers
  • 将日志同时输同到文件和屏幕
  • 自动切割日志
• 通过文件配置日志

介绍

logging模块是用来做日志记录的。
logging.config用来配置。
logging.handlers用来处理日志，可以是屏幕输出，可以是写文件（文件又可以自动切割文件），可以是发邮件。

最简单的用法是：

import logging

logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
 
屏幕上打印:
WARNING:root:This is warning message

logging.basicConfig(**kwargs)

以默认格式创建一个StreamHandler，然后把它加到root logger，函数参数可以做些配置。
如果root logger没有定义handlers，则当函数debug(),info(), warning(), error() and critical()调用时会自动调用basicConfig()。

如果root logger已经定义好了handlers,则这个函数什么也不干。

import logging

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename='myapp.log',
                filemode='w')
    
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
 
./myapp.log文件中内容为:
Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message
Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message
Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

logging.basicConfig函数各参数:
filename: 指定日志文件名
filemode: 和file函数意义相同，指定日志文件的打开模式，’w’或’a’
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
%(levelno)s: 打印日志级别的数值
%(levelname)s: 打印日志级别名称
%(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
%(filename)s: 打印当前执行程序名
%(funcName)s: 打印日志的当前函数
%(lineno)d: 打印日志的当前行号
%(asctime)s: 打印日志的时间
%(thread)d: 打印线程ID
%(threadName)s: 打印线程名称
%(process)d: 打印进程ID
%(message)s: 打印日志信息
datefmt: 指定时间格式，同time.strftime()
level: 设置日志级别，默认为logging.WARNING
stream: 指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略

logging.handlers

handlers控制日志的落地。有下面这些方式。

logging.StreamHandler: 日志输出到流，可以是sys.stderr、sys.stdout或者文件
logging.FileHandler: 日志输出到文件
日志回滚方式，实际使用时用RotatingFileHandler和TimedRotatingFileHandler
logging.handlers.BaseRotatingHandler
logging.handlers.RotatingFileHandler
logging.handlers.TimedRotatingFileHandler
logging.handlers.SocketHandler: 远程输出日志到TCP/IP sockets
logging.handlers.DatagramHandler: 远程输出日志到UDP sockets
logging.handlers.SMTPHandler: 远程输出日志到邮件地址
logging.handlers.SysLogHandler: 日志输出到syslog
logging.handlers.NTEventLogHandler: 远程输出日志到Windows NT/2000/XP的事件日志
logging.handlers.MemoryHandler: 日志输出到内存中的制定buffer
logging.handlers.HTTPHandler: 通过”GET”或”POST”远程输出到HTTP服务器

将日志同时输同到文件和屏幕

import logging

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename='myapp.log',
                filemode='w')

#################################################################################################
#定义一个StreamHandler，将INFO级别或更高的日志信息打印到标准错误，并将其添加到当前的日志处理对象#
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
#################################################################################################

logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
 
屏幕上打印:
root        : INFO     This is info message
root        : WARNING  This is warning message
./myapp.log文件中内容为:
Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message
Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message
Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

自动切割日志

import logging
from logging.handlers import RotatingFileHandler

#################################################################################################
#定义一个RotatingFileHandler，最多备份5个日志文件，每个日志文件最大10M
Rthandler = RotatingFileHandler('myapp.log', maxBytes=10*1024*1024,backupCount=5)
Rthandler.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
Rthandler.setFormatter(formatter)
logging.getLogger('').addHandler(Rthandler)
#######################################################################################

这个用的比较多。留下日志,1是可以跟踪性能信息，也可以跟踪出错信息。

通过文件配置日志

配置文件

#logger.conf
###############################################
[loggers]
keys=root,test01,test02
[logger_root]
level=DEBUG
handlers=hand01,hand02
[logger_test01]
handlers=hand01,hand02
qualname=test01
propagate=0
[logger_test02]
handlers=hand01,hand03
qualname=test02
propagate=0
###############################################
[handlers]
keys=hand01,hand02,hand03
[handler_hand01]
class=StreamHandler
level=INFO
formatter=form02
args=(sys.stderr,)
[handler_hand02]
class=FileHandler
level=DEBUG
formatter=form01
args=('myapp.log', 'a')
[handler_hand03]
class=handlers.RotatingFileHandler
level=INFO
formatter=form02
args=('myapp.log', 'a', 10*1024*1024, 5)
###############################################
[formatters]
keys=form01,form02
[formatter_form01]
format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s
datefmt=%a, %d %b %Y %H:%M:%S
[formatter_form02]
format=%(name)-12s: %(levelname)-8s %(message)s
datefmt=

代码使用配置文件

import logging
import logging.config

logging.config.fileConfig("logger.conf")
logger = logging.getLogger("test01")

logger.debug('This is debug message')
logger.info('This is info message')
logger.warning('This is warning message')