Search icon CANCEL
Subscription
0
Cart icon
Your Cart (0 item)
Close icon
You have no products in your basket yet
Save more on your purchases! discount-offer-chevron-icon
Savings automatically calculated. No voucher code required.
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Newsletter Hub
Free Learning
Arrow right icon
timer SALE ENDS IN
0 Days
:
00 Hours
:
00 Minutes
:
00 Seconds
Advanced Python Programming
Advanced Python Programming

Advanced Python Programming: Accelerate your Python programs using proven techniques and design patterns , Second Edition

Arrow left icon
Profile Icon Quan Nguyen
Arrow right icon
S$44.99 S$50.99
Full star icon Full star icon Full star icon Full star icon Half star icon 4.6 (14 Ratings)
eBook Mar 2022 606 pages 2nd Edition
eBook
S$44.99 S$50.99
Paperback
S$63.99
Subscription
Free Trial
Arrow left icon
Profile Icon Quan Nguyen
Arrow right icon
S$44.99 S$50.99
Full star icon Full star icon Full star icon Full star icon Half star icon 4.6 (14 Ratings)
eBook Mar 2022 606 pages 2nd Edition
eBook
S$44.99 S$50.99
Paperback
S$63.99
Subscription
Free Trial
eBook
S$44.99 S$50.99
Paperback
S$63.99
Subscription
Free Trial

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
OR
Modal Close icon
Payment Processing...
tick Completed

Billing Address

Table of content icon View table of contents Preview book icon Preview Book

Advanced Python Programming

Chapter 1: Benchmarking and Profiling

Recognizing the slow parts of your program is the single most important task when it comes to speeding up your code. In most cases, the code that causes the application to slow down is a very small fraction of the program. By identifying these critical sections, you can focus on the parts that need the most improvement without wasting time in micro-optimization.

Profiling is a technique that allows us to pinpoint the most resource-intensive parts of an application. A profiler is a program that runs an application and monitors how long each function takes to execute, thus detecting the functions on which your application spends most of its time.

Python provides several tools to help us find these bottlenecks and measure important performance metrics. In this chapter, we will learn how to use the standard cProfile module and the line_profiler third-party package. We will also learn how to profile the memory consumption of an application through the memory_profiler tool. Another useful tool that we will cover is KCachegrind, which can be used to graphically display the data produced by various profilers.

Finally, benchmarks are small scripts used to assess the total execution time of your application. We will learn how to write benchmarks and use them to accurately time your programs.

The topics we will cover in this chapter are listed here:

  • Designing your application
  • Writing tests and benchmarks
  • Writing better tests and benchmarks with pytest-benchmark
  • Finding bottlenecks with cProfile
  • Optimizing our code
  • Using the dis module
  • Profiling memory usage with memory_profiler

By the end of the chapter, you will have gained a solid understanding of how to optimize a Python program and will be armed with practical tools that facilitate the optimization process.

Technical requirements

To follow the content of this chapter, you should have a basic understanding of Python programming and be familiar with core concepts such as variables, classes, and functions. You should also be comfortable with working with the command line to run Python programs. Finally, the code for this chapter can be found in the following GitHub repository: https://github.com/PacktPublishing/Advanced-Python-Programming-Second-Edition/tree/main/Chapter01.

Designing your application

In the early development stages, the design of a program can change quickly and may require large rewrites and reorganizations of the code base. By testing different prototypes without the burden of optimization, you are free to devote your time and energy to ensure that the program produces correct results and that the design is flexible. After all, who needs an application that runs fast but gives the wrong answer?

The mantras that you should remember when optimizing your code are outlined here:

  • Make it run: We have to get the software in a working state and ensure that it produces the correct results. This exploratory phase serves to better understand the application and to spot major design issues in the early stages.
  • Make it right: We want to ensure that the design of the program is solid. Refactoring should be done before attempting any performance optimization. This really helps separate the application into independent and cohesive units that are easy to maintain.
  • Make it fast: Once our program is working and well structured, we can focus on performance optimization. We may also want to optimize memory usage if that constitutes an issue.

In this section, we will write and profile a particle simulator test application. A simulator is a program that considers some particles and simulates their movement over time according to a set of laws that we impose. These particles can be abstract entities or correspond to physical objects—for example, billiard balls moving on a table, molecules in a gas, stars moving through space, smoke particles, fluids in a chamber, and so on.

Building a particle simulator

Computer simulations are useful in fields such as physics, chemistry, astronomy, and many other disciplines. The applications used to simulate systems are particularly performance-intensive, and scientists and engineers spend an inordinate amount of time optimizing their code. In order to study realistic systems, it is often necessary to simulate a very high number of bodies, and every small increase in performance counts.

In our first example, we will simulate a system containing particles that constantly rotate around a central point at various speeds, just like the hands of a clock.

The necessary information to run our simulation will be the starting positions of the particles, the speed, and the rotation direction. From these elements, we have to calculate the position of the particle in the next instant of time. An example system is shown in the following diagram. The origin of the system is the (0, 0) point, the position is indicated by the x, y vector, and the velocity is indicated by the vx, vy vector:

Figure 1.1 – An example of a particle system

Figure 1.1 – An example of a particle system

The basic feature of a circular motion is that the particles always move perpendicular to the direction connecting the particle and the center. To move the particle, we simply change the position by taking a series of very small steps (which correspond to advancing the system for a small interval of time) in the direction of motion, as shown in the following diagram:

Figure 1.2 – Movement of a particle

Figure 1.2 – Movement of a particle

We will start by designing the application in an object-oriented (OO) way. According to our requirements, it is natural to have a generic Particle class that stores the particle positions, x and y, and their angular velocity, ang_vel, as illustrated in the following code snippet:

    class Particle: 
        def __init__(self, x, y, ang_vel): 
            self.x = x 
            self.y = y 
            self.ang_vel = ang_vel

Note that we accept positive and negative numbers for all the parameters (the sign of ang_vel will simply determine the direction of rotation).

Another class, called ParticleSimulator, will encapsulate the laws of motion and will be responsible for changing the positions of the particles over time. The __init__ method will store a list of Particle instances, and the evolve method will change the particle positions according to our laws. The code is illustrated in the following snippet:

class ParticleSimulator:
    def __init__(self, particles):
        self.particles = particles

We want the particles to rotate around the position corresponding to the x=0 and y=0 coordinates, at a constant speed. The direction of the particles will always be perpendicular to the direction from the center (refer to Figure 1.1 in this chapter). To find the direction of the movement along the x and y axes (corresponding to the Python v_x and v_y variables), it is sufficient to use these formulae:

    v_x = -y / (x**2 + y**2)**0.5
    v_y = x / (x**2 + y**2)**0.5

If we let one of our particles move, after a certain time t, it will reach another position following a circular path. We can approximate a circular trajectory by dividing the time interval, t, into tiny time steps, dt, where the particle moves in a straight line tangentially to the circle. (Note that higher-order curves could be used rather than straight lines for better accuracy, but we will stick with lines as the simplest approximation.) The final result is just an approximation of a circular motion.

In order to avoid a strong divergence, such as the one illustrated in the following diagram, it is necessary to take very small time steps:

Figure 1.3 – Undesired divergence in particle motion due to large time steps

Figure 1.3 – Undesired divergence in particle motion due to large time steps

In a more schematic way, we have to carry out the following steps to calculate the particle position at time t:

  1. Calculate the direction of motion (v_x and v_y).
  2. Calculate the displacement (d_x and d_y), which is the product of the time step, angular velocity, and direction of motion.
  3. Repeat Steps 1 and 2 enough times to cover the total time t.

The following code snippet shows the full ParticleSimulator implementation:

    class ParticleSimulator: 
        def __init__(self, particles): 
            self.particles = particles 
        def evolve(self, dt): 
            timestep = 0.00001 
            nsteps = int(dt/timestep) 
     
            for i in range(nsteps):
                for p in self.particles:
                    # 1. calculate the direction 
                    norm = (p.x**2 + p.y**2)**0.5 
                    v_x = -p.y/norm 
                    v_y = p.x/norm 
                    # 2. calculate the displacement 
                    d_x = timestep * p.ang_vel * v_x 
                    d_y = timestep * p.ang_vel * v_y 
                    p.x += d_x 
                    p.y += d_y 
                    # 3. repeat for all the time steps

And with that, we have finished building the foundation of our particle simulator. Next, we will see it in action by visualizing the simulated particles.

Visualizing the simulation

We can use the matplotlib library here to visualize our particles. This library is not included in the Python standard library, but it can be easily installed using the pip install matplotlib command.

Alternatively, you can use the Anaconda Python distribution (https://store.continuum.io/cshop/anaconda/), which includes matplotlib and most of the other third-party packages used in this book. Anaconda is free and is available for Linux, Windows, and Mac.

To make an interactive visualization, we will use the matplotlib.pyplot.plot function to display the particles as points and the matplotlib.animation.FuncAnimation class to animate the evolution of the particles over time.

The visualize function takes a ParticleSimulator particle instance as an argument and displays the trajectory in an animated plot. The steps necessary to display the particle trajectory using the matplotlib tools are outlined here:

  1. Set up the axes and use the plot function to display the particles. The plot function takes a list of x and y coordinates.
  2. Write an initialization function, init, and a function, animate, that updates the x and y coordinates using the line.set_data method. Note that in init, we need to return the line data in the form of line, due to syntactic reasons.
  3. Create a FuncAnimation instance by passing the init and animate functions and the interval parameters, which specify the update interval, and blit, which improves the update rate of the image.
  4. Run the animation with plt.show(), as illustrated in the following code snippet:
        from matplotlib import pyplot as plt 
        from matplotlib import animation 
        def visualize(simulator): 
            X = [p.x for p in simulator.particles] 
            Y = [p.y for p in simulator.particles] 
            fig = plt.figure() 
            ax = plt.subplot(111, aspect='equal') 
            line, = ax.plot(X, Y, 'ro') 
         
            # Axis limits 
            plt.xlim(-1, 1) 
            plt.ylim(-1, 1) 
            # It will be run when the animation starts 
            def init(): 
                line.set_data([], []) 
                return line, # The comma is important!
            def animate(i): 
                # We let the particle evolve for 0.01 time 
                  units 
                simulator.evolve(0.01) 
                X = [p.x for p in simulator.particles] 
                Y = [p.y for p in simulator.particles] 
                line.set_data(X, Y) 
                return line, 
            # Call the animate function each 10 ms 
            anim = animation.FuncAnimation(fig,
              animate,init_func=init,blit=True,
                interval=10) 
            plt.show()

To test this code, we define a small function, test_visualize, that animates a system of three particles rotating in different directions. Note in the following code snippet that the third particle completes a round three times faster than the others:

    def test_visualize(): 
        particles = [
                     Particle(0.3, 0.5, 1), 
                     Particle(0.0, -0.5, -1), 
                     Particle(-0.1, -0.4, 3)
        ] 
        simulator = ParticleSimulator(particles) 
        visualize(simulator) 
    if __name__ == '__main__': 
        test_visualize()

The test_visualize function is helpful to graphically understand the system time evolution. Simply close the animation window when you'd like to terminate the program. With this program in hand, in the following section, we will write more test functions to properly verify program correctness and measure performance.

Left arrow icon Right arrow icon
Download code icon Download Code

Key benefits

  • Benchmark, profile, and accelerate Python programs using optimization tools
  • Scale applications to multiple processors with concurrent programming
  • Make applications robust and reusable using effective design patterns

Description

Python's powerful capabilities for implementing robust and efficient programs make it one of the most sought-after programming languages. In this book, you'll explore the tools that allow you to improve performance and take your Python programs to the next level. This book starts by examining the built-in as well as external libraries that streamline tasks in the development cycle, such as benchmarking, profiling, and optimizing. You'll then get to grips with using specialized tools such as dedicated libraries and compilers to increase your performance at number-crunching tasks, including training machine learning models. The book covers concurrency, a major solution to making programs more efficient and scalable, and various concurrent programming techniques such as multithreading, multiprocessing, and asynchronous programming. You'll also understand the common problems that cause undesirable behavior in concurrent programs. Finally, you'll work with a wide range of design patterns, including creational, structural, and behavioral patterns that enable you to tackle complex design and architecture challenges, making your programs more robust and maintainable. By the end of the book, you'll be exposed to a wide range of advanced functionalities in Python and be equipped with the practical knowledge needed to apply them to your use cases.

Who is this book for?

This book is for intermediate to experienced Python programmers who are looking to scale up their applications in a systematic and robust manner. Programmers from a range of backgrounds will find this book useful, including software engineers, scientific programmers, and software architects.

What you will learn

  • Write efficient numerical code with NumPy, pandas, and Xarray
  • Use Cython and Numba to achieve native performance
  • Find bottlenecks in your Python code using profilers
  • Optimize your machine learning models with JAX
  • Implement multithreaded, multiprocessing, and asynchronous programs
  • Solve common problems in concurrent programming, such as deadlocks
  • Tackle architecture challenges with design patterns

Product Details

Country selected
Publication date, Length, Edition, Language, ISBN-13
Publication date : Mar 25, 2022
Length: 606 pages
Edition : 2nd
Language : English
ISBN-13 : 9781801817776
Vendor :
Google
Category :
Tools :

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
OR
Modal Close icon
Payment Processing...
tick Completed

Billing Address

Product Details

Publication date : Mar 25, 2022
Length: 606 pages
Edition : 2nd
Language : English
ISBN-13 : 9781801817776
Vendor :
Google
Category :
Tools :

Packt Subscriptions

See our plans and pricing
Modal Close icon
$19.99 billed monthly
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Simple pricing, no contract
$199.99 billed annually
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just S$6 each
Feature tick icon Exclusive print discounts
$279.99 billed in 18 months
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just S$6 each
Feature tick icon Exclusive print discounts

Frequently bought together


Stars icon
Total S$ 195.97
Advanced Python Programming
S$63.99
Learn Python Programming, 3rd edition
S$63.99
Mastering Python 2E
S$67.99
Total S$ 195.97 Stars icon

Table of Contents

31 Chapters
Section 1: Python-Native and Specialized Optimization Chevron down icon Chevron up icon
Chapter 1: Benchmarking and Profiling Chevron down icon Chevron up icon
Chapter 2: Pure Python Optimizations Chevron down icon Chevron up icon
Chapter 3: Fast Array Operations with NumPy, Pandas, and Xarray Chevron down icon Chevron up icon
Chapter 4: C Performance with Cython Chevron down icon Chevron up icon
Chapter 5: Exploring Compilers Chevron down icon Chevron up icon
Chapter 6: Automatic Differentiation and Accelerated Linear Algebra for Machine Learning Chevron down icon Chevron up icon
Section 2: Concurrency and Parallelism Chevron down icon Chevron up icon
Chapter 7: Implementing Concurrency Chevron down icon Chevron up icon
Chapter 8: Parallel Processing Chevron down icon Chevron up icon
Chapter 9: Concurrent Web Requests Chevron down icon Chevron up icon
Chapter 10: Concurrent Image Processing Chevron down icon Chevron up icon
Chapter 11: Building Communication Channels with asyncio Chevron down icon Chevron up icon
Chapter 12: Deadlocks Chevron down icon Chevron up icon
Chapter 13: Starvation Chevron down icon Chevron up icon
Chapter 14: Race Conditions Chevron down icon Chevron up icon
Chapter 15: The Global Interpreter Lock Chevron down icon Chevron up icon
Section 3: Design Patterns in Python Chevron down icon Chevron up icon
Chapter 16: The Factory Pattern Chevron down icon Chevron up icon
Chapter 17: The Builder Pattern Chevron down icon Chevron up icon
Chapter 18: Other Creational Patterns Chevron down icon Chevron up icon
Chapter 19: The Adapter Pattern Chevron down icon Chevron up icon
Chapter 20: The Decorator Pattern Chevron down icon Chevron up icon
Chapter 21: The Bridge Pattern Chevron down icon Chevron up icon
Chapter 22: The Façade Pattern Chevron down icon Chevron up icon
Chapter 23: Other Structural Patterns Chevron down icon Chevron up icon
Chapter 24: The Chain of Responsibility Pattern Chevron down icon Chevron up icon
Chapter 25: The Command Pattern Chevron down icon Chevron up icon
Chapter 26: The Observer Pattern Chevron down icon Chevron up icon
Assessments Chevron down icon Chevron up icon
Other Books You May Enjoy Chevron down icon Chevron up icon

Customer reviews

Top Reviews
Rating distribution
Full star icon Full star icon Full star icon Full star icon Half star icon 4.6
(14 Ratings)
5 star 71.4%
4 star 21.4%
3 star 7.1%
2 star 0%
1 star 0%
Filter icon Filter
Top Reviews

Filter reviews by




Krishnan Raghavan May 23, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
Python is a programming language that is mostly used for fast prototyping and software development both by beginners for its easy-to-learn syntax as well as by experienced programmers. It's not a language preferred when it comes to scaling or speed. Most programmers prefer other programming languages for this. The author of this book has tried to show that this is not really necessary and even Python has enough tools and support for optimizing and scaling.This book is best utilized by intermediate to expert programmers who are looking to scale up their applications and make them more robust.What I learnt from this book:1. How to identify sections of the code that is slowing down and increasing the execution time and how to optimize and increase the performance of the code using data structures, algorithms and third-party tools efficiently.2. Fast Array Operations with NumPy, Pandas and Xarray to implement fast numerical algorithms.3. Improve performance with Cython and other compilers like Numba Framework that can be used to compile Python code.4. Tools and Libraries that help implement parallelism and concurrency for web requests, Image processing tasks, deadlock, and Race Conditions kinds of situations.5. Factory Design Patterns and benefits of using Factory design patterns instead of direct object instantiation.6. How to implement Concurrency and Parallel Programming on multi-core processors and GPUs. Very useful for data science projects.At the end of each chapter, the author has provided a summary that helps in revising the chapter and questions that will test your knowledge about the chapter. Wherever applicable, additional material for reading is suggested.This book has helped me understand topics of which I was not aware previously. Kudos to Quan Nguyen for the effort in bringing out this excellent book. Thank you very much, Quan Nguyen.
Amazon Verified review Amazon
Ryan Zurrin Jun 10, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
The media could not be loaded. Advanced Python Programming 2nd edition by Quan Nguyen. Over 500 pages of pythonic knowledge that I consider a must know for anyone using python programming professionally. As a fulltime student working as a researcher, researching Breast Cancer detection using machine learning, I use python daily and this book has been so helpful for me in developing and strengthening areas I was previously lacking.Another one of the things I loved about this book is the example they use throughout the book, a simple particle simulator. If you love physics as I do, you will fall in love with this example, and how it grows throughout the book, getting better and better as we learn how to use more powerful techniques to achieve the best performance from whatever we are building.Advanced Python Programming 2nd Edition also covers topics like Machine Learning, just the basics, but it is a good start. It gets into how to use Concurrency and parallel processing, what the differences are between them, and what some of the common mistakes us beginners usually face when first starting out in these tough areas of python programming. This book is truly a toolbox of techniques for us to use, which can help us to become masters of this unique and diverse programming language.There is a whole section on Design Patterns which was recently so helpful for me in my research. I had to build a singleton class and had no idea what that even was, and I was able to look it up in this book and learn exactly what I needed to do to implement one on my own. Other design patterns covered are things like the Factory Pattern, the Builder Pattern, Creational Patterns – for which the Singleton was a part of, the Adapter Pattern, the Decorator Pattern, Bridge Pattern and more. It really gets into the nitty gritty of how to properly program in python.So, if you are programming in python professionally already or just looking for a book to boost up what you already know this book is for you. It does not get into the basics of python so it starts out assuming you already have that experience so if you never programmed in python before you may want to start someplace else before trying this book, but I think it is a great book for anyone who plans to use python on a regular basis.Packt books has done it again and brought us another great technical book by another great author, Quan Nguyen who does wonders in this book. Advanced Python Programming 2nd edition is an amazing book so I’d say pick it up if you can, it will not disappoint.
Amazon Verified review Amazon
Jaime Sierra Silva (Consignment) Nov 24, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
Python is a very versatile language, in general, one thing is to learn a language and another thing is to use it in the most optimal way, so that the software that is developed is of a performance for its users and the structure in which it is located.In "Advanced Python Programming", the author delves into techniques and practices to optimize programs written in Python, so that it uses optimally the resources at its disposal and fulfills its objectives in the best way. The book takes us through the different aspects to consider to improve our codes, the only goal is to be a better Python developer.
Amazon Verified review Amazon
jml May 13, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
Advanced Python Programming, Second Edition offers a variety of in-depth coverage in its roughly 550 pages. The book starts off with optimization techniques, useful to all Python programmers but especially those focusing on mathematical specialties (NumPy, Pandas, and Xarray). There’s also a neat introduction to machine learning, which leads smoothly into a treatment of parallel and threaded processing. Deadlocks, thread starvation, and the global interpreter lock are explained in a context useful to Python professionals. Finally, several in-depth chapters are devoted to the care and feeding of various design patterns and factories. If you're not comfortable with those functions when you start the book, you probably will be once you finish it. The author, Quan Nguyen, has done a solid job of presenting the material without overwhelming the reader, using code examples, projects, and diagrams where appropriate. Chapters are well-paced making for a very readable book. As the title indicates, this is not a beginner’s guide or a Python tutorial, but experienced programmers will definitely pick up some new knowledge from a thorough reading.
Amazon Verified review Amazon
Jaelyn Jensen May 20, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
First impression was "Even though it's pretty long (~550 pages), this will be an easy read, because I already have substantial experience with Design Patterns in C++."Well, it was a lot more than just a Design Patterns in Python3 book. I wasn't very far into the book when my hubris became embarrassingly obvious. The author didn't even start in on the Design Patterns stuff until nearly 2/3rds of the way through the book. Well, that part was a comparably easy read, partially because using the GoF patterns in Python is a little easier than in C++. Well, mostly, anyway. Python3 makes using most of the GoF patterns pretty straightforward.The first two-thirds of the book were more challenging (and informative) than I expected. The author takes a deep dive into various ways to optimize and improve your code. Of course, he started off with the observation that the choice of algorithm totally dominates that process. But I certainly learned a lot about Python3 (and various library) optimizations.I got introduced to a lot of different things in Python3 that I didn't know existed, and got to review some things I had not encountered in a long time. In a way, learning Python is a lot like learning Java, in the sense that the syntax of the language is pretty easy to understand. The problem is that learning the proper syntax rules puts you at about 5% of the way to being a proficient programmer. Learning the "Pythonic" way of doing stuff (like making appropriate use of things like tuples and dictionaries) gets you to maybe 15%. Learning a huge body of existing libraries gets you to about 80%, after which incremental gains get more challenging.I think that this book can get you to almost 100% (actually, 100% might not really be achievable in any discipline -- or maybe the field just continues to expand) of the way to production programming. Well, this book and a few years of experience. If you already have a bit of Python3 experience, then this book is a great follow-on to get your Python3 chops to the next level.I liked the way the assessment questions were used, and I appreciated the coverage of the assessment answers at the end. The assessments were well-done.I can think of only two things to suggest for improvement. The first would be to make this into 3 books instead of one huge tome. That might have made it somewhat less overwhelming The second would be to provide an overview of how to use the various help facilities in Python. Although by the time you really need this book, you probably already have that 2nd part figured out.This book will be one that I return to often for reference.
Amazon Verified review Amazon
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

How do I buy and download an eBook? Chevron down icon Chevron up icon

Where there is an eBook version of a title available, you can buy it from the book details for that title. Add either the standalone eBook or the eBook and print book bundle to your shopping cart. Your eBook will show in your cart as a product on its own. After completing checkout and payment in the normal way, you will receive your receipt on the screen containing a link to a personalised PDF download file. This link will remain active for 30 days. You can download backup copies of the file by logging in to your account at any time.

If you already have Adobe reader installed, then clicking on the link will download and open the PDF file directly. If you don't, then save the PDF file on your machine and download the Reader to view it.

Please Note: Packt eBooks are non-returnable and non-refundable.

Packt eBook and Licensing When you buy an eBook from Packt Publishing, completing your purchase means you accept the terms of our licence agreement. Please read the full text of the agreement. In it we have tried to balance the need for the ebook to be usable for you the reader with our needs to protect the rights of us as Publishers and of our authors. In summary, the agreement says:

  • You may make copies of your eBook for your own use onto any machine
  • You may not pass copies of the eBook on to anyone else
How can I make a purchase on your website? Chevron down icon Chevron up icon

If you want to purchase a video course, eBook or Bundle (Print+eBook) please follow below steps:

  1. Register on our website using your email address and the password.
  2. Search for the title by name or ISBN using the search option.
  3. Select the title you want to purchase.
  4. Choose the format you wish to purchase the title in; if you order the Print Book, you get a free eBook copy of the same title. 
  5. Proceed with the checkout process (payment to be made using Credit Card, Debit Cart, or PayPal)
Where can I access support around an eBook? Chevron down icon Chevron up icon
  • If you experience a problem with using or installing Adobe Reader, the contact Adobe directly.
  • To view the errata for the book, see www.packtpub.com/support and view the pages for the title you have.
  • To view your account details or to download a new copy of the book go to www.packtpub.com/account
  • To contact us directly if a problem is not resolved, use www.packtpub.com/contact-us
What eBook formats do Packt support? Chevron down icon Chevron up icon

Our eBooks are currently available in a variety of formats such as PDF and ePubs. In the future, this may well change with trends and development in technology, but please note that our PDFs are not Adobe eBook Reader format, which has greater restrictions on security.

You will need to use Adobe Reader v9 or later in order to read Packt's PDF eBooks.

What are the benefits of eBooks? Chevron down icon Chevron up icon
  • You can get the information you need immediately
  • You can easily take them with you on a laptop
  • You can download them an unlimited number of times
  • You can print them out
  • They are copy-paste enabled
  • They are searchable
  • There is no password protection
  • They are lower price than print
  • They save resources and space
What is an eBook? Chevron down icon Chevron up icon

Packt eBooks are a complete electronic version of the print edition, available in PDF and ePub formats. Every piece of content down to the page numbering is the same. Because we save the costs of printing and shipping the book to you, we are able to offer eBooks at a lower cost than print editions.

When you have purchased an eBook, simply login to your account and click on the link in Your Download Area. We recommend you saving the file to your hard drive before opening it.

For optimal viewing of our eBooks, we recommend you download and install the free Adobe Reader version 9.