小编mir*_*ulo的帖子

我正在从Windows任务栏运行命令行Python脚本,方法是使用实​​际脚本作为参数指向Python解释器的快捷方式.

处理完脚本后,解释器终止,输出窗口关闭,无法读取脚本输出.

在按下任何键之前,保持解释器窗口打开的最简单方法是什么？

在批处理文件中,可以暂停结束脚本.我在python中发现的最接近的是raw_input()它是次优的,因为它需要按下返回键(而不是任何键).

有任何想法吗？

如何重复列表的每个元素n次数并形成新列表？例如:

x=[1,2,3,4]
n=3

x1=[1,1,1,2,2,2,3,3,3,4,4,4]

x*n 不起作用

for i in x[i]
    x1=n*x[i]

必须有一个简单而聪明的方式.

我不明白变量行后的逗号是什么,意思是:http://matplotlib.org/examples/animation/simple_anim.html

line, = ax.plot(x, np.sin(x))

如果我删除逗号和变量"line",变为变量"line",则程序被破坏.上面给出的url的完整代码:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig = plt.figure()
ax = fig.add_subplot(111)

x = np.arange(0, 2*np.pi, 0.01)        # x-array
line, = ax.plot(x, np.sin(x))

def animate(i):
    line.set_ydata(np.sin(x+i/10.0))  # update the data
    return line,

#Init only required for blitting to give a clean slate.
def init():
    line.set_ydata(np.ma.array(x, mask=True))
    return line,

ani = animation.FuncAnimation(fig, animate, np.arange(1, 200), init_func=init,
    interval=25, blit=True)
plt.show()

根据http://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences逗号后变量似乎与仅包含一个项目的元组有关.

我正在寻找一种方法来转换像这样的元组列表:

[(1,4),(2,4),(3,4),(4,15),(5,15),(6,23),(7,23),(8,23),(9,15),(10,23),(11,15),(12,15)]

进入这样的字典:

{4:[1,2,3] ,15:[4,5,9,11,12], 23:[6,7,8,10]}

来自每个元组的第二个元素变为字典键,并且与该键相关联的所有第一元组元素都存储在值列表中.

你能告诉我怎么做吗？

好的,我有这个代码:

class SomeClass:
    @classmethod
    def func1(cls,arg1):
        #---Do Something---
    @classmethod
    def func2(cls,arg1):
        #---Do Something---

    # A 'function map' that has function name as its keys and the above function
    # objects as values
    func_map={'func1':func1,'func2':func2}

    @classmethod
    def func3(cls,arg1):
        # following is a dict(created by reading a config file) that
        # contains func names as keys and boolean as values that tells
        # the program whether or not to run that function
        global funcList
        for func in funcList:
            if funcList[func]==True:
                cls.func_map[func](arg1)        #TROUBLING PART!!! …

我知道seaborn.countplot有一个属性order可以设置来确定类别的顺序.但我想要做的是让类别按递减计数的顺序排列.我知道我可以通过手动计算计数(使用groupby原始数据框上的操作等)来实现这一点,但我想知道这个功能是否存在seaborn.countplot.令人惊讶的是,我无法在任何地方找到这个问题的答案.

我正在研究"Python For Data Analysis",我不了解特定的功能.添加两个pandas系列对象将自动对齐索引数据,但如果一个对象不包含该索引,则返回为NaN.例如来自书:

a = Series([35000,71000,16000,5000],index=['Ohio','Texas','Oregon','Utah'])
b = Series([NaN,71000,16000,35000],index=['California', 'Texas', 'Oregon', 'Ohio'])

结果:

    In [63]: a
    Out[63]: Ohio          35000
             Texas         71000
             Oregon        16000
             Utah           5000
    In [64]: b
    Out[64]: California      NaN
             Texas         71000
             Oregon        16000
             Ohio          35000

当我把它们加在一起时,我得到了......

    In [65]: a+b
    Out[65]: California       NaN
             Ohio           70000
             Oregon         32000
             Texas         142000
             Utah             NaN

那么为什么犹他州的价值是NaN而不是500？似乎500 + NaN = 500.是什么赋予了？我错过了什么,请解释一下.

更新:

    In [92]: # fill NaN with zero
             b = b.fillna(0)
             b
    Out[92]: California        0
             Texas         71000
             Oregon        16000
             Ohio          35000

    In …

有没有办法检查两个表达式在数学上是否相等？我期望 tg(x)cos(x) == sin(x)输出True,但它输出False.有没有办法与同情进行这样的比较？另一个例子 (a+b)**2 == a**2 + 2*a*b + b**2令人惊讶地也是输出False.

我发现了一些类似的问题,但没有人提到这个问题.

自从我学习Python以来,我有时看到的初学者示例如下:

sum_sq = [None] * 1_000

我已经买了三本Python书,但没有人提到我在这些例子中看到的内容1_000和100_000意思.

我的问题是:1_000和1000一样吗？如果是这样,为什么他们把它写成1_000？它有一个1000不具备的特殊功能吗？像:

if __name__ == __main__ 

有明智的理由使用下划线,我看不出使用的原因1_000.

我试图基于一些嵌套对象过滤数组.我准备了一些小提琴

输入数组如下所示:

let arrayOfElements = 
    [
        {
           "name": "a",
           "subElements": 
           [
             {"surname": 1},
             {"surname": 2}
           ]
        },
        {
           "name": "b",
           "subElements": 
           [
             {"surname": 3},
             {"surname": 1}
           ]
        },
        {
           "name": "c",
           "subElements": 
           [
             {"surname": 2},
             {"surname": 5}
           ]
        }
    ];

我希望这种情况的输出看起来像这样:

let filteredArray = 
    [
        {
          "name": "a",
          "subElements": 
          [
            {"surname": 1}
          ]
        },
        {
          "name": "b",
          "subElements": 
          [
            {"surname": 1}
          ]
        }
];

我正在使用这个公式来做到这一点:

let filteredArray = arrayOfElements.filter((element) => element.subElements.some((subElement) => subElement.surname === 1));

输出几乎是好的,但它返回带有姓氏的所有对象的对象(更好地检查小提琴:D),而不是将它们切掉.我该如何改进过滤？