какой стиль предпочтен?

Также я бы пошел на

def f2(c):
  d = {
    "USA": "N.Y.",
    "China": "Shanghai"
  }

  return d.get(c, "N/A")

, этот путь короче и «Get» предназначен для работы.

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

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

Отредактируйте: , чтобы очистить общую точку об исключении.

Paxdiablo правильно на общем моменте. Python в основном предназначен для «его проще, чтобы задать забыть, а затем разрешение», то есть попробуйте потом посмотреть, что не удается (исключения), то «смотреть, прежде чем прыгать», посмотрите, что там, а затем поступают. Это потому, что поиск атрибута в Python может быть дорогим, поэтому снова звонит одни и те же вещи (чтобы проверить границы) - это пустая трата ресурсов. Тем не менее, внутренние вещи в Python обычно получали более приятные помощники, так что лучше их использовать.

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

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

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

return d.get (c, "N/A")

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

+------------------------------+--------------------+
| Thread1                      | Thread2            |
+------------------------------+--------------------+
| Check is NY exists as a key. |                    |
|                              | Delete NY key/val. |
| Extract value for NY.        |                    |
+------------------------------+--------------------+

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

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

Ни то, ни другое.

return d.get(c, 'N/A')

Я с Дэвидом на этом:

def f2(c):
   d = {
        "USA": "N.Y.",
        "China": "Shanghai"
       }

   return d.get(c, "N/A")

... это именно то, как я бы написал.

Для решения ваших других вариантов:

в «F1 ()», в этом нет ничего плохого в этом, как SE, но словари имеют метод GET () для почти значительного использования случая использования: «Получите это из дикта И если это не там, верните это другое вместо этого. Это все ваш код, говорит, используя GET () просто более лаконично.

В «F2 ()», используя «кроме сама по себе, как это нахмурится», и, кроме того, вы на самом деле не делаете ничего полезного в ответ на исключение - в вашем случае вызывающий код никогда не узнает Было исключение. Так зачем использовать конструкцию, если он не добавляет значение вашей функции или код, который его называет?

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

try:
    return d[k]
except KeyError:
    return "N/A"

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

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

Делая его объектом типа (его поступление через конвертер типов в Silverlight) и он работал.

Как насчет этого:

byte[] array = new  byte[arrayLength];
if (array is byte[])
{
    // Your code
}

Я согласен, что в данном случае dict.get является лучшим решением.

В целом, я думаю, что ваш выбор будет зависеть от того, насколько вероятны исключения. Если вы ожидаете, что поиск ключа в основном пройдет, то try/catch является лучшим выбором IMO. Точно так же, если они будут часто проваляться, лучше заявление «если».

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