Typed memoryviews are a new Cython feature for accessing memory buffers, such as NumPy arrays, without any Python overhead. This makes them very useful for manipulating blocks of memory in Cython directly without calling into the Python-C API. Typed memoryviews have a clean declaration syntax and have a NumPy-like look and feel, supporting slicing, striding and indexing.
I go into more detail and provide some specific examples on how to use typed memoryviews in this webinar: “Advanced Cython: Using the new Typed Memoryviews”.
If you would like to watch the recorded webinar, you can find a link below (the different formats will play directly in different browsers so check to see which one works for you, and you won’t have to download the whole recording ahead of time):
We posted a recording of a 30 minute webinar that we did on the 20th that covers what Canopy is and why we developed it. There’s a few minutes of Brett Murphy(Product Manager at Enthought) discussing the “why” with some slides, and then Jason McCampbell (Development Manager for Canopy) gets into the interesting part with a 15+ minute demo of some of the key capabilities and workflows in Canopy. If you would like to watch the recorded webinar, you can find it here (the different formats will play directly in different browsers so check them and you won’t have to download the whole recording first):
Summed up in one line: Canopy provides the minimal set of tools for non-programmers to access, analyze and visualize data in an open-source Python environment.
The challenge in the past for scientists, engineers and analysts who wanted to use Python had been pulling together a working, integrated Python environment for scientific computing. Finding compatible versions of the dozens of Python packages, compiling them and integrating it all was very time consuming. That’s why we released the Enthought Python Distribution (EPD) many years back. It provided a single install of all the major packages you needed to do scientific and analytic computing with Python.
But the primary interface for a user of EPD was the command line. For a scientist or analyst used to an environment like MATLAB or one of the R IDEs, the command line is a little unapproachable and makes Python challenging to adopt. This is why we developed Canopy.
Enthought Canopy is both a Python distribution (like EPD) and an analysis environment. The analysis environment includes an integrated editor and IPython prompt to faciliate script development & testing and data analysis & plotting. The graphical package manager becomes the main interface to the Python ecosystem with its package search, install and update capabilities. And the documentation browser makes online documentation for Canopy, Python and the popular Python packages available on the desktop.
Check out the Canopy demo in the recorded webinar (link above). We hope it’s helpful.
We’ll be hosting two webinars this month, covering user interfaces with Traits and SciPy India 2009. Hope to see you there!
How do I…Build a user interface with Traits?
Friday December 4
1pm CST/ 7pm UTC Wait list (non-subscribers) Subscribe to EPD (guaranteed seat)
The Traits package is at the center of all development we do at Enthought and has changed the mental model we use for Python programming. In this week’s webinar, we’ll have an in-depth look at how we can use Traits to build user interfaces for scientific applications.
Scientific Computing with Python Webinar:
Summary of SciPy India
Friday December 18
1pm CST/ 7pm UTC Register at GoToMeeting
In a couple of weeks, Enthought President Travis Oliphant will head off to Kerala, India to speak at SciPy India 2009. Due to a training engagement, Travis missed SciPy for the first time this summer, so he’s excited for this additional opportunity to meet and collaborate with the scientific Python community. Speakers at the event include Jarrod Millman, David Cournapeau, Christopher Burns, Prabhu Ramachandran, and Asokan Pichai a great group. We’re looking forward to hearing Travis’ review of the proceedings.
It looks like it’s time for our mid-month Scientific Computing with Python webinar! This month’s topic is sure to prove very useful for many of you data analysts: Interpolation with NumPy and SciPy.
In many data-processing scenarios it is necessary to use a discrete set of available data-points to infer the value of a function at a new data-point. One approach to this problem is interpolation, which constructs a new model-function that goes through the original data-points. There are many forms of interpolation (polynomial, spline, kriging, radial basis function, etc.), and SciPy includes some of these interpolation forms. This webinar will review the interpolation modules available in SciPy and in the larger Python community and provide instruction on their use via example.
Envisage is a Python-based framework for building extensible applications. The Envisage Core and corresponding Envisage Plugins are components of the Enthought Tool Suite. We’ve found that Envisage grants us a degree of immediate functionality in our custom applications and have come to rely on the framework in much of our development.
For November’s EPD webinar Corran Webster will show how you can hook together existing Envisage plugins to quickly create a new GUI. We’ll also look at how you can easily turn an existing Traits UI interface into an Envisage plugin.
In order to better serve the Linux-users in our audience, we’ve decided to begin hosting our EPD webinars on WebEx instead of GoToMeeting. This means that our original limit of 35 attendees will be scaled back to 30. As usual, EPD subscribers at a Basic level or above will be guaranteed seats for the event while the general public may add their name to the wait list here.
How do I… use Envisage for GUIs?
Friday November 6, 2009
1pm CDT/6pm UTC
It’s already time for our October Scientific Computing with Python webinar! This month we’ll be handling Traits, one of our most popular training topics.
An essential component of the open source Enthought Tool Suite, The Traits package is at the center of all development we do at Enthought. In fact, it has changed the mental model we use for programming in the already extremely efficient Python programming language.
Briefly, a trait is a type definition that can be used for normal Python object attributes, giving the attributes some additional characteristics: initialization, validation, delegation, notification, and (optionally) visualization (GUIs). In this webinar we will provide an introduction to Traits by walking through several examples that show what you can do with Traits.
One of the useful tools in the the Enthought Python Distribution (EPD) is the signal processing module of SciPy. In this webinar we will demonstrate how to analyze and process signals using the Fast Fourier Transform (FFT), and the tools in scipy.signal. Topics to be covered include designing and applying time-domain and frequency-domain filters, down-sampling data, and dealing with data streams by processing chunks at a time while handling edge-effects.
As usual, all EPD subscribers at a basic level or above will be emailed the registration link and guaranteed a seat at the webinar. Non-subscribers will be granted access on a first-come, first-served basis by adding their names to the waiting listhere.
This has been a favorite topic in our private training courses, so we’re excited to present it to a wider audience. Hope to see you there!
September is well upon us and it looks like it’s already time for another Scientific Computing with Python webinar. Next week, Travis Oliphant will be hosting a presentation on regression analysis in NumPy and SciPy. As you are probably aware, Travis was the primary developer of NumPy, so we’re fortunate to have him presenting these tools. Here’s a word on what to expect Friday:
A common scientific and engineering need is to find the parameters to a model that best fit a particular data set. A large number of techniques and tools have been created for assisting with this general problem. They vary based on the model (e.g. linear or nonlinear), the characteristics of the errors on the data (e.g. weighted or un-weighted), and the error metric selected (e.g. least-squares, or absolute difference).
This webinar will provide an overview of the tools that SciPy and NumPy provide for regression analysis including linear and non-linear least-squares and a brief look at handling other error metrics. We will also demonstrate simple GUI tools that can make some problems easier and provide a quick overview of the new Scikits package statsmodels whose API is maturing in a separate package but should be incorporated into SciPy in the future.
Here’s the registration information:
Scientific Computing with Python Webinar: Regression analysis in NumPy