向pandas.DataFrame对象添加行的简单任务似乎很难实现.有3个与此相关的stackoverflow问题,其中没有一个给出了有效的答案.

这就是我想要做的.我有一个DataFrame,我已经知道了形状以及行和列的名称.

>>> df = pandas.DataFrame(columns=['a','b','c','d'], index=['x','y','z'])
>>> df
     a    b    c    d
x  NaN  NaN  NaN  NaN
y  NaN  NaN  NaN  NaN
z  NaN  NaN  NaN  NaN

现在,我有一个迭代计算行值的函数.如何用字典或pandas.Series？填写其中一行？以下是失败的各种尝试:

>>> y = {'a':1, 'b':5, 'c':2, 'd':3} 
>>> df['y'] = y
AssertionError: Length of values does not match length of index

显然它试图添加一列而不是一行.

>>> y = {'a':1, 'b':5, 'c':2, 'd':3} 
>>> df.join(y)
AttributeError: 'builtin_function_or_method' object has no attribute 'is_unique'

非常无法提供的错误消息.

>>> y = {'a':1, 'b':5, 'c':2, 'd':3} 
>>> …

介绍

我在编程工作中遇到了一个有趣的案例,要求我在python中实现动态类继承机制.我在使用术语"动态继承"时的意思是一个特别是不从任何基类继承的类,而是选择在实例化时从几个基类之一继承,具体取决于某些参数.

因此,我的问题如下:在我将介绍的情况下,通过动态继承实现所需额外功能的最佳,最标准和"pythonic"方式是什么.

为了以简单的方式总结这个案例,我将举例说明使用两个代表两种不同图像格式的类:'jpg'和'png'图像.然后我将尝试添加支持第三种格式的功能:'gz'图像.我意识到我的问题并不那么简单,但我希望你已经准备好与我一起承担更多的问题了.

两个图像的例子情况

此脚本包含两个类:ImageJPG和ImagePNG,都继Image承自基类.要创建图像对象的实例,系统会要求用户image_factory使用文件路径作为唯一参数来调用该函数.

然后,此函数从路径中猜出文件格式(jpg或png),并返回相应类的实例.

两个具体的图像类(ImageJPG和ImagePNG)都能够通过其data属性解码文件.两者都以不同的方式做到这一点.但是,Image为了执行此操作,都要求基类提供文件对象.

import os

#------------------------------------------------------------------------------#
def image_factory(path):
    '''Guesses the file format from the file extension
       and returns a corresponding image instance.'''
    format = os.path.splitext(path)[1][1:]
    if format == 'jpg': return ImageJPG(path)
    if format == 'png': return ImagePNG(path)
    else: raise Exception('The format "' + format + '" is not supported.') …

我在python中遇到一个奇怪的错误,其中使用__new__类的方法作为工厂将导致__init__实例化类的方法被调用两次.

这个想法最初是使用__new__母类的方法根据传递的参数返回她的一个孩子的特定实例,而不必在类之外声明工厂函数.

我知道使用工厂功能将是这里使用的最佳设计模式,但是在项目的这一点上改变设计模式将是昂贵的.因此我的问题是:有没有办法避免双重调用__init__并__init__在这种模式中只获得一次调用？

class Shape(object):
    def __new__(cls, desc):
        if cls is Shape:
            if desc == 'big':   return Rectangle(desc)
            if desc == 'small': return Triangle(desc)
        else:
            return super(Shape, cls).__new__(cls, desc)

    def __init__(self, desc):
        print "init called"
        self.desc = desc

class Triangle(Shape):
    @property
    def number_of_edges(self): return 3

class Rectangle(Shape):
    @property
    def number_of_edges(self): return 4

instance = Shape('small')
print instance.number_of_edges

>>> init called
>>> init called
>>> 3

任何帮助非常感谢.

我有一个pandas.DataFrame我想导出到CSV文件.但是,熊猫似乎写了一些值float而不是int类型.我无法找到如何改变这种行为.

构建数据框:

df = pandas.DataFrame(columns=['a','b','c','d'], index=['x','y','z'], dtype=int)
x = pandas.Series([10,10,10], index=['a','b','d'], dtype=int)
y = pandas.Series([1,5,2,3], index=['a','b','c','d'], dtype=int)
z = pandas.Series([1,2,3,4], index=['a','b','c','d'], dtype=int)
df.loc['x']=x; df.loc['y']=y; df.loc['z']=z

查看它:

>>> df
    a   b    c   d
x  10  10  NaN  10
y   1   5    2   3
z   1   2    3   4

出口它:

>>> df.to_csv('test.csv', sep='\t', na_rep='0', dtype=int)
>>> for l in open('test.csv'): print l.strip('\n')
        a       b       c       d
x       10.0    10.0    0       10.0
y       1       5       2       3 …

问题

我关注的是:我在一个经典的python列表中存储了一个相对论大数据集,为了处理数据,我必须多次遍历列表,对元素执行一些操作,并经常从列表中弹出一个项目.

似乎从Python列表中删除一个项目需要花费O(N),因为Python必须将手头元素上方的所有项目复制到一个位置.此外,由于要删除的项目的数量与列表中的元素的数量近似成比例,因此这导致O(N ^ 2)算法.

我希望找到一个具有成本效益的解决方案(时间和内存方面).我已经研究了我在互联网上可以找到的内容,并在下面总结了我的不同选项.哪一个是最佳人选？

保留本地索引:

while processingdata:
    index = 0
    while index < len(somelist):
        item = somelist[index]
        dosomestuff(item)
        if somecondition(item):
            del somelist[index]
        else:
            index += 1

这是我提出的原始解决方案.这不仅非常优雅,而且我希望有更好的方法来保持时间和记忆效率.

向后走的列表:

while processingdata:
    for i in xrange(len(somelist) - 1, -1, -1):
        dosomestuff(item)
        if somecondition(somelist, i):
            somelist.pop(i)

这样可以避免增加索引变量,但最终成本与原始版本相同.它还打破了dosomestuff(item)的逻辑,它希望以与它们在原始列表中出现的顺序相同的顺序处理它们.

制作新名单:

while processingdata:
    for i, item in enumerate(somelist):
        dosomestuff(item)
    newlist = []
    for item in somelist:
        if somecondition(item):
            newlist.append(item)
    somelist = newlist
    gc.collect()

这是一种非常天真的策略,用于从列表中删除元素并且需要大量内存,因为必须完成列表的几乎完整副本.

使用列表推导:

while processingdata:
    for i, item in enumerate(somelist):
        dosomestuff(item)
    somelist[:] …

我一直在寻找一个简单的python线程池模式的良好实现,真的找不到任何适合我的需求.我正在使用python 2.7,我发现的所有模块都不起作用,或者没有正确处理工作程序中的异常.我想知道是否有人知道可以提供我正在搜索的功能类型的库.非常感谢.

多

我的第一次尝试是使用内置multiprocessing模块,但由于这不使用线程而是使用子进程,而是遇到了无法对对象进行pickle的问题.不要去这里

from multiprocessing import Pool

class Sample(object):
    def compute_fib(self, n):
        phi = (1 + 5**0.5) / 2
        self.fib = int(round((phi**n - (1-phi)**n) / 5**0.5))

samples = [Sample() for i in range(8)]
pool = Pool(processes=8)
for s in samples: pool.apply_async(s.compute_fib, [20])
pool.join()
for s in samples: print s.fib

# PicklingError: Can't pickle <type 'instancemethod'>: attribute lookup __builtin__.instancemethod failed

期货

所以,我看到有一些的蟒蛇3.2凉爽的并发功能回到端口这里.这似乎完美且易于使用.问题是,当你在一个工人一个例外,你只能得到异常的类型,比如"ZeroDivisionError",但没有回溯,因此没有迹象表明其中线导致异常.代码变得无法调试.不行.

from concurrent import futures

class Sample(object):
    def compute_fib(self, n):
        phi = (1 + 5**0.5) …

我一直在阅读描述类继承,抽象基类甚至python接口的文档.但没有什么能成为我想要的东西.即,构建虚拟类的简单方法.当调用虚拟类时,我希望它根据给出的参数实例化一些更具体的类,并将其交给调用函数.现在我有一种将虚拟类的调用重新路由到底层类的简要方法.

这个想法如下:

class Shape:
    def __init__(self, description):
        if   description == "It's flat":  self.underlying_class = Line(description)
        elif description == "It's spiky": self.underlying_class = Triangle(description)
        elif description == "It's big":   self.underlying_class = Rectangle(description)
    def number_of_edges(self, parameters):
        return self.underlying_class(parameters)

class Line:
    def __init__(self, description):
        self.desc = description
    def number_of_edges(self, parameters):
        return 1

class Triangle:
    def __init__(self, description):
        self.desc = description
    def number_of_edges(self, parameters):
        return 3

class Rectangle:
    def __init__(self, description):
        self.desc = description
    def number_of_edges(self, parameters):
        return 4

shape_dont_know_what_it_is = Shape("It's big")
shape_dont_know_what_it_is.number_of_edges(parameters) …

在过去的六个月里,我一直在用python开发一个项目,并且喜欢这门语言.但我还没有找到可以为我提供一些额外功能的IDE或文本编辑器.我目前有语法高亮,这是最简单的事情之一,但不多.我梦想让我的IDE跳转到我的代码中导致崩溃的行而不是从回溯中读取行号并在我的文本编辑器中手动定位它.我一直在寻找能够在我的开发限制下做到这一点的事情,但没有成功.我的约束如下:

• 正在开发的python代码位于远程计算机上,配备有足够的RAM和CPU来运行代码.那台机器没有屏幕或键盘.
• 我从我的笔记本电脑编写代码,这是一个运行OS X的macbook pro,它不是为了执行代码.
• 远程计算机正在运行Fedora 12,并提供具有root访问权限的SSH连接.
• 我在家里的连接不够好,无法在远程机器上运行X11 IDE并在我的机器上显示界面.

我一直在做的是使用优秀的Cyber​​Duck客户端通过SSH登录远程机器.这使我能够在我的任何本地常用文本编辑器(如TextMate或TextWrangler)内打开驻留在远程计算机上的文本文件,并在每次保存文件时自动上载更改.这真的让你感觉到你正在编辑你常用的cocoa界面中的远程文件.

然后执行python代码,我打开第二个SSH连接,这次使用我要输入的终端:

$ ssh user@dns
$ ipython -pylab
$ execfile("/projectdir/code.py")

最后,我阅读了回溯并返回我的本地文本编辑器以找到正确的行号.肯定有更好的办法 !有任何想法吗 ？

我的问题很简单:我有一个很长的元素列表,我想迭代并根据条件检查每个元素.根据条件的结果,我想删除列表的当前元素,并像往常一样继续迭代它.

我已经在这个问题上阅读了其他几个主题.提出两种解决方案.要么从列表中创建一个字典(这意味着要复制已经填满我所有RAM的所有数据).要么反向走列表(这打破了我想要实现的算法的概念).

有没有更好或更优雅的方式呢？

def walk_list(list_of_g):
    g_index = 0
    while g_index < len(list_of_g):
        g_current = list_of_g[g_index]
        if subtle_condition(g_current):
            list_of_g.pop(g_index)
        else:
            g_index = g_index + 1

我已经阅读了几个小时的文档,关于在objective-c cocoa应用程序中绘制二维图形.似乎有几种不同的技术都特定于某些任务.我的理解是以下技术可以做到以下几点.如果我错了,请纠正我.

• Quartz 2D:用于将形状,文本和图像绘制到屏幕的主库.
• 核心图形:这是包含Quartz的框架的名称.这可以用作Quartz的同义词.
• QuartzGL:Quartz的GPU加速模式,默认情况下不启用,不一定能更快地在屏幕上绘制内容.
• OpenGL:最低级别的库,以更多代码行为代价直接与显卡对话.更适合3D图形.
• 核心图像:用于显示图像和文本的库,但不是用于绘制形状基元的库.
• 核心动画:用于自动动画对象的库.显然不适合移动大量物体.也不是连续动画的对象.
• QuickTime:除了视频之外还显示图像和文本的库,但可能不适合绘制原始形状.

我想要做的是为某些特定类型的数据创建一个浏览器.视图不会非常复杂,包括在特定位置绘制矩形.但是,用户应该能够通过向左或向右拖动视图来移动,并且此移动应该是流动的.这是一个非常接近我想要做的例子:

http://jbrowse.org/ucsc/hg19/

你会推荐什么样的绘图技术我开始编码？

我正在使用R软件进行统计分析,很遗憾它没有保留和恢复我的提示命令历史记录.实际上,按下新启动的交互式R会话上的向上箭头,每次都会显示空白历史记录.如果能以这样的方式做到这一点会很好,比方说,类似于ipython.我试着把它放在我的.Rprofile文件中无济于事.不会创建包含我的命令历史记录的文件.

.First <- function(){
        if (!any(commandArgs()=='--no-readline') && interactive()){
                require(utils)
                try(loadhistory(Sys.getenv("R_HISTFILE")))
        }
}

.Last <- function() {
        if (!any(commandArgs()=='--no-readline') && interactive()){
                require(utils)
                try(savehistory(Sys.getenv("R_HISTFILE")))
        }
}

当然这条线存在于我的 .bash_profile

export R_HISTFILE="$HOME/share/r_libs/.history"

所有这些都是在运行Linux的远程服务器上通过SSH进行的.任何帮助非常感谢!

我使用 Seaborn 生成多种类型的图表，但这里仅使用一个简单的示例来基于所包含的数据集进行说明：

import seaborn
tips = seaborn.load_dataset("tips")
axes = seaborn.scatterplot(x="day", y="tip", size="sex", hue="time", data=tips)

在此结果中，单个图例框包含两个标题“时间”和“性别”，每个标题都有子元素。

我如何轻松地将图例分成两个框，每个框都有一个标题？即，一个用于指示颜色代码的图例框（可以放置在左侧），一个用于指示尺寸代码的图例框（可以放置在右侧）。