Forem: Sayeb Chowdhury

Advanced Industrial Robotics and Its Applications

Sayeb Chowdhury — Thu, 21 Sep 2023 23:06:16 +0000

Advanced industrial robotics refers to the use of highly sophisticated robotic systems and technology in industrial settings to perform tasks autonomously or with minimal human intervention. These robots are equipped with advanced sensors, artificial intelligence, and automation capabilities, allowing them to perform a wide range of tasks with precision, efficiency, and flexibility. Here are some key aspects of advanced industrial robotics and their applications:

Automation and Efficiency: Advanced industrial robots are designed to automate repetitive and labor-intensive tasks, such as assembly, welding, painting, and material handling. They can work continuously without breaks, leading to increased productivity and efficiency in manufacturing processes.

Precision and Accuracy: These robots are equipped with high-precision sensors and algorithms, allowing them to perform tasks with a high degree of accuracy. This is crucial in industries where precision is critical, such as electronics manufacturing and medical device assembly.

Versatility: Advanced industrial robots are often designed to be versatile, capable of performing multiple tasks by reprogramming or reconfiguring their end-effectors or tools. This versatility makes them adaptable to changing production needs.

Collaborative Robotics (Cobots): Some advanced robots are designed to work alongside humans, known as collaborative robots or cobots. They are equipped with safety features that allow them to operate in close proximity to human workers, enhancing productivity and safety in tasks like pick-and-place operations.

Vision Systems: Many advanced industrial robots are equipped with vision systems, including cameras and image processing software, which enable them to recognize and manipulate objects in unstructured environments. This is valuable in tasks like quality inspection and bin picking.

Artificial Intelligence and Machine Learning: Advanced robotics often incorporate AI and machine learning algorithms, enabling robots to learn from experience and adapt to changing conditions. This can lead to improved decision-making and autonomous problem-solving capabilities.

Industrial Applications: Advanced industrial robotics find applications across various industries, including automotive manufacturing, aerospace, pharmaceuticals, food processing, logistics, and healthcare. They can be used in tasks ranging from precision machining to packaging and logistics optimization.

Safety and Reliability: Ensuring the safety of workers and the reliability of robot operations is a paramount concern in advanced industrial robotics. Safety features, risk assessments, and fail-safe mechanisms are integrated to minimize the potential for accidents.

Cost Efficiency: While advanced industrial robots may have a significant upfront cost, they often provide a return on investment through increased productivity, reduced labor costs, improved quality control, and decreased error rates.

Future Trends: As technology advances, we can expect even more advanced robotics, including robots with enhanced mobility, greater autonomy, and the ability to work in extreme environments. The integration of 5G connectivity, IoT, and cloud computing is also expected to play a significant role in the development of advanced industrial robotics.

In summary, advanced industrial robotics plays a pivotal role in modern manufacturing and various industries by improving efficiency, precision, and versatility while reducing labor-intensive tasks and enhancing workplace safety. As technology continues to evolve, the potential applications for advanced robotics are likely to expand further.

Voronoi Diagram

Sayeb Chowdhury — Thu, 21 Sep 2023 23:02:14 +0000

A Voronoi diagram, also known as a Voronoi tessellation, is a geometric structure that divides a space into regions based on the closest proximity to a set of input points or sites. Here are some key details about Voronoi diagrams:

Definition: Given a set of points in space, a Voronoi diagram partitions the space into polygons or regions, where each region represents the area that is closer to one specific input point than to any other point in the set.

Properties:

Each Voronoi polygon is associated with a single input point and contains all the points that are closer to that input point than to any other.
The boundaries of Voronoi polygons are equidistant between the two nearest input points.
Voronoi diagrams can be applied in both two-dimensional (2D) and three-dimensional (3D) spaces.

Applications:

Geographic Information Systems (GIS): Voronoi diagrams are used to divide a geographic area into regions served by the nearest facilities, such as hospitals, schools, or service centers.
Nearest Neighbor Analysis: They help identify the closest facility or point to any given location in a space.
Pattern Recognition: Voronoi diagrams are used to analyze spatial distributions and classify points based on their proximity to reference points.

Mesh Generation: In computational geometry, Voronoi diagrams are used to create meshes, which are used in various simulations, such as finite element analysis.
Construction:

There are several algorithms for constructing Voronoi diagrams, including Fortune's algorithm for 2D spaces and various extensions and adaptations for higher-dimensional spaces.
The construction process typically involves iteratively adding Voronoi edges, vertices, and polygons based on the input points.

Complexity:

The computational complexity of constructing a Voronoi diagram depends on the dimension of the space and the number of input points. In 2D, the most common scenario, algorithms can achieve a time complexity of O(n*log(n)), where 'n' is the number of input points.

Delaunay Triangulation: Voronoi diagrams are closely related to Delaunay triangulations. Delaunay triangulation of a set of points connects them to form non-overlapping triangles, and the edges of these triangles correspond to the Voronoi edges.

Overall, Voronoi diagrams are powerful tools for spatial analysis and have applications in diverse fields, including geography, computer science, engineering, and natural sciences, where proximity and spatial relationships are important considerations.

Convex Hull

Sayeb Chowdhury — Thu, 21 Sep 2023 22:59:02 +0000

A convex hull is a fundamental concept in computational geometry, and it refers to the smallest convex polygon or polyhedron that encloses a set of points or other geometric objects in space. In two dimensions (2D), it is a convex polygon, while in three dimensions (3D), it is a convex polyhedron. The convex hull problem involves finding this smallest convex shape that encompasses the given set of points.

Key characteristics and details about convex hulls include:

Convexity: The convex hull is always convex, meaning that for any two points within the hull, the line segment connecting them lies entirely within the hull. This property ensures that the hull does not have any "dents" or concave portions.

Efficiency: There are several algorithms for computing the convex hull of a set of points, with the most famous being the Graham's scan algorithm, the Jarvis march (gift wrapping) algorithm, and the QuickHull algorithm. These algorithms have varying time complexities, with some being more efficient for specific scenarios or data distributions.

Applications: Convex hulls have applications in various fields, including computer graphics, geographic information systems (GIS), pattern recognition, robotics, and computer-aided design. For example, in GIS, they are used to find the boundary of a geographical region, while in robotics, they help plan collision-free paths for robots.

Complexity: The computational complexity of finding the convex hull depends on the algorithm used and the number of points in the input set. In the worst case, the complexity can be O(n^2) or O(n*log(n)), where 'n' is the number of input points.

Incremental and Divide-and-Conquer Approaches: Convex hull algorithms can be broadly categorized into two types: incremental and divide-and-conquer. Incremental algorithms build the hull incrementally by adding points one by one, while divide-and-conquer algorithms divide the set of points into smaller subsets, compute their convex hulls, and then merge them to find the overall convex hull.

Higher Dimensions: While the concept of a convex hull is most commonly associated with 2D and 3D spaces, it can be extended to higher dimensions as well, where it involves finding the smallest convex polytope that encloses a set of points.

Overall, the convex hull problem is a fundamental problem in computational geometry with a wide range of practical applications, and it has been extensively studied, leading to the development of efficient algorithms for its computation.

Geometric Algorithms

Sayeb Chowdhury — Thu, 21 Sep 2023 22:56:49 +0000

Geometric algorithms are a class of computational algorithms designed to solve problems related to geometric objects and their relationships in space. These algorithms are used in various fields such as computer graphics, computer-aided design, robotics, geographic information systems, and more. They deal with geometric primitives like points, lines, polygons, and shapes in 2D or 3D space.

Here are some common tasks and problems that geometric algorithms address:

Convex Hull: Finding the smallest convex polygon that encloses a set of points. This is useful in various applications like pattern recognition and image processing.

Point-in-Polygon: Determining whether a point is inside or outside a polygon.

Line Segment Intersection: Detecting if two line segments intersect in space.

Voronoi Diagrams: Dividing a space into regions based on the closest point from a set of input points. This has applications in facility location and mesh generation.

Delaunay Triangulation: Partitioning a set of points into non-overlapping triangles such that no point is inside the circumcircle of any triangle. This is often used in finite element analysis and mesh generation.

Collision Detection: Determining if two or more geometric objects (e.g., polygons, circles) intersect or collide.

Robot Motion Planning: Planning the path of a robot or object in a 2D or 3D space, avoiding obstacles.

Computational Geometry in 3D: Extending geometric algorithms to three-dimensional space for applications like 3D modeling, computer-aided design, and 3D gaming.

Geometric algorithms are fundamental in computer science and are essential in solving problems that involve spatial data and objects. They often require efficient data structures and mathematical techniques to perform their calculations accurately and quickly. These algorithms play a crucial role in various real-world applications, ranging from GPS navigation systems to video games and computer-aided manufacturing.

3D Mapping in Sensing and Perception.

Sayeb Chowdhury — Wed, 20 Sep 2023 11:55:03 +0000

3D mapping in the sector of sensing and perception involves the creation of detailed, three-dimensional representations of physical environments or objects using various sensor technologies. This technology has wide-ranging applications in fields such as robotics, autonomous vehicles, augmented reality, virtual reality, urban planning, and more. Here are some brief details about 3D mapping in this context:

Lidar-based Mapping:

Principle: Lidar (Light Detection and Ranging) sensors use laser pulses to measure distances and create detailed 3D maps of surroundings.
Applications: Autonomous vehicles use lidar for real-time mapping and obstacle detection. It's also used in forestry, archaeology, and robotics.

Stereo Vision and Photogrammetry:

Principle: Stereo vision systems use multiple cameras to capture images from different angles, allowing the reconstruction of 3D scenes through triangulation. Photogrammetry involves extracting 3D information from 2D images.

Applications: These methods are used in creating 3D models from photos, helping in surveying, cultural heritage preservation, and even in consumer applications like 3D modeling for gaming.

Structured Light and Depth Sensing:

Principle: Structured light involves projecting known patterns onto an object and analyzing how they deform to determine depth. Depth sensing technologies, like Microsoft's Kinect, use infrared sensors to measure distances and create 3D models.

Applications: These methods are used in gaming, human-computer interaction, and robotics, including applications like gesture recognition and indoor mapping.

Simultaneous Localization and Mapping (SLAM):

Principle: SLAM is a technique used in robotics and autonomous systems to create maps of unknown environments while simultaneously tracking the position of the sensor or vehicle within that environment.

Applications: SLAM is vital for autonomous robots and drones, as well as augmented reality devices, to navigate and interact with the real world.

Radar-based Mapping:

Principle: Radar sensors use radio waves to detect objects and their distances, which can be used for 3D mapping.

Applications: Radar is commonly used in automotive applications for long-range object detection, such as adaptive cruise control and collision avoidance.

Augmented Reality (AR) and Virtual Reality (VR):

Principle: 3D mapping is essential in AR and VR to seamlessly integrate virtual objects or information into the real world.

Applications: AR is used for applications like gaming, navigation, and training, while VR creates immersive experiences for gaming, training, and simulations.

Urban Planning and Smart Cities:

Principle: 3D mapping is crucial for urban planning, helping city planners visualize and analyze infrastructure, buildings, and potential developments in three dimensions.

Applications: It aids in optimizing traffic flow, disaster preparedness, and improving the overall quality of urban living.
3D mapping in sensing and perception is a dynamic field with continuous advancements, enabling innovations in various industries and improving our understanding and interaction with the physical world.

Geometry in Robotics

Sayeb Chowdhury — Wed, 20 Sep 2023 11:28:52 +0000

This post encompasses various aspects related to how geometric principles and mathematical concepts are applied to enhance the capabilities and efficiency of robots. Here are some key points related to this topic:

Geometry in Robot Design: Geometry plays a crucial role in designing robotic systems. Engineers use geometric principles to determine the optimal shapes, sizes, and configurations of robot components, such as arms, joints, and end-effectors, to achieve desired tasks and movements.

Kinematics and Dynamics: Robot kinematics involves the study of motion, position, and orientation of robot parts and how they relate to each other geometrically. Dynamics, on the other hand, deals with the forces and torques affecting a robot's motion. Both aspects heavily rely on geometric concepts to model and control robot movements.

Path Planning: Geometry is essential for path planning, which involves finding feasible and efficient trajectories for robots to navigate from one point to another while avoiding obstacles. Geometric algorithms and representations like Voronoi diagrams and visibility graphs are used for this purpose.

Grasping and Manipulation: Robots often need to grasp and manipulate objects in their environment. Geometric techniques are applied to analyze object shapes, plan grasping strategies, and calculate the optimal forces required for manipulation tasks.

Multi-Robot Coordination: In scenarios where multiple robots collaborate, geometric principles help in coordinating their movements and actions. Concepts like convex hulls and spatial relationships are used to avoid collisions and optimize task allocation.

Sensing and Perception: Geometric methods are utilized in computer vision and sensor fusion to interpret the geometric properties of the environment. This includes tasks such as object recognition, depth perception, and 3D mapping.

Snapping Fixtures: Snapping fixtures refer to mechanisms where parts of a robot can be securely attached or detached using geometric principles like snapping, locking, or mating. These fixtures are designed for easy assembly and disassembly of robot components.

Applications: The application of geometry in robotics extends to various fields, including manufacturing, automation, healthcare, agriculture, and space exploration. Robots are increasingly used in these domains to perform complex tasks efficiently.

Geometry plays in advancing the capabilities and applications of robotic systems, encompassing design, control, planning, and interaction with the environment.

Wearable Robots for Aging Society

Sayeb Chowdhury — Wed, 20 Sep 2023 11:07:53 +0000

This is just a simple introduction to wearable robots for aging society.

Wearable assistive robots for the aging society are a subset of assistive technology designed to support and enhance the quality of life for elderly individuals. These robots are typically wearable devices or exoskeletons that are equipped with various sensors, actuators, and intelligent software to assist older adults in performing daily tasks, maintaining mobility, and promoting overall well-being. Here are some key aspects of wearable assistive robots for the aging society:

_Mobility Assistance: _ These robots can help seniors with mobility challenges by providing physical support and assistance in activities such as walking, standing up from a chair, or climbing stairs. They can help reduce the risk of falls and improve independence.

_Gait Correction: _ Some wearable assistive robots are designed to correct gait abnormalities and improve balance, helping seniors maintain a steady and safe walking pattern.

_Strength Augmentation: _ Exoskeletons and wearable devices can augment the user's physical strength, making it easier to lift objects or perform tasks that require muscle power, which can be especially helpful for seniors with reduced muscle strength.

_Fall Detection and Prevention: _ Many wearable assistive robots come with sensors that can detect when a user is about to fall and provide support or alert caregivers to prevent accidents.

_Monitoring and Health Tracking: _ These devices often include sensors for monitoring vital signs, such as heart rate and blood pressure, as well as tracking activities and sleep patterns, allowing for better health management and early detection of potential health issues.

_Cognitive Assistance: _ Some wearable assistive robots integrate AI and voice recognition technology to provide cognitive support, reminders for medication, and assistance with tasks like finding lost items or navigating through daily routines.

_Social Interaction: _ These robots can also provide companionship and reduce feelings of loneliness among the elderly by engaging in conversation, playing games, or facilitating video calls with loved ones.

_Customization: _ Wearable assistive robots are often adjustable to accommodate individual needs and preferences, ensuring a personalized and comfortable fit.

_User-Friendly Design: _ Efforts are made to design these devices to be user-friendly, lightweight, and aesthetically appealing to encourage adoption by older adults.

_Research and Development: _ The field of wearable assistive robots for the aging society is continually evolving, with ongoing research and development to improve their functionality, affordability, and accessibility.

The goal of wearable assistive robots is to enhance the autonomy and overall well-being of the aging population, enabling them to live independently and with dignity for as long as possible. As technology advances, these robots have the potential to play a significant role in addressing the challenges associated with an aging society, such as healthcare costs and caregiver shortages.

Numpy Indexing and Selection

Sayeb Chowdhury — Sat, 31 Dec 2022 10:29:04 +0000

NumPy Indexing and Selection

In this lecture we will discuss how to select elements or groups of elements from an array.

import numpy as np

#Creating sample array
arr = np.arange(0,11)

#Show
arr

Bracket Indexing and Selection

The simplest way to pick one or some elements of an array looks very similar to python lists:

#Get values in a range
arr[1:5]

#Get values in a range
arr[0:5]

Broadcasting

Numpy arrays differ from a normal Python list because of their ability to broadcast:

#Setting a value with index range (Broadcasting)
arr[0:5]=100

#Show
arr

# Reset array, we'll see why I had to reset in  a moment
arr = np.arange(0,11)

#Show
arr

#Important notes on Slices
slice_of_arr = arr[0:6]

#Show slice
slice_of_arr

#Change Slice
slice_of_arr[:]=99

#Show Slice again
slice_of_arr

Now notice that the changes also occur in our original array!

arr

The Data is not copied, it's a view of the original array! This avoids memory problems!

#To get a copy, need to be explicit
arr_copy = arr.copy()

arr_copy

Indexing a 2D array (matrices)

The general format is arr_2d[row][col] or arr_2d[row,col]. I recommend usually using the comma notation for clarity.

arr_2d = np.array(([5,10,15],[20,25,30],[35,40,45]))

#Show
arr_2d

#Indexing row
arr_2d[1]

# Format is arr_2d[row][col] or arr_2d[row,col]

# Getting individual element value
arr_2d[1][0]

# Getting individual element value
arr_2d[1,0]

# 2D array slicing

#Shape (2,2) from top right corner
arr_2d[:2,1:]

#Shape bottom row
arr_2d[2]

#Shape bottom row
arr_2d[2,:]

Fancy Indexing

Fancy indexing allows one to select entire rows or columns out of order. To show this, let's quickly build out a NumPy Array:

#Set up matrix
arr2d = np.zeros((10,10))

#Length of array
arr_length = arr2d.shape[1]

#Set up array

for i in range(arr_length):
    arr2d[i] = i

arr2d

Fancy indexing allows the following

arr2d[[2,4,6,8]]

#Allows in any order
arr2d[[6,4,2,7]]

More Indexing

Indexing a 2D Matrix can be a bit confusing at first, especially when you start to add in step size.

Selection

Let's briefly go over how to use brackets for selection based off of comparison operators.

arr = np.arange(1,11)
arr

arr > 4

bool_arr = arr>4

bool_arr

arr[bool_arr]

arr[arr>2]

x = 2
arr[arr>x]

NumPy Arrays

Sayeb Chowdhury — Sat, 31 Dec 2022 05:56:41 +0000

## NumPy

NumPy (or Numpy) is a Linear Algebra Library for Python. The reason it is so important for Data Science with Python cause almost all of the libraries in the PyData Ecosystem rely on NumPy as one of their main building blocks. NumPy is also incredibly fast as it has bindings to C libraries. One should use Arrays instead of Lists because of its efficiency is more than the Python's lists. We will now only learn the basics of NumPy. To get started, we need to install it!

Installation instructions

It is highly recommended, you install Python using the Anaconda distribution to make sure all underlying dependencies (such as Linear Algebra Libraries) all sync up with the use of a condo install. If you have Anaconda, install NumPy by going to your terminal or command prompt and type,

conda install numpy
If you cannot download Anaconda in your PC then you can also use Google Colab, also for more-http://docs.scipy.org/doc/numpy-1.10.1/user/install.html
Using numpy

Once you have installed numpy you can import it as a library or in Google Colab you have to write the below sentence in the first cell and ran it. Afterwards, you can do whatever you want.

import numpy as np

NumPy Arrays

NumPy Arrays are the main way we will use NumPy. NumPy Arrays essentially come in two flavors- Vectors and Matrices. Vectors are strictly 1D Arrays and Matrices are 2D Arrays ( you should know that Matrix can it still have one row and one column. One Row Matrix is also called as Row Vector and one Column Matrix is also called as Column Vector.

Creating NumPy Arrays
From a Python List

We can create an array by directly converting a list or list of lists.

my_list = [1,2,3]
my_list

np.array(my_list)

my_matrix = [[1,2,3],[4,5,6],[7,8,9]]
my_matrix

np.array(my_matrix)

Built-in methods

There are lots of built-in ways to generate Arrays.

arange- '.arange()'

Return evenly spaced values within a given interval.

np.arange(0,10)

np.arange(0,11,2)

*zeros and ones
*- '.zeroes()', '.ones()'
Generate arrays of zeros or ones.

np.zeros(3)

np.zeros((5,5))

np.ones(3)

np.ones((3,3))

linspace- '.linspace()'
Return evenly spaced numbers over a specified interval.

np.linspace(0,10,3)

np.linspace(0,10,50)

eye

Creates an Identity Matrix.

np.eye(4)

Random

NumPy also has lots of ways to create random number Arrays.

*rand
*
Create an array of the given shape and populate it with random samples from a uniform distribution over [0,1)

np.random.rand(2)

np.random.rand(5,5)

randn

Return a sample (or samples) from the "standard normal" distribution. Unlike ".rand()" which is uniform,

np.random.randn(2)

np.random.randn(5,5)

randint

Return random integers from low (inclusive) to high (exclusive)

np.random.randint(1,100)

np.random.randint(1,100,10)

Array Attributes and Methods

Let's see some useful attributes and methods of an array:

arr = np.arange(25)
ranarr = np.random.randint(0,50,10)

arr

ranarr

Reshape

Returns an array containing the same data with a new shape.

arr.reshape(5,5)

*max, min, argmax, argmin *
In the below, these are useful methods for finding Max or Min value also to find their index locations using argmin or argmax.

ranarr

ranarr.max()

ranarr.argmax()

ranarr.min()

ranarr.argmin()

Shape

Shape is an attribute that Arrays have, not a method.

# Vector
arr.shape

# Notice the two sets of brackets
arr.reshape(1,25)

arr.reshape(1,25).shape

arr.reshape(25,1)

arr.reshape(25,1).shape

dtype

You can also grab the data type of the object in the array.

arr.dtype

;)

Python 0.1

Sayeb Chowdhury — Fri, 30 Dec 2022 01:16:18 +0000

Hello, everyone! If you are reading this then I am really grateful that you are reading my write-up. Thank you. Let's start our very first lecture upon Python. Previous lecture- Python 0.0 was just a head start and now we will try to cover every topics related to Python Language Basics in the next few blogs. Here I will discuss about Variable and Basic operations and precedence. For coding I always use Google Colab but you can use anything, all are almost same.

Variable

In mathematics variables are usually expressed as x, y or z and the variables can have different values at a time. In Python, variable does not work like that. One have to express variable names by following the Variable Naming Conventions- https://www.python.org/dev/peps/pep-0008/#prescriptive-naming-conventions, and also they have to be sincere that they did not choose any Python reserved keywords- True, False, del, def, try, raise, None, return, if, else, elif, in, is, and, while, as, except, with, lambda, assert, finally, global, yield, break, for, not, class, from, pass, async, await, import, or, nonlocal, continue.
Variables are just like a container for storing different types of data as value.

stu_name = 'Sayeb' print(stu_name) print(type(stu_name)

Here the output will be Sayeb and .["stu_name" is the variable name and "'Sayeb'" is the value of that variable] But if I again write like this

stu_name = 123 print(stu_name) print(type(stu_name)

Now the output will be 123 and . This makes clear that a similar variable can hold only one data type. If one uses the same variable name twice then the value will be changed. Python is also very case sensitive as it will detect stu_name
and Stu_name different variable names.
Values are always stored from the right side of the assignment(=) to the variable on the left side. Unlike other languages, in Python, we do not need to declare data types manually. The data type is decided by the interpreter during the run-time. If we follow the rules our code will become more understandable by the Human Readers (us).

Basic operations and precedence

You can use different operators in Python. Below the math operators precedence is given.

  Math Operators from Highest to Lowest Precedence

  Operator     Operation            Example      Evaluates to....

  **           Exponent               2 ** 3          8                            

  %            Modulus/remainder      22 % 8          6             

  //           Integer division/
             floored quotient       22 // 8         2

  /            Division               22 / 8          2.75

  *            Multiplication         3 * 5           15

  -            Subtraction            5 - 2           3

  +            Addition               5 + 2           7

The order of operations (also called precedence) of Python math operators is similar to that of mathematics. The ** operator is evaluated first; the *, /, // and % operators are evaluated next, from left to right; and the + and - operators are evaluated last (also from left to right). You can use parentheses to override the usual precedence if you need to. Whitespace in between the operators and values doesn't matter for Python except for the indentation at the beginning of the line, but a single space is convention.

A programming language uses ‘operations’ to manipulate the
data stored in variables to achieve the desired results. Basic operations in Python is divided into two parts: Unary (meaning it is done with one variable) and Binary (meaning it is done using two variables or one variable and a single value of data).
Note: You cannot do any operation with None type.

Let’s explore each type of operation and understand what they do.

Unary operations

Unary + (plus): We use unary + (plus) operation by adding a ‘+’ before a variable or data. It does not change the data. (Works with int, float, complex, and boolean. For booleans, True and False will be valued as 1 and 0 respectively.) For example:

 unary_p_1 = 1
 print(+unary_1)
 unary_p_2 = True
 print(+unary_2)

Unary - (minus): We use unary - (minus) operation by adding a ‘-’ before a variable or data. It produces the negative value of the input (equivalent to the multiplication with -1). (Works with int, float, complex, and boolean. For booleans, True and False will be valued as 1 and 0 respectively.) For example:

unary_m_1 = 1.01 print(-unary_m_1) unary_m_2 = False print(-unary_m_2)

Unary ~ (invert): We use unary - (invert) operation by adding a ‘~’ before a variable or data. It produces a bitwise inverse of a given data. Simply, for any data x, a bitwise inverse is defined in python as -(x+1). (Works with int, and boolean. For booleans, True and False will be valued as 1 and 0 respectively.) For example:

unary_i_1 = 9 print(~unary_1) unary_i_2 = -10 print(~unary_i_2) unary_i_3 = True print(~unary_i_3)

Binary operation:

Operators are symbols that represent any kind of computation such as addition, subtraction, and etc.
The values or the variables the operator works on are called Operands.
1 + 2
Here, 1 and 2 are operands, and + is the operator computing addition.

1. Arithmetic operation

    a. + (addition)
    b. - (subtraction)
    c. * (multiplication)

add = 6 + 1 add_1 = 6 + 2.0 subtrac = 6 - 1 subtrac_1 = 6 - 1.0 multi = 6 * 8 multi_1 = 6 * 8.0 print(add) print(add_1) print(subtrac) print(subtrac_1) print(multi) print(multi_1)

d. / (division)
Division of numbers(float, int) yields a float results in float.

div_1 = 4 / 2 div_2 = -2 / 1 div_3 = 4 / 4.0 div_4 = -9.0 / 1 print( div_1 ) print( div_2 ) print( div_3 ) print( div_4 )

f. % (modulus)

g. ** (Exponentiation)
Basically it's the power operator (X**Y) = X^Y

1. Assignment operator
a. = (assign): It is used for putting value from the right
side of the equal sign(=) to a variable on the left side
of the equal sign(=).
For example: number = 123 print ( number ).
b. Compound Assignment Operators:
i. += (add and assign)
ii. -= (subtract and assign)
iii. = (multiply and assign)
iv. /= (divide and assign)
v. %= (modulus and assign)
vi. *= (exponent and assign)
vii. //= (floor division and assign)

2. Logical operator
a. and (logical AND)
b. or (logical OR)
c. not (Logical NOT)
Note: Details will be discussed in Branching.

3. Comparison or Relational operator

    a. == (equal)
    b. != (not equal)
    c. > (greater than)
    d. < (less than)
    e. >= (greater than or equal)
    f. <= (less than or equal)
       Note: Details will be discussed in _Branching_.

4. Membership Operator
a. in: Returns True if the first value is in the second.
Otherwise, returns False.
b. not in: Returns True if the first value is not in the
second. Otherwise, returns False.
Example:

print('t' in 'cat') print('t' in 'caT') print('t' not in 'caT') print( 4 in [345, 7, 89, 4 ])

5. Identity Operators
Identity operators check whether two values are identical or
not.
a. is: Returns True if the first value is identical or the
same as the second value.Otherwise, returns False.
b. is not: Returns False if the first value is identical or
the same as the second value. Otherwise, returns
True.
Example:

print( '123' is 123 ) print( '456' is '456' ) print( 234 is not '234' ) print( 1 is 1.0 ) print( 4 is not 4.0 )

7. Bitwise Operators

     a. & (Bitwise and)
     b. | (Bitwise or)
     c. ^ (Bitwise xor)
     d. ~ (Bitwise 1’s complement)
     e. << (Bitwise left-shift)
     f. >> (Bitwise right-shift)

Compound expression:

When we write an expression with two or more operations, it is called a compound expression. For example, we may write 7+9*3 where we have both addition and multiplication operations in a single expression. Determining the result of a compound expression is a little tricky. We need to think about what operation will be executed first. To determine that the computer follows Operator precedence, a set of rules that dictates the
computer should be done first. For our example, 7+9*3 the multiplication operation will have higher precedence and will be executed first. So the program will first calculate 9*3 which results in 27. Then it will calculate 7+27, which will result in 34.
Try the following examples and see what results in it shows:

5*3+2-1*2
1+7/7*7

Operator precedence:

In the table below precedence has been shown in descending order- highest to lowest. Highest precedence at the top, lowest at the bottom. Operators in the same precedence are evaluated from left to right.

 Operator                    Name of the operator/ Operation

   ()                           Parentheses (Grouping)

 f( args.... )                  Function call

 x[ index:index ]               Slicing

 x [ index ]                    Subscription

 x.attribute                    Attribute Reference

   **                           Exponentiation

   ~x                           Bitwise Not

  +x, -x                        Unary Plus, Unary Minus

  *, /, %, //                   Multiplication, Division, 
                                Modulus/ Remainder, Floor 
                                Quotient/ Integer Division 

  +, -                          Addition, Subtraction

  <<, >>                        Bitwise Shifts

   &                            Bitwise AND

   ^                            Bitwise XOR

   |                            Bitwise OR

  in, not in, is,               Comparisons, Membership,
  is not, <, <=,                Identity
  >, >=, <>, !=,
   ==

  not                           Boolean NOT

  and                           Boolean AND

  or                            Boolean OR

  lambda                        Lambda expression

Type Conversion:

Data types can be modified in two ways: Implicit (when the compiler changes the type of a data for you(user)) and Explicit (when you ( the user) change the type of a data using type changing functions, it is called “ Type-casting” )

Note: What is the compiler will be explained later. Assume it ( the compiler ) to be like a teacher who checks your code for any kind of mistakes and shows the problems/ errors and sometimes does type conversion
for you ( the user ) according to the computation need of a statement.

1. Implicit Type Conversion:
   If any of the operands are floating-point, then arithmetic 
   operation yields a floating-point value. If the result was 
   integer instead of floating-point, then removal of the 
   fractional part would lead to the loss of information.

2. Explicit Type Conversion:
   Conversion among different data types are possible by 
   using type conversion functions, though there are few 
   restrictions. Python has several functions for this 
   purpose among them below 3 are most used:
     a. str() : constructs a string from various data types 
        such as strings, integer numbers and float-point 
        numbers. 
        For example:
            `var = 12.4
             var_string = str(var)
             print(var_string)
             print(type(var))
             print(type(var_string))`

     b. int(): constructs an integer number from various data 
        types such as strings ( the input string has to 
        consist of numbers without any decimal points, 
        basically whole numbers), and float-point numbers ( 
        by rounding up to a whole number, basically it 
        truncates the decimal part). 
        For example:
            `var_str = '12'
             var_int = int(var_str)
             print(var_int)
             print(type(var_str))
             print(type(var_int))`

     c. float(): constructs a floating-point number from 
        various data types such as integer
        numbers, and strings (the input string has to be a 
        whole number or a floating point number). 
        For example:
            `var_str = '12'
             var_float = float(var_str)
             print(var_float)
             print(type(var_str))
             print(type(var_float))`

Input

For taking input from the user directly, Python has a special 
built-in function, input(). It takes a String as a prompt 
argument and it is optional. It is used to display 
information or messages to the user regarding the input. For 
example, “Please enter a number” is a prompt. After typing 
the data/input in the designated inbox box provided by the 
IDE ( Integrated Development Environment), the user needs to 
press the ENTER key, otherwise the program will be waiting 
for the user input indefinitely. The input() function 
converts it to a string and then returns the string to be 
assigned to the target variable.

             `val = input()
              print(val)
              print(type(val))`

Okay, that is the end of our today's lesson. In the next lesson, we will discuss about three data types integer, float and string.

Python 0.0

Sayeb Chowdhury — Fri, 02 Dec 2022 03:56:55 +0000

Introduction

A simple program can do the works in two hours which will take two days if three people want to do the same thing. This is the power of computer programming. Like a Swiss Army knife, a computer can also configure countless tasks. Many people waste their time by doing repetitive tasks like typing, clicking and so on, just because not that they want but they are unaware of that the machine they are using could do the jobs in seconds if they can give the right instructions.

What The Programs Can Do?

If one can learn the basics of programming then he/she will be able to automate the simple tasks such these:

# Moving, renaming thousands of files and sorting them into
folders.
# Will be able to fill out online forms (No typing is required )
# Downloading files or copying text from a website whenever it
updates
# Formatting or updating Excel spreadsheets
# Automatically check out the inbox's email and sending out
pre-written responses
These are the simple but also very much time consuming for us. They are often so specific or trivial that there is no ready-made software to perform.

What is Programming?

In TV shows we often see how programmers furiously typing cryptic streams of 1s and 0s on glowing screens, but in reality programming isn't that much mysterious. Programming is simply the act of instructions for the computer to perform. These instructions can be anything, even something those are similar to our daily lives.
All programs use basic instructions as building blocks. Some most common ones are below:

'Do this, then do that.'

'If this condition is true, perform this action. Otherwise, perform that action.'

'Keep doing that until the condition is True or False'

'Do this action exactly 27 times,'

One can combine these building blocks to implement more intricate decisions. For a simple program written in the Python programming language, starting at the top, Python software runs each line of code (Some lines are run only if a certain condition is True or False or else Python runs some other lines.) until it reaches the bottom. One might not know about programming but after seeing a program written in Python, it is easily assumable what the program is actually going to do.

What is Python?

Python is a high-tier programming language. It is mentioned as high-tier because it is almost similar to human language, that also makes it easy for everybody to learn. For writing a valid Python code one have to maintain the syntax rules. Python interpreter software reads source code(written in Python language) and perform its instructions.

The name Python comes from the surreal British comedy group Monty Python, not from the snake. Python programmers are affectionately called "Pythonistas",and both Monty Python and serpentine references usually pepper Python tutorials and documentation.

No one Is Too Late To Learn Programming

If you are a new bud in the world of programming and after exploring everything you are thinking that it should be best to give up now. Don't ever think about that, instead boost up your morale and do coding continuously. It is never late to learn anything.
You don't need to be a child to become a capable programmer. But the image of programmers as whiz kids is a persistent one. However, programming is much easier to learn today than it was in the 1990s. Today, there are more books, better search engines along many more online questions-answers websites. One top of that programming languages are now far more user-friendly. Today, the amount of programming we can learn in a dozen weekends is equal to the years between grade high school and high school graduation of 1990s.
It’s important to have a “growth mindset” about programming. In
other words, understand that people develop programming skills through practice. They aren’t just born as programmers, and being unskilled at programming now is not an indication that you can never become an expert.

Programming Is A Creative Activity

Programming is a creative task, like painting, writing, knitting, or constructing LEGO castles. Like painting a blank canvas, making software has many constraints but endless possibilities. The difference between programming and other creative activities is that when programming, you have all the raw materials you need in your computer; you don’t need to buy any additional canvas, paint, film, yarn, LEGO bricks, or electronic components. A decade-old computer is more than powerful enough to write programs. Once your program is written, it can be copied perfectly an infinite number of times. A knit sweater can only be worn by one person at a time, but a useful program can easily be shared online with the entire world.

So, let's start.

Introduction To Python 0.0

As we already know about something regarding Python language, let's dive in to see the deep of this High-Tier language. Like any other language Python also have different types of data, function, loop etcetera. For example: One can use 'print()' to show the output on screen, 'type()' to know about the current category of the stored data in a particular variable. With these two things beginners should become extremely habituated to do coding. These two functions are mostly but not all the time, very helpful for debugging the code or finding out the problems one is doing.

With different types of data, we can achieve different tasks. So, knowing those data types with clear concepts is very important to become an efficient programmer. In this 21st century, everybody can do everything, but those can do a task in a less amount of time and in a more efficient way is the most needed. Always keep this in mind.

Loops usually used to do the repetitive tasks. That's all for the head start and see you in the next lecture- Python 0.1. Till then, stay well.