A Brief Python Introduction¶
Keith Maull
Jan. 03, 2019
Python is a general purpose programming language that is ...¶
- interpreted
- dynamically typed (not statically typed)
- intuitive
- fun and addictive
Python syntax can be learned very quickly¶
- indentation matters
- there are no curly braces, semicolons or tricks ...
- the syntax is one of the true joys of the language once you learn not to fight it
We will learn 80% of the syntax today in 1 hour!¶
In [1]:
a_simple_list = ['a', 'b', 'c', 'd']
if a_simple_list[0] == 'a':
print("The first item of the list is an `a`")
In [2]:
for item in a_simple_list:
print(item)
In [3]:
count = 0
while (count < 5):
print(count)
count+=1
In [4]:
# functions are easy
def my_func(x, y):
return x*y
my_func(3,4)
Out[4]:
Python has many modules (aka "libraries") that do fun things¶
In [5]:
# random numbers generator
import random
print(random.randint(0,100))
In [6]:
# http library
import requests
r = requests.get("https://raw.githubusercontent.com/atebits/Words/master/Words/en.txt")
if r.status_code == 200:
data = r.text
print(data[:1000])
And a strength of the language is text processing ...¶
In [7]:
data.split('\n')[:10]
Out[7]:
In [8]:
top_100_five_letter_words = []
for w in data.split('\n'):
if len(w) == 5:
top_100_five_letter_words.append(w)
if len(top_100_five_letter_words) == 100:
break
print(top_100_five_letter_words)
In [9]:
top_100_five_letter_words_ending_in_g = []
for w in data.split('\n'):
if len(w) == 5 and w[-1] is 'g':
top_100_five_letter_words_ending_in_g.append(w)
if len(top_100_five_letter_words_ending_in_g) == 100:
break
print(top_100_five_letter_words_ending_in_g)
json support is excellent (as it should be)¶
In [10]:
import json
import requests
r = requests.get("https://raw.githubusercontent.com/LearnWebCode/json-example/master/pets-data.json")
if r.status_code == 200:
pet_data = json.loads(r.text)
print(data)
In [11]:
pet_data['pets'][0]
Out[11]:
Regular expressions ... also very accessible¶
In [12]:
# regular expressions
import re
s = r'^t.*ers$' # all words starting with `t` ending in `ers`
for w in data.split('\n'):
if re.match(s, w):
print(w)
There are many thousands of libraries to get lost in ...¶
Data types in Python are simple and complete ...¶
- You are already familiar with these:
- numbers (
1,1.87,-0.88, ...) - strings (
"Hello",'Hello') - Boolean (
True,False) None
- numbers (
In [13]:
### No surprises here ...
In [14]:
1 + 2
Out[14]:
In [15]:
'hello' + "Hello"
Out[15]:
Iterables are an important type category that includes:¶
- lists
- tuples
- sets
Lists are just like arrays ...¶
In [16]:
lst = [1, 2, "three"]
print(lst[1])
In [17]:
for i in lst:
print(i, end=" ")
In [18]:
lst + ['a', 'b']
Out[18]:
Python doesn't require you to keep up with indices ...¶
- but if you need them (which you rarely will) use
enumerate
In [19]:
for idx, l in enumerate(lst):
print("{}:{}".format(idx, l), end=" ")
You can also do cool things with list access ...¶
In [20]:
lst[-1]
Out[20]:
In [21]:
lst[0:2]
Out[21]:
In [22]:
lst[::-1]
Out[22]:
Tuples are another useful type¶
- they are just immutable lists
- and denoted
(1, 2, 'three)
Sets are also valuable¶
In [23]:
set([1,1,1,1,1,1,2,3,4,5,5,5,5,5,5,5])
Out[23]:
In [24]:
setA = set([1,2])
setB = set([1,2,3,4,5])
setA.union(setB)
Out[24]:
In [25]:
setA.difference(setB)
Out[25]:
In [26]:
setB.difference(setA)
Out[26]:
In [27]:
setA.intersection(setB)
Out[27]:
Dictionaries are also a crucial type in the language¶
- associative arrays
- key/value pairs
In [28]:
d = {"a": 5, "b": 6}
print(d)
In [29]:
d = dict([('a', 5), ('b', 6)])
print(d)
Providing the usual suspects ...¶
In [30]:
d['a']
Out[30]:
In [31]:
d.keys()
Out[31]:
In [32]:
d.values()
Out[32]:
In [33]:
for key, value in d.items():
print("{}=>{}".format(key, value))
Python logic operators are intuitive¶
- you've seen
inandis - but there is
not,not in,is not,and,or
In [34]:
1 is 2
Out[34]:
In [35]:
1 is not 2
Out[35]:
In [36]:
True and True
Out[36]:
In [37]:
True or False
Out[37]:
In [38]:
False or False
Out[38]:
In [39]:
False is not True
Out[39]:
In [40]:
s = 'supercalifragilistic'
In [41]:
'u' in s
Out[41]:
In [42]:
'z' not in s
Out[42]:
In [43]:
lst = ['a', 'b', 1, 2, 3]
In [44]:
'a' in lst
Out[44]:
In [45]:
s == 'supercalifragilistic'
Out[45]:
In [46]:
s is 'supercalifragilistic'
Out[46]:
In [47]:
lst == ['a', 'b', 1, 2, 3]
Out[47]:
In [48]:
lst is ['a', 'b', 1, 2, 3]
Out[48]:
Flow control in Python also includes all the usuals ...¶
if/elif/elseforwhile
In [49]:
s = 'this is a test'
if s[0] == 't':
print("the first letter is a 't'")
else:
print("the first letter is not a 't'")
In [50]:
for c in s:
print("{}".format(c))
In [51]:
# THIS IS NOT PYTHONIC! for is more elegant
i = 0
while(i < len(s)):
print("{}".format(s[i]))
i+=1
Python's built in functions are excellent¶
- There are about 69 functions
- some of the most common/useful are:
min,max,all,anyzip,range,len,map,sortedreversed
Let's play:¶
- PROBLEM: create a 16 character random password of upper, lower and number
- ONE SOLUTION: use what we know about the ASCII table and the
chr()built in function
HINT 1:
In [52]:
chr(122)
Out[52]:
In [53]:
import random
for i in range(0, 17):
# get a number in the ASCII range
while(True):
rnd_c = random.randint(48, 123)
if rnd_c < 58 or (rnd_c > 65 and rnd_c <91) or (rnd_c > 96 and rnd_c < 123):
break
print(chr(rnd_c), end="")
Functions are straightforward and intuitive¶
In [54]:
def a_function():
return 1
a_function()
Out[54]:
Function arguments (parameters) come in three flavors¶
- positional
- keyword
- mixed
Note: default values are allowed!
In [55]:
def a_function(a, b, c):
return a*b*c
a_function(1,2,3)
Out[55]:
In [56]:
def a_function(a=1, b=1, c=1):
return a*b*c
a_function(a=3,b=8,c=8)
Out[56]:
In [57]:
a_function(a=4)
Out[57]:
In [58]:
a_function(3,b=4,c=4)
Out[58]:
In [59]:
def a_function(a, b=1, c=1):
return a*b*c
a_function(6,b=8,c=8)
Out[59]:
In [60]:
a_function(6, 8, 8)
Out[60]:
Functions can return multiple values with tuples¶
In [61]:
def b_function():
return (1, 2, 3)
In [62]:
b_function()
Out[62]:
In [63]:
x, y, z = b_function()
print(x, y, z)
Exceptions are valuable for good code!¶
- Python supports
try/except/finallyand they should be used regularly
In [64]:
def c_function(a, b, c):
try:
if a<0:
raise Exception
return a*b*c
except Exception as e:
print("The first parameter cannot be less than zero.")
finally:
pass # we don't need to clean up anything after the exception
In [65]:
c_function(-1, 2, 3)
What did the function return from the exception???¶
ALL PYTHON FUNCTIONS IMPLICITLY RETURN None WHEN NO RETURN VALUE IS SPECIFIED
In [66]:
c_function(-1, 2, 3) is None
Out[66]:
Comprehensions¶
List comprehensions provide shorthand for building lists¶
In [67]:
l1 = [x for x in range(0,11)]
l1
Out[67]:
In [68]:
def pw_generator():
ascii_pw_range = list(range(48,58)) + list(range(65,91)) + list(range (97, 123))
return ''.join([chr(random.choice(ascii_pw_range)) \
for i in range(0,10)])
pw_generator()
Out[68]:
In [69]:
[pw_generator() for i in range(0,15)]
Out[69]:
Dictionary comprehensions are also quite nice ...¶
- Let's say you want to swap the key, value pairs in a dictionary ...
In [70]:
d1 = dict([('a', 1), ('b', 2), ('c', 3)])
{ v:k for (k,v) in d1.items() }
Out[70]:
- something more practical might be to filter out all values not meeting a criterion
In [71]:
d1 = dict([('a', 1), ('b', 2), ('c', 3)])
{ v:k for (k,v) in d1.items() if v%2 != 0}
Out[71]: