Uncle_Ragnar's questions

我不知道如何从主机上的 docker 容器执行脚本？

布局是这样的，它有Raspberry-pi（以下简称主机），主机上有一个get_data.py文件，用于从连接到主机的摄像头和温度传感器收集数据。该脚本在收集数据后返回一个 DTO。在本地一切正常，但是如何从 docker 容器中调用 get_data.py 脚本？？？

我真的很感激一个示例 dockerfile。

PS docker-compose.yml - 我还没看。

在推断str相关模型时遇到问题...

有几个模型通过多对多连接：

用户模型

class WSCustomer(models.Model):
first_name = models.CharField('Имя', max_length=255)
    
def __str__(self):
    return self.first_name

对象模型

class WSObject(models.Model):
title = models.CharField('Название', max_length=255)
customer = models.ManyToManyField(WSCustomer, related_name='own_object_customer', verbose_name='Заказчик', blank=True)

def __str__(self):
    return f'Объект: {self.title} | Заказчик: {self.customer}'

结果，在管理面板和模板中，我得到以下信息：

Объект: Объект1 | Заказчик: ws_users.WSCustomer.None

但是如果你查看管理面板，那么客户的str会正常显示

细微差别

模型存在于不同的应用程序中。

我在同一个ws_users应用程序中有一个自定义用户模型和一个客户模型。

class WSUser(AbstractBaseUser):

和客户模型：

class WSCustomer(models.Model):

在settings.py 中，基本用户模型设置为AUTH_USER_MODEL = 'ws_users.WSUser'这可能以某种方式相关吗？此外，如果您创建的 ManyToMany 关系不是通向WSCustomer客户，而是通向WSUser基本用户模型（在str方法中也只返回first_name），那么结果不会改变（（（

任务：创建博客文章时，用户不应填写开始日期和结束日期的字段，而应自动填写当前日期。

问题：如何在字段 DateField 中传递日期？我尝试了很多选项，但没有任何帮助，帖子只是没有保存......

可以使用 DateField 类型的字段进行更简单的操作变体吗？如果你使用 auto_now_add=True Django 会抱怨，因为 此设计已在此模型中使用。

模型.py

beginning_date = models.DateField('Начало события', default=date.today, blank=True)
ending_date = models.DateField('Окончание события', default=date.today, blank=True)

视图.py

if request.method == 'POST':
    new_post_form = NewPostForm(request.POST or None, request.FILES or None)
    if new_post_form.is_valid():
        post = new_post_form.save(commit=False)
        post.author = request.user
        post.beginning_date = date.today
        post.ending_date = date.today
        post.is_blog_post = True
        post.save()

完成models.py

class Post(models.Model):
    title = models.CharField('Название', max_length=255)
    slug = models.CharField('Идентификатор', max_length=255, db_index=True, unique=True)
    content = models.TextField('Пост')
    image = models.ImageField('Обложка', default='post_image.png', upload_to='posts_images', null=True)
    author = models.ForeignKey(VertexUser, related_name='post_author', on_delete=models.CASCADE, verbose_name='Автор')
    views = models.ManyToManyField(VertexUser, related_name='post_views', verbose_name='Просмотры', blank=True)
    like = models.ManyToManyField(VertexUser, related_name='users_post_like', verbose_name='Лайки', blank=True)
    dislike = models.ManyToManyField(VertexUser, related_name='users_post_dislike', verbose_name='Дизлайки', blank=True)
    publication_date = models.DateTimeField('Дата публикации', auto_now_add=True)
    editing_date = models.DateTimeField('Дата редактирования', auto_now=True)
    is_event = models.BooleanField('Событие', default=False)
    beginning_date = models.DateField('Начало события', auto_now_add=True)
    ending_date = models.DateField('Окончание события', auto_now_add=True)
    is_news = models.BooleanField('Новость', default=False)
    is_blog_post = models.BooleanField('Пост', default=False)
    is_edit = models.BooleanField('Отредктированно', default=False)
    on_main = models.BooleanField('На главную', default=False)
    active = models.BooleanField('Опубликованно', default=False)

    def __str__(self):
        return f'{self.title} | Автор: {self.author} | Опубликованно {self.active}'

    def get_absolute_url(self):
        return reverse('post_detail_page', args=[str(self.slug)])

    class Meta:
        verbose_name = 'Пост'
        verbose_name_plural = 'Посты'

有 Django 2.2 和 post 模型。计划这样做：每个帖子都应该有自己的照片画廊。您需要一次批量上传照片，还需要将这些照片绑定到特定的帖子，或者更确切地说绑定到它的模型，以便进一步在模板中对这些照片进行分类等。我什至不知道如何解决这个问题。也许有一些库可以实现这样的功能？

Django 2.2 Python 3.6 填写表格后，评论到达django，但没有存储在数据库中......在同一个应用程序中发布和评论模型。我没有任何追溯。我不明白我忽略了什么和在哪里......

视图.py

def post_detail(request, slug):
    post = Post.objects.get(slug=slug)

    if request.method == 'POST':
        new_comment_form = NewCommentForm(request.POST, instance=post)

        if 'add_comment' in request.POST and new_comment_form.is_valid():
            comment = new_comment_form.save(commit=False)
            comment.post = post
            comment.author = request.user
            comment.content = request.POST.get('content')
            comment.active = True
            comment.save()
    else:
        new_comment_form = NewCommentForm()

    context = {
        'post': post,
        'new_comment_form': new_comment_form,
    }
    template = 'content/post_detail.html'
    return render(request, template, context)

表格.py

class NewCommentForm(forms.ModelForm):

    class Meta:
        model = Comment
        fields = (
            'content',
        )

    def save(self, commit=True):
        comment = super(NewCommentForm, self).save(commit=False)
        comment.content = self.cleaned_data['content']

        if commit:
            comment.save()
        return comment

模型.py

class Comment(models.Model):
    post = models.ForeignKey(Post, related_name='post_comments', on_delete=models.CASCADE, verbose_name='Комментарии')
    author = models.ForeignKey(VertexUser, related_name='comment_author', on_delete=models.CASCADE, verbose_name='Автор')
    content = models.TextField('Содержание', blank=True)
    like = models.PositiveIntegerField('Лайки', default=0, blank=True, null=True)
    dislike = models.PositiveIntegerField('Дизлайки', default=0, blank=True, null=True)
    publication_date = models.DateTimeField('Дата публикации', auto_now=True, null=True)
    active = models.BooleanField('Опубликовано', default=True)

    def __str__(self):
        return f'Автор {self.author} | Опубликовано {self.publication_date}'

    class Meta:
        verbose_name = 'Комментарий'
        verbose_name_plural = 'Комментарии'

感谢您的关注。

有 Django 2.2，Python 3.7，这是构造：

视图.py

def complex_detail(request, slug):
    object = RealObject.objects.get(slug=slug)
    users = RealUser.objects.filter(department=request.user.department)

    context = {
        'object': object,
        'users': users,
    }
    template = 'objects/object_detail.html'
    return render(request, template, context)

模型文件

class RealObject(models.Model):
    title = models.CharField('Название', max_length=128, db_index=True, unique=True)
    slug = models.SlugField('Идентификатор', max_length=128, db_index=True, unique=True, blank=True)
    author = models.ForeignKey(RealUser, related_name='user_objects', on_delete=models.CASCADE, null=True, verbose_name='Менеджер')
    object_type = models.ForeignKey(ObjectType, on_delete=models.CASCADE, verbose_name='Тип объекта')
    active = models.BooleanField('Активен', default=False)

模板.html

  <form action="complex_detail" method="POST">
  {% csrf_token %}
  <select>
    {% for user in users %}
      {% if user.active == True %}
    <option name="{{ user.last_name }}">{{ user.first_name }} {{ user.last_name }}</option>
      {% endif %}
    {% endfor %}
  </select>
   <input type="submit" role="button" value="Назначить" name="apply">
  </form>

模板 (template.html) 有一个小表单，其中包含一个包含部门员工的下拉列表和“分配”按钮。任务是这样的：有必要将对象的作者更改为我们从列表中选择的作者......

感谢您的关注。

更新

视图.py

def complex_detail(request, slug):
    object = RealObject.objects.get(slug=slug)
    users = RealUser.objects.filter(department=request.user.department)
    form = ChangeAuthorObject(request.user.department, request.POST)

    if 'POST' in request.method:
        if form.is_valid():
            form.save()
        else:
            form = ChangeAuthorObject(request.user.department)

    context = {
        'object': object,
        'users': users,
        'form': form,
    }
    template = 'objects/object_detail.html'
    return render(request, template, context)

表格.py

class ChangeAuthorObject(forms.ModelForm):
    class Meta:
        model = RealObject
        fields = (
            'author',
        )

        def __init__(self, department, *args, **kwargs):
            super().__init__(self, *args, **kwargs)
            self.fields['author'].queryset = RealUser.objects.filter(department=department)

模板.html

<form action="complex_detail" method="POST">
          {% csrf_token %}
          {{ form }}
           <input type="submit" role="button" value="Назначить" name="apply">
          </form>

可用： Python 3.7 Django 2.2。用户个人资料页面，页面上有“我的帖子”、“审核帖子”、“网站上的帖子”三个按钮。每个按钮都有一个“名称”属性

任务：单击其中一个按钮时，根据按下的按钮将用户发送到带有过滤帖子的模板。

条件：无论用户按下了三个按钮中的哪一个，都需要根据按下的按钮将他发送到 filter.html 模板放置过滤数据的位置...

我不知道如何传递到按下特定按钮以获取进一步过滤数据的视图...

URLS.PY

from django.urls import path
from .views import *

urlpatterns = [
    path('login/', login_view, name='login'),
    path('logout/', logout_view, name='logout'),
    path('filter/', objects_filter, name='objects_filter'),
    path('<str:email>/', user_detail, name='user_detail'),
    path('', user_list, name='user_list'),
]

意见.PY

def objects_filter(request):
    template = 'objects/objects_filter.html'

    if request.method == 'POST':
        objects = RealObject.objects.filter(author=request.user)

        if request.POST.get('get_all'):
            context = {
                'objects': objects
            }
            return render(request, template, context)
    if request.POST.get('get_active_false'):
        objects = objects.get(active=False)
        context = {
            'objects': objects
        }
        return render(request, template, context)

    if request.POST.get('get_active_true'):
        objects = objects.get(active=True)
        context = {
            'objects': objects
        }
        return render(request, template, context)

return render(request, template)

当然，我明白一切都写得歪歪扭扭的，根本就不行，所以请不要骂人，我只是在学习……

模板.HTML

{% block content %}
    <h1>Добро пожаловать {{ user.first_name }}</h1>

    {% csrf_token %}
    <a class="btn btn-primary" type="submit" href="{% url 'objects_filter' %}" name="get_all" role="button">Все мои объекты <span class="badge badge-light">!!!</span></a>

    <button class="btn btn-primary" type="submit" href="{% url 'objects_filter' %}" name="get_active_false">Мои объекты на модерации <span class="badge badge-light">!!!</span></button>

    <button class="btn btn-primary" type="submit" href="{% url 'objects_filter' %}" name="get_active_true">Мои объекты на сайте <span class="badge badge-light">!!!</span></button>

    <a href="{% url 'new_object' %}">Добавить объект</a>

{% endblock %}

创建自定义用户模型并在管理面板中注册新用户后！！！无法从网站登录，错误 -请输入正确的邮件和密码。两个地方都要注意大小写。

Python 3.7，Django 2.2，站点上不允许用户注册，只能从管理面板并且只能由管理员进行。

MOELS.PY

class UserManager(BaseUserManager):
def create_user(self, email, first_name=None, password=None, is_active=True, 
is_staff=False, is_admin=False):
    if not email:
        raise ValueError('Поле email должно быть заполнено')
    if not password:
        raise ValueError('Неверный пароль')

    user = self.model(
        email=self.normalize_email(email),
        first_name=first_name
    )

    user.set_password(password)
    user.staff = is_staff
    user.admin = is_admin
    user.active = is_active
    user.save(using=self._db)
    return user

def create_staffuser(self, email, first_name=None, password=None):
    user = self.create_user(
        email,
        first_name=first_name,
        password=password,
        is_staff=True
    )
    return user

def create_superuser(self, email, first_name=None, password=None):
    user = self.create_user(
        email,
        first_name=first_name,
        password=password,
        is_staff=True,
        is_admin=True
    )
    return user


class RealUser(AbstractBaseUser):
    first_name = models.CharField('Имя', max_length=120)
    last_name = models.CharField('Фамилия', max_length=120, db_index=True)
    patronymic = models.CharField('Отчество', max_length=120)
    phone_number = models.CharField('Телефон', max_length=15, unique=True)
    email = models.EmailField('Почта', max_length=30, unique=True)
    image = models.ImageField('Фото', default='user.png', upload_to='user_img')
    description = models.TextField('О себе', default='')
    department = models.ForeignKey(UserDepartment, on_delete=models.SET_NULL, null=True, verbose_name='Отдел')
    position = models.ForeignKey(UserPosition, on_delete=models.SET_NULL, null=True, verbose_name='Должность')
    status = models.ForeignKey(UserStatus, on_delete=models.SET_NULL, null=True, verbose_name='Статус')
    active = models.BooleanField('Работает', default=True)
    staff = models.BooleanField(default=False)
    admin = models.BooleanField(default=False)

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name']

    objects = UserManager()

    def __str__(self):
        return f'СОТРУДНИК: {self.first_name} {self.last_name}, ПОЧТА: {self.email}, ТЕЛЕФОН: {self.phone_number}'
        # return self.email

    def get_full_name(self):
        return f'{self.first_name} {self.last_name}, ПОЧТА: {self.email}'
        # return self.email

    def get_short_name(self):
        return f'{self.last_name}, ПОЧТА: {self.email}'
        # return self.email

    def has_perm(self, perm, obj=None):
        return True

    def has_module_perms(self, app_label):
        return True

    @property
    def is_staff(self):
        return self.staff

    @property
    def is_admin(self):
        return self.admin

    @property
    def is_active(self):
        return self.active

    def get_absolute_url(self):
        return reverse('employee_detail', args=[str(self.email)])

    class Meta:
        verbose_name = 'Сотрудник'
        verbose_name_plural = 'Сотрудники'

管理员

from django.contrib.auth.forms import ReadOnlyPasswordHashField
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.contrib import admin
from django import forms
from .models import *

User = get_user_model()


class UserCreationForm(forms.ModelForm):
    password1 = forms.CharField(label='Пароль', widget=forms.PasswordInput)
    password2 = forms.CharField(label='Подтверждение паорля', widget=forms.PasswordInput)

    class Meta:
        model = RealUser
        fields = ('email', 'first_name',)

    def clean_password2(self):
        password1 = self.cleaned_data.get('password1')
        password2 = self.cleaned_data.get('password2')

        if password1 and password2 and password1 != password2:
            raise forms.ValidationError('Пароли не совпадают')

        return password2

    def save(self, commit=True):
        user = super().save(commit=False)
        user.set_password(self.cleaned_data['password1'])

        if commit:
            user.save()

        return user


class UserChangeForm(forms.ModelForm):
    password = ReadOnlyPasswordHashField()

    class Meta:
        model = RealUser
        fields = (
            'email',
            'password',
            'first_name',
            'trainee',
            'manager',
            'head',
            'staff',
            'admin',
        )

        def clean_password(self):
            return self.initial['password']


class UserAdmin(admin.ModelAdmin):
    search_fields = [
        'email',
        'last_name',
    ]

    list_filter = [
        'active',
        'head',
        'manager',
        'trainee',
        'staff',
    ]

    list_display = [
        'first_name',
        'last_name',
        'email',
        'phone_number',
        'active',
        'head',
        'manager',
        'trainee',
        'staff',
        'admin',
    ]

    class Meta:
        model = User


admin.site.register(UserDepartment)
admin.site.register(UserPosition)
admin.site.register(UserStatus)
admin.site.register(RealUser, UserAdmin)
admin.site.register(GuestUser)
admin.site.register(GuestUserStatus)

admin.site.unregister(Group)

登录.HTML

{% extends 'core/index.html' %}

{% block title %}
    Вход в личный кабинет
{% endblock %}

{% block content %}
    <h1>{{ user.first_name }}</h1>
    <div class="content-section">
        <form method="POST">
            {% csrf_token %}
            <fieldset class="form-group">
                <legend class="border-bottom mb-4">
                    Log in
                </legend>
                {{ form.as_p }}
            </fieldset>
            <div class="form-group">
                <button class="btn btn-outline-info" type="submit">
                    Login
                </button>
            </div>
        </form>
    </div>
{% endblock %}

设置.py

***
AUTH_USER_MODEL = 'users.RealUser'
***

我注意到了这一刻（有些东西告诉我这就是问题所在）。如果您进入管理配置文件中的管理面板，则密码将以散列形式显示，并且以文本形式为用户显示：

ADMIN.PY（已更正）

class UserCreationForm(forms.ModelForm):
    password1 = forms.CharField(label='Пароль', widget=forms.PasswordInput)
    password2 = forms.CharField(label='Подтверждение паорля', widget=forms.PasswordInput)

    class Meta:
        model = RealUser
        fields = ('email', 'first_name',)

    def clean_password2(self):
        password1 = self.cleaned_data.get('password1')
        password2 = self.cleaned_data.get('password2')

        if password1 and password2 and password1 != password2:
            raise forms.ValidationError('Пароли не совпадают')

        return password2

    def save(self, *args, **kwargs):
        user = super().save(*args, **kwargs)
        user.set_password(self.cleaned_data['password1'])
        user.save()

        return user

我无法解决这个问题...我有 Django 2.2 Python 3.7 和两个应用程序新闻和用户。有必要在新闻应用程序的Post模型中引用users ...应用程序的User模型中的用户名字段。

新闻模型.py

from users.models import User


class Post(models.Model):
    ****    
    author = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        blank=False,
        default='',
        verbose_name='Автор'
    )

用户模型.py

class User(AbstractBaseUser):

***

username = models.CharField(
    'Имя пользователя',
    max_length=255,
    unique=True,
    db_index=True,
    blank=False,
    default='',
)

***

def __str__(self):
    return f'Пользователь - {self.username}, Почта - {self.email}'

在__str__方法中，我返回用户名和邮件，这是必要的，但在 HTML 模板中，在 {{ post.author }} 变量中，我只需要用户名......问题是，是否有可能得到通过仅在 Post 模型中进行更改，以免在 HTML 模板中使用循环并且仅使用 {{ post.author }} 以及如何做到这一点？

附言

class Post(models.Model):
    ****    
    author = models.ForeignKey(
        User.username,
        on_delete=models.CASCADE,
        blank=False,
        default='',
        verbose_name='Автор'
    )

不起作用：

回溯：ForeignKey 的第一个参数必须是模型、模型名称或字符串“self”

感谢您的关注。

我在玩python，我不明白为什么我不能拉出嵌套字典的内容？任务是这样的：Python 3.7 需要在不使用第三方库的情况下将嵌套字典x的内容分配给变量foo ...

编码：

parsed_data = []
x = []
y = []


for i in range(5):
    a = 'category_title'
    b = 'category_slug'
    x.append({
        'cat_title': a,
        'cat_slug': b,
    })

for z in range(10):
    a = 'product_title'
    b = 'product_article'
    c = 'product_description'
    y.append({
        'prod_title': a,
        'prod_article': b,
        'prod_description': c,
    })

parsed_data.append({
    'categories': x,
    'products': y,
})

foo = parsed_data['categories']

print(foo)

追溯

foo = parsed_data['categories']
TypeError: list indices must be integers or slices, not str

任务是这样的： Django 2.2 有一个已创建的帖子，并且该帖子有评论，您需要“拉出”评论总数并在模板中显示。好吧，因此，有必要使用每个新评论更新此计数器。

这是代码： models.py

class Post(models.Model):
    ...

    comments = models.ForeignKey(
        'Comments', on_delete=models.CASCADE,
        blank=True, default='',
        related_name='post',
        verbose_name='Комментарии'
    )

    ...


class Comments(models.Model):
    author = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        blank=True, default='',
        on_delete=models.DO_NOTHING,
        verbose_name='Автор: '
    )

    content = models.TextField(
        'Комментарий',
        blank=True,
        default=''
    )

    like = models.PositiveIntegerField(
        'Лайк',
        default=0,
        blank=True
    )

    dislike = models.PositiveIntegerField(
        'Дизлайки',
        default=0,
        blank=True
    )

    date_pub = models.DateTimeField(
        'Дата публикации',
        auto_now=True
    )

    def __str__(self):
        return f'Автор: {self.author}, Дата публикации: {self.date_pub}'

视图.py

from django.shortcuts import render
from .models import Post


def index_page(request):
    posts = Post.objects.all()
    context = {
        'posts': posts,
    }
    return render(request, 'news/index.html', context)

样本

{% block content %}
<div class="container">
    {% for post in posts %}
    <div class="card">
        <div class="card-header">
            {{ post.author }}
            <br>
            {{ post.date_pub }}
            <br>
            <br>
            <small>
                Просмотры: <span class="badge">{{ post.view_counter }}</span> |
                Комментарии: <span class="badge">{{ post.comments }}</span>
            </small>
        </div>
        <div class="card-body">
            <h5 class="card-title">{{ post.title }}</h5>
            <p class="card-text">{{ post.content|truncatewords:20 }}</p>
            <div class="mb-3">
                {% if user.is_authenticate %}
                <button type="button" class="btn btn-info btn-sm">
                    Нравится <span class="badge badge-light">{{ post.like }}</span>
                </button>
                <button type="button" class="btn btn-danger btn-sm">
                    Не нравится <span class="badge badge-light">{{ post.dislike }}</span>
                </button>
                {% else %}
                <button type="button" class="btn btn-info btn-sm" disabled>
                    Нравится <span class="badge badge-light">{{ post.like }}</span>
                </button>
                <button type="button" class="btn btn-danger btn-sm" disabled>
                    Не нравится <span class="badge badge-light">{{ post.dislike }}</span>
                </button>
                {% endif %}
            </div>
            <a href="#" class="btn btn-primary">Читать!</a>
        </div>
    </div>
    {% endfor %}
</div>
{% endblock %}

预期结果：

谢谢你。

体内有一个循环，应该调用一个函数，但这个函数的生命周期应该在循环步骤内......所以代码：

class Viking:
    def __init__ (self):
        self.damage = 10
        self.hp = 100

    def crit (self):
        self.damage *= 3

x = Viking()

while True:
    x.hp -= 10
    if x.hp < 30:
        x.crit()

在这里，在这种情况下，x.damage 将始终等于 30，但是如何使它在循环的下一步中 x.damage 再次等于 10，尽管 x.hp -= 10 将继续执行。

一点背景知识：客户有一个位于顶部不深的站点。客户计划通过巧妙地将流量从着陆点重定向到主站点来生成着陆点，以便将主站点提升到搜索引擎的顶部。

是否有可能解决这个问题：在 Bitrix 上有一个主站点（如果重要的话），该站点有一个带有照片的画廊。此外，登陆页面将用Flask 编写，每个页面都有自己的（空）画廊。

任务：有必要在登陆页面上显示主站点的画廊，同时来自登陆页面的流量到主站点......困难在于不使用JS和/或PHP。

它应该是一个框架之类的东西，应该只显示图库，而不是整个页面，好吧，没有 JS 和 PHP，只有 HTML、CSS、Python ......

有一个“程序”，其中有 Viking、Wizzard Assasin 类，然后应该形成两个团队 red_team 和 blue_team。每个团队可以有 3 个成员 dude, dude2, dude3 任务是随机分配类到 dude/2/3 变量。我是这样实现的：

chance = randint (1, 3)
If chance == 1:
    dude = Viking (name = 'Red Viking')
if chance == 2:
    dude = Wizzard (name = 'Red Wizzard')
if chance == 3:
    dude = Assasin  (name = 'Red Assasin')
red_taem.append (dude.name)

chance = randint (1, 3)
If chance == 1:
    dude2 = Viking (name = 'Red Viking')
if chance == 2:
    dude2 = Wizzard (name = 'Red Wizzard')
if chance == 3:
    dude2 = Assasin  (name = 'Red Assasin')
red_team.append (dude2.name)

chance = randint (1, 3)
If chance == 1:
    dude3 = Viking (name = 'Red Viking')
if chance == 2:
    dude3 = Wizzard (name = 'Red Wizzard')
if chance == 3:
    dude3 = Assasin  (name = 'Red Assasin')
red_team.append (dude3.name)

而这种恐怖，只属于一队三人参赛！如果有20个呢？

实际上问题是：如何简化？为了不写10万行代码。

附言 如果您提供解决方案，请向我解释您的解决方案将如何工作。

类：实际上，这里仍然是 beleberd ...

class Viking:
    def __init__(self,  name):
        self.name = name
        self.hp = 100
        self.energy  = 100
        self.damage = 30
        self.block = 15
        self.role = 'tank'

class Assasin:
    def __init__(self, name):
        self.name = name
        self.hp = 100
        self.energy  = 100
        self.damage = 30
        self.block = 15
        self.role = 'ass'

class Wizzard:
    def __init__(self, name):
        self.name = name
        self.hp = 100
        self.energy  = 100
        self.damage = 30
        self.block = 15
        self.role = 'tank'

每个人都很温暖！请帮助一个没有经验的新手！有这样的节目...

p = int (input ('Введите целое, четное число: '))

player_list = [random.choices(string.ascii_uppercase) for i in range(p)]
class_list = [1, 2, 3, 4]
tmp_var_class = random.choices(class_list)

1. 从列表 player_list 我得到一个随机字母；
2. 从 temp_class_list 列表中，随机数；

如何连接它们并从接收到的数据中初始化一个变量（只是让我们不打印，我需要一个直接变量作为对象 O_o））），然后使其成为类继承人？以及如何使如果用户输入一个大数字，player_list 中的字母不重复，但其他小写字母连接到它们，例如？

把整件事都扔进字典里是行不通的。Python不允许将未散列的数据放入字典中......据我了解，连接“for”会帮助我，但我不明白以后如何初始化变量......

正如你所写的那样做了一切：

for _ in range(p):

    player_list = random.sample(string.ascii_uppercase, p)
    class_list = [1, 2, 3, 4]
    tmp_var_class = random.choice(class_list)

    var_name = ''.join(player_list).capitalize()

    globals()[var_name] = tmp_var_class
print ([var_name])

输出打印 = ['Xznqyd']

我 100% 错过了一些非常明显的事情（