Scribd
Upload
24 views29 pages

Python Notes Start From Keywords

The document provides an overview of Python keywords and identifiers, detailing the 35 reserved keywords in Python 3.8, their types, and usage. It also explains the rules for writing identifiers, the importance of indentation and comments in Python, and introduces docstrings for documentation. Additionally, it covers built-in functions and various programming constructs that utilize these keywords.

Uploaded by

Yashi Bajpai
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
24 views29 pages

Python Notes Start From Keywords

The document provides an overview of Python keywords and identifiers, detailing the 35 reserved keywords in Python 3.8, their types, and usage. It also explains the rules for writing identifiers, the importance of indentation and comments in Python, and introduces docstrings for documentation. Additionally, it covers built-in functions and various programming constructs that utilize these keywords.

Uploaded by

Yashi Bajpai
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 29

Python Keywords and Identifiers

Python Keywords

Keywords are the reserved words in Python.

We cannot use a keyword as a variable name, function name or any other identifier. They are
used to define the syntax and structure of the Python language.
In Python, keywords are case sensitive.

According to version 3.8 in python, there are 35 keywords that it supports.


List of All Python Keywords

False await else import pass

None break except in raise

True class finally is return

and continue for lambda try

as def from nonlocal while

assert del global not with

async elif if or yield

Built – in Functions:

Python has several functions readily available for use once you install python on your PC. These
functions are called built-in functions.

Example of Python Keywords


>>> a = 'Invertis University'
>>> 'Ivertis' in a
True
How to Identify Keywords in Python?

There are numerous ways to identify these keywords. Some of them are:
1. Syntax Highlighting in IDEs:

Most of the good python friendly IDEs usually highlight keywords while writing codes. Hence
easily identifiable. E.g. Spyder, PyCharm, Vim, Visual Studio Code, etc.

2. Python REPL Commands:

Python comes installed with its interpreter, the interactive Read-Eval-Print Loop (REPL)
environment. Here you can obtain the keywords with the following command:

>>> help("keywords")

Here is a list of the Python keywords. Enter any keyword to get more help.

False class from or


None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for not

3. Python Libraries:

You can use libraries like kwlist, to get a list of keywords supported by the current version of
python you are running the code on.

>>> import keyword


>>> keyword.kwlist
['false', 'None', 'True', 'and', 'as', 'assert', 'async', ...
>>> len(keyword.kwlist)
35

4. iskeyword() function:

This function is part of the keyword package and is used to check if a term is a python keyword
or not.

>>> import keyword

>>> keyword.iskeyword("finally")

True

>>> keyword.iskeyword("hi")

False

Types of Keywords in Python


1. Value Keywords

These python keywords are used to denote values. These values are single values that can be
used multiple times and about the same object or variable. These keywords are the only
keywords that begin with a capital letter. Let's see the different types of value keywords
possessed by python:

Python Usage
Keyword
True Used for assigning the value to a variable or represents the result of a
boolean expression evaluating to true
False Used for assigning the value to a variable or represents the result of a
boolean expression evaluating to false
None Represents null, nil, none, undef, or undefined values in python

Example:

>>> 1 == 1

True

>>> True or False

True

>>> 3 > 7
False

>>> True and False

False

>>> None == 0

False

>>> x = None

>>> y = None

>>> x == y

True

2. Operator Keywords

Many operators are used as symbols in other languages; on the contrary, python uses keywords
for defining these operators. Their function is similar to their literal meaning, making coding in
python lucid to understand. Let’s take a look at these keywords:
Python Keyword Math Operator
and AND, Intersection(^)
or OR, Union(v)
not NOT, Negation (¬)
in CONTAINS, (∈)
is Checking Identity

Example:
True>>> True and False
False
>>> True or False
True
>>> not False
True
>>> a = 'scaler academy'
>>> 'scaler' in a
True
>>> True is True
True
3. Control Flow Keywords

These keywords help us perform conditional logic and execute code given certain conditions.
They are commonly used in forming a pipeline on how the code should perform based on
decision-making conditions and hence are essential in python. Let's see how these control flow
keywords work:

Python Syntax Function


Keyword
If if <expression>: <body Executes the body of code if the expression
of code> evaluates to True
elif elif Similar to ‘if’, ‘elif’ is used to execute the body of
<expression>:<body of code if the expression evaluates to True. You can
code> use ‘elif’ only after ‘if’ and multiple times. The
function literally translates to ‘ else – if ‘.
else else:<body of code> Executes the body of code when all of the above
expressions gets evaluated to False

Example:
# My Calculator
a = int( input() )
b = int(input())
print ('enter operation: +, -, *, /')
opt = input()

if opt == '+':
print (a+b)
elif opt == '-':
print (a-b)
elif opt == '*':
print (a*b)
elif opt == '/':
print (a/b)
else:
print ('invalid input')

Output:

>3
>5
>enter operation: +, -, *, /
>+
>8
4. Iteration Keywords

In python programming, these keywords indicate the type of looping initiated. Synonymous with
python’s ease of usage, the function of these keywords are literally the same as what we type.
Let's see the various types of iteration keywords:

Python Syntax Function


Keyword
for for <element> in <condition>:<body of Loops the element according to
code> the condition and executes the
body of code until the element is
unable to fit in the condition.
while while <condition>:<body of code> Executes body of code until
condition is evaluated to False
break for <element> in It exits from the loop if
<condition1> <condition2>:break condition2 evaluates to True .
Also works with while loop
continue for <element> in Continues the looping if
<condition1> <condition2>:continue condition2 evaluates to True.
Also works with while loop

Example:

# Display numbers 5 to 10

# for loop example


for x in range (5,11):
print (x)

#################################

n=5
# while loop example
while n < 11:
print(n)
n+=1

Output:

>5
>6
>7
>8
>9
>10
>5
>6
>7
>8
>9
>10

5. Structural Keywords

We use various keywords in python to define the structure of certain pieces of code. These
keywords are very often used to make code modular and understandable. Let’s take a look at
these functions and their uses:

A parameter is the variable listed inside the parentheses in the function definition

Python Syntax Function


Keyword
def def <name of Defines the beginning of a function in
function>(<parameters>):<body of python
code>
class class <name of Defines the beginning of a class in
class>(<extends>):<body of code> python
with with <context manager> as <variable>: We use with to run codes within the
<body of code> context manager functions. Like:
reading and writing of files
as import <module> as <alias> It is used to provide an alias to
modules, functions, etc.
pass def function() Used with functions classes, if-else
statements, etc. to indicate ‘no –
operation’ taking place
lambda lambda <arguments>:<function> It is used to create a nameless
function. It is an inline function that
does not contain a return statement.

6. Return Keywords

These keywords help us give out results of functions. They are essential keywords that help us
determine with what value must exist the function. Let’s take a look at its functionalities.

Python Syntax Function


Keyword
return def <function>() <statement> Returns the statement when this
function is called
yield >>> def <function>(): … yield <statementl> Through yield we can have
… yield <statement2>>>> test = <function() numerous return statements
>>> next(test)<statement1> >>> which will perform sequentially
next(test)<statement2> using the in built next()
function in python

7. Import Keywords

There are many useful packages and libraries in python that can be installed and used to form
your code that is not available in the installed version of python. These libraries can be used in
the codebase using the following keywords:

Python Syntax Function


Keyword
import import <module> Imports all functions of the specified modules to be
used in the python file’s execution.
from from <module> import The from keyword is used together with import to
<function> import specific functions from a module.
as import <module> as Import module with a alias
<alias>

8. Exception Handling Keywords

The following keywords are used to raise and catch exceptions in python. Let’s take a look at
these keywords and their functions:

Python Syntax Function


Keyword
try try: <statements> Initiates try block where the statement is
executed if there is no exception
except try:<statement1>except Specifies the type of exception that
<exception>: <statement2> should occur and what subsequent
statements should execute
raise raise <exception> This statement can be used to raise a
particular exception to any block of code
finally try: Finally defines a piece of code that should
<statements>finally:<statements> run no matter what
assert assert <expression> An assert statement will result in
performing no operation if the expression
is executed as truthful, and it will raise an
AssertionError if the expression is
executed as False.
9. Asynchronous Programming Keywords

In python, to perform asynchronous programming, we used keywords defining these functions:


async and await. Let’s take a look

Python Syntax Function


Keyword
async async def Indicates that the following
<function>(<params>):<statements> function needs to run
asynchronously
await await <some async function call> OR It is used in asynchronous
<var> = await <some async function call> functions to specify a point in the
function where control is given
back to the event loop for other
functions to run

10. Variable Handling Keywords

These keywords are used to do manipulations on python variables. Let's take a look at their
functionality and syntax.

Python Syntax Function


Keyword
del del <variable> The keyword is used to reset the variable to an unused one
global global The keyword specifies that the variable is pulled from global
<variable> scope
nonlocal nonlocal Similar to global, this keyword specifies that the variable has
<variable> been pulled from parent scope

What are Python Identifiers?


An identifier is a name given to entities like class, functions, variables, etc. It helps to
differentiate one entity from another.

Rules for writing identifiers

1. Identifiers can be a combination of letters in lowercase (a to z) or uppercase (A to Z) or


digits (0 to 9) or an underscore _. Names like myClass, var_1 and print_this_to_screen,
all are valid example.
2. An identifier cannot start with a digit. 1variable is invalid, but variable1 is a valid name.
3. Keywords cannot be used as identifiers.
global = 1

Output

File "<interactive input>", line 1


global = 1
^
SyntaxError: invalid syntax

4. We cannot use special symbols like !, @, #, $, % etc. in our identifier.

a@ = 0

Output

File "<interactive input>", line 1


a@ = 0
^
SyntaxError: invalid syntax

5. An identifier can be of any length.


Example of Python Identifiers
Things to Remember

Python is a case-sensitive language. This means, Variable and variable are not the same.
Always give the identifiers a name that makes sense. While c = 10 is a valid name, writing count
= 10 would make more sense, and it would be easier to figure out what it represents when you
look at your code after a long gap.
Multiple words can be separated using an underscore, like this_is_a_long_variable.
Python Statement, Indentation and Comments

Python Statement

Instructions that a Python interpreter can execute are called statements. For example, a = 1 is an
assignment statement. if statement, for statement, while statement, etc. are other kinds of
statements which will be discussed later.
Multi-line statement

In Python, the end of a statement is marked by a newline character. But we can make a statement
extend over multiple lines with the line continuation character (\). For example:

a=1+2+3+\
4+5+6+\
7+8+9

This is an explicit line continuation. In Python, line continuation is implied inside


parentheses ( ), brackets [ ], and braces { }. For instance, we can implement the above multi-line
statement as:

a = (1 + 2 + 3 +
4+5+6+
7 + 8 + 9)

Here, the surrounding parentheses ( ) do the line continuation implicitly. Same is the case
with [ ] and { }. For example:

colors = ['red',
'blue',
'green']

We can also put multiple statements in a single line using semicolons, as follows:

a = 1; b = 2; c = 3
Python Indentation

Most of the programming languages like C, C++, and Java use braces { } to define a block of
code. Python, however, uses indentation.
A code block (body of a function, loop, etc.) starts with indentation and ends with the first un-
indented line. The amount of indentation is up to you, but it must be consistent throughout that
block.
Generally, four whitespaces are used for indentation and are preferred over tabs. Here is an
example.

for i in range(1,11):
print(i)
if i == 5:
break
Run Code

The enforcement of indentation in Python makes the code look neat and clean. This results in
Python programs that look similar and consistent.

Indentation can be ignored in line continuation, but it's always a good idea to indent. It makes the
code more readable. For example:

if True:
print('Hello')
a=5

and

if True: print('Hello'); a = 5

both are valid and do the same thing, but the former style is clearer.

Incorrect indentation will result in Indentation Error.


Python Comments
Comments are very important while writing a program. They describe what is going on inside a
program, so that a person looking at the source code does not have a hard time figuring it out.

You might forget the key details of the program you just wrote in a month's time. So taking the
time to explain these concepts in the form of comments is always fruitful.

In Python, we use the hash (#) symbol to start writing a comment.


It extends up to the newline character. Comments are for programmers to better understand a
program. Python Interpreter ignores comments.

#This is a comment
#print out Hello
print('Hello')
Run Code

Multi-line comments

We can have comments that extend up to multiple lines. One way is to use the hash(#) symbol at
the beginning of each line. For example:

#This is a long comment


#and it extends
#to multiple lines

Another way of doing this is to use triple quotes, either ''' or """.
These triple quotes are generally used for multi-line strings. But they can be used as a multi-line
comment as well. Unless they are not docstrings, they do not generate any extra code.

"""This is also a
perfect example of
multi-line comments"""

Docstrings in Python

A docstring is short for documentation string.


Python docstrings (documentation strings) are the string literals that appear right after the
definition of a function, method, class, or module.
Triple quotes are used while writing docstrings. For example:

def double(num):
"""Function to double the value"""
return 2*num

Docstrings appear right after the definition of a function, class, or a module. This separates
docstrings from multiline comments using triple quotes.

The docstrings are associated with the object as their __doc__ attribute.
So, we can access the docstrings of the above function with the following lines of code:

def double(num):
"""Function to double the value"""
return 2*num
print(double.__doc__)
Run Code

Output

Function to double the value


Python Variables, Constants and Literals

Python Variables

A variable is a named location used to store data in the memory. It is helpful to think of variables
as a container that holds data that can be changed later in the program. For example,

number = 10

Here, we have created a variable named number. We have assigned the value 10 to the variable.
You can think of variables as a bag to store books in it and that book can be replaced at any time.

number = 10
number = 1.1

Initially, the value of number was 10. Later, it was changed to 1.1.
Note: In Python, we don’t actually assign value to the variables. Instead, Python gives the
reference of the object(value) to the variable.

Assigning values to Variables in Python

As you can see from the above example, you can use the assignment operator = to assign a value
to a variable.
Example 1: Declaring and assigning value to a variable

website = "apple.com"
print(website)
Run Code

Output

apple.com

In the above program, we assigned a value apple.com to the variable website. Then, we printed
out the value assigned to website i.e. apple.com
Note: Python is a type-inferred language, so you don't have to explicitly define the variable type.
It automatically knows that apple.com is a string and declares the website variable as a string.
Example 2: Changing the value of a variable

website = "apple.com"
print(website)

# assigning a new value to website


website = "programiz.com"

print(website)
Run Code

Output

apple.com
programiz.com

In the above program, we have assigned apple.com to the website variable initially. Then, the
value is changed to programiz.com.

Example 3: Assigning multiple values to multiple variables

a, b, c = 5, 3.2, "Hello"

print (a)
print (b)
print (c)
Run Code

If we want to assign the same value to multiple variables at once, we can do this as:

x = y = z = "same"

print (x)
print (y)
print (z)
Run Code
The second program assigns the same string to all the three variables x, y and z.

Constants

A constant is a type of variable whose value cannot be changed. It is helpful to think of constants
as containers that hold information which cannot be changed later.

You can think of constants as a bag to store some books which cannot be replaced once placed
inside the bag.

Assigning value to constant in Python

In Python, constants are usually declared and assigned in a module. Here, the module is a new
file containing variables, functions, etc which is imported to the main file. Inside the module,
constants are written in all capital letters and underscores separating the words.

Example 3: Declaring and assigning value to a constant

Create a constant.py:

PI = 3.14
GRAVITY = 9.8

Create a main.py:

import constant

print(constant.PI)
print(constant.GRAVITY)

Output

3.14
9.8

In the above program, we create a constant.py module file. Then, we assign the constant value
to PI and GRAVITY. After that, we create a main.py file and import the constant module.
Finally, we print the constant value.
Note: In reality, we don't use constants in Python. Naming them in all capital letters is a
convention to separate them from variables, however, it does not actually prevent reassignment

Rules and Naming Convention for Variables and constants

1. Constant and variable names should have a combination of letters in lowercase (a to z) or


uppercase (A to Z) or digits (0 to 9) or an underscore (_). For example:

2. snake_case

3. MACRO_CASE

4. camelCase

CapWords

5. Create a name that makes sense. For example, vowel makes more sense than v.
6. If you want to create a variable name having two words, use underscore to separate them. For
example:

7. my_name

current_salary

8. Use capital letters possible to declare a constant. For example:


9. PI

10. G

11. MASS

12. SPEED_OF_LIGHT

TEMP

13. Never use special symbols like !, @, #, $, %, etc.

14. Don't start a variable name with a digit.

Literals in Python

Literals in Python is defined as the raw data assigned to variables or constants while
programming. We mainly have five types of literals which includes string literals, numeric
literals, boolean literals, literal collections and a special literal None.
Introduction to Literals in Python

Be it a friend, family member or a cousin you’re really close to, we all need a constant in life.
Well, the same applies to programming languages like Python!

Jokes apart, even if we speak mathematically, a constant can be defined as-

“A constant can be defined as an entity that has a fixed value or an entity whose value does not
vary.”
Well, we luckily have the concept of constants in Python as well! They are known as literals in
Python.

Python literals are quantities/ notations whose value does not change during the execution of a
program.

In this article, we will be deep-diving into what are literals in Python and the types of literal in
Python.

Literals in Python are nothing but a succinct way of representing the data types. In simpler
words, it is the way to represent a fixed value in our source code. They can either be numbers,
text, boolean or any other form of data.

Types of Literals in Python

Python literals are of several types, and their usage is also pretty varied. So let’s check them out
one by one.

There are five types of literal in Python, which are as follows-

 String Literals
 Numeric Literals
 Boolean Literals
 Literal Collections
 Special Literals

And these five types again have certain subtypes, which we will discuss in-depth and see their
implementation in Python.
1. String Literals in Python

Let’s discuss string literals in Python!

Creating a string literal in Python is really easy- enclose the text or the group of characters in
single, double or triple quotes. Using triple quotes also allows us to write multi-line strings.

Hence, we can say that there are two types of string literals in Python-

Single-line String

String literals that are enclosed within single quotes (‘’) are known as single-line strings.

Now, let’s look at an example to understand how they work-

#string literals
#single line literal
single_quotes_string='Scaler Academy'
double_quotes_string="Hello World"
print(single_quotes_string)
print(double_quotes_string)

We have successfully created a string using single quotes and double quotes in the above code
snippet. The output of it is-

Scaler Academy
Hello World

Multi-line String

A collection of characters or a string that goes on for multiple lines is a multi-line string.

These kinds of strings are again implemented in two types-

a) Adding backslash at the end of every line-

We can enable multi-line strings in Python by adding a backslash at the end of every line.

Let’s see how it's done-

#string literals
#multi line literal
str="Welcome\
to\
Scaler\
Academy"
print(str)
The output of this will be-

WelcometoScalerAcademy

b) Using triple quotes-

Triple quotes at the beginning and end of the string literally will allow us to create a multi-line
string in Python easily!

Let’s see the code for it-

#string literals
#multi line literal
str="""Welcome
to
Scaler
Academy"""
print(str)

The output will be-

Welcome
to
Scaler
Academy

2. Numeric Literals in Python

Numerical literals in Python are those literals that contain digits only and are immutable.
They are of four types-

Integer

The numerical literals that are zero, positive or negative natural numbers and contain no decimal
points are integers.

The different types of integers are-

 Decimal- It contains digits from 0 to 9. The base for decimal values is 10.
 Binary- It contains only two digits- 0 and 1. The base for binary values is 2 and prefixed
with “0b”.
 Octal- It contains the digits from 0 to 7. The base for octal values is 8. In Python, such
values are prefixed with “0o”.
 Hexadecimal- It contains digits from 0 to 9 and alphabets from A to F.

Now, let’s see some examples-

# integer literal
#positive whole numbers
x = 2586
#negative whole numbers
y = -9856
# binary literal
a = 0b10101
# decimal literal
b = 505
# octal literal
c = 0o350
# hexadecimal literal
d = 0x12b
print (x,y)
print(a, b, c, d)

Check out the output for this-

2586 -9856
21 505 232 299

Float

The floating-point literals are also known as real literals. Unlike integers, these contain decimal
points.
Float literals are primarily of two types-

A. Fractional- Fractional literals contain both whole numbers and decimal points.

An example of fractional literals will look like this-

Example

print(78.256)

Output

78.256

B. Exponential- Exponential literals in Python are represented in the powers of 10. The power
of 10 is represented by e or E. An exponential literal has two parts- the mantissa and the
exponent.

Note:

 Mantissa-The digits before the symbol E in an exponential literal is known as the


mantissa. In computing, it denotes the significant digits of the floating-point numbers.
 Exponent- The digits after the symbol E in an exponential literal are the exponent. It
denotes where the decimal point should be placed.

Let’s look at an example-

Example

print(2.537E5)

Output

253700.0

Complex

Complex literals are represented by A+Bj. Over here, A is the real part. And the entire B part,
along with j, is the imaginary or complex part. j here represents the square root of -1, which is
nothing but the iota or i we use in Mathematics.

# complex literal
a=7 + 8j
b=5j
print(a)
print(b)
The output of the code snippet will be-

(7+8j)
5j
Long

Long literals were nothing but integers with unlimited length. From Python 2.2 and onwards, the
integers that used to overflow were automatically converted into long ints. Since Python 3.0, the
long literal has been dropped. What was the long data type in Python 2 is now the standard int
type in Python 3.

Long literals used to be represented with a suffix- l or L. The usage of L was strongly
recommended as l looked a lot like the digit 1.

Check out the following example to see how it was denoted-

Example

#usage long literal before it was depreciated


x=037467L
print(x)

Note– The code snippet was executed using Python 1.8. Output

Success #stdin

Success #stdin #stdout 0.01s 7320KB


16183

3. Boolean Literals in Python

Boolean literals in Python are pretty straight-forward and have only two values-

 True- True represents the value 1.


 False-False represents the value 0.

Let’s see an example-

#boolean literals
x = (1 == 1)
y = (7 == False)
print("x is", x)
print("y is", y)

The expected output is-

x is True
y is False

We can see that we used boolean literals for comparison and based on the conditions, we
received the outputs True and False, respectively.

4. Special Literals in Python

Python literals have one special literal known as None. This literal in Python is used to signify
that a particular field is not created.

Python will print None as output when we print the variable with no value assigned to it. None is
also used for end of lists in Python.

Example

#special literals
val=None
print(val)

Output

None

5. Literal Collections in Python

If we wish to work with more than one value, then we can go for literal collections in Python.
Literal collections in Python are of four types-

List Literals

Lists are a collection of data declared using the square brackets([]), and commas separate the
elements of the list (,). This data can be of different types. Another important thing to know
about lists is that they are mutable.

Now let’s see an implementation-

# list literals
numbers = [10, 20, 30, 40, 50]
names = ['John', 'Jake', 'Jason', 25]
print(numbers)
print(names)

Output

[10, 20, 30, 40, 50]


['John', 'Jake', 'Jason', 25]
Tuple Literals

The literals that are declared using round brackets and can hold any data type are tuples.
Commas separate the elements of tuples. However, unlike lists, tuples are immutable.

Let’s check out a code snippet on tuples-

# tuple literals
even_numbers = (2, 4, 6, 8)
vowels=('a','e','i','o','u')
print(even_numbers)
print(vowels)

Output

(2, 4, 6, 8)
('a', 'e', 'i', 'o', 'u')

Dictionary Literals

Dictionary is a collection of data that stores value in a key-value format. These are enclosed in
curly brackets and separated by commas. Dictionaries are mutable and can also contain different
types of data.

Check out the below code snippet that shows how a dictionary works-

# dictionary literals
my_dict = {'a': 'apple', 'b': 'bat', 'c': 'car'}
print(my_dict)

Output

{'a': 'apple', 'b': 'bat', 'c': 'car'}

Set Literals

Set literals are a collection of unordered data that cannot be modified. It is enclosed within curly
brackets and separated by commas.

Let’s see the code for this-

#set literals
vowels = {'a', 'e', 'i', 'o', 'u'}
print(vowels)
Output

{'o', 'e', 'a', 'u', 'i'}

You might also like