+91-9952009545 | +91-9884386075 contact@slashprog.com

Python Programming Primer: for C/C++/Java/JavaScript developers

Duration: 15 hours (5 days @ 3 hours per day)
Course Track: Intermediate / Advanced

Price: ₹6000 INR / $100 USD / £80 GBP / €85 EUR

Schedule: Monday to Friday – 8:00 PM to 10:00 PM IST 

About the course

This master class is designed to ramp-up your coding skills on Python with focus on a pythonic approach towards problem-solving. You will undergo a smooth transition into the world of Python coding while learning the internals and intricate details of Python syntax, datatypes and language design in general. After successful completion of this course, you should be competent enough to crack most technical coding job interviews on Python skillsets. Kindly note that this training class will be fast-paced with live coding demonstations and discussions (similar to most corporate training sessions delivered by the instructor).

Target audience

This training class is intended for engineers and coding enthusiasts who have basic understanding and coding skills in other programming / scripting languages and are interested in acquiring coding skills on Python language. 


Participants should be familiar with programming in any programming language. Most comparative examples demonstrated in the training classes will be based on the assumption that the participant is familiar with C/C++/Java programming concepts.

Course Objectives

  • Learn the Pythonic approach towards problem-solving.
  • Unlearn traditional coding practices from other programming languages and think in terms of Python.
  • Learn the features, syntax and best practices in Python coding.
  • Deep dive in to the dynamic nature of Python language design for writing code.
  • Learn how to leverage Python features like ducktyping, monkey-patching, functional programming, concurrent programming and AOP.
  • Learn the best practices in choosing builtin datatypes and from standard library modules.

What Will NOT be Covered

  • Process and network automation-related library modules/concepts.
  • Multi-threading, multiprocessing miscellaneous Python libraries.
  • Web programming or web automation.
  • Any third-party library/modules.

Training Mode

This training program is designed to be a live master class conducted via Google Meet. Most concepts will be explained by live coding – attendees are expected to learn by interacting with the master and trying out short exercises provided by the master.

Training Requirements

As the training will be a live master class, each attendee must have a working computer/laptop with reliable internet connectivity for practice sessions and have the following software installed on their computer/laptop:

Module 1

Python coding bootstrap

Introduction to Python

  • An overview on python programming.
  • Python vs other mainstream languages (comparitive demonstrations)
    • Problem-solving approaches
    • Practices and paradigms

Common misconceptions about Python: demystified

[Breaking the following myths by code demonstrations, explanations and citing use-cases]

  • Python is a scripting language (?!)
  • Python is slow (?!)
  • Python is not fully object-oriented (?!)
  • Python is not scalable (?!)
  • Python is not designed for enterprise applications (?!)
  • Python is not meant for low-level / embedded development (?!)

An overview on Python development tools.

  • Python runtimes and implementations.
  • Using the Python REPL
  • Using IPython for exploration and rapid productivity
  • Using Jupyter notebook to maintain re-usable code snippets
  • Using VisualStudio Code
  • An overview on other IDE / Environments for programming and maintaining python code.
  • Using pylint to check whether python program following PEP8 style guidelines
  • An overview on Python PEPs with insight on PEP8 (style guide for writing Python programs).

Module 2

Getting started on Python

Python language syntax overview

  • Python statements and expressions
    • Simple statements and compound statements
    • Identifiers and expressions
    • Literals notations: numbers, strings, tuples, lists, sets and dictionaries
    • Python indentation rules
  • Flow control constructs:
    • Conditions
    • Loops
    • Iterations
    • Exception handling
  • Basic builtin functions: print(), input(), dir(), type()

Python language features and terminologies

  • Python as a dynamic programming language.
  • Static vs Dynamic typing – the unsettled debate.
  • Gradual typing syntax support in Python code.
  • Statements are not expressions.
  • The rationale behind the lack of ++ and -- operators.
  • Understanding immutable and hashable objects.
  • The “==” vs “is” operator.
  • The “in” operator.
  • Functions vs methods vs type constructors.
  • Type casting vs type constructors.
  • Names, Objects, Values, Types and Attributes.
  • Variables vs Attributes.

Module 3

Python design paradigms

Pythonisms (with demonstrations)

  • Everything in Python are ultimately objects.
  • All identifiers are names that act as references.
  • Python programs are modules.
  • Functions and classes are callable objects.
  • Methods are attributes that refer to callable objects.
  • Statements are not expressions.
  • Every object express boolean truthiness.
  • Every object express an offical and/or an unoffical string representation.
  • Every object can be introspected in runtime
  • Popular Python Zen idioms:
    • “Errors should never pass silently (unless explicitly silenced)!”
    • “There should be one and preferably only one obvious way to do it!”
    • “In the face of ambiguity — refuse the temptation to guess!”

Python programming styles and paradigms

  • Choosing the right style/paradigms for a given problem
    • Procedural paradigm and modularity
    • Object-Oriented-Programming (OOP)
    • Functional programming patterns
    • Aspect-Oriented-Programming (AOP) patterns
  • Assignment statements in Python: interesting ways.
  • More about type constructors: dealing with tuples, lists, sets and dictionaries.
  • Sequence indexing and slicing techniques.
  • Iterables, Collections, Generators and the Iterator protocol.

Module 4

Strings and Text processing

Working with Strings

  • String literal representations and syntax.
  • String-related operators, methods, expressions and built-in functions.
  • String formatting using the % operator, str.format() method
    and using f-strings.
  • Using str, bytes and bytearray types.

Regular expressions

  • Using regular expressions in Python with the re module
  • re.Pattern and re.Match objects
  • Using match(), search(), findall() and finditer() methods
  • Python-specific regex syntax nuances
  • Pythonic approaches to use regular expression match groups

Module 5

Working with files and filesystem

File I/O operations

  • An overview on I/O streams.
  • Using the with clause.
  • Reading and writing to small text files.
  • Managing read/write operations on large text files.
  • Managing read/write operations on binary files.
  • Working with CSV, INI, TOML and JSON files.
  • Using pickle to serialize data.
  • Patterns for reading/parsing text files and binary files

Filesystem path / stat / directory handling.

  • Creating, renaming and deleting files and directories.
  • Iterating through directory contents.
  • Gathering stat of files and directories.
  • Path manipulation using os.path and pathlib modules.

Module 6

Builtin collections and iteration helpers

Lists, Tuples and Sets.

  • Creating lists, tuples and sets:
    • Using literal notations.
    • Using constructor expressions.
    • Using comprehensions.
  • Tuple: sequence operations and methods.
  • Using min(), max(), sum(),
    all(), any() functions
  • List: operations and methods
  • List: slicing/dicing operations
  • Built-in iteration helpers: range(), zip(), enumerate(), reversed() and sorted()
  • Iteration helpers in itertools module
  • Sets: overview, operations and methods.
  • Using map(), filter(), reduce() functions.
  • More about comprehensions.
  • Using collections.deque.
  • Using heapq, bisect and array modules.

Module 7

Working with dictionaries

  • Introduction to dictionaries.
  • Creating, updating and managing dictionaries.
  • An overview on dictionary operators, functions and built-in methods.
  • Dictionary manipulation tips and techniques.
  • Using collections.ChainMap, collections.defaultdict and collections.Counter objects.
  • Working with persistent dictionaries using the shelve module.
  • Dictionaries everywhere in Python code:
    • Object’s attributes as dictionaries.
    • Variable namespace as dictionaries.
    • OS environment variables as dictionaries.
    • Examples of dictionary interface in various frameworks.

Module 8

All about Python functions

  • Defining functions
  • Function arguments, prototypes and polymorphism
  • Functions as first-class objects
  • Pure functions, functions with side-effects and Higher-order functions.
  • Improving readability of function definitions:
    • Using consistent doc-strings (PEP-257 and PEP-287).
    • Type hints for function prototypes (PEP-484).
    • Best practices for function design in Python.
  • Creating functions using lambda expressions
  • Inner functions and their use-cases.
  • Scoping rules: Python’s name resolution order

Module 9

On overview on Python OOP using class-based design

  • Defining a class in Python
  • Understanding scoping rules and name resolution within classes.
  • Instantiation and Inheritance
  • Class attributes and instance attributes
  • Life-cycle methods: __new__(), __init__() and __del__()
  • An overview on data-model methods (a.k.a dunder methods)
  • Using the @classmethod and @property accessors.
  • The @staticmethod debate: why you should rethink about using them.

Module 10

Odds and Ends

  • Classes vs Modules: when should you choose creating classes over modules.
  • Modules as namespaces, modules as first-class objects.
  • Unlearning classical OOP paradigms (from C++ / Java / Objective-C / C# and others).
  • Duck-typing and Monkey-patching: the way of life in python coding.
  • Python packaging: creating reusable and redistributable libraries.
  • On overview on creating standalone executables from Python code using PyInstaller and Nuitka

Course fee: ₹6000 INR / $100 USD / £80 GBP / €85 EUR (to be paid in advance for enrollment)

How to enroll ?

In order to enroll to this training class, you can fill in the form below registering your interest with the required details.

You will receive an acknowledgement email from registrations@slashprog.com once you submit the form. In this email, we will provide you with the details for paying the course fee including payment links if you chose “Pay via Stripe” or UPI/NEFT details if you chose UPI/NEFT payment option.

Once we receive the payment, we will reply back with the confirmation of your training registration and provide you links to connect using Google Meet along with the exact schedule for the classes by email.

If you have any further queries, you can email us directly to contact@slashprog.com

Kindly fill in the following details to enroll to this training class.

Kindly select your preferred payment method from below