Python essentials: data types¶
Description: Variables and memory, binary operations, logical expressions, composite variables types.
Plan for the video¶
- Names and comments
- Variables and memory
- Binary operations
- Logical expressions
- Composite variables types
📖 Kevin Sheppard “Introduction to Python for Econometrics, Statistics and Data Analysis.” Chapters: 3, 5, 10, 11, 13, 18, 22
Intro¶
- General–purpose programming language
- Open source
- High level language: slower in general but easier to write code and develop software
- With special tools and for particular problems is fast (approaching low level languages)
Native Python and the Scientific Stack (Python modules)¶
- NumPy implements fast array processing — vectorization
- SciPy is a collection of functions of common scientific operations (optimization, root finding, linear algebra, interpolation, numerical integration, etc.)
- Pandas is data manipulation package with special data types and methods
- Matplotlib is package for making figures and plots
Today: talking about core Python
Coding standard: PEP8¶
Python Enhancement Proposal 0008
https://www.python.org/dev/peps/pep-0008/
- Indentation: 4 spaces per level
- Max line length: 79 characters
- White space: around binary operations + according to precedence of operations
- Comments and docstrings
- Naming conventions
Names and comments¶
Names of variables $ \exists $ certain rules: can only contain numbers, letters (both upper and lower) and underscores (_)
Reserved words: and as assert break class continue def del elif else except exec finally for from global if import in is lambda not or pass print raise return try while with yield
Comments made with # at any location of a line
In [1]:
# This is a comment
Basic variable types¶
- Boolean
- Integer
- Floating point numbers
- Complex numbers
- Strings
In [2]:
x = False
y = True
x and y
Out[2]:
False
In [3]:
y = 1 < 5
y = y and (4 < 8)
y
Out[3]:
True
Check that at least one condition is satisfied¶
In [4]:
# Modify the code appropriately
z = (1 < 0)
z = (2 >= 4)
z = (5 <= 5)
z = (2 > 4)
z
Out[4]:
False
Integer¶
In [3]:
import sys
x = 1
print("x is %r" % x)
print("Type of x is %s" % type(x))
y = 0b1011 #binary (base=2)
# y = 0x10f #hex (base=16)
print("y is %r" % y)
print("Type of y is %s" % type(y))
print("y takes %d bytes in memory" % sys.getsizeof(y))
x is 1 Type of x is <class 'int'> y is 11 Type of y is <class 'int'> y takes 28 bytes in memory
Biggest integer that can be stored in memory¶
In [4]:
y = 0b1111111111111111111111111111110
# 1234567890123456789012345678901234567890
y = 0x1afe
print("y is %r" % y)
print("Type of y is %s" % type(y))
print("y takes %d bytes in memory" % sys.getsizeof(y))
y is 6910 Type of y is <class 'int'> y takes 28 bytes in memory
Python adjusts the memory for integers as to fit large numbers!
Arithmetics with integers¶
In [5]:
a = 155
b = 7
c=a+b
print("%d + %d = %r (%s)" % (a,b,c,type(c)))
155 + 7 = 162 (<class 'int'>)
In [6]:
c=a-50*b
print("%d - 50*%d = %r (%s)" % (a,b,c,type(c)))
155 - 50*7 = -195 (<class 'int'>)
Automatic casting¶
In [7]:
a = 155
b = 7
c = a**b
print("%d ^ %d = %r (%s)" % (a,b,c,type(c)))
c = a/b
print("%d / %d = %r (%s)" % (a,b,c,type(c)))
155 ^ 7 = 2149422977421875 (<class 'int'>) 155 / 7 = 22.142857142857142 (<class 'float'>)
Python adjusts the type of integers as to fit the result of arithmetic operation!
Integer division and remainder¶
In [8]:
a = 155
b = 7
c = a//b
print("%d // %d = %r (%s)" % (a,b,c,type(c)))
c = a%b
print("%d %% %d = %r (%s)" % (a,b,c,type(c)))
155 // 7 = 22 (<class 'int'>) 155 % 7 = 1 (<class 'int'>)
Booleans and integers¶
In [9]:
import sys
x = 15 > 10
print("x is %r" % x)
x is True
In [10]:
print("Type of x is %s" % type(x))
print("x takes %d bytes in memory" % sys.getsizeof(x))
Type of x is <class 'bool'> x takes 28 bytes in memory
In [11]:
y = 36
print("Type of y is %s" % type(y))
print("y takes %d bytes in memory" % sys.getsizeof(y))
Type of y is <class 'int'> y takes 28 bytes in memory
In [12]:
print(bool.__bases__) #see that boolean is a subclass of integer
(<class 'int'>,)
Arithmetics with booleans¶
In [13]:
z = (1 < 5) - 5
z
Out[13]:
-4
In [14]:
x = 15
z = x * (x > 10) + x**2 * (x < 10)
z
Out[14]:
15
What if $ x=10 $ in the last example?
Precedence of binary operators¶
- Power (**)
- Multiple/devide
- Plus/minus
- Comparison operators (< >)
- Equality operators (== !=)
- Logical operators (and not or)
In [15]:
y = 5 - 4 > True
y
Out[15]:
False
In [16]:
y = 6 < 10 <= 15
y
Out[16]:
True
In [17]:
y = 5 / 2**4 < 10 or 15
y
Out[17]:
True
Good practice¶
Use brackets to avoid ambiguity!
Float (floating point number)¶
Representation for real numbers
In [18]:
x = 183.0
print("x is %r" % x)
print("Type of x is %s" % type(x))
x is 183.0 Type of x is <class 'float'>
Floats have min and max limits¶
In [19]:
print("x takes %d bytes in memory" % sys.getsizeof(x))
sys.float_info
x takes 24 bytes in memory
Out[19]:
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
Special values: Inf, -Inf, NaN¶
In [20]:
x = 1.79769319e+308
print("x is %r" % x)
print("Type of x is %s" % type(x))
print("x takes %d bytes in memory" % sys.getsizeof(x))
x is inf Type of x is <class 'float'> x takes 24 bytes in memory
In [ ]:
import math as m
# import numpy as m
x = m.log(0) # implementations may vary in different packages/libraries!
print("x is %r" % x)
print("Type of x is %s" % type(x))
print("x takes %d bytes in memory" % sys.getsizeof(x))
Complex numbers¶
Representation for imaginary numbers
In [23]:
x = 1j+5
print("x is %r" % x)
print("Type of x is %s" % type(x))
print("x takes %d bytes in memory" % sys.getsizeof(x))
x is (5+1j) Type of x is <class 'complex'> x takes 32 bytes in memory
Euler formula¶
$$ e^{i \pi}+1 = 0 $$In [24]:
from cmath import exp, pi
x=1j
x = exp(x*pi)+1
print("x is %r" % x)
print("|x| is %1.20f" % abs(x))
print("Type of x is %s" % type(x))
print("x takes %d bytes in memory" % sys.getsizeof(x))
x is 1.2246467991473532e-16j |x| is 0.00000000000000012246 Type of x is <class 'complex'> x takes 32 bytes in memory
Strings¶
In [25]:
s='Hellow world'
print("s is %r" % s)
print("Type of s is %s" % type(s))
print("Length of \"%s\" is %d" %(s,len(s)))
print("s takes %d bytes in memory" % sys.getsizeof(s))
s is 'Hellow world' Type of s is <class 'str'> Length of "Hellow world" is 12 s takes 61 bytes in memory
Slicing strings¶
In [26]:
s='Australian National University'
# 012345678901234567890123456789
print("s[0:9] is %r" % s[0:9]) # from 1st up to and excluing 9th
print("s[:9] is %r" % s[:9]) # the same
print("s[11:] is %r" % s[11:]) # from 11th till the end
print("s[-10:] is %r" % s[-10:]) # 10th last till the end
print("s[::3] is %r" % s[::3]) # from beginning to end with step 3
print("s[0:0:-1] is %r" % s[::-1]) # from end till beginning with step -1 (reverse order)
s[0:9] is 'Australia' s[:9] is 'Australia' s[11:] is 'National University' s[-10:] is 'University' s[::3] is 'Atlnaolnei' s[0:0:-1] is 'ytisrevinU lanoitaN nailartsuA'
Slicing strings puzzle¶
In [27]:
s='jde4jecc doij naajo rdmp hin0icbdrs1cgdhttuif 7gjxm'
# 012345678901234567890123456789012345678901234567890
print("s[0:9] is %r" % s[::]) # output "economics"
s[0:9] is 'jde4jecc doij naajo rdmp hin0icbdrs1cgdhttuif 7gjxm'
Strings in the memory¶
In [28]:
s=''
for i in range(10):
s=s + 'a'
print("Memory(\"%s\", %d symbols) = %d bytes"%(s,len(s),sys.getsizeof(s)))
Memory("a", 1 symbols) = 50 bytes
Memory("aa", 2 symbols) = 51 bytes
Memory("aaa", 3 symbols) = 52 bytes
Memory("aaaa", 4 symbols) = 53 bytes
Memory("aaaaa", 5 symbols) = 54 bytes
Memory("aaaaaa", 6 symbols) = 55 bytes
Memory("aaaaaaa", 7 symbols) = 56 bytes
Memory("aaaaaaaa", 8 symbols) = 57 bytes
Memory("aaaaaaaaa", 9 symbols) = 58 bytes
Memory("aaaaaaaaaa", 10 symbols) = 59 bytes
Integers in the memory¶
In [29]:
x=2
for i in range(10):
x**=2
print("Memory(\"%d\") = %d bytes"%(x,sys.getsizeof(x)))
Memory("4") = 28 bytes
Memory("16") = 28 bytes
Memory("256") = 28 bytes
Memory("65536") = 28 bytes
Memory("4294967296") = 32 bytes
Memory("18446744073709551616") = 36 bytes
Memory("340282366920938463463374607431768211456") = 44 bytes
Memory("115792089237316195423570985008687907853269984665640564039457584007913129639936") = 60 bytes
Memory("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096") = 96 bytes
Memory("179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216") = 164 bytes
Floats in the memory¶
In [30]:
x=2.0
for i in range(10):
x**=2
print("Memory(\"%e\") = %d bytes"%(x,sys.getsizeof(x)))
Memory("4.000000e+00") = 24 bytes
Memory("1.600000e+01") = 24 bytes
Memory("2.560000e+02") = 24 bytes
Memory("6.553600e+04") = 24 bytes
Memory("4.294967e+09") = 24 bytes
Memory("1.844674e+19") = 24 bytes
Memory("3.402824e+38") = 24 bytes
Memory("1.157921e+77") = 24 bytes
Memory("1.340781e+154") = 24 bytes
--------------------------------------------------------------------------- OverflowError Traceback (most recent call last) <ipython-input-30-83fdb77b502f> in <module> 1 x=2.0 2 for i in range(10): ----> 3 x**=2 4 print("Memory(\"%e\") = %d bytes"%(x,sys.getsizeof(x))) OverflowError: (34, 'Result too large')
Assignment operator¶
In [31]:
a = 21
b = 10
c = 2
b **= c
print ("Line 1 - Value of b is %d" % b)
c *= a
print ("Line 2 - Value of c is %d" % c)
c -= a
print ("Line 3 - Value of c is %d" % c)
Line 1 - Value of b is 100 Line 2 - Value of c is 42 Line 3 - Value of c is 21
Id(.) function returns unique int for a variable (reference)¶
Python implements complex memory management system to avoid unnecessary memory allocation
In [32]:
x = 10
print("Initial id(x) is %s" % id(x))
y = x
print(" id(y) is %s" % id(y))
y +=x
print(" Now id(y) is %s" % id(y))
Initial id(x) is 4469753248
id(y) is 4469753248
Now id(y) is 4469753568
Composite variable types¶
- List Collection of variables of any types, can be sliced like strings
- Tuple Same as list but immutable (can not be edited)
- Dictionary Pairs of keys and values
- Set Unique elements of a collection (also has immutable counterpart)
- Range Sequence of integers, useful for loops in the code!
Lists and tuples¶
In [33]:
x = [True, 5, 5.2, 'string',] # trailing comma is ignored
y = (True, 5, 5.2, 'string',)
print("x is %r" % x)
print("Type of x is %s" % type(x))
print("x takes %d bytes in memory" % sys.getsizeof(x))
print()
print("y is (%r,%r,%r,%r)" % y)
print("Type of y is %s" % type(y))
print("Y takes %d bytes in memory" % sys.getsizeof(y))
x is [True, 5, 5.2, 'string'] Type of x is <class 'list'> x takes 104 bytes in memory y is (True,5,5.2,'string') Type of y is <class 'tuple'> Y takes 88 bytes in memory
Lists vs tuples¶
In [34]:
x = [True, 5, 5.2, 'string',] # last comma is ignored
y = (True, 5, 5.2, 'string',)
x[0] = 567; # lists are mutable
y[0] = 567; # tuples are immutable -> ERROR
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-34-afe959f6c3e1> in <module> 3 4 x[0] = 567; # lists are mutable ----> 5 y[0] = 567; # tuples are immutable -> ERROR TypeError: 'tuple' object does not support item assignment
Typical list operations¶
In [35]:
x = [True, 5, 5.2, 'string', 4, 4+2j, 'again']
print( x[0] ) # first element
print( x[1:-1] ) # slicing as with strings
print( len(x) ) # length of the list
x.append(586) # add a value at the end
print(x)
x.pop(3) # remove fourth element
print(x)
True [5, 5.2, 'string', 4, (4+2j)] 7 [True, 5, 5.2, 'string', 4, (4+2j), 'again', 586] [True, 5, 5.2, 4, (4+2j), 'again', 586]
Further learning resources¶
- Python book: Kevin Sheppard “Introduction to Python for Econometrics, Statistics and Data Analysis.” 3rd Edition University of Oxford Thursday 1st February, 2018.
- Precedence of binary operations https://www.tutorialspoint.com/python/operators_precedence_example.htm
- Euler formula https://www.youtube.com/watch?v=F_0yfvm0UoU
- Euler formula https://www.youtube.com/watch?v=-dhHrg-KbJ0
- Documenting your code https://realpython.com/documenting-python-code/