NumPy 1.5 Beginner's Guide und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 37,44
  • Alle Preisangaben inkl. MwSt.
Auf Lager.
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Ihren Artikel jetzt
eintauschen und
EUR 1,00 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Dieses Bild anzeigen

NumPy 1.5 Beginner's Guide (Englisch) Taschenbuch – 8. November 2011

Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 37,44
EUR 34,44 EUR 43,55
6 neu ab EUR 34,44 3 gebraucht ab EUR 43,55

Dieses Buch gibt es in einer neuen Auflage:

Wird oft zusammen gekauft

NumPy 1.5 Beginner's Guide + SciPy and NumPy + Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython
Preis für alle drei: EUR 72,39

Die ausgewählten Artikel zusammen kaufen
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Mehr über den Autor

Ivan Idris was born in Bulgaria from Indonesian parents. He moved to the Netherlands in the 1990s, where he graduated from high school and got a MSc in Experimental Physics.

His graduation thesis had a strong emphasis on Applied Computer Science. After graduating he worked for several companies as Java Developer, Datawarehouse Developer and QA Analyst.

His main professional interests are Business Intelligence, Big Data and Cloud Computing. Ivan Idris enjoys writing clean testable code and interesting technical articles.


Über den Autor und weitere Mitwirkende

Ivan Idris has a degree in Experimental Physics and several certifications (SCJP, SCWCD and other). His graduation thesis had a strong emphasis on Applied Computer Science. After graduating Ivan worked for several companies as a Java developer, Datawarehouse developer and Test Analyst.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?

In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:


Es gibt noch keine Kundenrezensionen auf
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne

Die hilfreichsten Kundenrezensionen auf (beta) 8 Rezensionen
12 von 12 Kunden fanden die folgende Rezension hilfreich
A decidedly weak introduction to NumPy, but with useful examples 31. Mai 2012
Von W. McKinney - Veröffentlicht auf
Format: Taschenbuch
Disclaimer: I was sent a free copy of the book for review by Packt.

There are fairly few books about scientific Python (I am in the process of writing one myself). Hans Petter Langtangen's books with Springer provide a good introduction to Python, NumPy, and SciPy for computational science and physical applications, but they leave a lot to be desired for the budding data analyst or R or MATLAB refugee. That being said, I was excited to see that this particular book was being written.

This is decidedly a beginner's guide. It gives a gentle introduction to NumPy arrays and features by means of hands-on examples. It does a good job of illustrating array-oriented computing (including such ideas as vectorization and broadcasting) using examples that are primarily derived from financial applications. Visualization uses matplotlib, although matplotlib is not given a more direct treatment until later in the book. In addition to examples combining array operations and matplotlib plots, the author gives an overview of the other important areas of the library: random number generation, fourier transforms, polynomials, ufuncs, and the linear algebra module. Additionally, there is a chapter on unit testing with NumPy and a short chapter on SciPy and statsmodels.

The quality and value of the book is hurt by a number of things.

First: editing and technical content. There is quite a bit of poorly formatted code and inconsistencies throughout the book that will very likely confuse new users. The author ought to have done a bit more research into common practice and conventions generally accepted by the scientific Python community: for example, sometimes functions are written using "numpy.", other times they are written without the explicit module reference. This sort of thing causes a lot of cognitive dissonance for readers.

Secondly, even though this is a beginner text, many of the topics would benefit from more in-depth explanations such as tables explaining the complete usage of common array methods such as reductions like mean, sum, and variance. The user is left to infer this from examples; this is more of a "learn by doing and experimenting" book, so keep that in mind.

Lastly, many important features of NumPy that distinguish it from MATLAB and R are omitted. In particular, array views, which are mentioned several times in the text, are never (as far as I can tell) very rigorously explained, which is likely to trip up new users. Other important features like broadcasting should also find a place in the book. Discussion of structured arrays, memory maps, and other more advanced IO features is also largely absent.

In summary. What this book is:

- A gentle introduction to many of NumPy's features, with a smattering of matplotlib and SciPy
- A series of useful and pretty interesting examples largely stemming from financial applications

What it is not:

- A guide for R users looking to pick up Python
- A comprehensive introduction to NumPy
- A primary text for new or aspiring scientific Python programmers

Before buying, I recommend taking a look at the table of contents. There is a lot of useful information and examples here, but I would suggest supplementing it with other content available online such as the Scientific Python Lectures [...]
9 von 9 Kunden fanden die folgende Rezension hilfreich
Learn by doing: less theory, more results 9. Dezember 2011
Von David W. Lambert - Veröffentlicht auf
Format: Taschenbuch
NumPy 1.5 achieves the goal stated on its cover "Learn by doing: less theory, more results". In my opinion, it is an exciting introduction to the large numpy module. Many of the examples pertain to money: stock market analysis. I learned quite a bit even though I was quite familiar with numpy prior to reading.

From the basic additional functionality of arithmetic operating over all data at once, to advanced math of polynomials, fast Fourier transform, singular value decomposition, to visualization with graphics, NumPy 1.5 motivates the python programmer to install and use numpy. The book assumes facility with python. For instance, author Ivan Idris expects you to know how to examine directories and files with your operating system. He expects you to know to import datetime and sys as you read the book. Since these are included in the companion code it may help to browse these sources alongside the text. Frankly, I appreciated being treated as competent. The book does not cover all the available random distributions, special functions, optimizations for special matrices. Nor should it as an introduction to numpy. Ivan provides direction for your further investigation.

I jotted a few notes as I read:
> The numpy installation instructions were included for several operating systems. My installation on ubuntu was perfect;
> The author employed a helpful a method of frequent summaries and quizzes;
> In many instances multiple solutions were presented for a task;
> NumPy 1.5 treats broadcasting almost implicitly. In chapter 1 we see an_array**3. It seems worth repeating that each value of the array is cubed, taking us back to the near origins of interactive computing, APL and Dartmouth BASIC;
> In addition to the tab completion help of ipython which was recommended, I'd have liked to also see advocacy for numpy.lookfor and in chapter 1. These handy documentation search functions assist finding the right method among the large numpy extension to python;
> I had to search the internet for matplotlib. Should NumPy 1.5 Beginner's Guide have explained the straightforward installation?

After a brief tour of numpy basics in chapter 1, NumPy: Beginner's Guide introduces additional numpy functionality and concepts with real-life examples as promised on the book's cover. For me the material from chapter 5 onward became easier, perhaps because both the author and I are physicists. Chapters 3 and 4 demonstrated numpy features to analyze stock market data. Chapter 5 continued by synthesizing wave forms with Fourier series. I enjoyed seeing the ringing created using a small number of terms of the Fourier series. On the the other hand, NumPy zipped through Eigenvalues and singular value decomposition without real world examples. Wherein the earlier chapters emphasized curve fits, it would have been appropriate for the SVD example to fit a lower order polynomial to same data. Also marginally interesting: FFT of stock market data. You might consider my complaints illegitimate. The book isn't a linear algebra text. If you know you need this functionality you probably understand it and now you've discovered that it, and more, is easily accessible from numpy.

The functionality of numpy is akin to a verbose form of APL, my first programming language. Thus I might be overly harsh. NumPy 1.5 introduces the rich numerical numpy toolset enabling rapid insight through a variety of approaches to manipulating data. I've used numpy for scientific computing. I recommend numpy for python even if all you need is to add two lists together, and I endorse Ivan Idris's NumPy 1.5 Beginner's Guide. It will familiarize you with numpy and help you to use it effectively.
10 von 11 Kunden fanden die folgende Rezension hilfreich
A good starting point for newbie number-crunchers 9. Januar 2012
Von hardcoreUFO - Veröffentlicht auf
Format: Taschenbuch
Due primarily to their relative popularity, there are far more books available for R than for Python, at least related to using the respective languages for data analysis and other numerical applications. There are fewer yet related to the various third-party packages that are available for Python. So, it was with more than a little excitement that I tracked down a copy of the NumPy 1.5 Beginner's Guide, authored by Ivan Idris.

One of the unavoidable issues with writing books about software is that for even moderately well-maintained packages, the release version has changed by the time the book is published; this is the case for Idris' book, as NumPy has reached version 1.6 (and many users work from the current codebase on GitHub). Don't let this deter you, however, as the major functionality changes little from version to version, particularly for point releases.

The book begins with thorough, visual installation instructions for the three major platforms (sorry, OS/2 users!). Though the NumPy website includes decent install instructions, this is a welcome chapter, particularly for new users, because it is well-organized and highly visual. Depending on your setup, the instructions for building from source may not be sufficient, at least on OS X, where some configuration is sometimes necessary depending on which version of Xcode (and hence, compilers) is installed.

In addition to installation guidance, the author reveals several avenues for 3rd-party help with NumPy, which is useful since one inevitably outstrips any book's ability to answer all one's questions. Its a good choice of recommended resources, too: mailing lists, IRC, and critically, Stack Overflow.

The catch-phrase of the Packt Beginner's Guide series is Learn by doing: less theory, more results. True to its word, this particular guide is extremely hands on, comprised mostly of step-by-step "Time for Action" recipes for performing particular atomic tasks using NumPy within Python. For the most part, this philosophy works to the user's benefit by providing a ton of useful guides to the core functionality of NumPy. However, in places this causes suffering due to lack of context. For example, what is a Bessel function, and why would I need it? How do I interpret the plot I just generated? To me, you could provide some background without fear of being mistaken for a textbook.

Though the book is technically a beginner's guide, it is stated up front that knowledge of Python is assumed. This is evident early: the reader is taken from the installation guide kiddie pool directly to the deep end of vector operations. The early chapters illustrate how NumPy works closely with other scientific programming packages, most notably Matplotlib and iPython. This includes a very condensed iPython tutorial, which is a boon because everyone doing scientific computing with Python should be using iPython as the default shell.

The early chapters do a solid job of covering NumPy fundamentals, and by fundamentals we are, of course, talking about ndarrays. The introduction to array data types jumps right in to creating custom types, a topic that is truly useful for those of us applying NumPy to real data. Overall, the range of array methods provided is deep relative to other resources I have encountered.

One of the nice things about the book is that you are almost guaranteed to learn something new, almost irrespective of your level of expertise. For as long as I've been using NumPy, I tend use a particular subset of its functionality, related to the sort of work I do. This book is more comprehensive than that. Who knew you could truncate the values of an array with ndarray.clip()? Not me. Some of the included workflows should be really useful for a lot of users, such as inserting arbitrary values into a sorted array such that it remains sorted.

A big take-home lesson from the book that is likely to impress the novice user is the manifold advantages of working with arrays, rather than looping over lists, be it by using ufuncs or vectorizing scalar functions. Its not only a performance boon, but from a development standpoint its much easier to read and to maintain.

My only pedantic criticism of the book is the use of some rather awkward English in places: "Get into Terms with Commonly Used Functions" doesn't sound quite right, and "Have a go hero" is an odd little phrase used to encourage hands-on programming that seems to have come straight from "Go Diego Go". This, along with a few function usage mistakes would suggest that another round of edits was in order.

Idris makes heavy use of financial applications for his examples. This is fine, I suppose, but it may be heavy going for those from other fields, given the finance's tendency to use specialized terminology. A broader range of motivating examples would have both shown the breadth of NumPy's potential application and helped the book appeal to a wider audience.

Though full coverage of a package so jammed with functionality as NumPy is impossible, this guide covers a reasonable cross section: Users are introduced to calculating and drawing waveforms, fitting polynomial functions, matrix functions and manipulation, statistical distributions, sorting algorithns and (you guessed it) financial functions.

It was very nice (particularly given the aforementioned constraints) to see a testing chapter, though it is just an overview of the key testing functions. This is a good example of where a little background would have made a big difference--new users are rarely able to appreciate the importance of testing, particularly unit testing, so a little motivation is required to make the concept stick, and to ensure that new NumPy users put them into practice.

Despite my criticisms, I would recommend The NumPy 1.5 Beginner's Guide without hesitation to users unfamiliar with NumPy (provided they already have some Python chops). NumPy is the most important Python package for mathematics, statistics and other numerical computation, and there is currently no better novice introduction in print. Having a copy of my own, it will be nice to have it close at hand to remind me of how much power is contained within the NumPy code base.

DISCLAIMER -- I was given a complementary electronic copy of the book from the publisher in exchange for writing a review.
3 von 3 Kunden fanden die folgende Rezension hilfreich
Teaches by Example 16. Dezember 2011
Von Mike Driscoll - Veröffentlicht auf
Format: Taschenbuch
This book is aimed at mathematicians, scientists and the like. I'm just a Python programmer. While the math was above my head most of the time, the book has lots of examples and code snippets. The author focuses on using stock market equations and finance, especially towards the end of the book. I thought the examples demonstrated NumPy pretty well. The last couple of chapters deal more with Matplotlib and SciPy than NumPy. If you're a scientist or such looking to apply Python to your research, I think this book will help you jump into the scientific part of Python.

I wrote a more full fledged review on the Mouse vs. The Python blog. Anyway, I thought this was a pretty good book, unlike some of Packt's other books. FULL DISCLOSURE: Packt sent me a free copy of the book to review.
2 von 2 Kunden fanden die folgende Rezension hilfreich
Excellent reference for the Numpy beginner 29. Dezember 2011
Von DUANE A KAUFMAN - Veröffentlicht auf
Format: Taschenbuch
Background on myself
Engineer formally trained in Physics and Mathematics. Utilize Python both at work and at home for small tasks, from automation of repetitive tasks, to reorganizing music libraries, or displaying exercise bike data.
I enjoy haunting comp.lang.python, but rarely contribute, as I find the level of responses there indicative of responders who a) Are much better coders than I, and b) know every nook and cranny of the Python language, and are more than willing to share their knowledge and experience.

Book is written in a clear manner, with a consistent layout and structure throughout, though sometimes the strict adherence to the form clutters introductory sections with unnecessary text [Page 14 'What just happened?'].

The book, like many of this kind uses different font types to indicate code examples, comments, etc. In my e-copy, some examples had incorrect spacing (Page 23), which, though slightly confusing, didn't degrade getting the intent across.

The book is also good about mentioning the numerous on-line places to go for help. Personally I have found the Python on-line community extremely helpful and non-judgmental.

It is too bad the page width (in characters) for the code examples was chosen to be less than a normal ipython session, as this causes wrapping artifacts when showing ipython output lines (page 56).

Throughout the book there are numerous Pop Quizzes, to probe the understanding of the reader on the recently-presented material. Answers to the quizzes are provided in the back of the book, as well as an extensive index.

Chapter 2 is a good introduction to the basic entity exposed by numpy: ndarrays. This chapter covers creation and manipulation of ndarrays in many different use scenarios.

In the next two chapters the author investigates further statistical functions of numpy to analyze the stock prices over a given time span. The data analyzed resides in a Comma-Separated-Value (CSV formatted file), and numpy methods are used to read the data from file.

From the vectors introduced so far, the author next delves into matrix creation and operations on matrices. At this point numpy Universal Functions are introduced, allowing Python-written functions to manipulate and calculate on numpy array objects. Following this, bit-wise operations are covered as well.

Chapter 6 starts off with numpy's uses in the field of linear algebra (matrix inversion, eigenvalues, linear equations and determinants), shifting to signal analysis using Fast Fourier Transforms, random numbers and various distribution types offered by numpy.

Chapter 8 covers an often-overlooked part of programming: testing. Numpy offers a rich set of comparison helper functions to facilitate testing, on both the scalar, vector and matrix objects. I know that I myself could do with writing more unit tests!

The next section details the use of a partner Python plotting package called matplotlib. The book details the use of matplotlib to create a variety of plots, utilizing matplotlib's ability to pull data from Yahoo Finance. Various types of axis formatting and data series representations are presented.

The content of Chapter 10 is a collection of miscellaneous purposes numpy can lend itself to: from interoperability with Matlab and Octave, signal processing, and manipulation of image data. A number of the examples call upon another companion software package, Scipy, which is a collection of utilities to aid in scientific computation (also based on numpy).

For the person familiar with Python, this book provides the introductory use and examples that will facilitate getting up and running with numpy in short order. The book was well laid-out, and provided examples with enought detail to allow for progressing beyond those examples without a problem.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.