Introduction to the

Python language

Essentials of Python

Delhi College of Arts and Commerce

By: Ayush Agarwal

Python Intro Overview

o  Values: 10 (integer),
3.1415 (decimal number or float),
'wellesley' (text or string)

o  Types: numbers and text: int, float, str

type(10) Knowing the type of a
type('wellesley') value allows us to choose
the right operator when
o  Operators: + - * / % = creating expressions.
o  Expressions: (they always produce a value as a result)
len('abc') * 'abc' + 'def'

o  Built-in functions: max, min, len, int, float,

str, round, print, input
Python Intro 2
 Concepts in this slide:
Simple Expressions: numerical values,
math operators,
Python as calculator expressions.

Input Output
Expressions Values
In [...] Out […]
1+2 3
3*4 12
3 * 4 12 # Spaces don't matter
3.4 * 5.67 19.278 # Floating point (decimal) operations
2 + 3 * 4 14 # Precedence: * binds more tightly than +
(2 + 3) * 4 20 # Overriding precedence with parentheses
11 / 4 2.75 # Floating point (decimal) division
11 // 4 2 # Integer division
11 % 4 3 # Remainder
5 - 3.4 1.6
3.25 * 4 13.0
11.0 // 2 5.0 # output is float if at least one input is float
5 // 2.25 2.0
5 % 2.25 0.5 Python Intro 3
 Concepts in this slide:
Strings and concatenation string values,
string operators,
TypeError

A string is just a sequence of characters that we write between a pair of double

quotes or a pair of single quotes. Strings are usually displayed with single quotes.
The same string value is created regardless of which quotes are used.

In [...] Out […]

"CS111" # Double quotes

'CS111'
'rocks!' # Single quotes
'rocks!'
'You say "Hi!"' 'You say "Hi!"' # Characters in a string
# can include spaces,
"No, I didn't" "No, I didn't" # punctuation, quotes
"CS111 " + 'rocks!' 'CS111 rocks!' # String concatenation
'123' + '4' '1234' # Strings and numbers
123 + 4 127 # are very different!
'123' + 4 TypeError # Can’t concatenate strings & num.
'123' * 4 '123123123123' # Repeated concatenation
'123' * '4' TypeError Python Intro 4
 Concepts in this slide:
Memory Diagram Model: variables,
assignment statement,
Variable as a Box memory diagram model,
NameError

# create var box o  A variable is a way to remember a value for later in the
# via assignment computer’s memory.
ans = 42 o  A variable is created by an assignment statement,
Memory diagram whose form is varName = expression
This is executed in two steps:
ans 42
1.  Evaluate expression to its value val
2.  If there is no variable box already labeled with
# lookup var value
varName create a new box labeled with varName
# in expressions
and store val in it; otherwise, change the contents
2*ans+27 # val is 111
of the existing box labeled varName to val .
# can lookup and o  When varName is used in an expression, it evaluates
# reassign the same var
to the current value in the box labeled varName ; if
ans = 2*ans+27
there is no such box, a NameError occurs.
Memory diagram o  Python variable names can contain letters, numbers,
and underscores, but not other characters; they cannot
ans 111
begin with numbers. Python Intro 5
 Concepts in this slide:
variables,
Variable Examples assignment statement,
memory diagram model
A variable names a value that we want to use later in a program. In the memory
diagram model, an assignment statement var = exp stores the value of exp in a box
labeled by the variable name. Later assignments can change the value in a variable box.
Note: The symbol = is pronounced “gets” not “equals”!
In [...] Memory Diagram Out […]
fav = 17 fav 17 12 4 # assignment stmt makes box, has no output
fav 17 # returns current contents of fav box
fav + fav 34 # contents of fav is unchanged
lucky = 8 lucky 8 # makes new box, has no output
fav + lucky 25
aSum = fav + lucky aSum 25 # makes new box, has no output
aSum * aSum 625
fav = 12 # change contents of fav box to 12
fav = fav - lucky # change contents of fav box to 4
# makes new box containing string;
name = 'CS111' name 'CS111' # strings are drawn *outside* box with
# arrow pointing to them (b/c they’re
# often “too big” to fit inside box)
name * fav 'CS111CS111CS111CS111' Python Intro 6
 Concepts in this slide:
Built-in functions: built-in functions,
arguments,
max and min function calls.

Python has many built-in functions that we can use. Built-in functions and user-
defined variable and function names names are highlighted with different colors in
both Thonny and Jupyter Notebooks.
In [...] Out […]

min(7, 3) 3
max(7, 3) 7
min(7, 3, 2, 8.19) 2 # can take any num. of arguments
max(7, 3, 2, 8.19) 8.19
smallest = min(-5, 2) # smallest gets -5
largest = max(-3.4, -10) # largest gets -3.4
max(smallest, largest, -1) -1

The inputs to a function are called its arguments and the function is said to be
called on its arguments. In Python, the arguments in a function call are delimited
by parentheses and separated by commas.

Python Intro 7
 Concepts in this slide:
Understanding variable and Values can have multiple
names. Functions are also
function names values.

One value can have multiple names. These names refer to the same value in the
computer memory. See the examples below for variables and functions.
>>> oneValue = 'abc' >>> max
>>> otherValue = oneValue Functions are <built-in function max>
>>> oneValue values. just like
numbers & strings
>>> myMaxFunction = max
'abc' >>> max(10,100)
>>> otherValue 100
'abc' >>> myMaxFunction(10,100)
Memory diagram 100
oneValue 'abc' Memory diagram

max built-in
otherValue function
myMaxFunction max
Built-in function id:
This function
>>> id(oneValue) displays the memory >>> id(max)
4526040688 address where a 4525077120
value is stored.
>>> id(otherValue) >>> id(myMaxFunction)
Different names can
4526040688 refer to the same 4525077120
value in memory. Python Intro 8
 Concepts in this slide:
Built-in functions: type types,
the function type.

Each Python value has a type. It can be queried with the built-in type function.
Types are special kinds of values that display as <class 'typeName'> Knowing the
type of a value is important for reasoning about expressions containing the value.
In [...] Out […]
type(123) int Thonny actually displays <class 'int'>,
<class 'float'>, etc., but we’ll often
type(3.141) float
abbreviate these as int, float, etc.
type(4 + 5.0) float
type('CS111') str
type('111') str
type(11/4) float
type(11//4) int
type(11%4) int
type(11.0%4) float
type(max(7, 3.4)) int
x = min(7, 3.4) # x gets 3.4
type(x) float
type('Hi,' + 'you!') str
type(type(111)) type # Special type for types!
Python Intro 9
 Concepts in this slide:
Using type with different values Every value in Python
has a type, which can be
queried with type.
Below are some examples of using type in Thonny, with different values:

Functions are values

with this type

Other types we will

learn about later in
the semester

Python Intro 10
 Concepts in this slide:
length of a string,
Built-in functions: len the function len,
TypeError

When applied to a string, the built-in len function returns the

number of characters in the string.
len raises a TypeError if used with non-string values.

In [...] Out […]

len('CS111') 5
len('CS111 rocks!') 12
len('com' + 'puter') 8
course = 'computer programming'
len(course) 20
len(111) TypeError
len('111') 3
len(3.141) TypeError
len('3.141') 5

Python Intro 11
 Concepts in this slide:
the str function
Built-in functions: str
The str built-in function returns a string representation of its argument.
It is used to create string values from ints and floats(and other types of values
we will meet later) to use in expressions with other string values.
In [...] Out […]
str('CS111') 'CS111'
str(17) '17'
str(4.0) '4.0'
'CS' + 111 TypeError
'CS' + str(111) 'CS111'
len(str(111)) 3
len(str(min(111, 42))) 2

Python Intro 12
 Concepts in this slide:
Built-in functions: int int function,
TypeError,
o  When given a string that’s a sequence of digits, optionally ValueError.
preceded by +/-, int returns the corresponding integer. On any other string
it raises a ValueError (correct type, but wrong value of that type).
o  When given a float, int return the integer the results by truncating it toward zero.

o  When given an integer, int returns that integer.

In [...] Out […]

int('42') 42
int('-273') -273
123 + '42' TypeError
123 + int('42') 165
int('3.141') ValueError # strings are not sequence
int('five') ValueError # of chars denoting integer
int(3.141) 3
int(98.6) 98 # Truncate floats toward 0
int(-2.978) -2
int(42) 42
Int(-273) -273 Python Intro 13
 Concepts in this slide:
float function,
Built-in functions: float ValueError

o  When given a string that’s a sequence of digits, optionally preceded by +/-,

and optionally including one decimal point, float returns the corresponding
floating point number. On any other string it raises a ValueError.
o  When given an integer, float converts it to floating point number.

o  When given a floating point number, float returns that number.

In [...] Out […]

float('3.141') 3.141
float('-273.15') -273.15
float('3') 3.0
float('3.1.4') ValueError
float('pi') ValueError
float(42) 42.0
float(98.6) 98.6

Python Intro 14
 Concepts in this slide:
Oddities of floating point numbers floating point numbers
are only approximations,
so don’t always behave
exactly like math
In computer languages, floating point numbers
(numbers with decimal points) don’t always behave
like you might expect from mathematics. This is a consequence of their fixed-
sized internal representations, which permit only approximations in many cases.

In [...] Out […]

2.1 – 2.0 0.10000000000000009
2.2 – 2.0 0.20000000000000018
2.3 – 2.0 0.2999999999999998
1.3 – 1.0 0.30000000000000004
100.3 - 100.0 0.29999999999999716
10.0/3.0 3.3333333333333335
1.414*(3.14159/1.414) 3.1415900000000003

Python Intro 15
 Concepts in this slide:
the round function,
Built-in functions: round called with varying
number of arguments.

o  When given one numeric argument, round returns the integer it’s closest to.
o  When given two arguments (a numeric argument and an integer number of
decimal places), round returns floating point result of rounding the first
argument to the number of places specified by the second.
o  In other cases, round raises a TypeError

In [...] Out […]

round(3.14156) 3
round(98.6) 99
round(-98.6) -99
round(3.5) 4
round(4.5) 5
round(2.718, 2) 2.72
round(2.718, 1) 2.7
round(2.718, 0) 3.0
round(1.3 - 1.0, 1) 0.3
# Compare to previous slide
round(2.3 - 2.0, 1) 0.3
Python Intro 16
 Concepts in this slide:
Built-in functions: print print function

print displays a character-based representation of its

argument(s) on the screen and returns a special None value (not displayed).

Input statements Characters displayed in

In [...] console (*not* the output
value of the expression!)
print(7) 7
print('CS111') CS111
print('CS' + 111) TypeError
print(len(str('CS111')) * min(17,3)) 15
college = 'Wellesley’
print('I go to ' + college) I go to Wellesley
dollars = 10
print('The movie costs $' The movie costs $10.
+ str(dollars) + '.')
print(1,'+',2,'=',1+2) 1 + 2 = 3
print(1,'+',2,'=',1+2,sep='') 1+2=3
The last two examples show that when print is given more than one argument, it prints
all arguments, separated by one space by default. The default can be overridden by a so-
called keyword argument named sep. Python Intro 17
 Concepts in this slide:
The '\n’ newline
More print examples character ; print returns
the None value, which is
normally hidden.
# '\n' is a single special
# newline character.
# Printing it causes the
# display to shift to the
# next line.

# Like previous example,

# but use sep keyword arg
# for newlines

# printed by 2nd print.

# printed by 3rd print.
# printed by 1st print; shows that print returns None
# Output of str; shows that print returns None

Python Intro 18
 Concepts in this slide:
The input function;
Built-in functions: input converting from string
returned by input.
input displays its single argument as a prompt on the screen and waits for the user to
input text, followed by Enter/Return. It returns the entered value as a string.
In [1]: input('Enter your name: ') Brown text is prompt.
Enter your name: Olivia Rodrigo
Out [1]: 'Olivia Rodrigo' Magenta text is entered by user.
In [2]: age = input('Enter your age: ')
Enter your age: 18
No output from assignment.
In [3]: age
Out [3]: '18' Value returned by input is always a string.
Convert it to a numerical type when needed.
In [4]: age + 4
TypeError Tried to add a string and a float.
In [5]: age = float(input('Enter your age: '))
Enter a number: 18
Example of nested function calls.
In [6]: age + 4
Out [6]: 22.0 age contains float('18'), which is 18.0
and 18.0 + 4 is 22.0
Python Intro 19
 Concepts in this slide:
complex expressions ;
Complex Expression Evaluation subexpressions;
expression evaluation
An expression is a programming language phrase
that denotes a value. Smaller subexpressions can be combined
to form arbitrarily large expressions.
Complex expressions are evaluated from “inside out”, first finding the value of
smaller expressions, and then combining those to yield the values of larger
expressions. See how the expression below evaluates to '35':
str((3 + 4) * len('C' + 'S' + str(max(110, 111))))

7 'CS' 111

'111' # str(111)

'CS111' # 'CS' + '111'

5 # len('CS111')

35 # 7 * 5

'35' # str(35) Python Intro 20

 Concepts in this slide:
Expressions, statements

Expressions vs. Statements

They always produce a value: They perform an action (that can be
visible, invisible, or both):
10
print(10)
10 * 20 – 100/25
age = 19
max(10, 20)
paper = Canvas(400, 550,
int("100") + 200
'yellow')
fav
paper.add(head)
fav + 3
"pie" + " in the sky” Statements may contain expressions,
which are evaluated before the action is
performed.
Expressions are composed of any
combination of values, variables print('She is ' + str(age)
operations, and function calls. + ' years old.')
Some statements return a None value
that is not normally displayed.
Python Intro 21
 Concepts in this slide:
Expressions, statements, and Jupyter displays Out[] for
expressions, but not statements. "
console printing in Jupyter Non-Out[] chars come from print

Notice the Out[]field for the

result when the input is an
expression.

An assignment is a statement
without any outputs

The print function returns a

None value that is not displayed
as an output in Jupyter.
Any function or method call that
returns None is treated as a
statement in Python.

These are characters displayed by

print in the “console”, which is
interleaved with In[]/Out[]
Python Intro 22
 Concepts in this slide:
Expressions, statements, and Thonny displays expressions, but
not statements. Expressions are
console printing in Thonny distinguished from printed output
by text size and indentation.

Notice no Out[]field for the

result when the input is an
expression for Thonny. Text is
bigger and has no indent!
An assignment is a statement
without any outputs

The print function returns a

None value that is not displayed
as an output in Thonny.
The text is displayed as smaller
and indented!

These are characters displayed by

print in the “console”, which is
interleaved with expressions
Python Intro 23
 Concepts in this slide:
Editor pane. .py Python
Putting Python code in a .py file program file, running a
program.

Rather than interactively entering code into the Python Shell, we can enter it in the
Editor Pane, where we can edit it and save it away as a file with the .py extension (a
Python program). Here is a nameage.py program. Lines beginning with # are comments.
We run the program by pressing the triangular “run” button.

Python Intro 24
 Concepts in this slide:
the 80-character limit,
Code Styling Advice coding advice.

1.  Give meaningful names to variables.

2.  Use space around operators (e.g, =, + )
3.  Use comments at the top of file
4.  Organize code in “blocks” of related statements preceded by comments for block.
5.  Use space between blocks to improve readability. Python Intro 25
 Concepts in this slide:
Error types,
Error messages in Python Error messages.

Type Errors
'111' + 5 TypeError: cannot concatenate 'str' and 'int' objects
len(111) TypeError: object of type 'int' has no len()

Value Errors
int('3.142') ValueError: invalid literal for int() with base 10: '3.142'
float('pi') ValueError: could not convert string to float: pi

Name Errors
CS + '111' NameError: name 'CS' is not defined

Syntax Errors A syntax error indicates a phrase is not well formed according to
the rules of the Python language. E.g. a number can’t be added to
a statement, and variable names can’t begin with digits.

1 + (ans=42) 2ndValue = 25
1 + (ans=42) 2ndValue = 25
^ ^
SyntaxError: invalid syntax SyntaxError: invalid syntax Python Intro 26
Test your knowledge
1.  Create simple expressions that combine values of different types and
math operators.
2.  Which operators can be used with string values? Give examples of
expressions involving them. What happens when you use other operators?
3.  Write a few assignment statements, using as assigned values either
literals or expressions. Experiment with different variable names that
start with different characters to learn what is allowed and what not.
4.  Perform different function calls of the built-in functions: max, min, len,
type, int, str, float, round, print.
5.  Create complex expressions that combine variables, function calls,
operators, and literal values.
6.  Use the function print to display the result of expressions involving string
and numerical values.
7.  Write simple examples that use input to collect values from a user and use
them in simple expressions. Remember to convert numerical values.
8.  Create situations that raise different kinds of errors: Type, Value, Name, or
Syntax errors.
Python Intro 27