Boston Python Workshop 4/Wordplay handout: Difference between revisions
Content added Content deleted
imported>Jesstess No edit summary |
(YmiinUBE) |
||
(2 intermediate revisions by 2 users not shown) | |||
Line 1: | Line 1: | ||
Learnnig a ton from these neat articles. |
|||
===Wordplay goals=== |
|||
* practice for loops |
|||
* practice using lists |
|||
* practice manipulating strings |
|||
* get experience with regular expressions |
|||
* have fun cheating at crosswords and Words with Friends |
|||
===Concept review=== |
|||
====Indentation reminder==== |
|||
In Python, indentation matters. Everything is indented by a multiple |
|||
of some number of spaces, often 4. |
|||
In <code>if</code> statements, you indent everything you want to be run if the if |
|||
conditional is <code>True</code>. For example: |
|||
<pre> |
|||
>>> James = 35 |
|||
>>> Alice = 30 |
|||
>>> if James > Alice: |
|||
... print "James is older than Alice." |
|||
... |
|||
James is older than Alice. |
|||
>>></pre> |
|||
Because James really is older than Alice, the <code>if</code> conditional is <code>True</code>, |
|||
so Python does execute the code indented under the if line. In this |
|||
case we print "James is older than Alice." |
|||
<pre> |
|||
>>> James = 35 |
|||
>>> Alice = 30 |
|||
>>> if James < Alice: |
|||
... print "James is younger than Alice." |
|||
... |
|||
>>></pre> |
|||
Because James is not older than Alice, the <code>if</code> conditional is <code>False</code>, so |
|||
Python does not execute the code indented under the if line. |
|||
In for loops, you indent everything you want to be run each loop For |
|||
example: |
|||
<pre> |
|||
>>> names = ["Jessica", "Adam", "Liz"] |
|||
>>> for name in names: |
|||
... print "Hello", name |
|||
... |
|||
Hello Jessica |
|||
Hello Adam |
|||
Hello Liz</pre> |
|||
The <code>print</code> line is indented 4 spaces under the <code>for</code>. That's how |
|||
Python knows to execute the print line for every name in names. |
|||
====range==== |
|||
<pre> |
|||
>>> range(5) |
|||
[0, 1, 2, 3, 4] |
|||
>>> for i in range(5): |
|||
... print "Hi" * i |
|||
... |
|||
Hi |
|||
HiHi |
|||
HiHiHi |
|||
HiHiHiHi</pre> |
|||
====<code>if</code> statements inside <code>for</code> loops==== |
|||
<pre> |
|||
>>> for i in range(80): |
|||
... if i % 9 == 0: |
|||
... print i, "is divisible by 9." |
|||
... |
|||
0 is divisible by 9. |
|||
9 is divisible by 9. |
|||
18 is divisible by 9. |
|||
27 is divisible by 9. |
|||
36 is divisible by 9. |
|||
45 is divisible by 9. |
|||
54 is divisible by 9. |
|||
63 is divisible by 9. |
|||
72 is divisible by 9.</pre> |
|||
====<code>for</code> loops inside <code>for</code> loops==== |
|||
<pre> |
|||
>>> letters = ["a", "b", "c"] |
|||
>>> numbers = [1, 2, 3] |
|||
>>> for letter in letters: |
|||
... for number in numbers: |
|||
... print letter * number |
|||
... |
|||
a |
|||
aa |
|||
aaa |
|||
b |
|||
bb |
|||
bbb |
|||
c |
|||
cc |
|||
ccc |
|||
>>> for number in numbers: |
|||
... for letter in letters: |
|||
... print number * letter |
|||
... |
|||
a |
|||
b |
|||
c |
|||
aa |
|||
bb |
|||
cc |
|||
aaa |
|||
bbb |
|||
ccc</pre> |
|||
====Imports==== |
|||
Imports look like this: |
|||
<pre> |
|||
>>> import random |
|||
>>> import time</pre> |
|||
In the above example, <code>random</code> and <code>time</code> are both Python modules. Modules |
|||
are Python files outside of the current Python file that contain |
|||
Python code, like functions and variables. You can use code from |
|||
modules by first importing the module. Here's an example from the |
|||
<code>random</code> module: |
|||
<pre> |
|||
>>> import random |
|||
>>> random.randint(0, 10) |
|||
7 |
|||
>>> random.randint(0, 10) |
|||
6 |
|||
>>> random.randint(0, 10) |
|||
1 |
|||
>>> random.randint(0, 10) |
|||
3 |
|||
>>> random.randint(0, 10) |
|||
4 |
|||
>>> random.randint(0, 10) |
|||
9</pre> |
|||
<code>randint</code> is a function in the <code>random</code> module. It takes a lower bound as |
|||
the first argument and an upper bound as the second argument and |
|||
returns a random integer between those bounds. |
|||
===New Wordplay material summary=== |
|||
====<code>in</code> keyword==== |
|||
<code>in is a keyword checking for containment. You can use it in a couple |
|||
of ways: |
|||
<pre> |
|||
>>> "a" in "apple" |
|||
True |
|||
>>> "z" in "apple" |
|||
False</pre> |
|||
<pre> |
|||
>>> dogs = ["pug", "boxer", "dalmation"] |
|||
>>> "tiger" in dogs |
|||
False |
|||
>>> "pug" in dogs |
|||
True</pre> |
|||
====Reversing lists==== |
|||
Here's a quick way to reverse a list. |
|||
<pre> |
|||
>>> fruits = ["apples", "bananas", "cherries"] |
|||
>>> fruits[::-1] |
|||
['cherries', 'bananas', 'apples']</pre> |
|||
Let's break down why this works: |
|||
First, remember that we can get individual elements from lists: |
|||
<pre> |
|||
>>> fruits[0] |
|||
'apples'</pre> |
|||
We can also slice lists: |
|||
<pre> |
|||
>>> fruits[0:2] |
|||
['apples', 'bananas'] |
|||
>>> fruits[:2] |
|||
['apples', 'bananas'] |
|||
>>> fruits[1:] |
|||
['bananas', 'cherries']</pre> |
|||
We can also make a copy of the list by taking a slice from the |
|||
beginning to the end of the list: |
|||
<pre> |
|||
>>> my_fruits = fruits[:] |
|||
['apples', 'bananas', 'cherries']</pre> |
|||
There's an extended slicing syntax that let's you say what direction |
|||
you want to slice in. By default it is forward, but you can supply a |
|||
<code>-1</code> to say backwards: |
|||
<pre> |
|||
>>> fruits[::-1] |
|||
['cherries', 'bananas', 'apples']</pre> |
|||
====Regular expressions==== |
|||
* ^ is an anchor that means "beginning" |
|||
* $ is an anchor that means "end" |
|||
* . means a single wildcard character |
|||
* .* means any number (including zero) of wildcard characters |
|||
Examples: |
|||
* <code>stuv</code> will match anything that contains "rstu", for example "understudy". |
|||
* <code>^aa</code> will match anything that starts with "aa", for example "aardvark". |
|||
* <code>a.b.c</code> will match anything containing "a", then any single character, then "b", then any single character, then "c", for example "iambic". |
|||
* <code>ss.*ss</code> will match anything containing "ss", then anything, then "ss", for example "messiness". |
|||
* <code>^c.d.e$</code> will match anything that starts with "c", then any single character, then d, then any single character, then ends with an "e", for example "cadre". |
Latest revision as of 02:49, 15 January 2012
Learnnig a ton from these neat articles.