Python developers who are starting out are often asked questions from areas of knowledge that are unlikely to be useful in the first few months of actual work. This is due to the fact that competition for entry-level positions is very high. Growing questions help employers choose the most prepared and motivated out of a large number of candidates.
We tell you what are the differences between a job interview and real life, what grow-up questions might be asked at an interview, and what skills a novice Python developer might need in the first few months of work.
What, besides Python, might be asked at a job interview
The following are examples of questions that may come across in job interviews, but are unlikely to come across in real life as a Junior Developer. However, this does not mean that less attention should be paid to studying them.
Basic sorting and search algorithms are now being asked of specialists at any level. In this way, the employer checks the general knowledge of the theory of algorithms, the understanding of the basic principles of effective solution of these tasks, and evaluates the developer's ability to see the possibilities of code optimization.
However, in real work, a Junior specialist never reproduces algorithms from memory. In all programming languages, standard tasks are already implemented internally. For example, for sorting in Python it is sufficient to use the .sort() method or the sorted() function.
Find the index of an item in a list using the expression mylist.index("value"), and check if the item exists in any collections using the operator in:
item in collections
In addition, the memorized theory of the algorithms does not guarantee that the novice developer will be able to apply this knowledge in practice. It is rather difficult to independently notice that the written code is algorithmically inefficient - this comes only with experience. At the first stages, senior colleagues at code reviews will help you to cope with this task.
Also, much depends on the area of programming. When creating knowledge-intensive products, such as search engines or game engines, algorithms are necessary. However, most of the applications where efficiency and speed are crucial are written in C or C++. Python allows you to quickly develop programs, but the speed of execution is inferior to many other languages.
! What to repeat: Big O notation, binary search, bubble sorting, fast sorting, inset sorting
For web development, knowledge of classical algorithm theory is less of a priority. Therefore, when interviewing for a Junior-Python developer, questions about algorithms are more of an extra filter. It shows that the applicant is interested in the topic and broadening his or her horizons.
How the Internet works
Another popular interview question is what happens the moment one enters a Web site address into the browser bar? It tests a general understanding of where requests go, where answers come from, and how the browser is involved in all of this.
This area of knowledge is mostly used in the work of Frontend and Fullstack developers. In everyday life Junior specialist may need this knowledge when combining development with a DevOps or system administrator position. As in the case of algorithms, such questions are asked at interviews to assess the breadth and depth of knowledge.
What to repeat: what is DNS, where does the server code and client code run, client-server interaction.
Metaclasses are a more advanced level topic, usually encountered by applicants for Middle positions and above. However, a novice developer may also be asked questions about metaclasses to find out how erudite the candidate is.
! What to repeat: the definition of metaclasses
Metaclasses are a tool for dynamically creating classes. It is rarely used, for example in framework development. In my opinion, metaclasses have been very accurately described by Tim Peters, author of the "Zen Python" development philosophy and Timsort (the standard sorting algorithm in Python): "[Metaclasses are] a deep magic that 99% of users don't even need to think about. If you're wondering if you need to use them, you don't need to (the people who really need them know exactly why they need them, and don't need to explain why)."
Python is a language with dynamic typing, meaning that the type of variables is not declared in advance but is determined at runtime. The same variable can contain a string, a number, a list, a dictionary, and an object in turn.
Classes and functions can also be in variables and passed to other functions as arguments. This is partly why Python does not need as many design patterns as Java or C++. You can read more about this in an article about why we don't need design patterns in Python.
Many patterns in Python are implemented simply and conveniently due to the structure and features of the language - they are already built into the basic syntax, you don't need to create them separately.
You can write a generator expression in one line of code:
gen = (x**2 for x in range(10))
It's also pretty easy to work with decorators. Not all Python developers would even call these a separate pattern, as they are so natural in the language. To use a decorator, all you have to do is write:
@my_decorator def some_func(): ...
! What to repeat: how the most used patterns in Python are arranged: generators, iterators, decorators
However, questions about design patterns can still come across in interviews. "What kinds of patterns do you know?" or "List the design patterns you know." At the entry level, developers often don't think about what patterns they use, so it's definitely worth reading about their classification and implementation ahead of time.
GIL, asynchrony, and all that stuff
Multi-threading, multiprocessing, asynchrony, how it all works and what GIL is, is another area of knowledge that most applicants won't need in the first few months but might ask about on a job interview.
Such approaches are used in high-load projects (high-load web applications), specialized frameworks such as Tornado, Twisted, Aiohttp, or complex computational tasks. Working with them requires more advanced programming skills, so a Junior-Python developer is unlikely to encounter multithreading and asynchrony in the first year.
! What to repeat: the difference between flow and process and synchronous code from asynchronous code, the definition of GIL, what it is needed for
However, this does not mean that materials on these topics can be safely ignored. At the interview, knowledge in these areas will help you stand out from other candidates.
What skills will come in handy in a real job
During the first months in the company, the junior specialist is adapting to internal processes, so he mostly does small tasks: fix bugs, roll out small features, add documentation, write tests for the uncovered part of the code. To cope with them successfully you need to understand not only the language but related areas of knowledge as well. About them now, and we'll talk in detail.
SQL and databases
It's hard to imagine a job in which the Junior-Python-developer knowledge on this topic is not useful. They are needed in the most basic operations: to make an upload from the database, add new information, analyze SQL-query generated by the framework.
The version control system is an integral part of collaborative development. You need to know the basic commands, be able to create branches and resolve conflicts. Junior specialists are expected not to have to explain from scratch how to make edits without breaking anything. Of course, most companies won't allow you to accidentally git push -force and wipe someone else's changes, but having basic git skills will make life a lot easier for you and your coworkers.
Job postings usually already specify the framework you'll be working in. And experience developing in it is an important criterion for the employer. Today the most popular Python framework is Django. If you mentioned Django in the vacancy, it is advisable to know the basics of models, applications, forms, templates, views, migrations (how to create and execute them), as well as be able to set up and operate an admin panel.
The second most common framework is Flask. Here reiterate how queries are handled, how the framework interacts with databases, and how templators work.
Linux runs 96.5% of the first million servers in the world, so you can't do without it when deploying code. At the same time not all companies have DevOps engineers who help to deliver changes in the code to the server, sometimes it has to be done by the developer himself.
A junior developer needs to know the basics of interaction with the Linux terminal: working with files and directories, users, groups and superusers, the structure and purpose of standard directories, as well as installing and removing programs. In addition, working with the Linux terminal in general is much more comfortable: some operations can be performed much faster than with the graphical interface.
Beginner developers often forget that the code is written for people and must therefore be structured and clear. An obligatory part of this is strict adherence to the code formatting standards specified in PEP 8: for example, the length of a line should not exceed 79 characters, the required number of blank lines between functions and classes, variables are named with lowercase letters, classes are named with uppercase letters, constants are named completely capitalized, there are spaces around the equal sign in some cases and none in others.
Another common mistake of beginners is to save on symbols and try to write the shortest solution possible. No matter how smart it is, it's hard to understand it at a glance. Of course, the code must be efficient, but not to the detriment of readability.