Краткий урок Python (8 части серии)
Красивая серия Caphify Python Tutorial направлена на людей без знаний о программировании и хотела бы забрать его. Как и в случае предыдущих частей, решения для упражнений доступны в Версия размещена на моем собственном сайте.
В прошлый раз, когда все начало получать интересную. На этот раз мы собираемся представить еще несколько типов данных, некоторые из которых являются Musable , который начинает вводить концепцию объектной идентичности или ссылки.
Первый тип данных – это списки, которые в основном такие же, как кортежи, но более полезны на практике. Синтаксис для литералов в списке использует кронштейны вместо скобок:
>>> nums = [1, 7, 4] >>> nums[2] 4 >>> nums + [3, 13] [1, 7, 4, 3, 13]
Индексирование, нарезка, а остальная часть сумки работают точно так же, как они делают на кортежах, и вы можете иметь списки списков или списков кортежей или кортежи списков.
Так какая большая разница?
Если вы играете с корзами и строками, вы могли бы заметить, что вы не можете назначить в них отдельных предметов:
>>> nums = (1, 2, 4) >>> nums[1] = 3 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment >>> word = 'hello' >>> word[2] = 'x' Traceback (most recent call last): File " ", line 1, in TypeError: 'str' object does not support item assignment
(Если бы это было возможно, я бы дал вам назначение, связанное с ним для части 3.)
И это то, что так важно о списках: они смены.
>>> nums = [1, 2, 4] >>> nums[0] = 1.5 >>> nums [1.5, 2, 4]
Так что вам может быть интересно, почему вы когда-либо будете использовать кортежи. Ну, там по крайней мере, две причины, по которым вы можете захотеть, чтобы ваши структуры данных были неизменными. Одним из них является, если данные должны быть постоянной, и любая модификация этого, безусловно, будет ошибкой. Возможно, вы захотите просто сделать список неизменным, чтобы убедиться, что вы случайно не изменяете. (Некоторые языки предлагают общий способ сделать невозможным изменить переменную, но Python не делает.) (Несомненные типы данных также имеют лучшую производительность, если вы не будете изменять их.) Другая большая причина заключается в том, чтобы избежать общего эталона.
Будьте готовы к чему-то действительно сложному. Помните, когда я сказал вам, что х это просто сокращение для x + y ? Это было своего рода упрощением. Это правда Для неизменных типов данных , но для смежных вещей, таких как списки, есть разница.
Соребительные типы данных Приложение Общая ссылка Отказ С неизменными типами, если вы назначите одну переменную к другому, а затем измените один, другое пребывание:
>>> x = 5
>>> y = x
>>> x += 1
>>> y
5
>>> words = ('hi', 'hello')
>>> words2 = words
>>> words += ('hey',)
>>> words2
('hi', 'hello')
>>> words
('hi', 'hello', 'hey')
Они не остаются связанными. Списки, однако:
>>> words = ['hi', 'hello'] >>> words2 = words >>> words += ['hey'] >>> words2 ['hi', 'hello', 'hey'] >>> words ['hi', 'hello', 'hey']
Это изменило оба! Это потому, что на самом деле был только один список. слова был установлен, чтобы обратиться к списку, то Words2 был установлен на значение слова Поэтому, когда вы меняете один, оба имена видят это как измененные. Принимая во внимание, что с кортежами или струнами или ints, поскольку они неизменны, когда вы делаете words2 + = («Эй»,) , что на самом деле происходит, это то, что он расширяется до words2 + («Эй»,) Так что создается второй кортеж, который состоит из слова2 + («Эй»,) . Когда Words2 это список, с другой стороны, words2 + = [«Эй»] объединяет [«Эй»] к Существующие Список хранится в Слова 2. . Мы называем это добавлением «на месте» или Мутирование Существующий список, в отличие от нового и ассигирования нового к той же переменной.
Но тогда есть этот поиск:
>>> words = ['hi', 'hello'] >>> words2 = words + ['hey'] >>> words ['hi', 'hello'] >>> words2 ['hi', 'hello', 'hey']
Если вы используете = (не + = ), Words2 переназначен и останавливается со ссылкой на один и тот же список, что и слова . Я сказал вам упрощенную историю ранее, потому что для неизменных типов данных не имеет значения.
Чтобы понять, как это работает, вам нужно понять разницу между переменной и его значением. Переменные в Python – не что иное, как имена. Если вы делаете nums = [1, 2, 3] а потом позже nums = [4, 5, 6] Вы не изменяете список, вы меняете Nums Отказ Это различие важно. Сам список – это блок данных, хранящихся в памяти где-то. Новый список хранится в другом месте памяти. Но когда вы делаете Nums2 это делает nums2. Обратитесь к тому же основные данные, как Nums в отличие от того, чтобы сделать идентичную копию.
это Оператор действительно полезен для понимания этого:
>>> list1 = [1, 2, 3] >>> list2 = [1, 2, 3] >>> list1 == list2 True >>> list1 is list2 False
== проверяет, являются ли два значения равный . это проверяет, они То же самое Отказ Если вы сделаете это с кормами, вы обнаружите, что TUPLE1 - TUPLE2 будет правдой. Это потому, что, поскольку кортежи неизменяются, когда вы назначаете ту же кортежную букву к двум переменным, Python не делает вторую копию в памяти; Он просто устанавливает обе вариации, чтобы указывать на тот же объект. Но когда вы делаете это со списками, Python должен предположить, что вы хотите, чтобы они могли изменить независимо, поэтому он должен сделать вторую копию.
Важно понимать, что Общая ссылка хорошая иногда и плохая других времен . Иногда вы хотите изменить список в одну часть программы и хотите, чтобы другие места, которые имеют дело с одним и тем же списком, чтобы увидеть изменение. В других случаях вы хотите, чтобы они оставались отдельными, даже если их ценности происходят, чтобы начать равную. Когда вы устанавливаете одну переменную к другому, которое относится к мультянутую объекту, он по умолчанию делится ссылкой, но есть способы сделать отчетную копию, если вы этого не хотите (без вывора буквального значения). Например, list2 [:] сделаю list2 отдельный, но идентичный список. Меняется в один после этого, не повлияет на другой.
Если общая ссылка все еще путает вас, вы не одиноки. Я все еще потратил через это после пары лет узнать Python (я думаю, что я сейчас над этим). Но это придет с практикой. На данный момент давайте продолжим.
Преобразование между списками и кортежами
Кстати, вы можете использовать Список или кортеж Функции для преобразования между списками и кортежами, или для преобразования нищих (но с использованием CLE в списке или кортеже не делают то, что вы можете ожидать - это дает вам представление, которое вы получаете, когда вы их распечатаете).
Сравнение других типов
Пока мы у нас на этом, я упоминаю, что все операторы сравнения работают над вещами, кроме чисел. На струнах, тем больше, чем и меньше, чем операторы обрабатывают строки, как будто персонажи с более высокими значениями являются «большим» – другими словами, они их в алфавиту. На самом деле, это упрощение.
Вы могли бы уже слышать Ascii Отказ Внутренне строка – это последовательность байтов, каждый из которых представляет символ. Например, байт 1100001 (97 в десятичной) это А Отказ ( A это 1000001 – 65.) Полный стол ASCII – Доступно здесь или на бесчисленных других веб-сайтах. (Технически, строки Python используют UTF-8, а не ASCII. Но это обсуждение в другое время, и UTF-8 полностью совместима.)
Для логиров, Правда считается больше, чем Ложь Отказ На самом деле, если вы играете, кроме кода, я показываю вам, вы, возможно, уже заметили, что Правда и Ложь Может использоваться как 1 и 0 Отказ Если вы этого не сделали, попробуйте Печать (True. + True + false + true ) .
Для списка или кортежа сравнение осуществляется путем сравнения по сравнению каждого элемента последовательности, и в первый раз он находит пару, которая не равна, список с большим элементом считается больше. Такое поведение можно рассматривать как обобщение того, как работает строковое сравнение, хотя строка не такая же, как список или кортеж символов. (На многих других языках есть отдельный Char Тип данных, а строка – это список Char s. Но в Python Strings – это их собственный тип данных.)
Никто
Там есть специальное значение под названием Нет Это очень похоже на Ложь , но полезно иметь в качестве альтернативы. Разница в функциональности в том, что Нет не может действовать как 0 или сравнивать с другими числами (что поднимает juyError ). Нет Оценка для Ложь при использовании в качестве условия. Но используя Нет вместо Ложь Можете сделать ваш код более четким, потому что установка переменной в Ложь подразумевает, что это только когда-либо должно иметь логическое значение. Использование Нет Связается, что переменная предназначена для проведения другого типа значения в какой-то момент или в какой-то ситуации, но не сейчас. Я покажу вам хотя бы пример позже, где использовать Нет лучше, чем использование Ложь , хотя бы либо работать.
Я действительно не хотел говорить о методах, пока мы не доберемся до объектов или, по крайней мере, не функционируют, а ну, я не могу избежать этого большего. На данный момент, давайте просто скажем, что методы в основном функционируют, прикрепленные к конкретному типу данных и с специальным Отказ синтаксис. Вот пример:
>>> nums = [5, 4] >>> nums.remove(5) >>> nums [4]
Так что списки есть это Удалить Способ, который принимает значение и удаляет первый элемент в списке, который является это значением. (Это только получает только первый; если Nums были [5, 4, 5] Это было бы [4, 5] После операции.)
Важный жаргон : значение функция Возвращает Это значение, которое он заменен, когда вы выполняете его. Например, вход Возвращает текст введен.
Удалить Метод списков ничего не возвращает, или быть более точным, он возвращает Нет Отказ
Строки имеют несколько прохладных методов, которые я не упомянул раньше (не нужно запомнить все это):
>>> word = 'hello'
>>> word.index('e')
1
>>> word.count('l')
2
>>> word.startswith('h')
True
>>> word.endswith('o')
True
>>> word.replace('l', 'x') # note that this doesn't modify the word, as I'll show on the next line
'hexxo'
>>> word # original word is unchanged. Since strings are immutable, all their methods return a new string.
'hello'
>>> sentence = "Hello, my friend."
>>> sentence.split(' ')
['Hello,', 'my', 'friend.']
>>> sentence.upper()
'HELLO, MY FRIEND.'
>>> sentence.lower()
'hello, my friend.'
>>> sentence.title()
'Hello, My Friend.'
>>> '...'.join(["hello", "my", "friend"]) # See how this works?
'hello...my...friend'
И много других. Списки и кортежи также имеют считать и показатель .
list.append (значение)– Добавляет значение в список на месте. Обратите внимание, что таким образом вам не нужно ставить кронштейны вокруг него. (Это также немного быстрее, чем использование+ =.)list.pop (i)– удаляет элемент в положенииi(по умолчанию-1) и верните его.list.insert (индекс, значение)– Вставляет данныйценностьНа данномИндексОтказСписок ()– Переверняет его на месте.list.clear ()– Удаляет все элементы. Разница между этим и установка переменной в[]Это переназначение разбивает общие ссылки;list.clear ()меняет список на месте.
Даже INT и поплавки имеют некоторые методы, но все они довольно неясны.
Чтобы использовать ваши новые знания изменных списков, методов и общего эталона, попробуйте написать программу, которая получает предложение от пользователя, а затем позволяет им сделать для него следующие вещи, пока они не сделают:
- Вставлять слово
- Удалить все вхождения слова
- Удалить слово в указанном положении
- Сохранить предложение, если они делают что-то случайное, и возвращает предложение к его сохраненному состоянию
И какие другие операции вы хотите реализовать.
Когда они закончили манипулирование своим предложением, распечатайте его с первым словом, заглавным, как правильное предложение. Затем напечатайте количество раз, когда каждая буква происходит в предложении.
<Решение опущено>
Еще один важный тип данных – это словарь (обычно только что называется диктором). Настоящий словарь имеет определение для каждого слова. У Python D ICT имеет «значение» для каждого «ключа», и вы можете найти ключ, чтобы получить его значение:
>>> spanish = {'casa': 'house', 'hola': 'hello', 'si': 'yes'}
>>> print(spanish['casa'])
'house'
Насколько аккуратно это!
Диктовы не уважают порядок, кстати, так {'a': 'z', 'b': 'y'} и {'b': 'y', 'a': 'z'} одинаковые диктовы.
Диктовы не хранят дубликаты, поэтому, когда вы назначаете ключ, он получает это значение независимо от того, что он имел или существует ли он ранее:
>>> spanish['hablar'] = 'talk'
{'casa': 'house', 'hola': 'hello', 'si': 'yes'}
>>> spanish
{'casa': 'house', 'hola': 'hello', 'si': 'yes', 'hablar': 'talk'}
>>> spanish['hablar'] = 'speak' # the verb more or less covers both English words
>>> spanish
{'casa': 'house', 'hola': 'hello', 'si': 'yes', 'hablar': 'speak'}
Чтобы удалить ключ из словаря, вы можете использовать дель :
>>> del spanish['hola']
>>> spanish
{'casa': 'house', 'si': 'yes', 'hablar': 'speak'}
Когда вы пытаетесь получить доступ к ключам словаря, который не существует, вы получите ошибку:
>>> spanish['entender'] # it means 'understand', by the way, but I haven't put it in the dictionary Traceback (most recent call last): File "", line 1, in KeyError: 'entender'
Полезные методы Dict:
Dict.get (ключ)– Как доступ к ключу, но если ключ не существует, вы получитеНетОтказ
Теперь, я думаю, что вы знаете Dicts, есть еще один случай, когда вы будете использовать кортежи вместо списков: словарные ключи не могут быть спискими, другими дикторами или другими встроенными мультяшными типами. Это, вероятно, является следствием того, как «Словарь хранится в памяти» (и я не мог точно объяснить вам, почему), но это так, поэтому вы можете использовать кортежи, если вы хотите, чтобы последовательность значений была ключом к диктому.
Итерация на диктографию
для и в Оба лечат диктопов в виде последовательностей ключей, поэтому:
>>> 'casa' in spanish True >>> 'house' in spanish False >>> for word in spanish: ... print(word, 'means', spanish[word]) casa means house hola means hello si means yes hablar means speak
Вот (надеюсь) веселое задание. Напишите программу, которая позволяет группе людей каждый ввести их имена и список результатов, которые они получили. Затем, когда пользователь подтверждает, что они сделаны, распечатайте наивысшую оценку и имя человека, который получил его, и средний балл каждого человека.
Некоторые функции, которые помогут вам вот встроенные Макс и сумма , который принимает последовательность любого типа и дает вам максимальное или общее значение, если применимо. (Если вы используете их на последовательности значений, которые не могут сравнить, как Max ([4, 'A']) Вы получите ошибку.) Вы можете сделать это без них, реализуя свою логику себя, но используя встроенные усилия.
<Решение опущено>
Краткий урок Python (8 части серии)
Оригинал: “https://dev.to/yujiri8/the-concise-python-tutorial-part-4-mutable-types-2k98”