diff options
| -rw-r--r-- | php.html.markdown | 135 | ||||
| -rw-r--r-- | python.html.markdown | 345 |
2 files changed, 446 insertions, 34 deletions
diff --git a/php.html.markdown b/php.html.markdown index c6c70cbb..33bf2859 100644 --- a/php.html.markdown +++ b/php.html.markdown @@ -4,17 +4,18 @@ author: Malcolm Fell author_url: http://emarref.net/ --- -# PHP - This document describes PHP 5+. ## [Basic Syntax](http://www.php.net/manual/en/language.basic-syntax.php) -All statements must end with a semi-colon; All PHP code must be between <?php and ?> tags. PHP can also be configured to respect the [short open tags](http://www.php.net/manual/en/ini.core.php#ini.short-open-tag) <? and ?>. +All statements must end with a semi-colon; All PHP code must be between <?php and ?> tags. PHP can also be +configured to respect the [short open tags](http://www.php.net/manual/en/ini.core.php#ini.short-open-tag) <? and ?>. ## [Comments](http://www.php.net/manual/en/language.basic-syntax.comments.php) ```php +<?php + // Two forward slashes start a one-line comment. # So will a hash (aka pound symbol) but // is more common @@ -27,11 +28,14 @@ All statements must end with a semi-colon; All PHP code must be between <?php an ## [Types](http://www.php.net/manual/en/language.types.php) -Types are [weakly typed](http://en.wikipedia.org/wiki/Strong_and_weak_typing) and begin with the $ symbol. A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. +Types are [weakly typed](http://en.wikipedia.org/wiki/Strong_and_weak_typing) and begin with the $ symbol. +A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. ### Scalars ```php +<?php + // Boolean values are case-insensitive $boolean = true; // or TRUE or True $boolean = false; // or FALSE or False @@ -54,20 +58,29 @@ $product = $number * $float; $quotient = $number / $float; // Shorthand arithmetic -$number += 1; // Will add 1 to $number -$number++; // Will add 1 to $number after it is used -++$number; // Will add 1 to $number before it is used. -$number /= $float // Will divide $number $float, and assign the quotient to $number - -// Strings -$sgl_quotes = 'String'; // Strings should be enclosed in single quotes; -$dbl_quotes = "This is a $sgl_quotes." // Avoid using double quotes to embed other variables -$escaped = "This contains a \t tab character."; // Escape special characters with backslash -$money = "I have $${integer} in the bank." // Enclose a variable in curly braces if needed +$number += 1; // Add 1 to $number +$number++; // Add 1 to $number after it is used +++$number; // Add 1 to $number before it is used. +$number /= $float // Divide and assign the quotient to $number + +// Strings should be enclosed in single quotes; +$sgl_quotes = '$String'; // => '$String' + +// Avoid using double quotes except to embed other variables +$dbl_quotes = "This is a $sgl_quotes." // => 'This is a $String' + +// Escape special characters with backslash +$escaped = "This contains a \t tab character."; + +// Enclose a variable in curly braces if needed +$money = "I have $${integer} in the bank." + +// Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners $nowdoc = <<<'END' Multi line string END; + $heredoc = <<<END Multi line $sgl_quotes @@ -80,6 +93,8 @@ $concatenated = $sgl_quotes . $dbl_quotes; ### Compound ```php +<?php + // Arrays $array = array(1, 2, 3); $array = [1, 2, 3]; // As of PHP 5.4 @@ -94,15 +109,24 @@ $associative["One"]; // Holds the value 1 ## Output ```php -echo('Hello World!'); // Prints Hello World! to stdout. Stdout is the web page if running in a browser. +<?php + +echo('Hello World!'); +// Prints Hello World! to stdout. +// Stdout is the web page if running in a browser. + print('Hello World!'); // The same as echo -echo 'Hello World!'; // echo is actually a language construct, so you can drop the parentheses. + +// echo is actually a language construct, so you can drop the parentheses. +echo 'Hello World!'; print 'Hello World!'; // So is print + echo 100; echo $variable; -echo function_result(); // Output the result of a function call that returns a value. More on functions later. +echo function_result(); -// If [short open tags](http://www.php.net/manual/en/ini.core.php#ini.short-open-tag) are configured, or your PHP version is 5.4.0 or greater, you can use the short echo syntax +// If short open tags are configured, or your PHP version is +// 5.4.0 or greater, you can use the short echo syntax <?= $variable ?> ``` @@ -111,15 +135,21 @@ echo function_result(); // Output the result of a function call that returns a v ### Assignment ```php +<?php + $x = 1; $y = 2; $x = $y; // A now contains the same value sa $y -$x = &$y; // A now contains a reference to $y. Changing the value of $x will change the value of $y also, and vice-versa. +$x = &$y; +// $x now contains a reference to $y. Changing the value of +// $x will change the value of $y also, and vice-versa. ``` ### Comparison ```php +<?php + // These comparisons will always be true, even if the types aren't the same. $a == $b // TRUE if $a is equal to $b after type juggling. $a != $b // TRUE if $a is not equal to $b after type juggling. @@ -141,14 +171,18 @@ $a !== $b // TRUE if $a is not equal to $b, or they are not of the same type. Variables can be converted between types, depending on their usage. ```php +<?php + $integer = 1; echo $integer + $integer; // Outputs 2; $string = '1'; -echo $string + $string; // Also outputs 2 because the + operator converts the strings to integers +echo $string + $string; +// Also outputs 2 because the + operator converts the strings to integers $string = 'one'; -echo $string + $string; // Outputs 0 because the + operator cannot cast the string 'one' to a number +echo $string + $string; +// Outputs 0 because the + operator cannot cast the string 'one' to a number ``` Type casting can be used to treat a variable as another type temporarily by using cast operators in parentheses. @@ -160,7 +194,8 @@ $zero = 0; $boolean = (boolean) $zero; // $boolean is false $integer = 5; -$string = strval($integer); // There are also dedicated functions for casting most types +$string = strval($integer); +// There are also dedicated functions for casting most types $var = null; // Null value ``` @@ -170,6 +205,8 @@ $var = null; // Null value ### If Statements ```php +<?php + if (/* test */) { // Do something } @@ -193,6 +230,7 @@ if (/* test */) { } else { // Do something default } +?> <?php if (/* test */): ?> This is displayed if the test is truthy. @@ -204,6 +242,8 @@ This is displayed otherwise. ### Switch statements ```php +<?php + switch ($variable) { case 'one': // Do something if $variable == 'one' @@ -221,6 +261,8 @@ switch ($variable) { ### Loops ```php +<?php + $i = 0; while ($i < 5) { echo $i++; @@ -247,7 +289,6 @@ while ($i < 5) { if ($i == 3) { break; // Exit out of the while loop and continue. } - echo $i++; } @@ -257,7 +298,6 @@ while ($i < 5) { if ($i == 3) { continue; // Skip this iteration of the loop } - echo $i++; } ``` @@ -267,6 +307,8 @@ while ($i < 5) { Functions are created with the ```function``` keyword. ```php +<?php + function my_function($my_arg) { $my_variable = 1; } @@ -277,16 +319,21 @@ function my_function($my_arg) { Functions may be invoked by name. ```php +<?php + my_function_name(); $variable = get_something(); // A function may return a value ``` -A valid function name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. There are three ways to declare functions. +A valid function name starts with a letter or underscore, followed by any +number of letters, numbers, or underscores. There are three ways to declare functions. ### [User-defined](http://www.php.net/manual/en/functions.user-defined.php) ```php +<?php + function my_function_name ($arg_1, $arg_2) { // $arg_1 and $arg_2 are required // Do something with $arg_1 and $arg_2; } @@ -320,6 +367,8 @@ $bar('C'); ### [Variable](http://www.php.net/manual/en/functions.variable-functions.php) ```php +<?php + $function_name = 'my_function_name'; $function_name(); // will execute the my_function_name() function @@ -330,6 +379,8 @@ $function_name(); // will execute the my_function_name() function Similar to variable functions, functions may be anonymous. ```php +<?php + function my_function($callback) { $callback('My argument'); } @@ -351,6 +402,8 @@ $my_function(); Classes are defined with the ```class``` keyword. ```php +<?php + class MyClass { const MY_CONST = 'value'; static $staticVar = 'something'; @@ -363,20 +416,20 @@ final class YouCannotExtendMe { } ``` -Classes are insantiated with the ```new``` keyword. Functions are referred to as methods if they belong to a class. +Classes are insantiated with the ```new``` keyword. Functions are referred to as +methods if they belong to a class. ```php +<?php + class MyClass { - function myFunction() - { + function myFunction() { } - final function youCannotOverrideMe() - { + final function youCannotOverrideMe() { } - public static function myStaticMethod() - { + public static function myStaticMethod() { } } @@ -392,6 +445,8 @@ MyClass::myStaticMethod(); // myStaticMethod cannot be run on $cls PHP offers some [magic methods](http://www.php.net/manual/en/language.oop5.magic.php) for classes. ```php +<?php + class MyClass { private $property; @@ -407,14 +462,16 @@ class MyClass { } $x = new MyClass(); -echo $x->property; // Will use the __get() method to retrieve the value of $property -$x->property = 'Something'; // Will use the __set() method to set the value of property +echo $x->property; // Will use the __get() method +$x->property = 'Something'; // Will use the __set() method ``` Classes can be abstract (using the ```abstract``` keyword), extend other classes (using the ```extends``` keyword) and implement interfaces (using the ```implements``` keyword). An interface is declared with the ```interface``` keyword. ```php +<?php + interface InterfaceOne { public function doSomething(); @@ -444,10 +501,14 @@ class SomeOtherClass implements InterfaceOne, InterfaceTwo By default, classes exist in the global namespace, and can be explicitly called with a backslash. ```php +<?php + $cls = new \MyClass(); ``` ```php +<?php + namespace My\Namespace; class MyClass @@ -460,6 +521,8 @@ $cls = new My\Namespace\MyClass; Or from within another namespace. ```php +<?php + namespace My\Other\Namespace; use My\Namespace\MyClass; @@ -470,6 +533,8 @@ $cls = new MyClass(); Or you can alias the namespace; ```php +<?php + namespace My\Other\Namespace; use My\Namespace as SomeOtherNamespace; @@ -482,6 +547,8 @@ $cls = new SomeOtherNamespace\MyClass(); Traits are available since PHP 5.4.0 and are declared using the ```trait``` keyword. ```php +<?php + trait MyTrait { public function myTraitMethod() { diff --git a/python.html.markdown b/python.html.markdown new file mode 100644 index 00000000..eb8f5cb4 --- /dev/null +++ b/python.html.markdown @@ -0,0 +1,345 @@ +--- +language: python +author: Louie Dinh +author_url: http://ldinh.ca +--- + +Python was created by Guido Van Rossum in the early 90's. It is now one of the most popular +languages in existence. I fell in love with Python for it's syntactic clarity. It's basically +executable pseudocode. + +Note: This article applies to Python 2.7 specifically, but should be applicable +to Python 2.x. Look for another tour of Python 3 soon! + +```python +# Single line comments start with a hash. +""" Multiline comments can we written + using three "'s +""" + +#################################################### +## 1. Primitive Datatypes and Operators +#################################################### + +# You have numbers +3 #=> 3 + +# Math is what you would expect +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Division is a bit tricky. It is integer division and floors the results +# automatically. +11 / 4 #=> 2 + +# To fix division we need to learn about floats. +2.0 # This is a float +5.0 / 2.0 #=> 2.5 ahhh...much better + +# Enforce precedence with parentheses +(1 + 3) * 2 #=> 8 + +# Boolean values are primitives +True +False + +# negate with not +not True #=> False +not False #=> True + + +# Equality is == +1 == 1 #=> True +2 == 1 #=> False + +# Strings are created with " or ' +"This is a string." +'This is also a string.' + +# Strings can be added too! +"Hello " + "world!" #=> "Hello world!" + +# A string can be treated like a list of characters +"This is a string"[0] #=> 'T' + +# None is an object +None #=> None + + +#################################################### +## 2. Variables and Collections +#################################################### + +# Printing is pretty easy +print "I'm Python. Nice to meet you!" + + +# No need to declare variables before assigning to them. +some_var = 5 # Convention is to use lower_case_with_underscores +some_var #=> 5 + +# Accessing a previously unassigned variable is an exception +some_other_var # Will raise a NameError + + +# Lists store sequences +li = [] +# You can start with a prefilled list +other_li = [4, 5, 6] + +# Add stuff to the end of a list with append +li.append(1) #li is now [1] +li.append(2) #li is now [1, 2] +li.append(4) #li is now [1, 2, 4] +li.append(3) #li is now [1, 2, 4, 3] +# Remove from the end with pop +li.pop() #=> 3 and li is now [1, 2, 4] +# Let's put it back +li.append(3) # li is now [1, 2, 4, 3] again. + +# Access a list like you would any array +li[0] #=> 1 +# Look at the last element +li[-1] #=> 4 +# Looking out of bounds is an IndexError +li[4] # Raises an IndexError + +# You can look at ranges with slice syntax. +# (It's a closed/open range for you mathy types.) +li[1:3] #=> [2, 4] +# Omit the beginning +li[:3] #=> [1, 2, 4] +# Omit the end +li[2:] #=> [4, 3] + +# Remove arbitrary elements from a list with del +del li[2] # li is now [1, 2, 3] + +# You can add lists +li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li and other_li is left alone + +# Concatenate lists with extend +li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6] + +# Check for existence in a list with in +1 in li #=> True + +# Examine the length with len +len(li) #=> 6 + +# Tuples are like lists but are immutable. +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Raises a TypeError + +# You can do all those list thingies on tuples too +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# However, you can unpack tuples into variables +a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3 +# Tuples are created by default if you leave out the parentheses +d, e, f = 4, 5, 6 +# Now look how easy it is to swap to values +e, d = d, e # d is now 5 and e is now 4 + + +# Dictionaries store mappings +empty_dict = {} +# Here is a prefilled dictionary +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Look up values with [] +filled_dict["one"] #=> 1 + +# Get all keys as a list +filled_dict.keys() #=> ["three", "two", "one"] +# Note - Dictionary key ordering is not guaranteed. +# Your results might not match this exactly. + +# Get all values as a list +filled_dict.values() #=> [3, 2, 1] +# Note - Same as above regarding key ordering. + +# Check for existence of keys in a dictionary with in +"one" in filled_dict #=> True +1 in filled_dict #=> False + + +# Sets store ... well sets +empty_set = set() +# Initialize a set with a bunch of values +filled_set = set([1,2,2,3,4]) # filled_set is now set([1, 2, 3, 4]) + +# Add more items to a set +filled_set.add(5) # filled_set is now set([1, 2, 3, 4, 5]) + +# Do set intersection with & +other_set = set([3, 4, 5 ,6]) +filled_set & other_set #=> set([3, 4, 5]) +# Do set union with | +filled_set | other_set #=> set([1, 2, 3, 4, 5, 6]) +# Do set difference with - +set([1,2,3,4]) - set([2,3,5]) #=> set([1, 4]) + +# Check for existence in a set with in +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Control Flow +#################################################### + +# Let's just make a variable +some_var = 5 + +# Here is an if statement. INDENTATION IS SIGNIFICANT IN PYTHON! +# prints "some var is smaller than 10" +if some_var > 10: + print "some_var is totally bigger than 10." +elif some_var < 10: # This elif clause is optional. + print "some_var is smaller than 10." +else: # This is optional too. + print "some_var is indeed 10." + + +""" +For loops iterate over lists +prints: + dog is a mammal + cat is a mammal + mouse is a mammal +""" +for animal in ["dog", "cat", "mouse"]: + # You can use % to interpolate formatted strings + print "%s is a mammal" % animal + +""" +While loops go until a condition is no longer met. +prints: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Shorthand for x = x + 1 + +# Handle exceptions with a try/except block +try: + # Use raise to raise an error + raise IndexError("This is an index error") +except IndexError as e: + pass # Pass is just a no-op. Usually you would do recovery here. + + +#################################################### +## 4. Functions +#################################################### + +# Use def to create new functions +def add(x, y): + print "x is %s and y is %s" % (x, y) + return x + y # Return values with a return statement + +# Calling functions with parameters +add(5, 6) #=> 11 and prints out "x is 5 and y is 6" +# Another way to call functions is with keyword arguments +add(y=6, x=5) # Keyword arguments can arrive in any order. + +# You can define functions that take a variable number of +# positional arguments +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# You can define functions that take a variable number of +# keyword arguments, as well +def keyword_args(**kwargs): + return kwargs + +# Let's call it to see what happens +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# You can do both at once, if you like +def all_the_args(*args, **kwargs): + pass + + +# Python has first class functions +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10): +add_10(3) #=> 13 + +# There are also anonymous functions +(lambda x: x > 2)(3) #=> True + +# There are built-in higher order functions +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# We can use list comprehensions for nice maps and filters +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Classes +#################################################### + +# We subclass from object to get a class. +class Human(object): + + # A class attribute. It is shared by all instances of this class + species = "H. sapiens" + + # Basic initializer + def __init__(self, name): + # Assign the argument to the instance's name attribute + self.name = name + + # An instance method. All methods take self as the first argument + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # A class method is shared among all instances + # They are called with the calling class as the first argument + @classmethod + def get_species(cls): + return cls.species + + # A static method is called without a class or instance reference + @staticmethod + def grunt(): + return "*grunt*" + + +# Instantiate a class +i = Human(name="Ian") +print i.say("hi") # prints out "Ian: hi" + +j = Human("Joel") +print j.say("hello") #prints out "Joel: hello" + +# Call our class method +i.get_species() #=> "H. sapiens" + +# Change the shared attribute +i.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Call the static method +Human.grunt() #=> "*grunt*" |