cs/coe 1520
Post on 05-Dec-2021
9 Views
Preview:
TRANSCRIPT
CS/COE 1520www.cs.pitt.edu/~nlf4/cs1520/
Python
Python
2
● Guido van Rossum started development on Python in 1989 as a project to keep him busy over the holiday break when his office was closed○ van Rossum was Python's
"Benevolent Dictator for Life"○ Worked for Google from
2005-2012, and worked at Dropbox from 2013-2019■ Both employers had him
spend 50% of his time working on Python
Guido van Rossum
● An interpreted language● Version 2.0 was released in Oct. 2000● Version 3.0 was released in Dec. 2008
○ 3.0 was a backwards-incompatible release■ Because of this Python 2.7 was actively used for many
years after the launch of 3.0■ 3.7 was released in 2018 Python
● This is the minimum version I will expect you to be using for the course
■ Be aware of the difference when checking online resources and running Python code on your computer!● You may need to use the command python3 if the default
python command is version 2.x○ You can check with:
■ $ python --version
Python
3
print("Hello World!")
Hello World
4
import random
# basic syntax overview exampler = random.randint(0, 100)while r < 85:
if r > 70:print(r, ": so close!", sep="")
elif r > 45: # yes, the else if syntax is odd...print(r, end="")print(": Getting there...")
else:print(f"{r}: Still so far away!")
r = random.randint(0, 100)print("OUT!")
Basic syntax
5
● Like JavaScript, Python is dynamically typed
● However, unlike JavaScript, Python is considered to be
strongly typed
○ 1 + "1" will raise an error
■ 1 + int("1") is fine, as is str(1) + "1"
○ 1 == "1" will evaluate to False
■ Not the same value, one is a string, one an int
■ Python does not have a === operator
Typing
6
● int
● float
○ 7 / 2
■ == 3.5
○ 7 // 2
■ == 3
○ 7.0 / 2.0
■ == 3.5
○ 7.0 // 2.0
■ == 3.0
Numerical types
7
● Generally the same as C
○ +, -, *, % all work as expected
○ No ++ or -- operators
○ Augmented assignments available, though (e.g., +=)
● Python-specific operators:
○ //
■ Integer division
○ **
■ Exponentiation
Numerical operators
8
● True
● False
● Comparison operators:
○ and
○ or
○ not
■ (True and False) or (not False) == True
Booleans
9
● Can be "double quoted"
● or 'single quoted'
● or """TRIPLE
QUOTED"""
○ '''triple singles also work'''
● Plenty of string methods available
○ Note specifically that they can be indexed and sliced
● No char type
Strings
10
String slicing
11
s = "slicing is fun!!"
print(s[0])print(s[2:7])print(s[-5])print(s[-5:-2])print(s[11:])print(s[:7])print(s[-5:])
def say_hi():print("Hi")
def shout(message="Hi"):print(message, "!", sep="")
shout()
shout("I love python")
shout(message="And keyword arguments")
Functions
12
● function foo(x, y=4) {
return x + y;
}
f(3) == 7 // true
Default parameters
13
Consider the following:
14
Python functions have no required type annotation
def quacker(an_animal):
an_animal.quack()
So how can we ensure that an_animal has a .quack() method?
● We can't!
● This is an example of duck typing
○ "If it walks like a duck and it quacks like a duck, then it must
be a duck"
● What happens if it does not have a .quack() method?
● Immutable sequences
○ t = ("CS", 1520, "Farnan")
○ t[2] = "Garrison" # ERROR!
Tuples
15
● How do you create an empty tuple?
● How about a tuple with only 1 item in it?
Special cases with tuples
16
● Note that the () can be omitted in tuple definition:
○ s = "CS", 1520, "Farnan"
○ t == s # True
● Further tuples can be "unpacked":
○ a, b, c = t
■ a == "CS"
■ b == 1520
■ c == "Farnan"
Tuple packing and unpacking
17
● Tuples can be used to make it seem like a function returns
multiple values:
def mult_ret():
return "one", "two", "three"
a, b, c = mult_ret()
Returning tuples
18
● Mutable sequences
○ l = [1, 2, 5]
l[0] = 0
l.append(3)
○ if 3 in l:
print(3, "is in", l)
Lists
19
● Key/value stores
○ d = {"Farnan":1520, "Garrison":8}
d["Ramirez"] = 1501
d["Garrison"] = "0008"
○ is "0008" in d ?
○ is "Garrison" in d ?
Dictionaries
20
● Unordered collections with no duplicate elements
○ s = {1, 2, 2, 3, 3, 3}
○ print(s)
Sets
21
● Already saw a while example…
● Only one type of for loop:
○ crazy_list = ["a", 1, 1.0, "d"]
for item in crazy_list:
print(item)
Looping
22
● We can use the range() function:
○ for i in range(10):
print(i)
● Generates a range object to lazily produce values
○ for i in range(1000000000):
print(i)
● Can be called with 1, 2, or 3 arguments:
○ range(end)
○ range(start, end)
○ range(start, end, step)
What about generating a sequence of numbers?
23
● crazy_dict = {1:"one", 2:"two", 3:"three"}
● for k in crazy_dict:
print(k, crazy_dict[k])
● for k, v in crazy_dict.items():
print(k, v)
Can loop over dictionaries as well:
24
● Succinct way to initialize lists:
○ squares = [x**2 for x in range(10)]
○ names = ["NICK", "FARNAN"]
low = [n.lower() for n in names if n == "NICK"]
List comprehensions
25
● Lists, range objects, etc. are iterable
○ Meaning that an iterator can be created for either type
■ Iterators must implement the method __next__()
● Successive calls to __next__() will iterate through the items
in the collection
● When no more items remain in the collection, all future calls
to __next__() should raise a StopIteration exception
■ Can be created via the iter() function
Iterators
26
● try:result = x / y
except ZeroDivisionError:print("division by zero!")
else:print("result is", result)
finally:print("executing finally clause")
● try:raise Exception("foo", "bar")
except Exception as e:print(e)print(type(e))print(e.args)
Exceptions and try statements
27
● This:○ crazy_list = ["a", 1, 1.0, "d"]
for item in crazy_list:
print(item)
● Is essentially:○ temp_iter = iter(crazy_list)
while True:
try:
item = temp_iter.__next__()
except StopIteration:
break
print(item)
Breakdown of a for loop
28
● len()
● sorted()
● min(), max()
● int(), str(), bool(), float()
● repr()
● type()
● help()
● …
Handy built-in functions:
29
● set()
○ Produces an empty set, printed as "set()" to avoid ambiguity
with an empty dict
● set([1, 2, 2, 3, 3, 3])
○ Produces {1, 2, 3}
● list(range(10))
○ Produces [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
● dict([("k1", "v1"), ("k2", "v2"), ("k3", "v3")])
○ Produces {'k1':'v1', 'k2':'v2', 'k3':'v3'}
Collection function examples
30
● Anonymous functions, similar to arrow functions in JS:
○ lambda params: expression
○ lambda x: x ** 2
○ lambda x, y: x + y
● E.g., sorting a dictionary by its values:
○ a_dict = {1:"one", 2:"two", 3:"three"}
list_of_tups = sorted(a_dict.items(), key=lambda t: t[1])
Lambda expressions
31
● Functions that use the yield keyword to return values in order to create iterators○ State is maintained between function calls to the generator
○ def enum(seq):n = 0for i in seq:
yield n, in += 1
○ def fibonacci():i = j = 1while True:
r, i, j = i, j, i + jyield r
Generators
32
● function* fib() {
let p = 0, c = 1;
while (true) {
yield c;
let temp = p;
p = c;
c = p + temp;
}
}
Generators
33
@plus_onedef add(x, y):
return x + y
Decorators
34
def plus_one(original_function):def new_function(x, y):
return original_function(x, y) + 1return new_function
● outf = open("example.txt", "w")for i in range(10):
outf.write(str(i) + "\n")outf.close()
● inf = open("example.txt")for line in inf:
print(line.strip())inf.close()
Basic File I/O
35
with open("example.txt") as inf:for line in inf:
print(line.strip())
Contexts and the with statement
36
Defining your own contexts
37
from contextlib import contextmanager
@contextmanagerdef tag(name):
print(f"<{name}>")yieldprint(f"</{name}>")
with tag("h1"):print("foo")
class Person:def __init__(self, name, age):
self.name = nameself.age = age
def display(self):print("Name:", self.name)print("Age:", self.age)print()
Basic OO
38
class Student(Person):def __init__(self, name, age):
super().__init__(name, age)
self.classes = []
def add_class(self, new):self.classes.append(new)
def display(self):super().display()print("Classes:", self.classes)print()
Basic Inheritance
39
class Dog:
tricks = []
def __init__(self, name):
self.name = name
def add_trick(self, trick):
self.tricks.append(trick)
f = Dog("Fido")
b = Dog("Buddy")
f.add_trick("roll over")
b.add_trick("play dead")
print(f.tricks)
Class variables
40
class Dog:
def __init__(self, name):
self.tricks = []
self.name = name
def add_trick(self, trick):
self.tricks.append(trick)
wow such instance variables
41
● Any Python file is a module that can be imported into other Python modules with import
● Let a.py contain:○ def print_n():
for i in range(10):print(i)
def print_l():for l in ["a", "b", "c"]:
print(l)
● Can then (in other files):○ import a
a.print_n()○ from a import print_l
print_l()
Modules
42
● Consider:
○ Running python a.py from the command line
○ Having import a in another Python file
● How can we have the former produce output while still being
able to use the latter to pull in definitions??
○ Both will evaluate each line of a.py
○ However, python a.py will have __name__ set to "__main__"
○ Hence, we can choose what to do if run as a script:
■ At the end of a.py, have:
● if __name__ == "__main__":
print("Producing output!")
Writing Python files
43
● So far we've only discussed built-ins and the standard library
○ I.e., modules that any Python install should have available
● When we start using Python to build web apps, we'll need
libraries that aren't available by default
○ Meaning they'll need to be specifically installed
● To ease management of other libraries, Python has the
Python Package Index (PyPI)
○ Similar to npm, ruby gems, or crates.io for NodeJS, Ruby, and
Rust, respectively
Additional Python libraries
44
● Library code will change over time
○ If you build your app to work on the current version of the
library, what if functionality that it depends on is broken in a
future version?
○ What if you want to maintain two different apps built on
different versions of the same library?
● Solution:
○ Virtual environments
■ Essentially per-application installs of Python packages
Dealing with different library versions
45
● Create a new environment:○ $ python -m venv virtual_env_name
■ If your default python is python2, then:● $ python3 -m venv virtual_env_name
■ Creates a folder named virtual_env_name containing:● A copy of the Python interpreter● A copy of the Python standard library● Copies of Python packages
● Start the virtual environment:○ $ source virtual_env_name/bin/activate
■ For bash/zsh, see other options in bin/ for fish/csh
● Leaving the virtual environment○ The command deactivate is available while in the venv:
■ $ deactivate
venv
46
● Once inside the virtual environment, you can install packages
from PyPI into the virtual environment using pip
● You can install packages using pip:
○ $ pip install pkg_name
● You can store the list of/versions of installed packages:
○ $ pip freeze > requirements.txt
● requirements.txt can then be used to recreated the virtual
environment on another machine:
○ $ pip install -r requirements.txt
pip
47
● This is only a brief introduction to Python● There are many topics that we neared by did not touch
upon○ E.g.,
■ Multiple inheritance■ Packages■ Protocols
● E.g., ○ Containers○ Iterators○ Context Managers
■ …
To wrap up…
48
top related