Python library advice

Hi Gary

I'm not a dyed-in-the-wool Python guy by any means but I do use it for scientific programing.  I use Anaconda's Scientific distibution. The Anaconda distribution has the advantage of being a self contained package that comes with many tools needed for scientific computation like NumPy, SciPY, Matplotlib and others. Anaconda also can use the Spyder IDE.  I'm sure there are many other dristributions that would work as well.

https://store.continuum.io/cshop/anaconda/

https://store.continuum.io/static/img/Anaconda-Quickstart.pdf

You will have a decision to make regarding using  3.3 or 2.7.  This choice is pretty much based on libraries available with each version.  I satyed with 2.7 although I think you could switch between the two with Anaconda.

Jim Jones

I was new to Python when I started developing TG.  I agree with Jim, the Anaconda distribution integrated everything I needed and save a lot of time.  Also, when I found an incompatibility between Anaconda on the Mac and the same version on PC, I emailed the support site and they worked with me finding and incorporating a fix in the next release.  Be sure you also web search "python astronomy".  Many of the packages they refer to are alredy part of Anconda.  Check existing libraries to see if the RA Dec <-> alt-az is already available.

Thanks for the pointers to the Anaconda Python distro.  I'm following up on that.

Is AstroPy the recommended library/module/package to use?  There is also palpy, PyEphem, astrolib, pySLALIB etc...  I'm thinking astropy is the most inclusive, and hopefuly reliable, but would welcome advice on that.

Gary Billings

Hi Gary,

I believe that Astropy would be a good choice. For cool stuff about Python in Astronomy, look at http://www.astrobetter.com/blog/tag/python/ but why not also Astropy Boot Camp (with many examples) http://phares.caltech.edu/iptf/iptf_SummerSchool_2014/astropy-boot-camp.html

Best wishes,

Tõnis

There is a lot of more content, useful for learning:
http://nbviewer.ipython.org/github/spacetelescope

but to learn how to use Python in astronomy, there are two courses (with lecture materials and homeworks+solutions):

http://nbviewer.ipython.org/github/spacetelescope/scientific-python-training-2012/tree/master/

and

http://nbviewer.ipython.org/github/spacetelescope/scientific-python-training-2015/tree/master/

Specifically about (aperture) photometry in Python, using AstroPy:

http://nbviewer.ipython.org/github/spacetelescope/UserTraining2015/blob/master/photutils.ipynb

Tõnis

I found this article in nature to be helpful in filtering wheat from chaff:

http://www.nature.com/news/programming-pick-up-python-1.16833

Also, a recent post about using python to do periodogram analysis on an RR Lyrae star seems relevant to the AAVSO community: 

https://jakevdp.github.io/blog/2015/06/13/lomb-scargle-in-python/&nbsp;

Kev.

Here's my two cents worth:

I started with FORTRAN, then later moved up to C and C++, with various assembly languages, and scientific programming environments like Maple, Mathcad and Matlab.  Recently I noticed that many of the technical courses offered on edX and Coursera required some knowledge of Python, so I decided to learn it.  Someone asked "Why Phthon?"  (and not C/C++), and for me the answer is very easy:  for someone who does not spent an appreciable amount of time writing code (in other words, needs to debug pretty much everything) there is nothing to beat an interpreted language.  With Python, your code is up and running in a flash, because the feedback is instantaneous.   

As to the environment, I am not familiar with all the distributions, having installed Canopy.  But I find that the native GUI, Idle, is just as good as Canopy and loads much faster.  The fancier distros tend to consume a fair amount of overhead.  Now it is true that with Canopy many of the most popular packages such as numpy and matplotlib are included, but downloading and installing them is trivially easy.  (Especially if you are on a linux platform; I mean, how hard is it to open a command window and type sudo apt-get install python-numpy?)

Finally, since I had already taken formal courses in C, C++ and FORTRAN I might have tried to learn Python from any of the myriad of tutorials out there, but after looking at the mountain of documentation, I concluded that a course would be the best and quickest way for me.  I surveyed the four or five Python courses offered on edX and Coursera, and came to the conclusion that the MIT 6.00.1x and 6.00.2x courses were right for me.  I recommend them heartily to anyone who has prior programming experience.  They are advertized as no prior knowledge required, but if you have not already been introduced to object oriented programming the learning curve will be very steep!

Hi Mike

The Programming Language Tower of Babel (Communications of the ACM, 1961) is even taller today and most of the languages we use now aren't even depicted on it. 

It's an interesting question and one worth exploring in detail elsewhere, but here are a few specific thoughts with a focus on Python.

I think the popularity of Python (vs Perl, Ruby, or other scripting languages) can be accounted for in terms of the following:

• Low barrier to entry. 
  • Its dynamically typed nature and non-verbose syntax help a lot. 
  • It encourages exploratory programming and a rapid edit/run cycle.
  • It's also often said that Python looks somewhat like pseudocode.
  • Despite the low entry cost, it's a powerful and capable language.
• Availability of many high quality libraries across a range of domains from science to web development.
  • Especially where high performance science libraries are concerned, there is a dependency upon C/C++ libraries wrapped and invoked from Python, but that turns out to be a strength in this case.

Python is increasingly being taught in schools/universities where Scheme might once have been; that may account in part for its popularity.

There are things I don't like about Python (e.g. I prefer whitespace to have no meaning) and every other programming language I've ever used. It's also true that hype has accompanied many programming languages, and continues to do so.

For a software engineer, languages like C/C++ and Java are sometimes be more desirable. When a language needs to be learned or used, that's really just part of the professional's job description and is helped by a formal study of programming paradigms.

When I'm building a big system (more than a couple of 1000 of lines of code) I prefer as much static typing in a language as possible in order to eliminate as many classes of bugs as possible and also to provide tools (e.g. Integrated Development Environments) with richer hints. For small programs/scripts, this is far less important.

When I learned Perl it changed my view of what a programming language could be, but Perl has suffered in its maturity. However, I don't think much really differentiates Perl or Python from other similar dynamically typed scripting languages except the amount of tool, library, and other support. To be fair though, Perl has quirks that made it rather less appealing than Python and others but many of us loved it anyway.

Other languages such as R occupy a niche, statistics in R's case, but with the right set of libraries, Python is quite capable in that area also.

To sum up re: Python, it's a capable language with great tool and library support (both important for a non-trivial language) from the laptop to high performance compute clusters and I probably "think faster" in Python (once I would have said that of Perl) than most other languages except Java. I've used both for around the same amount of time (Java since 1996, Python since around 2000). At the end of the day, every programming language is just a tool of course.

In any given week, I code in some combination of Python, R, C++, Java, JavaScript, Fortran (depending upon project), and other languages. I enjoy thinking about one language's strengths over another. At work I recently gave a talk about R and one of its frameworks/libraries: Shiny. For some classes of data-centric applications I can write a small amount of code and achieve a great deal that would require an order of magnitude or two in another language/framework. The choice of such things can substantially affect productivity depending upon the scenario.

I the 90s I developed compilers and interpreters, including one for the Amiga and one for the Newton PDA. These are among the programming languages that were useful in a particular context over a certain time frame, but have largely fallen into disuse. Some of the "500+" you refer to would fall into this category. Others would be niche languages (even moreso than something like R, e.g. Matlab, Mathematica). Still others are confined to research or academia or idle curiosity. A small number emerge into the light.

Every so often, a disruptive language comes along. Java was one of those in 1996. Likewise for Perl several years earlier and C in the early 70s. Plenty of other examples exist. But for each "important" and long lived language, many come and go, and there's certainly a merit-based, survival of the fittest process at work. That's not to say that the "best" (by some criteria) survive, just those that are most "successful" (by some criteria).

I like what Bjarne Stroustrup, creator of C++, had to say in his book, The Design and Evolution of C++:

I consider it the obligation of scientists and intellectuals to ensure that their ideas are made accessible and thus useful to society instead of being mere playthings for specialists.

David

Another python tool that might be of use for FITS is pyraf which gives you a python interface to IRAF. That may suit your FITS & WCS needs particularly if you are already familiar with IRAF.

pyephem (based on the c library libastro from xephem) can handle a lot of the basic coordinate transformations http://rhodesmill.org/pyephem/index.html

For the ra/dec >  alt/az you can do something like:

obs = ephem.Observer()
obs.lon = "-6.0"
obs.lat = "53.0"
obs.date = ephem.Date('2015/09/10 12:41:16)
obs.epoch = "2000"

t = ephem.FixedBody()
t._ra = "0:40:04.72"
t._dec = "18:47:48.7"

t.compute(obs)
# You then have t.az and t.alt to play with (though you may need to check the epoch!)

I use pyephem quite a bit for my tools. Mind you I'm not doing any FITS processing with it yet.

Others have mentioned anaconda. Another nice tool that comes with that is 'ipython notebook' which allows you to code in python in your browser and allow you to make changes to code without needing to rerun your entire script. Very useful for debugging/development.

Folks that have an interest in the technical aspects of observatory, CCD, mount, etc control might be interested in the INDI Open Astronomy Instrumentation Forums. 

http://indilib.org/forum/general.html

It includes the development and relaese of an observatory control program and library that runs on a Raspberry.

On another topic, the MIT 600.1x course on EdX looks really good.  Typical high quality MIT professor.  Starts slowly and gains steam rapidly.  Thanks for whoever posted the info about it.

Jim Jones