Рубрики
Без рубрики

Dead Simple Python: данные, набрав и неизменность

Динамическая печатание? Неизменный? Тройные цитаты? Есть много сокровищ, упакованных в этот странный маленький язык; Просто следите за сиськами ловушек. Помечено Python, начинающим, кодированием.

Мертвый простой Python (13 частей серии)

Я получил прекрасный комментарий к этой серии от Дамиан Ривас …

Я просто прочитал первые две части, которые в настоящее время выпущены. Я должен сказать, с Python, находящийся на 5-м языке, в котором я ныряю, я действительно ценю этот стиль преподавания! Трудно найти учебный материал, который не начинается с «Что является переменной» лол.

Ненавижу разочаровать, Дамиан, но я не мог избежать переменных навсегда!

Хорошо, ладно, я не собираюсь скончаться с объяснением # 2,582,596 переменных. Вы умные люди, я уверен, что вы знаете все о них сейчас.

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

Добро пожаловать в Python. Пожалуйста, не обращайте внимания на мебель на пути к кролику.

Я использую термин «переменные» на протяжении всей этой серии, в основном потому, что это стандартный термин по отношению к языкам. Это действительно использовать этот термин в Python, и он даже признан в официальной документации.

Однако Технический термин для переменной Python на самом деле является Имя ; Это относится ко всей концепции «имя привязки имени», я буду ссылаться на позже.

Используйте какой бы срок, с которым вам удобно. Просто понимайте, что Python «переменные» официально называют «именами», и вы можете услышать оба.

Летом 2011 года я сидел на крыльце качал в Сиэтл, Вашингтон и вошел в Freenode IRC. Я только что решил переключить языки из Visual Basic .NET в Python, и у меня были несколько вопросов.

Я присоединился к #python и прыгнул прямо в.

Как вы объявляете тип данных переменной в Python?

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

<_habnabit> Вы тип данных

Он и остальные регуляры комнаты были быстрыми, чтобы наполнить меня. Python – это динамически напечатанный язык , что означает, что мне не нужно идти и говорить языку, какую информацию идет в переменной. Мне даже не нужно использовать специальную «переменную декларацию» ключевое слово. Я просто назначаю.

netWorth = 52348493767.50

В этот точный момент Python стал моим совершеннолетним любимым языком.

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

Хм, динамически набран? Наркотим? Что все это значит?

  • Динамически набирается: тип данных переменной (объект) определяется во время выполнения. Контраст с «статически наведенным», где мы объявляем тип данных объекта первоначально. (C ++ статически набирается.)

  • Написано: язык имеет строгие правила о том, что вы можете сделать с разными типами данных, такие как добавление целого числа и строки вместе. Контрастное с «слабо набранным», где язык позволит вам сделать практически все, и он будет понять это для вас. (JavaScript слабо набирается.)

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

Итак, чтобы поставить это в другие условия: Python переменные есть Типы данных, но язык автоматически выясняет, что такое тип данных.

Итак, мы можем переназначить переменную, чтобы содержать любые данные, которые мы хотим …

netWorth = 52348493767.50
netWorth = "52.3B"

… но мы ограничены тем, что мы можем сделать с этим …

netWorth = 52348493767.50
netWorth = netWorth + "1 billion"
>>> Traceback (most recent call last):
>>>  File "", line 1, in 
>>> TypeError: unsupported operand type(s) for +: 'float' and 'str'

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

netWorth = 52348493767.50
type(netWorth)
>>> 

Мы можем на самом деле хотеть проверить, что такое DataType до Мы делаем что-то с этим. Для этого мы можем соединить Тип () Функция с это Оператор, как это:

if type(netWorth) is float:
    swimInMoneyBin()

Однако во многих случаях может быть лучше использовать Isinstance () вместо Тип () , как это будет учитывать подклассы и наследство (объектно-ориентированное программирование, любой?) Бонус, сама функция возвращает True или false …

if isinstance(netWorth, float):
    swimInMoneyBin()

Теперь факт, мы редко проверяем Isinstance () Отказ Питонисты предпочитают философию Утка печатает ; То есть вместо того, чтобы проверять, какой тип есть, мы просто ищем функции, которые нам нужны на объекте. Если это выглядит как утка, ходит как утка, квитанцы, как утка, она должна быть уткой. Nevermind, если это на самом деле роботная утка, или лось в костюме утки; Если у него есть черт, которые нам нужны, остальное обычно является спортивным точком.

Так как я только что ввел, что это Оператор, нам лучше что-то прояснить: это и ==. Не делайте то же самое!

Многие новички Python обнаруживают, что это работает …

richestDuck = "Scrooge McDuck"

if richestDuck is "Scrooge McDuck":
    print("I am the richest duck in the world!")

if richestDuck is not "Glomgold":
    print("Please, Glomgold is only the SECOND richest duck in the world.")

>>> I am the richest duck in the world!
>>> Please, Glomgold is only the SECOND richest duck in the world.

“О, это круто!” сказал определенный молодой разработчик в Сиэтле. ” Итак, в Python я просто использую это и не для сравнения. “

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

nephews = ["Huey", "Dewey", "Louie"]

if nephews is ["Huey", "Dewey", "Louie"]:
    print("Scrooge's nephews identified.")
else:
    print("Not recognized.")

>>> Not recognized.

“Чего ждать?” Вы могли бы тащить на это немного, даже подтверждая, что племянники - это племянники оценивает Правда Отказ Так что в мрачных падениях происходит?

Беда в том, что это Оператор проверяет, есть ли два операнда та же экземпляра И у Питона есть эти смешные вещи, называемые неизменные типы .

Упростить его, когда у вас есть что-то вроде целого числа или строки, только один из этих данных фактически существует в памяти программы одновременно. Ранее, когда я создал строку "Скрудж Макдук" , было только одно существование (не там всегда?) Если я скажу…

richestDuck = "Scrooge McDuck"
adventureCapitalist = "Scrooge McDuck"

… Мы бы сказали, что оба Richestduck. и авантюрист являются связанный к этому один экземпляр "Скрудж Макдук" в памяти. Они похожи на пару подписи, оба указывают на то же самое, из которых у нас есть только один.

Чтобы положить это еще один путь, если вы знакомы с указатели Это немного похоже на это (без страшных острых краев). У вас могут быть два указателя на одно и то же место в памяти.

Если мы изменили одну из этих переменных, скажите Richestduck. Мы были бы ремин Richestduck указывать на что-то другое в памяти. (Мы также были полны бобов для претензии Glomgold – это богатое.)

Музные типы С другой стороны, может хранить те же данные несколько раз в памяти. Списки, как [«Хуэй», «Дьюи», «Луи»] являются одним из тех созванных типов, поэтому это Оператор сообщил о том, что он сделал ранее. Два списка, хотя они содержали то же самое информацию, были не тот же экземпляр Отказ

Техническая примечание: Вы должны знать, что неизменность не на самом деле связанные с использованием только одного экземпляра вещи, хотя это общий побочный эффект. Это полезный способ представить это, но не полагайтесь на это всегда быть таким. Несколько экземпляров может существует. Запустите это в интерактивном терминале, чтобы увидеть, что я имею в виду …

a = 5
b = 5
a is b
>>> True
a = 500
b = 500
a is b
>>> False
a = 500; b = 500; a is b
>>> True

Фактическая истина за неизменностью, намного сложнее. Мой freenode #python Друг NED Batchelder ( Nedbat ) имеет Удивительный разговор обо всем этом , который вы должны полностью проверить.

Итак, что мы должны использовать вместо это ? Вы будете рады узнать, это просто хорошее старомодный == Отказ

nephews = ["Huey", "Dewey", "Louie"]

if nephews == ["Huey", "Dewey", "Louie"]:
    print("Scrooge's nephews identified.")
else:
    print("Not recognized.")

>>> Scrooge's nephews identified.

Как правило, вы должны всегда использовать ==. (и т. д.) Для сравнения ценности и это для сравнения экземпляры Отказ Значение, хотя они, кажется, работают то же самое, более ранний пример должен фактически читать …

richestDuck = "Scrooge McDuck"

if richestDuck == "Scrooge McDuck":
    print("I am the richest duck in the world!")

if richestDuck != "Glomgold":
    print("Please, Glomgold is only the SECOND richest duck in the world.")

>>> I am the richest duck in the world!
>>> Please, Glomgold is only the SECOND richest duck in the world.

Есть один полу исключение …

license = "1245262"
if license is None:
    print("Why is Launchpad allowed to drive, again?")

Это несколько распространено, чтобы проверить на не сознание с foo нет потому что есть только один Нет в существовании. Конечно, мы также могли бы просто сделать это состязания …

if not license:
    print("Why is Launchpad allowed to drive, again?")

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

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

intFoo = 6
fltBar = 6.5
strBaz = "Hello, world."

Оказывается, что идея не была ни оригинальной, ни блестящей.

Для начала, системах венгерской обозначения – это прогорное недопонимание приложений Венгерское обозначение, сама умная идея о разработке Microsoft Charles Simonyi.

В приложениях венгерский язык мы используем короткое сокращение в начале переменной имени, чтобы напомнить нам о цель из этой переменной. Он использовал это, например, в его разработке работа по Microsoft Excel, где он использовал бы ряд В начале любой переменной, относящейся к строкам, и Col В начале любой переменной, относящейся к столбцам. Это делает код более читабельным и серьезно помогает с предотвращением конфликтов имени ( rowindex против Colindex , Например). По сей день я использую приложения венгры в разработке GUI, чтобы различать типы и целей виджетов.

Системы венгерских, однако, несут всю точку зрения и добавляют сокращение Тип данных к переменной, такой как Intfoo или strbaz Отказ В статически типичном языке это яркие избыточные, но в Python, это может почувствовать себя хорошей идеей.

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

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

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

Нет, не тот тип литья, который приземлился Дэвид Теннант голос роль Скруджа Макдук …. Хотя он совершенно потрясающий в этой роли.

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

Например, чтобы преобразовать целое число или поплавок в строку, мы можем просто использовать str () функция.

netWorth = 52348493767.50
richestDuck = "Scrooge McDuck"
print(richestDuck + " has a net worth of $" + str(netWorth))
>>> Scrooge McDuck has a net worth of $52348493767.5

Внутри этого Печать (...) Заявление, я смог ConcateNate (комбинируйте) все три части в одну строку, которая будет напечатана, потому что все три части были строки . Печать (Richestduck + »имеет чистый ценность $" + Networth) не удалось бы с Типеррр Поскольку Python сильно набран (помните?), И вы не можете комбинировать поплавок и прямую струну.

Вы можете быть немного запутанным, потому что Это работает…

print(netWorth)
>>> 52348493767.5

Это потому, что Печать (...) Функция автоматически обрабатывает преобразование типа на заднем плане. Но это ничего не может сделать с этим + Оператор – это происходит до того, как данные передаются на Распечатать(...) – Поэтому мы должны сделать преобразование там сами.

Естественно, если вы пишете класс, вам нужно определить эти функции самостоятельно, но это за рамки этой статьи. (Подсказка, __str __ () и __int __ () обрабатывать отливку объекта в строку или целое число соответственно.)

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

housekeeper = "Mrs. Beakley"
housekeeper = 'Mrs. Beakley'
housekeeper = """Mrs. Beakley"""

Мы можем обернуть литерал в одиночных цитатах «...» Двойные кавычки "..." или тройные цитаты "" ... "" "" И Python будет относиться к нему (в основном) так же. Там что-то особенное в этом третьем варианте, но мы вернемся к нему.

Руководство по стилю Python, Pep 8 обращается к использованию одиночных и двойных кавычек:

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

Это пригодится, когда мы имеем дело с чем-то вроде этого …

quote = "\"I am NOT your secretary,\" shouted Mrs. Beakley."
quote = '"I am NOT your secretary," shouted Mrs. Beakley.'

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

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

print("Scrooge's \"money bin\" is really a huge building.")
>>> Scrooge's "money bin" is really a huge building.

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

Но помните, у нас также есть эти тройные цитаты ( «« « ), которые мы могли бы использовать здесь тоже.

print("""Scrooge's "money bin" is really a huge building.""")
>>> Scrooge's "money bin" is really a huge building.

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

Во-первых, тройные цитаты многоровный Отказ Другими словами, я могу использовать их, чтобы сделать это …

print("""\
Where do you suppose
    Scrooge keeps his
        Number One Dime?""")
>>> Where do you suppose
>>>    Scrooge keeps his
>>>        Number One Dime?

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

Встроенный TextWrap модуль Имеет некоторые инструменты для работы с многострочными струнами, включая те, которые позволяют вам иметь «надлежащие» отступ без него ( TextWrap. Plementent ).

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

def swimInMoney():
    """
    If you're not Scrooge McDuck, please don't try this.
    Gold hurts when you fall into it from forty feet.
    """
    pass

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

# This always works
print(swimInMoney.__doc__)

# This works in the interactive shell only
help(swimInMoney)

Специальные типы строки

Я хочу кратко коснуться двумя другими типами строк Python предлагает. На самом деле, они не совсем разные Типы строк – они все неизменные экземпляры класса ул ...| - Но строковый литерал обрабатывается немного по-разному по языку.

Сырые строки предшествуют с R , Такие как…

print(r"I love backslashes: \ Aren't they cool?")

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

print("A\nB")
>>> A
>>> B
print(r"A\nB")
>>> A\nB
print(r"\"")
>>> \"

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

Gotcha Alert: Если обратная косание – это Последнее Персонаж в вашей необработанной строке, он все еще будет действовать, чтобы избежать вашей закрывающей цитаты и создать синтаксическую ошибку в результате. Это связано с собственным языком языка Python, а не с струнами.

Другой «тип» строки является Форматированная строка или F-string , который новый как Python 3.6. Это позволяет вставлять значения переменных в строку очень красивым способом, без необходимости беспокоиться с конкатенацией или преобразованием, как и раньше.

Мы предшествуем строке с F Отказ Внутри мы можем заменить наши переменные, упаковывая их в {...} Отказ Мы поставили все это вместе, как это …

netWorth = 52348493767.50
richestDuck = "Scrooge McDuck"
print(f"{richestDuck} has a net worth of ${netWorth}.")
>>> Scrooge McDuck has a net worth of $52348493767.5.

Вы не просто ограничены переменными в этих фигурных скобках ( {...} ) На самом деле вы можете поставить практически любой действительный код Python, включая математику, вызовы функций, выражения … Что бы вы ни понадобились.

По сравнению со старшим str.format () Методы и % Форматирование (ни один из которых я буду скрывать здесь), F-Strings намного быстрее. Это потому, что они оцениваются до Код запускается.

Отформатированные строки были определены PEP 498 Так что иди туда для получения дополнительной информации.

Хотя мы получаем основные вещи с дороги, давайте немного поговорим о функциях Python. Я не буду спортивным своим интеллектом, переопределив «функции» еще раз. Это хватило, чтобы обеспечить основной пример.

def grapplingHook(direction, angle, battleCry):
    print(f"Direction = {direction}, Angle = {angle}, Battle Cry = {battleCry}")

grapplingHook(43.7, 90, "")

def Говорит, что мы определяем функцию, а затем мы предоставляем имя, а имена аргументов в скобках. Зевать

Давайте сделаем это немного интереснее. (Следующие работы в Python 3.6 и позже.)

def grapplingHook(direction: float, angle: float, battleCry: str = ""):
    print(f"Direction = {direction}, Angle = {angle}, Battle Cry = {battleCry}")

grapplingHook(angle=90, direction=43.7)

Верьте, или нет, это действительный Python! Там есть много нефте маленьких вкусностей, поэтому давайте сломаемся.

Вызов функций

Когда мы называем функцию, мы можем, очевидно, предоставить аргументы в том порядке, в котором они появляются в определении функции, как в первом примере: Grapplinghook (43,7, 90, "") Отказ

Однако, если мы хотим, мы действительно можем указать который аргумент, который мы передаем, какие значения. Это делает наш код более читаемым во многих случаях: Grapplinghook (угол = 90, 0,7) Отказ Бонус, нам на самом деле не нужно проходить аргументы чтобы До тех пор, пока все они имеют ценность.

Аргументы по умолчанию

Говоря о которых вы заметили, что я оставил ценность для BattleCry При этом вторым звонком, и это не злилось на меня? Это потому, что я предоставил значение по умолчанию Для аргумента в определении функции …

def grapplingHook(direction, angle, battleCry = ""):

В этом случае, если значение для BattleCry Тогда пустая строка "" используется. Я мог бы на самом деле поставить то, что я хотел там: "Яарг" , Нет или что-то еще.

Это довольно распространено для использования Нет В качестве значения по умолчанию, чтобы затем вы могли проверить, имеет ли аргумент указанным значением, как это …

def grapplingHook(direction, angle, battleCry = None):
    if battleCry:
        print(battleCry)

Но потом, если вы просто сделаете что-то вроде этого вместо этого …

def grapplingHook(direction, angle, battleCry = None):
    if not battleCry:
        battleCry = ""
    print(battleCry)

… В этот момент вы можете также просто дать BattleCry Это значение по умолчанию "" с самого начала.

Gotcha Alert: Аргументы по умолчанию оцениваются один раз и совместно используются между всеми вызовами функций. Это имеет странные последствия для смежных типов, таких как пустой список [] . Неподвижные вещи в порядке для аргументов по умолчанию, но вы должны избегать мультипных аргументов по умолчанию.

Gotcha Alert: Вы должны перечислить все ваши Требуется Аргументы (без значений по умолчанию) до Ваш необязательно аргументы (те, которые с значениями по умолчанию). (направление = 0, угол,) не в порядке, потому что дополнительный аргумент направление приходит до того, как требуется угол .

Тип намекания и функциональные аннотации

Если вы знакомы с статически напечатанными языками, такими как Java и C ++, это может заставить вас немного взволнован …

def grapplingHook(direction: float, angle: float, battleCry: str = "") -> None:

Но Это не делает то, что вы думаете, это делает!

Мы можем предоставить Тип подсказки В Python 3.6, а затем, которые предлагают именно это: Подсказки о том, какой тип данных должен быть передан. Точно так же -> Нет Часть перед толстой кишкой ( : ) подсказки на возвращенном типе.

Тем не мение…

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

Так какой смысл? Тип подсказки имеет несколько преимуществ, но самый непосредственный это Документация Отказ Определение функции теперь показывает, какой тип информации он хочет, что особенно полезен, когда ваш IDE автоматически волшебным образом показывает подсказки, когда вы вводите аргументы. Некоторые удостоверения личности и инструменты могут даже предупредить вас, если вы делаете что-то странное, как, скажем, передавая строку к чему-либо типу, указанному как целое число; Pycharm очень хорош в этом, на самом деле! Статические шашки типа Как Marpy также сделаю это. Я не собираюсь в эти инструменты здесь, но достаточно сказать, они существуют.

Я должен сделать это очень понятно, эти подсказки выше типа – это тип Функция Аннотация , который имеет все виды аккуратных случаев использования. Те, кто определен более подробно в PEP 3107 Отказ

Есть куча больше способов, которыми вы можете использовать тип подсказки, даже за пределы определений функций, с Набрав модуль Это было добавлено в Python 3.5.

Перегруженные функции?

Как вы можете догадаться, поскольку Python динамически набирает динамически напечатанный, у нас не имеет большого значения для перегруженных функций. Таким образом, Python даже не предоставляет им! Вы обычно можете иметь только одну версию. Если вы определяете функцию с тем же именем несколько раз, последняя версия, которую мы определили, будут просто Тень (Скрыть) Все остальные.

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

def grapplingHook(direction, angle, battleCry: str = ""):
    if isinstance(direction, str):
        # Handle direction as a string stating a cardinal direction...
        if direction == "north":
            pass
        elif direction == "south":
            pass
        elif direction == "east":
            pass
        elif direction == "west":
            pass
        else:
            # throw some sort of error about an invalid direction
    else:
        # Handle direction as an angle.

ПРИМЕЧАНИЕ, Я покинул подсказки к типу вышеупомянутым, как я работаю с несколькими возможностями. Это было честно ужасно пример, но вы получаете идею.

Gotcha Alert: Теперь, пока это было совершенно действительным, это почти всегда «кодовый запах» – признак плохого дизайна. Вы должны попытаться избежать Isinstance () Как можно больше, если только это абсолютно, положительно, лучший способ решить вашу проблему … И вы можете пойти целую карьеру без этого когда-либо в этом случае!

Возвратные типы

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

def landPlane():
    if getPlaneStatus() == "on fire":
        return
    else:
        # attempt landing, and then...
        return treasure

Это голые вернуть так же, как поговорка вернуть ни один , пока Вернуть сокровище вернет все равно ценность Сокровище является. (Кстати, этот код не будет работать, так как я никогда не определил сокровище. Это просто глупый пример.)

Эта конвенция позволяет вам легко обрабатывать дополнительные возвраты:

treasure = landPlane()
if treasure:
    storeInMoneyBin(treasure)

Неточный действительно замечательная вещь.

Gotcha Alert: Вы заметите, все остальные функции в этом руководстве не хватало вернуть заявления. Функция автоматически возвращает Нет Если он достигает конца, не нахождение вернуть утверждение; Нет необходимости прикреплять один на конце.

Тип намекания и по умолчанию

При использовании подсказки к типу вы можете соблазнить это …

def addPilot(name: str = None):
    if name is not None:
        print(name)
    else:
        print("Who is flying this thing?!?")

Это было приемлемым, но он больше не считается официально правильным. Вместо этого вы должны использовать Необязательно [...] справиться с этой ситуацией.

def addPilot(name: Optional[str] = None):

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

  • Python – это Динамически набран , что означает, что он выясняет тип данных объекта во время выполнения.

  • Python – это Сильно напечатано , что означает, что есть строгие правила о том, что вы можете сделать с любым данным типом данных.

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

  • это проверяет, являются ли операнды одинаковыми экземпляр объекта, в то время как == сравнивает значения. Не путайте их.

  • Системы венгерской нотации (например Intfoo ) – плохое представление. Пожалуйста, не делайте этого.

  • Вы можете обернуть струны в одном ( '...' ) или двойные цитаты ( "..." ).

  • Тройные строки цитаты («« … »« ») предназначены для многослойных струн. Они также могут быть использованы для DocStrings, документируя функцию, класс или модуль.

  • Струны сырые ( r "\ n" ) лечить любую обратную косание как буквальное. Это делает их отличными для регулярных моделей выражения.

  • Форматированные строки ( F »1 + 1 = {1 + 1}" ) Давайте волшебным образом заменим результат некоторых кода в строку.

  • Значения по умолчанию Может быть указан для аргументов функции, делая их Дополнительные аргументы Отказ Все дополнительные аргументы должны прийти после необходимых аргументов.

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

Как обычно, вы можете узнать много более об этих темах в документации Python.

Спасибо тебе Дениска , гриф , и Иканобори (Freenode IRC. #пьютор ) для предложенных ревизий.

Мертвый простой Python (13 частей серии)

Оригинал: “https://dev.to/codemouse92/dead-simple-python-data-typing-and-immutability-41dm”