L2 – Introduction to

Python
By
Dr. Mubarak Sufyan

1
Table of content:
 Keyword, Operators, and Syntax
 Operators
 Arithmetic Operators
 Logical Operators
 Variables
 Built-in Functions/Standard Library
 Functions
 Python Script
 Plotting in Python
 If statement
 Arrays
 Control Statement
 Fibonacci Numbers

2
 Whitespace
 Whitespace is meaningful in Python: especially indentation and
placement of newlines.
 Use a newline to end a line of code.
 Use \ when must go to next line prematurely.
 No braces { } to mark blocks of code in Python… Use consistent
indentation instead.
 The first line with less indentation is outside of the block.
 The first line with more indentation starts a nested block.
hello3.py
 Often a colon appears at the start of a new block. (E.g. for
function and class definitions.) 1 # Prints a helpful message.
2 def hello():
 Python uses indentation to indicate blocks, instead of {} 3 print("Hello, world!")
4 print("How are you?")
 Makes the code simpler and more readable 5
 In Java, indenting is optional. In Python, you must indent. 6 # main (calls hello twice)
7 hello()
3
8 hello()
WHAT IS A RECIPE

1. sequence of simple steps

2. flow of control process that specifies when each step is executed
3. a means of determining when to stop

1+2+3 = an algorithm!

4
 Keywords

 Each high-level language has its own set of predefined words that the
programmer must use to write a program.
 The words that make up a high-level programming language are known as key
words or reserved words.
 Each key word
 has a specific meaning, and
 cannot be used for any other purpose.
 An example of a Python statement that uses the key word print to print a
message on the screen.

5
 The Python keywords

 and  else  raise

 del  if  continue
 from  pass  finally
 not  yiel  is
 while  break  return
 as  except  def
 elif  import  for
 global  print  lambda
 or  class  try
 with  exec 

 Assert  in

6
 List methods
 Python has a set of built-in methods that you can use on lists.
 pop([i]), pop() : create stack (FIFO), or queue (LIFO) → pop(0)
 reverse() : reverse list
 append() : Adds an element at the end of the list
 clear() : Removes all the elements from the list
 copy() : Returns a copy of the list
 count() : Returns the number of elements with the specified value
 extend() : Add the elements of a list (or any iterable), to the end of the current list
 index() : Returns the index of the first element with the specified value
 insert() : Adds an element at the specified position
 pop() : Removes the element at the specified position
 remove() : Removes the item with the specified value
 reverse() : Reverses the order of the list
7
Values and types

8
Values and types

 A value is one of the basic things a program works with, like a letter or a
number.
 The values we have seen so far are 1, 2, and “Hello, World!” These values
belong to
 different types:
 2 is an integer, and
 “Hello, World!” is a string, so called because it contains a “string” of letters

9
Core data types

 Numbers
 Strings
 Lists
 Dictionaries
 Tuples
 Files
 Sets
Basic Datatypes
 Integers (default for numbers)
z = 5 / 2 # Answer 2, integer division
 Floats
x = 3.456
 Strings
 Can use “” or ‘’ to specify with “abc” == ‘abc’
 Unmatched can occur within the string: “matt’s”
 Use triple double-quotes for multi-line strings or
strings than contain both ‘ and “ inside of them:
“““a‘b“c”””
1- Python - Numbers
 Number data types store numeric values.
 They are immutable data types, which means that changing the value
of a number data type results in a newly allocated object.
 Number objects are created when you assign a value to them. For
example:
var1 = 1
var2 = 10
 You can also delete the reference to a number object by using the del
statement.
 The syntax of the del statement is:
del var1[,var2[,var3[....,varN]]]]
You can delete a single object or multiple objects by using the del
statement. For example:
del var del var_a, var_b
Numbers

 Can be integers, decimals (fixed precision), floating points (variable

precision), complex numbers etc.
 Simple assignment creates an object of number type such as:
 a=3
 b = 4.56
 Supports simple to complex arithmetic operators.
 Assignment via numeric operator also creates a number object:
 c=a/b
 a, b and c are numeric objects.
 Try dir(a) and dir(b) . This command lists the functions available for these objects
Different Numerical Types

Python supports four different numerical types:

 int (signed integers): often called just integers or ints, are positive or negative
whole numbers with no decimal point.
 long (long integers ): or longs, are integers of unlimited size, written like integers
and followed by an uppercase or lowercase L.
 float (floating point real values) : or floats, represent real numbers and are
written with a decimal point dividing the integer and fractional parts. Floats may
also be in scientific notation, with E or e indicating the power of 10 (2.5e2 = 2.5 x
102 = 250).
 complex (complex numbers) : are of the form a + bJ, where a and b are floats
and J (or j) represents the square root of -1 (which is an imaginary number). a is
the real part of the number, and b is the imaginary part. Complex numbers are not
used much in Python programming.
Different Numerical Types

int long float complex

10 51924361L 0 3.14j
100 -0x19323L 15.2 45.j
-786 0122L -21.9 9.322e-36j
80 0xDEFABCECBDAECBFBAEl 32.3+e18 .876j
-490 535633629843L -90 -.6545+0J
-0x260 -052318172735L -3.25E+101 3e+26J
0x69 -4721885298529L 70.2-E12 4.53e-7j
Number Type Conversion:
 Type int(x)to convert x to a plain integer.
 Type long(x) to convert x to a long integer.
 Type float(x) to convert x to a floating-point number.
 Type complex(x) to convert x to a complex number with real part
x and imaginary part zero.
 Type complex(x, y) to convert x and y to a complex number with
real part x and imaginary part y. x and y are numeric expressions
 Mathematical Functions:
Function Returns ( description )
abs(x) The absolute value of x: the (positive) distance between x and zero.
ceil(x) The ceiling of x: the smallest integer not less than x
cmp(x, y) -1 if x < y, 0 if x == y, or 1 if x > y
x
exp(x) The exponential of x: e
fabs(x) The absolute value of x.
floor(x) The floor of x: the largest integer not greater than x
log(x) The natural logarithm of x, for x> 0
log10(x) The base-10 logarithm of x for x> 0 .
max(x1, x2,...) The largest of its arguments: the value closest to positive infinity
min(x1, x2,...) The smallest of its arguments: the value closest to negative infinity
modf(x) The fractional and integer parts of x in a two-item tuple. Both parts have the same sign
as x. The integer part is returned as a float.
pow(x, y) The value of x**y.
round(x [,n]) x rounded to n digits from the decimal point. Python rounds away from zero as a tie-
breaker: round(0.5) is 1.0 and round(-0.5) is -1.0.
sqrt(x) The square root of x for x > 0
 Random Number Functions:
Function Returns ( description )
choice(seq) A random item from a list, tuple, or string.
randrange ([start,] stop [,step]) A randomly selected element from range(start, stop, step)

random() A random float r, such that 0 is less than or equal to r and r is less than 1

seed([x]) Sets the integer starting value used in generating random numbers. Call this
function before calling any other random module function. Returns None.

shuffle(lst) Randomizes the items of a list in place. Returns None.

uniform(x, y) A random float r, such that x is less than or equal to r and r is less than y
 Trigonometric Functions:
Function Description
acos(x) Return the arc cosine of x, in radians.
asin(x) Return the arc sine of x, in radians.
atan(x) Return the arc tangent of x, in radians.
atan2(y, x) Return atan(y / x), in radians.
cos(x) Return the cosine of x radians.
hypot(x, y) Return the Euclidean norm, sqrt(x*x + y*y).
sin(x) Return the sine of x radians.
tan(x) Return the tangent of x radians.
degrees(x) Converts angle x from radians to degrees.
radians(x) Converts angle x from degrees to radians.
2. Python - Strings
 Strings are amongst the most popular types in Python.
 can create them simply by enclosing characters in quotes.
 Python treats single quotes the same as double quotes.
 Creating strings is as simple as assigning a value to a variable. For
example:
var1 = 'Hello World!'
var2 = "Python Programming"
Strings
 A string object is a ‘sequence’, i.e., it’s a list of items where each item has a
defined position.
 Each character in the string can be referred, retrieved and modified by using its
position.
 This order id called the ‘index’ and always starts with 0.
 Accessing Values in Strings:
 Python does not support a character type;
 these are treated as strings of length one, thus also considered a substring.
 To access substrings, use the square brackets for slicing along with the index
or indices to obtain your substring:
 Example:
var 1 = 'Hello World!'
var2 = "Python Programming"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

This will produce following result:

var1[0]: H
var2[1:5]: ytho
 Updating Strings:
 You can "update" an existing string by (re)assigning a variable to another
string.
 The new value can be related to its previous value or to a completely
different string altogether.
 Example:
var1 = 'Hello World!'
print "Updated String :- ", var1[:6] + 'Python'

This will produce following result:

Updated String :- Hello Python
 Escape Characters:
Backslash Hexadecimal
Description
notation character
\a 0x07 Bell or alert
\b 0x08 Backspace
\cx Control-x
\C-x Control-x
\e 0x1b Escape
\f 0x0c Formfeed
\M-\C-x Meta-Control-x
\n 0x0a Newline
\nnn Octal notation, where n is in the range 0.7
\r 0x0d Carriage return
\s 0x20 Space
\t 0x09 Tab
\v 0x0b Vertical tab
\x Character x
\xnn Hexadecimal notation, where n is in the range 0.9, a.f, or A.F
 String Special Operators
Assume string variable a holds 'Hello' and variable b holds 'Python' then:
Operator Description Example
+ Concatenation - Adds values on either side of the operator a + b will give
HelloPython
* Repetition - Creates new strings, concatenating multiple copies of the same a*2 will give -
string HelloHello

[] Slice - Gives the character from the given index a[1] will give e

[:] Range Slice - Gives the characters from the given range a[1:4] will give ell

in Membership - Returns true if a character exists in the given string H in a will give 1

not in Membership - Returns true if a character does not exist in the given string M not in a will give
1

r/R Raw String - Suppress actual meaning of Escape characters. print r'\n' prints \n
and print R'\n'
prints \n
% Format - Performs String formatting See at next section
String Formatting Operator:
Format Symbol Conversion
%c character
%s string conversion via str() prior to formatting
%i signed decimal integer
%d signed decimal integer
%u unsigned decimal integer
%o octal integer
%x hexadecimal integer (lowercase letters)
%X hexadecimal integer (UPPERcase letters)
%e exponential notation (with lowercase 'e')
%E exponential notation (with UPPERcase 'E')
%f floating point real number
%g the shorter of %f and %e
%G the shorter of %f and %E
Other supported symbols and functionality are listed
in the following table:

Symbol Functionality
* argument specifies width or precision

- left justification

+ display the sign

<sp> leave a blank space before a positive number

# add the octal leading zero ( '0' ) or hexadecimal leading

'0x' or '0X', depending on whether 'x' or 'X' were used.
0 pad from left with zeros (instead of spaces)

% '%%' leaves you with a single literal '%'

(var) mapping variable (dictionary arguments)

m.n. m is the minimum total width and n is the number of digits

to display after the decimal point (if appl.)
Strings
 String objects support concatenation and repetition operations.
 Triple Quotes
 Python's triple quotes comes to the rescue
 by allowing strings to span multiple lines,
 including verbatim NEWLINEs, TABs, and any other special characters.
 The syntax for triple quotes consists of three consecutive single or double
quotes.
Raw String:
 Raw strings don't treat the backslash as a special
character at all. Every character you put into a raw
string stays the way you wrote it:
print 'C:\\nowhere'
This would print following result:
C:\nowhere
Now let's make use of raw string. We would put
expression in r'expression' as follows:
print r'C:\\nowhere'
This would print following result:
C:\\nowhere
 Unicode String:
 Normal strings in Python are stored internally as 8-bit ASCII, while
Unicode strings are stored as 16-bit Unicode. This allows for a
more varied set of characters, including special characters from
most languages in the world. I'll restrict my treatment of Unicode
strings to the following:
print u'Hello, world!'
This would print following result:
Hello, world!
 Built-in String Methods:
1 capitalize()
Capitalizes first letter of string
2 center(width, fillchar)
Returns a space-padded string with the original string centered to a total of width columns

3 count(str, beg= 0,end=len(string))

Counts how many times str occurs in string, or in a substring of string if starting index beg and
ending index end are given
3 decode(encoding='UTF-8',errors='strict')
Decodes the string using the codec registered for encoding. encoding defaults to the default string
encoding.
4 encode(encoding='UTF-8',errors='strict')
Returns encoded string version of string; on error, default is to raise a ValueError unless errors is
given with 'ignore' or 'replace'.
5 endswith(suffix, beg=0, end=len(string))
Determines if string or a substring of string (if starting index beg and ending index end are given)
ends with suffix; Returns true if so, and false otherwise
6 expandtabs(tabsize=8)
Expands tabs in string to multiple spaces; defaults to 8 spaces per tab if tabsize not provided
7 find(str, beg=0 end=len(string))
Determine if str occurs in string, or in a substring of string if starting index beg and ending index end are given;
returns index if found and -1 otherwise
8 index(str, beg=0, end=len(string))

Same as find(), but raises an exception if str not found

9 isa1num()

Returns true if string has at least 1 character and all characters are alphanumeric and false otherwise

10 isalpha()

Returns true if string has at least 1 character and all characters are alphabetic and false otherwise

11 isdigit()

Returns true if string contains only digits and false otherwise

12 islower()

Returns true if string has at least 1 cased character and all cased characters are in lowercase and false otherwise

13 isnumeric()

Returns true if a unicode string contains only numeric characters and false otherwise

14 isspace()

Returns true if string contains only whitespace characters and false otherwise
15 istitle()
Returns true if string is properly "titlecased" and false otherwise
16 isupper()
Returns true if string has at least one cased character and all cased characters are in uppercase and false
otherwise
17 join(seq)
Merges (concatenates) the string representations of elements in sequence seq into a string, with separator
string
18 len(string)
Returns the length of the string
19 ljust(width[, fillchar])
Returns a space-padded string with the original string left-justified to a total of width columns

20 lower()
Converts all uppercase letters in string to lowercase
21 lstrip()
Removes all leading whitespace in string
22 maketrans()
Returns a translation table to be used in translate function.
23 max(str)
Returns the max alphabetical character from the string str
24 min(str)

Returns the min alphabetical character from the string str

25 replace(old, new [, max])

Replaces all occurrences of old in string with new, or at most max occurrences if max given

26 rfind(str, beg=0,end=len(string))

Same as find(), but search backwards in string

27 rindex( str, beg=0, end=len(string))

Same as index(), but search backwards in string

28 rjust(width,[, fillchar])

Returns a space-padded string with the original string right-justified to a total of width columns.

29 rstrip()

Removes all trailing whitespace of string

30 split(str="", num=string.count(str))

Splits string according to delimiter str (space if not provided) and returns list of substrings; split into at most
num substrings if given
31 splitlines( num=string.count('\n'))

Splits string at all (or num) NEWLINEs and returns a list of each line with NEWLINEs removed
32 startswith(str, beg=0,end=len(string))

Determines if string or a substring of string (if starting index beg and ending index
end are given) starts with substring str; Returns true if so, and false otherwise
33 strip([chars])

Performs both lstrip() and rstrip() on string

34 swapcase()

Inverts case for all letters in string

35 title()

Returns "titlecased" version of string, that is, all words begin with uppercase, and the
rest are lowercase
36 translate(table, deletechars="")

Translates string according to translation table str(256 chars), removing those in the
del string
37 upper()

Converts lowercase letters in string to uppercase

38 zfill (width)

Returns original string leftpadded with zeros to a total of width characters; intended
for numbers, zfill() retains any sign given (less one zero)
39 isdecimal()

Returns true if a unicode string contains only decimal characters and false otherwise
Data Collection – Data Type

37
Arrays
 An array is a special variable, which can hold more than one value at a
time.
 You define an array like this:
1 data = [ 1 . 6 , 3 . 4 , 5 . 5 , 9 . 4 ]
 You can also use text like this:
1 carlist = [ ”Volvo” , ” Tesl a ” , ”Ford” ]
 You can use Arrays in Loops like this:
1 for x in data :
2 print( x )
 You can return the number of elements in the array like this:
1 N = len (data)
 You can get a specific value inside the array like this:
1 index = 2
2 x = cars [ inde x ]
 You can use the append() method to add an element to an array:
1 data.append ( 11.4 )
 many built in methods you can use in combination with arrays, like 38

sort(), clear(), copy(), count(), insert(), remove(), etc.

 Lists
 List is a more general
sequence object that allows
the individual items to be of
different types.
 Equivalent to arrays in other
languages.
 Lists have no fixed size and
can be expanded or
contracted as needed.
 Items in list can be retrieved
using the index.
 Lists can be nested just like
arrays, i.e., you can have a
list of lists.
Dictionaries

 A Mapping type
 Dictionaries store a mapping between a set of keys and a set of values.
 Keys can be any immutable type.
 Values can be any type
 A single dictionary can store values of different types
 can define, modify, view, lookup, and delete the key-value pairs in the dictionary.
 Dictionaries are unordered mappings of ’Name : Value’ associations.
 Comparable to hashes and associative arrays in other languages.
 Intended to approximate how humans remember associations.

More details will be in sperate lecture

Using dictionaries

41
 Sequence types:
Tuples, Lists, and
Strings
Mutable vs. Immutable

 Numbers, strings and tuples are immutable i.,e cannot be directly changed.
 Lists, dictionaries and sets can be changed in place.
 Sequence Types
1. Tuple: (‘john’, 32)
• A tuple is
• a sequence of comma-separated values inside a pair of parenthesis.
• a sequence of values much like a list.
• The values stored in a tuple can be any type, and they are indexed by
integers
• (read Chapter 10 from “Python for Everybody” book)
• A simple immutable ordered sequence of items
• Items can be of mixed types, including collection types
 Tuples are immutable lists.
 Maintain integrity of data during program execution.
2. Strings: “John Smith”
 Immutable
 Conceptually very much like a tuple
3. List: [1, 2, ‘john’, (‘up’, ‘down’)]
• Mutable ordered sequence of items of mixed types
Similar Syntax

 All three sequence types (tuples, strings, and lists)

share much of the same syntax and functionality.
 Key difference:
 Tuples and strings are immutable
 Lists are mutable
 The operations shown in this section can be applied
to all sequence types
 most examples will just show the operation
performed on one
Sequence Types 1
 Define tuples using parentheses and commas
>>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’)

 Define lists are using square brackets and

commas
>>> li = [“abc”, 34, 4.34, 23]

 Define strings using quotes (“, ‘, or “““).

>>> st = “Hello World”
>>> st = ‘Hello World’
>>> st = “““This is a multi-line
string that uses triple quotes.”””
Sequence Types 2
 Access individual members of a tuple, list, or string using
square bracket “array” notation
 Note that all are 0 based…
>>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’)
>>> tu[1] # Second item in the tuple.
‘abc’

>>> li = [“abc”, 34, 4.34, 23]

>>> li[1] # Second item in the list.
34

>>> st = “Hello World”

>>> st[1] # Second character in string.
‘e’
Positive and negative indices

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)

Positive index: count from the left, starting with 0

>>> t[1]
‘abc’
Negative index: count from right, starting with –1
>>> t[-3]
4.56
Slicing: return copy of a subset
>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)

Return a copy of the container with a subset of the

original members.
Start copying at the first index, and stop copying
before second.
>>> t[1:4]
(‘abc’, 4.56, (2,3))
Negative indices count from end
>>> t[1:-1]
(‘abc’, 4.56, (2,3))
Slicing: return copy of a =subset
>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)

Omit first index to make copy starting from beginning

of the container
>>> t[:2]
(23, ‘abc’)
Omit second index to make copy starting at first index
and going to end
>>> t[2:]
(4.56, (2,3), ‘def’)
Copying the Whole Sequence
 [ : ] makes a copy of an entire sequence
>>> t[:]
(23, ‘abc’, 4.56, (2,3), ‘def’)
 Note the difference between these two lines for
mutable sequences
>>> l2 = l1 # Both refer to 1 ref,
# changing one affects both
>>> l2 = l1[:] # Independent copies, two refs
 Mutability:
Tuples vs. Lists
Lists are mutable

>>> li = [‘abc’, 23, 4.34, 23]

>>> li[1] = 45
>>> li
[‘abc’, 45, 4.34, 23]

 We can change lists in place.

 Name li still points to the same memory
reference when we’re done.
Tuples are immutable
>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)
>>> t[2] = 3.14

Traceback (most recent call last):

File "<pyshell#75>", line 1, in -toplevel-
tu[2] = 3.14
TypeError: object doesn't support item assignment

You can’t change a tuple.

You can make a fresh tuple and assign its reference to
a previously used name.
>>> t = (23, ‘abc’, 3.14, (2,3), ‘def’)
The immutability of tuples means they’re faster than
lists.
Operations on Lists Only

>>> li = [1, 11, 3, 4, 5]

>>> li.append(‘a’) # Note the method syntax

>>> li
[1, 11, 3, 4, 5, ‘a’]

>>> li.insert(2, ‘i’)

>>>li
[1, 11, ‘i’, 3, 4, 5, ‘a’]
The extend method vs +

+ creates a fresh list with a new memory ref

 extend operates on list li in place.

>>> li.extend([9, 8, 7])

>>> li
[1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7]

 Potentially confusing:
 extend takes a list as an argument.
 append takes a singleton as an argument.
>>> li.append([10, 11, 12])
>>> li
[1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7, [10, 11, 12]]
Operations on Lists Only
Lists have many methods, including index, count,
remove, reverse, sort
>>> li = [‘a’, ‘b’, ‘c’, ‘b’]
>>> li.index(‘b’) # index of 1st occurrence
1
>>> li.count(‘b’) # number of occurrences
2
>>> li.remove(‘b’) # remove 1st occurrence
>>> li
[‘a’, ‘c’, ‘b’]
Operations on Lists Only

>>> li = [5, 2, 6, 8]

>>> li.reverse() # reverse the list *in place*

>>> li
[8, 6, 2, 5]

>>> li.sort() # sort the list *in place*

>>> li
[2, 5, 6, 8]

>>> li.sort(some_function)
# sort in place using user-defined comparison
Tuple details
 The comma is the tuple creation operator, not parens
>>> 1,
(1,)
 Python shows parens for clarity (best practice)
>>> (1,)
(1,)
 Don't forget the comma!
>>> (1)
1
 Trailing comma only required for singletons others
 Empty tuples have a special syntactic form
>>> ()
()
>>> tuple()
()
Summary: Tuples vs. Lists

 Lists slower but more powerful than tuples

 Lists can be modified, and they have lots of
handy operations and mehtods
 Tuples are immutable and have fewer features
 To convert between tuples and lists use the list()
and tuple() functions:
li = list(tu)
tu = tuple(li)
Python Variables

61
Variables
 One of the most powerful features of a
programming language is the ability to
manipulate variables.
 A variable is a name that refers to a value.
 An assignment statement creates new variables
and gives them values:
 Variable in python is always a reference to an object as
in python everything, even a function, is an object.
 Variables can be reassigned at any time
 Python is dynamically typed, Meaning that variables
 can be assigned without declaring their type,
 and that their type can change.
 Values can come from
 Constants
 Computation involving values of other variables
 The output of a function.
62
Variables
 Some rules for Variable names can be
 arbitrarily long.
 contain both letters and numbers, but they cannot start with a number.
 legal to use uppercase letters, but it is a good idea to begin variable names with a lowercase
letter (you’ll see why later).
 The underscore character ( _ ) can appear in a name (often used in names with multiple
words, such as my_name or airspeed_of_unladen_swallow).
 start with an underscore character, but generally avoid doing this unless we are writing
library code for others to use.
 Custom types can be defined.
 No need to declare
 Need to assign (initialize)
 use of uninitialized variable raises exception
 Not typed
if friendly: greeting = "hello world"
else: greeting = 12**2
print greeting
 Everything is a variable:
63
 functions, modules, classes
 Variables
 some basic rules for Python variables:
 A variable name must start with a letter or the underscore character
 A variable name cannot start with a number
 variable name can only contain alpha-numeric characters (A-z, 0-9) and underscores
 Variable names are case-sensitive, e.g., amount, Amount and AMOUNT are three different
variables.
 Can be any reasonable length

 Python determines data types for variables based on the context

 Available basic types:
 Numbers: Integers and floating point (64-bit)

 Complex numbers: x = complex(3,1) or x = 3+1j

 Strings, using double or single quotes: "cat" 'dog’

 Boolean: True and False

 Lists, dictionaries, and tuples

 These hold collections of variables

 Specialty types: files, network connections, objects 64

Statements
 A statement is a unit of code that the Python interpreter can execute.
 Two kinds of statements:
 print being an expression statement and
 assignment.
 When you type a statement in interactive mode, the interpreter executes it
and displays the result, if there is one.
 A script usually contains a sequence of statements.
 For example, the script

 The assignment statement produces no output.

65
Operators

66
 Operators

 Python supports a wide variety of operators which act

like functions, i.e. they do something and return a
value:
 Arithmetic: + - * / % **
 Logical: and or not
 Comparison: > < >= <= != ==
 Assignment: =
 Bitwise: & | ~ ^ >> <<
 Identity: is is not
 Membership: in not in
67
 Arithmetic operators

 Some additional arithmetic operators that modify variable values:

• The += operator is by far the most commonly used of these!

• A built-in function, type(), returns the type of the data assigned to a
variable. 68
Example: Operators on ints and floats

69
SIMPLE OPERATIONS

70
 logical operators

 Some additional logical operators that used for comparing

71
 LOGIC OPERATORS ON bools
pset_time = 15
sleep_time = 8
print(sleep_time > pset_time)
derive = True
drink = False
both = drink and derive
print(both)

72
COMPARISON OPERATORS

 Comparison: > < >= <= != ==

 For example: ON int, float, string
 i and j are variable names
 comparisons below evaluate to a Boolean
i>j
i >= j
i<j
i <= j
i == j equality test, True if i is the same as j
i != j inequality test, True if i not the same as j


73
 Assignment
 Assignment: =
 Binding a variable in Python means setting a name to hold a reference
to some object.
 Assignment creates references, not copies
 Names in Python do not have an intrinsic type.
 Objects have types.
 Python determines the type of the reference automatically based on the
data object assigned to it.
 You create a name the first time it appears on the left side of an
assignment expression:
x=3
 A reference is deleted via garbage collection after any names bound to
it have passed out of scope.
74
 Assignment
 Accessing Non-Existent Names
 If you try to access a name before it’s been properly created (by placing it on the
left side of an assignment), you’ll get an error.
>>> y
Traceback (most recent call last):
File "", line 1, in -toplevel- y
NameError: name ‘y' is not defined
>>> y = 3
>>> y
3
 Multiple Assignment
 You can also assign to multiple names at the same time.
>>> x, y = 2, 3
>>> x
2
>>> y
3 75
Bitwise

 Bitwise: & | ~ ^ >> <<

 The following table summarizes the bitwise Boolean operators:

Write code for each one for Lab 76

Identity

 Identity: is is not

Write code for each one for Lab 77

Membership
 Membership: in not in

 The ‘in’ Operator

 Boolean test whether a value is inside a container:
>>> t = [1, 2, 4, 5]
>>> 3 in t
False
>>> 4 in t
True
>>> 4 not in t
False
 For strings, tests for substrings
>>> a = 'abcde'
>>> 'c' in a
True
>>> 'cd' in a
True
>>> 'ac' in a
False
 Be careful: the in keyword is also used in the syntax of for loops and list comprehensions

78
The + Operator

The + operator produces a new tuple, list, or string

whose value is the concatenation of its arguments.

>>> (1, 2, 3) + (4, 5, 6)

(1, 2, 3, 4, 5, 6)

>>> [1, 2, 3] + [4, 5, 6]

[1, 2, 3, 4, 5, 6]

>>> “Hello” + “ ” + “World”

‘Hello World’
The * Operator

 The * operator produces a new tuple, list, or string

that “repeats” the original content.

>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)

>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>> “Hello” * 3
‘HelloHelloHello’
Expressions

 An expression is a combination of values, variables, and operators.

 A value all by itself is considered an expression, and so is a variable, so the
following are all legal expressions (assuming that the variable x has been
assigned a value):

81
Order of operations

 When more than one operator appears in an expression,

 the order of evaluation depends on the rules of precedence
 For mathematical operators, Python follows mathematical convention.
 The acronym PEMDAS is a useful way to remember the rules:
 Parentheses have the highest precedence and can be used to force an expression to
evaluate in the order you want
 Exponentiation has the next highest precedence, so 2**1+1 is 3, not 4, and 3*1**3 is 3,
not 27.
 Multiplication and Division have the same precedence, which is higher than Addition and
Subtraction, which also have the same precedence. So 2*3-1 is 5, not 4, and 6+4/2 is 8,
not 5.
 Operators with the same precedence are evaluated from left to right. So the expression
5-3-1 is 1, not 3, because the 5-3 happens first and then 1 is subtracted from 2.

82
Modulus operator
 The modulus operator works on integers and yields the
remainder when the first operand is divided by the second.
 In Python, the modulus operator is a percent sign (%).
 The syntax is the same as for other operators:

83
String operations
 The + operator works with strings, but it is not addition
in the mathematical sense.
 Instead it performs concatenation, which means joining
the strings by linking them end to end.
 For example:

 The * operator also works with strings by multiplying the

content of a string by an integer.
 For example:

84
Sets

 Special data type introduced since Python 2.4 onwards to support

mathematical set theory operations.
 Unordered collection of unique items.
 Set itself is mutable, BUT every item in the set has to be an immutable type.
 So, sets can have numbers, strings and tuples as items but cannot have lists or
dictionaries as items

Make a code for lab

 INPUT/OUTPUT
Method in Python

86
INPUT/OUTPUT: print

 used to output stuff to console

 keyword is print
x=1
Correct the error in this code
print(x)
x_str = str(x)
print("my fav num is", x, ".", "x =", x)
print("my fav num is " + x_str + ". " + "x = " + x_str)

87
INPUT/OUTPUT: print

88
INPUT/OUTPUT: input("")

 prints whatever is in the quotes

 user types in something and hits enter
 binds that value to a variable
text = input("Type anything... ")
print(5*text)
 input gives you a string so must cast if working with numbers
num = int(input("Type a number... "))
print(5*num)

89
Python Scripts

90
Python Scripts
 When you call a python program from the command line the interpreter
evaluates each expression in the file

 From the Python Shell you select Run → Run Module or hit F5 in order to
run or execute the Python Script

 Run Python Scripts from the Command Prompt in Windows

Run Python Scripts

Running Python Scripts from Console window on macOS

92
Plotting in Python

93
 Plotting in Python
 Typically you need to create some plots or charts.
 Plotting functions that
 In order to make plots or charts in Python you will
you will use a lot:
need an external library.
 plot()
 The most used library is Matplotlib.
 title()
 Matplotlib is a Python 2D plotting library
 Here you find an overview of the Matplotlib library:  xlabel()
https://matplotlib.org  ylabel()
 import the whole library like this:  axis()
 grid()
 subplot()
 4 basic plotting function in the Matplotlib library:  legend()
1. plot()
 show()
2. xlabel()
3. ylabel()
4. show()
94
Subplots

 The subplot command enables you to display multiple plots in the same
window.
 Example will be the Quiz

95
References:
 For more information, you can read from “Python
for Everybody” book
 Chapter 1 Why should you learn to write programs?
 Chapter 2 Variables, expressions, and statements
 Chapter 6 Strings
 Chapter 8 Lists
 Chapter 9 Dictionaries
 Chapter 10 Tuples

96
End
97