Introduc on to Python

Python: A Versatile and User-Friendly Language

Python is a high-level, general-purpose programming language renowned for its simplicity

and readability. Created by Guido van Rossum in the late 1980s, Python has gained immense
popularity due to its elegant syntax and powerful features.

Key Characteristics:

 Readability: Python's syntax emphasizes code clarity, reducing the need for
excessive punctuation and brackets.
 Interpreted Language: Python code is executed line by line, making it easier to
debug and test.
 Dynamic Typing: You don't need to declare variable types explicitly, as Python
automatically infers them at runtime.
 Standard Library: Python comes with a rich standard library offering modules for
various tasks, including file I/O, network programming, web development, and more.
 Cross-Platform Compatibility: Python runs on Windows, macOS, Linux, and other
operating systems.
 Large and Active Community: A strong community provides extensive support,
libraries, and frameworks.

Why Python is Popular:

 Rapid Development: Python's concise syntax and powerful libraries allow for faster
development cycles.
 Versatility: Python is used in a wide range of applications, including web
development, data science, machine learning, artificial intelligence, and automation.
 Easy to Learn: Python's gentle learning curve makes it accessible to beginners.
 Strong Ecosystem: A vast ecosystem of libraries and frameworks, such as Django,
Flask, NumPy, Pandas, and TensorFlow, extends Python's capabilities.

Key Features of Python Programming Language

Python is a versatile and powerful programming language that offers a range of features that
make it a popular choice for developers. Here are some of its key features:

Readability and Simplicity:

 Clean Syntax: Python's syntax is designed to be easy to read and write, reducing the
learning curve.
 Indentation-Based: Indentation is used to define code blocks, making code more
structured and visually appealing.

Interpreted Language:
  No Compilation: Python code is executed line by line, making it easier to debug and
test.
 Rapid Development: This feature allows for faster development cycles.

Dynamic Typing:

 Flexible Variable Types: You don't need to declare variable types explicitly, making
code more concise.
 Adaptable to Changing Data: Python can handle different data types seamlessly.

Standard Library:

 Rich Built-in Functions: Python comes with a comprehensive standard library,

offering modules for various tasks like file I/O, network programming, web
development, and more.
 Extensive Functionality: This reduces the need for external libraries in many cases.

Cross-Platform Compatibility:

 Runs on Multiple Platforms: Python code can be executed on Windows, macOS,

Linux, and other operating systems.

Object-Oriented Programming (OOP):

 Encapsulation, Inheritance, Polymorphism: Python supports OOP principles,

allowing you to create modular and reusable code.

Functional Programming:

 Higher-Order Functions and Lambdas: Python supports functional programming

paradigms, enabling you to write concise and elegant code.

Large and Active Community:

 Extensive Support: A large and active community provides abundant resources,

libraries, and frameworks.
 Continuous Development: The Python community actively contributes to its growth
and improvement.

Versatility:

 Wide Range of Applications: Python is used in various domains, including web

development, data science, machine learning, artificial intelligence, automation, and
more.

These features combined make Python a powerful and flexible language, suitable for both
beginners and experienced programmers.
 IDLE: Python's Integrated Development Environment

IDLE (Integrated Development Environment) is a simple yet powerful IDE that comes
bundled with Python. It's a great tool for beginners and experienced Python programmers
alike.

Key Features of IDLE:

 Python Shell: This is an interactive interpreter where you can execute Python code
line by line. It's perfect for testing small code snippets and learning Python
interactively.
 Text Editor: A multi-window text editor with features like syntax highlighting, auto-
completion, and code indentation, making it easier to write and read Python code.
 Debugger: A debugger to help you step through your code, inspect variables, and
identify errors.
 File Explorer: A simple file manager to navigate and open Python files.

How to Use IDLE:

1. Launch IDLE:
o On Windows, you can usually find it in the Start menu.
o On macOS, it's typically in the Applications folder.
o On Linux, you can open it from the terminal using the idle command.
2. Python Shell:
o Write Python code directly in the shell and press Enter to execute it.
o Use print() to display output.
3. Text Editor:
o Create a new file and write your Python code.
o Save the file with a .py extension.
o Run the script by pressing F5 or selecting "Run Module" from the Run menu.

Benefits of Using IDLE:

 Simple and User-Friendly: IDLE is easy to learn and use, especially for beginners.
 Cross-Platform Compatibility: It works on Windows, macOS, and Linux.
 Integrated Features: The integrated editor, shell, and debugger provide a
comprehensive development environment.
 Free and Open-Source: IDLE is freely available and open-source.

While IDLE is a good starting point for many Python programmers, there are more advanced
IDEs available like PyCharm, Visual Studio Code, and Thonny, which offer more features
and customization options. However, for basic Python development and learning, IDLE is a
solid choice.

Python Interpreter: The Engine Behind the Code

A Python interpreter is a program that reads and executes Python code line by line. It acts as
a bridge between your code and the computer's hardware, translating your instructions into
machine-understandable language.
How It Works:

1. Source Code Input: You write Python code in a text editor, saving it as a .py file.
2. Interpreter Execution: When you run the Python script, the interpreter reads the
code line by line.
3. Code Translation: It translates each line into bytecode, a lower-level representation
that's more efficient for the computer to process.
4. Bytecode Execution: The interpreter executes the bytecode instructions, performing
the actions specified in your code.
5. Output Generation: The results of the execution are displayed on the console or
saved to a file, depending on your code's purpose.

Key Points:

 Interactive Mode: You can also use the Python interpreter interactively. By typing
Python commands directly into the interpreter, you can get immediate results.
 Efficiency: While Python is interpreted, it's often optimized for performance,
especially with the use of just-in-time (JIT) compilation techniques.
 Cross-Platform Compatibility: Python interpreters are available for various
operating systems, making Python a highly portable language.

Popular Python Interpreters:

 CPython: The official Python implementation, written in C.

 PyPy: A high-performance Python implementation that uses just-in-time compilation.
 Jython: A Python implementation that runs on the Java Virtual Machine.
 IronPython: A Python implementation that runs on the .NET Common Language
Runtime.

Python Identifiers

In Python, identifiers are names given to entities like variables, functions, classes, modules,
etc. They are used to uniquely identify these entities within a program.

Rules for Python Identifiers:

1. Case-Sensitive: Python is case-sensitive, so myVariable and MyVariable are

different identifiers.
2. Start with a Letter or Underscore: Identifiers must begin with a letter (a-z, A-Z) or
an underscore (_).
3. Consist of Letters, Digits, and Underscores: After the initial letter or underscore,
you can use letters, digits (0-9), or underscores.
4. No Special Symbols: Special symbols like !, @, #, $, %, etc., are not allowed.
5. Keywords are Reserved: You cannot use Python keywords as identifiers. Keywords
are reserved words with special meanings in Python, such as if, else, for, while,
etc.

Best Practices for Naming Identifiers:

  Meaningful Names: Use names that reflect the purpose of the identifier. For
example, age is better than x.
 Use Underscores for Word Separation: Use underscores to separate words in long
identifiers, like my_variable_name.
 Avoid Single-Letter Names: Unless it's a common convention (like i for loop
counters), avoid using single-letter names.
 Consistent Naming Conventions: Stick to a consistent naming convention
throughout your code. Common conventions include snake_case and camelCase.

Example of Valid and Invalid Identifiers:

Valid Identifiers:

Python
myVariable
_my_variable
myVariable2
MY_CONSTANT

Invalid Identifiers:

Python
2myVariable # Starts with a digit
my-variable # Contains a hyphen
class # Keyword

Python Keywords

Python keywords are reserved words that have specific meanings in the language. They
cannot be used as variable names, function names, or other identifiers. Here's a list of 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

These keywords are essential for controlling the flow of your Python programs, defining
functions, classes, and modules, and handling exceptions and errors.

Remember:

 Keywords are case-sensitive.

 You cannot redefine or create new keywords.
 Using keywords as identifiers will result in syntax errors.
 Python Variables

In Python, variables are used to store data values. You don't need to declare a variable's data
type explicitly; Python automatically assigns it based on the value assigned to it.

How to Declare and Assign Variables:

Python
variable_name = value

Example:

Python
x = 10 # Integer
y = 3.14 # Float
name = "Alice" # String
is_student = True # Boolean

Dynamic Typing:

Python is dynamically typed, meaning the data type of a variable can change during the
execution of a program. For example:

Python
x = 10 # x is an integer
x = "Hello" # x is now a string

Basic Data Types in Python:

 Numbers:
o Integers (e.g., 10, -5, 0)
o Floating-point numbers (e.g., 3.14, -2.5)
o Complex numbers (e.g., 2+3j)
 Strings:
o Sequences of characters enclosed in single quotes, double quotes, or triple
quotes (e.g., 'Hello', "World", '''Multiline string''')
 Boolean:
o Represents True or False values
 Lists:
o Ordered collections of items, enclosed in square brackets (e.g., [1, 2, 3,
'apple'])
 Tuples:
o Ordered, immutable collections of items, enclosed in parentheses (e.g., (1, 2,
3))
 Sets:
o Unordered collections of unique items, enclosed in curly braces (e.g., {1, 2,
3})
 Dictionaries:
o Unordered collections of key-value pairs, enclosed in curly braces (e.g.,
{'name': 'Alice', 'age': 30})
Key Points:

 Variable names should be descriptive and follow naming conventions (e.g.,

snake_case).
 Use meaningful variable names to improve code readability.
 Avoid using reserved keywords as variable names.
 Python is case-sensitive, so myVariable and MyVariable are different variables.

Python Data Types

Python is a dynamically typed language, meaning you don't need to explicitly declare the data
type of a variable. The interpreter automatically infers the data type based on the assigned
value.

Here are the fundamental data types in Python:

1. Numbers:

 Integer: Whole numbers (e.g., 10, -5, 0)

 Float: Real numbers with decimal points (e.g., 3.14, -2.5)
 Complex: Complex numbers with real and imaginary parts (e.g., 2+3j)

2. Strings:

 Sequences of characters enclosed in single quotes, double quotes, or triple quotes

(e.g., 'Hello', "World", '''Multiline string''')

3. Boolean:

 Represents True or False values

4. List:

 Ordered collection of items, enclosed in square brackets (e.g., [1, 2, 3, 'apple'])

 Mutable: Elements can be changed, added, or removed.

5. Tuple:

 Ordered collection of items, enclosed in parentheses (e.g., (1, 2, 3))

 Immutable: Elements cannot be changed after creation.

6. Set:

 Unordered collection of unique items, enclosed in curly braces (e.g., {1, 2, 3})

7. Dictionary:
  Unordered collection of key-value pairs, enclosed in curly braces (e.g., {'name':
'Alice', 'age': 30})

Example:

Python
x = 10 # Integer
y = 3.14 # Float
name = "Alice" # String
is_student = True # Boolean
my_list = [1, 2, 3, "apple"] # List
my_tuple = (1, 2, 3) # Tuple
my_set = {1, 2, 3} # Set
my_dict = {'name': 'Alice', 'age': 30} # Dictionary

Python Operators

Operators are symbols that perform specific operations on variables and values. Python
supports a wide range of operators, categorized as follows:

1. Arithmetic Operators:

 +: Addition
 -: Subtraction
 *: Multiplication
 /: Division
 %: Modulus (remainder after division)
 //: Floor division (integer division)
 **: Exponentiation

2. Comparison Operators:

 ==: Equal to
 !=: Not equal to
 >: Greater than
 <: Less than
 >=: Greater than or equal to
 <=: Less than or equal to

3. Logical Operators:

 and: Logical AND

 or: Logical OR
 not: Logical NOT

4. Assignment Operators:

 =: Assignment
 +=: Add and assign
  -=: Subtract and assign
 *=: Multiply and assign
 /=: Divide and assign
 %=: Modulus and assign
 //=: Floor division and assign
 **=: Exponentiation and assign

5. Bitwise Operators:

 &: Bitwise AND

 |: Bitwise OR
 ^: Bitwise XOR
 ~: Bitwise NOT
 <<: Left shift
 >>: Right shift

6. Identity Operators:

 is: Checks if two objects are the same object

 is not: Checks if two objects are not the same object

7. Membership Operators:

 in: Checks if a value is present in a sequence

 not in: Checks if a value is not present in a sequence

Example:

Python
x = 10
y = 5

# Arithmetic operations
print(x + y) # Output: 15
print(x - y) # Output: 5
print(x * y) # Output: 50
print(x / y) # Output: 2.0
print(x % y) # Output: 0
print(x // y) # Output: 2
print(x ** y) # Output: 100000

# Comparison operations
print(x == y) # Output: False
print(x != y) # Output: True
print(x > y) # Output: True
print(x < y) # Output: False
print(x >= y) # Output: True
print(x <= y) # Output: False

# Logical operations
print(x > 5 and y < 10) # Output: True
print(x < 5 or y > 5) # Output: True
print(not (x == y)) # Output: True
 Operator Precedence and Associativity in Python

Operator Precedence

Operator precedence determines the order in which operations are performed. Operators with
higher precedence are evaluated first. Here's the precedence order from highest to lowest:

1. Parentheses: Used to group expressions and override the default precedence.

2. Exponentiation: **
3. Unary operators: +, -, ~ (bitwise NOT)
4. Multiplication, division, floor division, modulo: *, /, //, %
5. Addition, subtraction: +, -
6. Shift operators: <<, >>
7. Bitwise AND: &
8. Bitwise XOR: ^
9. Bitwise OR: |
10. Comparison operators: ==, !=, <, >, <=, >=
11. Logical NOT: not
12. Logical AND: and
13. Logical OR: or

Operator Associativity

Operator associativity determines the order of evaluation when two operators of the same
precedence appear in an expression. It can be left-to-right or right-to-left.

 Left-to-right Associativity: Most operators in Python are left-associative, meaning

they are evaluated from left to right. For example:

Python

5 - 3 + 2

This is evaluated as (5 - 3) + 2, resulting in 4.

 Right-to-left Associativity: Exponentiation (**) is right-associative. For example:

Python

2 ** 3 ** 2

This is evaluated as 2 ** (3 ** 2), resulting in 512.

Example:

Python
x = 10
y = 5
z = 2

result = x + y * z ** 2

In this expression, the operations are evaluated in the following order:

1. z ** 2 (exponentiation, right-to-left)
2. y * (z ** 2) (multiplication)
3. x + (y * (z ** 2)) (addition)

Expression

An expression in Python is a combination of values, variables, operators, and function calls

that evaluates to a single value. It's a fundamental building block in Python programming,
used to perform calculations, make comparisons, and construct more complex expressions.

Types of Expressions:

1. Arithmetic Expressions:
o Involve arithmetic operators like +, -, *, /, %, //, and **.

Python

result = 2 + 3 * 4

2. Comparison Expressions:
o Use comparison operators like ==, !=, <, >, <=, and >=.

Python

is_equal = 5 == 5

3. Logical Expressions:
o Employ logical operators like and, or, and not.

Python

is_true = (x > 10) and (y < 20)

4. Assignment Expressions:
o Assign values to variables using the = operator.

Python

x = 10
y = x + 5
 5. Function Calls:
o Invoke functions to perform specific tasks.

Python

result = math.sqrt(25)

6. List Comprehensions:
o Create lists in a concise way.

Python

squares = [x**2 for x in range(5)]

Input () function in Python

In Python, we use the input() function to take input from the user. This function pauses the
program execution until the user enters a value and presses the Enter key.

Basic Syntax:

Python
variable_name = input(prompt)

Here:

 variable_name: Stores the input value.

 prompt: An optional string displayed to the user to indicate what kind of input is
expected.

Important Note:

The input() function always returns a string, even if the user enters a number. To use the
input as a number (integer or float), you need to convert it using the int() or float()
function.

Example:

Python
name = input("Enter your name: ")
age = int(input("Enter your age: "))

print("Hello,", name)
print("Your age is", age)
Use code

Explanation:
 1. name = input("Enter your name: "): This line prompts the user to enter their
name. The input is stored as a string in the name variable.
2. age = int(input("Enter your age: ")): This line prompts the user to enter their
age. The input is first taken as a string, and then converted to an integer using the
int() function. The integer value is stored in the age variable.
3. The final two lines print the user's name and age.

The print() Function in Python

The print() function is a versatile built-in function in Python used to display output to the
console. It's one of the most commonly used functions for debugging, providing user
feedback, and generating reports.

Basic Usage:

Python
print("Hello, world!")

This simple code will print the message "Hello, world!" to the console.

Printing Multiple Values:

You can print multiple values separated by commas:

Python
name = "Alice"
age = 30
print("Name:", name, "Age:", age)

Output:

Name: Alice Age: 30

Comments in Python

Comments are lines of code that are ignored by the Python interpreter. They are used to
explain the code, improve readability, and make it easier to understand for both the
programmer and others who might read the code.

Types of Comments in Python:

1. Single-line Comments:
o These comments start with a # symbol.

Python

# This is a single-line comment

 x = 10 # This is a comment at the end of a line

2. Multi-line Comments:
o While Python doesn't have a specific syntax for multi-line comments like
some other languages, you can use multi-line strings:

Python

"""
This is a multi-line comment.
It can span multiple lines.
"""

The type() Function in Python

The type() function in Python is used to determine the data type of an object. It takes an
object as input and returns the type of that object.

Syntax:

Python
type(object)

Example:

Python
x = 10
y = 3.14
name = "Alice"
my_list = [1, 2, 3]

print(type(x)) # Output: <class 'int'>

print(type(y)) # Output: <class 'float'>
print(type(name)) # Output: <class 'str'>
print(type(my_list)) # Output: <class 'list'>

Common Data Types and Their Output:

Data Type type() Output

Integer <class 'int'>
Float <class 'float'>
String <class 'str'>
List <class 'list'>
Tuple <class 'tuple'>
Set <class 'set'>
Dictionary <class 'dict'>
 The eval() Function in Python

The eval() function in Python evaluates a string as a Python expression. It's a powerful tool
but should be used with caution, as it can potentially execute arbitrary code.

Basic Usage:

Python
expression = "2 + 3 * 4"
result = eval(expression)
print(result) # Output: 14

In this example:

1. The string "2 + 3 * 4" is passed to the eval() function.

2. The eval() function interprets the string as a mathematical expression.
3. The expression is evaluated, and the result (14) is assigned to the result variable.