This code does not execute properly try to figure out why перевод

Что не так с этим кодом? В чем его ошибка?

Что не так с этим кодом?
Код должен производить pacчeт траектории движeния капель щелока в excel. В vba к сожалению.

Что не так с этим кодом? Массивы
Подскажите, пожалуйста, что здесь неправильно. Дан массив из 20 элементов. Массив заполняется с.

Решение

Да я понимаю, просто сразу бы так и написал 🙂

То есть вопрос был в том чтоб обосрать каких-то ребят, которых вы называете «разработчики Ariane 5»?
Хотя не вы ТС.

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

Rius, кажись поцан сразу просек что там две строки, и конкатенировал их 😀

Rius, где Вы такие видео берете?

Добавлено через 35 секунд

Чаще лучше читать, а не говорить

Maksat333, Если уж хотите оставить этот код, то уж писали бы так:

Т.е., если код плохой, то он не становится хорошим просто из уважения к его автору. И наоборот.

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

Usaga, А что делать, когда иногда прилетает тз на проект, где кто-то наговнакодил до тебя, ты видешь эти тз, и начинаешь разводить холивары на тему, дайте мне переписать всё. Хотя там решение на 30 минут. Но тебе говорят, это не тот проект, чтобы на его тратить время. И в итоге ты мораешь свои руки, допиливаешь костыль(или нормальное что-то, так сказать цветочек на кучке гавнакода, но не факт), вроде как решаешь тз.
Кто должен тыкаться носом)?
А тот кто это начал, давно хз где =)

Добавлено через 2 минуты

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

Функции высшего порядка

Доброго времени суток.
Нужна помощь в решении задачи.

Определить функцию высшего порядка reduce2 (G,X,A), применение которой к списку одноразрядных целых чисел x=(x1 x2 … xk) выдает значение (g … (g (g a x1) x2) … xk). Например,
> Reduce2 (fun(Y,Z)-> (10*Y+Z) end, [1,2,3],0).
123 ; результат – число

Функции высшего порядка
Добрый день! Помогите кто чем может, пожалуйста. Нельзя использоваться стандартные возможности.

Erlang: Функции высшего порядка
Даны два списка X и Y. Список y является упорядоченным по некоторому правилу. Определить функцию.

Erlang: Функции высшего порядка
Пусть X – список элементов, а Y – список функций, с помощью которых можно получить числовые.

Erlang: Функции высшего порядка
Даны два списка: x=(x1 x2 … xp) – список элементов и y=(y1 y2 … yk) – список функций. Определить.

Решение

Книги: Чезарини Ф. Томпсон С. Программирование в Erlang
Бьярн Дэкер, Роберт Вирдинг Настольная книга по Erlang
Learn You Some Erlang for Great Good! (Изучай Erlang во имя добра!) Frederic Trottier-Hebert
— гуглите. Или на торрентах берите. Или покупайте. Всё есть.

Здравствуйте, пытаясь разобраться в вашем ответе возникли некоторые вопросы.
Шестая строка начинается с функции свертки F которая вычисляет в списке первый элемент X и остаток XS.
Вызывая эту же функцию (рекурсию reduce2) не понимаю что происходит при добавлении безымянной функции fun(Y,Z).
Пожалуйста объясните, что они означают?
Или X это Y и XS является Z?
Тогда мы в нашей новорекурсивно-безымянной функцией fun (Y,Z) вводим значения? какие? [1,2,3]?
Далее мы по моему предположению вызываем нами введенные данные в функции свертки F?
Остаток списка XS.
Получается остаток списка является [2,3]?
F(A,X)- результат выполнения функции F который станет новым значением A в следующей рекурсии.
Получается мы «прогнали» нашу рекурсию и оставшаяся последняя голова X нашего списка становится новым значением A?

Перевод «try to figure out why» на русский

попробуйте выяснить причину
poprobuyte vyyasnit’ prichinu

3 примеров, содержащих перевод

попытайтесь выяснить причину
popytaytes’ vyyasnit’ prichinu

2 примеров, содержащих перевод

попытаться выяснить, почему
popytat’sya vyyasnit’, pochemu

7 примеров, содержащих перевод

попытаться понять, почему
popytat’sya ponyat’, pochemu

5 примеров, содержащих перевод

пытаюсь понять, почему
pytayus’ ponyat’, pochemu

5 примеров, содержащих перевод

попробуем разобраться, почему
poprobuyem razobrat’sya, pochemu

4 примеров, содержащих перевод

попытайтесь выяснить, почему
popytaytes’ vyyasnit’, pochemu

3 примеров, содержащих перевод

попытаемся выяснить, почему
popytayemsya vyyasnit’, pochemu

2 примеров, содержащих перевод

попробуем выяснить, почему
poprobuyem vyyasnit’, pochemu

2 примеров, содержащих перевод

постараемся разобраться, почему
postarayemsya razobrat’sya, pochemu

2 примеров, содержащих перевод

пытаются выяснить, почему
pytayutsya vyyasnit’, pochemu

2 примеров, содержащих перевод

постарайтесь понять, почему
postaraytes’ ponyat’, pochemu

2 примеров, содержащих перевод

Выясните, почему
Vyyasnite, pochemu

The code doesn’t execute properly try to figure out why?

def multiply (a, b) : a * b

1/7/2018 8:13:49 AM

Give a link to the code. Otherwise, the code you have displayed has no error. Maybe you need to print or return the output as well.

.> https://www.sololearn.com/Discuss/227956/?ref=app https://www.sololearn.com/Discuss/226839/?ref=app»>Welcome to the fold of solving codewars intro question. >.> https://www.sololearn.com/Discuss/227956/?ref=app https://www.sololearn.com/Discuss/226839/?ref=app

okay thanks a lot

the only thing that could not work here is that you have to use propre indentation for the def block. Also you may have forgot the return key word to get the result of your multiply

Blog post: First Kata: «Multiply»

Okay as promised in my previous post additional Rust posts was possibly in the pipeline, I also mentioned Codewars.com and the katas I use for practice.

First kata: «multiply». The Kata problem was formulated as:

The code does not execute properly. Try to figure out why.

The original code, looked as follows:

Exit fullscreen mode

Here follows my solution, the solution in itself is not particularly interesting, but I can reflect on some of the things I learned from my solution (and possibly the failures leading up to the working solution)and I can spice it up with my approach to solving katas.

Exit fullscreen mode

The main function is just so you can run it from the command line, so the project was generated using cargo like so:

Exit fullscreen mode

This generated the src/main.rs file in a directory named: multiply containing the main function.

The main function is special: it is always the first code that runs in every executable Rust program

Now we have an idea about what function looks like in Rust. As described in the Rust cheatsheet:

Exit fullscreen mode

And as you have noticed, when generating an application with cargo you get a classical «hello world» example for free:

Exit fullscreen mode

Now lets skip the contents of the main function and look at the next function: multiply

Exit fullscreen mode

Using our newly obtained knowledge, we can read that the function is named «multiply»:

The two parameters are annotated with types: i32 which mean signed integer of size 32. The important lesson here is for me to understand two things.

As I described in my post on Learning Rust, there are good resources documenting Rust so if you want to have some details on i32 just look it up.

This lines uses our two operands, which match the parameters.

Here we can observe another Rust thing: the implicit return value, I would imagine that some people coming from other programming languages, find this a tad special. The implicit return value is the last value. You do not have to write an implicit return.

The same functionality exists in Perl, I must admit that I prefer explicit returns I am bit of an readability freak and I am not a huge fan of implicitness and magic in particular.

Out complete implementation of «multiply» end looking as follows:

Exit fullscreen mode

When you work on katas on Codewars.com, most katas hold unit-tests for testing your solution. The original tests for this kata looks as follows.

Exit fullscreen mode

You could do TDD and write a lot of tests for observing that your code works and I encourage doing this.

The test suite can be run using cargo

Exit fullscreen mode

I will not go into tests in this post, since our focus is on something else, the basic test structure is simple and you should be able to tweak it to your needs, so please read on.

Since we are using cargo and we get the main for free function we can also do manual testing. It just requires some minor tweaks to the main function, so we can allow it to take parameters, so we provide parameters via the command line.

Lets first do it using the modified version of a «Hello World», changed to the also popular «greeting» example.

Exit fullscreen mode

Getting string parameters to your Rust command line application is pretty basic and the documentation is pretty clear. If you are doing something more complex I am sure there is a crate that can help you out.

Now lets apply this to our multiplier:

Exit fullscreen mode

Do note that there are a subtle difference between then two, since we have to cast the parameters from strings to integers.

so line 8 and 9 does this: let operand1: i32 = args[1].parse().unwrap(); for each of the operands.

And there you have it, you can now test your Rust command line application if need be.

But lets get back to doing proper software development, since manual testing is tiresome and trivial (and error prone), so lets extend the unit-test suite with some more tests.

As shown earlier a test suite looks as follows:

Exit fullscreen mode

We can easily extend this with some interesting scenarios and corner cases, because a single test should capture the essence of such a simple function:

Exit fullscreen mode

This is all marvelous and it looks as if our simple multiplier is working as expected, but I want to leave you with a cliff hanger, based on a problem I ran into in another project, which also applies here:

The maximum value of an i32 can be extracted from Rust

Exit fullscreen mode

Do checkout the playground if you want to fool around with this brief example.

If we multiply 2147483647 with 2147483647 we get: 4.611686e+18 and the problem is of course relevant for the negative equivalents also (it there a term for this in mathematics?).

If you want to check it out, just add the following test to the test suite, since multiplying our maximum with 2 exceeds the maximum of our return type.

Exit fullscreen mode

This is it for now, I will do more write ups, since they are a good way for me to get my notes and katas in order, and perhaps somebody else can benefit from my notes or get inspired to learning Rust or just solving katas on Codewars.com.

I known I am skipping over a lot of things, and I hope you can still make sense of what I am writing and enjoy it, but I aim to cover these things in other posts, where they might prove more relevant or can be the focal point of the post.

LarisaOvchinnikova/java-codewars-solutions

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

My first steps in Java

Given an array of integers, return a new array with each value doubled.

The code does not execute properly. Try to figure out why.

Write a function that returns the total surface area and volume of a box as an array: [area, volume]

Your code will determine if the number passed is even (or not).

Find sum of two largest elements in array using one loop

Given an array of integers. Find the maximum product obtained from multiplying 2 adjacent numbers in the array.

Complete function saleHotdogs/SaleHotDogs, function accept 1 parameters:n, n is the number of customers to buy hotdogs, different numbers have different prices (refer to the following table), return a number that the customer need to pay how much money.

Complete the square sum function so that it squares each number passed into it and then sums the results together.

Create a public class called Cube without a constructor which gets one single private Integer variable Side, a getter GetSide() and a setter SetSide(int num) method for this property. Actually, getter and setter methods are not the common way to write this code in C#. In the next kata of this series, we gonna refactor the code and make it a bit more professional. Note: There’s no need to check for negative values!

Create a function isDivisible(n, x, y) that checks if a number n is divisible by two numbers x AND y. All inputs are positive, non-zero digits.

Complete the solution so that it reverses all of the words within the string passed in.

You task is to implement an simple interpreter for the notorious esoteric language HQ9+ that will work for a single character input: If the input is ‘H’, return ‘Hello World!’ If the input is ‘Q’, return the input If the input is ‘9’, return the full lyrics of 99 Bottles of Beer.

Conditions : N is divisible by divisor

N is less than or equal to bound

N is greater than 0.

Write a class Block that creates a block (Duh..) The constructor should take an array as an argument, this will contain 3 integers of the form [width, length, height] from which the Block should be created.

Write function bmi that calculates body mass index (bmi = weight / height ^ 2).

Given an array of N integers, you have to find how many times you have to add up the smallest numbers in the array until their Sum becomes greater or equal to K.

Implement a function, multiples(m, n), which returns an array of the first m multiples of the real number n. Assume that m is a positive integer.

You are going to be given a word. Your job is to return the middle character of the word. If the word’s length is odd, return the middle character. If the word’s length is even, return the middle 2 characters.

This code does not execute properly try to figure out why перевод

Copy raw contents

Copy raw contents

This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters

Footer

© 2022 GitHub, Inc.

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.

This code does not execute properly try to figure out why перевод

Now, this might be a stupid error, but I can’t figure it out.
I just started learning C++, and I am currently following this tutorial: http://www.cplusplus.com/doc/tutorial/program_structure/

However, after building the project, cout doesn not execute and the program does not end.

Output (After I manually stop the build):

Using:
Windows 7 32bit
MSYS and MinGW
Netbeans

And you let it run for 41 years? Talk about patience.

I see no reason why this would not work properly.

Boreeas it could be from how you open window where you write your code. there is one case where you must input this in your code

Stdafx is a VC++ generated header. I always remove Stdafx from all of my projects, and yet, my projects compile just fine. The Stdafx header is not a requirement.

netbeans is for java, isn’t it?

david91, as both me and framework have pointed out it’s a VC++ generated header so it isn’t going to help the Boreeas, because he is using NetBeans.

@chipp, it is mainly for Java but it supports C/++ as well, though I don’t see why anyone would develop in it as opposed to the countless other and «better» C/++ IDE’s out there.

@O.P: You might benefit from changing IDE’s as ascii suggested.

I use Visual Studio 2008, which is a premium IDE, but you can find the cut down «Express» version for C++ in the link below:

It might be a bit bulky to use at first but there are a lot of handy features in it that have become indisposable for me (I am not a sales rep from Microsoft 😉 ).

As for your code, it should work which leads me to believe that it’s probably your IDE.

I hope this helps!

P.S: If your a student, it might be worth your while to check with your school to see if they have a software licensing agreement with Microsoft (the program is called the MSDN Academic Alliance), which entities you to free software not limited to Visual Studio 2008/2010.

I would also blame some sort of poor NetBeans/compiler configuration, but without any further details I won’t be able to pinpoint it.

Maybe try reinstalling everything? *shrug*

Finally, in my experience Netbeans is actually a pretty decent IDE. Its code completion glitches at times and its C++0x support is iffy, but at least it runs properly when it’s on OS X (I’ve had major issues with C::B).

Глючный код на Python: 10 самых распространенных ошибок, которые допускают разработчики

О Python

Python — это интерпретируемый, объектно-ориентированный язык программирования высокого уровня с динамической семантикой. Встроенные структуры данных высокого уровня в сочетании с динамической типизацией и динамическим связыванием делают его очень привлекательным для БРПС (быстрой разработки прикладных средств), а также для использования в качестве скриптового и связующего языка для подключения существующих компонентов или сервисов. Python поддерживает модули и пакеты, тем самым поощряя модульность программы и повторное использование кода.

О данной статье

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

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

Ошибка № 1: неправильное использование выражений в качестве значений по умолчанию для аргументов функций

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

Распространенная ошибка в данном случае — это думать, что значение необязательного аргумента будет устанавливаться в значение по умолчанию каждый раз, как функция будет вызываться без значения для этого аргумента. В приведенном выше коде, например, можно предположить, что повторно вызывая функцию foo() (то есть без указания значения для агрумента bar), она всегда будет возвращать «baz», поскольку предполагается, что каждый раз, когда вызывается foo () (без указания аргумента bar), bar устанавливается в [ ] (т. е. новый пустой список).

Но давайте посмотрим что же будет происходить на самом деле:

А? Почему функция продолжает добавлять значение по умолчанию «baz» к существующему списку каждый раз, когда вызывается foo(), вместо того, чтобы каждый раз создавать новый список?

Ответом на данный вопрос будет более глубокое понимание того, что творится у Python «под капотом». А именно: значение по умолчанию для функции инициализируется только один раз, во время определения функции. Таким образом, аргумент bar инициализируется по умолчанию (т. е. пустым списком) только тогда, когда foo() определен впервые, но последующие вызовы foo() (т. е. без указания аргумента bar) продолжат использовать тот же список, который был создан для аргумента bar в момент первого определения функции.

Для справки, распространенным «обходным путем» для этой ошибки является следующее определение:

Ошибка № 2: неправильное использование переменных класса

Рассмотрим следующий пример:

Вроде все в порядке.

Ага, все как и ожидалось.

Что за черт?! Мы же только изменили A.x. Почему же C.x тоже изменилось?

В Python переменные класса обрабатываются как словари и следуют тому, что часто называют Порядком разрешения методов (MRO). Таким образом, в приведенном выше коде, поскольку атрибут x не найден в классе C, он будет найден в его базовых классах (только A в приведенном выше примере, хотя Python поддерживает множественное наследование). Другими словами, C не имеет своего собственного свойства x, независимого от A. Таким образом, ссылки на C.x фактически являются ссылками на A.x. Это будет вызывать проблемы, если не обрабатывать такие случаи должным образом. Так что при изучении Python обратите особое внимание на аттрибуты класса и работу с ними.

Ошибка № 3: неправильное указание параметров для блока исключения

Предположим, что у вас есть следующий кусок кода:

Проблема здесь заключается в том, что выражение except не принимает список исключений, указанных таким образом. Скорее, в Python 2.x выражение «except Exception, e» используется для привязки исключения к необязательному второму заданному второму параметру (в данном случае e), чтобы сделать его доступным для дальнейшей проверки. В результате в приведенном выше коде исключение IndexError не перехватывается выражением except; скорее, вместо этого исключение заканчивается привязкой к параметру с именем IndexError.

Правильный способ перехвата нескольких исключений с помощью выражения except — указать первый параметр в виде кортежа, содержащего все исключения, которые нужно перехватить. Кроме того, для максимальной совместимости используйте ключевое слово as, так как этот синтаксис поддерживается как в Python 2, так и в Python 3:

Ошибка № 4: непонимание правил области видимости Python

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

Таким образом, многие удивляются, когда получают UnboundLocalError в ранее работающем коде, когда он модифицируется путем добавления оператора присваивания где-нибудь в теле функции.

Эта особенность особенно сбивает разработчиков с толку при использовании списков. Рассмотрим следующий пример:

А? Почему foo2 падает, в то время как foo1 работает нормально?

Ответ такой же, как в предыдущем примере, но, по распространенному мнению, здесь ситуация более тонкая. foo1 не применяет оператор присваивания к lst, тогда как foo2 — да. Помня, что lst + = [5] на самом деле является просто сокращением для lst = lst + [5], мы видим, что мы пытаемся присвоить значение lst (поэтому Python предполагает, что он находится в локальной области видимости). Однако значение, которое мы хотим присвоить lst, основано на самом lst (опять же, теперь предполагается, что он находится в локальной области видимости), который еще не был определен. И мы получаем ошибку.

Ошибка № 5: изменение списка во время итерации по нему

Проблема в следующем куске кода должна быть достаточно очевидной:

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

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

Ошибка № 6: непонимание того, как Python связывает переменные в замыканиях

Рассмотрим следующий пример:

Вы можете ожидать следующий вывод:

Но на самом деле вы получите вот что:

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

Решение этой распространенной проблемы с Python будет таким:

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

Ошибка № 7: создание циклических зависимостей модуля

Допустим, у вас есть два файла, a.py и b.py, каждый из которых импортирует другой, следующим образом:

Сначала попробуем импортировать a.py:

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

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

Итак, возвращаясь к нашему примеру, когда мы импортировали a.py, у него не было проблем с импортом b.py, поскольку b.py не требует, чтобы что-либо из a.py было определено во время его импорта. Единственная ссылка в b.py на a — это вызов a.f(). Но этот вызов в g() и ничего в a.py или b.py не вызывает g(). Так что все работает прекрасно.

Но что произойдет, если мы попытаемся импортировать b.py (без предварительного импорта a.py, то есть):

Ой-ой. Это не хорошо! Проблема здесь в том, что в процессе импорта b.py он пытается импортировать a.py, который, в свою очередь, вызывает f(), который пытается получить доступ к b.x. Но b.x еще не было определено. Отсюда исключение AttributeError.

По крайней мере, одно из решений этой проблемы довольно тривиально. Просто измените b.py, чтобы импортировать a.py в g():

Теперь, когда мы его импортируем, все нормально:

Ошибка № 8: пересечение имен с именами модулями стандартной библиотеки Python

Одна из прелестей Python — это множество модулей, которые поставляются «из коробки». Но в результате, если вы сознательно не будете за этим следить, можно столкнуться с тем, что имя вашего модуля может быть с тем же именем, что и модуль в стандартной библиотеке, поставляемой с Python (например, в вашем коде может быть модуль с именем email.py, который будет конфликтовать со модулем стандартной библиотеки с таким же именем).

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

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

Ошибка № 9: неспособность учесть различия Python 2 и Python 3

Рассмотрим следующий файл foo.py:

На Python 2 он отработает нормально:

Но теперь давайте посмотрим как он будет работать в Python 3:

Что здесь только что произошло? «Проблема» в том, что в Python 3 объект в блоке исключения недоступен за его пределами. (Причина этого заключается в том, что в противном случае объекты в этом блоке будут сохраняться в памяти до тех пор, пока сборщик мусора не запустится и не удалит ссылки на них оттуда).

Один из способов избежать этой проблемы — сохранить ссылку на объект блока исключения за пределами этого блока, чтобы он оставался доступным. Вот версия предыдущего примера, которая использует эту технику, тем самым получая код, который подходит как для Python 2, так и для Python 3:

Запустим его в Python 3:

Ошибка № 10: неправильное использование метода __del__

Допустим, у вас есть вот такой файл mod.py:

И вы пытаетесь сделать вот такое из другого another_mod.py:

И получите ужасный AttributeError.

Почему? Потому что, как сообщается здесь, когда интерпретатор отключается, глобальные переменные модуля все имеют значение None. В результате в приведенном выше примере, в момент вызова __del__, имя foo уже было установлено в None.

Решением этой «задачи со звездочкой» будет использование atexit.register(). Таким образом, когда ваша программа завершает выполнение (то есть при нормальном выходе из нее), ваши handle’ы удаляются до того, как интерпретатор звершает работу.

С учетом этого, исправление для приведенного выше кода mod.py может выглядеть примерно так:

Подобная реализация обеспечивает простой и надежный способ вызова любой необходимой очистки после обычного завершения программы. Очевидно, что решение о том, как поступить с объектом, который связан с имненем self.myhandle, остается за foo.cleanup, но, думаю, идею вы поняли.

Заключение

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

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

How to Write Beautiful Python Code With PEP 8

Table of Contents

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Writing Beautiful Pythonic Code With PEP 8

PEP 8, sometimes spelled PEP8 or PEP-8, is a document that provides guidelines and best practices on how to write Python code. It was written in 2001 by Guido van Rossum, Barry Warsaw, and Nick Coghlan. The primary focus of PEP 8 is to improve the readability and consistency of Python code.

PEP stands for Python Enhancement Proposal, and there are several of them. A PEP is a document that describes new features proposed for Python and documents aspects of Python, like design and style, for the community.

This tutorial outlines the key guidelines laid out in PEP 8. It’s aimed at beginner to intermediate programmers, and as such I have not covered some of the most advanced topics. You can learn about these by reading the full PEP 8 documentation.

By the end of this tutorial, you’ll be able to:

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.

Why We Need PEP 8

PEP 8 exists to improve the readability of Python code. But why is readability so important? Why is writing readable code one of the guiding principles of the Python language?

As Guido van Rossum said, “Code is read much more often than it is written.” You may spend a few minutes, or a whole day, writing a piece of code to process user authentication. Once you’ve written it, you’re never going to write it again. But you’ll definitely have to read it again. That piece of code might remain part of a project you’re working on. Every time you go back to that file, you’ll have to remember what that code does and why you wrote it, so readability matters.

If you’re new to Python, it can be difficult to remember what a piece of code does a few days, or weeks, after you wrote it. If you follow PEP 8, you can be sure that you’ve named your variables well. You’ll know that you’ve added enough whitespace so it’s easier to follow logical steps in your code. You’ll also have commented your code well. All this will mean your code is more readable and easier to come back to. As a beginner, following the rules of PEP 8 can make learning Python a much more pleasant task.

Following PEP 8 is particularly important if you’re looking for a development job. Writing clear, readable code shows professionalism. It’ll tell an employer that you understand how to structure your code well.

If you have more experience writing Python code, then you may need to collaborate with others. Writing readable code here is crucial. Other people, who may have never met you or seen your coding style before, will have to read and understand your code. Having guidelines that you follow and recognize will make it easier for others to read your code.

Naming Conventions

“Explicit is better than implicit.”

When you write Python code, you have to name a lot of things: variables, functions, classes, packages, and so on. Choosing sensible names will save you time and energy later. You’ll be able to figure out, from the name, what a certain variable, function, or class represents. You’ll also avoid using inappropriate names that might result in errors that are difficult to debug.

Naming Styles

The table below outlines some of the common naming styles in Python code and when you should use them:

These are some of the common naming conventions and examples of how to use them. But in order to write readable code, you still have to be careful with your choice of letters and words. In addition to choosing the correct naming styles in your code, you also have to choose the names carefully. Below are a few pointers on how to do this as effectively as possible.

How to Choose Names

Choosing names for your variables, functions, classes, and so forth can be challenging. You should put a fair amount of thought into your naming choices when writing code as it will make your code more readable. The best way to name your objects in Python is to use descriptive names to make it clear what the object represents.

Similarly, to reduce the amount of typing you do, it can be tempting to use abbreviations when choosing names. In the example below, I have defined a function db() that takes a single argument x and doubles it:

At first glance, this could seem like a sensible choice. db() could easily be an abbreviation for double. But imagine coming back to this code in a few days. You may have forgotten what you were trying to achieve with this function, and that would make guessing how you abbreviated it difficult.

The following example is much clearer. If you come back to this code a couple of days after writing it, you’ll still be able to read and understand the purpose of this function:

The same philosophy applies to all other data types and objects in Python. Always try to use the most concise but descriptive names possible.

Code Layout

How you lay out your code has a huge role in how readable it is. In this section, you’ll learn how to add vertical whitespace to improve the readability of your code. You’ll also learn how to handle the 79 character line limit recommended in PEP 8.

Blank Lines

Vertical whitespace, or blank lines, can greatly improve the readability of your code. Code that’s bunched up together can be overwhelming and hard to read. Similarly, too many blank lines in your code makes it look very sparse, and the reader might need to scroll more than necessary. Below are three key guidelines on how to use vertical whitespace.

Surround top-level functions and classes with two blank lines. Top-level functions and classes should be fairly self-contained and handle separate functionality. It makes sense to put extra vertical space around them, so that it’s clear they are separate:

Surround method definitions inside classes with a single blank line. Inside a class, functions are all related to one another. It’s good practice to leave only a single line between them:

Use blank lines sparingly inside functions to show clear steps. Sometimes, a complicated function has to complete several steps before the return statement. To help the reader understand the logic inside the function, it can be helpful to leave a blank line between each step.

In the example below, there is a function to calculate the variance of a list. This is two-step problem, so I have indicated each step by leaving a blank line between them. There is also a blank line before the return statement. This helps the reader clearly see what’s returned:

If you use vertical whitespace carefully, it can greatly improved the readability of your code. It helps the reader visually understand how your code splits up into sections, and how those sections relate to one another.

Maximum Line Length and Line Breaking

PEP 8 suggests lines should be limited to 79 characters. This is because it allows you to have multiple files open next to one another, while also avoiding line wrapping.

Of course, keeping statements to 79 characters or less is not always possible. PEP 8 outlines ways to allow statements to run over several lines.

Python will assume line continuation if code is contained within parentheses, brackets, or braces:

If it is impossible to use implied continuation, then you can use backslashes to break lines instead:

However, if you can use implied continuation, then you should do so.

Below is an example of breaking before a binary operator:

You can immediately see which variable is being added or subtracted, as the operator is right next to the variable being operated on.

Now, let’s see an example of breaking after a binary operator:

Here, it’s harder to see which variable is being added and which is subtracted.

Breaking before binary operators produces more readable code, so PEP 8 encourages it. Code that consistently breaks after a binary operator is still PEP 8 compliant. However, you’re encouraged to break before a binary operator.

Indentation

“There should be one—and preferably only one—obvious way to do it.”

Indentation, or leading whitespace, is extremely important in Python. The indentation level of lines of code in Python determines how statements are grouped together.

Consider the following example:

The key indentation rules laid out by PEP 8 are the following:

Tabs vs. Spaces

As mentioned above, you should use spaces instead of tabs when indenting code. You can adjust the settings in your text editor to output 4 spaces instead of a tab character, when you press the Tab key.

Python 3 does not allow mixing of tabs and spaces. Therefore, if you are using Python 3, then these errors are issued automatically:

You can write Python code with either tabs or spaces indicating indentation. But, if you’re using Python 3, you must be consistent with your choice. Otherwise, your code will not run. PEP 8 recommends that you always use 4 consecutive spaces to indicate indentation.

Indentation Following Line Breaks

When you’re using line continuations to keep lines to under 79 characters, it is useful to use indentation to improve readability. It allows the reader to distinguish between two lines of code and a single line of code that spans two lines. There are two styles of indentation you can use.

The first of these is to align the indented block with the opening delimiter:

In this case, PEP 8 provides two alternatives to help improve readability:

Add a comment after the final condition. Due to syntax highlighting in most editors, this will separate the conditions from the nested code:

Add extra indentation on the line continuation:

An alternative style of indentation following a line break is a hanging indent. This is a typographical term meaning that every line but the first in a paragraph or statement is indented. You can use a hanging indent to visually represent a continuation of a line of code. Here’s an example:

Note: When you’re using a hanging indent, there must not be any arguments on the first line. The following example is not PEP 8 compliant:

When using a hanging indent, add extra indentation to distinguish the continued line from code contained inside the function. The following example is difficult to read because the code inside the function is at the same indentation level as the continued lines:

Instead, it’s better to use a double indent on the line continuation. This helps you to distinguish between function arguments and the function body, improving readability:

When you write PEP 8 compliant code, the 79 character line limit forces you to add line breaks in your code. To improve readability, you should indent a continued line to show that it is a continued line. There are two ways of doing this. The first is to align the indented block with the opening delimiter. The second is to use a hanging indent. You are free to chose which method of indentation you use following a line break.

Where to Put the Closing Brace

Line continuations allow you to break lines inside parentheses, brackets, or braces. It’s easy to forget about the closing brace, but it’s important to put it somewhere sensible. Otherwise, it can confuse the reader. PEP 8 provides two options for the position of the closing brace in implied line continuations:

Line up the closing brace with the first non-whitespace character of the previous line:

Line up the closing brace with the first character of the line that starts the construct:

You are free to chose which option you use. But, as always, consistency is key, so try to stick to one of the above methods.

Comments

“If the implementation is hard to explain, it’s a bad idea.”

You should use comments to document code as it’s written. It is important to document your code so that you, and any collaborators, can understand it. When you or someone else reads a comment, they should be able to easily understand the code the comment applies to and how it fits in with the rest of your code.

Here are some key points to remember when adding comments to your code:

Block Comments

Use block comments to document a small section of code. They are useful when you have to write several lines of code to perform a single action, such as importing data from a file or updating a database entry. They are important as they help others understand the purpose and functionality of a given code block.

PEP 8 provides the following rules for writing block comments:

Here is a block comment explaining the function of a for loop. Note that the sentence wraps to a new line to preserve the 79 character line limit:

Sometimes, if the code is very technical, then it is necessary to use more than one paragraph in a block comment:

If you’re ever in doubt as to what comment type is suitable, then block comments are often the way to go. Use them as much as possible throughout your code, but make sure to update them if you make changes to your code!

Inline Comments

Inline comments explain a single statement in a piece of code. They are useful to remind you, or explain to others, why a certain line of code is necessary. Here’s what PEP 8 has to say about them:

Below is an example of an inline comment:

Sometimes, inline comments can seem necessary, but you can use better naming conventions instead. Here’s an example:

Here, the inline comment does give extra information. However using x as a variable name for a person’s name is bad practice. There’s no need for the inline comment if you rename your variable:

Finally, inline comments such as these are bad practice as they state the obvious and clutter code:

Inline comments are more specific than block comments, and it’s easy to add them when they’re not necessary, which leads to clutter. You could get away with only using block comments so, unless you are sure you need an inline comment, your code is more likely to be PEP 8 compliant if you stick to block comments.

Documentation Strings

Documentation strings, or docstrings, are strings enclosed in double ( «»» ) or single ( »’ ) quotation marks that appear on the first line of any function, class, method, or module. You can use them to explain and document a specific block of code. There is an entire PEP, PEP 257, that covers docstrings, but you’ll get a summary in this section.

The most important rules applying to docstrings are the following:

Write them for all public modules, functions, classes, and methods.

Put the «»» that ends a multiline docstring on a line by itself:

For one-line docstrings, keep the «»» on the same line:

For a more detailed article on documenting Python code, see Documenting Python Code: A Complete Guide by James Mertz.

Whitespace in Expressions and Statements

Whitespace can be very helpful in expressions and statements when used properly. If there is not enough whitespace, then code can be difficult to read, as it’s all bunched together. If there’s too much whitespace, then it can be difficult to visually combine related terms in a statement.

Whitespace Around Binary Operators

Surround the following binary operators with a single space on either side:

Note: When = is used to assign a default value to a function argument, do not surround it with spaces.

When there’s more than one operator in a statement, adding a single space before and after each operator can look confusing. Instead, it is better to only add whitespace around the operators with the lowest priority, especially when performing mathematical manipulation. Here are a couple examples:

You can also apply this to if statements where there are multiple conditions:

In the above example, the and operator has lowest priority. It may therefore be clearer to express the if statement as below:

You are free to choose which is clearer, with the caveat that you must use the same amount of whitespace either side of the operator.

The following is not acceptable:

In slices, colons act as a binary operators. Therefore, the rules outlined in the previous section apply, and there should be the same amount of whitespace either side. The following examples of list slices are valid:

In summary, you should surround most operators with whitespace. However, there are some caveats to this rule, such as in function arguments or when you’re combining multiple operators in one statement.

When to Avoid Adding Whitespace

In some cases, adding whitespace can make code harder to read. Too much whitespace can make code overly sparse and difficult to follow. PEP 8 outlines very clear examples where whitespace is inappropriate.

The most important place to avoid adding whitespace is at the end of a line. This is known as trailing whitespace. It is invisible and can produce errors that are difficult to trace.

The following list outlines some cases where you should avoid adding whitespace:

Immediately inside parentheses, brackets, or braces:

Before a comma, semicolon, or colon:

Before the open parenthesis that starts the argument list of a function call:

Before the open bracket that starts an index or slice:

Between a trailing comma and a closing parenthesis:

To align assignment operators:

Make sure that there is no trailing whitespace anywhere in your code. There are other cases where PEP 8 discourages adding extra whitespace, such as immediately inside brackets, as well as before commas and colons. You should also never add extra whitespace in order to align operators.

Programming Recommendations

You will often find that there are several ways to perform a similar action in Python (and any other programming language for that matter). In this section, you’ll see some of the suggestions PEP 8 provides to remove that ambiguity and preserve consistency.

Don’t compare Boolean values to True or False using the equivalence operator. You’ll often need to check if a Boolean value is True or False. When doing so, it is intuitive to do this with a statement like the one below:

This way of performing an if statement with a Boolean requires less code and is simpler, so PEP 8 encourages it.

Use the fact that empty sequences are falsy in if statements. If you want to check whether a list is empty, you might be tempted to check the length of the list. If the list is empty, it’s length is 0 which is equivalent to False when used in an if statement. Here’s an example:

However, in Python any empty list, string, or tuple is falsy. We can therefore come up with a simpler alternative to the above:

A second option would be to evaluate x is None and then have an if statement based on not the outcome:

While both options will be evaluated correctly, the first is simpler, so PEP 8 encourages it.

Similarly, the same principle applies when you’re checking for suffixes. The example below outlines how you might check whether a string ends in jpg :

As with most of these programming recommendations, the goal is readability and simplicity. In Python, there are many different ways to perform the same action, so guidelines on which methods to chose are helpful.

When to Ignore PEP 8

The short answer to this question is never. If you follow PEP 8 to the letter, you can guarantee that you’ll have clean, professional, and readable code. This will benefit you as well as collaborators and potential employers.

However, some guidelines in PEP 8 are inconvenient in the following instances:

Tips and Tricks to Help Ensure Your Code Follows PEP 8

There is a lot to remember to make sure your code is PEP 8 compliant. It can be a tall order to remember all these rules when you’re developing code. It’s particularly time consuming to update past projects to be PEP 8 compliant. Luckily, there are tools that can help speed up this process. There are two classes of tools that you can use to enforce PEP 8 compliance: linters and autoformatters.

Linters

Linters are programs that analyze code and flag errors. They provide suggestions on how to fix the error. Linters are particularly useful when installed as extensions to your text editor, as they flag errors and stylistic problems while you write. In this section, you’ll see an outline of how the linters work, with links to the text editor extensions at the end.

The best linters for Python code are the following:

pycodestyle is a tool to check your Python code against some of the style conventions in PEP 8.

Install pycodestyle using pip :

You can run pycodestyle from the terminal using the following command:

Install flake8 using pip :

Run flake8 from the terminal using the following command:

An example of the output is also shown.

Note: The extra line of output indicates a syntax error.

These are also available as extensions for Atom, Sublime Text, Visual Studio Code, and VIM. You can also find guides on setting up Sublime Text and VIM for Python development, as well as an overview of some popular text editors at Real Python.

Autoformatters

It can be run via the command line, as with the linters. Let’s say you start with the following code that isn’t PEP 8 compliant in a file called code.py :

You can then run the following command via the command line:

code.py will be automatically reformatted to look like this:

Another Real Python tutorial, Python Code Quality: Tools & Best Practices by Alexander van Tol, gives a thorough explanation of how to use these tools.

Conclusion

You now know how to write high-quality, readable Python code by using the guidelines laid out in PEP 8. While the guidelines can seem pedantic, following them can really improve your code, especially when it comes to sharing your code with potential employers or collaborators.

In this tutorial, you learned:

On top of all this, you also saw how to use linters and autoformatters to check your code against PEP 8 guidelines.

If you want to learn more about PEP 8, then you can read the full documentation, or visit pep8.org, which contains the same information but has been nicely formatted. In these documents, you will find the rest of the PEP 8 guidelines not covered in this tutorial.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Writing Beautiful Pythonic Code With PEP 8

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Jasmine Finer

Jasmine is a Django developer, based in London.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Master Real-World Python Skills
With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal. Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session. Happy Pythoning!

dj9aj/Codewars-Kata-Solutions

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

readme.md

My Codewars Kata Solutions

A log of my codewars solutions so far. Hopefully I can refactor my code as I progress.

Very simple, given a number, find its opposite. But can you do it in 1 line of code and without any conditionals?

Find the smallest integer in the array

Given an array of integers your solution should find the smallest integer. For example:

altERnaTIng cAsE ALTerNAtiNG CaSe

Define String.prototype.toAlternatingCase (or a similar function/method such as to_alternating_case/toAlternatingCase/ToAlternatingCase in your selected language; see the initial solution for details) such that each lowercase letter becomes uppercase and each uppercase letter becomes lowercase.

For example: hello world».toAlternatingCase() === «HELLO WORLD» «HELLO WORLD».toAlternatingCase() === «hello world» «hello WORLD».toAlternatingCase() === «HELLO world» «HeLLo WoRLD».toAlternatingCase() === «hEllO wOrld» «12345».toAlternatingCase() === «12345» // Non-alphabetical characters are unaffected «1a2b3c4d5e».toAlternatingCase() === «1A2B3C4D5E» «String.prototype.toAlternatingCase».toAlternatingCase() === «sTRING.PROTOTYPE.TOaLTERNATINGcASE»

As usual, your function/method should be pure, i.e. it should not mutate the original string.

Exclamation marks series #11: Replace all vowel to exclamation mark in the sentence

Replace all vowel to exclamation mark in the sentence. aeiouAEIOU is vowel.

Convert a Number to a String!

What ways of achieving this do you know?

Write function avg which calculates average of numbers in given list.

Timmy & Sarah think they are in love, but around where they live, they will only know once they pick a flower each. If one of the flowers has an even number of petals and the other has an odd number of petals it means they are in love. Write a function that will take the number of petals of each flower and return true if they are in love and false if they aren’t.

My Refactored Solution

The code does not execute properly. Try to figure out why.

Invalid Syntax in Python: Common Reasons for SyntaxError

Table of Contents

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Identify Invalid Python Syntax

Python is known for its simple syntax. However, when you’re learning Python for the first time or when you’ve come to Python with a solid background in another programming language, you may run into some things that Python doesn’t allow. If you’ve ever received a SyntaxError when trying to run your Python code, then this guide can help you. Throughout this tutorial, you’ll see common examples of invalid syntax in Python and learn how to resolve the issue.

By the end of this tutorial, you’ll be able to:

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.

Invalid Syntax in Python

When you run your Python code, the interpreter will first parse it to convert it into Python byte code, which it will then execute. The interpreter will find any invalid syntax in Python during this first stage of program execution, also known as the parsing stage. If the interpreter can’t parse your Python code successfully, then this means that you used invalid syntax somewhere in your code. The interpreter will attempt to show you where that error occurred.

SyntaxError Exception and Traceback

When the interpreter encounters invalid syntax in Python code, it will raise a SyntaxError exception and provide a traceback with some helpful information to help you debug the error. Here’s some code that contains invalid syntax in Python:

Note that the traceback message locates the error in line 5, not line 4. The Python interpreter is attempting to point out where the invalid syntax is. However, it can only really point to where it first noticed a problem. When you get a SyntaxError traceback and the code that the traceback is pointing to looks fine, then you’ll want to start moving backward through the code until you can determine what’s wrong.

In the example above, there isn’t a problem with leaving out a comma, depending on what comes after it. For example, there’s no problem with a missing comma after ‘michael’ in line 5. But once the interpreter encounters something that doesn’t make sense, it can only point you to the first thing it found that it couldn’t understand.

Note: This tutorial assumes that you know the basics of Python’s tracebacks. To learn more about the Python traceback and how to read them, check out Understanding the Python Traceback and Getting the Most out of a Python Traceback.

There are a few elements of a SyntaxError traceback that can help you determine where the invalid syntax is in your code:

There are two other exceptions that you might see Python raise. These are equivalent to SyntaxError but have different names:

These exceptions both inherit from the SyntaxError class, but they’re special cases where indentation is concerned. An IndentationError is raised when the indentation levels of your code don’t match up. A TabError is raised when your code uses both tabs and spaces in the same file. You’ll take a closer look at these exceptions in a later section.

Common Syntax Problems

When you encounter a SyntaxError for the first time, it’s helpful to know why there was a problem and what you might do to fix the invalid syntax in your Python code. In the sections below, you’ll see some of the more common reasons that a SyntaxError might be raised and how you can fix them.

Misusing the Assignment Operator ( = )

There are several cases in Python where you’re not able to make assignments to objects. Some examples are assigning to literals and function calls. In the code block below, you can see a few examples that attempt to do this and the resulting SyntaxError tracebacks:

The first example tries to assign the value 5 to the len() call. The SyntaxError message is very helpful in this case. It tells you that you can’t assign a value to a function call.

The second and third examples try to assign a string and an integer to literals. The same rule is true for other literal values. Once again, the traceback messages indicate that the problem occurs when you attempt to assign a value to a literal.

Note: The examples above are missing the repeated code line and caret ( ^ ) pointing to the problem in the traceback. The exception and traceback you see will be different when you’re in the REPL vs trying to execute this code from a file. If this code were in a file, then you’d get the repeated code line and caret pointing to the problem, as you saw in other cases throughout this tutorial.

It’s likely that your intent isn’t to assign a value to a literal or a function call. For instance, this can occur if you accidentally leave off the extra equals sign ( = ), which would turn the assignment into a comparison. A comparison, as you can see below, would be valid:

Most of the time, when Python tells you that you’re making an assignment to something that can’t be assigned to, you first might want to check to make sure that the statement shouldn’t be a Boolean expression instead. You may also run into this issue when you’re trying to assign a value to a Python keyword, which you’ll cover in the next section.

Misspelling, Missing, or Misusing Python Keywords

Python keywords are a set of protected words that have special meaning in Python. These are words you can’t use as identifiers, variables, or function names in your code. They’re a part of the language and can only be used in the context that Python allows.

There are three common ways that you can mistakenly use keywords:

Another common issue with keywords is when you miss them altogether:

Once again, the exception message isn’t that helpful, but the traceback does attempt to point you in the right direction. If you move back from the caret, then you can see that the in keyword is missing from the for loop syntax.

You can also misuse a protected Python keyword. Remember, keywords are only allowed to be used in specific situations. If you use them incorrectly, then you’ll have invalid syntax in your Python code. A common example of this is the use of continue or break outside of a loop. This can easily happen during development when you’re implementing things and happen to move logic outside of a loop:

Here, Python does a great job of telling you exactly what’s wrong. The messages «‘break’ outside loop» and «‘continue’ not properly in loop» help you figure out exactly what to do. If this code were in a file, then Python would also have the caret pointing right to the misused keyword.

Another example is if you attempt to assign a Python keyword to a variable or use a keyword to define a function:

The list of protected keywords has changed with each new version of Python. For example, in Python 3.6 you could use await as a variable name or function name, but as of Python 3.7, that word has been added to the keyword list. Now, if you try to use await as a variable or function name, this will cause a SyntaxError if your code is for Python 3.7 or later.

print is a keyword in Python 2, so you can’t assign a value to it. In Python 3, however, it’s a built-in function that can be assigned values.

You can run the following code to see the list of keywords in whatever version of Python you’re running:

This code will tell you quickly if the identifier that you’re trying to use is a keyword or not.

Missing Parentheses, Brackets, and Quotes

Often, the cause of invalid syntax in Python code is a missed or mismatched closing parenthesis, bracket, or quote. These can be hard to spot in very long lines of nested parentheses or longer multi-line blocks. You can spot mismatched or missing quotes with the help of Python’s tracebacks:

Here, the traceback points to the invalid code where there’s a t’ after a closing single quote. To fix this, you can make one of two changes:

Another common mistake is to forget to close string. With both double-quoted and single-quoted strings, the situation and traceback are the same:

Quotes missing from statements inside an f-string can also lead to invalid syntax in Python:

Here, the reference to the ages dictionary inside the printed f-string is missing the closing double quote from the key reference. The resulting traceback is as follows:

Python identifies the problem and tells you that it exists inside the f-string. The message «unterminated string» also indicates what the problem is. The caret in this case only points to the beginning of the f-string.

This might not be as helpful as when the caret points to the problem area of the f-string, but it does narrow down where you need to look. There’s an unterminated string somewhere inside that f-string. You just have to find out where. To fix this problem, make sure that all internal f-string quotes and brackets are present.

The situation is mostly the same for missing parentheses and brackets. If you leave out the closing square bracket from a list, for example, then Python will spot that and point it out. There are a few variations of this, however. The first is to leave the closing bracket off of the list:

When you run this code, you’ll be told that there’s a problem with the call to print() :

Another variation is to add a trailing comma after the last element in the list while still leaving off the closing square bracket:

Now you get a different traceback:

In the previous example, 3 and print(foo()) were lumped together as one element, but here you see a comma separating the two. Now, the call to print(foo()) gets added as the fourth element of the list, and Python reaches the end of the file without the closing bracket. The traceback tells you that Python got to the end of the file (EOF), but it was expecting something else.

In this example, Python was expecting a closing bracket ( ] ), but the repeated line and caret are not very helpful. Missing parentheses and brackets are tough for Python to identify. Sometimes the only thing you can do is start from the caret and move backward until you can identify what’s missing or wrong.

Mistaking Dictionary Syntax

You saw earlier that you could get a SyntaxError if you leave the comma off of a dictionary element. Another form of invalid syntax with Python dictionaries is the use of the equals sign ( = ) to separate keys and values, instead of the colon:

Once again, this error message is not very helpful. The repeated line and caret, however, are very helpful! They’re pointing right to the problem character.

This type of issue is common if you confuse Python syntax with that of other programming languages. You’ll also see this if you confuse the act of defining a dictionary with a dict() call. To fix this, you could replace the equals sign with a colon. You can also switch to using dict() :

You can use dict() to define the dictionary if that syntax is more helpful.

Using the Wrong Indentation

There are two sub-classes of SyntaxError that deal with indentation issues specifically:

While other programming languages use curly braces to denote blocks of code, Python uses whitespace. That means that Python expects the whitespace in your code to behave predictably. It will raise an IndentationError if there’s a line in a code block that has the wrong number of spaces:

This might be tough to see, but line 5 is only indented 2 spaces. It should be in line with the for loop statement, which is 4 spaces over. Thankfully, Python can spot this easily and will quickly tell you what the issue is.

There’s also a bit of ambiguity here, though. Is the print(‘done’) line intended to be after the for loop or inside the for loop block? When you run the above code, you’ll see the following error:

If your tab size is the same width as the number of spaces in each indentation level, then it might look like all the lines are at the same level. However, if one line is indented using spaces and the other is indented with tabs, then Python will point this out as a problem:

Here, line 5 is indented with a tab instead of 4 spaces. This code block could look perfectly fine to you, or it could look completely wrong, depending on your system settings.

Python, however, will notice the issue immediately. But before you run the code to see what Python will tell you is wrong, it might be helpful for you to see an example of what the code looks like under different tab width settings:

Notice the difference in display between the three examples above. Most of the code uses 4 spaces for each indentation level, but line 5 uses a single tab in all three examples. The width of the tab changes, based on the tab width setting:

When you run the code, you’ll get the following error and traceback:

The solution to this is to make all lines in the same Python code file use either tabs or spaces, but not both. For the code blocks above, the fix would be to remove the tab and replace it with 4 spaces, which will print ‘done’ after the for loop has finished.

Defining and Calling Functions

You might run into invalid syntax in Python when you’re defining or calling functions. For example, you’ll see a SyntaxError if you use a semicolon instead of a colon at the end of a function definition:

The traceback here is very helpful, with the caret pointing right to the problem character. You can clear up this invalid syntax in Python by switching out the semicolon for a colon.

In addition, keyword arguments in both function definitions and function calls need to be in the right order. Keyword arguments always come after positional arguments. Failure to use this ordering will lead to a SyntaxError :

Here, once again, the error message is very helpful in telling you exactly what is wrong with the line.

Changing Python Versions

Sometimes, code that works perfectly fine in one version of Python breaks in a newer version. This is due to official changes in language syntax. The most well-known example of this is the print statement, which went from a keyword in Python 2 to a built-in function in Python 3:

This is one of the examples where the error message provided with the SyntaxError shines! Not only does it tell you that you’re missing parenthesis in the print call, but it also provides the correct code to help you fix the statement.

Another problem you might encounter is when you’re reading or learning about syntax that’s valid syntax in a newer version of Python, but isn’t valid in the version you’re writing in. An example of this is the f-string syntax, which doesn’t exist in Python versions before 3.6:

In versions of Python before 3.6, the interpreter doesn’t know anything about the f-string syntax and will just provide a generic «invalid syntax» message. The problem, in this case, is that the code looks perfectly fine, but it was run with an older version of Python. When in doubt, double-check which version of Python you’re running!

Python syntax is continuing to evolve, and there are some cool new features introduced in Python 3.8:

This TypeError means that you can’t call a tuple like a function, which is what the Python interpreter thinks you’re doing.

The helpful message accompanying the new SyntaxWarning even provides a hint ( «perhaps you missed a comma?» ) to point you in the right direction!

Conclusion

In this tutorial, you’ve seen what information the SyntaxError traceback gives you. You’ve also seen many common examples of invalid syntax in Python and what the solutions are to those problems. Not only will this speed up your workflow, but it will also make you a more helpful code reviewer!

When you’re writing code, try to use an IDE that understands Python syntax and provides feedback. If you put many of the invalid Python code examples from this tutorial into a good IDE, then they should highlight the problem lines before you even get to execute your code.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Identify Invalid Python Syntax

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Chad Hansen

Chad is an avid Pythonista and does web development with Django fulltime. Chad lives in Utah with his wife and six kids.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Master Real-World Python Skills
With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal. Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session. Happy Pythoning!

Related Tutorial Categories: basics python

Guide to naming in code

Summary

We present a guide to name entities in code based on putting naming in perspectives of semantic space, design, and readability. The main idea is that naming should not be considered as creation of tags, but as a fundamental part of design process, which implies integral and consistent vocabulary to be used. We discuss naming process and naming formalism from these perspectives and we provide guides for practical use. The work is based on 15 years of experience in engineering work, coding and development management in high-tech industries.

Contents

Names in Software Engineering

Let us consider what a programmer does. He models a situation in life to create a program which adds some value to it.

While doing this he extracts some things from the situation, conceptualizes them, and names them. Like a table is a concept of a wooden construction we see, and we name it using a word “table”. Note, all three are different.

In all this work a programmer uses some language to describe the situation with a certain vocabulary. This vocabulary defines and reflects meaning we put into our program, so it also defines if the program is modelling the situation well enough to add some value to it. Vocabulary in turn can be a source for building names of parts of a program.

We see three dimensions meeting here: world, thinking, artifact. These dimensions are pair-wise connected.

We also see two levels of abstraction meeting here: low-level, dealing with a part; high-level, dealing with a whole. These are also cross-dependent.

This can be visualized in a triangle model where entities are pair-wise connected.

Name is a reflection of meaning and design. When you name properly, you think properly, you design properly, and you use properly. Bad names lead to improper usage, bad design and bugs.

Programming is also creation of texts. Other programmers or the same programmer in future read the text and decode its concepts. Names are essential part of transferring proper meaning, so actions of future maintainers will not harm integrity of the program.

This shows that naming is essential part the whole process of software engineering, so their design impact all the rest in it.

Principles of Name Design

Thus, design of names, design of vocabulary and design of a model should be aligned, so should the principles we use for it.

In software engineering, as in any engineering discipline, in most cases a model is mechanical, i.e.

a system is a set of separate parts, each having its own concrete function.

Engineer needs to limit entities he works with simultaneously because of limitation of brain, and he usually creates generalizations and hierarchy in a model, which implies:

one entity has one name,

vocabulary has hierarchical structure,

no overlaps between names at the same hierarchy level.

Usually, an engineer works with other engineers, so

the vocabulary should be shared between all the engineers.

Try to think of these general principles of software design in application to naming:

consistency between parts of an integral system;

proper level of specification/generalization;

proper level of modularity/coupling;

maintainability and cognitive-friendly interface;

future-awareness – need to design taking evolution of system into account;

support of various scenarios and corner cases.

As program is a text, we need to make names readable as easy in a normal text to improve understanding of it while reading. It means we need to prefer English over formal language, and full words over excessive shortening.

Bad Naming

As it is usually not that easy to fix the architecture, the same holds for the vocabulary. Terms you use to describe your system cannot be fixed by simple Find/Replace in most cases. They impact a maintainer, and lead to wrong derivative changes in other names and in structure.

Names can be bad if they mislead, can mislead, are ambiguous, are too specific or too general, require time to understand, are inconsistent with context or other names or a convention, describe too little or too much.

Names can be bad because of bad design, for example if the same entity has different meaning in different contexts. In this case to fix name you need to redesign the entity.

Bad names in small pieces of code are not an exclusion. It is better to speak the same language in all parts of an integral space of your program.

Naming Process

Naming can be approached as a process of finding meaning of entities and expressing it clearly within a set of other names.

Since you spend time on design in general, you need to make time for name design. Reluctance of doing the latter is inconsistency which has no excuse, because it harms design and semantic space.

Engineering work contains of iterations. The knowledge of what you work with and what is to be done increase gradually:

Speculative (mental) experiments are naturally more used for naming since they are faster and since they precede more expensive physical experimentation. Also, impact of names is long-term and not always easily physically tested right away.

Names are derivatives from terms you have in a vocabulary you use to describe your model. So, naming process starts with understanding of what terms are more appropriate for your model to reflect a situation in life you work with.

Terms are more heavyweight than names, so more time should be spent on them. It is the time when you create a value of an insight about a problem and a solution.

Terms also define ability of a solution to evolve when a situation in life evolves. Fitting of key things of a situation with the terms you use in your solution lead to a robustness of a solution.

Concrete names should be built of terms in a more formal way, using conventions.

Fast Method

Fast method is for usage while writing a draft or a small part in an already established code.

Describe an entity “using your words”
What is your intention? How would you use it?

Use terms from the context/existing vocabulary to compile a derivative name
Do not create synonyms and do not use different wording for the same thing.

Check if the entity can be properly understood from the same line it will be used in
Do not imply that the reader has go to the definition/somewhere else to understand it correctly. Switching between contexts is for finding details, not for finding the idea. Switching to another context make you lose the original one.

Ask yourself: can others misinterpret the name?
Even if the misinterpretation will happen in 5% of cases it may lead to hours of debugging and worsen maintainability.

Check readability, prefer English over formal.
A text that can be easily read is easier to understand.

Long Method

Hard cases usually mean there are flaws in the design and the understanding of how the system (should) work. Instead of thinking “let us leave it as is and do some real work”, spending extra time in this case is a natural need.

Create a long description of an entity “using your words”
What is your intention? How would you use it?
Write the long description down, look at it.

Make the description precise, i.e. create a definition
What is the entity’s place and scope in the system? How is it different from the other entities you have in the same system and from the entities in use context of the system (if it is visible outside)? Do you put more specifics than needed? Do you generalize what you should not? Usually you increase level of abstraction vs. the values of the entity.
Write precise description down, look at it.

Create variants of long names
Try to put the essence of the definition in few words. Use English, not formal language here. Create multiple variants.
Write the list down, look at it.
Put names in use context in code, look at the code.

Check vocabulary
Check consistency with other parts of your code. Do you create a synonym? Do you use terms which may not be understood by a newcomer who will read your code 10 years later? Is it easy to read? Can it mislead someone even if it is formally perfect? How much time is required to figure out the correct meaning of the variable? A user should be able to read your code as fast as he reads a normal text.

Consider context to shorten names
What will be understood from the usage, so can be omitted? What can be omitted without losing possibility to distinguish the entity from other entities?
Several words are OK if needed, if you move 30 lines into a new function, it is OK to spend few more words to describe it in a name.
Put shorter names in use context in code, look at the code.

Make a survey to decide on a winner
The survey can be a mental experiment of physical. For the mental experiment you need to compare the names as other code users. Both ways have limitations. If you will ask people, they will be unable to identify in a short time if what you suggest is aligned with your design and purpose. Mental experimentation requires a skill and usually is very biased by your own opinion.

Sometimes naming analysis leads to redesign, do it
This is a natural consequence of you getting more knowledge of the system you work with, while finding meaning of entities.
Single entity with multiple responsibilities often makes it uneasy to name it and maintain it. It might happen if your entity is not logically integral. You may split it into parts in this case.

Create appropriate comment about complex entities
It may happen, that a name cannot hold everything you want to share with a reader. Add a comment with full description.

Non-descriptive names should be rare negotiated conventions
You may agree with your colleagues that you will use the name for this entity even if it cannot be understood straight without additional knowledge. For example, abbreviations go here.

Formatting

As code is a text which is read by people, we may reuse principles of creation of a natural language text for code. In a natural language text words are separated by spaces of the same length in a line, comma is followed by a space and has no leading space, etc. And this is applied for all paragraphs. It is better to do the same in code.

The broken window principle is applicable for name formatting. If one breaks a window in a car in an unsafe district, after some time the car will be left without wheels. Something done improperly sets the culture of negligence and pollutes everything around.

Stick to a style which is preferred in the code you change. If you begin a new module, you are freer in choice. Main name formatting styles are:

snake_case – fluently readable as underscore is very similar to a space;

CamelCase – readable, capital letters naturally attract attention;

camelCase – readable, can be used to distinguish from CamelCase.

Convention and consistency in naming open a very useful possibility to encode more meaning in names using styles. Styles can be used to differentiate entities by their class, which increase readability a lot, e.g.:

snake_case for variables, CamelCase for classes and functions;

snake_case for variables, CamelCase for classes, camelCase for functions.

camelCase for variables, CamelCase for classes and functions.

snake_case for variables and functions, CamelCase for classes in Python

snake_case for almost everything in C++ STL

QCamelCase for classes and camelCase for methods in Qt

Hungarian notation put variable type in all variable names. If you create a new style, avoid that, names are for meaning, not for implementation. However, if a type is a part of meaning, in can be in the name. For example, is you create an instance of a class, the class name is usually already abstracted from the implementation well enough to be used in an instance name.

Some styles use _ pre- and postfixes for marking non-public fields of classes. This is useful because it shows the scope in which a variable is used, which adds to understanding of its impact and its dependencies:

_private_function # in Python and Dart

int private_member_; // Google C++ Style Guide

Details & Examples

Meaning should be understood from the same line. Switching of contexts takes time and distracts from thinking on a topic. Do not expect jumping of eye back and forth as a standard way to understand your code. Do not expect that the correct meaning can only be understood from the definition, people will unlikely to go to the definition and will work with their guess instead.

If meaning cannot be understood from the same line – make it explicitly visible. Place a comment to describe what is happening and why, and provide a reference for further reading if needed.

Do not use one-two-letter-per-word abbreviations, even if this is very local. Eventually it may become bigger and, even if not, such code is not easy to understand from this line only, you need to get back to definitions of these variables and spend extra time to understand what is going on correctly. Abbreviations which are agreed convention is an exception, but these should be rare.

Bad: wcf.add(cr);

Prefer English over formal (but keep it formally correct). Name things so they can be read naturally in English. Avoid compound noun form if it can be misleading.

Bad: bool selection_all() const;
Good: bool all_selected() const

Bad: file_unable_to_parse,
Good: unable_to_parse_file,

Bad: DesignTypeNeedToOpen();
Good: TypeOfDesignToOpen();

Bad: SetAbstractGeometryStatus(); // What is abstract geometry status? Status of abstract geometry? abstract status of geometry? something else? Just by reading the name you cannot understand what it really is and is made for. In most cases it means that the name is wrong.

Narrow scope of usage and visibility. Create variables as close to their usage as possible. This improves readability and decrease coupling of code. This helps with having simpler names, as narrow context of usage requires less specifics to distinguish entities from each other. This will also tell a reader that there is no need to check if this variable is used anywhere else. Use code blocks and namespaces for that.

Violating this rule harms code understanding and harms design, since others may use variables in an unintended way, creating more coupling between modules than needed.

Do not create synonyms, use one term for everything related to what is meant by this term. You need to name one entity the same way everywhere. This way people will faster understand code and will be more careful when noting differences in names – they will expect the meaning is also different.

Bad: char console[] = «STD_OUT»;
Good: char std_out_name[] = «STD_OUT»;

Bad:
QLineEdit* rundir_editor_ = nullptr;
QPushButton* select_dir_ = nullptr; // is dir different from rundir?
Good:
QLineEdit* rundir_editor_ = nullptr;
QPushButton* select_rundir_ = nullptr;

Bad: return RecentMenuItemTextAndTooltip(mru_text, menu_item_tooltip); // all names refer to one entity using different wording

Do not use shortenings of words as a main method. It leads to overly relaxed attitude to naming and indulges to the reluctance to find simpler and shorter terms. It also adds cognitive complexity, because it leads to non-intuitive shortenings.

Remove unnecessary prefixes and postfixes.

Bad: bool is_visual_mode() const < return visual_mode_; >
Bad: bool get_visual_mode() const < return visual_mode_; >
Good: bool visual_mode() const

Object should be named per its purpose and data, not per its type.

Bad: Coloring coloring_;
Good: Coloring custom_colors_;

Use inline comment to identify meaning of arguments passed by value, so the line can be understood without checking the function definition.

Good: traits.set_color(color, true /*custom*/);

If a function does some things, it should be named with a verb.

Bad: void JobsQueueUpdate();
Good: void UpdateJobsQueue();

If a function is a simple getter of a parameter or a property, it should be a noun or an adjective. To preserve that in some conventions simple getters can be named using the same style as variables, e.g. in snake_case() .

Bad: string GetName() const ;
Good: sting name() const ;

Function name should not contain argument type in general, because each function call will already mention its argument.

Bad: bool ValidateRectangle(const Rectangle&) const;
Good: bool Validate(const Rectangle&);

Function name should not mislead about what it does.

Bad:
bool FilesAreAvailable(files) < // may set expectation that all files will be checked
for file in files:
if reader.open_existing(file):
return true; // but it only checks if at least one file is available
return false;
>

Name function by its resulting effect, not by one of possible applications

Bad:
void RunVisualDebugger(char* argv[], int* exit_status) <
forksys(argv, exit_status);
>
Good:
void Fork(char* argv[], int* exit_status) <
forksys(argv, exit_status);
>

Avoid putting implementation in name

Bad:
void CallLsfork(char* argv[], int* exit_status) <
lsforksys(argv, exit_status); //can change in future
>
Good:
void Fork(char* argv[], int* exit_status) <
lsforksys(argv, exit_status);
>

Predicates should be named such that they will be interpreted as predicates: having true/false possible states, not multiple states, are not confused with an instance of a class.

Bad: failed_state = True # name assumes multiple failed values; also, is this about politics and sociology?
Good: failed = True # `if failed:` is perfectly readable

Bad: is_active_user = True # if this is not a property, but boolean local data holder
Bad: active_user = True # like a variable with User instance
Good: user_is_active = True

Bad: at_least_one_running_instance = True
Good: at_least_one_instance_is_running = True

Do not sacrifice meaning over beauty.

Bad:
// note that all names are rather small
class Status(Enum):
SENT = 0
ACCEPTED = 1
REFUSED = 2
STARTED = 3
COMPLETED = 4 // successfully?
FAILED = 5
IN_PROGRESS = 6
ALIVE = 7

Better:
class Status(Enum):
SENT = 0
ACCEPTED = 1
REFUSED = 2
STARTED = 3
SUCCESSFULLY_COMPLETED = 4 // long, but clear
FAILED = 5
IN_PROGRESS = 6
ALIVE = 7

Meaning should be understood without knowing of rest associated names. Classification should be nonoverlapping. This is because such names will be broadly used in contexts alone, which will mislead readers about their meaning.

Bad:
FINISHED = 5 // successfully? prematurely?
FAILED = 6 // only this line helps to understand previous line meaning, and we are still not sure if something which is FINISHED can also be FAILED
Good:
SUCCEEDED = 5
FAILED = 6

Singularity and inconsistency in décor and formatting attract attention and slows down reading. Rules of formatting are created also for faster reading. If you don’t have any special reason, do not break the formatting rules.

Bad: //break a rule of one blank line between function bodies (if it is set) if the functions are similar

Bad:
void StartUp();
void PROCESS_DATA(); // why capitals?

Avoid misleading terms.

Bad: QCheckBox* check_geometry_ ; // using “check” to show that it is a checkbox can mislead a reader that this means “test geometry for errors”, hower it just enables showing of it

Do not mix more and less general terms as synonyms.

Bad: DesignLoadStatus error; // status can be either error or success or something else, in practice error variable may hold status of success

Name associative containers such that one can understand their two-fold nature. In some conventions you may use “to” for that: key_to_value

Compound nouns are good if they are not ambiguous.

Good?: id_of_task_of_parent_stage
Good: parent_stage_task_id

Final Remarks

All of the above is a try to formulate a consistent methodology of thinking while coding and designing. I hope this may also help development managers to facilitate interns’ progress. Thank you for your time!

Try and Except in Python

The try except statement can handle exceptions. Exceptions may happen when you run a program.

Exceptions are errors that happen during execution of the program. Python won’t tell you about errors like syntax errors (grammar faults), instead it will abruptly stop.

An abrupt exit is bad for both the end user and developer.

Instead of an emergency halt, you can use a try except statement to properly deal with the problem. An emergency halt will happen if you do not properly handle exceptions.

What are exceptions in Python?

Python has built-in exceptions which can output an error. If an error occurs while running the program, it’s called an exception.

If an exception occurs, the type of exception is shown. Exceptions needs to be dealt with or the program will crash. To handle exceptions, the try-catch block is used.

All exceptions in Python inherit from the class BaseException. If you open the Python interactive shell and type the following statement it will list all built-in exceptions:

The idea of the try-except clause is to handle exceptions (errors at runtime). The syntax of the try-except block is:

The idea of the try-except block is this:

try: the code with the exception(s) to catch. If an exception is raised, it jumps straight into the except block.

except: this code is only executed if an exception occured in the try block. The except block is required with a try block, even if it contains only the pass statement.

It may be combined with the else and finally keywords.

else: Code in the else block is only executed if no exceptions were raised in the try block.

finally: The code in the finally block is always executed, regardless of if a an exception was raised or not.

Catching Exceptions in Python

The try-except block can handle exceptions. This prevents abrupt exits of the program on error. In the example below we purposely raise an exception.

After the except block, the program continues. Without a try-except block, the last line wouldn’t be reached as the program would crash.

In the above example we catch the specific exception ZeroDivisionError. You can handle any exception like this:

You can write different logic for each type of exception that happens:

try-except

Lets take do a real world example of the try-except block.

The program asks for numeric user input. Instead the user types characters in the input box. The program normally would crash. But with a try-except block it can be handled properly.

The try except statement prevents the program from crashing and properly deals with it.

Entering invalid input, makes the program continue normally:

The try except statement can be extended with the finally keyword, this will be executed if no exception is thrown:

The program continues execution if no exception has been thrown.

There are different kinds of exceptions: ZeroDivisionError, NameError, TypeError and so on. Sometimes modules define their own exceptions.

The try-except block works for function calls too:

try finally

A try-except block can have the finally clause (optionally). The finally clause is always executed.
So the general idea is:

For instance: if you open a file you’ll want to close it, you can do so in the finally clause.

try else

The else clause is executed if and only if no exception is raised. This is different from the finally clause that’s always executed.

You can catch many types of exceptions this way, where the else clause is executed only if no exception happens.

Raise Exception

Any type of exception can be raised:

Built-in exceptions

A list of Python’s Built-in Exceptions is shown below. This list shows the Exception and why it is thrown (raised).

User-defined Exceptions

Python has many standard types of exceptions, but they may not always serve your purpose.
Your program can have your own type of exceptions.

To create a user-defined exception, you have to create a class that inherits from Exception.

You made a user-defined exception named LunchError in the above code. You can raise this new exception if an error occurs.

Outputs your custom error:

Your program can have many user-defined exceptions. The program below throws exceptions based on a new projects money:

IndentationError: Unexpected Unindent in Python

Python indentation is a part of the syntax. It’s not just for decoration.

You’ll learn what these errors mean and how to solve them:

So if you want to learn how to solve those errors, then you’re in the right place.

Let’s kick things off with error #1!

How to Solve IndentationError: unexpected indent in Python

Python is a beautiful language. One of the key features of this beauty is the lack of curly braces and other symbols that mark the beginning and end of each block.

Even in C it is considered a good practice to indent, denoting different levels in the code. Compare the same C ++ code with and without indentation. First with the indentation:

And the same code without indentation:

Both codes will compile and run, but the indented code is a lot easier to read. In the second case, it isn’t clear which parenthesis goes with which.

In Python, parentheses aren’t needed, but indentation is. This is what the C++ program would look like in Python:

However, there is a downside to this beauty. If you make a mistake in the indentation, the program will be inconsistent, which will lead to errors when it’s running.

Perhaps, this is a better option than changing the indentation and not getting the error, but changing the meaning of the program.

The error IndentationError: unexpected indent is one that results from wrong indentation. It happens when there are no keywords in front of the indentation. Here’s an example:

Python expects a keyword line to come before an indented line. List of keywords followed by an indented line:

Python warns you if it finds a line that’s indented, but the previous line doesn’t have these keywords.

How to Solve IndentationError: unexpected indent error in Python

You’ll get a similar error if you don’t indent after a keyword, here’s an example:

IndentationError: expected an indented block happens when you start a construct that assumes you have at least one indented block, but you didn’t indent this.

This is an easy fix. Just indent a block that’s inside a loop or other appropriate construction.

Python uses spaces for indentation, and tabs are automatically converted to four spaces in Python 3 editors.

Another feature is that the number of indent spaces can be any, but inside the block they’re the same.

Since using different numbers of indentations can be confusing, PEP8 recommends exactly four spaces per level of indentation:

This code is possible, it won’t cause an error, but it’ll make your code look terrible to people who’ll read it later.

Often, the IndentationError: unexpected indent error shows up when copying code from any source.

This is a reason why you shouldn’t mindlessly copy-paste code from somewhere.When you borrow code, it’s always best to retype it.

So there won’t be as many errors when you run this code later. And you better understand what you copied.

Even in your very first program, you can get this error if you copy the code along with the layout characters:

Another copying error can happen when you edit your code in a text editor without the ability to replace tabs with 4 spaces, such as Notepad++, and use both tabs and spaces for indentation.

This error is the hardest to figure out because it looks like the code’s on the same line.

The first line has a tab and the second has 4 spaces, which is an entirely different level of indentation for a Python interpreter:

For this error, you can either remove or replace all of the indents, or enable service characters, in Notepad++ this looks like this:

Now you can just replace the tabs with spaces.

How to Solve IndentationError: unindent does not match any outer indentation level in Python

Another error that happens when copying code or when your attention wanders is IndentationError: unindent does not match any outer indentation level. Let’s look at some code that causes such an error:

Draw vertical lines along the indentation levels. We have three indentation levels here: –

When the lines are drawn, it becomes obvious that the indentation is not in line with the print statement. This line doesn’t belong to any of the existing indentation levels.

You need one more space, then the code will run:

One way to get around this kind of error is to use automatic code formatters based on PEP8 standards, like autopep8 or Black.

These projects are not primarily intended to fix bugs, but to bring the code up to PEP8 standard, and to maintain code consistency in the project.

When you start out with Python, it is helpful to use these utilities to make beautiful code. But you shouldn’t just do this carelessly. Pay attention to the inaccuracies that such utilities fix.

How to Solve IndentationError: unexpected unindent in Python

A much rarer error is IndentationError: unexpected unindent. Using the try-except operator causes it only under certain conditions.

If you write try, you have to include the except keyword. But if you have just a try without an except, you get SyntaxError: invalid syntax:

But you’ll get an IndentationError: unexpected unindent if you try to use try-except inside a function, loop, condition, or context.

The Python interpreter walks through the code and finds the try keyword, and searches down the except keyword lines at the same indentation level.

If it doesn’t find it, then it means the try-except operator hasn’t finished yet. Until the whole thing’s done, a line with a lower indentation level cannot appear. Here’s an example:

This error is much less common and harder to find. Try must always have at least one except. If you don’t need to do anything on an exception, use the pass keyword.

This isn’t great, but it is syntactically correct.

Use accurate error definitions in your try-except statements, and don’t use empty excepts. If you’re trying to handle an exception, use at least BaseException.

Python Traceback — Как правильно исправлять ошибки в коде

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

Содержание статьи

Понимание того, какую информацию предоставляет traceback Python является основополагающим критерием того, как стать лучшим Python программистом.

К концу данной статьи вы сможете:

Python Traceback — Как правильно читать трассировку?

Traceback (трассировка) — это отчет, который содержит вызовы выполненных функций в вашем коде в определенный момент.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Traceback называют по разному, иногда они упоминаются как трассировка стэка, обратная трассировка, и так далее. В Python используется определение “трассировка”.

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

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

Когда вы запускаете эту программу, вы получите следующую трассировку:

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

Python Traceback — Как правильно понять в чем ошибка?

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

Подробный обзор структуры трассировки в Python 3

Существует несколько секций для каждой трассировки Python, которые являются крайне важными. Диаграмма ниже описывает несколько частей:

В Python лучше всего читать трассировку снизу вверх.

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

8. Errors and Exceptions¶

Until now error messages haven’t been more than mentioned, but if you have tried out the examples you have probably seen some. There are (at least) two distinguishable kinds of errors: syntax errors and exceptions.

8.1. Syntax Errors¶

Syntax errors, also known as parsing errors, are perhaps the most common kind of complaint you get while you are still learning Python:

8.2. Exceptions¶

Even if a statement or expression is syntactically correct, it may cause an error when an attempt is made to execute it. Errors detected during execution are called exceptions and are not unconditionally fatal: you will soon learn how to handle them in Python programs. Most exceptions are not handled by programs, however, and result in error messages as shown here:

The rest of the line provides detail based on the type of exception and what caused it.

The preceding part of the error message shows the context where the exception occurred, in the form of a stack traceback. In general it contains a stack traceback listing source lines; however, it will not display lines read from standard input.

Built-in Exceptions lists the built-in exceptions and their meanings.

8.3. Handling Exceptions¶

The try statement works as follows.

First, the try clause (the statement(s) between the try and except keywords) is executed.

If no exception occurs, the except clause is skipped and execution of the try statement is finished.

If an exception occurs during execution of the try clause, the rest of the clause is skipped. Then, if its type matches the exception named after the except keyword, the except clause is executed, and then execution continues after the try/except block.

If an exception occurs which does not match the exception named in the except clause, it is passed on to outer try statements; if no handler is found, it is an unhandled exception and execution stops with a message as shown above.

A try statement may have more than one except clause, to specify handlers for different exceptions. At most one handler will be executed. Handlers only handle exceptions that occur in the corresponding try clause, not in other handlers of the same try statement. An except clause may name multiple exceptions as a parenthesized tuple, for example:

A class in an except clause is compatible with an exception if it is the same class or a base class thereof (but not the other way around — an except clause listing a derived class is not compatible with a base class). For example, the following code will print B, C, D in that order:

Note that if the except clauses were reversed (with except B first), it would have printed B, B, B — the first matching except clause is triggered.

The try … except statement has an optional else clause, which, when present, must follow all except clauses. It is useful for code that must be executed if the try clause does not raise an exception. For example:

The use of the else clause is better than adding additional code to the try clause because it avoids accidentally catching an exception that wasn’t raised by the code being protected by the try … except statement.

When an exception occurs, it may have an associated value, also known as the exception’s argument. The presence and type of the argument depend on the exception type.

If an exception has arguments, they are printed as the last part (‘detail’) of the message for unhandled exceptions.

Exception handlers don’t just handle exceptions if they occur immediately in the try clause, but also if they occur inside functions that are called (even indirectly) in the try clause. For example:

8.4. Raising Exceptions¶

The raise statement allows the programmer to force a specified exception to occur. For example:

The sole argument to raise indicates the exception to be raised. This must be either an exception instance or an exception class (a class that derives from Exception ). If an exception class is passed, it will be implicitly instantiated by calling its constructor with no arguments:

If you need to determine whether an exception was raised but don’t intend to handle it, a simpler form of the raise statement allows you to re-raise the exception:

8.5. Exception Chaining¶

The raise statement allows an optional from which enables chaining exceptions. For example:

This can be useful when you are transforming exceptions. For example:

Exception chaining happens automatically when an exception is raised inside an except or finally section. This can be disabled by using from None idiom:

8.6. User-defined Exceptions¶

Programs may name their own exceptions by creating a new exception class (see Classes for more about Python classes). Exceptions should typically be derived from the Exception class, either directly or indirectly.

Exception classes can be defined which do anything any other class can do, but are usually kept simple, often only offering a number of attributes that allow information about the error to be extracted by handlers for the exception.

Most exceptions are defined with names that end in “Error”, similar to the naming of the standard exceptions.

8.7. Defining Clean-up Actions¶

The try statement has another optional clause which is intended to define clean-up actions that must be executed under all circumstances. For example:

If a finally clause is present, the finally clause will execute as the last task before the try statement completes. The finally clause runs whether or not the try statement produces an exception. The following points discuss more complex cases when an exception occurs:

If an exception occurs during execution of the try clause, the exception may be handled by an except clause. If the exception is not handled by an except clause, the exception is re-raised after the finally clause has been executed.

An exception could occur during execution of an except or else clause. Again, the exception is re-raised after the finally clause has been executed.

If a finally clause includes a return statement, the returned value will be the one from the finally clause’s return statement, not the value from the try clause’s return statement.

A more complicated example:

As you can see, the finally clause is executed in any event. The TypeError raised by dividing two strings is not handled by the except clause and therefore re-raised after the finally clause has been executed.

In real world applications, the finally clause is useful for releasing external resources (such as files or network connections), regardless of whether the use of the resource was successful.

8.8. Predefined Clean-up Actions¶

Some objects define standard clean-up actions to be undertaken when the object is no longer needed, regardless of whether or not the operation using the object succeeded or failed. Look at the following example, which tries to open a file and print its contents to the screen.

The problem with this code is that it leaves the file open for an indeterminate amount of time after this part of the code has finished executing. This is not an issue in simple scripts, but can be a problem for larger applications. The with statement allows objects like files to be used in a way that ensures they are always cleaned up promptly and correctly.

After the statement is executed, the file f is always closed, even if a problem was encountered while processing the lines. Objects which, like files, provide predefined clean-up actions will indicate this in their documentation.

Значения исключений и ошибок в Python

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

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

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

Ошибки могут быть разных видов:

Разберем их по очереди.

Синтаксические ошибки (SyntaxError)

Синтаксические ошибки часто называют ошибками разбора. Они возникают, когда интерпретатор обнаруживает синтаксическую проблему в коде.

Рассмотрим на примере.

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

Недостаточно памяти (OutofMemoryError)

Но поскольку Python использует архитектуру управления памятью из языка C (функция malloc() ), не факт, что все процессы восстановятся — в некоторых случаях MemoryError приведет к остановке. Следовательно, обрабатывать такие ошибки не рекомендуется, и это не считается хорошей практикой.

Ошибка рекурсии (RecursionError)

Эта ошибка связана со стеком и происходит при вызове функций. Как и предполагает название, ошибка рекурсии возникает, когда внутри друг друга исполняется много методов (один из которых — с бесконечной рекурсией), но это ограничено размером стека.

Все локальные переменные и методы размещаются в стеке. Для каждого вызова метода создается стековый кадр (фрейм), внутрь которого помещаются данные переменной или результат вызова метода. Когда исполнение метода завершается, его элемент удаляется.

Ошибка отступа (IndentationError)

Эта ошибка похожа по духу на синтаксическую и является ее подвидом. Тем не менее она возникает только в случае проблем с отступами.

Исключения

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

Программы обычно не обрабатывают исключения, что приводит к подобным сообщениям об ошибке:

Ошибка типа (TypeError)

Ошибка деления на ноль (ZeroDivisionError)

Оставшаяся часть строки с ошибкой предлагает подробности о причине ошибки на основе ее типа.

Теперь рассмотрим встроенные исключения Python.

Встроенные исключения

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

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

Ошибка прерывания с клавиатуры (KeyboardInterrupt)

Исключение KeyboardInterrupt вызывается при попытке остановить программу с помощью сочетания Ctrl + C или Ctrl + Z в командной строке или ядре в Jupyter Notebook. Иногда это происходит неумышленно и подобная обработка поможет избежать подобных ситуаций.

Стандартные ошибки (StandardError)

Рассмотрим некоторые базовые ошибки в программировании.

Арифметические ошибки (ArithmeticError)

Все перечисленные выше исключения относятся к классу Arithmetic и вызываются при ошибках в арифметических операциях.

Деление на ноль (ZeroDivisionError)

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

Переполнение (OverflowError)

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

Ошибка утверждения (AssertionError)

Когда инструкция утверждения не верна, вызывается ошибка утверждения.

Ошибка атрибута (AttributeError)

Ошибка импорта (ModuleNotFoundError)

Ошибка импорта вызывается при попытке импортировать несуществующий (или неспособный загрузиться) модуль в стандартном пути или даже при допущенной ошибке в имени.

Ошибка поиска (LookupError)

LockupError выступает базовым классом для исключений, которые происходят, когда key или index используются для связывания или последовательность списка/словаря неверна или не существует.

Здесь есть два вида исключений:

Ошибка ключа

Ошибка индекса

Если пытаться получить доступ к индексу (последовательности) списка, которого не существует в этом списке или находится вне его диапазона, будет вызвана ошибка индекса (IndexError: list index out of range python).

Ошибка памяти (MemoryError)

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

Ошибка имени (NameError)

Ошибка имени возникает, когда локальное или глобальное имя не находится.

Ошибка выполнения (Runtime Error)

Ошибка типа (TypeError)

Ошибка типа вызывается при попытке объединить два несовместимых операнда или объекта.

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

Ошибка значения (ValueError)

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

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

Пользовательские исключения в Python

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

Это можно сделать, создав новый класс, который будет наследовать из класса Exception в Python.

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

Недостатки обработки исключений в Python

У использования исключений есть свои побочные эффекты, как, например, то, что программы с блоками try-except работают медленнее, а количество кода возрастает.

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

Выводы!

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

Обработка исключений — один из основных факторов, который делает код готовым к развертыванию. Это простая концепция, построенная всего на 4 блоках: try выискивает исключения, а except их обрабатывает.

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

jonasbn/rust-multiply-kata

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

First Kata: «Multiply»

Okay as promised in my previous post additional Rust posts was possibly in the pipeline, I also mentioned Codewars.com and the katas I use for practice.

First kata: «multiply». The Kata problem was formulated as:

The code does not execute properly. Try to figure out why.

The original code, looked as follows:

Here follows my solution, the solution in itself is not particularly interesting, but I can reflect on some of the things I learned from my solution (and possibly the failures leading up to the working solution)and I can spice it up with my approach to solving katas.

The main function is just so you can run it from the command line, so the project was generated using cargo like so:

This generated the src/main.rs file in a directory named: multiply containing the main function.

The main function is special: it is always the first code that runs in every executable Rust program

Now we have an idea about what function looks like in Rust. As described in the Rust cheatsheet:

And as you have noticed, when generating an application with cargo you get a classical «hello world» example for free:

Now lets skip the contents of the main function and look at the next function: multiply

Using our newly obtained knowledge, we can read that the function is named «multiply»:

The two parameters are annotated with types: i32 which mean signed integer of size 32. The important lesson here is for me to understand two things.

As I described in my post on Learning Rust, there are good resources documenting Rust so if you want to have some details on i32 just look it up.

This lines uses our two operands, which match the parameters.

Here we can observe another Rust thing: the implicit return value, I would imagine that some people coming from other programming languages, find this a tad special. The implicit return value is the last value. You do not have to write an implicit return.

The same functionality exists in Perl, I must admit that I prefer explicit returns I am bit of an readability freak and I am not a huge fan of implicitness and magic in particular.

Out complete implementation of «multiply» end looking as follows:

When you work on katas on Codewars.com, most katas hold unit-tests for testing your solution. The original tests for this kata looks as follows.

You could do TDD and write a lot of tests for observing that your code works and I encourage doing this.

The test suite can be run using cargo

I will not go into tests in this post, since our focus is on something else, the basic test structure is simple and you should be able to tweak it to your needs, so please read on.

Since we are using cargo and we get the main for free function we can also do manual testing. It just requires some minor tweaks to the main function, so we can allow it to take parameters, so we provide parameters via the command line.

Lets first do it using the modified version of a «Hello World», changed to the also popular «greeting» example.

Getting string parameters to your Rust command line application is pretty basic and the documentation is pretty clear. If you are doing something more complex I am sure there is a crate that can help you out.

Now lets apply this to our multiplier:

Do note that there are a subtle difference between then two, since we have to cast the parameters from strings to integers.

so line 8 and 9 does this: let operand1: i32 = args[1].parse().unwrap(); for each of the operands.

And there you have it, you can now test your Rust command line application if need be.

But lets get back to doing proper software development, since manual testing is tiresome and trivial (and error prone), so lets extend the unit-test suite with some more tests.

As shown earlier a test suite looks as follows:

We can easily extend this with some interesting scenarios and corner cases, because a single test should capture the essence of such a simple function:

This is all marvelous and it looks as if our simple multiplier is working as expected, but I want to leave you with a cliff hanger, based on a problem I ran into in another project, which also applies here:

The maximum value of an i32 can be extracted from Rust

Do checkout the playground if you want to fool around with this brief example.

If we multiply 2147483647 with 2147483647 we get: 4.611686e+18 and the problem is of course relevant for the negative equivalents also (it there a term for this in mathematics?).

If you want to check it out, just add the following test to the test suite, sine multiplying our maximum with 2 exceeds the maximum of our return type.

This is it for now, I will do more write ups, since they are a good way for me to get my notes and katas in order, and perhaps somebody else can benefit from my notes or get inspired to learning Rust or just solving katas on Codewars.com.

I known I am skipping over a lot of things, and I hope you can still make sense of what I am writing and enjoy it, but I aim to cover these things in other posts, where they might prove more relevant or can be the focal point of the post.

LarisaOvchinnikova / java-codewars-solutions Goto Github PK

java-codewars-solutions’s Introduction

My first steps in Java

Given an array of integers, return a new array with each value doubled.

The code does not execute properly. Try to figure out why.

Write a function that returns the total surface area and volume of a box as an array: [area, volume]

Your code will determine if the number passed is even (or not).

Find sum of two largest elements in array using one loop

Given an array of integers. Find the maximum product obtained from multiplying 2 adjacent numbers in the array.

Complete function saleHotdogs/SaleHotDogs, function accept 1 parameters:n, n is the number of customers to buy hotdogs, different numbers have different prices (refer to the following table), return a number that the customer need to pay how much money.

Complete the square sum function so that it squares each number passed into it and then sums the results together.

Create a public class called Cube without a constructor which gets one single private Integer variable Side, a getter GetSide() and a setter SetSide(int num) method for this property. Actually, getter and setter methods are not the common way to write this code in C#. In the next kata of this series, we gonna refactor the code and make it a bit more professional. Note: There’s no need to check for negative values!

Create a function isDivisible(n, x, y) that checks if a number n is divisible by two numbers x AND y. All inputs are positive, non-zero digits.

Complete the solution so that it reverses all of the words within the string passed in.

You task is to implement an simple interpreter for the notorious esoteric language HQ9+ that will work for a single character input: If the input is ‘H’, return ‘Hello World!’ If the input is ‘Q’, return the input If the input is ‘9’, return the full lyrics of 99 Bottles of Beer.

Conditions : N is divisible by divisor

N is less than or equal to bound

N is greater than 0.

Write a class Block that creates a block (Duh..) The constructor should take an array as an argument, this will contain 3 integers of the form [width, length, height] from which the Block should be created.

Write function bmi that calculates body mass index (bmi = weight / height ^ 2).

Given an array of N integers, you have to find how many times you have to add up the smallest numbers in the array until their Sum becomes greater or equal to K.

Implement a function, multiples(m, n), which returns an array of the first m multiples of the real number n. Assume that m is a positive integer.

You are going to be given a word. Your job is to return the middle character of the word. If the word’s length is odd, return the middle character. If the word’s length is even, return the middle 2 characters.

What is the output of this code?

static int Test(out int x, int y=4) < x = 6; return x * y; >static void Main(string[] args)

2/18/2017 7:34:31 PM

The answer is 30

What is the output of this code? int * test() < static int x[4]; for(int i=0;i

The ans is not 24

What is the output of this code? class A def initialize(x) puts x/2 end end class B

What is the output of this code? 30

can anyone explain how u all are getting 1 as the answer??

A compile error ^.^

Compiles and runs just fine if it’s wrapped in a class. Then the answer is 30. class Program < static int Test(out int x, int y=4) < x = 6; return x * y; >static void Main(string[] args) < int a; int z = Test(out a); Console.WriteLine(a + z); >>

def unlucky_days(year) (1..12).count < |month| Time.new(year, month, 13).friday? >end year = 2017 puts unlucky_days(year) https://www.sololearn.com/discuss/276583/?ref=app

Test Test:: (Test obj)

Ошибки «Path not found» и «Path does not exist»: как исправить

Автор: Юрий Белоусов · 24.09.2020

При работе с программами, утилитами и запуске игр пользователи могут столкнуться с появлением ошибок: «Path not found» и «Path does not exist». В этой статье рассмотрим, что это за ошибки и что делать, чтобы их исправить.

Что означают ошибки «Path not found» и «Path does not exist»

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

Обе эти ошибки оповещают об одной и той же проблеме, а именно — о невозможности построить путь к указанному файлу. Это может быть, как исполняемый exe файл, так и вспомогательные файлы, требуемые для работы программы или игры.

«Path not found» и «Path does not exist» — что делать, если возникли ошибки

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

Целостность пути может быть нарушена в результате:

Если исключить последний пункт, то решений у данной проблемы 2:

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

Если ошибки «Path not found» и «Path does not exist» возникают не во время запуска, а непосредственно во время работы программы, то диагностировать проблемный файл становится на порядок сложнее. Если в тексте ошибки указан путь, то нужно опять-таки по нему проследовать. Если из подсказок есть только конечный файл, к которому происходит обращение, то можно воспользоваться встроенным поиском Windows, чтобы его найти. Но это может стать весьма проблематичным, если файл был удален или переименован.

Ошибки «Path not found» и «Path does not exist» могут возникать и в программировании: при компиляции программ или их запуске. Причина аналогичная – не верное указан путь / url. И решение стандартное – сопоставить указанный путь с иерархией каталогов и сверить соответствие имен папок.

С абсолютным путем (вида: https://www.urfix.ru/content/images/index.php ) проблемы возникают редко, так как ссылка будет работать корректно при указании на нее из любого файла и из любой директории.

А вот с относительными путями все сложнее (вида: /content/images/index.php ), в которых не указаны корневые директории. Каждый начинающий вебмастер и программист сталкивался с подобной ошибкой. Решается элементарно: либо указывается абсолютный путь, либо – относительный, согласно иерархии каталогов.

Не нашли ответ? Тогда воспользуйтесь формой поиска:

Debugging¶

Different kinds of errors can occur in a program, and it is useful to distinguish among them in order to track them down more quickly:

The first step in debugging is to figure out which kind of error you are dealing with. Although the following sections are organized by error type, some techniques are applicable in more than one situation.

Syntax errors¶

On the other hand, the message does tell you where in the program the problem occurred. Actually, it tells you where Python noticed a problem, which is not necessarily where the error is. Sometimes the error is prior to the location of the error message, often on the preceding line.

If you are building the program incrementally, you should have a good idea about where the error is. It will be in the last line you added.

If you are copying code from a book, start by comparing your code to the book’s code very carefully. Check every character. At the same time, remember that the book might be wrong, so if you see something that looks like a syntax error, it might be.

Here are some ways to avoid the most common syntax errors:

If nothing works, move on to the next section.

I can’t get my program to run no matter what I do.¶

If the compiler says there is an error and you don’t see it, that might be because you and the compiler are not looking at the same code. Check your programming environment to make sure that the program you are editing is the one Python is trying to run. If you are not sure, try putting an obvious and deliberate syntax error at the beginning of the program. Now run (or import) it again. If the compiler doesn’t find the new error, there is probably something wrong with the way your environment is set up.

If this happens, one approach is to start again with a new program like Hello, World!, and make sure you can get a known program to run. Then gradually add the pieces of the new program to the working one.

Runtime errors¶

Once your program is syntactically correct, Python can import it and at least start running it. What could possibly go wrong?

My program does absolutely nothing.¶

This problem is most common when your file consists of functions and classes but does not actually invoke anything to start execution. This may be intentional if you only plan to import this module to supply classes and functions.

If it is not intentional, make sure that you are invoking a function to start execution, or execute one from the interactive prompt. Also see the Flow of Execution section below.

My program hangs.¶

If a program stops and seems to be doing nothing, we say it is hanging. Often that means that it is caught in an infinite loop or an infinite recursion.

Infinite Loop¶

If you think you have an infinite loop and you think you know what loop is causing the problem, add a print statement at the end of the loop that prints the values of the variables in the condition and the value of the condition.

Infinite Recursion¶

Most of the time, an infinite recursion will cause the program to run for a while and then produce a Maximum recursion depth exceeded error.

If you suspect that a function or method is causing an infinite recursion, start by checking to make sure that there is a base case. In other words, there should be some condition that will cause the function or method to return without making a recursive invocation. If not, then you need to rethink the algorithm and identify a base case.

If there is a base case but the program doesn’t seem to be reaching it, add a print statement at the beginning of the function or method that prints the parameters. Now when you run the program, you will see a few lines of output every time the function or method is invoked, and you will see the parameters. If the parameters are not moving toward the base case, you will get some ideas about why not.

Flow of Execution¶

Now when you run the program, it will print a trace of each function as it is invoked.

When I run the program I get an exception.¶

If something goes wrong during runtime, Python prints a message that includes the name of the exception, the line of the program where the problem occurred, and a traceback.

The traceback identifies the function that is currently running, and then the function that invoked it, and then the function that invoked that, and so on. In other words, it traces the path of function invocations that got you to where you are. It also includes the line number in your file where each of these calls occurs.

The first step is to examine the place in the program where the error occurred and see if you can figure out what happened. These are some of the most common runtime errors:

NameError You are trying to use a variable that doesn’t exist in the current environment. Remember that local variables are local. You cannot refer to them from outside the function where they are defined. TypeError

There are several possible causes:

I added so many print statements I get inundated with output.¶

One of the problems with using print statements for debugging is that you can end up buried in output. There are two ways to proceed: simplify the output or simplify the program.

To simplify the output, you can remove or comment out print statements that aren’t helping, or combine them, or format the output so it is easier to understand.

To simplify the program, there are several things you can do. First, scale down the problem the program is working on. For example, if you are sorting an array, sort a small array. If the program takes input from the user, give it the simplest input that causes the problem.

Second, clean up the program. Remove dead code and reorganize the program to make it as easy to read as possible. For example, if you suspect that the problem is in a deeply nested part of the program, try rewriting that part with simpler structure. If you suspect a large function, try splitting it into smaller functions and testing them separately.

Often the process of finding the minimal test case leads you to the bug. If you find that a program works in one situation but not in another, that gives you a clue about what is going on.

Similarly, rewriting a piece of code can help you find subtle bugs. If you make a change that you think doesn’t affect the program, and it does, that can tip you off.

Semantic errors¶

In some ways, semantic errors are the hardest to debug, because the compiler and the runtime system provide no information about what is wrong. Only you know what the program is supposed to do, and only you know that it isn’t doing it.

The first step is to make a connection between the program text and the behavior you are seeing. You need a hypothesis about what the program is actually doing. One of the things that makes that hard is that computers run so fast.

You will often wish that you could slow the program down to human speed, and with some debuggers you can. But the time it takes to insert a few well-placed print statements is often short compared to setting up the debugger, inserting and removing breakpoints, and walking the program to where the error is occurring.

My program doesn’t work.¶

You should ask yourself these questions:

In order to program, you need to have a mental model of how programs work. If you write a program that doesn’t do what you expect, very often the problem is not in the program; it’s in your mental model.

The best way to correct your mental model is to break the program into its components (usually the functions and methods) and test each component independently. Once you find the discrepancy between your model and reality, you can solve the problem.

Of course, you should be building and testing components as you develop the program. If you encounter a problem, there should be only a small amount of new code that is not known to be correct.

I’ve got a big hairy expression and it doesn’t do what I expect.¶

Writing complex expressions is fine as long as they are readable, but they can be hard to debug. It is often a good idea to break a complex expression into a series of assignments to temporary variables.

This can be rewritten as:

The explicit version is easier to read because the variable names provide additional documentation, and it is easier to debug because you can check the types of the intermediate variables and display their values.

Another problem that can occur with big expressions is that the order of evaluation may not be what you expect. For example, if you are translating the expression x/2pi into Python, you might write:

A good way to debug expressions is to add parentheses to make the order of evaluation explicit:

Whenever you are not sure of the order of evaluation, use parentheses. Not only will the program be correct (in the sense of doing what you intended), it will also be more readable for other people who haven’t memorized the rules of precedence.

I’ve got a function or method that doesn’t return what I expect.¶

If you have a return statement with a complex expression, you don’t have a chance to print the return value before returning. Again, you can use a temporary variable. For example, instead of:

you could write:

Now you have the opportunity to display the value of count before returning.

I’m really, really stuck and I need help.¶

First, try getting away from the computer for a few minutes. Computers emit waves that affect the brain, causing these effects:

If you find yourself suffering from any of these symptoms, get up and go for a walk. When you are calm, think about the program. What is it doing? What are some possible causes of that behavior? When was the last time you had a working program, and what did you do next?

Sometimes it just takes time to find a bug. We often find bugs when we are away from the computer and let our minds wander. Some of the best places to find bugs are trains, showers, and in bed, just before you fall asleep.

No, I really need help.¶

It happens. Even the best programmers occasionally get stuck. Sometimes you work on a program so long that you can’t see the error. A fresh pair of eyes is just the thing.

Before you bring someone else in, make sure you have exhausted the techniques described here. Your program should be as simple as possible, and you should be working on the smallest input that causes the error. You should have print statements in the appropriate places (and the output they produce should be comprehensible). You should understand the problem well enough to describe it concisely.

When you bring someone in to help, be sure to give them the information they need:

When you find the bug, take a second to think about what you could have done to find it faster. Next time you see something similar, you will be able to find the bug more quickly.

Remember, the goal is not just to make the program work. The goal is to learn how to make the program work.

An Intro to Threading in Python

Table of Contents

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Threading in Python

Python threading allows you to have different parts of your program run concurrently and can simplify your design. If you’ve got some experience in Python and want to speed up your program using threads, then this tutorial is for you!

In this article, you’ll learn:

This article assumes you’ve got the Python basics down pat and that you’re using at least version 3.6 to run the examples. If you need a refresher, you can start with the Python Learning Paths and get up to speed.

All of the sources used in this tutorial are available to you in the Real Python GitHub repo.

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.

Take the Quiz: Test your knowledge with our interactive “Python Threading” quiz. Upon completion you will receive a score so you can track your learning progress over time:

What Is a Thread?

A thread is a separate flow of execution. This means that your program will have two things happening at once. But for most Python 3 implementations the different threads do not actually execute at the same time: they merely appear to.

It’s tempting to think of threading as having two (or more) different processors running on your program, each one doing an independent task at the same time. That’s almost right. The threads may be running on different processors, but they will only be running one at a time.

Getting multiple tasks running simultaneously requires a non-standard implementation of Python, writing some of your code in a different language, or using multiprocessing which comes with some extra overhead.

Because of the way CPython implementation of Python works, threading may not speed up all tasks. This is due to interactions with the GIL that essentially limit one Python thread to run at a time.

Tasks that spend much of their time waiting for external events are generally good candidates for threading. Problems that require heavy CPU computation and spend little time waiting for external events might not run faster at all.

This is true for code written in Python and running on the standard CPython implementation. If your threads are written in C they have the ability to release the GIL and run concurrently. If you are running on a different Python implementation, check with the documentation too see how it handles threads.

If you are running a standard Python implementation, writing in only Python, and have a CPU-bound problem, you should check out the multiprocessing module instead.

Architecting your program to use threading can also provide gains in design clarity. Most of the examples you’ll learn about in this tutorial are not necessarily going to run faster because they use threads. Using threading in them helps to make the design cleaner and easier to reason about.

So, let’s stop talking about threading and start using it!

Starting a Thread

If you look around the logging statements, you can see that the main section is creating and starting the thread:

thread_function() itself doesn’t do much. It simply logs some messages with a time.sleep() in between them.

When you run this program as it is (with line twenty commented out), the output will look like this:

You’ll notice that the Thread finished after the Main section of your code did. You’ll come back to why that is and talk about the mysterious line twenty in the next section.

Daemon Threads

In computer science, a daemon is a process that runs in the background.

Let’s look a little more closely at the output of your program above. The last two lines are the interesting bit. When you run the program, you’ll notice that there is a pause (of about 2 seconds) after __main__ has printed its all done message and before the thread is finished.

This pause is Python waiting for the non-daemonic thread to complete. When your Python program ends, part of the shutdown process is to clean up the threading routine.

When you run the program now, you should see this output:

The difference here is that the final line of the output is missing. thread_function() did not get a chance to complete. It was a daemon thread, so when __main__ reached the end of its code and the program wanted to finish, the daemon was killed.

join() a Thread

Daemon threads are handy, but what about when you want to wait for a thread to stop? What about when you want to do that and not exit your program? Now let’s go back to your original program and look at that commented out line twenty:

Working With Many Threads

The example code so far has only been working with two threads: the main thread and one you started with the threading.Thread object.

Frequently, you’ll want to start a number of threads and have them do interesting work. Let’s start by looking at the harder way of doing that, and then you’ll move on to an easier method.

The harder way of starting multiple threads is the one you already know:

Running this code multiple times will likely produce some interesting results. Here’s an example output from my machine:

If you walk through the output carefully, you’ll see all three threads getting started in the order you might expect, but in this case they finish in the opposite order! Multiple runs will produce different orderings. Look for the Thread x: finishing message to tell you when each thread is done.

The order in which threads are run is determined by the operating system and can be quite hard to predict. It may (and likely will) vary from run to run, so you need to be aware of that when you design algorithms that use threading.

Fortunately, Python gives you several primitives that you’ll look at later to help coordinate threads and get them running together. Before that, let’s look at how to make managing a group of threads a bit easier.

Using a ThreadPoolExecutor

The easiest way to create it is as a context manager, using the with statement to manage the creation and destruction of the pool.

Here’s the __main__ from the last example rewritten to use a ThreadPoolExecutor :

Note: Using a ThreadPoolExecutor can cause some confusing errors.

Unfortunately, ThreadPoolExecutor will hide that exception, and (in the case above) the program terminates with no output. This can be quite confusing to debug at first.

Running your corrected example code will produce output that looks like this:

Race Conditions

Once you’ve seen what a race condition is and looked at one happening, you’ll move on to some of the primitives provided by the standard library to prevent race conditions from happening.

Race conditions can occur when two or more threads access a shared piece of data or resource. In this example, you’re going to create a large race condition that happens every time, but be aware that most race conditions are not this obvious. Frequently, they only occur rarely, and they can produce confusing results. As you can imagine, this makes them quite difficult to debug.

Fortunately, this race condition will happen every time, and you’ll walk through it in detail to explain what is happening.

For this example, you’re going to write a class that updates a database. Okay, you’re not really going to have a database: you’re just going to fake it, because that’s not the point of this article.

.update() looks a little strange. It’s simulating reading a value from a database, doing some computation on it, and then writing a new value back to the database.

Here’s how you’ll use this FakeDatabase :

.submit() has a signature that allows both positional and named arguments to be passed to the function running in the thread:

You might have expected that to happen, but let’s look at the details of what’s really going on here, as that will make the solution to this problem easier to understand.

One Thread

Before you dive into this issue with two threads, let’s step back and talk a bit about some details of how threads work.

You won’t be diving into all of the details here, as that’s not important at this level. We’ll also be simplifying a few things in a way that won’t be technically accurate but will give you the right idea of what is happening.

The diagram is laid out so that time increases as you move from top to bottom. It begins when Thread 1 is created and ends when it is terminated.

Next time.sleep() is called, which makes the current thread pause and allows other threads to run. Since there is only one thread in this example, this has no effect.

Two Threads

When Thread 2 finally goes to sleep, the shared database.value is still unmodified at zero, and both private versions of local_copy have the value one.

The two threads have interleaving access to a single shared object, overwriting each other’s results. Similar race conditions can arise when one thread frees memory or closes a file handle before the other thread is finished accessing it.

Why This Isn’t a Silly Example

The example above is contrived to make sure that the race condition happens every time you run your program. Because the operating system can swap out a thread at any time, it is possible to interrupt a statement like x = x + 1 after it has read the value of x but before it has written back the incremented value.

The details of how this happens are quite interesting, but not needed for the rest of this article, so feel free to skip over this hidden section.

How Does This Really Work Show/Hide

The code above isn’t quite as out there as you might originally have thought. It was designed to force a race condition every time you run it, but that makes it much easier to solve than most race conditions.

There are two things to keep in mind when thinking about race conditions:

Even an operation like x += 1 takes the processor many steps. Each of these steps is a separate instruction to the processor.

The operating system can swap which thread is running at any time. A thread can be swapped out after any of these small instructions. This means that a thread can be put to sleep to let another thread run in the middle of a Python statement.

Let’s look at this in detail. The REPL below shows a function that takes a parameter and increments it:

It’s rare to get a race condition like this to occur, but remember that an infrequent event taken over millions of iterations becomes likely to happen. The rarity of these race conditions makes them much, much harder to debug than regular bugs.

Now back to your regularly scheduled tutorial!

Now that you’ve seen a race condition in action, let’s find out how to solve them!

Basic Synchronization Using Lock

Fortunately, Python’s Lock will also operate as a context manager, so you can use it in a with statement, and it gets released automatically when the with block exits for any reason.

Let’s look at the FakeDatabase with a Lock added to it. The calling function stays the same:

It’s worth noting here that the thread running this function will hold on to that Lock until it is completely finished updating the database. In this case, that means it will hold the Lock while it copies, updates, sleeps, and then writes the value back to the database.

If you run this version with logging set to warning level, you’ll see this:

Look at that. Your program finally works!

You can turn on full logging by setting the level to DEBUG by adding this statement after you configure the logging output in __main__ :

Running this program with DEBUG logging turned on looks like this:

In this output you can see Thread 0 acquires the lock and is still holding it when it goes to sleep. Thread 1 then starts and attempts to acquire the same lock. Because Thread 0 is still holding it, Thread 1 has to wait. This is the mutual exclusion that a Lock provides.

Many of the examples in the rest of this article will have WARNING and DEBUG level logging. We’ll generally only show the WARNING level output, as the DEBUG logs can be quite lengthy. Try out the programs with the logging turned up and see what they do.

Deadlock

When the program calls l.acquire() the second time, it hangs waiting for the Lock to be released. In this example, you can fix the deadlock by removing the second call, but deadlocks usually happen from one of two subtle things:

Lock and RLock are two of the basic tools used in threaded programming to prevent race conditions. There are a few other that work in different ways. Before you look at them, let’s shift to a slightly different problem domain.

Producer-Consumer Threading

The Producer-Consumer Problem is a standard computer science problem used to look at threading or process synchronization issues. You’re going to look at a variant of it to get some ideas of what primitives the Python threading module provides.

For this example, you’re going to imagine a program that needs to read messages from a network and write them to disk. The program does not request a message when it wants. It must be listening and accept messages as they come in. The messages will not come in at a regular pace, but will be coming in bursts. This part of the program is called the producer.

On the other side, once you have a message, you need to write it to a database. The database access is slow, but fast enough to keep up to the average pace of messages. It is not fast enough to keep up when a burst of messages comes in. This part is the consumer.

In between the producer and the consumer, you will create a Pipeline that will be the part that changes as you learn about different synchronization objects.

Producer-Consumer Using Lock

The general design is that there is a producer thread that reads from the fake network and puts the message into a Pipeline :

The producer also uses a SENTINEL value to signal the consumer to stop after it has sent ten values. This is a little awkward, but don’t worry, you’ll see ways to get rid of this SENTINEL value after you work through this example.

On the other side of the pipeline is the consumer:

The consumer reads a message from the pipeline and writes it to a fake database, which in this case is just printing it to the display. If it gets the SENTINEL value, it returns from the function, which will terminate the thread.

This should look fairly familiar as it’s close to the __main__ code in the previous examples.

Remember that you can turn on DEBUG logging to see all of the logging messages by uncommenting this line:

It can be worthwhile to walk through the DEBUG logging messages to see exactly where each thread acquires and releases the locks.

Now let’s take a look at the Pipeline that passes messages from the producer to the consumer :

Woah! That’s a lot of code. A pretty high percentage of that is just logging statements to make it easier to see what’s happening when you run it. Here’s the same code with all of the logging statements removed:

That seems a bit more manageable. The Pipeline in this version of your code has three members:

Let’s run the code that has logging set to WARNING and see what it looks like:

While it works for this limited test, it is not a great solution to the producer-consumer problem in general because it only allows a single value in the pipeline at a time. When the producer gets a burst of messages, it will have nowhere to put them.

Producer-Consumer Using Queue

The producer also did not have to change too much:

consumer had to change a little more:

While you got to take out the code related to the SENTINEL value, you did have to do a slightly more complicated while condition. Not only does it loop until the event is set, but it also needs to keep looping until the pipeline has been emptied.

Making sure the queue is empty before the consumer finishes prevents another fun issue. If the consumer does exit while the pipeline has messages in it, there are two bad things that can happen. The first is that you lose those final messages, but the more serious one is that the producer can get caught attempting to add a message to a full queue and never return.

The rest of the consumer should look familiar.

The Pipeline has changed dramatically, however:

The core devs who wrote the standard library knew that a Queue is frequently used in multi-threading environments and incorporated all of that locking code inside the Queue itself. Queue is thread-safe.

Running this program looks like the following:

If you read through the output in my example, you can see some interesting things happening. Right at the top, you can see the producer got to create five messages and place four of them on the queue. It got swapped out by the operating system before it could place the fifth one.

The consumer then ran and pulled off the first message. It printed out that message as well as how deep the queue was at that point:

Note: Your output will be different. Your output will change from run to run. That’s the fun part of working with threads!

Try playing with different queue sizes and calls to time.sleep() in the producer or the consumer to simulate longer network or disk access times respectively. Even slight changes to these elements of the program will make large differences in your results.

Here’s what the final code looks like using queue.Queue directly:

That’s easier to read and shows how using Python’s built-in primitives can simplify a complex problem.

Lock and Queue are handy classes to solve concurrency issues, but there are others provided by the standard library. Before you wrap up this tutorial, let’s do a quick survey of some of them.

Threading Objects

There are a few more primitives offered by the Python threading module. While you didn’t need these for the examples above, they can come in handy in different use cases, so it’s good to be familiar with them.

Semaphore

Semaphores are frequently used to protect a resource that has a limited capacity. An example would be if you have a pool of connections and want to limit the size of that pool to a specific number.

Timer

A threading.Timer is a way to schedule a function to be called after a certain amount of time has passed. You create a Timer by passing in a number of seconds to wait and a function to call:

Barrier

Remember that threads are scheduled by the operating system so, even though all of the threads are released simultaneously, they will be scheduled to run one at a time.

One use for a Barrier is to allow a pool of threads to initialize themselves. Having the threads wait on a Barrier after they are initialized will ensure that none of the threads start running before all of the threads are finished with their initialization.

Conclusion: Threading in Python

You’ve now seen much of what Python threading has to offer and some examples of how to build threaded programs and the problems they solve. You’ve also seen a few instances of the problems that arise when writing and debugging threaded programs.

If you’d like to explore other options for concurrency in Python, check out Speed Up Your Python Program With Concurrency.

If you’re interested in doing a deep dive on the asyncio module, go read Async IO in Python: A Complete Walkthrough.

Whatever you do, you now have the information and confidence you need to write programs using Python threading!

Special thanks to reader JL Diaz for helping to clean up the introduction.

Take the Quiz: Test your knowledge with our interactive “Python Threading” quiz. Upon completion you will receive a score so you can track your learning progress over time:

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Threading in Python

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Jim Anderson

Jim has been programming for a long time in a variety of languages. He has worked on embedded systems, built distributed build systems, done off-shore vendor management, and sat in many, many meetings.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Master Real-World Python Skills
With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal. Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session. Happy Pythoning!

Python’s assert: Debug and Test Your Code Like a Pro

Table of Contents

Python’s assert statement allows you to write sanity checks in your code. These checks are known as assertions, and you can use them to test if certain assumptions remain true while you’re developing your code. If any of your assertions turn false, then you have a bug in your code.

Assertions are a convenient tool for documenting, debugging, and testing code during development. Once you’ve debugged and tested your code with the help of assertions, then you can turn them off to optimize the code for production. Assertions will help you make your code more efficient, robust, and reliable.

In this tutorial, you’ll learn:

To get the most out of this tutorial, you should have previous knowledge of expressions and operators, functions, conditional statements, and exceptions. Having a basic understanding of documenting, debugging, and testing Python code is also a plus.

Free Download: Get a sample chapter from Python Tricks: The Book that shows you Python’s best practices with simple examples you can apply instantly to write more beautiful + Pythonic code.

Getting to Know Assertions in Python

Python implements a feature called assertions that’s pretty useful during the development of your applications and projects. You’ll find this feature in several other languages too, such as C and Java, and it comes in handy for documenting, debugging, and testing your code.

If you’re looking for a tool to strengthen your debugging and testing process, then assertions are for you. In this section, you’ll learn the basics of assertions, including what they are, what they’re good for, and when you shouldn’t use them in your code.

What Are Assertions?

In Python, assertions are statements that you can use to set sanity checks during the development process. Assertions allow you to test the correctness of your code by checking if some specific conditions remain true, which can come in handy while you’re debugging code.

The assertion condition should always be true unless you have a bug in your program. If the condition turns out to be false, then the assertion raises an exception and terminates the execution of your program.

With assertions, you can set checks to make sure that invariants within your code stay invariant. By doing so, you can check assumptions like preconditions and postconditions. For example, you can test conditions along the lines of This argument is not None or This return value is a string. These kinds of checks can help you catch errors as soon as possible when you’re developing a program.

What Are Assertions Good For?

Assertions are mainly for debugging. They’ll help you ensure that you don’t introduce new bugs while adding features and fixing other bugs in your code. However, they can have other interesting use cases within your development process. These use cases include documenting and testing your code.

The primary role of assertions is to trigger the alarms when a bug appears in a program. In this context, assertions mean Make sure that this condition remains true. Otherwise, throw an error.

In practice, you can use assertions to check preconditions and postconditions in your programs at development time. For example, programmers often place assertions at the beginning of functions to check if the input is valid (preconditions). Programmers also place assertions before functions’ return values to check if the output is valid (postconditions).

Assertions make it clear that you want to check if a given condition is and remains true. In Python, they can also include an optional message to unambiguously describe the error or problem at hand. That’s why they’re also an efficient tool for documenting code. In this context, their main advantage is their ability to take concrete action instead of being passive, as comments and docstrings are.

Finally, assertions are also ideal for writing test cases in your code. You can write concise and to-the-point test cases because assertions provide a quick way to check if a given condition is met or not, which defines if the test passes or not.

You’ll learn more about these common use cases of assertions later in this tutorial. Now you’ll learn the basics of when you shouldn’t use assertions.

When Not to Use Assertions?

In general, you shouldn’t use assertions for data processing or data validation, because you can disable assertions in your production code, which ends up removing all your assertion-based processing and validation code. Using assertions for data processing and validation is a common pitfall, as you’ll learn in Understanding Common Pitfalls of assert later in this tutorial.

Additionally, assertions aren’t an error-handling tool. The ultimate purpose of assertions isn’t to handle errors in production but to notify you during development so that you can fix them. In this regard, you shouldn’t write code that catches assertion errors using a regular try … except statement.

Understanding Python’s assert Statements

Now you know what assertions are, what they’re good for, and when you shouldn’t use them in your code. It’s time to learn the basics of writing your own assertions. First, note that Python implements assertions as a statement with the assert keyword rather than as a function. This behavior can be a common source of confusion and issues, as you’ll learn later in this tutorial.

In this section, you’ll learn the basics of using the assert statement to introduce assertions in your code. You’ll study the syntax of the assert statement. Most importantly, you’ll understand how this statement works in Python. Finally, you’ll also learn the basics of the AssertionError exception.

The Syntax of the assert Statement

In Python, assert is a simple statement with the following syntax:

Here’s how this statement works in practice:

With a truthy expression, the assertion succeeds, and nothing happens. In that case, your program continues its normal execution. In contrast, a falsy expression makes the assertion fail, raising an AssertionError and breaking the program’s execution.

To make your assert statements clear to other developers, you should add a descriptive assertion message:

The message in this assertion clearly states which condition should be true and what is making that condition fail. Note that the assertion_message argument to assert is optional. However, it can help you better understand the condition under test and figure out the problem that you’re facing.

An important point regarding the assert syntax is that this statement doesn’t require a pair of parentheses to group the expression and the optional message. In Python, assert is a statement instead of a function. Using a pair of parentheses can lead to unexpected behaviors.

For example, an assertion like the following will raise a SyntaxWarning :

This warning has to do with non-empty tuples always being truthy in Python. In this example, the parentheses turn the assertion expression and message into a two-item tuple, which always evaluates to true.

Fortunately, recent versions of Python throw a SyntaxWarning to alert you of this misleading syntax. However, in older versions of the language, an assert statement like the one above will always succeed.

This issue often appears when you’re using long expressions or messages that take more than a single line. In these cases, the parentheses are the natural way to format the code, and you may end up with something like the following:

Using a pair of parentheses to split a long line into multiple lines is a common formatting practice in Python code. However, in the context of an assert statement, the parentheses turn the assertion expression and message into a two-item tuple.

In practice, if you want to split a long assertion into several lines, then you can use the backslash character ( \ ) for explicit line joining:

The backslash at the end of first line of this assertion joins the assertion’s two physical lines into a single logical line. This way, you can have appropriate line length without the risk of a warning or a logical error in your code.

Note: PEP 679 was created on January 7, 2022, and is proposing to allow parentheses around the assertion expression and message. If the PEP gets approved and implemented, then the issue of accidental tuples won’t affect Python code in the future.

There’s an edge case of this parentheses-related issue. If you provide only the assertion expression in parentheses, then assert will work just fine:

Why is this happening? To create a single-item tuple, you need to place a comma after the item itself. In the code above, the parentheses by themselves don’t create a tuple. That’s why the interpreter ignores the parentheses, and assert works as expected.

Even though the parentheses seem to work in the scenario described in the above example, it’s not a recommended practice. You can end up shooting yourself in the foot.

The AssertionError Exception

Most of the time, you won’t raise AssertionError exceptions explicitly in your code. The assert statement takes care of raising this exception when the assertion condition fails. Additionally, you shouldn’t attempt to handle errors by writing code that catches the AssertionError exception, as you’ll learn later in this tutorial.

Finally, AssertionError is a built-in exception that inherits from the Exception class and is considered a concrete exception that should be raised instead of subclassed.

That’s it! Now you know the basics of the assert statement. You’ve learned the statement’s syntax, how assert works in practice, and also what the main characteristics of the AssertionError exception are. It’s time to move forward and explore some effective and common ways to write assertions in Python.

Exploring Common Assertion Formats

When it comes to writing the assert statement, you’ll find several assertion formats that are common in Python code. Being aware of these formats will allow you to write better assertions.

The following examples showcase a few of these common assertion formats, starting with assertions that compare objects:

Comparison assertions are intended to test conditions that compare two or more objects using comparison operators. These assertions can also include compound expressions based on Boolean operators.

Another common assertion format is related to membership tests:

The assertion format in the example below is related to an object’s identity:

Finally, you’ll learn how to check the data type of your objects in the context of an assertion:

Type check assertions commonly involve using the built-in isinstance() function to make sure that a given object is an instance of a certain class or classes.

Even though these are some of the most common assertion formats that you’ll find in Python code, there are many other possibilities. For example, you can use the built-in all() and any() functions to write assertions that check for the truth value of items in an iterable:

The all() assertions check if all the items in an input iterable are truthy, while the any() examples check if any item in the input iterable is truthy.

Your imagination is the only limit for writing useful assertions. You can write assertions using predicate or Boolean-valued functions, regular Python objects, comparison expressions, Boolean expressions, or general Python expressions. Your assertion will depend on what specific condition you need to check at a given moment.

Now you know some of the most common assertion formats that you can use in your code. It’s time to learn about specific use cases of assertions. In the following section, you’ll learn how to use assertions to document, debug, and test your code.

Documenting Your Code With Assertions

The assert statement is an effective way to document code. For example, if you want to state that a specific condition should always be true in your code, then assert condition can be better and more effective than a comment or a docstring, as you’ll learn in a moment.

To understand why assertions can be a handy documenting tool, say that you have a function that takes a server name and a tuple of port numbers. The function will iterate over the port numbers trying to connect to the target server. For your function to work correctly, the tuple of ports shouldn’t be empty:

If someone accidentally calls get_response() with an empty tuple, then the for loop will never run, and the function will return None even if the server is available. To alert programmers to this buggy call, you can use a comment, like you did in the example above. However, using an assert statement can be more effective:

So, using assertions in situations like the one described above is an effective and powerful way to document your intentions and avoid hard-to-find bugs due to accidental errors or malicious actors.

Debugging Your Code With Assertions

At its core, the assert statement is a debugging aid for testing conditions that should remain true during your code’s normal execution. For assertions to work as a debugging tool, you should write them so that a failure indicates a bug in your code.

In this section, you’ll learn how to use the assert statement to assist you while debugging your code at development time.

An Example of Debugging With Assertions

You’ll typically use assertions to debug your code during development. The idea is to make sure that specific conditions are and remain true. If an asserted condition becomes false, then you immediately know that you have a bug.

As an example, say that you have the following Circle class:

A Few Considerations on Debugging With Assertions

In general, the conditions that you check with an assert statement should be true, unless you or another developer in your team introduces a bug in the code. In other words, these conditions should never be false. Their purpose is to quickly flag if someone introduces a bug. In this regard, assertions are early alerts in your code. These alerts are meant to be useful during development.

To properly use assertions as a debugging tool, you shouldn’t use try … except blocks that catch and handle AssertionError exceptions. If an assertion fails, then your program should crash because a condition that was supposed to be true became false. You shouldn’t change this intended behavior by catching the exception with a try … except block.

The goal of assertion should be to uncover programmers’ errors rather than users’ errors. Assertions are useful during the development process, not during production. By the time you release your code, it should be (mostly) free of bugs and shouldn’t require the assertions to work correctly.

Finally, once your code is ready for production, you don’t have to explicitly remove assertions. You can just disable them, as you’ll learn in the following section.

Disabling Assertions in Production for Performance

Now say that you’ve come to the end of your development cycle. Your code has been extensively reviewed and tested. All your assertions pass, and your code is ready for a new release. At this point, you can optimize the code for production by disabling the assertions that you added during development. Why should you optimize your code this way?

Assertions are great during development, but in production, they can affect the code’s performance. For example, a codebase with many assertions running all the time can be slower than the same code without assertions. Assertions take time to run, and they consume memory, so it’s advisable to disable them in production.

Now, how can you actually disable your assertions? Well, you have two options:

In this section, you’ll learn how to disable your assertions by using these two techniques. Before doing this, you’ll get to know the built-in __debug__ constant, which is the internal mechanism that Python uses to disable assertions.

Understanding the __debug__ Built-in Constant

The value of __debug__ depends on which mode Python runs in, normal or optimized:

Normal mode is typically the mode that you use during development, while optimized mode is what you should use in production. Now, what does __debug__ have to do with assertions? In Python, the assert statement is equivalent to the following conditional:

Normal or debug mode allows you to have assertions in place as you develop and test the code. Once your current development cycle is complete, then you can switch to optimized mode and disable the assertions to get your code ready for production.

The potential to disable assertions in optimized mode is the main reason why you must not use assert statements to validate input data but as an aid to your debugging and testing process.

Note: Assertions are typically turned off in production code to avoid any overhead or side effect that they may cause.

Now, the updated Circle works as expected if you run the code in optimized mode:

An interesting side effect of running Python in optimized mode is that code under an explicit if __debug__: condition is also disabled. Consider the following script:

Now try running the script in normal and optimized mode to check its behavior in each mode:

Setting the PYTHONOPTIMIZE Environment Variable

To try PYTHONOPTIMIZE out, fire up your command line and run the following command:

Once you’ve set PYTHONOPTIMIZE to a non-empty string, you can launch your Python interpreter with the bare-bones python command. This command will automatically run Python in optimized mode.

Now go ahead and run the following code from the directory containing your circle.py file:

Again, your assertions are off, and the Circle class accepts negative radius values. You’re running Python in optimized mode again.

Running Python in Optimized Mode

The main results of running Python in the first level of optimization is that the interpreter sets __debug__ to False and removes the assertions from the resulting compiled bytecode. These optimizations make the code smaller and potentially faster than the same code running in normal mode.

The second level of optimization does the same as the first level. It also removes all the docstrings from the compiled code, which results in an even smaller compiled bytecode.

Testing Your Code With Assertions

Testing is another field in the development process where assertions are useful. Testing boils down to comparing an observed value with an expected one to check if they’re equal or not. This kind of check perfectly fits into assertions.

Assertions must check for conditions that should typically be true, unless you have a bug in your code. This idea is another important concept behind testing.

Here are a few examples of writing test cases using assert statements. The examples below take advantage of some built-in functions, which provide the testing material:

Now, why does pytest favor plain assert statements in test cases over a custom API, which is what other testing frameworks prefer? There are a couple of remarkable advantages behind this choice:

These advantages make working with pytest a pleasant experience for beginners and people coming from other testing frameworks with custom APIs.

You can check the current value of your PYTHOPTIMIZE environment variable by running the following command:

If PYTHONOPTIMIZE is set, then this command’s output will display its current value.

A remarkable feature to note is that pytest integrates nicely with the assert statement. The library can display error reports with detailed information about the failing assertions and why they’re failing. As an example, check out the the lines starting with the E letter in the above output. They display error messages.

Understanding Common Pitfalls of assert

Even though assertions are such a great and useful tool, they have some downsides. Like any other tool, assertions can be misused. You’ve learned that you should use assertions mainly for debugging and testing code during development. In contrast, you shouldn’t rely on assertions to provide functionality in production code, which is one of the main drivers of pitfalls with assertions.

In particular, you may run into pitfalls if you use assertions for:

Another common source of issues with assertions is that keeping them enabled in production can negatively impact your code’s performance.

Finally, Python has assertions enabled by default, which can confuse developers coming from other languages. In the following sections, you’ll learn about all these possible pitfalls of assertions. You’ll also learn how to avoid them in your own Python code.

Using assert for Data Processing and Validation

You shouldn’t use assert statements to verify the user’s input or any other input data from external sources. That’s because production code typically disables assertions, which will remove all the verification.

For example, suppose you’re building an online store with Python, and you need to add functionality to accept discount coupons. You end up writing the following function:

Now consider the example of a pair of shoes at twenty-five percent off:

All right, price_with_discount() works nicely! It takes the product as a dictionary, applies the intended discount to the current price, and returns the new price. Now, try to apply some invalid discounts:

Applying an invalid discount raises an AssertionError that points out the violated condition. If you ever encounter this error while developing and testing your online store, then it shouldn’t be hard to figure out what happened by looking at the traceback.

In general, you can write assert statements to process, validate, or verify data during development. However, if those operations remain valid in production code, then make sure to replace them with an if statement or a try … except block.

Here’s a new version of price_with_discount() that uses a conditional instead of an assertion:

Now you can wrap up any calls to this function in a try … except block that catches the ValueError and sends an informative message to the users so that they can take action accordingly.

The moral of this example is that you shouldn’t rely on the assert statement for data processing or data validation, because this statement is typically turned off in production code.

Handling Errors With assert

Another important pitfall with assertions is that sometimes developers use them as a quick form of error handling. As a result, if the production code removes assertions, then important error checks are also removed from the code. So, keep in mind that assertions aren’t a replacement for good error handling.

Here’s an example of using assertions for error handling:

What can you do to fix this example? Try updating square() to use an if statement and a ValueError :

Don’t ever catch AssertionError exceptions in your code, because that would silence failing assertions, which is a clear sign of misused assertions. Instead, catch concrete exceptions that are clearly related to the errors that you’re handling and let your assertions fail.

Use assertions only to check errors that shouldn’t happen during the normal execution of your programs unless you have a bug. Remember that assertions can be disabled.

Running assert on Expressions With Side Effects

Another subtle pitfall with the assert statement appears when you use this statement to check operations, functions, or expressions that have some kind of side effect. In other words, these operations modify the state of objects outside the operation’s scope.

In those situations, the side effect takes place every time your code runs the assertion, which might silently change your program’s global state and behavior.

Consider the following toy example, in which a function modifies the value of a global variable as a side effect:

To prevent unexpected behaviors like the one in the above example, use assertion expressions that don’t cause side effects. For example, you can use pure functions that just take input arguments and return the corresponding output without modifying the state of objects from other scopes and namespaces.

Impacting Performance With assert

Too many assertions in production can impact your code’s performance. This issue becomes critical when the asserted conditions involve too much logic, such as long compound conditions, long-running predicate functions, and classes implying a costly instantiation process.

Assertions can impact your code’s performance in two main ways. They will:

An assert statement that checks for a None value can be relatively inexpensive. However, more complex assertions, especially those running heavy code, can measurably slow down your code. Assertions also consume memory to store their own code and any required data.

Additionally, to prevent performance issues during development, your assertions should be fairly slim and to the point.

Having assert Statements Enabled by Default

In contrast, other programming languages have assertions disabled by default. For example, if you’re coming into Python from Java, you may assume that your assertions won’t run unless you explicitly turn them on. This assumption can be a common source of confusion for Python beginners, so keep it in mind.

Conclusion

Now you know how to use Python’s assert statement to set sanity checks throughout your code and make sure that certain conditions are and remain true. When any of these conditions fail, you have a clear indication of what’s happening. This way, you can quickly debug and fix your code.

The assert statement is pretty handy when you need to document, debug, and test your code during the development stages. In this tutorial, you learned how to use assertions in your code and how they can make your debugging and testing process more efficient and straightforward.

In this tutorial, you learned:

With this knowledge on the assert statement, you can now write robust, reliable, and less buggy code, which can take you to the next level as a developer.

Free Download: Get a sample chapter from Python Tricks: The Book that shows you Python’s best practices with simple examples you can apply instantly to write more beautiful + Pythonic code.

Some frequent errors¶

In this section we collect some frequent errors typically found in beginner’s numpy code. We try to show where the problems come from by some easy examples and explain typical fixes.

Error: data type not understood В¶

We wish to construct an array, for example filled with zeros, but only get a data type not understood error message like this:

The reason is that the call of zeros is slightly wrong. The correct call syntax is:

In the above example, shape would be 3 and dtype is 4 which is of course an invalid type description. The following are all valid examples:

Error: setting an array element with a sequence В¶

This happens most often when we store the result of some computation which we think is scalar but in fact is not due to an error inside that computation. In the following example we compute a scalar product and store its value inside a matrix:

Why does this fail? Well, the result of dot is in this case not a scalar at all:

we started with a row vector and put the transpose on the wrong side. The other way round we get what we wanted:

Error: matrices are not aligned В¶

This error message comes from a whole class of more or less generic errors occurring during array manipulation. They can sometimes be very hard to find:

Why does this fail? We want to multiply a 3 times 3 matrix with a vector of 3 elements, everything should be fine from the mathematical point of view, no? If we look at the operands more closely we see it’s not:

The vector is really a row vector! We need to transpose it first:

Error: operands could not be broadcast В¶

The error message we look at in this section tells us that we violated the broadcasting rules. This is not uncommon as broadcasting can give very unexpected results if done wrong or not understood properly. Remember that we can (for example) add a matrix and a vector but only if their shapes fulfill certain criteria:

If we look at v :

we see that this column vector is one element to long. Let’s construct another one with matching length:

Now it works as expected.

The exact broadcasting rules can be found at:

Error: array dimensions must agree В¶

Here another simple case of a shape mismatch. We try to stack some matrices together in the usual block-matrix manipulation fashion:

We can not stack together arrays if their shapes do not match! Let’s correct our mistake and build a matrix from two individual rows:

Making 1 million requests with python-aiohttp

In this post I’d like to test limits of python aiohttp and check its performance in terms of requests per minute. Everyone knows that asynchronous code performs better when applied to network operations, but it’s still interesting to check this assumption and understand how exactly it is better and why it’s is better. I’m going to check it by trying to make 1 million requests with aiohttp client. How many requests per minute will aiohttp make? What kind of exceptions and crashes can you expect when you try to make such volume of requests with very primitive scripts? What are main gotchas that you need to think about when trying to make such volume of requests?

Hello asyncio/aiohttp

Async programming is not easy. It’s not easy because using callbacks and thinking in terms of events and event handlers requires more effort than usual synchronous programming. But it is also difficult because asyncio is still relatively new and there are few blog posts, tutorials about it. Official docs are very terse and contain only basic examples. There are some Stack Overflow questions but not that many only 410 as of time of writing (compare with 2 585 questions tagged “twisted”) There are couple of nice blog posts and articles about asyncio over there such as this, that, that or perhaps even this or this.

In synchronous world you just do:

How does that look in aiohttp?

hmm looks like I had to write lots of code for such a basic task… There is “async def” and “async with” and two “awaits” here. It seems really confusing at first sight, let’s try to explain it then.

You make your function asynchronous by using async keyword before function definition and using await keyword. There are actually two asynchronous operations that our hello() function performs. First it fetches response asynchronously, then it reads response body in asynchronous manner.

Aiohttp recommends to use ClientSession as primary interface to make requests. ClientSession allows you to store cookies between requests and keeps objects that are common for all requests (event loop, connection and other things). Session needs to be closed after using it, and closing session is another asynchronous operation, this is why you need async with every time you deal with sessions.

After you open client session you can use it to make requests. This is where another asynchronous operation starts, downloading request. Just as in case of client sessions responses must be closed explicitly, and context manager’s with statement ensures it will be closed properly in all circumstances.

To start your program you need to run it in event loop, so you need to create instance of asyncio loop and put task into this loop.

It all does sound bit difficult but it’s not that complex and looks logical if you spend some time trying to understand it.

Fetch multiple urls

Now let’s try to do something more interesting, fetching multiple urls one after another. With synchronous code you would do just:

This is really quick and easy, async will not be that easy, so you should always consider if something more complex is actually necessary for your needs. If your app works nice with synchronous code maybe there is no need to bother with async code? If you do need to bother with async code here’s how you do that. Our hello() async function stays the same but we need to wrap it in asyncio Future object and pass whole lists of Future objects as tasks to be executed in the loop.

Now let’s say we want to collect all responses in one list and do some postprocessing on them. At the moment we’re not keeping response body anywhere, we just print it, let’s return this response, keep it in list, and print all responses at the end.

To collect bunch of responses you probably need to write something along the lines of:

Common gotchas

Now let’s simulate real process of learning and let’s make mistake in above script and try to debug it, this should be really helpful for demonstration purposes.

This is how sample broken async function looks like:

This code is broken, but it’s not that easy to figure out why if you dont know much about asyncio. Even if you know Python well but you dont know asyncio or aiohttp well you’ll be in trouble to figure out what happens.

What is output of above function?

It produces following output:

What happens here? You expected to get response objects after all processing is done, but here you actually get bunch of generators, why is that?

Let’s break our code in some other way.

Again above code is broken but it’s not easy to figure out why if you’re just learning asyncio.

Above produces following output:

What happens here? If you examine your localhost logs you may see that requests are not reaching your server at all. Clearly no requests are performed. Print statement prints that responses variable contains object, and later it alerts that pending tasks were destroyed. Why is it happening? Again you forgot about await

faulty line is this

I guess main lesson from those mistakes is: always remember about using “await” if you’re actually awaiting something.

Sync vs Async

Finally time for some fun. Let’s check if async is really worth the hassle. What’s the difference in efficiency between asynchronous client and blocking client? How many requests per minute can I send with my async client?

With this questions in mind I set up simple (async) aiohttp server. My server is going to read full html text of Frankenstein by Marry Shelley. It will add random delays between responses. Some responses will have zero delay, and some will have maximum of 3 seconds delay. This should resemble real applications, few apps respond to all requests with same latency, usually latency differs from response to response.

Server code looks like this:

Synchronous client looks like this:

How long will it take to run this?

On my machine running above synchronous client took 2:45.54 minutes.

My async code looks just like above code samples above. How long will async client take?

On my machine it took 0:03.48 seconds.

It is interesting that it took exactly as long as longest delay from my server. If you look into messages printed by client script you can see how great async HTTP client is. Some responses had 0 delay but others got 3 seconds delay. In synchronous client they would be blocking and waiting, your machine would simply stay idle for this time. Async client does not waste time, when something is delayed it simply does something else, issues other requests or processes all other responses. You can see this clearly in logs, first there are responses with 0 delay, then after they arrrived you can see responses with 1 seconds delay, and so on until most delayed responses arrive.

Testing the limits

Now that we know our async client is better let’s try to test its limits and try to crash our localhost. I’m going to reset server delays to zero now (so no more random.choice of delays) and just see how fast we can go.

I’m going to start with sending 1k async requests. I’m curious how many requests my client can handle.

So 1k requests take 7 seconds, pretty nice! How about 10k? Trying to make 10k requests unfortunately fails…

That’s bad, seems like I stumbled across 10k connections problem.

It says “too many open files”, and probably refers to number of open sockets. Why does it call them files? Sockets are just file descriptors, operating systems limit number of open sockets allowed. How many files are too many? I checked with python resource module and it seems like it’s around 1024. How can we bypass this? Primitive way is just increasing limit of open files. But this is probably not the good way to go. Much better way is just adding some synchronization in your client limiting number of concurrent requests it can process. I’m going to do this by adding asyncio.Semaphore() with max tasks of 1000.

Modified client code looks like this now:

At this point I can process 10k urls. It takes 23 seconds and returns some exceptions but overall it’s pretty nice!

How about 100 000? This really makes my computer work hard but suprisingly it works ok. Server turns out to be suprisingly stable although you can see that ram usage gets pretty high at this point, cpu usage is around 100% all the time. What I find interesting is that my server takes significantly less cpu than client. Here’s snapshot of linux ps output.

Overall it took around 53 seconds to process.

Pretty powerful if you ask me.

Finally I’m going to try 1 million requests. I really hope my laptop is not going to explode when testing that.

1 000 000 requests finished in 9 minutes.

It means average request per minute rate of 111 111. Impressive.

Epilogue

You can see that asynchronous HTTP clients can be pretty powerful. Performing 1 million requests from async client is not difficult, and the client performs really well in comparison to synchronous code.

I wonder how it compares to other languages and async frameworks? Perhaps in some future post I could compare Twisted Treq with aiohttp. There is also question how many concurrent requests can be issued by async libraries in other languages. E.g. what would be results of benchmarks for some Java async frameworks? Or C++ frameworks? Or some Rust HTTP clients?

EDITS (24/04/2016)

EDITS (10/09/2016)

Earlier version of this post contained problematic usage of ClientSession that caused client to crash. You can find this older version of article here. For more details about this issue see this GitHub ticket.

EDITS (08/11/2016)

Fixed minor bugs in code samples:

Blog about programming (Python) and occasionally about data analysis

Ошибки в JavaScript и как их исправить

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

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

Как читать ошибки?

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

Типичная ошибка из Chrome выглядит так:

Теперь к самим ошибкам.

Uncaught TypeError: undefined is not a function

Связанные ошибки: number is not a function, object is not a function, string is not a function, Unhandled Error: ‘foo’ is not a function, Function Expected

Возникает при попытке вызова значения как функции, когда значение функцией не является. Например:

Эта ошибка обычно возникает, если вы пытаетесь вызвать функцию для объекта, но опечатались в названии.

Другие вариации, такие как “number is not a function” возникают при попытке вызвать число, как будто оно является функцией.

Как исправить ошибку: убедитесь в корректности имени функции. Для этой ошибки, номер строки обычно указывает в правильное место.

Uncaught ReferenceError: Invalid left-hand side in assignment

Связанные ошибки: Uncaught exception: ReferenceError: Cannot assign to ‘functionCall()’, Uncaught exception: ReferenceError: Cannot assign to ‘this’

Вызвано попыткой присвоить значение тому, чему невозможно присвоить значение.

Наиболее частый пример этой ошибки — это условие в if:

В этом примере программист случайно использовал один знак равенства вместо двух. Выражение “left-hand side in assignment” относится к левой части знака равенства, а, как можно видеть в данном примере, левая часть содержит что-то, чему нельзя присвоить значение, что и приводит к ошибке.

Uncaught TypeError: Converting circular structure to JSON

Связанные ошибки: Uncaught exception: TypeError: JSON.stringify: Not an acyclic Object, TypeError: cyclic object value, Circular reference in value argument not supported

Так как a и b в примере выше имеют ссылки друг на друга, результирующий объект не может быть приведен к JSON.

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

Unexpected token ;

Связанные ошибки: Expected ), missing ) after argument list

Интерпретатор JavaScript что-то ожидал, но не обнаружил там этого. Обычно вызвано пропущенными фигурными, круглыми или квадратными скобками.

Токен в данной ошибке может быть разным — может быть написано “Unexpected token ]”, “Expected <” или что-то еще.

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

Ошибка с [ ] < >( ) обычно вызвано несовпадающей парой. Проверьте, все ли ваши скобки имеют закрывающую пару. В этом случае, номер строки обычно указывает на что-то другое, а не на проблемный символ.

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

Unexpected; обычно вызвано символом; внутри литерала объекта или массива, или списка аргументов вызова функции. Номер строки обычно также будет верным для данного случая.

Uncaught SyntaxError: Unexpected token ILLEGAL

Связанные ошибки: Unterminated String Literal, Invalid Line Terminator

В строковом литерале пропущена закрывающая кавычка.

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

Uncaught TypeError: Cannot read property ‘foo’ of null, Uncaught TypeError: Cannot read property ‘foo’ of undefined

Связанные ошибки: TypeError: someVal is null, Unable to get property ‘foo’ of undefined or null reference

Попытка прочитать null или undefined так, как будто это объект. Например:

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

Uncaught TypeError: Cannot set property ‘foo’ of null, Uncaught TypeError: Cannot set property ‘foo’ of undefined

Связанные ошибки: TypeError: someVal is undefined, Unable to set property ‘foo’ of undefined or null reference

Попытка записать null или undefined так, как будто это объект. Например:

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

Uncaught RangeError: Maximum call stack size exceeded

Связанные ошибки: Uncaught exception: RangeError: Maximum recursion depth exceeded, too much recursion, Stack overflow

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

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

Uncaught URIError: URI malformed

Связанные ошибки: URIError: malformed URI sequence

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

XMLHttpRequest cannot load some/url. No ‘Access-Control-Allow-Origin’ header is present on the requested resource

Связанные ошибки: Cross-Origin Request Blocked: The Same Origin Policy disallows reading the remote resource at some/url

Эта проблема всегда связана с использованием XMLHttpRequest.

Как исправить ошибку: убедитесь в корректности запрашиваемого URL и в том, что он удовлетворяет same-origin policy. Хороший способ найти проблемный код — посмотреть на URL в сообщении ошибки и найти его в своём коде.

InvalidStateError: An attempt was made to use an object that is not, or is no longer, usable

Связанные ошибки: InvalidStateError, DOMException code 11

Означает то, что код вызвал функцию, которую нельзя было вызывать в текущем состоянии. Обычно связано c XMLHttpRequest при попытке вызвать на нём функции до его готовности.

Как исправить ошибку: посмотрите на код в строке, указывающей на ошибку, и убедитесь, что он вызывается в правильный момент или добавляет нужные вызовы до этого (как с xhr.open ).

Заключение

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

Какие самые непонятные ошибки вы встречали? Делитесь своими наблюдениями в комментариях.

Вопросы по ошибкам в торговых роботах для Криптовалюты

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

Общие вопросы по роботам

Дайте мне прибыльные настройки для робота
К некоторым роботам мы даем для примера настройки (Smart Investor, Pair Trading PRO), чтобы было от чего оттолкнуться дальше. Но вообще мы не даем каких-либо настроек. Настройки — это дело сугубо индивидуальное, и одни могут подойти одним, но не подходят другим трейдерам. Главное что надо понимать, торговый бот — это инструмент, а не «черный ящик». А Вы настраиваете его под себя, под свой характер торговли, под свои требования. Для подбора настроек, практически к каждому роботу мы предлагаем скрипты для тестирования и подбора параметров в ТСЛаб.

Могу ли я оплатить робота за USDT?
Да, можно, для этого напишите нам предварительно на почту (Daytschool@gmail.com) или укажите в комментариях к заказу. Мы вам пришлем номер кошелька USDT (TRC20) и укажем точную сумму на момент оплаты.

Сменил аккаунт на криптобирже, могу запустить робота там?
Да, у вас есть возможность перенести робота на другой аккаунт, перепривязка стоит 2000руб. Для этого напишите нам на почту соответствующий запрос (Daytschool@gmail.com)

При запуске робота появляется такая ошибка:

Причинами могут быть следующие случаи:
— Вы запускаете робота прямо из архива — надо распаковать все файлы.
— Вы распаковали не все файлы — надо распаковать все файлы
— Система безопасности / брандмауер не дает доступа бота к вспомогательным файлам — если на удаленном сервере, то в большинстве случае хватает перезагрузки сервера и/или запуска от имени администратора (нажать на файл правой кнопкой мышки вызвать меню, и в перечне выбрать «Запустить от имени администратора»).

При нажатии кнопки «Старт» появляется такая ошибка:

Данная ошибка значит, что в таблице настроек робота есть незаполненные поля. Если Вы какими-то полями не пользуетесь, заполните их в соответствии с инструкцией на робота (находится в папке с роботом).

Вопросы по роботам для Binance

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

У меня появляется ошибка «Ошибка HTTP» («Не могу получить котировки»). Что делать?

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

У меня появляется ошибка «Ошибка получения балансов».

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

«Ошибка получения списка позиций»

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

Возникла ошибка «Order would immediately trigger».

Стоп ордер на продажу не может быть выставлен ниже цены исполнения — это и предупреждает биржа, при этом не ставит ордер. Как только цена вернется, бот успешно установит ордер.

Возникла ошибка «Order’s position side does not match user’s setting»

Возникла ошибка «Margin is insufficient»

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

Возникла ошибка «Exceeded the maximum allowable position at current leverage».

Вы превысили допустимую позицию при текущем кредитном плече. Смените кредитное плечо или уменьшите выставляемый объем заявки.

Возникла ошибка «Invalid API-key, IP, or permissions for action».

Неправильный ключ. Здесь причин может быть несколько:
— Неправильно ввели открытый и/или закрытый (Secret) ключи.
— Перепутали местами открытый и закрытый ключ.
— Ключ создан раньше, чем открыта фьючерсная секция — надо создать новый.
— Ключ создан до активации счета.
— Добавили случайно пробел в конце поля ввода или в начале, (такое может быть и при ручном вводе и при копировании ключей).
— В настройках ключей не стоит галочка разрешающая торговлю на фьючерсах.
Пересоздайте ключи и проблема решена. Лучше пересоздавать через другой браузер (при создании через Google Chrome иногда возникают ошибки).

Ошибка «Apologies but we are unable to provide services to you as per our Terms of Use»

Ошибка говорит о том, что Бинанс не может предоставлять вам услуги в соответствии с Условиями использования Бинанса. Причина — вы живете в Америке или вы входили на биржу с Американского сервера или вы использовали VPN с IP Америки. Решение — запускать бота на другом IP адресе, не относящемся к пулу Американских IP адресов.

Вопросы по роботам для Bitmex

Появляются ошибка «ERROR: Bitmex html 502 Error» («Не могу получить котировки», » Ошибка получения балансов»)
Это ошибки общения с биржей. Общение с бирже ведется через HTTP протокол, и иногда бывают ошибки. Но бот успешно обрабатывает их, и на всякий случай выводит в логи. Ничего делать не надо, бот будет продолжать торговать.

Хочу запустить робота, но появляется такая ошибка:

У вас еще не создан кошелек на бирже (для проверки необходимо). Просто зайдите в раздел «Депозит», и биржа автоматически создаст его.
Проверьте корректность ввода ApiKey и ApiSecret.

Возникла ошибка «Exceeded the maximum allowable position at current leverage».
Вы превысили допустимую позицию при текущем кредитном плече. Смените кредитное плечо или уменьшите выставляемый объем заявки.

Возникла ошибка «You are not authorized to execute this request».
Для выполнения запроса необходима авторизация (ApiKey, ApiSecret). Проверьте корректность ввода ApiKey и ApiSecret и наличие подключения.

Возникла ошибка «This action disabled is on this account».
Обратитесь в техподдержку биржи; некоторые возможности были отключены в аккаунте.

Возникла ошибка «Reach max open order limit».
Достигнут лимит одновременно открытых заявок. Уменьшите количество заявок.

Возникла ошибка «Quantity less than min quantity».
Объем заявки меньше минимально допустимого для данного инструмента. Отрегулируйте в настройках робота объем на вход.

Возникла ошибка «Symbol is closed».
Инструмент больше недоступен (экспирация или биржа убрала его из листинга).

Вопросы по роботам для OKEx

Возникла ошибка «Order placement due to insufficient balance»
Недостаточно средств для совершения сделки.
Убедитесь что:
— У вас достаточно средств.
— Средства находятся на «Торговом счету».
— Выбран верный инструмент. (Часто бывает что на аккаунте USDT, а инструмент XXX/USD)
— Сумма сделки не превышает количество средств на счету

Где регулируется плечо?
Кредитное плечо регулируется только на сайте/приложении биржи.

Order placement failed due to insufficient balance
Недостаточно денежных средств для размещения ордера заданным объёмом, уменьшите рабочий объем или пополните депозит.

Order placement failed. Order amount should be at least 1 contract (showing up when placing an order with less than 1 contract)
Размер выставляемой позиции должен быть не менее 1 лота, измените рабочий объем.

Order placement function is blocked by the platform
В настройках ключей API не поставлено разрешение на торговлю.

Unified accountblocked
Ваш аккаунт заблокирован, обратитесь в поддержку биржи

Order modification failed for insufficient margin
Не удалось изменить ордер из-за недостаточной маржи

Insufficient balance
Недостаточно средств на балансе. Проверьте баланс кошелька и убедитесь, хватает ли нужной монеты для совершения сделки.

Вы уже сейчас можете начать изучать Видео курс- роботы в TSLab и научиться самому делать любых роботов!

Также можете научиться программировать роботов на нашем Видео курсе «Роботы для QUIK на языке Lua»

Если же вам не хочется тратить время на обучение, то вы просто можете выбрать уже готовые роботы из тех, что представлены у нас ДЛЯ TSLab, ДЛЯ QUIK, ДЛЯ MT5, ДЛЯ КРИПТОВАЛЮТЫ!

Также можете посмотреть совершенно бесплатные наработки для МТ4, Квика, МТ5. Данный раздел также постоянно пополняется.

Не откладывайте свой шанс заработать на бирже уже сегодня!

Python Operating System Coursera Quiz & Assessment Answers | Google IT Automation with Python Professional Certificate 2021

Hello Peers, Today we are going to share all week assessment and quizzes answers of Using Python to Interact with the Operating System, Google IT Automation with Python Professional course launched by Coursera for totally free of cost✅✅✅. This is a certification course for every interested student.

In case you didn’t find this course for free, then you can apply for financial ads to get this course for totally free.

Check out this article for – “How to Apply for Financial Ads?”

Here, you will find Using Python to Interact with the Operating System Exam Answers in Bold Color which are given below.

By the end of this course, you’ll be able to manipulate files and processes on your computer’s operating system. You’ll also have learned about regular expressions — a very powerful tool for processing text files — and you’ll get practice using the Linux command line on a virtual machine. And, this might feel like a stretch right now, but you’ll also write a program that processes a bunch of errors in an actual log file and then generates a summary file. That’s a super useful skill for IT Specialists to know.

What you will learn

Skills you will gain

Practice Quiz: Automation

Question 1

At a manufacturing plant, an employee spends several minutes each hour noting uptime and downtime for each of the machines they are running. Which of the following ideas would best automate this process?

This is a practical application of using Python (and some extra hardware, in this case) to automate a task, freeing up a human’s time. The solutions can be complex if the return in saved human time warrants it.

Question 2

One important aspect of automation is forensic value. Which of the following statements describes this term correctly?

Forensic value, in relation to automation, is the value we get while debugging from properly logging every action our automation scripts take.

Question 3

An employee at a technical support company is required to collate reports into a single file and send that file via email three times a day, five days a week for one month, on top of his other duties. It takes him about 15 minutes each time. He has discovered a way to automate the process, but it will take him at least 10 hours to code the automation script. Which of the following equations will help them decide whether it’s worth automating the process?

With 10 hours to automate, the employee will start saving time before the month is over.

Question 4

A company is looking at automating one of their internal processes and wants to determine if automating a process would save labor time this year. The company uses the formula [time_to_automate Peer Graded Assessment

Practice Quiz: Managing Files & Directories

Question 1

Question 2

The new_directory function creates a new directory inside the current working directory, then creates a new empty file inside the new directory, and returns the list of files in that directory. Fill in the gaps to create a file «script.py» in the directory “PythonPrograms”.

Question 3

Which of the following methods from the os module will create a new directory?

os.mkdir() will create a new directory with the name provided as a string parameter.

Question 4

The file_date function creates a new file in the current working directory, checks the date that the file was modified, and returns just the date portion of the timestamp in the format of yyyy-mm-dd. Fill in the gaps to create a file called “newfile.txt” and check the date that it was modified.

Question 5

The parent_directory function returns the name of the directory that’s located just above the current working directory. Remember that ‘..’ is a relative path alias that means “go up to the parent directory”. Fill in the gaps to complete this function.

Practice Quiz: Reading & Writing CSV Files

Question 1

We’re working with a list of flowers and some information about each one. The create_file function writes this information to a CSV file. The contents_of_file function reads this file into records and returns the information in a nicely formatted block. Fill in the gaps of the contents_of_file function to turn the data in the CSV file into a dictionary using DictReader.

Note

This question throws:

Incorrect\
Something went wrong! Contact Coursera Support about this question!

Question 2

Using the CSV file of flowers again, fill in the gaps of the contents_of_file function to process the data without turning it into a dictionary. How do you skip over the header record with the field names?

Question 3

In order to use the writerows() function of DictWriter() to write a list of dictionaries to each line of a CSV file, what steps should we take? (Check all that apply)

We have to create a DictWriter() object instance to work with, and pass to it the fieldnames parameter defined as a list of keys.

The non-optional fieldnames parameter list values should be written to the first row.

The CSV file has to be open before we can write to it.

Question 4

Which of the following is true about unpacking values into variables when reading rows of a CSV file? (Check all that apply)

We need to have the exact same amount of variables on the left side of the equals sign as the length of the sequence on the right side when unpacking rows into individual variables.

Although they read the CSV rows into different datatypes, both csv.reader or csv.DictReader can be used to parse CSV files.

We have to create an instance of the reader class we are using before we can parse the CSV file.

Question 5

If we are analyzing a file’s contents to correctly structure its data, what action are we performing on the file?

Parsing a file means analyzing its contents to correctly structure the data. As long as we know what the data is, we can organize it in a way our script can use effectively.

Reading and Writing Files

Video: Reading Files

What is the difference between the readline() and read() methods?

Both methods read from the current position. The readline() method reads one line, while read() reads until the end of the file.

Video: Iterating through Files

Can you identify which code snippet will correctly open a file and print lines one by one without whitespace?

Here, we are iterating line by line, and the strip() command is used to remove extra whitespace.

Video: Writing Files

What happens to the previous contents of a file when we open it using “w” (“write” mode)?

When using write mode, the old contents get deleted as soon as the file is opened.

Managing Files and Directories

Video: Working with Files

How can we check if a file exists inside a Python script?

The os.path.exists function will return True if the file exists, False if it doesn’t.

Video: More File Information

Some more functions of the os.path module include getsize() and isfile() which get information on the file size and determine if a file exists, respectively. In the following code snippet, what do you think will print if the file does not exist?

Because the file does not exist, getsize() will never be called and our error message will be printed instead.

Video: Directories

What’s the purpose of the os.path.join function?

By using os.path.join we can concatenate directories in a way that can be used with other os.path() functions.

Reading and Writing CSV Files

Video: What is a CSV file?

If we have data in a format we understand, then we have what we need to parse the information from the file. What does parsing really mean?

If we know the format of the data, we can separate it into understandable parts.

Video: Reading CSV Files

Which of the following lines would correctly interpret a CSV file called “file” using the CSV module? Assume that the CSV module has already been imported.

The reader() function of the CSV module will interpret the file as a CSV.

Video: Generating CSV

Which of the following must we do before using the csv.writer() function?

The file must be open, preferably using with open() as, and write permissions must be given.

Video: Reading and Writing CSV Files with Dictionaries

DictReader() allows us to convert the data in a CSV file into a standard dictionary. DictWriter() \ allows us to write data from a dictionary into a CSV file. What’s one parameter we must pass in order for DictWriter() to write our dictionary to CSV format?

This will help DictWriter() organize the CSV rows properly.

Reading and Writing Files

Graded Assessment

Source

Practice Quiz: Advanced Regular Expressions

Question 1

We’re working with a CSV file, which contains employee information. Each record has a name field, followed by a phone number field, and a role field. The phone number field contains U.S. phone numbers, and needs to be modified to the international format, with “+1-” in front of the phone number. Fill in the regular expression, using groups, to use the transform_record function to do that.

Question 2

The multi_vowel_words function returns all words with 3 or more consecutive vowels (a, e, i, o, u). Fill in the regular expression to do that.

Question 3

When capturing regex groups, what datatype does the groups method return?

Because a tupleis returned, we can access each index individually.

Question 4

The transform_comments function converts comments in a Python script into those usable by a C compiler. This means looking for text that begins with a hash mark (#) and replacing it with double slashes (//), which is the C single-line comment indicator. For the purpose of this exercise, we’ll ignore the possibility of a hash mark embedded inside of a Python command, and assume that it’s only used to indicate a comment. We also want to treat repetitive hash marks (###), (####), etc., as a single comment indicator, to be replaced with just (//) and not (#//) or (//#). Fill in the parameters of the substitution method to complete this function:

Question 5

The convert_phone_number function checks for a U.S. phone number format: XXX-XXX-XXXX (3 digits followed by a dash, 3 more digits followed by a dash, and 4 digits), and converts it to a more formal format that looks like this: (XXX) XXX-XXXX. Fill in the regular expression to complete this function.

Practice Quiz: Basic Regular Expressions

Question 1

The check_web_address function checks if the text passed qualifies as a top-level web address, meaning that it contains alphanumeric characters (which includes letters, numbers, and underscores), as well as periods, dashes, and a plus sign, followed by a period and a character-only top-level domain such as “.com”, “.info”, “.edu”, etc. Fill in the regular expression to do that, using escape characters, wildcards, repetition qualifiers, beginning and end-of-line characters, and character classes.

Question 2

The check_time function checks for the time format of a 12-hour clock, as follows: the hour is between 1 and 12, with no leading zero, followed by a colon, then minutes between 00 and 59, then an optional space, and then AM or PM, in upper or lower case. Fill in the regular expression to do that. How many of the concepts that you just learned can you use here?

Question 3

The contains_acronym function checks the text for the presence of 2 or more characters or digits surrounded by parentheses, with at least the first character in uppercase (if it’s a letter), returning True if the condition is met, or False otherwise. For example, “Instant messaging (IM) is a set of communication technologies used for text-based communication” should return True since (IM) satisfies the match conditions.” Fill in the regular expression in this function:

Question 4

What does the “r” before the pattern string in re.search(r”Py.*n”, sample.txt) indicate?

“Raw” strings just means the Python interpreter won’t try to interpret any special characters and, instead, will just pass the string to the function as it is.

Question 5

What does the plus character [+] do in regex?

The plus character [+], matches one or more occurrences of the character that comes before it.

Question 6

Fill in the code to check if the text passed includes a possible U.S. zip code, formatted as follows: exactly 5 digits, and sometimes, but not always, followed by a dash with 4 more digits. The zip code needs to be preceded by at least one space, and cannot be at the start of the text.

Practice Quiz: Regular Expressions

Question 1

When using regular expressions, which of the following expressions uses a reserved character that can represent any single character?

The dot (.) represents any single character.

Question 2

Which of the following is NOT a function of the Python regex module?

The grep command utilizes regular expressions on Linux, but is not a part of the standard re Python module.

Question 3

The circumflex [^] and the dollar sign [$] are anchor characters. What do these anchor characters do in regex?

The circumflex and the dollar sign specifically match the start and end of a line.

Question 4

When using regex, some characters represent particular types of characters. Some examples are the dollar sign, the circumflex, and the dot wildcard. What are these characters collectively known as?

Special characters, sometimes called meta characters, give special meaning to the regular expression search syntax.

Question 5

The grep command is used to scan files for a string of characters occurring that fits a specified sequence.

Regular Expressions

Video: What are regular expressions?

Which of the following demonstrates how regex (regular expressions) might be used?

Video: Why use regular expressions?

Rather than using the index() function of the string module, we can use regular expressions, which are more flexible. After importing the regular expression module re, what regex function might be used instead of standard methods?

Video: Basic Matching with grep

Using the terminal, which of the following commands will correctly use grep to find the words “sling” and “sting” (assuming they are in our file, file.txt)?

$ grep s+ing /usr/file.txt

Basic Regular Expressions

Video: Simple Matching in Python

Fill in the code to check if the text passed contains the vowels a, e and i, with exactly one occurrence of any other character in between.

Video: Wildcards and Character Classes

Fill in the code to check if the text passed contains punctuation symbols: commas, periods, colons, semicolons, question marks, and exclamation points.

Video: Repetition Qualifiers

The repeating_letter_a function checks if the text passed includes the letter “a” (lowercase or uppercase) at least twice. For example, repeating_letter_a(“banana”) is True, while repeating_letter_a(“pineapple”) is False. Fill in the code to make this work.

Video: Escaping Characters

Fill in the code to check if the text passed has at least 2 groups of alphanumeric characters (including letters, numbers, and underscores) separated by one or more whitespace characters.

Video: Regular Expressions in Action

Fill in the code to check if the text passed looks like a standard sentence, meaning that it starts with an uppercase letter, followed by at least some lowercase letters or a space, and ends with a period, question mark, or exclamation point.

Advance Regular Expressions

Video: Capturing Groups

Fix the regular expression used in the rearrange_name function so that it can match middle names, middle initials, as well as double surnames.

Video: More on Repetition Qualifiers

The long_words function returns all words that are at least 7 characters. Fill in the regular expression to complete this function.

Video: Extracting a PID Using regexes in Python

Add to the regular expression used in the extract_pid function, to return the uppercase message in parenthesis, after the process id.

Video: Splitting and Replacing

We want to split a piece of text by either the word “a” or “the”, as implemented in the following code. What is the resulting split list?

Graded Assessment

Practice Quiz: Data Streams

Question 1

Which command will print out the exit value of a script that just ran successfully?

Echo will print out the exit value (question mark variable) of a script that just ran successfully.

Question 2

Which command will create a new environment variable?

This command will create a new environment variable, and give it a value.

Question 3

Which I/O stream are we using when we use the input function to accept user input in a Python script?

STDIN is the standard I/O stream for input.

Question 4

What is the meaning of an exit code of 0?

An exit value of 0 always indicates the program exited without error.

Question 5

Which statements are true about input and raw_input in Python 2? (select all that apply)

In Python 2, input evaluates the user’s input as an expression.

raw_input gets a raw string from the user.

Practice Quiz: Processing Log Files

Question 1

You have created a Python script to read a log of users running CRON jobs. The script needs to accept a command line argument for the path to the log file. Which line of code accomplishes this?

This will assign the script’s first command line argument to the variable “syslog”.

Question 2

Which of the following is a data structure that can be used to count how many times a specific error appears in a log?

A dictionary is useful to count appearances of strings.

Question 3

Which keyword will return control back to the top of a loop when iterating through logs?

The continue statement is used to return control back to the top of a loop.

Question 4

When searching log files using regex, which regex statement will search for the alphanumeric word “IP” followed by one or more digits wrapped in parentheses using a capturing group?

This expression will search for the word “IP” followed by a space and parentheses. It uses a capture group and \d+ to capture any digit characters found in the parentheses.

Question 5

Which of the following are true about parsing log files? (Select all that apply.)

Since log files can get pretty large, it’s a good idea to parse them one line at a time instead of loading the entire file into memory at once.

We can save a lot of time by not parsing lines that don’t contain what we need.

Before we can parse our log file, we have to use the open() or with open() command on the file first.

Practice Quiz: Python Subprocesses

Question 1

What type of object does a run function return?

This object includes information related to the execution of a command.

Question 2

How can you change the current working directory where a command will be executed?

This will `change the current working directory where the command will be executed.

Question 3

When a child process is run using the subprocess module, which of the following are true? (check all that apply)

To run the external command, a secondary environment is created for the child subprocess, where the command is executed.

While the parent process is waiting on the subprocess to finish, it’s blocked, meaning the parent can’t do any work until the child finishes.

After the external command completes its work, the child process exits, and the flow of control returns to the parent.

Question 4

When using the run command of the subprocess module, what parameter, when set to True, allows us to store the output of a system command?

The capture_output parameter allows us to get and store the output of the system command we’re using.

Question 5

What does the copy method of os.environ do?

The copy method of os.environ makes a new copy of the dictionary containing the environment variables, making modification easier.

Data Streams

Video: Reading Data interactively

Which line of code from the seconds.py script will convert all integer inputs into seconds?

This line of code uses a function to convert the number of hours, minutes, and seconds into seconds.

Video: Standard Streams

Which I/O stream is the output function using when showing an error message?

STDERR displays output specifically for error messages.

Video: Environment Variables

Which directory is NOT listed in the PATH variable by default?

This directory is not listed by default.

Video: Command-Line Arguments and Exit Status

Where are the command line arguments stored?

The list of arguments are stored in the sys module.

Python Subprocesses

Video: Running System Commands in Python

A system command that sends ICMP packets can be executed within a script by using which of the following?

This function will execute a system command such as ping.

Video: Obtaining the Output of a System Command

Which of the following is a Unicode standard used to convert an array of bytes into a string?

This encoding is part of the Unicode standard that can transform an array of bytes into a string.

Video: Advanced Subprocess Management

Which method do you use to prepare a new environment to modify environment variables?

Calling this method of the os.environ dictionary will copy the current environment variables to store and prepare a new environment.

Processing Log Files

Video: Filtering Log Files with Regular Expressions

We’re using the same syslog, and we want to display the date, time, and process id that’s inside the square brackets. We can read each line of the syslog and pass the contents to the show_time_of_pid function. Fill in the gaps to extract the date, time, and process id from the passed line, and return this format: Jul 6 14:01:23 pid:29440.

Video: Making Sense out of the Data

Which of the following is a correct printout of a dictionary?

A dictionary stores key:value pairs.

Graded Assessment

Practice Quiz: Other Test Concepts

Question 1

In what type of test is the code not transparent?

This type of test relies on the tester having no knowledge of the code.

Question 2

Verifying an automation script works well with the overall system and external entities describes what type of test?

This test verifies that the different parts of the overall system interact as expected.

Question 3

_ ensures that any success or failure of a unit test is caused by the behavior of the unit in question, and doesn’t result from some external factor.

By ensuring the unit of code we are testing is isolated, we can ensure we know where the bug originated.

Question 4

A test that is written after a bug has been identified in order to ensure the bug doesn’t show up again later is called _

Regression testing is a type of software test used to confirm that a recent program or code change has not adversely affected existing features, by re-executing a full or partial selection test cases.

Question 5

What type of software testing is used to verify the software’s ability to behave well under significantly stressed testing conditions?

Load testing verifies the behavior of the software remains consistent under conditions of significant load.

Practice Quiz: Simple Tests

Question 1

You can verify that software code behaves correctly using test _.

The software code should behave the way you expect with as many possible values or test cases.

Question 2

What is the most basic way of testing a script?

The most basic way of testing a script is to use different parameters and get the expected results.

Question 3

When a test is codified into its own software, what kind of test is it?

Codifying tests into its own software and code that can be run to verify that our programs do what we expect them to do is automatic testing.

Question 4

Using _ simplifies the testing process, allowing us to verify the program’s behavior repeatedly with many possible values.

Test cases automatically test with a range of possible values to verify the program’s behavior.

Question 5

The more complex our code becomes, the more value the use of _ provides in managing errors.

Software testing is the process of evaluating computer code to determine whether or not it does what you expect it to do, and the more complex the code, the more likely failure is.

Simple Tests

Video: What is testing?

When you test software, what are you really looking for?

You want to find errors and defects when testing software.

Video: Manual Testing and Automated Testing

The advantage of running automated tests is that they will always get the same expected _ if the software code is good.

Automatic tests will always get the same expected result if the software code is good.

Unit Tests

Video: Unit Tests

An important characteristic of a unit test is _.

Unit tests test the piece of code they target.

Video: Writing Unit Tests in Python

What module can you load to use a bunch of testing methods for your unit tests?

This module provides a TestCase class with a bunch of testing methods.

Video: Edge Cases

Which of the following would NOT be considered as an edge case when testing a software’s input for a user’s first and last name?

A user’s name with only letters is expected.

Video: Additional Test Cases

Which of the following is NOT an advantage of running an automatic unit test in a suite for a single function?

It’s harder to manage multiple test scripts.

Other Test Concepts

Video: Black Box vs. White Box

Which of the following is descriptive of a black-box test case?

Black-box tests have no knowledge of the code.

Video: Other Test Types

Running a piece of software code as-is to see if it runs describes what type of testing?

Keep it up! This test finds out if the program can run in its basic form before undergoing more refined test cases.

Errors and Exceptions

Video: The Try-Except Construct

When a try block is not able to execute a function, which of the following return examples will an exception block most likely NOT return?

An exception is not meant to produce an error, but to bypass it.

Video: Raising Errors

What keyword can help provide a reason an error has occurred in a function?

This keyword is used to produce a message when a conditional is false.

Video: Testing for Expected Errors

When using the assertRaises method, what is passed first?

Way to go! The expected error is passed first.

Lab Assessment

Graded Assessment

Scripts

Practice Quiz: Other Test Concepts

Question 1

In what type of test is the code not transparent?

This type of test relies on the tester having no knowledge of the code.

Question 2

Verifying an automation script works well with the overall system and external entities describes what type of test?

This test verifies that the different parts of the overall system interact as expected.

Question 3

_ ensures that any success or failure of a unit test is caused by the behavior of the unit in question, and doesn’t result from some external factor.

By ensuring the unit of code we are testing is isolated, we can ensure we know where the bug originated.

Question 4

A test that is written after a bug has been identified in order to ensure the bug doesn’t show up again later is called _

Regression testing is a type of software test used to confirm that a recent program or code change has not adversely affected existing features, by re-executing a full or partial selection test cases.

Question 5

What type of software testing is used to verify the software’s ability to behave well under significantly stressed testing conditions?

Load testing verifies the behavior of the software remains consistent under conditions of significant load.

Practice Quiz: Simple Tests

Question 1

You can verify that software code behaves correctly using test _.

The software code should behave the way you expect with as many possible values or test cases.

Question 2

What is the most basic way of testing a script?

The most basic way of testing a script is to use different parameters and get the expected results.

Question 3

When a test is codified into its own software, what kind of test is it?

Codifying tests into its own software and code that can be run to verify that our programs do what we expect them to do is automatic testing.

Question 4

Using _ simplifies the testing process, allowing us to verify the program’s behavior repeatedly with many possible values.

Test cases automatically test with a range of possible values to verify the program’s behavior.

Question 5

The more complex our code becomes, the more value the use of _ provides in managing errors.

Software testing is the process of evaluating computer code to determine whether or not it does what you expect it to do, and the more complex the code, the more likely failure is.

Simple Tests

Video: What is testing?

When you test software, what are you really looking for?

You want to find errors and defects when testing software.

Video: Manual Testing and Automated Testing

The advantage of running automated tests is that they will always get the same expected _ if the software code is good.

Automatic tests will always get the same expected result if the software code is good.

Unit Tests

Video: Unit Tests

An important characteristic of a unit test is _.

Unit tests test the piece of code they target.

Video: Writing Unit Tests in Python

What module can you load to use a bunch of testing methods for your unit tests?

This module provides a TestCase class with a bunch of testing methods.

Video: Edge Cases

Which of the following would NOT be considered as an edge case when testing a software’s input for a user’s first and last name?

A user’s name with only letters is expected.

Video: Additional Test Cases

Which of the following is NOT an advantage of running an automatic unit test in a suite for a single function?

It’s harder to manage multiple test scripts.

Other Test Concepts

Video: Black Box vs. White Box

Which of the following is descriptive of a black-box test case?

Black-box tests have no knowledge of the code.

Video: Other Test Types

Running a piece of software code as-is to see if it runs describes what type of testing?

Keep it up! This test finds out if the program can run in its basic form before undergoing more refined test cases.

Errors and Exceptions

Video: The Try-Except Construct

When a try block is not able to execute a function, which of the following return examples will an exception block most likely NOT return?

An exception is not meant to produce an error, but to bypass it.

Video: Raising Errors

What keyword can help provide a reason an error has occurred in a function?

This keyword is used to produce a message when a conditional is false.

Video: Testing for Expected Errors

When using the assertRaises method, what is passed first?

Way to go! The expected error is passed first.

Lab Assessment

Graded Assessment

Scripts

Practice Quiz – Advanced Bash Concepts

Question 1

Which command does the while loop initiate a task(s) after?

Tasks to be performed are written after do.

Question 2

Which line is correctly written to start a FOR loop with a sample.txt file?

The contents of sample.txt are loaded into a file variable which will do any specified task.

Question 3

Which of the following Bash lines contains the condition of taking an action when n is less than or equal to 9?

This line will take an action when n is less than or equal to 9.

Question 4

Which of the following statements are true regarding Bash and Python? [Check all that apply]

When a script is complex, it’s better to write it in a more general scripting language, like Python.

Bash scripts aren’t as flexible or robust as having the entire Python language available, with its many different functions to operate on strings, lists, and dictionaries.

Because of the ease of testing and the fact that requiring testing implies complexity, Python is preferable for code requiring verification.

Question 5

The _ command lets us take only bits of each line using a field delimiter.
1 / 1 point

The cut command lets us take only bits of each line using a field delimiter.

Practice Quiz: Bash Scripting

Question 1

Which of the following commands will output a list of all files in the current directory?

The star [*] globe will echo or output all files in the current directory.

Question 2

Which module can you load in a Python script to take advantage of star [*] like in BASH?

The glob module must be imported into a Python script to utilize star [*] like in BASH.

Question 3

Conditional execution is based on the _ of commands.

In Bash scripting, the condition used in conditional execution is based on the exit status of commands.

Question 4

What command evaluates the conditions received on exit to verify that there is an exit status of 0 when the conditions are true, and 1 when they are false?

test is a command that evaluates the conditions received and exits with zero when they’re true and with one when they’re false.

Question 5

The opening square bracket ([), when combined with the closing square bracket (]), is an alias for which command?

The test command can be called with square brackets ([]).

Practice Quiz: Interacting with the Command Line

Question 1

Which of the following commands will redirect errors in a script to a file?

Question 2

When running a kill command in a terminal, what type of signal is being sent to the process?

The kill command sends a SIGTERM signal to a processor ID (PID) to terminate.

Question 3

What is required in order to read from standard input using Python?

Using sys.stdin, we can read from standard input in Python.

Question 4

_ are tokens delivered to running processes to indicate a desired action.

Using signals, we can tell a program that we want it to pause or terminate, or many other possible commands.

Question 5

In Linux, what command is used to display the contents of a directory?

The ls command lists the file contents of a directory.

Interacting with the Command Line Shell

Video: Basic Linux Commands

Which of the following Linux commands will create an empty file?

The touch command will create an empty file.

Video: Redirecting Streams

Bash Scripting

Video: Creating Bash Scripts

Which command will correctly run a bash script?

Video: Using Variables and Globs

When defining a variable you receive the “command not found” message. Which of the following commands will resolve this error?

The variable “User4” has a value of “billy”.

Video: Conditional Execution in Bash

A conditional block in Bash that starts with ‘if’, ends with which of the following lines?

The if conditional ends with fi (a backwards “if”).

Advanced Bash Concept

Video: For Loops in Bash Scripts

Which “for” conditional line will add users Paul and Jeremy to a user variable?

The elements Paul and Jeremy are added to the user variable.

Video: Advanced Command Interaction

When using the following command, what would each line of the output start with?

Video: Choosing Between Bash and Python

Which of the following statements would make it better to start using Python instead of Bash?

It is better to use Python and its standard library to use when working across multiple platforms.

Multiply in Python with Examples

In this Python tutorial, we will discuss how to multiply in python. Also, we will discuss:

Multiply in Python

Now, we will discuss how to multiply in Python. We will see how to multiply float numbers, multiply complex numbers, multiply string with an integer and Multiply two numbers using the function in python.

How to multiply numbers in Python

In python, to multiply number, we will use the asterisk character ” * ” to multiply number.

Example:

After writing the above code (how to multiply numbers in Python), Ones you will print “ number ” then the output will appear as a “ The product is: 60 ”. Here, the asterisk character is used to multiply the number.

You can refer to the below screenshot to multiply numbers in python.

This is how we can multiply numbers in python.

How to multiply float numbers in Python

In python, we can also multiply one or both numbers using asterisk character ” * “ when it is of float type, then the product is float number.

Example:

After writing the above code (how to multiply float numbers in Python), Ones you will print “ number ” then the output will appear as a “ The product is: 6.0 ”. Here, the asterisk character is used to multiply the float number.

You can refer to the below screenshot to multiply float numbers in python.

This is how we can multiply float numbers in python.

How to multiply complex numbers in Python

In python, to multiply complex numbers, we use complex() method to multiply two numbers and the complex number contains real and imaginary parts. Here, we multiply each term with the first number by each in the second.

Example:

After writing the above code (how to multiply complex numbers in Python), Ones you will print “ product ” then the output will appear as a “ The product of complex number is: (-10+24j) ”. Here, the complex() is used to multiply the complex number.

You can refer to the below screenshot to multiply complex numbers in python.

This is how we can multiply complex numbers in python

How to multiply string with an integer in python

In python, to multiply string with an integer in Python, we use a def function with parameters and it will duplicate the string n times.

Example:

After writing the above code (how to multiply string with an integer in python), Ones you will print then the output will appear as a “ Hello all Hello all Hello all Hello all Hello all ”. Here, n is 5, and s is “ Hello all “ and it will return duplicate string 5 times.

You can refer to the below screenshot to multiply string with an integer in python.

This is how we can multiply string with an integer in python.

Multiply two numbers using the function in python

In python, to multiply two numbers by using a function called def, it can take two parameters and the return will give the value of the two numbers.

Example:

After writing the above code (multiply two numbers using the function in python), Ones you will print then the output will appear as a “ The product is: 75 ”. Here, we define the function for multiplication, and then it will return the value.

You can refer to the below screenshot to multiply two numbers using the function in python

This is how we can multiply two numbers using the function in python.

Multiply two lists python

In python, to multiply two equal length lists we will use zip() to get the list and it will multiply together and then it will be appended to a new list.

Example:

After writing the above code (multiply two lists in python), Ones you will print “multiply” then the output will appear as a “ [5 10 12] ”. Here, we multiply each element from one list by the element in the other list.

You can refer to the below screenshot to multiply two list in python

Multiply two lists python

Multiply all value in the list using math.prod python

To multiply all value in the list, a prod function has been included in the math module in the standard library. We will use import math to get the product of the list.

Example:

After writing the above code (multiply all value in the list using math.prod), Ones you will print “s1 s2” then the output will appear as a “ The product of list1 is: 30 The product of list2 is: 20 ”. Here, we multiply all the elements of list1 and then list2 to get the product.

You can refer to the below screenshot multiply all value in the list using math.prod

Multiply all value in the list using traversal python

To multiply all value in the list using traversal, we need to initialize the value of the product to 1. Multiply every number with the product and traverse till the end of the list.

Example:

After writing the above code (multiply all value in the list using traversal python), Ones you will print “Multiplylist(l1) Multiplylist(l2)” then the output will appear as a “ 15 40 ”. Here, we multiply all the elements of l1 and then l2 to get the product. The value stored in the product at the end will give you results.

You can refer to the below screenshot multiply all value in the list using traversal python

Python element-wise multiplication

Let us see how we can multiply element wise in python.

In python, element-wise multiplication can be done by importing numpy. To multiply two equal-length arrays we will use np.multiply() and it will multiply element-wise.

Example:

After writing the above code (python element-wise multiplication), Ones you will print “np.multiply(m1, m2)” then the output will appear as a “ [6 5 6] ”. Here, we multiply each element and it will return a product of two m1 and m2.

You can refer to the below screenshot python element-wise multiplication.

This is how we can multiply two lists in python.

You may like following Python tutorials:

In this tutorial, we learned how to multiply in Python.

Python is one of the most popular languages in the United States of America. I have been working with Python for a long time and I have expertise in working with various libraries on Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… I have experience in working with various clients in countries like United States, Canada, United Kingdom, Australia, New Zealand, etc. Check out my profile.

The pass Statement: How to Do Nothing in Python

Table of Contents

In Python, the pass keyword is an entire statement in itself. This statement doesn’t do anything: it’s discarded during the byte-compile phase. But for a statement that does nothing, the Python pass statement is surprisingly useful.

Sometimes pass is useful in the final code that runs in production. More often, pass is useful as scaffolding while developing code. In specific cases, there are better alternatives to doing nothing.

In this tutorial, you’ll learn:

Free Bonus: Click here to get a Python Cheat Sheet and learn the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.

Python pass Statement: Syntax and Semantics

In Python syntax, new indented blocks follow a colon character ( : ). There are several places where a new indented block will appear. When you start to write Python code, the most common places are after the if keyword and after the for keyword:

After the for statement is the body of the for loop, which consists of the two indented lines immediately following the colon.

In this case, there are two statements in the body that are repeated for each value:

The statements inside this type of block are technically called a suite in the Python grammar. A suite must include one or more statements. It can’t be empty.

In this if statement, removing the pass statement would keep the functionality the same and make your code shorter. You might be wondering why the Python syntax includes a statement that tells the interpreter to do nothing. Couldn’t you achieve the same result by not writing a statement at all?

In some cases, explicitly telling Python to do nothing serves an important purpose. For example, because the pass statement doesn’t do anything, you can use it to fulfill the requirement that a suite include at least one statement:

Even if you don’t want to add any code inside the if block, an if block with no statement creates an empty suite, which is invalid Python syntax.

To fix this, you can use pass :

Temporary Uses of pass

There are many situations in which pass can be useful to you while you’re developing, even if it won’t appear in the final version of your code. Much like scaffolding, pass can be handy for holding up the main structure of your program before you fill in the details.

It might sound strange to write code that will be deleted later, but doing things this way can accelerate your initial development.

Future Code

There are many cases where the structure of the code requires, or could use, a block. While you may eventually have to write code there, it’s sometimes hard to get out of the flow of working on something specific and start working on a dependency. In these cases, a pass statement is a useful way to do the minimal amount of work for the dependency so you can go back to what you were working on.

As a concrete example, imagine writing a function that processes a string and then both writes the result to a file and returns it:

This function saves and returns the middle third of a string. You don’t need to finish implementing save_to_file() before you can test the output for an off-by-one error. However, if save_to_file() doesn’t exist in some form, then you’ll get an error.

This function doesn’t do anything, but it allows you to test get_and_save_middle() without errors.

Another use case for pass is when you’re writing a complicated flow control structure, and you want a placeholder for future code. When implementing the fizz-buzz challenge with the modulo operator, for example, it’s useful to first understand the structure of the code:

This structure identifies what should be printed in each case, which gives you the skeleton of the solution. Such structural skeletons are useful when trying to figure out the branching logic of which if statements are needed and in which order.

After you figure out the core logic of the problem, you can decide whether you’ll print() directly in the code:

This function is straightforward to use since it directly prints the strings. However, it’s not a pleasant function to test. This can be a useful trade-off. However, in coding interviews, the interviewer will sometimes ask you to write tests. Writing the structure first allows you to make sure you understand the logical flow before checking what the other requirements are.

An alternative would be to write a function that returns the string and then do the looping elsewhere:

This function pushes the printing functionality up the stack and is easier to test.

Figuring out the core conditionals and structure of the problem using pass makes it easier to decide exactly how the implementation should work later on.

This approach is also useful when writing classes. If you need to write a class to implement something, but you don’t fully understand the problem domain, then you can use pass to first understand the best layout for your code architecture.

For example, imagine you’re implementing a Candy class, but the properties you need aren’t obvious. Eventually you’ll need to conduct some careful requirement analysis, but while implementing the basic algorithms, you can make it obvious that the class isn’t ready yet:

This allows you to instantiate members of the class and pass them around without having to decide what properties are relevant to the class.

Commented Out Code

When you comment out code, it’s possible to invalidate the syntax by removing all code in a block. If you have an if … else condition, then it might be useful to comment out one of the branches:

In this example, expensive_computation() runs code that takes a long time, such as multiplying big arrays of numbers. While you’re debugging, you might need to temporarily comment out the expensive_computation() call.

For example, maybe you want to run this code against some problematic data and see why there are so many values that aren’t None by checking the logs for the description. Skipping the expensive computation for the valid values would speed up testing quite a bit.

However, this isn’t valid code:

In this example, the if branch doesn’t have any statements in it. Comments are stripped early in the parsing process, before the indentation is inspected to see where blocks begin and end.

In this case, adding a pass statement makes the code valid:

Now it’s possible to run the code, skip the expensive computation, and generate the logs with the useful information.

Partially commenting out code while troubleshooting behavior is useful in many cases. In a case like the example above, you might comment out code that takes a long time to process and isn’t the source of the problem.

Another situation in which you might want to comment out code while troubleshooting is when the commented-out code has an undesirable side effect, like sending an email or updating a counter.

Similarly, sometimes it’s useful to comment out a whole function while keeping the call. If you’re using a library that needs a callback, then you might write code like this:

This code calls get_data() and attaches a callback to the result.

It might be useful to have a test run that discards the data in order to make sure that the source is given correctly. However, this isn’t valid Python code:

Since the function has no statements in its block, Python can’t parse this code.

Once again, pass can help you:

This is valid Python code that will discard the data and help you confirm that the arguments are correct.

Markers for Debuggers

When you run code in a debugger, it’s possible to set a breakpoint in the code where the debugger will stop and allow you to inspect the program state before continuing.

When a test run triggers a breakpoint often, such as in a loop, there might be many instances where the program state isn’t interesting. To address this problem, many debuggers also allow a conditional breakpoint, a breakpoint that will trigger only when a condition is true. For example, you might set a breakpoint in a for loop that’s triggered only if a variable is None to see why this case isn’t handled correctly.

However, many debuggers allow you to set only a few basic conditions on your breakpoints, such as equality or maybe a size comparison. You might need a more complicated condition, such as checking that a string is a palindrome before breaking.

While the debugger might not be capable of checking for palindromes, Python can do so with minimal effort. You can take advantage of that functionality by having a do-nothing if statement and setting a breakpoint on the pass line:

Although the pass line doesn’t do anything, it makes it possible for you to set a breakpoint there. Now you can run this code in a debugger and break only on strings that are palindromes.

Empty Functions

In some cases, it may even be useful for you to include an empty function in the deployed version of your code. For example, a function in a library might expect a callback function to be passed in.

An even more common case is when your code defines a class that inherits from a class that expects a method to be overridden. However, in your specific case, you don’t need to do anything. Or perhaps the reason you’re overriding the code is to prevent an overridable method from doing anything.

In all those cases, you’ll need to write an empty function or method. Once again, the problem is that having no lines after the def line isn’t valid Python syntax:

This fails because a function, like other blocks, has to include at least one statement. To fix this problem, you can use pass :

Now that the function has a statement, even one that does nothing, it’s valid Python syntax.

As another example, imagine you have a function that expects a file-like object to write to. However, you want to call the function for another reason and would like to discard the output. You can use pass to write a class that discards all data:

Empty Classes

Sometimes you want to raise specific exceptions in your code because they have a specific recovery path. However, you want to make sure that those exceptions inherit from a general exception in case someone is catching the general exception. These exception classes have no behavior or data. They’re just markers.

In order to see the usefulness of a rich exception hierarchy, you can consider password rule checking. Before trying to change the password on a website, you want to test it locally for the rules it enforces:

Note: This example is purely to illustrate Python semantics and techniques. Research has shown that password complexity rules don’t increase security.

For more information, see the National Institute of Standards and Technology (NIST) guidelines and the research they’re based on.

Each of those errors should have its own exception. The following code implements those rules:

This function will raise an exception if the password doesn’t follow the specified rules. A more realistic example would note all the rules that haven’t been followed, but that’s beyond the scope of this tutorial.

You can use this function in a wrapper to print the exception in a nice way:

In this case, friendly_check() catches only InvalidPasswordError since other ValueError exceptions are probably bugs in the checker itself. It prints out the exception’s name and value, which shows the rule that wasn’t followed.

In some situations, your users might not care exactly which problems exist in the input. In that case, you would just want to catch ValueError :

In this code, all invalid input is treated the same since you don’t care what problems the credentials have.

Because of these differing use cases, check_password() needs all four exceptions:

Each of these exceptions describes a different rule being violated. In code that matches a string against more sophisticated rules, there might be many more of these, arranged in a complex structure.

Despite the need for four different classes, none of the classes has any behavior. The pass statement allows you to define all four classes quickly.

Marker Methods

Some methods in classes exist not to be called but to mark the class as somehow being associated with this method.

The Python standard library has the abc module. The name of the module stands for abstract base class. This module helps define classes that aren’t meant to be instantiated but rather serve as a common base for some other classes.

Nothing should ever instantiate the Origin class directly. Each request should come from either a LoggedIn origin or a NotLoggedIn origin. Here’s a minimalist implementation:

While a real Origin class would be more complicated, this example shows some of the basics. Origin.description() will never be called since all the subclasses must override it.

The methods in a Protocol are never called. They serve only to mark the types of needed methods:

Demonstrating how to use a Protocol like this in mypy isn’t relevant to the pass statement. But it is important to see that the body of the method has only the pass statement.

There are more examples of such markers being used outside the Python language and standard libraries. For example, they’re used in the zope.interface package to indicate interface methods and in automat to indicate inputs to a finite-state automaton.

In all these cases, classes need to have methods but never call them. Because of this, the body doesn’t matter. But since the body can’t be empty, you can use the pass statement to add a body.

Alternatives to pass

The pass statement isn’t the only way to do nothing in your code. It’s not even the shortest, as you’ll see later. It’s not even always the best or most Pythonic approach.

Any expression in Python is a valid statement, and every constant is a valid expression. So the following expressions all do nothing:

Docstrings

Even when a docstring isn’t mandatory, it’s often a good substitute for the pass statement in an empty block. You can modify some examples from earlier in this this tutorial to use a docstring instead of pass :

In all these cases, the docstring makes the code clearer. The docstring will also be visible when you use this code in the interactive interpreter and in IDEs, making it even more valuable.

Note: The docstrings above are brief because there are several classes and functions. A docstring meant for production would usually be more thorough.

One technical advantage of docstrings, especially for those functions or methods that never execute, is that they’re not marked as “uncovered” by test coverage checkers.

Ellipsis

The original use for Ellipsis was in creating multidimensional slices. However, it’s now also the recommended syntax to fill in a suite in a stub file:

This function not only does nothing, but it’s also in a file that the Python interpreter never evaluates.

Raise an Error

Permanent Uses of pass

Using pass in Exception Catching

Here’s a function that removes a file and doesn’t fail if the file doesn’t exist:

Because nothing needs to be done if a FileNotFoundError is raised, you can use pass to have a block with no other statements.

Note: It’s important to use caution when ignoring exceptions. An exception usually means that something unexpected has happened, and some recovery is needed. Before ignoring exceptions, think carefully about what could cause them.

Note that the pass statement will often be replaced by a logging statement. However, there’s no requirement to do this if the error is expected and well understood.

In this case, you could also use the context manager contextlib.suppress() to suppress the error. However, if you need to handle some errors while ignoring others, then it’s more straightforward to have an empty except class with nothing except the pass statement.

For example, if you wanted to have ensure_nonexistence() deal with directories as well as files, then you could use this approach:

Using pass in if … elif Chains

When you use long if … elif chains, sometimes you don’t need to do anything in one case. However, you can’t skip that elif because execution would continue through to the other condition.

Imagine that a recruiter gets tired of using the fizz-buzz challenge as an interview question and decides to ask it with a twist. This time, the rules are a bit different:

The interviewer believes that this new twist will make answers more interesting.

As with all coding interview questions, there are many ways to solve this challenge. But one way is to use a for loop with a chain that mimics the description above:

The if … elif chain mirrors the logic of moving to the next option only if the previous one did not take.

This use case for the pass statement allows you to avoid refactoring the logic and to keep the code arranged in a way that matches the description of the behavior.

Conclusion

You now understand what the Python pass statement does. You’re ready to use it to improve your development and debugging speed as well as to deploy it tactfully in your production code.

In this tutorial, you’ve learned:

Now you’ll be able to write better and more efficient code by knowing how to tell Python to do nothing.

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Moshe Zadka

Moshe has been using Python since 1998. He has contributed to CPython, and is a founding member of the Twisted project. He has been teaching Python in various venues since 2002.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Master Real-World Python Skills
With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal. Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session. Happy Pythoning!

Related Tutorial Categories: basics python