Python

Python is a popular programming language. It was created by Guido van Rossum, and
released in 1991.

It is used for:

 web development (server-side),

 software development,
 mathematics,
 system scripting.

What can Python do?

 Python can be used on a server to create web applications.
 Python can be used alongside software to create workflows.
 Python can connect to database systems. It can also read and modify files.
 Python can be used to handle big data and perform complex mathematics.
 Python can be used for rapid prototyping, or for production-ready software
development.

Why Python?
 Python works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc).
 Python has a simple syntax similar to the English language.
 Python has syntax that allows developers to write programs with fewer lines than some
other programming languages.
 Python runs on an interpreter system, meaning that code can be executed as soon as it
is written. This means that prototyping can be very quick.
 Python can be treated in a procedural way, an object-oriented way or a functional way.

Python History and Versions

o Python laid its foundation in the late 1980s.
o The implementation of Python was started in December 1989 by Guido Van Rossum at CWI in Netherland.
o In February 1991, Guido Van Rossum published the code (labeled version 0.9.0) to alt.sources.
o In 1994, Python 1.0 was released with new features like lambda, map, filter, and reduce.
o Python 2.0 added new features such as list comprehensions, garbage collection systems.
o On December 3, 2008, Python 3.0 (also called "Py3K") was released. It was designed to rectify the
fundamental flaw of the language.
o ABC programming language is said to be the predecessor of Python language, which was capable of
Exception Handling and interfacing with the Amoeba Operating System.
o The following programming languages influence Python:
o ABC language.
o Modula-3
Java vs. Python
One of the heated debates of these times is that which programming language is superior Java or Python.
The following content will help you conclude and decide which one is a better option and why. The
following would be a drawn comparison between the two and the comparison would be on the following
factors-

o Speed
o Code
o Trends
o Salary

Topic Java Python

Compilation Java is both compiled and interpreted Python is an interpreted language, i.e., it is
process language. The source code is first compiled and executed simultaneously line
compiled and converted to bytecode, by line.
and afterward, it depends on JIM
whether the bytecode will be collected
or interpreted

Length of The length of the code of java programs Python has shorter lines of code as you
code is more as compared to that of Python directly write the code and it gets
as every program has to be written in a interpreted.
class. For Eg- to write hello world
program, the code is- For eg-
public class HelloWorld {
public static void main(String[] args) { print('Hello, world!')
System.out.println("Hello, World");
}
}

Complexity Java is a statically typed programming Python is dynamically typed and there are
of syntax language. There are hardcore rules for no hardcore rules for semi-colon and braces.
braces and semi-colon. It works on inundation.

Ease of Strongly typed, need to define exact Dynamically typed, no need to define the
typing types of variables. exact type of variables.

Speed Java is faster as compared to Python. Python is relatively slow as it is interpreted

language and it determines the type of the
variable at run time, which makes it slow.

Usage It has been in trend for a long time and Data science and machine language are
is vastly used in Android application made very simple, using Python. Also, it is
development, embedded systems, and being used for web development.
web applications.
 Salary The java pay for beginners is less as Python developers are less as compared to
trends compared to python beginners, but the Java developers that are why are being paid
trend is changing and python more. Also, the technicality in the work of
developers are taking that spot. python developers is more; that is why they
are being paid more.

Python Comments
Comments can be used to explain Python code.

Comments can be used to make the code more readable.

Comments can be used to prevent execution when testing code.

Creating a Comment
Comments starts with a #, and Python will ignore them:

Multiline Comments
Python does not really have a syntax for multiline comments.

To add a multiline comment you could insert a # for each line

Or, not quite as intended, you can use a multiline string.

Since Python will ignore string literals that are not assigned to a variable, you can add a
multiline string (triple quotes) in your code, and place your comment inside it:

Example
"""
This is a comment
written in
more than just one line
"""
print("Hello, World!")

Variables
Variables are containers for storing data values.
Creating Variables
Python has no command for declaring a variable.

A variable is created the moment you first assign a value to it.

Example
x = 5
y = "John"
print(x)
print(y)
Variables do not need to be declared with any particular type, and can even change type after
they have been set.

Example
x = 4 # x is of type int
x = "Sally" # x is now of type str
print(x)

Casting
If you want to specify the data type of a variable, this can be done with casting.

Example
x = str(3) # x will be '3'
y = int(3) # y will be 3
z = float(3) # z will be 3.

Get the Type

You can get the data type of a variable with the type() function.

Example
x = 5
y = "John"
print(type(x))
print(type(y))

Single or Double Quotes?

String variables can be declared either by using single or double quotes:
Example
x = "John"
# is the same as
x = 'John'

Case-Sensitive
Variable names are case-sensitive.

Example
This will create two variables:

a = 4
A = "Sally"
#A will not overwrite a

Variable Names
A variable can have a short name (like x and y) or a more descriptive name (age, carname,
total_volume). Rules for Python variables:

 A variable name must start with a letter or the underscore character

 A variable name cannot start with a number
 A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9,
and _ )
 Variable names are case-sensitive (age, Age and AGE are three different variables)
 A variable name cannot be any of the Python keywords.

Camel Case
 Each word, except the first, starts with a capital letter:
 myVariableName = "John"


Pascal Case
 Each word starts with a capital letter:
 MyVariableName = "John"


Snake Case
 Each word is separated by an underscore character:
 my_variable_name = "John"

Many Values to Multiple Variables

Python allows you to assign values to multiple variables in one line:

x, y, z = "Orange", "Banana", "Cherry"

One Value to Multiple Variables
And you can assign the same value to multiple variables in one line:

x = y = z = "Orange"

Unpack a Collection
If you have a collection of values in a list, tuple etc. Python allows you to extract the values
into variables. This is called unpacking.

Unpack a list:

fruits = ["apple", "banana", "cherry"]

x, y, z = fruits

Python Classes/Objects
Python is an object oriented programming language.

Almost everything in Python is an object, with its properties and methods.

A Class is like an object constructor, or a "blueprint" for creating objects.

Create a Class
To create a class, use the keyword class:

ExampleGet your own Python Server

Create a class named MyClass, with a property named x:

class MyClass:
x = 5

Create Object
Now we can use the class named MyClass to create objects:

Example
Create an object named p1, and print the value of x:

p1 = MyClass()
print(p1.x)
 Standard data types
A variable can contain a variety of values. On the other hand, a person's id must be stored as an integer,
while their name must be stored as a string.

The storage method for each of the standard data types that Python provides is specified by Python. The
following is a list of the Python-defined data types.

1. Numbers
2. Sequence Type
3. Boolean
4. Set
5. Dictionary

The data types will be briefly discussed in this tutorial section. We will talk about every single one of them
exhaustively later in this instructional exercise.

Numbers
Numeric values are stored in numbers. The whole number, float, and complex qualities have a place with
a Python Numbers datatype. Python offers the type() function to determine a variable's data type. The
instance () capability is utilized to check whether an item has a place with a specific class.

When a number is assigned to a variable, Python generates Number objects. For instance,

1. a = 5
2. print("The type of a", type(a))
3.
4. b = 40.5
5. print("The type of b", type(b))
6.
7. c = 1+3j
8. print("The type of c", type(c))
9. print(" c is a complex number", isinstance(1+3j,complex))

Output:

The type of a <class 'int'>

The type of b <class 'float'>
The type of c <class 'complex'>
c is complex number: True

Python supports three kinds of numerical data.

o Int: Whole number worth can be any length, like numbers 10, 2, 29, - 20, - 150, and so on. An integer can
be any length you want in Python. Its worth has a place with int.
o Float: Float stores drifting point numbers like 1.9, 9.902, 15.2, etc. It can be accurate to within 15 decimal
places.
o Complex: An intricate number contains an arranged pair, i.e., x + iy, where x and y signify the genuine and
non-existent parts separately. The complex numbers like 2.14j, 2.0 + 2.3j, etc.

Sequence Type
String

The sequence of characters in the quotation marks can be used to describe the string. A string can be
defined in Python using single, double, or triple quotes.

String dealing with Python is a direct undertaking since Python gives worked-in capabilities and
administrators to perform tasks in the string.

When dealing with strings, the operation "hello"+" python" returns "hello python," and the operator + is
used to combine two strings.

Because the operation "Python" *2 returns "Python," the operator * is referred to as a repetition operator.

The Python string is demonstrated in the following example.

Example - 1

1. str = "string using double quotes"

2. print(str)
3. s = '''''A multiline
4. string'''
5. print(s)

Output:
 string using double quotes
A multiline
string

Look at the following illustration of string handling.

Example - 2

1. str1 = 'hello javatpoint' #string str1

2. str2 = ' how are you' #string str2
3. print (str1[0:2]) #printing first two character using slice operator
4. print (str1[4]) #printing 4th character of the string
5. print (str1*2) #printing the string twice
6. print (str1 + str2) #printing the concatenation of str1 and str2

Output:

he
o
hello javatpointhello javatpoint
hello javatpoint how are you

List

Lists in Python are like arrays in C, but lists can contain data of different types. The things put away in the
rundown are isolated with a comma (,) and encased inside square sections [].

To gain access to the list's data, we can use slice [:] operators. Like how they worked with strings, the list
is handled by the concatenation operator (+) and the repetition operator (*).

Look at the following example.

Example:

1. list1 = [1, "hi", "Python", 2]

2. #Checking type of given list
3. print(type(list1))
4.
5. #Printing the list1
6. print (list1)
7.
8. # List slicing
9. print (list1[3:])
10.
11. # List slicing
12. print (list1[0:2])
13.
14. # List Concatenation using + operator
15. print (list1 + list1)
16.
17. # List repetation using * operator
18. print (list1 * 3)

Output:

[1, 'hi', 'Python', 2]

[2]
[1, 'hi']
[1, 'hi', 'Python', 2, 1, 'hi', 'Python', 2]
[1, 'hi', 'Python', 2, 1, 'hi', 'Python', 2, 1, 'hi', 'Python', 2]

Tuple
In many ways, a tuple is like a list. Tuples, like lists, also contain a collection of items from various data
types. A parenthetical space () separates the tuple's components from one another.

Because we cannot alter the size or value of the items in a tuple, it is a read-only data structure.

Let's look at a straightforward tuple in action.

Example:

1. tup = ("hi", "Python", 2)

2. # Checking type of tup
3. print (type(tup))
4.
5. #Printing the tuple
6. print (tup)
7.
8. # Tuple slicing
9. print (tup[1:])
10. print (tup[0:1])
11.
12. # Tuple concatenation using + operator
13. print (tup + tup)
14.
15. # Tuple repatation using * operator
16. print (tup * 3)
17.
18. # Adding value to tup. It will throw an error.
19. t[2] = "hi"

Output:

<class 'tuple'>
('hi', 'Python', 2)
('Python', 2)
('hi',)
('hi', 'Python', 2, 'hi', 'Python', 2)
 ('hi', 'Python', 2, 'hi', 'Python', 2, 'hi', 'Python', 2)

Traceback (most recent call last):

File "main.py", line 14, in <module>
t[2] = "hi";
TypeError: 'tuple' object does not support item assignment

Dictionary
A dictionary is a key-value pair set arranged in any order. It stores a specific value for each key, like an
associative array or a hash table. Value is any Python object, while the key can hold any primitive data
type.

The comma (,) and the curly braces are used to separate the items in the dictionary.

Look at the following example.

1. d = {1:'Jimmy', 2:'Alex', 3:'john', 4:'mike'}

2.
3. # Printing dictionary
4. print (d)
5.
6. # Accesing value using keys
7. print("1st name is "+d[1])
8. print("2nd name is "+ d[4])
9.
10. print (d.keys())
11. print (d.values())

Output:

1st name is Jimmy

2nd name is mike
{1: 'Jimmy', 2: 'Alex', 3: 'john', 4: 'mike'}
dict_keys([1, 2, 3, 4])
dict_values(['Jimmy', 'Alex', 'john', 'mike'])

Boolean
True and False are the two default values for the Boolean type. These qualities are utilized to decide the
given assertion valid or misleading. The class book indicates this. False can be represented by the 0 or
the letter "F," while true can be represented by any value that is not zero.

Look at the following example.

1. # Python program to check the boolean type

2. print(type(True))
3. print(type(False))
4. print(false)

Output:
 <class 'bool'>
<class 'bool'>
NameError: name 'false' is not defined

Set
The data type's unordered collection is Python Set. It is iterable, mutable(can change after creation), and
has remarkable components. The elements of a set have no set order; It might return the element's altered
sequence. Either a sequence of elements is passed through the curly braces and separated by a comma
to create the set or the built-in function set() is used to create the set. It can contain different kinds of
values.

Look at the following example.

1. # Creating Empty set

2. set1 = set()
3.
4. set2 = {'James', 2, 3,'Python'}
5.
6. #Printing Set value
7. print(set2)
8.
9. # Adding element to the set
10.
11. set2.add(10)
12. print(set2)
13.
14. #Removing element from the set
15. set2.remove(2)
16. print(set2)

Built-in Data Types

In programming, data type is an important concept.

Variables can store data of different types, and different types can do different things.

Python has the following data types built-in by default, in these categories:

Text Type: str

Numeric Types: int, float, complex

Sequence Types: list, tuple, range

Mapping Type: dict

Set Types: set, frozenset

 Boolean Type: bool

Binary Types: bytes, bytearray, memoryview

Internal Types
o Code
o Frame
o Traceback
o Slice
o Ellipsis
o Xrange

We will briefly introduce these internal types here. The general application programmer would typically not
interact with these objects directly, but we include them here for completeness. Please refer to the source
code or Python internal and online documentation for more information.

In case you were wondering about exceptions, they are now implemented as classes. In older versions of
Python, exceptions were implemented as strings.

1. Code Objects
Code objects are executable pieces of Python source that are byte-compiled, usually as return values from
calling the compile() BIF. Such objects are appropriate for execution by either exec or by the eval() BIF.
All this will be discussed in greater detail in Chapter 14.

Code objects themselves do not contain any information regarding their execution environment, but they are
at the heart of every user-defined function, all of which do contain some execution context. (The actual byte-
compiled code as a code object is one attribute belonging to a function.) Along with the code object, a
function's attributes also consist of the administrative support that a function requires, including its name,
documentation string, default arguments, and global namespace.

2. Frame Objects
These are objects representing execution stack frames in Python. Frame objects contain all the information
the Python interpreter needs to know during a runtime execution environment. Some of its attributes include
a link to the previous stack frame, the code object (see above) that is being executed, dictionaries for the
local and global namespaces, and the current instruction. Each function call results in a new frame object,
and for each frame object, a C stack frame is created as well. One place where you can access a frame
object is in a traceback object (see the following section).

3. Traceback Objects
When you make an error in Python, an exception is raised. If exceptions are not caught or "handled," the
interpreter exits with some diagnostic information similar to the output shown below:

Traceback (innermost last): File "<stdin>", line N?, in ??? ErrorName: error
reason

The traceback object is just a data item that holds the stack trace information for an exception and is
created when an exception occurs. If a handler is provided for an exception, this handler is given access to
the traceback object.

4. Slice Objects
Slice objects are created using the Python extended slice syntax. This extended syntax allows for different
types of indexing. These various types of indexing include stride indexing, multi-dimensional indexing, and
indexing using the Ellipsis type. The syntax for multi-dimensional indexing
is sequence[start1 : end1, start2 : end2], or using the ellipsis, sequence [..., start1 : end1]. Slice
objects can also be generated by the slice() BIF.

Stride indexing for sequence types allows for a third slice element that allows for "step"-like access with a
syntax of sequence[starting_index : ending_index : stride].

Support for the stride element of the extended slice syntax have been in Python for a long time, but until 2.3
was only available via the C API or Jython (and previously JPython). Here is an example of stride indexing:

>>> foostr = 'abcde' >>> foostr[::-1] 'edcba' >>> foostr[::-2] 'eca' >>>
foolist = [123, 'xba', 342.23, 'abc'] >>> foolist[::-1] ['abc', 342.23, 'xba',
123]

5. Ellipsis Objects
Ellipsis objects are used in extended slice notations as demonstrated above. These objects are used to
represent the actual ellipses in the slice syntax (...). Like the Null object None, ellipsis objects also have a
single name, Ellipsis, and have a Boolean TRue value at all times.

6. XRange Objects
XRange objects are created by the BIF xrange(), a sibling of the range() BIF, and used when memory is
limited and when range() generates an unusually large data set. You can find out more
about range() and xrange() in Chapter 8.

For an interesting side adventure into Python types, we invite the reader to take a look at the types module
in the standard Python library.

Python Operators
Introduction:
In this article, we are discussing Python Operators. The operator is a symbol that performs a specific
operation between two operands, according to one definition. Operators serve as the foundation upon
which logic is constructed in a program in a particular programming language. In every programming
language, some operators perform several tasks. Same as other languages, Python also has some
operators, and these are given below -

o Arithmetic operators
o Comparison operators
o Assignment Operators
o Logical Operators
o Bitwise Operators
o Membership Operators
o Identity Operators
o Arithmetic Operators

Arithmetic Operators
Arithmetic operators used between two operands for a particular operation. There are many arithmetic
operators. It includes the exponent (**) operator as well as the + (addition), - (subtraction), *
(multiplication), / (divide), % (reminder), and // (floor division) operators.

Consider the following table for a detailed explanation of arithmetic operators.

Operator Description

+ (Addition) It is used to add two operands. For example, if a = 10, b = 10 => a+b = 20

- (Subtraction) It is used to subtract the second operand from the first operand. If the first operand is less
than the second operand, the value results negative. For example, if a = 20, b = 5 => a - b
= 15

/ (divide) It returns the quotient after dividing the first operand by the second operand. For example,
if a = 20, b = 10 => a/b = 2.0

* It is used to multiply one operand with the other. For example, if a = 20, b = 4 => a * b =
(Multiplication) 80

% (reminder) It returns the reminder after dividing the first operand by the second operand. For example,
if a = 20, b = 10 => a%b = 0

** (Exponent) As it calculates the first operand's power to the second operand, it is an exponent operator.

// (Floor It provides the quotient's floor value, which is obtained by dividing the two operands.
division)

Comparison operator
Comparison operators mainly use for comparison purposes. Comparison operators compare the values
of the two operands and return a true or false Boolean value in accordance. The example of comparison
operators are ==, !=, <=, >=, >, <. In the below table, we explain the works of the operators.

Operator Description

== If the value of two operands is equal, then the condition becomes true.

!= If the value of two operands is not equal, then the condition becomes true.

<= The condition is met if the first operand is smaller than or equal to the second operand.
 >= The condition is met if the first operand is greater than or equal to the second operand.

> If the first operand is greater than the second operand, then the condition becomes true.

< If the first operand is less than the second operand, then the condition becomes true.

Assignment Operators
Using the assignment operators, the right expression's value is assigned to the left operand. There are
some examples of assignment operators like =, +=, -=, *=, %=, **=, //=. In the below table, we explain
the works of the operators.

Operator Description

= It assigns the value of the right expression to the left operand.

+= By multiplying the value of the right operand by the value of the left operand, the left operand
receives a changed value. For example, if a = 10, b = 20 => a+ = b will be equal to a = a+ b and
therefore, a = 30.

-= It decreases the value of the left operand by the value of the right operand and assigns the
modified value back to left operand. For example, if a = 20, b = 10 => a- = b will be equal to a =
a- b and therefore, a = 10.

*= It multiplies the value of the left operand by the value of the right operand and assigns the
modified value back to then the left operand. For example, if a = 10, b = 20 => a* = b will be equal
to a = a* b and therefore, a = 200.

%= It divides the value of the left operand by the value of the right operand and assigns the reminder
back to the left operand. For example, if a = 20, b = 10 => a % = b will be equal to a = a % b and
therefore, a = 0.

**= a**=b will be equal to a=a**b, for example, if a = 4, b =2, a**=b will assign 4**2 = 16 to a.

//= A//=b will be equal to a = a// b, for example, if a = 4, b = 3, a//=b will assign 4//3 = 1 to a.

Bitwise Operators
The two operands' values are processed bit by bit by the bitwise operators. The examples of Bitwise
operators are bitwise OR (|), bitwise AND (&), bitwise XOR (^), negation (~), Left shift (<<), and Right shift
(>>).
 Operator Description

& (binary and) A 1 is copied to the result if both bits in two operands at the same location are 1. If not, 0 is
copied.

| (binary or) The resulting bit will be 0 if both the bits are zero; otherwise, the resulting bit will be 1.

^ (binary xor) If the two bits are different, the outcome bit will be 1, else it will be 0.

~ (negation) The operand's bits are calculated as their negations, so if one bit is 0, the next bit will be 1, and
vice versa.

<< (left shift) The number of bits in the right operand is multiplied by the leftward shift of the value of the
left operand.

>> (right The left operand is moved right by the number of bits present in the right operand.
shift)

Logical Operators
The assessment of expressions to make decisions typically uses logical operators. The examples of logical
operators are and, or, and not. In the case of logical AND, if the first one is 0, it does not depend upon
the second one. In the case of logical OR, if the first one is 1, it does not depend on the second one.
Python supports the following logical operators. In the below table, we explain the works of the logical
operators.

Operator Description

and The condition will also be true if the expression is true. If the two expressions a and b are the same, the
be true.

or The condition will be true if one of the phrases is true. If a and b are the two expressions, then an or b m
true and b is false.

not If an expression a is true, then not (a) will be false and vice versa.

Membership Operators
The membership of a value inside a Python data structure can be verified using Python membership
operators. The result is true if the value is in the data structure; otherwise, it returns false.
 Operator Description

in If the first operand cannot be found in the second operand, it is evaluated to be true (list, tuple,
or dictionary).

not in If the first operand is not present in the second operand, the evaluation is true (list, tuple, or
dictionary).

Identity Operators

Operator Description

is If the references on both sides point to the same object, it is determined to be true.

is not If the references on both sides do not point at the same object, it is determined to be true.

Operator Precedence
The order in which the operators are examined is crucial to understand since it tells us which operator
needs to be considered first. Below is a list of the Python operators' precedence tables.

Operator Description

** Overall other operators employed in the expression, the exponent operator is given
precedence.

~+- the minus, unary plus, and negation.

* / % // the division of the floor, the modules, the division, and the multiplication.

+- Binary plus, and minus

>> << Left shift. and right shift

& Binary and.

^| Binary xor, and or

<= < > >= Comparison operators (less than, less than equal to, greater than, greater then equal to).
 <> == != Equality operators.

= %= /= //= -= += Assignment operators

*= **=

is is not Identity operators

in not in Membership operators

not or and Logical operators

Python Built in Functions

Python has a set of built-in functions.

Function Description

abs() Returns the absolute value of a number

all() Returns True if all items in an iterable object are true

any() Returns True if any item in an iterable object is true

ascii() Returns a readable version of an object. Replaces none-ascii characters

with escape character

bin() Returns the binary version of a number

bool() Returns the boolean value of the specified object

bytearray() Returns an array of bytes

bytes() Returns a bytes object

callable() Returns True if the specified object is callable, otherwise False

chr() Returns a character from the specified Unicode code.

classmethod() Converts a method into a class method

compile() Returns the specified source as an object, ready to be executed

complex() Returns a complex number

delattr() Deletes the specified attribute (property or method) from the specified
object

dict() Returns a dictionary (Array)

dir() Returns a list of the specified object's properties and methods

divmod() Returns the quotient and the remainder when argument1 is divided by
argument2

enumerate() Takes a collection (e.g. a tuple) and returns it as an enumerate object

eval() Evaluates and executes an expression

exec() Executes the specified code (or object)

filter() Use a filter function to exclude items in an iterable object

float() Returns a floating point number

format() Formats a specified value

frozenset() Returns a frozenset object

getattr() Returns the value of the specified attribute (property or method)

globals() Returns the current global symbol table as a dictionary

hasattr() Returns True if the specified object has the specified attribute
(property/method)

hash() Returns the hash value of a specified object

help() Executes the built-in help system

hex() Converts a number into a hexadecimal value

id() Returns the id of an object

input() Allowing user input

int() Returns an integer number

isinstance() Returns True if a specified object is an instance of a specified object

issubclass() Returns True if a specified class is a subclass of a specified object

iter() Returns an iterator object

len() Returns the length of an object

list() Returns a list

locals() Returns an updated dictionary of the current local symbol table

map() Returns the specified iterator with the specified function applied to each
item

max() Returns the largest item in an iterable

memoryview() Returns a memory view object

min() Returns the smallest item in an iterable

next() Returns the next item in an iterable

object() Returns a new object

oct() Converts a number into an octal

open() Opens a file and returns a file object

ord() Convert an integer representing the Unicode of the specified character

pow() Returns the value of x to the power of y

print() Prints to the standard output device

property() Gets, sets, deletes a property

range() Returns a sequence of numbers, starting from 0 and increments by 1 (by

default)

repr() Returns a readable version of an object

reversed() Returns a reversed iterator

round() Rounds a numbers

set() Returns a new set object

setattr() Sets an attribute (property/method) of an object

slice() Returns a slice object

 sorted() Returns a sorted list

staticmethod() Converts a method into a static method

str() Returns a string object

sum() Sums the items of an iterator

super() Returns an object that represents the parent class

tuple() Returns a tuple

type() Returns the type of an object

vars() Returns the __dict__ property of an object

zip() Returns an iterator, from two or more iterators

Python Numbers
There are three numeric types in Python:

 int
 float
 complex

Variables of numeric types are created when you assign a value to them:

x = 1 # int
y = 2.8 # float
z = 1j # complex
Int
Int, or integer, is a whole number, positive or negative, without decimals, of unlimited length.

Integers:

x = 1
y = 35656222554887711
z = -3255522

Float
Float, or "floating point number" is a number, positive or negative, containing one or more
decimals.

Floats:

x = 1.10
y = 1.0
z = -35.59

Float can also be scientific numbers with an "e" to indicate the power of 10.

Floats:

x = 35e3
y = 12E4
z = -87.7e100

Complex
Complex numbers are written with a "j" as the imaginary part:

Complex:

x = 3+5j
y = 5j
z = -5j

Sequence Type

String
The sequence of characters in the quotation marks can be used to describe the string. A string can be
defined in Python using single, double, or triple quotes.

String dealing with Python is a direct undertaking since Python gives worked-in capabilities and
administrators to perform tasks in the string.
When dealing with strings, the operation "hello"+" python" returns "hello python," and the operator + is
used to combine two strings.

Because the operation "Python" *2 returns "Python," the operator * is referred to as a repetition operator.

The Python string is demonstrated in the following example.

List
Lists in Python are like arrays in C, but lists can contain data of different types. The things put away in the
rundown are isolated with a comma (,) and encased inside square sections [].

To gain access to the list's data, we can use slice [:] operators. Like how they worked with strings, the list
is handled by the concatenation operator (+) and the repetition operator (*).

Tuple
In many ways, a tuple is like a list. Tuples, like lists, also contain a collection of items from various data
types. A parenthetical space () separates the tuple's components from one another.

Because we cannot alter the size or value of the items in a tuple, it is a read-only data structure.

Let's look at a straightforward tuple in action.

String Operators

Operator Description

+ It is known as concatenation operator used to join the strings given either side of the
operator.

* It is known as repetition operator. It concatenates the multiple copies of the same string.

[] It is known as slice operator. It is used to access the sub-strings of a particular string.

[:] It is known as range slice operator. It is used to access the characters from the specified
range.

in It is known as membership operator. It returns if a particular sub-string is present in the

specified string.

not in It is also a membership operator and does the exact reverse of in. It returns true if a
particular substring is not present in the specified string.

r/R It is used to specify the raw string. Raw strings are used in the cases where we need to
print the actual meaning of escape characters such as "C://python". To define any string
as a raw string, the character r or R is followed by the string.
 % It is used to perform string formatting. It makes use of the format specifiers used in C
programming like %d or %f to map their values in python. We will discuss how formatting
is done in python.

Python String functions

Python provides various in-built functions that are used for string handling. Many String fun

Method Description

capitalize() It capitalizes the first character of the String. This function is

deprecated in python3

casefold() It returns a version of s suitable for case-less comparisons.

center(width ,fillchar) It returns a space padded string with the original string centred
with equal number of left and right spaces.

count(string,begin,end) It counts the number of occurrences of a substring in a String

between begin and end index.

decode(encoding = 'UTF8', errors = Decodes the string using codec registered for encoding.
'strict')

encode() Encode S using the codec registered for encoding. Default

encoding is 'utf-8'.

endswith(suffix It returns a Boolean value if the string terminates with given

,begin=0,end=len(string)) suffix between begin and end.

expandtabs(tabsize = 8) It defines tabs in string to multiple spaces. The default space

value is 8.

find(substring ,beginIndex, It returns the index value of the string where substring is found
endIndex) between begin index and end index.

format(value) It returns a formatted version of S, using the passed value.

index(subsring, beginIndex, It throws an exception if string is not found. It works same as

endIndex) find() method.

isalnum() It returns true if the characters in the string are alphanumeric i.e.,
alphabets or numbers and there is at least 1 character.
Otherwise, it returns false.

isalpha() It returns true if all the characters are alphabets and there is at
least one character, otherwise False.

isdecimal() It returns true if all the characters of the string are decimals.
isdigit() It returns true if all the characters are digits and there is at least
one character, otherwise False.

isidentifier() It returns true if the string is the valid identifier.

islower() It returns true if the characters of a string are in lower case,

otherwise false.

isnumeric() It returns true if the string contains only numeric characters.

isprintable() It returns true if all the characters of s are printable or s is empty,

false otherwise.

isupper() It returns false if characters of a string are in Upper case,

otherwise False.

isspace() It returns true if the characters of a string are white-space,

otherwise false.

istitle() It returns true if the string is titled properly and false otherwise.
A title string is the one in which the first character is upper-case
whereas the other characters are lower-case.

isupper() It returns true if all the characters of the string(if exists) is true
otherwise it returns false.

join(seq) It merges the strings representation of the given sequence.

len(string) It returns the length of a string.

ljust(width[,fillchar]) It returns the space padded strings with the original string left
justified to the given width.

lower() It converts all the characters of a string to Lower case.

lstrip() It removes all leading whitespaces of a string and can also be

used to remove particular character from leading.

partition() It searches for the separator sep in S, and returns the part before
it, the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.

maketrans() It returns a translation table to be used in translate function.

replace(old,new[,count]) It replaces the old sequence of characters with the new

sequence. The max characters are replaced if max is given.

rfind(str,beg=0,end=len(str)) It is similar to find but it traverses the string in backward

direction.

rindex(str,beg=0,end=len(str)) It is same as index but it traverses the string in backward

direction.
 rjust(width,[,fillchar]) Returns a space padded string having original string right
justified to the number of characters specified.

rstrip() It removes all trailing whitespace of a string and can also be used
to remove particular character from trailing.

rsplit(sep=None, maxsplit = -1) It is same as split() but it processes the string from the backward
direction. It returns the list of words in the string. If Separator is
not specified then the string splits according to the white-space.

split(str,num=string.count(str)) Splits the string according to the delimiter str. The string splits
according to the space if the delimiter is not provided. It returns
the list of substring concatenated with the delimiter.

splitlines(num=string.count('\n')) It returns the list of strings at each line with newline removed.

startswith(str,beg=0,end=len(str)) It returns a Boolean value if the string starts with given str
between begin and end.

strip([chars]) It is used to perform lstrip() and rstrip() on the string.

swapcase() It inverts case of all characters in a string.

title() It is used to convert the string into the title-case i.e., The
string meEruT will be converted to Meerut.

translate(table,deletechars = '') It translates the string according to the translation table passed
in the function .

upper() It converts all the characters of a string to Upper Case.

zfill(width) Returns original string leftpadded with zeros to a total of width

characters; intended for numbers, zfill() retains any sign given
(less one zero).

rpartition()

The format() method

The format() method is the most flexible and useful method in formatting strings. The curly braces {} are
used as the placeholder in the string and replaced by the format() method argument. Let's have a look
at the given an example:

1. # Using Curly braces

2. print("{} and {} both are the best friend".format("Devansh","Abhishek"))
3.
4. #Positional Argument
5. print("{1} and {0} best players ".format("Virat","Rohit"))
6.
7. #Keyword Argument
8. print("{a},{b},{c}".format(a = "James", b = "Peter", c = "Ricky"))

Output:

Devansh and Abhishek both are the best friend

Rohit and Virat best players
James,Peter,Ricky

Python String Formatting

Escape Sequence
Let's suppose we need to write the text as - They said, "Hello what's going on?"- the given statement can
be written in single quotes or double quotes but it will raise the SyntaxError as it contains both single
and double-quotes.

Example
Consider the following example to understand the real use of Python operators.

1. str = "They said, "Hello what's going on?""

2. print(str)

Output:

SyntaxError: invalid syntax

We can use the triple quotes to accomplish this problem but Python provides the escape sequence.

The backslash(/) symbol denotes the escape sequence. The backslash can be followed by a special
character and it interpreted differently. The single quotes inside the string must be escaped. We can apply
the same as in the double quotes.

Example -

1. # using triple quotes

2. print('''''They said, "What's there?"''')
3.
4. # escaping single quotes
5. print('They said, "What\'s going on?"')
6.
7. # escaping double quotes
8. print("They said, \"What's going on?\"")

Output:

They said, "What's there?"

They said, "What's going on?"
They said, "What's going on?"

The list of an escape sequence is given below:

Sr. Escape Sequence Description Example

1. \newline It ignores the new line. print("Python1 \

Python2 \
Python3")
Output:
Python1 Python2 Python3

2. \\ Backslash print("\\")
Output:
\

3. \' Single Quotes print('\'')

Output:
'

4. \\'' Double Quotes print("\"")

Output:
"

5. \a ASCII Bell print("\a")

6. \b ASCII Backspace(BS) print("Hello \b World")

Output:
Hello World

7. \f ASCII Formfeed print("Hello \f World!")

Hello World!

8. \n ASCII Linefeed print("Hello \n World!")

Output:
Hello
World!

9. \r ASCII Carriege Return(CR) print("Hello \r World!")

Output:
World!

10. \t ASCII Horizontal Tab print("Hello \t World!")

Output:
Hello World!

11. \v ASCII Vertical Tab print("Hello \v World!")

Output:
Hello
World!
 12. \ooo Character with octal value print("\110\145\154\154\157")
Output:
Hello

13 \xHH Character with hex value. print("\x48\x65\x6c\x6c\x6f")

Output:
Hello

Python Memory Allocation

Memory allocation is an essential part of the memory management for a developer. This process basically
allots free space in the computer's virtual memory, and there are two types of virtual memory works while
executing programs.

o Static Memory Allocation

o Dynamic Memory Allocation

Static Memory Allocation -

Static memory allocation happens at the compile time. For example - In C/C++, we declare a static array
with the fixed sizes. Memory is allocated at the time of compilation. However, we cannot use the memory
again in the further program.

1. static int a=10;

Stack Allocation

The Stack data structure is used to store the static memory. It is only needed inside the particular function
or method call. The function is added in program's call stack whenever we call it. Variable assignment
inside the function is temporarily stored in the function call stack; the function returns the value, and the
call stack moves to the text task. The compiler handles all these processes, so we don't need to worry
about it.

Call stack (stack data structure) holds the program's operational data such as subroutines or function call
in the order they are to be called. These functions are popped up from the stack when we called.

Dynamic Memory Allocation

Unlike static memory allocation, Dynamic memory allocates the memory at the runtime to the program.
For example - In C/C++, there is a predefined size of the integer of float data type but there is no
predefine size of the data types. Memory is allocated to the objects at the run time. We use the Heap for
implement dynamic memory management. We can use the memory throughout the program.

1. int *a;
2. p = new int;
As we know, everything in Python is an object means dynamic memory allocation inspires the Python memory
management. Python memory manager automatically vanishes when the object is no longer in use.
Heap Memory Allocation

Heap data structure is used for dynamic memory which is not related to naming counterparts. It is type
of memory that uses outside the program at the global space. One of the best advantages of heap
memory is to it freed up the memory space if the object is no longer in use or the node is deleted.

In the below example, we define how the function's variable store in the stack and a heap.

Default Python Implementation

Python is an open-source, object-oriented programming language which default implemented in the C
programming language. That's very interesting fact - A language which is most popular written in another
language? But this is not a complete truth, but sort of.

Basically, Python language is written in the English language. However, it is defined in the reference
manual that isn't useful by itself. So, we need an interpreter based code on the rule in the manual.

The benefit of the default implementation, it executes the Python code in the computer and it also
converts our Python code into instruction. So, we can say that Python's default implementation fulfills the
both requirements.

Note - Virtual Machines are not the physical computer, but they are instigated in the software.

The program that we write using Python language first converts into the computer-relatable
instructions bytecode. The virtual machine interprets this bytecode.

Python Garbage Collector

As we have explained earlier, Python removes those objects that are no longer in use or can say that it
frees up the memory space. This process of vanish the unnecessary object's memory space is called the
Garbage Collector. The Python garbage collector initiates its execution with the program and is activated
if the reference count falls to zero.

When we assign the new name or placed it in containers such as a dictionary or tuple, the reference count
increases its value. If we reassign the reference to an object, the reference counts decreases its value if. It
also decreases its value when the object's reference goes out of scope or an object is deleted.

As we know, Python uses the dynamic memory allocation which is managed by the Heap data structure.
Memory Heap holds the objects and other data structures that will be used in the program. Python
memory manager manages the allocation or de-allocation of the heap memory space through the API
functions.

Python Objects in Memory

As we know, everything in Python is object. The object can either be simple (containing numbers, strings,
etc.) or containers (dictionary, lists, or user defined classes). In Python, we don't need to declare the
variables or their types before using them in a program.

Let's understand the following example.

 Example -

1. a= 10
2. print(a)
3. del a
4. print(a)

Output:

10
Traceback (most recent call last):
File "", line 1, in
print(x)
NameError : name 'a' is not defined

As we can see in the above output, we assigned the value to object x and printed it. When we remove
the object x and try to access in further code, there will be an error that claims that the variable x is not
defined.

Hence, Python garbage collector works automatically and the programmers doesn't need to worry about
it, unlike C.

Reference Counting in Python

Reference counting states that how many times other objects reference an object. When a reference of
the object is assigned, the count of object is incremented one. When references of an object are removed
or deleted, the count of object is decremented. The Python memory manager performs the de-allocation
when the reference count becomes zero. Let's make it simple to understand.

Example -

Suppose, there is two or more variable that contains the same value, so the Python virtual machine rather
creating another object of the same value in the private heap. It actually makes the second variable point
to that the originally existing value in the private heap.

This is highly beneficial to preserve the memory, which can be used by another variable.

1. x = 20

When we assign the value to the x. the integer object 10 is created in the Heap memory and its reference
is assigned to x.

1. x = 20
2. y = x
3. if id(x) == id(y):
4. print("The variables x and y are referring to the same object")
 In the above code, we have assigned y = x, which means the y object will refer to the same object because
Python allocated the same object reference to new variable if the object is already exists with the same
value.

Now, see another example.

Example -

1. x = 20
2. y = x
3. x += 1
4. If id(x) == id(y):
5. print("x and y do not refer to the same object")

Output:

x and y do not refer to the same object

The variables x and y are not referring the same object because x is incremented by one, x creates the
new reference object and y still referring to 10.

Transforming the Garbage Collector

The Python Garbage collector has classified the objects using its generation. Python Garbage collector
has the three-generation. When we define the new object in the program, its life cycle is handled by the
garbage collector's first generation. If the object has use in a different program, it will be stimulated up
to the next generation. Every generation has a threshold.

The garbage collector comes into action if the threshold of the number of allocations minus the number
of de-allocation is exceeded.

We can modify the threshold value manually using the GC module. This module provides
the get_threshold() method to check the threshold value of a different generation of the garbage
collector. Let's understand the following example.

Example -
1. Import GC
2. print(GC.get_threshold())

Output:

(700, 10, 10)

In the above output, the threshold value 700 is for the first generation and other values for the second
and third generation.

The threshold value for trigger the garbage collector can be modified using the set_threshold() method.

Examples of Python Applications

1. Web Applications

By taking advantage of Python web frameworks (e.g. Flask and Django), Python can be manipulated in the
backend to build effective server-side web applications.
Although web frameworks are not required to construct a sustainable backbone for a web application, it’s rare
that existing open-source libraries wouldn’t be implemented in conjunction with server-side Python
development to speed up the app deployment process.

However, you should note that Python is not directly compiled and interpreted in the web browser.

Although projects such as pyjs can compile Python to JavaScript, Python developers typically interlace Python
and JavaScript to create both server and client-side applications.
In other words, Python is solely executed on the server-side while JavaScript is downloaded to the client-side of
the web browser and executed accordingly.

Although a mountainous number of Python web frameworks and micro-frameworks exist out there, Django,
Flask, and Pyramid take the cake.

Let’s briefly explore Django and Flask below with consideration for their distinct complexity levels and learning
curves.

Django

Established as an open-source Python framework, Django is notorious for building complex data-driven web
application instances.
The framework is packaged with a variety of templates, libraries, and application programming interfaces (APIs)
that allow for scalable web development projects.

It is the most popular large-scale framework, integrated onto leading websites, including Instagram, Pinterest,
Bitbucket, The Washington Times, and Nextdoor.

Flask

Although Flask is better characterized as a micro-framework for Python-driven web applications, it still leads
as an up and coming leader in concise, yet complex, data-driven web app programming.

As a micro-framework, it possesses built-in development servers and support for convenient unit testing.
Additionally, it is prominent as a Unicode-based Python micro-framework that supports RESTFUL request
dispatching.

Flask also has extensive documentation for programmers to get a head start.

Now you understand how each of these frameworks differs, you can better understand the following example
applications of these frameworks in action.

Since Flask has risen to prominence as a scalable, yet compact and efficient, mini-framework, an array of
machine learning applications have been deployed.

Some stand-out examples include computer vision algorithms that can predict gender and diabetic retinopathy
detection based on eye fundus photographs.

Now see what Django – the more complex of the two frameworks – can do for you.

The modern websites below have used Django, along with Sentry, to scalably deploy large-structured web
and mobile applications:

 Disqus
 Instagram
 Spotify
 Dropbox
 The Washington Post
 Mozilla
 Pinterest
 National Geographic
 The Onion
 National Aeronautics and Space Administration (NASA)

2. Console-Based Applications

Otherwise known as terminal applications, console-based applications are broadly defined as any Python-
associated app that runs inside the terminal.

In the grand scheme of casual Python development, console-based Python deployments have the following
advantages:

 They’re much more fun and fulfilling to write than simple script-based applications.
 Terminal apps enable you and involved users to play with complex code without ambiguous layers of
abstraction between you and the user.

 You’ll learn about fundamental user interaction issues at a primitive level that doesn’t include wishy-

washy UI/UX distractions.

Although console-based applications and command-line interfaces (CLIs) primarily exist to support convenient
user interaction during more complex command-line processes, fun and practical use cases include:

 Command-line Python applications that consume the News API and return up-to-date world and
national events.
 A simple terminal-based chatbot application built with ML/Tensorflow.

3. Data Science Implementations

Data science might be the most salient Python implementation of them all.

By using already-integrated code dependencies, such as Pandas, NumPy, or Matplotlib, amateur and expert-
level Python programmers can seamlessly visualize and manually extract actionable insights from massive public
and private datasets – both off and on the cloud.
At a high level, developers can even synthesize data science manipulations with ML models to extract, visualize,
and predict features from unstructured data (e.g. imaging data, time-series stock market data, or house price
predictions).

What’s more, open-source Github repositories are filled to the brim with business-level Python applications such
as NLP-driven sentiment and toxic comment classification or future sales predictions.

Additionally, data science communities such as Kaggle provide that extra bit of inspiration for you to get started
on novel data science solutions to big corporate problems.
4. Desktop GUI Applications

Admittedly, Python isn’t fully optimized for deploying business-grade desktop GUIapplications, at least not
when you compare it to C and Java libraries.

However, developers can get started with official Python documentation and implement toolkits/frameworks
such as PyQT, Tkinter, Kivy, WxPython, and PyGUI to create lightweight user interfaces with full software
functionality in mind.
For example, this Github repository boasts 15 distinct PyQT-driven projects that use Python-driven UI and
backend components to create responsive and functional Python applications.
A preview of these applications include:

 Untabbed Web Browser

 Tabbed Web Browser
 Minesweeper
 Notepad
 Calculator
 Word Processor
 Webcam/Snapshot
 Media Player
 Post-it Note
 Paint Software
 Unzip
 Translator
 Weather
 Currency converter GUI
 And Solitaire

5. Software Development

As Python rises to new and unforeseen popularity, product/project development pipelines have gradually
adapted to Python’s set of frameworks and best practices.

Although software development with Python covers the technical trails of ML/Deep Learning, scripting, and
web/OS-level application development, Python’s most advantageous contribution to software development is
its ability to accommodate project ideation and development and advance applications from insecure to robust.

With Python, rising software developers can effectively fulfill the following development-focused goals:

 Advancing Python applications from conception through full-stack execution and app deployment by

integrating Python frameworks and development tools.

 Contributing to private and open-source Python applications by regulating version-controlled workflows

and collaboration with your development team.

 Understanding interactions between raw code and the client-side facet of your web apps/Python

applications
 Writing secure apps that blockade and deter cybercriminals from exploiting common open patches and
vulnerabilities.
 Adopting best practices in code review and portfolio development with your Python applications

6. Business Applications

With modern business applications covering the spectrum of e-commerce, ERP, and much more, having a
scalable and open-source language is crucial.

Python allows businesses to develop scalable and fully functional applications right out of the box.

Platforms such as Tryton can be used by business analysts to develop and deploy Python applications.

The umbrella of business development in Python can encompass many tools including:

 Web development (e.g. Instagram)

 Data science solutions (e.g. Spotify w/ their Discovery Playlists)
 ML frameworks (e.g. Uber’s driver-rider algorithms)
 Natural Language Processing (NLP) (e.g. Google Home Assistant, Amazon Alexa, and chatbots for
customer service).
 Video game development (e.g. Sims 4)
 Entertainment (e.g. Light and Magic studio)
 Blockchain-enabled contracts (e.g. Pyethereum)
 Fintech platforms (e. g. Citigroup and JP Morgan Chase)

7. Image Processing

Python is a useful tool for image manipulation and analysis. With its open-source dependencies, which can
oftentimes be installed on your command line, you can extract and manipulate features with a mere 8-10 lines
of code.

Whether it’s research, education, or industry-level applications, these following Python libraries provide you
with convenient image analysis tools.

 Scikit-image
 NumPy
 Scipy
 PIL/Pillow
 OpenCV-Python
 SimpleCV
 Mahotas
 SimpleTK
 Pgmagick
 Pycario

8. Game Development

In addition to research and business applications, Python has a critical role in backend game development with
logic and mods.

Perhaps the most memorable Python applications in game development include the following:

 Civilization IV
 Battlefield 2
 Sims 4
 Toontown Online
 World of Tanks
 EVE Online
 Frets on Fire

Additionally, by using open-source game development libraries such as pygame, programmers can build simple
games such as a Dungeon Game and Guessing Game.
9. Web Scraping Applications

By using prebuilt Python libraries such as Beautiful Soup, developers with minimal hands-on Python experience
can extract specific, purposeful data from virtually any webpage.
At a higher level, Python web scraping libraries can be combined with NLP models to effectively scrape the
surface web for textual and visual information associated with specific words, intentions, or emotions.

Examples include:

 Extracting table from Nepia.com’s shipping impact page

 Scraping dates and times that governmental safety orders were imposed
 Scraping information about trending Github repositories, such as name, stars, links, etc.

10. Machine Learning and Artificial Intelligence

In nearly every corporate and research-focused department, massive machine learning/deep learning models
and architectures are beginning to be used to solve big data problems.

Whether it’s an ML algorithm that can generate new cancer drugs or a model that detects dangerous highway
activity for an autonomous car, ML is bound to revolutionize every industry sector.

In short, machine learning can be divided into visual and non-visual tasks that are supervised, semi-supervised,
or unsupervised. Examples of business and research-level ML python applications include:

 Classifying toxic and insincere questions on Quora with NLP

 Retrieving Google landmarks images with computer vision
 Generating images and transferring image styles

ML frameworks such as Tensorflow/Keras/Pytorch can be used to develop and deploy predictive and generative
models.