Explore advanced Python concepts and tools used by experienced Python developers.

Python for Programmers

In this module, we’ll explore advanced Python concepts and tools used by experienced Python developers. We'll begin by exploring Python modules and then move on to topics such as unicode, generators, and iterators. Lastly, we'll go over web-related tasks with Python, methods of testing code, and other useful skills.

Advanced Concepts in Python

The `aiohttp` package is designed for creating asynchronous HTTP
clients and servers. You can install it with pip like this:

# Using `aiohttp` to download files
Once that's installed, let's update our code to use `aiohttp` so that we
can download the files:

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


better-coroutine

React

Dart

GoJS React

Typescript React

Vue.js


You will notice here that we import a couple of new items: `aiohttp`
and `async_timeout`. The latter is actually one of the `aiohttp`'s dependencies and allows us to create a timeout context manager. 
 Let's
start at the bottom of the code and work our way up. In the bottom
conditional statement, we start our asynchronous event loop and call our
`main` function (line 34).  In the main function, we create a `ClientSession` object that we pass on to our download coroutine function for each of the urls we want to download (lines 27 - 29).
 In the `download_coroutine`, we call our session's `get()` method which gives us a response object (line 9). Now we get
to the part that is a bit magical. When you use the **content**
attribute of the response object, it returns an instance of
`aiohttp.StreamReader` which allows us to download the file in chunks
of whatever size we'd like. As we read the file, we write it out to
local disk. Finally we call the response's `release()` method (line 17), which
will finish the response processing.

According to `aiohttp's` documentation, because the response object was
created in a context manager, it technically calls `release()` implicitly.
But in Python, explicit is usually better and there is a note in the
documentation that we shouldn't rely on the connection just going away,
so we believe that it's better to just release it in this case.

While we are writing the file, we
are still blocking the portion of
the code that actually writes to disk. There is another library called `aiofiles` that we could use to try and make the file writing asynchronous too, but we will leave that update to the learner.


Let's see a good example of coroutine using aiohttp package.

A Better Coroutine Example