1. WHAT KIND OF THING IS IT? Python: Basic Numeric Types http://www.flickr.com/photos/iamthestig2/3925864142/sizes/l/in/photostream/

2. Data Types All data in the computer is stored as a sequence of bits These bits can mean different things depending on how they are interpreted. A data type is a way of interpreting the meaning of the bits and also a specification of how to process those bits. More specifically, a data type is defined by  The set of values that are elements of the type  The set of operations that can be applied on those values Python has a set of pre-defined (built-in) types and programmers are also free to define their own data types. 2

3. Built in Types The principal built-in types are numerics, sequences, mappings, files, classes, instances and exceptions. There are three basic numeric types  int – unlimited (arbitrary) precision  float – usually 64 bits of precision (system dependent)  complex – two floats the real and imag (z.real and z.imag) Default types  A sequence of digits is an int  A sequence of digits that includes a ‘.’ is a float 3

4. Types The function “type” will accept a value and return the values type  type(32)  type(“32”)  type(3.1) There are function to convert to other types  int(32)  int(35235252352369482358235923583469146)  float(352352.1)  complex(3.2, 18.5)

5. Notes on Type Conversion Functions int(x, base) : converts x to an int  if x is a number, then it is converted to an int  if x is a string and base is not given, then x is converted to an int with a base of 10  if x is not a number OR if base is given, then x must be a string float(x) : converts x to a float  x may be a string or a number  If x is outside the range of a Python float, an OverflowError will be raised.

6. Notes on Min/Max others The minimum and maximum float values are  sys.float_info.max  sys.float_info.min There are several special float values  x = float('+inf')  y = float('-inf')  z = float('nan')  a = x / y There is no minimum nor maximum for int. Why?

7. Expressions Expressions are code fragments that compute new values by combining other values. Expressions involve operators. An operator acts on values. An operator is characterized by  arity – the number of inputs  precedence – the order of application in an expression involving more than one operator  associativity – the order of application in an expression involving more than on occurrence of the same operator. 7

8. Operator Precedence OperatorDescription lambdaLambda expression if – elseConditional expression orBoolean OR andBoolean AND not xBoolean NOT in, not in, is, is not,, >=, <>, !=, == Comparisons, including membership tests and identity tests, |Bitwise OR ^Bitwise XOR &Bitwise AND >Shifts +, -Addition and subtraction *, /, //, %Multiplication, division, remainder +x, -x, ~xPositive, negative, bitwise NOT **Exponentiation x[index], x[index:index], x(arguments...), x.attribute Subscription, slicing, call, attribute reference 8

9. Operators Examples  x + y is the sum of x and y  x – y is the difference of x and y  x * y is the product of x and y  x / y is the quotient of x and y  x // is the floored quotient of x and y (integer division)  x % y is the remainder of x / y  x ** y is x raised to the power y  -x is x negated  +x is x

10. Notes on some of the Arithmetic Operators The / operator performs floating point division. It returns a float even if both the numerator and denominator are ints. The // operator performs integer division.  When the result is positive, the result is truncated.  When the result is negative, the // operator truncates downward.  This doesn’t always return an integer. If either the numerator or denominator is a float, it will be a float. 10

11. Coercion Rule: the operands of a binary operator must have the same type. Question: are the following allowed?  x = 3.2 + 3  y = 18 – 3.1 Whenever both arguments to an operand are of different built-in numeric type, the narrower type is coerced to the wider.  x = 3.2 + 3  y = 18 – 3.1 11

12. Examples What are the following values and types  1 / 2  1 % 2  10 % 3  32 / 4  32 // 4  32.0 / 4.0  10.0 // 4.0  3.2 ** 2

13. Casting You can programmatically make computed values into different types  float(2)  int(2.0)  int(-2.5)  float(3//2) http://www.flickr.com/photos/84338444@N00/3779270029/sizes/z/in/photostream/ 13

14. Math Library Computing with numbers is common. Common functions related to mathematics are collected into a library of functions known as the math library.  In order to use these functions, must import the library using  import math  The math library includes the functions shown on the following slids 14

15. Numeric and Representation math.ceil(x). Return the ceiling of x, the smallest integer greater than or equal to x. math.copysign(x, y). Return x with the sign of y. copysign(1, -0.0) returns -1.0. math.fabs(x). Return the absolute value of x. math.factorial(x). Return x factorial. Raises ValueError if x is not integral or is negative. math.floor(x). Return the floor of x, the largest integer less than or equal to x. math.fmod(x, y. )Return fmod(x, y), as defined by the platform C library. Note that the Python expression x % y may not return the same result. Function fmod() is generally preferred when working with floats, while Python’s x % y is preferred when working with integers. math.frexp(x). Return the mantissa and exponent of x as the pair (m, e). m is a float and e is an integer such that x == m * 2**e exactly. math.fsum(iterable). Return an accurate floating point sum of values in the iterable. math.isinf(x). Checks if the float x is positive or negative infinite. math.isnan(x). Checks if the float x is a NaN (not a number). NaNs are part of the IEEE 754 standards. Operation like but not limited to inf * 0, inf / inf or any operation involving a NaN, e.g. nan * 1, return a NaN. math.ldexp(x, i). Return x * (2**i). This is essentially the inverse of function frexp(). math.modf(x). Return the fractional and integer parts of x. Both results carry the sign of x and are floats. math.trunc(x). Return the Real value x truncated to an Integral (usually an integer). 15

16. Power, Logarithmic, Trigonometric math.exp(x). Return e**x. math.log(x[, base]). Return the logarithm of x to the given base. If the base is not specified, return the natural logarithm of x (that is, the logarithm to base e). math.log1p(x). Return the natural logarithm of 1+x (base e). The result is calculated in a way which is accurate for x near zero. math.log10(x). Return the base-10 logarithm of x. math.pow(x, y). Return x raised to the power y. pow(1.0, x) and pow(x, 0.0) always return 1.0, even when x is a zero or a NaN. If both x and y are finite, x is negative, and y is not an integer then pow(x, y) is undefined, and raises ValueError math.sqrt(x). Return the square root of x. math.acos(x). Return the arc cosine of x, in radians. math.asin(x). Return the arc sine of x, in radians. math.atan(x). Return the arc tangent of x, in radians. math.atan2(y, x). Return atan(y / x), in radians. The result is between -pi and pi. math.cos(x). Return the cosine of x radians. math.hypot(x, y). Return the Euclidean norm, sqrt(x*x + y*y). This is the length of the vector from the origin to point (x, y). math.sin(x). Return the sine of x radians.math.tan(x)Return the tangent of x radians. math.degrees(x). Converts angle x from radians to degrees. math.radians(x). Converts angle x from degrees to radians. math.pi is the mathematical constant pi. math.e is the mathematical constant e. 16

17. Example: Quadratic Equation Consider writing a function so solve the quadratic equation: Note that x may have two values for a particular assignment of constants a, b and c. Write a program that reads a, b and c as inputs. The function should produce the two solutions. 17

18. Example: Quadratic Equation # quadratic.py # A program to compute the (real) roots of a quadratic equation. # Note: this program crashes if there are no real roots # valid example: 3, 4, -2 # invalid example: 1, 2, 3 def main(): print("This program finds the real roots to a quadratic equation.") print() a, b, c = eval(input("Enter coefficients a, b and c: ")) denom = 2*a discRoot = math.sqrt(b*b – 4*a*c) root1 = (-b + discRoot) / denom root2 = (-b – discRoot) / denom print("The solutions are: ", root1, root2) main() # quadratic.py # A program to compute the (real) roots of a quadratic equation. # Note: this program crashes if there are no real roots # valid example: 3, 4, -2 # invalid example: 1, 2, 3 def main(): print("This program finds the real roots to a quadratic equation.") print() a, b, c = eval(input("Enter coefficients a, b and c: ")) denom = 2*a discRoot = math.sqrt(b*b – 4*a*c) root1 = (-b + discRoot) / denom root2 = (-b – discRoot) / denom print("The solutions are: ", root1, root2) main() 18

19. Example: factorials 19 As a creative musician you would like to monetize your ability by copyrighting all possible sequences of tones drawn from a 6-note instrument (say, the kazoo).  How many combinations of these 6 notes are there if each note is played once for the same duration?  The answer is given by 6 factorial (or 6!). N! = N * (N-1) * (N-1) * … * 2 * 1  Write a function to read a value N from the user and compute the factorial of N. # factorial.py # This program computes the factorial of N (N must be a positive integer) def main(): print("This program computes the factorial") n = eval(input("Please enter a positive integer: ")) factorial = 1 for factor in range(n,1,-1): factorial = factorial * factor print("The factorial of ", n, "is", factorial) main() # factorial.py # This program computes the factorial of N (N must be a positive integer) def main(): print("This program computes the factorial") n = eval(input("Please enter a positive integer: ")) factorial = 1 for factor in range(n,1,-1): factorial = factorial * factor print("The factorial of ", n, "is", factorial) main()

20. Example Consider the following infinite series:  1 + 1/1! + 1/2! + 1/3! + 1/4! + … This series is equal to the value “e” or 2.71828… Write a program to compute the value of this series for the first N terms.

21. Numbers (again) Not only are ints and floats supported, but so are complex values.  A complex value is a point on the complex plane  The imaginary unit j corresponds to the solution of: j**2 = -1  A complex number is given by two values: the real and imaginary components. A complex value can be constructed using  3+2j  complex(3, 2) Operators support complex arithmetic  (3+2j)*(5-2j)  (3+2j)-complex(5,-2)  (1+2j)/(1+1j) A complex value has two attributes  x = 3 + 2j  x.real  x.imag

22. Booleans There is a 'bool' data type with two values  True  False Three Boolean operators: or, and, not The two binary operators are short-circuit ExpressionResult x or yif x is false then y else x x and yif x is false then x else y not xif x is false then True else False

23. Comparisons There are eight comparison operations in Python. Each of these operators produces a bool. OperatorDescription a < bless than a <= bless than or equal to a > bgreater than a >= bgreater than or equal to a == bequal a != bnot equal isobject identity is notnegated object identity

24. Comparisons Unlike Java, comparisons can be chained  x < y <= z is equivalent to x < y and y <= z except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false).

25. Booleans All python values have a truthiness (similar to JavaScript). Any object can be used where a Boolean is needed. The following values are "falsey"  None  False  0, 0.0, 0+0j  Any empty sequence or map  Any object that overrides methods in a certain way The following values are "truthy"  Everything not listed above

26. Examples What are the values of the following?  1<2 and 3<5  1<2 or 5<3  5<1 or 5<2  1<2<3  "" or 2<5  "Hello" and "World"  "Jim" or "Jill"  [1,2,3] and [4,5,6]

27. Bitwise Operators Bitwise operations only apply to integers. Bitwise operators apply logical operations to bits of an integer. OperatorDescription x | ybitwise or x ^ ybitwise exclusive or x & ybitwise and x << nleft shift x >> nright shift ~xinvert (negate)

28. Bitwise For the bitwise operators  1 is True  0 is False Consider the least significant three bits of an int. 5 | 13 0101 1001 1101 5 & 13 0101 1001 0001 5 >> 1 0101 0010 5 << 1 0101 1010 5 ^ 13 0101 1001 1100