Introduction to Python

Introduction to Python

• Python is a versatile, high-level programming language, known for being:
  • Interpreted
  • Interactive
  • Object-oriented
• Guido van Rossum created it between 1985 and 1990
• Released in 2000
• It gets its name from "Monty Python's Flying Circus"

Key Features

• Easy to Learn: Simple syntax and structure
• Easy to Maintain: Source code is easy to maintain
• Portable: Runs on various platforms with the same interface
• Interpreted: No need to compile before execution
• Extensible: Python can be embedded within other languages like C, C++, and Java
• Free and Open Source: Freely distributable, readable, and editable
• High Level: Programmers can focus on problem-solving without low-level details
• Scalable: Well-structured and supports large programs

Applications

• Used in:
  • Bit Torrent file sharing
  • Google search engine
  • YouTube
  • Intel
  • Cisco
  • HP
  • IBM
  • i-Robot
  • NASA
  • Facebook
  • Dropbox

Python Interpreter

• Interpreter executes high-level code line by line
• Compiler translates high-level code into low-level language all at once
• Interpreter vs Compiler:
  • Interpreter: Takes single instructions as input; no intermediate object code is generated; conditional control statements execute slower; less memory required, errors arise for every instruction; Example: Python
  • Compiler: Takes the entire program as input; generates intermediate object code; conditional control statements execute faster; more memory required, errors displayed after the entire program is checked; Example: C Compiler

Modes of Python Interpreter

• Two modes exist:
  • Interactive mode
  • Script mode
• Interactive Mode: Allows direct interaction with the OS, where statements are executed and results are displayed immediately
  • Good for learning, experimentation, and testing small code snippets
  • Statements can't be saved and must be retyped for re-running
• Script Mode: Used to write Python programs in a file and then use the interpreter to execute the file's content
  • Scripts can be saved for future use with the ".py" extension
• Integrated Development Learning Environment (IDLE): A Python-written graphical user interface that comes with the default Python implementation
  • It features a multi-window text editor supporting syntax highlighting and auto-completion with smart indentation

Values

• Represented as letters, numbers, or strings (e.g., 2, 42.0, 'Hello, World!')
• Each value belongs to a specific data type

Data Types

• Every value in Python has a data type which is a set of values with allowable operations
• Four standard data types:

Numbers

• Numerical values are stored, with this data type being immutable
• Python supports:
  • Integers
  • Floating-point numbers
  • Complex numbers

Sequence

• An ordered collection of items indexed by positive integers
• Combines mutable and immutable data types

Strings

• Sequence of characters (letters, numbers, special symbols)
• Indicated by:
  • Single quotes (' ')
  • Double quotes (" ")
  • Triple quotes (""" """)
• Individual characters are accessed via subscript (index) using indexing and slicing
• Strings are immutable (contents cannot be altered after creation)
• Positive indexing accesses the string from the beginning
• Negative indexing accesses the string from the end
• Subscript retrieves the first element
• Common string operations include:
  • Indexing
  • Slicing
  • Concatenation
  • Repetitions
  • Membership

Lists

• An ordered sequence of items between square brackets [ ], with values called elements/items
• Lists can hold items of different data types
• Common operations include:
  • Indexing
  • Slicing
  • Concatenation
  • Repetitions
  • Updation
  • Insertion
  • Deletion

Tuples

• Similar to lists, tuples are an ordered sequence of items
• Tuples are immutable
• Encased in parentheses () instead of square brackets
• Tuples are faster than lists
• Tuples protect data from accidental changes
• Used as keys in dictionaries, unlike lists

Dictionaries

• Lists are ordered sets of objects, dictionaries are unordered sets
• Created using curly brackets {}
• Items can be accessed via keys, not position
• A key of the dictionary is associated or mapped to a value, forming key-value pairs
• Values can be any Python data type

Variables

• Used to store a value by assigning it a name for later use, stored in named memory locations
• Variable names should be meaningful and without spaces
• No need to declare a variable before assignment in Python

Keywords

• Reserved words that can't be used as identifiers
• Used to define the syntax and structure of Python code with case sensitivity

Identifiers

• A name given to entities like classes, functions, and variables
• Identifiers composed of lowercase (a to z), uppercase (A to Z), digits (0 to 9), and underscores (_)
• Identifiers cannot:
  • Start with a digit
  • Use keywords
  • Use special symbols
• Identifiers can be of any length

Statements

• Instructions that a Python interpreter can execute
• Statements form a unit of code, such as creating a variable or displaying a value

Expressions

• Combination of values, variables, and operators
• A value or variable by itself is also considered an expression

Input

• Data entered by the user during program execution via the input() function
  • variable = input ("data")

Output

• Displayed to the user via the print statement
  • print (expression/constant/variable)

Comments

• Designated by a hash sign #
• Comments are ignored by the interpreter
• Python does not have a multiple-line commenting feature
• Each line must be commented individually

Docstring

• Short for documentation and enclosed in triple quotes
• Placed used as the first statement in a module, function, class, or method definition to explain what it does
• Syntax example:

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

Lines and Indentation

• Python uses indentation to define code blocks instead of braces {}
• Indentation is a space given to the block of codes for class and function definitions or flow control

Quotation

• Single ('...'), double ("..."), and triple quotes ("""...""") are used to denote string literals

Tuple Assignment

• Assigns elements in a tuple using a single assignment statement
• Python's tuple assignment is versatile because the left side is a tuple of variables, and the right side is a tuple of values
• The number of variables and values has to match
• Used for tuple packing and unpacking Example:

#Tuple Assignment Problem
(a,b) = (b,a)

#Tuple Packing
>>> b = ("George", 25, "20000") # tuple packing

#Tuple Unpacking
>>> (name, age, salary) = b # tuple unpacking
>>> name
'George'
>>> age
25
>>> salary
'20000'

Operators

• Constructs that manipulate the value of operands that include:
  • Arithmetic Operators
  • Comparison (Relational) Operators
  • Assignment Operators
  • Logical Operators
  • Bitwise Operators
  • Membership Operators
  • Identity Operators

Arithmetic Operations

• Symbols used for performing mathematical tasks
• Assume a=10 and b=5
  • Addition (+): Adds values. Example: a + b = 30
  • Subtraction (-): Subtracts values. Example: a - b = -10
  • Multiplication (*): Multiplies values. Example: a * b = 200
  • Division (/): Divides values. Example: b / a = 2
  • Modulus (%): Returns remainder. Example: b % a = 0
  • Exponent (**): Performs exponential calculation. Example: a ** b = 10 to the power 20
  • Floor Division (//): Removes decimal points. Example: 5 // 2 = 2

Comparison Operations

• Comparison symbols used to compare operands (return True or False given a = 10, b = 5) Example list:
  • EqualTo: a ==b = False
  • NotEqual: a != b = True
  • GreaterThan: a>b = True
  • LessThan: `a0 def my_details( name, age=40 ): print("Name: ", name) print("Age ", age) my_details(name="george") #Output: #Name: george #Age 40

### Variable-Length Arguments
- Python uses `*args` in func def to manage variable no. of arguments with syntax example:
```python
 def my_details(*name ):
    	print(*name)
 my_details("rajan","rahul","micheal", 'arjun')
#Output:
#rajan rahul micheal arjun

Modules

• Python organises code in modules for clarity with definitions, functions & statements
• You can expand the standard library of Python into modules
• You must import a module to use it

Module Operations

• Modules can be accessed by defining access & referencing functions or methods with dot notation
• Dot notation synatx

 import module_name functionname(variable)

User Defined Example

#Name of file: cal
import cal
x=cal.add(5,4)
print(x)

Builtin Example

#Name of file: math
import math
x=math.sqrt(25)
print(x)

Built-in Method Examples

• math.ceil(x): Smallest integer > or = to specified X - math.floor(x): Biggest integer < or = to specified X - math.factorial(x): Return X factorial -math.gcd(x):Return highest common devisor of given numbers x, y - math.sprt(x): Return square root of X
• math.log(x): Return natural logarithm X
• math.log10(x): Return base-10 logarithm X
• math.log2(x): Return base-2 logarithm X
• math.sin(x): Return sine of specified x radians - math.cos(x):Return cosine number of x radians -math.tan(x):Return tangent X radians
• math.pi(x): π = 3.141592 - math.e(x): e = 2.718281

Random Module

• Generates pesudo-random numbers with varying parameters using methods such as: -randrange(stop) -randrange(start, stop[, step]) -uniform(a,b) #Returns random floating point number & the range needs to b specified

Illustrative Programs

Program to perform two number swap

a = int(input("Enter a value "))
b = int(input("Enter b value "))
c=a
a=b
b=c
print("a=",a,"b=",b,)

Program to circulate n numbers

a=list(input("enter the list"))
for i in range(1,len(a),1):
    print(a[i:]+a[:i])