Lecture 5 – Computing with Numbers (Math Lib).pptx

Python Programming, 3/e 1
Python Programming:
An Introduction to
Computer Science
Lecture 5 / Chapter 3 in book
Computing with Numbers

Objectives
 To understand the concept of data types.
 To be familiar with the basic numeric data types
in Python.
 To understand the fundamental principles of how
numbers are represented on a computer.
 To be able to use the Python Math library.
 To be able to read and write programs that
process numerical data.

Numeric Data Types
 The information that is stored and manipulated by
computer programs is referred to as data.
 There are two different kinds of numbers!
 (5, 4, 3, 6) are whole numbers – they don’t have a
fractional part
 (.25, .10, .05, .01) are decimal fractions
 Inside the computer, whole numbers and decimal
fractions are represented quite differently!
 We say that decimal fractions and whole numbers
are two different data types.

Numeric Data Types
 The data type of an object determines what
values it can have and what operations can be
performed on it.
 Whole numbers are represented using the
integer (int for short) data type.
 These values can be positive or negative whole
numbers.

Numeric Data Types
 Python has a special function to tell us the
data type of any value.
>>> type(3)
<class 'int'>
>>> type(3.1)
<class 'float'>
>>> type(3.0)
<class 'float'>
>>> myInt = 32
>>> type(myInt)
<class 'int'>
>>>

Numeric Data Types
 Why do we need two number types?
 Values that represent counts can’t be fractional
(you can’t have 3 ½ quarters)
 Most mathematical algorithms are very efficient
with integers
 The float type stores only an approximation to the
real number being represented!
 Since floats aren’t exact, use an int whenever
possible!

7
Numeric Data Types
Operations on ints
produce ints,
operations on floats
produce floats
(except for /).

8
Numeric Data Types
 Integer division produces a whole number.
 That’s why 10//3 = 3
 Think of it as ‘gozinta’, where 10//3 = 3 since 3 gozinta
(goes into) 10, 3 times (with a remainder of 1)
 10%3 = 1 is the remainder of the integer division of 10
by 3.
For more info on //: https://www.pythontutorial.net/advanced-python/python-floor-division/

Rounding floats
 Python can also round floats, using the simple,
round() function
>>> round(7.36)
7
 Lets use it on Pi! - do you know, the number of Pi?
pi = 3.141592653589793
>>> round(pi, 3)
3.142
>>> round(3.6)
4

Accumulating Results: Factorial
 How did we calculate 6!=6*5*4*3*2*1 ?
 6*5 = 30
 Take that 30, and 30 * 4 = 120
 Take that 120, and 120 * 3 = 360
 Take that 360, and 360 * 2 = 720
 Take that 720, and 720 * 1 = 720

 The general form of an accumulator
algorithm looks like this:
Initialize the accumulator variable
Loop until final result is reached
update the value of accumulator
variable

 It looks like we’ll need a loop!
fact = 1
for factor in [6, 5, 4, 3, 2, 1]:
fact = fact * factor
 For a random number n – we need a loop and
range accumulator to calculate n!

Range () method

Range() method
 What does range(n) return?
0, 1, 2, 3, …, n-1
 What does range(5) return? 0, 1, 2, 3, 4
 range has another optional parameter!
range(start, n) returns
start, start + 1, …, n-1
 But wait! There’s more!
range(start, n, step)
start, start+step, …, n-1
 list(<sequence>) to make a list

 Completed factorial program:
# factorial.py
# Program to compute the factorial of a number
# Illustrates for loop with an accumulator
def main():
n = eval(input("Please enter a whole number: "))
fact = 1
for factor in range(n,1,-1):
fact = fact * factor
print("The factorial of", n, "is", fact)
main()

Using the Math Library
 Besides (+, -, *, /, //, **, %, abs), we have
lots of other math functions available in a
math library.
 A library is a module with some useful
definitions/functions.

 Let’s write a program to compute the roots of a
quadratic equation!
 The only part of this we don’t know how to do is
find a square root… but it’s in the math library!
2
4
2
b b ac
x
a
  


 To use a library, we need to make sure this line
is in our program:
import math
 Importing a library makes whatever functions are
defined within it available to the program.

 To access the sqrt library routine, we need to
access it as math.sqrt(x).
 Using this dot notation tells Python to use the
sqrt function found in the math library module.
 To calculate the root, you can do
discRoot = math.sqrt(b*b – 4*a*c)
2
4
2
b b ac
x
a
  


20
2
4
2
b b ac
x
a
  

1) Let:
a= 1
b = 3
c = -4
2) Given formula 3) Plug numbers
Sqr 25 = 5
X1 = (-3 + 5)/2
X1 = 1
X2 = (-3 - 5)/2
X2 = -4
Solution 1 Solution 2
x^2 + 3x – 4 = 0 An example of a quadratic equation to try
 a*x^2 + b*x + c = 0.
2
4
2
b b ac
x
a
  


Roots of quadratic equation
# quadratic.py
# A program that computes the real roots of a quadratic equation.
# Illustrates use of the math library.
# Note: This program crashes if the equation has no real roots.
import math # Makes the math library available.
def main():
print("This program finds the real solutions to a quadratic")
print()
a, b, c = eval(input("Please enter the coefficients (a, b, c): "))
discRoot = math.sqrt(b * b - 4 * a * c)
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print()
print("The solutions are:", root1, root2 )

This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 3, 4, -1
The solutions are: 0.215250437022 -1.54858377035
 What do you suppose this means?
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 1, 2, 3
Traceback (most recent call last):
File "<pyshell#26>", line 1, in -toplevel-
main()
File "C:Documents and SettingsTerryMy DocumentsTeachingW04CS
120Textbookcodechapter3quadratic.py", line 14, in main
discRoot = math.sqrt(b * b - 4 * a * c)
ValueError: math domain error
>>>
Roots of quadratic equation

 If a = 1, b = 2, c = 3, then we are trying to
take the square root of a negative number!
 Using the sqrt function is more efficient than
using **.
 How could you use ** to calculate a square
root? /power by 0.5/

Python Mathematics English
pi An approximation of pi
e e An approximation of e
sqrt(x) The square root of x
sin(x) sin x The sine of x
cos(x) cos x The cosine of x
tan(x) tan x The tangent of x
asin(x) arcsin x The inverse of sine x
acos(x) arccos x The inverse of cosine x
atan(x) arctan x The inverse of tangent x
log(x) ln x The natural (base e) logarithm of x
log10(x) The common (base 10) logarithm of x
exp(x) The exponential of x
ceil(x) The smallest whole number >= x
floor(x) The largest whole number <= x
24

x
10
log x
x
e
x
 
 
x
 
 

Quick conversion of numbers
 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 (1)
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. Deprecated in Python 3.
Instead use return (x>y)-(x<y).
exp(x) - The exponential of x: e
x
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.

Mathematical functions (2)
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
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
acos(x) - Returns the arc cosine of x, in radians.
asin(x) - Returns the arc sine of x, in radians.
atan(x) - Returns the arc tangent of x, in radians.
atan2(y, x) - Returns atan(y / x), in radians.
cos(x) - Returns 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.

End of Lecture 5
Any questions?
30

Lecture 5 – Computing with Numbers (Math Lib).pptx

More Related Content

Similar to Lecture 5 – Computing with Numbers (Math Lib).pptx (20)

Recently uploaded (20)

Lecture 5 – Computing with Numbers (Math Lib).pptx

Editor's Notes