Gain insights into Pythonic programming techniques. Learn about documentation, data types, safety, performance, and function design to write fast, maintainable, and correct Python code.

python3.8.tar.gz

Python3.8

Python3.8Code

This course is an invaluable resource for anyone who wants to learn the correct Pythonian way of writing highly performant code that is easy to maintain and grow.

The course is divided into six chapters: documentation tips, data types/data structures tips, safety tips, performance tips, function design tips, and general tips. Throughout each chapter, you will get hands-on experience working with real Python code to help ingrain each concept.

By the end, you will know how to make your programs correct, safe, fast, and easy to maintain.

Pythonic Programming Tips for Software Engineers

## `sum()` almost anything
The built-in `sum()` function is an excellent tool for summing up all numbers in an iterable and `for` operations dependent on such summation. For example, we can easily calculate the mean of a set, even if we don’t have access to statistics, `numpy`, `scipy`, or a similar module:

data = {1, 1, 1, 1, 2, 3} # set() eliminates duplicates 
mean = sum(data) / len(data)
print(mean)

In fact, `sum()` is an optimized accumulator loop like this:

def sum(iterable, init=0):
  for x in iterable:
    init += x 
  return init

print(sum([2,4,6,8]))

### A notable exception
There is one notable exception. That is, `sum()` doesn’t allow us to concatenate a collection of strings. Concatenating a large list of strings is prohibitively inefficient. It is inefficient to the extent that Python developers invoked two rarely combined principles from *The Zen of Python*:

1. Special cases aren’t special enough to break the rules (so, let `sum()` concatenate strings).
2. Practicality beats purity.

We should avoid a list and tuple summation with `sum()` for the same performance reasons. The `itertools.chain.from_iterable()` function has a long name but a short running time. On an average computer, concatenating 100 10-element lists with `itertools` is 10–15 times faster than concatenating the lists with `sum()`.


Let's run the following code to verify the execution time.

# `sum()` almost anything
The built-in `sum()` function is an excellent tool for summing up all numbers in an iterable and `for` operations dependent on such summation. For example, we can easily calculate the mean of a set, even if we don’t have access to statistics, `numpy`, `scipy`, or a similar module:

## A notable exception
There is one notable exception. That is, `sum()` doesn’t allow us to concatenate a collection of strings. Concatenating a large list of strings is prohibitively inefficient. It is inefficient to the extent that Python developers invoked two rarely combined principles from *The Zen of Python*:

1. Special cases aren’t special enough to break the rules (so, let `sum()` concatenate strings).
2. Practicality beats purity.

We should avoid a list and tuple summation with `sum()` for the same performance reasons. The `itertools.chain.from_iterable()` function has a long name but a short running time. On an average computer, concatenating 100 10-element lists with `itertools` is 10–15 times faster than concatenating the lists with `sum()`.


Let's run the following code to verify the execution time.

Learn how to use sum(), pickle, and input() functions.

Introduction

Documentation Tips

General Tips

Data Types and Data Structures Tips

Function Tips

Performance Tips

Safety Tips

Wrapping Up

Miscellaneous Tips

`sum()` almost anything

A notable exception

Miscellaneous Tips

sum() almost anything

A notable exception

`sum()` almost anything