Как получить "центральный прямоугольник" матрицы с заданной шириной и высотой?
Есть
numpy матрица, представляющая серое изображение. Как получить её "центральный прямоугольник" с заданной шириной и высотой?
Пример матрицы/картинки:

10  10  3  234 170 54
142 0   3  231 10  3
10  10  7  230 255 11
59  152 1  204 115 144
10  90  14 243 10  12

Результат для ширины 2 и высоты 3:

3 231
7 230
1 204

попробуйте так:

rows, cols = 3, 2

row_start = a.shape[0] // 2 - rows // 2
col_start = a.shape[1] // 2 - cols // 2
res = a[row_start : row_start + rows, col_start : col_start + cols]

результат:

In [59]: res
Out[59]:
array([[  3, 231],
       [  7, 230],
       [  1, 204]])


Что выполняет данная строка?
<code>
return '%08x%08x%08x%08x%08x' % (h0, h1, h2, h3, h4)
</code>

Возвращает строку из перечисленных переменных, выведя каждую из них в формате
%08x, т.е. в 16-ричном виде (
x), на отображение каждой переменной отводится 8 разрядов, недостающие разряды дополняются нулями (
08).


Какой ответ делать на OPTIONS запрос в CRUD на Django?
У меня есть код, который обрабатывает запросы на django. Он должен отвечать на запросы пользователя.
У него прописаны ответы на POST и GET запросы. Но фронтэнд отправляет options запрос, и он не делает никакого ответа. Что мне прописать?
<code>
@csrf_exempt
def user_api(request, email=""):

    if request.method=="OPTIONS":
        return

    if email == "" and request.method == "GET":
        users = User.objects.all()
        users_serializer = UserSerializer(users, many=True)
        return JsonResponse(users_serializer.data, safe=False)

    elif email == "" and request.method == "POST":
        user_data = JSONParser().parse(request)
        user_serializer = UserSerializer(data=user_data)
        if user_serializer.is_valid():
            user_serializer.save()
            return JsonResponse("New user was created successfully", safe=False)
        else:
            return JsonResponse("Failed to create user", safe=False)

    else:
        # search the specified email and return data in json
        if request.method == "POST":
            try:
                user = User.objects.get(email=email)
                user_serializer = UserSerializer(user, many=False)
                print(user_serializer.data)
                return JsonResponse(user_serializer.data, safe=False)
            except ObjectDoesNotExist:
                return JsonResponse("User does not exists", safe=False)

        elif request.method == "PUT":
            user_data = JSONParser().parse(request)
            user = User.objects.get(email=user_data['email'])  # щоб знати конкретного юзера, інфу якого змінюватимемо
            user_serializer = UserSerializer(user, data=user_data)
            if user_serializer.is_valid():
                user_serializer.save()
                return JsonResponse("User information was updated successfully", safe=False)
            else:
                return JsonResponse("Failed to update user information", safe=False)

        elif request.method == "DELETE":
            user = User.objects.get(email=email)
            user.delete()
            return JsonResponse("User account was deleted successfully", safe=False)
</code>

В
OPTIONS просто возвращайте строку со всеми методами.
И ещё, у вас же куча HTTP-методов в одной функции! Используйте класс с разными методами-обработчиками. Декоратор
csrf_exempt на него вешается через другой декоратор
method_decorator, и можно на метод
dispatch, который вызывается поверх остальных.

class UserView(View):
    allowed_methods = ["options", "get", "put", "post", "delete"]

    @method_decorator(csrf_exempt)
    def dispatch(self, request, *args, **kwargs):
        return super(UserView, self).dispatch(request, *args, **kwargs)

    def options(self, request, id):
        response = HttpResponse()
        response["allow"] = ",".join([self.allowed_methods])
        return response

    def get(self, request, email=""):
        users = User.objects.all()
        users_serializer = UserSerializer(users, many=True)
        return JsonResponse(users_serializer.data, safe=False)

    def put(self, request, email=""):
        user_data = JSONParser().parse(request)
        user = User.objects.get(email=user_data["email"])  # щоб знати конкретного юзера, інфу якого змінюватимемо
        user_serializer = UserSerializer(user, data=user_data)
        if user_serializer.is_valid():
            user_serializer.save()
            return JsonResponse("User information was updated successfully", safe=False)
        else:
            return JsonResponse("Failed to update user information", safe=False)

    def post(self, request, email=""):
        if email == "":
            user_data = JSONParser().parse(request)
            user_serializer = UserSerializer(data=user_data)
            if user_serializer.is_valid():
                user_serializer.save()
                return JsonResponse("New user was created successfully", safe=False)
            else:
                return JsonResponse("Failed to create user", safe=False)

        else:
            # search the specified email and return data in json
            try:
                user = User.objects.get(email=email)
                user_serializer = UserSerializer(user, many=False)
                print(user_serializer.data)
                return JsonResponse(user_serializer.data, safe=False)
            except ObjectDoesNotExist:
                return JsonResponse("User does not exists", safe=False)

    def delete(self, request, email=""):
        user = User.objects.get(email=email)
        user.delete()
        return JsonResponse("User account was deleted successfully", safe=False)

PS: обязательно посмотрите на DRF! Он позволяет значительно сократить объём кода на написание REST API подобного CRUD'a сущностей.


Наследование класса от object
Есть ли какая-то причина для наследования класса от
object?
Я только что нашел код, который делает это, и не могу найти вескую причину, почему.

class MyClass(object):
    # Код класса...

 перевод вопроса Python class inherits object от участника @tjvr

В Python 3, помимо совместимости между Python 2 и 3, нет причин. В Python 2 много причин.
История Python 2.x
В Python 2.x (начиная с версии 2.2) есть два стиля классов в зависимости от наличия или отсутствия
object в качестве базового класса:

классы «классического» стиля не имеют
object в качестве базового класса

>>> class ClassicSpam:      # Нет базовых классов
...     pass
>>> ClassicSpam.__bases__
()

классы «нового» стиля, прямо или косвенно (например, наследуют от встроенного типа) имеют
object в качестве базового класса:

>>> class NewSpam(object):           # напрямую наследуется от object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # косвенно наслудуется от object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,)
>>> IntSpam.__bases__[0].__bases__   # ... потому что int наследуется от object
(<type 'object'>,)

Без сомнения, при написании класса вы всегда захотите использовать классы нового стиля. У этого есть множество преимуществ, перечислю некоторые из них:

Поддержка дескрипторов. В частности, с дескрипторами возможны следующие конструкции:

classmethod: Метод, который в качестве неявного аргумента получает класс вместо экземпляра.
staticmethod: Метод, который не принимает неявный аргумент self в качестве первого аргумента.
свойства с property: Создание функций для получения, установки, и удаления атрибутов.
__slots__: Экономит потребление памяти, а также ускоряет доступ к атрибутам. Конечно, это накладывает ограничения.

Статический метод
__new__: позволяет настраивать создание экземпляров класса.

Порядок разрешения методов (MRO): в каком порядке будут производиться поиск базовых классов класса при попытке определить, какой метод вызывать.

Если вы не наследуетись от
object, забудьте об этом. Здесь можно найти более исчерпывающее описание предыдущих пунктов списка, а также другие преимущества классов «нового» стиля.
Одним из недостатков классов нового стиля является то, что сам класс требует больше памяти. Однако, если вы не создаете много объектов класса, я сомневаюсь, что это будет проблемой.
История Python 3.x
В Python 3 все упрощено. Существуют только классы «нового» стиля (называемые просто классами), поэтому единственная разница при добавлении
object, требуется чтобы бы вы вводили еще 8 символов.
Это:

class ClassicSpam:
    pass

полностью эквивалентно (кроме их имени :-) этому:

class NewSpam(object):
     pass

и этому:

class Spam():
    pass

У всех есть
object в
__bases__.

>>> [object in cls.__bases__ for cls in {Spam, NewSpam, ClassicSpam}]
[True, True, True]

Итак, что нужно делать?
В Python 2: всегда явно наследовуйтесь от
object.
В Python 3: наследуйтесь от
object, если вы пишете код, который пытается быть агностиком Python, то есть он должен работать как в Python 2, так и в Python 3. В противном случае нет, это действительно не имеет значения, поскольку Python вставляет его вместе вас.
 перевод ответа от участника @DimitrisFasarakisHilliard


Найти абзацы, удалить все теги, оставив только название
Задание:

С помощью регулярного выражения написать программу, которая ищет в
тексте все абзацы, удаляет теги и оставляет только текст:

Было:
<p> текст </p>
Стало:
текст

Попытка решения:

import re

input_filename = "../progr.txt"
result_filename = "../result.txt"

input_file = open(input_filename, mode = 'r', encoding = "utf-8")
resultfile = open(result_filename, mode = 'w', encoding = "utf-8")
mytext = input_file.read()

lookfor = r'^(?:(?!^$)[\s\S])+$'
results = re.findall(lookfor, mytext)
rst = re.sub('^(?:(?!^$)[\\s\\S])+$','', results)
print(rst)

Получаю ошибку:

expected string or bytes-like object

Решение:

res = re.sub(r"<p>(.*?)</p>", r"\1", text, flags=re.S)

пояснения регулярного выражения:
(.*?)

круглые скобки обозначают группу захвата ("capturing group"), которую можно использовать в части замены обращаясь к содержимому группы по его порядковому номеру - пример:
r"\1".

. -  точка в регулярных выражениях имеет особый смысл - это шаблон для указания любого единичного символа
знак
* после точки обозначает мультипликатор, повторяющий предшествующий символ или группу ноль или более раз
знак
? после звездочки обозначает нежадный модификатор, указывающий что предыдущий символ/группа повторится ноль или один раз. Это нужно для того, чтобы в группу захвата попало содержимое только одного тега.

Таким образом выражение
re.sub(r"<p>(.*?)</p>", r"\1", text, flags=re.S) будет заменять все найденные подстроки вида
"<p>любой текст</p>" на содержимое тега.
PS если убрать знак вопроса из решения то в группу захвата попадет только одна подстрока от первого вхождения
"<p>" до последнего вхождения
"</p>":

In [72]: re.sub(r"<p>(.*)</p>", r"\1", "prefix <p>first</p>, middle, <p>second</p> suffix", flags=re.S)
Out[72]: 'prefix first</p>, middle, <p>second suffix'

вместо:

In [73]: re.sub(r"<p>(.*?)</p>", r"\1", "prefix <p>first</p>, middle, <p>second</p> suffix", flags=re.S)
Out[73]: 'prefix first, middle, second suffix'


Балансировка (нужно оптимизировать код)
Есть задача, нужно отбалансировать список чисел так, чтобы в итоге вывело минимальную абсолютную разницу.
Нужно ускорить , чтобы можно было быстро посчитать до 10^6 входных чисел.

Входные данные:
n = количество чисел
Количество чисел до n

Пример входа:
6
1 2 3 4 5 6
Выход:
0
Потому что 1 + 2 + 3 + 4 - 5 - 6
Минимальная абсолютная разница = 0

Мой код:

n = int(input())
list_of_nums = list(map(int,input().split()))
minim = 9999999999
for i in range(len(list_of_nums)):
    tmp = abs( sum(list_of_nums[i + 1:]) - sum(list_of_nums[:i+1]) )
    if tmp < minim:
        minim = tmp
print(minim)

если взять ваш код за основу, то

вместо
range(len(list_of_nums)) надо все таки проходить
range(1, len(list_of_nums) - 1)

ваш код из-за вычисления сумм имеет сложность O(n^2), хотя можно уложиться в O(n):

например чтобы получать суммы не надо считать сумму всех элементов слева и справа от
i, а достаточно увеличивать и уменьшать суммы на один элемент
кстати это позволяет избавиться от вашего узкого места с
minim = 9999999999, ведь можно предложить список чисел, значительно больших
9999999999
код:

left = sum(arr[:1])
right = sum(arr[1:])
minim = abs(left - right)

for i in range(1, len(arr) - 1):
    left += arr[i]
    right -= arr[i]

    tmp = abs(left - right)
    if tmp < minim:
        minim = tmp

print(minim)

по идее можно попробовать оптимизировать abs, перейдя к квадратам, но, честно говоря, я не знаю что быстрее, если
abs делается через
if, тогда работа с квадратами быстрее, если через сброс бита знака, то
abs быстрее


Найти элементы, которые больше всех предыдущих элементов
Всем привет, есть задание "Найти элементы, которые больше всех предыдущих элементов списка), никак не могу допереть как обращаться сразу ко всем предыдущим элементам, а не к одному. Подскажите как можно решить это задание.
<code>
import random

newlist = []
testlist = []
a=1
b=300

def list_create():
    for i in range(1, 30):
        newlist.append(random.randint(a,b))

    print(newlist)

list_create()
</code>

import random

newlist = []
testlist = []
a=1
b=300

def list_create():
    for i in range(1, 30):
        newlist.append(random.randint(a,b))

    return newlist

list_ = list_create()
for i in range(1, len(list_)):
    if max(list_[:i]) < list_[i]:
        print(list_[i])

с помощью
list_[:x] перем все предыдущие элементы и находим максимум

более эффективный вариант

import random

newlist = []
testlist = []
a=1
b=300

def list_create():
    for i in range(1, 30):
        newlist.append(random.randint(a,b))

    return newlist

list_ = list_create()
max_ = list_[0]
for el in list_[1:]:
    if max_ < el:
        print(el)
        max_ = el


Как скрипту Python перезапустить самого себя?
Имеется скрипт Python с аргументами на входе. При определённых условиях ему необходимо перезапустить самого себя. Я делаю следующее:

import os
import sys
...
if condition_to_restart == True:
    os.execv(sys.argv[0], sys.argv)

Скрипт пытается перезапуститься, но вылезает ошибка
OSError: [Errno 13] Permission denied
Как скипту с аргументами на Python перезапустить самого себя?

Если коротко - у вас скрипт не отмечен как исполняемый, а в
sys.argv[0] будет именно сам скрипт. Можно указать первым аргументом чтоб запустился питон, и он запустил скрипт:

import os
import sys
...
if condition_to_restart == True:
    os.execv(sys.executable, [sys.executable] + sys.argv)


Как в одном потоке получить данные из других потоков?
Вот мой код, который иллюстрирует проблему:

from threading import Thread
import queue
import time

q = queue.Queue()

class Worker(Thread):
    def __init__(self, name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        if self.name == '0':
            update_tasks()
        else:
            while True:
                task = q.get()
                result = do_work(task)
                if not result:
                    q.put(task)

def update_tasks():
    while True:
        tasks = set(get_new_tasks()) - set(get_completed_tasks) - set(list(q.queue))
        for task in tasks:
            q.put(task)
        time.sleep(10)

def run_threads():
    threads = []
    for i in range(15):
        my_thread = Worker(str(i))
        my_thread.start()
        threads.append(my_thread)
    for thread in threads:
        thread.join()

run_threads()

Я запускаю 15 потоков.
Из них 1 поток я отправляю пополнять количество задач функцией
update_tasks()
А остальные 14 должны решать эти задачи функцией
do_work()
Новые задачи поступают каждые 10 секунд.
При этом, в свежеполученных задачах постоянно приходят те, что уже выполнены.
Поэтому функция
update_tasks() сравнивает свежеполученные задачи с теми, что уже сделаны, и теми, что находятся сейчас в очереди.
А теперь сама проблема:

do_work() решает задачу примерно за 1 минуту и
14 задач, которые сейчас в работе снова поступают в список новых задач. Потому что они еще не появились в списке решенных задач. Но и в
q.queue их уже нет.
Эта конструкция их пропускает:

asks = set(get_new_tasks()) - set(get_completed_tasks) - set(list(q.queue))

Подскажите, пожалуйста, как можно одним потоком получить задачи, которые в это время выполняют другие потоки, для того чтобы избежать повторного выполнения одних и тех же задач?

исходя из вашего кода, зачем вообще проверять выполнение задач в воркерах, не проще ли делать это в update_tasks, она ведь и так знает что отправляла воркерам, а безрезультатные task добавляет сам воркер
<code>
def update_tasks():
    _tasks = set()  # ожидающие выполнения или уже выполненные task

    while True:
        tasks = get_new_tasks() - _tasks  # только новые task

        if tasks:
            _tasks.update(tasks)
            for task in tasks:
                q.put(task)
</code>


Чтение json ответа в Python
Отравляю в PAPI генерируемый запрос.
Получаю ответ в виде JSON данных

id_list_sql =

  {
  "status": "ok",
  "meta": {
    "count": 100
  },
  "data": {
    "56320": {
      "global_rating": 4602,
      "clan_id": null,
      "nickname": "Zoltan",
      "account_id": 56320
    },
    "17925": {
      "global_rating": 10649,
      "clan_id": null,
      "nickname": "Dessa",
      "account_id": 17925
    }
  }
}

response = requests.get(id_list_sql) #открываю ответ
data = response.json()

for item in data['data']:
    global_rating = item['global_rating']
    clan_id123 = item['clan_id']
    nickname = item['nickname']

Ранее я пользовался этой структурой и она работала, а сейчас вылазит ошибка с которой я на долго встрял

Traceback (most recent call last):
global_rating = item['global_rating']
TypeError: string indices must be integers

Прошу объяснить новичку, почему лыжи не едут и как сделать что бы поехали.

Смотрите, в
data['data'] у вас словарь, а при итерации словаря он возвращает ключи, а именно
"56320" и
"17925". У вас же в цикле обработка идет так, как-будто там словари, поэтому и возникает ошибка при обращении к строкам.
Вы писали, что код ранее работал, получается, раньше в
"data" возвращался список (
"data": [{"global_rating": 4602, ...), а теперь там словарь.
Поэтому, как вариант, вы можете сразу список значений словаря запросить через
values (а если нужен и ключ, и значение словаря, то вместо
values используйте
items):

data = response.json()

for item in data['data'].values():
    global_rating = item['global_rating']
    clan_id123 = item['clan_id']
    nickname = item['nickname']

PS.
Без
values у вас было бы так:

for k in data['data']:
    item = data['data'][k]
    global_rating = item['global_rating']
    clan_id123 = item['clan_id']
    nickname = item['nickname']


Как сделать вывод текста из БД в телеграм бота?
Пишу бота на pyTelegramBotAPI. Хочу сделать чтобы человек нажимал на кнопку, и ему выводился текст из базы данных, как это реализовать ? Благодарю за ответ)

# обработчик команды /stat
@bot.message_handler(commands=['stat'])
def stat(message):
    stat_kb = types.InlineKeyboardMarkup()
    stat_kb_total = types.InlineKeyboardButton(text='Всего', callback_data='stat_total')
    stat_kb.add(stat_kb_total)

    bot.send_message(message.chat.id, 'Выберите', reply_markup=stat_kb)

# обработчик inline
@bot.callback_query_handler(func=lambda call: True)
def callback_inline(call):
    if call.data == 'stat_total':
        stat_func(call.message.chat.id, 'stat_total')  # вызов функции

# функция отправки статистики из БД
def stat_func(chat_id, where_call):
    from db_func import select_stat_ticket_type
        if where_call == 'stat_total':
        bot.send_message(chat_id, 'Всего:\n{}'.format(select_stat_ticket_type())

# функция выбора статистики из БД
def select_stat_ticket_type():
    ticket_type_list = ['Э', 'К', 'О', 'В', 'От']

    stat_ticket_type = ''
    for i in ticket_type_list:
        conn = sqlite3.connect(db)
        cursor = conn.execute("SELECT COUNT(row_id) FROM ticket WHERE ticket_type=?", (i,)).fetchone()
        if cursor is None:
            conn.close()
        else:
            conn.close()
            if cursor[0] == 0:
                pass
            else:
                stat_ticket_type = stat_ticket_type + i + ' - ' + str(cursor[0]) + '\n'
    return stat_ticket_type


Поиск анаграммы Python (Оптимизация)
Имеется задание, где нужно найти количество пар анаграмм.Я написал код, с использованием Counter'а, но он работает слишком медленно. Мне нужно , чтобы он до 10 секунд обрабатывал 100.000 слов.
Входные данные:
n - количество слов (от 2 до 10^5)
Каждая новая строка до 'n' слово из 10 латинских букв нижнего регистра.
Пример входа:

5
qwertyuiop
twoplussix
poiuytrewq
plustwosix
poiuqwerty

Пример вывода:
4
Мой код:

def comparing(tmp,stack):
    global counter
    ch = True
    if stack == -999:
        return counter
    for i in range(len(tmp)):
        if Counter(tmp[i]) == Counter(stack):
            counter+=1
            ch = False
    if ch == True:
        tmp.insert(-1,stack)

    counter = 0
n = int(input())
tmp = []
for i in range(n):
    tmp.append(input())

for i in range(n):
    x = tmp.pop(0)
    comparing(tmp,x)
print(comparing([0,0],-999))

Приведённый код многократно считает одно и то же - счётчики букв в слове.
Однако проще отсортировать буквы в каждом слове - получается ключ для поиска, и посчитать одинаковые ключи- да хоть тем же Counter
<code>
from collections import Counter

n = int(input())
cn = Counter()
for i in range(n):
    s = "".join(sorted(input()))
    cn[s] += 1
res = 0
for x in cn:
    t = cn[x]
    res += t*(t-1)//2
print(res)
</code>


Как создать класс словарь?
Есть ли возможность к примеру создать класс
Аdict, который бы работал, как словарь?
т.е. к примеру
Adict[5] = 'test'
Сделать класс, экземпляры, которого будут словарями, сложности не составляет. Надо всего лишь наследоваться от класса
dict. И я подумал, что аналогично можно создать и метакласс, экземпляры, которого будучи классами, тоже работали бы схожим образом, но я не понимаю от чего надо наследоваться и какие методы следует переопределять. Надо ли наследоваться от
dict или метаклассы могут наследоваться только от
type?
Я хоть немного двигаюсь в правильном направлении здесь?:

class ADictMeta(dict):
    def __new__(cls, *args, **kwargs):
        return super().__new__(cls, args, kwargs)

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __getitem__(self, item):
        return self.__dict__[item]

class Adict(metaclass=ADictMeta):
    pass

Заранее спасибо за помощь!

Метакласс должен быть потомком типа
type, по крайней мере, если вы хотите чтобы класс, созданный с таким метаклассом являлся именно классом, а не просто словарем.
А наследоваться от
dict вообще не обязательно, если в качестве хранилища вы используете внутренний словарь класса.

class ADictMeta(type):
    def __setitem__(self, key, value):
        setattr(self, key, value)

    def __getitem__(self, key):
        return getattr(self, key)

class Adict(metaclass=ADictMeta):
    pass

Adict['key'] = 'value'
print(Adict.key) # value

Если же нужно отдельное хранилище, то все равно лучше не наследоваться от
dict, вряд ли множественное наследование здесь пройдет успешно. Для того, чтобы другие объекты воспринимали его как изменяемый словарь, достаточно чтобы он реализовал методы базового класса
MutableMapping

class ADictMeta(type):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.mydict = {}

    def __delitem__(self, key):
        del self.mydict[key]

    def __setitem__(self, key, value):
        self.mydict[key] = value

    def __getitem__(self, key):
        return self.mydict[key]

    def clear(self):
        self.mydict.clear()

    def pop(self, *args, **kwargs):
        return self.mydict.pop(*args, **kwargs)

    def popitem(self):
        return self.mydict.popitem()

    def setdefault(self, *args, **kwargs):
        return self.mydict.setdefault(*args, **kwargs)

    def update(self, *args, **kwargs):
        self.mydict.update(*args, **kwargs)

    def __contains__(self, key):
        return key in self.mydict

    def get(self, *args, **kwargs):
        return self.mydict.get(*args, **kwargs)

    def items(self):
        return self.mydict.items()

    def keys(self):
        return self.mydict.keys()

    def values(self):
        return self.mydict.values()

    def __len__(self):
        return len(self.mydict)

    def __iter__(self):
        return iter(self.mydict)

class Adict(metaclass=ADictMeta):
    pass

Adict['key'] = 'value'
print(dict(Adict)) # {'key': 'value'}
print({**Adict, 'key2': 'value2'}) # {'key': 'value', 'key2': 'value2'}


Ошибка expected string , помогите пожалуйста [закрыт]

Закрыт. Этот вопрос не по теме. Ответы на него в данный момент не принимаются.

 Вопрос вызван проблемой, которая больше не воспроизводится, или опечаткой. Хотя похожие вопросы могут быть уместны на этом сайте, решение для этого вопроса вряд ли поможет будущим посетителям. Обычно можно избежать подобных вопросов написанием и исследованием минимальной программы для воспроизведения проблемы до публикации вопроса.

Закрыт 2 года назад.

                        Улучшить вопрос

<code>
import re

input_filename = "../progr.txt"
result_filename = "../result.txt"

input_file = open(input_filename, mode = 'r', encoding='Latin-1')
resultfile = open(result_filename, mode = 'w', encoding='Latin-1')
mytext = input_file.read()

lookfor = r"[\w,-]+@[A-Za-z-]+\.[\w.]+"

mytext = input_file.read
results = re.findall(lookfor, mytext)

for item in results:
    print(item)
</code>

Вы пытаетесь считать данные из одного и того же файла дважды. Так не работает, в первый раз считали все данные – последующие считывания будут выдавать пустой результат.
Как я понял, вы пытаетесь получить email'ы из файла с помощью регулярки. Если убрать из кода дублирующую строчку

mytext = input_file.read  # <--- убрать вот эту строку
results = re.findall(lookfor, mytext)

то все должно запуститься
По крайней мере с примером

[email protected]
[email protected]
asdlkasdasd

отрабатывает без проблем.


Объединение элементов list(списка) python
Есть список:

a = [[01.01.2020], ['Andre'], [23], [02.01.2020], ['John'], [24], [03.01.2020], ['Sasha'], [25]]

Нужно объединить в один список 3 элемента, в таком виде:

a = [[01.01.2020, 'Andre', 23],
    [02.01.2020, 'John', 24],
    [03.01.2020, 'Sasha', 25]]

Объединял в таком виде:

all=[]
for lst in a:
    for el in lst:
        all.append(el)

Но при этом все элементы добавляются в один список


Изображение в базе данных
Скажите, как в бд sqlite3 можно добавить изображение?
Нашел в интернете код, попробовал вставить сначала число, всё работает.
Но когда пытаюсь сделать то же самое, но с изображением, возникает ошибка:

    cur.execute(query)
sqlite3.OperationalError: near "'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x0.........0>

Есть бд с названием f, в ней таблица с названием foods, в ней колонки:
Name  | Energy | Photo
Пока в колонке Photo указал тип STRING (не знаю какой лучше указывать для изображений)
В колонке Photo хочу добавить фотографию:

import sqlite3

def import_pict_binary(pict_path):
    f = open(pict_path, 'rb')
    pict_binary = f.read()
    return pict_binary

con = sqlite3.connect("f.sqlite")
cur = con.cursor()
binary_pict = import_pict_binary('corn.jpg')
query = "UPDATE foods SET Photo = {} WHERE Name = 'Кукуруза'".format(binary_pict)
cur.execute(query)
con.commit()

Скажите, что я неверно указал в запросе?

Картинку в самой бд лучше не хранить. Обычно делается так. Картинка сохраняется на диск, а в базе прописывается путь. Таким образом картинку ты сможешь показать не выполняя запрос к базе, как минимум.
Если тебе все таки очень надо, то есть 2 варианта

Поле в таблице должно быть байтовым, а картинку ты должен читать как набор байтов.
Поле должно быть строковым, а картинку закодировать в base64

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


Хочу сделать ограничение бота в беседах ВКонтакте. Питон
Авторизируюсь через пользователя. Хочу сделать так, что если пишешь в беседе, к примеру, с идентификатором 1, то работало все, но если в беседе 2, то ничего не писалось. Делаю ограничение через peer_id, питон ругается на reply, хотя он мне нужен. Спасибо за решение проблемы.
Сам код:
<code>
# -*- coding: utf-8 -*-

import vk_api
import requests
from vk_api.longpoll import *
from vk_api.utils import *
from vk_api.keyboard import *

token = "фу"

vk = vk_api.VkApi(token="бе", api_version='5.89')
vk_session = vk_api.VkApi (token=token)
longpoll = VkLongPoll (vk_session)
vk = vk_session.get_api ()

for event in longpoll.listen():
    if event.type == VkEventType.MESSAGE_NEW and event.to_me and event.text:
        if event.text == "Sitis баф атаки" or event.text == "sitis баф атаки" or event.text == "ситис баф атаки"  or event.text == "Ситис баф атаки" :
            if event.from_chat:
                vk.messages.send(
                chat_id=event.chat_id,
                random_id=get_random_id(),

                message='Благословение атаки',
                reply_to=event.message_id
        )
    ```
</code>

Для того, чтоб узнать чат-айди сообщения, необходимо ввести строку message = chat_id
Покажется айди чата, который можно впихнуть в chat_id.


Ошибка типа данных: "ValueError: parameters are of unsupported type"
Есть столбец
guildToken типа
TEXT, и пытаюсь получить из него значение:

pyguild = (ctx.guild.id,)
cur.execute(
    "SELECT guildToken FROM guildsConfig WHERE guildID == ?", (ctx.guild.id))
token = cur.fetchall()

В итоге, ошибка:

Traceback (most recent call last):
  File "C:\Users\Максим\AppData\Local\Programs\Python\Python39\lib\site-packages\discord\ext\commands\core.py", line 85, in wrapped
    ret = await coro(*args, **kwargs)
  File "C:\Users\Максим\Desktop\HelperBotForDiscord-master\helper.py", line 163, in checkDB
    print(cur.execute(
ValueError: parameters are of unsupported type

у вас сразу две ошибки -  двойной знак равенства вместо одинарного и вы передали в качестве параметров скаляр вместо кортежа или списка:
Попробуйте так:
<code>
cur.execute(
    "SELECT guildToken FROM guildsConfig WHERE guildID = ?", (ctx.guild.id, ))
# ERRORs: ---------------------------------------------^  ----------------^^
</code>
PS обратите внимание на запятую после ctx.guild.id - благодаря ней в скобках передаётся кортеж. Если ее убрать, то передаваться будет скалярное значение.


Поиск дружественных чисел
Задача: найти все пары дружественных чисел, меньших 10000. Дружественными называются два числа, если каждое из них равно сумме делителей другого. Равные числа дружественными не считаются.
У меня самого есть 2 кода:

import datetime

a = datetime.datetime.now()

for i in range(1, 10001):
    k = 0
    n = 0
    for x in range(1, i):
        if i % x == 0:
            k += x
    for j in range(1, k):
        if k % j == 0:
            n += j
    if i == n and i < k:
        print(i, k)
print(datetime.datetime.now() - a)

Этот выполняется за 14 с мелочью секунд, но по мне это как-то слишком долго.

import datetime

a = datetime.datetime.now()

for i in range(1, 10001):
    k = sum(filter(lambda x: i % x == 0, range(1, i)))
    n = sum(filter(lambda x: k % x == 0, range(1, k)))
    if i == n and i < k:
        print(i, k)
print(datetime.datetime.now() - a)

Попробовал упростить задачу с помощью анонимных функций и итераторов - на 1 секунду программа выполняется быстрее (что интересно, профайлер Pycharm для первого решения выдает такой же результат (14 сек), но если для второго решения запустить профайлер, то он покажет 27 секунд, а не 13, с чем это связано я не понимаю)
Скорее всего есть решения быстрее, поэтому спрашиваю совета.

Если убрать лишние вычисления и не считать дважды для одного числа, то на моей машине в 3.5 раза быстрее будет:

divsum = [0]*10001

for i in range(1, 10001):
    k = 0
    for x in range(1, 1 + i // 2):
        if i % x == 0:
            k += x
    if k <= 10000:
        divsum[i] = k
        if divsum[k] == i:
            print(i, k)
print(datetime.datetime.now() - a)

А если оптимизировать, считая делители только до корня из числа (парный делитель получить нетрудно), то быстрее в 70 раз:

divsum = [0]*10001

for i in range(1, 10001):
    k = 1
    x = 2
    while  x*x < i:
        if i % x == 0:
            k += x
            k += i//x
        x += 1
    if x*x==i:
        k += x

    if k <= 10000:
        divsum[i] = k
        if k < i and divsum[k] == i:
            print(i, k)


Что такое метаклассы в Python?
Что такое метаклассы в Python и для чего нужно их использовать?
 перевод вопроса What are metaclasses in Python? участника @e-satis

Классы как объекты
Прежде чем разбираться в метаклассах, нужно пройти мастер-классы по Python. Python имеет очень своеобразное представление о том, что такое классы, заимствованное из языка Smalltalk.
В большинстве языков класс - это просто фрагменты кода, которые описывают, как создать объект. Это отчасти верно и в Python:

>>> class ObjectCreator(object):
...       pass
...

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

Но в Python классы это нечто большее. Классы это тоже объекты.
Да, объекты.
Как только вы используете ключевое слово
class, Python выполняет его и создает объект. Данные  создаст в памяти объект с именем «ObjectCreator».

>>> class ObjectCreator(object):
...       pass
...

Этот объект (класс) сам по себе может создавать объекты (экземпляры), и поэтому он является классом.
Но все же это объект, а значит

Вы можете присвоить его переменной
Вы можете скопировать его
Вы можете добавить к нему атрибуты
Вы можете передать его как параметр функции

например:

>>> print(ObjectCreator) # Вы можете распечатать класс, потому что это объект
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # Вы можете передать класс в качестве параметра
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # Вы можете добавлять атрибуты в класс
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # Вы можете назначить класс переменной
>>> print(ObjectCreatorMirror.new_attribute)
foo

Динамическое создание классов
Поскольку классы являются объектами, вы можете создавать их на лету, как и любой объект.
Во-первых, вы можете создать класс в функции, используя
class

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # вернуть класс, а не экземпляр
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # функция возвращает класс, а не экземпляр
<class '__main__.Foo'>
>>> print(MyClass()) # вы можете из этого создать объект
<__main__.Foo object at 0x89c6d4c>

Но это не так динамично, так как вам все равно придется писать весь класс самостоятельно.
Поскольку классы являются объектами, они должны быть созданы чем-то.
Когда вы используете ключевое слово
class, Python создает этот объект автоматически. Но, как и в большинстве случаев в Python, он позволяет делать это вручную.
Помните функцию
type? Старая добрая функция, которая позволяет узнать, к какому типу относится объект:

>>> print(type(1))
<type 'int'>

>>> print(type("1"))
<type 'str'>

>>> print(type(ObjectCreator))
<type 'type'>

>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

Что ж, у
type есть совершенно другие возможности, он также может создавать классы на лету.
type может принимать описание класса как параметры и возвращать класс
(Я знаю, глупо, что одна и та же функция может иметь два совершенно разных использования в зависимости от параметров, которые вы ей передаете. Это проблема из-за обратной совместимости в Python)

type работает следующим образом:

type(name, bases, attrs)

Где:

name: название класса

base: кортеж родительских классов для наследования (может быть пустым)

attrs: словарь, содержащий имена и значения атрибутов

пример:

>>> class MyShinyClass(object):
...       pass

можно создать вручную следующим образом:

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # создать экземпляр из класса
<__main__.MyShinyClass object at 0x8997cec>

Вы заметите, что мы используем «MyShinyClass» как имя класса и как переменную для хранения ссылки на класс. Они могут быть разными, но нет причин усложнять ситуацию.

type принимает словарь для определения атрибутов класса

>>> class Foo(object):
...       bar = True

Можно превратить в:

>>> Foo = type('Foo', (), {'bar':True})

И использовать как обычный класс:

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

И, конечно, вы можете наследовать от него:

>>>   class FooChild(Foo):
...         pass

либо

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar унаследован от Foo
True

В конце концов, вы захотите добавить методы в свой класс. Просто определите функцию с соответствующей сигнатурой и назначьте ее как атрибут.

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True

После динамического создания класса вы можете добавить еще больше методов, точно так же, как добавление методов к нормально созданному объекту класса

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

Вы видите, к чему мы идем: в Python классы - это объекты, и вы можете создавать классы на лету, динамически.
Это то, что делает Python, когда вы используете ключевое слово
class, и он это делает с помощью метаклассов
Что такое метаклассы
Метаклассы - это «материал», который создает классы.
Вы определяете классы для создания объектов, верно?
Но мы узнали, что классы Python - это объекты.
Что ж, метаклассы создают эти объекты. Это классы классов, вы можете изобразить их так:

MyClass = MetaClass()
my_object = MyClass()

Вы видели, что
type позволяет делать что-то вроде этого:

MyClass = type('MyClass', (), {})

Это потому, что функция
type на самом деле является метаклассом.
type - это метакласс, который Python использует для создания всех классов за кулисами.
Теперь вы задаетесь вопросом, какого черта это написано строчными буквами, а не
Type?
Что ж, я думаю, это вопрос согласованности с
str, классом, который создает строковые объекты, и
int с классом, который создает целочисленные объекты.
type - это просто класс, который создает объекты класса.
Вы увидите это, проверив атрибут
__class__.
Все, абсолютно все, в Python является объектом. Сюда входят целые числа, строки, функции и классы. Все они объекты. И все они созданы из класса:

>>> age = 35
>>> age.__class__
<type 'int'>

>>> name = 'bob'
>>> name.__class__
<type 'str'>

>>> def foo(): pass
>>> foo.__class__
<type 'function'>

>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

Теперь, что такое
__class__ у любого
__class__?

>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

Итак, метакласс - это просто материал, который создает объекты класса.
Если хотите, можете назвать это «фабрикой классов».

type - это встроенный метакласс, который использует Python, но, конечно, вы можете создать свой собственный метакласс.
Атрибут metaclass
Метаклассы в Python 2
В Python 2 вы можете добавить атрибут
__metaclass__ при написании класса (синтаксис Python 3 см. В следующем разделе):

class Foo(object):
    __metaclass__ = something... # Что-нибудь
    [...]

Если вы это сделаете, Python будет использовать метакласс для создания класса
Foo.
Осторожно, это сложно.
Сначала вы пишете
class Foo(object), но объект класса
Foo еще не создан в памяти.
Python будет искать
__metaclass__ в определении класса. Если он его найдет, он будет использовать его для создания класса объекта
Foo. Если это не так, он будет использовать
type для создания класса.
Прочтите это несколько раз
Когда вы сделаете это:

class Foo(Bar):
    pass

Python делает следующее:
Есть ли в
Foo атрибут
__metaclass__?
Если да, создайте в памяти объект класса с именем
Foo, используя то, что находится в
__metaclass__.
Если Python не может найти
__metaclass__, он будет искать
__metaclass__ на уровне MODULE и пытаться сделать то же самое (но только для классов, которые ничего не наследуют, в основном классов старого стиля).
Затем, если он вообще не может найти какой-либо
__metaclass__, он будет использовать собственный метакласс
Bar (первого родителя который может быть по умолчанию
type) для создания объекта класса.
Будьте осторожны: атрибут
__metaclass__ не будет унаследован, а метакласс родительского элемента (
Bar.__class__) будет. Если
Bar использовал атрибут
__metaclass__, который создал
Bar с
type() (а не
type.__new__()), подклассы не унаследуют это поведение
Теперь главный вопрос: что можно добавить в
__metaclass__?
Ответ - то, что может создать класс.
А что может создать класс?
type или что-либо, что его подклассы используют
Метаклассы в Python 3
Синтаксис для установки метакласса был изменен в Python 3:

class Foo(object, metaclass=something):
    ...

Т.е. атрибут
__metaclass__ больше не используется, а был превращен в аргумент в списке родительских классов
Однако поведение метаклассов в основном остается неизменным.
Одна вещь, добавленная к метаклассам в Python 3, заключается в том, что вы также можете передавать атрибуты как ключевые слова-аргументы в метакласс, например:

class Foo(object, metaclass=something, kwarg1=value1, kwarg2=value2):
    ...

Прочтите раздел ниже, чтобы узнать, как Python справляется с этим.
Пользовательские метаклассы
Основная цель метакласса, автоматически изменять класс при его создании.
Обычно вы делаете это для API, где хотите создавать классы, соответствующие текущему контексту.
Представьте себе глупый пример, в котором вы решили, что атрибуты всех классов в вашем модуле должны быть написаны в верхнем регистре. Есть несколько способов сделать это, но один из них - установить
__metaclass__ на уровне модуля.
Таким образом, все классы этого модуля будут созданы с использованием этого метакласса, и нам просто нужно указать метаклассу перевести все атрибуты в верхний регистр.
К счастью,
__metaclass__ на самом деле может быть любым вызываемым объектом, он не обязательно должен быть формальным классом (я знаю, что что-то с «class» в его имени не обязательно должно быть классом, поймите… это полезно).
Итак, мы начнем с простого примера, используя функцию.

# метаклассу автоматически передаются те же аргументы
# которые вы обычно передаете в `type`
def upper_attr(future_class_name, future_class_parents, future_class_attrs):
    """
       Вернётся объект класса со списком его атрибутов
       в верхнем регистре.
    """
    # выберим все атрибуты, которые не начинается с '__'
    # и поставим их в верхний регистр
    uppercase_attrs = {
        attr if attr.startswith("__") else attr.upper(): v
        for attr, v in future_class_attrs.items()
    }

    # пусть `type` создаст класс
    return type(future_class_name, future_class_parents, uppercase_attrs)

__metaclass__ = upper_attr # это повлияет на все классы в модуле

class Foo(): # __metaclass__ не будет работать с «объектом»
    # но мы можем определить здесь __metaclass__, чтобы воздействовать только на этот класс
    # и это будет работать с дочерними элементами «объекта»
    bar = 'bip'

Давайте проверим:

>>> hasattr(Foo, 'bar')
False
>>> hasattr(Foo, 'BAR')
True
>>> Foo.BAR
'bip'

Теперь сделаем то же самое, но с использованием реального класса для метакласса:

# помните, что `type` на самом деле является классом вроде `str` и `int`
# так что вы можете унаследовать от него
class UpperAttrMetaclass(type):
    # __new__ - это метод, вызываемый до __init__
    # это метод, который создает объект и возвращает его
    # в то время как __init__ просто инициализирует объект, переданный как параметр
    # вы редко используете __new__, за исключением случаев
    # когда вы хотите контролировать, как объект создаётся
    # здесь созданный объект - это класс, и мы хотим его настроить
    # поэтому мы переопределяем __new__
    # вы можете делать кое-что и в __init__, если хотите
    # при продвинутом использовании нужно также переопределить __call__, но мы не будем делать это
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in future_class_attrs.items()
        }
        return type(future_class_name, future_class_parents, uppercase_attrs)

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

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type(clsname, bases, uppercase_attrs)

Возможно, вы заметили дополнительный аргумент
cls. В этом нет ничего особенного:
__new__ всегда получает класс, в котором он определен, в качестве первого параметра. Точно так же, как у вас есть
self для обычных методов, которые получают экземпляр в качестве первого параметра, или определяющий класс для методов класса.
Но это неправильное ООП. Мы вызываем
type напрямую и не переопределяем и не вызываем родительский
__new__.

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type.__new__(cls, clsname, bases, uppercase_attrs)

Мы можем сделать его еще чище, используя
super, который упростит наследование (потому что, у вас могут быть метаклассы которые наследуются от метаклассов):

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return super(UpperAttrMetaclass, cls).__new__(
            cls, clsname, bases, uppercase_attrs)

Вот и все. Больше в метаклассах больше ничего нет.
Причина сложности кода с использованием метаклассов заключается не в метаклассах, а в том, что вы обычно используете метаклассы для выполнения извращенных вещей, основанных на интроспекции, манипулировании наследованием, переменными, такими как
__dict__ и т.д.
В самом деле, метаклассы особенно полезны для черной магии и, следовательно, для сложных вещей. Но сами по себе они просты:

Перехватить создание класса
Изменить класс
Вернуть измененный класс

Зачем для метаклассов использовать классы, а не функций?
Поскольку metaclass может принимать любые вызываемые объекты, зачем использовать класс, если он явно более сложен?
Для этого есть несколько причин:

Ясные намерение. Когда вы читаете
UpperAttrMetaclass(type), вы знаете, что будет дальше

Вы можете использовать ООП. Метакласс может наследоватся от метакласса, переопределять родительские методы. Метаклассы могут даже использовать метаклассы.

Подклассы класса будут экземплярами его метакласса, если вы укажите метакласс с помощью класса, а не с помощью функции.

Вы можете лучше структурировать свой код. Вы никогда не используете метаклассы для чего-то столь же тривиального, как приведенный выше пример. Обычно это для чего-то сложного. Возможность создавать несколько методов и группировать их в один класс очень полезно для облегчения чтения кода.

Вы можете подключиться к
__new__,
__init__ и
__call__. Это позволит вам делать разные вещи. Даже если обычно вы можете делать все это в
__new__, некоторым людям просто удобнее использовать
__init__.

Они называются метаклассами, черт возьми! Это должно что-то значить!

Зачем использовать метаклассы?
А теперь большой вопрос. Зачем использовать какую-то непонятную функцию, подверженную ошибкам?
Ну, обычно вы этого не делаете:

Метаклассы - это более глубокая магия, и 99% пользователей не должны беспокоиться об этом. Если вы задаетесь вопросом, нужны ли они вам, то нет (люди, которым они действительно нужны, чтобы точно знать, что они им нужны, и не нуждаются в объяснении почему).

Python гуру Tim Peters.
Основной вариант использования метакласса - создание API. Типичным примером этого является Django ORM. Это позволяет вам определить что-то вроде этого:

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

Но если вы сделаете это:

person = Person(name='bob', age='35')
print(person.age)

Он не вернет объект
IntegerField. Он вернет
int и даже может взять его прямо из базы данных.
Это возможно, потому что
models.Model определяет
__metaclass__ и использует некоторую магию, которая превратит
Person, которую вы только что определили с помощью простых операторов, в сложный крючок для поля базы данных.
Django делает что-то сложное простым, предоставляя простой API и используя метаклассы, воссоздавая код из этого API, чтобы делать реальную работу за кулисами.
Последнее слово
Во-первых, вы знаете, что классы - это объекты, которые могут создавать экземпляры.
На самом деле классы сами по себе являются экземплярами метаклассов.

>>> class Foo(object): pass
>>> id(Foo)
142630324

В Python все является объектом, и все они являются экземплярами классов или экземплярами метаклассов.
Кроме
type

type на самом деле является отдельным метаклассом. Это не то, что вы могли бы воспроизвести на чистом Python, это делается путем небольшого мошенничества на уровне реализации.
Во-вторых, метаклассы сложны. Возможно, вы не захотите использовать их для очень простых изменений класса. Вы можете менять классы, используя два разных методы:

monkey patching
Декораторы классов

В 99% случаев, когда вам нужно изменить класс, вам лучше использовать их.
Но в 98% случаев вам вообще не нужно менять класс.
 перевод ответа от участника @e-satis


Как вытащить определенные свойства файла?
Каким образом можно получить определенные(имя, количество страниц, размер в кб, дата изменения файла) свойства(атрибуты) файла(pdf) с помощью модуля os или другого модуля?

Попробуйте этот код для нахождения даты и времени создания файла
<code>
 import os
 import datetime
 def modification_date(filename):
      t = os.path.getmtime(filename)
      return datetime.datetime.fromtimestamp(t)
</code>


Найти самую длинную строку, которая является подстрокой всех слов
Требуется написать программу, которая принимает несколько слов, и нам нужно найти то, которое чаще всего повторяется. Подскажите, есть ли какие-нибудь функции?  А то понятия не имею как это написать
Пример ввода:
Sample Samplin SamplingsFun Saplingdsajisfasfijoi
Пример вывода:
Sampl

Судя по вашему вопросу ваш преподаватель не ждет от вас использование каких-либо "готовых функций". Это классическая задача на алгоритмы. Она сводится к нахождению общей подстроки попарно между всеми имеющимися строками.
Алгоритм примерно такой:

Берете первые 2 слова (обозначим их длины x1 и x2) и строите матрицу (двумерный массив) размером x1+1 на x2+1
Заполняете первый столбец матрицы нулями
Заполняете первую строку матрицы нулями
Заполняете клетки на пересечении разных букв нулями
Заполняете клетки на пересечении одинаковых букв значением равным значению на пересечении двух предыдущих индексов плюс 1 (то есть если сейчас вы смотрите индексы 5 и 7 и в заголовках этих двух индексов одинаковые буквы, то вы берете значение из клетки 4 и 6 и прибавляете к нему 1 и результат записываете в клетку с индексом 5 и 7)

Все пункты с 2 по 5 само собой делаются за один раз в двух вложенных циклах. После чего ваша таблица для первой пары слов готова.

Находите в полученной матрице самое большое число...
...и двигаясь по диагонали от него ( каждый раз уменьшая оба индекса на единицу переписываете посимвольно любой из заголовков матрицы - это и есть повторяющиеся символы в этой паре строк)

В итоге после сравнения первых двух слов у вас есть общая строка для этой пары, третью строку можно уже сравнивать с полученной подстрокой и тем самым уточнить полученный результат и так далее. Но нужно учитывать, что подстрок может оказаться несколько и тогда лучше отслеживать все варианты - лишние в ходе проверок сами должны отсеяться.
P.S.: Задача на столько типовая, что по ней и ей подобным есть целый ворох статей в вики, главное правильно сформулировать вопрос!


Не запускаются несколько потоков в Thread
Не работают несколько потоков, запускается всего один, много вариантов перепробовал, но что то не пойму
<code>
import random, time
from threading import Thread

class Bot:
    def __init__(self, name):
        self.name = name
        self.gold = 1
        Bot.game(self)

    def game(self):
        print(f"у {self.name} | {self.gold} - денег")
        self.gold += Bot.gold(self)
        time.sleep(1)
        Bot.game(self)

    def gold(self):
        return random.randint(1,self.gold)

for i in range(10):
    th = Thread(target=Bot(i))
    th.start()
</code>

Я не разбираюсь в модуле
threading но так у меня все заработало

import random, time
from threading import Thread

class Bot:
    def __init__(self, name):
        self.name = name
        self.gold = 1
        Bot.game(self)

    def game(self):
        print(f"у {self.name} | {self.gold} денег")
        self.gold += Bot.gold(self)
        time.sleep(1)
        Bot.game(self)

    def gold(self):
        return random.randint(1, self.gold)

for i in range(10):
    th = Thread(target = Bot, args = (i, ))
    th.start()


Клавиатура в PyQt5
Есть код. Всё работает, кроме одного.
Как сделал так, чтобы при нажатию клавиш
1 - 6 произовдился звук. Но он не производиться. Производиться только по нажати кнопок в самом окне PyQt.

import sys
from PyQt5 import QtMultimedia, QtCore
from PyQt5.QtGui import QPixmap
from PyQt5.QtWidgets import QWidget, QLabel, QPushButton, QLineEdit, QApplication, QMainWindow
from PyQt5.QtWidgets import QWidget, QTableView, QDialog, QPushButton, QApplication, QVBoxLayout
from PyQt5.QtSql import QSqlDatabase, QSqlTableModel

DB_ALBUMS = 'ALBUMS'
DB_SONGS = 'SONGS'

class Music(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Песни')
        self.setWindowTitle('Список песен')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        db = QSqlDatabase.database(DB_SONGS)
        self.model = QSqlTableModel(self, db)
        self.model.setTable('Songs')

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Albom(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Альбомы')
        self.setWindowTitle('Список альбомов')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        db = QSqlDatabase.database(DB_ALBUMS)
        self.model = QSqlTableModel(self, db)
        self.model.setTable('Albom')

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Guitar(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

        self.db = QSqlDatabase.addDatabase('QSQLITE', DB_ALBUMS)
        self.db.setDatabaseName('Database_ALbom.sqlite')
        self.db.open()

        self.initUI()

        self.db_01 = QSqlDatabase.addDatabase('QSQLITE', DB_SONGS)
        self.db_01.setDatabaseName('Database_Musik.sqlite')
        self.db_01.open()

        self.initUI()

    def initUI(self):
        self.setGeometry(250, 55, 1200, 800)
        self.setWindowTitle('Гитара')

        self.First_button = QPushButton('Первая струна(клавиша 1)', self)
        self.First_button.resize(170, 50)
        self.First_button.move(40, 100)
        self.First_button.clicked.connect(lambda: self._play('D:\\Downloads\\First_str.mp3'))
        self.First_button.setShortcut('1')

        self.Second_button = QPushButton('Вторая струна(клавиша 2)', self)
        self.Second_button.resize(170, 50)
        self.Second_button.move(40, 200)
        self.Second_button.clicked.connect(lambda: self._play('D:\\Downloads\\Second_str.mp3'))
        self.Second_button.setShortcut('2')

        self.Third_button = QPushButton('третья струна(клавиша 3)', self)
        self.Third_button.resize(170, 50)
        self.Third_button.move(40, 300)
        self.Third_button.clicked.connect(lambda: self._play('D:\\Downloads\\Third_str.mp3'))
        self.Third_button.setShortcut('3')

        self.Fourth_button = QPushButton('Четвёртая струна(клавиша 4)', self)
        self.Fourth_button.resize(170, 50)
        self.Fourth_button.move(40, 400)
        self.Fourth_button.clicked.connect(lambda: self._play('D:\\Downloads\\Fourth_str.mp3'))
        self.Fourth_button.setShortcut('4')

        self.Fifth_button = QPushButton('Пятая струна(клавиша 5)', self)
        self.Fifth_button.resize(170, 50)
        self.Fifth_button.move(40, 500)
        self.Fifth_button.clicked.connect(lambda: self._play('D:\\Downloads\\Fifth_str.mp3'))
        self.Fifth_button.setShortcut('5')

        self.Sixth_button = QPushButton('Шестая струна(клавиша 6)', self)
        self.Sixth_button.resize(170, 50)
        self.Sixth_button.move(40, 600)
        self.Sixth_button.clicked.connect(lambda: self._play('D:\\Downloads\\Sixth_str.mp3'))
        self.Sixth_button.setShortcut('6')

        self.Accords_button = QPushButton('список альбомов', self)
        self.Accords_button.resize(200, 100)
        self.Accords_button.move(300, 500)
        self.Accords_button.clicked.connect(self._show_albom)

        self.Songs_button = QPushButton('список песен', self)
        self.Songs_button.resize(200, 100)
        self.Songs_button.move(300, 200)
        self.Songs_button.clicked.connect(self._show_music)

        self.pixmap = QPixmap('12.jpg')
        self.image = QLabel(self)
        self.image.move(650, 2)
        self.image.resize(600, 900)
        self.image.setPixmap(self.pixmap)

    def _play(self, url):
        self.url = QtCore.QUrl.fromLocalFile(url)
        self.content = QtMultimedia.QMediaContent(self.url)
        self.player = QtMultimedia.QMediaPlayer()
        self.player.setMedia(self.content)
        self.player.play()

    def _show_music(self):
        music = Music(self)
        music.refresh()
        music.show()

    def _show_albom(self):
        albom = Albom(self)
        albom.refresh()
        albom.show()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Guitar()
    ex.show()
    sys.exit(app.exec_())

void QWidget::keyPressEvent(QKeyEvent *event)
Этот обработчик событий для события
event может быть повторно реализован в подклассе для получения событий нажатия клавиш для виджета. Виджет должен иметь фокус, чтобы получить событие нажатия клавиши.

import sys
from PyQt5 import QtMultimedia, QtCore
from PyQt5.QtGui import QPixmap
from PyQt5.QtWidgets import QWidget, QLabel, QPushButton, QLineEdit, QApplication, QMainWindow
from PyQt5.QtWidgets import QWidget, QTableView, QDialog, QPushButton, QApplication, QVBoxLayout
from PyQt5.QtSql import QSqlDatabase, QSqlTableModel

DB_ALBUMS = 'ALBUMS'
DB_SONGS = 'SONGS'

class Music(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Песни')
        self.setWindowTitle('Список песен')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        db = QSqlDatabase.database(DB_SONGS)
        self.model = QSqlTableModel(self, db)
        self.model.setTable('Songs')

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Albom(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Альбомы')
        self.setWindowTitle('Список альбомов')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        db = QSqlDatabase.database(DB_ALBUMS)
        self.model = QSqlTableModel(self, db)
        self.model.setTable('Albom')

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Guitar(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

        self.db = QSqlDatabase.addDatabase('QSQLITE', DB_ALBUMS)
        self.db.setDatabaseName('Database_ALbom.sqlite')
        self.db.open()

        self.initUI()

        self.db_01 = QSqlDatabase.addDatabase('QSQLITE', DB_SONGS)
        self.db_01.setDatabaseName('Database_Musik.sqlite')
        self.db_01.open()

        self.initUI()

    def initUI(self):
        self.setGeometry(250, 55, 1200, 800)
        self.setWindowTitle('Гитара')

        self.First_button = QPushButton('Первая струна(клавиша 1)', self)
        self.First_button.resize(170, 50)
        self.First_button.move(40, 100)
        self.First_button.clicked.connect(lambda: self._play('D:\\Downloads\\First_str.mp3'))
        self.First_button.setShortcut('1')

        self.Second_button = QPushButton('Вторая струна(клавиша 2)', self)
        self.Second_button.resize(170, 50)
        self.Second_button.move(40, 200)
        self.Second_button.clicked.connect(lambda: self._play('D:\\Downloads\\Second_str.mp3'))
        self.Second_button.setShortcut('2')

        self.Third_button = QPushButton('третья струна(клавиша 3)', self)
        self.Third_button.resize(170, 50)
        self.Third_button.move(40, 300)
        self.Third_button.clicked.connect(lambda: self._play('D:\\Downloads\\Third_str.mp3'))
        self.Third_button.setShortcut('3')

        self.Fourth_button = QPushButton('Четвёртая струна(клавиша 4)', self)
        self.Fourth_button.resize(170, 50)
        self.Fourth_button.move(40, 400)
        self.Fourth_button.clicked.connect(lambda: self._play('D:\\Downloads\\Fourth_str.mp3'))
        self.Fourth_button.setShortcut('4')

        self.Fifth_button = QPushButton('Пятая струна(клавиша 5)', self)
        self.Fifth_button.resize(170, 50)
        self.Fifth_button.move(40, 500)
        self.Fifth_button.clicked.connect(lambda: self._play('D:\\Downloads\\Fifth_str.mp3'))
        self.Fifth_button.setShortcut('5')

        self.Sixth_button = QPushButton('Шестая струна(клавиша 6)', self)
        self.Sixth_button.resize(170, 50)
        self.Sixth_button.move(40, 600)
        self.Sixth_button.clicked.connect(lambda: self._play('D:\\Downloads\\Sixth_str.mp3'))
        self.Sixth_button.setShortcut('6')

        self.Accords_button = QPushButton('список альбомов', self)
        self.Accords_button.resize(200, 100)
        self.Accords_button.move(300, 500)
        self.Accords_button.clicked.connect(self._show_albom)

        self.Songs_button = QPushButton('список песен', self)
        self.Songs_button.resize(200, 100)
        self.Songs_button.move(300, 200)
        self.Songs_button.clicked.connect(self._show_music)

        self.pixmap = QPixmap('12.jpg')
        self.image = QLabel(self)
        self.image.move(650, 2)
        self.image.resize(600, 900)
        self.image.setPixmap(self.pixmap)

    def _play(self, url):
        self.url = QtCore.QUrl.fromLocalFile(url)
        self.content = QtMultimedia.QMediaContent(self.url)
        self.player = QtMultimedia.QMediaPlayer()
        self.player.setMedia(self.content)
        self.player.play()

# +++ vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
    def keyPressEvent(self, event):
        if event.key() == QtCore.Qt.Key_1:
            self._play('D:\\Downloads\\First_str.mp3')
        elif event.key() == QtCore.Qt.Key_2:
            self._play('D:\\Downloads\\Second_str.mp3')
        elif event.key() == QtCore.Qt.Key_3:
            self._play('D:\\Downloads\\Third_str.mp3')
        elif event.key() == QtCore.Qt.Key_4:
            self._play('D:\\Downloads\\Fourth_str.mp3')
        elif event.key() == QtCore.Qt.Key_5:
            self._play('D:\\Downloads\\Fifth_str.mp3')
        elif event.key() == QtCore.Qt.Key_6:
            self._play('D:\\Downloads\\Sixth_str.mp3')

        super().keyPressEvent(event)
# +++ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    def _show_music(self):
        music = Music(self)
        music.refresh()
        music.show()

    def _show_albom(self):
        albom = Albom(self)
        albom.refresh()
        albom.show()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Guitar()
    ex.show()
    sys.exit(app.exec_())


python telegram bot верно оформить callback_data для Inline Keyboard
Есть список моделей авто:

name_car = ['ГАЗ ГАЗель NEXT (2013 - )', 'УАЗ Patriot, I Рестайлинг 3, 2.7 АКПП (150 л.с.) 4WD 2.7 (2019 - )', 'CHERY Tiggo 4, I Рестайлинг, 2.0 CVT (122 л.с.) 2.0 (2018 - )', 'CHERY TIGGO 8 (2020 - )', 'CHERY Tiggo 7, I, 1.5 AMT (152 л.с.) (2016 - )', 'ISUZU D-Max, II, 3.0d AT (177 л.с.) 4WD (2011 - )', 'ГАЗ СОБОЛЬ (1995 - )', 'JEEP Cherokee, V (KL) Рестайлинг, 2.4 AT (177 л.с.) 4WD (2018 - )', 'JEEP Renegade, I, Trailhawk 2.4 AT (175 л.с.) 4WD (2017 - )', 'JEEP Grand Cherokee, IV (WK2) Рестайлинг, 3.0 AT (238 л.с.) 4WD (2014 - )', 'JEEP Wrangler, IV (JL), 2.0 AT (272 л.с.) 4WD (2017 - )', 'FAW Besturn X40, I, 1.6 AT (108 л.с.) (2019 - )', 'ISUZU D-Max, II Рестайлинг, 3.0d AT (177 л.с.) 4WD (2019 - )', 'FAW Besturn X80, I Рестайлинг, 2.0 AT (142 л.с.) (2018 - )', 'JEEP Compass, II, 2.4 AT (150 л.с.) 4WD (2018 - )', 'УАЗ Patriot, I Рестайлинг 3, 2.7 MT (150 л.с.) 4WD (2018 - )', 'УАЗ ПРОФИ (2017 - )', 'FIAT DOBLO (2018 - )']

Хочу поместить список в кнопки:

if message.text == '🚗 Запись на тест-драйв':
    keyboard = types.InlineKeyboardMarkup()
    for i in name_car:
        button1 = types.InlineKeyboardButton(text=i, callback_data=i)
        keyboard.add(button1)
    bot.send_message(message.chat.id, "Выберите автомобиль из списка:", reply_markup=keyboard)

После этого получаю ошибку:

ERROR - TeleBot: "A request to the Telegram API was unsuccessful. Error code: 400 Description: Bad Request: BUTTON_DATA_INVALID"

Но, если я чуть изменяю код, то всё работает как надо:

if message.text == '🚗 Запись на тест-драйв':
    keyboard = types.InlineKeyboardMarkup()
    for i in name_car:
        button1 = types.InlineKeyboardButton(text=i, callback_data=i[0])
        keyboard.add(button1)
    bot.send_message(message.chat.id, "Выберите автомобиль из списка:", reply_markup=keyboard)

Когда я начинаю проверять, что сохраняется в i, то модели не совпадают с тем, что я нажала в боте:

@bot.callback_query_handler(func=lambda call: True)
def callback_worker(call):
    for i in name_car:
        if call.data == i[0]:
            bot.edit_message_text(chat_id=call.message.chat.id,
                                  message_id=call.message.message_id, text=i)

Подскажите, как оформить более правильно код, чтобы i совпадало абсолютно точно с тем, что нажимает пользователь?

ticket_list = {'power_supply': 'Электроснабжение', 'water_supply': 'Водоснабжение'}

# Создать клавиатуру из словаря
ticket_kb = types.InlineKeyboardMarkup()
if where_call == 'ticket':
    for k, v in ticket_list.items():
        ticket_kb.add(types.InlineKeyboardButton(text=v, callback_data=k))
    return ticket_kb

# Если call.data имеется в словаре (ключ) изменить сообщение подставив значение
@bot.callback_query_handler(func=lambda call: True)
def callback_inline(call):
    if call.data in ticket_list:
       bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id,
                              text='{}\nвыберите объект'.format(ticket_list[call.data]))


Не запускается программа на Qt5. До этого запускалась стабильно, после обновления проблемы начались
Я просто перенес файлы скрипта в новую папку, создал новое окружение и загрузил все зависимости с помощью pip3
При запуске программы пишет вот такую ошибку.
<code>
qt.qpa.plugin: Could not find the Qt platform plugin "xcb" in ""
This application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.
</code>
Как исправить?

Проблема решается командой
<code>
pip install pyqt5-tools
</code>


Почему функция min в Python отрабатывает неправильно?
Нужно получить минимальное значение из tuple за исключением нулей. Написал вот такую функцию:
<code>
print(min(values, key=lambda x: x or max(values)))
</code>
если values=(1, 0, 1, 0), печатает 1, всё правильно, но если values = (0, 1, 0, 1, 1, 0), печатает 0. Подскажите, пожалуйста, в чём может быть проблема?

Так происходит потому, что у нуля вес получается таким же, как и у единицы:

values = (0, 1)

print(0 or max(values))  # 1
print(1 or max(values))  # 1

А функция возвращает первое найденное минимальное значение. Поэтому если 0 идёт раньше, чем 1, то он и возвращается:

The key argument specifies a one-argument ordering function like that
used for list.sort().
If multiple items are minimal, the function returns the first one
encountered.

Я бы на Вашем месте отфильтровал значения, например так:

values = (0, 1)
result = min(x for x in values if x != 0)  # 1


Почему не работает выражение литерал.метод()? [дубликат]

На этот вопрос уже дан ответ здесь:

Почему у целого числа нельзя вызвать метод напрямую?

                                (1 ответ)

Закрыт 2 года назад.

Как я понял, что все данные в языке Python представлены в виде объектов, а объекты создаются, в том числе с помощью литералов. Таким образом,
1 — это литерал объекта класса
int:

>>> type(1)
<class 'int'>

Потом я решил посмотреть методы этого объекта:

>>> dir(1)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

Когда я решил использовать метод
bit_length, получил ошибку:

>>> 1.bit_length()
  File "<stdin>", line 1
    1.bit_length()
      ^
SyntaxError: invalid syntax

Почему?

Потому, что синтаксический анализатор ожидает в этом случае дробную часть числа после точки и воспринимает точку как десятичный разделитель. Это можно обойти, воспользовавшись скобками:

In [21]: (1).bit_length()
Out[21]: 1

или поставив пробел после числа:

In [26]: 1 .bit_length()
Out[26]: 1

Для справки - похожая конструкция работает для вещественных чисел, т.к. второй точки в числе быть не может и анализатор может однозначно определить, что после второй точки идет вызов метода литерала типа
float:

In [22]: 1.23.is_integer()
Out[22]: False


Как сделать из float число int python3
Проблема такая. Есть, например, две переменные, одна из них float, а другая - int или тоже float. И может получиться такое, что при вычислении одного числа из другого получается целое число, например: 2.62 - 1.62 = 1.0
Как убрать этот ноль и точку в конце числа?

для начала надо разобраться для чего удалять
0
превратить число с плавающей запятой в целое можно функцией
int

a = 3.14
b = 2.78

c = int(a - b)

если же выводить на экран без дробной части, то можно использовать функцию
format и вообще представление числа с плавающей запятой как
.0f
если же хочется превращать число с плавающей запятой в целое, только когда оно целое, то можно сделать так:

c = int(c) if c == float(int(c)) else c


Ошибка в коде с библиотекой OpenCV
Пытаюсь обработать картинку в Python. Выдает ошибку. Помогите.

import cv2
import os
img = open('/Users/alex/auto.jpg', "wb")
img = cv2.flip(img, -1) # flip video image vertically

TypeError: Expected Ptr<cv::UMat> for argument 'src'

Вот такая теперь ошибка:

 gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

cv2.error: OpenCV(4.4.0) /private/var/folders/nz/vv4_9tw56nv9k3tkvyszvwg80000gn/T/pip-req-build-9ugsgs06/opencv/modules/imgproc/src/color.simd_helpers.hpp:92: error: (-2:Unspecified error) in function 'cv::impl::(anonymous namespace)::CvtHelper<cv::impl::(anonymous namespace)::Set<3, 4, -1>, cv::impl::(anonymous namespace)::Set<1, -1, -1>, cv::impl::(anonymous namespace)::Set<0, 2, 5>, cv::impl::(anonymous namespace)::SizePolicy::NONE>::CvtHelper(cv::InputArray, cv::OutputArray, int) [VScn = cv::impl::(anonymous namespace)::Set<3, 4, -1>, VDcn = cv::impl::(anonymous namespace)::Set<1, -1, -1>, VDepth = cv::impl::(anonymous namespace)::Set<0, 2, 5>, sizePolicy = cv::impl::(anonymous namespace)::SizePolicy::NONE]'
> Invalid number of channels in input image:
>     'VScn::contains(scn)'
> where
>     'scn' is 1

Попробуйте читать документацию. Изображения для opencv надо открывать через метод
imread:

img = cv2.imread('/Users/alex/auto.jpg')


Вызвать функцию Python и передать значение

def town(message):
    if message.text == 'Москва':
        keyboard = types.ReplyKeyboardMarkup(True,False)
        keyboard.add('Дружбы Народов')
        keyboard.add('Лубянка')
        keyboard.add('Выхино')
        send = bot.send_message(message.chat.id,'Выберите район', reply_markup=keyboard)
        bot.register_next_step_handler(send,next)

Подскажите пожалуйста как при клике на кнопку Дружбы Народов, Лубянка или Выхино вызвать функцию
next и передать в неё к примеру значение 123

@bot.message_handler(content_types=['text'])
def town(message):
    if message.text == 'Москва':
       keyboard = types.ReplyKeyboardMarkup(True,False)
       keyboard.add('Дружбы Народов')
       keyboard.add('Лубянка')
       keyboard.add('Выхино')
       bot.send_message(message.chat.id,'Выберите район', reply_markup=keyboard)

    elif message.text == 'Лубянка':
         msg = bot.send_message(message.chat.id, 'введите текст')
         bot.register_next_step_handler(msg, next)

def next(message):
    print('на предыдущем шаге вы ввели', message.text)

UPD:

def func(message):
    msg = bot.send_message(message.chat.id, 'введите текст')
    bot.register_next_step_handler(msg, func_2, '123')

def func_2(message, value):
    print(message.text)
    print(value)


Как посчитать среднее значение по каждому интервалу и вывести в отдельный DataFrame?
Нужно посчитать среднее значение по каждому интервалу и вывести в отдельный DataFrame.
Имеем:

                              Groups  pairs
Interval
A1        A1-A2; A1-A1; A1-A3; A1-A1      4
A2        A2-A3; A2-A2; A2-A1; A2-A2      4
A3        A3-A2; A3-A2; A3-A1; A3-A3      4
A4                      A4-A3; A4-A4      2
A6                             A6-A4      1
A7                             A7-A8      1
A8               A8-A6; A8-A9; A8-A8      3
A9                      A9-A8; A9-A7      2

Хотим получить:

                              Groups  pairs sred
Interval
A1        A1-A2; A1-A1; A1-A3; A1-A1      4  2951,2
A2        A2-A3; A2-A2; A2-A1; A2-A2      4  3347.65
A3        A3-A2; A3-A2; A3-A1; A3-A3      4  3744.1
A4                      A4-A3; A4-A4      2  4140.55
A6                             A6-A4      1  4933.45
A7                             A7-A8      1  5329.9
A8               A8-A6; A8-A9; A8-A8      3  5726.35
A9                      A9-A8; A9-A7      2  6122.8

Мой код реализации:

import pandas as pd

# Импортирую

excel_file = pd.ExcelFile('example.xlsx')
require_cols = [1]
df = pd.read_excel('example.xlsx', usecols=require_cols)
df_min_max = df.aggregate(['min', 'max'])
my_list = df["Data"].tolist()

# Меняем кол-во интервалов
bins = 9

# Сопоставляем данные с интервалами
df["Interval"] = pd.cut(df["Data"], bins,
                        labels=["A" + str(x) for x in range(1, bins + 1)])
# Разбиваем на группы

df["Interval"] = df["Interval"].astype(str)
df.loc[1:, "Groups"] = df.loc[1:, "Interval"] + "-" + df["Interval"].shift().loc[1:]

res = (df
       .dropna(subset=["Groups"])
       .groupby("Interval")
       ["Groups"]
       .apply(lambda x: x.str.cat(sep="; "))).to_frame()

res["pairs"] = res["Groups"].str.split(";").apply(lambda x: len(x))

# Выводим результаты

print(my_list)
print(df_min_max)
print(res)

Столбцы
pairs,
Group и
sred можно получить одной командой:

res = (df
       .dropna(subset=["Groups"])
       .groupby("Interval")
       .agg(pairs=("Data", "count"),
            Groups=("Groups", lambda x: x.str.cat(sep="; ")),
            sred=("Data", "mean")))

результат:

In [18]: res
Out[18]:
          pairs                      Groups     sred
Interval
A1            4  A1-A2; A1-A1; A1-A3; A1-A1  2898.25
A2            4  A2-A3; A2-A2; A2-A1; A2-A2  3366.75
A3            4  A3-A2; A3-A2; A3-A1; A3-A3  3602.75
A4            2                A4-A3; A4-A4  4026.00
A6            1                       A6-A4  4870.00
A7            1                       A7-A8  5521.00
A8            3         A8-A6; A8-A9; A8-A8  5827.00
A9            2                A9-A8; A9-A7  6158.00


Как в методе класса обозначить пересекаются ли круги или нет(Питон)
Есть код

class Circle:
    def __init__(self, center, radius):
        self.center = center
        self.radius = radius
    def square(self):
        return (3.14 * self.radius**2)

Он принимает координаты центра круга и его радиус, а потом находит площадь круга, его необходимо доработать, добавив ему ещё один метод
def do_intersect, который будет принимать другой объект класса Circle и возвращать True или False в зависимости от того, пересекаются круги или нет. Но как это сделать я не знаю...

понятно что две окружности пересекаются, если расстояние между их центрами меньше суммы их радиусов.
Поэтому ищем гипотенузу и сравниваем.
Наверно координаты идут кортежем, поэтому вынесем их в конец инициализации
<code>
class Circle:
    def __init__(self, radius, *args):
        self.center = args
        self.radius = radius

    def square(self):
        return 3.14 * self.radius ** 2

    def do_intersect(self, other):
        dist = ((self.center[0] - other.center[0]) ** 2 + (self.center[1] - other.center[1]) ** 2) ** 0.5
        return abs(self.radius - other.radius) <= dist <= self.radius + other.radius

circle = Circle(3, 1, 1)
circle2 = Circle(1, 1, 1)
print(circle.do_intersect(circle2))
</code>


Как в kotlin выводить массив без квадратных скобок?
У меня возникла проблема в выводе массива.
Я знаю, что есть в Python аналог вывода массива.
<code>
a = [1, 5, 7]
print(*a) // вывод будет 1 5 7
</code>
Но есть ли способ такой же выводить массив в kotlin.
Через цикл for я знаю как выводить, хочется узнать, есть ли другие способы.

fun main() {
    val arr = arrayOf(1, 5, 7)
    println(arr.joinToString(" "))
}


Почему функция возвращает None в Python? [дубликат]

На этот вопрос уже даны ответы здесь:

Почему из функции возвращается None

                                (2 ответа)

Закрыт 1 год назад.

Мне нужно было решить задачу - Даны три числа. Найдите те два из них, сумма которых наибольшая.
Вроде бы правильно её решил, но код возвращает в место двух максимальных чисел None.
Код:
<code>
a = int(input('Введите первое число: '))
b = int(input('Введите второе число: '))
c = int(input('Введите третье число: '))

def maximum(a, b, c):
    if a > b:
        if a > c:
            if c > b:
                return "Два максимальных элемента: " + str(a) + ", " + str(c)

print(maximum(a, b, c))
</code>
Помогите плз)

Самое короткое решение
<code>
def maximum(*args):
    return sorted(args)[1:]
</code>


PyQT5: 2 базы данных
Есть код. Есть 2 базы данных. Получается открыть только первую(Database_Musik), При нажатию на кнопку про альбомы, открывается пустое окно. Как исправить помогите. Наверное я где-то, что-то одинаково назвал.
<code>
import sys
from PyQt5 import QtMultimedia, QtCore
from PyQt5.QtGui import QPixmap
from PyQt5.QtWidgets import QWidget, QLabel, QPushButton, QLineEdit, QApplication, QMainWindow
from PyQt5.QtWidgets import QWidget, QTableView, QDialog, QPushButton, QApplication, QVBoxLayout
from PyQt5.QtSql import QSqlDatabase, QSqlTableModel

class Music(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Песни')
        self.setWindowTitle('Список песен')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        self.model = QSqlTableModel(self)
        self.model.setTable('Songs') # ('films') !!!

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Albom(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Альбомы')
        self.setWindowTitle('Список альбомов')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        self.model = QSqlTableModel(self)
        self.model.setTable('Albom')

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Guitar(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

        self.db = QSqlDatabase.addDatabase('QSQLITE')
        self.db.setDatabaseName('Database_ALbom.sqlite')
        self.db.open()

        self.initUI()

        self.db_01 = QSqlDatabase.addDatabase('QSQLITE')
        self.db_01.setDatabaseName('Database_Musik.sqlite')
        self.db_01.open()

        self.initUI()

    def initUI(self):
        self.setGeometry(250, 55, 1200, 800)
        self.setWindowTitle('Гитара')

        self.First_button = QPushButton('Первая струна(клавиша 1)', self)
        self.First_button.resize(170, 50)
        self.First_button.move(40, 100)

        self.Second_button = QPushButton('Вторая струна(клавиша 2)', self)
        self.Second_button.resize(170, 50)
        self.Second_button.move(40, 200)

        self.Accords_button = QPushButton('список альбомов', self)
        self.Accords_button.resize(200, 100)
        self.Accords_button.move(300, 500)
        self.Accords_button.clicked.connect(self._show_albom)

        self.Songs_button = QPushButton('список песен', self)
        self.Songs_button.resize(200, 100)
        self.Songs_button.move(300, 200)
        self.Songs_button.clicked.connect(self._show_music)

    def _show_music(self):
        music = Music(self)
        music.refresh()
        music.show()

    def _show_albom(self):
        albom = Albom(self)
        albom.refresh()
        albom.show()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Guitar()
    ex.show()
    sys.exit(app.exec_())
</code>

При подключении к нескольким БД соединениям нужно назначать имена.
А при использовании - указывать конкретную БД.
Я пометил места изменений
# <<<

import sys
from PyQt5 import QtMultimedia, QtCore
from PyQt5.QtGui import QPixmap
from PyQt5.QtWidgets import QWidget, QLabel, QPushButton, QLineEdit, QApplication, QMainWindow
from PyQt5.QtWidgets import QWidget, QTableView, QDialog, QPushButton, QApplication, QVBoxLayout
from PyQt5.QtSql import QSqlDatabase, QSqlTableModel

DB_ALBUMS = 'ALBUMS' # <<<
DB_SONGS = 'SONGS' # <<<

class Music(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Песни')
        self.setWindowTitle('Список песен')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        db = QSqlDatabase.database(DB_SONGS) # <<<
        self.model = QSqlTableModel(self, db) # <<<
        self.model.setTable('Songs') # ('films') !!!

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Albom(QDialog):
    def __init__(self, parent):
        super().__init__(parent)

        self.setWindowTitle('Альбомы')
        self.setWindowTitle('Список альбомов')
        self.setGeometry(250, 55, 800, 400)

        main_layout = QVBoxLayout()

        db = QSqlDatabase.database(DB_ALBUMS) # <<<
        self.model = QSqlTableModel(self, db) # <<<
        self.model.setTable('Albom')

        self.view_films = QTableView()
        self.view_films.setModel(self.model)

        main_layout.addWidget(self.view_films)

        self.setLayout(main_layout)

    def refresh(self):
        self.model.select()

class Guitar(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

        self.db = QSqlDatabase.addDatabase('QSQLITE', DB_ALBUMS) # <<<
        self.db.setDatabaseName('Database_ALbom.sqlite')
        self.db.open()

        self.initUI()

        self.db_01 = QSqlDatabase.addDatabase('QSQLITE', DB_SONGS) # <<<
        self.db_01.setDatabaseName('Database_Musik.sqlite')
        self.db_01.open()

        self.initUI()

    def initUI(self):
        self.setGeometry(250, 55, 1200, 800)
        self.setWindowTitle('Гитара')

        self.First_button = QPushButton('Первая струна(клавиша 1)', self)
        self.First_button.resize(170, 50)
        self.First_button.move(40, 100)

        self.Second_button = QPushButton('Вторая струна(клавиша 2)', self)
        self.Second_button.resize(170, 50)
        self.Second_button.move(40, 200)

        self.Accords_button = QPushButton('список альбомов', self)
        self.Accords_button.resize(200, 100)
        self.Accords_button.move(300, 500)
        self.Accords_button.clicked.connect(self._show_albom)

        self.Songs_button = QPushButton('список песен', self)
        self.Songs_button.resize(200, 100)
        self.Songs_button.move(300, 200)
        self.Songs_button.clicked.connect(self._show_music)

    def _show_music(self):
        music = Music(self)
        music.refresh()
        music.show()

    def _show_albom(self):
        albom = Albom(self)
        albom.refresh()
        albom.show()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Guitar()
    ex.show()
    sys.exit(app.exec_())

P.S.: Не рекомендуется сохранять ссылки на БД. При необходимости получить инстанс соединения используйте
QSqlDatabase.database(db_name), где
db_name - имя подключения к базе.


Pandas массив в Python не сохраняется в csv
Есть  простой код:

 import pandas as pd

 df = pd.read_csv('sample.csv')
 df.to_csv('result.csv')

Выходит ошибка при сохранения массива в csv:

----> 5 df.to_csv('result.csv')

/opt/conda/lib/python3.7/site-packages/pandas/core/generic.py in to_csv(self, path_or_buf, sep, na_rep, float_format, columns, header, index, index_label, mode, encoding, compression, quoting, quotechar, line_terminator, chunksize, date_format, doublequote, escapechar, decimal, errors)
   3143         if verify_is_copy:
   3144             self._check_setitem_copy(stacklevel=5, t='referant')
-> 3145
   3146         if clear:
   3147             self._clear_item_cache()

/opt/conda/lib/python3.7/site-packages/pandas/io/formats/csvs.py in <module>
     14
     15 from pandas._libs import writers as libwriters
---> 16 from pandas.compat import StringIO, range, zip
     17
     18 from pandas.core.dtypes.generic import (

ImportError: cannot import name 'StringIO' from 'pandas.compat' (/opt/conda/lib/python3.7/site-packages/pandas/compat/__init__.py)

Помогла переустановка Pandas через анаконду.


Создать функцию-генератор из списка с изменяющимся инкрементом
Подвох в том, что шаг должен быть 2 вариантов, которые должны чередоваться.
Например:
a=[1,2,3,4,5,6,7,8,9]
step=1 or 2
generator(a,step)
вывод:
[1,2,4,5,7,8]
Важно также прописать условия, чтобы не выходить за границы списка. Я попробовал следущий код:
<code>
def generate_step(a, step):
    a = iter(a)
    step= 1 or 2
    it=iter(range(step))
    while True:
        for x in it:
            for dummy in range(step):
                try:
                    x = next(a)
                except StopIteration:
                    return
            yield x

a = [1, 2, 3, 4, 5, 6, 7]
b = generate_step(a, 2)
print(next(b))
</code>
Выводит только одно число, а не список

У вас какой-то сумбур в коде (такое впечатление, что вы пытались собрать что-то одно из нескольких разных примеров). Все намного проще. Вот сама функция-генератор:
UPDATE изменил на 2 чередующихся шага

def generate_step(data: list, step1: int, step2: int):
    pos = 0
    step_count = True
    while pos < len(data):
        yield data[pos]
        if step_count:
            pos += step1
            step_count = False
        else:
            pos += step2
            step_count = True

А вот так выводим "ленивые" значения:

a = [1, 2, 3, 4, 5, 6, 7]
b = (generate_step(a, 1, 2))
for value in b:
    print(value)

Вывод:

1
2
4
5
7


Подсчитать количество элементов в ячейке dataframe
Имеется такой dataframe:

                        Interval
A1    A1-A2; A1-A1; A1-A3; A1-A1
A2    A2-A3; A2-A2; A2-A1; A2-A2
A3    A3-A2; A3-A2; A3-A1; A3-A3
A4                  A4-A3; A4-A4
A6                         A6-A4
A7                         A7-A8
A8           A8-A6; A8-A9; A8-A8
A9                  A9-A8; A9-A7
Name: x, dtype: object

По каждой группе надо посчитать количество пар
Вот мой кусочек кода:

import pandas as pd
import numpy as np

# Импортируй

excel_file = pd.ExcelFile('example.xlsx')
require_cols = [1]
df = pd.read_excel('example.xlsx', usecols=require_cols)
df_min_max = df.aggregate(['min', 'max'])
my_list = df["Data"].tolist()

# Меняем кол-во интервалов
bins = 9

# Сопоставляем данные с интервалами
interval = pd.cut(np.array(my_list), bins)
iv = df["Interval"] = pd.cut(df["Data"], bins,
                             labels=["A" + str(x) for x in range(1, bins + 1)])
# Разбиваем на группы

df["Interval"] = df["Interval"].astype(str)
df.loc[1:, "x"] = df.loc[1:, "Interval"] + "-" + df["Interval"].shift().loc[1:]

res = (df
       .dropna(subset=["x"])
       .groupby("Interval")
       ["x"]
       .apply(lambda x: x.str.cat(sep="; ")))

# Выводим результаты

print(my_list)
print(interval)
print(df_min_max)
print(iv)
print(res)

Желаемый результат:

                        Interval   пары
A1    A1-A2; A1-A1; A1-A3; A1-A1   4
A2    A2-A3; A2-A2; A2-A1; A2-A2   4
A3    A3-A2; A3-A2; A3-A1; A3-A3   4
A4                  A4-A3; A4-A4   2
A6                         A6-A4   1
A7                         A7-A8   1
A8           A8-A6; A8-A9; A8-A8   3
A9                  A9-A8; A9-A7   2

файл

При df

  Group                    Interval
0    A1  A1-A2; A1-A1; A1-A3; A1-A1
1    A2  A2-A3; A2-A2; A2-A1; A2-A2
2    A3  A3-A2; A3-A2; A3-A1; A3-A3
3    A4                A4-A3; A4-A4
4    A6                       A6-A4
5    A7                       A7-A8
6    A8         A8-A6; A8-A9; A8-A8
7    A9                A9-A8; A9-A7

делаем:

df["pairs"] = df["Interval"].str.split(";").apply(lambda x: len(x))

получаем df:

  Group                    Interval  pairs
0    A1  A1-A2; A1-A1; A1-A3; A1-A1      4
1    A2  A2-A3; A2-A2; A2-A1; A2-A2      4
2    A3  A3-A2; A3-A2; A3-A1; A3-A3      4
3    A4                A4-A3; A4-A4      2
4    A6                       A6-A4      1
5    A7                       A7-A8      1
6    A8         A8-A6; A8-A9; A8-A8      3
7    A9                A9-A8; A9-A7      2

UPDATE
Переписал весь код автора, чтобы получить желаемый результат:

import pandas as pd
import numpy as np

# Импортируй

excel_file = pd.ExcelFile('example.xlsx')
require_cols = [1]
df = pd.read_excel('example.xlsx', usecols=require_cols)
df_min_max = df.aggregate(['min', 'max'])
my_list = df["Data"].tolist()

# Меняем кол-во интервалов
bins = 9

# Сопоставляем данные с интервалами
df["Interval"] = pd.cut(df["Data"], bins,
                             labels=["A" + str(x) for x in range(1, bins + 1)])
# Разбиваем на группы

df["Interval"] = df["Interval"].astype(str)
df.loc[1:, "Groups"] = df.loc[1:, "Interval"] + "-" + df["Interval"].shift().loc[1:]

res = (df
       .dropna(subset=["Groups"])
       .groupby("Interval")
       ["Groups"]
       .apply(lambda x: x.str.cat(sep="; "))).to_frame()

res["pairs"] = res["Groups"].str.split(";").apply(lambda x: len(x))

# Выводим результаты

print(my_list)
print(interval)
print(df_min_max)
print(res)

Теперь у вас в датафрейме
res содержатся нужные вам данные:

                              Groups  pairs
Interval
A1        A1-A2; A1-A1; A1-A3; A1-A1      4
A2        A2-A3; A2-A2; A2-A1; A2-A2      4
A3        A3-A2; A3-A2; A3-A1; A3-A3      4
A4                      A4-A3; A4-A4      2
A6                             A6-A4      1
A7                             A7-A8      1
A8               A8-A6; A8-A9; A8-A8      3
A9                      A9-A8; A9-A7      2


Как разослать сообщения в телеграм боте, имея базу user_id (telebot+sqlite)
Сижу над этим вопросом 2 вечера, не могу понять что надо делать: есть база с id юзеров, как сделать так чтобы по команде в боте осуществлялась рассылка по всем id? Видел похожий вопрос, но он мне никак не помог, к сожалению.
вот отправка на 1 id:
<code>
@bot.message_handler(commands=['dist'])
def dist(message):
    bot.send_message(11111111, message.text[message.text.find(' '):])
</code>
Как сделать отправку по id в базе?

Довольно таки простой вопрос - вам поможет цикл
for :)
Допустим ваша таблица в
sqlite называется -
orders.
Простой пример:

def connecting():
    conn = sqlite3.connect("database.db")
    return conn

@bot.message_handler(commands=['dist'])
def dist(message):
   conn = connecting()
   cursor = conn.cursor()
   cursor.execute("SELECT id FROM orders")
   results = cursor.fetchall()
   for result in results:
       bot.send_message(result[0], message_to_send) # в message_to_send передайте текст любым удобным для вас способом
   conn.close()


Объясните, пожалуйста, строчку
Не могу понять что происходит в этой строчке. Скажите, пожалуйста, можно ли это расписать как-то более подробно в несколько строк? И если да, то как?
<code>
mines = set(tuple(int(i) - 1 for i in input().split()) for _ in range(k))
</code>

mines = set() # создаём объект set
for i in range(k):
    arr = []
    for el in input().split(): #разделяем входные данные по пробелу
        arr.append(int(el) - 1)
    mines.add(tuple(arr)) #превращаем в кортеж и добавляем в mines

print(mines)


Задано список слов. Вывести все гласные буквы, которые не входят ни в какое из слов. Использовать множества)
<code>
str_data=input("Enter string: ")
print("Input data:", str_data)
str_1='aeoyui'
set1=set()
set2=set()
for i in range(len(str_data)):
    if str_data[i] in str_1:
        set2.add(str_data[i])
    else:
       set1.add(str_data[i])

print(" Result:", set1)
</code>
Не могу понять как вывести те гласные буквы, которые не являются в слове, поправьте пожалуйста и если можно объясните)Буду очень благодарен

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

str_data=input("Enter string: ")
print("Input data:", str_data)

vowel='aeoyui'

result = set(vowel) - set(str_data)
print("Result:", result)

Результат:

Enter string: hello, world, hah
Input data: hello, world, hah
Result: {'i', 'y', 'u'}