Vipul's Blog

Tkinter Geometry management

noreply@blogger.com (Vipul's Blog) — Mon, 28 Dec 2020 14:52:00 +0530

Tkinter Geometry management

Geometry Management

All Tkinter widgets have access to the specific geometry management methods, which have the purpose of organizing widgets throughout the parent widget area. Tkinter exposes the following geometry manager classes: pack, grid, and place.

The pack() Method - This geometry manager organizes widgets in blocks before placing them in the parent widget.
The grid() Method - This geometry manager organizes widgets in a table-like structure in the parent widget.
The place() Method - This geometry manager organizes widgets by placing them in a specific position in the parent widget.

Tkinter pack() Method

This geometry manager organizes widgets in blocks before placing them in the parent widget.

Syntax

widget.pack( pack_options )

Here is the list of possible options-

expand: When set to true, widget expands to fill any space not otherwise used in widget's parent.
fill: Determines whether widget fills any extra space allocated to it by the packer, or keeps its own minimal dimensions: NONE (default), X (fill only horizontally), Y (fill only vertically), or BOTH (fill both horizontally and vertically).
side: Determines which side of the parent widget packs against: TOP (default), BOTTOM, LEFT, or RIGHT.

Tkinter grid() Method

This geometry manager organizes widgets in a table-like structure in the parent widget.

Syntax

widget.grid( grid_options )

Here is the list of possible options-

column : The column to put widget in; default 0 (leftmost column).
columnspan: How many columns widgetoccupies; default 1.
ipadx, ipady :How many pixels to pad widget, horizontally and vertically, outside v's borders.
row: The row to put widget in; default the first row that is still empty.
rowspan : How many rowswidget occupies; default 1.
sticky : What to do if the cell is larger than widget. By default, with sticky='', widget is centered in its cell. sticky may be the string concatenation of zero or more of N, E, S, W, NE, NW, SE, and SW, compass directions indicating the sides and corners of the cell to which widget sticks.
padx, pady : How many pixels to pad widget, horizontally and vertically, outside v's borders.

Tkinter place() Method

This geometry manager organizes widgets by placing them in a specific position in the parent widget.

Syntax

widget.place( place_options )

Here is the list of possible options-

anchor : The exact spot of widget other options refer to: may be N, E, S, W, NE, NW, SE, or SW, compass directions indicating the corners and sides of widget; default is NW (the upper left corner of widget)
bordermode : INSIDE (the default) to indicate that other options refer to the parent's inside (ignoring the parent's border); OUTSIDE otherwise.
height, width : Height and width in pixels.
relheight, relwidth :Height and width as a float between 0.0 and 1.0, as a fraction of the height and width of the parent widget.
relx, rely : Horizontal and vertical offset as a float between 0.0 and 1.0, as a fraction of the height and width of the parent widget.
x, y : Horizontal and vertical offset in pixels.

Loops in Python

noreply@blogger.com (Vipul's Blog) — Wed, 23 Dec 2020 21:50:00 +0530

CONSTANTS

Loops

You go through your shopping list until you've collected every item from it. The dealer gives a card for each player until everyone has five.
The athlete does push-ups until reaching one-hundred... Loops everywhere! As for for loops in Python: they are perfect for processing repetitive programming tasks.

In Python, and all other modern programming languages, iteration statements (also called loops) allow a set of instructions to be repeatedly executed until a certain condition is reached. This condition may be predetermined (as in the for loop) or open-ended (as in the while and do-while loops). In another way we can say, A loop can be used to tell a program to execute statements repeatedly. Or we can say that a loop repeatedly executes the same set of instructions until a termination condition is met.

For Loop

Python implements an iterator-based 'for loop'. It is a type of 'for loop' that iterates over a list of items through an explicit or implicit iterator.

The loop is introduced by the keyword 'for' which is followed by a random variable name

which will contain the values supplied by the object.

This is the syntax of Python's 'for loop':

for variable in list:
statements
else:
statements

Here is an example of a 'for loop' in Python:

pizza = ["New York Style Pizza", "Pan Pizza", "Thin n Crispy Pizza", "Stuffed Crust" ,"Pizza"]

for choice in pizza:
if choice == "Pan Pizza":
print("Please pay $16. Thank you!")
print("Delicious, cheesy " + choice)
else:
print("Cheesy pan pizza is my all-time favorite!")
print("Finally, I'm full!")

Run this and you'll get the following output on Python Shell:

Delicious, cheesy New York Style Pizza
Please pay $16. Thank you!
Delicious, cheesy Pan Pizza
Delicious, cheesy Thin n Crispy Pizza
Delicious, cheesy Stuffed Crust Pizza
Cheesy pan pizza is my all-time favorite!
Finally, I'm full!

Using the range() Function with the for Loop

The range() function can be combined with the 'for loop' to supply the numbers required by the loop. In the following example, the range(1, x+1) provided the numbers 1 to 50 needed by the 'for loop' to add the sum of 1 until 50:

x = 50
total = 0
for number in range(1, x+1):
total = total + number
print('Sum of 1 until %d: %d' % (x, total))

The Python Shell will display:

l.py
Sum of 1 until 50: 1275

The While Loop

A Python 'while loop' repeatedly carries out a target statement while the condition is true. The loop iterates as long as the defined condition is true. When it ceases to be true and becomes false, control passes to the first line after the loop.

The 'while loop' has the following syntax:

while condition
statement
statement

Here is a simple 'while loop':

counter = 0
while (counter < 10):
print('The count is:' , counter)
counter = counter + 1
print('Done!')

If you run the code, you should see this output:

l.py

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
The count is: 9
Done!

Conditionals in Python

noreply@blogger.com (Vipul's Blog) — Sat, 28 Nov 2020 19:42:00 +0530

If-else

If-Else

Introduction

We use if statements in our everyday life all the time - even if our everyday life is not written in Python. If the light is green then I'll cross the road; otherwise I'll wait. If the sun is up then I'll get out of bed; otherwise I'll go back to sleep. Okay, maybe it's not this direct, but when we take actions based on conditions, our brain does what a computer would do: evaluate the conditions and act upon the results. Well, a computer script doesn't have a subconscious mind, so for practicing data science we have to understand how an if statement works and how we can apply it in Python!

Let's say we have two values: a = 10 and b = 20. We compare these two values: a == b.
This comparison has either a True or a False output. (Test it in your Jupyter Notebook!)

We can go even further and set a condition: if a == b is True then we print 'yes'.
If it's False then we print 'no'. And that's it, this is the logic of the Python if statements.
Here's the syntax:

Run this mini script in your Jupyter Notebook! The result will be (obviously): no.

Now, try the same - but set b to 10!

The returned message is yes.

Python if statement syntax

Let's take a look at the syntax,
because it has pretty strict rules.

The basics are simple:

You have:

1.an if keyword, then

2.a condition, then

3.a statement, then

4.an else keyword, then

5.another statement.

6.However, there are two things to watch out for:

1. Never miss the colons at the end of the if and else lines!

2. And never miss the indentation at the beginning of the statement-lines!

If you miss any of the above two, an error message will be returned saying "invalid syntax" and your Python script will fail.

Python if statements - level 2

Now that you understand the basics, it's time to make your conditions more complex - by using arithmetic, comparison and logical operators. (Note: if the word "operators" does not ring any bells, you might want to check out this article first:

This script will return yes, since both of the conditions, (a + b) / c == 1 and c - b - a == 0 are actually True and the logical operator between them was: and.

Of course, you can make this even more complex if you want, but the point is: having multiple operators in an if statement is absolutely possible - in fact, it's pretty common in real life scenarios!

Python if statements - level 3

You can take it to the next level again, by using the elif keyword (which is a short form of the "else if" phrase) to create condition-sequences. "Condition-sequence" sounds fancy but what really happens here is just adding an if statement into an if statement:

Sure enough the result will be "second condition is true".

You can do this infinite times, and build up a huge if-elif-elif-...-elif-else sequence if you want!
And... This was more or less everything you have to know about Python if statements.

Function in Python

noreply@blogger.com (Vipul's Blog) — Fri, 27 Nov 2020 01:10:00 +0530

Functions

A function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing.

As you already know, Python gives you many built-in functions like print(), etc. but you can also create your own functions. These functions are called user-defined functions.

Defining a Function

You can define functions to provide the required functionality. Here are simple rules to define a function in Python.

Function blocks begin with the keyword def followed by the function name and parentheses ( ( ) ).
Any input parameters or arguments should be placed within these parentheses. You can also define parameters inside these parentheses.
The first statement of a function can be an optional statement - the documentation string of the function or docstring.
The code block within every function starts with a colon (:) and is indented.
The statement return [expression] exits a function, optionally passing back an expression to the caller. A return statement with no arguments is the same as return None.

Syntax:

def functionname( parameters ):

"function_docstring"

function_suite

return [expression]

By default, parameters have a positional behavior and you need to inform them in the same order that they were defined.

example:

The following function takes a string as input parameter and prints it on the standard screen.

def printme( str ):

"This prints a passed string into this function"

print (str)

return

Calling a Function

Defining a function gives it a name, specifies the parameters that are to be included in the function and structures the blocks of code.

Once the basic structure of a function is finalized, you can execute it by calling it from another function or directly from the Python prompt. Following is an example to call the printme() function-

def printme( str ):

"This prints a passed string into this function"

print (str)

return

printme("This is first call to the user defined function!")

printme("Again second call to the same function")

This is first call to the user defined function!

Again second call to the same function

Pass by Reference vs Value

All parameters (arguments) in the Python language are passed by reference. It means if you change what a parameter refers to within a function, the change also reflects back in the calling function. For example-

def changeme( mylist ):

"This changes a passed list into this function"

print ("Values inside the function before change: ", mylist)

mylist[2]=50

print ("Values inside the function after change: ", mylist)

return

mylist = [10,20,30]

changeme( mylist )

print ("Values outside the function: ", mylist)

OUTPUT:

Values inside the function before change: [10, 20, 30]

Values inside the function after change: [10, 20, 50]

Values outside the function: [10, 20, 50]

Function Arguments

You can call a function by using the following types of formal arguments-

Required arguments
Keyword arguments
Default arguments
Variable-length arguments

Required Arguments

Required arguments are the arguments passed to a function in correct positional order. Here, the number of arguments in the function call should match exactly with the function definition.

To call the function printme(), you definitely need to pass one argument, otherwise it gives a syntax error

Keyword Arguments

Keyword arguments are related to the function calls. When you use keyword arguments in a function call, the caller identifies the arguments by the parameter name.

This allows you to skip arguments or place them out of order because the Python interpreter is able to use the keywords provided to match the values with parameters. You can also make keyword calls to the printme() function

Default Arguments

A default argument is an argument that assumes a default value if a value is not provided in the function call for that argument.

Variable-length Arguments

You may need to process a function for more arguments than you specified while defining the function. These arguments are called variable-length arguments and are not named in the function definition, unlike required and default arguments.

The Anonymous Functions

These functions are called anonymous because they are not declared in the standard manner by using thedefkeyword. You can use thelambdakeyword to create small anonymous functions.

Lambda forms can take any number of arguments but return just one value in the form of an expression. They cannot contain commands or multiple expressions.
An anonymous function cannot be a direct call to print because lambda requires an expression.
Lambda functions have their own local namespace and cannot access variables other than those in their parameter list and those in the global namespace.
Although it appears that lambdas are a one-line version of a function, they are not equivalent to inline statements in C or C++, whose purpose is to stack allocation by passing function, during invocation for performance reasons.

Syntax:

lambda [arg1 [,arg2,.....argn]]:expression

example:

sum = lambda arg1, arg2: arg1 + arg2

print ("Value of total : ", sum( 10, 20 ))

print ("Value of total : ", sum( 20, 20 ))

OUTPUT:

Value of total : 30

Value of total : 40

Operators

noreply@blogger.com (Vipul's Blog) — Wed, 25 Nov 2020 19:12:00 +0530

Operators

Operators are the constructs, which can manipulate the value of operands. Consider the expression 4 + 5 = 9. Here, 4 and 5 are called operands and + is called the operator.

Types of Operator

Python language supports the following types of operators-

Arithmetic Operators
Comparison (Relational) Operators
Assignment Operators
Logical Operators
Bitwise Operators
Membership Operators
Identity Operators

Python Arithmetic Operators

Assume variable a holds the value 10 and variable b holds the value 21, then-

Operators and their description:-

+ Addition
Adds values on either side of the operator.

example:-

a + b = 31
- Subtraction
Subtracts right hand operand from left hand operand.

example:-

a - b = -11
* Multiplication
Multiplies values on either side of the operator

example:-

a * b = 210
/ Division
Divides left hand operand by right hand operand

example:-

b / a = 2.1
% Modulus
Divides left hand operand by right hand operand and returns remainder

example:-

b%a=1
** Exponent
Performs exponential (power) calculation on operators

example:-

a**b =10 to the power 20
//
Floor Division - The division of operands where the result is the quotient in which the digits after the decimal point are removed.

example:-

9//2 = 4 and 9.0//2.0 = 4.0

Python Comparison Operators

These operators compare the values on either side of them and decide the relation among them. They are also called Relational operators.

Assume variable a holds the value 10 and variable b holds the value 20, then-

==
If the values of two operands are equal, then the condition becomes true.

example:-

(a == b) is not true.
!=
If values of two operands are not equal, then condition becomes true.

example:-

(a!= b) is true.
>
If the value of left operand is greater than the value of right operand, then condition becomes true.

example:-

(a > b) is not true.
<
If the value of left operand is less than the value of right operand, then condition becomes true.

example:-

(a < b) is true.
>=
If the value of left operand is greater than or equal to the value of right operand, then condition becomes true.

example:-

(a >= b) is not true.
<=
If the value of left operand is less than or equal to the value of right operand, then condition becomes true.

example:-

(a <= b) is true.

Python Assignment Operators

Assume variable a holds 10 and variable b holds 20, then-

=
Assigns values from right side operands to left side operand

example:-

c = a + b assigns value of a + b into c
+= Add AND
It adds right operand to the left operand and assign the result to left operand

example:-

c += a is equivalent to c = c + a
-= Subtract AND
It subtracts right operand from the left operand and assign the result to left operand

example:-

c -= a is equivalent to c = c - a
*= Multiply AND
It multiplies right operand with the left operand and assign the result to left operand

example:-

c *= a is equivalent to c = c * a
/= Divide AND
It divides left operand with the right operand and assign the result to left operand

example:-

c /= a is equivalent to c = c / ac /= a is equivalent to c = c / a
%= Modulus AND
It takes modulus using two operands and assign the result to left operand

example:-

c %= a is equivalent to c = c % a
**= Exponent AND
Performs exponential (power) calculation on operators and assign value to the left operand

example:-

c **= a is equivalent to c = c ** a
//= Floor Division
It performs floor division on operators and assign value to the left operand

example:-

c //= a is equivalent to c = c // a

Python Bitwise Operators

Bitwise operator works on bits and performs bit-by-bit operation. Assume if a = 60; and b = 13; Now in binary format they will be as follows-

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

Pyhton's built-in function bin() can be used to obtain binary representation of an integer number.

The following Bitwise operators are supported by Python language-

& Binary AND
Operator copies a bit to the result, if it exists in both operands

example:-

(a & b) (means 0000 1100)
| Binary OR
It copies a bit, if it exists in either operand.

example:-
^ Binary XOR
It copies the bit, if it is set in one operand but not both.

example:-

(a ^ b) = 49 (means 0011 0001)
~ Binary Ones Complement
It is unary and has the effect of 'flipping' bits.

example:-

(~a ) = -61 (means 1100 0011 in 2's complement form due to a signed binary number.
<< Binary Left Shift
The left operand’s value is moved left by the number of bits specified by the right operand.

example:-

a << = 240 (means 1111 0000)
>> Binary Right Shift
The left operand’s value is moved right by the number of bits specified by the right operand.

example:-

a >> = 15 (means 0000 1111)

Python Logical Operators

The following logical operators are supported by Python language. Assume variable a holds True and variable b holds False then-

and Logical AND
If both the operands are true then condition becomes true.

example:-

(a and b) is False.
or Logical OR
If any of the two operands are non-zero then condition becomes true.

example:-

(a or b) is True.
not Logical NOT
Used to reverse the logical state of its operand.

example:-

Not(a and b) is True.

Python Membership Operators

Python’s membership operators test for membership in a sequence, such as strings, lists, or tuples. There are two membership operators as explained below-

in
Evaluates to true, if it finds a variable in the specified sequence and false otherwise.

example:-

x in y, here in results in a 1 if x is a member of sequence y.
not in
Evaluates to true, if it does not find a variable in the specified sequence and false otherwise.

example:-

x not in y, here not in results in a 1 if x is not a member of sequence Y

Python Identity Operators

Identity operators compare the memory locations of two objects. There are two Identity operators as explained below:

is
Evaluates to true if the variables on either side of the operator point to the same object and false otherwise.

example:-

x is y, here is results in 1 if id(x) equals id(y).
is not
Evaluates to false if the variables on either side of the operator point to the same object and true otherwise.

example:-

x is not y, here is not results in 1 if id(x) is not equal to id(y)

Python Operators Precedence

The following table lists all the operators from highest precedence to the lowest.

**
Exponentiation (raise to the power)
~ +-
Ccomplement, unary plus and minus (method names for the last two are +@ and -@)
* / % //
Multiply, divide, modulo and floor division
+-
Addition and subtraction
>> <<
Right and left bitwise shift
&
Bitwise 'AND'
^|
Bitwise exclusive `OR' and regular `OR'
<= < > >=
Comparison operators
<> == !=
Equality operators
= %= /= //= -= += *= **=
Assignment operators
is is not
Identity operators
in not in
Membership operators
not or and
Logical operators

Data Types in Python

noreply@blogger.com (Vipul's Blog) — Wed, 25 Nov 2020 02:00:00 +0530

Data types

Introduction to Data types

In computer science and computer programming, a data type or simply type is a classification of data which tells the compiler or interpreter how the programmer intends to use the data. Most programming languages support various types of data, for example: real, integer or Boolean. A data type provides a set of values from which an expression (i.e. variable, function...) may take its values. This data type defines the operations that can be done on the data, the meaning of the data, and the way values of that type can be stored. A type of value from which an expression may take its value

Variables

Variables are nothing but reserved memory locations to store values. It means that when you create a variable, you reserve some space in the memory.

Based on the data type of a variable, the interpreter allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to the variables, you can store integers, decimals or characters in these variables.

Assigning Values to Variables

Python variables do not need explicit declaration to reserve memory space. The declaration happens automatically when you assign a value to a variable. The equal sign (=) is used to assign values to variables.

The operand to the left of the = operator is the name of the variable and the operand to the right of the = operator is the value stored in the variable.

For example-

counter = 100

miles = 1000.0

name = "John"

print (counter)

print (miles)

print (name)

Here, 100, 1000.0 and "John" are the values assigned to counter, miles, and name variables, respectively. This produces the following result -

100

1000.0

John

Multiple Assignment

Python allows you to assign a single value to several variables simultaneously.

For example-

a=b=c=1

Here, an integer object is created with the value 1, and all the three variables are assigned to the same memory location. You can also assign multiple objects to multiple variables.

For example-

a, b, c = 1, 2, "john"

Here, two integer objects with values 1 and 2 are assigned to the variables a and b respectively, and one string object with the value "john" is assigned to the variable c.

Standard Data Types

The data stored in memory can be of many types. For example, a person's age is stored as a numeric value and his or her address is stored as alphanumeric characters. Python has various standard data types that are used to define the operations possible on them and the storage method for each of them.

Python has five standard data types-

Numbers
String
List
Tuple
Dictionary

Python Numbers

Number data types store numeric values. Number objects are created when you assign a value to them. For example-

var1 = 1

var2 = 10

You can also delete the reference to a number object by using the del statement. The syntax of the del statement is −

del var1[,var2[,var3[....,varN]]]]

You can delete a single object or multiple objects by using the del statement.

For example-

del var

del var_a, var_b

Python supports three different numerical types -

int (signed integers)
float (floating point real values)
complex (complex numbers)

All integers in Python 3 are represented as long integers. Hence, there is no separate number type as long.

Python Strings

Strings in Python are identified as a contiguous set of characters represented in the quotation marks. Python allows either pair of single or double quotes. Subsets of strings can be taken using the slice operator ([ ] and [:] ) with indexes starting at 0 in the beginning of the string and working their way from -1 to the end.

The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition operator. For example-

str = 'Hello World!'

print (str)

print (str[0])

print (str[2:5])

print (str[2:])

print (str * 2)

print (str + "TEST")

This will produce the following result-

Hello World!

llo

llo World!

Hello World!Hello World!

Hello World!TEST

Python Lists

Lists are the most versatile of Python's compound data types. A list contains items separated by commas and enclosed within square brackets ([]). To some extent, lists are similar to arrays in C. One of the differences between them is that all the items belonging to a list can be of different data type.

The values stored in a list can be accessed using the slice operator ([ ] and [:]) with indexes starting at 0 in the beginning of the list and working their way to end -1. The plus (+) sign is the list concatenation operator, and the asterisk (*) is the repetition operator. For example-

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']

print (list)

print (list[0])

print (list[1:3])

print (list[2:])

print (tinylist * 2)

print (list + tinylist)

This produces the following result-

['abcd', 786, 2.23, 'john', 70.200000000000003]

abcd

[786, 2.23]

[2.23, 'john', 70.200000000000003]

[123, 'john', 123, 'john']

['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

Python Tuples

A tuple is another sequence data type that is similar to the list. A tuple consists of a number of values separated by commas. Unlike lists, however, tuples are enclosed within parenthesis.

The main difference between lists and tuples is- Lists are enclosed in brackets ( [ ] ) and their elements and size can be changed, while tuples are enclosed in parentheses ( ( ) ) and cannot be updated. Tuples can be thought of as read-only lists. For example-

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

tinytuple = (123, 'john')

print (tuple)

print (tuple[0])

print (tuple[1:3])

print (tuple[2:])

print (tinytuple * 2)

print (tuple + tinytuple)

This produces the following result-

('abcd', 786, 2.23, 'john', 70.200000000000003)

abcd

(786, 2.23)

(2.23, 'john', 70.200000000000003)

(123, 'john', 123, 'john')

('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

The following code is invalid with tuple, because we attempted to update a tuple, which is not allowed. Similar case is possible with lists -

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]

tuple[2] = 1000

list[2] = 1000

Python Dictionary

Python's dictionaries are kind of hash-table type. They work like associative arrays or hashes found in Perl and consist of key-value pairs. A dictionary key can be almost any Python type, but are usually numbers or strings. Values, on the other hand, can be any arbitrary Python object.

Dictionaries are enclosed by curly braces ({ }) and values can be assigned and accessed using square braces ([]). For example-

dict = {}

dict['one'] = "This is one"

dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print (dict['one'])

print (dict[2])

print (tinydict)

print (tinydict.keys())

print (tinydict.values())

This produces the following result-

This is one

This is two

{'dept': 'sales', 'code': 6734, 'name': 'john'}

['dept', 'code', 'name']

['sales', 6734, 'john']

Dictionaries have no concept of order among the elements. It is incorrect to say that the elements are "out of order"; they are simply unordered.

Data Type Conversion

Sometimes, you may need to perform conversions between the built-in types. To convert between types, you simply use the type-name as a function.

There are several built-in functions to perform conversion from one data type to another. These functions return a new object representing the converted value.

int(x [,base]): Converts x to an integer. The base specifies the base if x is a string.
float(x): Converts x to a floating-point number.
complex(real [,imag]) : Creates a complex number.
str(x) : Converts object x to a string representation.
repr(x) : Converts object x to an expression string.
eval(str) Evaluates a string and returns an object.
tuple(s) : Converts s to a tuple.
list(s) : Converts s to a list.
set(s) : Converts s to a set.
dict(d) : Creates a dictionary. d must be a sequence of (key,value) tuples.
frozenset(s) : Converts s to a frozen set.
chr(x) : Converts an integer to a character.
unichr(x) : Converts an integer to a Unicode character.
ord(x) : Converts a single character to its integer value.
hex(x) : Converts an integer to a hexadecimal string.
oct(x) : Converts an integer to an octal string.

Decision Making in Python Programs

noreply@blogger.com (Vipul's Blog) — Sun, 22 Nov 2020 11:35:00 +0530

Decision making structures require that the programmer specifies one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

There come situations in real life when we need to make some decisions and based on these decisions, we decide what should we do next. Similar situations arise in programming also where we need to make some decisions and based on these decisions we will execute the next block of code. For example, in Python if x occurs then execute y else execute z. There can also be multiple conditions like in Python if x occurs then execute p, else if condition y occurs execute q, else execute r. This condition of Python else-if is one of the many ways of importing multiple conditions.

if statement in Python:

if statement is the most simple decision making statement. It is used to decide whether a certain statement or block of statements will be executed or not i.e if a certain condition is true then a block of statement is executed otherwise not.

The if statement is the simplest example of a decision structure in Python. In an if statement a logical test is made which can evaluate to either true or false. If the result of the test is true, the statements in the if branch are executed. If the result of the test is false, the statements in the else branch are executed. Once the statements in the appropriate branch have been executed, the flow of execution continues on to the statements that follow the if statement.

if(condition) 
{
   // Statements to execute if
   // condition is true
}

Here, condition after evaluation will be either true or false. Python if statement accepts boolean values – if the value is true then it will execute the block of statements below it otherwise not. If we do not provide the curly braces ‘{‘ and ‘}’ after if(condition) then by default if statement will consider the first immediately below statement to be inside its block.

a = int ( input ( "Enter a number: " ) )
b = int ( input ( "Enter another number: " ) )
if a > b :
    print ( "First number is greater than second number " )

if-else in Python

The if statement alone tells us that if a condition is true it will execute a block of statements and if the condition is false it won’t. But what if we want to do something else if the condition is false. Here comes the Python else statement. We can use the else statement with if statement to execute a block of code when the condition is false.

if (condition)
{
    // Executes this block if
    // condition is true
}
else
{
    // Executes this block if
    // condition is false
}

a = int ( input ( "Enter a number: " ) )
b = int ( input ( "Enter another number: " ) )
if a > b :
    print ( "First number is greater than second number " )
else :
    print ( "Second number is greater than first number " )

Nested if statements

An if statement gives us the ability to ask a single question and do something in response to that question. Often, the logic of a particular situation will dictate that we ask more than one question to resolve a situation. In that case, we may need to make use of a nested if. The following example demonstrates how this works in practice. The program below has the user enter three floating point numbers that form the coefficients of a polynomial p(x) = a x2 + b x + c. The program will then try to determine what kind of roots the polynomial has.

The key decision that has to be made is based on the value of the descriminant, b2 - 4 a c. If that quantity is negative, the polynomial has no real roots. If it 0, the equation has one real root, and if it is greater than 0 there are two distinct real roots. The program below uses a pair of nested if statements to determine which of these three cases we are dealing with.

a = input("Enter a number: ")
b = input("Enter another number: ")
if a>b:
    print("First number is greater then Second number")
elif a==b:
    print("Both number is equal")
else:
    print("Second number is greater than First number")

Difference Between a program and a Script

noreply@blogger.com (Vipul's Blog) — Sun, 22 Nov 2020 11:25:00 +0530

What is Difference Between a program and a Script

Basically, all scripting languages are programming languages. The theoretical difference between the two is that scripting languages do not require the compilation step and are rather interpreted. For example, normally, a C program needs to be compiled before running whereas normally, a scripting language like JavaScript or PHP need not be compiled.

What is a Scripting Language?

Scripting languages, as the name suggests, is a programming language that supports scripts. A scripting language binds a set of software components that collaborate to solve a particular problem. Scripting assumes the existence of powerful components and provides the means to connect them together. Scripting languages are glue languages that integrate the execution of system utilities including compilers; command line interpretation; shell-based programming; and execution of codes written in web-based languages. The purpose of a scripting language is the development of applications by plugging existing components together and they generally favor high-level programming over execution speed. Scripting is used in a variety of applications, and scripting languages are correspondingly diverse. Python is a powerful scripting language for complex system involving operating system, networks, and web-based programming.

What is a Programming Language?

A programming language is an organized way of communicating with a computer, such that the computer behaves according to the instructions given by the programmer. A programming language is an artificial formalism in which algorithms can be expressed. In the modern era, the problems to be solved by computers lie in different problem domains such as scientific computing, database programming, business applications, process automation, and web-based applications. All these domains are quite different with varied requirements. A programming language is a specific set of instructions given to a computer in a language that the computer understands to perform specific tasks. Today’s programming languages are the product of development that started in the 1950s. The term programming languages usually refer to high-level languages such as C++, Java, Ada, Pascal, and FORTRAN.

Script :

"Scripts" are distinct from the core code of the application, which is usually written in a different language, and are often created or at least modified by the end-user.
Scripts are often interpreted from source code or bytecode, whereas the applications they control are traditionally compiled to native machine code.
A script may refer to any of the following:
1. A script or scripting language is a computer language with a series of commands within a file that is capable of being executed without being compiled. Good examples of server-side scripting languages include Perl, PHP, and Python. The best example of a client side scripting language is JavaScript. A full list of scripting languages and other programming languages can be found through our programming language definition.
Advantages of scripts
Open source, allowing users to view and edit the script if needed.
Does not require the file to be compiled, but may be when necessary.
Easy to learn and write.
Easy to port between different operating systems.
Much faster to develop than an actual program - some individuals and companies write scripts as a prototype for actual programs.
Disadvantages of scripts
Open source, allows others to view source code, which may be prohibited by some companies.
Requires the user to install an interpreter or separate program before the script can be run.
In some situations, they may be slower than a compiled program.

Program :

The program has an executable form that the computer can use directly to execute the instructions.
The same program in its human-readable source code form, from which executable programs are derived (e.g., compiled)

Scripts vs Programs

It is important to understand the difference between a "script" and a "real program", and which languages are appropriate for each.
Scripts tend to be small (no more than a few hundred or a few thousand lines of code) and do not do any significant computation of their own.
Instead, scripts run "real programs" to do most of the computational work. The job of the script is simply to automate and document the process of running programs.
As a result, scripting languages do not need to be efficient and are generally interpreted rather than compiled. ( Interpreted language programs run an order of magnitude or more slower than equivalent compiled programs, unless most of their computation is done by built-in, compiled subprograms. )
Real programs may be quite large and may implement complex computational algorithms. Hence, they need to be fast and as a result are usually written in compiled languages.
If you plan to use exclusively pre-existing programs such as Unix commands and/or add-on application software, and need only automate the execution of these programs, then you need to write a script and should choose a good scripting language.
If you plan to implement your own algorithm(s) that may require a lot of computation, then you need to write a program and should select an appropriate compiled programming language

How to install Python on Linux

noreply@blogger.com (Vipul's Blog) — Tue, 17 Nov 2020 18:43:00 +0530

Installing Python 3.8 on Ubuntu with Apt

Installing Python 3.8 on Ubuntu with apt is a relatively straightforward process and takes only a few minutes:

Run the following commands as root or user with sudo access to update the packages list and install the prerequisites:
```
sudo apt updatesudo apt install software-properties-common
```

Add the deadsnakes PPA to your system’s sources list:

sudo add-apt-repository ppa:deadsnakes/ppa

When prompted press Enter to continue:

Press [ENTER] to continue or Ctrl-c to cancel adding it.

Once the repository is enabled, install Python 3.8 with:
```
sudo apt install python3.8
```
Verify that the installation was successful by typing:
```
python3.8 --version
```
```
Python 3.8.0
```
At this point, Python 3.8 is installed on your Ubuntu system, and you can start using it.

__________________________________________________________________

Installing Python 3.8 on Ubuntu from Source

In this section, we’ll explain how to compile Python 3.8 from the source.

Update the packages list and install the packages necessary to build Python:

sudo apt updatesudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev libsqlite3-dev wget

Download the latest release’s source code from the Python download page using wget:
```
wget https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tgz
```
At the time of writing this article, the latest release is 3.8.0.
When the download finishes,:
```
tar -xf Python-3.8.0.tgz
```
Switch to the Python source directory and execute the configure script which performs a number of checks to make sure all of the dependencies on your system are present:
```
cd Python-3.8.0./configure --enable-optimizations
```
The --enable-optimizations option optimizes the Python binary by running multiple tests. This makes the build process slower.
Start the Python 3.8 build process:
```
make -j 8
```
For faster build time, modify the -j to correspond to the number of cores in your processor. You can find the number by typing nproc.
When the build process is complete, install the Python binaries by typing:
```
sudo make altinstall
```
Do not use the standard make install as it will overwrite the default system python3 binary.
That’s it. Python 3.8 has been installed and ready to be used. Verify it by typing:
```
python3.8 --version
```
The output should show the Python version:
```
Python 3.8.0
```

Python3 Vs Python2

noreply@blogger.com (Vipul's Blog) — Mon, 16 Nov 2020 19:46:00 +0530

If you’re new to Python perhaps you’ve heard there are two major versions out in the wild: Python 2 and Python 3. So which should you learn and why is there a debate about this?

It’s understandable that porting large existing code bases to a new version is a prospect which sends a shiver down many a developer’s spine. Python 3 was released to fix problems present in Python 2. The nature of these changes meant that Python 3 was incompatible with Python 2. It also meant that Python 3 did not carry forward the problems of Python 2. Some aspects of Python 3 have been back ported to Python 2.6 and 2.7 to make the migration to Python 3 easier.Python 2 was supposed to be retired in 2015 but slow adoption of Python 3 led to an extended deadline of 2020. Python 2.7 will receive updates till 2020 for security and bug fixes only.

I am new to Python. Should I learn Python 2 or Python 3?

Python 3 fixes many of the problems that are present in Python 2. Python 3 is also the future of the language since Python 2 will be retired in 2020. It's therefore recommended that beginners learn Python 3. Moreover, if you're going to write new code.

If you've to maintain legacy Python 2 code, it's still best to learn Python the right way from Python 3. Then you can study the differences between Python 2 and 3. The point is that the two versions are much more similar than different.

Users who are new to use Python may get confused about the different versions available in today’s market. Though Python 3 is the latest version, still there are few developers using Python 2. You can see advantages in both the versions and utilize those based on the requirement. Now let us see the details on Python2 Vs Python 3.

Why Python 3?

The answer I give most people is because Python 2 has been end-of-life’d. The people that work directly on Python have decided that there won’t ever be a Python 2.8. They also decided that Python 2.7, from now on, will only get security updates from the Python 3 development branch. No new features unless someone wants to spend the extra required time to back port them. Thankfully, several people are willing to do this. This has given us the amazing __future__ module full of Python 3 goodies, but that’s not the same as using them natively.

Another, somewhat embarrassing reason, is that I hadn’t had a lot of pure Python 3 experience. I wanted to be able to learn more of the newest version of my favorite language. Python 3 scared me when I first looked at it a year or so ago. It seemed like a big change for no real gain and I had visions of having to rewrite everything I had done to support this new interpreter. I was so wrong.

Python 3.0 – Released in the year 2008
Python 3.6 – Released in the year 2016
Python 3.7 under development
Python 3 is to manage the design defects in the earlier versions
Python 3 syntax is simple and easy to understand
Python 3 Print syntax is plainly treated as a function.
Example: print “hello”
In Python 3, dividing two (2) integers result in an integer value
3.0/2.0= 1.5
Libraries are being developed and they are made strict to use with Python 3
Here range does what xrange does in Python 2.7 and xrange function is not available
For-loop variable does not leak into the global namespace
Python 3 has only one input taking method which is input(). raw_input() is not available in Python 3. In case to use raw_input() like Python 2, make use of eval () method
Rules of ordering comparisons in Python 3 have been made simpler

Why you must learn Python 2?

Even though, Python 2 is known to be the old version of open source where you will still need to learn Python 2. For becoming the DevOps engineer and you should also work with the different configurations management tools such as Ansible and puppet. Here, you should also work with both available versions. If the company’s code is written in Python 2, you need to learn to work for it. If the entire development team is perfectly working on the project which depends on particular third-party libraries and the third party software that you are not capable of port and Python 3, so Python 2 is an only available option for the user.

There's ASCII str type and unicode type, but no separate type to handle bytes of data
Two types of integers: C-based integers (int) and Python long integer (long)
Return type of division is int if operands are integers: 5 / 4 gives 1; 4 / 2 gives 2
round(16.5) returns a float of value 16.0
Unorderable types can be compared
print is a statement: print "Hello World!"
range() returns a list of numbers while xrange() returns an object for lazy evaluation
Functions/methods map(), filter(), zip(), dict.items(), dict.keys(), dict.values() return lists
raw_input() returns input as str and input() evaluates the input as a Python expression
Raising exceptions: raise IOError("file error") or raise IOError, "file error"
Handling exceptions: except NameError, err: or except (TypeError, NameError), err:
On generators, a method or function call: g.next() or next(g)
Loop variables in a comprehension leak to global namespace

Which Python Version you should Use?

When it is about the comparison of Python 2 version and the 3 today, Also, Python 3 is an outright winner. The reason is simple that Python 2 will be available after the year 2020. Even the adoption of Mass Python 3 is also a clear direction of the future. After considering declining any kind of support for Python 2 programming language along with the additional benefits from the upgrades to Python 3, it is usually advisable for the developer to choose Python version 3. On the other hand, if the job demands the capabilities of Python 2, this would be just a compelling reason for using this version.

Main differences

While Python 2 and 3 are quite similar, there are notable differences in code handling and syntax. You should not assume that code written in Python 2 will work smoothly in Python 3 or vice versa.

Print

In Python 2, print is a statement not a function. You use it as follows:

print "I'm a print statement in Python 2"

In Python 3, print() is explicitly treated as a function, so we use standard function syntax:

print("I'm a print statement in Python 3")

Note that Python 3’s print() syntax is backwards-compatible with Python 2.7, so a Python 3 print() function will run in either version.

Nmap & Zenmap

noreply@blogger.com (Vipul's Blog) — Fri, 28 Aug 2020 01:18:00 +0530

Watch out this video for practical Knowledge:-

Nmap:- Nmap is free and is one of the most powerful network scanning tools available for both Windows and Linux platforms. Nmap can help both network administrators and cybersecurity professionals in many ways.

Features:-

Creating a network inventory
Checking for live hosts
Determining operating systems
Determining running services and their version
Identifying vulnerabilities on a host
Detecting sniffers
Determining whether a firewall is present on a network

Zenmap:- Zenmap is the graphical user interface (GUI) version of Nmap and is supported on multiple platforms, such as Windows, Linux, and macOS. The creation of Zenmap was geared toward beginners as it's easier to use than the traditional command-line interface of Nmap. To download Zenmap on your system, please visit https://nmap.org/zenmap/ .

The following shows the Zenmap interface. It's quite simple to use: simply enter the target and select the type of scan you would like to perform. Depending on the type of scan you select, the necessary Nmap operators will be set in the command field.

For better understanding go for the Video.

Nmap

noreply@blogger.com (Vipul's Blog) — Tue, 25 Aug 2020 16:01:00 +0530

For Practical Watch Video here:-

Nmap:- Nmap is free and is one of the most powerful network scanning tools available for both Windows and Linux platforms. Nmap can help both network administrators and cybersecurity professionals in many ways.

Nmap features include the following:

Creating a network inventory
Checking for live hosts
Determining operating systems
Determining running services and their version
Identifying vulnerabilities on a host
Detecting sniffers
Determining whether a firewall is present on a network

The basics of Nmap and move gradually on to advanced scanning techniques. As penetration testers, we must ensure that we have an arsenal of tools that will help us to perform our jobs efficiently. However, as professionals, we must also ensure that we are very familiar with, and know how to use, each tool available to us.

Watch out the video to know how Nmap Works.

Google hacking and search operators

noreply@blogger.com (Vipul's Blog) — Sun, 23 Aug 2020 09:44:00 +0530

The concept of Google hacking is not actually hacking into Google's network infrastructure or systems, but rather using advanced search parameters within the Google search engine.
We can use Google to help us find vulnerable systems, hidden information, and resources on the internet by simply inserting special search operators in the Google search bar.

Let's imagine that you would like to use the Google search engine to look for various websites, but you don't want to see results that contain certain keywords or phrases. We can use the
<string of text here> -<keyword>
syntax to do this. The keyword is the phrase or text that you want to exclude.

The following table is a brief list of Google search operators, also known as Google dorks, that can help you find sensitive information on the internet:

Setting Up Kali Linux

noreply@blogger.com (Vipul's Blog) — Sat, 22 Aug 2020 20:49:00 +0530

For practical Watch out this Video..

As a future ethical hacker and/or penetration tester, it is quite important when testing payloads or practicing hacking skills that you do not disrupt or cause any sort of harm or damage to other people's computers or network infrastructure, such as that of your
organization. To elaborate further, we'll use a simple analogy. Imagine you work for a company called ACME (a fictional organization) and you're the network/system administrator. Your IT director has noticed you express an interest in cybersecurity and
that you have significant potential in becoming a penetration tester or an ethical hacker. They, therefore, approve official training in penetration testing certification for you. Once the training has ended, access to the virtual labs through the Authorized Training Centre (ATC) is usually terminated, which poses a real challenge for you: how are you going to practice your hacking skills when the training course and lab access has ended? Another challenge is the fact that practicing hacking techniques on an organization's network is intrusive and illegal.
This brings us to the importance of building our own personal lab environment for practicing and improving our skill set. Furthermore, having our own penetration testing lab will allow us to try new attacks, tools, and techniques without worrying about being intrusive or creating a security breach in a company network. Most importantly, you will learn about the importance of building and designing a suitable penetration testing lab for practicing various hacking techniques on Windows and Linux operating systems.

Footprinting & Reconnaissance

noreply@blogger.com (Vipul's Blog) — Thu, 20 Aug 2020 20:19:00 +0530

Footprinting:

Footprinting is the procedure whereby as much information as possible is gathered in relation to a target. In footprinting, the objective is to obtain specific details about the target, such as its operating systems and the service versions of running applications. The information that's collected can be used in various ways to gain access to the target system, network, or organization. Footprinting allows a penetration tester to understand the security posture of the target infrastructure, quickly identify security vulnerabilities on the

target systems and networks, create a network map of the organization, and reduce the area of focus to the specific IP addresses, domain names, and the types of devices regarding

which information is required.

Reconnaissance:

From a military perspective, reconnaissance is the observation and research of an enemy target. In cybersecurity, as a penetration tester, we use various tools and techniques to gather detailed information about a target organization and its underlying infrastructure.

Reconnaissance is vital in the field of penetration testing. As a penetration tester, we definitely need to know about our target, as well as its vulnerabilities and operating systems, before we attempt to gain access via exploitation. The information gathered during the reconnaissance phase will help us to choose the right tools and techniques to successfully exploit the target.