Ввод данных: функция input()

a = input() b = input() a = int(a) b = int(b)

a,b = input().split() a = int(a) b = int(b)

a,b = map(int, input().split())

функция input возвращает текстовую строку. Если переменные должны быть целочисленными, то после считывания выполняется преобразование типов при помощи функции int, и записываются новые значения в переменные a и b.

 

Вывод данных: функция print()

a = 1

b = 2

print(a, ‘+’, b, ‘=‘, a + b)

Выводимые значения разделяются пробелом. Но это можно изменить: разделять выводимые значения можно любым словом, с переходом на следующую строку или не разделять никак. Для этого нужно функции print передать специальный именованный параметр sep, равный строке, используемый в качестве разделителя (sep – separator). По умолчанию sep= “ “ и между значениями выводится пробел. Чтобы в качестве разделителя было двоеточия нужно передать параметр sep, равный строке ‘:’:

print(a, b, sep = ‘:’) # результат – 1:2

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

print(a, ‘+’, b, ‘=‘, a + b, sep = ‘’) # результат –1+2=3

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

print(a, b, sep = ‘\n’)

Символ обратного слеша в текстовых строках является указанием на обозначение специального символа, в зависимости от того, какой символ записан после того. Наиболее часто употребляется символ новой строки ‘\n’. А для того, чтобы вставить в строку сам символ обратного слеша, нужно повторить его два раза: ‘\\’.

Вторым именованным параметром функции print является end, определяющий симвро вывода после работы функции print. По умолчанию параметр end = ‘\n’, т.е. следующий вывод будет происходить с новой строки. Этот параметр также можно изменить.

Например:

print(a, b, sep = ‘,’, end = ‘’) # 1,2 без перехода на новую строку.

Строки

Строки в Python определяются кавычками «"» или апострофами «'». Внутри кавычек могут присутствовать апострофы или наоборот. Например, строка «Он сказал 'привет'!» будет выведена на экран как

Он сказал 'привет'!

Если нужно использовать строку из несколько строчек, то эту строку надо начинать и заканчивать тремя двойными кавычками «"""».

Вы можете подставить в шаблон строки элементы из кортежа или словаря. Знак процента «%» между строкой и кортежем, заменяет в строке символы «%s» на элемент кортежа. Словари позволяют вставлять в строку элемент под заданным индексом. Для этого надо использовать в строке конструкцию «%(индекс)s». В этом случае вместо «%(индекс)s» будет подставлено значение словаря под заданным индексом.

Print "Name: %s \n Number: %s \n String: %s" % (my class.name, 3, 3 * "_")

Name: Poromenos

Number: 3

String: ___

strString = """Этот текст расположен

на нескольких строках"""

print "This %(verb)s a %(noun)s." % {"noun": "test", "verb":"is"}

This is a test.

Структуры данных

Python имеет следующие структуры данных:

· Списки (lists). Списки – похожи на одномерные массивы (многомерный массив можно создавать как список включающий список);

· Кортежи (tuples). Кортеж – неизменяемый список;

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

Примеры:

spisok = [1, ["другой", "список"], ("a", "в")] #Состав: число, список и кортеж

spisok = ["первый", 2, 3. 14] #Состав списка: строка, целое и дробное число

spisok [0] = "снова первый" #Изменяем 1-й (0-й) элемент списка

spisok [2] = 3.14 #Изменяем последний элемент листа

slovar = {"Key 1": "San 1", 2: 3, "pi": 3.14}#Словарь, с разными индексами

slovar ["pi"] = 3.15 #Изменяем элемент словаря под индексом "pi".

tuplau = (1, 2, 3) #Задаем кортеж

oznlk = len #Объявление синонима функции

print oznlk (spisok) # печатает 3

 

По-другому, текст может быть заключен в утроенные кавычки: """ или ’’’. Концы строк не нужно “прятать” при использовании утроенных кавычек, но они будут включены в текст.

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

word=’мисал’

print(word[4]) # напечатает – л

print(word[0:2]) # напечатает – мис

print(word[2:4]) # напечатает – сал

Строки в языке Python невозможно изменить. Попытка изменить символ в определенной позиции или подстроку вызовет ошибку:

a='123'

print(a,1, 2, sep='=', end = '\n')

a[0]='0'

print(1, 2)

выдаст сообщение

Traceback (most recent call last):

File "C:/Users/1/PycharmProjects/untitled2/22.py", line 3, in <module>

a[0]='0'

TypeError: 'str' object does not support item assignment

Индексы среза имеют значения по умолчанию:

· Опущенный первый индекс считается равным 0, опущенный второй индекс дает длину строки.

Пример:

b=[1,2,3,4,5,6,7]

a=b[:5] # a=[1,2,3,4,5]

c=b[5:] # c=[6,7];

· Если верхняя граница меньше нижней, то возвращается пустая строка;

· Отрицательные индексы в срезах выходящие за пределы обрабатываются равными нулю. Лучший способ запомнить, как определяются индексы в срезе — считать их указывающими между символами, с номером 0 на левой границе первого символа. А правая граница последнего символа имеет индекс равный длине строки.

Например:

b=[1,2,3,4,5,6,7]

a=b[:-2] # a=[1,2,3,4,5]

c=b[-2:] # c=[6,7];

 

u’Hello World!’ – строка кодировки Unicode

 

Вы можете подставить в шаблон строки элементы из кортежа или словаря. Знак процента «%» между строкой и кортежем, заменяет в строке символы «%s» на элемент кортежа. Словари позволяют вставлять в строку элемент под заданным индексом. Для этого надо использовать в строке конструкцию «%(индекс)s». В этом случае вместо «%(индекс)s» будет подставлено значение словаря под заданным индексом.

Print "Name: %s \n Number: %s \n String: %s" % (my class.name, 3, 3 * "_")

Name: Poromenos

Number: 3

String: ___

strString = """Этот текст расположен

на нескольких строках"""

print "This %(verb)s a %(noun)s." % {"noun": "test", "verb":"is"}

This is a test. Можно использовать часть массива, задавая первый и последний индекс через «:». Если нет первого элемента, то отсчет начинается с начала массива, а если нет последнего, то массив считывается до последнего элемента. Отрицательные значения определяют положение элемента с конца. Например:

spisok = ["Elem 1", 2, 3.14]

print spisok [:] #Выводятся все элементы массива ['Elem 1', 2, 3.14]

print spisok [0: 2] #Выводятся 0-й и 1-й элемент массива. [' Elem 1', 2]

print spisok [-3:-1] #Выводятся элементы от 0-го (-3) до 2-го (-1) ['Elem 1',2]

print spisok [1:] #Выводятся элементы от 1-ого, до последнего [2, 3.14]

 

Простые конструкции

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

1. Python не содержит операторных скобок (begin..end как в pascal или {..} как в Си), вместо этого блоки определяются отступами: пробелами или табуляцией (нужно выполнять только в одной из форм);

2. Вход в блок из операторов осуществляется двоеточием;

3. Однострочные начинаются со знака «#»;

4. Многострочные комментарии начинаются и заканчиваются тремя кавычками «"""»;

5. При присвоении значения переменной используется знак «=»;

6. Знак сравнения значений – «==»;

7. Для добавления значения переменной используется оператор «+=»;

8. Для уменьшения – «-=». Эта операция может взаимодействовать с большинством типов, в том числе со строками.

Примеры:

a = 1 # а присваивается значение 1

a += 2 # значение а увеличивается на 2

a -= 3 # значение а уменьшается на 3

"""Пример многострочного комментария

Строки комментария игнорируются"""

s = "Доброе " # в переменную s записывается строка текста "Доброе "

s += " утро." # в переменную s добавляется строка текста "утро"

print s # напечатается текст “Доброе утро.”

# Следующая строка меняет значения переменных местами.

a, s = s, a

Вот несколько примеров использования функции range, которые объясняют роль ее параметров.

A=list(range(10)) # A=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

A=list(range(2,10)) # A=[2, 3, 4, 5, 6, 7, 8, 9]

A=list(range(1,10,2)) # A=[1, 3, 5, 7, 9]

A=list(range(10,2,-2)) # A=[10, 8, 6, 4]

 

3.4. Потоковый ввод-вывод и
работа с текстовыми файлами

При стандартном потоковом вводе данных используется оператор input(), который устанавливает строковый тип переменного и вводит символьные значения.

Пример:

N=input()

В случае необходимости пропуска строки текстов при вводе можно написать

input()

Если необходимо ввести значения группы переменных, разделенных пробелами, необходимо использовать split()

a,b,c=input().split() # можно написать input().split(‘ ‘)

Если значения разделены символом «,», нужно написать split(‘,‘)

Если при вводе данных требуется запрос на ввод данных, то используется функция raw_input(приглашение), которая выводит на экран приглашение и ожидает ввода пользователя, возвращая то, что ввел пользователь в виде своего значения.

x = int(raw_input ("Введи число:"))

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

Ввод/вывод массива.

Print(‘ Количество элементов:')

n=input()

print ':'вводите элементы

x=[]

for x in range(n): x.append(input())

print 'массив:'

for x in x: print (x)

print 'обратно:'

for x in reversed(x): print (x)

 

Задача с большими числами. Записано два неотрицательных целых числа, не превышающих 10¹⁰⁰, по одному в каждой строке. Нужно вывести одно целое число — сумму чисел А и В, без лидирующих нулей.

Можно написать два варианта решения этой задачи

1) аналогично методам решения, предлагаемым на языке Паскаль для малых чисел[4]

A=int(input())

B=int(input())

print(A+B)

2) с использованием потоковых функций.

print(int(input ())+int(input ()))

или

r=input # обозначение input через имя r

print(int(r())+int(r()))

 

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

Пример:

print(N) # выводит значение в текстовой форме.

При выводе нескольких значений между значениями ставится разделитель «» (пробел).

Пример:

print(N, a[N]) – выводит через пробел индекс и значение элемента массива.

В случае необходимости пропуска строки текстов можно написать

input()

Если необходимо ввести значения группы переменных, разделенных пробелами, необходимо использовать split()

a,b,c=input().split() # можно написать input().split(‘ ‘)

Если значения разделены символом «,», нужно написать split(‘,‘)

 

Для работы с текстовыми файлами

inp = open('input.txt', 'r') – открытие файла inp из 'input.txt'

out = open('output.txt', 'w') – открытие файла out из 'output.txt'

T = int(inp.readline()) – ввод целого числа в переменную Т

out.write(ans + "\n") – вывод значения переменной ans с переходом на новую строку

Операторы

Операторы while, if, for – операторы перемещения.

Оператор while пока истинно логическое выраңение выполняет блок операторов.

Например;

s = n = 0 while s < 43: s += 12 n += 3 print(n) # напечатает 48	s	n

Оператор for сравнивает переменную из списка. Чтобы получить список цифр до числа <san> — используйте функцию range(<san>).

Примеры операторов

rangelist = range (10) # Получаем список из десяти цифр (от 0 до 9)

print rangelist # Печатает эти значения

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in rangelist: # number увеличиваясь входит в список...

if number in (3, 4, 7, 9): # Если number входит в кортеж (3, 4, 7, 9)...

break # Операция «break» обеспечивает выход из цикла

else: # необязательно. Условие выполняется, если цикл не был прерван

continue # «continue» продолжает цикл. Хотя здесь это не требуется

pass # Ничего не делать

if rangelist [1] == 2:

print "Второй элемент – 2"

elif rangelist [1] == 3:

print "Второй элемент – 3"

else:

print "Незнайка"

while rangelist[1] == 1:

pass

Задача 1. Для заданного числа n посчитать сумму чисел от 1 до n.

Можно предложить 3 варианта решения.

Вариант 1.

n=int(input()))
s=0
if n>i:
for i in range(1,n+1):
s+=i
else:
for i in range(1,n-1,-1):
s+=i
print(s)

Вариант 2.

n=int(input())

if n>0: s=n*(n+1) // 2

else: s=(2-n)*(n+1) // 2

print(s)

Вариант 3.

n=int(input())

s=(n*n+abs(n)) // 2

print(s if n>0 else 1-s)

Задача 2. Для подсчета числа отрицательных элементов массива можно применить следующую программу;

Вариант 1.

N=int(input())

K=0

for i in range(N):

x=int(input())

if x<0:

K+=1

print(K)

Вариант 2.

K=0

for i in range(int(input())):

if int(input())<0:

K+=1

print(K)

Вариант 3.

K=0

for i in range(int(input())):

K+= int(input())<0

print(K)

3) Ввод последователҗности из элементов и подсчет среднего значения.

a = []

N = 2016

S=0

for i in range(0, N):

a.append(int(input()))

S+=a[i]

print(S / N)

2-ой вариант решения данной задачи

N = 2016

print(sum(map(int,input().split())) / N)

 

Функции

При объявлении функции используется ключевое слово «def». Аргументы функции задаются в скобках. Можно задавать необязательные аргументы, присваивая им значение по умолчанию. Функции могут возвращать кортежи, в таком случае надо писать возвращаемые значения через запятую.

Ключевое слово «lambda» служит для объявления элементарных функций.

def f (ar1, ar2 = 100, ar3 = "test"):

# ar2 и ar3 - необязательные аргументы, принимают значение, объявленное

# по умолчанию, если не задать им другое значение при вызове функции.

return arg3, arg2, arg1

“”” Функция вызывается со значением 1-го аргумента – "Ar 1", 2-го – по умолчанию, и 3-го - "Named ar". “””

r1, r2, r3 = f ("Ar 1", ar3 = "Named ar")

# r1, r2 и r3 принимают значения "Named ar", 100, "Ar 1" соответственно

print r1, r2, r3 # Named ar 100 Ar 1

 

# Следующая запись эквивалентна def f(x): return x + 1

fvar = lambda x: x + 1

print fvar (1) # 2

Рекурсивные функции записываются следующим образом:

def F(n):

if n > 0:

G(n - 1)

def G(n):

print('*')

if n > 1:

F(n - 2)

N= int(input())

print(F(n))

Значение чисел Фибоначчи можно оформить через рекурсивную функцию

def F(n):

if n < 2: return 1

else: return F(n - 1)+F(n-2)

n=int(input())

print(F(n))

Значение чисел Фибоначчи можно оформить через рекурсивную функцию

def F(n):

if n < 2: return 1

else: return F(n - 1)* n

n=int(input())

print(F(n))

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

Пример 1: Числа фиббоначчи

def F(n):

a=0

b=1

while a<n:

print(a,end=’ ‘)

a,b=b,a+b

F(50)

Результат:

0 1 1 2 3 5 8 13 21 34

Пример 2: Наибольший общий делитель

def NOD(a,b):

while a*b>0:

if a>b: a%=b

else: b%=a

print(150,42)

Результат:

6

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

В Python процедуры имеют практически такой же синтаксис, как и функции, но не возвращают никаких значений.

def ИМЯ_ПРОЦЕДУРЫ(СПИСОК_ПАРАМЕТРОВ):

ДЕЙСТВИЕ 1

ДЕЙСТВИЕ 2

…

ДЕЙСТВИЕ N

Пример процедуры, выводящей последовательность чисел Фибоначчи до значения N:

def f(n)

a=0

b=1

while a<n:

print(a,end=’ ‘)

a,b=b,a+b

f(50)

Результат:

0 1 1 2 3 5 8 13 21 34

Глобальные переменные

Глобальные переменные объявляются вне функций и могут читаться без каких-либо объявлений. Если необходимо изменить значение глобальной переменной из функции, то необходимо в начале функции ключевым словом «global» объявить эту переменную, иначе Python объявит ее локальной в этой функции.

 

n = 5

m = 7

def f():

print(n) # Выводит 5

def f1():

# Это вызывает исключение, поскольку переменная n глобальной не была

# вызвана из функции. В этом случае создается одноименная переменная

# внутри этой функции и доступную только для операторов этой функции.

print (n)

n = 3

def f2():

global n

# В этой функции значение переменной изменяется.

n = 3

 

Подключение библиотек

Внешние библиотеки можно подключить процедурой «import [libname]», где [libname] – название подключаемой библиотеки. Можно использовать команду «from [libname] import [funcname]», Чтобы использовать функцию [funcname] из библиотеки [libname]

Примеры модулей

• random – псевдослучайные числа с различными распределениями

• whrandom – генератор псевдослучайных чисел

• bisect – поддержание последовательностей в сортированном состоянии

• array – эффективные массивы чисел

• UserString – интерфейсный класс для создания строковых объектов

• os – основные службы операционной системы

 

Import random #Импортируем библиотеку «random»

From time import clock #И заодно функцию «clock» из библиотеки «time»

randomint = random.randint (1, 100)

print Randomint # 64

 

Модуль Math –математические функции для работы с вещественными числами.

• cos(x) – Возвращает косинус x.

• log(x) – Возвращает натуральный логарифм x.

• pow(x, y) – Возвращает x**y.

• sqrt(x) – Возвращает квадратный корень из x.

• sin(x) – Возвращает синус x.

Модуль также определяет две константы:

• pi – Число пи.

• e – Число e.

 

Служебные модули

 

sys – Доступ к характерным для системы параметрам и функциям.

atexit – Регистрирует функции и выполняет их при окончании работы программы.

types – Имена для всех встроенных типов.

operator – Операторы языка Python в виде функций.

traceback – Модуль для работы с объектами traceback.

imp – Доступ к операциям, производимым инструкцией import.

pprint – Представление и вывод данных в более привлекательном виде.

repr – Альтернативная реализация функции repr() с ограничением размера.

Модуль Sys предоставляет доступ к переменным, используемым или поддерживаемым интерпретатором, и функциям, которые интенсивно взаимодействуют с интерпретатором. Модуль sys всегда доступен.

Несколько примеров:

• Argv — Список аргументов, переданных в командной строке программе на языке Python

• Exit([exit_code]) — Прерывает выполнение программы.

• Maxint — Наибольшее целое число, которое может быть представлено в рамках типа int.

• Modules — Словарь, отображающий имена импортированных модулей в объекты-модули.

 

 

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

Объекты типа file предназначены для работы с внешними данными. Файловые объекты должны поддерживать основные методы: read(), write(), readline(), readlines(), seek(), tell(), close().

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

open(file, mode=’r/w/x/a/b/t/+’, buffering=None, encoding=None, errors=None, newline=None, closefd=True) # Открывает файл и возвращает поток.

‘r’ — для чтения (выступает значением по умолчанию).

‘w’ —для записи, содержимое файла удаляется, если файла с таким именем нет, то он автоматически создается.

‘x’ — открытие на запись, если файл не существует, иначе исключение.

‘a’ — дозаписывание информации в конец существующего файла.

‘b’ — открытие в двоичном режиме.

‘t’ — открытие в текстовом режиме (выступает значением по умолчанию).

‘+’ — открытие на чтение и запись.

Кроме того, вышеперечисленные режимы могут быть объеденены. По умолчанию режим ‘rt’. Если вы хотите произвести чтение в двоичном режиме, то укажите ‘rb’.

Аргумент encoding задает кодировку и используется только в текстовом режиме чтения файла.

Пример копирования файла:

f = open("inp.txt", "r")

g = open("outp.txt", "w")

for line in f.readlines():

g.write(line)

g.close()

f.close()

Если в аргументе метода read ничего не указать, то он выведет всю информацию. Но можно обращаться к файлу с целью побитового вывода. (вспоминаем, что кириллица занимает по 2 байта на символ). Итак, пробуем вывести первые 6 букв:

>>> f = open('file.txt', 'r')

>>> print f.read(12)

Еще один способ используемый для этого цикл.

f = open('file.txt', 'r')

for line in f:

print line

f.close()

>>>Привет! Я - файл:)

Работы с файлом, его нужно обязательно закрыть. Используем для этого метод close().

Записываем информацию в файл:

Итак, открываем файл в режиме запись ‘w’, при этом все содержимое файла удалиться. И записываем в него слово ‘string’ с помощью метода write():

f = open('file.txt', 'w')

f.write('string1\n') #\n - перенос строки

f.write('sting2')

f.close()

# Проверяем, записались ли значения

f = open('file.txt', 'r')

print f.read()

f.close()

Результат:

string1

sting2

f = open('file.txt', 'w')

f.write('abvgd\n') #\n - перенос строки

f.seek(3) #переход на три байта

f.write('0000n') # вставляем после 3 символа и стираем все остальное

f.write('hello')

f.close()

# читаем значение построчно

f = open('file.txt', 'r')

print f.readline()

f.close()

# читаем ВСЕ строки

f = open('file.txt', 'r')

print f.readlines()

f.close()

Результат:

abv0000

['abv0000n', 'hello']

Вносим изменения в файл, не затронув при этом старые данные:

f = open('file.txt', 'w')

f.writelines('test')

f.close()

f = open('file.txt', 'r')

print f.read()

f.close()

Результат:

abv0000

['abv0000n', 'hello']

test

Python имеет встроенные библиотеки. В этом примере сохраним в бинарном файле структуру списка, прочитать ее и сохраним строку в текстовом файле. Для преобразования структуры данных используем стандартную библиотеку «pickle»

Import pickle

mylist = ["Это", "-", 4, 13327]

# Откроем файл C:\b.dat для записи. Символ «r» предотвращает замену

# специальных сиволов (таких как \n, \t, \b и др.).

mf = file (r"C: \b.dat", "w")

pickle.dump(mylist, mf)

mf.close()

mf = file(r"C:\text.txt", "w")

mf.write("Это - a sample string")

myfile.close()

myfile = file (r"C:\text.txt")

print myfile.read()

'This is a sample string'

myfile.close()

# Открываем файл для чтения

myfile = file(r"C:\binary.dat")

loadedlist = pickle.load(myfile)

myfile.close()

print loadedlist

['This', 'is', 4, 13327]

 

http://pythonworld.ru/samouchitel-python

https://habrahabr.ru/post/29778/

 

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

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

· Простое перечисление. Например

animal = ["Бобер", 1.2, 31]

· Преобразование строки в список. Например

b = list("help") # b=['h', 'e', 'l', 'p']

· Создание с помощью списковых включений. Например

c=[x**2 for x in range(20) if x%3==1]

# c=[1,16,49,100,169,256,361]

 

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

len(s) – длина последовательности s

x in s – проверка принадлежности элемента последовательности или принадлежность подстроки строке.

x not in s = not x in s

s + s1 – конкатенация последовательностей

s*n или n*s – последовательность из n раз повторенной s. Если n < 0, возвращается пустая последовательность.

s[i] –i-й элемент s или len(s)+i-й, если i < 0

s[i:j:d] Срез из последовательности s от i до j с шагом

min(s) Наименьший элемент s

max(s) Наибольший элемент s

s[i] = x i-й элемент списка s заменяется на x

s[i:j:d] = t Срез от i до j (с шагом d) заменяется на (список) t

del s[i:j:d] – Удаление элементов среза из последовательности

Кроме того, для списков определен ряд методов.

append(x) – Добавляет элемент в конец последовательности

count(x) – Считает количество элементов, равных x

extend(s) – Добавляет к концу последовательности последовательность s

index(x) – Возвращает наименьшее i, такое, что s[i] == x. Возбуждает исключение ValueError, если x не найден в s

insert(i, x) – Вставляет элемент x в i-й промежуток

pop(i) – Возвращает i-й элемент, удаляя его из последовательности

reverse() – Меняет порядок элементов s на обратный

sort([cmpfunc]) – Сортирует элементы s. Может быть указана своя функция сравнения cmpfunc.

Для преобразования кортежа в список есть функция list, для обратной операции – tuple.

Стеки

Стек – упорядоченная коллекция элементов, где добавление нового или удаление существующих всегда происходит только на одном из концов. Этот конец обычно называют “вершиной”, а противоположный ему - “основанием”.

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

· stack() создаёт новый пустой стек. Параметры не нужны, возвращает пустой стек.

· push(item) добавляет новый элемент на вершину стека. В качестве параметра выступает элемент; функция ничего не возвращает.

· pop() удаляет верхний элемент из стека. Параметры не требуются, функция возвращает элемент. Стек изменяется.

· peek() возвращает верхний элемент стека, но не удаляет его. Параметры не требуются, стек не модифицируется.

· isEmpty() проверяет стек на пустоту. Параметры не требуются, возвращает булево значение.

· size() возвращает количество элементов в стеке. Параметры не требуются, тип результата – целое число

Операция над стеком	Содержание стека	Возвращаемое значение
s.isEmpty()	[]	True
s.push(2)	[2]
s.push('эш')	[2,'эш']
s.peek()	[2,'эш']	'эш'
s.push(True)	[2,'эш',True]
s.size()	[2,'эш',True]
s.isEmpty()	[2,' эш ',True]	False
s.push(3.14)	s.push(3.14)
s.pop()	[2,' эш ',True]	3.14
s.pop()	[2,' эш ']	True
s.size()	[2,' эш ']

 

Пример реализации стека:

class Stack:

def __init__(self):

self.items=[]

def isEmpty(self):

return self.items=[]

def push(self,item):

self.items.append(item)

def pop(self):

return self.items.pop()

def peek(self):

return self.items[len(self.items)-1]

def size(self):

return len(self.items)

from python.basic.stack import Stack

s=Stack

print(s.isEmpty

s.push(4)

s.push(‘dog’)

print(s.speek())

s.push(True)

print(s.size())

print(s.isEmpty())

print(s.pop())

print(s.pop())

print(s.size())

Множества

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

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

Множество задается перечислением элементов в фигурных скобках. Например:

A={1,2,3}

Функция set() создает пустое множество. Функция set с параметрами в виде списка, строки или кортежа вернет множество, составленное из элементов списка, строки, кортежа. Например:

A = set('один')

print(A)

выведет {'д', 'и', 'н', 'о'}.

Каждый элемент может входить в множество только один раз, порядок задания элементов не важен. Например, программа:

A = set('абракадабра') # A={‘a’, ‘б’, ‘д’, ‘к’, ‘р’}

B = set('бардак') # В={‘a’, ‘б’, ‘д’, ‘к’, ‘р’}

print(A==B)

выдаст значение True.

Примеры присвоения значений:

a=set() # a – пусто

b = {‘б’, ‘e’, ‘р’}

c= set('хан') # с={‘х’, ‘а’, ‘н’}

d={2*i for i in range(5)} # d={0, 2, 4, 6, 8}

e=set([‘бер’, ‘один’, ‘один’, ‘one’, ‘one’, ‘ein’]) # е={‘бер’, ‘один’, ‘one’, ‘ein’}

Число элементов определяет функция len(a). Например:

print(len(set(‘четыре’))) # выведет число 5

Перебор вех элементов множества можно при помощи цикла for

f={1,3,4,7}

for san in f: print(san) # напечатает 7 1 4 3

Принадлежность элемента можно проверить с помощью опереации in.

print(3 in {1,3,4,7}) # напечатает True

Новый элемент добавляет метод add.

a={1,3,4,7}

a.add(6) # a= {1,3,4,6,7}

Метод pop удаляет из множества один случайный элемент, возвращая его значение. При пустом множестве генерируется исключение KeyError

Функция list из множества формирует список.

Операции с множествами:

len(s) – число элементов в множестве

x in s – принадлежность x s

s.isdisjoint(s1) – истина в случае пустого пересечения множеств

s==s1 – истина в случае совпадения множеств

s.issubset(s1) – s подмножество s1

s.issuperset(s1) – s1 подмножество s

s.union(s1,s2…) – объединение множеств

s.intersection(s1,s2,…) – пересечение s с остальными множествами

s.difference(s1,s2…) – вычитание из s подмножеств

s.simmetric_difference(s1) – исключающее или

s.copy(s1) – копирование.

Операции изменения множества:

s.update(s1,s2,…) – добавляет элементы в множестве

s.intersection_update(s1,s2,…) – пересечение в множестве оставляет

s.difference_update(s1,s2,…) – вычитает из множества

s.simmetric_difference_update(s1,s2,…) – оставляет элементы, встречающиеся только в одном множестве

s.add(b) – добавляет элемент

s.remove(b) – удаляет элемент. При удалении не существующего элемента формируется исключение KeyError.

s.discard(b) – удаляет элемент

s.pop() – удаляет случайный элемент

s.clear() – очищает множество

 

Компьютерная графика

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

Исполнитель «черепашка» управляется командами относительных («вперёд-назад» и «направо-налево») и абсолютных («перейти в точку с координатами...») перемещений. Исполнитель представляет собой «перо», оставляющее след на плоскости рисования. Перо можно поднять, тогда при перемещении след оставаться не будет. Кроме того, для пера можно установить толщину и цвет. Все эти функции исполнителя обеспечиваются модулем turtle («черепаха»).

Приведённая программа создаёт графическое окно и помещает перо («черепашку») в исходное положение:

import turtle # Инициализация

turtle.reset() # Здесь могут быть вычисления и команды рисования

turtle._root.mainloop() # Эта команда показывает окно, пока его не закроют

Рис. Окно рисования

Полученное окно имеет фиксированный размер, зависящий от версии Python, перо позиционируется в центре. Идея рисования заключается в перемещении пера («черепашки») в точки окна рисования с указанными координатами или в указанных направлениях на заданные расстояния, а также в проведении отрезков прямых, дуг и окружностей.