Vasyl Kolomiets's questions

按照https://developers.facebook.com/docs/instagram-api/getting-started/?locale=ru_RU我可以访问我的页面，但无法访问我作为 facebook -developer 有权访问的客户端页面 也就是说，在这个阶段

curl -i -X GET \ 
"https://graph.facebook.com/v18.0/me/accounts?access_token={access-token}"

我只为自己获取该页面，而不为客户获取该页面。

我是否缺少任何权限？

在回答@carlosrafaelgn类似问题后，我遵循了通过以下请求获取可用业务的路径：

GET https://graph.facebook.com/v18.0/me/businesses?access_token=xxx

然后 - 获取 Instagram 帐户 ID。在这里，我获得了两项业务（我自己和客户），但通过请求为客户提供服务

GET https://graph.facebook.com/v18.0/BUSINESS_ID/instagram_business_accounts?access_token=xxx

我得到的回复是空的。也就是说，这个：

你能提出一个方法或理由吗？
例如，我被授予访问权限的应用程序是否可能未链接到任何 Facebook 页面？

请不要对“可以通过谷歌搜索”的问题投反对票。我已经用谷歌搜索了 1.5 个小时。
问题的本质。一些文字识别包等 需要特定代或性能级别的显卡。唉，我不记得正确的名字了。
这个数字的范围大约是 3 到 9...根据这个数字，包可以工作或拒绝工作。该表位于 Nvidia 网站上。

但我到处都找不到它。
你能分享一个链接吗？

这是代码

ex_value = ''
try:
    2/0
except ValueError as ex_value:
    print(ex_value)
except ZeroDivisionError as ex_value:
    print(ex_value)
finally:
    print(ex_value)

这是终端打印

division by zero
Traceback (most recent call last):

  File "C:\Users\Vasil\anaconda3\envs\AMZ\lib\site-packages\spyder_kernels\py3compat.py", line 356, in compat_exec
    exec(code, globals, locals)

  File "d:\onedrive\projects\chud_amaz\soft_in_dev\moduled_way_oop\code_questions\try_except_var_in_finally.py", line 15, in <module>
    print(ex_value)

NameError: name 'ex_value' is not defined

如何最终打印消息以及为什么尝试删除我的ex_value变量。

我们有销售数据。您需要为每个帐户添加帐户中不同商品的总数。其他猫头鹰 - 添加一列，其中每个组将是该组列的总和。此代码有效。

import pandas as pd


df_fee = pd.DataFrame(
    dict(
        sku=2*[1, 1, 2, 3, 4, 4],
        order_id=3*[3, 3, 4, 5],
        quantity=4*[ 1, 2, 3],
    )
)


def __count_nd_fill_units_by_group(g):
    order_sum = g['quantity'].sum()
    g.loc[:, "units_in_order"] = order_sum
    #   
    # g = g.assign(units_in_order=order_sum)
    #             
    return g

print(df_fee)   
df_fee.loc[:, "units_in_order"] = None
df_fee = df_fee.groupby(['order_id', ], group_keys=False).apply(__count_nd_fill_units_by_group)
df_fee.sort_values(by=['order_id',], inplace=True)
print(df_fee) 

并产生这个结果：

        sku  order_id  quantity
0     1         3         1
1     1         3         2
2     2         4         3
3     3         5         1
4     4         3         2
5     4         3         3
6     1         4         1
7     1         5         2
8     2         3         3
9     3         3         1
10    4         4         2
11    4         5         3
    sku  order_id  quantity  units_in_order
0     1         3         1              12
1     1         3         2              12
4     4         3         2              12
5     4         3         3              12
8     2         3         3              12
9     3         3         1              12
2     2         4         3               6
6     1         4         1               6
10    4         4         2               6
3     3         5         1               6
7     1         5         2               6
11    4         5         3               6

d:\onedrive\projects\chud_amaz\soft_in_dev\moduled_way_oop\code_questions\order_total_units_filling.py:21: FutureWarning：在未来的版本中，df.iloc[:, i] = newvals将尝试就地设置值，而不是总是设置一个新数组。要保留旧行为，请使用df[df.columns[i]] = newvals或者，如果列不唯一，则使用df.isetitem(i, newvals) g.loc[:, "units_in_order"] = order_sum

两个问题。

1. 感觉更好（更短、更容易、更快）
2. 最后的信息是什么。它有潜在的危险吗？

有一个数据框

df = pd.DataFrame({
    'a':(1,2,3,2.003),
    'b':(2,2,6,1.993),
    'f':(2.5,2,6,2.0),
    'flag':(False,False,False,False),
})
df

       a      b    f   flag
0  1.000  2.000  2.5  False
1  2.000  2.000  2.0  False
2  3.000  6.000  6.0  False
3  2.003  1.993  2.0  False

你可以和他一起做。

df[['a','b']]
       a      b
0  1.000  2.000
1  2.000  2.000
2  3.000  6.000
3  2.003  1.993

所以。

df[['a','b']] - 2

       a      b
0 -1.000  0.000
1  0.000  0.000
2  1.000  4.000
3  0.003 -0.007

但是列减法却意外的吓人

df[['a','b']] - df.f
Out[31]: 
    a   b   0   1   2   3
0 NaN NaN NaN NaN NaN NaN
1 NaN NaN NaN NaN NaN NaN
2 NaN NaN NaN NaN NaN NaN
3 NaN NaN NaN NaN NaN NaN

我期望有两列，第三列的元素被逐个元素地减去。怎么了？

有一个工作项目。
由于读取 1+ GB 的 csv 文件和各种groupby() + apply(). 承诺只取代一条线的广告吸引了人们。
在 Anaconda / Python 3.9.12 中从头开始安装所有必要的包。只安装了 Dask 以防万一。

我运行它，它是：

    UserWarning: Dask execution environment not yet initialized. Initializing...
To remove this warning, run the following python code before doing dataframe operations:

    from distributed import Client

    client = Client()


    2022-06-06 13:00:20,340 - distributed.diskutils - INFO - Found stale lock file and directory 'D:\\OD\\OneDrive\\Projects\\Chud_Amaz\\Soft_in_dev\\moduled_way_OOP\\dask-worker-space\\worker-75ktabxn', purging
    2022-06-06 13:00:20,365 - distributed.diskutils - INFO - Found stale lock file and directory 'D:\\OD\\OneDrive\\Projects\\Chud_Amaz\\Soft_in_dev\\moduled_way_OOP\\dask-worker-space\\worker-97o0hmer', purging
    2022-06-06 13:00:20,370 - distributed.diskutils - INFO - Found stale lock file and directory 'D:\\OD\\OneDrive\\Projects\\Chud_Amaz\\Soft_in_dev\\moduled_way_OOP\\dask-worker-space\\worker-ck5pxauy', purging
    2022-06-06 13:00:20,377 - distributed.diskutils - INFO - Found stale lock file and directory 'D:\\OD\\OneDrive\\Projects\\Chud_Amaz\\Soft_in_dev\\moduled_way_OOP\\dask-worker-space\\worker-qswh4ton', purging
    2022-06-06 13:00:20,386 - distributed.diskutils - INFO - Found stale lock file and directory 'D:\\OD\\OneDrive\\Projects\\Chud_Amaz\\Soft_in_dev\\moduled_way_OOP\\dask-worker-space\\worker-vmsc68w6', purging
    2022-06-06 13:00:20,390 - distributed.diskutils - INFO - Found stale lock file and directory 'D:\\OD\\OneDrive\\Projects\\Chud_Amaz\\Soft_in_dev\\moduled_way_OOP\\dask-worker-space\\worker-ys_mgy6k', purging
    OD ---> Cant read csv D:\_\OD\AD__OD_04.06.22\AD__RET.csv. Error is index 0 is out of bounds for axis 0 with size 0
    Traceback (most recent call last):
  File D:\OD\OneDrive\Projects\Chud_Amaz\Soft_in_dev\moduled_way_OOP\izi_report_main_foldered.py:108 in <module>
    main_foldered()

  File D:\OD\OneDrive\Projects\Chud_Amaz\Soft_in_dev\moduled_way_OOP\izi_report_main_foldered.py:81 in main_foldered
    assert False, "Bad input files"

AssertionError: Bad input files

由于我不明白 Dask 想从我这里得到什么，所以我想问 - 那会是什么？嗯，也就是说，一切正常。在模块中添加了以下内容：

try:
    import modin.pandas as pd
except:
    import pandas as pd

而我被骗了。告诉我——去哪里跑？
是的。我有Windows10，AMD。

所以，简而言之，问题是：

安装后modin[dask]运行代码报错：

Error is index 0 is out of bounds for axis 0 with size 0
Traceback (most recent call last):

他自己read_csv() 有这些参数：

            readed_into_df = pd.read_csv(
                str(file_path),
                skiprows=skiprows_list,
                sep=separator,
                encoding=en_cod_,
                thousands=",",  # TODO: chek it
                on_bad_lines="skip",
                usecols=columns_dtype.keys(),
                dtype=columns_dtype,
            )

使用在线商店时，您必须处理来自不同本地化的数据。它们包含一个对处理很重要的日期。自然，日期格式在不同语言的意义上是不同的——西班牙语、法语、英语、德语等。

这是西班牙语的示例：
“2021 年 9 月 9 日 12:19:03 GMT-7”
“2022 年 2 月 8 日 23:28:33 GMT-8”
“1 年前 2021 00:31:47 GMT-7”

当您尝试在 Pfndas 中使用 pd.to_datetime() 时，您会遇到错误。

pd.to_datetime("1 ago 2021 00:31:47 GMT-7")
    
ParserError: Unknown string format: 1 ago 2021 00:31:47 GMT-7

这里和这里都有关于该主题的解决方案 - 使用PyICU. 但是没有 Windows 的“本机”安装。
同时，我很想用每种语言的“句柄”替换几个月的必要缩写，并pd.to_datetime()在上下文替换后使用它们。然后对于每种语言可以有几个语言环境。西班牙语——墨西哥和西班牙等。

问题 1PyICU ：使用 “手动”替换几个月的缩写有什么好处以及可能出现什么“问题”。通过文件名，我可以理解它是什么语言。

问题 2：也许出现了一些新的模块来解析日期而不需要告诉它语言？

问题3，短）csv ：如果日期中有不同的语言，读取时如何解析日期？

添加。我认为这里给出的解决方案将适合我，并且可以在此处获取带有偏移时钟的所有区域的表。

在处理文件时，我从不同的来源和不同的编码中获取它们。因此，在一个循环中，我遍历列表中可能的编码en_codings = ['utf-8', "cp1250", "cp1251", "cp1252", "latin1", "utf-8-sig"] 并使用发生读取的编码。

任务参数允许你跳过“坏行”，所以我on_bad_lines="skip"在我的pandas版本 1.4.2 中使用了该参数。大多数文件至少以某种方式处理。有时会有一个“损坏”的文件，其中最后一行不包含所有元素。然后，尽管on_bad_lines="skip"给出了错误ParserError: Error tokenizing data. C error: EOF inside string starting at row 4390，尽管在我的理解中它只是不得不被跳过......

附件：csv 文件。但这是最后几行的样子：

如您所见，最后一行已损坏。

我想找到一个pandas.read_csv()可以跳过这种坏行变体的参数组合。我再说一遍 - 问题是它是最后一个......文件中间的相同行通常会被跳过。
哦，是的-Windows 10。

添加。 问题是由于在启动新字段的打开引号之后捕获了文件结尾字符这一事实。如果您使用句柄引用引号，则读取该文件。

从 Python 获取 *.exe 的愿望导致了此处和此处描述的问题。
我理解不可能回答这类问题，我将描述我对如何从 Python 代码中获取 exe 文件的理解。你能指出概念上的缺陷吗？所以：

1. 我们将代码带入工作状态。我们至少检查菜单所有分支上代码的可运行性。

2. 检查所有导入的模块（安装了 conda 和安装了 pip）

3. 指定要手动包含在复制文件中的 tkinter dll 的路径。在这里我不知道 - 如何处理我的 mysql 连接？

4. 我们将所有内容都转移到脚本中并等待它被创建。

5. 我开始 - 一个黑色的窗口闪烁了一秒钟，一切都无声无息地关闭了。
   好吧，这里是代码：

   '''Imports are automatically detected (normally) in the script to freeze  ))) '''
   cx_Freeze.setup(
       name="Name_1st_exe",
       description='My Hello World App!',
       options={
           "build_exe":
           {
           "packages": [
               "tkinter", "matplotlib",
               "functools",
               "json",
               "time", "datetime",
               "pathlib",
               "PIL",
               "winsound",
               "mysql",
               "PyPDF2",
               "fitz",
               'numpy', 'collections',
               'requests',
               'pprint',
               'abc',
           ],
           "include_files": [
               r"D:\OD\OneDrive\PyCodes\AnaPy\ICO\python-powered-h-140x182.ico",                    
               r"D:\Games\Anaconda\envs\postman\Library\bin\tcl86t.dll",
               r"D:\Games\Anaconda\envs\postman\Library\bin\tk86t.dll",
               # может, что то еще?
           ],
           'include_msvcr': True,
           }
       },
       version="0.2",
       executables=executables)
   

我可以补充一点，该程序集是在 Windows 10 上完成的，以便在 Windows 10 上运行。Python = 3.9.7 全部来自 Anaconda。
我不得不使用conda install some_modules -c conda-forge.

无法看到所需的 tkinter 菜单）

也许是希望MySQL在程序集中使用的问题，或者是抽象类的模块abc。如果有人分享他们创建此类程序集的经验，我将不胜感激。

添加。 回应 - 有人从 Tkinter + abc + mysql 得到一个 exe 吗？或者我是唯一一个试图这样做的人......

根据有关带有过滤答案的列表的问题的材料，当您在字段中键入时，我尝试编写带有弹出窗口的类似代码。窗口弹出，但它是空的。你能告诉我吗？

这里想到了以下几点。输入字段有两个事件处理程序：

1. 跟踪字段中的输入 - 将输入的字符传递到下拉列表过滤窗口
2. 下拉列表本身，其中以输入字符串的字符开头的行应该可见。好吧，通常从列表中选择城市。

我无法更容易地实现它，因为在 Python 中成熟的 Tk 陛下没有这种类型的例子。即使在这里，与图书馆的作者一起，导师也很幼稚……
具体来说，在这里-从列表中选择一种编程语言，并通过部分输入在列表中定位。同样，这里一切正常，我尝试添加一个单独的窗口，该窗口出现在鼠标右键单击上。

import tkinter as tk
from tkinter import ttk


def on_change_selection(event):
    # перенос выбранного из списка значения в окно ввода
    selection = event.widget.curselection()
    if selection:
        index = selection[0]
        data = event.widget.get(index)
        entry_text.set(data)
        filter_listbox(event)



def create_listbox(event):
    # создание выпадающего окна со списком языков. Может нужен OnTop() ?
    global city_start_values_list
    global city_listbox, listbox_values
    print("box creating")

    list_root = tk.Tk()
    listbox_values = tk.Variable(master=list_root)  # list_root
    city_listbox = tk.Listbox(list_root, listvariable=listbox_values)
    city_listbox.bind('<<ListboxSelect>>', on_change_selection)

    city_listbox.pack()
    list_root.mainloop()


def filter_listbox(event):
    global city_start_values_list
    global city_listbox, listbox_values

    entered_text = ent_lookup.get().lower()
    if not listbox_values:
        return
    if entered_text == '':
        listbox_values.set(city_start_values_list)
        # city_listbox["values"] = city_start_values_list
    else:
        # фильтруем значения, начинающиеся с подстроки
        values = [el for el in city_start_values_list if el.startswith(entered_text)]
        # city_listbox["values"] = values
        listbox_values.set(values)

    print(ent_lookup.get())


# основная программа - задание поля ввода с описанием. binding обработчиков
city_listbox, listbox_values = None, None

city_start_values_list = [
    'C', 'C++', 'Java',
    'Python', 'Perl',
    'PHP', 'ASP', 'JS'
]


root = tk.Tk()
root.minsize(170, 100)

mainframe = ttk.Frame(root, padding="2 5 2 2")
mainframe.pack(side=tk.BOTTOM, fill=tk.X)

lbl_lookup = ttk.Label(mainframe, text='real')
lbl_lookup.pack(side=tk.LEFT)

entry_text = tk.StringVar(root)
ent_lookup = ttk.Entry(mainframe, width=30, textvariable=entry_text)
ent_lookup.pack(side=tk.RIGHT)

ent_lookup.bind('<Button-3>', create_listbox)
ent_lookup.bind('<KeyRelease>', filter_listbox)  # '<Key>'

root.mainloop()

这里：

无论如何 - 在哪里阅读 tk.Variable() 和参数textvariableforEntry和listvariable for Listbox？互联网上对他们保持沉默......

我们需要获取当前工作目录的最近父级。

In [1]: Path()
Out[1]: WindowsPath('.')

In [2]: Path().parent
Out[2]: WindowsPath('.')

In [3]: Path(Path().absolute()).parent
Out[3]: WindowsPath('D:/AnaPy')

当然，我设法得到了我想要的，但可能有更好的解决方案。
我仍然不明白为什么 Path().parent 它不起作用。

有时使用globals()函数很方便。在下面的示例中，我使用一些约定创建了一个函数字典，即函数名称的第一个字符必须与键匹配：

def a_fun(c):
    print(c, 'from a_fun')


def b_fun(c):
    print(c, 'from b_fun')

def fun():
    fun_dict = dict.fromkeys({'a', 'b'})
    return {key: globals()[key + '_fun'] for key in fun_dict}

fun()['a'](33), fun()['b'](44)

该代码本身可以正常工作并产生：

33 from a_fun  
44 from b_fun

但是在类描述中，这是不可能的。我只是这样管理：

class fabric():

    def __a_fun(self, c):
        print(c, 'from __a_fun')


    def __b_fun(self, c):
        print(c, 'from __b_fun')

    def fun(self):
        # print(locals())
        # print(globals())
        return {'a': self.__a_fun, 'b': self.__b_fun}

z = fabric()

z.fun()['a'](33)

是什么赋予了

33 from __a_fun

问题是locals()和globals()字典中缺少 __a_fun 和 __b_fun 。
你能告诉我这是否可以像第一个例子一样完成吗？这个想法是在添加下一个数据处理选项时不更改代码。好吧，如果发生了变化，我只需在文件中添加一个函数，不需要在其他地方进行更改。
也就是说，使用类中的函数自动填充字典的问题。

我处理来自不同人的数据，这些人以 csv 格式向我发送文件。当然，数据包带有错误、不完整等。在这里，我的脚本挂在我的服务器上，它会定期读取我的邮件、提取文件并按应有的方式处理它们。
很明显，为了防止程序在任何门柱的情况下崩溃，我在每个函数或类方法中都放置了try ... except并返回一个符号 - 子程序中的处理是否结束。每个方法函数具有以下结构：

def files_reading(self):
    """Read the files."""
    self.response["exit_is_ok"] = False

    try:   # do something here
       ...
       self.response["file"] = some_file
       self.response["exit_is_ok"] = True
    except Exception as error:
       self.response["exit_message"] = f'{error} while reading'

    return self.response

也就是在入口处，我将标志设置为False，在没有异常的情况下将其更改为True。如果功能有问题，当然应该跳过这个数据包。即在主循环中，每次调用该方法时，都会检查“Ok”或“Ok”。
那么主程序是这样的：

def main():
    """Calculate Amazon reports."""
   ...

   for sender in senders:
        ...
        izi_report = globals()[task_name](path_to_files_folder)
        # ===data reading===
        readed = izi_report.files_reading()
        pd_files = readed["files"]
        if not readed["exit_is_ok"]:
            print(received["folder"], "--->", readed["exit_message"])
            continue 

        # ===data_processing===
        data_response = izi_report.data_processing(**pd_files)
        if not data_response["exit_is_ok"]:
            print(received["folder"], "--->", data_response["exit_message"])
            continue

        #  ===write to xlsx===
        files = data_response["files"]
        xl_response = izi_report.excel_writer(files)
        if not xl_response["exit_is_ok"]:
            print(received["folder"], "--->", xl_response["exit_message"])
            continue
        ...

可以看出，相同的行序列不断重复。稍后，将发送一封信，而不是打印。
所以这就是问题所在。在这种情况下如何遵守DRY规则。毕竟，您不能将“继续”放入函数中。或者更一般的问题。有没有办法更好地实现这个想法。

在数据处理任务中，一切都是例行公事。我们收到一个包裹（或一封信），阅读文件，处理文件，根据到达的文件集（例如，xlsx 文件）创建所需类型的报告，格式化报告，并将生成的文件发回。对于这样的任务，我构建了一个抽象类：

from pathlib import Path

from abc import ABC, abstractmethod   # , abstractproperty


class IZI_report(ABC):
"""Class for reports."""

def __init__(self,  path_to_files_folder: Path):
    self.path_to_files_folder = path_to_files_folder
    self.response = {             # dict_to_return
        "exit_is_ok": False,
        "exit_message": "",
         # ...
     }

@abstractmethod
def files_reading(self, path_to_files_folder):
    ...

@abstractmethod
def data_processing(self, **pd_files):
    ...

@abstractmethod
def excel_writer(self, path_to_files_folder, client_name, files):
    ...

@abstractmethod
def excel_file_formatting(self, file_to_attach):
    ...

这假设预文件已经在file_to_attach. 但这并不重要。
一切都会好起来的，但是在 Windows 环境中使用本机库格式化 Excel 文件比不依赖于操作系统的“通用”文件快 10 倍。因此，该方法的每个具体实现 excel_file_formatting(self, file_to_attach)对我来说都是这样的：

def excel_file_formatting(self, file_to_attach):

    def o_excel_file_formatting(file_to_attach):
        # используем медленный универсальный модуль
        ...


    def w_excel_file_formatting(file_to_attach):
        # используем быстрый windows-модуль
        ...

   
    return (w_excel_file_formatting if current_os_is_win else o_excel_file_formatting)(file_to_attach)

但在我看来并不漂亮。由于每个特定的方法都重复编写了提供格式化的辅助函数。例如o_header_wrap_and_size或o_search_and_colorise。我认为这个名字清楚地表明了他们的工作。如果它们到处都是重复的，那么就违反了DRY原则。
可以将这些小辅助函数直接包含在抽象类中，但这在某种程度上违反了抽象类中方法的“比例性”。并且制作一个完整的类工厂而不是抽象类方法在某种程度上是可怕和麻烦的。
问题 - 在这种情况下创建方法的标准规则是什么被认为是正确的，“pythonic”？
似乎嵌套类会在这里做，不是吗？
但是，关于嵌套（内部，嵌套) 类被划分。有反对，有赞成。对此有什么建议吗？

有一个这样的目录结构：

   test_0    
    |-----level_1
    |-----level_1_a
    |-----level_1_b
    | ... (и т.д.)  ....      
    |-----task     
           |----file.csv   
           |----rest.py     
            ... (и т.д.)  ....

您需要将包含文件的文件夹移动到指定的文件夹。也就是说，例如在level_1中：

   test_0    
    |-----level_1
        |-----task     
               |----file.csv   
               |----rest.py     
               ... (и т.д.)  ....
    |-----level_1_a
    |-----level_1_b
    | ... (и т.д.)  ....      

嗯，这里是代码，

from pathlib import Path

work_dir = Path() / "test_0"
task_dir = work_dir / "task"

folder_move_to = work_dir / "level_1" / "task"
folder_move_to.mkdir()

for file in task_dir.iterdir():
    file.rename(work_dir / "level_1" / "task" / file.name)

task_dir.rmdir()

例如，此处给出了类似的变体。
一切都差不多好了。但有一种感觉，不知何故它是“硬”。应该更好））

问题：在这种情况下，哪种方式移动文件夹更好、更安全、更短......

该类的使用是有意义的Path()，但不是必需的。
在这里，这样的决定对我来说似乎很麻烦。有什么更优雅的吗？
这个问题被解决了 100,500 次，显然在谷歌上搜索得很糟糕。

from pathlib import Path

folder_name = input("folder name:")
folder = Path(folder_name)
if folder.is_dir():
    folder_count = len([1 for file in folder.iterdir()])

print(f"В папке {folder_name} есть {folder_count} объектов")

有两个框架 - 含税的订单和每种产品的税务指南。

必须为每个产品代码选择那些“税”值高于“参考书”标准值的订单。

这是代码：

import pandas as pd


def marker(g, epsilon):
    """Mark."""
    g = g.query("fee + fee_preview < -@epsilon")
    return g


df_orders = pd.DataFrame({
    "order_id": list(range(1, 14)),
    "sku": 9 * ["a", ] + 4 * ["b", ],
    "fee_amount": [-1, -1, -1, -1, -1.1, -0.8, -1.1, -2, -2, -2.1, -2.1, -2.1, -4.3],
    "quanty": 7 * [1, ] + 2 * [2, ] + 3 * [1, ] + [2, ],
})

print(df_orders)

df_fee = pd.DataFrame({
    "fee": [1, 0.8, 2.1, 4.3],
    "sku": ["a", "d", "b", "g"],
})

print(df_fee)


df_orders["fee"] = df_orders["fee_amount"] / df_orders["quanty"]

df = df_orders.join(df_fee.set_index("sku"), on="sku", rsuffix="_preview")

dd = df.groupby("sku").apply(marker, 0.005)
print(dd)

一切正常，结果如下：

        order_id sku  fee_amount  quanty
0          1   a        -1.0       1
1          2   a        -1.0       1
2          3   a        -1.0       1
3          4   a        -1.0       1
4          5   a        -1.1       1
5          6   a        -0.8       1
6          7   a        -1.1       1
7          8   a        -2.0       2
8          9   a        -2.0       2
9         10   b        -2.1       1
10        11   b        -2.1       1
11        12   b        -2.1       1
12        13   b        -4.3       2
   fee sku
0  1.0   a
1  0.8   d
2  2.1   b
3  4.3   g
        order_id sku  fee_amount  quanty   fee  fee_preview
sku                                                        
a   4          5   a        -1.1       1 -1.10          1.0
    6          7   a        -1.1       1 -1.10          1.0
b   12        13   b        -4.3       2 -2.15          2.1

但是我对.join()膨胀中间帧的操作感到困惑。

难道没有类似的“更多 SQL”，或者其他更经济地使用内存的解决方案吗？

我决定将使用SQLite的工作代码从 Windows 10 移植到 Ubuntu 16.4。此外，在 ARM64 NANOPI NEO4 上。嗯，原来是这样的服务器。一个程序去了。但是第二个，使用SQLite - 好吧，没办法。说数据库结构不好。

pi@NanoPi-NEO4:~/py_codes/scheduler$ python3 main_scheduler.py
2021-04-01 14:51:39,165 - Sheduler.get_sheduled_tasks - INFO - Вызов с args=(<sqlite3.Cursor object at 0x7fa5d6a960>,), kwargs={}
Traceback (most recent call last):
  File "main_scheduler.py", line 586, in <module>
    sheduled_tasks = get_sheduled_tasks(c)
  File "/home/pi/py_codes/scheduler/logger.py", line 20, in wrap_log
    result = func(*args, **kwargs)
  File "main_scheduler.py", line 112, in get_sheduled_tasks
    records = cursor.execute('SELECT * FROM tasks_sheduled WHERE not finished').fetchall()
sqlite3.DatabaseError: malformed database schema (tasks_reports) - default value of column [is_handmade] is not constant

这是主要错误：

sqlite3.DatabaseError: malformed database schema (TABLE_NAME) - default value of column [COLUMN_NAME] is not constant

但我没有更改数据库中的任何内容。刚刚复制并粘贴了文件。
是否需要任何特殊迁移？

以供参考。在 Windows Python 3.8 和 Ubuntu 上 - Python 3.6
列 [is_handmade] 的默认值设置为 False。

这是数据集：

import pandas as pd
test = pd.DataFrame({"par1": [1, 2, 3, 4, 5], 
                     "par2": [11, 12, 13, 14, 15],
                     "par3": [21, 22, 23, 24, 25],
                     })

test
Out[45]: 
   par1  par2  par3
0     1    11    21
1     2    12    22
2     3    13    23
3     4    14    24
4     5    15    25

如何获得满足一组条件的第一行？

具体来说，我有一组数字 p1、p2、p3。如何选择条件 par1>p1 & par2>p2 & par3>p3 为真的第一行？例如，找到一个适合尺寸为 p1、p2、p3 的对象的框。

这是我的解决方案：

test[(test["par1"]>2) & (test["par2"]>13) &  (test["par3"]>1)].iloc[0, :]

Out[43]: 
par1     4
par2    14
par3    24
Name: 3, dtype: int64

有人怀疑 Pandas 有更好的解决方案。这就像使用 break 按条件退出循环。选择所有满足条件的记录显然是多余的。

有一个问题，我给出了解决方案。

源表。

test = pd.DataFrame({"par1": [1, 2, 3, 4, 5], "par2": [11, 12, 13, 14, 15],
                     "country": ["UA", "UA", "US", "US", "CHI"],
                     })
print(test)

   par1  par2 country
0     1    11      UA
1     2    12      UA
2     3    13      US
3     4    14      US
4     5    15     CHI

它需要转换为以下形式的列表字典：

{'CHI': [{'country': 'CHI', 'par1': 5, 'par2': 15}],
 'UA': [{'country': 'UA', 'par1': 1, 'par2': 11},
        {'country': 'UA', 'par1': 2, 'par2': 12}],
 'US': [{'country': 'US', 'par1': 3, 'par2': 13},
        {'country': 'US', 'par1': 4, 'par2': 14}]}

我是这样解决的：

def dictionarizer(g):
    global param_dict
    param_dict.update({g.country.values[0]: g.to_dict(orient="records")})
    
param_dict = dict()
test.groupby("country").apply(dictionarizer)

但我不喜欢这个解决方案。全局变量、函数副作用……你能
提出一个更“时尚的解决方案”吗？
更好的是

{'CHI': [{ 'par1': 5, 'par2': 15}],
 'UA': [{ 'par1': 1, 'par2': 11},
        { 'par1': 2, 'par2': 12}],
 'US': [{ 'par1': 3, 'par2': 13},
        { 'par1': 4, 'par2': 14}]}