Forem: Michael Abraham Wekesa

Python Classes and Objects - Get to know how classes and objects work!

Michael Abraham Wekesa — Sat, 24 Dec 2022 19:30:48 +0000

Python is a high level and an object oriented programming language.
In python classes are used to construct objects, thus a class is a code template for creating objects.

A class being a blueprint for an object creation, it is a form of data structure that is user-defined, binding an objects data members and its methods in a single unit.

An object on the other hand is an instance of a class. Objects have states and behaviors. The state of an object represents its attributes and the behavior its methods.
An object must also have an identity in order of it to be identified uniquely.
Hence an object must have identity, state and behavior.

A real world example of a class and objects:

A car can be a class, as it is a template of a vehicle of any model, brand, different car engine size etc.
So lets define a car in a class template;

class: Car
State: model, color, brand
Behavior: fuel consumption

Using the class above, we can now create car objects:

First Object:

State

brand: Toyota
model: Corolla
color: Blue

Behavior

Fuel consumption: For every 35 kilometers it consumes 1 gallon of fuel.

Second Object :

State

brand: Honda
model: Civic
color: Green

Behavior

Fuel consumption: For every 40 kilometers it consumes 1 gallon of fuel.

From the first and second objects, they are both created from the same class but have different states and behaviors.

Creating a class in python
The keyword class is used in python to create a class, followed by the class name. It is best practice to have a class name with the UpperCaseCamelCase naming convention.

After defining the class name, the block of statements that follow for the specific class define its attributes and methods.
With python classes, there is Docstrings which is the first string in a class that briefly describes the class. It is not necessary but it is best practice in python classes, methods or functions to have docstrings.

We will use the example of the car class in the code examples:

Defining a class in Python

class Car:
    def __init__(self, color, brand, model):
       # instance variables(state)
       self.color = color
       self.brand = brand
       self.model = model

    # behavior (instance method)
    def car_details(self):
      print(f'Car brand: {self.brand}, model: {self.model}, color: {self.color}')

    # behavior (instance method)
    def fuel_consumption(distance=10, fuel_amount=1):
      print(f'For every {distance} kilometers it consumes {fuel_amount} gallon of fuel')

The self keyword represents the instance of the class within itself. Meaning the class attributes and methods can be accessed within itself using the "self" keyword.

From the above class, with the fuel_consumption method, there are two parameters, this is to ensure that each object has its unique rate of fuel consumption based on a specific distance covered by the car object.

The __init__ is a type of function known as a constructor which in python is a special method used to create and initialize an object of a class.

Creating an object of a class
Here is how we get to create an object of an already defined class. We will use the Car class that we defined above;

toyota_corolla = Car(model='Corolla', brand='Toyota', color='Blue')

toyota_corolla.car_details()

Output:

Car brand: Toyota, model: Corolla, color: Blue

For the fuel_consumption method, we have to pass in the distance and fuel_amount arguments.

toyota_corolla = Car(model='Corolla', brand='Toyota', color='Blue')

toyota_corolla.fuel_consumption(distance=35, fuel_amount=1)

Output:

For every 35 kilometers it consumes 1 gallon of fuel

When defining the fuel_consumption method there is a default value for both fuel_amount and distance parameters, in case there are no arguments passed in, then the default values will be used instead. The default values are distance=10 and fuel_amount=1.

toyota_corolla = Car(model='Corolla', brand='Toyota', color='Blue')

toyota_corolla.fuel_consumption()

Output:

For every 10 kilometers it consumes 1 gallon of fuel

Class Attributes
When designing a class, there are two types of variables, the instance variables and the class variables.

Instance variables - These are attributes attached to an instance class. They are variables defined in the constructor, in the __init__ class method.

Class variables - Are attributes or variables declared in the class but outside any instance method including the __init__ method.

When accessing a class attribute can be accessed by using a dot on an instance followed by the attribute name; instance_name.attribute_name.

It is in the same way that an attribute can be modified, example(using the Car class):

toyota_corolla = Car(model='Corolla', brand='Toyota', color='Blue')

toyota_corolla.color = 'Yellow'
toyota_corolla.car_details()

Output:

Car brand: Toyota, model: Corolla, color: Yellow

From the above example, the Toyota Corolla's color is changed from Blue to Yellow.

Class Methods
With Object Oriented Programming a class can have 3 types of methods within the class:

Static Method: It is a general-purpose utility method that finishes just one task. We don't use instance or class variables within this static method because it doesn't have access to the class attributes.

Class Method: Used to access or modify the class's state. When implementing a method, if we only use class variables, we should declare that method as a class method.

Instance Method: Used to access or alter the status of the object. Methods are referred to as instance methods if they contain instance variables.

A class method is linked to the class itself, not to any class objects.
Only class variables are accessible to it.

Python Functions – How to write, call and the best ways to write a function

Michael Abraham Wekesa — Sat, 24 Dec 2022 16:51:55 +0000

Functions are a set of statements bundled together to perform a specific task. A function can accept arguments that are manipulated to cause about a specific output or effect as intended.
Functions are often used in order to organize code, including getting rid of repetitive code, thus helps greatly in achieving the DRY principle in software engineering. DRY stands for 'Don't Repeat Yourself'.

Functions can be seen as executable code blocks and can be called once or more.

In Python we define functions using the def keyword followed by the function's name and finally the parenthesis. Parameters to the function are defined within the parenthesis.

When calling a function that accepts some arguments, we pass them in the parenthesis.

An example of a function:


def print_hello_world():
    print("Hello World!")

When calling the function:


print_hello_world()

Output:

Hello World!

Functions can have parameters, parameters are used as placeholders or variables for inputs that will be passed as inputs during the calling of a function. Arguments on the other hand are values that are passed in a function as inputs to the function.

Functions with parameters

Declaring parameters when defining a function:

def sum_two_numbers(a, b):
  sum = a + b
  return sum

When calling the function we pass in the arguments, which in this case are a and b. For a = 3 and b = 4;

sum_two_numbers(3, 4)

Output:

When you take a look at the sum_two_numbers function, there is the keyword return. The return keyword is used to output the results back to the caller. It is also used as the exit point of a function.

Lambda functions

Lambda functions are small and anonymous(unlike the normal functions, they're defined without a name) functions, they take any number of arguments and return a result, however the can only have one expression.

A simple example of a lambda function that squares a value

x = 4
# print a the square of x
square_fun = (lambda x:x **2)(x)
print(square_fun)

Output:

Docstrings in functions

A docstring is a string literal that is used in a function, class or when defining a class method. They give a brief description about the class or method, or a function in this case. It is not necessary to have a docstring but it is recommended.

The docstring of a function can be accessed using the __doc__ attribute.

Example of a docstring in functions:

def mul_number(a, b):
    """ multiply  to values, a and b"""
    return a*b

Getting the docstring of a function:

print(mul_number.__doc__)

Output:

multiply  to values, a and b

It is important to note that with functions or blocks of code in python, indentation is very crucial, it is easy to break code or have semantic errors, with unintended indentation.

This is a simple tutorial to give a brief introduction to functions from which you can lay a basis of understanding functions in python.

There is more to functions, being an explorer is one way to find out!

What are loops and conditional statements in Python? Understand them better!

Michael Abraham Wekesa — Tue, 10 May 2022 18:44:31 +0000

With the basics of python, you can now speak the language. in order to get to know and dive in further in to programming and putting some serious logic in code, there are a few things to learn and understand. Let's do it the python way!

Conditional statements
Loops

Conditional statements

Conditional statements are commands used in handling decisions, in which a decision is made if and only if the pre-stated conditions are either true or false.
For example the traffic lights, you only start driving if and only if the lights turn from red to green else you wait.

Before diving deep into conditional statements there are some logical conditions to consider, of which play a crucial part in making conditions with conditional statements, in python these basic logical conditions from math are:

Less than, e.g a < b
Equals, e.g a == b
Greater than, e.g a > b
Less than or equal to, e.g a <= b
Greater than or equal to, e.g a>= b
Not Equals, e.g a != b

These logical conditions are used with if statements and loops in manipulating the control flow in programming.

1. If statement
A program will only continue to be executed if only the test expression evaluates to true and if the test expression is false, the statements after the condition is not executed.

if 2 > 1:
   print("Greater!")

Output:

Greater

2. Nested if statements
One condition is executed and if true then the next condition is executed and so on till the last if condition is met. These if statements are declared inside other if statements.

n = 10
if n < 20:
   n = 20
   print(" Greater than 10")
   if n < 30:
      n = 30
      print(" Greater than 20")

Output:

Greater than 10!
Greater than 20!

3. Elif statements
elif is a keyword that enables a program to go through another if condition if the previous one is false e.g.

a = 43
b = 57
if a == 57:
   print("a is equal to 57!")
elif b == 57:
   print("b is equal to 57!")
else:
   print("Sorry, neither a nor b is equal to 57!")

Output:

b is equal to 57!

4. If not Statements
not is a keyword that returns True if the statement is not true. returns true if a value is false;

num_list = [2,4,6,8,9]
num = 5
if num not in num_list:
   print("num not in num_list")
else:
   print("Found it in num_list!")

Output:

num not in num_list

Python loops

A loop is basically a set of instructions or statements of a given program that is repeated a finite number of times until a certain condition is met.
There are two types of loops in python:

For loops
while loops

1. for loops
A for loop is used for iterating over a sequence of statements multiple times, e.g a list, dictionary or a tuple.

instruments = ["Guitar", "Piano", "Flute", "Drums"]
for instrument in instruments:
   print(instrument)

Output:

Guitar
Piano
Flute
Drums

2. while loops
While loops repeat a statement or a block of statements until a given condition is false. It checks the condition before executing the loop body, if the condition is true, it will go on until it is false, then exit the loop.

i = 1
while i != 5:
  print(i)
  i += 1

Output:

Break statement
A break statement is used in stopping a loop even if the condition still passes as true.

i = 1
while i != 8:
  print(i)
  if i == 6:
    break
  i += 1

Output:

Continue statement
The continue keyword can stop the current iteration and continue with the next iteration.

i = 0
while i != 8:
  i += 1
  if i == 6:
    continue
  print(i)

Output:

With the knowledge of loops and conditional statements. There's more to do with python. As we progress we unleash its potential.
Here is a simple calculator in which we get to implement the conditional statements.

Simple calculator

print("The simple calculator")
print("===========")
num1 = input("Enter the first value: ")
num2 = input("Enter the second value: ")
print("===========")
print("\n1.Addition\t2.Subtraction\n3.Multiplication\t4.Division")
choice = input("Pick a choice (1,2,3 or 4): ")
num1 = int(num1)
num2 = int(num2)

if choice == "1":
    print( num1 + num2)
elif choice == "2":
    print(num1 - num2)
elif choice == "3":
    print(num1 * num2)
elif choice == "4":
    print(num1 / num2)
else:
    print("invalid option")

Conclusion
With that, adios! And happy coding. Hope you found this informative.

Welcome to Python 101! — Lets get started with the basics

Michael Abraham Wekesa — Sat, 16 Apr 2022 07:59:13 +0000

Python is a high-level programming language, in layman's language, it is closer to human understanding(English like) than it is to machines. Python is an interpreted language and a general purpose programming language.

A brief history of python

Python is programming language that came into life in the 1980s and was developed by Guido van Rossum at Centrum Wiskunde & Informatica (CWI) in the Netherlands, with the ideology of it being a successor to the ABC programming language.

Since then python has evolved through several versions to the latest version python 3.10 (as of the time of writing this article) with a first release date of 4 October, 2021

Python 2.0, released 16 October 2000, with new features including a cycle-detecting garbage collector for memory management and support for Unicode.

Python 3.0, released on 3 December 2008.With this version there was massive revision that it was not backward compatible with previous python versions.

Before we get our hands dirty, let's set some rules of engagement, shall we!

Syntax in Python

Python has a very simple and user friendly syntax, that you'll find simple and easy to grasp.
Some include:

Indentation in python is crucial, it can break your code!
Python is case sensitive, State and state are different
All variables should start with a lowercase letter
classes begin with capital letters
The standard is to actually use English names in programming

Identifiers (names you define for variables, types, functions, and labels) should not be keywords in python and start with a symbol or number.

For more on style and best practices in python check out on PEP-8

Installing python

Python Basics

Base types

int (integer)

value = 76

float

value = 56.21

bool (boolean)

is_blue = True

str (string)

message = "Hello world!"

Backslash is used for escaping characters.
e.g

\' - Single quote
\b - backspace
\n - new line
\r - carriage return
\t - tab

message = " \t Sammy\'s cat ran away\nand into the bush it went.\n"
# print - an inbuilt function to print an output
print(message)

# output
#     Sammy's cat ran away
# and into the bush it went.

Multiline strings

   message = """ Lorem ipsum dolor sit amet, consectetur adipiscing elit, 
   sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
   Ut enim ad minim veniam, 
   quis nostrud exercitation ullamco laboris nisi ut 
   aliquip ex ea commodo consequat."""

Sequence types

list

Lists are modifiable and can hold values of different types.

list_country = ["Russia",  "South Africa", "Japan", "Peru"]
random_list  = ["x", 3.14, 4, False, "No way"]

tuple

Tuples cannot be modified once created. They are immutable.

coordinates = (33.56, 4.56, 21.89)

range

Is a function returning a sequence of numbers, starts from 0 and increments by 1 by default.
Format: range(start, stop, step)

for x in range(0,10,2):
    print(x)

Mapping types

Dictionary

Is a collection of data that is stored in key-value pair, key is unique
e.g "Laptop" is the key and "Mac book" the value.

backpack = {"Laptop":"Mac book", "Headphones": "Sony",  "Hard drive": "SSD"}

Set types

A set is an unordered collection that is mutable, iterable and has unique elements.

fruits = {"apple", "mango", "orange"}

2.frozen-set

Freezes the elements, making them unchangeable.

fruits = ({"apple, "mango", "orange"})

Conversions

Change a value of one data type to another.

""" 1.str to int"""
int("10") #output: 10

""" 2. float to int"""
int(10.34) #output: 10

""" 3. any data type to str"""
str(10.10) #output: "10.1"
str(3==3) #output:  "True"

""" 4. character to ASCII code """
ord('*') #output: 42

""" 5. string to list"""
message = "Hello world!"
message_list = list(message)
# print- print output
print(message_list)
# output
# ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!']

""" 6. dictionary to list """
day = {"day":14, "month": "Feb", "year": 2022}
# create a list with list compression
generated_list = [(x, y) for x, y  in day.items()]
# print - print output
print(generated_list)
# output
# [('day', 14), ('month', 'Feb'), ('year', 2022)]

""" 7. list to string """
word_list = ["The", "new", "version", "of", "slack", "is", "amazing"]
word_str = " ".join(word_list)
print(word_str)
# output
# The new version of slack is amazing

""" 8. list to set """
number_list = [34, 45, 67 ,87]
number_set = set(number_list)
print(number_set)
# output
# {34, 67, 45, 87}

""" 9. list to dictionary """
day_list = [('day', 14), ('month', 'Feb'), ('year', 2022)]
day_dict = dict(day_list)
print(day_dict)
# output
# {"day":14, "month": "Feb", "year": 2022}

Working with Strings

There are several ways in which strings can be manipulated.

print("Hello")

# output
# Hello

print("Hello", "world", "!")

# output
# Hello world !

print("Hello", "world", sep="-")

# output
# Hello-world

print("Hello") # for every print, output is set to a new line
print("world")

# output
# Hello
# World

print("Hello", "world", sep="-", end="!") 

# output
# Hello-world!

print("Hello", end=" ") # without new line
print("World")

# output
# Hello world

String Concatenation

String concatenation is the operation of joining character strings end-to-end.(wikipedia)

first_name = "John"
middle_name = "Magarita"
last_name = "Omondi"

print(first_name + " " + middle_name + " " + last_name)

# output
# John Magarita Omondi

String formatting

first_name = "John"
middle_name = "Magarita"
last_name = "Omondi"
salary = 50000
print("{0} {1} earns a salary of ${2}".format(first_name, middle_name, salary))

# output
# John Magarita earns a salary of $50000

With knowing the basics of python, you can write simple command line programs
for example:

Simple mad-libs generator program

""" A simple word game that takes user input based on the word type and 
inserting in to a paragraph """

noun1 = input("Enter a noun(Plural): ")
place = input("Enter a place: ")
noun2 = input("Enter a noun: ")
noun3 = input("Enter a noun(Plural): ")
adjective1 = input("Enter an Adjective: ")
verb1 = input("Enter a verb: ")
verb2 = input("Enter a verb: ")
number = input("Enter a number: ")
adjective2 = input("Enter an Adjective: ")
body_part = input("Enter a body part: ")
verb3 = input("Enter a verb: ")

mad_lib = """Two {0}, both alike in dignity,
In fair {1} where we lay our scene,
From ancient {2} break to new mutiny,
Where civil blood makes civil hands unclean.
From forth the fatal loins of these two foes
A pair of star-cross`d {3} take their life;
Whole misadventured piteous overthrows
Do with their {4} bury their parents` strife.
The fearful passage of their {5} love,
And the continuance of their parents` rage,
Which, but their children`s end, nought could {6},
Is now the {7} hours` traffic of our stage;
The which if you with {8} {9} attend,
What here shall {10}, our toil shall strive to mend. """.format(noun1, place, noun2, noun3, adjective1, verb1, verb2,number, adjective2,body_part, verb3)

print("\n====Mad Lib (Romeo and Juliet: Prologue Ad-lib) ====\n")
print(mad_lib)

Conclusion

Python is an amazing multi-purpose programming language that can be used in almost all fields in technology, from AI to scripting and data science. The best part is, it is fun to learn and user-friendly.
Happy coding!