Краткое пособие по языку программирования Python

Содержание

Немного о языке

Python язык уже не очень молодой (1991 г), но невероятно популярный в наше время.

Разрабатывается сообществом во главе с Гвидо Ван Россумом ("Пожизненным Великодушным Диктатором")

Свойства Python:

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

Области применения:

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

Имеются две основные версии:

  • 2.х
  • 3.х

Основное различие:

  • поддержка Python 2.7 заканчивается в 2020 году.
  • в 3-ей версии строки переведены в Unicode.
  • в 3-ей версии у функции print появились скобки
  • имеются различия в стандартной библиотеке

Лучше сразу начинать программировать в 3-ей версии!

Начало работы

Python можно использовать в двух основных режимах:

  • диалоговом (REPL)
  • пакетном

Рассмотрим работу с Python в режиме REPL

  • READ
  • EVAL
  • PRINT
  • LOOP

Запуск интерпретатора команд:

python3
Python 3.7.4 (default, Jul  9 2019, 18:15:00)
[Clang 10.0.0 (clang-1000.11.45.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

Для выхода из интерактивного режима введите quit() или exit().

Мы можем использовать его в режиме калькулятора

>>> 2+2
4

Причем с поддержкой очень больших чисел:

>>> 2**64
18446744073709551616L

L - указывает на длинный целочисленный тип

Результат деления:

>>> 5//2
2
>>> 5.0/2
2.5

Точность вычислений:

>>> 1.001+5
6.0009999999999994
>>>round(1.001+5)
6
>>>round(1.001+5,2)
6.0
>>> round(1.001+5,3)
6.001
>>>

Представление чисел в двоичной системе:

>>> bin(5)
'0b101'

В шестнадцатиричной:

>>> hex(15)
'0xf'

Работа в пакетном режиме

Необходимо подготовить текст программы в файле с расширением .py, а затем выполнить его:

python3 имя.py

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

Переменные, операторы, выражения

Типы данных

  • None (неопределенное значение переменной)
  • Логические переменные (Boolean Type)
  • Числа (Numeric Type) – int – целое число – float – число с плавающей точкой – complex – комплексное число
  • Списки (Sequence Type) – list – список – tuple – кортеж – range – диапазон
  • Строки (Text Sequence Type ) – str
  • и др.

Объявление переменной:

a=5

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

Тип можно узнать функцией type:

>>> a=5
>>> type(a)
<class 'int'>

Еще примеры:

>>> a = 10
>>> b = "hello"
>>> c = (1, 2)
>>> type(a)
<class 'int'>
>>> type(b)
<class 'str'>
>>> type(c)
<class 'tuple'>

Операции над строками

Конкатенация:

>>> message="hello"
>>> print(message)
hello
>>> print(message + '!')
hello!

Строки можно дублировать:

>>> print('spam' * 3)
spamspamspam

Длина строки:

>>> len('spam')
4

Доступ к частям строки:

>>> S = 'spam'
>>> S[0]
's'
>>> S[2]
'a'
>>> S[-2]
'a'

Работа со срезами:

>>> s = 'spameggs'
>>> s[3:5]
'me'
>>> s[2:-2]
'ameg'
>>> s[:6]
'spameg'
>>> s[1:]
'pameggs'
>>> s[:]
'spameggs'

Срез с шагом:

>>> s[::-1]
'sggemaps'
>>> s[3:5:-1]
''
>>> s[2::2]
'aeg'
  • S = 'str'; S = "str"; S = '''str'''; S = """str""" Литералы строк
  • S = "s\np\ta\nbbb" Экранированные последовательности
  • S = r"C:\temp\new" Неформатированные строки (подавляют экранирование)
  • S = b"byte" Строка байтов
  • S1 + S2 Конкатенация (сложение строк)
  • S1 * 3 Повторение строки
  • S[i] Обращение по индексу
  • S[i:j:step] Извлечение среза
  • len(S) Длина строки
  • S.find(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или -1
  • S.rfind(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
  • S.index(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
  • S.rindex(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
  • S.replace(шаблон, замена) Замена шаблона
  • S.split(символ) Разбиение строки по разделителю
  • S.isdigit() Состоит ли строка из цифр
  • S.isalpha() Состоит ли строка из букв
  • S.isalnum() Состоит ли строка из цифр или букв
  • S.islower() Состоит ли строка из символов в нижнем регистре
  • S.isupper() Состоит ли строка из символов в верхнем регистре
  • S.isspace() Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы ('\f'), "новая строка" ('\n'), "перевод каретки" ('\r'), "горизонтальная табуляция" ('\t') и "вертикальная табуляция" ('\v'))
  • S.istitle() Начинаются ли слова в строке с заглавной буквы
  • S.upper() Преобразование строки к верхнему регистру
  • S.lower() Преобразование строки к нижнему регистру
  • S.startswith(str) Начинается ли строка S с шаблона str
  • S.endswith(str) Заканчивается ли строка S шаблоном str
  • S.join(список) Сборка строки из списка с разделителем S
  • ord(символ) Символ в его код ASCII
  • chr(число) Код ASCII в символ
  • S.capitalize() Переводит первый символ строки в верхний регистр, а все остальные в нижний
  • S.center(width, [fill]) Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
  • S.count(str, [start],[end]) Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
  • S.expandtabs([tabsize]) Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
  • S.lstrip([chars]) Удаление пробельных символов в начале строки
  • S.rstrip([chars]) Удаление пробельных символов в конце строки
  • S.strip([chars]) Удаление пробельных символов в начале и в конце строки
  • S.partition(шаблон) Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
  • S.rpartition(sep) Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
  • S.swapcase() Переводит символы нижнего регистра в верхний, а верхнего – в нижний
  • S.title() Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
  • S.zfill(width) Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
  • S.ljust(width, fillchar=" ") Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
  • S.rjust(width, fillchar=" ") Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
  • S.format(*args, **kwargs) Форматирование строки

Преобразования из строк в числа и наоборот

>>> a="123"
>>> int(a)
123
>>> float(a)
123.0
>>>
>>> "123"+str(5)
'1235'
>>>
>>> bin(256)
'0b100000000'
>>> s=bin(256)
>>> s2=s[2:]
>>> s2
'100000000'
>>>

>*Упражнение* >Определить, сколько единиц в представлении числа 257 с помощью средств работы со строками

> Решение:

s1=bin(257)
s2=s1[2:]
s2.count('1')

Операторы ветвления

if num > 0:
    print("Число больше нуля") 
else:
    print("Число меньше или равно нулю") 

Ветвлений может быть много:

if num > 0:
    print("Число больше нуля") 
elif num < 0:
    print("Число меньше нуля")
else:
    print("Число равно нулю")

Задание: написать код с проверкой возраста

age=input("Введи свой возраст: ")
if age >=18:
   print("Доступ разрешен")
else:
   print("Доступ запрещен")

Операторы цикла

Операторы цикла позволяют задавать повторение некоторого действия (группы действий).

>>> i = 5
>>> while i < 15:
...     print(i)
...     i = i + 2
...
5
7
9
11
13
>>> for i in 'hello world':
...     if i == 'o':
...         continue
...     print(i * 2, end='')
...
hheellll  wwrrlldd
for number in [0, 1, 2, 3, 4]:
    print(number)
0
1
2
3
4
for number in range(10):
    if number % 2 == 0:
        print(number)
>>> for i in range(10):
...   print(i)
...
0
1
2
3
4
5
6
7
8
9

Списки и кортежи

Список - это набор изменяемых элементов. Кортеж - набор неизменяемых.

Создание списка:

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

Создание кортежа:

>>> tuple(range(5))
(0, 1, 2, 3, 4)

Создание пустых списка и кортежа:

a=[]
b=()

Как ссылаться на элементы? Можно делать это через индекс, например [0]. Можно ссылаться на часть списка, например [1:]

>>> a=[1,2,3,4,5]
>>> a[0]
1
>>> a[1:]
[2, 3, 4, 5]
>>>

Можно ссылаться на подмассив:

>>> a[1:3]
[2, 3]
>>>

А вот так можно указывать элементы с конца:

>>> a[:-1]
[1, 2, 3, 4]
>>> a[:-2]
[1, 2, 3]
>>>

Функции

Основы

Объявление функции в Питоне:

def fname(parameters):
   body

Функция без параметров

def hello():
   print("Hello, all!")

Функция с параметром

def hello(name):
   print("Hello, "+name)

Вызов функции:

hello("Вася")

Более сложный пример:

# Build and return a list
def firstn(n):
  num, nums = 0, []
  while num < n:
    nums.append(num)
    num += 1
  return nums

lst=firstn(100) 
sum_of_first_n = sum(lst)
print(sum_of_first_n)
print(lst)

Из функции возвращается список, который можно обработать стандартной функцией sum, в результате определяется сумма элементов списка

Можно вернуть пару явно

def pair():
  return [2,2]

print(pair())

Если написать без скобок, то возвращается "кортеж" (?) (2,2)

Рассмотрим пример функции, считающую последовательность Фибоначчи:

def fib(n):    
     a, b = 0, 1
     while a < n:
       print(a, end=' ')
       a, b = b, a+b
       print()

>>> fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Вариант той же функции, только с возвращением списка:

>>> def fib2(n):  
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    
>>> f100            
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Рекурсия

Рассмотрим вычисление факториала:

>>> def fact(n):
...   if n<=1:
...     return 1
...   else:
...     return n*fact(n-1)
...
>>> fact(10)
3628800
>>>

>*Упражнение* >Написать функцию, определяющую сумму элементов списка двумя способами: итеративным (циклом) и рекурсивным.

Лямбда-функции

Безымянные функции, которые можно сохранить в переменной или сразу вызвать.

square=lambda x: x*x
print(square(10))

Можно и так:

print( (lambda x: x*x)(5) )

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

def getfun():
  return lambda x:x*x
print(getfun()(2))

Самое главное и очевидное применение: использование в качестве параметров там, где функция используется однократно

a=[53,78,23,79,0,34,12,92,112]
b=sorted(a,key=lambda x: x%10)
print(b)
>>>[0, 12, 92, 112, 53, 23, 34, 78, 79]

Массив сортируется, исходя из значения параметра `key` (остаток от деления на 10).

Специальные функции для обработки данных

Определим сумму ряда чисел от 1 до 100 (включительно)

print(sum(range(1,101)))
>>> 5050

Зададим функцию-предикат, проверяющую, делится ли аргумент с остатком на 2 и на 3

def f(x): return x % 2 != 0 and x % 3 != 0

Теперь можно отфильтровать из ряда числа, удовлетворяющие данному условию

>>> list(filter(f,range(1,101)))
[1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97]

И последнее: можно найти сумму этих чисел:

>>> sum(list(filter(f,range(1,101))))
1633

> Упражнение: > Перепишите выражение с использованием lambda-функции

Еще одна полезная и интересная функция - map. Она применяет функцию к каждому элементу списка.

>>> list(map(lambda x: x*x,range(10)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Функция `reversed` переставляет элементы списка в обратном порядке:

list(reversed(list(map(lambda x: x*x,range(10))))
>>>[81, 64, 49, 36, 25, 16, 9, 4, 1, 0]

Задания

  • Напишите функцию, проверяющую, является ли список палиндромом (последовательности слева направо и справа налево совпадают). Функция возвращает либо `True` либо `False`
  • Написать функцию репликатор, которая получает на вход список и число, далее формирует список, в котором каждый элемент повторяется заданное число раз
  • Написать функцию, проверяющую, является ли переданное число простым

Списковые выражения

Списковые выражения создают список элементов

>>> [x for x in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Решим задачу с генерацией списка, куда входят числа, делящиеся с остатком на 2 и на 3:

[x for x in range(100) if x % 2 != 0 and x % 3 != 0]
[1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97]

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

>>> a = []
>>> for i in range(1,15):
...     a.append(i)
... 
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

а теперь с помощью спискового выражения:

>>> a = [i for i in range(1,15)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Извлекаем из строки цифры:

>>> a = "lsj94ksd231 9"
>>> b = [int(i) for i in a if '0'<=i<='9']
>>> b
[9, 4, 2, 3, 1, 9]

Генераторы

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

Генераторы - итерируемые объекты, но, в общем случае, вы можете их использовать только один раз. Это связано с тем, что они не хранят все значения в памяти, а генерируют значения "на лету" - по мере запроса:

Простейшее определение генератора:

def generate_ints(N):
    for i in range(N):
        yield i

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

list(generate_ints(10))
>>>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Генераторы позволяют создавать списки проще и быстрее.

Выходные данные генератора такие же, как у списка. Так в чем же разница? Одно из главных отличий заключается в том, как в список и генератор хранят элементы в памяти. Списки хранят все элементы в памяти сразу, тогда как генераторы "создают" каждый элемент на лету, отображая их, а затем перемещаются к следующему элементу, удаляя предыдущий элемент из памяти.

список можно перебирать столько раз, сколько захотите, но генератор можно перебирать только один раз. Для повторной итерации необходимо создать генератор снова.

yield

Ключевое слово yield, в отличие от оператора return, используется для превращения обычной функции Python в генератор. Оно используется в качестве альтернативы одновременному возвращению целого списка.

Получение значение из генератора:

def gen():
   for i in (1,2,3):
     yield i
g=gen()
next(g)
>>>1

> Задача > - Написать реализацию бесконечной последовательности чисел с помощью генератора. Можно взять последовательность Фибоначчи или последовательность простых чисел

Небольшие фокусы

Функция `eval` позволяет выполнить выражение Питона, заданного в виде строки:

eval("2+2")
>>>4

> Задача

> - Написать функцию, проверяющую правильность расстановки скобок в арифметическом выражении.

> - Написать функцию, вычисляющую арифметическое выражение, записанное в префиксной форме. Выражение задается как набор бинарных операций в круглых скобках, то есть (* (- 2 1) (/ 4 2)). Скобки для группировки операций обязательны.

> - Подсчитать количество счастливых билетов, их процент ко всем шестизначным билетам

Псевдослучайные числа

Функции для работы с псевдослучайными числами находятся в модуле random.

import random
value=random.randrange(N)

> Задача

> - Реализовать неэффективную "болотную" сортировку,в которой элементы выстраиваются на произвольные (случайные) позиции. Сортировка продолжается до тех пор, пока элементы случайно не займут правильные позиции. Посмотреть в документации, как измерить время работы программы.

Работа с файлами

Основные функции работы с файлами:

open - открытие файла

В следующем примере мы открываем файл на чтение и читаем его содержимое в список строк

f=open("имя")
text=lst(f)

> Задача > - Написать программу, выводящую случайный афоризм из текстового файла на экран. Написать реализацию с помощью генератора

Регулярные выражения в Python

Сначала импортируем пакет:

import re

Самые популярные средства для работы с регулярными выражениями

  • re.match()
  • re.search()
  • re.findall()
  • re.split()
  • re.sub()
  • re.compile()

match()

Данная функция проверяет, начинается ли строка с данного выражения

result = re.match('12', '12345678')
print result

Результат:
<_sre.SRE_Match object at 0x0000000009BE4370>

Искомая подстрока найдена. Чтобы вывести ее содержимое, используем метод group().

result = re.match('12', '12345678')
print result.group(0)

Результат:
12

Пример с несуществующей строкой:

result = re.match('23', '123456789')
print result

Результат:
None

Для того, чтобы увидеть начало совпавшего фрагмента вызывается res.start(), а для окончания: res.end().

search()

Функция search ищет по всей строке и возвращает первое совпадение

findall()

Функция findall возвращает список всех найденных подстрок

split()

Функция split разбивает строку по заданному шаблону

>>> res=re.split(",","562,42,5,6,7,5,4,46,56")
>>> res
['562', '42', '5', '6', '7', '5', '4', '46', '56']
>>>

У функции есть параметр maxsplit=1, который управляет количеством разбиений (слева направо).

sub()

Ищет шаблон в строке и заменяет его на новое значение.

Таблица обозначений:

Оператор Описание
. Один любой символ, кроме новой строки \n.
? 0 или 1 вхождение шаблона слева
+ 1 и более вхождений шаблона слева
* 0 и более вхождений шаблона слева
\w Любая цифра или буква (\W — все, кроме буквы или цифры)
\d Любая цифра [0-9] (\D — все, кроме цифры)
\s Любой пробельный символ (§ — любой непробельный символ)
\b Граница слова
[..] Один из символов в скобках ([^..] — любой символ, кроме тех, что в скобках)
\ Экранирование специальных символов (\. означает точку или \+ — знак «плюс»)
^ и $ Начало и конец строки соответственно
{n,m} От n до m вхождений ({,m} — от 0 до m)
a | b Соответствует a или b
() Группирует выражение и возвращает найденный текст
\t, \n, \r Символ табуляции, новой строки и возврата каретки соответственно
   

Классы и ООП

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

Для ООП нужно описывать программные сущности: классы.

Описание класса

class Person:
   name="Vasya"
   def who(self):
      print("My name is "+self.name)

Далее мы можем создать экземпляр класса и воспользоваться его методом:

v=Person()
v.who()

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

class Person:
   name="Vasya"
   def __init__(self,name):
      self.name=name
   def who(self):
      print("My name is "+self.name)

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

v=Person("Маша")
v.who()

А вот так можно использовать общие для класса переменные:

 class Person:
    population=0
    def __init__(self,name):
       self.name=name
       Person.population+=1
    def who(self):
       print("My name is "+self.name)
       print("Total: "+str(Person.population))

p1=Person("Маша")
p1.who()
p2=Person("Саша")
p2.who()

Вывод программы:

My name is Маша
Total: 1
My name is Саша
Total: 2

В классах можно создавать деструкторы и потом использовать их (команда `del`)

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

class SchoolMember: 
  def __init__(self, name, age):
    self.name = name
    self.age = age
    print("Initialized SchoolMember: ",self.name)
  def tell(self):
    print("Name:  Age: ", self.name, self.age)

class Teacher(SchoolMember):
  def __init__(self, name, age, salary): 
    SchoolMember.__init__(self, name, age) 
    self.salary = salary
    print ("Initialized Teacher: ", self.name)
  def tell(self): 
    SchoolMember.tell(self)
    print("Salary: ", self.salary)

class Student(SchoolMember):
  def __init__(self, name, age, marks): 
    SchoolMember.__init__(self, name, age) 
    self.marks = marks
    print("Initialized Student: ",self.name)
  def tell(self): 
    SchoolMember.tell(self)
    print("Marks: ",self.marks)

t = Teacher("Mrs. Shrividya", 40, 30000)
s = Student("Swaroop", 22, 75)
members = [t, s]
for member in members:
  member.tell()

Интересные пакеты

`pandas` - анализ данных `pygments` - подготовка документации `pil` - обработка изображений `matplotlib` - построение графиков

Построение графиков (matplotlib)

Простой график:

import matplotlib
import matplotlib.pyplot as plt
import numpy as np

t = np.arange(0.0, 2.0, 0.01)
s = 1 + np.sin(2 * np.pi * t)

fig, ax = plt.subplots()
ax.plot(t, s)

ax.set(xlabel='time (s)', ylabel='voltage (mV)',
       title='About as simple as it gets, folks')
ax.grid()

fig.savefig("test.png")
plt.show()

График со штрих-пунктиром:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 500)
y = np.sin(x)

fig, ax = plt.subplots()

line1, = ax.plot(x, y, label='Using set_dashes()')
line1.set_dashes([2, 2, 10, 2])  

line2, = ax.plot(x, y - 0.2, dashes=[6, 2], label='Using the dashes parameter')

ax.legend()
plt.show()

Несколько кривых

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-5, 5, 100)

def sigmoid(alpha):
    return 1 / ( 1 + np.exp(- alpha * x) )

dpi = 80
fig = plt.figure(dpi = dpi, figsize = (512 / dpi, 384 / dpi) )

plt.plot(x, sigmoid(0.5), 'ro-')
plt.plot(x, sigmoid(1.0), 'go-')
plt.plot(x, sigmoid(2.0), 'bo-')

plt.legend(['A = 0.5', 'A = 1.0', 'A = 2.0'], loc = 'upper left')

fig.savefig('sigmoid.png')

Еще пример:

import matplotlib as mpl 
import matplotlib.pyplot as plt 
import math

dpi = 80
fig = plt.figure(dpi = dpi, figsize = (512 / dpi, 384 / dpi) )
mpl.rcParams.update({'font.size': 10})

plt.axis([0, 10, -1.5, 1.5])

plt.title('Sine & Cosine')
plt.xlabel('x')
plt.ylabel('F(x)')

xs = []
sin_vals = []
cos_vals = []

x = 0.0 
while x < 10.0:
    sin_vals += [ math.sin(x) ]
    cos_vals += [ math.cos(x) ]
    xs += [x] 
    x += 0.1 

plt.plot(xs, sin_vals, color = 'blue', linestyle = 'solid',
         label = 'sin(x)')
plt.plot(xs, cos_vals, color = 'red', linestyle = 'dashed',
         label = 'cos(x)')

plt.legend(loc = 'upper right')
fig.savefig('trigan.png')

Решения задач

Проверка списка на палиндром:

def pal(lst):
        return lst==list(reversed(lst));

print(pal([1,2,3,2,1]))
print(pal([1,2,3,2,1,1]))

>>> True
    False

Тест числа на простоту

def prime1(value):
        return len([x for x in range(2,value) if value%x==0])==0

print(prime1(2))
print(prime1(3))
print(prime1(4))
print(prime1(17))

Репликатор

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

Простейшая реализация на циклах:

def replicator(lst,n):
    res=[]
    for i in lst:
        for x in range(n):
            res.append(i)
    return res

print(replicator(['a','b','c'],5))

Проверка расстановки скобок

завести пустой стек

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

return стек пуст
def check(string):
brackets_open = ('(', '[', '{', '<')
brackets_closed = (')', ']', '}', '>')
stack = []
for i in string:
    if i in brackets_open:
        stack.append(i)
    if i in brackets_closed:    
        if len(stack) == 0:
            return False
        index = brackets_closed.index(i)
        open_bracket = brackets_open[index]
        if stack[-1] == open_bracket:
            stack = stack[:-1]  
        else: return False  
return (not stack)  

Реализация с двумя скобками:

def check(string):
  op = '('
  cl = ')'
  stack = []
  for i in string:
    if i==op:
      stack.append(i)
    if i==cl:    
      if len(stack) == 0:
        return False
      if stack[-1] == op:
        stack = stack[:-1]     
  return (not stack) 

print(check("(12)()"))

Счастливые билеты

## суммирование цифр строки
def dsum(s):
   return sum([int(x) for x in list(s)])

def happy():
    count = 0
    for x in range(1000000):
      st = "%06d" % x
      if(dsum(st[:3])==dsum(st[3:6])):
        count +=1
    return count

print(happy())

Бесконечный генератор последовательности

Болотная сортировка с измерением времени

import random
import time

def bogosort(lst):
  sortlst=sorted(lst)
  while(lst!=sortlst):
    random.shuffle(lst)

start=time.time()
random.seed()
bogosort([random.randint(1,10) for x in range(10)])
end=time.time()
print(end-start)

Генерация пароля:

import random
# Щепотка цифр
str1 = '123456789'
# Щепотка строчных букв
str2 = 'qwertyuiopasdfghjklzxcvbnm'
# Щепотка прописных букв. Готовится преобразованием str2
в верхний     регистр.
str3 = str2.upper()
print(str3)
# Выведет: 'QWERTYUIOPASDFGHJKLZXCVBNM'

# Соединяем все строки в одну
str4 = str1+str2+str3
print(str4)
# Выведет: '123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'

# Преобразуем получившуюся строку в список
ls = list(str4)
# Тщательно перемешиваем список
random.shuffle(ls)
# Извлекаем из списка 12 произвольных значений
psw = ''.join([random.choice(ls) for x in range(12)])
# Пароль готов
print(psw)
# Выведет: '1t9G4YPsQ5L7'

Тоже самое в 2 строки:

import random
print(''.join([random.choice(list('123456789qwertyuiopasdfghjklzxc
vbnmQWERTYUIOPASDFGHJKLZXCVBNM')) for x in range(12)]))

Автор: Anton Shtanyuk

Created: 2019-10-15 Tue 11:16

Emacs 26.1 (Org mode 9.1.14)

Validate