Питон это: Что такое Python? – Описание языка программирования Python

Содержание

Подробнее о Python | Python: Настройка окружения

Зарегистрируйтесь для доступа к 15+ бесплатным курсам по программированию с тренажером

Чтобы глубже погрузиться в настройку окружения Python, нам нужно вспомнить теоретические основы этого языка. Они помогут глубже разобраться в окружении и работе с ним.

Язык программирования

Что такое язык программирования? За этим понятием скрываются две связанных, но независимых темы.

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

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

Например, в Python нельзя написать my name = 5 с пробелом в имени переменной. Эти правила существуют не только в книгах, но и в головах конкретных программистов и разработчиков языка.

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

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

Среда выполнения — это конкретное воплощение спецификации, поэтому ее иногда называют реализацией.

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

У Python нет выделенной спецификации, но есть эталонная реализация. Она называется CPython — это интерпретатор Python, реализованный на языке C. Если вы слышите разговоры про Python, то скорее всего имеется в виду именно эталонная реализация CPython.

Прочие варианты обычно имеют свои названия. Например, реализация языка для запуска программ на платформе .NET называется IronPython.

Python

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

Интерпретируемый язык программирования

Существуют языки программирования, в которых есть стадия компиляции в машинный код. Например, компиляция есть у языков C, Rust, Go. Это компилируемые языки.

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

Строго говоря, и у Python есть фаза компиляции, но при этом внешне он ведет себя именно как интерпретируемый язык программирования:

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

Динамическая типизация

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

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

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

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

Сильная типизация

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

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

Дополнительные материалы

Что такое компиляция
Что такое интерпретация

Остались вопросы? Задайте их в разделе «Обсуждение»

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

Для полного доступа к курсу нужен базовый план

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

Получить доступ

130

курсов

1000

упражнений

2000+

часов теории

3200

тестов

Открыть доступ

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

130 курсов, 2000+ часов теории
1000 практических заданий в браузере
360 000 студентов

Электронная почта *

Отправляя форму, вы принимаете «Соглашение об обработке персональных данных» и условия «Оферты», а также соглашаетесь с «Условиями использования»

Наши выпускники работают в компаниях:

Python — это просто.

Пошаговое руководство по программированию и анализу данных Нилаб Нисчал

Артикул	2867
ISBN	978-5-9775-6849-4
Количество страниц	416
Формат издания	197 x 250 мм
Печать	Черно-белая
Серия	Это просто

~~963 ₽~~
722 ₽

# Python# бэкенд# для начинающих

Описание
Детали

Отзывы (0)

Описание

Рассмотрены основы синтаксиса языка Python на примере дистрибутива Anaconda. Показаны приложения IPython, Spyder IDE, Jupyter Notebook. Описан синтаксис переменных, функций, циклов. Подробно изучаются структуры данных в Python: строки, списки, кортежи, множества и словари. Объясняется понятие классов и их применение в объектно-ориентированном программировании. Описаны возможности библиотеки обработки изображений Pillow, библиотеки Tkinter для создания приложений с графическим интерфейсом. Отдельный раздел посвящен обработке ошибок и исключений в программах. Рассматриваются библиотеки NumPy и Pandas, приводятся практические примеры их использования для анализа и обработки данных. Описана библиотека Matplotlib и ее возможности в сфере визуализации данных.

Для программистов

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

• Исследуйте возможности Python с использованием дистрибутива Anaconda
• Узнайте, как установить и использовать Python на своем компьютере
• Создавайте свои переменные, объекты и изучите их синтаксис
• Изучите встроенные типы объектов Python, такие как строки, списки, кортежи, множества и словари
• Научитесь вызывать встроенные функции, а также писать свои собственные
• Организуйте свой код и другие объекты в более крупные компоненты с помощью модулей
• Исследуйте классы — инструмент объектно-ориентированного программирования
• Пишите сложный код, научитесь обрабатывать ошибки и исключения
• Узнайте о массивах NumPy и операциях с ними
• Изучите анализ данных с помощью Pandas
• Погрузитесь в захватывающий мир визуализации с использованием Matplotlib
• Научитесь создавать приложения Python с графическим интерфейсом

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

Если бы годы назад ко мне в руки попала эта книга, я бы сэкономил месяцы, потраченные на множество блогов, книг и сайтов, откуда черпал знания и идеи. Сегодня очень нужны профессионалы, готовые сразу же приступить к решению бизнес-задач. Больше не существует роскоши в виде длительной и непродуктивной учебы, выполняемой за счет вашего работодателя. Надеемся, что эта книга поможет вам восполнить этот пробел.
Анкит Куш, основатель и генеральный директор компании Cobodh, Руководитель, регион APAC, облачная маркетинговая аналитика, Searce (технарь и энтузиаст, грезящий о технологической сингулярности)

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

Детали

Артикул	2867
ISBN	978-5-9775-6849-4
Количество страниц	416
Серия	Это просто
Переплет	Мягкая обложка
Печать	Черно-белая
Год	2022
Габариты, мм	250 × 197 × 32
Вес, кг	1.18

Дополнительные файлы скачать: Зеркало1Дополнительные файлы скачать (Chrome): Зеркало2

✓ Новинки на 2 недели раньше магазинов
✓ Цены от издательства ниже до 30%
✓ Акции и скидки только для подписчиков
✓ Важные новости БХВ

ПОЛЕЗНАЯ РАССЫЛКА КНИЖНЫХ НОВОСТЕЙ

Подписываясь на рассылку, вы соглашаетесь с политикой конфиденциальности и обработкой своих персональных данных.

Сравнение объектов в Python — Real Python

Смотреть сейчас Это руководство содержит соответствующий видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Правильное сравнение объектов Python: «is» vs «==»

is для сравнения чисел, пока он вдруг не перестанет работать. Возможно, вы где-то слышали, что Python 9Оператор 0008 is быстрее, чем оператор == , или вам может показаться, что он выглядит более Pythonic. Однако важно помнить, что эти операторы ведут себя по-разному.
Оператор == сравнивает значение или равенство двух объектов, тогда как оператор Python is проверяет, указывают ли две переменные на один и тот же объект в памяти. В подавляющем большинстве случаев это означает, что вы должны использовать операторы равенства == и != , за исключением случаев, когда вы сравниваете с None .
Из этого руководства вы узнаете:
В чем разница между равенством объектов и идентичностью
Когда использовать операторы равенства и идентичности для сравнения объектов

Что эти оператора Python делают под капотом
Почему использование — это , а — это не для сравнения значений, что приводит к неожиданному поведению
Как написать пользовательский __eq__() метод класса для определения поведения оператора равенства
Пит-стоп Python: Это руководство представляет собой быстрый и практичный способ найти нужную информацию, так что вы вернетесь к своему проекту в кратчайшие сроки!
Бесплатный бонус: Нажмите здесь, чтобы получить шпаргалку по Python и изучить основы Python 3, такие как работа с типами данных, словарями, списками и функциями Python.

Сравнение удостоверений с Python есть и не является операторами
Python — это , а — это не , операторы сравнивают тождество двух объектов. В CPython это их адрес памяти. Все в Python является объектом, и каждый объект хранится в определенном месте памяти. Операторы Python — это , а — это не , проверяющие, ссылаются ли две переменные на один и тот же объект в памяти.
Примечание: Имейте в виду, что объекты с одинаковым значением обычно хранятся по разным адресам памяти.
Вы можете использовать id() для проверки подлинности объекта:
>>>
>>> справка(id) Справка по встроенному идентификатору функции во встроенных модулях: идентификатор (объект, /) Вернуть идентификатор объекта. Это гарантированно будет уникальным среди одновременно существующих объектов. (CPython использует адрес памяти объекта.) >>> идентификатор (id) 2570892442576
В последней строке указан адрес памяти, где хранится сама встроенная функция id .
В некоторых распространенных случаях объекты с одинаковым значением по умолчанию будут иметь одинаковый идентификатор. Например, числа от -5 до 256 — это , интернированное в CPython. Каждое число хранится в единственном и фиксированном месте в памяти, что экономит память для часто используемых целых чисел.
Вы можете использовать sys.intern() для интернирования строк для повышения производительности. Эта функция позволяет сравнивать их адреса памяти, а не сравнивать строки посимвольно:
>>>
>>> из sys import стажер >>> a = 'привет, мир' >>> b = 'привет, мир' >>> а есть б ЛОЖЬ >>> идентификатор (а) 1603648396784 >>> идентификатор (б) 1603648426160 >>> а = стажер(а) >>> б = стажер(б) >>> а есть б Истинный >>> идентификатор (а) 1603648396784 >>> идентификатор (б) 1603648396784
Переменные a и b изначально указывают на два разных объекта в памяти, о чем свидетельствуют их разные идентификаторы. Когда вы стажируете их, вы гарантируете, что a и b указывают на один и тот же объект в памяти. Любая новая строка со значением 'hello world' теперь будет создаваться в новой ячейке памяти, но когда вы интернируете эту новую строку, вы убедитесь, что она указывает на тот же адрес памяти, что и первый 'hello world' . что вы интернировали.
Примечание: Несмотря на то, что адрес памяти объекта уникален в любой момент времени, он различается между запусками одного и того же кода и зависит от версии CPython и компьютера, на котором он работает.
Другими интернированными объектами по умолчанию являются None , True , False и простые строки. Имейте в виду, что в большинстве случаев разные объекты с одинаковым значением будут храниться по разным адресам памяти. Это означает, что вы не должны использовать оператор Python is для сравнения значений.
Удаление рекламы
Когда интернированы только некоторые целые числа
За кулисами Python интернирует объекты с часто используемыми значениями (например, целыми числами от -5 до 256) для экономии памяти. Следующий фрагмент кода показывает, что только некоторые целые числа имеют фиксированный адрес памяти:
>>>
>>> а = 256 >>> б = 256 >>> а есть б Истинный >>> идентификатор (а) 1638894624 >>> идентификатор (б) 1638894624 >>> а = 257 >>> б = 257 >>> а есть б ЛОЖЬ >>> идентификатор (а) 2570926051952 >>> идентификатор (б) 2570926051984
Первоначально a и b указывают на один и тот же интернированный объект в памяти, но когда их значения выходят за пределы диапазона обычных целых чисел (в диапазоне от -5 до 256), они сохраняются по разным адресам памяти.
Когда несколько переменных указывают на один и тот же объект
Когда вы используете оператор присваивания ( = ), чтобы сделать одну переменную равной другой, вы заставляете эти переменные указывать на один и тот же объект в памяти. Это может привести к неожиданному поведению изменяемых объектов:
. >>>
>>> а = [1, 2, 3] >>> б = а >>> а [1, 2, 3] >>> б [1, 2, 3] >>> а.добавить(4) >>> а [1, 2, 3, 4] >>> б [1, 2, 3, 4] >>> идентификатор (а) 2570926056520 >>> идентификатор (б) 2570926056520
Что только что произошло? Вы добавляете новый элемент в a , но теперь b содержит и этот элемент! Что ж, в строке, где b = a , вы устанавливаете b так, чтобы она указывала на тот же адрес памяти, что и a , так что теперь обе переменные ссылаются на один и тот же объект.
Если вы определяете эти списки независимо друг от друга, то они хранятся по разным адресам памяти и ведут себя независимо:
>>>
>>> а = [1, 2, 3] >>> б = [1, 2, 3] >>> а есть б ЛОЖЬ >>> идентификатор (а) 2356388925576 >>> идентификатор (б) 2356388952648
Поскольку a и b теперь относятся к разным объектам в памяти, изменение одного не влияет на другой.
Сравнение равенства с операторами Python == и !=
Напомним, что объекты с одинаковым значением часто хранятся по отдельным адресам памяти . Используйте операторы равенства == и != , если вы хотите проверить, имеют ли два объекта одинаковое значение, независимо от того, где они хранятся в памяти. В подавляющем большинстве случаев это то, что вы хотите сделать.
Когда копия объекта равна, но не идентична
В приведенном ниже примере вы устанавливаете b как копию a (который является изменяемым объектом, таким как список или словарь). Обе переменные будут иметь одинаковое значение, но каждая будет храниться по разным адресам памяти:
>>>
>>> а = [1, 2, 3] >>> b = a.copy() >>> а [1, 2, 3] >>> б [1, 2, 3] >>> а == б Истинный >>> а есть б ЛОЖЬ >>> идентификатор (а) 2570926058312 >>> идентификатор (б) 2570926057736
a и b теперь хранятся по разным адресам памяти, поэтому a is b больше не будет возвращать True . Однако a == b возвращает True , поскольку оба объекта имеют одинаковое значение.
Как работает сравнение по равенству
Магия оператора равенства == происходит в методе класса __eq__() объекта слева от знака == .
Примечание: Это так, если только объект справа не является подклассом объекта слева. Для получения дополнительной информации проверьте официальную документацию.
Это магический метод класса, который вызывается всякий раз, когда экземпляр этого класса сравнивается с другим объектом. Если этот способ не реализован, то == по умолчанию сравнивает адреса памяти двух объектов.
В качестве упражнения создайте класс SillyString , который наследуется от str , и реализуйте __eq__() , чтобы сравнить, совпадает ли длина этой строки с длиной другого объекта:
класс SillyString(str): # Этот метод вызывается при использовании == на объекте def __eq__(я, другой): print(f'сравнение {себя} с {другим}') # Возвращаем True, если self и other имеют одинаковую длину вернуть len(я) == len(другой)
Теперь SillyString 'hello world' должен быть равен строке 'world hello' и даже любому другому объекту такой же длины:
>>>
>>> # Сравнить две строки >>> 'привет, мир' == 'привет, мир' ЛОЖЬ >>> # Сравните строку с SillyString >>> 'привет, мир' == SillyString('привет, мир') сравнивая привет мир с привет мир Истинный >>> # Сравните SillyString со списком >>> SillyString('привет мир') == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] сравнение hello world с [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] Истинный
Это, конечно, глупое поведение для объекта, который иначе ведет себя как строка, но он иллюстрирует, что происходит, когда вы сравниваете два объекта, используя == . Оператор != дает ответ, обратный этому, если не реализован конкретный метод класса __ne__() .
Приведенный выше пример также ясно показывает, почему рекомендуется использовать Python is 9.Оператор 0009 для сравнения с None вместо оператора == . Он не только быстрее, поскольку сравнивает адреса памяти, но и безопаснее, поскольку не зависит от логики каких-либо методов класса __eq__() .
Удаление рекламы Сравнение операторов сравнения Python Как правило, вы всегда должны использовать операторы равенства == и != , за исключением случаев, когда вы сравниваете с Нет : Используйте операторы Python == и != для сравнения равенства объектов . Здесь вы обычно сравниваете ценность двух объектов. Это то, что вам нужно, если вы хотите сравнить, имеют ли два объекта одинаковое содержимое, и вам все равно, где они хранятся в памяти. Используйте операторы Python is и not , когда вы хотите сравнить идентификатор объекта . Здесь вы сравниваете, указывают ли две переменные на один и тот же объект в памяти. Основной вариант использования этих операторов — когда вы сравниваете с Нет . Сравнивать с None по адресу памяти быстрее и безопаснее, чем с помощью методов класса. Переменные с одинаковыми значениями часто хранятся по разным адресам памяти. Это означает, что вы должны использовать == и != для сравнения их значений и использовать операторы Python is и is not только тогда, когда вы хотите проверить, указывают ли две переменные на один и тот же адрес памяти. Вывод В этом руководстве вы узнали, что == и != сравнивают значение двух объектов , тогда как Python — это , а не . Операторы сравнивают, относятся ли две переменные к одному и тому же объекту. в памяти . Если вы будете помнить об этом различии, вы сможете предотвратить неожиданное поведение в своем коде. Если вы хотите узнать больше об удивительном мире объектов, интернированных и Python — это оператор , а затем посмотрите, почему вы почти никогда не должны использовать «is» в Python. Вы также можете посмотреть, как вы можете использовать sys.intern() для оптимизации использования памяти и времени сравнения для строк, хотя есть вероятность, что Python уже автоматически обрабатывает это за вас за кулисами.
Теперь, когда вы узнали, что делают под капотом операторы равенства и идентичности , вы можете попробовать написать свои собственные методы класса __eq__() , которые определяют, как экземпляры этого класса сравниваются при использовании .0008 == оператор. Идите и примените свои новые знания об этих операторах сравнения Python!
Смотреть сейчас Это руководство содержит связанный с ним видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Правильное сравнение объектов Python: «is» и «==»
>>> класс MyString: ... защита __init__(я): ... self.s = 'строка' ... def __is__(self, s): ... вернуть self.s == s ... >>> >>> >>> м = МояСтрока() >>> м это 'сс' ЛОЖЬ >>> m is 'string' # <--- Ожидается, что это сработает ЛОЖЬ >>> >>> класс MyString: . .. защита __init__(я): ... self.s = 'строка' ... def __eq__(self, s): ... вернуть self.s == s ... >>> >>> м = МояСтрока() >>> м это 'сс' ЛОЖЬ >>> m is 'string' # <--- Ожидалось, что все сработает, но снова ошибка ЛОЖЬ >>>
- это тестов для тождества , а не равенства . Это означает, что Python просто сравнивает адрес памяти, в котором находится объект. — это .в основном отвечает на вопрос «У меня есть два имени для одного и того же объекта?» — перегружать, что не имело бы смысла.
4
Оператор is эквивалентен сравнению значений id(x) . Например:
>>> s1 = 'строка' >>> s2 = 'ул' >>> s1 это s2 Истинный >>> идентификатор (s1) 4564468760 >>> идентификатор (s2) 4564468760 >>> id(s1) == id(s2) # эквивалентно `s1 is s2` Истинный
id в настоящее время реализован для использования указателей в качестве сравнения. Таким образом, вы не можете перегрузить , это сам , и, насколько я знаю, вы также не можете перегрузить id .
Значит, нельзя. Необычно для питона, но это так.
3
Python — это ключевое слово , которое проверяет идентичность объекта. Вы НЕ должны использовать его для проверки равенства строк. Может показаться, что это часто работает, потому что реализации Python, как и многие языки очень высокого уровня, выполняют «интернирование» строк. Другими словами, строковые литералы и значения хранятся в хешированном списке, а те, которые идентичны, отображаются как ссылки на один и тот же объект. (Это возможно, потому что строки Python неизменяемы).
Однако, как и в случае с любой деталью реализации, на это полагаться не следует. Если вы хотите проверить равенство, используйте оператор ==. Если вы действительно хотите проверить подлинность объекта, используйте - это — и мне было бы трудно придумать случай, когда вам следует заботиться об идентификаторе строкового объекта. К сожалению, вы не можете рассчитывать на то, что две строки являются как-то «намеренно» идентичными ссылками на объекты из-за вышеупомянутого интернирования.
2
Ключевое слово is сравнивает объекты (точнее, сравнивает, если две ссылки относятся к одному и тому же объекту).
Именно поэтому, я думаю, нет механизма для обеспечения собственной реализации.
Иногда это работает со строками, потому что Python хранит строки «умно», так что когда вы создаете две идентичные строки, они сохраняются в одном объекте.
>>> a = "строка" >>> б = "строка" >>> а есть б Истинный >>> c = "str"+"ing" >>> а есть в Истинный
Надеюсь, вы сможете увидеть сравнение ссылок и данных в простом примере «копии»:
>>> a = {"a":1} >>> б = а >>> c = a. copy() >>> а есть б Истинный >>> а есть в ЛОЖЬ
Если вы не боитесь напортачить с байт-кодом, вы можете перехватить и исправить COMPARE_OP с аргументом 8 ("is") , чтобы вызвать функцию ловушки для сравниваемых объектов. Посмотрите документацию модуля dis для запуска.
И не забудьте перехватить __builtin__.id() , если кто-то будет делать id(a) == id(b) вместо a is b .
2
‘is’ сравнивает идентификатор объекта, тогда как == сравнивает значения.
Пример:
а=[1,2] б=[1,2] #a==b возвращает Истина #a is b возвращает False р=д=[1,2] #p==q возвращает Истина #p is q возвращает True
не удается сравнить строковую переменную со строковым значением и двумя строковыми переменными, когда строка начинается с «-». Моя версия Python 2.6.6
>>> s = '-hi' >>> s это "-привет" ЛОЖЬ >>> с = '-привет' >>> к = '-привет' >>> с это к ЛОЖЬ >>> "-привет" это "-привет" Истинный
Вы не можете перегрузить оператор is . Что вы хотите перегрузить, так это оператор == . Это можно сделать, определив в классе метод __eq__ .
Вы используете сравнение идентификаторов. == , вероятно, то, что вы хотите. Исключением является случай, когда вы хотите проверить, являются ли один элемент и другой ТОЧНО одним и тем же объектом и находятся в одной и той же позиции памяти. В ваших примерах элементы не совпадают, поскольку один из них имеет другой тип (my_string), чем другой (строка). Кроме того, нет такого понятия, как какой-то класс. __is__ в питоне (если, конечно, вы сами его туда не засунули). Если бы это было так, сравнение объектов с на было бы ненадежным, чтобы просто сравнить ячейки памяти.
Когда я впервые столкнулся с ключевым словом is , это меня тоже смутило. Я бы подумал, что это и == ничем не отличаются. Они выдавали один и тот же вывод интерпретатора для многих объектов. Этот тип предположения на самом деле ИМЕННО то, для чего является . … Это эквивалент Python: «Эй, не перепутайте эти два объекта. Они разные», что, по сути, и сказал [кто бы это ни был, кто меня поправил]. Сформулировано по-разному, но один пункт == другой пункт.
для некоторых полезных примеров и некоторого текста, чтобы помочь с иногда запутанными различиями посетите документ с почтового хоста python.org, написанный «Дэнни Ю»
, или, если он не в сети, используйте незарегистрированный pastebin, который я сделал из его тела.
на случай, если они через 20 или около того голубых лун (голубые луны — это настоящее событие) обе не работают, я приведу примеры кода
### >>> my_name = "Дэнни" >>> ваше_имя = "ян" >>> мое_имя == ваше_имя 0 # или Ложь ### ### >>> мое_имя[1:3] == ваше_имя[1:3] 1 #или правда ### ### >>> мое_имя[1:3] — это ваше_имя[1:3] 0 ###
Ошибки утверждения могут легко возникнуть с ключевым словом is при сравнении объектов. Например, объекты a и b могут содержать одно и то же значение и иметь один и тот же адрес памяти.