Python 2 Functions

Functions

 def hello():  
   print("Hello functions")  
 hello()  

Functions with Parameters

 def add(i, j):  
   return i + j  
 print(add(12, 23))  

Exception Handling

 try:  
   i = int(input("Enter value 1 : "))  
   j = int(input("Enter value 2 : "))  
   res = i / j  
   print(res)  
 except ValueError:  
   print("Invalid Input")  
 except ZeroDivisionError:  
   print("Cannot divide by zero")  

 def divide():  
   try:  
     i = int(input("Enter value 1 : "))  
     j = int(input("Enter value 2 : "))   
     res = i / j  
     print(res)  
   except ValueError:  
     print("Invalid Input")  
   except ZeroDivisionError:  
     print("Cannot divide by zero")  


 divide()  

Python

print

 print("Hello Python")  

Memory Variable

 name = "Shalvin P D"  
 print("Hello ", name)  

Multiple assignments

 name, passion = "Shalvin", "IT"  
 print(f"{name} - {passion}")  

input

 name = input("Enter your name : ")  
 print("Hello ", name)  

int()

 i = int(input("Enter value 1 : "))  
 j = int(input("Enter value 2 : "))  
 res = i + j  
 print(res)  

float()

 i = float(input("Enter value 1 : "))  
 j = float(input("Enter value 2 : "))  
 res = i + j  
 print(res)  

Lists

 technologies = [".Net", "Python", "Angular"]  
 for tech in technologies:  
   print(tech)  

Lists append()

 technologies = [".Net", "Python", "Angular"]  
 technologies.append("C#")  
 for tech in technologies:  
   print(tech)  

Lists remove()

 technologies = [".Net", "Python", "Angular", "C#", "PHP"]  
 technologies.remove("PHP")  
 for tech in technologies:  
   print(tech)  

Lists Concatenation

technologies1 = [".Net", "Python", "Angular", "C#"]

technologies2 = ["DevOps", "Jenkins"]

technologies = technologies1 + technologies2

for tech in technologies:
    print(tech)

Dictionary

 contact = {"name" : "Shalvin", "location": "Kochi"}  
 print(contact)  
 print(contact["name"])  
 print(f'{contact["name"]} : {contact["location"]}')  

List of Dictionaries

 contacts = [{"name" : "Shalvin", "location": "Kochi"},  
       {"name": "Praseed", "location": "UK"}]  
 print(contacts)  
 first_contact = contacts[0]  
 print(first_contact)  
 print(f"{first_contact['name']} - {first_contact['location']}")  
 

 print("Listing all contacts")  
 for contact in contacts:  
   print(f"{contact['name']} - {contact['location']}")  

Blazor I : Blazor Server Getting Started

Blazor is a free and open-source web framework that enables developers to create web apps using C# and HTML developed by Microsoft. Previously creating such apps required the knowledge of JavaScript Libraries/Frameworks like Angular, React, VueJS, JQuery, etc. Now it is possible for .Net developers to use their familiar tools and language (C#) to create compelling UIs. Blazor has different variants like Blazor Server, Blazor Web Assembly, Blazor United aka Full Stack Blazor (.Net 8), etc. In this article we will be concentrating on Blazor Server.

Blazor Server

Blazor Server is a Server Side technology for creating highly responsive Single Page Application (SPA). It uses SignalR web sockets to push the UI udates to browser. A persistent connection between Web Server and Client Browser is required for Blazor Server to work. So it is not possible to create Progressive Web Apps (PWA) with Blazor Server. Since Blazor is a Server Side technology it can access all the server resources including database access. No need of an exta Web API layer. Blazor Server works even on old Browsers.

Prerequisites

.Net (Core) 3 or later is required for building Blazor. Visual Studio is recommended by not mandatory. .Net CLI in combination with any editor can be used for creating Blazor Application which we will see later. .Net Core is platform independent so you can develop Blazor application in any platform you like. I am starting out with Visual Studio Community which is a freeware from Microsoft. I am selecting Blazor Server App as the project template.

Creational Design Patterns

 

Creational design patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. They increase flexibility in deciding which objects need to be created for a given use case. Some of the most commonly used creational design patterns include:

• Abstract Factory: Creates an instance of several families of classes.

• Builder: Separates object construction from its representation, always creates the same type of object.

• Factory Method: Creates an instance of several derived classes.

• Prototype: A fully initialized instance to be copied or cloned.

• Singleton: A class of which only a single instance can exist.

• Abstract factory pattern: This pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

• Builder pattern: This pattern separates the construction of a complex object from its representation, allowing the same construction process to create various representations.

• Factory method pattern: This pattern defines an interface for creating an object, but allows subclasses to alter the type of objects that will be created.

• Prototype pattern: This pattern specifies the kind of objects to create using a prototypical instance, and creates new objects by copying this prototype.

• Singleton pattern: This pattern ensures that a class has only one instance and provides a global point of access to it.

It's important to note that, the best pattern to use depends on the specific situation, and it's important to weigh the trade-offs between the different options before implementing one.

Design Patterns

Design patterns are a set of best practices and solutions to common problems that occur in software design. They provide a way to structure code in a way that is easy to understand, maintain, and extend. 

There are several types of design patterns, including: 

Creational patterns, which deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. 

Structural patterns, which deal with object composition, creating relationships between objects to form larger structures. 

Behavioral patterns, which deal with communication between objects, what goes on between objects and how they operate together. 

 

 Some of the most well-known design patterns include:

Singleton pattern, which ensures that a class has only one instance and provides a global point of access to it.

Factory pattern, which creates objects without specifying the exact class of object that will be created.

Observer pattern, which allows objects to be notified of changes to other objects.

Decorator pattern, which allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class.

Strategy pattern, which allows an algorithm's behavior to be selected at runtime.

Design patterns are not specific to any programming language, but they are often implemented in object-oriented languages like C# or Java.

It's important to note that, while design patterns are a great way to solve common problems, they should be used judiciously, as overuse can lead to code that is hard to understand and maintain.