Crazy Theory's questions

我正在读取一个文件，其内容是这样的：

block1:
   Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla consequat ante nisi, id 
   vestibulum felis tempor ac. Ut semper, ligula id sollicitudin efficitur, nisl diam elementum 
   lectus, nec iaculis turpis felis non mauris. Aenean elementum tortor a tristique iaculis. Morbi 
   a aliquam diam. Donec blandit orci sit amet ante hendrerit sodales.
block2:
   <h1> Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla consequat ante nisi, id 
   vestibulum felis tempor ac. Ut semper, ligula id sollicitudin efficitur, nisl diam elementum 
   lectus, nec iaculis turpis felis non mauris. Aenean elementum tortor a tristique iaculis. Morbi 
   a aliquam diam. Donec blandit orci sit amet ante hendrerit sodales. Morbi quis quam quis augue 
   fermentum tempus ac a ante. In vel dui interdum turpis sodales tincidunt. Praesent eget maximus 
   lorem. Phasellus mollis gravida nisi vitae pellentesque. Curabitur sed felis eget quam 
   tincidunt malesuada. </h1>

需要获取每个块的内容，我试过下面的代码：

f = open("filename.txt")
fcontent = f.read()
f.close()

contents = []
block_names = ("block1", "block2")

positions = len(block_names)
for pos in range(positions):
    current_block = block_names[pos]
    next_block = block_names[pos + 1]

    contents.append(
        fcontent[fcontent.find(current_block)] + len(current_block) + 1: next_block]
    )

问题的重点在标题中。

我举个例子：

if <condition>: break

if <condition>: continue

从 PEP8 的角度来看，这样的符号是错误的吗？搜索信息，但没有找到。

我想将一个类方法作为一个属性来访问，但是如果我不能直接把它变成一个属性呢？假设有一个方法在概念上和名称上都类似于属性，但是该类的作者将其作为方法留下了。有可能这样做吗？这样的做法会违反任何原则吗？

SomeClass.some_method = property(SomeClass.some_method)

我为序列化程序编写了 mixins 并遇到了以下问题：

class UniqueLinkInspectionMixin(serializers.Serializer, ABC):
    """
    Класс, отвечающий за валидацию пришедших uidb и токена в представлении,
    в котором он используется.
    """

    uidb = serializers.CharField()
    token = serializers.CharField()

    def __init__(self, *args, **kwargs):
        """
        Конструктор, определяющий поле для валидации.
        """

        self.token_generator = default_token_generator
        super().__init__(*args, **kwargs)

    @staticmethod
    def get_customer(uidb):
        """
        Метод, осуществляющий получение пользователя
        по пришедшему uidb.
        """

        try:
            uid = urlsafe_base64_decode(uidb).decode()
            return Customer.objects.get(pk=uid)

        except (TypeError, ValueError, OverflowError, Customer.DoesNotExist):
            pass

    def validate(self, attrs):
        """
        Валидирует пришедшие данные.
        """

        uidb, token = attrs['uidb'], attrs['token']
        customer = self.get_customer(uidb)

        if not (
            customer is not None
            and self.token_generator(customer, token)
        ):
            raise serializers.ValidationError(
                'As a result of checking the link, '
                'it turned out to be incorrect or inactive.'
            )


class DoublePasswordMixin(serializers.Serializer, ABC):
    """
    Сериализатор, от которого должны наследоваться другие сериализаторы,
    ожидающие два парольных поля, которые объявлены здесь.
    """

    password = PasswordField()
    confirm_password = PasswordField()

    def validate(self, attrs):
        """
        Метод, который осуществляет проверку на соответствие
        двух введенных паролей.
        """

        if attrs['password'] != attrs.pop('confirm_password'):
            raise serializers.ValidationError('Password mismatch.')

如您所见，它们中的每一个都有自己的 validate 方法实现。因此，假设我为密码恢复编写了一个序列化程序，并同时从这两个 mixin 继承它，一个包含验证传入唯一链接的逻辑，另一个验证密码，列表中的第一个我将继承的类将替换第二个。请帮我解决这个问题。

我正在 DRF 中编写一个 API，以便随后访问它并编写客户端。为了正确选择将附加 uidb 和令牌的地址，出现问题。如果这个地址在 DRF 项目的框架内，那么用户将直接访问 API，信息将以 REST 格式呈现给他。

为了更清楚我的意思，让我们以注册端点为例：Android或iOS客户端上的用户，但这并不重要，即使是网络，将他的数据输入到表单中，然后将它们发送到API 及其验证已经在那里进行，如果一切顺利，用户将被保存为非活动状态，并向他们的电子邮件地址发送一条消息。链接应该是什么？她应该去哪里？我相信在用户打开给他的链接后，他应该会看到一个漂亮的题词“感谢您确认注册”或类似的东西。

在我的项目中，我实现了电子邮件地址验证。

用户在表单中输入注册所需的所有数据，然后我们cleaned_data从属性中获取电子邮件地址并发送消息。

我通过以下方式实现发送（我会在解释后附上代码）：

1. 有一个继承自 FormView 的 mixin，它定义了 FormValid 方法，以便将发送消息所需的数据发送到表单的 save 方法。
2. 我们从上面的 mixin 中继承视图并定义随后在提交中使用的字段。

这是混合：

class SendsMessageMixin(FormView):
    """
    A mixin that provides all inherited
    classes with the functionality of sending an email.
    """

    email_subject = email_template_name = token_generator = None

    def form_valid(self, form):
        """
        When this method is triggered, the data that will
        later be used to send the message is passed to the form save method.
        """

        form.save(
            **
            {
                'request': self.request,
                'use_https': self.request.is_secure(),
                'subject': self.email_subject,
                'template_name': self.email_template_name,
                'token_generator': self.token_generator
            }
        )

        return super().form_valid(form)

表现：

class Registration(UnauthorizedRequiredMixin, SendsMessageMixin):
    form_class = ConsumerCreationForm
    template_name = 'consumers/registration.html'
    email_subject = 'Confirm your account.'
    email_template_name = 'mail/verification.html'
    token_generator = default_token_generator
    success_url = reverse_lazy('message_sent')

表格保存方法：

    def save(self, **sending_data):
        """
        Saves an inactive user to the database, after sending
        a message asking for confirmation of registration to the email address.
        """

        consumer = super().save(commit=False)
        consumer.set_password(self.cleaned_data['password'])

        prepare_data_and_send_message_with_uid_and_token(consumer=consumer, **sending_data)
        consumer.save()

        return consumer

消息内容生成：

def prepare_data_and_send_message_with_uid_and_token(request, consumer, use_https, subject,
                                                     template_name, token_generator):
    """
    Prepares data to be loaded into message content,
    the main purpose of which is to send a unique link to the user.
    """

    content = {
        'domain': get_current_site(request).domain,
        'uid': urlsafe_base64_encode(force_bytes(consumer.pk)),
        'token': token_generator.make_token(consumer),
        'protocol': 'https' if use_https else 'http'
    }

    send_message(subject, template_name, content, consumer.email)

发送消息

@task()
def send_message(subject, template_name, content, to_email):
    """
    Sends a message to the specified email address in the background.
    """

    body = render_to_string(template_name, content)
    message = EmailMessage(subject, body, to=[to_email])
    message.send()

huey用于后台发送

消息本身：

{% autoescape off %}
Hello, your email address has been selected for registration!
To confirm, follow the link.
{{ protocol }}://{{ domain }}{% url 'activate' uidb64=uid token=token %}
In case you didn't do it, just ignore this message.
{% endautoescape %}

切换到生成的激活链接时，会触发dispatch方法，由于方法在这里没有发挥作用，所以一般不重要。

在此调度方法中，我从 kwargs 字典中提取 uidb64 并使用以下构造：

urlsafe_base64_decode(uidb64).decode().

它返回无。

最重要的是，无论如何都会返回 None 。我想强调一下，uidb64 是完美生成的并进入了 kwargs。

我将添加一个我试图覆盖密码恢复表单的功能（以便在后台发送消息），当我转到生成的链接时，即 PasswordResetConfirmView 视图，使用现成的逻辑，一切一声巨响，我能够恢复该帐户的密码，因此uidb收到了我的帐户（解码工作没有返回None）。

在我之前有一个任务 otvalidirovat 用户输入的值（用户名）。它需要满足要求

• 用户名可以包含拉丁字母 (a-z)、数字 (0-9)。
• 不能使用和号 (&)、dog(@)、等于 (=)、加法 (+)、括号 (<>)、逗号 (,)、下划线 (_)、撇号 (')、连字符 (-) 和点。

这些要求取自 Gmail，但针对项目进行了轻微调整。

请有规律地帮忙。在正则表达式中，我一般为 0。

我开始使用 FastAPI 框架并将 SQLAlchemy 连接到它，总的来说，它不是很高兴，因为我不喜欢将不必要的抽象连接到我的代码中，而是基于互联网上的意见和创建者的事实框架在我决定使用它的示例中推荐这个 ORM。

错误如下：

asyncpg.exceptions.DataError: invalid input for query argument $1: 'lalala@gmail.com' (a bytes-like object is required, not 'str')

存储包db.py文件：

from databases import Database
import sqlalchemy

address = ""

storage = Database(address)

metadata = sqlalchemy.MetaData()

consumers = sqlalchemy.Table(
    "consumers",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("first_name", sqlalchemy.String),
    sqlalchemy.Column("last_name", sqlalchemy.String),
    sqlalchemy.Column("email", sqlalchemy.String, unique=True),
    sqlalchemy.Column("password", sqlalchemy.String)
)

engine = sqlalchemy.create_engine(address)

metadata.create_all(engine)

我的检索代码，放在utils.py文件中的存储包中：

from .db import consumers, storage

async def get_user_by_email(email: str):
    return await storage.fetch_one(
        consumers.select().where(consumers.c.email == email)
    )

身份验证包中的models.py文件：

from pydantic import BaseModel, EmailStr


class CreateConsumer(BaseModel):
    email:            EmailStr
    first_name:       str
    last_name:        str
    password:         str
    confirm_password: str

身份验证包中的routes.py文件：

from fastapi import APIRouter
from .models import CreateConsumer
from storage.utils import get_user_by_email

authentication = APIRouter()


@authentication.post('/sign-up')
async def sign_up(user: CreateConsumer):
    if await get_user_by_email(user.email):
        pass

我的问题是一个视图为用户提供了创建广告的功能，但我的序列化程序不允许选择作者。（如果创建广告的用户不能选择自己，而是选择管理员，那将是愚蠢的）

但这分别是问题所在，我无法从 request.user 序列化程序中填写排除字段。

我的代码：

模型

class Ad(models.Model):
    author = models.ForeignKey(
        get_user_model(),
        on_delete=models.CASCADE,
        null=True
    )
    category = models.ForeignKey(
        Category,
        null=True,
        on_delete=models.SET_NULL
    )
    name = models.CharField(
        max_length=80,
    )
    text = models.TextField(
        max_length=256,
    )
    cost = models.PositiveIntegerField(

    )
    currency = models.ForeignKey(
        Currency,
        null=True,
        on_delete=models.SET_NULL
    )
    city = models.ForeignKey(
        City,
        null=True,
        on_delete=models.SET_NULL
    )
    pub_date = models.DateTimeField(
        auto_now_add=True
    )

    class Meta:
        ordering = ['-pub_date']

    def __str__(self):
        return self.name

串行器

class AdSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Ad
        exclude = ['author']

表现

class CreateMixin(views.APIView):
    """Allows heirs to use the same method of creating objects."""
    serializer_class = permission_classes = None

    def post(self, request):
        """Creates an object and, if everything is successful,
         returns its serialized form to the user."""
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid() and serializer.save():
            return Response(serializer.data, status=status.HTTP_201_CREATED)

class CreateAd(CreateMixin):
    """Provides functionality for creating an ad."""
    serializer_class = serializers.AdSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

我和其他人一起从我的 mixin 继承了创建广告的视图。很明显，当可以分配作者对象字段时，我将停止继承，因为mixin提供了抽象框架限制的功能，因此，不要关注它）

我对如何跟踪数据库中新记录的出现以及是否存在这种可能性很感兴趣。

我在标签中指出了 Golang，不是因为问题涉及它的某些组件，而是因为它的实现是必要的。

在标准的 db/sql 中，我在方法中找不到类似的东西。

请告诉我如何监控。

这个问题困扰了我很长时间，我仍然无法弄清楚为什么会这样，请告诉我。

我正在运行一个函数，其中 goroutine 从源收集数据并将其组装成一个列表，该列表随后飞到等待该列表的管道。在所有这些过程之后，该函数返回通道。

刚拿到数据

package main

import (
    "github.com/PuerkitoBio/goquery"
    "net/http"
)

type (
    TextField struct {
        Selector string
    }
    GraphicField struct {
        Selector  string
        Attribute string
    }
    Item struct {
        InclusiveSelector string
        TextFields        []TextField
        GraphicFields     []GraphicField
    }
    Source struct {
        Address       string
        ContentObject Item
    }
)

func (s Source) DocumentProvidedSourceInformation() (*goquery.Document, error) {
    r, err := http.Get(s.Address)

    if err != nil {
        return nil, err
    }

    document, err := goquery.NewDocumentFromReader(r.Body)

    if err != nil {
        return nil, err
    }

    defer r.Body.Close()

    return document, nil
}

func (s Source) TheftLastItem(html *goquery.Document) <-chan []string {
    var exhaustChannel chan []string

    go func() {
        var exhaustData []string

        html.Find(s.ContentObject.InclusiveSelector).First().Each(
            func(index int, item *goquery.Selection) {
                for _, textField := range s.ContentObject.TextFields {
                    exhaustData = append(exhaustData, item.Find(textField.Selector).Text())
                }
                for _, graphicField := range s.ContentObject.GraphicFields {
                    graphicItem, presence := item.Find(graphicField.Selector).Attr(graphicField.Attribute)

                    if presence {
                        exhaustData = append(exhaustData, graphicItem)
                    }
                }
                exhaustChannel <- exhaustData
            },
        )
    }()
    return exhaustChannel
}

运行代码

package main

import "fmt"


func main() {
   textFields := []TextField{
       {
           Selector: ".caption",
       },
       {
           Selector: ".game-specs",
       },
       {
           Selector: ".score",
       },
   }

   graphicFields := []GraphicField{
       {
           Selector: ".image",
           Attribute: "style",
       },
   }

   game := Item{
       InclusiveSelector: ".simple-list .item",
       TextFields: textFields,
       GraphicFields: graphicFields,
   }

   stopGame := Source{
       Address: "https://stopgame.ru/games",
       ContentObject: game,
   }

   document, err := stopGame.DocumentProvidedSourceInformation()

   if err != nil {
       fmt.Println(err)
   }

   for {
       data := stopGame.TheftLastItem(document)
       fmt.Println(<-data) // на этом моменте останавливается осуществление кода
   }
}

通过试用（fmt.Println）我发现该函数本身可以正常工作，但是当我在启动过程中接收到数据并将其丢弃打印时，我的工作停止了。我立即启动了一个无限循环，因为这种实现将来会引起我的兴趣。但是如果你尝试运行一次，结果是一样的。

我的代码是这样工作的：

有一个源类型，它有一个地址和一个源包含的对象，这个对象有一个css选择器，其中包含关于它的所有信息，除了选择器之外，它还包含字段，字段有一个对应于给定的名称选择器和值。

编码

package main

import (
    "fmt"
    "github.com/PuerkitoBio/goquery"
    "net/http"
)

type Item struct {
    Selector string
    Fields   []Field
}

type Field struct {
    Name     string
    Selector string
    Value    string
}

type Source struct {
    Address string
    Item    Item
}

func (s Source) ParseData() Item {
    request, _ := http.Get(s.Address)
    html, _ := goquery.NewDocumentFromReader(request.Body)

    html.Find(s.Item.Selector).First().Each(
        func(index int, item *goquery.Selection) {
            for _, field := range s.Item.Fields {
                field.Value = item.Find(field.Selector).Text()
            }
        })
    return s.Item
}

func main() {
    stopGame := Source{
        Address: "https://stopgame.ru/games",
        Item: Item{
            Selector: ".simple-list .item",
            Fields: []Field{
                {
                    Name:     "Caption",
                    Selector: ".caption",
                },
                {
                    Name:     "About",
                    Selector: ".game-specs",
                },
                {
                    Name: "Rating",
                    Selector: ".score",
                },
            },
        },
    }
    for _, field := range stopGame.ParseData().Fields {
        fmt.Println(field.Value)
    }
}

当涉及到执行一个循环，该循环遍历从源接收到的对象的所有字段并显示该字段的值时，则什么都不显示

下面的代码显示了我如何从标签中提取电影链接的示例。

func (movie Movie) GettingData() {
    document := GetMarkupDoc(settings.IviAddress + "movies")

    link, _ := document.Find(".nbl-slimPosterBlock").First().Attr("href")

    fmt.Println(link)

Вовзращает:
C:\Go\src\Caretaker\processing>processing.exe
/watch/437652

我需要得到最后一个字符 / 之后的内容，即 437652。我尝试使用 regexp，但不知何故，我没有找到一种方法来使用正则表达式将字符串剪切成我需要的内容。也在这里：

image, _ := document.Find(".image").First().Attr("style")

这里，图片路径是从 style 属性中解析出来的。在出口处：

background-image: url(https://адрес);

请告诉我，使用哪个库以及如何提取这些命运多舛的数据？

我在开发过程中想知道，如何在写入文件之前清除它？

例如，在一个文本文件中，第一行有短语“Hello world！”。根据程序执行流程中发生的情况，我想覆盖该值，例如“再见世界！”。但是如果你只是简单地重复 file.WriteString("Goodbye World!") 操作，就会发生串联。

在这种情况下，有必要在写入之前清除文件，将光标移动到零位置，或者其他什么。

您能告诉我如何使用 Windows 操作系统跟踪目录中出现的文件吗？很明显需要声明一个循环，但是不清楚如何获取一个新文件。例如，在我的 .py 文件旁边的目录中有一个文件夹，其中会出现新文件，这个文件夹已经有一个 d.txt 文件，当我运行 Python 脚本时，我希望我把另一个文件放在那里，例如 c.txt 它会检测到它，并且在这个依赖项中我计划执行我需要的操作。

想知道如何在一个项目中链接两种语言。我对 Golang 和 Python 特别感兴趣，我想编写一个可以解析来自多个站点的大量信息的电报机器人。但是在Golang中实现bot本身不太适合我，我想用Python构建bot的“引擎”，并从Golang中获取解析信息，请问有哪些实现方式？

我正在尝试覆盖 PasswordResetForm 表单，以便在 save() 方法之后，电子邮件由 celery 任务异步发送，但不幸的是发生了错误。这是跟踪：

  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/core/handlers/exception.py", line 34, in inner
    response = get_response(request)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/core/handlers/base.py", line 115, in _get_response
    response = self.process_exception_by_middleware(e, request)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/core/handlers/base.py", line 113, in _get_response
    response = wrapped_callback(request, *callback_args, **callback_kwargs)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/views/generic/base.py", line 71, in view
    return self.dispatch(request, *args, **kwargs)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/utils/decorators.py", line 43, in _wrapper
    return bound_method(*args, **kwargs)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/utils/decorators.py", line 130, in _wrapped_view
    response = view_func(request, *args, **kwargs)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/contrib/auth/views.py", line 222, in dispatch
    return super().dispatch(*args, **kwargs)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/views/generic/base.py", line 97, in dispatch
    return handler(request, *args, **kwargs)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/views/generic/edit.py", line 142, in post
    return self.form_valid(form)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/lib/python3.8/site-packages/django/contrib/auth/views.py", line 235, in form_valid
    form.save(**opts)
  File "/mnt/c/users/huawei/desktop/adsboard_project_venv/tbads/reset_password_system/forms.py", line 52, in save
    json.dumps(context), json.dumps(from_email), json.dumps(user.email),
  File "/usr/lib/python3.8/json/__init__.py", line 231, in dumps
    return _default_encoder.encode(obj)
  File "/usr/lib/python3.8/json/encoder.py", line 199, in encode
    chunks = self.iterencode(o, _one_shot=True)
  File "/usr/lib/python3.8/json/encoder.py", line 257, in iterencode
    return _iterencode(o, 0)
  File "/usr/lib/python3.8/json/encoder.py", line 179, in default
    raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type User is not JSON serializable

我的代码：

表格.py

from django.contrib.auth.forms import PasswordResetForm, SetPasswordForm
from django.contrib.auth import get_user_model
from django.contrib.auth.tokens import default_token_generator
from django.contrib.sites.shortcuts import get_current_site
from django.utils.encoding import force_bytes
from django.utils.http import urlsafe_base64_encode
from .tasks import send_mail_message


class GetUserEmailForm(PasswordResetForm):
    email = forms.EmailField(
        widget=forms.EmailInput(attrs={'class': 'input-login input-form', 'placeholder': 'Email'})
    )

    def clean_email(self):
        email = self.cleaned_data.get('email')
        try:
            get_user_model().objects.get(email=email)
        except get_user_model().DoesNotExist:
            raise forms.ValidationError(
                'Пользователь с таким адресом электронной почты не существует.'
            )
        return email

    def save(self, domain_override=None,
             subject_template_name='registration/password_reset_subject.txt',
             email_template_name='registration/password_reset_email.html',
             use_https=False, token_generator=default_token_generator,
             from_email=None, request=None, html_email_template_name=None, **kwargs):
        email = self.cleaned_data["email"]
        for user in self.get_users(email):
            if not domain_override:
                current_site = get_current_site(request)
                site_name = current_site.name
                domain = current_site.domain
            else:
                site_name = domain = domain_override
            context = {
                'email': user.email,
                'domain': domain,
                'site_name': site_name,
                'uid': urlsafe_base64_encode(force_bytes(user.pk)),
                'user': user,
                'token': token_generator.make_token(user),
                'protocol': 'https' if use_https else 'http',
            }

            send_mail_message.delay(subject_template_name, email_template_name,
                                    context, from_email, user.email,
                                    html_email_template_name=html_email_template_name)

任务.py

from django.template import loader
from tbads.celery import celery_app
from django.core.mail import EmailMultiAlternatives


@celery_app.task
def send_mail_message(subject_template_name, email_template_name,
                      context, from_email, to_email, html_email_template_name=None):
    subject = loader.render_to_string(subject_template_name, context)
    subject = ''.join(subject.splitlines())
    body = loader.render_to_string(email_template_name, context)

    email_message = EmailMultiAlternatives(subject, body, from_email, [to_email])
    if html_email_template_name is not None:
        html_email = loader.render_to_string(html_email_template_name, context)
        email_message.attach_alternative(html_email, 'text/html')

    email_message.send()

我尝试使用 json.dumps 和 to.JSON 转换参数，但没有带来太多结果，请告诉我，有什么问题？

我没有附上代码，因为这个问题不涉及任何具体错误。用户在其帐户下进入会话以阻止他访问登录页面后，如何在 Django 中实现？在模板中，写 if not request.user.is_authenticated "show" - 好吧，就是这样。一个好的选择通常是在会话中的用户删除此页面时，或者重定向到主页面。

我想获取用户输入的所有文本，但不知道该怎么做：

from tkinter import *

print("Hello, this is Python interpreter\nYou can enter your code in the window.")
# def interpreter(code):
#         pass

interpreter_window = Tk()
interpreter_window.title("Python")

coding = Text(interpreter_window, height=20, width=40)
coding.pack()
# s = coding.get(???)
# print(s)
#??????
interpreter_window.mainloop()