Python literals can be defined as data that is given in a variable or constant.

Python supports the following literals:

1. String literals:

String literals can be formed by enclosing a text in quotes. We can use both single and double quotes to create a string.

Example:

"Aman" , '12345'  

Types of Strings:

There are two types of strings supported in Python:

a) Single-line Strings: Strings that are terminated within a single line are known as single-line strings.

Example:

text1='hello'  

b) Multi-line String: A piece of text that is written in multiple lines is known as a "multi-line string."

There are two ways to create multiline strings:

1. Adding black slash at the end of each line.

Example:

text1='hello\    
user'    
print(text1)  

'hellouser' 

2) Using triple quotation marks: marks: -

Example:

str2='''''welcome  
to  
SSSIT'''    
print str2   

Output:

welcome  
to  
SSSIT  

II. Numeric literals:

Numeric literals are immutable. Numeric literals can belong to the following four different numerical types:

Int(signed integers) Long(long integers) float(floating point) Complex(complex)

Numbers (which can be both positive and negative) with no fractional part. eg: 100

Integers of unlimited size followed by lowercase or uppercase L eg: 87032845L

Real numbers with both integer and fractional part eg: -26.2

in the form of a+bj, where a forms the real part and b forms the imaginary part of the complex number. eg: 3.14j

Example — Numeric Literals

x = 0b10100 #Binary Literals  
y = 100 #Decimal Literal   
z = 0o215 #Octal Literal  
u = 0x12d #Hexadecimal Literal  
  
#Float Literal  
float_1 = 100.5   
float_2 = 1.5e2  
  
#Complex Literal   
a = 5+3.14j  
  
print(x, y, z, u)  
print(float_1, float_2)  
print(a, a.imag, a.real)  

Output:

20 100 141 301
100.5 150.0
(5+3.14j) 3.14 5.0

III. Boolean literals:

A Boolean literal can have any of two values: True or False.

Example —Boolean Literals

x = (1 == True)  
y = (2 == False)  
z = (3 == True)  
a = True + 10  
b = False + 10  
  
print("x is", x)  
print("y is", y)  
print("z is", z)  
print("a:", a)  
print("b:", b)  

Output:

x is True
y is False
z is False
a: 11
b: 10

IV. Special literals.

Python contains one special literal, i.e., None.

None is used to specify a field that is not created. It is also used for the end of lists in Python.

Example — Special Literals

val1=10    
val2=None    
print(val1)     
print(val2)   

Output:

10
None

V. Literal Collections.

Python provides four types of literal collection: list literals, tuple literals, dictionary literals, and set literals.

List:

• List contains items of different data types. Lists are mutable i.e.., modifiable.
• The values stored in List are separated by comma(,) and enclosed within square brackets([]). We can store different types of data in a List.

Example — List literals

list=['John',678,20.4,'Peter']    
list1=[456,'Andrew']    
print(list)    
print(list + list1)  

Output:

['John', 678, 20.4, 'Peter']
['John', 678, 20.4, 'Peter', 456, 'Andrew']

Dictionary:

• Python dictionary stores the data in the key-value pair.
• It is enclosed by curly-braces {} and each pair is separated by the commas(,).

Example

dict = {'name': 'Pater', 'Age':18,'Roll_nu':101}  
print(dict)  

Output:

{'name': 'Pater', 'Age': 18, 'Roll_nu': 101}

Tuple:

• Python tuple is a collection of different data-type. It is immutable which means it cannot be modified after creation.
• It is enclosed by the parentheses () and each element is separated by the comma(,).

Example

tup = (10,20,"Dev",[2,3,4])  
print(tup)  

Output:

(10, 20, 'Dev', [2, 3, 4])

Set:

• Python set is the collection of the unordered dataset.
• It is enclosed by the {} and each element is separated by the comma(,).

Example: — Set Literals

set = {'apple','grapes','guava','papaya'}  
print(set)  

Output:

{'guava', 'apple', 'papaya', 'grapes'}

Python literals — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Every scripting language has designated words or keywords with particular definitions and usage guidelines. Python is no exception. The fundamental constituent elements of any Python program are Python keywords.

This tutorial will give you a basic overview of all Python keywords and a detailed discussion of some important keywords that are frequently used.

Introducing Python Keywords

Python keywords are unique words reserved with defined meanings and functions that we can only apply for those functions. You’ll never need to import any keywords into your program because they’re already there.

Python’s built-in methods and classes are not the same as the keywords. Built-in methods and classes are constantly present; however, they are not as limited in their application as keywords.

Assigning a particular meaning to Python keywords means you can’t use them for other purposes in our code. You’ll get a message of SyntaxError if you attempt to do the same. If you attempt to assign anything to a built-in method or type, you will not receive a SyntaxError message; however, it is still not a smart idea.

Python contains thirty-five keywords in the most recent version, i.e., Python 3.8.

In distinct versions of Python, the preceding keywords might be changed. Some extras may be introduced, while others may be deleted. By writing the following statement into the coding window, you can anytime retrieve the collection of keywords in the version you are working on.

Code

# Python program to demonstrate the application of iskeyword()  
# importing keyword library which has lists  
import keyword  
    
# displaying the complete list using "kwlist()."  
print("The set of keywords in this version is: ")  
print( keyword.kwlist )  

Output:

The set of keywords in this version is : 
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

By calling help(), you can retrieve a list of currently offered keywords:

Code

help("keywords")  

How to Identify Python Keywords

Python’s keyword collection has evolved as new versions were introduced. The await and async keywords, for instance, were not introduced till Python 3.7. Also, in Python 2.7, the words print and exec constituted keywords; however, in Python 3+, they were changed into built-in methods and are no longer part of the set of keywords. In the paragraphs below, you’ll discover numerous methods for determining whether a particular word in Python is a keyword or not.

Write Code on a Syntax Highlighting IDE

There are plenty of excellent Python IDEs available. They’ll all highlight keywords to set them apart from the rest of the terms in the code. This facility will assist you in immediately identifying Python keywords during coding so that you do not misuse them.

Verify Keywords with Script in a REPL

There are several ways to detect acceptable Python keywords plus know further regarding them in the Python REPL.

Look for a SyntaxError

Lastly, if you receive a SyntaxError when attempting to allocate to it, name a method with it, or do anything else with that, and it isn’t permitted, it’s probably a keyword. This one is somewhat more difficult to see, but it is still a technique for Python to tell you if you’re misusing a keyword.

Python Keywords and Their Usage

The following sections categorize Python keywords under the headings based on their frequency of use. The first category, for instance, includes all keywords utilized as values, whereas the next group includes keywords employed as operators. These classifications will aid in understanding how keywords are employed and will assist you in arranging the huge collection of Python keywords.

• A few terms mentioned in the segment following may be unfamiliar to you. They’re explained here, and you must understand what they mean before moving on:
• The Boolean assessment of a variable is referred to as truthfulness. A value’s truthfulness reveals if the value of the variable is true or false.

In the Boolean paradigm, truth refers to any variable that evaluates to true. Pass an item as an input to bool() to see if it is true. If True is returned, the value of the item is true. Strings and lists which are not empty, non-zero numbers, and many other objects are illustrations of true values.

False refers to any item in a Boolean expression that returns false. Pass an item as an input to bool() to see if it is false. If False is returned, the value of the item is false. Examples of false values are “ “, 0, { }, and [ ].

Value Keywords: True, False, None

Three Python keywords are employed as values in this example. These are singular values, which we can reuse indefinitely and every time correspond to the same entity. These values will most probably be seen and used frequently.

The Keywords True and False

These keywords are typed in lowercase in conventional computer languages (true and false); however, they are typed in uppercase in Python every time. In Python script, the True Python keyword represents the Boolean true state. False is a keyword equivalent to True, except it has the negative Boolean state of false.

True and False are those keywords that can be allocated to variables or parameters and are compared directly.

Code

print( 4 == 4 )  
print( 6 > 9 )  
print( True or False )  
print( 9 <= 28 )  
print( 6 > 9 )  
print( True and False )  

Output:

True
False
True
True
False
False

Because the first, third, and fourth statements are true, the interpreter gives True for those and False for other statements. True and False are the equivalent in Python as 1 & 0. We can use the accompanying illustration to support this claim:

Code

print( True == 3 )  
print( False == 0 )  
print( True + True + True)  

Output:

False
True
3

The None Keyword

None is a Python keyword that means “nothing.” None is known as nil, null, or undefined in different computer languages.

If a function does not have a return clause, it will give None as the default output:

Code

print( None == 0 )  
print( None == " " )  
print( None == False )  
A = None   
B = None  
print( A == B )  

Output:

False
False
False
True

If a no_return_function returns nothing, it will simply return a None value. None is delivered by functions that do not meet a return expression in the program flow. Consider the following scenario:

Code

def no_return_function():  
    num1 = 10  
    num2 = 20  
    addition = num1 + num2  
  
number = no_return_function()  
print( number )  

Output:

None

This program has a function with_return that performs multiple operations and contains a return expression. As a result, if we display a number, we get None, which is given by default when there is no return statement. Here’s an example showing this:

Code

def with_return( num ):  
    if num % 4 == 0:  
        return False  
  
number = with_return( 67 )  
print( number )  

Output:

None

Operator Keywords: and, or, not, in, is

Several Python keywords are employed as operators to perform mathematical operations. In many other computer languages, these operators are represented by characters such as &, |, and!. All of these are keyword operations in Python:

Writers created Python programming with clarity in mind. As a result, many operators in other computer languages that employ characters in Python are English words called keywords.

The and Keyword

The Python keyword and determines whether both the left-hand side and right-hand side operands and are true or false. The outcome will be True if both components are true. If one is false, the outcome will also be False:

It’s worth noting that the outcomes of an and statement aren’t always True or False. Due to and’s peculiar behavior, this is the case. Instead of processing the inputs to corresponding Boolean values, it just gives <component1> if it is false or <component2> if it is true. The outputs of a and expression could be utilized with a conditional if clause or provided to bool() to acquire an obvious True or False answer.

The or Keyword

<component1> or <component2>  

The or keyword in Python is utilized to check if, at minimum, 1 of the inputs is true. If the first argument is true, the or operation yields it; otherwise, the second argument is returned:

Similarly to the and keyword, the or keyword does not change its inputs to corresponding Boolean values. Instead, the outcomes are determined based on whether they are true or false.

The not Keyword

The not keyword in Python is utilized to acquire a variable’s contrary Boolean value:

The not keyword is employed to switch the Boolean interpretation or outcome in conditional sentences or other Boolean equations. Not, unlike and, and or, determines the specific Boolean state, True or False, afterward returns the inverse.

Code

False and True  
False or True  
not True  

Output:

False
True
False

The in Keyword

The in keyword of Python is a robust confinement checker, also known as a membership operator. If you provide it an element to seek and a container or series to seek into, it will give True or False, depending on if that given element was located in the given container:

<an_element> in <a_container>  

Testing for a certain character in a string is a nice illustration of how to use the in keyword:

Code

container = "Javatpoint"  
print( "p" in container )  
print( "P" in container )  

Output:

True
False

Lists, dictionaries, tuples, strings, or any data type with the method __contains__(), or we can iterate over it will work with the in keyword.

The is Keyword

In Python, it’s used to check the identification of objects. The == operation is used to determine whether two arguments are identical. It also determines whether two arguments relate to the unique object.

When the objects are the same, it gives True; otherwise, it gives False.

Code

print( True is True )  
print( False is True )  
print( None is not None )  
print( (9 + 5) is (7 * 2) )  

Output:

True
False
False
True

True, False, and None are all the same in Python since there is just one version.

Code

print( [] == [] )  
print( [] is [] )  
print( {} == {} )  
print( {} is {} )  

Output:

True
False
True
False

A blank dictionary or list is the same as another blank one. However, they aren’t identical entities because they are stored independently in memory. This is because both the list and the dictionary are changeable.

Code

print( '' == '' )  
print( '' is '' )  

Output:

True
True

Strings and tuples, unlike lists and dictionaries, are unchangeable. As a result, two equal strings or tuples are also identical. They’re both referring to the unique memory region.

The nonlocal Keyword

Nonlocal keyword usage is fairly analogous to global keyword usage. The keyword nonlocal is designed to indicate that a variable within a function that is inside a function, i.e., a nested function is just not local to it, implying that it is located in the outer function. We must define a non-local parameter with nonlocal if we ever need to change its value under a nested function. Otherwise, the nested function creates a local variable using that title. The example below will assist us in clarifying this.

Code

def the_outer_function():  
    var = 10  
    def the_inner_function():  
        nonlocal var  
        var = 14  
        print("The value inside the inner function: ", var)  
    the_inner_function()  
    print("The value inside the outer function: ", var)  
  
the_outer_function()  

Output:

The value inside the inner function:  14
The value inside the outer function:  14

the_inner_function() is placed inside the_outer_function in this case.

The the_outer_function has a variable named var. Var is not a global variable, as you may have noticed. As a result, if we wish to change it inside the the_inner_function(), we should declare it using nonlocal.

As a result, the variable was effectively updated within the nested the_inner_function, as evidenced by the results. The following is what happens if you don’t use the nonlocal keyword:

Code

def the_outer_function():  
    var = 10  
    def the_inner_function():  
        var = 14  
        print("Value inside the inner function: ", var)  
    the_inner_function()  
    print("Value inside the outer function: ", var)  
  
the_outer_function()  

Output:

Value inside the inner function:  14
Value inside the outer function:  10

Iteration Keywords: for, while, break, continue

The iterative process and looping are essential programming fundamentals. To generate and operate with loops, Python has multiple keywords. These would be utilized and observed in almost every Python program. Knowing how to use them correctly can assist you in becoming a better Python developer.

The for Keyword

The for loop is by far the most popular loop in Python. It’s built by blending two Python keywords. They are for and in, as previously explained.

The while Keyword

Python’s while loop employs the term while and functions similarly to other computer languages’ while loops. The block after the while phrase will be repeated repeatedly until the condition following the while keyword is false.

The break Keyword

If you want to quickly break out of a loop, employ the break keyword. We can use this keyword in both for and while loops.

The continue Keyword

You can use the continue Python keyword if you wish to jump to the subsequent loop iteration. The continue keyword, as in many other computer languages, enables you to quit performing the present loop iteration and go on to the subsequent one.

Code

# Program to show the use of keywords for, while, break, continue  
for i in range(15):  
    
    print( i + 4, end = " ")  
        
    # breaking the loop when i = 9  
    if i == 9:  
        break     
print()  
        
# looping from 1 to 15  
i = 0 # initial condition  
while i < 15:  
        
    # When i has value 9, loop will jump to next iteration using continue. It will not print  
    if i == 9:  
        i += 3  
        continue  
    else:  
        # when i is not equal to 9, adding 2 and printing the value  
        print( i + 2, end = " ")  
            
    i += 1  

Output:

4 5 6 7 8 9 10 11 12 13 
2 3 4 5 6 7 8 9 10 14 15 16 

Exception Handling Keywords — try, except, raise, finally, and assert

try: This keyword is designed to handle exceptions and is used in conjunction with the keyword except to handle problems in the program. When there is some kind of error, the program inside the “try” block is verified, but the code in that block is not executed.

except: As previously stated, this operates in conjunction with “try” to handle exceptions.

finally: Whatever the outcome of the “try” section, the “finally” box is implemented every time.

raise: The raise keyword could be used to specifically raise an exception.

assert: This method is used to help in troubleshooting. Often used to ensure that code is correct. Nothing occurs if an expression is interpreted as true; however, if it is false, “AssertionError” is raised. An output with the error, followed by a comma, can also be printed.

Code

# initializing the numbers  
var1 = 4  
var2 = 0  
    
# Exception raised in the try section  
try:  
    d = var1 // var2 # this will raise a "divide by zero" exception.  
    print( d )  
# this section will handle exception raised in try block  
except ZeroDivisionError:  
    print("We cannot divide by zero")  
finally:  
    # If exception is raised or not, this block will be executed every time  
    print("This is inside finally block")  
# by using assert keyword we will check if var2 is 0  
print ("The value of var1 / var2 is : ")  
assert var2 != 0, "Divide by 0 error"  
print (var1 / var2)  

Output:

We cannot divide by zero
This is inside finally block
The value of var1 / var2 is : 
---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
Input In [44], in ()
     15 # by using assert keyword we will check if var2 is 0
     16 print ("The value of var1 / var2 is : ")
---> 17 assert var2 != 0, "Divide by 0 error"
     18 print (var1 / var2)

AssertionError: Divide by 0 error

The pass Keyword

In Python, a null sentence is called a pass. It serves as a stand-in for something else. When it is run, nothing occurs.

Let’s say we possess a function that has not been coded yet however we wish to do so in the long term. If we write just this in the middle of code,

Code

def function_pass( arguments ):  

Output:

def function_pass( arguments ):
                                   ^
IndentationError: expected an indented block after function definition on line 1

as shown, IndentationError will be thrown. Rather, we use the pass command to create a blank container.

Code

def function_pass( arguments ):  
    pass  

We can use the pass keyword to create an empty class too.

Code

class passed_class:  
    pass  

The return Keyword

The return expression is used to leave a function and generate a result.

The None keyword is returned by default if we don’t specifically return a value. The accompanying example demonstrates this.

Code

def func_with_return():  
    var = 13  
    return var  
  
def func_with_no_return():  
    var = 10  
  
print( func_with_return() )  
print( func_with_no_return() )  

Output:

13
None

The del Keyword

The del keyword is used to remove any reference to an object. In Python, every entity is an object. We can use the del command to remove a variable reference.

Code

var1 = var2 = 5  
del var1  
print( var2 )  
print( var1 )  

Output:

5
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Input In [42], in ()
      2 del var1
      3 print( var2 )
----> 4 print( var1 )

NameError: name 'var1' is not defined

We can notice that the variable var1’s reference has been removed. As a result, it’s no longer recognized. However, var2 still exists.

Deleting entries from a collection like a list or a dictionary is also possible with del:

Code

list_ = ['A','B','C']  
del list_[2]  
print(list_)  

Output:

['A', 'B']

Python keywords — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Variables can hold values, and every value has a data type. Python is a dynamically typed language; hence, we do not need to define the type of the variable while declaring it. The interpreter implicitly binds the value to its type.

a = 5

The variable a holds an integer value of five, and we did not define its type. Python interpreter will automatically interpret variables a as an integer type.

Python enables us to check the type of the variable used in the program. Python provides us with the type() function, which returns the type of the variable passed.

Consider the following example to define the values of different data types and check their type:

a=10  
b="Hi Python"  
c = 10.5  
print(type(a))  
print(type(b))  
print(type(c))  

Output:

<type 'int'>
<type 'str'>
<type 'float'>

Standard data types

A variable can hold different types of values. For example, a person’s name must be stored as a string, whereas its id must be stored as an integer.

Python provides various standard data types that define the storage method for each of them. The data types defined in Python are given below.

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

In this section of the tutorial, we will give a brief introduction to the above data types. We will discuss each one of them in detail later in this tutorial.

Numbers

A number stores numeric values. The integer, float, and complex values belong to the Python Numbers data type. Python provides the type() function to know the data-type of the variable. Similarly, the isinstance() function is used to check whether an object belongs to a particular class.

Python creates Number objects when a number is assigned to a variable. For example;

a = 5  
print("The type of a", type(a))  
  
b = 40.5  
print("The type of b", type(b))  
  
c = 1+3j  
print("The type of c", type(c))  
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 types of numeric data.

1. Int — Integer value can be any length such as integers 10, 2, 29, -20, -150 etc. Python has no restriction on the length of an integer. Its value belongs to int
2. Float — Float is used to store floating-point numbers like 1.9, 9.902, 15.2, etc. It is accurate upto 15 decimal points.
3. complex — A complex number contains an ordered pair, i.e.., x + iy where x and y denote the real and imaginary parts, respectively. The complex numbers like 2.14j, 2.0 + 2.3j, etc.

Sequence Type

String

The string can be defined as the sequence of characters represented in the quotation marks. In Python, we can use single, double, or triple quotes to define a string.

String handling in Python is a straightforward task since Python provides built-in functions and operators to perform operations on the string.

In the case of string handling, the operator + is used to concatenate two strings, as the operation “hello" + "python” returns “hello python”.

The operator * is known as a repetition operator, as the operation “Python” *2 returns "Python Python."

The following example illustrates the string in Python.

Example — 1

str = "string using double quotes"  
print(str)  
s = '''''A multiline 
string'''  
print(s)  

Output:

string using double quotes
A multiline
string

Consider the following example of string handling:

Example — 2

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

Output:

he
o
hello javatpointhello javatpoint
hello javatpoint how are you

List

Python lists are similar to arrays in C. However, the list can contain data of different types. The items stored in the list are separated with a comma (,) and enclosed within square brackets [].

We can use slice [:] operators to access the data of the list. The concatenation operator (+) and repetition operator (*) work with the list in the same way they worked with the strings.

Consider the following example:

list1  = [1, "hi", "Python", 2]    
#Checking type of given list  
print(type(list1))  
  
#Printing the list1  
print (list1)  
  
# List slicing  
print (list1[3:])  
  
# List slicing  
print (list1[0:2])   
  
# List Concatenation using + operator  
print (list1 + list1)  
  
# List repetation using * operator  
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

Tuples are similar to the list in many ways. Like lists, tuples also contain a collection of items of different data types. The items of the tuple are separated by a comma (,) and enclosed in parentheses ().

A tuple is a read-only data structure, as we can’t modify the size and value of the items in it.

Let’s see a simple example of the tuple.

tup  = ("hi", "Python", 2)    
# Checking type of tup  
print (type(tup))    
  
#Printing the tuple  
print (tup)  
  
# Tuple slicing  
print (tup[1:])    
print (tup[0:1])    
  
# Tuple concatenation using + operator  
print (tup + tup)    
  
# Tuple repatation using * operator  
print (tup * 3)     
  
# Adding value to tup. It will throw an error.  
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

Dictionary is an unordered set of a key-value pair of items. It is like an associative array or a hash table where each key stores a specific value. Key can hold any primitive data type, whereas value is an arbitrary Python object.

The items in the dictionary are separated with the comma (,) and enclosed in curly braces ().

Consider the following example:

d = {1:'Jimmy', 2:'Alex', 3:'john', 4:'mike'}     
  
# Printing dictionary  
print (d)  
  
# Accesing value using keys  
print("1st name is "+d[1])   
print("2nd name is "+ d[4])    
  
print (d.keys())    
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

The Boolean type provides two built-in values: true and false. These values are used to determine whether the given statement is true or false. It is denoted by the class bool. True can be represented by any non-zero value or ‘T’ whereas false can be represented by the 0 or ‘F’. Consider the following example:

# Python program to check the boolean type  
print(type(True))  
print(type(False))  
print(false)  

Output:

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

Set

Python Set is the unordered collection of the data type. It is iterable, mutable (it can be modified after creation), and has unique elements. In set, the order of the elements is undefined; it may return the changed sequence of the element. The set is created by using the built-in function set(), or a sequence of elements is passed in the curly braces and separated by the comma. It can contain various types of values. Consider the following example:

# Creating Empty set  
set1 = set()  
  
set2 = {'James', 2, 3,'Python'}  
  
#Printing Set value  
print(set2)  
  
# Adding element to the set  
  
set2.add(10)  
print(set2)  
  
#Removing element from the set  
set2.remove(2)  
print(set2)  

Output:

{3, 'Python', 'James', 2}
{'Python', 'James', 3, 2, 10}
{'Python', 'James', 3, 10}

Python Data Types — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Variable is a name that is used to refer to memory location. Python variable is also known as an identifier and used to hold value.

In Python, we don’t need to specify the type of variable because Python is a infer language and smart enough to get variable type.

Variable names can be a group of both letters and digits, but they have to begin with a letter or an underscore.

It is recommended to use lowercase letters for the variable name. Rahul and Rahul both are two different variables.

Identifier Naming

Variables are example of identifiers. An Identifier is used to identify the literals used in the program. The rules to name an identifier are given below.

• The first character of the variable must be an alphabet or underscore ( _ ).
• All the characters except the first character may be an alphabet of lower-case(a-z), upper-case (A-Z), underscore, or digit (0–9).
• The identifier name must not contain any white space, or special character (! @, #, %, ^, &, *).
• The identifier name must not be similar to any keyword defined in the language.
• Identifier names are case sensitive; for example, my name, and my name is not the same.
• Examples of valid identifiers: are a123, _n, n_9, etc.
• Examples of invalid identifiers: 1a, n%4, n 9, etc.

Declaring Variable and Assigning Values

Python does not bind us to declare a variable before using it in the application. It allows us to create a variable at the required time.

We don’t need to declare explicitly variables in Python. When we assign any value to the variable, that variable is declared automatically.

The equal (=) operator is used to assign value to a variable.

Object References

It is necessary to understand how the Python interpreter works when we declare a variable. The process of treating variables is somewhat different from many other programming languages.

Python is a highly object-oriented programming language; that’s why every data item belongs to a specific type of class. Consider the following example.

print("John")  

Output:

John

The Python object creates an integer object and displays it on the console. In the above print statement, we have created a string object. Let’s check the type of it using the built-in type() function in Python.

type("John")  

Output:

<class 'str'>

In Python, variables have a symbolic name that is a reference or pointer to an object. The variables are used to denote objects by that name.

Let’s understand the following example

a = 50

In the above image, the variable a refers to an integer object.

Suppose we assign the integer value 50 to a new variable b.

a = 50

b = a

The variable b refers to the same object that points to because Python does not create another object.

Let’s assign the new value to b. Now both variables will refer to the different objects.

a = 50

b =100

Python manages memory efficiently if we assign the same variable to two different values.

Object Identity

In Python, every created object identifies uniquely. Python provides the guarantee that no two objects will have the same identifier. The built-in id() function, is used to identify the object identifier. Consider the following example.

a = 50  
b = a  
print(id(a))  
print(id(b))  
# Reassigned variable a  
a = 500  
print(id(a))  

Output:

140734982691168
140734982691168
2822056960944

We assigned the b = a, a, and b both point to the same object. When we checked by the id() function it returned the same number. We reassign a to 500; then it referred to the new object identifier.

Variable Names

We have already discussed how to declare the valid variable. Variable names can be any length and can have uppercase, lowercase (A to Z, a to z), the digit (0–9), and underscore character(_). Consider the following example of valid variable names.

name = "Devansh"  
age = 20  
marks = 80.50  
  
print(name)  
print(age)  
print(marks)  

Output:

Devansh
20
80.5

Consider the following valid variables' name.

name = "A"  
Name = "B"  
naMe = "C"  
NAME = "D"  
n_a_m_e = "E"  
_name = "F"  
name_ = "G"  
_name_ = "H"  
na56me = "I"  
  
print(name,Name,naMe,NAME,n_a_m_e, NAME, n_a_m_e, _name, name_,_name, na56me)  

Output:

A B C D E D E F G F I

In the above example, we have declared a few valid variable names such as name, _name_, etc. But it is not recommended because when we try to read code, it may create confusion. The variable name should be descriptive to make the code more readable.

The multi-word keywords can be created by the following method.

• Camel Case — In the camel case, each word or abbreviation in the middle begins with a capital letter. There is no intervention of whitespace. For example — name of student, valueOfVaraible, etc.
• Pascal Case — It is the same as the Camel Case, but here the first word is also capitalized. For example — NameOfStudent, etc.
• Snake Case — In the snake case, Words are separated by the underscore. For example — name_of_student, etc.

Multiple Assignment

Python allows us to assign a value to multiple variables in a single statement, which is also known as multiple assignments.

We can apply multiple assignments in two ways, either by assigning a single value to multiple variables or assigning multiple values to multiple variables. Consider the following example.

1. Assigning a single value to multiple variables Eg:

x=y=z=50    
print(x)    
print(y)    
print(z)    

Output:

50  
50  
50 

1. 2. Assigning multiple values to multiple variables Eg:

a,b,c=5,10,15    
print a    
print b    
print c    

Output:

5  
10  
15  

The values will be assigned in the order in which variables appear.

Python Variable Types

There are two types of variables in Python — Local variables and Global variables. Let’s understand the following variables.

Local Variable

Local variables are the variables that are declared inside the function and have scope within the function. Let’s understand the following example.

Example -

# Declaring a function  
def add():  
    # Defining local variables. They has scope only within a function  
    a = 20  
    b = 30  
    c = a + b  
    print("The sum is:", c)  
  
# Calling a function  
add()  

Output:

The sum is: 50

Explanation:

In the above code, we declared a function named add() and assigned a few variables within the function. These variables will be referred to as the local variables which have scope only inside the function. If we try to use them outside the function, we get the following error.

add()  
# Accessing local variable outside the function   
print(a)  

Output:

The sum is: 50
    print(a)
NameError: name 'a' is not defined

We tried to use a local variable outside their scope; it threw the NameError.

Global Variables

Global variables can be used throughout the program, and its scope is in the entire program. We can use global variables inside or outside the function.

A variable declared outside the function is the global variable by default. Python provides the global keyword to use the global variables inside the function. If we don’t use the global keyword, the function treats it as a local variable. Let’s understand the following example.

Example -

# Declare a variable and initialize it  
x = 101  
  
# Global variable in function  
def mainFunction():  
    # printing a global variable  
    global x  
    print(x)  
    # modifying a global variable  
    x = 'Welcome To Javatpoint'  
    print(x)  
  
mainFunction()  
print(x)  

Output:

101
Welcome To Javatpoint
Welcome To Javatpoint

Explanation:

In the above code, we declare a global variable x and assign a value to it. Next, we defined a function and accessed the declared variable using the global keyword inside the function. Now we can modify its value. Then, we assigned a new string value to the variable x.

Now, we called the function and proceeded to print x. It printed the as newly assigned value of x.

Delete a variable

We can delete the variable using the del keyword. The syntax is given below.

Syntax -

del <variable_name>

In the following example, we create a variable x and assign a value to it. We deleted variable x, and print it, we get the error “variable x is not defined”. The variable x will no longer use in the future.

Example -

# Assigning a value to x  
x = 6  
print(x)  
# deleting a variable.   
del x  
print(x)  

Output:

6
Traceback (most recent call last):
  File "C:/Users/DEVANSH SHARMA/PycharmProjects/Hello/multiprocessing.py", line 389, in 
    print(x)
NameError: name 'x' is not defined

Maximum Possible Value of an Integer in Python

Unlike the other programming languages, Python doesn’t have long int or float data types. It treats all integer values as an int data type. Here, the question arises. What is the maximum possible value that can hold by the variable in Python? Consider the following example.

Example -

# A Python program to display that we can store  
# large numbers in Python  
  
a = 10000000000000000000000000000000000000000000  
a = a + 1  
print(type(a))  
print (a)  

Output:

<class 'int'>
10000000000000000000000000000000000000000001

As we can see in the above example, we assigned a large integer value to variable x and checked its type. It printed class <int> not long int. Hence, there is no limitation number by bits and we can expand to the limit of our memory.

Python doesn’t have any special data type to store larger numbers.

Print Single and Multiple Variables in Python

We can print multiple variables within the single print statement. Below are example of single and multiple printing values.

Example — 1 (Printing Single Variable)

# printing single value   
a = 5  
print(a)  
print((a)) 

Output:

5
5

Example — 2 (Printing Multiple Variables)

a = 5  
b = 6  
# printing multiple variables  
print(a,b)  
# separate the variables by the comma  
Print(1, 2, 3, 4, 5, 6, 7, 8)   

Output:

5 6
1 2 3 4 5 6 7 8

Basic Fundamentals:

This section contains the fundamentals of Python, such as:

I) Tokens and their types.

ii) Comments

a) Tokens:

• The tokens can be defined as a punctuator mark, reserved words, and each word in a statement.
• The token is the smallest unit inside the given program.

There are the following tokens in Python:

• Keywords.
• Identifiers.
• Literals.
• Operators.

We will discuss above the tokens in detail next tutorials.

Python variables — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

In order to become a Python developer, the first step is to learn how to install or update Python on a local machine or computer. In this tutorial, we will discuss the installation of Python on various operating systems.

Installation on Windows

Visit the link https://www.python.org/downloads/ to download the latest release of Python. In this process, we will install Python 3.8.6 on our Windows operating system. When we click on the above link, it will bring us to the following page.

Step 1: Select the Python version to download.

Click on the download button.

Step — 2: Click on the Install Now

Double-click the executable file, which has been downloaded; the following window will open. Select "Customize installation" and proceed. Click on the Add Path check box; it will set the Python path automatically.

We can also click on "customize installation" to choose the desired location and features. Other important thing is install launcher for the all user must be checked.

Step — 3 Installation in Process

Now, try to run Python on the command prompt. Type the command "python --version" in the case of Python 3.

We are ready to work with Python.

How to Installation on Mac ?

To install Python 3 on MacOS, visit the link https://medium.com/python-tutorial-python-programming-language/how-to-install-python-on-mac-python-tutorial-f325c51dc6f7 and follow the instructions given in the tutorial.

How Installation on CentOS ?

To install Python3 on CentOS, visit the link https://medium.com/python-tutorial-python-programming-language/how-to-install-python-on-centos-python-tutorial-35d257cf5b89 and follow the instructions given in the tutorial.

How to Installation on Ubuntu ?

To install Python3 on Ubuntu, visit the link https://medium.com/python-tutorial-python-programming-language/how-to-install-python-in-ubuntu-python-tutorial-640561c3cc5b and follow the instructions given in the tutorial.

How to install python — python tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

Python is a high-level, dynamic, general-purpose language. It was developed by Guido Van Rossum in 1991. Python’s syntax allows developers to use fewer lines of code than any other programming language. It basically focuses on the code readability of program. Python 2.7 is installed by default on MacOS but we can install other versions like python 3.5 and 3.6.

In this tutorial, we are learning how to install Python 3.6.3 on the MAC Operating system.

Prerequisites

• MacOS
• Login as an administrator on terminal

Installation

There are following steps which are used while installing Python3 on MacOS.

1) Checking python’s version on the system

We can check which version of the Python is currently installed on our system. Generally, Python 2.7 is installed by default.

Let’s see how can we do it.

$ python -version   

It shows Python 2.7.10 is installed on the computer, which happens quite often.

2) Download Python 3.6.3

In order to install Python 3.6.3, we must download the latest version from its official website, https://www.python.org/downloads/ . The file is downloaded in .pkg format which can be directly installed by using Installer command.

3) Install Python 3.6.3

Since the downloaded file is already in.pkg format, no mounting is required, and we can use the installer command to install Python 3.6.3.

Let’s see how we can do it.

Since The installer is used with super user permissions hence sudo forces terminal to prompt the user to fill the admin password. The process installs Python 3.6.3 to the root directory, which is mentioned with the target option.

4) Verify Python3

To check which Python version is installed on the machine, we can use the python --version command. Since the default installed version is Python 2.7.10, it shows Python 2.7.10. but it gives us flexibility to check the version of Python 3 on our computer.

Let’s see how we can use Python 3 to check which version of Python 3 is running.

$ python -version  

5) Working on Python’s script mode

To work on the Python command line, we simply type python3 on the terminal. Python shell open where we can run Python statements such as print statements as we did here.

To run a Python file (.py) on the terminal, we simply type the file name, and the file will be interpreted.

Well, we have installed Python3 on our MacOS.

How to Install Python on Mac — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

Python is a high-level, dynamic, general-purpose language. It was developed by Guido Van Rossum in 1991. Python’s syntax allows developers to use fewer lines of code than any other programming language. It basically focuses on the code readability of programs. Python 2.7 is installed by default on CentOS, but we can install other versions like Python 3.5 and 3.6. In this tutorial, we are learning how to install Python 3.6.3 on CentOS.

Prerequisites

• CentOS
• Log in as an administrator on the terminal
• Yum must be configured on the system.

Installation

Installation includes the following steps:

1. Install IUS Community Repository

In order to install Python 3.6 on CentOS, we first need to install the IUS community repository, which provides extra packages for Enterprise Linux. Execute the following command to install the IUS community repository:

$ sudo yum -y install https://centos7.iuscommunity.org/ius-release.rpm   

2. Install Python 3

Execute the following command to install Python 3.6 on CentOS:

$ sudo yum install python36u   

3. Verify Python

To verify if we have installed the correct version of Python, we just need to type python 3.6 -V on the terminal. The command will show the version installed, which is 3.6.4 in my case.

4. Working on Python’s script mode

Just type python3.6 on the terminal to enter Python’s script mode. We can execute the Python statements on this shell. Since Python 2 is by default installed on CentOS, typing python on the terminal takes us to the Python 2 shell, so we have to type python3.6 to work on the desired Python shell.

Execute the valid Python statements, which get interpreted and show the desired output on the terminal as shown below.

Hence, we have installed and can get started with Python 3.

How to Install Python on CentOS — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

Python is a high-level, dynamic, and general-purpose programming language. It was designed and developed by the Python Software Foundation.

Python is a cross-platform language and was first released on February 20, 1991.

In this tutorial, we are working on the installation process of Python, which includes the following steps:

Although Python 2.7 is installed by default in Ubuntu, we can install other Python versions, like Python 3.

To install Python 3, just type the following command in the terminal, and it will be installed automatically.

Python Installation

1. Update the APT Repository

$ apt-get update

2) Install Python

$ apt-get install python3.6  

3) Verify Python

$ python  

When we type Python, it shows the default installed Python, which is 2.7.

For Python 3, type the following command, and it will show the other version as well.

Well, on the basis of these commands, we can test applications for both Python versions.

How to Install Python in Ubuntu — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Python is known for its general-purpose nature, which makes it applicable in almost every domain of software development. Python makes its presence felt in every emerging field. It is the fastest-growing programming language and can develop any application.

Here, we are specifying application areas where Python can be applied.

1) Web Applications

We can use Python to develop web applications. It provides libraries to handle internet protocols such as HTML and XML, JSON, Email processing, request, beautifulSoup, Feedparser, etc. One of Python web-framework named Django is used on Instagram. Python provides many useful frameworks, and these are given below:

• Django and Pyramid framework(Use for heavy applications)
• Flask and Bottle (Micro-framework)
• Plone and Django CMS (Advance Content management)

2) Desktop GUI Applications

The GUI stands for "Graphical User Interface," which provides smooth interaction with any application. Python provides a Tk GUI library to develop a user interface. Some popular GUI libraries are given below.

• Tkinter or Tk
• wxWidgetM
• Kivy (used for writing multitouch applications )
• PyQt or Pyside

3) Console-based Application

Console-based applications run from the command line, or shell. These applications are computer programs that execute commands. This kind of application was more popular in the old generation of computers. Python can develop this kind of application very effectively. It is famous for having REPL, which stands for "Read-Eval-Print Loop," which makes it the most suitable language for command-line applications.

Python provides many free library or module which helps to build the command-line apps. The necessary IO libraries are used to read and write. It helps to parse argument and create console help text out-of-the-box. There are also advanced libraries that can develop independent console apps.

4) Software Development

Python is useful for the software development process. It works as a support language and can be used to build control and management, testing, etc.

• SCons is used to build control.
• Buildbot and Apache Gumps are used for automated continuous compilation and testing.
• Round or Trac for bug tracking and project management.

5) Scientific and Numeric

This is the era of artificial intelligence, where machines can perform tasks just like humans. Python is the most suitable language for artificial intelligence or machine learning. It consists of many scientific and mathematical libraries, which make it easy to solve complex calculations.

Implementing machine learning algorithms requires complex mathematical calculations. Python has many libraries for scientific and numerical computing, such as Numpy, Pandas, Scipy, Scikit-learn, etc. If you have some basic knowledge of Python, you need to import libraries at the top of the code. A few popular frameworks for machine libraries are given below.

• SciPy
• Scikit-learn
• NumPy
• Pandas
• Matplotlib

6) Business Applications

Business applications differ from standard applications. E-commerce and ERP are examples of business applications. This kind of application requires extensive scalability and readability, and Python provides all these features.

Oddo is an example of an all-in-one Python-based application that offers a range of business applications. Python provides a Tryton platform, which is used to develop the business application.

7) Audio or Video-based Applications

Python is flexible enough to perform multiple tasks and can be used to create multimedia applications. Some multimedia applications that are made with Python are TimPlayer, cplay, etc. The few multimedia libraries are listed below.

• Gstreamer
• Pyglet
• QT Phonon

8) 3D CAD Applications

CAD (computer-aided design) is used to design engineering-related architecture. It is used to develop the 3D representation of a part of a system. Python can create a 3D CAD application by using the following functionalities:

• Fandango (Popular )
• CAMVOX
• HeeksCNC
• AnyCAD RCAM

9) Enterprise Applications

Python can be used to create applications that can be used within an enterprise or organization. Some real-time applications are OpenERP, Tryton, Picalo, etc.

10) Image Processing Application

Python contains many libraries that are used to work with the image. The image can be manipulated according to our requirements. Some libraries for image processing are given below.

In this topic, we have described all types of applications where Python plays an essential role in the development of these applications. In the next tutorial, we will learn more concepts about Python.

Python Applications — python tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.

Python provides many useful features that make it popular and valuable compared to other programming languages. It supports object-oriented programming and procedural programming approaches and provides dynamic memory allocation. We have listed below a few essential features.

1) Easy to Learn and Use

Python is easy to learn as compared to other programming languages. Its syntax is straightforward and much the same as that of the English language. There is no use of the semicolon or curly bracket; the indentation defines the code block. It is the recommended programming language for beginners.

2) Expressive Language

Python can perform complex tasks using a few lines of code. A simple example, the hello world program you simply type print(“Hello World”). It will take only one line to execute, while Java or C takes multiple lines.

3) Interpreted Language

Python is an interpreted language, which means the Python program is executed one line at a time. The advantage of being an interpreted language is that it makes debugging easy and portable.

4) Cross-platform Language

Python can run equally well on different platforms such as Windows, Linux, UNIX, Macintosh, etc. So, we can say that Python is a portable language. It enables programmers to develop the software for several competing platforms by writing a program only once.

5) Free and Open Source

Python is freely available for everyone. It is freely available on its official website, www.python.org. It has a large community across the world that is dedicatedly working towards make new python modules and functions. Anyone can contribute to the Python community. The term "open-source" means “anyone can download its source code without paying a penny.”

6) Object-Oriented Language

Python supports an object-oriented language, and concepts of classes and objects come into existence. It supports inheritance, polymorphism, and encapsulation, etc. The object-oriented procedure helps programmers write reusable code and develop applications with less code.

7) Extensible

It implies that other languages such as C/C++ can be used to compile the code, and thus it can be used further in our Python code. It converts the program into byte code, and any platform can use that byte code.

8) Large Standard Library

It provides a vast range of libraries for the various fields such as machine learning, web developer, and also for the scripting. There are various machine learning libraries, such as TensorFlow, Pandas, Numpy, Keras, PyTorch, etc. Django, Flask, and Pyramids are the popular frameworks for Python web development.

9) GUI Programming Support

A graphic user interface is used for the developing desktop application. PyQT5, Tkinter, and Kivy are the libraries that are used for developing the web application.

10) Integrated

It can be easily integrated with languages like C, C++, and JAVA, etc. Python runs code line by line like C, C++, and Java. It makes it easy to debug the code.

11. Embeddable

The code of the other programming language can be used in the Python source code. We can use Python source code in another programming language as well. It can embed other languages into our code.

12. Dynamic Memory Allocation

In Python, we don’t need to specify the data type of the variable. When we assign some value to the variable, it automatically allocates the memory to the variable at run time. Suppose we are assigned the integer value 15 to x, then we don’t need to write int x = 15. Just write "x = 15."

Python Features — Python Tutorial was originally published in Python Tutorial | Python Programming Language on Medium, where people are continuing the conversation by highlighting and responding to this story.