The for loop in Python provides the ability to loop over the items of any sequence, such as a list, tuple or a string. It performs the same action on each item of the sequence. This loop starts with the for keyword, followed by a variable that represents the current item in the sequence. The in keyword links the variable to the sequence you want to iterate over. A colon (:) is used at the end of the loop header, and the indented block of code beneath it is executed once for each item in the sequence.
Syntax of Python for Loop
for iterating_var in sequence:
statement(s)
Here, the iterating_var is a variable to which the value of each sequence item will be assigned during each iteration. Statements represents the block of code that you want to execute repeatedly.
Before the loop starts, the sequence is evaluated. If it’s a list, the expression list (if any) is evaluated first. Then, the first item (at index 0) in the sequence is assigned to iterating_var variable.
During each iteration, the block of statements is executed with the current value of iterating_var. After that, the next item in the sequence is assigned to iterating_var, and the loop continues until the entire sequence is exhausted.
Flowchart of Python for Loop
The following flow diagram illustrates the working of for loop −
Python for Loop with Strings
A string is a sequence of Unicode letters, each having a positional index. Since, it is a sequence, you can iterate over its characters using the for loop.
Example
The following example compares each character and displays if it is not a vowel (‘a’, ‘e’, ‘i’, ‘o’, ‘u’).
zen ='''
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
'''for char in zen:if char notin'aeiou':print(char, end='')
On executing, this code will produce the following output −
Btfl s bttr thn gly.
Explct s bttr thn mplct.
Smpl s bttr thn cmplx.
Cmplx s bttr thn cmplctd.
Python for Loop with Tuples
Python’s tuple object is also an indexed sequence, and hence you can traverse its items with a for loop.
Example
In the following example, the for loop traverses a tuple containing integers and returns the total of all numbers.
numbers =(34,54,67,21,78,97,45,44,80,19)
total =0for num in numbers:
total += num
print("Total =", total)
On running this code, it will produce the following output −
Total = 539
Python for Loop with Lists
Python’s list object is also an indexed sequence, and hence you can iterate over its items using a for loop.
Example
In the following example, the for loop traverses a list containing integers and prints only those which are divisible by 2.
numbers =[34,54,67,21,78,97,45,44,80,19]
total =0for num in numbers:if num%2==0:print(num)
When you execute this code, it will show the following result −
34
54
78
44
80
Python for Loop with Range Objects
Python’s built-in range() function returns an iterator object that streams a sequence of numbers. This object contains integers from start to stop, separated by step parameter. You can run a for loop with range as well.
Syntax
The range() function has the following syntax −
range(start, stop, step)
Where,
Start − Starting value of the range. Optional. Default is 0
Stop − The range goes upto stop-1
Step − Integers in the range increment by the step value. Option, default is 1.
Example
In this example, we will see the use of range with for loop.
for num inrange(5):print(num, end=' ')print()for num inrange(10,20):print(num, end=' ')print()for num inrange(1,10,2):print(num, end=' ')
When you run the above code, it will produce the following output −
0 1 2 3 4
10 11 12 13 14 15 16 17 18 19
1 3 5 7 9
Python for Loop with Dictionaries
Unlike a list, tuple or a string, dictionary data type in Python is not a sequence, as the items do not have a positional index. However, traversing a dictionary is still possible with the for loop.
Example
Running a simple for loop over the dictionary object traverses the keys used in it.
numbers ={10:"Ten",20:"Twenty",30:"Thirty",40:"Forty"}for x in numbers:print(x)
On executing, this code will produce the following output −
10
20
30
40
Once we are able to get the key, its associated value can be easily accessed either by using square brackets operator or with the get() method.
Example
The following example illustrates the above mentioned approach.
numbers ={10:"Ten",20:"Twenty",30:"Thirty",40:"Forty"}for x in numbers:print(x,":",numbers[x])
It will produce the following output −
10 : Ten
20 : Twenty
30 : Thirty
40 : Forty
The items(), keys() and values() methods of dict class return the view objects dict_items, dict_keys and dict_values respectively. These objects are iterators, and hence we can run a for loop over them.
Example
The dict_items object is a list of key-value tuples over which a for loop can be run as follows −
numbers ={10:"Ten",20:"Twenty",30:"Thirty",40:"Forty"}for x in numbers.items():print(x)
Python supports to have an else statement associated with a loop statement. However, the else statement is executed when the loop has exhausted iterating the list.
Example
The following example illustrates the combination of an else statement with a for statement that searches for prime numbers from 10 to 20.
#For loop to iterate between 10 to 20for num inrange(10,20):#For loop to iterate on the factors for i inrange(2,num):#If statement to determine the first factorif num%i ==0:#To calculate the second factor
j=num/i
print("%d equals %d * %d"%(num,i,j))#To move to the next numberbreakelse:print(num,"is a prime number")break</pre>
When the above code is executed, it produces the following result −
10 equals 2 * 5
11 is a prime number
12 equals 2 * 6
13 is a prime number
14 equals 2 * 7
15 equals 3 * 5
16 equals 2 * 8
17 is a prime number
18 equals 2 * 9
19 is a prime number
Python loops allow us to execute a statement or group of statements multiple times.
In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. There may be a situation when you need to execute a block of code several number of times.
Programming languages provide various control structures that allow for more complicated execution paths.
Flowchart of a Loop
The following diagram illustrates a loop statement −
Types of Loops in Python
Python programming language provides following types of loops to handle looping requirements −
Sr.No.
Loop Type & Description
1
while loopRepeats a statement or group of statements while a given condition is TRUE. It tests the condition before executing the loop body.
2
for loopExecutes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
3
nested loopsYou can use one or more loop inside any another while, for or do..while loop.
Python Loop Control Statements
Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.
Python supports the following control statements. Click the following links to check their detail.
Let us go through the loop control statements briefly
Sr.No.
Control Statement & Description
1
break statementTerminates the loop statement and transfers execution to the statement immediately following the loop.
2
continue statementCauses the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3
pass statementThe pass statement in Python is used when a statement is required syntactically but you do not want any command or code to execute.
A Python match-case statement takes an expression and compares its value to successive patterns given as one or more case blocks. Only the first pattern that matches gets executed. It is also possible to extract components (sequence elements or object attributes) from the value into variables.
With the release of Python 3.10, a pattern matching technique called match-case has been introduced, which is similar to the switch-case construct available in C/C++/Java etc. Its basic use is to compare a variable against one or more values. It is more similar to pattern matching in languages like Rust or Haskell than a switch statement in C or C++.
Syntax
The following is the syntax of match-case statement in Python –
match variable_name:
case 'pattern 1': statement 1
case 'pattern 2': statement 2...
case 'pattern n': statement n
Example
The following code has a function named weekday(). It receives an integer argument, matches it with all possible weekday number values, and returns the corresponding name of day.
defweekday(n):
match n:
case 0:return"Monday"
case 1:return"Tuesday"
case 2:return"Wednesday"
case 3:return"Thursday"
case 4:return"Friday"
case 5:return"Saturday"
case 6:return"Sunday"
case _:return"Invalid day number"print(weekday(3))print(weekday(6))print(weekday(7))</pre>
On executing, this code will produce the following output −
Thursday
Sunday
Invalid day number
The last case statement in the function has "_" as the value to compare. It serves as the wildcard case, and will be executed if all other cases are not true.
Combined Cases in Match Statement
Sometimes, there may be a situation where for more than one cases, a similar action has to be taken. For this, you can combine cases with the OR operator represented by "|" symbol.
Example
The code below shows how to combine cases in match statement. It defines a function named access() and has one string argument, representing the name of the user. For admin or manager user, the system grants full access; for Guest, the access is limited; and for the rest, there's no access.
defaccess(user):
match user:
case "admin"|"manager":return"Full access"
case "Guest":return"Limited access"
case _:return"No access"print(access("manager"))print(access("Guest"))print(access("Ravi"))</pre>
On running the above code, it will show the following result −
Full access
Limited access
No access
List as the Argument in Match Case Statement
Since Python can match the expression against any literal, you can use a list as a case value. Moreover, for variable number of items in the list, they can be parsed to a sequence with "*" operator.
Example
In this code, we use list as argument in match case statement.
defgreeting(details):
match details:
case [time, name]:returnf'Good {time} {name}!'
case [time,*names]:
msg=''for name in names:
msg+=f'Good {time} {name}!\n'return msg
On executing, this code will produce the following output −
Good Morning Ravi!
Good Afternoon Guest!
Good Evening Kajal!
Good Evening Praveen!
Good Evening Lata!
Using "if" in "Case" Clause
Normally Python matches an expression against literal cases. However, it allows you to include if statement in the case clause for conditional computation of match variable.
Example
In the following example, the function argument is a list of amount and duration, and the intereset is to be calculated for amount less than or more than 10000. The condition is included in the case clause.
defintr(details):
match details:
case [amt, duration]if amt<10000:return amt*10*duration/100
case [amt, duration]if amt>=10000:return amt*15*duration/100print("Interest = ", intr([5000,5]))print("Interest = ", intr([15000,3]))</pre>
On executing, this code will produce the following output −
Python supports nested if statements which means we can use a conditional if and if…else statement inside an existing if statement.
There may be a situation when you want to check for additional conditions after the initial one resolves to true. In such a situation, you can use the nested if construct.
Additionally, within a nested if construct, you can include an if…elif…else construct inside another if…elif…else construct.
Syntax of Nested if Statement
The syntax of the nested if construct with else condition will be like this −
if boolean_expression1: statement(s)if boolean_expression2: statement(s) Flowchart of Nested if Statement Following is the flowchart of Python nested if statement −
nested if statement flowchart Example of Nested if Statement The below example shows the working of nested if statements −
num = 36 print ("num = ", num) if num % 2 == 0: if num % 3 == 0: print ("Divisible by 3 and 2") print("....execution ends....") When you run the above code, it will display the following result −
num = 36 Divisible by 3 and 2 ....execution ends.... Nested if Statement with else Condition As mentioned earlier, we can nest if-else statement within an if statement. If the if condition is true, the first if-else statement will be executed otherwise, statements inside the else block will be executed.
Syntax The syntax of the nested if construct with else condition will be like this −
if expression1: statement(s) if expression2: statement(s) else statement(s) else: if expression3: statement(s) else: statement(s) Example Now let's take a Python code to understand how it works −
num=8 print ("num = ",num) if num%2==0: if num%3==0: print ("Divisible by 3 and 2") else: print ("divisible by 2 not divisible by 3") else: if num%3==0: print ("divisible by 3 not divisible by 2") else: print ("not Divisible by 2 not divisible by 3") When the above code is executed, it produces the following output −
num = 8 divisible by 2 not divisible by 3 num = 15 divisible by 3 not divisible by 2 num = 12 Divisible by 3 and 2 num = 5 not Divisible by 2 not divisible by 3
The if-else statement in Python is used to execute a block of code when the condition in the if statement is true, and another block of code when the condition is false.
Syntax of if-else Statement
The syntax of an if-else statement in Python is as follows −
if boolean_expression:# code block to be executed# when boolean_expression is trueelse:# code block to be executed# when boolean_expression is false
If the boolean expression evaluates to TRUE, then the statement(s) inside the if block will be executed otherwise statements of the else block will be executed.
Flowchart of if-else Statement
This flowchart shows how if-else statement is used −
If the expr is True, block of stmt1, 2, 3 is executed then the default flow continues with stmt7. However, if the expr is False, block stmt4, 5, 6 runs then the default flow continues.
Python implementation of the above flowchart is as follows −
if expr==True:
stmt1
stmt2
stmt3
else:
stmt4
stmt5
stmt6
Stmt7
Python if-else Statement Example
Let us understand the use of if-else statements with the following example. Here, variable age can take different values. If the expression age > 18 is true, then eligible to vote message will be displayed otherwise not eligible to vote message will be displayed. Following flowchart illustrates this logic −
Now, let’s see the Python implementation the above flowchart.
age=25print("age: ", age)if age >=18:print("eligible to vote")else:print("not eligible to vote")
On executing this code, you will get the following output −
age: 25
eligible to vote
To test the else block, change the age to 12, and run the code again.
age: 12 not eligible to vote Python if elif else Statement The if elif else statement allows you to check multiple expressions for TRUE and execute a block of code as soon as one of the conditions evaluates to TRUE.
Similar to the else block, the elif block is also optional. However, a program can contains only one else block whereas there can be an arbitrary number of elif blocks following an if block.
Syntax of Python if elif else Statement if expression1: statement(s) elif expression2: statement(s) elif expression3: statement(s) else: statement(s) How if elif else Works? The keyword elif is a short form of else if. It allows the logic to be arranged in a cascade of elif statements after the first if statement. If the first if statement evaluates to false, subsequent elif statements are evaluated one by one and comes out of the cascade if any one is satisfied.
Last in the cascade is the else block which will come in picture when all preceding if/elif conditions fails.
Example Suppose there are different slabs of discount on a purchase −
20% on amount exceeding 10000,
10% for amount between 5-10000,
5% if it is between 1 to 5000.
no discount if amount<1000
The following flowchart illustrates these conditions −
if-elif We can write a Python code for the above logic with if-else statements −
print('Payable amount = ',amount - discount) Set amount to test all possible conditions: 800, 2500, 7500 and 15000. The outputs will vary accordingly −
Amount: 800 Payable amount = 800 Amount: 2500 Payable amount = 2375.0 Amount: 7500 Payable amount = 6750.0 Amount: 15000 Payable amount = 12000.0 While the code will work perfectly fine, if you look at the increasing level of indentation at each if and else statement, it will become difficult to manage if there are still more conditions.
Python if elif else Statement Example The elif statement makes the code easy to read and comprehend. Following is the Python code for the same logic with if elif else statements −
The if statement in Python evaluates whether a condition is true or false. It contains a logical expression that compares data, and a decision is made based on the result of the comparison.
Syntax of the if Statement
if expression:
# statement(s) to be executed
If the boolean expression evaluates to TRUE, then the statement(s) inside the if block is executed. If boolean expression evaluates to FALSE, then the first set of code after the end of the if block is executed.
Flow Diagram (Flowchart) of the if Statement
The below diagram shows flowchart of the if statement −
Example of Python if Statement
Let us consider an example of a customer entitled to 10% discount if his purchase amount is > 1000; if not, then no discount is applicable. The following flowchart shows the whole decision making process −
First, set a discount variable to 0 and an amount variable to 1200. Then, use an if statement to check whether the amount is greater than 1000. If this condition is true, calculate the discount amount. If a discount is applicable, deduct it from the original amount.
Python code for the above flowchart can be written as follows −
Python’s decision making functionality is in its keywords − if..elif…else. The if keyword requires a boolean expression, followed by colon (:) symbol. The colon (:) symbol starts an indented block. The statements with the same level of indentation are executed if the boolean expression in if statement is True. If the expression is not True (False), the interpreter bypasses the indented block and proceeds to execute statements at earlier indentation level.
Decision structures evaluate multiple expressions which produce TRUE or FALSE as outcome. You need to determine which action to take and which statements to execute if outcome is TRUE or FALSE otherwise.
Following is the general form of a typical decision making structure found in most of the programming languages −
Python programming language assumes any non-zero and non-null values as TRUE, and if it is either zero or null, then it is assumed as FALSE value.
Types of Decision Making Statements in Python
Python programming language provides following types of decision making statements. Click the following links to check their detail.
Sr.No.
Statement & Description
1
if statementsAn if statement consists of a boolean expression followed by one or more statements.
2
if…else statementsAn if statement can be followed by an optional else statement, which executes when the boolean expression is FALSE.
3
nested if statementsYou can use one if or else if statement inside another if or else if statement(s).
Let us go through each decision making briefly −
Single Statement Suites
If the suite of an if clause consists only of a single line, it may go on the same line as the header statement.
Example
Here is an example of a one-line if clause −
var =100if( var ==100):print("Value of expression is 100")print("Good bye!")
When the above code is executed, it produces the following result −
Value of expression is 100
Good bye!
if…else statement
In this decision making statement, if the if condition is true, then the statements within this block are executed, otherwise, the else block is executed.
The program will choose which block of code to execute based on whether the condition in the if statement is true or false.
Example
The following example shows the use of if…else statement.
var =100if( var ==100):print("Value of var is equal to 100")else:print("Value of var is not equal to 100")
On running the above code, it will show the following output −
Value of var is equal to 100
Nested if statements
A nested if is another decision making statement in which one if statement resides inside another. It allows us to check multiple conditions sequentially.
Example
In this example, we will see the use of nested-if statement.
var =100if( var ==100):print("The number is equal to 100")if var %2==0:print("The number is even")else:print("The given number is odd")elif var ==0:print("The given number is zero")else:print("The given number is negative")
On executing the above code, it will display the below output −
Python program control flow is regulated by various types of conditional statements, loops, and function calls. By default, the instructions in a computer program are executed in a sequential manner, from top to bottom, or from start to end. However, such sequentially executing programs can perform only simplistic tasks. We would like the program to have a decision-making ability, so that it performs different steps depending on different conditions.
Most programming languages including Python provide functionality to control the flow of execution of instructions. Normally, there are two type of control flow statements in any programming language and Python also supports them.
Decision Making Statements
Decision making statements are used in the Python programs to make them able to decide which of the alternative group of instructions to be executed, depending on value of a certain Boolean expression.
The following diagram illustrates how decision-making statements work −
The if Statements
Python provides if..elif..else control statements as a part of decision marking. It consists of three different blocks, which are if block, elif (short of else if) block and else block.
Example
Following is a simple example which makes use of if..elif..else. You can try to run this program using different marks and verify the result.
marks =80
result =""if marks <30:
result ="Failed"elif marks >75:
result ="Passed with distinction"else:
result ="Passed"print(result)
This will produce following result:
Passed with distinction
The match Statement
Python supports Match-Case statement, which can also be used as a part of decision making. If a pattern matches the expression, the code under that case will execute.
Example
Following is a simple example which makes use of match statement.
defcheckVowel(n):
match n:
case 'a':return"Vowel alphabet"
case 'e':return"Vowel alphabet"
case 'i':return"Vowel alphabet"
case 'o':return"Vowel alphabet"
case 'u':return"Vowel alphabet"
case _:return"Simple alphabet"print(checkVowel('a'))print(checkVowel('m'))print(checkVowel('o'))</pre>
This will produce following result:
Vowel alphabet Simple alphabet Vowel alphabet Loops or Iteration Statements Most of the processes require a group of instructions to be repeatedly executed. In programming terminology, it is called a loop. Instead of the next step, if the flow is redirected towards any earlier step, it constitutes a loop.
The following diagram illustrates how the looping works −
looping_works If the control goes back unconditionally, it forms an infinite loop which is not desired as the rest of the code would never get executed.
In a conditional loop, the repeated iteration of block of statements goes on till a certain condition is met. Python supports a number of loops like for loop, while loop which we will study in next chapters.
The for Loop The for loop iterates over the items of any sequence, such as a list, tuple or a string .
Example Following is an example which makes use of For Loop to iterate through an array in Python:
words = ["one", "two", "three"] for x in words: print(x) This will produce following result:
one two three The while Loop The while loop repeatedly executes a target statement as long as a given boolean expression is true.
Example Following is an example which makes use of While Loop to print first 5 numbers in Python:
i = 1 while i < 6: print(i) i += 1 This will produce following result:
1 2 3 4 5 Jump Statements The jump statements are used to jump on a specific statement by breaking the current flow of the program. In Python, there are two jump statements break and continue.
The break Statement It terminates the current loop and resumes execution at the next statement.
Example The following example demonstrates the use of break statement −
x = 0
while x < 10: print("x:", x) if x == 5: print("Breaking...") break x += 1
print("End") This will produce following result:
x: 0 x: 1 x: 2 x: 3 x: 4 x: 5 Breaking... End It skips the execution of the program block and returns the control to the beginning of the current loop to start the next iteration. Example The following example demonstrates the use of continue statement −
Open Compiler for letter in "Python": # continue when letter is 'h' if letter == "h": continue print("Current Letter :", letter)
This will produce following result:
Current Letter : P Current Letter : y Current Letter : t Current Letter : o Current Letter : n
A bool object is accepted as argument to type conversion functions. With True as argument, the int() function returns 1, float() returns 1.0; whereas for False, they return 0 and 0.0 respectively. We have a one argument version of complex() function.
If the argument is a complex object, it is taken as real part, setting the imaginary coefficient to 0.
Example
a=int(True)print("bool to int:", a)
a=float(False)print("bool to float:", a)
a=complex(True)print("bool to complex:", a)
On running this code, you will get the following output −
bool to int: 1 bool to float: 0.0 bool to complex: (1+0j)
Python Boolean Expression Python boolean expression is an expression that evaluates to a Boolean value. It almost always involves a comparison operator. In the below example we will see how the comparison operators can give us the Boolean values. The bool() method is used to return the truth value of an expresison.
Syntax: bool([x]) Returns True if X evaluates to true else false. Without parameters it returns false. Below we have examples which use numbers streams and Boolean values as parameters to the bool function. The results come out as true or false depending on the parameter.
Example # Check true a = True print(bool(a)) # Check false a = False print(bool(a)) # Check 0 a = 0.0 print(bool(a)) # Check 1 a = 1.0 print(bool(a)) # Check Equality a = 5 b = 10 print(bool( a==b)) # Check None a = None print(bool(a)) # Check an empty sequence a = () print(bool(a)) # Check an emtpty mapping a = {} print(bool(a)) # Check a non empty string a = 'Tutorialspoint' print(bool(a))
Python has built-in support to store and process numeric data (Python Numbers). Most of the times you work with numbers in almost every Python application. Obviously, any computer application deals with numbers. This tutorial will discuss about different types of Python Numbers and their properties.
Python – Number Types
There are three built-in number types available in Python:
integers (int)
floating point numbers (float)
complex numbers
Python also has a bult-in Boolean data type called bool. It can be treated as a sub-type of int type, since it’s two possible values True and False represent the integers 1 and 0 respectively.
Python − Integer Numbers
In Python, any number without the provision to store a fractional part is an integer. (Note that if the fractional part in a number is 0, it doesn’t mean that it is an integer. For example a number 10.0 is not an integer, it is a float with 0 fractional part whose numeric value is 10.) An integer can be zero, positive or a negative whole number. For example, 1234, 0, -55 all represent to integers in Python.
There are three ways to form an integer object. With (a) literal representation, (b) any expression evaluating to an integer, and (c) using int() function.
Literal is a notation used to represent a constant directly in the source code. For example −
>>> a =10
However, look at the following assignment of the integer variable c.
a =10
b =20
c = a + b
print("a:", a,"type:",type(a))print("c:", c,"type:",type(c))
Here, c is indeed an integer variable, but the expression a + b is evaluated first, and its value is indirectly assigned to c.
The third method of forming an integer object is with the return value of int() function. It converts a floating point number or a string in an integer.
>>> a=int(10.5)>>> b=int("100")
You can represent an integer as a binary, octal or Hexa-decimal number. However, internally the object is stored as an integer.
Binary Numbers in Python
A number consisting of only the binary digits (1 and 0) and prefixed with “0b” is a binary number. If you assign a binary number to a variable, it still is an int variable.
A represent an integer in binary form, store it directly as a literal, or use int() function, in which the base is set to 2
An octal number is made up of digits 0 to 7 only. In order to specify that the integer uses octal notation, it needs to be prefixed by “0o” (lowercase O) or “0O” (uppercase O). A literal representation of octal number is as follows −
a=0O107print(a,type(a))
It will produce the following output −
71 <class 'int'>
Note that the object is internally stored as integer. Decimal equivalent of octal number 107 is 71.
Since octal number system has 8 symbols (0 to 7), its base is 7. Hence, while using int() function to covert an octal string to integer, you need to set the base argument to 8.
a=int('20',8)print(a,type(a))
It will produce the following output −
16 <class 'int'>
Decimal equivalent of octal 30 is 16.
In the following code, two int objects are obtained from octal notations and their addition is performed.
a=0O56print("a:",a,"type:",type(a))
b=int("0O31",8)print("b:",b,"type:",type(b))
c=a+b
print("addition:", c)
To obtain the octal string for an integer, use oct() function.
a=oct(71)print(a,type(a))
Hexa-decimal Numbers in Python
As the name suggests, there are 16 symbols in the Hexadecimal number system. They are 0-9 and A to F. The first 10 digits are same as decimal digits. The alphabets A, B, C, D, E and F are equivalents of 11, 12, 13, 14, 15, and 16 respectively. Upper or lower cases may be used for these letter symbols.
For the literal representation of an integer in Hexadecimal notation, prefix it by “0x” or “0X”.
a=0XA2print(a,type(a))
It will produce the following output −
162 <class 'int'>
To convert a Hexadecimal string to integer, set the base to 16 in the int() function.
a=int('0X1e',16)print(a,type(a))
Try out the following code snippet. It takes a Hexadecimal string, and returns the integer.
num_string ="A1"
number =int(num_string,16)print("Hexadecimal:", num_string,"Integer:",number)
It will produce the following output −
Hexadecimal: A1 Integer: 161
However, if the string contains any symbol apart from the Hexadecimal symbol chart an error will be generated.
num_string ="A1X001"print(int(num_string,16))
The above program generates the following error −
Traceback (most recent call last):
File "/home/main.py", line 2, in
print (int(num_string, 16))
ValueError: invalid literal for int() with base 16: 'A1X001'
Python’s standard library has hex() function, with which you can obtain a hexadecimal equivalent of an integer.
Open Compiler
a=hex(161)print(a,type(a))
It will produce the following output −
0xa1 <class 'str'>
Though an integer can be represented as binary or octal or hexadecimal, internally it is still integer. So, when performing arithmetic operation, the representation doesn’t matter.
A floating point number has an integer part and a fractional part, separated by a decimal point symbol (.). By default, the number is positive, prefix a dash (-) symbol for a negative number.
A floating point number is an object of Python’s float class. To store a float object, you may use a literal notation, use the value of an arithmetic expression, or use the return value of float() function.
Using literal is the most direct way. Just assign a number with fractional part to a variable. Each of the following statements declares a float object.
>>> a=9.99>>> b=0.999>>> c=-9.99>>> d=-0.999
In Python, there is no restriction on how many digits after the decimal point can a floating point number have. However, to shorten the representation, the E or e symbol is used. E stands for Ten raised to. For example, E4 is 10 raised to 4 (or 4th power of 10), e-3 is 10 raised to -3.
In scientific notation, number has a coefficient and exponent part. The coefficient should be a float greater than or equal to 1 but less than 10. Hence, 1.23E+3, 9.9E-5, and 1E10 are the examples of floats with scientific notation.
>>> a=1E10>>> a
10000000000.0>>> b=9.90E-5>>> b
9.9e-05>>>1.23E31230.0
The second approach of forming a float object is indirect, using the result of an expression. Here, the quotient of two floats is assigned to a variable, which refers to a float object.
Python’s float() function returns a float object, parsing a number or a string if it has the appropriate contents. If no arguments are given in the parenthesis, it returns 0.0, and for an int argument, fractional part with 0 is added.
>>> a=float()>>> a
0.0>>> a=float(10)>>> a
10.0
Even if the integer is expressed in binary, octal or hexadecimal, the float() function returns a float with fractional part as 0.
The float() function retrieves a floating point number out of a string that encloses a float, either in standard decimal point format, or having scientific notation.
In mathematics, infinity is an abstract concept. Physically, infinitely large number can never be stored in any amount of memory. For most of the computer hardware configurations, however, a very large number with 400th power of 10 is represented by Inf. If you use “Infinity” as argument for float() function, it returns Inf.
One more such entity is Nan (stands for Not a Number). It represents any value that is undefined or not representable.
>>> a=float('Nan')>>> a
Nan
Python − Complex Numbers
In this section, we shall know in detail about Complex data type in Python. Complex numbers find their applications in mathematical equations and laws in electromagnetism, electronics, optics, and quantum theory. Fourier transforms use complex numbers. They are Used in calculations with wavefunctions, designing filters, signal integrity in digital electronics, radio astronomy, etc.
A complex number consists of a real part and an imaginary part, separated by either “+” or “−”. The real part can be any floating point (or itself a complex number) number. The imaginary part is also a float/complex, but multiplied by an imaginary number.
In mathematics, an imaginary number “i” is defined as the square root of -1 (\sqrt{−1}). Therefore, a complex number is represented as “x+yi”, where x is the real part, and “y” is the coefficient of imaginary part.
Quite often, the symbol “j” is used instead of “I” for the imaginary number, to avoid confusion with its usage as current in theory of electricity. Python also uses “j” as the imaginary number. Hence, “x+yj” is the representation of complex number in Python.
Like int or float data type, a complex object can be formed with literal representation or using complex() function. All the following statements form a complex object.
>>> a=5+6j>>> a
(5+6j)>>>type(a)<class'complex'>>>> a=2.25-1.2J>>> a
(2.25-1.2j)>>>type(a)<class'complex'>>>> a=1.01E-2+2.2e3j>>> a
(0.0101+2200j)>>>type(a)<class'complex'>
Note that the real part as well as the coefficient of imaginary part have to be floats, and they may be expressed in standard decimal point notation or scientific notation.
Python’s complex() function helps in forming an object of complex type. The function receives arguments for real and imaginary part, and returns the complex number.
There are two versions of complex() function, with two arguments and with one argument. Use of complex() with two arguments is straightforward. It uses first argument as real part and second as coefficient of imaginary part.
If you use only one numeric argument for complex() function, it treats it as the value of real part; and imaginary part is set to 0.
a=complex(5.3)print("a:", a,"type:",type(a))
It will produce the following output −
a: (5.3+0j) type: <class 'complex'>
The complex() function can also parse a string into a complex number if its only argument is a string having complex number representation.
In the following snippet, user is asked to input a complex number. It is used as argument. Since Python reads the input as a string, the function extracts the complex object from it.
a="5.5+2.3j"
b=complex(a)print("Complex number:", b)
It will produce the following output −
Complex number: (5.5+2.3j)
Python’s built-in complex class has two attributes real and imag − they return the real and coefficient of imaginary part from the object.
a=5+6jprint("Real part:", a.real,"Coefficient of Imaginary part:", a.imag)
It will produce the following output −
Real part: 5.0 Coefficient of Imaginary part: 6.0
The complex class also defines a conjugate() method. It returns another complex number with the sign of imaginary component reversed. For example, conjugate of x+yj is x-yj.
>>> a=5-2.2j>>> a.conjugate()(5+2.2j)
Number Type Conversion
Python converts numbers internally in an expression containing mixed types to a common type for evaluation. But sometimes, you need to coerce a number explicitly from one type to another to satisfy the requirements of an operator or function parameter.
Type float(x) to convert x to a floating-point number.
Type complex(x) to convert x to a complex number with real part x and imaginary part zero. In the same way type complex(x, y) to convert x and y to a complex number with real part x and imaginary part y. x and y are numeric expressions
Let us see various numeric and math-related functions.
Theoretic and Representation Functions
Python includes following theoretic and representation Functions in the math module −
Sr.No.
Function & Description
1
math.ceil(x)The ceiling of x: the smallest integer not less than x
2
math.comb(n,k)This function is used to find the returns the number of ways to choose “x” items from “y” items without repetition and without order.
3
math.copysign(x, y)This function returns a float with the magnitude (absolute value) of x but the sign of y.
4
math.cmp(x, y)This function is used to compare the values of to objects. This function is deprecated in Python3.
5
math.fabs(x)This function is used to calculate the absolute value of a given integer.
6
math.factorial(n)This function is used to find the factorial of a given integer.
7
math.floor(x)This function calculates the floor value of a given integer.
8
math.fmod(x, y)The fmod() function in math module returns same result as the “%” operator. However fmod() gives more accurate result of modulo division than modulo operator.
9
math.frexp(x)This function is used to calculate the mantissa and exponent of a given number.
10
math.fsum(iterable)This function returns the floating point sum of all numeric items in an iterable i.e. list, tuple, array.
11
math.gcd(*integers)This function is used to calculate the greatest common divisor of all the given integers.
12
math.isclose()This function is used to determine whether two given numeric values are close to each other.
13
math.isfinite(x)This function is used to determine whether the given number is a finite number.
14
math.isinf(x)This function is used to determine whether the given value is infinity (+ve or, -ve).
15
math.isnan(x)This function is used to determine whether the given number is “NaN”.
16
math.isqrt(n)This function calculates the integer square-root of the given non negative integer.
17
math.lcm(*integers)This function is used to calculate the least common factor of the given integer arguments.
18
math.ldexp(x, i)This function returns product of first number with exponent of second number. So, ldexp(x,y) returns x*2**y. This is inverse of frexp() function.
19
math.modf(x)This returns the fractional and integer parts of x in a two-item tuple.
math.perm(n, k)This function is used to calculate the permutation. It returns the number of ways to choose x items from y items without repetition and with order.
22
math.prod(iterable, *, start)This function is used to calculate the product of all numeric items in the iterable (list, tuple) given as argument.
23
math.remainder(x,y)This function returns the remainder of x with respect to y. This is the difference x − n*y, where n is the integer closest to the quotient x / y.
24
math.trunc(x)This function returns integral part of the number, removing the fractional part. trunc() is equivalent to floor() for positive x, and equivalent to ceil() for negative x.
25
math.ulp(x)This function returns the value of the least significant bit of the float x. trunc() is equivalent to floor() for positive x, and equivalent to ceil() for negative x.
Power and Logarithmic Functions
Sr.No.
Function & Description
1
math.cbrt(x)This function is used to calculate the cube root of a number.
2
math.exp(x)This function calculate the exponential of x: ex
3
math.exp2(x)This function returns 2 raised to power x. It is equivalent to 2**x.
4
math.expm1(x)This function returns e raised to the power x, minus 1. Here e is the base of natural logarithms.
5
math.log(x)This function calculates the natural logarithm of x, for x> 0.
6
math.log1p(x)This function returns the natural logarithm of 1+x (base e). The result is calculated in a way which is accurate for x near zero.
7
math.log2(x)This function returns the base-2 logarithm of x. This is usually more accurate than log(x, 2).
math.cos(x)This function returns the cosine of x radians.
6
math.sin(x)This function returns the sine of x radians.
7
math.tan(x)This function returns the tangent of x radians.
8
math.hypot(x, y)This function returns the Euclidean norm, sqrt(x*x + y*y).
Angular conversion Functions
Following are the angular conversion function provided by Python math module −
Sr.No.
Function & Description
1
math.degrees(x)This function converts the given angle from radians to degrees.
2
math.radians(x)This function converts the given angle from degrees to radians.
Mathematical Constants
The Python math module defines the following mathematical constants −
Sr.No.
Constants & Description
1
math.piThis represents the mathematical constant pi, which equals to “3.141592…” to available precision.
2
math.eThis represents the mathematical constant e, which is equal to “2.718281…” to available precision.
3
math.tauThis represents the mathematical constant Tau (denoted by ). It is equivalent to the ratio of circumference to radius, and is equal to 2.
4
math.infThis represents positive infinity. For negative infinity use “−math.inf”.
5
math.nanThis constant is a floating-point “not a number” (NaN) value. Its value is equivalent to the output of float(‘nan’).
Hyperbolic Functions
Hyperbolic functions are analogs of trigonometric functions that are based on hyperbolas instead of circles. Following are the hyperbolic functions of the Python math module −
Sr.No.
Function & Description
1
math.acosh(x)This function is used to calculate the inverse hyperbolic cosine of the given value.
2
math.asinh(x)This function is used to calculate the inverse hyperbolic sine of a given number.
3
math.atanh(x)This function is used to calculate the inverse hyperbolic tangent of a number.
4
math.cosh(x)This function is used to calculate the hyperbolic cosine of the given value.
5
math.sinh(x)This function is used to calculate the hyperbolic sine of a given number.
6
math.tanh(x)This function is used to calculate the hyperbolic tangent of a number.
Special Functions
Following are the special functions provided by the Python math module −
Sr.No.
Function & Description
1
math.erf(x)This function returns the value of the Gauss error function for the given parameter.
2
math.erfc(x)This function is the complementary for the error function. Value of erf(x) is equivalent to 1-erf(x).
3
math.gamma(x)This is used to calculate the factorial of the complex numbers. It is defined for all the complex numbers except the non-positive integers.
4
math.lgamma(x)This function is used to calculate the natural logarithm of the absolute value of the Gamma function at x.
Random Number Functions
Random numbers are used for games, simulations, testing, security, and privacy applications. Python includes following functions in the random module.
random.random()A random float r, such that 0 is less than or equal to r and r is less than 1
4
random.seed([x])This function sets the integer starting value used in generating random numbers. Call this function before calling any other random module function. Returns None.
5
random.shuffle(seq)This function is used to randomize the items of the given sequence.
6
random.uniform(a, b)This function returns a random floating point value r, such that a is less than or equal to r and r is less than b.
Built-in Mathematical Functions
Following mathematical functions are built into the Python interpreter, hence you don’t need to import them from any module.
Sr.No.
Function & Description
1
Python abs() functionThe abs() function returns the absolute value of x, i.e. the positive distance between x and zero.
2
Python max() functionThe max() function returns the largest of its arguments or largest number from the iterable (list or tuple).
3
Python min() functionThe function min() returns the smallest of its arguments i.e. the value closest to negative infinity, or smallest number from the iterable (list or tuple)
4
Python pow() functionThe pow() function returns x raised to y. It is equivalent to x**y.
5
Python round() Functionround() is a built-in function in Python. It returns x rounded to n digits from the decimal point.
6
Python sum() functionThe sum() function returns the sum of all numeric items in any iterable (list or tuple). It has an optional start argument which is 0 by default. If given, the numbers in the list are added to start value.
