Go vs Python изучение основ языка Go в сравнении с Python


Оглавление (нажмите, чтобы открыть):

JavaScript vs Python vs GO — решающая битва 02.02.2020 15:08

Светлана Шаповалова, коммерческий автор и переводчик, специально для «Нетологии» перевела статью Доминика Т с анализом всех сильных и слабых сторон JavaScript, Python и GO. Проанализируем бекэнд, фронтэнд и возможности нативной разработки.

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

Давайте сравним

Вот языки, которые я хочу сравнить:

Производительность

1. Go — низкоуровневый язык программирования, по производительности сопоставим с Java, но удобнее в плане структуры и синтаксиса.

2. Node.js — платформа, основанная на C и работающая на движке V8. Производительность «из коробки» зачастую выше, чем у Python.

3. И Python на последнем месте: далеко не первый по производительности, он, тем не менее, отлично подойдет там, где не нужна сверхскорость — например, в обучении.

Удобство

Вертикальная ось — «Легкость и понятность». Горизонтальная ось — «Скорость и эффективность»

1. Go и Python. Если вы когда-либо использовали фреймворк Django, написанный на Python, то знаете, что создать с его помощью полноценное приложение с MySQL можно буквально за минуты. Впрочем, Go — это язык с сильной типизацией, множеством библиотек и неограниченными возможностями.

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

Масштабируемость

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

2. JavaScript тоже хорош за счет инструментов сборки вроде webpack, хотя и не поддерживает нативный импорт.

Фронтэнд и бэкэнд

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

1. Go хорош как для бекэнда, так и для фронтэнда, и успешно балансирует между ними.

2. JavaScript отлично подходит для фронтэнда благодаря библиотекам вроде React. Но использовать его для бекэнда и интеграции с базами данных — это сплошное мучение.

3. У Python есть Django, поэтому для бекэнда он лучше, чем JavaScript. Однако JavaScript отлично работает в связке API + React и набирает все большую популярность.

Популярность

1. Согласно рейтингу TIOBE, Python в 2020 году займет пятое место среди самых популярных языков программирования, однако со временем сместится ниже.

2. JavaScript — на восьмом месте, однако его перспективы оптимистичнее, чем у Python.

3. Go — абсолютный фаворит. И не потому, что расположился на тринадцатом месте, а потому, что взлетел туда аж с пятьдесят третьего всего за год — и это очень круто.

Совместимость

1. JavaScript работает в браузерах и на серверной стороне, в нативных и мобильных приложениях — во многом благодаря Angular и React.

2. Go работает практически повсюду: отчасти из-за мощной поддержки разработчиков и фулстек-библиотекам, отчасти из-за Android NDK. Кто знает, не станет ли Go для Google нативным и основным android-языком вместо Java? Ведь именно Google — создатели Go.

3. Python работает на телефонах и десктопе, однако загружается дольше, чем ОС Windows после обновлений, и не стоит этого времени. Совсем.

Машинное обучение.

1. Python. TensorFlow, Scikit-learn Чтобы «обучить» машину различать изображения или речь, понадобиться лишь одна из этих библиотек и немного математики.

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

3. JavaScript — полный лузер в этой категории. Разве что какой-нибудь мазохист додумается использовать его для машинного обучения.

Работа

1. JavaScript — это отец фронтэнда и всей веб-разработки. Кроме веб-сборки, JavaScript — единственный язык, нативно поддерживаемый браузерами. Очевидно, что на сегодняшний день полно вакансий для JavaScript-разработчика.

2. Для Python-разработчиков тоже много работы, особенно в областях обработки данных, бекэнда и машинного обучения.

3. Язык Go относительно молод, поэтому будет возникать все больше стартапов, использующих именно его.

Итого

  • Go: 10 очков
  • JavaScript: 9 очков
  • Python: 9 очков

Выводы

Каждый из этих языков по-своему крут, так какой же выбрать? Советую ориентироваться на следующий список:

  • наука о данных Python
  • бекэнд или фулстак Python или Go
  • React или Angular + бекэнд JavaScript или Go
  • гибридные и нативные приложения JavaScript + React или Go
  • первый язык для новичка Python
  • скорость и эффективность Go

Мнение автора и редакции может не совпадать. Хотите написать колонку для «Нетологии»? Читайте наши условия публикации.

Язык программирования Go: мнения и перспектива

Введение

Go – это язык программирования, который был разработан корпорацией Google. Часто его еще называют “Golang” – сокращение от “Google language”. Это компилируемый и многопоточный язык, релиз которого состоялся в ноябре 2009 года, а самый свежий выпуск 1.6 датируется февралем 2020 года. Одной из ключевых фигур, которые принимали участие в создании Go, является Роб Пайк, известный разработчик языков программирования, а также операционных систем, в данный момент работающий в Google. Выступая на одной из конференций, он отметил, что язык Go – это попытка перенять лучшие стороны таких языков, как C++ и Java.

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

Применение

Язык Go разрабатывался как язык для создания различных высокоэффективных программ, однако большинство программистов сходятся во мнении, что лучше всего он подходит для создания веб-приложений (в качестве back-end). При этом Go дает возможности писать и другие проекты, к примеру, Docker, InfluxDB и Kubernetes. По сути, применение языка Go ограничивается тремя основными направлениями: сетевое программное обеспечение, консольные утилиты и бэкенд.

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

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

Плюсы языка Go

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

Во-первых, это его простота. Язык Go разрабатывался в качестве замены C: его высокая производительность почти сопоставима с языком Си, но более простой синтаксис дает возможность разрабатывать приложения гораздо быстрее (к примеру, как на Python). При этом многие разработчики изучают этот язык после Python или PHP либо используют два языка в связке (Python/Go и PHP/Go). Упрощенный синтаксис облегчает не только написание своего собственного кода, но и чтение кода, написанного другими программистами, что особенно важно в командной работе. Эта особенность Go, в свою очередь, ведет к другому важному факту: быстрое освоение Go позволяет перевести внимание с изучения самого языка на изучение программирования в целом.

Программисты постоянно сравнивают язык Go с другими языками: в его пользу свидетельствует тот факт, что, к примеру, в PHP существует 67 ключевых слов, а в Go их всего лишь 25.

Тут необходимо сделать отступление и сказать о том, что желание создать простой язык программирования родилось у разработчиков Google неслучайно: изначально они задумывали Go как быстро изучаемый язык, который запросто могут выучить несколько не очень опытных программистов для того, чтобы затем вместе писать какое-нибудь приложение. Именно поэтому некоторые считают язык Go языком, пригодным для больших корпораций, где в разработке продуктов будет участвовать множество разных людей. Как уже было замечено выше, простой и понятный синтаксис ведет к тому, что программистам Go не нужно вводить какие-то другие стандарты, обозначения или комментарии – они и без этого отлично поймут код друг друга. Многословность Go радует одних разработчиков и огорчает других, но именно благодаря ей код Go читается так легко.

Поэтому некоторые компании (к примеру, CrowdStrike) сознательно переходят с других языков программирования на Go для того, чтобы в дальнейшем более легко расширять пул своих разработчиков.

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

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

Нельзя не отметить и четкую направленность языка Go: в отличие от PHP, на котором пишут большие проекты, Go больше предназначен для некрупных сервисов, которые необходимо быстро написать и внедрить, но которые должны отличаться чрезвычайной надежностью (так называемое robust software).

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

Синтаксис Go может быть непривычен тем, кто до этого программировал на PHP или Python. Если рассматривать код Go в сравнении с PHP, то Go не имеет объектов или классов, зато в нем есть структура, а точнее тип, который содержит именованные поля:

Еще одной причиной, по которой Go завоевывает все большую популярность, является наличие go fmt – инструмента, который помогает стандартизировать код. А использование go vet поможет вам найти возможные проблемы в коде. Иными словами, авторы языка Go попытались максимально упросить задачу разработки приложений на этом языке, особенно для новичков.

Именно поэтому многие на данный момент считают Go одним из лучших языков программирования и советуют изучать его не только студентам, но и школьникам. Кстати, такой прецедент уже был: учитель научил несколько 11-летних школьников писать и разбираться в коде на таком уровне, что они смогли написать генератор фракталов Мандельброта. А главное, для этого ему понадобилось всего 12-13 часов!

Минусы языка Go

В качестве негативной стороны Go часто называют его малую на данный момент распространенность – действительно, есть куда более распространенные языки программирования, которые используются для выполнения большинства задач. Значит ли это, что изучать Go не стоит? Совсем нет. Существует множество корпораций, которые используют язык Go в своих разработках. В первую очередь это, конечно же, Google Inc., а также Basecamp, BBC Worldwide, Canonical, DigitalOcean, Dropbox, eBay, Yahoo и многие другие компании по всему миру. Поэтому перспективы у этого языка программирования точно есть. Безусловно, программисты Go могут быть менее востребованы, чем, к примеру, PHP-разработчики, однако и конкуренция ниже, а значит, выше шанс найти интересную и хорошо оплачиваемую работу.

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

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

Вывод

Язык Go еще достаточно молод для того, чтобы говорить о какой-то определенной перспективе. Однако уже сейчас многие воспринимают Go как современный или даже передовой язык, который способствует развитию языков программирования в целом. Даже если вы уже долго время являетесь сторонником какого-то определенного языка программирования, Go может предложить вам много новых инструментов, которые расширят ваш кругозор или даже вызовут желание разрабатывать приложения на Go. При этом вы потратите минимальное время на знакомство с синтаксисом этого языка (вплоть до пары дней), поэтому даже если ваши ожидания в отношении Go не оправдаются, вы получите интересный и ценный опыт.

Go vs Python: изучение основ языка Go в сравнении с Python

Это не соревнование двух языков, а просто еще один способ обучения. Рассматриваем возможности языка Go, проводя параллели с Python.

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

Hello World

Начнем с классики – незаменимой для обучения программы Hello World. В Python мы выводим легендарную фразу всего одной строчкой:

1 print(«Hello world»)

В Go придется приложить чуть больше усилий: указать имя главного пакета, подключить модуль fmt и оформить функцию main :

func main() <
fmt.Println(«Hello world»)
>

123456789 package main import «fmt» func main()

Вывод данных

Продолжим с выводом и решим три фундаментальные задачи:

  • вывод строки с переходом на следующую строку;
  • вывод строки без перехода на следующую строку;
  • форматированный вывод.

В Python все три вещи может сделать единственная функция print :

print(«Some string»)
print(«Some string», end=»»)
print(«Name: <>, Age: <>».format(«Peter», 35))

123 print(«Some string»)print(«Some string», end=»»)print(«Name: <>, Age: <>».format(«Peter», 35))

У языка Go есть три разных метода:

func main() <
fmt.Println(«Some string»)
fmt.Print(«Some string»)
fmt.Printf(«Name: %s, Age: %dn», «Peter», 35)
>

123456789 package main import «fmt» func main()

Комментарии

Комментарии – важная часть документации кода.

В Python они выглядят так:

«»»doc string для целого модуля»»»

class Class(object):
«»»doc string для класса»»»

12345678910 «»»doc string для целого модуля»»» # строчный комментарий class Class(object): «»»doc string для класса»»» print(__doc__)print(Class.__doc__)

Язык программирования Go предлагает широко распространенный синтаксис комментирования:

// обычный строчный комментарий

только на несколько строк
*/

/* Многострочный комментарий для функции main().
Чтобы увидеть его, запустите в консоли команду:

12345678910111213141516171819 package main // обычный строчный комментарий /* тоже комментарий только на несколько строк*/ /* Многострочный комментарий для функции main(). Чтобы увидеть его, запустите в консоли команду: godoc comments.go */ func main() <>

Многострочные блоки

В Python за многострочность отвечают тройные кавычки. Также для оформления строк можно использовать двойные и одинарные кавычки.

print(
«»»Это
многострочная строка.
«»»
)
print(«O’word » ‘Another «word» ‘ «Last word.»)

123456 print( «»»Этомногострочная строка.»»»)print(«O’word » ‘Another «word» ‘ «Last word.»)

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

func main() <
fmt.Println(`Это
многострочная строка.
`)
fmt.Println(
«O’word » +
«Another «word» » +
«Last word.»)
>

12345678910111213 package main import «fmt» func main()

Списки

Срез ( slice ) – это последовательность элементов, длина которой может изменяться. Основное различие между массивом и срезом состоит в том, что, работая с массивом, вы должны знать его размер.

Работа со списками в Python:

# инициализируем список
numbers = [0] * 5
# изменяем один элемент
numbers[2] = 100
some_numbers = numbers[1:3]
print(some_numbers) # [0, 100]
# получаем размер
print(len(numbers)) # 5

# инициализируем другой список
scores = []
scores.append(1.1)
scores[0] = 2.2
print(scores) # [2.2]

1234567891011121314 # инициализируем списокnumbers = [0] * 5# изменяем один элементnumbers[2] = 100some_numbers = numbers[1:3]print(some_numbers) # [0, 100]# получаем размерprint(len(numbers)) # 5 # инициализируем другой списокscores = []scores.append(1.1)scores[0] = 2.2print(scores) # [2.2]

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

func main() <
// инициализируем массив
var numbers [5]int // [0, 0, 0, 0, 0]
// меняем один элемент
numbers[2] = 100
// создаем срез из массива
some_numbers := numbers[1:3]
fmt.Println(some_numbers) // [0, 100]
// получаем размер
fmt.Println(len(numbers))

// инициализируем срез
var scores []float64
scores = append(scores, 1.1) // пересоздаем, чтобы добавить элемент
scores[0] = 2.2 // изменяем
fmt.Println(scores) // [2.2]

// когда вы точно не знаете, сколько элементов
// собираетесь положить в срез, можно сделать так
var things [100]string
things[0] = «Peter»
things[1] = «Anders»
fmt.Println(len(things)) // 100
>

12345678910111213141516171819202122232425262728 package main import «fmt» func main() < // инициализируем массив var numbers [5]int // [0, 0, 0, 0, 0] // меняем один элемент numbers[2] = 100 // создаем срез из массива some_numbers := numbers[1:3] fmt.Println(some_numbers) // [0, 100] // получаем размер fmt.Println(len(numbers)) // инициализируем срез var scores []float64 scores = append(scores, 1.1) // пересоздаем, чтобы добавить элемент scores[0] = 2.2 // изменяем fmt.Println(scores) // [2.2] // когда вы точно не знаете, сколько элементов // собираетесь положить в срез, можно сделать так var things [100]string things[0] = «Peter» things[1] = «Anders» fmt.Println(len(things)) // 100>

Ассоциативные массивы

В ассоциативных массивах ключ может иметь нечисловое значение.

В Python эту функцию выполняют словари (dictionaries):

elements = <>
elements[«H»] = 1
print(elements[«H»]) # 1

# удалить по ключу
elements[«O»] = 8
elements.pop(«O»)

# проверка наличия ключа

if «O» in elements:
print(elements[«O»])
if «H» in elements:
print(elements[«H»])

1234567891011121314 elements = <>elements[«H»] = 1print(elements[«H»]) # 1 # удалить по ключуelements[«O»] = 8elements.pop(«O») # проверка наличия ключа if «O» in elements: print(elements[«O»])if «H» in elements: print(elements[«H»])

В Go для этой же цели мы можем использовать отображения:

func main() <
elements := make(map[string]int)
elements[«H»] = 1
fmt.Println(elements[«H»])

// удаление по ключу
elements[«O»] = 8
delete(elements, «O»)

// сделать что-то с элементом, если он есть в отображении
if number, ok := elements[«O»]; ok <
fmt.Println(number) // не будет выведено >
if number, ok := elements[«H»]; ok <
fmt.Println(number) // 1
>
>

1234567891011121314151617181920 package main import «fmt» func main() < elements := make(map[string]int) elements[«H»] = 1 fmt.Println(elements[«H»]) // удаление по ключу elements[«O»] = 8 delete(elements, «O») // сделать что-то с элементом, если он есть в отображении if number, ok := elements[«O»]; ok < fmt.Println(number) // не будет выведено >if number, ok := elements[«H»]; ok < fmt.Println(number) // 1 >>

В Go даже можно создать отображение отображений:

elements : make(map[string]map[string]int)
elements[«H»] = map[string]int <
«protons»: 1,
«neutrons»: 0,
>

12345 elements : make(map[string]map[string]int)elements[«H»] = map[string]int

Но помните, что для этой цели существует struct .

Логические значения

В Python внутри условия if можно использовать выражения с разными типами данных – в большинстве случаев они автоматически конвертируются в логическое значение True или False :

x = 1
if x:
print «Yes»
y = []
if y:
print «не будет выведено»

print(True and False) # False
print(True or False) # True
print(not True) # False

12345678910 x = 1if x: print «Yes»y = []if y: print «не будет выведено» print(True and False) # Falseprint(True or False) # Trueprint(not True) # False

У языка Go нет быстрого способа оценить истинность выражения, поэтому приходится делать это явно для каждого типа данных:

x := 1
if x != 0 <
fmt.Println(«Yes»)
>
var y []string
if len(y) != 0 <
fmt.Println(«не будет выведено»)
>

fmt.Println(true && false) // false
fmt.Println(true || false) // true
fmt.Println(!true) // false

1234567891011121314151617181920 package main import «fmt» func main() < x := 1 if x != 0 < fmt.Println(«Yes») >var y []string if len(y) != 0 < fmt.Println(«не будет выведено») >fmt.Println(true && false) // false fmt.Println(true || false) // true fmt.Println(!true) // false >

В этих примерах также видна работа основных логических операторов.

Циклы

В Python существует несколько видов циклов:

i = 1
while i for :

func main() <
i := 1
for i for можно использовать для перебора элементов коллекции и в Python:

names = [«Peter», «Anders», «Bengt»]
for i, name in enumerate(names):
print(«<>. <>».format(i + 1, name))

123 names = [«Peter», «Anders», «Bengt»]for i, name in enumerate(names): print(«<>. <>».format(i + 1, name))

func main() <
names := []string <
«Peter»,
«Anders»,
«Bengt»,
>
/* будет выведено:

1. Peter
2. Anders
3. Bengt
*/
for i, name := range names <
fmt.Printf(«%d. %sn», i+1, name)
>
>

1234567891011121314151617181920 package main import «fmt» func main() < names := []string< «Peter», «Anders», «Bengt», >/* будет выведено: 1. Peter 2. Anders 3. Bengt */ for i, name := range names < fmt.Printf(«%d. %sn», i+1, name) >>

Switch

Множественные условия могут быть определены с помощью конструкции switch .

В Python она выглядит так:

def input_():
return int(input())

number = input_()
if number == 8:
print(«Oxygen»)
elif number == 1:
print(«Hydrogen»)
elif number == 2:
print(«Helium»)
elif number == 11:
print(«Sodium»)
else:
print(«I have no idea what %d is» % number)

# Альтернативное решение
number = input_()
db = <1: «Hydrogen», 2: «Helium», 8: «Oxygen», 11: «Sodium»>
print(db.get(number, «I have no idea what %d is» % number))

123456789101112131415161718192021 def input_(): return int(input()) number = input_()if number == 8: print(«Oxygen»)elif number == 1: print(«Hydrogen»)elif number == 2: print(«Helium»)elif number == 11: print(«Sodium»)else: print(«I have no >

А вот вариант кода для Go:

func str2int(s string) int <
i, err := strconv.Atoi(s)
if err != nil <
panic(«Not a number»)
>
return i
>

func main() <
var number_string string
fmt.Scanln(&number_string)
number := str2int(number_string)

switch number <
case 8:
fmt.Println(«Oxygen»)
case 1:
fmt.Println(«Hydrogen»)
case 2:
fmt.Println(«Helium»)
case 11:
fmt.Println(«Sodium»)
default:
fmt.Printf(«I have no idea what %d isn», number)
>

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950 package main import ( «fmt» «strconv») func str2int(s string) int < i, err := strconv.Atoi(s) if err != nil < panic(«Not a number») >return i> func main()

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

Вариативные функции

В Python функции могут принимать переменное число аргументов различных типов с помощью somefunction (*args) .

def average(*numbers):
return sum(numbers) / len(numbers)

print(average(1, 2, 3, 4)) # 10/4 = 2.5

12345 def average(*numbers): return sum(numbers) / len(numbers) print(average(1, 2, 3, 4)) # 10/4 = 2.5

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

func average(numbers …float64) float64 <
total := 0.0
for _, number := range numbers <
total += number
>
return total / float64(len(numbers))
>

func main() <
fmt.Println(average(1, 2, 3, 4)) // 2.5
>

123456789101112131415 package main import «fmt» func average(numbers …float64) float64 < total := 0.0 for _, number := range numbers < total += number >return total / float64(len(numbers))> func main() < fmt.Println(average(1, 2, 3, 4)) // 2.5>

Измерение времени

В Python методы работы со временем собраны в модуле time :

t0 = time.time()
time.sleep(3.5)
t1 = time.time()
print(«Took <:.2f>seconds».format(t1 — t0))

123456 import time t0 = time.time()time.sleep(3.5) t1 = time.time()print(«Took <:.2f>seconds».format(t1 — t0))

В Go, как ни странно, тоже есть такой модуль:

import «fmt»
import «time»

func main() <
t0 := time.Now()
elapsed := time.Since(t0)
fmt.Printf(«Took %s», elapsed)
>


12345678910 package main import «fmt»import «time» func main()

Замыкания функций

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

Вот так можно реализовать замыкание в Python:

def run():
def increment(amount):
return number + amount

number = 0
number = increment(1)
number = increment(2)
print(number) # 3

1234567891011 def run(): def increment(amount): return number + amount number = 0 number = increment(1) number = increment(2) print(number) # 3 run()

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

def increment(amount):
number += amount
increment(1)
increment(2)

1234 def increment(amount): number += amountincrement(1)increment(2)

Нужную переменную можно объявить прямо внутри increment . А чтобы она была доступна на внешнем уровне, используется ключевое слово global .

def increment(amount):
global number
number += amount
increment(1)
increment(2)

12345 def increment(amount): global number number += amountincrement(1)increment(2)

А вот пример замыкания в Go:

/* Это должна быть именно локальная переменная.
Нельзя написать `func increment(amount int) <` */
increment := func(amount int) <
number += amount
>
increment(1)
increment(2)

12345678910111213141516171819 package main import «fmt» func main() < number := 0 /* Это должна быть именно локальная переменная. Нельзя написать `func increment(amount int) <` */ increment := func(amount int) < number += amount >increment(1) increment(2) fmt.Println(number) // 3 >

Defer

В Go defer имеет замечательный синтаксис. Отложенная операция стоит сразу после ключевого слова, так что смысл конструкции сразу же становится очевиден:

func main() <
f, _ := os.Open(«defer.py»)
defer f.Close()
// теперь вы можете читать из f
// он будет закрыт в конце программы
>

123456789101112 package main import ( «os») func main() < f, _ := os.Open(«defer.py») defer f.Close() // теперь вы можете читать из f // он будет закрыт в конце программы>

В Python вы можете добиться того же, поместив код в try-finally блок:

f = open(«defer.py»)
try:
f.read()
finally:
f.close()

12345 f = open(«defer.py»)try: f.read()finally: f.close()

Panic Recover

Чтобы сгенерировать и поймать ошибку, в Python используется ключевое слово raise и конструкция try-except :

try:
raise Exception(«Shit»)
except Exception as e:
print(«error was:», e)

1234 try: raise Exception(«Shit»)except Exception as e: print(«error was:», e)

В Go для этого есть оператор panic и функция recover :

// будет выведено:
// error was: Shit!
defer func() <
fmt.Println(«error was:», recover())
>()
panic(«Shit!»)
>

12345678910111213 package main import «fmt» func main() < // будет выведено: // error was: Shit! defer func() < fmt.Println(«error was:», recover()) >() panic(«Shit!»)>

Изменяемость

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

def upone(mutable, index):
mutable[index] = mutable[index].upper()

list_ = [«a», «b», «c»]
upone(list_, 1)
print(list_) # [‘a’, ‘B’, ‘c’]

1234567891011 def upone(mutable, index): mutable[index] = mutable[index].upper() list_ = [«a», «b», «c»]upone(list_, 1)print(list_) # [‘a’, ‘B’, ‘c’] dict_ = <«a»: «anders», «b»: «bengt»>upone(dict_, «b»)print(dict_) #

func upone_list(thing []string, index int) <
thing[index] = strings.ToUpper(thing[index])
>

func upone_map(thing map[string]string, index string) <
thing[index] = strings.ToUpper(thing[index])
>

func main() <
// mutable
list := []string<«a», «b», «c»>
upone_list(list, 1)
fmt.Println(list) // [a B c]

// mutable
dict := map[string]string <
«a»: «anders»,
«b»: «bengt»,
>
upone_map(dict, «b»)
fmt.Println(dict) // map[a:anders b:BENGT]
>

1234567891011121314151617181920212223242526272829 package main import ( «fmt» «strings») func upone_list(thing []string, index int) < thing[index] = strings.ToUpper(thing[index])>func upone_map(thing map[string]string, index string) < thing[index] = strings.ToUpper(thing[index])>func main() < // mutable list := []string<«a», «b», «c»>upone_list(list, 1) fmt.Println(list) // [a B c] // mutable dict := map[string]string < «a»: «anders», «b»: «bengt», >upone_map(dict, «b») fmt.Println(dict) // map[a:anders b:BENGT]>

Структуры

В Python для создания пользовательских наборов полей используются классы. Метод __init__ вызывается при создании экземпляра класса:

from math import sqrt

class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y

def distance(point1, point2):
return sqrt(point1.x * point2.x + point1.y * point2.y)

p1 = Point(1, 3)
p2 = Point(2, 4)
print(distance(p1, p2)) # 3.74165738677

12345678910111213141516 from math import sqrt >

В Go существует специальное ключевое слово struct :

type Point struct <
x float64
y float64
>

func distance(point1 Point, point2 Point) float64 <
return math.Sqrt(point1.x*point2.x + point1.y*point2.y)
>

// Так как структуры автоматически копируются при передаче,
// лучше передавать их в функцию как указатели

func distance_better(point1 *Point, point2 *Point) float64 <
return math.Sqrt(point1.x*point2.x + point1.y*point2.y)
>

func main() <
p1 := Point<1, 3>
p2 := Point<2, 4>
fmt.Println(distance(p1, p2)) // 3.7416573867739413
fmt.Println(distance_better(&p1, &p2)) // 3.7416573867739413
>

1234567891011121314151617181920212223242526272829 package main import ( «fmt» «math») type Point struct < x float64 y float64>func distance(point1 Point, point2 Point) float64 < return math.Sqrt(point1.x*point2.x + point1.y*point2.y)>// Так как структуры автоматически копируются при передаче,// лучше передавать их в функцию как указатели func distance_better(point1 *Point, point2 *Point) float64 < return math.Sqrt(point1.x*point2.x + point1.y*point2.y)>func main() < p1 := Point<1, 3>p2 := Point <2, 4>fmt.Println(distance(p1, p2)) // 3.7416573867739413 fmt.Println(distance_better(&p1, &p2)) // 3.7416573867739413>

Методы

В Python методы определяются прямо внутри классов с помощью ключевого слова def , и первым аргументом принимают ссылку на экземпляр класса:

from math import sqrt

class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y

def distance(self, other):
return sqrt(self.x * other.x + self.y * other.y)

p1 = Point(1, 3)
p2 = Point(2, 4)
print(p1.distance(p2)) # 3.74165738677
print(p2.distance(p1)) # 3.74165738677

12345678910111213141516 from math import sqrt >

Методы в Go – это функции, прикрепленные к какому-то конкретному типу. Его параметр обязательно указывается в сигнатуре метода:

type Point struct <
x float64
y float64
>

func (this Point) distance(other Point) float64 <
return math.Sqrt(this.x*other.x + this.y*other.y)
>

func (this *Point) distance_better(other *Point) float64 <
return math.Sqrt(this.x*other.x + this.y*other.y)
>

func main() <
p1 := Point<1, 3>
p2 := Point<2, 4>
fmt.Println(p1.distance(p2)) // 3.7416573867739413
fmt.Println(p1.distance_better(&p2)) // 3.7416573867739413
>

1234567891011121314151617181920212223242526 package main import ( «fmt» «math») type Point struct < x float64 y float64>func (this Point) distance(other Point) float64 < return math.Sqrt(this.x*other.x + this.y*other.y)>func (this *Point) distance_better(other *Point) float64 < return math.Sqrt(this.x*other.x + this.y*other.y)>func main() < p1 := Point<1, 3>p2 := Point <2, 4>fmt.Println(p1.distance(p2)) // 3.7416573867739413 fmt.Println(p1.distance_better(&p2)) // 3.7416573867739413>

Горутины

Горутины языка Go – это независимые параллельные операции. Сама функция main является горутиной. Для их определения используется оператор go :

func f(url string) <
response, err := http.Get(url)
if err != nil <
panic(err)
>
defer response.Body.Close()
body, err := ioutil.ReadAll(response.Body)
if err != nil <
panic(err)
>

// Смотрите пример на https://golang.org/pkg/sync/#WaitGroup
func main() <
var wg sync.WaitGroup
urls := []string <
«https://www.peterbe.com»,
«https://python.org»,
«https://golang.org»,
>
for _, url := range urls <
wg.Add(1)
go func(url string) <
defer wg.Done()
f(url)
>(url)
>
// ждем, когда горутина закончит работу
wg.Wait()
>

1234567891011121314151617181920212223242526272829303132333435363738394041 package main import ( «fmt» «io/ioutil» «net/http» «sync») func f(url string) < response, err := http.Get(url) if err != nil < panic(err) >defer response.Body.Close() body, err := ioutil.ReadAll(response.Body) if err != nil < panic(err) >fmt.Println(len(body))> // Смотрите пример на https://golang.org/pkg/sync/#WaitGroupfunc main() < var wg sync.WaitGroup urls := []string< «https://www.peterbe.com», «https://python.org», «https://golang.org», >for _, url := range urls < wg.Add(1) go func(url string) < defer wg.Done() f(url) >(url) > // ждем, когда горутина закончит работу wg.Wait()>

В Python параллельное программирование также возможно с помощью модуля multiprocessing :

import urllib2
import multiprocessing

def f(url):
req = urllib2.urlopen(url)
try:
print(len(req.read()))
finally:
req.close()

urls = («https://www.peterbe.com», «https://python.org», «https://golang.org»)

if __name__ == «__main__»:
p = multiprocessing.Pool(3)
p.map(f, urls)

123456789101112131415161718 import urllib2import multiprocessing def f(url): req = urllib2.urlopen(url) try: print(len(req.read())) finally: req.close() urls = («https://www.peterbe.com», «https://python.org», «https://golang.org») if __name__ == «__main__»: p = multiprocessing.Pool(3) p.map(f, urls)

Args

Часто бывает необходимо получить аргументы переданные в команде терминала. Рассмотрим эту задачу на примере команды:

go run args.go peter anders bengt

1 go run args.go peter anders bengt

Программа должна вернуть все три аргумента в верхнем регистре:

PETER
ANDERS
BENGT

123 PETERANDERSBENGT

В Python для разбора неопределенного количества неименованных параметров удобно воспользоваться синтаксисом *args . Список аргументов находится в sys.argv .

def transform(*args):
for arg in args:
print(arg.upper())

if __name__ == «__main__»:
transform(*sys.argv[1:])

12345678910 import sys def transform(*args): for arg in args: print(arg.upper()) if __name__ == «__main__»: transform(*sys.argv[1:])

В Go аргументы командной строки хранятся в os.Args :

func transform(args []string) <
for _, arg := range args <
fmt.Println(strings.ToUpper(arg))
>

>
func main() <
args := os.Args[1:]
transform(args)
>

123456789101112131415161718 package main import ( «fmt» «os» «strings») func transform(args []string) < for _, arg := range args < fmt.Println(strings.ToUpper(arg))>>func main()

Псевдонимы для импорта

В Python для импортируемых модулей можно использовать алиасы – короткие псевдонимы:

import string as s

123 import string as s print(s.upper(«world»))

У языка Go тоже есть такая возможность:

func main() <
fmt.Println(s.ToUpper(«world»))
>

12345678910 package main import ( «fmt» s «strings») func main()

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

import (
pb «github.com/golang/groupcache/groupcachepb»
)

123 import ( pb «github.com/golang/groupcache/groupcachepb»)

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

123 import ( _ «image/png» )

Быстрое форматирование строк

Строки не всегда нужно печатать, иногда требуется просто быстро их отформатировать и передать, куда следует. В Python для этого есть простая функция f :

max = 10
raise Exception(f»The max. number is »)

12 max = 10raise Exception(f»The max. number is »)

В Golang для быстрого форматирования используется метод Sprintf модуля fmt :

func main() <
max := 10
panic(fmt.Sprintf(«The max. number is %d», max))
>

12345678 package main import «fmt» func main()

Отбор уникальных значений

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

def uniqify(seq):
seen = <>
unique = []
for item in seq:
if item not in seen:
seen[item] = 1
unique.append(item)
return unique

items = [«B», «B», «E», «Q», «Q», «Q»]
print(uniqify(items)) # prints [‘B’, ‘E’, ‘Q’]

123456789101112 def uniqify(seq): seen = <> unique = [] for item in seq: if item not in seen: seen[item] = 1 unique.append(item) return unique items = [«B», «B», «E», «Q», «Q», «Q»]print(uniqify(items)) # prints [‘B’, ‘E’, ‘Q’]

А здесь вы можете найти самый быстрый способ унифицировать список в Python.

Вот аналогичный код для языка Go:

func uniqify(items []string) []string <
uniq := make([]string, 0)
seen := make(map[string]bool)

// для большей эффективности:
// seen := make(map[string]struct<>)
// https://stackoverflow.com/questions/37320287/maptstruct-and-maptbool-in-golang

for _, i := range items <
if _, exists := seen[i]; !exists <
uniq = append(uniq, i)
seen[i] = true
>
>

func main() <
items := []string<«B», «B», «E», «Q», «Q», «Q»>
items = uniqify(items)
fmt.Println(items) // prints [B E Q]
>

123456789101112131415161718192021222324252627 package main import «fmt» func uniqify(items []string) []string < uniq := make([]string, 0) seen := make(map[string]bool) // для большей эффективности: // seen := make(map[string]struct<>) // https://stackoverflow.com/questions/37320287/maptstruct-and-maptbool-in-golang for _, i := range items < if _, exists := seen[i]; !exists < uniq = append(uniq, i) seen[i] = true >> return uniq> func main() < items := []string<«B», «B», «E», «Q», «Q», «Q»>items = uniqify(items) fmt.Println(items) // prints [B E Q]>

Учиться новому проще на фундаменте имеющихся знаний. Сравнивая особенности Python и языка Go, мы находим множество сходств между ними. Это позволяет глубже понять концепции программирования и проще изучить новое.

Полезные материалы о Go

  • REST API приложение на Go: пошаговый туториал;
  • Программирование на Go с нуля: 9 полезных видеоуроков;
  • Более 200 избранных ссылок на материалы о языке Go

5 причин, почему мы перешли с Python на Go (перевод)

Всем привет! Решил выкладывать здесь свои переводы статей, так как это удобно и не требует особых усилий в оформлении. На этот раз это статья 5 Reasons Why We switched from Python To Go by Tigran Bayburtsyan.

P.S.: Любая авторская статья лишь отражает мнение и опыт автора, которые могут не совпадать с вашими, и это нормально — сколько людей столько и мнений.

Python прекрасен! Особенно Python 3 с его асинхронной функциональностью. Но на деле Go не даёт никому шансов выжить в мире enterprise…

Если вы прониклись этой цитатой, тогда вы возможно пробовали или хотя бы смотрели в сторону языка программирования Go. Который по моему мнению самый простой язык программирования, подходящий для разработки любых приложений. Да! Вы не ослышались, для меня изучить Go оказалось проще, чем Javascript. Я думаю, это главная причина того, что Go разошёлся такой популярностью всего за несколько лет.

Итак, что мы имели перед использованием Go?

TreeScale.com — это, в основном, приложение, основанное на API, с панелью инструментов и некоторыми аналитическими возможностями. Вот наш технологический стек:

  • React.js для клиентской части панели инструментов
  • Django Python для серверной части панели инструментов + сервис аутентификации
  • Node.js для API сервиса
  • PostgreSQL как база данных и Cassandra для логирования
  • Самописные реестры для контейнеров на языке Rust

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

Это основная причина, почему мы начали размышлять о слиянии API сервиса и серверной части в единый проект: у них есть много схожего функционала, код которого приходится повторять на множестве различных языков и технологий. Но оказалось, что нам пришлось бы совершать много лишних телодвижений по настройке API сервиса Django, особенно с пользовательскими JSON ответами.

После месяца работы над созданием API сервиса на Django, я почувствовал, что Django крут только пока вы делаете что-то обыденное, но когда вы хотите больше производительности и настраиваемых модулей — это становится куда более сложным делом.

Почему Go?

Как я говорил ранее, Go — самый простой язык, что я когда-либо видел и использовал до этого. Но это было лишь начало.

Вот 5 основных причин, почему мы перешли с Python Django в пользу Go.

#1 Он компилируется в один бинарный файл

Goland создан как компилируемый язык, и команда разработчиков Google проделала большую работу над ним. Используя статическое связывание (static linking — прим.перев.) он действительно объединяет все зависимости библиотек и модулей в единый бинарный файл основанный на типе и архитектуре используемой операционной системы. Это значит, если вы компилируете серверную часть своего приложения на своём ноутбуке под Linux x86 CPU, то вы можете просто загрузить скомпилированный бинарник на сервер и это будет работать, без установки каких-либо зависимостей на нём!

#2 Система статических типов

Система типов это действительно важная часть большого масштабируемого приложения. Python крутой и интересный язык, но иногда вы просто получаете нестандартные исключения, потому что пытаетесь использовать переменные как число (integer), но оказывается, что это строка (string).

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

#3 Производительность!!

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

В нашем случае, Go производительнее благодаря своего модели параллелизма и масштабируемости CPU. Всякий раз, когда нам необходимо обработать внутренний запрос, мы делаем это с помощью отдельной Горутины, которая в 10 раз менее прожорлива, чем потоки в Python. Таким образом, мы сохраняем много ресурсов (память, CPU), потому что используем встроенные функции языка.

#4 Вам не нужен фреймворк для Go

Это наиболее крутая штука в этом языке программирование. Создатели Go и Go-сообщество сделали так много инструментов, которые в самом языке поставляются “из коробки”, что в большинстве случаев отпадает необходимость в какой-либо сторонней библиотеке. Например, в нём есть http, json, html templating , изначально встроенные в язык, тем самым вы можете создавать сложные API сервисы даже не думая о поиске какой-либо библиотеке на Github!

Но конечно, есть множество библиотек и фреймворков, написанных для Go и создания веб-приложений на Go, но я рекомендую вам самим создать ваше приложение или API сервис без использования сторонних библиотек, потому что в большинстве случаев они не сделают вашу жизнь проще, как это делают встроенные пакеты.

#5 Отличная поддержка >Поддержка IDE это одна из самых важных вещей, когда вы пытаетесь перейти на другой язык программирования. Комфортная IDE в среднем может сохранить до 80% вашего времени написания кода. Я нашёл плагин Go для JetBrains IDEA, который также поддерживает WebStorm, PHPStorm, и так далее. Этот плагин предоставляет всё, что необходимо для разработки проекта, со всей мощью JetBrains IDEA вы можете реально ускорить свою разработку.

Основываясь на нашей статистике кода, после переписывания всех проектов на Go мы получили на 64% меньше кода, чем раньше.

Вам действительно не нужно отлаживать код, которого не существует. Меньше кода, меньше проблем!

Заключение

Go дал нам большую гибкость, единый язык для всех случаев и во всех из них, он работает очень и очень хорошо. Мы получили на 30% больше производительности нашей серверной части и API сервисов. И теперь мы можем обрабатывать журнал событий в режиме реального времени, перемещать его в базу данных и создавать потоки на Websocket из одного или нескольких сервисов. Это потрясающий результат возможностей языка Go.

Umputun тут был

заметки на разные темы

Домой
Еженедельный подкаст
Подкаст Радио-Т
Пираты РТ
Теория и практика звукозаписи

Go или не Go?

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

Давайте по пунктам. На вопрос «стоит ли его изучать», я смело скажу — да, стоит. И этому есть пара весомых причин:

Это вполне практичный язык и умение писать на нем позволит вам сделать что-то. Это «что-то» можно сделать и на других языках, но можно и на Go. Если иметь ввиду небольшие домашние проекты, то тут по практичности и скорости достижения результата Go, для меня, примерно на одном уровне с Python. Однако, если проект не самый мелкий и/или его развитие и сопровождения может потребоваться, то тут я отдам предпочтение Go.

Go очень простой язык. T.e. совсем, совсем простой, простой как дверь, прямой как железная дорога. На его изучение может уйти от пары часов до пары недель, в зависимости от опыта изучающего. При этом сроки не фиктивные, как в случае с другими языками, которые сами по себе простые, но чтоб сделать в них что-то реальное надо изучить все вокруг, их экосистему, системы сборки, магию тестирования, минимальные фреймворки и библиотеки. С Go все это заметно проще и, что немаловажно, он не особо нагружает мозг.

Теперь попробую развернуть, обосновать и ответить за все.

Писать небольшие и средние проекты на Go на удивление приятно, быстро и результативно. Я не знаю, как будет в случае действительно больших проектов, такого опыта у меня пока не много, но с мелкими и средними все в порядке. С момента моего практического соприкосновения с Go, я написал на нем целую кучу того, где я раньше использовал python, и где мне всегда казалось, что это слишком много для python, либо где использовал java и ощущал, что java это перебор для такого. Не бахвальства ради, но прояснения для, вот короткий список:

бэкенд того, что делает news.radio-t.com. Это проект а не проектик, там на самом деле много всего за сценой.

система раздачи и баллансировки (этакий специальный CDN) для подкастов. Эта штука была написана много лет назад на java и вполне работала, пока не сломалась. Тронув ее чтоб починить, я увидел там много кода и его большая часть довольно низкоуровневая. Нет, код там неплохой, но лучший код это, как известно, код который не надо писать. В результате, я переписал эту штуку на Go за вечер и для того, чтоб добиться сравнимой производительности мне не пришлось даже задуматься. Все почти сразу заработало и работает сейчас.

бот для нашего гиттер чата. Он тоже был на java много лет и, честно говоря, его можно было бы переписать на чем угодно. Там с годами многие самые сложные вещи устарели, а то, что осталось – оно совсем простое. Но писать на Go его было просто и приятно.

идет неспешный процесс написание новой версии ukeeper v2 на Go. Тут все несколько сложнее. Это реально большой проект на java и он перерос себя и свою архитектуру. Я пару раз уже засучивал рукава и пытался раздробить его на мелкие части, убрать старый хлам и упростить все, что можно. Но задача это пугающе велика и по сути сводится к переписыванию многих частей с использованием современных методов и технологий, плюс к вдумчивому отсеканию лишнего. В виде эксперимента я попытался написать основной сервис, тот что делает главную магию, на Go и результат приятно удивил. Код простой и почти прямой, производительность более чем, масштабируемость в ассортименте. И на написание этого сервиса ушло всего пару выходных.

есть целый ряд мелких и средних проектов по работе, которые были либо написаны с нуля, либо как upgrade с их py версии, которая стала выходить из под контроля. Там много чего, начиная от диспетчера RMQ с хитрым форвардингом и до систем управления ресурсами в AWS. Есть и более традиционные системы для бизнес задач и вычислительные системы и разное другое.

В процессе столь тесного общения с Go я заметил целый ряд особенностей:

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

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

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

В процессе работы на Go я обратил внимание, что мне нет необходимости настолько часто искать ответы в интернетах как на python или java. Нет, ничего плохого в том, чтоб погуглить проблему нет, но если такой необходимости не возникает то это еще лучше. На python, который я использую не постоянно, мне часто приходилось искать вполне тривиальные вещи, которые можно сделать многими способами и которые я уже делал правильно, но забыл как. На java, который мой основной язык, искать приходиться строго противоположное — нетривиальные проблемы или проблемы с магией, которой в большой java (со всеми полезными enterprise фреймворками) немало.

По бесцеремонности Go для меня даже уделывает python. Я имею ввиду все эти предварительные . действия, которые надо совершить до того, как начнешь писать код.

Если к этому моменту я вас убедил и ваши рукава засучены, а пальцы зависли над клавиатурой в непреодолимом желании попробовать, то вот вам ответ на вопрос «как и что учить?». Во первых, я бы не советовал читать книги по Go. Да, есть пара достойных книг которые может и стоит почитать со временем, но гораздо практичней будет просмотреть 3 ресурса:

  1. Go by Example – очень лаконично, и почти о всем, что надо для быстрого старта.
  2. Learn X in Y minutes – прелестный способ, мой личный фаворит.
  3. How to Write Go Code — тоже коротко и сердито.


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

По поводу «это отстой, a не язык». Тут мне трудно спорить и не только потому, что я это и сам говорил. Язык, для ценителей, на самом деле не самый . выразительный. И для беглого взгляда, программа на Go выглядит странно, а для многих неприятно. Однако, к тому, как оно выглядит привыкаешь быстро, ну и это «бее» можно выдать и о любом новом синтаксисе. Я помню, как меня доставал по началу питон со своими отступами и java с своими длинными конструкциями.

И про скудность языка тоже не поспоришь. Да, он такой. Да, там нет многого из того, что хотелось в том числе и мне. Однако, как и все практичное в нашей области, Go это компромисс. И этот компромисс действительно выглядит не особо привлекательно со стороны. Я вполне понимаю критиков языка и местами разделяю их позицию, за исключением их вывода — «это неподходящий язык, в топку его». Из моего практического опыта эти компромиссы не настолько суровы как кажется со стороны. На Go можно писать код, можно читать код и оба эти процесса на удивление приятны. Тут есть какой-то особый феномен который я затрудняюсь описать. По всем признакам Go должен был оказаться провалом и ошибкой природы, но на практике это реально рабочий инструмент вполне подходящий к целому классу задач.

Я думаю, что Go это не очередная хипстеровская тенденция о которой забудут если не завтра, то через год. Это реальная и настоящая вещь и она пришла надолго.

�� Go vs Python: изучение основ языка Go в сравнении с Python

Это не соревнование двух языков, а просто еще один способ обучения. Рассматриваем возможности языка Go, проводя параллели с Python.

Go или Python? Голосуем��

Go vs Python: изучение основ языка Go в сравнении с Python

Комментарии (26)

Александр Овчинников

GO — лайк, Python — ретвит?��

Евгений Жилинский

Видел тут недавно книгу: изучение go при помощи javascript

Ярослав Мик

по всем статьям питон лучше

Грегор Замза

Два моих любимых языка

Андрей Алексеев

Функция, объявленная в функции.

Вадим Кравченко

чушь местами. Буду говорить только про go — «передаем массив в ф-ю и его можно изменить внутри», только на самом деле передают слайс, который хранит указатель на массив и никто не говорит что именно с массивом такое не прокатит. — Что значит лучше передавать структуры по указателю? а как на счет того что скопировать маленькую структуру в стек и работать с копией в стеке это быстрее чем кидать ее в кучу? а как на счет того что go не гарантирует что передавая как значение или как указатель компилятор не проведет оптимизации, которые сделают все ровно наоборот? — Методы хрен с ними, но по факту в go синтаксис методов это сахар и на самом деле можно делать так Type.Method(InstanceOfType, ) — Горутины не параллельные а конкурентные. — Помимо аргументов через args можно еще удобно парсить флаги — Импорт через _ не объяснили для чего нужен. Чтобы вызвать init(вызывается всегда при импорте), который может породить горутину с полезным кодом. Одно предложение поленились написать =(

Артём Кац

Yaroslav, кроме производительности

Ярослав Мик

Артём, а что Го разве низкоуровневый?

Артём Кац

Yaroslav, его создали как подобие языка C, только проще и понятнее. Он используется для хайлоад решений. (В моём мухосранске, уже 2 вакансии видел где обязателен go, представьте что будет через 5 лет, когда у него уже будет большое комьюнити)

Ярослав Мик

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

Сергей Фомин

«Сравнивая их мы видим сходство между ними».. ШТА. Да Go позаёбистее в сто раз

Андрей Любимов

Артём, Если смотреть на Google trends (стата конечно не точная, но представление дает) то популярность пистона растет, а GO падает

Что выбрать для веб Python или Go?

Скажем для форума или интернет магазина

А у самого какие мысли?

Что go за зверь такой

в плане веба? Есть ли что-то, чего нет у python?

Зачем предлагать хипстерские технологии когда есть стабильные продуманные решения?

Re: Что go за зверь такой

Если ты знаешь питон и не знаешь го, зачем ты вообще что-то спрашиваешь? Бери и делай.

Go, возможно, лет через 10-15 и станет нормальным языком, а пока он очень недоразвитый. Его производительность не нужна в большинстве случаев, зато нужно колесо все время изобретать и ногу себе отстрелить можно запросто. Для форума или интернет-магазина? Ну да, питон или пэхапэ. Можно использовать Django.

Бери сразу Rust.

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

Не принципиально. Backend для интернет магазина или форума обычно не имеет страшной нагрузки (если это не Амазон). Там основная задача понять как и где хранить данные. DB — самая критичная часть. Плюс frontend.

Одним серваком справится. У тебя неверные представления о Java.

Нахрена, если это решается шаред-хостингом, опенкартом/smf и 1/4 фрилансера. Сейчас скажут что-то писать еще.

Пересядь с иглы одобрения смузихлёбов на wordpress.

PHP, Ruby, Python – краткая характеристика трёх языков программирования

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

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

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

PHP: самый популярный язык для Интернета

PHP ( Hypertext PreProcessor , препроцессор гипертекста) – язык программирования, исполняемый на стороне веб-сервера, спроектированный Расмусом Лердорфом ( Rasmus Lerdorf ) в качестве инструмента создания динамических и интерактивных веб-сайтов.

Этот язык оказался достаточно гибким и мощным, поэтому приобрёл большую популярность и используется в проектах любого масштаба: от простого блога до крупнейших веб-приложений в Интернете:

Преимущества PHP:

  • является свободным программным обеспечением, распространяемым под особой лицензией (PHP license);
  • легок в освоении на всех этапах;
  • поддерживается большим сообществом пользователей и разработчиков;
  • имеет развитую поддержку баз данных;
  • имеется огромное количество библиотек и расширений языка;
  • может использоваться в изолированной среде;
  • предлагает нативные средства организации веб-сессий, программный интерфейс расширений;
  • является довольно полной заменой проприетарной среды ASP ( Active Server Pages ) от Microsoft ;
  • может быть развёрнут почти на любом сервере;
  • портирован под большое количество аппаратных платформ и операционных систем.

Недостатки PHP:

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

Проекты, использующие PHP:

  • Zend ;
  • Yahoo ;
  • Facebook ;
  • Google
  • NASA ;
  • W3C .

Популярность:

Согласно Википедии , на 1 января 2013 года PHP был установлен на более чем 240 миллионах веб-сайтов (39% от всего объёма исследованных) или на 2,1 миллионах веб-серверов.

Использование

Скрипты, написанные на языке PHP , обычно хранятся в файлах с расширением .php , которые содержат в себе смесь обычных HTML -тэгов со специальной разметкой: открывающим тэгом :

Ruby: интерпретируемый, чистый ООП-язык

Ruby – динамический императивный объектно-ориентированный язык программирования, разработанный Юкихиро Матсумото . Ruby был создан под влиянием таких языков, как Perl , Eiffel и Smalltalk .

Он характеризуется динамической типизацией и автоматическим управлением памятью. Язык Ruby используется в веб-разработке в составе открытого веб-фреймворка Rails , чаще называемого Ruby on Rails ( RoR ):

Преимущества Ruby:

  • открытая разработка;
  • работает на многих платформах;
  • может внедряться в HTML -разметку;
  • относится к языкам программирования сверхвысокого уровня ( VHLL ), то есть обладает высоким уровнем абстракции и предметным подходом в реализации алгоритмов;
  • реализует концептуально чистую объектно-ориентированную парадигму;
  • предоставляет продвинутые методы манипуляции строками и текстом;
  • легко интегрирует в свои программы высокопроизводительные серверы баз данных ( DB2, MySQL, Oracle и Sybase );
  • благодаря VHLL программы на Ruby хорошо масштабируются и легко сопровождаются;
  • простой и чистый синтаксис значительно облегчает программистам первые шаги в обучении этому языку;
  • имеется простой программный интерфейс для создания многопоточных приложений;
  • имеет продвинутые средства для работы с массивами;
  • возможности языка можно расширить при помощи библиотек, написанных на C или Ruby ;
  • зарезервированные слова могут являться идентификаторами, если это не создаёт неоднозначности для парсера;
  • дополнительные возможности для обеспечения безопасности;
  • встроенный отладчик.

Недостатки Ruby:

  • обучение языку выше начального уровня может оказаться непростым;
  • информационных ресурсов, посвящённых Ruby , явно недостаточно;
  • Ruby менее производителен по сравнению со многими другими языками, применяемыми в веб-разработке;
  • Ruby относительно медленно разрабатывается и развивается.

Проекты, использующие Ruby:

  • Google SketchUp ;
  • 37signals ;
  • GitHub ;
  • Shopify ;
  • Indiegogo ;
  • Basecamp .

Популярность

Согласно официальному сайту Ruby , этот язык входит в десятку наиболее популярных языков программирования. Рост популярности самого языка обусловлен популярностью программных продуктов, написанных на Ruby , в особенности RoR .

Использование

Файлы программ, написанных на Ruby , имеют расширение .rb . Эти файлы можно запустить как скрипты командной оболочки при помощи интерпретатора. Например, учитывая, что интерпретатор Ruby находится в /usr/bin :

Python: язык программирования общего назначения

Python широко применяется как интерпретируемый язык для скриптов различного назначения (хотя существуют и трансляторы языка Python ).

Как и Ruby , Python имеет целью приблизить синтаксис реальной программы, написанной на нём, к описывающему задачу псевдокоду, что позволяет программисту уменьшить объём программы. Идея создания данного языка возникла в конце 1980-х и была реализована Гвидо ван Россумом .

Элегантный дизайн и эффективный, дисциплинирующий синтаксис этого языка облегчают программистам совместную работу над кодом. Python – мультипарадигмальный язык программирования: он позволяет совмещать процедурный подход к написанию кода с объектно-ориентированным и функциональным:

Преимущества Python:

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

Недостатки Python:

  • не слишком удачная поддержка многопоточности;
  • на Python создано не так уж много качественных программных проектов по сравнению с другими универсальными языками программирования, например, с Java ;
  • отсутствие коммерческой поддержки средств разработки (хотя эта ситуация со временем меняется);
  • изначальная ограниченность средств для работы с базами данных;
  • бенчмарки показывают меньшую производительность Python по сравнению с основными Java VM , что создаёт этому языку репутацию медленного.

Проекты с использованием Python:

  • Yahoo Maps ;
  • Zope Corporation ;
  • Linux Weekly News ;
  • Shopzilla ;
  • Ultraseek .

Популярность

Согласно Wikipedia , Python прочно вошёл в 8 наиболее популярных языков программирования по версии TIOBE Programming Community Index . А если не считать отдельно языки с C-подобным синтаксисом ( C++, C#, ObjectiveC, Java и т. д.), то Python является третьим по популярности языком.

Использование

Интерпретатор python можно использовать как для запуска скриптов, так и в режиме интерактивной оболочки.

Наберите в командной строке:

Потребность в специалистах

Основываясь на анализе Jobs Tractor , учитывающем более 45000 вакансий разработчиков, опубликованных в Twitter за последний год, потребность в программистах такова:

  • PHP – требуется 8238 человек;
  • Ruby – 2937 человек;
  • Python – 1587 человек.

Разумеется, статистика – не единственный фактор, который стоит принимать во внимание при изучении языка программирования.

Какой же язык программирования стоит изучать?

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

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

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

Развитые фреймворки, включающие в себя функции для работы с пользовательскими данными (статьями, темами, постами, фотографиями и т. д.) называются фреймворками управления контентом ( Content Management Framework – CMF ).

Если добавить к этому элементы интерфейса для конечного пользователя сайта, получается так называемая система управления контентом или CMS ( Content Management System ). CMS позволяет получить сайт с прототипом интерфейса и минимальной функциональностью сразу после установки или после определённой настройки, то есть вообще без программирования.

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

Для PHP разработано много фреймворков и CMS . Вы вполне можете начать работать с какими-то CMS , даже не имея понятия о веб-программировании. Наиболее популярными CMS являются WordPress , Joomla и Drupal .

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

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

В случае с Python , из множества фреймворков наиболее популярными являются Django и CherryPy . Они дают наиболее полный набор средств для веб-разработки « из коробки ».

Если вы решили заняться Ruby , то ваш выбор более очевиден: Rails является основным средством веб-разработки на этом языке, хотя существуют и другие, существенно менее популярные фреймворки.

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

Резюмируя сказанное:

  • PHP – лучший язык для создания динамических веб-страниц;
  • Python – универсальный язык программирования, при помощи которого можно делать любые приложения в диапазоне от интернет-сайтов и десктопных приложений до роботов и системных сервисов;
  • Ruby – наиболее высокоуровневый язык, позволяющий вам уделять меньше внимания деталям интерфейса и организации хранения данных, чтобы сосредоточиться на прикладной задаче.

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

Данная публикация представляет собой перевод статьи « PHP vs Ruby vs Python: Three Programming Languages in a Nutshell » , подготовленной дружной командой проекта Интернет-технологии.ру

Создание модуля Python на Go

Введение

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

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

В последнее время я работал над продуктом TachoBI для анализа карт тахографа и котнроля режима труда и отдыха водителей, который базируется на ERP системе с открытым исходным кодом Odoo. Так как этот продукт ориентирован на конечных пользователей, то полностью распространять всю систему в исходниках идея не очень и я начал думать, как это можно исправить. Первая идея была написать модули на С и распространять в виде библиотеки к Python приложению, но так как сроки поджимали, а функциональноть была объемная, то эту затею я оставил и стал искать другое решение. Как-то мне пришла идея, а нельзя ли скрестить Python и Go, так как скорость разработки и подерживаемость кода находятся приблизительно на одном уровне. Такое решение было найдено, но без С все-таки не обошлось.

Задача

В качестве примера для иллюстрации я выбрал простую задачку. Пусть на вход в функцию подается строка и ненулевое число, а на выходе получается их конкатенация. Например: “строка” + 1 = “строка1”.

Так как оба языка работают с С, то их взаимодействие мы построим через питоновкую С-шную библиотеку, а к ней с помощью CGO присоединим функцию на Go. Для работы используются Go 1.8 и Python 2.7.

Подготовка функции на Go

Итак файл lib.go, в котором будет функция, выполняющая нашу задачу будет выглядеть вот так:

Подготовка C библиотеки для Python

В стандартной документации по Python описано как можно создавать для него C-ные модули. Наша библиотека будет называться test_lib, поэтому скелет нашего модуля будет храниться в файле test_lib.go со следующим содержимым:

Здесь весь С-ный код находится в блоке комментария /**/ , перед импортом “C”. Такой блок называется преамбулой и используется при компиляции С частей пакета. Переменные и функции из преаумбулы можно вызывать в gо коде. Между импортом и комментарием не должно быть пробелов. Подробнее можно посмотреть в документации CGO.

Давайте разберемся что делает преамбула.

Сначала мы присоединяем заголовочный файл Python.h, чтобы получить возможность работать с питоновскими объектами. Затем мы создаем объекты для обработки ошибок test_lib_error и нашей будующей функции Concat , которая и будет реализовывать нашу задачу. Через них будет происходить общение с go-ным кодом.

Функция Parse_Args будет описана ниже. Далее объявляем массив test_lib_methods , который содержит таблицу методов реализуемых расширением, в формате <название, функция, параметры, описание>.

Затем инициализируем модуль функцией inittest_lib .

Для того чтобы пробросить текс ошибки из Go в питоновское исключение, создается функция setException . Которая в C-ную переменную test_lib_error передаст текст, который получит на входе.

Объедиение созданной библиотеки с Go функцией

Мы выполнили все необходимые приготовления, и теперь нам осталось связать нашу функцию sum , с функцией Concat в нашей библиотеке. Для этого в файл lib.go необходимо добавить следующий код:

Как видно тут в преамбуле мы указываем функцию Parse_Args , которая была объявлена в файле test_lib.go, с ее помощью мы поместим входные параметры в соответствующие переменные для дальнешей работы.

Преамбуда //export указывает на то, что мы можем использовать эту функцию в коде на С (в файле test_lib.go), в котором она инициализируется добавляется в таблицу функций.

Посмторим что происходит в самой функции. Сначала инициализируются переменные с С-ными типами (различны с типами в Go), затем эти переменные инициализируются входными параметрами, и если опрерация не удалось будет выбрасываться питоновский Exception. Если все прошло нормально и входные параметры мы получили, вызываем нашу функцию sum для проведения операции. Надо обратить внимание, что перед тем как передать входные параметры в функцию они из С-ных типов приводятся к типам в Go.

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

Сборка и проверка

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

А проверить можно выполнив команду

P.S. на последней версии MacOS Siera данная операция не выполняется, и пока мне не удалось разобраться почему.

Заключение

Касательно моей основной задачи перевести весь код с Python на Go не заняло у меня много времени. А получившее решение было более чем работоспособным. Кроме того необходимо отметить что такми образом можно использовать функциональность горутин в Python об этом указано в статье[1], но сам я данную штутку не пробывал. Весь исходный код примера лежит можно увидеть на github.

Мой путь от Python к Go — делюсь советами и ресурсами

От переводчика: перевели для вас статью Илада Леева о переходе с Python на Go. Статья будет полезна не только начинающим программистам, но и всем, кто так либо иначе интересуется Go.

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

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

Напоминаем: для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».

Наблюдения

Первое, что я сделал в начале пути, — изучил отличный официальный туториал “Tour Of Go”. Он дает понимание синтаксиса языка.

Для того чтобы улучшить знания, я прочитал еще и книгу “Go for Python Programmers”, которая позволила приступить к следующему этапу — пробам и ошибкам.

Я взял привычные функции, которые использовал в Python (сериализация JSON или работа с HTTP-вызовами), и попробовал написать их на Go. Благодаря такому наглядному сравнению мне удалось выявить ключевые отличия между языками.

Прежде всего, Python не требует специфической иерархии каталогов, тогда как Go — да.

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

Официальный туториал “How to Write Go Code” объясняет, как организовать свою работу.

Статическая строгая типизация

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

Нет сомнений, что динамические языки сильнее подвержены ошибкам, со стороны разработчика требуется больше усилий при проверке входных данных. Пример — функция, которая вычисляет сумму двух целых чисел. Если передать строку в функцию (что случается не так уж и редко), то это приведет к ошибке TypeError.

В Go такое произойти не может, поскольку здесь нужно объявлять тип для каждой переменной и функции и то, какой тип переменной функция вернет.

Сначала это раздражает: мне казалось, что эта особенность Go замедляет работу, — но потом пришло понимание, что на самом деле объявление всего экономит время, а вероятность ошибки снижается.

У Go есть нативная поддержка параллелизма с использованием подпрограмм и каналов — это удобно.

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

Вот визуализация всего сказанного от Ивана Данилюка.

Больше примеров здесь и здесь.

Ну, json.loads() больше нет. В Python все просто: используем json.loads, и нет проблем.

Но в Go, статически типизированном языке, эта операция становится сложнее.

Здесь при использовании JSON все заранее определено. Любое поле, которое не вписывается в заданную структуру, будет игнорироваться, и это хорошо. Об этом можно думать как о заранее согласованном протоколе между двумя сторонами. Данные, которые вы получили в JSON, должны быть ожидаемы, а поля и типы JSON «согласованы» обеими сторонами.

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

Декодирование JSON на GO лучше всего объясняется в этом посте или здесь.

Ленитесь конвертировать ваш JSON в Go-структуру? Нет проблем, этот инструмент все сделает за вас.

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

Вам нет дела до переменных? Окей! Просто используйте _ (подчеркивание) и назначьте его пустому идентификатору.

Мастрид-туториалом для этой части работы с языком является информация из “Effective Go”.

Поиск подходящей библиотеки и фреймворков

Я использовал с Python фреймворки и библиотеки вроде Flask, Jinja2, Requests и даже Kazoo, поэтому боялся, что не найду ничего подходящего для Go.

Но комьюнити уже решило эти проблемы: у языка есть собственные уникальные библиотеки, которые позволяют полностью забыть о том, что вы использовали ранее.

Вот мои фавориты.

Python Requests => net/http

net/http предоставляет удобную и легкую в использовании реализацию HTTP-клиента и сервера.

Flask + Jinja2 => Gin

Gin — веб-фреймворк HTTP с очень простым API: параметрами в пути, загружаемыми файлами, маршрутизацией групп (/ api / v1, / api / v2), пользовательскими форматами журналов, обслуживающими статические файлы, рендерингом HTML и действительно мощным кастомным middleware.
Оцените этот бенчмарк.

CLI Creation => Cobra

Cobra — библиотека для создания мощных CLI-приложений, а также программа для генерации приложений и командных файлов.
Cobra применяется во многих крупных Go-проектах, включая Kubernetes, etcd и OpenShift.

Вот еще несколько библиотек, которые я настоятельно рекомендую: Viper, Gonfig и этот потрясающий список — Awesome-Go.

Другие полезные ресурсы

Подводим итоги

Будучи постоянным пользователем Python в течение пяти лет, я боялся, что переход на Go будет болезненным.

Но нет: есть наработки сообщества Go, которое расширяет и дополняет возможности языка, а также различные полезные ресурсы, которые помогут с переходом и вам.

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

Мастер Йода рекомендует:  Введение в мобильную разработку для Android с каких языков начать изучение
Добавить комментарий