Python Advanced Programming: The Guide to Learn Python Programming. Reference with Exercises and Samples About Dynamical Programming, Multithreading, Multiprocessing, Debugging, Testing and More

By Marcus Richards

 

If you want to learn the most modern programming language in the world, then keep reading.

Python is an high-level programming language. It's a modern language, easy to learn and understand but very powerful.

It's a versatile programming language that is now being used on a lot of different projects, from world-class internet companies to small hobbyists, Python is extremely flexible and can be useful in a lot of different fields.

• With Python, you can develop apps, games and any kind of software.
• In fact, Python is one of the highest-demand skill for professional developers.

Python Advanced Programming approaches this programming language in a very practical method to make sure you can learn everything you need to start working with Python as soon as possible and to handle advanced feature of this unique language.

 

You will learn...

▸ Advanced procedural programming techniques
▸ What is Dynamic Code Execution
▸ Advanced OOP functions most developers are not aware of
▸ Functional-style programming with Python
▸ How to debug, test and profile your software
▸ How to handle multiple processes
▸ The best techniques to spread the workload on different threads

• Language: English
• Publisher: Marcus Richards
• Release date: Mar 19, 2024
• ISBN: 9798224869794

Book preview

Chapter 1: Advanced Programming Techniques

In this Chapter we will investigate a wide scope of programming methodologies and present various extra, consistently further created, Python etymological structure. Bits of the material in this segment is very trying, yet recall that the most dynamic techniques are now and again required and you can commonly skim the primary go through to get an idea of what should be conceivable and scrutinized even more circumspectly when the need rises.

The part's first area delves all the more profoundly into Python's procedural highlights. It begins by telling the best way to utilize what we previously canvassed in a novel manner, and after that profits to the topic of generators. The segment at that point presents dynamic programming—stacking modules by name at runtime and executing self-assertive code at runtime. The area comes back to the subject of nearby (settled) capacities, however what's more covers the utilization of the nonlocal watchword and recursive capacities. Prior we perceived how to utilize Python's predefined decorators—in this segment we figure out how to make our own decorators. The area finishes up with inclusion of annotations.

The second part covers all new material relating to object-oriented program-ming. It starts by the introduction of __slots__, a mechanism to minimize the memory used by any object. Then, it shows how to access object attributes without using its properties.

The section also describes functors, and context managers—these are used in conjunction with the with keyword, and in many cases (e.g., file handling) they can be used to replace try ... except ... finally constructs with simpler try ... except constructs. The section also shows how to create custom context managers, and introduces additional advanced features, including class decorators, abstract base classes, multiple inheritance, and metaclasses.

The third area intoduces some basic concepts of functional programming, and presents some valuable functions from the functools, itertools,and administrator modules. This segment additionally tells the best way to utilize halfway capacity application to simplify code, and how to make and utilize co-routines.

This chapter takes everything that we have just covered and transforms it into the deluxe Python toolbox, with all the first instruments (tech-niques and punctuations), in addition to numerous new ones that can make our programming simpler, shorter, and increasingly viable. A portion of the devices can have tradable uses, for instance, a few occupations should be possible utilizing either a class decorator or a metaclass, while others, for example, descriptors, can be utilized in various approaches to accomplish various impacts. A portion of the apparatuses secured here, for instance, setting supervisors, we will utilize constantly, and others will stay prepared close by for those specific circumstances for which they are the ideal arrangement.

––––––––

Further Procedural Programming

The majority of this area manages additional facilities relating with procedural programming and functions, yet the absolute first subsection is diverse in that it shows a helpful programming system dependent on what we previously covered without presenting any new syntax.

Branching Using Dictionaries 

As we noted before, functions are items like everything else in Python, and a function’s name is an object reference that alludes to the functions. On the off chance that we compose a function’s name without brackets, Python realizes we mean the reference, and we can transfer such references around simply like any others. We can utilize this reality to supplant if proclamations that have loads of elif provisions with a single function call.

We will obseve an intelligent console called dvds-dbm.py, featuring the following menu:

(A)dd (E)dit (L)ist (R)emove (I)mport e(X)port (Q)uit

The software has a function that gets the user’s decision and which will return just a legitimate decision, for this situation one of an, e, l, r, I, x, and q. Here are two proportional code pieces for calling the important functions dependent on the user’s decision:

––––––––

if action == a:

add_dvd(db)

elif action == e:

edit_dvd(db)

elif action == l:

list_dvds(db)

elif action == r:

remove_dvd(db)

elif action == i:

import_(db)

elif action == x:

export(db)

elif action == q:

quit(db)

functions = dict(a=add_dvd, e=edit_dvd, l=list_dvds, r=remove_dvd, i=import_, x=export, q=quit)

functions[action](db)

The decision is held as a one-character string in the activity variable, and the database to be utilized is held in the db variable. The import_() function has a trailing underscore to keep it distinct from the built-in import proclamation.

In the correct hand code piece we make a lexicon whose keys are the legitimate menu decisions, and whose qualities are function references. In the second proclamation we recover the function reference comparing to the given activity and call the function alluded to utilizing the call administrator, (), and in this model, passing the db contention. Not exclusively is the code on the right-hand side a lot shorter than the code on the left, yet in addition it can scale (have unmistakably more word reference things) without influencing its performance, dissimilar to one side hand code whose speed relies upon what number of elifs must be tried to locate the suitable function to call.

The convert-incidents.py program uses this technique in its import_() method, as this extract from the method shows:

call = {(.aix, dom): self.import_xml_dom,

(.aix, etree): self.import_xml_etree,

(.aix, sax): self.import_xml_sax,

(.ait, manual): self.import_text_manual,

(.ait, regex): self.import_text_regex,

(.aib, None): self.import_binary,

(.aip, None): self.import_pickle}

result = call[extension, reader](filename)

The total method is 13 lines in length; the expansion parameter is processed in the method, and the reader is passed in. The word reference keys are 2-tuples, and the qualities are methods. On the off chance that we had utilized if statements, the code would be 22 lines in length, and would not scale also.

Generator Expressions and Functions

It is additionally conceivable to make generator expressions. These are syntactically nearly identical to list comprehensions, the distinction being that they are encased in paantheses instead of backets. Here are their syntaxes:

(expression for item in iterable)

(expression for item in iterable if condition)

Here are two equal code bits that show how a simple for ... in loop containing a yield articulation can be coded as a generator:

Both functions return a generator that produces a list of key–value items for the given dictionary. If we need all the items in one go we can pass the generator returned by the

functions to list() or tuple(); otherwise, we can iterate over the generator to retrieve items as we need them.

Generators give a method for performing languid evaluation, which implies that they figure just the values that are really required. This can be more productive than, say, processing an extremely enormous rundown in one go. A few generators produce the same number of values as we request—with no upper limit. For instance:

def quarters(next_quarter=0.0):

while True:

yield next_quarter

next_quarter += 0.25

This function will return 0.0, 0.25, 0.5, and so on, forever. Here is how we could use the generator:

result = []

for x in quarters():

result.append(x)

if x >= 1.0:

break

The break command is useful - without that, the for ... in loop would never finish!

At the end the result list is [0.0, 0.25, 0.5, 0.75, 1.0].

Each time we call quarters() we get back a generator that starts at 0.0 and increments by 0.25; yet imagine a scenario in which we need to reset the generator's present value. It is possible to pass a value into a generator, as this new version of the generator function shows:

def quarters(next_quarter=0.0):

while True:

received = (yield next_quarter)

if received is None:

next_quarter += 0.25

else:

next_quarter = received

The yield expression restores each an incentive to the caller in return. What's more, if the caller calls the generator's send() technique, the worth sent is gotten in the generator function as the consequence of the yield expression. Here is the way we can utilize the new generator function:

result = []

generator = quarters()

while len(result) < 5:

x = next(generator)

if abs(x - 0.5) < sys.float_info.epsilon:

x = generator.send(1.0)

result.append(x)

We make a variable to allude to the generator and call the implicit next() function which recovers the next thing from the generator it is given. (A similar impact can be accomplished by calling the generator's __next__() unique strategy, for this situation, x = generator.__next__().) If the worth is equivalent to 0.5 we send the worth 1.0 into the generator (which quickly yields this value back). This time the outcome rundown is [0.0, 0.25, 1.0, 1.25, 1.5].

In the following subsection we will audit the enchantment numbers.py program which procedures files given on the command line. Sadly, the Windows shell ace gram (cmd.exe) doesn't give trump card development (likewise called file globing), so if a program is kept running on Windows with the contention *.*, the strict content *.* will go into the sys.argv list instead of the considerable number of files in the present directory. We tackle this issue by making two distinctive get_files() capacities, one for Windows and the other for Unix, the two of which use generators. Here's the code:

if sys.platform.startswith(win):

def get_files(names):

for name in names:

if os.path.isfile(name):

yield name

else:

for file in glob.iglob(name):

if not os.path.isfile(file):

continue

yield file

else:

def get_files(names):

return (file for file in names if os.path.isfile(file))

In either case the function is relied upon to be called with a rundown of filenames, for instance, sys.argv[1:], as its contention.

On Windows the function repeats over every one of the