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

# Algorithm

Before moving onto the code, let's see the following steps to solve the problem:

+ Scan the expression from right to left. For every symbol, check whether it's an operator or operand. 
  + If it is an operand, push it into the stack.
  + If it is an operator, pop from the stack _two_ times.
    + Concatenate the popped items and the operator.
    + Push the concatenated result into the stack.
+ When traversing through the expression is complete, the stack will hold one element only, i.e., the final result (the postfix expression).

from collections import deque

def postfix(prefix):
    stack = deque()

    prefix = ''.join((reversed(prefix)))    #Reversing the expression
    for symbol in prefix:

        if symbol != '+' and symbol != '-' and symbol != '*' and symbol != '/':
            stack.append(symbol)    # Push if an operand

        else:
            # If an operator, then pop two operands from stack
            operand1 = stack.pop()
            operand2 = stack.pop()
            # Concatenate operands and operator and again push it in stack
            stack.append(operand1+operand2+symbol)
            
    return(stack.pop()) # Poping the result

print(postfix('*-A/BC+/AKL'))

# Explanation
In the code above, we implement stack using `collections.deque` (see import at __line 1__). See the header of the function `postfix` at __line 3__. It takes the _prefix_ expression in the `prefix` argument. Initially, we make `stack` (an empty stack) using the `deque()` constructor (at __line 4__).

As told above, we have to traverse through the `prefix` in the reverse direction (right to left). For this, we have a `reversed()` function at __line 6__. But there's a slight trick. This function returns an _iterator_. To specify the iterator as a string, we use the `join` attribute to join an empty string (`''`) with the iterator returned by the `reversed()` function. Now, `prefix` holds the reversed prefix expression. We can now iterate it from left to right, as usual (see __line 7__).

Then at __line 9__, we are checking the condition for each `symbol` if it's an operator (`+`, `-`, `*`, `/`) or not. There are the following two cases:

+ If the `symbol` isn't an operator, then definitely it is an operand. In such a case, we push the `symbol` into `stack` (see __line 10__). 
+ If the `symbol` is an operator, pop _two_ times from `stack`. While popping from `stack`, we store the result: the first time the result is stored in `operand1` (at __line 14__), and the second time the result is stored in `operand2` (at __line 15__). Now we have to concatenate `operand1`, `operand2`, and the `symbol` (operator). Then the concatenated result is to be pushed into `stack` (see __line 17__).

For each `symbol` in `prefix`, these cases will be checked. Once the whole expression is traversed, we'll only be left with one single element in `stack`, which is the _postfix_ expression for the `prefix` containing the _prefix_ expression. At __line 19__, we pop it and return the popped item.

Now, look at __line 21__. We are calling the `postfix` function with __*-A/BC+/AKL__ as an argument and printing the result: __ABC/-AK/L+*__

---

The solution to the 'Prefix to Postfix Conversion' 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: Prefix to Postfix Conversion

Algorithm