from model.db.tb1 import Tb1
query = Tb1.select().where(Tb1.id > 0)
print "select query:", query.sql()[0] % tuple(query.sql()[1])
print "query result:"
for item in query.dicts().execute():
    print item

%matplotlib inline

import numpy as np
import matplotlib.pyplot as plt

plt.figure(figsize=(8,4))

x = np.linspace(0, 10, 1000)
y = np.sin(x)
z = np.cos(x**2)

plt.plot(x,y,label="$sin(x)$",color="red",linewidth=2)
plt.plot(x,z,"b--",label="$cos(x^2)$")

# plt.plot?

plt.xlabel("Time(s)")
plt.ylabel("Volt")
plt.title("PyPlot First Example")
plt.ylim(-1.2,1.2)
plt.legend()

plt.show()

x = np.arange(0, 5, 0.1)
line, = plt.plot(x, x*x) # plot返回一个列表，通过line,获取其第一个元素
# 调用Line2D对象的set_*方法设置属性值
line.set_antialiased(False)

# 同时绘制sin和cos两条曲线，lines是一个有两个Line2D对象的列表
lines = plt.plot(x, np.sin(x), x, np.cos(x))
# 调用setp函数同时配置多个Line2D对象的多个属性值
plt.setp(lines, color="r", linewidth=2.0)

line.get_linewidth()
plt.getp(lines[0], "color") # 返回color属性
plt.getp(lines[1]) # 输出全部属性

for idx, color in enumerate("rgbyck"):
    plt.subplot(320+idx+1, axisbg=color)
plt.show()

plt.subplot(221) # 第一行的左图
plt.subplot(222) # 第一行的右图
plt.subplot(212) # 第二整行
plt.show()

fig = plt.figure()
ax = fig.add_subplot(111)
t = ax.scatter(np.random.rand(20), np.random.rand(20))
fig.show()

#! /usr/bin/python
# -*- coding:utf-8 -*-
"""
@author: abc
@file: xpath_demo.py
@date: 2017-02-04
"""
__author__ = "abc"

import lxml.html

import requests


if __name__ == "__main__":
    url = "http://noogel.xyz"
    res = requests.get(url)
    doc = lxml.html.document_fromstring(res.content)
    title_xpath = ".//header[@id='header']//a[@class='brand']/span[@class='site-title']"
    print doc.xpath(title_xpath)[0].text

def parrent_node(index):
    """父节点"""
    return abs(index / 2)


def left_node(index):
    """左子节点"""
    return 2 * index


def right_node(index):
    """右子节点"""
    return 2 * index + 1


def max_heapify(array, index):
    """维护最大堆"""
    left = left_node(index)
    right = right_node(index)
    if left <= len(array) and array[left - 1] > array[index - 1]:
        largest = left
    else:
        largest = index
    if right <= len(array) and array[right - 1] > array[largest - 1]:
        largest = right
    if largest != index:
        array[index - 1], array[largest - 1] = array[largest - 1], array[index - 1]
        max_heapify(array, largest)


def build_max_heap(array):
    """建最大堆"""
    for index in range(len(array) / 2, 0, -1):
        max_heapify(array, index)

array = [4, 1, 3, 2, 16, 9, 10, 14, 8, 7]
print array
build_max_heap(array)
print array

#! /usr/bin/python
# -*- coding:utf-8 -*-
"""
@author: abc
@file: xyzforest.py
@date: 2017-01-06
"""
__author__ = "abc"

import numpy as np
import pandas as pd
import csv
from sklearn.ensemble import RandomForestClassifier


class Titanic(object):
    """
    Titanic
    """
    def __init__(self):
        """
        __init__
        """
        self.train_path = "/home/abc/Projects/kaggle/Titanic/train.csv"
        self.test_path = "/home/abc/Projects/kaggle/Titanic/test.csv"

    def load_data(self, path):
        """
        加载数据
        :param path:
        :return:
        """
        return pd.read_csv(path, header=0)

    def wash_train_data(self, train_data):
        """
        清洗训练数据
        :param train_data:
        :return:
        """
        # PassengerId,Survived,Pclass,Name,Sex,Age,SibSp,Parch,Ticket,Fare,Cabin,Embarked
        # 性别数值化
        train_data.Sex = train_data.Sex.map({'female': 0, 'male': 1}).astype(int)

        # Embarked 数值化, 补充众数
        if len(train_data.Embarked[train_data.Embarked.isnull()]) > 0:
            train_data.Embarked[train_data.Embarked.isnull()] = train_data.Embarked.dropna().mode().values
        ports_dict = {name: index for index, name in enumerate(set(train_data.Embarked))}
        train_data.Embarked = train_data.Embarked.map(ports_dict).astype(int)

        # 年龄补充平均数
        if len(train_data.Age[train_data.Age.isnull()]) > 0:
            train_data.Age[train_data.Age.isnull()] = train_data.Age.dropna().median()

        # 删除多余字段
        train_data = train_data.drop(self.drop_label(), axis=1)

        self.data_concat(train_data)

        return train_data.values

    def wash_test_data(self, test_data):
        """
        清洗测试数据
        :param test_data:
        :return:
        """
        # PassengerId,Pclass,Name,Sex,Age,SibSp,Parch,Ticket,Fare,Cabin,Embarked
        test_data.Sex = test_data.Sex.map({'female': 0, 'male': 1}).astype(int)

        if len(test_data.Embarked[test_data.Embarked.isnull()]) > 0:
            test_data.Embarked[test_data.Embarked.isnull()] = test_data.Embarked.dropna().mode().values
        ports_dict = {name: index for index, name in enumerate(np.unique(test_data.Embarked))}
        test_data.Embarked = test_data.Embarked.map(ports_dict).astype(int)

        if len(test_data.Age[test_data.Age.isnull()]) > 0:
            test_data.Age[test_data.Age.isnull()] = test_data.Age.dropna().median()

        if len(test_data.Fare[test_data.Fare.isnull()]) > 0:
            median_fare = np.zeros(3)
            for f in range(0, 3):  # loop 0 to 2
                median_fare[f] = test_data[test_data.Pclass == f + 1]['Fare'].dropna().median()
            for f in range(0, 3):  # loop 0 to 2
                test_data.loc[(test_data.Fare.isnull()) & (test_data.Pclass == f + 1), 'Fare'] = median_fare[f]

        test_data = test_data.drop(self.drop_label(), axis=1)

        self.data_concat(test_data)

        return test_data.values

    def drop_label(self):
        """
        drop_label
        :return:
        """
        return ['Name', 'Ticket', 'PassengerId']

    def data_concat(self, raw_data):
        """
        data_concat
        :param raw_data:
        :return:
        """
        # 根据年龄优化
        raw_data.loc[raw_data.Age < 18, "Age"] = 0
        raw_data.loc[raw_data.Age >= 18, "Age"][raw_data.Age < 45] = 1
        raw_data.loc[raw_data.Age >= 45, "Age"] = 2
        # 根据父母孩子数量优化
        raw_data.loc[raw_data.Parch > 0, "Parch"] = 1
        raw_data.loc[raw_data.Cabin.isnull(), "Cabin"] = 1
        raw_data.loc[raw_data.Cabin.notnull(), "Cabin"] = 0

    def rediction_model(self, train_data, label_data, test_data):
        """
        预测模型
        :param train_data:
        :param test_data:
        :return:
        """
        forest = RandomForestClassifier(n_estimators=2000)
        forest = forest.fit(train_data, label_data)
        return forest.predict(test_data).astype(int)

    def save_result(self, path, head, data):
        """
        save_result
        :param path:
        :param head:
        :param data:
        :return:
        """
        with open(path, "wb") as wbf:
            csv_obj = csv.writer(wbf)
            csv_obj.writerow(head)
            for item in data:
                csv_obj.writerow(list(item))

    def run(self):
        """
        运行
        :return:
        """
        # 加载数据
        train_data = self.load_data(self.train_path)
        test_data = self.load_data(self.test_path)
        passenger_id = test_data.PassengerId.values
        # 清洗数据
        train_data = self.wash_train_data(train_data)
        test_data = self.wash_test_data(test_data)
        train_data, label_data = train_data[0::, 1::], [val for val in train_data[0::, 0]]
        head = ["PassengerId", "Survived"]
        data = zip(passenger_id, self.rediction_model(train_data, label_data, test_data))
        self.save_result("xyzforest.csv", head, data)

if __name__ == "__main__":
    tt = Titanic()
    print tt.run()

#! /data/server/python/bin/python
# -*- coding:utf-8 -*-
"""
k-近邻算法
"""
import math
import operator
from collections import Counter


def knn(position, data_set, labels, k):
    """
    k-近邻算法
    :param position: 待分类点
    :param data_set: 数据样本
    :param labels: 标签集合
    :param k: 取值
    :return: 所属标签
    """
    distance_list = []
    for index, item in enumerate(data_set):
        distance_list.append((
            labels[index],
            math.sqrt(reduce(operator.add, [(v - position[i]) ** 2 for i, v in enumerate(item)]))
        ))
    distance_list = sorted(distance_list, key=lambda x: x, reverse=True)
    result = Counter([val[0] for val in distance_list[:k]])
    result_labels = sorted(result.items(), lambda x, y: cmp(x[1], y[1]), reverse=True)
    return result_labels[0][0]


if __name__ == "__main__":
    point = [0.2, 0.3]
    data_set = [[1, 1.1], [1, 1], [0, 0], [0, 0.1]]
    labels = ['A', 'A', 'B', 'B']
    k = 3
    print knn(point, data_set, labels, k)

#! /usr/bin/python
# -*- coding:utf-8 -*-
"""
@author: abc
@file: euclidean_distance.py
@date: 2016-12-09
@desc: 余弦相似度
"""
__author__ = "abc"

import cv2
import numpy as np

w_fg = 20
h_fg = 15
pic_flag = 3


def read_pic(fn):
    """
    read_pic
    :param fn:
    :return:
    """
    fnimg = cv2.imread(fn)
    img = cv2.resize(fnimg, (800, 600), interpolation=cv2.INTER_AREA)
    w = img.shape[1]
    h = img.shape[0]
    w_interval = w / w_fg
    h_interval = h / h_fg

    alltz = []
    alltz.append([])
    alltz.append([])
    alltz.append([])

    for now_h in xrange(0, h, h_interval):
        for now_w in xrange(0, w, w_interval):
            b = img[now_h:now_h + h_interval, now_w:now_w + w_interval, 0]
            g = img[now_h:now_h + h_interval, now_w:now_w + w_interval, 1]
            r = img[now_h:now_h + h_interval, now_w:now_w + w_interval, 2]
            btz = np.mean(b)
            gtz = np.mean(g)
            rtz = np.mean(r)

            alltz[0].append(btz)
            alltz[1].append(gtz)
            alltz[2].append(rtz)

    return alltz


def get_cossimi(x, y):
    """
    get_cossimi
    :param x:
    :param y:
    :return:
    """
    myx = np.array(x)
    myy = np.array(y)
    cos1 = np.sum(myx * myy)
    cos21 = np.sqrt(sum(myx * myx))
    cos22 = np.sqrt(sum(myy * myy))
    return cos1 / float(cos21 * cos22)


if __name__ == "__main__":
    # 提取特征
    train_x = []
    d = []

    for ii in xrange(1, pic_flag + 1):
        smp_x = []
        b_tz = np.array([0, 0, 0])
        g_tz = np.array([0, 0, 0])
        r_tz = np.array([0, 0, 0])
        mytz = np.zeros((3, w_fg * h_fg))
        for jj in xrange(1, 3):
            fn = '/home/abc/Projects/machine_learning/img/base/p' + str(ii) + '-' + str(jj) + '.jpg'
            print fn
            tmptz = read_pic(fn)
            mytz += np.array(tmptz)
        mytz /= 3
        train_x.append(mytz[0].tolist() + mytz[1].tolist() + mytz[2].tolist())

    for index in xrange(1, 5):
        fn = '/home/abc/Projects/machine_learning/img/base/test{}.jpg'.format(index)
        testtz = np.array(read_pic(fn))
        simtz = testtz[0].tolist() + testtz[1].tolist() + testtz[2].tolist()
        maxtz = 0
        nowi = 0

        for i in xrange(pic_flag):
            nowsim = get_cossimi(train_x[i], simtz)
            if nowsim > maxtz:
                maxtz = nowsim
                nowi = i

        print '%s属于第%d类' % (fn, nowi + 1)

def get_euclidean_distance(x, y):
    """
    计算欧氏距离
    :param x:
    :param y:
    :return:
    """
    myx = np.array(x)
    myy = np.array(y)
    return np.sqrt(np.sum((myx - myy) * (myx - myy)))

#! /usr/bin/python
# -*- coding:utf-8 -*-
"""
@author: abc
@file: euclidean_distance.py
@date: 2016-12-09
@desc: 欧氏距离
"""
__author__ = "abc"

import cv2
import numpy as np


def get_euclidean_distance(x, y):
    """
    计算欧氏距离
    :param x:
    :param y:
    :return:
    """
    myx = np.array(x)
    myy = np.array(y)
    return np.sqrt(np.sum((myx - myy) * (myx - myy)))


def handle_img(imgpath):
    """
    handle_img
    :param imgpath:
    :return:
    """
    myimg1 = cv2.imread(imgpath)

    cv2.namedWindow('img1')
    cv2.imshow('img1', myimg1)
    cv2.waitKey()
    cv2.destroyAllWindows()

    w = myimg1.shape[1]
    h = myimg1.shape[0]

    sz1 = w
    sz0 = h

    flag = 16

    myimg2 = np.zeros((sz0, sz1, 3), np.uint8)
    black = np.array([0, 0, 0])
    white = np.array([255, 255, 255])
    centercolor = np.array([125, 125, 125])
    for y in xrange(sz0 - 1):
        for x in xrange(sz1 - 1):
            myhere = myimg1[y, x, :]
            mydown = myimg1[y + 1, x, :]
            myright = myimg1[y, x + 1, :]

            lmyhere = myhere
            lmyright = myright
            lmydown = mydown

            if get_euclidean_distance(lmyhere, lmydown) > flag and get_euclidean_distance(lmyhere, lmyright) > flag:
                myimg2[y, x, :] = black
            elif get_euclidean_distance(lmyhere, lmydown) <= flag and get_euclidean_distance(lmyhere, lmyright) <= flag:
                myimg2[y, x, :] = white
            else:
                myimg2[y, x, :] = centercolor

    cv2.namedWindow('img2')
    cv2.imshow('img2', myimg2)
    cv2.waitKey()
    cv2.destroyAllWindows()


if __name__ == "__main__":
    imgpath = "/home/abc/Projects/machine_learning/img/test4.png"
    handle_img(imgpath)