Каковы важные языковые особенности (идиомы) Python для изучения на ранней стадии [дублировать]

https://stackoverflow.com/questions/567251

05-09-2019
|

Вопрос

На этот вопрос уже есть ответ здесь:

Дзен Python [закрыт] 22 ответа
Питон:Я что-то упускаю?[закрыто] 16 ответов

Мне было бы интересно узнать, что сообщество StackOverflow считает важными языковыми особенностями (идиомами) Python.Функции, которые определили бы программиста как Pythonic.

Идиома Python (pythonic) - "кодовое выражение", которое является естественным или характерным для языка Python.

Кроме того, какие идиомы следует изучить всем программистам на Python на ранней стадии?

Заранее спасибо

Похожие:

Решение

Python - это язык , который можно описать как:

"правила, которые вы можете уместить на ладони с огромным пакетом крючков".

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

Возьмем, к примеру, встроенную функцию len (data). len(data) работает, просто проверяя наличие data.__len__() метод, а затем вызывает его и возвращает значение.Таким образом, len() может работать с любым объектом, который реализует __len__() способ.

Начните с изучения типов и базового синтаксиса:

Динамические Строго Типизированные языки
bool, int, float, строка, список, кортеж, dict, set
утверждения с отступом: "все является объектом"
определения основных функций

Затем переходите к изучению того, как работает python:

импорт и модули (действительно простые)
путь к python (sys.path)
в dir() функция
__builtins__

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

итераторы
переопределяет , например __len__ (таких там тонны)
понимание списков и генераторы
классы и объекты (опять же, действительно просто, как только вы знаете пару правил)
правила наследования python

И как только вы почувствуете уровень комфорта с этими предметами (с акцентом на то, что делает их питоновскими), обратите внимание на более конкретные предметы:

Многопоточность в python (обратите внимание на глобальную блокировку интерпретатора)
контекстные менеджеры
доступ к базе данных
file IO
розетки
и т.д...

И никогда не забывай Дзен Питона (автор: Тим Питерс)

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Другие советы

Эта страница охватывает все основные идиомы python: http://python.net /~goodger/projects/pycon/2007/idiomatic/handout.html

Важной идиомой в Python является docstrings.

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

# this is m.py
""" module docstring """

class c:
    """class docstring"""
    def m(self):
        """method docstring"""
        pass

def f(a):
    """function f docstring"""
    return

Теперь, когда вы набираете help(m), help(m.f) и т.д.он напечатает строку документа в виде справочного сообщения.

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

Это также может быть применено к более нетрадиционным (т.е.неидиоматические) виды использования, такие как грамматики в Анализатор Dparser.

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

x = 5
""" pseudo docstring for x """

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

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

def trace(num_args=0):
  def wrapper(func):
    def new_f(*a,**k):
      print_args = ''
      if num_args > 0:
        print_args = str.join(',', [str(x) for x in a[0:num_args]])
      print('entering %s(%s)' %(f.__name__,print_args))
      rc = f(*a,**k)
      if rc is not None:
        print('exiting %s(%s)=%s' %(f.__name__,str(rc)))
      else:
        print('exiting %s(%s)' %(f.__name__))
      return rc
    return new_f
  return wrapper

@trace(1)
def factorial(n):
  if n < 2:
    return 1
  return n * factorial(n-1)
factorial(5)

и получите результат, подобный:

entering factorial(5)
entering factorial(4)
entering factorial(3)
entering factorial(2)
entering factorial(1)
entering factorial(0)
exiting factorial(0)=1
exiting factorial(1)=1
exiting factorial(2)=2
exiting factorial(3)=6
exiting factorial(4)=24
exiting factorial(5)=120

Все, что связано с использованием списка.
Понимания, генераторы и т.д.

С более продвинутой точки зрения, понимание того, как словари используются внутри Python.Классы, функции, модули, ссылки - все это просто свойства в словаре.Поняв это, легко понять, как обезьянничать с исправлением и использовать мощные методы __gettattr__, __setattr__ и __call__.

Вот один из них, который может помочь.В чем разница между:

[ foo(x) for x in range(0, 5) ][0]

( foo(x) for x in range(0, 5) ).next()

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

Лично мне очень нравится синтаксис Python, определяющий блоки кода с помощью отступ, а не словами "BEGIN" и "END" (как в Microsoft Basic и Visual Basic - мне это не нравится) или с использованием левых и правых фигурных скобок (как в C, C ++, Java, Perl - мне это нравится).

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

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

Ладно, я слезу со своей мыльницы.;-)

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

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

return HandEvaluator.StraightFlush, (PokerCard.longFaces[index + 4], 
  PokerCard.longSuits[flushSuit]), []

или даже

return False, False, False

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

Использование подстановок строк:

name = "Joe"
age = 12
print "My name is %s, I am %s" % (name, age)

Когда я не программирую на python, этого простого использования мне не хватает больше всего.

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

doctests - это простой текстовый файл, содержащий сеанс интерактивного интерпретатора плюс текст, подобный этому:

Let's instantiate our class::

>>> a=Something(text="yes")
>>> a.text
yes

Now call this method and check the results::

>>> a.canify()
>>> a.text
yes, I can

Если , например,a.текст возвращает что-то другое, тест завершится неудачей.

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

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

Python предоставляет способ тестирования функций, на самом деле двух!!

Один из способов заключается в использовании profile модуль, вот так:

import profile

def foo(x, y, z):
    return x**y % z # Just an example.

profile.run('foo(5, 6, 3)')

Другой способ сделать это - использовать timeit модуль, подобный этому:

import timeit

def foo(x, y, z):
    return x**y % z # Can also be 'pow(x, y, z)' which is way faster.

timeit.timeit('foo(5, 6, 3)', 'from __main__ import *', number = 100) 
# timeit.timeit(testcode, setupcode, number = number_of_iterations)

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow