Merge branch 'wip' of github.com:OpenTechSchool/python-beginners into wip

gnunicorn · gnunicorn · commit 6b7126dcb00e · 2012-08-28T22:56:28.000+02:00
diff --git a/docs/en/conditional_loops.rst b/docs/en/conditional_loops.rst
@@ -0,0 +1,11 @@
+Conditional Loops
+*****************
+
+Introduction
+============
+
+
+Exercise
+========
+
+
diff --git a/docs/en/conditionals.rst b/docs/en/conditionals.rst
@@ -0,0 +1,39 @@
+Conditional statements
+**********************
+Introduction
+============
+
+So far we have accomplished predefined tasks, but in all honesty we were accomplishing no better achievements than the 18th century automata, or the music boxes following one set of instruction to the end. What makes programming so much more powerful is conditional statements. This is the ability to *test* a variable (or a name) against a value and act in one way if the condition is met by the variable or an other way if not. They are also commonly called by programmers *if statements*.
+
+To know if a condition is *true* of *false*, we need a new type of data: 
+the booleans. They allow logic operations. A logic statement or operation 
+can be avaluated to be true or false. Our conditional statement can then be 
+understood like this: **if** *(evaluation of a condition returns true)* **then** *do some operation* **else** *do an other operation*. And any operation that can be avaluated as *true* or *false* can but put to the test. All comparisons return *true* or *false*: *=,>,<*.
+
+
+Examples
+========
+Here are some simple examples::
+
+    condition = True
+    if condition:
+        print "condition met"
+
+    if not condition:
+        print "condition not met"
+
+    direction = -30
+    if direction > 0 :
+        forward(direction)
+    else:
+        left(180)
+        forward (-direction)
+
+
+Exercise
+========
+
+[some example...]
+
+Bonus Exercise
+==============
diff --git a/docs/en/functions_parameters.rst b/docs/en/functions_parameters.rst
@@ -1,4 +1,70 @@
 Functions with parameters
 *************************
+Introduction
+============
 
-Todo
+Now we know how to *factorise* this code a little. But functions as we have defined them so far are not flexible. the variables are defined inside the function,
+and we need to rewrite a whole function to cahnge the value of an angle, or a distance in it.
+
+That is why we need to be able to give parameters, or also called *arguments* so that *names* we use in the function can be used with different values each time we call the function:
+
+Remember how we defined the function ``line_without_moving`` in the previous section::
+
+    def line_without_moving():
+        forward(50)
+        backward(50)
+
+We can improve it by giving it a parameter::
+
+    def line_without_moving(length):
+        forward(length)
+        backward(length)
+
+The parameter acts as a *name* only known inside the function's definition. We use the newly defined function by calling it with the value we want the parameter to have like this::
+
+    line_without_moving(50)
+    line_without_moving(40)
+
+We have been using functions with parameters since the beginning of the tutorial with the *forward*, *left*, etc... 
+
+
+And we can put as many arguments (or parameters) as we want, separating them with commas and giving them different names::
+   def tilted_line_without_moving(length,angle):
+        left(angle)
+        forward(length)
+        backward(length)
+
+
+A parameterised function for a variable size hexagon
+====================================================
+
+Exercise
+--------
+Write a function that takes allows you to draw hexagons of any size you want, each time you call the function.
+
+
+
+A function of several parameters
+================================
+
+Exercise
+--------
+
+Write a function that draws a honeycomb with a variable number of hexagons, of variable sizes
+
+
+Solution
+--------
+
+::
+    
+    def hexagon(size):
+        for i in range(6):
+            forward(size)
+            left(60)
+    def honeycomb(size,count):
+        for i in range(count):
+            hexagon(size)
+            forward(size)
+            right(60)
+  
diff --git a/docs/en/index.rst b/docs/en/index.rst
@@ -13,4 +13,6 @@ Table of contents:
     functions
     loops
     functions_parameters
-
+    conditionals
+    logical_operators
+    conditional_loops
diff --git a/docs/en/logical_operators.rst b/docs/en/logical_operators.rst
@@ -0,0 +1,7 @@
+Logical operators
+=========================
+
+We can also do some more complex things with 
+We can return the opposite of a logic operation, with **not** as a keyword in front of your expression, or combine several logic statements together with logical **and** and **or** links between them (they are usually called *operators*)
+
+
