Почему Python рекомендуется в качестве языка программирования начального уровня? [закрыто]

Я прочитал здесь на P.SE больше вопросов, в которых начинающим программистам рекомендуется выбрать Python в качестве первого языка программирования.

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

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

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

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

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

IMO, наиболее заметные моменты, которые говорят на Python как на языке начального уровня, таковы:

• у него небольшая кривая обучения - переход от «Hello world» к нулю происходит намного быстрее, чем в большинстве других языков
• он интуитивно понятен - синтаксис разработан так, чтобы следовать принципу наименьшего удивления, и в целом он очень последовательный (к сожалению, стандартные библиотеки не всегда следуют этой последовательности)
• это требует очень небольшого шаблона : типичный «Hello world» - это одна строка кода, и простые программы могут быть написаны без какого-либо дополнительного фонового шума, который необходимо объяснить (например, ключевые слова объявления функций, операторы импорта, конструкции классов, директивы препроцессора, и т.д.)
• есть отличные, простые инструменты для работы с кодом Python, особенно интерактивный интерпретатор; вам не нужно изучать систему сборки, IDE, специальный текстовый редактор или что-либо еще, чтобы начать использовать python - командная строка, интерактивный редактор и простой текстовый редактор - все, что вам нужно
• он использует динамическую типизацию , но в отличие от многих других языков с динамической типизацией, типы прозрачны, а ошибки, связанные с типами, редки

Привет, мир в Python:

 print "Hi there"

Привет, мир на Java:

 class HelloWorldApp {
  public static void main(String[] args) {
    System.out.println("Hello World!"); // Display the string.
    }
  }

Привет, мир в C:

  #include<stdio.h>
  int main(int argc, char** argv)
  {
    printf("Hello World");
   }

Пришло время поговорить о компиляции для двух других, и Python намного проще. Мне нужно поговорить только об одной идее, на которую я заинтересован, - все механизмы, которые усложняют дело, просто исчезают в python. Я могу подождать, пока они не будут готовы говорить о модулях, не нужно торопиться, чтобы получить stdio.h для простых программ. Я могу подождать, пока они не будут готовы к таким темам, как классы, не нужно спешить с ними для их первых программ. У него есть REPL для дурачения в командной строке. Python очень хорош в концептуальном минимуме. Это хорошо, потому что помогает начинающим сосредоточиться на задаче.

Это необычная точка зрения.

Согласие взрослых - очень маленькая часть философии Python. Это, конечно, не "вращается" вокруг этого. Это даже не часть "Zen of Python", которую вы получаете, если делаете это import thisв интерпретаторе.

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

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

Есть два разных пункта. Когда вы воспитываете ребенка, вы должны поместить их в пузырь, в котором есть только безопасные вещи, или позволить им играть во дворе, где они могут споткнуться и упасть?

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

В Python этого не существует. Если вы хотите сказать «Hello World», вы просто print "Hello World". Использование Python в качестве точки входа позволяет кому-то взяться за дело и просто написать код, который ему нужен, чтобы добиться желаемого. Первый программист не может понять значение инкапсуляции, прежде чем они поймут основы программирования.

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

Другие преимущества:

• Много библиотек, которые делают много вещей
• Гибкость в обучении как объектно-ориентированному, так и функциональному программированию, не создавая впечатление, что один был вынужден вписаться в язык, предназначенный для другого.

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

• Абсолютный минимум стандартного кода для простых программ.

• Вывоз мусора.

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

• Чистый, простой синтаксис.

Сравните это, например, с Java или C ++ и трудностью объяснения всех понятий, связанных с программой «Hello, world». Сложные вещи включают в себя:

• Самоанализ (эквивалент Python для отражения).

• Обезьяна исправления.

• Вещи, которые можно сделать с помощью огромной стандартной библиотеки.

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

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

ИМХО, учить людей программированию на «безопасных» языках - очень плохая идея. Люди предполагают, что все легко, и думают только о добавлении слоев и слоев кода. И потерять возможность отлаживать / исправлять проблемы, когда они возникают.

Хорошие программисты обязательно должны знать C / C ++ или даже ассемблер. И их мышление должно исходить и с этой стороны. А не - «О, GC, это делает Magic (тм), мы крутые, и почему C ++ не имеет GC, это глупо». отношение.

Для начинающего программиста отсутствие статических типов - это особенность, а не ошибка!

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

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

1. Типы связаны со значениями, а не переменными. Это, возможно, более интуитивно понятно, поскольку отражает причину сбоя программ.

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

   Учащиеся, работающие с компилятором, могут работать только с программами, которые они полностью понимают, чтобы не столкнуться с ошибкой компиляции, которую они не могут решить.

3. Проверка ошибок во время выполнения позволяет запускать неполные программы. Это позволяет создавать более инкрементные программы, в которых ученик сначала может беспокоиться о том, чтобы правильно начать программу, и только потом видит, что происходит.

4. Некоторые важные понятия, такие как параметрический полиморфизм и типизирование утки, предоставляются бесплатно на динамическом языке, но требуют более сложных систем типов на статическом языке.

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

• Программы для начинающих невелики и не имеют много путей к коду (поэтому вам не нужно сильно беспокоиться об ошибках типов в редко используемых фрагментах кода)

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

Для начинающих программистов в Python есть одна очень, очень , очень важная вещь, которую все, кажется, упустили из виду: форсирование правильного отступа.

Как и некоторые другие комментаторы, я учил начинающих в течение нескольких лет. Было очень странно видеть такие вещи:

#include <stdio.h>

int main(char *args[])
                                                                     {
   int A = 1, B = 1, C;
for (int X = 0;X < 20;X++)
{
   printf("%d\n", A);
C = B + A;
      A = B;  B = C;
}
        }

Теперь представьте себе это ужасное несоответствие более ста строк кода. Для некоторых студентов все их проекты выглядели так.

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

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

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

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

К тому времени новичок сможет лучше понимать варианты и компромиссы и готов к C / C ++, Java, Assembler, Prolog, Lisp и т. Д. На самом деле, Lisp может быть хорошим первым языком, хотя и довольно строгим !

Ключевая проблема с Python в качестве первого языка - это динамическая типизация и отсутствие объявления переменных. ИМХО они единственная серьезная проблема с языком.

Простое добавление строки, гласящей, что я собираюсь сохранить строку только в переменной foo, позволяет программисту, среде разработки, языку (а для «профессионального кода» - бедному дураку, который должен прийти в себя и поддержать его впоследствии) работать вместе. Для обычных разработчиков и начинающих особенно не имеет смысла использовать переменную для более чем одного типа. Это вполне нормально в тех редких случаях, когда имеет смысл использовать явный тип var / object, который допускает динамическую типизацию.