Python for Computational Science

PDF version (8 slides per page)

All slides in a single HTML page

Intro to Python programming

• 3: Make sure you have the software
  
• 4: Material associated with these slides
  
• 5: Installing TCSE3-3rd-examples.tar.gz
  
• 6: Scientific Hello World script
  
• 7: Purpose of this script
  
• 8: The code
  
• 9: Comments
  
• 10: Alternative print statements
  
• 11: printf format strings
  
• 12: Strings in Python
  
• 13: Where to find Python info
  
• 14: New example: reading/writing data files
  
• 15: Reading input/output filenames
  
• 16: Exception handling
  
• 17: Open file and read line by line
  
• 18: Defining a function
  
• 19: Data transformation loop
  
• 20: Alternative file reading
  
• 21: Loading data into lists
  
• 22: Loop over list entries
  
• 23: Running the script
  
• 24: More about headers
  
• 25: Are scripts compiled?
  
• 26: About Python for the experienced computer scientist
  
• 27: Python and error checking
  
• 28: Computing with arrays
  
• 29: A first glimpse of NumPy
  
• 30: Loading file data into NumPy arrays
  
• 31: More on computing with NumPy arrays
  
• 32: Interactive Python
  
• 33: Editing capabilities in IPython
  
• 34: TAB completion
  
• 35: More examples
  
• 36: IPython and the Python debugger
  
• 37: More on debugging
  
• 38: On the efficiency of scripts
  
• 39: The classical script
  
• 40: What to learn
  
• 41: A code: simulation of an oscillating system
  
• 42: Usage of the simulation code
  
• 43: A plot of the solution
  
• 44: Plotting graphs in Gnuplot
  
• 45: Typical manual work
  
• 46: The user interface
  
• 47: Program tasks
  
• 48: Parsing command-line options
  
• 49: Modules for parsing command-line arguments
  
• 50: Creating a subdirectory
  
• 51: Writing the input file to the simulator
  
• 52: Running the simulation
  
• 53: Making plots
  
• 54: Python vs Unix shell script
  
• 55: Other programs for curve plotting
  
• 56: Series of numerical experiments
  
• 57: Handling command-line args (1)
  
• 58: Handling command-line args (2)
  
• 59: The loop over m
  
• 60: Collecting plots in an HTML file
  
• 61: Animated GIF file
  
• 62: Some improvements
  
• 63: Playing around with experiments
  
• 64: Remarks
  
• 65: Exercise
  
• 66: Increased quality of scientific work
  
• 67: New example: converting data file formats
  
• 68: Example on an output file
  
• 69: Program flow
  
• 70: What to learn
  
• 71: Reading in the first 3 lines
  
• 72: Output to many files
  
• 73: Writing output
  
• 74: Dictionaries
  
• 75: Dictionaries for our application
  
• 76: Dissection of the previous slide
  
• 77: The items in a dictionary
  
• 78: Remarks
  
• 79: Next step: make the script reusable
  
• 80: The load data function
  
• 81: How to call the load data function
  
• 82: Iterating over several lists
  
• 83: The dump data function
  
• 84: Reusing the functions
  
• 85: How to make a module
  
• 86: Module with application script
  
• 87: Usage of convert3.py
  
• 88: How to solve exercises
  
• 89: Example: write a join function
  
• 90: The next steps
  
• 91: Refined pseudo code
  
• 92: How to present the answer to an exercise
  
• 93: How to print exercises with a2ps
  

• 95: Contents
  
• 96: More info
  
• 97: Numerical Python (NumPy)
  
• 98: A taste of NumPy: a least-squares procedure
  
• 99: Resulting plot
  
• 100: Making arrays
  
• 101: Making float, int, complex arrays
  
• 102: Array with a sequence of numbers
  
• 103: Warning: arange is dangerous
  
• 104: Array construction from a Python list
  
• 105: From ``anything'' to a NumPy array
  
• 106: Changing array dimensions
  
• 107: Array initialization from a Python function
  
• 108: Basic array indexing
  
• 109: More advanced array indexing
  
• 110: Slices refer the array data
  
• 111: Loops over arrays (1)
  
• 112: Loops over arrays (2)
  
• 113: Array computations
  
• 114: Standard math functions can take array arguments
  
• 115: Other useful array operations
  
• 116: More useful array methods and attributes
  
• 117: Modules for curve plotting and 2D/3D visualization
  
• 118: Curve plotting with Easyviz
  
• 119: Basic Easyviz example
  
• 120: Decorating the plot
  
• 121: The resulting plot
  
• 122: Plotting several curves in one plot
  
• 123: The resulting plot
  
• 124: Example: plot a function given on the command line
  
• 125: Plotting 2D scalar fields
  
• 126: Adding plot features
  
• 127: The resulting plot
  
• 128: Other commands for visualizing 2D scalar fields
  
• 129: Commands for visualizing 3D fields
  
• 130: More info about Easyviz
  

• 132: Integer arrays as indices
  
• 133: More about references to data
  
• 134: Complex number computing
  
• 135: A root function
  
• 136: Array type and data type
  
• 137: Matrix objects (1)
  
• 138: Matrix objects (2)
  
• 139: Compound expressions generate temporary arrays
  
• 140: In-place array arithmetics
  
• 141: Vectorization (1)
  
• 142: Vectorization (2)
  
• 143: Vectorization of functions with if tests; problem
  
• 144: Vectorization of functions with if tests; solutions
  
• 145: General vectorization of if-else tests
  
• 146: Vectorization via slicing
  
• 147: Random numbers
  
• 148: Basic linear algebra
  
• 149: A linear algebra session
  
• 150: A least-squares procedure
  
• 151: File I/O with arrays; plain ASCII format
  
• 152: File I/O with arrays; binary pickling
  
• 153: ScientificPython
  
• 154: ScientificPython: numbers with units
  
• 155: SciPy
  
• 156: SymPy: symbolic computing in Python
  
• 157: Python + Matlab = true
  

• 159: Contents
  
• 160: More info
  
• 161: Optimizing slow Python code
  
• 162: Getting started: Scientific Hello World
  
• 163: The nature of Python vs. C
  
• 164: Calling C from Python
  
• 165: Wrapper code
  
• 166: Extension modules
  
• 167: Writing wrapper code
  
• 168: Integration issues
  
• 169: Scientific Hello World example
  
• 170: Fortran 77 implementation
  
• 171: One-slide F77 course
  
• 172: Using F2PY
  
• 173: Call by reference issues
  
• 174: General adjustment of interfaces to Fortran
  
• 175: Check F2PY-generated doc strings
  
• 176: Interface files
  
• 177: Outline of the interface file
  
• 178: Adjustment of the interface
  
• 179: Output arguments are always returned
  
• 180: General adjustment of interfaces
  
• 181: Specification of input/output arguments; .pyf file
  
• 182: Specification of input/output arguments; .f file
  
• 183: Specification of input/output arguments; .f90 file
  
• 184: Integration of Python and C
  
• 185: Using F2PY
  
• 186: Step 1: Write Fortran 77 signatures
  
• 187: Step 2: Generate interface file
  
• 188: Step 3: compile C code into extension module
  
• 189: Using SWIG
  
• 190: SWIG interface file
  
• 191: Making the module
  
• 192: A build script
  
• 193: Building modules with Distutils (1)
  
• 194: Building modules with Distutils (2)
  
• 195: Testing the hw3 function
  
• 196: Specifying input/output arguments
  
• 197: Other tools
  
• 198: Integrating Python with C++
  
• 199: Interfacing C++ functions (1)
  
• 200: Interfacing C++ functions (2)
  
• 201: Interfacing C++ classes
  
• 202: Function bodies and usage
  
• 203: Adding a subclass
  
• 204: SWIG interface file
  
• 205: Adding a class method
  
• 206: Using the module
  
• 207: Remark
  

• 209: Contents
  
• 210: GUI toolkits callable from Python
  
• 211: Discussion of GUI toolkits
  
• 212: More info
  
• 213: Tkinter, Pmw and Tix
  
• 214: Scientific Hello World GUI
  
• 215: The code (1)
  
• 216: The code (2)
  
• 217: Structure of widget creation
  
• 218: The event loop
  
• 219: Binding events
  
• 220: Packing widgets
  
• 221: Packing from top to bottom
  
• 222: Lining up widgets with frames
  
• 223: Code for middle frame
  
• 224: Change fonts
  
• 225: Add space around widgets
  
• 226: Changing colors and widget size
  
• 227: Translating widgets
  
• 228: Learning about pack
  
• 229: The grid geometry manager
  
• 230: Basic grid options
  
• 231: Example: Hello World GUI with grid
  
• 232: The sticky option
  
• 233: Configuring widgets (1)
  
• 234: Configuring widgets (2)
  
• 235: Glade: a designer tool
  
• 236: GUI as a class
  
• 237: The basics of Python classes
  
• 238: Implementing a subclass
  
• 239: Creating the GUI as a class (1)
  
• 240: Creating the GUI as a class (2)
  
• 241: Creating the GUI as a class (3)
  
• 242: Creating the GUI as a class (4)
  
• 243: More on event bindings (1)
  
• 244: More on event bindings (1)
  
• 245: A kind of calculator
  
• 246: Turn strings into code: eval and exec
  
• 247: A GUI for simviz1.py
  
• 248: The code (1)
  
• 249: The code (2)
  
• 250: Layout
  
• 251: The text entry field
  
• 252: The result is not good...
  
• 253: Improved text entry layout
  
• 254: The image
  
• 255: Simulate and visualize buttons
  
• 256: Resizing widgets (1)
  
• 257: Resizing widgets (2)
  
• 258: Pmw demo program
  
• 259: Test/doc part of library files
  

• 261: Contents
  
• 262: More info
  
• 263: Is Python slow for numerical computing?
  
• 264: Comments
  
• 265: Case: filling a grid with point values
  
• 266: Python object for grid data
  
• 267: Slow loop
  
• 268: Migrate gridloop to F77
  
• 269: F77 function
  
• 270: Making the extension module
  
• 271: Array storage in Fortran and C/C++
  
• 272: Example: storing a 2x3 array
  
• 273: F2PY and multi-dimensional arrays
  
• 274: Always specify input/output data
  
• 275: gridloop2 seen from Python
  
• 276: Handling of arrays with F2PY
  
• 277: Input/output arrays (1)
  
• 278: Input/output arrays (2)
  
• 279: Input/output arrays (3)
  
• 280: Storage compatibility requirements
  
• 281: F2PY and storage issues
  
• 282: Caution
  
• 283: About Python callbacks
  
• 284: Vectorized callback seen from Python
  
• 285: Vectorized callback from Fortran
  
• 286: Caution
  
• 287: Avoiding callback by string-based if-else wrapper
  
• 288: Compiled callback function
  
• 289: gridloop2 wrapper
  
• 290: Building the module on the fly
  
• 291: gridloop2 could be generated on the fly
  
• 292: Extracting a pointer to the callback function
  
• 293: C implementation of the loop
  
• 294: Using F2PY to wrap the C function
  
• 295: Step 0: The modified C function
  
• 296: Step 1: Fortran 77 signatures
  
• 297: Step 3 and 4: Generate interface file and compile module
  
• 298: Manual writing of extension modules
  
• 299: NumPy objects as seen from C
  
• 300: Creating new NumPy array in C
  
• 301: Wrapping data in a NumPy array
  
• 302: From Python sequence to NumPy array
  
• 303: Python interface
  
• 304: gridloop1 in C; header
  
• 305: gridloop1 in C; safety checks
  
• 306: Callback to Python from C
  
• 307: gridloop1 in C; the loop
  
• 308: Memory management
  
• 309: Reference counting
  
• 310: gridloop1; loop with memory management
  
• 311: gridloop1; more testing in the loop
  
• 312: gridloop2 in C; header
  
• 313: gridloop2 in C; macros
  
• 314: gridloop2 in C; another macro
  
• 315: gridloop2 in C; more macros
  
• 316: gridloop2 in C; indexing macros
  
• 317: gridloop2 in C; the return array
  
• 318: Registering module functions
  
• 319: Doc strings
  
• 320: The required init function
  
• 321: Building the module
  
• 322: A setup.py script
  
• 323: Using the module
  
• 324: Debugging
  
• 325: Debugging example (1)
  
• 326: 1st debugging example (1)
  
• 327: 1st debugging example (3)
  
• 328: 1st debugging example (3)
  
• 329: 2nd debugging example
  
• 330: 3rd debugging example (1)
  
• 331: 3rd debugging example (2)
  
• 332: 3rd debugging example (3)
  
• 333: 4th debugging example
  
• 334: 5th debugging example
  
• 335: Summary of the debugging examples
  
• 336: Next example
  
• 337: Two-dim. C array as double pointer
  
• 338: Problems
  
• 339: From NumPy array to double pointer
  
• 340: Callback via a function pointer (1)
  
• 341: Callback via a function pointer (2)
  
• 342: The alternative gridloop1 code (1)
  
• 343: The alternative gridloop1 code (2)
  
• 344: gridloop1 with C++ array object
  
• 345: The C++ class wrapper (1)
  
• 346: The C++ class wrapper (2)
  
• 347: The C++ class wrapper (3)
  
• 348: Using the wrapper class
  
• 349: The loop is straightforward
  
• 350: Reference counting
  
• 351: SCXX: basic ideas
  
• 352: Example
  
• 353: The similar code with Python C API
  
• 354: gridloop1 with SCXX
  
• 355: Error checking
  
• 356: The loop over grid points
  
• 357: The Weave tool (1)
  
• 358: The Weave tool (2)
  
• 359: The Weave tool (3)
  
• 360: Exchanging pointers in Python code
  
• 361: MyArray: some favorite C++ array class
  
• 362: Filter between NumPy array and C++ class
  
• 363: Typical conversion function
  
• 364: Version with data copying
  
• 365: Ideas
  
• 366: gridloop1 in C++
  
• 367: Calling C++ from Python (1)
  
• 368: Calling C++ from Python (2)
  
• 369: SWIG'ing the filter class
  
• 370: setup.py
  
• 371: Manual alternative
  
• 372: Summary
  
• 373: Comparison
  
• 374: Efficiency
  
• 375: Efficiency test: 1100x1100 grid
  
• 376: Conclusions about efficiency
  
• 377: More F2PY features
  
• 378: Other tools
  

• 380: Python info
  
• 381: Electronic Python documentation
  
• 382: Python variables
  
• 383: Common types
  
• 384: Numbers
  
• 385: List and tuple
  
• 386: Dictionary
  
• 387: Strings
  
• 388: NumPy arrays
  
• 389: Mutable and immutable types
  
• 390: Operating system interface
  
• 391: Files
  
• 392: Functions
  
• 393: Example: a grep script (1)
  
• 394: Example: a grep script (2)
  
• 395: Modules
  
• 396: Interactive Python
  
• 397: IPython and the Python debugger
  
• 398: More on debugging