Question

以下查询提取ca. 100＆＃000; 000数据点到python。将使用matplotlib绘制数据。

cur.execute("""SELECT  \
        loggingdb_ips_integer.ipsvalue,
        loggingdb_ips_integer.ipstimestamp,
        loggingdb_ips_integer.varid 
        FROM public.loggingdb_ips_integer
        WHERE
        (loggingdb_ips_integer.varid = 17884) OR
        (loggingdb_ips_integer.varid = 55437) OR
        (loggingdb_ips_integer.varid = 34637) OR
        (loggingdb_ips_integer.varid = 17333)
        ; """)

分别对每个WHERE子句运行4个查询是否更有效，或者我应该立即拉入整个enchilada，并将其转换为3轴的numpy数组？如果后者更有效，那么转换（规范化？）数组的最佳方法是什么？因为我的天真，请不要跳我 - 我是一名医生，经过培训;我对编码的理解非常有限！

Answer 1

Python和数据库之间的通信相对较慢。所以通常你想减少查询的数量。在数据库中尽可能多地使用数据库，并仅提取所需的数据。

这些一般的经验法则让我猜测使用1个查询会比4个查询更好。但是，100K行并不是很多，所以使用哪种方法并不重要。除非你将要运行这个代码数百万次，并且需要每隔纳秒削减一次，否则你会轻而易举地浪费时间，而不是只选择一个时间。如果你真的需要那种性能，那么你应该重新思考Python是否是这项工作的正确语言。俗话说，preoptimization is the root of all evil。

但是，由于这很可能不是代码的主要瓶颈，我会根据最容易阅读和维护的代码选择使用哪种方法，而不一定是最快的代码。

如果完全每个varid的行数相同然后你可以使用NumPy重塑技巧将数据哄骗到3个轴，第一个轴对应varids（见下文）。在这种情况下，进行一次查询可能是最简单的也是最快的。

如果行数不完全相同，那么代码会变得复杂一些。您需要一个Python循环和一个布尔NumPy掩码来选择正确的行。在这种情况下，可能更容易做出四个单独的查询。

现在，出于好奇，我决定测试我的声明，即1个查询比4更快。也许你会在这里找到一些你可以重复使用的代码。

import oursql
import config
import numpy as np

def create_random_data():
    connection = oursql.connect(
        host=config.HOST, user=config.USER, passwd=config.PASS,
        db='test')
    with connection.cursor() as cursor:
        sql = 'DROP TABLE IF EXISTS `mytable`'
        cursor.execute(sql)
        sql = '''CREATE TABLE `mytable` (
            `id` INT(11) NOT NULL AUTO_INCREMENT,
            `ipsvalue` INT(11) DEFAULT NULL,
            `ipstimestamp` INT(11) DEFAULT NULL,
            `varid` INT(11) DEFAULT NULL,        
            PRIMARY KEY (`id`)
            ) ENGINE=MyISAM DEFAULT CHARSET=latin1'''
        cursor.execute(sql)
        sql = '''
            INSERT INTO mytable (ipsvalue, ipstimestamp, varid)
            VALUES (?, ?, ?)'''
        N = 10**5
        args = np.empty((N, 3))
        args[:, :-1] = np.random.randint(100, size=(N, 2))
        args[:, -1] = np.tile(np.array([17884, 55437, 34637, 17333]), N//4)
        cursor.executemany(sql, args)

def one_query():
    connection = oursql.connect(
        host=config.HOST, user=config.USER, passwd=config.PASS,
        db='test')
    with connection.cursor() as cursor:
        varids = sorted((17884, 55437, 34637, 17333))
        sql = '''SELECT varid, ipsvalue, ipstimestamp FROM mytable
                 WHERE varid IN {}
                 ORDER BY varid, ipstimestamp, ipsvalue'''.format(tuple(varids))
        cursor.execute(sql)
        data = np.array(cursor.fetchall())
        data = data.reshape(4, -1, 3)
        arr = dict()
        for i, varid in enumerate(varids): 
            arr[varid] = data[i]
        return arr

def four_queries():
    connection = oursql.connect(
        host=config.HOST, user=config.USER, passwd=config.PASS,
        db='test')
    with connection.cursor() as cursor:
        arr = dict()
        varids = (17884, 55437, 34637, 17333)
        for varid in varids:
            sql = '''SELECT varid, ipsvalue, ipstimestamp FROM mytable
                     WHERE varid = ?
                     ORDER BY ipstimestamp, ipsvalue'''
            cursor.execute(sql, [varid])
            arr[varid] = np.array(cursor.fetchall())
        return arr

arr = one_query()
arr2 = four_queries()
assert all([np.all(arr[key]==arr2[key]) for key in arr])

one_query和four_queries都返回一个密钥为varid值的字典。正如您所看到的，性能并没有那么不同，尽管使用一个查询比四个快一点：

In [219]: %timeit four_queries()
1 loops, best of 3: 238 ms per loop

In [221]: %timeit one_query()
1 loops, best of 3: 195 ms per loop

Answer 2

只运行一次查询肯定会更快。至于正常化＆＃39;数据（我认为你的意思是http://en.wikipedia.org/wiki/Feature_scaling）

Scikit的功能scale适用于numpy（但你必须自己分组）

你也可以在postgresql中使用：

  select
     col
     ,avg(col)
     ,stddev(col)
   from thetable
     group by col

然后使用z-score公式通过加入表来缩放个人：

 select
   (col - avg) / stddev as zscore
 from thetable as t
   join ( 
     paste the query above here
   ) as aggr on aggr.col=t.col

- col将是 varid 。在你去哪里的表现可能并不重要。它的声音更像你，你的问题是如何分组和缩放数据以及最简单的方法。

来自postgres的非规范化numpy数组

2 个答案: