Python programming language has a rich history to showcase its long journey: introduced almost 30 years ago, in 1991, Python has climbed all the way up to become one of the most popular programming languages of today. Python’s great features enrich the language even more; these include, for instance, incredible code readability, support for multiple programming paradigms, and numerous libraries and modules. This allows Python to be the go-to solution for many teams, becoming the backbone of all sorts of projects: web development, (data) science, desktop applications, machine learning, and so on.
However, this extensive functionality that Python provides comes with an important caveat: hiring the right Python developer — whether remote or onsite — becomes ever so tricky. Why? Although Python programming language is often hailed as “newbie-friendly” and “simple”, in reality, its powerful capabilities lead to challenging technical interviews. Both the interviewer and Python developer test each others’ knowledge to the maximum, often working within severe time constraints. Obviously enough, this is not the ideal environment — a Python expert needs a hiring expert with sufficient technical background to match them.
Another issue is related to the way Python developers are typically hired — hiring with just your company’s human resources department may prove to be harder than expected. We can take a look at how a typical hiring process is organized: HR managers are overburdened with large numbers of job candidates. As companies often hire during tight time windows, prospective employees are given little to no time to really showcase their knowledge: in this environment, both the recruiter and the job candidate are pressured into rushing their technical interview, trying to squeeze as much useful information as possible. Needless to say, gauging if the interviewee is a good fit becomes quite tricky.
As more and more teams are going 100% remote, the ability to work remotely is becoming increasingly important for many Python developers. With Soshace, you can take full advantage of remote work: finally, your project will not suffer from regional constraints, having to resort to local developers. Instead, you can utilize the power of the global developer community, choosing from a wide array of Python developers — all able to contribute to your team both professionally and culturally.
We pride ourselves on our remote developers — our rigorous vetting process allows us to present you with only the best of remote professionals. Behind our hiring process are countless interviews, resume screenings, and tests — and only the best Python developers make it through. Realizing the importance of soft skills, we also gauge how effective job candidates can communicate and work in a team. In today’s work culture, soft skills are no less important than hard skills — so we focus on both of these areas when testing our candidates.
So what is the right way to hire Python developers? The right way is to trust professionals to hire professionals! Whether you are planning to build a new killer web app, optimize your business performance, or something else — our Python developers are ready to join your team and realize your most creative ideas. We solve all of the problems above and let our remote Python developers concentrate on what they love doing — their job.
To test just how well a candidate knows Python, we can present them with a number of theoretical and coding challenges -- candidates are not required to memorize each line of documentation, of course, but solid foundational knowledge is always a good sign that a developer is overall proficient in programming and Python web development.
Python 2 vs. Python 3
One of the most common problems that Python developers face is the difference between Python 2 and Python 3. Although v.3 has been accepted as the new standard, there are still many large projects running Python 2 as legacy code, which means v.2 proficiency (in terms of knowing the difference between the two versions) is still a valuable skill. There are many differences between Python 2 and Python 3, so we will outline the most crucial ones.
Exhausting iterators. With the transition to Python 3, many commands of the language started to behave like generators to increase efficiency and performance. A feature like an iterator (and how it can be exhausted) can cause some confusion; this is how it would look like in Python 2:
capitals = ["Bern", "Oslo", "Vienna", "Lisbon"]
countries = ["Switzerland", "Norway", "Austria", "Portugal"]
answers = zip(capitals, countries)
print(answers)
for answer in answers:
print('{} is the capital city of {}.' .format(answer[0], answer[1]))
In Python 2, this code works fine; in Python 3, however, lines answers = zip(capitals, countries) and print(answers) result in a message like <zip object at 0x107957eb09> -- Python 3 no longer returns all these values at once to improve efficiency (as returning all values of a large list would probably stall the program altogether). The iterator was exhausted on line 4, so the loop function has nothing to loop. To make this code Python 3-compatible, we pass these values into a list:
capitals = ["Bern", "Oslo", "Vienna", "Lisbon"]
countries = ["Switzerland", "Norway", "Austria", "Portugal"]
answers = list(zip(capitals, countries))
print(answers)
for answer in answers:
print('{} is the capital city of {}.' .format(answer[0], answer[1]))
Processing user input. In Python 3, users inputs via input(0 are finally made to be stored as str objects -- this is different from Python 2 which forced the developer to utilize raw_input() instead.
Returning iterable objects. In Python 2, certain functions and methods return lists, while Python 3 updated them to return iterable objects -- this is a more memory-efficient approach as objects are normally iterated over only once. When a list is required, though, we can transform any iterable object via the list() function.
What are some bad practices that should be avoided?
Non-standard naming conventions. Some developers take Python’s brevity to the extreme and try to shave milliseconds off by not typing full variable names; that way, a line like color = “blue” becomes clr = “blue” or even c = “blue”. Besides naming conventions, aspects like code layout, indentation, commenting, and using whitespaces are important because these rules are a standard that allows for writing better code faster. Especially in a collaborative environment, developers can work with PEP 8-compliant code created by their colleagues with ease: they know what to expect from each line of code, how to organize it properly, and so on.
Silent generic exceptions. In some (very specific) cases, the try… except… combo can replace if… else…; this can be attributed to if-statements executing their checks every time they are called, while try-statements do not utilize checking at all. Using the if — else block, the “if” check is performed for the whole amount of strings in the list — in some cases, this can cause significant load. To skip constant checks, we can utilize try — except and guide the user through our program without stopping it:
try: do_something(value) except: pass
The caveat of this method that we cannot learn what type of errors we may be running and do not know what our system is doing at any given moment. Instead, we can fine-tune this method by adding specific exceptions and/or logging, making our code maintainable:
class specific_error(Exception):
pass
try:
do_something(value)
except AttributeError as e:
log.info("Error number 17 was raised")
create_backup(value)
except Exception as e:
log.debug(str(e))
raise specific_error(e)
Importing with *. Some Python programmers prefer to import functions from modules like this: from os import * -- this allows them to use functions more easily (e.g. rename instead of os.rename) However, this makes the overall code harder to debug: this function rename lies among hundreds of lines of code, so if it happens to act up, it may be hard to trace it back to its original module (which was imported as plain *)
Furthermore, carelessly importing with * can introduce errors to the code; for instance, the developer can two standard library modules:
from html import * from glob import *
However, both of these modules have a function called escape: in case of html, it escapes special HTML characters, while glob’s escape function escapes special characters in a path. In this scenario, glob overwrites html, preventing the html function from running altogether.
Long blocks of if… elif… elif… statements. In some instances, the developer has to connect a lot of if and elif statements -- and this can get cumbersome really fast:
if x == 4: a() elif x == 5: b() elif x == 6: c() elif x == 7: d() elif x == 8: e()
As we can see, there are a number of common elements that we can abstract away via dictionaries:
mapping = {
4: a,
5: b,
6: c,
7: d,
8: e,
}
mapping[x]()
Here is what we achieve by using dictionaries:
- Clarity, as dictionaries are easy to read.
- Easy editing: they can be created from files or added with input.
- Better reusability: to reuse the conditional code block given above, we can just type mapping[x](); otherwise, we would be forced into copy-pasting the code block.
Did Python get its name from Oenpelli python or African rock python?
Alright, we’re joking. Trivia fans will, of course, know that this programming language was actually named after Monty Python, a British comedy group.
How can lambda functions be used?
A lambda function allows the developer to perform compact operations without actually having to give the function a name. Typically, Python functions are defined via def our_function_name() -- lambda functions, however, do not require any name/definition at all, as they are designed for performing simple operations.
In Python, lambda functions boast the ability to take any number of arguments -- but an important caveat is that they are limited to a single expression. Its basic syntax is as follows:
lambda arguments : expression
So a no-lambda function like
def addition(a, b): return a + b
# Call the function
addition(2, 3) # Output: 5
Can be transformed into
addition = lambda a, b : a + b print addition(2, 3)
Most importantly, this little tricks allows for cleaner code and less boilerplate, highlighting Python’s famous simplistic nature. However, using a lambda function for long calculations is controversial as way too many characters are placed on a single line.
How can Generators be used? What are their benefits?
Using generators, we can declare a function with functionality similar to an iterator, which can be used in a for a loop -- this allows for cleaner code and better memory efficiency compared to a regular for loop. In a scenario where we need to, say, add up a rather small list of numbers, for loop is indeed suitable: the integers would be placed in memory for quick access.
As our list grows, however, memory can quickly become overfilled and fail to store other important information. This is where generators step in: they create list elements and store them in memory one by one instead of flooding the memory completely.
def generate_numbers(n): num, numbers = 1, [] while num < n: numbers.append(num) num += 1 return numbers total = sum(generate_numbers(1000))
