Эта глава проект от моей предстоящей книги От одного до нуля Чтобы появиться в 2021 году с ностархом, научит вас и как писать чистый и простой код. Чтобы оставаться настроенными о выпуске книги, подписаться на Академия кодирования электронной почты Finxter (это бесплатно)!
Написать Clean & Simple Code
История : Я научился сосредоточиться на написании чистого кода тяжело. Одним из моих исследовательских проектов в течение моего времени в качестве докторского научного сотрудника в распределенных системах было кодировать распределенную систему обработки графика с нуля. Система позволила вам запустить алгоритмы диаграммы, такие как вычисление кратчайшего пути на большой карте в распределенной среде для ускорения вычислений среди нескольких машин. Если вы когда-либо написали распределенное приложение, в котором два процесса, которые находятся на разных компьютерах взаимодействуют друг с другом через сообщения, вы знаете, что сложность может быстро стать подавляющей. Мой код имел тысячи строк кода, и ошибки часто появились. Я не продвинулся в течение нескольких недель одновременно – это было очень разочаровывающим. Теоретически, понятия, которые я разработал, звучал великолепно и убедительно. Но практика достала меня! Наконец, через месяц или настолько работающий полный рабочий день на базе кода, не видя какого-либо обнадеживающего прогресса, я решил радикально упростить базу кода. Я начал использовать библиотеки вместо кодирования функций самостоятельно. Я удалил большие кодовые блоки преждевременных оптимизаций (см. Позже). Я удалил блоки кода, которые я прокомментировал возможное позже. I Refactowed переменные и имена функций. Я структурировал код в логических единицах и классах. И, через неделю или около того, был не только мой код более читаемым и понятенным другими исследователями, он также был более эффективным и менее багги. Мне удалось снова добиться прогресса, и мое расстройство быстро превратилось в энтузиазм-чистый код, спасал мой исследовательский проект!
Сложность : В предыдущих главах вы узнали, как вредная сложность предназначена для любого кодового проекта в реальном мире. Сложность убивает вашу производительность, мотивацию и время. Потому что большинство из нас не научились говорить в исходном коде из раннего возраста, он может быстро сокрушить наши познавательные способности. Чем больше у вас код, тем более подавляющее это становится. Но даже короткие кодовые фрагменты и алгоритмы могут быть сложными. Следующий фрагмент кода одноклассника из нашей книги Python One-listers Это отличный пример куска исходного кода, который короткий и лаконичный, но все еще сложный!
# Quicksort algorithm to sort a list of integers
unsorted = [33, 2, 3, 45, 6, 54, 33]
q = lambda l: q([x for x in l[1:] if x <= l[0]]) + [l[0]] +
q([x for x in l if x > l[0]]) if l else []
print(q(unsorted))
# [2, 3, 6, 33, 33, 45, 54]
Вы можете найти объяснение этого фрагмента кода в нашей книге Python One-listers или онлайн на https://blog.finxter.com/python-one-line-vicksort/ Отказ
Сложность происходит от многих направлений при работе с исходным кодом. Он замедляет наше понимание кода. И это увеличивает количество ошибок в нашем коде. Оба медленного понимания, так и большего количества ошибок повышают затраты на проекту и количество часов людей, необходимых для его завершения. Роберт С. Мартин, автор книги Чистый код , утверждает, что тем сложнее прочитать и понимать код, тем выше расходы на запись кода также:
«Действительно, соотношение времени, потраченное на чтение по сравнению с письмом, более 10 к 1. Мы постоянно читаем старый код как часть усилий, чтобы написать новый код… [следовательно,] облегчает чтение, облегчает запись. “ – Роберт С. Мартин
Эти отношения визуализируются в Рисунок 5-1 Отказ Ось X соответствует количеству строк, написанных в данном кодовом проекте. Ось Y соответствует времени для записи одной дополнительной строки кода. В общем, чем больше кода вы уже написали в одном проекте, тем больше времени требуется, чтобы написать дополнительную строку кода. Это почему? Скажем, вы написали N строки кода, и вы добавляете n + 1 st линия кода. Добавление этой строки может возникнуть потенциально все ранее написанные строки. Может иметь небольшой штраф производительности, который влияет на общий проект. Это может использовать переменную, которая определяется в другом месте. Он может ввести ошибку (с вероятностью C ) и найти эту ошибку, вы должны искать весь проект (Итак, ваши ожидаемые расходы на строку кода – C * T (N) для неуклонно Увеличение функции T с увеличением ввода n ). Это может заставить вас писать дополнительные строки кода, чтобы обеспечить обратную совместимость. Есть еще много причин, но вы получаете точку: дополнительная сложность заставляет замедлить ваш прогресс, тем больше написанного вами кода.
Рисунок 5-1: Чистый код улучшает масштабируемость и обслуживание вашей кодовой базы.
Но рисунок 5-1 также показывает разницу между записью грязных против чистого кода. Если написание грязного кода не приведет к любой выгоде, никто не сделает этого! Существует очень реальное преимущество записи грязного кода: в краткосрочной перспективе он меньше времени, а для небольших кодовых проектов. Если вы заправляете все функциональные возможности в 100-строчной кодовой скрипте, вам не нужно много времени вкладывать много времени и структурирования вашего проекта. Но, как вы добавите все больше и больше кода, файл монолитного кода вырастает от 100 до 1000 строк и в определенной точке будет гораздо менее эффективным по сравнению с более вдумбимым подходом, в котором вы структурируете код логически в разных модулях, классах, или файлы. Как правило, старайтесь всегда писать вдумчивый и чистый код – потому что дополнительные расходы на мышление, рефакторинг и реструктуризация еще много времени заплатит за любой нетривиальный проект. Кроме того, чистый код записи – это просто правильная вещь. Философия тщательно создания вашего программирования искусства будет продолжать вас в жизни.
Вы не всегда знаете последствия вашего кода второго порядка. Подумайте о космическом корабле на миссии в направлении Венеры в 1962 году, где крошечная ошибка – упущение дефиса в исходном коде, вызвало инженеров NASA, чтобы выпустить команду самоуничтожения, которая привела к убытке ракеты на сумму более 18 миллионов долларов на время.
Чтобы смягчить все эти проблемы, есть простое решение: Напишите более простой код. Простой код менее подвержен ошибкам, менее переполнен, проще понять и проще поддерживать. Это веселее читать и писать. Во многих случаях это более эффективно и занимает меньше места. Это также облегчает масштабирование вашего проекта, потому что люди не будут напуганы сложностью проекта. Если новые кодировщики заглядывают в ваш код, чтобы увидеть, хотят ли они внести свой вклад, они лучше верят, что они могут понять это. С простым кодом все в вашем проекте станет проще. Вы сделаете более быстрый прогресс, получить больше поддержки, потратьте меньше времени отладки, будьте более мотивированы и иметь больше удовольствия в процессе.
Итак, давайте узнаем, как написать чистый и простой код?
Чистый код элегантный и приятный для чтения. Он сосредоточен в том смысле, что каждая функция, класс, модуль фокусируется на одной идее. Функция Transfer_Funds (A, B) В вашем банковском приложении только это передает средства со счета А Для учетной записи B Отказ Это не проверяет кредит отправителя А – для этого есть другая функция check_credit (a) Отказ Просто, но легко понять и сосредоточиться. Как вы получаете простой и чистый код? Потратив время и усилия, чтобы редактировать и пересмотреть код. Это называется рефакторингом, и он должен быть запланированным и важным элементом вашего процесса разработки программного обеспечения.
Давайте погрузимся в некоторые принципы для написания чистого кода. Пересматривайте их время от времени – они будут значимыми рано или поздно, если вы участвуете в некоторых реальных проектах.
Принципы для записи чистого кода
Далее вы собираетесь узнать ряд принципов, которые помогут вам написать чистый код.
Принцип 1: Вы не будете нуждаться в этом
Принцип предполагает, что вы никогда не должны реализовать код, если вы только ожидаете, что вам нужно, чтобы вы когда-нибудь нуждаетесь в его предоставленной функциональности в будущем – потому что вам это не понадобится! Вместо этого напишите код только в том случае, если вы на 100% уверены, что вам это нужно. Код для сегодняшних потребностей и не завтра.
Это помогает подумать от первых принципов: простейший и чистый код – это пустой файл. У него нет ошибок, и это легко понять. Теперь иди оттуда – что вам нужно добавить к этому? В главе 4 вы узнали о минимальном жизнеспособном продукте. Если вы минимизируете количество функций, которые вы преследуете, вы будете убирать более чистые и более простые код, чем вы могли бы когда-либо достичь методов рефакторинга или все остальные принципы объединены. Как вы знаете, о том, что оставив свои функции не только полезны, если они не нужны. Оставляя их даже имеет смысл, если они обеспечивают относительно небольшое значение по сравнению с другими функциями, которые вы могли бы вместо этого. Стоимость возможностей редко измерена, но чаще всего они очень важны. Только потому, что функция предоставляет некоторые преимущества не оправдывают его реализацию. Вам нужно действительно нужна функция, прежде чем даже рассмотреть ее реализацию. Пожимайте низкосовесные фрукты сначала до того, как вы достигнете выше!
Принцип 2: принцип наименее удивления
Этот принцип является одним из золотых правил эффективного приложения и дизайна пользователей. Если вы открываете поисковую систему Google, курсор будет уже сосредоточен на поле ввода поиска, чтобы вы могли начать вводить слово поиск прямо сейчас, не требуя, чтобы нажать на поле ввода. Не удивительно вообще – но отличный пример принципа наименее удивления. Чистый код также использует этот принцип дизайна. Скажем, вы пишете конвертер валют, который преобразует ввод пользователя с USD на RMB. Вы храните ввод пользователя в переменной. Какое имя переменной лучше подходит, user_input или var_x ? Принцип наименее удивления отвечает на этот вопрос для вас!
Принцип 3: не повторяйся
Не повторяйте себя (сухой) – это широко признанный принцип, который подразумевает, что если вы пишете код, который частично повторяется – или это даже копирование и вставляется из вашего собственного кода – это знак плохого стиля кодирования. Отрицательный пример – следующий код Python, который печатает одну и ту же строку пять раз в оболочку:
print('hello world')
print('hello world')
print('hello world')
print('hello world')
print('hello world')Код повторяется, поэтому принцип предполагает, что будет лучший способ написания его. И есть!
for i in range(5):
print('hello world')
Код гораздо короче, но семантически эквивалентна. В коде нет избыточности.
Принцип также показывает вам, когда создать функцию и когда это не требуется для этого. Скажем, вам нужно преобразовать мили в километры в несколько экземпляров в вашем коде (см. Листинг 5-1 ).
miles = 100 kilometers = miles * 1.60934 # ... # BAD EXAMPLE distance = 20 * 1.60934 # ... print(kilometers) print(distance) ''' OUTPUT: 160.934 32.1868 '''
Листинг 5-1: Преобразовать мили до километров дважды.
Принцип Не повторяйте себя предполагает, что было бы лучше написать функцию Miles_to_km (миль) Однажды, а не выполнять одно и то же конвертацию явно в коде несколько раз (см. Листинг 5-2 ).
def miles_to_km(miles):
return miles * 1.60934
miles = 100
kilometers = miles_to_km(miles)
# ...
distance = miles_to_km(20)
# ...
print(kilometers)
print(distance)
'''
OUTPUT:
160.934
32.1868
'''
Листинг 5-2: Использование функции для преобразования миль до километров.
Таким образом, код проще для обслуживания, вы можете легко увеличить точность преобразования впоследствии без поиска кода для всех экземпляров, где вы использовали методологию неточной преобразования. Также легче понимать для человеческих читателей вашего кода. Нет сомнений в целях функции miles_to_km (20) Хотя вам, возможно, придется задуматься о целях вычисления 20 * 1.60934.
Принцип Не повторяйте себя часто сокращается как сухие и нарушения его как мокрых: Нам нравится печатать , Писать
Принцип 4: код для людей не машин
Основная цель исходного кода состоит в том, чтобы определить, какие машины должны делать и как это сделать. Тем не менее, если это было единственным критерием, вы бы использовали язык машины низкого уровня, такой как ассемблер для достижения этой цели, потому что это самый выразительный и самый мощный язык. Целью высокого уровня языков программирования, таких как Python, заключается в том, чтобы помочь людям писать лучший код и сделать это быстрее. Наш следующий принцип для чистого кода – постоянно напоминать себе, что вы пишете код для других людей, а не для машин. Если ваш код будет иметь какое-либо влияние в реальном мире, он будет читать несколько раз или программист, который требует ваше место, если вы перестанете работать на базе кода. Всегда предполагайте, что ваш исходный код будет прочитан другими людьми. Что вы можете сделать, чтобы облегчить свою работу? Или, чтобы положить его проще: что вы можете сделать, чтобы смягчить негативные эмоции, которые они будут испытывать против оригинального программиста кодовой базы их работы? Код для людей не машин!
Что это значит на практике? Есть много последствий. Прежде всего, используйте значимые имена переменной. Листинг 5-3 Показывает отрицательный пример без значимых имен переменной.
# BAD
xxx = 10000
yyy = 0.1
zzz = 10
for iii in range(zzz):
print(xxx * (1 + yyy)**iii)
Листинг 5-3: Пример записи кода для машин.
Угадайте: что вычисляет код?
Давайте посмотрим на семантически эквивалентный код в Листинг 5-4 Это использует значимые имена переменной.
# GOOD
investments = 10000
yearly_return = 0.1
years = 10
for year in range(years):
print(investments * (1 + yearly_return)**year)
Листинг 5-4: Использование функции для преобразования миль до километров.
Имена переменной указывают на то, что вы рассчитываете стоимость первоначальных вложений 1000, усугубляемых в течение 10 лет, принимая годовой доход от 10%.
Принцип для записи кода имеет много дополнительных приложений. Это также относится к отступам, пробелам, комментариям и длина линии. Чистый код радикально оптимизирует для чистябольности человека. Как Martin Fowler, международный эксперт по программному обеспечению и автору популярной книжной рефакторинга, утверждает:
«Любой дурак может написать код, который может понять компьютер. Хорошие программисты пишут код, которые могут понять, что люди могут понять».
Принцип 5: стоять на плечах гигантов
Там нет значения при изобретении колеса. Программирование представляет собой десятилетие, и лучшие кодерации в мире дали нам большое наследие: коллективную базу данных миллионов тонко настроенных и хорошо проверенных алгоритмов и функций кода. Доступ к коллективной мудрости миллионов программистов так же просто, как и использование оператора Import One-Liner. Вы будете безумие не использовать эту сверхдержаву в своих собственных проектах. Помимо простых в использовании, использование библиотечного кода, вероятно, улучшит эффективность вашего кода, поскольку функции, которые использовались тысячами кодеров, как правило, намного оптимизированы, чем ваши собственные функции кода. Кроме того, библиотечные вызовы легче понимать и принимать меньше места в вашем проекте кода. Например, если вам понадобится алгоритм кластеризации, чтобы визуализировать кластеры клиентов, вы можете либо реализовать его самим или стоять на плечах гигантов и импортировать алгоритм кластеризации из внешней библиотеки и передавать ваши данные в него. Последнее гораздо больше времени эффективно – вы займете гораздо меньше времени, чтобы реализовать ту же функциональность с меньшим количеством ошибок, меньшего пространства и более качественного кода. Библиотеки являются одной из главных причин, по которым мастер-коды могут быть в 10 000 раз более продуктивными, чем средние кодеры.
Вот два-лайнер, который импортирует модуль KMAINS из библиотеки Python Scikit-Sulect Python, а не нарисованный колесо:
from sklearn.cluster import KMeans kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
Если вы хотите реализовать k, означает алгоритм, это займет у вас несколько часов и 50 строк кода – и он загромочет вашу кодовую основу, чтобы весь будущий код станет сложнее для реализации.
Принцип 6: Используйте правильные имена
Ваши решения о том, как назвать свои функции, функциональные аргументы, объекты, методы и переменные раскрывают независимо от того, являются ли вы начинающим, промежуточным или экспертом. Как? На любом языке программирования существует множество обоснованных конвенций, которые используются всеми опытными кодерами. Если вы их нарушаете, он немедленно рассказывает читателю вашу кодовую базу, что у вас не было много опыта с практическими проектами кода. Чем больше таких «рассказывает» существует в вашем коде, тем менее серьезным будет читатель вашего кода.
Есть много явных и неявных правил, регулирующих правильное название ваших элементов кода. Эти правила могут даже отличаться от языка программирования к языку программирования. Например, вы будете использовать CamelcaSenaming Для переменных на языке программирования Java, пока вы будете использовать underscore_naming в питоне. Если вы начнете использовать чехол на верблюда в Python, все сразу увидят, что вы начинающий Python. Пока вам нельзя понравиться, это не очень большая проблема, которую нужно восприниматься как новичок – все были один в один момент времени. Далеко хуже состоит в том, что другие кодеры будут негативно удивлены при чтении их кода. Вместо того, чтобы думать о том, что делает код, они начинают думать о том, как ваш код написан. Вы знаете, что принцип наименьшего сюрприза – нет никакой ценности в удивительных других кодерах, выбрав нетрадиционные имена переменных.
Итак, давайте погрузимся в список правила именования больших пальцев, вы можете рассмотреть при написании исходного кода. Это ускорит вашу способность узнать, как писать чистые кодовые имена. Тем не менее, лучший способ учиться – это изучить кодекс людей, которые лучше вас. Прочитайте множество программированных учебных пособий, присоединитесь к сообществу StackoverView и проверить код GitHub проектов с открытым исходным кодом.
- Выберите описательные имена. Скажем, вы создаете функцию для преобразования валют от USD на EUR в Python. Назовите это
USD_TO_EUR (сумма)а неf (x)Отказ - Выберите однозначные имена. Вы можете подумать, что
dollar_to_euro (сумма)Было бы хорошее название для ранее обсуждаемой функции. Пока это лучше, чемf (x), это хуже, чемUSD_TO_EUR (сумма)Потому что он вводит ненужную степень двусмысленности. Вы имеете в виду мы, канадский или австралийский доллар? Если вы в США, ответ может быть очевиден для вас. Но австралийский кодер может не знать, что код написан в США и может взять на себя другой выход. Минимизируйте эти смущения! - Используйте произношенные имена. Большинство кодеров подсознательно читают код, произнося его в уме. Если они не могут сделать это подсознательно, потому что имя переменной является непрограммой, проблема расшифровки имени переменной принимает свое ценное внимание. Они должны активно думать о возможных способах разрешения неожиданного именования. Например, имя переменной
cssmr_lstМожет быть описательным и однозначным, но он не произносится. Выбор имени переменнойCustomer_ListСтоит дополнительное пространство в вашем коде! - Используйте именованные константы, не волшебные числа Отказ В вашем коде вы можете использовать магическое число 0,9 несколько раз, чтобы преобразовать сумму в долларах США на сумму в евро. Тем не менее, читатель вашего кода, включая ваше будущее, которое перечитает ваш собственный код – должен думать о цели этого номера. Это не самоуверенно. Гораздо лучший способ обрабатывать этот «магический номер» 0,9 – хранить его в переменной
Conversion_rate.9И используйте его как фактор в ваших вычислениях преобразования. Например, вы можете затем рассчитать свой доход в евро какдоход_уро * доход_узОтказ Таким образом, их не волшебный номер в вашем коде, и он становится более читаемым.
Это только некоторые из конвенций именования. Опять же, чтобы выбрать конвенции, лучше всего Google их один раз (например, «Соглашения о именовании Python») и изучают проекты кода GitHub от экспертов в вашем поле.
Принцип 7: Принцип одностороннего ответственности
Принцип одной ответственности означает, что каждая функция имеет одну основную задачу. Функция должна быть маленькой и делать только одну вещь. Лучше иметь много маленьких функций, чем одна большая функция, делая все одновременно. Причина проста: инкапсуляция функциональности снижает общую сложность в вашем коде.
Как правило, Каждый класс и каждая функция должны иметь только одну причину для изменения. Если есть несколько причин для изменения, несколько программистов хотели бы изменить один и тот же класс одновременно. Вы смешали слишком много ответственности в своем классе, и теперь он становится грязным и загроможденным.
Давайте рассмотрим небольшие примеры, используя код Python, который может работать на устройстве Reader для моделирования и управления опытом чтения пользователя (см. Листинг 5-5 ).
class Book:
def __init__(self):
self.title = "Python One-Liners"
self.publisher = "NoStarch"
self.author = "Mayer"
self.current_page = 0
def get_title(self):
return self.title
def get_author(self):
return self.author
def get_publisher(self):
return self.publisher
def next_page(self):
self.current_page += 1
return self.current_page
def print_page(self):
print(f"... Page Content {self.current_page} ...")
python_one_liners = Book()
print(python_one_liners.get_publisher())
# NoStarch
python_one_liners.print_page()
# ... Page Content 0 ...
python_one_liners.next_page()
python_one_liners.print_page()
# ... Page Content 1 ...
Листинг 5-5: Моделирование класса книг с нарушением единственного принципа ответственности – класс книги отвечает за моделирование данных, так и для представления данных. У него есть две обязанности.
Код в Листинг 5-5 Определяет класс Книга С четырьмя атрибутами: название, автор, издатель и текущий номер страницы. Вы определяете методы Getter для атрибутов, а также несколько минимальных функций для перемещения на следующую страницу. Функция next_page () Может быть вызван каждый раз, когда пользователь нажимает кнопку на устройстве для чтения. Другая функция print_page () отвечает за печать текущей страницы на устройство для чтения. Это дается только как заглушка, и он будет более сложным в реальном мире. Хотя код выглядит чистым и простым, оно нарушает единственный принцип ответственности: классная книга отвечает за моделирование таких данных, как содержание книги, но он также несет ответственность за печать книги на устройство. У вас есть несколько причин для изменения. Возможно, вы захотите изменить моделирование данных книги, например, используя базу данных вместо файлового метода ввода/вывода. Но вы также можете захотеть изменить представление моделированных данных, например, используя другую схему форматирования книги на экранах другого типа. Моделирование и печать – это две разные функции, инкапсулируемые в одном классе. Давайте изменим это в Листинг 5-6 !
class Book:
def __init__(self):
self.title = "Python One-Liners"
self.publisher = "NoStarch"
self.author = "Mayer"
self.current_page = 0
def get_title(self):
return self.title
def get_author(self):
return self.author
def get_publisher(self):
return self.publisher
def get_page(self):
return self.current_page
def next_page(self):
self.current_page += 1
class Printer:
def print_page(self, book):
print(f"... Page Content {book.get_page()} ...")
python_one_liners = Book()
printer = Printer()
printer.print_page(python_one_liners)
# ... Page Content 0 ...
python_one_liners.next_page()
printer.print_page(python_one_liners)
# ... Page Content 1 ...
Листинг 5-6: Придерживаясь принципов одной ответственности – класс книги отвечает за моделирование данных, а класс печати отвечает за представление данных.
Код в Листинг 5-6 выполняет ту же задачу, но это удовлетворяет единственному принципу ответственности. Вы создаете как книгу, так и класс принтера. Класс книги представляет книгу META информацию и текущий номер страницы. Класс принтера печатает книгу на устройство. Вы передаете книгу, для которой вы хотите распечатать текущую страницу в метод Принтер.Print_page () Отказ Таким образом, моделирование данных и представление данных развязаны, и код становится легче поддерживать.
Вы хотите развивать навыки Хорошо округлый Python Professional То же оплачивается в процессе? Станьте питоном фрилансером и закажите свою книгу Оставляя крысиную гонку с Python На Amazon ( Kindle/Print )!
Рекомендации:
- https://code.tutsplus.com/tutorials/solid-part-1-the-single-responsibility-principle–net-36074
- https://en.wikipedia.org/wiki/Single-responsibility_principle
- https://medium.com/hackernoon/the-secret-behind-the-single-responsibility-principle-e2f3692bae25
- https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=8263157&casa_token=Ydc5j4wwdWAAAAAA:iywl9VJ_TRe_Q3x2F7-XOgKHvrnz7TuJhBQ8iDtsSVDv1WXTGN-bCSscP0WjSs7X7LVXJFGNfgM&tag=1
- https://raygun.com/blog/costly-software-errors-history/
Куда пойти отсюда?
Достаточно теории, давайте познакомимся!
Чтобы стать успешным в кодировке, вам нужно выйти туда и решать реальные проблемы для реальных людей. Вот как вы можете легко стать шестифункциональным тренером. И вот как вы польские навыки, которые вам действительно нужны на практике. В конце концов, что такое использование теории обучения, что никто никогда не нуждается?
Практические проекты – это то, как вы обостряете вашу пилу в кодировке!
Вы хотите стать мастером кода, сосредоточившись на практических кодовых проектах, которые фактически зарабатывают вам деньги и решают проблемы для людей?
Затем станьте питоном независимым разработчиком! Это лучший способ приближения к задаче улучшения ваших навыков Python – даже если вы являетесь полным новичком.
Присоединяйтесь к моему бесплатным вебинаре «Как создать свой навык высокого дохода Python» и посмотреть, как я вырос на моем кодированном бизнесе в Интернете и как вы можете, слишком от комфорта вашего собственного дома.
Присоединяйтесь к свободному вебинару сейчас!
Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.
Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python One-listers (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.
Его страсти пишут, чтение и кодирование. Но его величайшая страсть состоит в том, чтобы служить стремлению кодер через Finxter и помогать им повысить свои навыки. Вы можете присоединиться к его бесплатной академии электронной почты здесь.