Gain insights into advanced Python 3, learn the Pythonic Way, explore data structures, functional and object-oriented paradigms, and master iterables, generators, and coroutines through practical projects.

python3.tar.gz

python3

python3-copy

This highly interactive and advanced course will give you insight into the most common Python tricks and tips. This course is for practicing Python programmers who are aiming for proficiency in Python 3. If you want to switch from Python 2 to Python 3, this is your go-to course. 

This course will help you learn the Pythonic Way of writing code and leveraging advanced robust features to become more proficient than the average developer. You’ll start by covering Python’s built-in data structures, and then you’ll move on to different programming paradigms like functional programming and object-oriented programming. 

In the latter half of the course, you’ll focus on iterables, generators, and coroutines. You’ll also have the opportunity to work on two projects to help strengthen what you learn. In all, this course is perfect for anyone who wants to become a confident and competent Pythonista by picking up the idioms and practical tips.

Mastering the Art of Programming in Python 3

def factorial(n):
   if n == 1 or n == 0:
       return 1
   else:
        return n*factorial(n-1)

def square_factorial(n):
    return [(lambda a : a*a)(x) for x in (list(map(factorial, range(n))))]

print(square_factorial(6))

# Explanation

In the code above, according to the problem statement, there are two parts: the `factorial` and the `square_factorial` function. Let us first go through the `factorial` function.

Look at the function's header at __line 1__. It takes a parameter `n`. We are using the recursive approach to compute the factorial of the number `n`. The recursion will not be explained, as it is not our concern here. 

Now, look at the main part of the solution: the `square_factorial` function. According to its definition (at __line 7__), it takes a parameter `n`. It is used to calculate the squares of the factorials of the first `n` numbers (from 0 to `n-1`). The challenge was to write a single-line implementation. The following expression solves it:
```python3
return [(lambda a : a*a)(x) for x in (list(map(factorial, range(n))))]
```
Let us break it down, to understand what we did. 
+ The part `for x in (list(map(factorial, range(n))))` calculates the factorial of the first `n` numbers. The `map` function applies the `factorial` function to every member of an iterable (0... `n-1`) calculated with the `range()` function, and returns the result. The result for every member is stored in a list using the `list()` function. Now we can call the `lambda` function on each member of this list to calculate the squares. The part `for x` will pick each factorial from here one by one.

+ The part `(lambda a : a*a)(x)` will calculate the squares. This anonymous function takes `a` as a parameter and returns `a*a` (the square of the number). As discussed above, `x` will hold each factorial turn by turn, so this anonymous function is called on `x` in every iteration. We are storing the squares in a list. In the end, the list is returned.

Look at __line 10__. We are calling `square_factorial` for the first __6__ numbers: __0, 1, 2, 3, 4,__ and __5__. The part `(list(map(factorial, range(n))))` will generate __[1, 1, 2, 6, 24, 120]__. Then `(lambda a : a*a)(x) for x in [1, 1, 2, 6, 24, 120]` will create __[1, 1, 4, 36, 576, 14400]__ which is the final result.

---

The solution to the 'Square the Factorials' challenge.

Introduction

Built-in Data Structures

Functional Programming

Project I: Data Science with Data Structures

Data science with Data Structures

Project I Review

Object-Oriented Idioms

Iterables and Generators

Coroutines

Project II: Build Your Own Matrix Module

Build Your Own Matrix Library

Project II Review

Meta-Programming

The End

Solution Review: Square the Factorials

Explanation