Exploring Python Basic Terms

Get to know about python basic terms

Photo by Victoria Borodinova from Pexels

Python basic terms

  1. Identifiers
  2. keywords
  3. Operators
  4. Object Id,Object Type
  5. Sequences
  6. Set Types
  7. Mappings
  8. Iterable
  9. Iterator
  10. Simple statements
  11. Compound statements
  12. Built-in types
  13. Built-in functions
  14. Built-in methods
  15. Mutable, Immutable
  17. Docstring


Python identifiers are names given to identify variables, class, function, module, packages, methods, instance variables, or any other object.
Identifiers start with lowercase or uppercase letter A-Z a-z , or underscore.
It can then followed by zero or more letters, digits, and underscore.
Special characters and space are not allowed in identifiers.

Naming Convention:

  1. If an identifier starts with an underscore, then it is a private identifier
    Refer to my story for underscores in python.
  2. Class names should normally use the CapWords convention.
    class BankAccount:
  3. Modules should have short, all-lowercase names. Underscores can be used in the module name if it improves readability.
  4. Python packages should also have short, all-lowercase names, although the use of underscores is discouraged.
  5. Function names should be lowercase, with words separated by underscores as necessary to improve readability.
    def withdrawal():
    def bank_withdrawal():
  6. Variable names follow the same convention as function names.
  7. Method names and also instance variables should be lowercase with words separated by underscores as necessary to improve readability.
  8. Use one leading underscore only for non-public methods and instance variables.

Names to avoid:

Never use the characters ‘l’ (lowercase letter el), ‘O’ (uppercase letter oh), or ‘I’ (uppercase letter eye) as single-character variable names. In some fonts, these characters are indistinguishable from the numerals one and zero.

Example 1: Space is given in the function name

def bank withdrawal():

#Output:SyntaxError: invalid syntax

Example 2:Special characters given in function name

def withdrawal%():
#Output:SyntaxError: invalid syntax


Keywords are reserved words that cannot be used as ordinary identifiers.

Source: Python Documentation


The following operators are supported in python.

Source: Python Documentation

Object Id,Object Type

Every object has an identity, type, and value.
Object Id is the object address in the memory.id() function returns the object’s identity
Object type determines the type of the object like list,dict, tuple, string etc.
type() function returns the object type

print (id(list1))#Output:39270408
print (type(list1))#Output:<class 'list'>

print (id(tuple1))#Output:39405192
print (type(tuple1))#Output:<class 'tuple'>

print (id(dict1))#Output:22432336
print (type(dict1))#Output:<class 'dict'>


Sequences represent finite ordered set indexed by non-negative numbers.

  1. Immutable Sequences
print (str1[1])#Output: y
print (tup1[1])#Output:2

2. Mutable Sequences

print (lis1[2]) #Output:3

Set Types

Set types represent unordered, finite sets of unique, immutable objects. Common uses for sets is to remove duplicates from the sequence and perform mathematical set operations like union, intersection, difference, symmetric difference.

  1. Sets
    Sets are immutable. Created by using a built-in set() constructor.Empty set is given as set()
  2. Frozen sets
    Frozen sets are immutable. Since it is immutable and also hashable, it can be used as dictionary keys
print (set1)#Output:{1,2,3}

print (set2)#Output:{1,2,3}

print (fro1)#Output:frozenset({1, 2, 3})


A mapping object maps values of one type (the key type) to arbitrary objects. Mappings are mutable objects. There is currently only one standard mapping type, the dictionary. A dictionary’s keys are almost arbitrary values. The only types of values not acceptable as keys are values containing lists or dictionaries or other mutable types that are compared by value rather than by object identity.



An object capable of returning its members one at a time. Iterables can be iterated upon using for loop.

Example. List,set,tuple,dict,range object,file objects

for i in list1:
    print(i , end=" ") #Output:1 2 3

for i in set1:
    print(i , end=" ")#Output:1 2 3

for i in tuple1:
    print(i , end=" ")#Output:1 2 3

for i in dict1:
    print (i,end=" ")#Output:1 2 3

for i in r:
    print (i,end=" ")#Outpur:1 2 3


An object representing a stream of data. If an iterable contains the iter() function, we can convert to an iterator.

We can iterate over iterators 
 1.Using for loop

We can iterate over the iterator. But it will iterate one time only. Attempting to iterate second time will just return the same exhausted iterator object used in the previous iteration pass, making it appear like an empty container.

for i in n2:
    print (i, end=" ") #Output: 1 2 3 
print ("")
#exhausted iterator returns an empty container
print (n3)#Output: []

2.Using next() function
When the iterator is exhausted( no more data available) a StopIteration exception is raised instead.

print (next(n2))#Output: 1
print (next(n2))#Output: 2
print (next(n2))#Output: 3
print (next(n2))#Output:StopIteration

Refer to my story Iterable vs Iterator

Simple Statements

A simple statement is comprised of a single logical line

Source: Python documentation

Compound Statements

Compound statements contain (groups of) other statements; they affect or control the execution of those other statements in some way.
A compound statement consists of one or more ‘clauses.’ A clause consists of a header and a ‘suite.’ The clause headers of a particular compound statement are all at the same indentation level. Each clause header begins with a uniquely identifying keyword and ends with a colon. A suite is a group of statements controlled by a clause.

Source: Python Documentation

Built-in types

The principal built-in types are numerics, sequences, mappings, classes, instances, and exceptions.

Built-in functions

The Python interpreter has a number of built-in functions that are always available. A built-in function object is a wrapper around a C function. The number and type of arguments are determined by the C function.

Source: Python Documentation

Built-in methods

Built-in methods on mutable objects.

Methods are called on an object. Its return type is None. It will modify the original object itself. But python function doesn’t modify the object, it will return a new object.

Ex. List object has a built-in method sort and built-in function sorted()

sort →This has to be called on an object (list) like list.sort()
It will modify the original list. It won’t return anything.

sorted() -This is built in function. sorted(list)
It will return a new sorted list. It won’t modify the original list.

#built-in methods
print (list1.sort())#Output:None
print (list1)#Output:[1,2,3,4,5,6,7]

#built-in functions
print (sorted(list2)) #Output:[1,2,3,4,5,6,7]
# It won't modify the original list.
print (list2)#Output:[2, 1, 5, 3, 7, 6, 4]

Built-in methods supported by list, tuple,dict, and set.

Image Source: Author

Built-in methods supported by strings

Built-in methods on immutable objects like string will return a new copy of the string. It won’t modify the original string.

Image Source: Author

Mutable objects

Objects whose value can change are said to be mutable; objects whose value is unchangeable once they are created are called immutable.

Mutable objects -List,dictionary,set

Immutable objects -Strings, tuple


Comments in Python start with # and continue until the end of the line. Comments are important because it will improve the readability of the code. Comments in the program are for humans to read and understand and not for the computer to execute.

# sorting the given list
print (sorted(colors))


A docstring is a string literal that occurs as the first statement in a module, function, class, or method definition. It allows programmers to add quick notes about the function/class. It can span multiple lines also. We can access the docstring using the __doc__ method.
For consistency, always use “””triple double quotes””” around docstrings.

def add1(a,b):
"""This function used to calculate subtraction of 2 numbers"""
return a-b

#Output: This function used to calculate subtraction of 2 numbers

Resources(Python Documentation):


Built-in types

Compound statements

Simple statements

iterable definition

Naming convention

Docstring conventions

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s