Братцы-питонщики! В вам обращаюсь я, друзья мои.

Надо попатчить Sphinx-doс. Чтобы тот в сигнатурах методов и функций не раскрывал значения аргументов по умолчанию, а писал их так же, как есть.

Например, есть у меня вот такая сигнатура. Вполне понятная, ко вставке в документацию пригодная.

def mega_method(freq=1e10, prop_speed=scipy.constants.c)

Sphinx её раскроет во что-то такое:

def mega_method(freq=10000000000., prop_speed=299792458.)

Так жить нельзя: если аргументов не два, а 5-7, то сигнатура становится совсем нечитаемой.

Надо сделать так, чтобы в conf.py можно было вставить ещё одну настройку: раскрывать сигнатуры — или таки оставить их как есть.

Хочу я нарисовать иерархию классов одной софтины, сгенерировать из неё болванку питоньего кода и начать его реализовывать вместе с моими чёрными братьями.

Имею спросить: а какой софт умеет генерить болванку именно питоньего кода?

Есть у меня, джентельмены, colormap на 1000x1000 точек. Хочу я его отрисовать в matplotlib'е. Отрисовываю через plt.pcolormesh.

Одна беда: нельзя ли сделать так, чтобы его при таскании / увеличении он перерисовывался побыстрее?

import matplotlib
import matplotlib.pyplot as plt

import numpy as np

r_array = np.linspace(0, 2, 1000)
phi_array = np.linspace(0, 2 * np.pi, 1000)

r_grid, phi_grid, = np.meshgrid(r_array, phi_array)


z_grid = r_grid + phi_grid
x_grid = r_grid * np.cos(phi_grid)
y_grid = r_grid * np.sin(phi_grid)

plt.pcolormesh(x_grid, y_grid, z_grid)
plt.show()

Джентельмены! А нет ли в Django какой-нибудь стандартной вьюшки для сброса пароля? Чтобы достаточно было включить её в urls.py и дать на неё ссылку на одной из моих страниц?

Есть у меня, джентельмены, питонья библиотека, которая кушает на вход указатели на массивы, выделенные на CUDA-устройстве (void*, приведённый к int).

Я хочу выделить память на видеокарте, засунуть туда свои данные и получить-таки указатель на область выделенной памяти. Выделить память и засунуть данные я могу через pycuda.driver.to_device. А как бы мне получить адрес в памяти из получившегося DeviceAllocation?

Джентельмены! Верно ли я понимаю, что программная модель CUDA более не поддерживает выделение памяти на конкретном устройстве? Равно как и исполнение какого бы то ни было ядра на конкретном же устройстве?

А что же будет, если у меня не одна, а целых две CUDA-видеокарты (и не факт, что одинаковые)? Верно ли я понимаю, что CUDA каким-то макаром попробует раскидать исполнение между ними?

P.S. Раньше я не пользовался CUDA для разработки, обходился OpenCL.

Хочу я, джентельмены, сменить работу. С тем, чтоб добывать пропитание с наименьшей реальной загрузкой. Кто поделится своим опытом и наблюдениями — тому буду премного благодарен.

Наименьшей - это появляться на работе не каждый день, или успевать сделать всё потребное часа за три — а потом спокойно заниматься главными делами. То бишь, чертежами в SolidWorks, FPGA-разработкой, общением с китайскими поставщиками и прочими мелкими радостями.

Пропитание — это для Москвы тысяч от 45 в месяц.

P.S. Опыт коммерческой разработки, если что, есть. Изучить неизученное — не проблема.

P.P.S. Кто расскажет что интересное — с меня еврейские няшки.

^__^

Есть у меня, джентельмены, драйверы шаговых двигателей, АЦП с параллельными выходами и прочая периферия. В основном - 3.3-вольтовая.

Надо мне, джентельмены, всеми этими штукес управлять. Можно, в целом, расчехлить своё Raspberry Pi, но не слишком это удобно, каждый раз перекидывать программу по SSH. Хочется сначала отладиться на локальном хосту.

Примерные частоты - до пары мегагерц. Из тех задач, что попадались - там были десятки килогерц.

Не сможете ли присоветовать какой ни есть девайс?

Достался мне питоний код, в котором определено немалое число словарей и списков. В том числе - вложенных. Например - таких (этот самый простой):

{"bla": {"bla_bla": 100,
                        "bla_bla": "bla"},
           "bla": {"bla_bla": 60},
           "bla_bla": {"limit": 32},
           "bla_saver": {"bla_bla":
                           [os.path.join(root.common.bla_dir,
                                         "tmp %s/bla" % root.bla),
                            os.path.join(root.common.bla_dir,
                                         "tmp %s/bla" % root.bla),
                            os.path.join(root.common.cache_dir,
                                         "tmp %s/bla" % root.bla)]},
           "lines": {"bla_bla": 0.01,
                     "bla_bla": 0.0,
                     "layers":
                     [{"type": "bla_bla", "bla_bla": 32,
                       "bla": 13, "bla": 13,
                       "bla_bla": "bla",
                       "bla_bla": 0.0001,
                       "bla_bla": 0.0,
                       "bla_bla_bla": 0.0},
                      {"bla": "bla_bla",
                       "bla": 5, "bla": 5, "bla": (2, 2)},
                      {"type": "bla_bla",
                       "bla": 5, "bla": 5, "bla": (2, 2)},
                    {"bla": "bla",
                     "bla": 0.00005, "bla": 0.75, "bla": 2, "bla": 5},
                     {"type": "bla", "bla_bla": 6,
                       "bla_bla": 0.9,

                       "bla_bla_bla": 0}],
                     "bla_bla_bla_bla": {"bla": bla,
                                            "bla": bla}}}

Нет ли способов красиво отформатировать такой код, с тем, чтобы чем глубже засунут очередной словарь, тем больше для него был отступ? И чтобы каждый ключик был с новой строки?

P.S. PrettyPrint едва ли поможет: форматировать надо сам код, а не выводимые им данные. Да и многие элементы словарей - подгружаются через какие-то функции.

P.P.S. Нет, я не могу задать словари где-нибудь вовне. Да, мне нужно задавать их прямо в Python-коде.

Есть у меня, джентельмены, питоний код, который я хочу задокументировать. Например - вот такой.

# encoding: utf-8
"""
This module does blah blah!.

"""
import numpy.random
from numpy.random import uniform

class UberMegaClass(object):
    """HELL YEAH!!!!"""
    def __init__(self, num_of_something):
        print("!!!!!")
        self.num_of_something = num_of_something

    def do_something(self, arg1, arg2=None):
        print(self.num_of_something)

Я хватаю sphinx-apidoc, создаю им документацию, собираю её через make html, и всё бы круто. Но есть одна беда: дьявольский Sphinx считает, что функции, импортированные в модуль, относятся к моему модулю же. А значит - ему надо документировать и их. Таким образом, в документацию к моему проекту включается и документация от некоторых функций NumPy. Конкретно в этом случае - от random.uniform.

Как бы мне это забороть?

Хочу я, джентельмены, настроить в Ubuntu 13.10 отображение шрифтов точно такое же, как и в Windows 7. Особенно хочу настроить Courier New. Для этого я поставил Infinality и воткнул там тему Windows 7.

Получилось, однако, ни разу не похоже. Как видите, шрифты в Windows получаются пожирнее.

Настройки анти-алиасинга в Ubuntu выставлены так.

Как бы мне поправить дело? Очень уж виндовозные шрифты хороши и удобны.

P.S. Кто скажет что умное, тот держи няшу авансом.

Есть у меня, джентельмены, BLOBы, числом до миллиона. Размером примерно 36 кБ каждый. У каждого из них имеет свой идентификатор, а кроме того, каждый из них имеет одну или несколько категорий.

Надо мне делать следующее:

1) Уметь выгружать такие BLOBы на диск, потому как память не резиновая.

2) Уметь подгружать с диска BLOBы, соответствующие конкретной категории. С хорошей производительностью.

Я пытался сделать это через SQLite, подгружая BLOBы каждой категории через список IDшек, относящихся к ней (создавая временную табличку в памяти). Однако скорость получилась очень небольшой.

Можете ли что-нибудь посоветовать?

Нет ли способа поиметь в Python'е локальные переменные внутри циклов? Такие, которые не будут загромождать область видимости вовне? Иначе, когда код разрастается на экран-другой, понимать, что к чему, становится всё труднее.

Я знаю, что для хорошего кода тела циклов выносят в функции и методы. Однако клепаемый код - это, зачастую, одноразовые скрипты для статистических расчётов. Которые пишутся в духе «посмотрим на графики от предыдущей итерации и добавим/удалим пяток строк». О проектировании часто речь не идёт вообще, потому как я часто не знаю, что буду писать дальше.

Python здесь - это замена MATLABу.

И таки да, нет ли способа сделать так, чтобы переменные внутри циклов были локальными?

Джентельмены!

Есть у меня двуклассовый классификатор, который выдаёт решения в виде некоторой чиселки. Я знаю, что чем больше чиселка, тем больше вероятность, что данные, скормленные классификатору, относятся к классу 1, а не к классу 0.

Я хочу построить функцию, которая будет принимать решение классификатора и выдавать вероятность принадлежности к классу 1. Для этого делаем кросс-валидацию обучающего множества и получаем значения-решения для каждого его элемента.

После этого строим эмпирическую функцию вероятности как P[prior emp 1] (x)= Num(class 1 with dec value <= x), как-то её сглаживаем и дифференцируем, чтобы получить плотность вероятности. Так получаем f0(x) и f1(x) для классов 0 и 1.

Апстериорную вероятность считаем как P1[posterior] (x) := |class 1| * f1(x) / (|class 0| * f0(x) + |class 1| * f1(x) )

Как правильно называется такой тип оценки вероятности, когда мы строим априорные вероятности для классов непосредственно из данных?

Есть у меня вот такой код:

funcs = []

for i in (0,1):
 funcs.append(lambda: i == 1)

print funcs[0], funcs[0]()
print funcs[1], funcs[1]()

Выдаёт он мне:

<function <lambda> at 0x0000000001D72518> 1
<function <lambda> at 0x0000000001FDDDD8> 1

Как бы мне сделать так, чтобы первая функция выдавала 0, а вторая - 1? Где здесь собака зарыта?

Нужно искать минимумы/максимумы многомерных функций. А то, что есть в SciPy из коробки, мало на что пригодно.

Желателен хороший оптимизатор (лучше всего - с поддержкой генетических алгоритмов) с возможностью задавать регион поиска типа [x1min, x1max, x2min, x2max,...].

Чем пользуются настоящие джентельмены?

Скрипт вроде

for article in session.query(Article):
    print article.description

выполняется секунд двадцать, отгрызает пару гигов памяти и внезапно дохнет, не напечатав ничего, зато выдав ошибку:

Traceback (most recent call last):
  File "C:\Users\***\workspace\RCV1\Main.py", line 25, in <module>
    for article in session.query(Article):
  File "C:\Python27\lib\site-packages\sqlalchemy-0.7.3-py2.7-win32.egg\sqlalchemy\orm\query.py", line 2146, in instances
    fetch = cursor.fetchall()
  File "C:\Python27\lib\site-packages\sqlalchemy-0.7.3-py2.7-win32.egg\sqlalchemy\engine\base.py", line 2985, in fetchall
    l = self.process_rows(self._fetchall_impl())
  File "C:\Python27\lib\site-packages\sqlalchemy-0.7.3-py2.7-win32.egg\sqlalchemy\engine\base.py", line 2952, in _fetchall_impl
    return self.cursor.fetchall()
  File "C:\Python27\lib\encodings\utf_8.py", line 16, in decode
    return codecs.utf_8_decode(input, errors, True)
MemoryError

Гонять его приходится под Win64, Python стоит 32-битный. Сама база занимает гига два.

Как бы мне исправить положение?

Я дошёл до стадии «подтверждение PIN по телефону, указал там своё мобло и понадеялся на лучшее.

Во втором окошке водил как номер с +7, так и без него.

Никакой обещанный робот мне не позвонил и PIN ввести не предложил.

Как бы мне это забороть?

Есть у меня C++ные интерфейсы IReadableDataset и его наследники: IEditableDataset и IStatistics. Наследование IReadableDataset у них у обоих виртуальное.

И есть реализация Dataset, которая наследует IEditableDataset и IStatistics. А значит, виртуально наследует IReadableDataset через IStatistics и IEditableDataset.

Имею спросить: нельзя ли здесь отказаться от виртуального наследования? Вроде есть какой-то способ эмулировать его с помощью шаблонов?

Есть у меня геометрические вектора. Обычные трёхмерные. Нужно мне над ними проводить всякие операции вроде сложения-умножения-векторного произведения и прочего. Ну и матрицы сдвига-поворота хотелось бы поиметь из коробки. Желательно также уметь находить для прямой точку пересечение с поверхностью вида z(x,y). Что бы мне заюзать?