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: Collecting plots in a PostScript file
  
• 62: Implementation of ps-file report
  
• 63: Animated GIF file
  
• 64: Some improvements
  
• 65: Playing around with experiments
  
• 66: Remarks
  
• 67: Exercise
  
• 68: Increased quality of scientific work
  
• 69: New example: converting data file formats
  
• 70: Example on an output file
  
• 71: Program flow
  
• 72: What to learn
  
• 73: Reading in the first 3 lines
  
• 74: Output to many files
  
• 75: Writing output
  
• 76: Dictionaries
  
• 77: Dictionaries for our application
  
• 78: Dissection of the previous slide
  
• 79: The items in a dictionary
  
• 80: Remarks
  
• 81: Next step: make the script reusable
  
• 82: The load data function
  
• 83: How to call the load data function
  
• 84: Iterating over several lists
  
• 85: The dump data function
  
• 86: Reusing the functions
  
• 87: How to make a module
  
• 88: Module with application script
  
• 89: Usage of convert3.py
  
• 90: How to solve exercises
  
• 91: Example: write a join function
  
• 92: The next steps
  
• 93: Refined pseudo code
  
• 94: How to present the answer to an exercise
  
• 95: How to print exercises with a2ps
  

• 97: Contents
  
• 98: More info
  
• 99: Optimizing slow Python code
  
• 100: Getting started: Scientific Hello World
  
• 101: The nature of Python vs. C
  
• 102: Calling C from Python
  
• 103: Wrapper code
  
• 104: Extension modules
  
• 105: Writing wrapper code
  
• 106: Integration issues
  
• 107: Scientific Hello World example
  
• 108: Fortran 77 implementation
  
• 109: One-slide F77 course
  
• 110: Using F2PY
  
• 111: Call by reference issues
  
• 112: Check F2PY-generated doc strings
  
• 113: Interface files
  
• 114: Outline of the interface file
  
• 115: Adjustment of the interface
  
• 116: Output arguments are always returned
  
• 117: General adjustment of interfaces
  
• 118: Specification of input/output arguments; .pyf file
  
• 119: Specification of input/output arguments; .f file
  
• 120: Integration of Python and C
  
• 121: Using F2PY
  
• 122: Step 1: Write Fortran 77 signatures
  
• 123: Step 2: Generate interface file
  
• 124: Step 3: compile C code into extension module
  
• 125: Using SWIG
  
• 126: SWIG interface file
  
• 127: Making the module
  
• 128: A build script
  
• 129: Building modules with Distutils (1)
  
• 130: Building modules with Distutils (2)
  
• 131: Testing the hw3 function
  
• 132: Specifying input/output arguments
  
• 133: Other tools
  
• 134: Integrating Python with C++
  
• 135: Interfacing C++ functions (1)
  
• 136: Interfacing C++ functions (2)
  
• 137: Interfacing C++ classes
  
• 138: Function bodies and usage
  
• 139: Adding a subclass
  
• 140: SWIG interface file
  
• 141: Adding a class method
  
• 142: Using the module
  
• 143: Remark
  

• 145: Computational steering
  
• 146: Example on computational steering
  
• 147: Example on what we can do
  
• 148: Principles
  
• 149: About the F77 code
  
• 150: Creating a Python interface w/F2PY
  
• 151: Using timeloop2 from Python
  
• 152: Arguments to timeloop2
  
• 153: Interfacing the timeloop2 routine
  
• 154: Testing the extension module
  
• 155: More info on the current example
  
• 156: Comparison with Matlab
  

• 158: Contents
  
• 159: GUI toolkits callable from Python
  
• 160: Discussion of GUI toolkits
  
• 161: More info
  
• 162: Tkinter, Pmw and Tix
  
• 163: Scientific Hello World GUI
  
• 164: The code (1)
  
• 165: The code (2)
  
• 166: Structure of widget creation
  
• 167: The event loop
  
• 168: Binding events
  
• 169: Packing widgets
  
• 170: Packing from top to bottom
  
• 171: Lining up widgets with frames
  
• 172: Code for middle frame
  
• 173: Change fonts
  
• 174: Add space around widgets
  
• 175: Changing colors and widget size
  
• 176: Translating widgets
  
• 177: Learning about pack
  
• 178: The grid geometry manager
  
• 179: Basic grid options
  
• 180: Example: Hello World GUI with grid
  
• 181: The sticky option
  
• 182: Configuring widgets (1)
  
• 183: Configuring widgets (2)
  
• 184: Glade: a designer tool
  
• 185: GUI as a class
  
• 186: The basics of Python classes
  
• 187: Implementing a subclass
  
• 188: Creating the GUI as a class (1)
  
• 189: Creating the GUI as a class (2)
  
• 190: Creating the GUI as a class (3)
  
• 191: Creating the GUI as a class (4)
  
• 192: More on event bindings (1)
  
• 193: More on event bindings (1)
  
• 194: A kind of calculator
  
• 195: Turn strings into code: eval and exec
  
• 196: A GUI for simviz1.py
  
• 197: The code (1)
  
• 198: The code (2)
  
• 199: Layout
  
• 200: The text entry field
  
• 201: The result is not good...
  
• 202: Improved text entry layout
  
• 203: The image
  
• 204: Simulate and visualize buttons
  
• 205: Resizing widgets (1)
  
• 206: Resizing widgets (2)
  
• 207: Pmw demo program
  
• 208: Test/doc part of library files
  

• 210: Contents
  
• 211: More info
  
• 212: Numerical Python (NumPy)
  
• 213: A taste of NumPy: a least-squares procedure
  
• 214: Resulting plot
  
• 215: Making arrays
  
• 216: Making float, int, complex arrays
  
• 217: Array with a sequence of numbers
  
• 218: Warning: arange is dangerous
  
• 219: Array construction from a Python list
  
• 220: From ``anything'' to a NumPy array
  
• 221: Changing array dimensions
  
• 222: Array initialization from a Python function
  
• 223: Basic array indexing
  
• 224: More advanced array indexing
  
• 225: Slices refer the array data
  
• 226: Loops over arrays (1)
  
• 227: Loops over arrays (2)
  
• 228: Array computations
  
• 229: Standard math functions can take array arguments
  
• 230: Other useful array operations
  
• 231: More useful array methods and attributes
  
• 232: Modules for curve plotting and 2D/3D visualization
  
• 233: Curve plotting with Easyviz
  
• 234: Basic Easyviz example
  
• 235: Decorating the plot
  
• 236: The resulting plot
  
• 237: Plotting several curves in one plot
  
• 238: The resulting plot
  
• 239: Example: plot a function given on the command line
  
• 240: Plotting 2D scalar fields
  
• 241: Adding plot features
  
• 242: The resulting plot
  
• 243: Other commands for visualizing 2D scalar fields
  
• 244: Commands for visualizing 3D fields
  
• 245: More info about Easyviz
  

• 247: Contents
  
• 248: More info
  
• 249: Classes in Python
  
• 250: The basics of Python classes
  
• 251: Implementing a subclass
  
• 252: Comment on object-orientation
  
• 253: Private/non-public data
  
• 254: Special attributes
  
• 255: Testing on the class type
  
• 256: Creating attributes on the fly
  
• 257: Another way of adding new attributes
  
• 258: Special methods
  
• 259: Example: functions with extra parameters
  
• 260: Possible (inferior) solutions
  
• 261: Solution: class with call operator
  
• 262: Some special methods
  
• 263: Comparison, length, call
  
• 264: Indexing and slicing
  
• 265: Arithmetic operations
  
• 266: In-place arithmetic operations
  
• 267: Right-operand arithmetics
  
• 268: Type conversions
  
• 269: Boolean evaluations
  
• 270: Example on call operator: StringFunction
  
• 271: Implementation of StringFunction classes
  
• 272: New-style classes
  
• 273: Static data
  
• 274: Static methods
  
• 275: Properties
  
• 276: Attribute access; traditional
  
• 277: Attribute access; recommended style
  
• 278: More about scope
  
• 279: Demonstration of scopes (1)
  
• 280: Demonstration of scopes (2)
  
• 281: Demonstration of scopes (3)
  
• 282: Namespaces for exec and eval
  
• 283: Generalized StringFunction class (1)
  
• 284: First implementation
  
• 285: Efficiency tests
  
• 286: A more efficient StringFunction (1)
  
• 287: A more efficient StringFunction (2)
  
• 288: Extension to many independent variables
  
• 289: Efficiency tests
  
• 290: Removing all overhead
  
• 291: Final efficiency test
  
• 292: Adding pretty print and reconstruction
  
• 293: Examples on StringFunction functionality (1)
  
• 294: Examples on StringFunction functionality (2)
  
• 295: Exercise
  
• 296: Exercise, 2nd part
  

• 298: Integer arrays as indices
  
• 299: More about references to data
  
• 300: Complex number computing
  
• 301: A root function
  
• 302: Array type and data type
  
• 303: Matrix objects (1)
  
• 304: Matrix objects (2)
  
• 305: Compound expressions generate temporary arrays
  
• 306: In-place array arithmetics
  
• 307: Vectorization (1)
  
• 308: Vectorization (2)
  
• 309: Vectorization of functions with if tests; problem
  
• 310: Vectorization of functions with if tests; solutions
  
• 311: General vectorization of if-else tests
  
• 312: Vectorization via slicing
  
• 313: Random numbers
  
• 314: Basic linear algebra
  
• 315: A linear algebra session
  
• 316: A least-squares procedure
  
• 317: File I/O with arrays; plain ASCII format
  
• 318: File I/O with arrays; binary pickling
  
• 319: ScientificPython
  
• 320: ScientificPython: numbers with units
  
• 321: SciPy
  
• 322: SymPy: symbolic computing in Python
  
• 323: Python + Matlab = true
  

• 325: Contents
  
• 326: More info
  
• 327: Is Python slow for numerical computing?
  
• 328: Comments
  
• 329: Case: filling a grid with point values
  
• 330: Python object for grid data
  
• 331: Slow loop
  
• 332: Migrate gridloop to F77
  
• 333: F77 function
  
• 334: Making the extension module
  
• 335: Array storage in Fortran and C/C++
  
• 336: Example: storing a 2x3 array
  
• 337: F2PY and multi-dimensional arrays
  
• 338: Always specify input/output data
  
• 339: gridloop2 seen from Python
  
• 340: Handling of arrays with F2PY
  
• 341: Input/output arrays (1)
  
• 342: Input/output arrays (2)
  
• 343: Input/output arrays (3)
  
• 344: Storage compatibility requirements
  
• 345: F2PY and storage issues
  
• 346: Caution
  
• 347: About Python callbacks
  
• 348: Vectorized callback seen from Python
  
• 349: Vectorized callback from Fortran
  
• 350: Caution
  
• 351: Avoiding callback by string-based if-else wrapper
  
• 352: Compiled callback function
  
• 353: gridloop2 wrapper
  
• 354: Building the module on the fly
  
• 355: gridloop2 could be generated on the fly
  
• 356: Extracting a pointer to the callback function
  
• 357: C implementation of the loop
  
• 358: Using F2PY to wrap the C function
  
• 359: Step 0: The modified C function
  
• 360: Step 1: Fortran 77 signatures
  
• 361: Step 3 and 4: Generate interface file and compile module
  
• 362: Manual writing of extension modules
  
• 363: NumPy objects as seen from C
  
• 364: Creating new NumPy array in C
  
• 365: Wrapping data in a NumPy array
  
• 366: From Python sequence to NumPy array
  
• 367: Python interface
  
• 368: gridloop1 in C; header
  
• 369: gridloop1 in C; safety checks
  
• 370: Callback to Python from C
  
• 371: gridloop1 in C; the loop
  
• 372: Memory management
  
• 373: Reference counting
  
• 374: gridloop1; loop with memory management
  
• 375: gridloop1; more testing in the loop
  
• 376: gridloop2 in C; header
  
• 377: gridloop2 in C; macros
  
• 378: gridloop2 in C; another macro
  
• 379: gridloop2 in C; more macros
  
• 380: gridloop2 in C; indexing macros
  
• 381: gridloop2 in C; the return array
  
• 382: Registering module functions
  
• 383: Doc strings
  
• 384: The required init function
  
• 385: Building the module
  
• 386: A setup.py script
  
• 387: Using the module
  
• 388: Debugging
  
• 389: Debugging example (1)
  
• 390: 1st debugging example (1)
  
• 391: 1st debugging example (3)
  
• 392: 1st debugging example (3)
  
• 393: 2nd debugging example
  
• 394: 3rd debugging example (1)
  
• 395: 3rd debugging example (2)
  
• 396: 3rd debugging example (3)
  
• 397: 4th debugging example
  
• 398: 5th debugging example
  
• 399: Summary of the debugging examples
  
• 400: Next example
  
• 401: Two-dim. C array as double pointer
  
• 402: Problems
  
• 403: From NumPy array to double pointer
  
• 404: Callback via a function pointer (1)
  
• 405: Callback via a function pointer (2)
  
• 406: The alternative gridloop1 code (1)
  
• 407: The alternative gridloop1 code (2)
  
• 408: gridloop1 with C++ array object
  
• 409: The C++ class wrapper (1)
  
• 410: The C++ class wrapper (2)
  
• 411: The C++ class wrapper (3)
  
• 412: Using the wrapper class
  
• 413: The loop is straightforward
  
• 414: Reference counting
  
• 415: SCXX: basic ideas
  
• 416: Example
  
• 417: The similar code with Python C API
  
• 418: gridloop1 with SCXX
  
• 419: Error checking
  
• 420: The loop over grid points
  
• 421: The Weave tool (1)
  
• 422: The Weave tool (2)
  
• 423: The Weave tool (3)
  
• 424: Exchanging pointers in Python code
  
• 425: MyArray: some favorite C++ array class
  
• 426: Filter between NumPy array and C++ class
  
• 427: Typical conversion function
  
• 428: Version with data copying
  
• 429: Ideas
  
• 430: gridloop1 in C++
  
• 431: Calling C++ from Python (1)
  
• 432: Calling C++ from Python (2)
  
• 433: SWIG'ing the filter class
  
• 434: setup.py
  
• 435: Manual alternative
  
• 436: Summary
  
• 437: Comparison
  
• 438: Efficiency
  
• 439: Efficiency test: 1100x1100 grid
  
• 440: Conclusions about efficiency
  
• 441: More F2PY features
  
• 442: Other tools
  

• 444: Python info
  
• 445: Electronic Python documentation
  
• 446: Python variables
  
• 447: Common types
  
• 448: Numbers
  
• 449: List and tuple
  
• 450: Dictionary
  
• 451: Strings
  
• 452: NumPy arrays
  
• 453: Mutable and immutable types
  
• 454: Operating system interface
  
• 455: Files
  
• 456: Functions
  
• 457: Example: a grep script (1)
  
• 458: Example: a grep script (2)
  
• 459: Modules
  
• 460: Interactive Python
  
• 461: IPython and the Python debugger
  
• 462: More on debugging