2017-03-19T12:34:05Z

Eroman:

= About =

This class is python for beginners, taugh Spring 2017

== Contact ==

My email is [mailto:eroman@itcollege.ee eroman@itcollege.ee]

= Frequently Asked Questions =

== What should I know already ==

It would be good to know:

* How to use the unix command line
* GIT

== What editor/IDE should I use? ==

Whatever you want! I recommend learning emacs or vim. If you do not know how to use any specific editor and do not want to learn one now, then use spyder for writing python.

== What python version are we using? ==

I will teach using python 3

== What books/resources do you recommend? ==

This page contains most of python's syntax: https://learnxinyminutes.com/docs/python3/

== What software do I need to install? ==

You only need python 3 and an editor.

I recommend that you install an interactive python shell, like IPython[https://ipython.org/ 1] or bpython[https://bpython-interpreter.org/ 2]

= Grading =

There will be a test on the last day. It is pass/fail. You may do a project instead of the test. I recommend this, since it will be more fun and you will learn more.

== Test ==

The test will cover only builtin python types and only use the standard library. There will be 3 test dates. The format will be A series of unit test cases which you must write a function that will make the unit test pass.

You may use the internet during the exam.

=== Test dates ===

Primary date: Thursday March 23rd, starting at 8:15AM

Makeup date 1: in june, TBA

Makeup date 2: in august, TBA

=== Test topics ===

* <code>if</code>, <code>elif</code>, <code>else</code> statements
* functions
* lists and dictionaries
** see https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lists
* for loops
* basic string manipulation

=== Example problem ===

<source lang="python">from unittest import TestCase

class StringCountTestCase(TestCase):
"""
Write a function that for any string, prepends 'Hello '
>>> test_function('Bob')
'Hello Bob'
"""
def setUp(self):
self.test_function = None # Assign to your function

def test_sally(self):
result = self.test_function('Sally')
self.assertEqual(result, 'Hello Sally')
</source>
=== Example solution ===

<code>python3 -m unittest exam.py</code>

<source lang="python">from unittest import TestCase

def prepend_hello(string):
return "Hello {}".format(string)

class StringCountTestCase(TestCase):
"""
Write a function that for any string, prepends 'Hello '
>>> test_function('Bob')
'Hello Bob'
"""
def setUp(self):
self.test_function = prepend_hello

def test_sally(self):
result = self.test_function('Sally')
self.assertEqual(result, 'Hello Sally')
</source>
=== Practice Test ===

https://gist.github.com/evrom/4f8158b2613cb80c5050e7315fa309cc

== Project due date ==

The project is due the class before the last class (March 16th). You may submit your project before then, and I will check it. If It does not meet the requirements, I will give you feedback.

To present your project, come at 10:00AM on the last day of class (Thursday, March 23rd)

== Project Requirements ==

* it can do something
* it uses version control
** it has more than one commit
** it has commit messages that are relevant to the commit
* it has a relevant unit test
* it has a README that describes what it does and how to run it.

== Project idea examples ==

* a game
* exploring a technology like image recognition
* a command line tool that does something
* a web application in python
** [http://flask.pocoo.org/ Flask] is simple and has good documentation for building a website
** for a website that would require users to sign up and login, consider [https://www.djangoproject.com/ Django]
* a web scraper
* many websites have HTTP APIs that can give you data, you can make something that uses data from public APIs.

=== If you want to do things with cryptography ===

* a cryptographic chat app
* a password storage bank like KeePassX

== Can I ...? ==

=== Can I use python 2? ===

Yes

=== Can I use external libraries outside of the standard library? ===

Yes

If you use external libraries, include a [https://pip.pypa.io/en/stable/user_guide/#requirements-files <code>requirements.txt</code>] or [https://docs.python.org/3/distutils/setupscript.html <code>setup.py</code>] which has a list of packages required by your project

== Project Tips ==

=== .gitignore ===

include a <code>.gitignore</code> file in the root directory of your project. This will prevent <code>.pyc</code> and <code>__pycache__</code> from being added to your git project.

You can save this file as <code>.gitignore</code>:<br />
https://github.com/github/gitignore/blob/master/Python.gitignore

= Lecture Notes =

== Recordings ==

recordings are found here: https://echo360.e-ope.ee/ess/portal/section/fc0c6bfd-9187-4365-b2c9-0085b3a89906

== Testing Python Code ==

https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/testing

== Lecture 1 ==

Basic types, lists, for-loops, functions, imports and classes https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lecture1

== Lecture 2 ==

importable modules, unit tests, dictionaries https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lecture2

== Lecture 3 ==

Command line arguements, opening and using files, csv files https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lecture3

=== Assets ===

file to count words in: http://pastebin.com/3faqcc5j csv file: https://docs.google.com/spreadsheets/d/1uSbHeppEyKNxF0WncvhxTBF8wj_co0v5XOYlXKLL8Lg/edit?usp=sharing

== Lecture 4 ==

Exceptions, slices, Http request to get JSON data, Basic dynamic website https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lecture4

== Lecture 5 ==

Advanced testing, datetime, python style guide. https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lecture5

=== survey ===

https://docs.google.com/forms/d/e/1FAIpQLSeCu0boQIBbRsCcgLovm0Jis3JLYnjD8JhCBlh4nQUPpF6N1Q/viewform

== Lecture 6 ==

List and Dictionary transformations and manipulations. Intro to numpy with linear algebra and intro to pandas with extracting data from a csv.<br />
https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lecture6

== Lecture 7 ==

Reduce function, using break and return for control flow, handling user input, handling errors

https://wiki.itcollege.ee/index.php/I719_Fundamentals_of_Python/lecture7

I719 Fundamentals of Python/lecture7

2017-03-19T12:24:21Z

Eroman: Created page with "= Advanced control flow = == Task 1 == Make a function that returns the sum of all elements in an iterable <source lang="python">>>> my_sum_function([2,3,5]) # 2 + 3 + 5 10..."

= Advanced control flow =

== Task 1 ==

Make a function that returns the sum of all elements in an iterable

<source lang="python">>>> my_sum_function([2,3,5])
# 2 + 3 + 5
10</source>
== all, sum, any ==

<code>all</code>, true if all elements are true<br />
<code>any</code>, true if any elements are true

== Task 2 ==

Find if all elements are false

<source lang="python">opposite_all([False, False])
>>> True</source>
== Task 3 ==

Implement <code>all</code> function with a for loop

<source lang="python">my_all([True, True])
>>> True</source>
== Break loops ==

== Task 4 ==

Implement <code>any</code> with a for loop, use a <code>break</code> statement

== Error Handling ==

* When to raise an exception
* handling user input

=== Example: Addition calculator ===

this calculator is error prone. Users can put in a value that cannot be cast to an integer, which will cause this programs to raise an error.

<source lang="python">def add_two_numbers(a, b):
return int(a) + int(b)

def main():
a = input('Write a number: ')
b = input('Write a number: ')
result = add_two_numbers(a, b)
print(result)

if __name__ == "__main__":
main</source>
giving an error like this on bad user input

<pre>Write a number: a
Write a number: 1
Traceback (most recent call last):
File "calc.py", line 12, in <module>
main()
File "calc.py", line 7, in main
result = add_two_numbers(a, b)
File "calc.py", line 2, in add_two_numbers
return int(a) + int(b)
ValueError: invalid literal for int() with base 10: 'a'
</pre>
==== With error handled ====

<source lang="python">def add_two_numbers(a, b):
return int(a) + int(b)

def main():
a = input('Write a number: ')
b = input('Write a number: ')
try:
result = add_two_numbers(a, b)
except ValueError:
print('you must type a valid integer!')
else:
print(result)

if __name__ == "__main__":
main()</source>
==== With checking before ====

<source lang="python">def add_two_numbers(a, b):
return int(a) + int(b)

def main():
a = input('Write a number: ')
b = input('Write a number: ')
if a.isdigit() and b.isdigit():
result = add_two_numbers(a, b)
print(result)
else:
print('you must type a valid integer!')

if __name__ == "__main__":
main()</source>
= Splats =

* dict as kwargs
* list as args

== Task: Sum of all arguments ==

=== Solution ===

<source lang="python">def sum_args(*args):
return sum(args)

if __name__ == "__main__":
print(sum_args(1, 3, 5)) # 9
</source>
=== Pass a list into the function ===

<source lang="python">def sum_args(*args):
return sum(args)

if __name__ == "__main__":
print(sum_args(*[1, 3, 5])) # 9
</source>

I719 Fundamentals of Python/testing

2017-03-16T09:01:48Z

Eroman:

= Basic Testing =

In the examples, <code>app.py</code>, <code>test_app.py</code> and <code>__init__.py</code> are all in the same directory. The tests are ran with the command <code>python3 -m unittest test_app.py</code>

== check the output of a function ==

<code>app.py</code>

<source lang="python">def get_hello_world():
return "Hello World!"</source>
<code>test_app.py</code>

<source lang="python">import unittest

from app import get_hello_world

class HelloWorldTestCase(unittest.TestCase):
def test_value(self):
result = get_hello_world()
self.assertEqual("Hello World!", result)</source>
== Check the side effect of a function ==

<code>app.py</code>

<source lang="python">class MyPrinter():
def __init__(self, value=None):
self.value = value

def print_value(self):
print(self.value)

def set_value(self, value):
self.value = value</source>
<code>test_app.py</code>

<source lang="python">import unittest

from app import MyPrinter

class HelloWorldTestCase(unittest.TestCase):
def test_value(self):
value = "Test Value"
my_printer = MyPrinter()
my_printer.set_value(value)
self.assertEqual(my_printer.value, value)</source>
= Advanced Testing =

== Testing the bitcoin price printer ==

You can convert

<code>btc_price.py</code>

<source lang="python">import requests

def main():
r = requests.get('https://api.coindesk.com/v1/bpi/currentprice.json')
data = r.json()
price = data['bpi']['EUR']['rate']
print(price)

if __name__ == '__main__':
main()</source>
to something with a testable function

<code>btc_price.py</code>

<source lang="python">import requests

def get_btc_price():
r = requests.get('https://api.coindesk.com/v1/bpi/currentprice.json')
data = r.json()
price = data['bpi']['EUR']['rate']
return price

if __name__ == '__main__':
print(get_btc_price())</source>
== Writing a Unit test ==

in the same directory, make a file that starts with <code>test_</code>. So for this example, the file is named <code>test_btc_price.py</code>. Also ensure an <code>__init__.py</code> file exists so you can import python modules in this directory.

<pre>├── btc_price.py
├── test_btc_price.py
├── __init__.py</pre>
`<br />
and then write a unit test on the value

<code>test_btc_price.py</code>

<source lang="python">import unittest

from btc_price import get_btc_price

class BtcPriceTestCase(unittest.TestCase):
def test_price_accurate(self):
price = get_btc_price() # The bitcoin returned changes over time!
self.assertEqual(price, '1000')</source>
and run using <code>python3 -m unittest btc_price_test.py</code>

This test will fail becuase the price of bitcoins change.<br />
so instead check that value is correct in another way.<br />
In this example, we check that the string value is floating point, like <code>1,101.12</code>. This is not as robust as checking if the value is correct. So if the value does not change, do not do this.

<code>btc_price_test.py</code>

<source lang="python">import unittest

from btc_price import get_btc_price

class BtcPriceTestCase(unittest.TestCase):
def test_price_format(self):
"""Test price is a string with correct format"""
price = get_btc_price() # The bitcoin returned changes over time!
price_without_comma = price.replace(',', '')
# if string `price_without_comma` cannot be converted to
# a float, then this line will raise an error.
# an unhandled error will cause the test to fail.
float(price_without_comma)</source>
== Testing IO dependent functions without doing the IO ==

In the previous Bitcoin price example, running the test also makes a HTTP request.

This means:

* our test will fail without internet
* our test will fail if the bitcoin price API changes or is down

You may want to test these things in your test. This would make our unittest more like a functional test.

You can stub out IO functions, and test if the function is correctly written, not that the price API works.

To do this with depedency inject, we must change our original code as well.

<code>btc_price.py</code>

<source lang="python">import requests

# use `requests` by default, but allow another library to be used
def get_btc_price(request_library=requests):
r = request_library.get('https://api.coindesk.com/v1/bpi/currentprice.json')
data = r.json()
price = data['bpi']['EUR']['rate']
return price

if __name__ == '__main__':
print(get_btc_price())</source>
<source lang="python">import json
import requests
import unittest

MOCK_RESPONSE_BODY ='''
{"time":{"updated":"Mar 4, 2017 11:00:00 UTC","updatedISO":"2017-03-04T11:00:00+00:00","updateduk":"Mar 4, 2017 at 11:00 GMT"},"disclaimer":"This data was produced from the CoinDesk Bitcoin Price Index (USD). Non-USD currency data converted using hourly conversion rate from openexchangerates.org","bpi":{"USD":{"code":"USD","symbol":"$","rate":"1,284.8250","description":"United States Dollar","rate_float":1284.825},"GBP":{"code":"GBP","symbol":"£","rate":"1,044.8261","description":"British Pound Sterling","rate_float":1044.8261},"EUR":{"code":"EUR","symbol":"€","rate":"1,209.5317","description":"Euro","rate_float":1209.5317}}}
'''

class MockResponse:
@staticmethod
def json():
return json.loads(MOCK_RESPONSE_BODY)

class MockRequests:
@staticmethod
def get(url):
# This will raise an `AssertionError` if the url that the function is called with is different than expected, causing the test to fail

assert url == 'https://api.coindesk.com/v1/bpi/currentprice.json'
return MockResponse()

class BtcPriceTestCase(unittest.TestCase):
def test_price_accurate(self):
# use the stub version for the test
price = get_btc_price(request_library=MockRequests())
# The value does not change now
self.assertEqual(price, '1,209.5317')

if __name__ == '__main__':
print(get_btc_price())
</source>
That was a lot of code. Forturnately python 3 has a library for making these mock objects. See https://docs.python.org/3/library/unittest.mock.html

<code>test_btc_price.py</code>

<source lang="python">import json
import unittest

from unittest.mock import Mock

MOCK_RESPONSE_BODY = '''
{"time":{"updated":"Mar 4, 2017 11:00:00 UTC","updatedISO":"2017-03-04T11:00:00+00:00","updateduk":"Mar 4, 2017 at 11:00 GMT"},"disclaimer":"This data was produced from the CoinDesk Bitcoin Price Index (USD). Non-USD currency data converted using hourly conversion rate from openexchangerates.org","bpi":{"USD":{"code":"USD","symbol":"$","rate":"1,284.8250","description":"United States Dollar","rate_float":1284.825},"GBP":{"code":"GBP","symbol":"£","rate":"1,044.8261","description":"British Pound Sterling","rate_float":1044.8261},"EUR":{"code":"EUR","symbol":"€","rate":"1,209.5317","description":"Euro","rate_float":1209.5317}}}
'''

class BtcPriceTestCase(unittest.TestCase):
def test_price_accurate(self):
# generate the mocks in the test function scope
mock_response = Mock()
mock_response.json = Mock(return_value=json.loads(MOCK_RESPONSE_BODY))

mock_requests = Mock()
mock_requests.get = Mock(return_value=mock_response)
price = get_btc_price(request_library=mock_requests)
# The value does not change now
self.assertEqual(price, '1,209.5317')</source>
== Patch ==

But we still had to change our function to support a changeable 'requests_library'. This is okay as well, and is normal in some languages. The practice is called Dependency Injection, and is used with object oriented design. But often in python, people will 'patch' a function when it is ran in a testing environment. This changes the body of the function in runtime.

see https://docs.python.org/3/library/unittest.mock.html#unittest.mock.patch

<code>test_btc_price.py</code>

<source lang="python">import json
import unittest
from unittest.mock import Mock, patch

from btc_price import get_btc_price

MOCK_RESPONSE_BODY = '''
{"time":{"updated":"Mar 4, 2017 11:00:00 UTC","updatedISO":"2017-03-04T11:00:00+00:00","updateduk":"Mar 4, 2017 at 11:00 GMT"},"disclaimer":"This data was produced from the CoinDesk Bitcoin Price Index (USD). Non-USD currency data converted using hourly conversion rate from openexchangerates.org","bpi":{"USD":{"code":"USD","symbol":"$","rate":"1,284.8250","description":"United States Dollar","rate_float":1284.825},"GBP":{"code":"GBP","symbol":"£","rate":"1,044.8261","description":"British Pound Sterling","rate_float":1044.8261},"EUR":{"code":"EUR","symbol":"€","rate":"1,209.5317","description":"Euro","rate_float":1209.5317}}}
'''

class BtcPriceTestCase(unittest.TestCase):
def test_price_accurate(self):
# generate the mocks in the test function scope
mock_response = Mock()
mock_response.json = Mock(return_value=json.loads(MOCK_RESPONSE_BODY))

mock_requests = Mock()
mock_requests.get = Mock(return_value=mock_response)
with patch('btc_price.requests', mock_requests):
price = get_btc_price()
# The value does not change now
self.assertEqual(price, '1,209.5317')
</source>
And you can omit the keyword argument for <code>request_library</code>, reverting to the original script<br />
<code>btc_price.py</code>

<source lang="python">import requests

def get_btc_price():
r = requests.get('https://api.coindesk.com/v1/bpi/currentprice.json')
data = r.json()
price = data['bpi']['EUR']['rate']
return price

if __name__ == '__main__':
print(get_btc_price())
</source>

= check the print value =

<source lang="python">
import unittest
from unittest.mock import Mock, patch

def print_hello():
print('Hello')

class PrintHelloTestCase(unittest.TestCase):
@patch("builtins.print",autospec=True)
def test_somethingelse(self, mock_print):
print_hello()
mock_print.assert_called_with("Hello")

if __name__ == '__main__':
print_hello()

</source>