This is an old version of this page. You can view the most recent version or browse the history.

Python Workshop 2

Draft

This page is a draft

I am going to go for a Raymond Hettinger style presentation, https://www.cs.odu.edu/~tkennedy/cs330/f20/Public/languageResources/#python-programming-videos.

These materials are web-centric (i.e., do not need to be printed and are available at https://www.cs.odu.edu/~tkennedy/python-workshop).

Who am I?

I have taught various courses, including:

CS 300T - Computers in Society
CS 333 - Programming and Problem Solving
CS 330 - Object Oriented Programming and Design
CS 350 - Introduction to Software Engineering
CS 410 - Professional Workforce Development I
CS 411W - Professional Workforce Development II
CS 417 - Computational Methods & Software

Most of my free time is spent writing Python 3 and Rust code, tweaking my Vim configuration, or learning a new (programming) language. My current language of interest is Rust (at the time of writing).

Referenced Courses & Materials

I am going to pull from CS 330, CS 350, CS 411W, and CS 417 lecture notes.

CS 330 - Object Oriented Programming & Design
- S.O.L.I.D
- Iterators
CS 350 - Introduction to Software Engineering
CS 417 - Computational Methods & Software
- Python non-linear solver discussion

I will also pull a couple examples from the previous:

The Broad Strokes

This workshop is intended as discussion on how to write Rust code that makes use of:

Tentative Topics

I will focus on:

Lambda functions, usage, syntax, and expressions
Structuring large python codebases
Profiling python, engineering best practices
Advanced tutorials for modern development : Classes, Polymorphism, Interfaces, etc.
Debugging options in python ( A language that promotes rapid development is usually hard to debug. How can we do it in python? )
Multithreading/Concurrent python
Documenting code

Classes and OOP will take a while (the topic is quite vast). I will also discuss testing python code (with unit testing and integration testing) and code coverage, along with tox for basic configuration management.

I will try to fit in a few of the remaining topics:

Correct usage of the .loc and .iloc functionality
How to use NumPy
Python for Machine learning, Tensorflow
Data and workflow management
Pandas Dataframe usage
How do we use RDD and DataFrame.
Implementing cryptographic algorithms

I should be able to fit in some discussion of NumPy.

Object Oriented

We need to discuss the rules of a class checklist.

C++	Java	Python 3	Rust
Default Constructor	Default Constructor	`__init__`	`new()` or Default trait
Copy Constructor	Clone and/or Copy Constructor	`__deepcopy__`	`Clone` trait
Destructor
	finalize (deprecated/discouraged)	`__del__`	`Drop` trait
Assignment Operator (=)
Accessors (Getters)	Accessors (Getters)	Accessors (`@property`)	Accessors (Getters)
Mutators (Setters)	Mutators (Setters)	Setter (`@attribute.setter`)	Mutators (setters)
Swap
Logical Equivalence Operator (==)	equals	`__eq__`	`std::cmp::PartialEq` trait
Less-Than / Comes-Before Operator (<)	hashCode	`__hash__`	`std::cmp::PartialOrd` trait
`std::hash` (actual hashing)	hashCode	`__hash__`	`std::hash::Hash` trait
Stream Insertion Operator (<<)	toString	`__str__`	`std::fmt::Display` trait
		`__repr__`	`std::fmt::Debug` trait
`begin()` and `end()`	`iterator`	`__iter__`	`iter()` and `iter_mut()`