#数据库
dbpath=F:\mongodb\data
directoryperdb = true


#日志
logpath=F:\mongodb\logs\mongod.log
#错误日志采用追加模式
logappend=true
#启用日志模式，默认启用
journal=true 
#这个选项可以过滤掉一些无用的日志信息，若需要调试使用，请设置为false
quiet=true 
#cpu=true
#verbose = true

# 认证
#autho =false

# 管理
#reset = true

# 主节点配置
master = true

# 子节点配置
#slave = true
#source = 192.168.3.56
#only = xxx

#端口号 默认27017
port=27017

mongod -f f:\mongodb\config.ini --install --serviceName "mongodb"

mongod --remove

net start mongodb

del f:\mongodb\data\mongod.lock
mongod.exe --dbpath=f:\mongodb\data --logpath=f:\mongodb\logs\db.log

user 'dbname`

def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return '<h1>Hello, web!</h1>'

# server.py
# 从wsgiref模块导入:
from wsgiref.simple_server import make_server
# 导入我们自己编写的application函数:
from hello import application

# 创建一个服务器，IP地址为空，端口是8000，处理函数是application:
httpd = make_server('', 8000, application)
print "Serving HTTP on port 8000..."
# 开始监听HTTP请求:
httpd.serve_forever()

import time

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'

def produce(c):
    c.next()
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

if __name__=='__main__':
    c = consumer()
    produce(c)

from collections import nametuple

Point = nametuple('Point',['x','y'])
p = Point(1,2)
pring p.x,p.y

from collections import deque
q = deque(['a','b','c'])
a.append('xx)

>>> import base64
>>> base64.b64encode('binary\x00string')
'YmluYXJ5AHN0cmluZw=='
>>> base64.b64decode('YmluYXJ5AHN0cmluZw==')
'binary\x00string'

import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?')
print md5.hexdigest()

import hashlib

sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()

'00\d'可以匹配'007'，但无法匹配'00A'；

'\d\d\d'可以匹配'010'；

无法识别连续的空格，用正则表达式试试：

try:
    f = open('iotest.txt', 'rb')
    print f.read()
finally:
    if f:
        f.close()

with open('iotest.txt', 'rb') as f:
    print f.read().decode('gbk')

absolute_path = sys.path[0]
#print absolute_path
def search(path,name):
    for x in os.listdir(path):
        fullname = os.path.join(path,x)
        if os.path.isfile(fullname):
            #print '文件：%s' % fullname
            if name in x:
                print '选中：%s' % fullname
        else:
            search(fullname,name)

search(absolute_path,'test')

f = open('dump.txt', 'wb')
pickle.dump(dic, f)
f.close()

f = open('dump.txt', 'rb')
d = pickle.load(f)
f.close()

str_json = json.dumps(dic)
print str_json
print json.loads(str_json)

class Student(object):
    def __init__(self,name,age,score):
        self.name = name
        self.age = age
        self.score = score
    def student2dict(self,object):
        return {'name':self.name,'age':self.age,'score':self.score}

hammer = Student('hammer',27,100)
print json.dumps(hammer,default=hammer.student2dict)

# 1 使用Process来创建进程
def run_proc(name):
    print 'Run child process %s (%s)...' % (name, os.getpid())

if __name__=='__main__':
    print 'Parent process %s.' % os.getpid()
    p = Process(target=run_proc, args=('test',))
    print 'Process will start.'
    p.start()
    p.join()
    print 'Process end.'
####################

#2 学习使用Pool,进程池
def long_time_task(name):
    print '执行 tast %s(%s)...' % (name,os.getpid())
    start = time.time()
    time.sleep(random.random() * 3 )
    end = time.time()
    print 'Task %s run %0.2f seconds.' % (name,end - start)

if __name__ =='__main__':
    print '父进程id %s .' % os.getpid()
    p = Pool()
    for i in range(5):
        p.apply_async(long_time_task,args=(i,))
    print '等待所有子进程执行完毕.'
    p.close() #close之后Pool不能新增子进程了
    p.join() # join方法会等待所有子进程执行完毕
    print 'All done .'
#########################

# 3 学习使用Queue,实现进程间通信
# 写数据进程执行的代码:
def write(q):
    for value in ['A', 'B', 'C']:
        print 'Put %s to queue...' % value
        q.put(value)
        time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
    while True:
        value = q.get(True)
        print 'Get %s from queue.' % value

if __name__=='__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()

# 学习使用多线程，主要是threading
import time,threading
def loop():
    print 'thread %s is running ...' % threading.current_thread().name
    n = 0
    while n < 5:
        n = n+1
        print 'thread %s >>> %s' % (threading.current_thread().name,n)
        time.sleep(1)
    print 'thread %s ended.' % threading.current_thread().name
print 'thread %s is running...' % threading.current_thread().name
t = threading.Thread(target=loop,name = 'ChildThread')
t.start()
t.join()
print 'thread %s ended.' % threading.current_thread().name

if __name__=='__main__':
    test()

python setup.py install

pip install PIL

pip install pillow

from __future__ import unicode_literals
from __future__ import division

#父类
class Animal(object):
    def run(self):
        print "Animal is running"

class Dog(Animal):
    pass
class Cat(Animal):
    pass

dog = Dog()
dog.run()
cat = Cat()
cat.run()

# 给dog对象动态新增方法set_age

def set_age(self,age): #定义一个函数作为实例方法
    self.age = age

dog.set_age = MethodType(set_age,dog,Dog)# 给实例绑定一个方法
dog.set_age(25)
print 'dog的age:%s' % dog.age

def set_price(self,price): #定义一个函数作为实例方法
    self.price = price

Animal.set_price = MethodType(set_price,None,Animal)# 给类绑定一个方法
dog.set_price('200$')
cat.set_price('300$')
print dog.price
print cat.price

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

class Dog(Mammal, RunnableMixin, CarnivorousMixin):
    pass

这样Dog类就继承了Mammal类，RunnableMixin类，CarnivorousMixin类

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__

class Chain(object):
    # class实例化调用
    def __init__(self,path = ''):
        self._pathh = path
    # 调用Chain不存在的属性时
    def __getattr__(self, path):
        return Chain('%s/%s' % (self._pathh,path))
    def __str__(self):
        return self._pathh

print Chain().statu.v2.member.center
结果
/statu/v2/member/center

# -*- coding:utf-8 -*-
# 单元测试
class Dict(dict):

    def __init__(self, **kw):
        super(Dict, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

# -*- coding:utf-8 -*-
# 进行单元测试
import unittest
from mydict import Dict
class TestDict(unittest.TestCase):

    def test_init(self):
        d = Dict(a=1, b='test')
        self.assertEquals(d.a, 1)
        self.assertEquals(d.b, 'test')
        self.assertTrue(isinstance(d, dict))

    def test_key(self):
        d = Dict()
        d['key'] = 'value'
        self.assertEquals(d.key, 'value')

    def test_attr(self):
        d = Dict()
        d.key = 'value'
        self.assertTrue('key' in d)
        self.assertEquals(d['key'], 'value')

    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):
            value = d['empty']

    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty

    def setUp(self):
        print 'setUp...开始测试'

    def tearDown(self):
        print 'tearDown...测试结束'

nameList = （'xiaoming','xiaoli','xiaozhang'）

# -*- coding: utf-8 -*-

a = 'Hi ,%s,you have 钱数:%d' % ('Hammercui',10000)
print a

常见的占位符有：

%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

def my_abs(x):
    if x>0:
        return x
    else:
        return -x

print my_abs(-2000)

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(5)

 L[:10:2]
[0, 2, 4, 6, 8]

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

map(str,[1,2,3,4])
结果：
['1','2','3','4']

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

def is_odd(n):
    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
结果
# 结果: [1, 5, 9, 15]

def f(x)
	return x*x

def int2(x, base=2):
    return int(x, base)

int2('1000000')
结果
64

import functools
int2 = functools.partical(int,base=2)
int2('1000000')
结果
64

 DaoMaster.DevOpenHelper helper = 
new DevOpenHelper(application,"xue_old.db",null);

public static class DevOpenHelper extends OpenHelper {
      public DevOpenHelper(Context context, String name, CursorFactory factory) {
          super(context, name, factory);
      }

      @Override
      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
          Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion + " by dropping all tables");
          dropAllTables(db, true);
          onCreate(db);
      }
  }

//删除当前所有表
dropAllTables(db, true);
//新建当前所有表
onCreate(db);

public class HMROpenHelper extends DaoMaster.OpenHelper {

    public HMROpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
        super(context, name, factory);
    }

    /**
     * 数据库升级
     * @param db
     * @param oldVersion
     * @param newVersion
     */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        //操作数据库的更新
        MigrationHelper.migrate(db,NoteDao.class,LessonDao.class,ZhangDao.class);
    }

}

public class MigrationHelper {

    /**
     * 调用升级方法
     * @param db
     * @param daoClasses 一系列dao.class
     */
    public static void migrate(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        //1 新建临时表
        generateTempTables(db, daoClasses);
        //2 创建新表
        createAllTables(db, false, daoClasses);
        //3 临时表数据写入新表，删除临时表
        restoreData(db, daoClasses);
    }


    /**
     * 生成临时表，存储旧的表数据
     * @param db
     * @param daoClasses
     */
    private static void generateTempTables(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        //方法2
        for (int i=0;i<daoClasses.length;i++){
            DaoConfig daoConfig = new DaoConfig(db,daoClasses[i]);
            String tableName = daoConfig.tablename;
            if (!checkTable(db,tableName))
                continue;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            StringBuilder insertTableStringBuilder = new StringBuilder();
            insertTableStringBuilder.append("alter table ")
                    .append(tableName)
                    .append(" rename to ")
                    .append(tempTableName)
                    .append(";");
            db.execSQL(insertTableStringBuilder.toString());
        }
    }

    /**
     * 检测table是否存在
     * @param db
     * @param tableName
     */
    private static Boolean checkTable(SQLiteDatabase db,String  tableName){
        StringBuilder query = new StringBuilder();
        query.append("SELECT count(*) FROM sqlite_master WHERE type='table' AND name='").append(tableName).append("'");
        Cursor c = db.rawQuery(query.toString(), null);
        if (c.moveToNext()){
            int count = c.getInt(0);
            if(count>0){
               return true;
            }
            return false;
        }
        return false;
    }

    /**
     * 删除所有旧表
     * @param db
     * @param ifExists
     * @param daoClasses
     */
    private static void dropAllTables(SQLiteDatabase db, boolean ifExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "dropTable", ifExists, daoClasses);
    }

    /**
     * 创建新的表结构
     * @param db
     * @param ifNotExists
     * @param daoClasses
     */
    private static void createAllTables(SQLiteDatabase db, boolean ifNotExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "createTable", ifNotExists, daoClasses);
    }

    /**
     * 创建根删除都在NoteDao声明了，可以直接拿过来用
     * dao class already define the sql exec method, so just invoke it
     */
    private static void reflectMethod(SQLiteDatabase db, String methodName, boolean isExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        if (daoClasses.length < 1) {
            return;
        }
        try {
            for (Class cls : daoClasses) {
                //根据方法名，找到声明的方法
                Method method = cls.getDeclaredMethod(methodName, SQLiteDatabase.class, boolean.class);
                method.invoke(null, db, isExists);
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 临时表的数据写入新表
     * @param db
     * @param daoClasses
     */
    private static void restoreData(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for (int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            if (!checkTable(db,tempTableName))
                continue;
            // get all columns from tempTable, take careful to use the columns list
            List<String> columns = getColumns(db, tempTableName);
            //新表，临时表都包含的字段
            ArrayList<String> properties = new ArrayList<>(columns.size());
            for (int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;
                if (columns.contains(columnName)) {
                    properties.add(columnName);
                }
            }
            if (properties.size() > 0) {
                final String columnSQL = TextUtils.join(",", properties);

                StringBuilder insertTableStringBuilder = new StringBuilder();
                insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
                insertTableStringBuilder.append(columnSQL);
                insertTableStringBuilder.append(") SELECT ");
                insertTableStringBuilder.append(columnSQL);
                insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");
                db.execSQL(insertTableStringBuilder.toString());
            }
            StringBuilder dropTableStringBuilder = new StringBuilder();
            dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
            db.execSQL(dropTableStringBuilder.toString());
        }
    }

    private static List<String> getColumns(SQLiteDatabase db, String tableName) {
        List<String> columns = null;
        Cursor cursor = null;
        try {
            cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 0", null);
            if (null != cursor && cursor.getColumnCount() > 0) {
                columns = Arrays.asList(cursor.getColumnNames());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null)
                cursor.close();
            if (null == columns)
                columns = new ArrayList<>();
        }
        return columns;
    }
}

HMROpenHelper helper = new HMROpenHelper(application, "xue_old.db", null);
       SQLiteDatabase sqlDB = helper.getWritableDatabase();
       return  sqlDB;

buildscript {
  repositories {
    mavenCentral()
   }
  dependencies {
    classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
  }
}

apply plugin: 'android-apt`

android{
...
}

dependencies{
 compile 'com.jakewharton:butterknife:8.2.1'
 apt 'com.jakewharton:butterknife-compiler:8.2.1'
}

class ExampleActivity extends Activity {
  @BindView(R.id.title) TextView title;
  @BindView(R.id.subtitle) TextView subtitle;
  @BindView(R.id.footer) TextView footer;

  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.simple_activity);
    ButterKnife.bind(this);
    // TODO Use fields...
  }
}

class ExampleActivity extends Activity {
  @BindString(R.string.title) String title;
  @BindDrawable(R.drawable.graphic) Drawable graphic;
  @BindColor(R.color.red) int red; // int or ColorStateList field
  @BindDimen(R.dimen.spacer) Float spacer; // int (for pixel size) or float (for exact value) field
  // ...
}

public class FancyFragment extends Fragment {
  @BindView(R.id.button1) Button button1;
  @BindView(R.id.button2) Button button2;

  @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fancy_fragment, container, false);
    ButterKnife.bind(this, view);
    // TODO Use fields...
    return view;
  }
}

@BindViews({ R.id.first_name, R.id.middle_name, R.id.last_name })
List<EditText> nameViews;

ButterKnife.apply(nameViews, DISABLE);
ButterKnife.apply(nameViews, ENABLED, false);

ButterKnife.apply(nameViews, View.ALPHA, 0.0f);

@OnClick(R.id.submit)
public void submit(View view) {
  // TODO submit data to server...
}

public class FancyFragment extends Fragment {
  @BindView(R.id.button1) Button button1;
  @BindView(R.id.button2) Button button2;
  private Unbinder unbinder;

  @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fancy_fragment, container, false);
    unbinder = ButterKnife.bind(this, view);
    // TODO Use fields...
    return view;
  }

  @Override public void onDestroyView() {
    super.onDestroyView();
    unbinder.unbind();
  }
}

buildscript {
    repositories {
      mavenCentral()
    }
    dependencies {
       	 ···
        // replace with the current version of the android-apt plugin
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}

repositories {
    mavenCentral()
    mavenLocal()
}

apply plugin: 'android-apt'
def AAVersion = 'XXX'

dependencies {
	...
    apt "org.androidannotations:androidannotations:$AAVersion"
    compile "org.androidannotations:androidannotations-api:$AAVersion"
	...
}

apt {
    arguments {
        androidManifestFile variant.outputs[0]?.processResources?.manifestFile
        // if you have multiple outputs (when using splits), you may want to have other index than 0

        // you should set your package name here if you are using different application IDs
        // resourcePackageName "your.package.name"

        // You can set optional annotation processing options here, like these commented options:
        // logLevel 'INFO'
        // logFile '/var/log/aa.log'
    }
}