Разное

Программы на питоне пример: Примеры программ | Python 3 для начинающих и чайников

Содержание

Пишем 3 программы на Python за пару минут / itProger

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

#1 — Перемещение файлов

Первая программа будет трансфером для файлов. Её можно применять для автоматической сортировки файлов по папкам. К примеру, через Питон программу вы отслеживаете тип файла что попал в папку «Загрузки» и далее программа автоматически перемещает файл в папку музыка, фото, программы и так далее в зависимости от типа самого файла.

Для выполнения такой программы сперва подключите библиотеку «watchdog»:

pip install watchdog

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

# Подключение всех модулей
from watchdog.observers import Observer
import os
import time
# FileSystemEventHandler - класс по отслеживанию изменений
from watchdog.events import FileSystemEventHandler


# Создаем класс наследник, через него может отслеживать изменения в папках
class Handler(FileSystemEventHandler):
	# При любых изменениях в папке, мы перемещаем файлы в ней
	def on_modified(self, event):
		# Перебираем все файлы в папке folder_track
		for filename in os.listdir(folder_track):
			# Проверяем расширенеи файла
			extension = filename.split(".")
			# Если это фото,
			if len(extension) > 1 and (extension[1].lower() == "jpg" or extension[1].lower() == "png" or extension[1].lower() == "svg"):
				# то перемещаем файл в папку с фото
				file = folder_track + "/" + filename
				new_path = folder_dest + "/Photos/" + filename
				os.rename(file, new_path)
			# Если файл видео, то в папку с видео
			# Такое же можно прописать и для других расширений файлов
			elif len(extension) > 1 and extension[1].lower() == "mp4":
				file = folder_track + "/" + filename
				new_path = folder_dest + "/Videos/" + filename
				os.rename(file, new_path)


# Папка что отслеживается
folder_track = '/ПОЛНЫЙ_ПУТЬ_К_ВАШЕЙ_ПАПКЕ'
# Папка куда перемещать будем
folder_dest = '/ПОЛНЫЙ_ПУТЬ_К_ВАШЕЙ_ПАПКЕ'

# Запуск всего на отслеживание
handle = Handler()
observer = Observer()
observer.schedule(handle, folder_track, recursive=True)
observer.start()

# Программа будет срабатывать каждые 10 милисекунд 
try:
	while(True):
		time.sleep(10)
except KeyboardInterrupt:
	observer.stop()

observer.join()
#2 — Создание сервера

Наша вторая программа будет представлять из себя полноценный сервер, созданный с использованием лишь Python, без дополнительных фреймворков, по типу Django или Flask.

Что очень круто, так это то, что такой сервер можно создать используя лишь встроенные модули Python. Для этого импортируем из http.server два необходимых классах. Далее указываем «localhost» и порт по которому будем подключаться и создаем объект на основе HTTPServer. После этого запускаем сервер на постоянное выполнение.

from http.server import HTTPServer, CGIHTTPRequestHandler
server_data = ("localhost", 8080)
server = HTTPServer(server_data, CGIHTTPRequestHandler)
server.serve_forever()

Также можно добавить файл «index.html» и прописать в нем всю разметку. На странице сервера будет отображаться содержимое из этого файла.

#3 — Управление браузером

Первое что необходимо сделать, так это установить «Selenium» через терминал: 

pip install selenium

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

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

from selenium import webdriver
browser = webdriver.Chrome('/ПУТЬ_К_ПАПКЕ_С_ДРАЙВЕРОМ/chromedriver')
browser.get("https://itproger.com")
Видео на эту тему

Также вы можете просмотреть детальное видео по разработке всех этих трёх программ:

Дополнительный курс

На нашем сайте также есть углубленный курс по изучению языка Питон. В ходе огромной программы вы изучите не только язык Питон, но также научитесь создавать веб сайты за счёт веб технологий и фреймворка Джанго. За курс вы изучите массу нового и к концу программы будете уметь работать с языком Питон, создавать на нём полноценные ПК приложения на основе библиотеки Kivy, а также создавать веб сайты на основе библиотеки Джанго.

Программа-мечта начинающего питоновода / Хабр

Практически любой начинающий программист на Python патологически старается написать свой чат. А если еще и с GUI, то эта прорамма является просто пределом мечтаний.

Что-то вроде введения

Для начала введем в нашу задачу насколько условностей — пишем мы чат для локальной сети с разрешенными широковещательными UDP-пакетами. Для простоты решения задачи так же решим, что в качестве GUI будем использовать библиотеку Tkinter(обычно в дистрибьютивах Linux она идет из коробки, так же и в официальной сборке Python под Windows она является стандартной).

Запитоним сеть

Работа с сокетами в питоне не зависит от платформы(по большому счету даже под PyS60 мы получим рабочий сетевой код, по этому примеру).

Для нашего чата мы решили использовать широковещательные UDP-пакеты. Одной из причин их использования была возможность отказаться от использования сервера. Необходимо принять еще одну условность в нашей программе — номер порта, и пусть он будет равен 11719, во первых, это простое число(а ведь это уже многое). А, во вторых, этот порт, по официальной информации IANA, не занят.

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

import socket

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.bind(('0.0.0.0',11719))
while 1:
	message = s.recv(128)
	print (message)

У сокета мы выставили свойства SO_REUSEADDR(позволяет нескольким приложениям «слушать» сокет) и SO_BROADCAST(указывает на то, что пакеты будут широковещательные) в значние истины. На самом деле на некоторых системах возможна работа скрипта и без этих строчек, но все же лучше явно указать эти свойства.

На прослушку мы подключаемся к адресу ‘0.0.0.0’ — это означает, что прослушиваются вообще все интерфейсы. Можно указывать в поле адреса и просто пустые кавычки, но все же лучше явно указать адрес.

Так же создадим широковещательную «засиралку» сети(для проверки первой программы):

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
while 1:
	sock.sendto('broadcast!',('255.255.255.255',11719))

В отношении же передающей части, необходима лишь только опция SO_BROADCAST(зато теперь обязательна на всех платформах) и с помощью метода sendto() мы рассылаем по всей сети наши пакеты. Остановив с помощью CTRL+C сетевой флуд перейдем к описанию интерфейса.

Окна, окна, окна

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

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

from Tkinter import *

tk=Tk()
tk.title('MegaChat')
tk.geometry('400x300')
tk.mainloop()

Все бы ничего, но мы создаем, не галерею окон разных размеров, а чат. А значит нам нужны на окне еще и элементы — лог чата, поле, где мы укажем свой ник и текст сообщения, который мы вводим. Без кнопки отправить можно обойтись, если наше поле для сообщения будет само реагировать на нажатие клавиши Enter.

Решение проблемы проще, чем кажется. Для лога чата можно использовать виджет Text, а для двух остальных Entry. Для того, чтобы разместить элементы на форме мы используем автоматический компоновщик pack, который будет известным только ему способом расставлять элементы, придерживаясь только явноуказанных указаний. Однако, ему можно указать сторону к которой крепить виджеты, расширять ли их и в какую сторону, и еще некоторые параметры компоновки.

from Tkinter import *

tk=Tk()
tk.title('MegaChat')
tk.geometry('400x300')
log = Text(tk)
nick = Entry(tk)
msg = Entry(tk)
msg.pack(side='bottom', fill='x', expand='true')
nick.pack(side='bottom', fill='x', expand='true')
log.pack(side='top', fill='both',expand='true')
tk.mainloop()

А что же до связи интерфейса с данными программы? Или как заставить в фоне выполняться какую-нибудь процедуру? Ну Entry можно связать с StingVar’ами(указав в конструкторе виджетов свойство textvariable). а для запуска фоновой процедуры есть у Tkinter’а метод after(<время в мс>,<функция>). Если в конце исполнения этой процедуры указать переинициализацию ее, то процедура будет выполняться постоянно, пока запущена программа.

Несколько нажатий клавиш и мы получаем:

from Tkinter import *

tk=Tk()

text=StringVar()
name=StringVar()
name.set('HabrUser')
text.set('')
tk.title('MegaChat')
tk.geometry('400x300')

log = Text(tk)
nick = Entry(tk, textvariable=name)
msg = Entry(tk, textvariable=text)
msg.pack(side='bottom', fill='x', expand='true')
nick.pack(side='bottom', fill='x', expand='true')
log.pack(side='top', fill='both',expand='true')

def loopproc():
	print ('Hello '+ name.get() + '!')
	tk.after(1000,loopproc)

tk.after(1000,loopproc)
tk.mainloop()

В консоли забегало приветствие. Меняя ник мы можем убедится, что связь между полем Entry и нашей переменной работает идеально. Самое время реализовать возможность передачи пользователем своего сообщения в программу по нажатию на Enter. Реализуется это еще проще, с помощью метода bind(<действие>, <функция>) у виджетов. Единственное, что нам нужно учесть, что функция должна принимать параметр event. За одно перенесем с консоли действие в поле лога. Получаем:

from Tkinter import *

tk=Tk()

text=StringVar()
name=StringVar()
name.set('HabrUser')
text.set('')
tk.title('MegaChat')
tk.geometry('400x300')

log = Text(tk)
nick = Entry(tk, textvariable=name)
msg = Entry(tk, textvariable=text)
msg.pack(side='bottom', fill='x', expand='true')
nick.pack(side='bottom', fill='x', expand='true')
log.pack(side='top', fill='both',expand='true')

def loopproc():
	log.insert (END,'Hello '+ name.get() + '!\n')
	tk.after(1000,loopproc)

def sendproc(event):
	log.insert (END,name.get()+':'+text.get()+'\n')
	text.set('')

msg.bind('<Return>',sendproc)
tk.after(1000,loopproc)
tk.mainloop()
Почти готово…

И кажется, что осталось объединить программы из первой и второй частей статьи и мы получим готовый чат. Что ж, попробуем. Однако сразу скажу, что специально выводить сообщения, которые мы отправляем не будем — так как при прослушивании широковещательного трафика мы их и так получим.

import socket
from Tkinter import *

tk=Tk()

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.bind(('0.0.0.0',11719))

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,1)

text=StringVar()
name=StringVar()
name.set('HabrUser')
text.set('')
tk.title('MegaChat')
tk.geometry('400x300')

log = Text(tk)
nick = Entry(tk, textvariable=name)
msg = Entry(tk, textvariable=text)
msg.pack(side='bottom', fill='x', expand='true')
nick.pack(side='bottom', fill='x', expand='true')
log.pack(side='top', fill='both',expand='true')

def loopproc():
	message = s.recv(128)
	log.insert(END,message)
	tk.after(1,loopproc)

def sendproc(event):
	sock.sendto (name.get()+':'+text.get(),('255.255.255.255',11719))
	text.set('')

msg.bind('<Return>',sendproc)
tk.after(1,loopproc)
tk.mainloop()

Однако, чуда не произошло. Программа намертво встала в ожидании входящего пакета. Фоновый поток оказался не таким уж и фоновым и для продолжения выполнения остальной программы он должен иногда завершаться. Чтобы это происходило слушающий сокет необходимо перевести в неблокирующий режим и для того, чтобы мы не получали сообщение об ошибке когда в сокете пусто оградим этот кусок кода try’ем.

import socket
from Tkinter import *

tk=Tk()

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.bind(('0.0.0.0',11719))

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,1)

text=StringVar()
name=StringVar()
name.set('HabrUser')
text.set('')
tk.title('MegaChat')
tk.geometry('400x300')

log = Text(tk)
nick = Entry(tk, textvariable=name)
msg = Entry(tk, textvariable=text)
msg.pack(side='bottom', fill='x', expand='true')
nick.pack(side='bottom', fill='x', expand='true')
log.pack(side='top', fill='both',expand='true')

def loopproc():
	s.setblocking(False)
	try:
		message = s.recv(128)
		log.insert(END,message+'\n')
	except:
		tk.after(1,loopproc)
		return
	tk.after(1,loopproc)
	return

def sendproc(event):
	sock.sendto (name.get()+':'+text.get(),('255.255.255.255',11719))
	text.set('')

msg.bind('<Return>',sendproc)
tk.after(1,loopproc)
tk.mainloop()
«А после доработать напильником…»

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

# -*- coding: utf-8 -*- 

import socket
from Tkinter import *

#Решаем вопрос с кирилицей
reload(sys)
sys.setdefaultencoding('utf-8')
#-----------------------------

tk=Tk()

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.bind(('0.0.0.0',11719))

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,1)

text=StringVar()
name=StringVar()
name.set('HabrUser')
text.set('')
tk.title('MegaChat')
tk.geometry('400x300')

log = Text(tk)
nick = Entry(tk, textvariable=name)
msg = Entry(tk, textvariable=text)
msg.pack(side='bottom', fill='x', expand='true')
nick.pack(side='bottom', fill='x', expand='true')
log.pack(side='top', fill='both',expand='true')

def loopproc():
	log.see(END)
	s.setblocking(False)
	try:
		message = s.recv(128)
		log.insert(END,message+'\n')
	except:
		tk.after(1,loopproc)
		return
	tk.after(1,loopproc)
	return

def sendproc(event):
	sock.sendto (name.get()+':'+text.get(),('255.255.255.255',11719))
	text.set('')

msg.bind('<Return>',sendproc)

msg.focus_set()

tk.after(1,loopproc)
tk.mainloop()

P.S. И не забывайте — длина питона может достигать 9-10 метров.

Создаем первое программное обеспечение на Python

В этом уроке мы создадим на основе языка программирования Python свое первое программное обеспечение с .exe файлом.

Введение в GUI

GUI (Graphical user interface) — графический интерфейс пользователя. С этого понятия мы и начнем. На самом деле никаких скрытых смыслов здесь нет и GUI — это графическое представление для всех ваших программ.

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

В «питоне» есть много модулей, которые вы можете импортировать и на его основе создавать свой графический интерфейс. Мы будем использовать Tkinter — встроенный GUI  для Python. Он устанавливается вместе «питоном».

Кроме того, вы также можете попробовать PyQT, Kivy (лучше всего подходит для кроссплатформенности, при создании ПО под apk, exe или MAC). Официальный сайт — kivy.org.

В этом уроке я собираюсь использовать Tkinter. Удобная вещь в Python состоит в том, что вы можете импортировать другие файлы в свой файл. Точно также нужно импортировать Tkinter, аналогично #include в C.

from Tkinter import *
import Tkinter
import tkMessageBox
top = Tk()
L1 = Label(top, text="HI")
L1.pack( side = LEFT)
E1 = Entry(top, bd =5)
E1.pack(side = RIGHT)
B=Button(top, text ="Hello",)
B.pack()

top.mainloop()

Здесь Tk() относится к классу в модуле Tkinter, который мы сохраняем, инициализируя в top. Label — это метод для печати текста, Entry — для создания пустой записи, Button — для создания кнопки.

pack — это ключ для упаковки всего в макет. mainloop сохраняет все видимым, пока вы не закроете графический интерфейс.

Создаем собственный калькулятор

Выше мы увидели простой графический интерфейс с кнопкой и полями. Приступим к созданию простого калькулятора Python.

Сразу скажу, что стиль кода, названия переменных очень важны и существует n-способов создания кода, но здесь мы только хотим понять суть создания ПО, а не выучить все правила правильного написания кода.

Создание GUI

Прежде чем перейти к коду, мы создадим графический интерфейс для нашего приложения-калькулятора. Для более легкого понимания мы будем использовать только одну кнопку и 4 строчки для ввода.

Воспользуемся написанным кодом выше и возьмем оттуда label, entry и button.

from Tkinter import *
import Tkinter
import tkMessageBox

top = Tkinter.Tk()
L1 = Label(top, text="My calculator",).grid(row=0,column=1)
L2 = Label(top, text="Number 1",).grid(row=1,column=0)
L3 = Label(top, text="Number 2",).grid(row=2,column=0)
L4 = Label(top, text="Operator",).grid(row=3,column=0)
L4 = Label(top, text="Answer",).grid(row=4,column=0)
E1 = Entry(top, bd =5)
E1.grid(row=1,column=1)
E2 = Entry(top, bd =5)
E2.grid(row=2,column=1)
E3 = Entry(top, bd =5)
E3.grid(row=3,column=1)
E4 = Entry(top, bd =5)
E4.grid(row=4,column=1)
B=Button(top, text ="Submit",).grid(row=5,column=1,)

top.mainloop()

Создание функции

В нашем случае сразу после ввода 2 чисел и указания операции между ними должен быть показан ответ.

Начнем с кнопки Submit (см. изображение калькулятора выше).

Нам нужно дать команду кнопке, создать функцию, которая предназначена для этого.

B=Button(top, text ="Submit", command =processing).grid(row=5,column=1)

def process():
    number1=Entry.get(E1)
    number2=Entry.get(E2)
    operator=Entry.get(E3)

Называем функцию process, которая после нажатия кнопки, простыми словами, обращается за данными к нашим строкам ввода и получает значения, введенные пользователем. Полученные данные мы сохраняем в number1, number2, operator.

Процесс вычислений

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

Для того, чтобы преобразовать тип данных мы строковую переменную оборачиваем в int.

number1 = int(number1)
number2 = int(number2)

Тем не менее, есть еще одна проблема — получение значения оператора (например, + — * /) для работы.

На самом деле решение довольно простое — использовать условный оператор if  и делать вычисления внутри условий.

number1=int(number1)
number2=int(number2)
if operator == "+&quфot;:
    answer = number1 + number2
if operator == "-":
    answer = number1 - number2
if operator == "*":
    answer= number1 * number2
if operator == "/":
    answer = number1 / number2

Строка в Python обозначается как » « или ‘ ‘,  то есть здесь в if мы проверяем строковый оператор, полученный от пользователя и сохраняем результат в переменной answer.

Теперь, наконец, нам нужно отправить вывод:

Entry.insert(E4,0,answer)

Код целиком будет выглядеть так:

from Tkinter import *
import Tkinter
import tkMessageBox
def process():
    number1=Entry.get(E1)
    number2=Entry.get(E2)
    operator=Entry.get(E3)
    number1=int(number1)
    number2=int(number2)
    if operator =="+":
        answer=number1+number2
    if operator =="-":
        answer=number1-number2
    if operator=="*":
        answer=number1*number2
    if operator=="/":
        answer=number1/number2
    Entry.insert(E4,0,answer)
    print(answer)

top = Tkinter.Tk()
L1 = Label(top, text="My calculator",).grid(row=0,column=1)
L2 = Label(top, text="Number 1",).grid(row=1,column=0)
L3 = Label(top, text="Number 2",).grid(row=2,column=0)
L4 = Label(top, text="Operator",).grid(row=3,column=0)
L4 = Label(top, text="Answer",).grid(row=4,column=0)
E1 = Entry(top, bd =5)
E1.grid(row=1,column=1)
E2 = Entry(top, bd =5)
E2.grid(row=2,column=1)
E3 = Entry(top, bd =5)
E3.grid(row=3,column=1)
E4 = Entry(top, bd =5)
E4.grid(row=4,column=1)
B=Button(top, text ="Submit",command = process).grid(row=5,column=1,)

top.mainloop()

Вы успешно написали код нашего калькулятора.

Обработка исключений

Заголовок звучит слишком техническим? Определенно нет, не переживайте. Мы всегда должны учитывать много разных моментов.

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

Здесь идет процесс обработки исключений Python, также во многих программах и на веб-страницах выдается предупреждение или предупреждающие сообщения.

Обработка исключений считается простым процессом. Давайте посмотрим, как это сделать в нашей программе:

def proces():
    try:
        number1=Entry.get(E1)
        number2=Entry.get(E2)
        operator=Entry.get(E3)
        number1=int(number1)
        number2=int(number2)
        if operator =="+":
            answer=number1+number2
        if operator =="-":
            answer=number1-number2
        if operator=="*":
            answer=number1*number2
        if operator=="/":
            answer=number1/number2
        Entry.insert(E4,0,answer)
        print(answer)
    except ValueError:
        tkMessageBox.showwarning("Warning","Please enter the value in integer")

Здесь мы сделали простое диалоговое окно с предупреждением. tkMessageBox.showwarning — это настраиваемое предупреждение для Tkinter, где в скобках указываются заголовок диалогового окна и сообщение.

Создание EXE

Вы создали программу на Python, которая полностью работаете после отладки ошибок. Но есть одна проблема — что если вы хотите поделиться своим кодом Python с другими? У них должен быть установлен Python, но часто это просто невозможно. Кроме того вы можете не иметь делания раскрыть свой код и тогда лучше всего создать *.exe — файл.

Чтобы создать исполняемую *.exe версию или Apk (для Android) необходимо «заморозить» (freeze) ваш код.

Есть много способов «заморозить» ваш код, но я бы предложил использовать Pyinstaller.

Шаг 1

Перейдите на сайт pyinstaller.org и установите его. Можно это сделать через pip, а можно скачать Pyinstaller.

pip install pyinstaller

Шаг 2

Перейдите в папку, в которой находится код, нажмите SHIFT + правую клавишу мыши и далее «Открыть в командной строке». Т.е. либо «open in command prompt» или «power shell» в зависимости от вашей версии ОС.

python pyinstaller.py --noconsole yourscript.py
pyinstaller.exe --onefile --windowed --name myapps --icon=yourico.ico yourscript.py

Добавляем свой значок для EXE-файла и помещаем всё в один файл с помощью второй команды.

Исходную программу на Python и *.exe файл вы можете скачать ниже:

На этом мы заканчиваем урок по разработке своего первого программного обеспечения на Python.

Разработка мобильных приложений на Python. Библиотека KivyMD / Хабр

Приветствую! Сегодня речь снова пойдет о библиотеке KivyMD — наборе виджетов для кроссплатформенной разработки на Python в стиле Material Design. В этой статье я сделаю не обзор виджетов KivyMD, как в недавней статье, а, скорее, это будет материал больше о позиционировании виджетов. Что-то похожего на туториал по разработке мобильных приложений на Python для новичков здесь не будет, так что если впервые слышите о фреймворке Kivy, вряд ли вам будет все это интересно. Ну, а мы погнали под кат!

На днях скачал из Google Play демонстрационное приложение Flutter UIKit:


И сейчас мы с вами попробуем повторить один экран из этого приложения. Давайте сразу посмотрим на результаты: слева — Flutter, справа — Kivy & KivyMD.

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

Итак! Что бросается в глаза, глядя на экран, который мы будем воспроизводить? Прозрачный фон переднего layout. В Kivy такую возможность предоставляет FloatLayout, который позволяет размещать в себе виджеты и контроллы один над другим следующим образом:

Схематично наш экран будет выглядеть так:
Разметка этого экрана довольно простая:
Почему я говорю о FloatLayout, если наш экран унаследован от Screen?

<[email protected]>:

    ...

Просто потому, что Screen —> RelativeLayout —> FloatLayout.

Все виджеты во FloatLayout позиционируются от нижнего левого угла, то есть, на экране им автоматически присваивается позиция (0, 0). В разметке не сложно проследить порядок добавления элементов на экран сверху вниз:

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

MDToolbar:
    ...
    pos_hint: {"top": 1}

Каждому виджету в Kivy помимо конкретных координат (x, y) можно указать подсказку позиции:

pos_hint: {"top": 1}  # верхняя граница экрана
pos_hint: {"bottom": 1}  # нижняя граница экрана
pos_hint: {"right": 1}  # правая граница экрана
pos_hint: {"center_y": .5}  # центр экрана по вертикали
pos_hint: {"center_x": .2}  # отступ в 20 % по горизонтали от левой границы экрана
...
...

Так вот, нижнее фоновое изображение…

    BoxLayout:
        size_hint_y: None
        height: root.height - toolbar.height

        FitImage:
            source: "smokestackheather.jpeg"

… благодаря виджету FitImage (библиотека KivyMD), автоматически растягивается на все выделенное ему пространство с сохранением пропорций изображения:

По умолчанию каждому виджету и лайоуту в Kivy предоставляется 100 % пространства, если не указанно иное. Например, если вы захотите добавить на экран одну кнопку, вы, очевидно сделаете следующее:

from kivy.app import App
from kivy.lang import Builder

KV = """
Button:
    text: "Button"
"""


class MyApp(App):
    def build(self):
        return Builder.load_string(KV)


MyApp().run()

И получите результат:
Кнопка заняла 100 % пространства. Чтобы разместить кнопку по центру экрана, нужно, во-первых, задать ей необходимый размер и, во-вторых, указать, где она будет находится:

from kivy.app import App
from kivy.lang import Builder

KV = """
Button:
    text: "Button"
    size_hint: None, None
    size: 100, 50
    pos_hint: {"center_y": .5, "center_x": .5}
"""


class MyApp(App):
    def build(self):
        return Builder.load_string(KV)


MyApp().run()

Теперь картина изменилась:
Также можно указать свойство size_hint, от 0 до 1, (эквивалент 0-100%), то есть, подсказка размера:

from kivy.app import App
from kivy.lang import Builder

KV = """
BoxLayout:

    Button:
        text: "Button"
        size_hint_y: .2

    Button:
        text: "Button"
        size_hint_y: .1

    Button:
        text: "Button"
"""


class MyApp(App):
    def build(self):
        return Builder.load_string(KV)


MyApp().run()

Или тоже самое, но подсказка ширины (size_hint_x):

from kivy.app import App
from kivy.lang import Builder

KV = """
BoxLayout:

    Button:
        text: "Button"
        size_hint_x: .2

    Button:
        text: "Button"
        size_hint_x: .1

    Button:
        text: "Button"
"""


class MyApp(App):
    def build(self):
        return Builder.load_string(KV)


MyApp().run()

MDToolbar имеет высоту в 56dp, не может занимать все пространство, и если ему не подсказать, что его место сверху, то он автоматически прилипнет к нижней части экрана:
Список карточек — OrderProductLayout (о нем мы поговорим ниже) — это ScrollView с элементами MDCard и он занимает всю высоту экрана, но благодаря padding (значения отступов в лайоутах) кажется, что он находится чуть выше центра экрана. Ну а MDBottomAppBar по умолчанию кидает якорь к нижней границе экрана. Поэтому только MDToolbar мы указали, где его место.

Теперь давайте посмотрим, что представляет из себя виджет OrderProductLayout:

Как видим, это четыре карточки, вложенные в ScrillView. В отличие от родительского экрана, который унаследован от FloatLayout, здесь все виджеты читаются сверху вниз.
Это очень удобно, поскольку прослеживается четкая иерархия виджетов, древовидная структура и с одного взгляда понятно, какой виджет/контролл какому лайоуту принадлежит. В Kivy наиболее частым используемым лайоутом является BoxLayout — коробка, которая позволяет размещать в себе виджеты по вертикали либо по горизонтали (по умолчанию — последнее):
Более наглядно это видно из следующей схемы, где используется BoxLayout горизонтальной ориентации:
Мы запретили BoxLayout использовать 100% пространства — size_hint_y: None и сказали — твоя высота будет ровно такой, какой будет высота самого высокого элемента, вложенного в тебя — height: self.minimum_height.

Список изображений:

Если бы мы захотели использовать вертикальную прокрутку списка, нам нужно было бы изменить GridLayout следующим образом:

    ScrollView:

        GridLayout:
            size_hint_y: None
            height: self.minimum_height
            cols: 1

Заменить строки (rows) на столбцы (cols) и указать в minimum не ширину, а высоту:

from kivy.app import App
from kivy.lang import Builder
from kivy.metrics import dp
from kivy.uix.button import Button

KV = """
ScrollView:

    GridLayout:
        id: box
        size_hint_y: None
        height: self.minimum_height
        spacing: "5dp"
        cols: 1
"""


class MyApp(App):
    def build(self):
        return Builder.load_string(KV)

    def on_start(self):
        for i in range(20):
            self.root.ids.box.add_widget(
                Button(
                    text=f"Label {i}",
                    size_hint_y=None,
                    height=dp(40),
                )
            )


MyApp().run()

Следующие карты — выбор цвета и размера (они практически идентичны):

Отличительной особенностью языка разметки Kv Language является не только четкая структура виджетов, но и то, что этот язык поддерживает некоторые возможности языка Python. А именно: вызов методов, создание/изменение переменных, логические, I/O и математические операции…
Вычисление значения value, объявленного в Label

        Label:
            value: 0
            text: str(self.value)

… происходит непосредственно в самой разметке:

        MDIconButton:
            on_release: label_value.value -= 1 if label_value.value > 0 else 0

И я никогда не поверю, что вот это (код Flutter)…

… логичнее и читабельнее кода Kv Language:

Вчера меня спрашивали, как у Kivy обстоят дела со средой разработки, есть ли автокомплиты, хотрелоад и прочие прелести? С автокомплитами все отлично, если пользоваться PyCharm:
Насчет хотрелоад… Python — интерпретируемый язык. Kivy использует Python. Соответственно, чтобы увидеть результат, не нужна компиляция кода, запустил — увидел/протестирвал. Как я уже говорил, Kivy не использует нативные API для рендера UI, поэтому позволяет эмулировать различные модели устройств и платформ с помощью модуля screen. Достаточно запустить ваш проект с нужными параметрами, чтобы на компьютере открылось окно тестируемого приложения так, как если бы оно было запущено на реальном устройстве. Звучит странно, но поскольку Kivy абстрагируется от платформы в отрисовке UI, это позволяет не использовать тяжелые и медленные эмуляторы для тестов. Это касается только UI. Например, тестовое приложение, описываемое в этой статье тестировалось с параметрами -m screen:droid2, portrait, scale=.75.

Слева — запущено на мобильном устройстве, справа — на компьютере:

Полный список параметров модуля screen:

devices = {
    # device: (name, width, height, dpi, density)
    'onex': ('HTC One X', 1280, 720, 312, 2),
    'one': ('HTC One', 1920, 1080, 468, 3),
    'onesv': ('HTC One SV', 800, 480, 216, 1.5),
    's3': ('Galaxy SIII', 1280, 720, 306, 2),
    'note2': ('Galaxy Note II', 1280, 720, 267, 2),
    'droid2': ('Motorola Droid 2', 854, 480, 240, 1.5),
    'xoom': ('Motorola Xoom', 1280, 800, 149, 1),
    'ipad': ('iPad (1 and 2)', 1024, 768, 132, 1),
    'ipad3': ('iPad 3', 2048, 1536, 264, 2),
    'iphone4': ('iPhone 4', 960, 640, 326, 2),
    'iphone5': ('iPhone 5', 1136, 640, 326, 2),
    'xperiae': ('Xperia E', 480, 320, 166, 1),
    'nexus4': ('Nexus 4', 1280, 768, 320, 2),
    'nexus7': ('Nexus 7 (2012 version)', 1280, 800, 216, 1.325),
    'nexus7.2': ('Nexus 7 (2013 version)', 1920, 1200, 323, 2),

    # taken from design.google.com/devices
    # please consider using another data instead of
    # a dict for autocompletion to work
    # these are all in landscape
    'phone_android_one': ('Android One', 854, 480, 218, 1.5),
    'phone_htc_one_m8': ('HTC One M8', 1920, 1080, 432, 3.0),
    'phone_htc_one_m9': ('HTC One M9', 1920, 1080, 432, 3.0),
    'phone_iphone': ('iPhone', 480, 320, 168, 1.0),
    'phone_iphone_4': ('iPhone 4', 960, 640, 320, 2.0),
    'phone_iphone_5': ('iPhone 5', 1136, 640, 320, 2.0),
    'phone_iphone_6': ('iPhone 6', 1334, 750, 326, 2.0),
    'phone_iphone_6_plus': ('iPhone 6 Plus', 1920, 1080, 400, 3.0),
    'phone_lg_g2': ('LG G2', 1920, 1080, 432, 3.0),
    'phone_lg_g3': ('LG G3', 2560, 1440, 533, 3.0),
    'phone_moto_g': ('Moto G', 1280, 720, 327, 2.0),
    'phone_moto_x': ('Moto X', 1280, 720, 313, 2.0),
    'phone_moto_x_2nd_gen': ('Moto X 2nd Gen', 1920, 1080, 432, 3.0),
    'phone_nexus_4': ('Nexus 4', 1280, 768, 240, 2.0),
    'phone_nexus_5': ('Nexus 5', 1920, 1080, 450, 3.0),
    'phone_nexus_5x': ('Nexus 5X', 1920, 1080, 432, 2.6),
    'phone_nexus_6': ('Nexus 6', 2560, 1440, 496, 3.5),
    'phone_nexus_6p': ('Nexus 6P', 2560, 1440, 514, 3.5),
    'phone_samsung_galaxy_note_4': ('Samsung Galaxy Note 4',
                                    2560, 1440, 514, 3.0),
    'phone_samsung_galaxy_s5': ('Samsung Galaxy S5', 1920, 1080, 372, 3.0),
    'phone_samsung_galaxy_s6': ('Samsung Galaxy S6', 2560, 1440, 576, 4.0),
    'phone_sony_xperia_c4': ('Sony Xperia C4', 1920, 1080, 400, 2.0),
    'phone_sony_xperia_z_ultra': ('Sony Xperia Z Ultra', 1920, 1080, 348, 2.0),
    'phone_sony_xperia_z1_compact': ('Sony Xperia Z1 Compact',
                                     1280, 720, 342, 2.0),
    'phone_sony_xperia_z2z3': ('Sony Xperia Z2/Z3', 1920, 1080, 432, 3.0),
    'phone_sony_xperia_z3_compact': ('Sony Xperia Z3 Compact',
                                     1280, 720, 313, 2.0),
    'tablet_dell_venue_8': ('Dell Venue 8', 2560, 1600, 355, 2.0),
    'tablet_ipad': ('iPad', 1024, 768, 132, 1.0),
    'tablet_ipad_mini': ('iPad Mini', 1024, 768, 163, 1.0),
    'tablet_ipad_mini_retina': ('iPad Mini Retina', 2048, 1536, 326, 2.0),
    'tablet_ipad_pro': ('iPad Pro', 2732, 2048, 265, 2.0),
    'tablet_ipad_retina': ('iPad Retina', 2048, 1536, 264, 2.0),
    'tablet_nexus_10': ('Nexus 10', 2560, 1600, 297, 2.0),
    'tablet_nexus_7_12': ('Nexus 7 12', 1280, 800, 216, 1.3),
    'tablet_nexus_7_13': ('Nexus 7 13', 1920, 1200, 324, 2.0),
    'tablet_nexus_9': ('Nexus 9', 2048, 1536, 288, 2.0),
    'tablet_samsung_galaxy_tab_10': ('Samsung Galaxy Tab 10',
                                     1280, 800, 148, 1.0),
    'tablet_sony_xperia_z3_tablet': ('Sony Xperia Z3 Tablet',
                                     1920, 1200, 282, 2.0),
    'tablet_sony_xperia_z4_tablet': ('Sony Xperia Z4 Tablet',
                                     2560, 1600, 297, 2.0)TodoList()
        app.run()

}

Ну, и, наконец, финальный результат — запуск на мобильном устройстве…

Единственное, что огорчает, это скорость запуска. У того же Flutter она просто феноменальная!

Надеюсь, был кому-то полезен, до новых встреч!

CGI: пишем простой сайт на Python. Часть 3: Пример приложения

Мы уже научились обрабатывать формы и устанавливать cookies. Сегодня же мы посмотрим, что может из этого получиться.

Чтобы работать с пользовательскими данными, нужно где-то эти данные сохранять. Самый простой (но далеко не самый изящный и безопасный) — хранение данных в файлах. Более продвинутый способ — хранение в базе данных. Мы остановимся на первом способе, как на самом простом.

Собственно, ничего нового здесь объясняться не будет. Работу с файлами вы уже знаете, обрабатывать формы уже умеете.

Сегодня мы напишем прототип приложения типа «твиттер». Данные в файлах будем хранить в json.

Создадим 2 файла: один будет отвечать за обработку данных, вводимых пользователем, второй — вспомогательный модуль, который упростит код первого.

cgi-bin/wall.py:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import cgi
import html
import http.cookies
import os

from _wall import Wall
wall = Wall()

cookie = http.cookies.SimpleCookie(os.environ.get("HTTP_COOKIE"))
session = cookie.get("session")
if session is not None:
    session = session.value
user = wall.find_cookie(session)  # Ищем пользователя по переданной куке

form = cgi.FieldStorage()
action = form.getfirst("action", "")

if action == "publish":
    text = form.getfirst("text", "")
    text = html.escape(text)
    if text and user is not None:
        wall.publish(user, text)
elif action == "login":
    login = form.getfirst("login", "")
    login = html.escape(login)
    password = form.getfirst("password", "")
    password = html.escape(password)
    if wall.find(login, password):
        cookie = wall.set_cookie(login)
        print('Set-cookie: session={}'.format(cookie))
    elif wall.find(login):
        pass  # А надо бы предупреждение выдать
    else:
        wall.register(login, password)
        cookie = wall.set_cookie(login)
        print('Set-cookie: session={}'.format(cookie))

pattern = '''
<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
<title>Стена</title>
</head>
<body>
    Форма логина и регистрации. При вводе несуществующего имени зарегистрируется новый пользователь.
    <form action="/cgi-bin/wall.py">
        Логин: <input type="text" name="login">
        Пароль: <input type="password" name="password">
        <input type="hidden" name="action" value="login">
        <input type="submit">
    </form>

    {posts}

    {publish}
</body>
</html>
'''

if user is not None:
    pub = '''
    <form action="/cgi-bin/wall.py">
        <textarea name="text"></textarea>
        <input type="hidden" name="action" value="publish">
        <input type="submit">
    </form>
    '''
else:
    pub = ''

print('Content-type: text/html\n')

print(pattern.format(posts=wall.html_list(), publish=pub))

Здесь мы используем форматирование строк для формирования страницы (кстати, это первый шаг на пути к созданию собственного шаблонизатора).

Не забудьте дать этому файлу права на выполнение (второму файлу эти права не нужны).

cgi-bin/_wall.py (здесь определены функции publish, login и другие):

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import json
import random
import time


class Wall:
    USERS = 'cgi-bin/users.json'
    WALL = 'cgi-bin/wall.json'
    COOKIES = 'cgi-bin/cookies.json'

    def __init__(self):
        """Создаём начальные файлы, если они не созданы"""
        try:
            with open(self.USERS, 'r', encoding='utf-8'):
                pass
        except FileNotFoundError:
            with open(self.USERS, 'w', encoding='utf-8') as f:
                json.dump({}, f)

        try:
            with open(self.WALL, 'r', encoding='utf-8'):
                pass
        except FileNotFoundError:
            with open(self.WALL, 'w', encoding='utf-8') as f:
                json.dump({"posts": []}, f)

        try:
            with open(self.COOKIES, 'r', encoding='utf-8'):
                pass
        except FileNotFoundError:
            with open(self.COOKIES, 'w', encoding='utf-8') as f:
                json.dump({}, f)

    def register(self, user, password):
        """Регистриует пользователя. Возвращает True при успешной регистрации"""
        if self.find(user):
            return False  # Такой пользователь существует
        with open(self.USERS, 'r', encoding='utf-8') as f:
            users = json.load(f)
        users[user] = password
        with open(self.USERS, 'w', encoding='utf-8') as f:
            json.dump(users, f)
        return True

    def set_cookie(self, user):
        """Записывает куку в файл. Возвращает созданную куку."""
        with open(self.COOKIES, 'r', encoding='utf-8') as f:
            cookies = json.load(f)
        cookie = str(time.time()) + str(random.randrange(10**14))  # Генерируем уникальную куку для пользователя
        cookies[cookie] = user
        with open(self.COOKIES, 'w', encoding='utf-8') as f:
            json.dump(cookies, f)
        return cookie

    def find_cookie(self, cookie):
        """По куке находит имя пользователя"""
        with open(self.COOKIES, 'r', encoding='utf-8') as f:
            cookies = json.load(f)
        return cookies.get(cookie)

    def find(self, user, password=None):
        """Ищет пользователя по имени или по имени и паролю"""
        with open(self.USERS, 'r', encoding='utf-8') as f:
            users = json.load(f)
        if user in users and (password is None or password == users[user]):
            return True
        return False

    def publish(self, user, text):
        """Публикует текст"""
        with open(self.WALL, 'r', encoding='utf-8') as f:
            wall = json.load(f)
        wall['posts'].append({'user': user, 'text': text})
        with open(self.WALL, 'w', encoding='utf-8') as f:
            json.dump(wall, f)

    def html_list(self):
        """Список постов для отображения на странице"""
        with open(self.WALL, 'r', encoding='utf-8') as f:
            wall = json.load(f)
        posts = []
        for post in wall['posts']:
            content = post['user'] + ' : ' + post['text']
            posts.append(content)
        return '<br>'.join(posts)

Разумеется, в нашем простом «твиттере» очень много недостатков: не выводятся предупреждения пользователю, регистрация при несуществующем имени, пароли хранятся в открытом виде, использованные куки не удаляются, и многие другие. Кто хочет, может усовершенствовать.

Но есть и преимущество: поскольку у нас теперь 2 разных файла (почти независимых), то можно поменять систему хранения данных (например, база данных вместо файлов), вообще не затрагивая wall.py.

Напоследок покажу, как это работает:

Сначала зарегистрировались, теперь нужно ещё раз ввести логин-пароль, чтобы войти.

Можно писать.

В следующей (возможно последней) части я покажу, как это всё можно опубликовать в сети интернет.

Python | Первая программа

Первая программа на Python

Последнее обновление: 24.01.2019

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

Как было сказано в прошлой теме, программа интерпретатора, если при установке не был изменен адрес, по умолчанию
устанавливается на Linux по пути usr/local/bin/python37, а на Windows по пути
C:\Users\[имя_пользователя]\AppData\Local\Programs\Python\Python37\ и представляет файл под названием python.exe.

Запустим интерпретатор и введем в него следующую строку:


print("hello world")

И консоль выведет строку «hello world»:

Для этой программы использовалась функция print(), которая выводит некоторую строку на консоль.

Создание файла программы

В реальности, как правило, программы определяются во внешних файлах-скриптах и затем передаются интерпретатору на выполнение. Поэтому создадим файл программы.
Для этого на диске C или где-нибудь в другом месте файловой системы определим для скриптов папку python. А в этой папке создадим новый текстовый файл, который
назовем hello.py. По умолчанию файлы с кодом на языке Python, как правило, имеют расширение py.

Откроем этот файл в любом текстовом редакторе и добавим в него следующий код:


name = input("Введите имя: ")
print("Привет,", name)

Скрипт состоит из двух строк. Первая строка с помощью функции input() ожидает ввода пользователем своего имени. Введенное
имя затем попадает в переменную name.

Вторая строка с помощью функции print() выводит приветствие вместе с введенным именем.

Теперь запустим командную строку/терминал и с помощью команды cd перейдем к папке, где находится файл с исходным кодом hello.py (например, в моем случае это папка C:\python).
Далее вначале введем полный путь к интерпретатору, а затем полный путь к файлу скрипта:

К примеру, в моем случае в консоль надо будет вести:


C:\Users\Eugene\AppData\Local\Programs\Python\Python37\python.exe hello.py

Но если при установке была указана опция «Add Python 3.7 to PATH», то есть путь к интерпретатору Python был добавлен в переменные среды, то вместо полного пути к интерпретатору можно просто написать python:

Варианты с обоими способами запуска:

В итоге программа выведет приглашение к вводу имени, а затем приветствие.

Подборка крутых Python библиотек / Пишем 7 программ на Python / itProger

Среди крупных библиотек и фреймворков, есть и те, чей потенциал не столь велик, так как они были созданы, по большей части, ради забавы и выполняют совсем небольшой функционал.

В статье мы рассмотрим 7 небольших библиотек и создадим на их основе различные мини программы. 

Сокращение ссылок

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

Создать такую ссылку можно всего за три строчки кода, при помощи использования библиотеки PyShorteners. Вам нужно установить библиотеку в проект, выполнить её подключение, а также создать объект на её основе.

Пример рабочего кода:

import pyshorteners

s = pyshorteners.Shortener()
print("Сокращенная ссылка - ", s.tinyurl.short('https://itproger.com/courses/'))
Скорость соединения

Нужно проверить скорость интернета? Не проблема, так как в Питоне есть специальная библиотека Pyspeedtest, которая позволяет быстро выполнить полную проверку скорости вашего WiFi.

Пример рабочего кода:

import pyspeedtest

st = pyspeedtest.SpeedTest()

st.download()
st.upload()
st.ping()
Редактор видео

Все еще в поиске крутого видео редактора? Зачем что-то искать, когда есть Python и замечательная библиотека MoviePy 🙂

За счет  MoviePy вы можете перевернуть видео, можете его обрезать, можете изменить количество FPS и можете выполнить ещё много других действий.

Мы создадим программу, что будет принимать видео и отделять от него звук, который будем сохранять в качестве отдельного файла. Чтобы такое записать потребуется лишь пару строк кода:

import moviepy.editor

video = moviepy.editor.VideoFileClip("some.mov")
audio = video.audio

audio.write_audiofile("new_audio.mp3")
Википедия

А как часто вы пользуетесь википедией? Если часто, то процесс поиска информации в ней можно немного упростить. За счёт официальной библиотеки, что так и называется Wikipedia, вы можете быстро находить информацию по разным ключевым словам.

Пример кода:

import wikipedia
wikipedia.set_lang("ru")
print(wikipedia.summary("New York City"))
Красивая консоль

Зачастую вся информация в консоли — это скучный белый или же черный текст. Согласитесь, такое и читать не интересно. Благо в питоне есть библиотека TermColor.

За счет этой библиотеки мы быстро можем настроить какие именно стили будут применены к тексту в консоли:

from termcolor2 import c

print(c("Some text").blue.on_white.underline)
Создание таблиц

Супер классной библиотекой является PrettyTable. Она позволяет мега быстро создать красивую таблицу для вывода в консоль. Если вы где-то учитесь или же часто нужно демонтировать информацию, то рекомендуем сохранить название этой библиотеки.

Работать с ней просто. Нужно лишь создать объект на основе PrettyTable и далее поместить в него название рядов и сами ряды.

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

Пример кода:

from prettytable import PrettyTable

table = PrettyTable()
table.field_names = ['Names', 'Age', 'City']
table.add_row(["Алекс", 20, "Москва"])
table.add_row(["Боб", 25, "Москва"])
table.add_row(["Саша", 30, "Минск"])
table.add_row(["Петя", 23, "Киев"])
table.add_row(["Вася", 67, "Москва"])

table.align = 'r'
table.sortby = "Age"
print(table)
Выключение компьютера

Если надоело выключать компьютер привычным способом, то можно создать программу на Питон. При чём для её реализации вам потребуется лишь использовать встроенную библиотеку os.

Пример кода:

import os
os.system("shutdown -s")
Видео на эту тему

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

Дополнительный курс

На нашем сайте также есть углубленный курс по изучению языка Питон. В ходе огромной программы вы изучите не только язык Питон, но также научитесь создавать веб сайты за счёт веб технологий и фреймворка Джанго. За курс вы изучите массу нового и к концу программы будете уметь работать с языком Питон, создавать на нём полноценные ПК приложения на основе библиотеки Kivy, а также создавать веб сайты на основе библиотеки Джанго.

Объектно-ориентированное программирование на Python

Объектно-ориентированное программирование

Python — это язык программирования с несколькими парадигмами. Он поддерживает разные подходы к программированию.

Один из популярных подходов к решению проблемы программирования — создание объектов. Это известно как объектно-ориентированное программирование (ООП).

Объект имеет две характеристики:

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

Попугай может быть объектом, так как имеет следующие свойства:

  • имя, возраст, цвет как атрибуты
  • пение, танец как поведение

Концепция ООП в Python направлена ​​на создание повторно используемого кода.Эта концепция также известна как СУХОЙ (Не повторяйся).

В Python концепция ООП следует некоторым основным принципам:


Класс

Класс — это план объекта.

Мы можем думать о классе как об эскизе попугая с ярлыками. Он содержит все подробности о имени, цвете, размере и т. Д. Основываясь на этих описаниях, мы можем изучить попугая. Здесь попугай — это объект.

Примером класса попугая может быть:

класс Попугай:
    пройти 

Здесь мы используем ключевое слово class для определения пустого класса Parrot .Из класса мы создаем экземпляры. Экземпляр — это конкретный объект, созданный из определенного класса.


Объект

Объект (экземпляр) — это реализация класса. Когда класс определен, определяется только описание объекта. Следовательно, память или хранилище не выделяются.

Пример объекта класса попугай может быть:

obj = Попугай () 

Здесь obj — это объект класса Parrot .

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

Пример 1: Создание класса и объекта в Python

  класс Попугай:

    # атрибут класса
    разновидности = "птица"

    # атрибут экземпляра
    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст

# создать экземпляр класса Parrot
blu = Попугай ("Голубой", 10)
woo = Попугай ("Ву", 15)

# доступ к атрибутам класса
print ("Blu is a {}". format (blu .__ class __. разновидности))
print ("Ву тоже {}".формат (ву .__ класс __. виды))

# доступ к атрибутам экземпляра
print ("{} исполнилось {} лет" .format (blu.name, blu.age))
print ("{} {} лет" .format (woo.name, woo.age))  

Выход

  Blu - птица
Ву тоже птица
Блу 10 лет
Ву 15 лет  

В приведенной выше программе мы создали класс с именем Parrot . Затем мы определяем атрибуты. Атрибуты — это характеристика объекта.

Эти атрибуты определены в методе __init__ класса.Это метод инициализатора, который запускается первым при создании объекта.

Затем мы создаем экземпляры класса Parrot . Здесь blu и woo — это ссылки (значения) на наши новые объекты.

Мы можем получить доступ к атрибуту класса, используя __class __. Views . Атрибуты класса одинаковы для всех экземпляров класса. Точно так же мы получаем доступ к атрибутам экземпляра, используя blu.name и blu.age . Однако атрибуты экземпляра различны для каждого экземпляра класса.

Чтобы узнать больше о классах и объектах, перейдите в раздел Классы и объекты Python


Методы

Методы — это функции, определенные внутри тела класса. Они используются для определения поведения объекта.

Пример 2: Создание методов в Python

  класс Попугай:
    
    # атрибутов экземпляра
    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст
    
    # метод экземпляра
    def Sing (я, песня):
        верните "{} sings {}".формат (собственное имя, песня)

    def dance (сам):
        return "{} сейчас танцует" .format (self.name)

# создать экземпляр объекта
blu = Попугай ("Голубой", 10)

# вызываем наши методы экземпляра
print (blu.sing ("Счастливый"))
печать (blu.dance ())  

Выход

  Blu поет 'Happy'
Blu сейчас танцует  

В приведенной выше программе мы определяем два метода: sing () и dance () . Они называются методами экземпляра, потому что они вызываются для объекта экземпляра i.e blu .


Наследование

Наследование — это способ создания нового класса для использования деталей существующего класса без его изменения. Вновь сформированный класс является производным классом (или дочерним классом). Точно так же существующий класс является базовым классом (или родительским классом).

Пример 3: Использование наследования в Python

  # родительский класс
класс Bird:
    
    def __init __ (сам):
        print («Птица готова»)

    def whoisThis (я):
        print ("Птица")

    def плавать (сам):
        print («Плыви быстрее»)

# дочерний класс
класс Пингвин (Птица):

    def __init __ (сам):
        # вызов функции super ()
        супер().__в этом__()
        print («Пингвин готов»)

    def whoisThis (я):
        print («Пингвин»)

    def run (self):
        print ("Беги быстрее")

пегги = Пингвин ()
peggy.whoisThis ()
peggy.swim ()
peggy.run ()  

Выход

  Птица готова
Пингвин готов
Пингвин
Плавать быстрее
Беги быстрее  

В приведенной выше программе мы создали два класса: Bird (родительский класс) и Penguin (дочерний класс). Дочерний класс наследует функции родительского класса.Мы можем увидеть это из метода swim () .

Опять же, дочерний класс изменил поведение родительского класса. Мы можем видеть это из метода whoisThis () . Кроме того, мы расширяем функции родительского класса, создавая новый метод run () .

Кроме того, мы используем функцию super () внутри метода __init __ () . Это позволяет нам запускать метод __init __ () родительского класса внутри дочернего класса.


Инкапсуляция

Используя ООП в Python, мы можем ограничить доступ к методам и переменным. Это предотвращает прямую модификацию данных, которая называется инкапсуляцией. В Python мы обозначаем частные атрибуты с помощью подчеркивания в качестве префикса, то есть одиночного _ или двойного __ .

Пример 4: Инкапсуляция данных в Python

  класс Компьютер:

    def __init __ (сам):
        self .__ maxprice = 900

    def sell (self):
        print ("Цена продажи: {}".формат (self .__ maxprice))

    def setMaxPrice (self, price):
        self .__ maxprice = цена

c = Компьютер ()
c.sell ()

# изменить цену
c .__ maxprice = 1000
c.sell ()

# используя функцию установки
c.setMaxPrice (1000)
c.sell ()  

Выход

  Цена продажи: 900
Цена продажи: 900
Цена продажи: 1000  

В приведенной выше программе мы определили класс Computer .

Мы использовали метод __init __ () для хранения максимальной продажной цены Computer .Мы пытались изменить цену. Однако мы не можем его изменить, потому что Python обрабатывает __maxprice как частные атрибуты.

Как показано, чтобы изменить значение, мы должны использовать функцию установки, то есть setMaxPrice () , которая принимает цену в качестве параметра.


Полиморфизм

Полиморфизм — это способность (в ООП) использовать общий интерфейс для нескольких форм (типов данных).

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

Пример 5: Использование полиморфизма в Python

  класс Попугай:

    def fly (self):
        print («Попугай умеет летать»)
    
    def плавать (сам):
        print («Попугай не умеет плавать»)

класс Пингвин:

    def fly (self):
        print («Пингвин не умеет летать»)
    
    def плавать (сам):
        print («Пингвин умеет плавать»)

# Общий интерфейс
def flying_test (птица):
    bird.fly ()

#instantiate objects
blu = Попугай ()
пегги = Пингвин ()

# передача объекта
летающий_тест (blu)
fly_test (peggy)  

Выход

  Попугай умеет летать
Пингвин не умеет летать  

В приведенной выше программе мы определили два класса: Parrot и Penguin .У каждого из них есть общий метод fly () . Однако их функции разные.

Чтобы использовать полиморфизм, мы создали общий интерфейс, то есть функцию flying_test () , которая принимает любой объект и вызывает метод объекта fly () . Таким образом, когда мы передали объекты blu и peggy в функции flying_test () , она работала эффективно.


Ключевые моменты, о которых следует помнить:

  • Объектно-ориентированное программирование делает программу простой и эффективной для понимания.
  • Поскольку класс является общедоступным, код можно использовать повторно.
  • Данные безопасны и надежны благодаря абстракции данных.
  • Полиморфизм позволяет использовать один и тот же интерфейс для разных объектов, поэтому программисты могут писать эффективный код.

.

Полное руководство по изучению программирования на Python

Это руководство по Python представляет собой универсальное руководство по программированию для всех начинающих. Он может помочь вам изучить Python от начального до продвинутого за простые и легкие шаги.

Python очень интуитивно понятен и прост в освоении. Это также один из наиболее предпочтительных языков программирования для работы в областях анализа данных и машинного обучения.

Индекс

TIOBE также поставил его на третье место среди самых популярных языков программирования в 2019 году.А его использование увеличилось на 2% по сравнению с прошлым годом. Следовательно, вы приняли правильное решение изучить Python.

Если вы новичок в программировании на Python, мы настоятельно рекомендуем вам изучить этот учебник. Однако вы можете сразу перейти к разделу учебника Python [Go] .

Учебное пособие по Python для начинающих

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

Мы организовали этот курс, чтобы обеспечить глубину, детализацию и степень. Даже новичок может обратиться к нему и изучить Python с наименьшими усилиями, не затрачивая много времени. Это руководство поможет вам применить эти знания в ваших реальных проектах.

В следующих разделах рассказывается история Python, функции, домены, зачем изучать Python, как установить и запустить Python на таких платформах, как Windows, Linux и Mac OS X.

Наверх

История Python

Это был голландский программист, Гвидо Ван Россум , который написал Python как хобби-проект программирования еще в конце 1980-х.С тех пор он превратился в один из самых совершенных языков компьютерного мира.

Что привело Гвидо к созданию Python?

По его собственным словам, Гвидо раскрыл секрет создания Python. Он начал работать над ним как над проектом на выходные, используя свободное время на Рождество в декабре 1989 года. Изначально он хотел создать интерпретатор, потомок языка программирования ABC, разработчиком которого он был. И все мы знаем, что это был не кто иной, как Python, который постепенно превратился в полноценный язык программирования.

Как появилось название Python?

Гуидо изначально считал хакеров Unix / C целевыми пользователями своего проекта. И что еще более важно, он любил смотреть знаменитый комедийный сериал [Летающий цирк Монти Пайтона]. Таким образом, имя Python пришло ему в голову, так как оно пришлось не только ему по вкусу, но и его целевым пользователям.

Список известных выпусков Python

Версия Python

Дата выпуска

Python v0.1.0 (Первое издание)

1990

Python v0.9.5 (поддержка Macintosh)

2 января 1992 г.

Python v1.0.0

26 января 1994 г.

Python v1.1.0

26 января 1994 г.

Python v1.5.0

3 января 1998 г.

Python v1.6.0 (последняя обновленная версия)

5 сентября 2000 г.

Python v2.0.0 (добавлено понимание списка)

16 октября 2000 г.

Python v2.7.0 (последняя обновленная версия)

3 июля 2010 г.

Python v3.0,0

3 декабря 2008 г.

Python v3.7.0 (последняя обновленная версия)

июнь 2018 г. и продолжение.

Если вы хотите перейти к разделу Python tutorial , щелкните здесь .

Наверх

Тихие функции Python

☛ Код Качество

Код

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

☛ Производительность разработчика

Python имеет чистый и элегантный стиль программирования. Он использует английский синтаксис и динамически типизируется. Итак, вы никогда не объявляете переменную. Простое присвоение связывает имя с объектом любого типа. Код Python значительно меньше, чем эквивалентный код C ++ / Java. Это означает, что меньше нужно вводить, ограничиваться отладкой и меньше поддерживать. В отличие от скомпилированных языков, программы на Python не нуждаются в компиляции и компоновке, что еще больше повышает продуктивность разработчика.

☛ Код переносимости

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

☛ Встроенные и внешние библиотеки

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

Библиотеки Python для анализа данных и машинного обучения

☛ Интеграция компонентов

Некоторые приложения требуют взаимодействия различных компонентов для поддержки сквозных рабочих процессов. Один такой компонент может быть скриптом Python, тогда как другие могут быть программой, написанной на таких языках, как Java / C ++ или любой другой технологии.

Python имеет несколько способов поддержки взаимодействия между приложениями. Он позволяет использовать такие механизмы, как загрузка библиотек C и C ++ или наоборот, интеграция с компонентами Java и DotNET, связь с использованием COM / Silverlight и взаимодействие с USB-устройствами через последовательные порты.Он даже может обмениваться данными по сети с использованием таких протоколов, как SOAP, XML-RPC и CORBA.

☛ Бесплатное использование, изменение и распространение

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

☛ Объектно-ориентированный от Core

Python в первую очередь следует за конструкцией объектно-ориентированного программирования (ООП).ООП обеспечивает интуитивно понятный способ структурирования кода, а твердое понимание лежащих в его основе концепций может позволить вам максимально использовать свое кодирование. С помощью ООП легко визуализировать сложную проблему на более мелкие потоки, определяя объекты и то, как они соотносятся. А затем мы можем сформировать реальную логику, чтобы программа работала.

Если вы хотите перейти к разделу Python tutorial , нажмите здесь .

Наверх

Области программирования Python

☛ Разработка веб-приложений

Python имеет львиную долю в области веб-разработки.Многие работодатели ищут программистов полного цикла, знающих Python. И вы можете стать одним из них, изучив фреймворки (WAF), такие как Django, Flask, CherryPy и Bottle, которые обеспечивают обширную поддержку веб-разработки. Все они разработаны

.

Научитесь создавать и импортировать специальные и встроенные модули

Что такое модули в Python?

Модули

относятся к файлу, содержащему операторы и определения Python.

Файл, содержащий код Python, например: example.py , называется модулем, и его имя модуля будет example .

Мы используем модули, чтобы разбить большие программы на небольшие управляемые и организованные файлы. Кроме того, модули обеспечивают возможность повторного использования кода.

Мы можем определить наши наиболее часто используемые функции в модуле и импортировать его, вместо того, чтобы копировать их определения в разные программы.

Создадим модуль. Введите следующее и сохраните его как example.py .

  # Пример модуля Python

def add (a, b):
   "" "Эта программа добавляет два
   числа и вернуть результат "" "

   результат = a + b
   вернуть результат  

Здесь мы определили функцию add () внутри модуля с именем example .Функция принимает два числа и возвращает их сумму.


Как импортировать модули в Python?

Мы можем импортировать определения внутри модуля в другой модуль или интерактивный интерпретатор в Python.

Для этого мы используем ключевое слово import . Чтобы импортировать наш ранее определенный модуль , пример , мы вводим следующее в командной строке Python.

  >>> пример импорта  

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

Используя имя модуля, мы можем получить доступ к функции, используя точку . оператор. Например:

  >>> example.add (4,5.5)
9,5  

Python имеет множество стандартных модулей. Вы можете ознакомиться с полным списком стандартных модулей Python и вариантов их использования. Эти файлы находятся в каталоге Lib внутри места, где вы установили Python.

Стандартные модули можно импортировать так же, как мы импортируем наши пользовательские модули.

Есть разные способы импорта модулей. Они перечислены ниже ..


Оператор импорта Python

Мы можем импортировать модуль с помощью оператора import и получить доступ к определениям внутри него с помощью оператора точки, как описано выше. Вот пример.

  # пример инструкции импорта
# для импорта математики стандартного модуля

импорт математики
print («Значение числа пи», math.pi)  

Когда вы запустите программу, вывод будет:

  Значение Пи равно 3.141592653589793  

Импорт с переименованием

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

  # импортировать модуль, переименовав его

импортировать математику как m
print («Значение числа пи», m.pi)  

Мы переименовали модуль math в m . В некоторых случаях это может сэкономить нам время на набор текста.

Обратите внимание, что имя math не распознается в нашей области. Следовательно, math.pi недействителен, а m.pi — правильная реализация.


Python из … Оператор импорта

Мы можем импортировать определенные имена из модуля без импорта модуля в целом. Вот пример.

  # импортировать только пи из математического модуля

из математического импорта пи
print («Значение числа пи», пи)  

Здесь мы импортировали только атрибут pi из модуля math .

В таких случаях мы не используем оператор точки. Мы также можем импортировать несколько атрибутов следующим образом:

  >>> из математического импорта pi, e
>>> пи
3.141592653589793
>>> е
2,718281828459045  

Импортировать все имена

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

  # импортировать все имена из стандартного модуля math

из математического импорта *
print («Значение числа пи», пи)  

Здесь мы импортировали все определения из математического модуля. Это включает все имена, видимые в нашей области видимости, кроме тех, которые начинаются с подчеркивания (частные определения).

Импорт всего, что отмечен звездочкой (*), не является хорошей практикой программирования. Это может привести к дублированию определений идентификатора. Это также затрудняет читаемость нашего кода.


Путь поиска модуля Python

При импорте модуля Python просматривает несколько мест. Интерпретатор сначала ищет встроенный модуль. Затем (если встроенный модуль не найден) Python просматривает список каталогов, определенных в sys.path . Поиск ведется в таком порядке.

  • Текущий каталог.
  • PYTHONPATH (переменная среды со списком каталогов).
  • Зависящий от установки каталог по умолчанию.
>>> import sys
>>> sys.path
['',
'C: \ Python33 \ Lib \ idlelib',
'C: \ Windows \ system32 \ python33.zip',
'C: \ Python33 \ DLLs',
'C: \ Python33 \ lib',
'C: \\ Python33',
'C: \ Python33 \ lib \ site-packages'] 

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


Перезарядка модуля

Интерпретатор Python импортирует модуль только один раз за сеанс. Это делает вещи более эффективными. Вот пример, показывающий, как это работает.

Предположим, у нас есть следующий код в модуле с именем my_module .

  # Этот модуль показывает эффект
# многократный импорт и перезагрузка

print («Этот код был выполнен»)  

Теперь мы видим эффект от множественного импорта.

  >>> импортировать my_module
Этот код был выполнен
>>> импортировать my_module
>>> import my_module  

Мы видим, что наш код был выполнен только один раз.Это означает, что наш модуль был импортирован только один раз.

Теперь, если наш модуль изменился во время работы программы, нам пришлось бы его перезагрузить. Один из способов сделать это — перезапустить интерпретатор. Но это мало помогает.

Python предоставляет более эффективный способ сделать это. Мы можем использовать функцию reload () внутри модуля imp , чтобы перезагрузить модуль. Сделать это можно следующими способами:

  >>> импортный имп
>>> импортировать my_module
Этот код был выполнен
>>> импортировать my_module
>>> имп.перезагрузить (my_module)
Этот код был выполнен
<модуль 'my_module' из '. \\ my_module.py'>  

Встроенная функция dir ()

Мы можем использовать функцию dir () , чтобы узнать имена, определенные внутри модуля.

Например, мы определили функцию add () в модуле example , который у нас был в начале.

Мы можем использовать dir в модуле , пример следующим образом:

  >>> dir (пример)
['__builtins__',
'__cached__',
'__doc__',
'__файл__',
'__initializing__',
'__loader__',
'__имя__',
'__package__',
'добавить']  

Здесь мы видим отсортированный список имен (вместе с добавляем ).Все остальные имена, начинающиеся с подчеркивания, являются атрибутами Python по умолчанию, связанными с модулем (не определяемыми пользователем).

Например, атрибут __name__ содержит имя модуля.

  >>> пример импорта
>>> пример .__ имя__
'пример'  

Все имена, определенные в нашем текущем пространстве имен, можно узнать с помощью функции dir () без каких-либо аргументов.

  >>> а = 1
>>> b = "привет"
>>> импорт математики
>>> dir ()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']  

.Программа Python

для поиска HCF или GCD

Наивысший общий делитель (H.C.F) или наибольший общий делитель (G.C.D) двух чисел — это наибольшее положительное целое число, которое идеально делит два заданных числа. Например, H.C.F для 12 и 14 равняется 2.

.

Исходный код: Использование циклов

  # Программа Python для поиска H.C.F двух чисел

# определить функцию
def compute_hcf (x, y):

# выберите меньшее число
    если x> y:
        меньше = у
    еще:
        меньше = х
    для i в диапазоне (1, меньше + 1):
        если ((x% i == 0) и (y% i == 0)):
            hcf = я
    возврат hcf

число1 = 54
число2 = 24

print ("H.К.Ф. равно ", compute_hcf (num1, num2))
  

Выход

  H.C.F. это 6 
 

Здесь два целых числа, хранящиеся в переменных num1 и num2 , передаются в функцию compute_hcf () . Функция вычисляет H.C.F. эти два числа и возвращает его.

В функции мы сначала определяем меньшее из двух чисел, поскольку H.C.F может быть только меньше или равняться наименьшему числу. Затем мы используем цикл для , чтобы перейти от 1 к этому числу.

На каждой итерации мы проверяем, идеально ли наше число делит оба входных числа. Если это так, мы сохраняем номер как H.C.F. По завершении цикла мы получаем наибольшее число, которое идеально делит оба числа.

Вышеупомянутый метод прост для понимания и реализации, но неэффективен. Гораздо более эффективный метод поиска H.C.F. — алгоритм Евклида.

алгоритм Евклида

Этот алгоритм основан на том, что H.C.F. двух чисел также делит их разницу.

В этом алгоритме мы делим большее на меньшее и берем остаток. Теперь разделите меньшее на этот остаток. Повторяйте, пока остаток не станет 0.

Например, если мы хотим найти H.C.F. Из 54 и 24 мы делим 54 на 24. Остаток равен 6. Теперь мы делим 24 на 6, а остаток равен 0. Следовательно, 6 является требуемым H.C.F.

Исходный код: использование алгоритма Евклида

  # Функция для поиска HCF с использованием алгоритма Евклида
def compute_hcf (x, y):
   while (y):
       х, у = у, х% у
   вернуть х

hcf = compute_hcf (300, 400)
print ("ХКФ есть", hcf)  

Здесь мы зацикливаемся, пока y не станет равным нулю.Оператор x, y = y, x% y выполняет замену значений в Python. Щелкните здесь, чтобы узнать больше о замене переменных в Python.

На каждой итерации мы помещаем значение y в x , а остаток (x% y) в y одновременно. Когда y становится равным нулю, мы имеем H.C.F. в x .

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *