Александр

import random


def get_data():
    count_number = int(input('Сколько чисел сгенерировать?: '))
    start_end = input('Введите диапозон через пробел: ').split(" ")
    start = int(start_end[0])
    end = int(start_end[1])
    return count_number, start, end

def random_number_generator(start, end):
    random_number = random.randint(start, end)
    return random_number
def write_numbers_to_list():
    result = []

    count, start, end = get_data()
    for i in range(count):
        result.append(random_number_generator(start, end))
    return "Сгенерированные числа: {0}".format(result)
def print_result():
    rnd = write_numbers_to_list()
    print(rnd)

def main():
    print_result()

if __name__ == '__main__':
    main()

def main():
    numbers = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
    numbers = [number for number in set(numbers)]
    print(numbers)

if __name__ == '__main__':
    main()

from subprocess import Popen
from speech_recognition import (Recognizer, AudioFile)
from speech_recognition import (UnknownValueError, RequestError)


class SpeechOggAudioFileToText:
    def __init__(self):
        self.recognizer = Recognizer()

    def ogg_to_wav(self, file):
        args = ['ffmpeg','-i', file, 'test.wav']
        process = Popen(args)
        process.wait()
    @property
    def text(self):
        AUDIO_FILE = 'test.wav'
        with AudioFile(AUDIO_FILE) as source:
            audio = self.recognizer.record(source)
        try:
            text = self.recognizer.recognize_google(audio, language='RU')
            return text
        except UnknownValueError:
            print("Не удаётся распознать аудио файл")
        except RequestError as error:
            print("Не удалось запросить результаты: {0}".format(error))

def main():
    speech_ogg = SpeechOggAudioFileToText()
    speech_ogg.ogg_to_wav('test.ogg')
    print(speech_ogg.text)

if __name__ == '__main__':
    main()

from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.textinput import TextInput
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.gridlayout import GridLayout
from kivy.uix.label import Label
from kivy.config import Config

Config.set('graphics', 'width', '800')
Config.set('graphics', 'height', '400')
Config.set('graphics', 'resizable', '0')

class ThoughtApp(App):
    def build (self):
        base=(BoxLayout(orientation='vertical'))
        fl=FloatLayout()
        adduser=(Label(text='Добавить участника:',
        pos=(-120,360),
        font_size=22,
        bold=True,
        font_name='C:\Windows\Fonts\calibril.ttf',
        size_hint=(.6,.1)))
        fl.add_widget(adduser)
        self.textinput=(TextInput(multiline=False,
        pos=(225,355),
        size_hint=(.5,.15),
        font_size=16))
        fl.add_widget(self.textinput)
        plusbtn=(Button(size_hint=(27/800,30/800),
        text='+',
        pos=(635,366.5),
        on_press=self.pluspress,
        background_color=[.55,.55,.55,1],
        background_normal=''))
        fl.add_widget(plusbtn)
        base.add_widget(fl)
        self.names_gl=GridLayout(rows=1,)
        base.add_widget(self.names_gl)
        return base
    def pluspress(self, event):
        self.names_gl.add_widget(Button(text=self.textinput.text,
        background_color=[.1,.9,.9,1],
        background_normal=''))
        self.textinput.text=''

if __name__ == '__main__':
    ThoughtApp().run()

from time import sleep
import pyautogui
import keyboard

ENTER = "enter"
ESCAPE = "escape"

def writing_data_file():
    if keyboard.is_pressed(ENTER):
        sleep(0.5)
        cursor_position = pyautogui.position()
        print(cursor_position)
        with open("cursor_position.txt", "a") as file:
            file.write("{0}\n".format(cursor_position))
    if keyboard.is_pressed(ESCAPE):
        quit()

while True:
    writing_data_file()

import sys
from PySide2.QtCore import *
from PySide2.QtGui import *
from PySide2.QtWidgets import *
import cv2 # OpenCV
import qimage2ndarray # for a memory leak


class ThreadCamera(QThread):
    status = True
    changePixmap = Signal(QImage)

    def __init__(self):
        super().__init__()
        self.capture = cv2.VideoCapture(0)

    def setStatus(self, status):
        self.status = status
    def captureRelease(self):
        self.capture.release()

    def run(self):

        while self.status:
            face_cascade = cv2.CascadeClassifier(r'haarcascade_frontalface_default.xml')
            ret, frame = self.capture.read()
            if (ret == True):
                self.capture.set(3,640)
                self.capture.set(4, 480)
                frame = cv2.cvtColor (frame, cv2.COLOR_BGR2RGB)
                gray = cv2.cvtColor (frame, cv2.COLOR_BGR2GRAY)
                faces = face_cascade.detectMultiScale(gray, 1.3, 5)
                for (x,y,w,h) in faces:
                    frame = cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)
                    roi_gray = gray[y:y+h, x:x+w]
                    roi_color = frame[y:y+h, x:x+w]
                image = qimage2ndarray.array2qimage(frame)
                self.changePixmap.emit(image)


class ThreadVideoFile(QThread):
    status = True
    changePixmap = Signal(QImage)

    def __init__(self, path):
        super().__init__()
        self.capture = cv2.VideoCapture(path)
    def set_status(self, status):
        self.status = status
    def captureRelease(self):
        self.capture.release()

    def run(self):

        while self.status:
            face_cascade = cv2.CascadeClassifier(r'haarcascade_frontalface_default.xml')
            ret, frame = self.capture.read()
            if (ret == True):
                self.capture.set(3,640)
                self.capture.set(4, 480)
                frame = cv2.cvtColor (frame, cv2.COLOR_BGR2RGB)
                gray = cv2.cvtColor (frame, cv2.COLOR_BGR2GRAY)
                faces = face_cascade.detectMultiScale(gray, 1.3, 5)
                for (x,y,w,h) in faces:
                    frame = cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)
                    roi_gray = gray[y:y+h, x:x+w]
                    roi_color = frame[y:y+h, x:x+w]
                image = qimage2ndarray.array2qimage(frame)
                self.changePixmap.emit(image)



class Dialog(QDialog):
    def __init__(self, parent):
        super().__init__()
        self.resize(400, 100)
        self.label = QLabel()
        self.label.setText("<center><h1>Выберите действие</h1></center>")

        self.button_open_camera = QPushButton('Камера')
        self.button_open_camera.clicked.connect(parent.open_camera)
        self.button_open_file = QPushButton('Видео файл')
        self.button_open_file.clicked.connect(parent.open_file)

        layout = QVBoxLayout()
        layout.addWidget(self.label)
        layout.addWidget(self.button_open_camera)
        layout.addWidget(self.button_open_file)
        self.setLayout(layout)



class VideoWidget(QWidget):

    def __init__(self):
        super().__init__()
        self.initUI()

        self.thread_camera = ThreadCamera()
        self.thread_video = ThreadVideoFile("videoplayback.mp4")



    @Slot(QImage)
    def setImage (self, image):
        self.label.setPixmap(QPixmap.fromImage(image))

    def initUI(self):
        self.setFixedSize(640, 480)
        self.label = QLabel(self)
        self.label.setText("Загрузите видео")
        self.label.setAlignment(Qt.AlignCenter)
        self.label.installEventFilter(self)
        self.layout = QVBoxLayout(self)
        self.layout.setContentsMargins(0, 0, 0, 0)
        self.layout.addWidget(self.label)
        self.setLayout(self.layout)


    def eventFilter(self, obj, event):
        # Только фильтровать событие label, переписать его поведение,
        # другие события будут проигнорированы
        if obj == self.label:
            # здесь отфильтруйте событие mouse и перепишите его поведение
            if event.type() == QEvent.MouseButtonPress:

                if event.buttons() == Qt.LeftButton:
                    self.dialog = Dialog(self)
                    self.dialog.exec_()
        return False
    def open_file(self):
        if self.thread_video.isRunning() is True:
            self.thread_video.set_status(False)
            self.thread_video.captureRelease()

        self.dialog.hide()
        self.thread_camera.setStatus(False)
        self.thread_camera.captureRelease()

        self.label.setText("Загрузите видео")

        fileDialog = QFileDialog(self)
        supportedMimeTypes = ["video", "*.*"]
        fileDialog.setMimeTypeFilters(supportedMimeTypes)
        moviesLocation = QStandardPaths.writableLocation(QStandardPaths.MoviesLocation)
        fileDialog.setDirectory(moviesLocation)

        if fileDialog.exec_() == QDialog.Accepted:
            self.file = fileDialog.selectedUrls()[0].toDisplayString()
            self.thread_video = ThreadVideoFile(self.file)
        self.thread_video.changePixmap.connect(self.setImage)
        self.thread_video.start()


    def open_camera(self):
        self.dialog.hide()

        self.thread_video.set_status(False)
        self.thread_video.captureRelease()
        self.label.setText("Загрузите видео")

        self.thread_camera = ThreadCamera()
        self.thread_camera.changePixmap.connect(self.setImage)
        self.thread_camera.start()


def main():
    app = QApplication([])
    video_widget = VideoWidget()
    video_widget.show()
    sys.exit(app.exec_())

if __name__ == '__main__':
    main()

#ifndef PERSON_H
#define PERSON_H

#include <string>

using namespace std;

namespace person{
    class CppPerson{
        public:
            string name;
            int age;
            CppPerson();
            CppPerson(const string &name, const int &age);
            ~CppPerson();
            void setName(const string &name);
            string getName();
            int getAge();
    };
}
#endif

#include <string>
#include "Person.hpp"


namespace person{
    CppPerson::CppPerson(){}

    CppPerson::CppPerson(const string &name, const int &age){
        this->name = name;
        this->age = age;
    }
    CppPerson::~CppPerson(){}

    void CppPerson::setName(const string &name){
        this->name = name;
    }

    string CppPerson::getName(){
        return name;
    }

    int  CppPerson::getAge(){
        return age;
    }
}

from libcpp.string cimport string

cdef extern from "Person.hpp" namespace "person":
    cdef cppclass CppPerson:
        CppPerson(string name, int age) except +
        void setName(string name)
        string getName()
        int getAge()


cdef class Person:
    cdef CppPerson *cpp_person

    def __cinit__(self, name, age):
        self.cpp_person = new CppPerson(name.encode(), age)
        if self.cpp_person == NULL:
            raise MemoryError('Not enough memory.')

    def __dealloc__(self):
        del self.cpp_person
    def setName(self, name):
        self.cpp_person.setName(name.encode())
    def getName(self):
        return self.cpp_person.getName().decode()
    def getAge(self):
        return self.cpp_person.getAge()

from distutils.core import setup, Extension
from Cython.Build import cythonize

setup(ext_modules = cythonize(Extension(
           "person_module",                                                 # the extesion name
           sources=["person_module.pyx", "Person.cpp"],     # the Cython source and
                                                                                       # additional C++ source files
           language="c++",                                                   # generate and compile C++ code
      )))

from person_module import Person

def main():
    alexandr = Person("Александр", 35)
    print(alexandr.getName())
    print(alexandr.getAge())

if __name__ == '__main__':
    main()

# Python 3.7+
import asyncio

async def hello_world():
    await asyncio.sleep(3)
    print('Hello World!')

asyncio.run(hello_world())

from threading import Timer

def hello_world():
    print('Hello World!')

timer = Timer(3, hello_world)
timer.start()
timer.join()

# Python 3.7+
import asyncio
from threading import Timer

async def hello_world():
    await asyncio.sleep(3)
    print('Hello World!')

def wait():
    asyncio.run(hello_world())

timer = Timer(3, wait)
timer.start()
timer.join()

from tkinter import Tk, Button, mainloop
from vlc import MediaPlayer

URL = "https://str2.pcradio.ru/Eminem-med"


class Player(Tk):
    def __init__(self):
        print("Инициализация Player")
        self.player = MediaPlayer()
        super().__init__()

        self.button = Button(self, text="Воспроизвести файл из интернета")
        self.button.configure(command=self.play)
        self.button.pack()

        self.protocol("WM_DELETE_WINDOW", self.on_closing)

    def play(self):
        return self.player.play()
    def set_mrl(self, mrl):
        return self.player.set_mrl(mrl)

    def on_closing(self):
        self.player.stop()
        del self.player
        self.destroy()


class TkPlayer(Player):
    pass

def main():
    tk_player = TkPlayer()
    tk_player.set_mrl(URL)
    tk_player.mainloop()

if __name__ == '__main__':
    main()