Category Archives: Programming

Python Course Zero to Mastery Started at Udemy

Python usually uses an interpreter. The compiler are a little bit different.

Interpret translates line by line.

Compiler takes all lines to machine code.

What is programming language? We give some instruction to translator. They tell the machine what to do. Translator can be interpreter or compiler.

Interpreter:

Compiler:

Python basics till numbers:

Double Slash in Python:


/ -> float division
//-> integer division

don’t memorize which available on the documentation

String type conversation.

Formatted String:

String Index

selfish[start:stop:stepover]

Immutabilty

Built in functions
Booleans

Software to find your current age with python:

#1 “old style” string formatting(% operator)

Source: https://realpython.com/python-string-formatting/

Template string ta pore kokhono hoyto dekhbo, ei ar ki

password length printing code from the course:

List

Matrix

list operations:

we can see the function from online documentation from the official site or other sites

 

 

 

 

Dictionary

Tuple:

Set:

set is an unordered collection of unique objects.

conditional.

 

Truthy and Falsy:

 

Exercise: Logical Operators

Equality

is vs == 
with using ‘is’ it needs to be refers to the same object

with == it needs to be equally same valued

for example:

 

 

Exercise: Counter will print item in list

Range

Enumerate:

while

 

break, pass, continue

Exercise:

Exercise:

Parameters and Arguments:

Return in python:

How it works:

without return it prints none:

 

with return it prints something that I insisted for:

Nested Return:

#issues with print and return

Exercise:

 

Exercise: To find even and max value from a list

 

Abstraction: private vs Public

 

Inheritance:

Polymorphism:

 

no amount of video is enough you have to learn by your way of development projects.

4 pillars in oop Encapsulation, Abstraction, Inherítance, Polymorphism

 

Now i am looking for another video from youtube to earn something about it.

Now the exercise from the udemy course:

Super,Object Introspection, Dunder/Magic method

1st example:

 

2nd example:

 

#Multiple Inheritance

#Method Resolution Order(MRO)

Pure Function

 

Map()

filter()

zip()

output: [(1, 10, 5), (2, 20, 4), (3, 30, 3)]

reduce() function and how it works in python:

I have seen two videos here from udemy and youtube to clear this concept for me

code from udemy:

reduce()

Output:

Exercise solutions here in function:

#1 Capitalize all of the pet names and print the list

output:

#2 Zip the 2 lists into a list of tuples, but sort the numbers from lowest to highest.

#3 Filter the scores that pass over 50%

#4 Combine all of the numbers that are in a list on this file using reduce (my_numbers and scores). What is the total?

Output:

Lambda Expressions in python:

Lambda is a computer science term. Which is an anonymous function. Which don’t use more than once for a purpose. Usually in lambda we don’t need to decalre any function name. What happens inside a function we can write in simple line using lambda function.

lambda using map:

lambda using filter:

lambda using reduce:

# Exercises using lambda
1. make a lambda example to squre

2. make a lambda example to make a sorted list

List Comprehension

Set and Dict Comprehension:

#dict comprehension

Comprehension is for shorthand.

Now a small exercise:

Problem: to write a one line code to find duplicate character to show in a answer
Soln code:

Output:

Decorators:

another example:

Higher Order Function HOC

the decorator can supercharge the function and can add an extra feature

Decorator:

Another example:

Practical Application of Decorator:

Exercise:

Need to do later as it is not downloading on my tablet

Error Handling:

error:

custom error in error handling:

Generators:
Range is a generator. Generator is special type in python

generator is iterable but all iterable is not generator
example: range is generator that is always iterable, list is also iterable but not generator

Modules:

Some examples of using modules here:
utility.py : in this file I put all the functions for opertions

Now I am sending values to those function using main :

 

Again another way:
main_buy.py:

shopping_cart.py:

The thing need to remember usually in a package automatically a file __init__.py creates.

Another important thing a successful program without error run with exit code 0
And with error run with exit code 1

Another way of example:

main.py

utility.py

shopping_cart.py

 

__name__:
Again example with names:

__name__

print(__name__)
#if __name__==’__main__’:

test.py:

utility.py

Python Built in Modules:

In other language it is known as standard library.
You don’t need to remember all, just know it exists and google it when needful.

https://docs.python.org/3/py-modindex.html

 

 

 

 

 

Java learned as so far:

Java variables,
Array, 2d array
Method
Different method invoking and return type
Class
– Class is actually a blueprint/specification/design
– A class can create as many as objects it needs to create
Object
– Earth is a software application where human and other thing is software objects.For creating object we need to create a human class
– Objects do particular behavior in a class
– Object exist only in application runtime actually when application is running
– Objects have identity,state and behavior

this keyword – it represent current object
Instance
Constructor – The costructor is a special method with the same name as the class and it’s used to instantiate objects from that class
– Every class has a by default constructor if we don’t put it manually
– The constructor is special method containing instructions for object creation. it can be said it is so called birth method. It has instructions for how the object will be born when the application starts up
Static keyword
Stack and heap memory
Garbage collection
Object oriented Programming = better organizing of code, it is a way to organize our code from multiple files by creating objects
Local variable
Reference variable
Instance variable
Inheritance
– Inheritance is the approach to get/transfer behaviour of one class to another
– We use extends keyword for inheriting, in inheritance we inherit from parent class which known as base class and the class which needs inheritation is known as child class or sub class/derived class
super keyword it extract constructor and it’s variable from parent class but reverse is not possible
Overrides
– Same method name with different purpose
– Same method name in parent class but in child class the method name is same but with different purpose
– Overrides means replace
– Override is not a good idea sometimes so we go for interface
Interfaces
– Interface is a contract with a class. The class needs to implements that method of the interface according to contract
– Interface has a method which does not need body, so it is just only to define, it is called as abstract method
– one parent class
– We use implements keyword while putting interface in a class
Abstract class
– When you don’t need all methods to invoke you can use abstract method, you can not make object from abstract class. Abstract method needs to be in abstract class. We use abstract keyword for both method and object to define abstract class and methods
– you can only extend abstract class but can not instantiate abstract class
– We can define abstract class as a type while creating object
Polymorphism

Loops
Exception Handling

Collection Framework
Wrapper class
Threading
Concurrency
Database

Jshell
Functional Interfaces
Lambda expressions

-Lambda helps us to use separate from associated object
– it can run without class
– We need to use lot of interfaces for this

Streams

Ei bold kora jayga diye project banaye banaye clear korte hobe
Italic kora jaygagula motamuti clear asey In Sha Allah, Alhamdulillah
The source is : Imtiaz Ahmed’s complete Java course

 

Master Object Oriented Design in Java course note

Association: It defines relationship between classes, it defines how the software will behave
Dependency Association: For example from code:

A driver receives a vehicle reference only as driver then only he can drive or accelerate

Composition: A particular object . It imply ownership
for example in this code:

Aggregation Association: It does not imply ownership

Here Department to SpanishCourse relation is composite

But Course to Student relationship is not composite because it does not imply ownership a student can take many courses or not

We find this relationship from above diagram, the block diamond and white diamond is the part of UML diagram

Forming Association between objects:

has a relationship in customer .

Now when to stop delivery

Overview of software design:
For example: Hospital Employee Management System
Task of the software:
Hire and Terminate Employees
Print Reports(XML,CSV Formats)

Problem Statement:
Current status of the software

Tips for design:
– You must draw design in paper or whiteboard don’t go to code directly
– Don’t overdesign or overdraw
– We have to develop iteratively but early steps should be kept simple
– Class names should be nouns based on their intention

Single Responsibility Priniciple(SRP): Not all the things in the same class

Don’t repeat yourself(DRY):

Arrow sign always describe that it is depends on that dependency class:

 


DAO=Data Access Object

Single Responsibility Principle Special Notes:
A class should have only one single reason to change

 

Open closed principle sayings about class design:

Classes should be open for extension but closed for modification.

Open Closed Principle and Strategy pattern:
Software modules should be open for extension and closed for modification
In development lifecycle software requirements needs to be constantly pour in. If developed need to change the already made codes the design is fragile. Fragile means broken.

So open closed principle save engineers from fragile design

instanceof operator we used here in the code:
HotelManagementSystem class:

Here it is like a junk drawer

So we will make it changes because it is violating OCP principle. This chamging process is known as Strategy pattern. So let’s do it.

We could also do it with interface class except abstract class

Example after applying Strategy pattern:
Nurse.java

Doctor,java

HospitalManagement.java

 

Employee.java

 

EmergencyRoomProcess.java

To String Tutorial:

DemoToString.java

Dependency Inversion Principle:
Device Manufacturing Company has:

The manufacturing process:
1. Assembly
2. Testing
3. Packaging
4. Storage

GeneralMAnufacturingProcess
UML diagram:

We depend on something in driving like car is stopping by traffic light
Imagine a life every car has different mechanism
Violation of Dependency Inversion Principle
When higher level modules depend on lower level ones succeptible to change
Dangers of coupling:
Tight coupling :

Well design software has single responsibility
This method says high level modules should not depend on lowlevel modules. It should depend on abstractions
Abstract classes and Interfaces don’t change as often as concrete classes/ derivatives
Cohesion means related things together.

This code I tried to run in class inside class but did not worked. Then I downloaded course code and run worked then again I tried to do with my directory structure then it worked.

Quizes from OOP course:
Q1:
Q2: The Dependency Inversion Principle states
Interfaces and abstract classes change far less often the concrete derivatives. Concrete classes should depend on Interfaces and abstract classes because they change less often and are higher level modules

Q3: In general the dependency inversion principle states that code should only depend on things that don’t change often
True
Liskov Substitution Principle:
Subtypes must be substitutable for their basetypes

There are some patterns which is not good known as Anti-pattern:
Here the link can be found


This is a ISA relationship, Nurse and Doctor depends on Employee class. Employee class is Abstract class

When it is adding a substitute teacher who does not work as like a teacher it violates the LISKOV pronciple as per this line of definition: Subtypes must be substitutable for their basetypes

So we changed to a new UML which does not violate LISKOV principle and did the code.

New UML:


Question 1:
The Liskov Substitution principle states, that child classes should not be substitutable in place of their parents.

Interface Segregation Principle:

Fat class is a class which has too many responsibilities.

CustomerTransaction