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

# Introduction

There are _three_ types of methods defined on the Python object:
+ Class method
+ Instance method
+ Static method

Let's begin writing a class that contains all the types mentioned earlier.

class MyClass:

  # Instance method
  def instancemethod(self, arg1, arg2, ...):
    return 'instance method called', self

  # Class method
  @classmethod
  def classmethod(cls, arg1, arg2, arg3):
    return 'class method called', cls

  # Static method 
  @staticmethod
  def staticmethod(arg1, arg2, arg3):
    return 'static method called'

Let's discuss them one by one.
## Instance method
The first method `instanceMethod` is an _instance method_. This type is mostly used. It can accept any number of parameters. Here, `self` points to an instance of `MyClass` when this method is called.

> ⚙️ __Note__: With `self`, we can access any attribute or any method on the same object.

An instance method can also access _class attributes_. Here's how you can do it: `self.__attribute__`.

## Class method
Obvious from its name, a method bound to a class and not to an object of a class, is called a __class method__. It has access to the state of a class and thus can modify it. The second method `classMethod` is a _class method_. It's decorated by `@classmethod`. 

A class method receives the class (`cls`) as an implicit first argument, just like an instance method receives the instance (`self`). 

> ⚙️ __Note__: Instead of `self` parameter, class methods take a `cls` argument that points to the class and not to the object instance.
We generally use a class method to create factory methods. 

## Static method
The third method `staticMethod` is a _static method_. It's decorated by `@staticmethod`.
 
It's neither bound to a class nor to an object. It can't access the state of a class so can't modify it either. It also doesn't receive any _implicit_ arguments. However, an arbitrary number of parameters is allowed. 

We generally use a static method to create utility functions.

# Example

Let's bring the above discussion into action.

Learn comparison among class, instance and static methods.

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

Class, Instance and Static Methods

Introduction