Искомая комбинация слов нигде не встречается: Нравственные основы цивилизованного общества или «yandex

Автозаполнение из пользовательского списка

AutoFill может реально сэкономить время, если вы часто работаете с заданными списками данных. Вы можете определить свои собственные списки, а затем ...

Установка полей печати по умолчанию

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

Перекрывающиеся символы

Хотите добавить надстрочный знак над одним или двумя символами в документе? Есть несколько способов, которые вы можете попробовать, как описано в разделе...

Создание тонких пространств

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

Применение формата заглавных букв

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

3.Строки, списки и кортежи - начало программирования на Python для начинающих веб-разработчиков

3.1. Типы данных последовательности

В прошлой главе мы представили встроенные типы Python int , float , и str , и мы наткнулись на кортеж .

Целые числа и числа с плавающей запятой - это числовые типы , что означает, что они содержат числа. Мы можно использовать числовые операторы, которые мы видели в предыдущей главе, чтобы сформировать числовые выражения. Интерпретатор Python может затем вычислить эти выражения для производить числовые значения, что делает Python очень мощным калькулятор.

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

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

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

Списки заключены в квадратные скобки ( [ и ] ) и кортежи в круглые скобки ( ( и ) ).

Список, не содержащий элементов, называется пустым списком , а кортеж с no elements - это пустой кортеж .

 [10, 20, 30, 40, 50]
[«спам», «тарзанка», «глотать»]
(2, 4, 6, 8)
(«два», «четыре», «шесть», «восемь»)
[("сыр", "queso"), ("красный", "rojo"), ("школа", "escuela")]
 

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

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

Примечание

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

 >>> вещь = 2, 4, 6, 8
>>> тип (вещь)
<класс 'кортеж'>
>>> вещь
(2, 4, 6, 8)
 

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

 >>> одиночный элемент = (2,)
>>> тип (одиночный)
<класс 'кортеж'>
>>> not_tuple = (2)
>>> тип (not_tuple)
<класс 'int'>
>>> empty_tuple = ()
>>> тип (empty_tuple)
<класс 'кортеж'>
 

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

3.2. Работа с частями последовательности

Типы последовательностей имеют общий набор операций.

3.2.1. Индексирование

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

 >>> фрукт = "банан"
>>> фрукты [1]
'а'
>>> fruit = ['яблоки', 'вишня', 'груши']
>>> фрукты [0]
'яблоки'
>>> цены = (3.99, 6,00, 10,00, 5,25)
>>> цены [3]
5,25
>>> пары = [('сыр', 'queso'), ('красный', 'rojo'), ('школа', 'escuela')]
>>> пары [2]
('школа', 'escuela')
 

Выражение плод [1] выбирает символ с индексом 1 из плод и создает новую строку, содержащую только этот один символ, Вы можете быть удивлены, увидев, что это 'a' .

Вы, вероятно, ожидали увидеть 'b' , но компьютерные ученые обычно начинают отсчет с нуля, а не с единицы.Думайте об индексе как о числах на линейке измеряя, сколько элементов вы переместили в последовательность из начало. И линейки, и индексы начинаются с 0 .

3.2.2. Длина

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

Для списков и кортежей len возвращает количество элементов в последовательности:

 >>> len (['a', 'b', 'c', 'd'])
4
>>> len ((2, 4, 6, 8, 10, 12))
6
>>> пары = [('сыр', 'queso'), ('красный', 'rojo'), ('школа', 'escuela')]
>>> len (пары)
3
 

3.2.3. Доступ к элементам в конце последовательности

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

 >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq [len (seq)] # ОШИБКА!
 

Это не сработает. Это вызывает ошибку времени выполнения IndexError: список индекса вне диапазон . Причина в том, что len (seq) возвращает количество элементов в list, 16, но нет элемента в позиции индекса 16 в seq .

Поскольку мы начали отсчет с нуля, шестнадцать индексов пронумерованы от 0 до 15. Чтобы чтобы получить последний элемент, мы должны вычесть 1 из длины:

 >>> last = seq [len (seq) - 1]
 

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

Выражение seq [-1] дает последний элемент, seq [-2] дает предпоследний и так далее.

 >>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> простые_числа [-2]
29
>>> одноклассники = («Алехандро», «Эд», «Кэтрин», «Пресила», «Шон», «Питер»)
>>> одноклассники [-5]
'Эд'
>>> word = "Алфавит"
>>> слово [-3]
'b'
 

3.2.4. Обход и

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

Цикл Python для упрощает выражение обхода:

 prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

для числа в простых_числах:
    печать (число ** 2)
 

Примечание

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

3.3.

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

 фруктов = ['яблоки', 'бананы', 'черника', 'апельсины', 'манго']

для index, fruit in enumerate (фрукты):
    print ("Фрукт" + фрукт + "находится в позиции" + str (index) + ".")
 

3.3.1. Ломтики

Подпоследовательность последовательности называется срезом , а операция, которая извлекает подпоследовательность, которая называется , нарезка . Как и в случае с индексированием, мы используем квадратные скобки ( [ ] ) в качестве оператора среза, но вместо одного целого числа значение внутри у нас есть два, разделенные двоеточием (: ):

 >>> singers = "Петр, Павел и Мария"
>>> певцы [0: 5]
'Питер'
>>> певцы [7:11]
'Павел'
>>> певцы [17:21]
'Мэри'
>>> одноклассники = («Алехандро», «Эд», «Кэтрин», «Пресила», «Шон», «Питер»)
>>> одноклассники [2: 4]
('Кэтрин', 'Пресила')
 

Оператор [n: m] возвращает часть последовательности из n-го элемента. к m-му элементу, включая первый, но исключая последний.Это поведение противоречит интуиции; это имеет больше смысла, если вы представите индексы, указывающие между знаков, как на следующей диаграмме:

Если вы опустите первый индекс (перед двоеточием), срез начнется с начало строки. Если вы опустите второй индекс, срез перейдет в конец строки. Таким образом:

 >>> фрукт = "банан"
>>> фрукт [: 3]
'запретить'
>>> фрукт [3:]
'ана'
 

Как вы думаете, что означает s [:] ? А как насчет одноклассников [4:] ?

Отрицательные индексы также разрешены, поэтому

 >>> фрукты [-2:]
'на'
>>> одноклассники [: - 2]
('Алехандро', 'Эд', 'Кэтрин', 'Пресила')
 

Подсказка

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

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

 >>> странный_лист = [(1, 2), [1, 2], '12', 12, 12.0]
>>> print (список_транзи [0], тип (список_странных [0]))
(1, 2) <класс 'кортеж'>
>>> print (список_транзи [0: 1], тип (список_странных [0: 1]))
[(1, 2)] <класс 'список'>
>>> print (список_транзи [2], тип (список_странных [2]))
12 <класс 'str'>
>>> print (список_транзи [2: 3], тип (список_странных [2: 3]))
[12] <список классов>
>>>
 

Хотя элементы списка (или кортежа) могут быть любого типа, независимо от того, как вы нарезать его, фрагмент списка - это список.

3.3.2.

Оператор в возвращает, содержится ли данный элемент в списке или кортеж:

 >>> stuff = ['это', 'то', 'эти', 'те']
>>> 'this' в материале
Правда
>>> 'все' в материале
Ложь
>>> 4 в (2, 4, 6, 8)
Правда
>>> 5 в (2, 4, 6, 8)
Ложь
 

в несколько иначе работает со строками. Он оценивается как Истинно , если один строка является подстрокой другого:

 >>> 'p' в 'яблоке'
Правда
>>> 'я' в 'яблоке'
Ложь
>>> 'ap' в 'яблоке'
Правда
>>> 'pa' в 'яблоке'
Ложь
 

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

 >>> 'а' в 'а'
Правда
>>> "яблоко" в "яблоке"
Правда
>>> '' в 'а'
Правда
>>> '' в 'яблоке'
Правда
 

3.4. Объекты и методы

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

Давайте посмотрим на некоторые строковые методы в действии, чтобы увидеть, как это работает.

 >>> 'яблоко'.upper ()
'ЯБЛОКО'
>>> 'COSATU'.lower ()
'cosatu'
>>> 'rojina'.capitalize ()
'Рожина'
>>> '42'.isdigit ()
Правда
>>> 'four'.isdigit ()
Ложь
>>> 'remove_the_spaces' .strip ()
'remove_the_spaces'
>>> 'Миссисипи'. Начинается с ('Мисс')
Правда
>>> 'Aardvark'.startswith (' Муравей ')
Ложь
 

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

В первом примере за строкой "яблоко" следует оператор точки. а затем метод upper () , который имеет пустой список параметров. Мы говорим что метод upper () - это , вызванный в строке, 'apple' . Вызов метода вызывает выполнение действия с использованием значения, на котором вызывается метод. Действие дает результат, в данном случае строковое значение «Яблоко» . Мы говорим, что метод upper () возвращает строку «Apple» при его вызове (или при вызове ) строки «яблоко» .

В четвертом примере метод - это цифра () (снова с пустым параметром list) вызывается в строке '42' . Поскольку каждый из персонажей строка представляет собой цифру, метод isdigit () возвращает логическое значение Правда . Вызов isdigit () на "четыре" дает False .

Полоса () удаляет начальные и конечные пробелы.

3,5. Функция

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

 >>> dir (str)
 ['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
  '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
  '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__',
  '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__',
  '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__',
  '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
  'capize', 'center', 'count', 'encode', 'endwith', 'expandtabs',
  'найти', 'формат', 'формат_карты', 'индекс', 'isalnum', 'isalpha',
  isdecimal, isdigit, isidentifier, islower, isnumeric,
  isprintable, isspace, istitle, isupper, join, ljust,
  'нижний', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind',
  'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split',
  'splitlines', 'startwith', 'strip', 'swapcase', 'title', 'перевести',
  'верхний', 'zfill']
>>>
 

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

 >>> печать (str.replace .__ doc__)
S.replace (old, new [, count]) -> str

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

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

 >>> 'Миссисипи'.replace (' i ',' X ')
"MXssXssXppX"
>>> 'Миссисипи'. Заменить ('p', 'MO')
'MississiMOMOi'
>>> 'Миссисипи'.replace (' i ',' ', 2)
'Mssssippi'
 

Первый пример заменяет все вхождения 'i' на 'X' . В второй заменяет одиночный символ 'p' двумя символами 'MO' . В третьем примере первые два вхождения 'i' заменяются пустым нить.

3.6.

Есть два общих метода для всех трех типов последовательностей: count и , индекс . Давайте посмотрим на их документацию, чтобы увидеть, что они делают.

 >>> печать (str.count .__ doc__)
S.count (sub [, начало [, конец]]) -> int

Возвращает количество неперекрывающихся вхождений подстроки sub в
строка S [начало: конец]. Необязательные аргументы start и end:
интерпретируется как в обозначении среза.
>>> print (кортеж.count .__ doc__)
T.count (значение) -> целое число - вернуть количество вхождений значения
>>> print (list.count .__ doc__)
L.count (значение) -> integer - вернуть количество вхождений значения
>>> печать (str.index .__ doc__)
S.index (sub [, начало [, конец]]) -> int

Подобно S.find (), но вызывает ошибку ValueError, если подстрока не найдена.
>>> print (tuple.index .__ doc__)
T.index (value, [start, [stop]]) -> integer - вернуть первый индекс значения.
Вызывает ValueError, если значение отсутствует. >>> печать (list.index .__ doc__)
L.index (value, [start, [stop]]) -> integer - вернуть первый индекс значения.
Вызывает ValueError, если значение отсутствует.
 

Мы исследуем эти функции в упражнениях.

3,7. Списки изменяемые

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

 >>> fruit = ["банан", "яблоко", "айва"]
>>> fruit [0] = "груша"
>>> fruit [-1] = "апельсин"
>>> фрукты
['груша', 'яблоко', 'апельсин]
 

Оператор скобок, применяемый к списку, может появляться в любом месте выражения.Когда он появляется слева от задания, он меняет один из элементов в списке, поэтому первый элемент fruit был изменен с «банан» до «груша» и последние от «айва» до «апельсин» . An присвоение элементу списка называется присвоением позиции . Предмет присвоение не работает для строк:

 >>> my_string = 'ТЕСТ'
>>> my_string [2] = 'X'
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: объект 'str' не поддерживает назначение элементов
 

, но для списков:

 >>> my_list = ['T', 'E', 'S', 'T']
>>> my_list [2] = 'X'
>>> мой_лист
['T', 'E', 'X', 'T']
 

С помощью оператора среза мы можем обновить сразу несколько элементов:

 >>> a_list = ['a', 'b', 'c', 'd', 'e', ​​'f']
>>> a_list [1: 3] = ['x', 'y']
>>> a_list
['a', 'x', 'y', 'd', 'e', ​​'f']
 

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

 >>> a_list = ['a', 'b', 'c', 'd', 'e', ​​'f']
>>> a_list [1: 3] = []
>>> a_list
['a', 'd', 'e', ​​'f']
 

И мы можем добавлять элементы в список, сжимая их в пустой фрагмент в желаемое место:

 >>> a_list = ['a', 'd', 'f']
>>> a_list [1: 1] = ['b', 'c']
>>> a_list
['a', 'b', 'c', 'd', 'f']
>>> a_list [4: 4] = ['e']
>>> a_list
['a', 'b', 'c', 'd', 'e', ​​'f']
 

3.

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

del удаляет элемент из списка:

 >>> a = ['один', 'два', 'три']
>>> дель а [1]
>>> а
['один три']
 

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

Вы можете использовать срез в качестве индекса для del :

 >>> a_list = ['a', 'b', 'c', 'd', 'e', ​​'f']
>>> del a_list [1: 5]
>>> a_list
['a', 'f']
 

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

3.9. Список методов

Помимо count и index , списки имеют несколько полезных методов. Поскольку списки изменяемы, эти методы изменяют список, в котором они вызывается, а не возвращает новый список.

 >>> mylist = []
>>> mylist.append ('это')
>>> мой список
['это']
>>> mylist.append ('это')
>>> мой список
['это', 'то']
>>> mylist.insert (1, 'вещь')
>>> мой список
['это', 'вещь', 'то']
>>> мой список.Сортировать()
>>> мой список
['то', 'вещь', 'это']
>>> mylist.remove ('вещь')
>>> мой список
['что это']
>>> mylist.reverse ()
>>> мой список
['это', 'то']
 

Метод sort особенно полезен, поскольку он упрощает использование Python для сортировки данных, которые вы поместили в список.

3.10. Имена и изменяемые значения

Если мы выполним эти операторы присваивания,

 >>> a = [1, 2, 3]
>>> b = [1, 2, 3]
 

мы знаем, что имена a и b будут относиться к списку с номерами 1 , 2 и 3 .Но мы пока не знаем, указывают ли они на тот же . список.

Возможны два состояния:

или

В одном случае a и b относятся к двум разным объектам, которые имеют одинаковые ценить. Во втором случае они относятся к одному и тому же объекту.

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

Мы можем проверить, относятся ли два имени к одному и тому же объекту, используя is оператор:

Это говорит нам о том, что a и b не относятся к одному и тому же объекту, и что это первая из двух диаграмм состояний, которая описывает отношения.

3.11. Псевдоним

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

 >>> a = [1, 2, 3]
>>> б = а
>>> а это б
Правда
 

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

Поскольку один и тот же список имеет два разных имени, a и b , мы говорим, что он - это с псевдонимом .Поскольку списки изменяемы, изменения, внесенные с одним псевдонимом, влияют на другой:

 >>> b [0] = 5
>>> а
[5, 2, 3]
 

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

3.12. Списки клонирования

Если мы хотим изменить список, а также сохранить копию оригинала, нам нужно возможность сделать копию самого списка, а не только ссылки.Этот процесс иногда называют клонированием , чтобы избежать двусмысленности слова «копия».

Самый простой способ клонировать список - использовать оператор среза:

 >>> a = [1, 2, 3]
>>> b = a [:]
>>> б
[1, 2, 3]
 

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

Теперь мы можем вносить изменения в b , не беспокоясь о a :

 >>> b [0] = 5
>>> а
[1, 2, 3]
 

3.

Вложенный список - это список, который появляется как элемент другого списка. В этом list элемент с индексом 3 является вложенным списком:

 >>> nested = ["привет", 2.0, 5, [10, 20]]
 

Если мы напечатаем вложенных [3] , мы получим [10, 20] . Чтобы извлечь элемент из вложенный список, мы можем выполнить два шага:

 >>> elem = nested [3]
>>> элем [0]
10
 

Или мы можем объединить их:

Операторы скобок вычисляются слева направо, поэтому это выражение получает Элемент three-eth из вложил и извлек из него элемент one-eth.

3,14. Строки и списки

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

Команда list принимает в качестве аргумента тип последовательности и создает список из его элементов. При применении к строке вы получаете список символов.

 >>> list ("Хрустящая лягушка")
['C', 'r', 'u', 'n', 'c', 'h', 'y', '', 'F', 'r', 'o', 'g']
 

Метод split вызывается для строки и разделяет строку на список строк, разбивая его на части всякий раз, когда подстрока вызвала появляется разделитель.По умолчанию разделитель - это пробел, который включает пробелы, табуляции и символы новой строки.

 >>> "Хрустящая лягушка в темном сладко-сладком шоколаде" .split ()
["Хрустящий", "лягушка", "покрытый", "в", "темный", "сладко-горький", "шоколадный"]
 

Здесь у нас 'o' в качестве разделителя.

 >>> "Хрустящая лягушка в темном сладко-сладком шоколаде" .split ('o')
['Crunchy fr', 'gc', 'с оттенком темного, сладко-горького ch', 'c', 'поздно']
 

Обратите внимание, что разделителя нет в списке.

Метод соединения приблизительно противоположен методу разделения . Он принимает в качестве аргумента список строк и возвращает строку со всеми элементы списка соединены вместе.

 >>> ''. join (['хрустящий', 'сырой', 'без костей', 'настоящий', 'мертвый', 'лягушка'])
'хрустящая сырая настоящая мертвая лягушка без костей'
 

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

 >>> '**'. Join (['хрустящий', 'сырой', 'без костей', 'настоящий', 'мертвый', 'лягушка'])
'хрустящая ** сырая ** без костей ** настоящая ** мертвая ** лягушка'
 

Разделителем также может быть пустая строка.

 >>> '' .join (['хрустящий', 'сырой', 'без костей', 'настоящий', 'мертвый', 'лягушка'])
'crunchyrawunbonedrealdeadfrog'
 

3,15. Присвоение кортежа

Время от времени полезно менять местами значения двух переменных. С обычные операторы присваивания, мы должны использовать временную переменную.Для Например, чтобы поменять местами a и b :

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

Левая часть представляет собой набор переменных; правая часть - это набор значений. Каждому значению присваивается соответствующая переменная. Все выражения на правая сторона оценивается перед любым из заданий. Эта функция делает Назначение кортежей довольно универсально.

Естественно, количество переменных слева и количество значений на право должно быть одинаковым:

 >>> а, б, в, г = 1, 2, 3
ValueError: требуется более 3 значений для распаковки
 

3,16. Логические значения

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

Примечание

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

Есть только два логических значения: Истина и Ложь .

 >>> тип (Истина)
<класс 'bool'>
>>> type (Ложь)
<класс 'bool'>
 

Использование заглавных букв важно, так как true и false не являются логическими значения в Python .:

 >>> тип (истина)
Отслеживание (последний вызов последний):
Файл «<интерактивный ввод>», строка 1, в <модуле>
NameError: имя 'true' не определено
 

3.17. Логические выражения

Логическое выражение - это выражение, вычисляющее логическое значение.

Оператор == сравнивает два значения и выдает логическое значение:

 >>> 5 == 5
Правда
>>> 5 == 6
Ложь
 

В первом операторе два операнда равны, поэтому выражение оценивает to True ; во втором утверждении 5 не равно 6, поэтому мы получаем False .

Оператор == является одним из шести распространенных операторов сравнения ; другие являются:

 x! = Y # x не равно y
x> y # x больше y
x  = y # x больше или равно y
x <= y # x меньше или равно y
 

Хотя эти операции, вероятно, вам знакомы, символы Python отличается от математических символов.Распространенной ошибкой является использование одного знак равенства ( = ) вместо двойного знака равенства ( == ). Помните, что = - это оператор присваивания , а == - это оператор сравнения . Также там не может быть = < или => .

3,18. Логические операторы

Есть три логических оператора : и , или , и не . В семантика (значение) этих операторов аналогична их значению в английском языке.Например, x> 0 и x <10 истинно, только если x больше 0 и при этом x меньше 10.

n% 2 == 0 или n% 3 == 0 истинно, если либо условий истинно, то есть, если число делится на 2 или делится на 3.

Наконец, оператор not отрицает логическое выражение, поэтому not (x> y) истинно, если (x> y) ложно, то есть, если x меньше или равно л .

 >>> 5> 4 и 8 == 2 * 4
Правда
>>> Верно и неверно
Ложь
>>> Ложь или правда
Правда
 

3,19. Оценка короткого замыкания

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

Это может быть весьма полезно для предотвращения ошибок времени выполнения.Представьте, что вы хотите проверьте, четное ли пятое число в кортеже целых чисел с именем чисел .

Будет работать следующее выражение:

 >>> числа = (5, 11, 13, 24)
>>> числа [4]% 2 == 0
 

, если, конечно, в числах нет 5 элементов, и в этом случае вы получит:

 Traceback (последний вызов последний):
  Файл "", строка 1, в 
IndexError: индекс кортежа вне допустимого диапазона
>>>
 

Оценка короткого замыкания позволяет избежать этой проблемы.

 >>> len (числа)> = 5 и числа [4]% 2 == 0
Ложь
 

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

3.20. «Истина»

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

числовые типы

Значения, равные 0, ложны, все остальные верны.

типов последовательностей

Пустые последовательности - ложные, непустые - истинные.

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

 >>> 'А' и 'яблоки'
'яблоки'
>>> '' и 'яблоки'
''
>>> '' или [5, 6]
[5, 6]
>>> ('a', 'b', 'c') или [5, 6]
('а', 'б', 'в')
 

3.21. Глоссарий

псевдонимов

Несколько переменных, содержащих ссылки на один и тот же объект.

логическое значение

Имеется ровно два логических значения: Истина и Ложь . Логический значения результат, когда логическое выражение оценивается Python Интерпретатор. У них тип bool .

логическое выражение

Выражение, которое может быть истинным или ложным.

clone

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

оператор сравнения

Один из операторов, сравнивающих два значения: == , ! = , > , <, > = и <= .

составной тип данных

Тип данных, в котором значения состоят из компонентов или элементов, это сами по себе ценности.

element

Одна из частей, составляющих тип последовательности (строка, список или кортеж).У элементов есть значение и индекс. Доступ к значению осуществляется с помощью индексный оператор ( [* index *] ) в последовательности.

неизменяемый тип данных

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

index

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

логический оператор

Один из операторов, который объединяет логические выражения: и , или , а не .

изменяемый тип данных

Тип данных, который можно изменять. Все изменяемые типы являются составными типы. Списки и словари - это изменяемые типы данных; струны и кортежи - нет.

вложенный список

Список, который является элементом другого списка.

slice

Часть строки (подстрока), заданная диапазоном индексов. Более как правило, подпоследовательность любого типа последовательности в Python может быть создана с помощью оператора среза (последовательность [начало: остановка] ).

размер шага

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

.

traverse

Чтобы перебирать элементы коллекции, выполняя аналогичный операция на каждом.

кортеж

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

присвоение кортежа

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