Как выглядит python программа

Примеры программ

Решение задачи C4 из диагностической работы ЕГЭ 2015

Для большинства учеников самой сложной и нерешаемой задачей в ЕГЭ по информатике является задача C4.

Поэтому я разберу одну из них, и покажу, как такие задачи можно решать на языке Python.

Интерпретатор hq9+

Сегодня мы напишем интерпретатор ещё одного эзотерического языка программирования, под названием hq9+.

Задача про словарь

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

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

Пишем блэкджек

Ну, точнее, не блэкджек, а его мини-вариант под названием очко.

Интерпретатор brainfuck

Сегодня я решил что-нибудь написать на python. Что-нибудь простенькое, но не очень. Решил остановиться на интерпретаторе brainfuck.

• Книги о Python
• GUI (графический интерфейс пользователя)
• Курсы Python
• Модули
• Новости мира Python
• NumPy
• Обработка данных
• Основы программирования
• Примеры программ
• Типы данных в Python
• Видео
• Python для Web
• Работа для Python-программистов

• Сделай свой вклад в развитие сайта!
• Самоучитель Python
• Карта сайта
• Отзывы на книги по Python
• Реклама на сайте

2.1. Теория¶

Язык Python является одним из самых простых в изучении и самых приятных в использовании из языков программирования, получивших широкое распространение. Программный код на языке Python легко читать и писать, и, будучи лаконичным, он не выглядит загадочным. Python — очень выразительный язык, позволяющий уместить приложение в меньшее количество строк, чем на это потребовалось бы в других языках, таких как C++ или Java.

2.1.1. История создания¶

Разработка языка Python была начата в конце 1980-х годов сотрудником голландского института CWI (Центр математики и информатики, голл. Centrum Wiskunde & Informatica) Гвидо ван Россумом (англ. Guido van Rossum), на основе языка ABC (Рисунок 2.1.1). В феврале 1991 года Гвидо опубликовал исходный текст в группе новостей alt.sources.

Рисунок 2.1.1 — Гвидо ван Россум на конференции в 2006 г. ¶

О создании Python Гвидо ван Россум написал в 1996 г.:

«Около 6 лет назад, в декабре 1989 г., я думал над проектом в области программирования в качестве хобби, которое бы заняло меня на время Рождественских выходных. Мой офис… был закрыл, но компьютер был и дома, и, в общем, это все, что у меня было на руках. Я решил написать интерпретатор для нового скриптового языка, о котором думал в последнее время: наследника ABC, который бы оказался привлекательным для Unix/C хакеров. Пилотное название «Питон» было выбрано с одной стороны в связи с немного скептическим отношением к перспективам проекта, а с другой — из-за того, что я большой фанат шоу «Летающий цирк Монти Пайтона».

Покинув в декабре 2012 года корпорацию Google, с 2013 года Гвидо работал в компании Dropbox Inc, выйдя на пенсию в 2019, а с 2020 работает в компании Microsoft. Имея статус «великодушного пожизненного диктатора» проекта — он продолжает наблюдать за процессом разработки Python, принимая окончательные решения, когда это необходимо (не менее 50% рабочего времени по договоренности с DropBox).

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

• ABC: отступы для группировки операторов, высокоуровневые структуры данных;
• Modula-3: пакеты, модули;
• С, C++: некоторые синтаксические конструкции;
• Smalltalk: ООП;
• Java: обработка исключений и др.

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

Развитие языка происходит согласно четко регламентированному процессу создания, обсуждения, отбора и реализации документов PEP (Python Enhancement Proposal) — предложений по развитию Python.

В 2008 году, после длительного тестирования, вышла первая версия Python 3000 (или Python 3.0, также используется сокращение Py3k). В Python 3000 устранены многие недостатки архитектуры с максимально возможным (но не полным) сохранением совместимости со старыми версиями Python. На сегодня поддерживаются обе ветви развития (Python 3.x и 2.x) (сравнение и рекомендации), однако получать новый функционал будет только версия 3 6.

Ключевые вехи развития языка приведены в Таблице 2.1.1.

Таблица 2.1.1 — Основные вехи развития языка Python ¶

Ветвь (дата выхода)

Актуальная версия (дата выхода) (могла устареть)

22 полезных примера кода на Python

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

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

1. Получаем гласные

Этот пример возвращает в строке найденные гласные «a e i o u» . Это может оказаться полезным при поиске или обнаружении гласных.

def get_vowels(String): return [each for each in String if each in "aeiou"] get_vowels("animal") # [a, i, a] get_vowels("sky") # [] get_vowels("football") # [o, o, a]

2. Первая буква в верхнем регистре

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

def capitalize(String): return String.title() capitalize("shop") # [Shop] capitalize("python programming") # [Python Programming] capitalize("how are you!") # [How Are You!]

3. Печать строки N раз

Этот пример может печатать любую строку n раз без использования циклов Python.

n=5 string="Hello World " print(string * n) #Hello World Hello World Hello World Hello World Hello World

4. Объединяем два словаря

Этот пример выполняет слияние двух словарей в один.

def merge(dic1,dic2): dic3=dic1.copy() dic3.update(dic2) return dic3 dic1= dic2= merge(dic1,dic2) #

5. Вычисляем время выполнения

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

import time start_time= time.time() def fun(): a=2 b=3 c=a+b end_time= time.time() fun() timetaken = end_time - start_time print("Your program takes: ", timetaken) # 0.0345

6. Обмен значений между переменными

Это быстрый способ обменять местами две переменные без использования третьей.

a=3 b=4 a, b = b, a print(a, b) # a= 4, b =3

7. Проверка дубликатов

Это самый быстрый способ проверки наличия повторяющихся значений в списке.

def check_duplicate(lst): return len(lst) != len(set(lst)) check_duplicate([1,2,3,4,5,4,6]) # True check_duplicate([1,2,3]) # False check_duplicate([1,2,3,4,9]) # False

8. Фильтрация значений False

Этот пример используется для устранения всех ложных значений из списка, например false, 0, None, » » .

def Filtering(lst): return list(filter(None,lst)) lst=[None,1,3,0,"",5,7] Filtering(lst) #[1, 3, 5, 7]

9. Размер в байтах

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

def ByteSize(string): return len(string.encode("utf8")) ByteSize("Python") #6 ByteSize("Data") #4

10. Занятая память

Пример позволяет получить объём памяти, используемой любой переменной в Python.

import sys var1="Python" var2=100 var3=True print(sys.getsizeof(var1)) #55 print(sys.getsizeof(var2)) #28 print(sys.getsizeof(var3)) #28

11. Анаграммы

Этот код полезен для проверки того, является ли строка анаграммой. Анаграмма — это слово, полученное перестановкой букв другого слова.

from collections import Counter def anagrams(str1, str2): return Counter(str1) == Counter(str2) anagrams("abc1", "1bac") # True

12. Сортировка списка

Этот пример сортирует список. Сортировка — это часто используемая задача, которую можно реализовать множеством строк кода с циклом, но можно ускорить свою работу при помощи встроенного метода сортировки.

my_list = ["leaf", "cherry", "fish"] my_list1 = ["D","C","B","A"] my_list2 = [1,2,3,4,5] my_list.sort() # ['cherry', 'fish', 'leaf'] my_list1.sort() # ['A', 'B', 'C', 'D'] print(sorted(my_list2, reverse=True)) # [5, 4, 3, 2, 1]

13. Сортировка словаря

orders = < 'pizza': 200, 'burger': 56, 'pepsi': 25, 'Coffee': 14 >sorted_dic= sorted(orders.items(), key=lambda x: x[1]) print(sorted_dic) # [('Coffee', 14), ('pepsi', 25), ('burger', 56), ('pizza', 200)]

14. Получение последнего элемента списка

my_list = ["Python", "JavaScript", "C++", "Java", "C#", "Dart"] #method 1 print(my_list[-1]) # Dart #method 2 print(my_list.pop()) # Dart

15. Преобразование разделённого запятыми списка в строку

Этот код преобразует разделённый запятыми список в единую строку. Его удобно использовать, когда нужно объединить весь список со строкой.

my_list1=["Python","JavaScript","C++"] my_list2=["Java", "Flutter", "Swift"] #example 1 "My favourite Programming Languages are" , ", ".join(my_list1)) # My favourite Programming Languages are Python, JavaScript, C++ print(", ".join(my_list2)) # Java, Flutter, Swift

16. Проверка палиндромов

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

def palindrome(data): return data == data[::-1] palindrome("level") #True palindrome("madaa") #False

17. Перемешивание списка

from random import shuffle my_list1=[1,2,3,4,5,6] my_list2=["A","B","C","D"] shuffle(my_list1) # [4, 6, 1, 3, 2, 5] shuffle(my_list2) # ['A', 'D', 'B', 'C']

18. Преобразование строки в нижний и верхний регистры

str1 ="Python Programming" str2 ="IM A PROGRAMMER" print(str1.upper()) #PYTHON PROGRAMMING print(str2.lower()) #im a programmer

19. Форматирование строки

Этот код позволяет форматировать строку. Под форматированием в Python подразумевается присоединение к строке данных из переменных.

#example 1 str1 ="Python Programming" str2 ="I'm a <>".format(str1) # I'm a Python Programming #example 2 - another way str1 ="Python Programming" str2 =f"I'm a " # I'm a Python Programming

20. Поиск подстроки

Этот пример будет полезен для поиска подстроки в строке. Я реализую его двумя способами, позволяющими не писать много кода.

programmers = ["I'm an expert Python Programmer", "I'm an expert Javascript Programmer", "I'm a professional Python Programmer" "I'm a beginner C++ Programmer" ] #method 1 for p in programmers: if p.find("Python"): print(p) #method 2 for p in programmers: if "Python" in p: print(p)

21. Печать в одной строке

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

# fastest way import sys sys.stdout.write("Call of duty ") sys.stdout.write("and Black Ops") # output: Call of duty and Black Ops #another way but only for python 3 print("Python ", end="") print("Programming") # output: Python Programming

22. Разбиение на фрагменты

Этот пример покажет, как разбить список на фрагменты и разделить его на меньшие части.

def chunk(my_list, size): return [my_list[i:i+size] for i in range(0,len(my_list), size)] my_list = [1, 2, 3, 4, 5, 6] chunk(my_list, 2) # [[1, 2], [3, 4], [5, 6]]

На правах рекламы

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

• Блог компании VDSina.ru
• Python
• Программирование

Примеры программ на языке Python

Данный пример чисто демонстрационный, так как его можно значительно улучшить.

from urllib import urlopen # из модуля urllib импортируем функцию urlopen u = urlopen("http://python.org") # открываем URL на чтение words = <> # связываем имя words с пустым словарём # (словарь — неупорядоченный [[ассоциативный массив]]) for line in u: # читаем u по строкам line = line.strip(" \n") # отбрасываем начальные и конечные пробелы for word in line.split(" "): # режем каждую строку на слова, ограниченные пробелами try: # блок обработки исключений words[word] += 1 # пытаемся увеличить words[word] на единицу except KeyError: # если не получилось (раньше words[word] не было) words[word] = 1 # присваиваем единицу # теперь словарь words содержит частоту встречаемости каждого слова. # Например, words может содержать pairs = words.items() # делаем из словаря список пар # pairs == [("яблоко",5), ("апельсин",12), ("груша",8)] pairs.sort(key=lambda x: x[1], reverse=True) # сортируем по убыванию второго элемента пары for p in pairs[:10]: # печатаем первые 10 элементов списка print(p[0], p[1]) 

Текст для версии 3.7.1

from urllib.request import urlopen # из модуля urllib импортируем функцию urlopen u = urlopen("http://python.org") # открываем URL на чтение words = <> # связываем имя words с пустым словарём # (словарь — неупорядоченный [[ассоциативный массив]]) for line in u: # читаем u по строкам line =line.decode("utf-8") # преобразуем байт-строку в строку line = line.strip(" \n") # отбрасываем начальные и конечные пробелы for word in line.split(" "): # режем каждую строку на слова, ограниченные пробелами try: # блок обработки исключений words[word] += 1 # пытаемся увеличить words[word] на единицу except KeyError: # если не получилось (раньше words[word] не было) words[word] = 1 # присваиваем единицу # теперь словарь words содержит частоту встречаемости каждого слова. # Например, words может содержать pairs = words.items() # делаем из словаря список пар # pairs == [("яблоко",5), ("апельсин",12), ("груша",8)] A= sorted (pairs, key=lambda x: x[1], reverse=True) # сортируем по убыванию второго элемента пары for p in A[:10]: # печатаем первые 10 элементов списка print(p[0], p[1]) 

Примеры работы с последовательностями править

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

>>> l = ['A', 'B', 'C', 'D', 'E'] # исходный список >>> # 0 1 2 3 4 5 # пронумерованные промежутки между элементами >>> # -5 -4 -3 -2 -1 # нумерация с конца >>> l[0:2] # срез от нулевого до второго промежутка ['A', 'B'] >>> l[1:-2] # срез от второго до второго с конца элемента ['B','C'] >>> l[1::2] # каждый второй элемент начиная с первого ['B', 'D'] >>> l[::-1] # все элементы в обратном порядке ['E', 'D', 'C', 'B', 'A'] 

Функции подобные range() поддерживают то же правило (для версий языка 2.x):

>>> range(2, 5) [2, 3, 4] >>> range(5) [0, 1, 2, 3, 4] 

>>> [0]*10 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> [ i for i in range(5) if i%2==0] [0, 2, 4] 

import sys # для получения объектов из вышележащих фрэймов стека

class CannotResolve(Exception): # класс исключения для случая ненахождения функции

pass

class Resolver(object): # класс, реализующий разрешение на этапе исполнения

emess = "Can't found appropriate signature of func %s() for call with" + \ " params %r" # сообщение об ошибке def __init__(self,name): # конструктор self.function_map = <> # словарь, отображающий типы параметров на функции self.default = None # функция по умолчанию self.name = name # имя функции для вывода сообщений об ошибках def __call__(self,*dt): # имитируем функцию, принимающую любое количество # позиционных параметров cls = tuple(map(type,dt)) # создаем tuple из типов переданных аргументов # функция type возвращает тип своего параметра # map вызовет type для каждого элемента из dt try: x = self.function_map[cls] # пытаемся получить функцию из словаря except KeyError: # если подходящей нет, if self.default is not None: # используем функцию по умолчанию x = self.default else: # если её нет - возбуждаем исключение raise CannotResolve(self.emess % (self.name,cls)) return x(*dt) # вызываем функцию и возвращаем результат

def overload(*dt): # декоратор для перегрузки в качестве параметров

# принимает типы параметров def closure(func): name = func.__name__ # получаем имя функции fr = sys._getframe(1).f_locals.get(name,Resolver(name)) # опускаемся на один шаг вниз по стеку и находим # локальную переменную с именем функции # если же ее нет, то используем новый # Resolver-объект fr.function_map[dt] = func # добавляем новую функцию к словарю # разрешения вызовов return fr return closure

def overdef(func): # для создания функции по умолчанию

name = func.__name__ # аналогично как и в функции overload fr = sys._getframe(1).f_locals.get(name,Resolver(name)) fr.default = func return fr

1. теперь воспользуемся полученными декораторами

@overdef # это будет функция по умолчанию def f(*dt,**mp):

print ("Default call") # если нет явного return, то вернется None

@overload(int) # единственный параметр — целое def f(x):

return x + 1

@overload(str) # единственный параметр — строка def f(x):

return x + "1"

@overload(str,int) # строка и целое def f(x,y):

return x + str(y)

print (f»1″) # напечатает : 2 print (f»1″) # напечатает : 11 f(2,2) # напечатает : Default call

Управление контекстом выполнения править

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

from __future__ import with_statement # задействует оператор with в коде from contextlib import contextmanager from threading import Lock # Описание менеджера контекста @contextmanager def locked(lock): lock.acquire() try: yield finally: lock.release() # Определение блокировки myLock = Lock() # Применение оператора with locked(myLock): # print "Охраняемый блок кода. Блокировка будет освобождена при любом выходе из этого блока." # 

Генератор чисел Фибоначчи править

Пример генератора чисел Фибоначчи и его использования:

def fibonacci(max): # генератор (а не функция, т.к. оператор return заменён на yield) a, b = 0, 1 while a  max: yield a # return a, + запоминаем место рестарта для следующего вызова a, b = b, a + b # параллельное присваивание, которое выполняется одновременно и параллельно for n in fibonacci(100): # используем генератор fibonacci() как итератор print(n) # печатаем все числа Фибоначчи меньшие 100 через пробел 

Альтернативный синтаксис доступа к элементам словаря править

Можно определить словарь, который в дополнение к обычному синтаксису доступа к значению по ключу d[key] может предоставлять синтаксически более наглядный доступ к атрибуту d.key в случае алфавитно-цифровых ключей:

class Entity(dict): # наследуем класс от __builtin__.dict def __getattr__(self, key): # этот метод будет вызван, если атрибут # с именем key не будет найден у экземпляра класса try: return self[key] # пытаемся вернуть элемент словаря except KeyError, k: # если такого элемента нет, то возбуждаем raise AttributeError, k # исключение AttributeError # по договоренности __getattr__ # не должно возбуждать других исключений def __setattr__(self, key, value): # этот метод будет вызван при присвоении self[key] = value # атрибуту key значения value def __delattr__(self, key): # а этот при удалении атрибута try: # с помощью del mydict.g del self[key] except KeyError, k: raise AttributeError, k def __repr__(self): # используется функцией repr return self.__class__.__name__ + "(" + dict.__repr__(self) + ")" d = Entity(a=1) d.b_100 = 100 assert d.a == d['a'] and d.b_100 == d['b_100'] 

Функтор с генерацией байтокода править

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

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

Это только пример, он реализует всего одну операцию — сложение и имеет несколько других ограничений.

#------------------------------------------------------------------------------- import byteplay # специальный модуль для удобной работы с Python-байтокодом import new # для создания функции во время исполнения import functools # для update_wrapper import inspect # для получения информации о параметрах, принимаемых функцией #------------------------------------------------------------------------------- class FastFunctor(object): def __init__(self,func,code = None): self.func = None # здесь будем хранить результирующую функцию self.ofunc = func # а здесь исходную(original) функцию if code is None: # конструируем байтокод для вызова функции self.code = [(byteplay.LOAD_CONST,func)] rparams = inspect.getargspec(func)[0] # получаем список параметров, принимаемых функцией self.code.extend((byteplay.LOAD_FAST,i) for i in rparams) self.code.append((byteplay.CALL_FUNCTION,len(rparams))) else: # если же функтор создан из другого функтора, # то только копируем переданный байтокод self.code = code # создаем новый объект кода self.ocode = bp.Code.from_code(func.func_code) def __add__(self,obj): # этот метод вызывается для операции '+' code = self.code[:] # копируем байтокод if isinstance(obj,FastFunctor): # если прибавляемый объект - функтор # просто дописываем его код к нашему # после своего исполнения он "оставит" в вершине стека результат code.extend(obj.code) else: # иначе загружаем объект в стек code.append((byteplay.LOAD_CONST,obj)) # дописываем байтокод, складывающий два верхних элемента в стеке code.append((byteplay.BINARY_ADD ,None )) # создаем новый функтор, с байтокодом получения суммы return self.__class__(self.ofunc,code = code) def __call__(self,*dt,**mp): # этот метод будет вызван для операции вызова object() return self.fast()(*dt,**mp) # конструируем и вызываем функцию def fast(self): # конструируем функцию из байтокода if self.func is None: # если функция не была создана раннее code = self.code + [(bp.RETURN_VALUE,None)] # добавляем байтокод возврата oc = self.ocode # создаем объект кода из байтокода и другой информации bin_code = byteplay.Code(code, oc.freevars, oc.args, oc.varargs, oc.varkwargs, oc.newlocals, "%s>" % id(self), "%s>" % id(self), 0, "auto_generated code") # конструируем новую функцию из объекта кода self.func = new.function(bin_code.to_code(),globals()) # после этой операции для всех средств интроспекции # созданная функция будет выглядеть как оригинальная self.func = functools.update_wrapper(self.func,self.ofunc) return self.func 

# Ниже представлено тестирование скорости объектов FastFunctor и SlowFunctor # (статья "Функциональное программирование на Python", см. сноску после блока кода) # из IPython (для удобства чтения лог немного изменен) # строки, начинающиеся с "In [XX]:" вводятся, остальные — вывод интерпретатора In [1]: import fastfunctor In [2]: func = lambda x : x + 1 # Создаем очень простую функцию In [3]: vl = 1 # Переменная, для предотвращения оптимизации In [4]: functor = fastfunctor.Functor(func) In [5]: %timeit (functor + functor + 1)(vl) # Тестируем "лобовой" способ 1000 loops, best of 3: 661 mks per loop # Очень медленно In [6]: functor2 = (functor + functor + 1) # Конструируем функтор один раз In [7]: %timeit functor2(vl) # и тестируем только непосредственно вызов 100000 loops, best of 3: 4.52 mks per loop # Значительно лучше In [8]: functor3 = (functor + functor + 1).fast() # Получаем результирующую функцию In [9]: %timeit functor3(vl) 1000000 loops, best of 3: 1.42 mks per loop In [10]: def of(vl): return x(vl) + x(vl) + 1 # Создаем функцию "вручную" In [11]: %timeit of(vl) 1000000 loops, best of 3: 1.42 mks per loop # Скорость полностью совпадает со # скоростью функтора In [12]: sfunctor = SlowFunctor(func) # Простая реализация функтора In [13]: sfunctor = sfunctor + sfunctor + 1 # In [14]: %timeit sfunctor(vl) # 100000 loops, best of 3: 12.6 mks per loop # Примерно в 9 раз медленнее, чем статический # вариант

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

Используя эту технику, можно создать полноценный функтор, добавив функции для других операций ( __sub__, __div__ и другие) и расширив его на случай нескольких входных функций с разными аргументами.

Транспонирование матрицы править

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

from pprint import pprint # модуль pprint используется для удобного вывода на экран matrix = [[0.5, 0, 0, 0, 0], [ 1, 0.5, 0, 0, 0], [ 1, 1, 0.5, 0, 0], [ 1, 1, 1, 0.5, 0], [ 1, 1, 1, 1, 0.5]] matrix_t = list(zip(*matrix)) # непосредственно транспонирование pprint(matrix) pprint(matrix_t) 

[[0.5, 0, 0, 0, 0], [1, 0.5, 0, 0, 0], [1, 1, 0.5, 0, 0], [1, 1, 1, 0.5, 0], [1, 1, 1, 1, 0.5]] [[0.5, 1, 1, 1, 1], [0, 0.5, 1, 1, 1], [0, 0, 0.5, 1, 1], [0, 0, 0, 0.5, 1], [0, 0, 0, 0, 0.5]] 

Нахождение Факториала править

factorial = lambda x: factorial(x - 1) * x if x > 1 else 1 

Решение квадратного уравнения править

Простая программа для решения квадратных уравнений (то есть вида: ax 2 +bx+c=0). Даются небольшие пояснения, каким образом уравнение решается в том или ином случае (например, для неполных квадратных уравнений).

a = int(input('a = ', )) # запрашиваем первый коэффициент b = int(input('b = ', )) # запрашиваем второй коэффициент c = int(input('c = ', )) # запрашиваем третий коэффициент if a!= 0 and b % 2 == 0 and c!= 0: # решение по сокращенной формуле, т.к. b - четное k = b / 2 d1 = k ** 2 - a * c k1 = (-k + d1 ** 0.5) / a k2 = (-k - d1 ** 0.5) / a print('так как коэффициент b - четное число, решаем по сокращенной формуле') print(f'k1 = k1>') print(f'k2 = k2>') if a != 0 and b % 2 != 0 and c != 0: # решение полного уравнения d = b ** 2 - 4 * a * c if d > 0: k1 = (-b + d ** 0.5) / (2 * a) print(f'дискриминант равен: d>') print(f'первый корень равен: round(k1, 2)>') k2 = (-b - d ** 0.5) / (2 * a) print(f'второй корень равен: round(k2, 2)>') elif d  0: print(f'так как дискриминант меньше нуля и равен: d>') print('действительных корней нет') else: k = -b / (2 * a) print(f'уравнение имеет один корень: k>') if a != 0 and c != 0 and b == 0: # решение уравнения при b = 0 if (- c / a) >= 0: k1 = (-c / a) ** 0.5 print(f'первый корень равен: k1>') k2 = (-1) * ((-c / a) ** 0.5) print(f'второй корень равен: k2>') if (- c / a)  0: print(f' -c / a = : -c / a>, т.е. < 0, поэтому действительных корней нет') if a != 0 and c== 0 and b != 0: # решение уравнения при с = 0 print(f'корень уравнения равен либо нулю, либо -b / a>') if a != 0 and b== 0 and c == 0: # решение уравнения при b = 0 и c = 0 print(f'корни уравнения равны нулю, a*x**2 = 0') 

Что такое дробь править

cls @ECHO OFF title Folder Private if EXIST «HTG Locker» goto UNLOCK if NOT EXIST Private goto MDLOCKER

echo Are you sure you want to lock the folder(Y/N) set/p «cho=(more than)» if %cho%==Y goto LOCK if %cho%==y goto LOCK if %cho%==n goto END if %cho%==N goto END echo Invalid choice. goto CONFIRM

ren Private «HTG Locker» attrib +h +s «HTG Locker» echo Folder locked goto End

echo Enter password to unlock folder set/p «pass=(more than)» if NOT %pass%== [Ваш пароль] goto FAIL attrib -h -s «HTG Locker» ren «HTG Locker» Private echo Folder Unlocked successfully goto End

echo Invalid password goto end

md Private echo Private created successfully goto End

Вычисление числа Пи править

from decimal import * getcontext().prec = int(input('Введите начальную точность:')) # Десятичная точность. def Factorial(F): result = 1 for i in range(2, F + 1): result *= i return result b = int(input('Введите число слагаемых:')) # Число слагаемых. n = 0 k = 0 while k  b: getcontext().prec += 20 # Увеличивается точность. n += (Decimal(Factorial(4 * k) / (Factorial(k) ** Decimal(4))) * Decimal( (1103 + 26390 * k) / (Decimal((4 * 99) ** Decimal(4 * k))))) k += 1 N = n n = Decimal(9801) / (Decimal(Decimal(2 * (Decimal(2 ** Decimal(0.5))) * N))) print(Decimal(n)) input() 

Тренажёр для изучения координат править

Программа, интересная и как тренажёр для учебной работы с координатами (5-7 класс) и как пример несложной программы, которую может написать начинающий программист (8-9 класс)

from tkinter import import random okno = Tk() okno.geometry('1500x700+0+0') koordinatkax=random.randint(-15,15) koordinatkay=random.randint(-6,6) holst = Canvas(okno, width=1500, height = 600, bg = "white") holst.create_line(0,300,1500,300,fill="black",width=3,arrow=LAST) holst.create_line(750,600,750,0,fill="black",width=3,arrow=LAST) metka = Label(okno,font=20,text="Привет всем! Найди точку с координатами x o">+ str(koordinatkax) + ", y o">+ str(koordinatkay)) metka.place(x = 0,y = 620) metkaX = Label(holst,font=20,text="X") metkaX.place(x = 1475,y =310) metkaY = Label(holst,font=20,text="Y") metkaY.place(x =760,y = 10) #положительные метки Y metka1Y = Label(holst,font=20,text="1") metka1Y.place(x =725,y = 240) #метка 0 metka0 = Label(holst,font=20,text="0") metka0.place(x =725,y = 305) #положительные метки X metka1X = Label(holst,font=20,text="1") metka1X.place(x =792,y = 308) #отрицательные метки Y metka1Y = Label(holst,font=20,text="-1") metka1Y.place(x =725,y = 340) #отрицательные метки X metka1X = Label(holst,font=20,text="-1") metka1X.place(x =692,y = 308) for i in range(14): holst.create_line(0,50*i,1500,50*i,fill="black",width=1) holst.create_line(745,50*i,755,50*i,fill="black",width=3) for i in range(30): holst.create_line(50*i,0,50*i,600,fill="black",width=1) holst.create_line(50*i,295,50*i,305,fill="black",width=3) holst.place(x=0,y=0) knopka = Button(okno) knopka.place(x = 50,y = 650) def gdelevyklik(event): xo = koordinatkax*50+750 yo = 300-koordinatkay*50 if int(((event.x-xo)**2+(event.y-yo)**2)**0.5)  5: okno.title("Молодец! Левая кнопка мыши нажата" + str(event.x) + " " + str(event.y)) else: okno.title("Не правильно! Левая кнопка мыши нажата" + str(event.x) + " " + str(event.y)) holst.bind('', gdelevyklik)