The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Version 1 - Inefficient Trial Division¶

First a function to generate all factors. We need only test candidate factors up to $n$.

from six.moves import filter, map, range, reduce

factors = lambda n: list(filter(lambda x: not n % x, range(1, n+1)))

factors(24)

[1, 2, 3, 4, 6, 8, 12, 24]

This isn't really that helpful, since we are only interested in prime factors. While we can implement a primality predicate and filter out composites numbers, it isn't particularly efficient. Let's rethink our approach.

Instead of iterating over all integers up to $n$, we can just iterate over the prime numbers. But first we'll need a prime number generator. The simple Sieve of Eratosthenes (250s BCE) seems like a good place to start.

Version 1: The obvious but inefficient way¶

from itertools import takewhile

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

sum(filter(lambda x: x%2==0, takewhile(lambda x: x <= 4*10**6, fibonacci())))

4613732

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

from six.moves import range

Version 1: The obvious way¶

sum(filter(lambda x: x%3==0 or x%5==0, range(1000)))

233168

Version 2: If you prefer list comprehensions¶

sum(x for x in range(1000) if x%3==0 or x%5==0)

233168

IPython's Rich Display System¶

In Python, objects can declare their textual representation using the __repr__ method. IPython expands on this idea and allows objects to declare other, richer representations including:

HTML
JSON
PNG
JPEG
SVG
LaTeX

A single object can declare some or all of these representations; all are handled by IPython's display system. This Notebook shows how you can use this display system to incorporate a broad range of content into your Notebooks.

Basic display imports¶

The display function is a general purpose tool for displaying different representations of objects. Think of it as print for these rich representations.

from IPython.display import display

A few points:

Calling display on an object will send all possible representations to the Notebook.
These representations are stored in the Notebook document.
In general the Notebook will use the richest available representation.

If you want to display a particular representation, there are specific functions for that:

from IPython.display import display_pretty, display_html, display_jpeg, display_png, display_json, display_latex, display_svg

Images¶

To work with images (JPEG, PNG) use the Image class.

from IPython.display import Image

i = Image(filename='../images/ipython_logo.png')

Returning an Image object from an expression will automatically display it:

i

Or you can pass it to display:

display(i)

An image can also be displayed from raw data or a url

Image(url='http://python.org/images/python-logo.gif')

SVG images are also supported out of the box (since modern browsers do a good job of rendering them):

from IPython.display import SVG
SVG(filename='images/python_logo.svg')

Links to local files¶

If we want to create a link to one of them, we can call use the FileLink object.

from IPython.display import FileLink, FileLinks
FileLink('Running Code.ipynb')

Alternatively, if we want to link to all of the files in a directory, we can use the FileLinks object, passing '.' to indicate that we want links generated for the current working directory. Note that if there were other directories under the current directory, FileLinks would work in a recursive manner creating links to files in all sub-directories as well.

FileLinks('.')

Embedded vs Non-embedded Images¶

By default, image data is embedded in the Notebook document so that the images can be viewed offline. However it is also possible to tell the Image class to only store a link to the image. Let's see how this works using a webcam at Berkeley.

from IPython.display import Image
img_url = 'http://www.lawrencehallofscience.org/static/scienceview/scienceview.berkeley.edu/html/view/view_assets/images/newview.jpg'

# by default Image data are embedded
Embed      = Image(img_url)

# if kwarg `url` is given, the embedding is assumed to be false
SoftLinked = Image(url=img_url)

# In each case, embed can be specified explicitly with the `embed` kwarg
# ForceEmbed = Image(url=img_url, embed=True)

Here is the embedded version. Note that this image was pulled from the webcam when this code cell was originally run and stored in the Notebook. Unless we rerun this cell, this is not todays image.

Embed

Here is today's image from same webcam at Berkeley, (refreshed every minutes, if you reload the notebook), visible only with an active internet connection, that should be different from the previous one. Notebooks saved with this kind of image will be lighter and always reflect the current version of the source, but the image won't display offline.

SoftLinked

Of course, if you re-run this Notebook, the two images will be the same again.

Audio¶

IPython makes it easy to work with sounds interactively. The Audio display class allows you to create an audio control that is embedded in the Notebook. The interface is analogous to the interface of the Image display class. All audio formats supported by the browser can be used. Note that no single format is presently supported in all browsers.

from IPython.display import Audio
Audio(url="http://www.nch.com.au/acm/8k16bitpcm.wav")

A Numpy array can be auralized automatically. The Audio class normalizes and encodes the data and embed the result in the Notebook.

For instance, when two sine waves with almost the same frequency are superimposed a phenomena known as beats occur. This can be auralised as follows

import numpy as np
max_time = 3
f1 = 220.0
f2 = 224.0
rate = 8000.0
L = 3
times = np.linspace(0,L,rate*L)
signal = np.sin(2*np.pi*f1*times) + np.sin(2*np.pi*f2*times)

Audio(data=signal, rate=rate)

Video¶

More exotic objects can also be displayed, as long as their representation supports the IPython display protocol. For example, videos hosted externally on YouTube are easy to load (and writing a similar wrapper for other hosted content is trivial):

from IPython.display import YouTubeVideo
# a talk about IPython at Sage Days at U. Washington, Seattle.
# Video credit: William Stein.
YouTubeVideo('1j_HxD4iLn8')

Using the nascent video capabilities of modern browsers, you may also be able to display local videos. At the moment this doesn't work very well in all browsers, so it may or may not work for you; we will continue testing this and looking for ways to make it more robust.

The following cell loads a local file called animation.m4v, encodes the raw video as base64 for http transport, and uses the HTML5 video tag to load it. On Chrome 15 it works correctly, displaying a control bar at the bottom with a play/pause button and a location slider.

from IPython.display import HTML
from base64 import b64encode
video = open("images/animation.m4v", "rb").read()
video_encoded = b64encode(video).decode('ascii')
video_tag = '<video controls alt="test" src="data:video/x-m4v;base64,{0}">'.format(video_encoded)
HTML(data=video_tag)

HTML¶

Python objects can declare HTML representations that will be displayed in the Notebook. If you have some HTML you want to display, simply use the HTML class.

from IPython.display import HTML

s = """<table>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
<tr>
<td>row 1, cell 1</td>
<td>row 1, cell 2</td>
</tr>
<tr>
<td>row 2, cell 1</td>
<td>row 2, cell 2</td>
</tr>
</table>"""

h = HTML(s); h

Pandas makes use of this capability to allow DataFrames to be represented as HTML tables.

import pandas

Here is a small amount of stock data for APPL:

%%file data.csv
Date,Open,High,Low,Close,Volume,Adj Close
2012-06-01,569.16,590.00,548.50,584.00,14077000,581.50
2012-05-01,584.90,596.76,522.18,577.73,18827900,575.26
2012-04-02,601.83,644.00,555.00,583.98,28759100,581.48
2012-03-01,548.17,621.45,516.22,599.55,26486000,596.99
2012-02-01,458.41,547.61,453.98,542.44,22001000,540.12
2012-01-03,409.40,458.24,409.00,456.48,12949100,454.53

Writing data.csv

Read this as into a DataFrame:

df = pandas.read_csv('data.csv')

And view the HTML representation:

df

External sites¶

You can even embed an entire page from another site in an iframe; for example this is today's Wikipedia page for mobile users:

from IPython.display import IFrame
IFrame('http://en.mobile.wikipedia.org/?useformat=mobile', width='100%', height=350)

LaTeX¶

And we also support the display of mathematical expressions typeset in LaTeX, which is rendered in the browser thanks to the MathJax library.

from IPython.display import Math
Math(r'F(k) = \int_{-\infty}^{\infty} f(x) e^{2\pi i k} dx')

With the Latex class, you have to include the delimiters yourself. This allows you to use other LaTeX modes such as eqnarray:

from IPython.display import Latex
Latex(r"""\begin{eqnarray}
\nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} & = \frac{4\pi}{c}\vec{\mathbf{j}} \\
\nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\
\nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\
\nabla \cdot \vec{\mathbf{B}} & = 0 
\end{eqnarray}""")

Or you can enter latex directly with the %%latex cell magic:

%%latex
\begin{align}
\nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} & = \frac{4\pi}{c}\vec{\mathbf{j}} \\
\nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\
\nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\
\nabla \cdot \vec{\mathbf{B}} & = 0
\end{align}

While displaying equations look good for a page of samples, the ability to mix math and text in a paragraph is also important.
This expression $\sqrt{3x-1}+(1+x)^2$ is an example of an inline equation. As you see, MathJax equations can be used this way as well, without unduly disturbing the spacing between lines.

`USE_FOLDER_AS_CATEGORY`	Category c specified in metadata	Article in subfolder d	Article's Category
`True`	`True`	`True`	c
`True`	`True`	`False`	c
`True`	`False`	`True`	d
`True`	`False`	`False`	`DEFAULT_CATEGORY` (Misc)
`False`	`True`	`True`	c
`False`	`True`	`False`	c
`False`	`False`	`True`	`DEFAULT_CATEGORY` (Misc)
`False`	`False`	`False`	`DEFAULT_CATEGORY` (Misc)

Author:	David Goodger
Address:	123 Example Street Example, EX Canada A1B 2C3
Contact:	docutils-develop@lists.sourceforge.net
Authors:	Me Myself I
Organization:	humankind
Date:	2012-01-03
Status:	This is a "work in progress"
Revision:	7302
Version:	1
Copyright:	This document has been placed in the public domain. You may do with it as you wish. You may copy, modify, redistribute, reattribute, sell, buy, rent, lease, destroy, or improve it, quote it at length, excerpt, incorporate, collate, fold, staple, or mutilate it, or do anything else to it that your or anyone else's heart desires.
field name:	This is a generic bibliographic field.
field name 2:	Generic bibliographic fields may contain multiple body elements. Like this.

`-a`	command-line option "a"
`-b file`	options can have arguments and long descriptions
`--long`	options can be long also
`--input=file`	long options can also have arguments
`--very-long-option`
	The description can also start on the next line. The description may contain multiple body elements, regardless of where it starts.
`-x, -y, -z`	Multiple options are an "option group".
`-v, --verbose`	Commonly-seen: short & long options.
`-1 file, --one=file, --two file`
	Multiple options with arguments.
`/V`	DOS/VMS-style options too

Header row, column 1 (header rows optional)	Header 2	Header 3	Header 4
body row 1, column 1	column 2	column 3	column 4
body row 2	Cells may span columns.
body row 3	Cells may span rows.	Table cells contain body elements.
body row 4	Cells may span rows.	Table cells contain body elements.
body row 5	Cells may also be empty: `-->`

Inputs		Output
A	B	A or B
False	False	False
True	False	True
False	True	True
True	True	True

	Date	Open	High	Low	Close	Volume	Adj Close
0	2012-06-01	569.16	590.00	548.50	584.00	14077000	581.50
1	2012-05-01	584.90	596.76	522.18	577.73	18827900	575.26
2	2012-04-02	601.83	644.00	555.00	583.98	28759100	581.48
3	2012-03-01	548.17	621.45	516.22	599.55	26486000	596.99
4	2012-02-01	458.41	547.61	453.98	542.44	22001000	540.12
5	2012-01-03	409.40	458.24	409.00	456.48	12949100	454.53

re	Revised, revisited, based on 're' module.
Structured	Structure-enhanced text, structuredtext.
Text	Well it is, isn't it?

Louis Tiao