Сайт о телевидении

У каждой операции есть свои операторы. В унарных и бинарных операциях применяются базовые операторы (сложение, вычитание, отрицание, унарный плюс, унарный минус, присваивание). Тернарный имеет три аргумента: условие if, выражение, если условие == true, и выражение, если условие == false.

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

A = b + c

К переменной b прибавляется c, результат присваивается переменной a. Весь пример в целом a = b + c - это выражение. Переменные, которые в нем фигурируют, - это операнды. Производимая операция - сложение, а используемый для этого оператор - “+”.

Арифметические операторы Python

Пайтон предоставляет огромное количество библиотек для решения вычислительных задач. Большой набор методов ставит Python на один уровень с Matlab и Octave. Арифметические операции применяются относительно к целым числам типа int, вещественным типа float, комплексным complex.

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

Все возможные арифметические операции приведены в таблице.

Добавление одного числа к другому выполняет оператор additional. Вычитание осуществляется с помощью subtraction. Умножение одного числа на другое происходит с multiplication. Возведение в степень осуществляется с помощью exponenta. Для деления используется division.

Оператор modulus (%) возвращает остаток от деления левого операнда на правый. Если переменная a = 10, переменная b = 20, то b%a == 0. Что такое оператор деления с остатком, легко понять на следующем примере. Если 9/2 == 4.5, то 9//2 возвращает результат, равный 4. Деление с floor division (//) возвращает целое число от операции деления левого операнда на правый.

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

Наряду с целыми и вещественными числами в Python существуют комплексные числа. Они состоят из действительной и мнимой части. Записываются в виде c = a+bj, где а - действительная часть,

C.real() #a

b - мнимая.

C.imag() #b

Арифметические операции c комплексными числами имеют те же свойства, что и с вещественными. Использование complex numbers можно представить на плоскости с прямоугольной системой координат. Точка a пересечения оси X и оси Y соответствует комплексному числу x + yi. Таким образом, на оси X располагаются вещественные числа, а на вертикальной оси Y - мнимые.

Сравнение

Операторы в Python используется для сравнения переменных. Кроме стандартных, известных из математических задач, существует проверка по значению и по типу, а также проверка неравенства.

Операции сравнения осуществляются в виде a x b, где x - это оператор сравнения.

В программировании оператор “=” работает не так, как в математике. Соответствие значений каждого аргумента определяется оператором “==”, но “=” только присваивает значение. С помощью!= проверяется неравенство переменных. Этот оператор можно заменить как “<>”, что не является стандартным оператором в других языках, как Си, Джава или Джаваскрипт.

Присваивание

Операторы Python присваивают значение переменной.

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

Алгоритм работы:

• вычисление левостороннего значения;
• вычисление правостороннего значения;
• присвоение одного значения другому - при конфликте типов должно быть осуществлено их приведение;
• возврат результата операции - true или false.

И математической операции работают по такому принципу:

a x b, где x - это оператор, означает что a = a x b. Таким образом, a += b говорит о том, что значение переменной a прибавляется к значению переменной b, а их результат присваивается переменной a. То же самое происходит с другими примерами. Например, a **= b расшифровывается как a = a ** b, то есть a возводится в степень b, результат в итоге присваивается a.

Условия

Проверка условий выполняется с помощью тернарного оператора Python.

Он состоит из двух или трех частей:

• if - проверяемое выражение;
• elif - необязательная инструкция (аналогичная if else или elseif);
• else - основная инструкция.

a = int(input()) if X: A = Y else: A = Z

Выражение можно задать в одной строке.

A = Y if X else Z

Части else и elseif можно отбрасывать, выражение выглядит так:

If 1: print("hello 1")

В Пайтоне существуют операторы break и continue. Break прерывает выполнение кода на всех уровнях. Continue прекращает текущую итерацию, продолжает выполнение со следующей точки.

Побитовые

Такие операторы Python интерпретируют операнды как последовательность нулей и единиц.

Они используют числа в двоичном представлении, возвращают результат в виде 32-битного числа.

a = 0 #a = 1 #a = 2 #a = 3 #a = 255 #

Отрицательное число в двоичном формате получается методом замены бита на противоположное и прибавления 1.

314 #-314 #+ 1 =

Отличие a >> b от a >>> b в том, что при сдвиге и отбрасывании правых значений слева добавляются копии первых битов.

9 #9 >> 2 #-9 #-9 >> 2 #

Но при a >>> b левые значение будут заполнены нулями.

9 #-9 >>> 2 #

Логические

Всего существует три логических оператора.

• and - возвращает true, если a == b == x;
• or - возвращает true есть a == x или b == x;
• not - возвращает false, если a == b == x.

Принадлежность

Оператор принадлежности проверяет, является ли переменная частью некоторой последовательности.

• a in b возвращает true, если находит переменную a в последовательности b;
• a not in b возвращает true, если не находит переменную а в последовательности b.

Тождественность

• a is b возвращает true, если переменные справа и слева указывают на один объект;
• a is not b возвращает true, если переменные не указывают на один объект.

Приоритеты

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

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

• Лямбда выражения.
• Python.
• Булевое ИЛИ.
• Булевое И.
• Булевое НЕ.
• Операторы тождественности, принадлежности, операторы присваивания.
• Битовый ИЛИ.
• Битовый НЕ.
• Битовый И.
• Битовый оператор сдвига битов.
• Сложение и вычитание.
• Умножение и деление, включая операцию получения остатка деления и целого числа.
• Битовое НЕ.
• Возведение в степень.
• Обращение к элементу массива по индексу, слайсинг, обращение к объекту класса, вызов функции с аргументами.

Первый пункт в списке - лямбда-выражение. Lambda expression используется для создания анонимных функций. Лямбда ведет себя как обычная функция, и объявляется в виде

Def (arguments): return expression

После лямбда-выражения следуют операции, выполняемые тернарным оператором Python.

В конце списка располагаются методы манипуляции массивом и функциями. Обращение к элементу массива по индексу выглядит так:

В рассматриваемом случае а - это массив, i - это индекс элемента.

Слайсинг означает передачу полной копии массива или выборочную последовательность из членов списка. Диапазон желаемых значения указывается в . В качестве аргументов x представляется начало отсчета, y - конец, а z - шаг прохождения по элементам массива при каждой итерации. X по умолчанию обозначает начало списка, y - конец, z равняется единице. Если указать z как отрицательное число, значения списка передаются в обратном порядке с конца к началу.

О ператоры являются конструкциями, которые могут манипулировать значением операндов. Рассмотрим выражение 4 + 5 = 9. Здесь, 4 и 5 называются операндами и + называется оператором.

Типы операторов

Язык Python поддерживает следующие типы операторов:

• Арифметические операторы
• Сравнение (реляционные) операторы
• Операторы присваивания
• Логические операторы
• Битовые операторы
• Членские операторы
• Операторы идентификации

Давайте рассмотрим все операторы один за другим.

Арифметические операторы в Python

а значение 10, а переменная б содержит значение 21, то:

оператор	Описание	пример
+ Сложение	Добавление значений по обе стороны от оператора.	а + b = 31
– Вычитание	Вычитание правого операнда из левого операнда.	а – b = -11
* Умножение	Умножение значения по обе стороны от оператора	a * b = 210
/ Деление	Делит левый операнд на правый операнд	б / а = 2,1
% Модуль	Делит левый операнд на правый операнд и возвращает остаток	б % а = 1
** Экспонента	Выполняет экспоненциальный расчет на операторах	а ** b = 10 в степени 20
// деление с округлением	Отдел пола – Разделение операндов, где результат является фактором, в котором цифра после десятичной запятой удаляется. Но если один из операндов отрицателен, то результат округляется, т.е. округляется от нуля (по отношению к отрицательной бесконечности):	9 // 2 = 4 и 9,0 // 2,0 = 4,0, -11 // 3 = -4, -11,0 // 3 = -4,0

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

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

Предположим, переменная а содержит значение 10, а переменная б имеет значение 20, то:

оператор	Описание	пример
==	Если значения двух операндов равны, то условие становится истинным.	(а == б) не верно.
!=	Если значения двух операндов не равны, то условие становится истинным.	(а! = б) истинно.
>	Если значение левого операнда больше значения правого операнда, то условие становится истинным.	(а > б) не верно.
<	Если значение левого операнда меньше значения правого операнда, то условие становится истинным.	(а < б) истинно.
> =	Если значение левого операнда больше или равно значению правого операнда, то условие становится истинным.	(а >= б) не верно.
<=	Если значение левого операнда меньше или равно значению правого операнда, то условие становится истинным.	(а <= б) истинно.

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

Предположим, переменная содержит а значение 10, а переменная б имеет значение 20, то:

оператор	Описание	пример
=	Назначает значения с правой стороной операндов левой стороне операнда	с = а + b присваивает значение a + b в c
+ = Добавить и	Добавляет правый операнд к левому операнду и присвоить результат левого операнда	с + = а эквивалентно c = c + a
– = вычесть и	Вычитает правый операнд из левого операнда и присваивает результат левого операнда	с – = а эквивалентно c = c – a
* = умножить и	Умножает правый операнд на левый операнд и присваивает результат левого операнда	с * = а эквивалентно c = c * a
/ = разделить и	Делит левый операнд на правый операнд и присваивает результат левого операнда	с / = а эквивалентно c = c / ac /= a эквивалентно с = с / а
% = Модуль и	Принимает модуль с помощью двух операндов и присваивает результат левого операнда	c% = а эквивалентно c = c % a
** = Экспонент и	Выполняет вычисление экспоненту от операторов и присваивает значение левого операнда	с ** = а эквивалентно c = c ** a
// = Floor Division	Выполняет деление операторов с округлением и присваивает значение левого операнда	с // = а эквивалентно c = c // a

Битовые операторы в Python

Побитовые операторы работают над битами и выполняют операции бит за битом. Допустим, если а = 60; и б = 13; В настоящее время в двоичном формате они будут выглядить следующим образом:

—————–

а&б = 0000 1100

а|б = 0011 1101

а^б = 0011 0001

Встроенная функция bin() в Python может быть использована для получения двоичного представления целого числа.

Следующие Битовые операторы поддерживаются языком Python:

Оператор	Описание	Пример
& бинарный И	копии оператора бита, в результате, если они существует в обоих операндах	(а & б) (0000 означает 1100)
| бинарный ИЛИ	копирует бит, если он существует в любом из операндов.	(а | б) = 61 (означает 0011 1101)
^ бинарный Исключающий или	копирует бит, если он установлен в одном операнде, но не в обоих.	(а ^ б) = 49 (означает 0011 0001)
~ Бинарным комплемент	Это унарное и имеет эффект бит «листать».	(~ а) = -61 (в форме означает двойной комплемент 1100 0011 из-за подписанного двоичного числа.
<< Двоичный сдвиг влево	Значение левого операнда перемещается влево на число битов, заданное правым операндом.	а << = 240 (1111 означает 0000)
>> Двоичный сдвиг вправо	Значение левого операнда перемещается вправо на число битов, заданное правым операндом.	а >> = 15 (0000 означает 1111)

Логические операторы в Python

Следующие логические операторы поддерживаются языком Python. Предположим, переменная справедлива и переменная б имеет значение False, то:

Членские Операторы в Python

Статус операторов тестирования на членство в последовательности, такие как строки, списки или кортежи. Есть два членских операторов, как объяснено ниже:

Операторы идентификации в Python

Операторы идентификации сравнивают ячейки памяти двух объектов. Есть два оператора идентификации как объяснено ниже:

Операторы приоритетов в Python

В следующей таблице перечислены все операторы от наивысшего приоритета к самому низкому.

Порядковый номер	Оператор & Описание
1	** Возведение в степень (повышение мощности)
2	~ + – Дополнение, унарный плюс и минус (имена методов для двух последних являются + @ и – @)
3	* / % // Умножение, деление по модулю и остаток от деления
4	+ – Сложение и вычитание
5	>> << Правый и левый побитовый сдвиг
6	& Побитовое «И»
7	^ | Побитовое исключающее “ИЛИ и регулярное ИЛИ”
8	<= <>> = операторы сравнения
9	<> ==! = операторы равенства
10	= %= /= //= -= += *= **= операторы присваивания
11	is not операторы идентификации
12	in not in операторы членства
13	not или and Логические операторы

• Перевод

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

4. Выбор значений

4.1. Правильный путь

Начиная с версии 2.5, Python поддерживает синтаксис «value_if_true if test else value_if_false». Таким образом, вы можете выбрать одно из двух значений, не прибегая к странному синтаксису и подробным пояснениям:
test = True # test = False result = "Test is True" if test else "Test is False" # result = "Test is True"
Увы, это всё еще немного некрасиво. Вы также можете использовать несколько таких конструкций в одной строке:
test1 = False test2 = True result = "Test1 is True" if test1 else "Test1 is False, test2 is True" if test2 else "Test1 and Test2 are both False"
Сначала выполняется первый if/else, а если test1 = false, выполняется второй if/else. Вы можете делать и более сложные вещи, особенно если воспользуетесь скобками.

Этот способ весьма новый, и я испытываю к нему смешанные чувства. Это правильная, понятная конструкция, она мне нравится… но она всё еще уродлива, особенно при использовании нескольких вложенных конструкций. Конечно, синтаксис всех уловок для выбора значений некрасив. У меня слабость к описанному ниже способу с and/or, сейчас я нахожу его интуитивным, сейчас я понимаю, как он работает. К тому же он ничуть не менее эффективен, чем «правильный» способ.

Хотя инлайновый if/else - новый, более правильный способ, вам всё же стоит ознакомиться со следующими пунктами. Даже если вы планируете использовать Python 2.5, вы встретите эти способы в старом коде. Разумеется, если вам нужна обратная совместимость, будет действительно лучше просмотреть их.

4.2. Уловка and/or

«and» и «or» в Python - сложные создания. Применение and к нескольким выражениям не просто возвращает True или False. Оно возвращает первое false-выражение, либо последнее из выражений, если все они true. Результат ожидаем: если все выражения верны, возвращается последнее, являющееся true; если одно из них false, оно и возвращается и преобразуется к False при проверке логического значения.

Аналогично, операция or возвращает первое true-значение, либо последнее, если ни одно из них не true.

Это вам не поможет, если вы просто проверяете логическое значение выражения. Но можно использовать and и or в других целях. Мой любимый способ - выбор значения в стиле, аналогичном тернарному оператору языка C «test? value_if_true: value_if_false»:
test = True # test = False result = test and "Test is True" or "Test is False" # теперь result = "Test is True"
Как это работает? Если test=true, оператор and пропускает его и возвращает второе (последнее) из данных ему значений: "Test is True" or "Test is False" . Далее, or вернет первое true выражение, т. е. "Test is True".

Если test=false, and вернет test, останется test or "Test is False" . Т. к. test=false, or его пропустит и вернет второе выражение, "Test is False".

Внимание, будьте осторожны со средним значением («if_true»). Если оно окажется false, выражение с or будет всегда пропускать его и возвращать последнее значение («if_false»), независимо от значения test.

После использования этого метода правильный способ (п. 4.1) кажется мне менее интуитивным. Если вам не нужна обратная совместимость, попробуйте оба способа и посмотрите, какой вам больше нравится. Если не можете определиться, используйте правильный.

Конечно, если вам нужна совместимость с предыдущими версиями Python, «правильный» способ не будет работать. В этом случае and/or - лучший выбор в большинстве ситуаций.

4.3. True/False в качестве индексов

Другой способ выбора из двух значений - использование True и False как индексов списка с учетом того факта, что False == 0 и True == 1:
test = True # test = False result = ["Test is False","Test is True"] # теперь result = "Test is True"
Этот способ более честный, и value_if_true не обязано быть true. Однако у него есть существенный недостаток: оба элемента списка вычисляются перед проверкой. Для строк и других простых элементов это не проблема. Но если каждый из них требует больших вычислений или операций ввода-вывода, вычисление обоих выражений недопустимо. Поэтому я предпочитаю обычную конструкцию или and/or.

Также заметьте, что этот способ работает только тогда, когда вы уверены, что test - булево значение, а не какой-то объект. Иначе придется писать bool(test) вместо test, чтобы он работал правильно.

5. Функции

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

Начнем этот раздел с предупреждения. Эта проблема много раз смущала многих программистов, включая меня, даже после того, как я разобрался в проблеме. Легко ошибиться, используя значения по умолчанию:
def function(item, stuff = ): stuff.append(item) print stuff function(1) # выводит "" function(2) # выводит "" !!!
Значения по умолчанию для аргументов вычисляются только один раз, в момент определения функции. Python просто присваивает это значение нужной переменной при каждом вызове функции. При этом он не проверяет, изменилось ли это значение. Поэтому, если вы изменили его, изменение будет в силе при следующих вызовах функции. В предыдущем примере, когда мы добавили значение к списку stuff, мы изменили его значение по умолчанию навсегда. Когда мы вызываем функцию снова, ожидая дефолтное значение, мы получаем измененное.

Решение проблемы: не используйте изменяемые объекты в качестве значений по умолчанию. Вы можете оставить всё как есть, если не изменяете их, но это плохая идея. Вот как следовало написать предыдущий пример:
def function(item, stuff = None): if stuff is None: stuff = stuff.append(item) print stuff function(1) # выводит "" function(2) # выводит "", как и ожидалось
None неизменяем (в любом случае, мы не пытаемся его изменить), так что мы обезопасили себя от внезапного изменения дефолтного значения.

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

5.1.1. Заставляем дефолтные значения вычисляться каждый раз

Если вы не хотите вносить в код функции лишний беспорядок, можно заставить интерпретатор заново вычислять значения аргументов перед каждым вызовом. Следующий декоратор делает это:
from copy import deepcopy def resetDefaults(f): defaults = f.func_defaults def resetter(*args, **kwds): f.func_defaults = deepcopy(defaults) return f(*args, **kwds) resetter.__name__ = f.__name__ return resetter
Просто примените этот декоратор к функции, чтобы получить ожидаемые результаты:
@resetDefaults # так мы применяем декоратор def function(item, stuff = ): stuff.append(item) print stuff function(1) # выводит "" function(2) # выводит "", как и ожидалось

5.2. Переменное число аргументов

Python позволяет использовать произвольное число аргументов в функциях. Сначала определяются обязательные аргументы (если они есть), затем нужно указать переменную со звездочкой. Python присвоит ей значение списка остальных (не именованных) аргументов:
def do_something(a, b, c, *args): print a, b, c, args do_something(1,2,3,4,5,6,7,8,9) # выводит "1, 2, 3, (4, 5, 6, 7, 8, 9)"
Зачем это нужно? Например, функция должна принимать несколько элементов и делать с ними одно и то же (например, складывать). Можно заставить пользователя передавать функции список: sum_all(). А можно позволить передавать произвольное число аргументов, тогда получится более чистый код: sum_all(1,2,3).

Функция также может иметь переменное число именованных аргументов. После определения всех остальных аргументов укажите переменную с "**" в начале. Python присвоит этой переменной словарь полученных именованных аргументов, кроме обязательных:
def do_something_else(a, b, c, *args, **kwargs): print a, b, c, args, kwargs do_something_else(1,2,3,4,5,6,7,8,9, timeout=1.5) # выводит "1, 2, 3, (4, 5, 6, 7, 8, 9), {"timeout": 1.5}"
Зачем так делать? Я считаю, самая распространенная причина - функция является оберткой другой функции (или функций), и неиспользуемые именованные аргументы могут быть переданы другой функции (см. п. 5.3).

5.2.1. Уточнение

Использование именованных аргументов и произвольного числа обычных аргументов после них, по-видимому, невозможно, потому что именованные аргументы должны быть определены до "*"-параметра. Например, представим функцию:
def do_something(a, b, c, actually_print = True, *args): if actually_print: print a, b, c, args
У нас проблема: не получится передать actually_print как именованный аргумент, если при этом нужно передать несколько неименованных. Оба следующих варианта вызовут ошибку:
do_something(1, 2, 3, 4, 5, actually_print = True) # actually_print сначала приравнивается к 4 (понятно, почему?), а затем # переопределяется, вызывая TypeError ("got multiple values for keyword argument") do_something(1, 2, 3, actually_print = True, 4, 5, 6) # Именованные аргументы не могут предшествовать обычным. Происходит SyntaxError. Единственный способ задать actually_print в этой ситуации - передать его как обычный аргумент: do_something(1, 2, 3, True, 4, 5, 6) # результат: "1, 2, 3, (4, 5, 6)"
Единственный способ задать actually_print в этой ситуации - передать его как обычный аргумент:
do_something(1, 2, 3, True, 4, 5, 6) # результат: "1, 2, 3, (4, 5, 6)"

5.3. Передача списка или словаря в качестве нескольких аргументов

Поскольку можно получить переданные аргументы в виде списка или словаря, нет ничего удивительного в том, что передавать аргументы функции тоже можно из списка или словаря. Синтаксис совершенно такой же, как в предыдущем пункте, нужно поставить перед списком звездочку:
args = pow(*args) # возвращает pow(5,2), т. е. 25
А для словаря (что используется чаще) нужно поставить две звездочки:
def do_something(actually_do_something=True, print_a_bunch_of_numbers=False): if actually_do_something: print "Something has been done" # if print_a_bunch_of_numbers: print range(10) kwargs = {"actually_do_something": True, "print_a_bunch_of_numbers": True} do_something(**kwargs) # печатает "Something has been done", затем ""
Историческая справка: в Python до версии 2.3 для этих целей использовалась встроенная функция apply (function, arg_list, keyword_arg_dict)".

Operator	Описание	Примеры
	Логический оператор "И". Условие будет истинным если оба операнда истина.	True and True равно True. True and False равно False. False and True равно False. False and False равно False.
	Логический оператор "ИЛИ". Если хотя бы один из операндов истинный, то и все выражение будет истинным.	True or True равно True. True or False равно True. False or True равно True. False or False равно False.
	Логический оператор "НЕ". Изменяет логическое значение операнда на противоположное.	not True равно False. not False равно True.

Python. Операторы ветвления. Условный оператор. Оператор множественного выбора. Структуры организации циклов.

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

Оператора ветвления if....else

Условный оператор реализует выполнение определённых команд при условии, что некоторое логическое выражение (условие) принимает значение «истина» true. В большинстве языков программирования условный оператор начинается с ключевого слова if

Оператор множественного выбора

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

Циклы while и for

Инструкция while, обеспечивает способ организации универсальных циклов;

Инструкция for, предназначена для обхода элементов в последовательностях и выполнения

блока программного кода для каждого из них.

14. Python. Кортежи, словари, списки. Срезы

Кортеж, по сути - неизменяемый список.

Зачем нужны кортежи, если есть списки?

Защита от дурака. То есть кортеж защищен от изменений, как намеренных (что плохо), так и случайных (что хорошо).

Ну и создать кортеж из итерируемого объекта можно с помощью все той же пресловутой функции tuple()

>>> a = tuple("hello, world!")

("h", "e", "l", "l", "o", ",", " ", "w", "o", "r", "l", "d", "!")

Словари в Python - неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.

Методы словарей

dict.clear () - очищает словарь.

dict.copy () - возвращает копию словаря.

classmethod dict.fromkeys (seq[, value]) - создает словарь с ключами из seq и значением value (по умолчанию None).

dict.get (key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).

dict.items () - возвращает пары (ключ, значение).

dict.keys () - возвращает ключи в словаре.

dict.pop (key[, default]) - удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).

dict.popitem () - удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.

dict.setdefault (key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ с значением default (по умолчанию None).

dict.update () - обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

dict.values () - возвращает значения в словаре.

Что такое списки?

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

Чтобы использовать списки, их нужно создать. Создать список можно несколькими способами. Например, можно обработать любой итерируемый объект (например, строку) встроенной функцией list:.

Таблица "методы списков"

Метод Что делает

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

list.extend(L) Расширяет список list, добавляя в конец все элементы списка L

list.insert(i, x) Вставляет на i-ый элемент значение x

list.remove(x) Удаляет первый элемент в списке, имеющий значение x

list.pop([i]) Удаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент

list.index(x, ]) Возвращает положение первого элемента от start до end со значением x

list.count(x) Возвращает количество элементов со значением x

list.sort() Сортирует список на основе функции

list.reverse() Разворачивает список

list.copy() Поверхностная копия списка (новое в python 3.3)

list.clear() Очищает список (новое в python 3.3)

Срезы

В Python, кроме индексов, существуют ещё и срезы.

item - берёт срез от номера START, до STOP (не включая его), с шагом STEP. По умолчанию START = 0, STOP = длине объекта, STEP = 1. Соответственно, какие-нибудь (а возможно, и все) параметры могут быть опущены.

>>> a =

Также все эти параметры могут быть и отрицательными:

>>> a =

>>> a[::-1]

>>> a[-2::-1]

>>> a

В последнем примере получился пустой список, так как START < STOP, а STEP отрицательный. То же самое произойдёт, если диапазон значений окажется за пределами объекта:

>>> a =

>>> a

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

>>> a =

>>> a =