文本序列类型

通过 itertools.islice() 可以实现 set dict 的切片操作。

去掉字符串头和尾的空格

用生成器来写中序遍历

函数体里包含 yield 关键字的函数都是生成器函数

生成器

如果表达式创建了一个元组,那么必须被圆括号包裹.

List Comprehensions 列表推导

Generator Expressions 生成器表达式

言外之意就是,如果调用 iter 之后没有报 TypeError, 说明该对象是可迭代的(iterable)

迭代器是一个代表数据流的对象

与 C++ 不同，key 形参用来指定进行比较前在每个列表元素上调用的函数。

After comparing the pipelined ML models, we can easily display a comparison boxplot.

Well working ML models: 1) XGBoost 2) LightGBM 3) CatBoost.

Training time of some popular ML models. After considering the performance, it's worth using XGBoost and LightGBM.

Example (below) of when creating pipelines with scikit-learn makes sense. Basically, it's convenient to use it while comparing multiple models in a loop

I suppose this is also an argument that Python tries to make? That other languages have this con:

• cons: closing tags make it more verbose / increase duplication and that Python is simpler / more concise because it uses indentation instead of closing delimiters like end or } ?

var_ 主要用来避免与关键字冲突

_var 这种单下划线对于解释器没有实际作用.程序员之间表示内部使用的公用做法

用下划线来表示没有用的变量

.get(key) 如果键存在返回相应的值，否则返回 None

len 函数返回字典中键值对的个数

用来检查键值是否在字典中。

当键值都是简单字符串的时候，键可以不用引号包裹。

Python对 dict 的值没有限制， 可以是任意类型（包括可变类型和自定义对象）

一个对象必须是不可变的才能用作 dict 的键。

这句话不是很准确。 严谨的说，一个对象必须是可哈希（hashable) 的，才可以用作 dict 的键。

dict 键值的限制：

1. 键不能重复
2. 键必须是不可变量（列表、字典不可以）

dict 键必须是不可修改的（immutable）

dict 键和值的类型不必相同

尽管 Python 中访问字典元素与顺序无关, 但是 Python 会保存字典中元素定义的顺序(Python 3.7 引入的新特性).

Python 中字典同样可以通过数字来访问,但是与列表不同的是,数字大小与元素的顺序没有关系.

https://realpython.com/python-defaultdict 可以参看这篇文章. defaultdict 可以处理 missing key 的情况.

注意: Python 中字典不能通过数字下标访问元素.

可以通过元素列表初始化字典.

dd = dict([('a',1),('b',2)])

Python 中字典和列表的相同点是:

1. 可以修改的
2. 动态变化,支持增加和缩减.
3. 支持嵌套. 列表中可以嵌套另一个列表, 字典可以包含另一个字典.字典也可以包含列表.

Python 中字典与列表的不同点:

1. 列表通过下标访问元素
2. 字典用过键值访问元素

这篇文章主要介绍了 Python 中字典处理缺省键值的方法。

引入了一个新的数据类型 defaultdict，并介绍了它访问和修改不存在键值时的机制。

主要是重写了 .missing__() 使得在通过 subscription operation 访问修改缺省键值时自动调用该方法，从而避免了dict 的 TypeError。

如果初始化 defaultdict 没有参数, 该变量蜕变成一个标准 dict。

不接受形参，并且返回一个值。

用 Python 的 defaultdict 处理不存在的键

想要学习 defaultdict 的原因: 看到 up 主在实现 DFS 的时候用到了这个语法

可以看到的是作者用到了对缺省键的访问操作。

注意 给 .default_factory 赋值的时候一定不要带括号。

当我们访问不存在键的时候，defaultdict 会自动将调用 default_factory 的值赋给该键。

如果对已存在的键调用 setdefault ，不会修改原值。

如果是缺省键，就会创建新的键值对。

处理缺省键的四种方式:

1. .setdefault()
2. .get()
3. key in dict
4. try and except

如果你想要访问或者修改一个缺省键值, defaultdict 会自动创建这个键然后生成一个默认值

这句子不错

Decide when and why to use a Python defaultdict rather than a standard dict.

augemented assignment operators In Chinese: 增强赋值运算符

Python 中的 set 是单一对象的集合，不存在重复项。 与 C++ 的 set , unordered_set 类似

defaultdict 速度和效率往往好于 dict

深入分析 defaultdict

何时以及为什么用 Python 的 defaultdict 而不是常规的 dict

missing() 不会被除 getitem() 之外的其他操作调用。

You can write Python code to parametrize calls:

python -c "
from mymodule import set_dragon_feeding_schedule, Creatures, Date
set_dragon_feeding_schedule(
    feeding_times=['10:00', '14:00', '18:00'],
    dishes={Creatures.Tiger: 2, Creatures.Human: 1},
    start_day=Date('1020-03-01'),
)
"

instead of:

python -m mymodule \
    set_dragon_feeding_schedule \
    --feeding-times ['10:00','14:00','18:00'] # hopefully this way it gets recognized \
    # how will you define parsing a dict with enum to integer mapping? 
    --dishes=Creatures.Tiger:2 \
    --dishes=Creatures.Human:1 \
    --start-day=1020-03-21 # BTW bash allows no comments in multiline calls

Good example of writing CLI interfaces in Python with typer:

import typer
from pathlib import Path

app = typer.Typer()

@app.command()
def find_dragon(name: str, path: Path, min_age_years: int = 200):
    <implementation goes here>

@app.command()
def feed_dragon(dragon_name: str, n_humans: int = 3):
    <implementation goes here>

if __name__ == "__main__":
    app()

later we can call it that way:

python example.py find_dragon 'Drake' --path /on/my/planet

From Python 3.9 it's much more convenient to:

• merge dictionaries with the | (pipe) operator, e.g. x | y
• update them with |=

Streamlit vs Dash

Comparison of dashboard tech stack as of 10/2020:

Python-igraph 0.8.3. (2020, October 8). Igraph Support Forum. https://igraph.discourse.group/t/python-igraph-0-8-3/473

This is important

All Python versions less than 3.6 are now EOL

Supriver - find high moving stocks before they move using anomaly detection and machine learning. Surpriver uses machine learning to look at volume + price action and infer unusual patterns which can result in big moves in stocks

Like a string, a list is a sequence of values. In a string, the values are characters; in a list, they can be any type. The values in a list are called elements or sometimes itemsThe syntax for accessing the elements of a list is the same as for accessing the characters of a string—the bracket operator. The expression inside the brackets specifies the index. Remember that the indices start at 0:

       cheeses[0]

' Cheddar ' Unlike strings, lists are mutable. When the bracket operator appears on the left side of an assignment, it identifies the element of the list that will be assigned. numbers = [42, 123] numbers[1] = 5 numbers [42, 5] The most common way to traverse the elements of a list is with a for loop. The syntax is the same as for strings: for cheese in cheeses: print(cheese) This works well if you only need to read the elements of the list. But if you want to write or update the elements, you need the indices. A common way to do that is to combine the built-in functions range and len : for i in range(len(numbers)): numbers[i] = numbers[i] 2 This loop traverses the list and updates each element. len returns the number of elements in the list. range returns a list of indices from 0 to

n

1, where n is the length of the list. Each time through the loop i gets the index of the next element. The assignment statement in the body uses i to read the old value of the element and to assign the new value. The + operator concatenates lists: a = [1, 2, 3] b = [4, 5, 6] c = a + b c [1, 2, 3, 4, 5, 6] The operator repeats a list a given number of times: [0] 4 [0, 0, 0, 0] [1, 2, 3] 3 [1, 2, 3, 1, 2, 3, 1, 2, 3] The first example repeats [0] four times. The second example repeats the list [1, 2, 3] three times. *ython provides methods that operate on lists. For example, append adds a new element to the end of a list: t = [ ' a ' , ' b ' , ' c ' ] t.append( ' d ' ) t [ ' a ' , ' b ' , ' c ' , ' d ' ] extend takes a list as an argument and appends all of the elements: t1 = [ ' a ' , ' b ' , ' c ' ] t2 = [ ' d ' , ' e ' ] t1.extend(t2) t1 [ ' a ' , ' b ' , ' c ' , ' d ' , ' e ' ] This example leaves t2 unmodified. sort arranges the elements of the list from low to high: t = [ ' d ' , ' c ' , ' e ' , ' b ' , ' a ' ] t.sort() t [ ' a ' , ' b ' , ' c ' , ' d ' , ' e ' ] Most list methods are void; they modify the list and return None . If you accidentally write t = t.sort() , you will be disappointed with the result.

*A string is a sequence , which means it is an ordered collection of other values.

• You can access the characters one at a time with the bracket operator:

         fruit            =
  

  ' banana ' letter = fruit[1] The second statement selects character number 1 from fruit and assigns it to letter . The expression in brackets is called an index .A lot of computations involve processing a string one character at a time. Often they start at the beginning, select each character in turn, do something to it, and continue until the end. This pattern of processing is called a traversal A segment of a string is called a slice . Selecting a slice is similar to selecting a character: s = ' Monty Python ' s[0:5] ' Monty ' s[6:12] ' PythonIt is tempting to use the [] operator on the left side of an assignment, with the intention of changing a character in a string. For example: greeting = ' Hello, world! ' greeting[0] = ' J ' TypeError: ' str ' object does not support item assignment The “object” in this case is the string and the “item” is the character you tried to assign. For now, an object is the same thing as a value, but we will refine that definition later (Section 10.10). The reason for the error is that strings are immutable ,

Miller, J. C., & TIng, T. (2019). EoN (Epidemics on Networks): A fast, flexible Python package for simulation, analytic approximation, and analysis of epidemics on networks. Journal of Open Source Software, 4(44), 1731. https://doi.org/10.21105/joss.01731

After all, magically you get the right Python snippet (based on scikit-learn)

TPOT automates the following:

• feature selection
• feature preprocessing
• feature construction
• model selection
• parameter optimisation

Python django development

Basic get api with fastapi

How to display html finally in jupyter notebooks

How to display html in jupyter notebooks

Hide a CLI argument from the help text

Add a help text for a CLI argument You can use the help parameter to add a help text for a CLI argument. This example without default

Setting a dynamic default value. And we can even make the default value be dynamically generated by passing a function as the first function argument:

How to define an optional parameter in function definition in typer

With Libra you can write your ML code much faster:

For example, that's how it compares to Keras.

Simple explanation of a difference between return and yield in Python

Privacy Preserving Data Analysis of Personal Data (May 27, 2020). (n.d.). Retrieved June 25, 2020, from https://www.youtube.com/watch?time_continue=11&v=wRI84xP0cVw&feature=emb_logo

Weird sqlalchemy behavior but totally an accurate statement. When using postgres and not specifying how to handle deletes, if you delete via object instead of filter.delete, sqlalchemy will set all children with foreignkey id's to None.

Dumps out query history-super helpful for debug!

Disable autocommit and autoflush in sqlalchemy.

Apart from printing the result, it is better to debug with logging.

Sample logger:

import logging
logging.basicConfig(
    filename='application.log',
    level=logging.WARNING,
    format= '[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
    datefmt='%H:%M:%S'
)

logging.error("Some serious error occurred.")
logging.warning('Function you are using is deprecated.')

the sample result:

[12:52:35] {<stdin>:1} ERROR - Some serious error occurred.
[12:52:35] {<stdin>:1} WARNING - Function you are using is deprecated.

to find its location, type:

logging.getLoggerClass().root.handlers[0].baseFilename

Importance of naming conventions for sqlalchemy when running alembic db migrations.

Difference between defaultdict and dict

Example of memoization in Python:

import timeit

def memoize_fib(func):
    cache = {}
    def inner(arg):
        if arg not in cache:            
            cache[arg] = func(arg)
        return cache[arg]
    return inner


def fib(num):
    if num == 0:
        return 0
    elif num == 1:
        return 1
    else:
        return fib(num-1) + fib(num-2)

fib = memoize_fib(fib)


print(timeit.timeit('fib(30)', globals=globals(), number=1))
print(timeit.timeit('fib(30)', globals=globals(), number=1))
print(timeit.timeit('fib(30)', globals=globals(), number=1))

Output:

4.9035000301955733e-05
1.374000021314714e-06
1.2790005712304264e-06

Difference between a shallow copy (=) and a deep copy:

Shifting from Python 2 to 3 isn't always straight to the point

@property decorator

Example of a ternary operator (one-line version of if-else):

to_check = 6
msg = "Even" if to_check%2 == 0 else "Odd"
print(msg)

Usual if-else:

msg = ""
if(to_check%2 == 0):
  msg = "Even"
else:
  msg = "Odd"
print(msg)

__init__ method in Python (which essentially all classes have)

Decorators

Flask isn't as full of features as Django (which makes him lighter), but it still offers:

• build-int dev server
• Restful request dispatching
• HTTP request handling
• much more...

Difference between range() and xrange()

Main advantage of NumPy arrays over (nested) Python lists

Unpickling

Pickling

When to use lambdas

Monkey patching in Python

Multi-threading is available in Python but it;s often not a good idea

PAY $1 OR MORE TO ALSO UNLOCK!

Teach Your Kids to Code: A Parent-Friendly Guide to Python Programming MSRP: $23.95 Already had

Invent Your Own Computer Games with Python, 4th Edition MSRP: $23.95 Already had

Black Hat Python: Python Programming for Hackers and Pentesters MSRP: $27.95 https://www.amazon.com/Black-Hat-Python-Programming-Pentesters-ebook/dp/B00QL616DW/

Gray Hat Python: Python Programming for Hackers and Reverse Engineers MSRP: $31.95 https://www.amazon.com/Gray-Hat-Python-Programming-Engineers-ebook/dp/B007V2DNEK/

PAY $8 OR MORE TO ALSO UNLOCK!

Mission Python: Code a Space Adventure Game! MSRP: $23.95

Python for Kids: A Playful Introduction to Programming MSRP: $27.95

Cracking Codes with Python: An Introduction to Building and Breaking Ciphers MSRP: $23.95

Python Playground: Geeky Projects for the Curious Programmer MSRP: $23.95

Math Adventures with Python: An Illustrated Guide to Exploring Math with Code MSRP: $23.95

PAY $15 OR MORE TO ALSO UNLOCK!

Python Crash Course, 2nd Edition: A Hands-On, Project-Based Introduction to Programming MSRP: $31.95

Automate the Boring Stuff with Python, 2nd Edition: Practical Programming for Total Beginners MSRP: $31.95

Python Flash Cards PDF ONLY MSRP: $27.95

Serious Python: Black-Belt Advice on Deployment, Scalability, Testing, and More MSRP: $27.95

Impractical Python Projects: Playful Programming Activities to Make You Smarter

DataForScience/Epidemiology101. (2020). [Jupyter Notebook]. Data For Science. https://github.com/DataForScience/Epidemiology101 (Original work published 2020)

Hot Reloading is what provides a great experience with updating your Dash code inside the Jupyter Notebooks

3 display modes of Dash using Jupyter Notebooks:

1. app.run_server(mode='external')
2. app.run_server(mode='inline')
3. app.run_server(mode='jupyterlab')

Moreover, you can display your Dash result inside a Jupyter Notebook using IPython.display.IFrame with this line:

app.run_server(mode='inline')

How Dash can run inside Jupyter Notebooks

Dash can be tried out inside a Jupyter Notebook right in your browser using binder.

To use Dash in Jupyter Notebooks, you have to import:

from jupyter_dash import JupyterDash

instead of:

import dash

Therefore, all the imports could look like that for a typical Dash app inside a Jupyter Notebook:

import plotly.express as px
from jupyter_dash import JupyterDash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output

A generator signals its termination with an exception (StopIteration). This was already a feature of generators.

The "trick" to make coroutines work, is that this exception is used as a real return value when the coroutine terminates (with a return statement).

The return value is (somehow) incapsulated into the exception that's being raised, and the event loop handles it.

In depth explanation: http://www.dabeaz.com/coroutines/

The event loop in python orchestrate the whole "simulated concurrency" among coroutines.

Deep down, python has a library select that talks very closely with the OS and gets data from sockets. This is actually how the orchestra works really at the bottom layer. https://docs.python.org/3/library/select.html#module-select

in fact, async in python was built on top of the generators (that existed in python since long before).

A generator is a function that can be suspended --yielding a value-- and then resumed.

A key functionality of the generators in python is that when they are resumed they can receive a value back from the code that stopped/resumed them. This translates into the syntax new_value = await coroutine()

Async routines collaborate each with the others by saying when they can be paused. This is why they are called coroutines.

The communication between coroutines happen thanks to the event loop

变量

代码组

多行语句

Python标识符规则。

quick web server from terminal using python3 http module

You can create estimation plots with:

• this website
• R package
• Python package
• MATLAB package

To calculate RFM we need recency value. Firstly, we shall specify the most recent transaction as "today" and then to find the latest transaction of a specific client:

df['Recency'] = (today - df.InvoiceDate)/np.timedelta64(1,'D')

Calculating frequency and aggregating data of each client may be done with the groupby method:

abt = df.groupby(['CustomerID']).agg({'Recency':'min', 'MonetaryValue':'sum', 'InvoiceNo':'count'})

lastly, we can update the column names and display RFM data:

abt = df.groupby(['CustomerID']).agg({'Recency':'min', 'MonetaryValue':'sum', 'InvoiceNo':'count'})
abt.rename(columns = {'InvoiceNo':'Frequency'}, inplace = True)
abt = abt[['Recency', 'Frequency', 'MonetaryValue']]
abt.head()

Deleting rows where value is null:

df = df[~df.CustomerID.isnull()]

Assigning different data types to columns:

df['CustomerID'] = df.CustomerID.astype(int)

Deleting irrelevant columns:

df.drop(['Description', 'StockCode', 'Country'], axis = 1, inplace = True)

Checking the % of missing data:

print(str(round(df.isnull().any(axis=1).sum()/df.shape[0]*100,2))+'% obserwacji zawiera braki w danych.')

Sample output:

24.93% obserwacji zawiera braki w danych.

Building a simple dataframe with a summary of our columns (data types, sum and % of nulls):

summary = pd.DataFrame(df.dtypes, columns=['Dtype'])
summary['Nulls'] = pd.DataFrame(df.isnull().any())
summary['Sum_of_nulls'] = pd.DataFrame(df.isnull().sum())
summary['Per_of_nulls'] = round((df.apply(pd.isnull).mean()*100),2)
summary.Dtype = summary.Dtype.astype(str)
print(summary)

the output:

                      Dtype  Nulls  Sum_of_nulls  Per_of_nulls
InvoiceNo            object  False             0         0.000
StockCode            object  False             0         0.000
Description          object   True          1454         0.270
Quantity              int64  False             0         0.000
InvoiceDate  datetime64[ns]  False             0         0.000
UnitPrice           float64  False             0         0.000
CustomerID          float64   True        135080        24.930
Country              object  False             0         0.000

When to use different programming languages (advice from an Amazon employee):

• Java - enterprise applications
• C# - Microsoft's spin on Java (useful in the Microsoft's ecosystem)
• Ruby - when speed is more important then legibility or debugging
• Python - same as Ruby but also for ML/AI (don't forget to use type hinting to make life a little saner)
• Go/Rust - fresh web service where latency and performance were more important than community/library support
• Haskell/Erlang - for very elegant/mathematical functional approach without a lot of business logic
• Clojure - in situation when you love Lisp (?)
• Kotlin/Scala - languages compiling to JVM bytecode (preferable over Clojure). Kotlin works with Java and has great IntelliJ support
• C - classes of applications (operating systems, language design, low-level programming and hardware)
• C++ - robotics, video games and high frequency trading where the performance gains from no garbage collection make it preferable to Java
• PHP/Hack - testing server changes without rebuilding. PHP is banned at Amazon due to security reasons, but its successor, Hack, runs a lot of Facebook and Slack's backends

Undefined nature of JavaScript can hide an error for a long time. For example,

function add(a,b) { return + (a + b) }
add(2,2)
add('2', 2)

will result in a number, but is it the same one?

Using PPS with Python

• Download ppscore: pip install ppscoreshell
• Calculate the PPS for a given pandas dataframe:

  import ppscore as pps
  pps.score(df, "feature_column", "target_column")
  

• Calculate the whole PPS matrix:

  pps.matrix(df)
  

Examples of projects that use documentation well

(chech the list below)

Class method should contain:

• brief description
• arguments
• label on default/optional arguments
• side effects description
• raised exceptions
• restrictions on when the method can be called

(check example below)

Type hinting introduced in Python 3.5 extends 4 rules of Jeff Atwood and comments the code itself, such as this example:

def hello_name(name: str) -> str:
    return(f"Hello {name}")

• user knows that the code expects input of type str
• the same about output

3 main categories of docstrings

Docstring conventions

Multi-line docstring example:

"""This is the summary line

This is the further elaboration of the docstring. Within this section,
you can elaborate further on details as appropriate for the situation.
Notice that the summary and the elaboration is separated by a blank new
line.

# Notice the blank line above. Code should continue on this line.

Example of using __doc:

Code (version 1):

def say_hello(name):
    print(f"Hello {name}, is it me you're looking for?")

say_hello.__doc__ = "A simple function that says hello... Richie style"

Code (alternative version):

def say_hello(name):
    """A simple function that says hello... Richie style"""
    print(f"Hello {name}, is it me you're looking for?")

Input:

>>> help(say_hello)

Returns:

Help on function say_hello in module __main__:

say_hello(name)
    A simple function that says hello... Richie style

init

Docstrings in scripts

You can always facilitate documentation with tools.

(check the table below)

Recommended videos to start documenting

(check the list below)

argparse

Different docstring formats:

• Google docstrings (not a formal specification)
• reStructured Text
• NumPy/SciPy docstrings
• Epytext

Public and Open Source Python projects should have the docs folder, and inside of it:

• Tutorials
• How-To Guides
• References
• Explanations

(check the table below for a summary)

dir() function examines directory of Python objects. For example dir(str).

Inside dir(str) you can find interesting property __doc__

Docstrings - built-in strings that help with documentation

help() function.

After typing help(str) it will return all the info about str object

project_root/
│
├── project/  # Project source code
├── docs/
├── README
├── HOW_TO_CONTRIBUTE
├── CODE_OF_CONDUCT
├── examples.py

(private, shared or open sourced)

Think only about """ when using docstrings

Python vs Fortran ;)

unittest Python library doesn't work well in a notebook

To unit test an exception handler:

worker = Worker(..., exception_handler=[handle_exception])
try:
    raise Exception()
except Exception:
    exc_info = sys.exc_info()

worker.handle_exception(job, *exc_info)

Although Miguel's tutorial is excellent, this companion piece by vsupalov can be helpful.

mkdocs for diagrams seems cool. :)

https://github.com/UnlockedEdu/documentation-pipeline-generator

How long to keep a failed job.

How long to keep a successful job.

You can add metadata on the job like keeping track of the number of times a job has been retried for example.

Exception handlers are attached to the worker.

Write an exception handler that requeues a failed job.

Debugging tests themselves

1. Set a breakpoint on the first line of the failing function (e.g. test_decrement)
2. Click the "Debug Test" option above the function
3. Open Debug Console and type: inc_dec.decrement(3) to see what is the actual output when we use x=3
4. Stop the debugger and correct the tests
5. Save the test file and run the tests again to look for a positive result

pytest-xdist provides support for parallel testing.

1. To enable it on Windows:

py -3 -m pip install pytest-xdist

1. Create a file pytest.ini in your project directory and specify in it the number of CPUs to be used (e.g. 4):

   [pytest]
   addopts=-n4
   

2. Run your tests

pytest displays failed tests also in PROBLEMS

Another way to view the test results:

View > Output > Python Test Log

Test Explorer is activated after discovering tests in Python:

After discovering tests, we can run them, for example, using CodeLens:

After using python.testing.autoTestDiscoverOnSaveEnabled, it'll be set to true and discovering tests whenever a test file is saved.

If discovery succeeds, the status bar shows Run Tests instead:

Tip to use when tests aren't discoverable in subfolderds (create __init__.py file)

Start testing in VS Code by using Python: Configure Tests (it automatically chooses one testing framework and disables the rest).

Otherwise, you can configure tests manually by setting only one of the following to True:

• python.testing.unittestEnabled
• python.testing.pytestEnabled
• python.testing.nosetestsEnabled

Default behaviour of test discovery by pytest framework

Default behaviour of test discovery by unittest framework

Sample test file using unittest framework. inc_dec is the file that's being tested:

import inc_dec    # The code to test
import unittest   # The test framework

class Test_TestIncrementDecrement(unittest.TestCase):
    def test_increment(self):
        self.assertEqual(inc_dec.increment(3), 4) # checks if the results is 4 when x = 3

    def test_decrement(self):
        self.assertEqual(inc_dec.decrement(3), 4)

if __name__ == '__main__':
    unittest.main()

Nose2 testing

• More on unit testing on Wikipedia
• useful examples on GitHub

e.g. test of an exact number entry:

    def test_validator_valid_string():
        # The exact assertion call depends on the framework as well
        assert(validate_account_number_format("1234567890"), true)