summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--README.markdown1
-rw-r--r--c.html.markdown9
-rw-r--r--clojure.html.markdown98
-rw-r--r--dart.html.markdown3
-rw-r--r--erlang.html.markdown239
-rw-r--r--file.erb1
-rw-r--r--fsharp.html.markdown252
-rw-r--r--haskell.html.markdown93
-rw-r--r--java.html.markdown370
-rw-r--r--lua.html.markdown1
-rw-r--r--php.html.markdown640
-rw-r--r--python.html.markdown119
-rw-r--r--r.html.markdown36
13 files changed, 1458 insertions, 404 deletions
diff --git a/README.markdown b/README.markdown
index 3223a2bd..77e09abd 100644
--- a/README.markdown
+++ b/README.markdown
@@ -17,7 +17,6 @@ properly!
The most requested languages are:
* Scala
-* Python
* Javascript
... but there are many more requests to do "every language", so don't let that stop you.
diff --git a/c.html.markdown b/c.html.markdown
index f5b6245d..69bf099e 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -2,6 +2,7 @@
language: c
author: Adam Bard
author_url: http://adambard.com/
+filename: learnc.c
---
Ah, C. Still the language of modern high-performance computing.
@@ -12,6 +13,7 @@ memory management and C will take you as far as you need to go.
```c
// Single-line comments start with //
+
/*
Multi-line comments look like this.
*/
@@ -19,6 +21,7 @@ Multi-line comments look like this.
// Import headers with #include
#include <stdlib.h>
#include <stdio.h>
+#include <string.h>
// Declare function signatures in advance in a .h file, or at the top of
// your .c file.
@@ -75,7 +78,7 @@ unsigned long long ux_long_long;
// on your machine. sizeof(T) gives you the size of a variable with type T in
// bytes so you can express the size of these types in a portable way.
// For example,
-printf("%d\n", sizeof(int)); // => 4 (on machines with 4-byte words)
+printf("%lu\n", sizeof(int)); // => 4 (on machines with 4-byte words)
// Arrays must be initialized with a concrete size.
char my_char_array[20]; // This array occupies 1 * 20 = 20 bytes
@@ -107,7 +110,7 @@ Char #17 is the NUL byte.
Chars #18, 19 and 20 have undefined values.
*/
-printf("%d\n", a_string[16]); => 0
+printf("%d\n", a_string[16]); // => 0
///////////////////////////////////////
// Operators
@@ -293,7 +296,7 @@ function_1();
// <return type> <function name>(<args>)
int add_two_ints(int x1, int x2){
- return x1 + x2; // Use return a return a value
+ return x1 + x2; // Use return to return a value
}
/*
diff --git a/clojure.html.markdown b/clojure.html.markdown
index 24250a87..39a27bcf 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -2,9 +2,10 @@
language: clojure
author: Adam Bard
author_url: http://adambard.com/
+filename: learnclojure.clj
---
-Clojure is a variant of LISP developed for the Java Virtual Machine. It has
+Clojure is a Lisp family language developed for the Java Virtual Machine. It has
a much stronger emphasis on pure [functional programming](https://en.wikipedia.org/wiki/Functional_programming) than
Common Lisp, but includes several [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) utilities to handle
state as it comes up.
@@ -23,9 +24,9 @@ and often automatically.
;
; The clojure reader assumes that the first thing is a
; function or macro to call, and the rest are arguments.
-;
-; Here's a function that sets the current namespace:
-(ns test)
+
+; The first call in a file should be ns, to set the namespace
+(ns learnclojure)
; More basic examples:
@@ -59,15 +60,18 @@ and often automatically.
(class false) ; Booleans are java.lang.Boolean
(class nil); The "null" value is called nil
-; If you want to create a literal list of data, use ' to make a "symbol"
+; If you want to create a literal list of data, use ' to stop it from
+; being evaluated
'(+ 1 2) ; => (+ 1 2)
+; (shorthand for (quote (+ 1 2))
-; You can eval symbols.
+; You can eval a quoted list
(eval '(+ 1 2)) ; => 3
; Collections & Sequences
;;;;;;;;;;;;;;;;;;;
+; Lists are linked-list data structures, while Vectors are array-backed.
; Vectors and Lists are java classes too!
(class [1 2 3]); => clojure.lang.PersistentVector
(class '(1 2 3)); => clojure.lang.PersistentList
@@ -76,16 +80,18 @@ and often automatically.
; it to stop the reader thinking it's a function.
; Also, (list 1 2 3) is the same as '(1 2 3)
+; "Collections" are just groups of data
; Both lists and vectors are collections:
(coll? '(1 2 3)) ; => true
(coll? [1 2 3]) ; => true
+; "Sequences" (seqs) are abstract descriptions of lists of data.
; Only lists are seqs.
(seq? '(1 2 3)) ; => true
(seq? [1 2 3]) ; => false
-; Seqs are an interface for logical lists, which can be lazy.
-; "Lazy" means that a seq can define an infinite series, like so:
+; A seq need only provide an entry when it is accessed.
+; So, seqs which can be lazy -- they can define infinite series:
(range 4) ; => (0 1 2 3)
(range) ; => (0 1 2 3 4 ...) (an infinite series)
(take 4 (range)) ; (0 1 2 3)
@@ -94,8 +100,8 @@ and often automatically.
(cons 4 [1 2 3]) ; => (4 1 2 3)
(cons 4 '(1 2 3)) ; => (4 1 2 3)
-; Use conj to add an item to the beginning of a list,
-; or the end of a vector
+; Conj will add an item to a collection in the most efficient way.
+; For lists, they insert at the beginning. For vectors, they insert at the end.
(conj [1 2 3] 4) ; => [1 2 3 4]
(conj '(1 2 3) 4) ; => (4 1 2 3)
@@ -165,20 +171,26 @@ x ; => 1
; => "Hello Finn, you passed 3 extra args"
-; Hashmaps
+; Maps
;;;;;;;;;;
+; Hash maps and array maps share an interface. Hash maps have faster lookups
+; but don't retain key order.
(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Arraymaps will automatically become hashmaps through most operations
+; if they get big enough, so you don't need to worry.
+; Maps can use any hashable type as a key, but usually keywords are best
; Keywords are like strings with some efficiency bonuses
(class :a) ; => clojure.lang.Keyword
-; Maps can use any type as a key, but usually keywords are best
-(def stringmap (hash-map "a" 1, "b" 2, "c" 3))
+(def stringmap {"a" 1, "b" 2, "c" 3})
stringmap ; => {"a" 1, "b" 2, "c" 3}
-(def keymap (hash-map :a 1 :b 2 :c 3))
-keymap ; => {:a 1, :c 3, :b 2} (order is not guaranteed)
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
; By the way, commas are always treated as whitespace and do nothing.
@@ -197,7 +209,8 @@ keymap ; => {:a 1, :c 3, :b 2} (order is not guaranteed)
(stringmap "d") ; => nil
; Use assoc to add new keys to hash-maps
-(assoc keymap :d 4) ; => {:a 1, :b 2, :c 3, :d 4}
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
; But remember, clojure types are immutable!
keymap ; => {:a 1, :b 2, :c 3}
@@ -268,6 +281,7 @@ keymap ; => {:a 1, :b 2, :c 3}
(require 'clojure.string)
; Use / to call functions from a module
+; Here, the module is clojure.string and the function is blank?
(clojure.string/blank? "") ; => true
; You can give a module a shorter name on import
@@ -311,4 +325,56 @@ keymap ; => {:a 1, :b 2, :c 3}
(doto (Calendar/getInstance)
(.set 2000 1 1 0 0 0)
.getTime) ; => A Date. set to 2000-01-01 00:00:00
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; Software Transactional Memory is the mechanism clojure uses to handle
+; persistent state. There are a few constructs in clojure that use this.
+
+; An atom is the simplest. Pass it an initial value
+(def my-atom (atom {}))
+
+; Update an atom with swap!.
+; swap! takes a function and calls it with the current value of the atom
+; as the first argument, and any trailing arguments as the second
+(swap! my-atom assoc :a 1) ; Sets my-atom to the result of (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Sets my-atom to the result of (assoc {:a 1} :b 2)
+
+ ; Use '@' to dereference the atom and get the value
+my-atom ;=> Atom<#...> (Returns the Atom object)
+@my-atom ; => {:a 1 :b 2}
+
+; Here's a simple counter using an atom
+(def counter (atom 0))
+(defn inc-counter []
+ (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Other STM constructs are refs and agents.
+; Refs: http://clojure.org/refs
+; Agents: http://clojure.org/agents
```
+
+### Further Reading
+
+This is far from exhaustive, but hopefully it's enought o get you on your feet.
+
+Clojure.org has lots of articles:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org has documentation with examples for most core functions:
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure is a great way to build your clojure/FP skills:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org (yeah, really) has a number of getting started articles:
+[http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/dart.html.markdown b/dart.html.markdown
index d064dc7d..27365746 100644
--- a/dart.html.markdown
+++ b/dart.html.markdown
@@ -1,7 +1,8 @@
---
-language: Dart
+language: dart
author: Joao Pedrosa
author_url: https://github.com/jpedrosa/
+filename: learndart.dart
---
Dart is a newcomer into the realm of programming languages.
diff --git a/erlang.html.markdown b/erlang.html.markdown
new file mode 100644
index 00000000..66370a7d
--- /dev/null
+++ b/erlang.html.markdown
@@ -0,0 +1,239 @@
+---
+language: erlang
+author: Giovanni Cappellotto
+author_url: http://www.focustheweb.com/
+filename: learnerlang.erl
+---
+
+```latex
+% Percent sign start a one-line comment.
+
+%% Two percent characters shall be used to comment functions.
+
+%%% Three percent characters shall be used to comment modules.
+
+% We use three types of punctuation in Erlang.
+% Commas (`,`) separate arguments in function calls, data constructors, and
+% patterns.
+% Periods (`.`) (followed by whitespace) separate entire functions and
+% expressions in the shell.
+% Semicolons (`;`) separate clauses. We find clauses in several contexts: in kn
+% function definitions and in `case`, `if`, `try..catch` and `receive`
+% expressions.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 1. Variables and pattern matching.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+Num = 42. % All variable names must start with an uppercase letter.
+% Erlang has single assignment variables, if you try to assign a different value
+% to the variable `Num`, you’ll get an error.
+
+% In most languages, `=` denotes an assignment statement. In Erlang, however,
+% `=` denotes a pattern matching operation. `Lhs = Rhs` really means this:
+% evaluate the right side (Rhs), and then match the result against the pattern
+% on the left side (Lhs).
+Num = 7 * 6.
+
+% Floating point number.
+Pi = 3.14159.
+
+% Atoms, are used to represent different non-numerical constant values. Atoms
+% start with lowercase letters, followed by a sequence of alphanumeric
+% characters or the underscore (`_`) or at (`@`) sign.
+Hello = hello.
+
+% Tuples are similar to structs in C.
+Point = {point, 10, 45}.
+
+% If we want to extract some values from a tuple, we use the pattern matching
+% operator `=`.
+{point, X, Y} = Point. % X = 10, Y = 45
+
+% We can use `_` as a placeholder for variables that we’re not interested in.
+% The symbol `_` is called an anonymous variable. Unlike regular variables,
+% several occurrences of _ in the same pattern don’t have to bind to the same
+% value.
+Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.
+{_, {_, {_, Who}, _}, _} = Person. % Who = joe
+
+% We create a list by enclosing the list elements in square brackets and
+% separating them with commas.
+% The individual elements of a list can be of any type.
+% The first element of a list the head of the list. If you imagine removing the
+% head from the list, what’s left is called the tail of the list.
+ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].
+
+% If `T` is a list, then `[H|T]` is also a list, with head H and tail T.
+% The vertical bar (`|`) separates the head of a list from its tail.
+% `[]` is the empty list.
+% We can extract elements from a list with a pattern matching operation. If we
+% have the nonempty list `L`, then the expression `[X|Y] = L`, where `X` and `Y`
+% are unbound variables, will extract the head of the list into `X` and the tail
+% of the list into `Y`.
+[FirstThing|OtherThingsToBuy] = ThingsToBuy.
+% FirstThing = {apples, 10}
+% OtherThingsToBuy = {pears, 6}, {milk, 3}
+
+% There are no strings in Erlang. Strings are really just lists of integers.
+% Strings are enclosed in double quotation marks (`"`).
+Name = "Hello".
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 2. Sequential programming.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Modules are the basic unit of code in Erlang. All the functions we write are
+% stored in modules. Modules are stored in files with `.erl` extensions.
+% Modules must be compiled before the code can be run. A compiled module has the
+% extension `.beam`.
+-module(geometry).
+-export([area/1]).
+
+% The function area consists of two clauses. The clauses are separated by a
+% semicolon, and the final clause is terminated by dot-whitespace.
+% Each clause has a head and a body; the head consists of a function name
+% followed by a pattern (in parentheses), and the body consists of a sequence of
+% expressions, which are evaluated if the pattern in the head is successfully
+% matched against the calling arguments. The patterns are matched in the order
+% they appear in the function definition.
+area({rectangle, Width, Ht}) -> Width * Ht;
+area({circle, R}) -> 3.14159 * R * R.
+
+% Compile the code in the file geometry.erl.
+c(geometry). % {ok,geometry}
+
+% We need to include the module name together with the function name in order to
+% identify exactly which function we want to call.
+geometry:area({rectangle, 10, 5}). % 50
+geometry:area({circle, 1.4}). % 6.15752
+
+% In Erlang, two functions with the same name and different arity in the same
+% module represent entirely different functions.
+-module(lib_misc).
+-export([sum/1]).
+sum(L) -> sum(L, 0).
+sum([], N) -> N;
+sum([H|T], N) -> sum(T, H+N).
+
+% Funs are "anonymous" functions. They are called this because they have no
+% name.
+Double = fun(X) -> 2*X end.
+Double(2). % 4
+
+% Functions accept funs as their arguments and can return funs.
+Mult = fun(Times) -> ( fun(X) -> X * Times end ) end.
+Triple = Mult(3).
+Triple(5). % 15
+
+% List comprehensions are expressions that create lists without having to use
+% funs, maps, or filters.
+% The notation `[F(X) || X <- L]` means "the list of `F(X)` where `X` is taken
+% from the list `L`."
+L = [1,2,3,4,5].
+[2*X || X <- L]. % [2,4,6,8,10]
+
+% Guards are constructs that we can use to increase the power of pattern
+% matching. Using guards, we can perform simple tests and comparisons on the
+% variables in a pattern.
+% You can use guards in the heads of function definitions where they are
+% introduced by the `when` keyword, or you can use them at any place in the
+% language where an expression is allowed.
+max(X, Y) when X > Y -> X;
+max(X, Y) -> Y.
+
+% A guard is a series of guard expressions, separated by commas (`,`).
+% The guard `GuardExpr1, GuardExpr2, ..., GuardExprN` is true if all the guard
+% expressions `GuardExpr1, GuardExpr2, ...` evaluate to true.
+is_cat(A) when is_atom(A), A =:= cat -> true;
+is_cat(A) -> false.
+is_dog(A) when is_atom(A), A =:= dog -> true;
+is_dog(A) -> false.
+
+% A `guard sequence` is either a single guard or a series of guards, separated
+%by semicolons (`;`). The guard sequence `G1; G2; ...; Gn` is true if at least
+% one of the guards `G1, G2, ...` evaluates to true.
+is_pet(A) when is_dog(A); is_cat(A) -> true;
+is_pet(A) -> false.
+
+% Records provide a method for associating a name with a particular element in a
+% tuple.
+% Record definitions can be included in Erlang source code files or put in files
+% with the extension `.hrl`, which are then included by Erlang source code
+% files.
+-record(todo, {
+ status = reminder, % Default value
+ who = joe,
+ text
+}).
+
+% We have to read the record definitions into the shell before we can define a
+% record. We use the shell function `rr` (short for read records) to do this.
+rr("records.hrl"). % [todo]
+
+% Creating and updating records:
+X = #todo{}.
+% #todo{status = reminder, who = joe, text = undefined}
+X1 = #todo{status = urgent, text = "Fix errata in book"}.
+% #todo{status = urgent, who = joe, text = "Fix errata in book"}
+X2 = X1#todo{status = done}.
+% #todo{status = done,who = joe,text = "Fix errata in book"}
+
+% `case` expressions.
+% `filter` returns a list of all those elements `X` in `L` for which `P(X)` is
+% true.
+filter(P, [H|T]) ->
+ case P(H) of
+ true -> [H|filter(P, T)];
+ false -> filter(P, T)
+ end;
+filter(P, []) -> [].
+
+% `if` expressions.
+max(X, Y) ->
+ if
+ X > Y -> X;
+ X < Y -> Y;
+ true -> nil;
+ end.
+
+% Warning: at least one of the guards in the if expression must evaluate to true;
+% otherwise, an exception will be raised.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 3. Exceptions.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Exceptions are raised by the system when internal errors are encountered or
+% explicitly in code by calling `throw(Exception)`, `exit(Exception)` or
+% `erlang:error(Exception)`.
+generate_exception(1) -> a;
+generate_exception(2) -> throw(a);
+generate_exception(3) -> exit(a);
+generate_exception(4) -> {'EXIT', a};
+generate_exception(5) -> erlang:error(a).
+
+% Erlang has two methods of catching an exception. One is to enclose the call to
+% the function, which raised the exception within a `try...catch` expression.
+catcher(N) ->
+ try generate_exception(N) of
+ Val -> {N, normal, Val}
+ catch
+ throw:X -> {N, caught, thrown, X};
+ exit:X -> {N, caught, exited, X};
+ error:X -> {N, caught, error, X}
+ end.
+
+% The other is to enclose the call in a `catch` expression. When you catch an
+% exception, it is converted into a tuple that describes the error.
+catcher(N) -> catch generate_exception(N).
+
+```
+
+## References
+
+* "Programming Erlang: Software for a Concurrent World" by Joe Armstrong
+* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml)
+* [Erlang/OTP Documentation](http://www.erlang.org/doc/)
diff --git a/file.erb b/file.erb
new file mode 100644
index 00000000..5f162aa5
--- /dev/null
+++ b/file.erb
@@ -0,0 +1 @@
+<%= rawcode %>
diff --git a/fsharp.html.markdown b/fsharp.html.markdown
index 5c54130d..b1860372 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -2,15 +2,16 @@
language: F#
author: Scott Wlaschin
author_url: http://fsharpforfunandprofit.com/
+filename: learnfsharp.fs
---
F# is a general purpose functional/OO programming language. It's free and open source, and runs on Linux, Mac, Windows and more.
-It has a powerful type system that traps many errors at compile time, but it uses type inference so that it read more like a dynamic language.
+It has a powerful type system that traps many errors at compile time, but it uses type inference so that it reads more like a dynamic language.
-The syntax of F# is similar to Python:
+The syntax of F# is different from C-style languages:
-* Curly braces are not used to delimit blocks of code. Instead, indentation is used.
+* Curly braces are not used to delimit blocks of code. Instead, indentation is used (like Python).
* Whitespace is used to separate parameters rather than commas.
If you want to try out the code below, you can go to [tryfsharp.org](http://www.tryfsharp.org/Create) and paste it into an interactive REPL.
@@ -123,7 +124,7 @@ printfn "A string %s, and something generic %A" "hello" [1;2;3;4]
// Modules are used to group functions together
// Indentation is needed for each nested module.
-module Addition =
+module FunctionExamples =
// define a simple adding function
let add x y = x + y
@@ -132,12 +133,12 @@ module Addition =
let a = add 1 2
printfn "1+2 = %i" a
- // partial application
+ // partial application to "bake in" parameters
let add42 = add 42
let b = add42 1
printfn "42+1 = %i" b
- // composition
+ // composition to combine functions
let add1 = add 1
let add2 = add 2
let add3 = add1 >> add2
@@ -153,40 +154,177 @@ module Addition =
printfn "1+2+3+7 = %i" d
// ================================================
-// Data Types
+// Lists and collection
// ================================================
+// There are three types of ordered collection:
+// * Lists are most basic immutable collection.
+// * Arrays are mutable and more efficient when needed.
+// * Sequences are lazy and infinite (e.g. an enumerator).
+//
+// Other collections include immutable maps and sets
+// plus all the standard .NET collections
+
+module ListExamples =
+
+ // lists use square brackets
+ let list1 = ["a";"b"]
+ let list2 = "c" :: list1 // :: is prepending
+ let list3 = list1 @ list2 // @ is concat
+
+ // list comprehensions (aka generators)
+ let squares = [for i in 1..10 do yield i*i]
+
+ // prime number generator
+ let rec sieve = function
+ | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+ | [] -> []
+ let primes = sieve [2..50]
+ printfn "%A" primes
+
+ // pattern matching for lists
+ let listMatcher aList =
+ match aList with
+ | [] -> printfn "the list is empty"
+ | [first] -> printfn "the list has one element %A " first
+ | [first; second] -> printfn "list is %A and %A" first second
+ | _ -> printfn "the list has more than two elements"
+
+ listMatcher [1;2;3;4]
+ listMatcher [1;2]
+ listMatcher [1]
+ listMatcher []
+
+ // recursion using lists
+ let rec sum aList =
+ match aList with
+ | [] -> 0
+ | x::xs -> x + sum xs
+ sum [1..10]
+
+ // -----------------------------------------
+ // Standard library functions
+ // -----------------------------------------
+
+ // map
+ let add3 x = x + 3
+ [1..10] |> List.map add3
+
+ // filter
+ let even x = x % 2 = 0
+ [1..10] |> List.filter even
+
+ // many more -- see documentation
+
+module ArrayExamples =
+
+ // arrays use square brackets with bar
+ let array1 = [| "a";"b" |]
+ let first = array1.[0] // indexed access using dot
+
+ // pattern matching for arrays is same as for lists
+ let arrayMatcher aList =
+ match aList with
+ | [| |] -> printfn "the array is empty"
+ | [| first |] -> printfn "the array has one element %A " first
+ | [| first; second |] -> printfn "array is %A and %A" first second
+ | _ -> printfn "the array has more than two elements"
+
+ arrayMatcher [| 1;2;3;4 |]
+
+ // Standard library functions just as for List
+
+ [| 1..10 |]
+ |> Array.map (fun i -> i+3)
+ |> Array.filter (fun i -> i%2 = 0)
+ |> Array.iter (printfn "value is %i. ")
+
+
+module SequenceExamples =
+
+ // sequences use curly braces
+ let seq1 = seq { yield "a"; yield "b" }
+
+ // sequences can use yield and
+ // can contain subsequences
+ let strange = seq {
+ // "yield! adds one element
+ yield 1; yield 2;
+
+ // "yield!" adds a whole subsequence
+ yield! [5..10]
+ yield! seq {
+ for i in 1..10 do
+ if i%2 = 0 then yield i }}
+ // test
+ strange |> Seq.toList
+
+
+ // Sequences can be created using "unfold"
+ // Here's the fibonacci series
+ let fib = Seq.unfold (fun (fst,snd) ->
+ Some(fst + snd, (snd, fst + snd))) (0,1)
+
+ // test
+ let fib10 = fib |> Seq.take 10 |> Seq.toList
+ printf "first 10 fibs are %A" fib10
+
+
+// ================================================
+// Data Types
+// ================================================
module DataTypeExamples =
// All data is immutable by default
// Tuples are quick 'n easy anonymous types
+ // -- Use a comma to create a tuple
let twoTuple = 1,2
let threeTuple = "a",2,true
+
+ // Pattern match to unpack
+ let x,y = twoTuple //sets x=1 y=2
- // Record types have named fields
+ // ------------------------------------
+ // Record types have named fields
+ // ------------------------------------
+
+ // Use "type" with curly braces to define a record type
type Person = {First:string; Last:string}
- let person1 = {First="john"; Last="Doe"}
+
+ // Use "let" with curly braces to create a record
+ let person1 = {First="John"; Last="Doe"}
+ // Pattern match to unpack
+ let {First=first} = person1 //sets first="john"
+
+ // ------------------------------------
// Union types (aka variants) have a set of choices
// Only case can be valid at a time.
+ // ------------------------------------
+
+ // Use "type" with bar/pipe to define a union type
type Temp =
| DegreesC of float
| DegreesF of float
+
+ // Use one of the cases to create one
let temp1 = DegreesF 98.6
let temp2 = DegreesC 37.0
- // Union types are great for modelling state without using flags
- type EmailAddress =
- | ValidEmailAddress of string
- | InvalidEmailAddress of string
+ // Pattern match on all cases to unpack
+ let printTemp = function
+ | DegreesC t -> printfn "%f degC" t
+ | DegreesF t -> printfn "%f degF" t
+
+ printTemp temp1
+ printTemp temp2
+
+ // ------------------------------------
+ // Recursive types
+ // ------------------------------------
- let trySendEmail email =
- match email with // use pattern matching
- | ValidEmailAddress address -> () // send
- | InvalidEmailAddress address -> () // dont send
-
// Types can be combined recursively in complex ways
// without having to create subclasses
type Employee =
@@ -195,6 +333,20 @@ module DataTypeExamples =
let jdoe = {First="John";Last="Doe"}
let worker = Worker jdoe
+
+ // ------------------------------------
+ // Modelling with types
+ // ------------------------------------
+
+ // Union types are great for modelling state without using flags
+ type EmailAddress =
+ | ValidEmailAddress of string
+ | InvalidEmailAddress of string
+
+ let trySendEmail email =
+ match email with // use pattern matching
+ | ValidEmailAddress address -> () // send
+ | InvalidEmailAddress address -> () // dont send
// The combination of union types and record types together
// provide a great foundation for domain driven design.
@@ -211,10 +363,35 @@ module DataTypeExamples =
| ActiveCart of ActiveCartData
| PaidCart of PaidCartData
- // All complex types have pretty printing built in for free
+ // ------------------------------------
+ // Built in behavior for types
+ // ------------------------------------
+
+ // Core types have useful "out-of-the-box" behavior, no coding needed.
+ // * Immutability
+ // * Pretty printing when debugging
+ // * Equality and comparison
+ // * Serialization
+
+ // Pretty printing using %A
printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
twoTuple person1 temp1 worker
-
+
+ // Equality and comparison built in.
+ // Here's an example with cards.
+ type Suit = Club | Diamond | Spade | Heart
+ type Rank = Two | Three | Four | Five | Six | Seven | Eight
+ | Nine | Ten | Jack | Queen | King | Ace
+
+ let hand = [ Club,Ace; Heart,Three; Heart,Ace;
+ Spade,Jack; Diamond,Two; Diamond,Ace ]
+
+ // sorting
+ List.sort hand |> printfn "sorted hand is (low to high) %A"
+ List.max hand |> printfn "high card is %A"
+ List.min hand |> printfn "low card is %A"
+
+
// ================================================
// Active patterns
// ================================================
@@ -224,6 +401,8 @@ module ActivePatternExamples =
// F# has a special type of pattern matching called "active patterns"
// where the pattern can be parsed or detected dynamically.
+ // "banana clips" are the syntax for active patterns
+
// for example, define an "active" pattern to match character types...
let (|Digit|Letter|Whitespace|Other|) ch =
if System.Char.IsDigit(ch) then Digit
@@ -242,7 +421,26 @@ module ActivePatternExamples =
// print a list
['a';'b';'1';' ';'-';'c'] |> List.iter printChar
-
+ // -----------------------------------
+ // FizzBuzz using active patterns
+ // -----------------------------------
+
+ // You can create partial matching patterns as well
+ // Just use undercore in the defintion, and return Some if matched.
+ let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+ let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+ // the main function
+ let fizzBuzz i =
+ match i with
+ | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+ | MultOf3 -> printf "Fizz, "
+ | MultOf5 -> printf "Buzz, "
+ | _ -> printf "%i, " i
+
+ // test
+ [1..20] |> List.iter fizzBuzz
+
// ================================================
// Conciseness
// ================================================
@@ -289,7 +487,7 @@ module AlgorithmExamples =
module AsyncExample =
- // F# has some built-in features to help with async code
+ // F# has built-in features to help with async code
// without encountering the "pyramid of doom"
//
// The following example downloads a set of web pages in parallel.
@@ -301,10 +499,14 @@ module AsyncExample =
// Fetch the contents of a URL asynchronously
let fetchUrlAsync url =
- async {
+ async { // "async" keyword and curly braces
+ // creates an "async" object
let req = WebRequest.Create(Uri(url))
- use! resp = req.AsyncGetResponse()
+ use! resp = req.AsyncGetResponse()
+ // use! is async assignment
use stream = resp.GetResponseStream()
+ // "use" triggers automatic close()
+ // on resource at end of scope
use reader = new IO.StreamReader(stream)
let html = reader.ReadToEnd()
printfn "finished downloading %s" url
@@ -360,7 +562,7 @@ module NetCompatibilityExamples =
// F# is also a fully fledged OO language.
// It supports classes, inheritance, virtual methods, etc.
- // interface
+ // interface with generic type
type IEnumerator<'a> =
abstract member Current : 'a
abstract MoveNext : unit -> bool
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 563674c9..84b8f263 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -5,7 +5,7 @@ author_url: http://adit.io
---
Haskell was designed as a practical, purely functional programming language. It's famous for
-it's monads and it's type system, but I keep coming back to it because of it's elegance. Haskell
+its monads and its type system, but I keep coming back to it because of its elegance. Haskell
makes coding a real joy for me.
```haskell
@@ -44,15 +44,21 @@ not False -- True
1 /= 1 -- False
1 < 10 -- True
+-- In the above examples, `not` is a function that takes one value.
+-- Haskell doesn't need parentheses for function calls...all the arguments
+-- are just listed after the function. So the general pattern is:
+-- func arg1 arg2 arg3...
+-- See the section on functions for information on how to write your own.
+
-- Strings and characters
"This is a string."
'a' -- character
'You cant use single quotes for strings.' -- error!
--- Strings can be added too!
+-- Strings can be concatenated
"Hello " ++ "world!" -- "Hello world!"
--- A string can be treated like a list of characters
+-- A string is a list of characters
"This is a string" !! 0 -- 'T'
@@ -68,14 +74,24 @@ not False -- True
-- You can also have infinite lists in Haskell!
[1..] -- a list of all the natural numbers
--- joining two lists
+-- Infinite lists work because Haskell has "lazy evaluation". This means
+-- that Haskell only evaluates things when it needs to. So you can ask for
+-- the 1000th element of your list and Haskell will give it to you:
+
+[1..] !! 999 -- 1000
+
+-- And now Haskell has evaluated elements 1 - 1000 of this list...but the
+-- rest of the elements of this "infinite" list don't exist yet! Haskell won't
+-- actually evaluate them until it needs to.
+
+- joining two lists
[1..5] ++ [6..10]
-- adding to the head of a list
0:[1..5] -- [0, 1, 2, 3, 4, 5]
-- indexing into a list
-[0..] !! 5 -- 4
+[0..] !! 5 -- 5
-- more list operations
head [1..5] -- 1
@@ -104,6 +120,10 @@ snd ("haskell", 1) -- 1
-- A simple function that takes two variables
add a b = a + b
+-- Note that if you are using ghci (the Haskell interpreter)
+-- You'll need to use `let`, i.e.
+-- let add a b = a + b
+
-- Using the function
add 1 2 -- 3
@@ -132,19 +152,19 @@ fib x = fib (x - 1) + fib (x - 2)
-- Pattern matching on tuples:
foo (x, y) = (x + 1, y + 2)
--- Pattern matching on arrays. Here `x` is the first element
--- in the array, and `xs` is the rest of the array. We can write
+-- Pattern matching on lists. Here `x` is the first element
+-- in the list, and `xs` is the rest of the list. We can write
-- our own map function:
-map func [x] = [func x]
-map func (x:xs) = func x:(map func xs)
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
-- Anonymous functions are created with a backslash followed by
-- all the arguments.
-map (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
-- using fold (called `inject` in some languages) with an anonymous
-- function. foldl1 means fold left, and use the first value in the
--- array as the initial value for the accumulator.
+-- list as the initial value for the accumulator.
foldl1 (\acc x -> acc + x) [1..5] -- 15
----------------------------------------------------
@@ -179,10 +199,10 @@ foo 5 -- 75
-- of parentheses:
-- before
-(even (double 7)) -- true
+(even (fib 7)) -- true
-- after
-even . double $ 7 -- true
+even . fib $ 7 -- true
----------------------------------------------------
-- 5. Type signatures
@@ -197,13 +217,17 @@ True :: Bool
-- Functions have types too.
-- `not` takes a boolean and returns a boolean:
-not :: Bool -> Bool
+-- not :: Bool -> Bool
-- Here's a function that takes two arguments:
-add :: Integer -> Integer -> Integer
+-- add :: Integer -> Integer -> Integer
+
+-- When you define a value, it's good practice to write its type above it:
+double :: Integer -> Integer
+double x = x * 2
----------------------------------------------------
--- 6. Control Flow
+-- 6. Control Flow and If Statements
----------------------------------------------------
-- if statements
@@ -259,7 +283,42 @@ Just "hello"
Just 1
----------------------------------------------------
--- 8. The Haskell REPL
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- While IO can't be explained fully without explaining monads,
+-- it is not hard to explain enough to get going.
+
+-- An `IO a` value is an IO action: you can chain them with do blocks
+action :: IO String
+action = do
+ putStrLn "This is a line. Duh"
+ input <- getLine -- this gets a line and gives it the name "input"
+ input2 <- getLine
+ return (input1 ++ "\n" ++ input2) -- This is the result of the whole action
+
+-- This didn't actually do anything. When a haskell program is executed
+-- an IO action called "main" is read and interpreted.
+
+main = do
+ putStrLn "Our first program. How exciting!"
+ result <- action -- our defined action is just like the default ones
+ putStrLn result
+ putStrLn "This was all, folks!"
+
+-- Haskell does IO through a monad because this allows it to be a purely
+-- functional language. Our `action` function had a type signature of `IO String`.
+-- In general any function that interacts with the outside world (i.e. does IO)
+-- gets marked as `IO` in its type signature. This lets us reason about what
+-- functions are "pure" (don't interact with the outside world or modify state)
+-- and what functions aren't.
+
+-- This is a powerful feature, because it's easy to run pure functions concurrently
+-- so concurrency in Haskell is very easy.
+
+
+----------------------------------------------------
+-- 9. The Haskell REPL
----------------------------------------------------
-- Start the repl by typing `ghci`.
diff --git a/java.html.markdown b/java.html.markdown
new file mode 100644
index 00000000..f4ab4220
--- /dev/null
+++ b/java.html.markdown
@@ -0,0 +1,370 @@
+---
+
+language: java
+
+author: Jake Prather
+
+author_url: http://github.com/JakeHP
+
+filename: LearnJava.java
+
+---
+
+Java is a general-purpose, concurrent, class-based, object-oriented computer programming language.
+[Read more here.](http://docs.oracle.com/javase/tutorial/java/index.html)
+
+```java
+// Single-line comments start with //
+/*
+Multi-line comments look like this.
+*/
+
+// Import ArrayList class inside of the java.util package
+import java.util.ArrayList;
+// Import all classes inside of java.security package
+import java.security.*;
+
+// Each .java file contains one public class, with the same name as the file.
+public class LearnJava {
+
+ // A program must have a main method as an entry point
+ public static void main (String[] args) {
+
+ // Use System.out.println to print lines
+ System.out.println("Hello World!");
+ System.out.println(
+ "Integer: " + 10 +
+ " Double: " + 3.14 +
+ " Boolean: " + true);
+
+ // To print without a newline, use System.out.print
+ System.out.print("Hello ");
+ System.out.print("World");
+
+
+ ///////////////////////////////////////
+ // Types & Variables
+ ///////////////////////////////////////
+
+ // Declare a variable using <type> <name> [
+ // Byte - 8-bit signed two's complement integer
+ // (-128 <= byte <= 127)
+ byte fooByte = 100;
+
+ // Short - 16-bit signed two's complement integer
+ // (-32,768 <= short <= 32,767)
+ short fooShort = 10000;
+
+ // Integer - 32-bit signed two's complement integer
+ // (-2,147,483,648 <= int <= 2,147,483,647)
+ int fooInt = 1;
+
+ // Long - 64-bit signed two's complement integer
+ // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ long fooLong = 100000L;
+
+ // (Java has no unsigned types)
+
+ // Float - Single-precision 32-bit IEEE 754 Floating Point
+ float fooFloat = 234.5f;
+
+ // Double - Double-precision 64-bit IEEE 754 Floating Point
+ double fooDouble = 123.4;
+
+ // Boolean - true & false
+ boolean fooBoolean = true;
+ boolean barBoolean = false;
+
+ // Char - A single 16-bit Unicode character
+ char fooChar = 'A';
+
+ // Use final to make a variable immutable
+ final int HOURS_I_WORK_PER_WEEK = 9001;
+
+ // Strings
+ String fooString = "My String Is Here!";
+
+ // \n is an escaped character that starts a new line
+ String barString = "Printing on a new line?\nNo Problem!";
+ System.out.println(fooString);
+ System.out.println(barString);
+
+ // Arrays
+ //The array size must be decided upon declaration
+ //The format for declaring an array is follows:
+ //<datatype> [] <var name> = new <datatype>[<array size>];
+ int [] intArray = new int[10];
+ String [] stringArray = new String[1];
+ boolean [] booleanArray = new boolean[100];
+
+ // Another way to declare & initialize an array
+ int [] y = {9000, 1000, 1337};
+
+ // Indexing an array - Accessing an element
+ System.out.println("intArray @ 0: " + intArray[0]);
+
+ // Arrays are zero-indexed and mutable.
+ intArray[1] = 1;
+ System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+ // Others to check out
+ // ArrayLists - Like arrays except more functionality is offered,
+ // and the size is mutable
+ // LinkedLists
+ // Maps
+ // HashMaps
+
+ ///////////////////////////////////////
+ // Operators
+ ///////////////////////////////////////
+ System.out.println("\n->Operators");
+
+ int i1 = 1, i2 = 2; // Shorthand for multiple declarations
+
+ // Arithmetic is straightforward
+ System.out.println("1+2 = " + (i1 + i2)); // => 3
+ System.out.println("2-1 = " + (i2 - i1)); // => 1
+ System.out.println("2*1 = " + (i2 * i1)); // => 2
+ System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
+
+ // Modulo
+ System.out.println("11%3 = "+(11 % 3)); // => 2
+
+ // Comparison operators
+ System.out.println("3 == 2? " + (3 == 2)); // => 0 (false)
+ System.out.println("3 != 2? " + (3 != 2)); // => 1 (true)
+ System.out.println("3 > 2? " + (3 > 2)); // => 1
+ System.out.println("3 < 2? " + (3 < 2)); // => 0
+ System.out.println("2 <= 2? " + (2 <= 2)); // => 1
+ System.out.println("2 >= 2? " + (2 >= 2)); // => 1
+
+ // Bitwise operators!
+ /*
+ ~ Unary bitwise complement
+ << Signed left shift
+ >> Signed right shift
+ >>> Unsigned right shift
+ & Bitwise AND
+ ^ Bitwise exclusive OR
+ | Bitwise inclusive OR
+ */
+
+ // Incrementations
+ int i=0;
+ System.out.println("\n->Inc/Dec-rementation");
+ System.out.println(i++); //i = 1. Post-Incrementation
+ System.out.println(++i); //i = 2. Pre-Incrementation
+ System.out.println(i--); //i = 1. Post-Decrementation
+ System.out.println(--i); //i = 0. Pre-Decrementation
+
+ ///////////////////////////////////////
+ // Control Structures
+ ///////////////////////////////////////
+ System.out.println("\n->Control Structures");
+
+ // If statements are c-like
+ if (false){
+ System.out.println("I never run");
+ }else if (false) {
+ System.out.println("I am also never run");
+ } else {
+ System.out.println("I print");
+ }
+
+ // While loop
+ int fooWhile = 0;
+ while(fooWhile < 100)
+ {
+ //System.out.println(fooWhile);
+ //Increment the counter
+ //Iterated 99 times, fooWhile 0->99
+ fooWhile++;
+ }
+ System.out.println("fooWhile Value: " + fooWhile);
+
+ // Do While Loop
+ int fooDoWhile = 0;
+ do
+ {
+ //System.out.println(fooDoWhile);
+ //Increment the counter
+ //Iterated 99 times, fooDoWhile 0->99
+ fooDoWhile++;
+ }while(fooDoWhile < 100);
+ System.out.println("fooDoWhile Value: " + fooDoWhile);
+
+ // For Loop
+ int fooFor;
+ //for loop structure => for(<start_statement>; <conditional>; <step>)
+ for(fooFor=0; fooFor<10; fooFor++){
+ //System.out.println(fooFor);
+ //Iterated 10 times, fooFor 0->9
+ }
+ System.out.println("fooFor Value: " + fooFor);
+
+ // Switch Case
+ int month = 3;
+ String monthString;
+ switch (month){
+ case 1: monthString = "January";
+ break;
+ case 2: monthString = "February";
+ break;
+ case 3: monthString = "March";
+ break;
+ default: monthString = "Some other month";
+ break;
+ }
+ System.out.println("Switch Case Result: " + monthString);
+
+
+ ///////////////////////////////////////
+ // Converting Data Types And Typcasting
+ ///////////////////////////////////////
+
+ // Converting data
+
+ // Convert String To Integer
+ Integer.parseInt("123");//returns an integer version of "123"
+
+ // Convert Integer To String
+ Integer.toString(123);//returns a string version of 123
+
+ // For other conversions check out the following classes:
+ // Double
+ // Long
+ // String
+
+ // Typecasting
+ // You can also cast java objects, there's a lot of details and
+ // deals with some more intermediate concepts.
+ // Feel free to check it out here:
+ // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+ ///////////////////////////////////////
+ // Classes And Functions
+ ///////////////////////////////////////
+
+ System.out.println("\n->Classes & Functions");
+
+ // (definition of the Bicycle class follows)
+
+ // Use new to instantiate a class
+ Bicycle trek = new Bicycle();
+
+ // Call object methods
+ trek.speedUp(3);
+ trek.setCadence(100);
+
+ // toString is a convention
+ System.out.println("trek info: " + trek.toString());
+
+ } // End main method
+} // End LearnJava class
+
+
+// You can include other, non-public classes in a .java file
+
+
+// Class Declaration Syntax:
+// <public/private/protected> class <class name>{
+// //data fields, constructors, functions all inside
+// }
+
+class Bicycle {
+
+ // Bicycle's Fields/Variables
+ public int cadence; // Public: Can be accessed from anywhere
+ private int speed; // Private: Only accessable from within the class
+ protected int gear; // Protected: Accessible from the class and subclasses
+
+ // Constructors are a way of creating classes
+ // This is a default constructor
+ public Bicycle() {
+ gear = 1;
+ cadence = 50;
+ speed = 5;
+ }
+
+ // This is a specified constructor (it contains arguments)
+ public Bicycle(int startCadence, int startSpeed, int startGear) {
+ gear = startGear;
+ cadence = startCadence;
+ speed = startSpeed;
+ }
+
+ // Function Syntax:
+ // <public/private/protected> <return type> <function name>(<args>)
+
+ // Java classes often implement getters and setters for their fields
+
+ // Method declaration syntax:
+ // <scope> <return type> <method name>(<args>)
+ public int getCadence() {
+ return cadence;
+ }
+
+ // void methods require no return statement
+ public void setCadence(int newValue) {
+ cadence = newValue;
+ }
+
+ public void setGear(int newValue) {
+ gear = newValue;
+ }
+
+ public void speedUp(int increment) {
+ speed += increment;
+ }
+
+ public void slowDown(int decrement) {
+ speed -= decrement;
+ }
+
+ public String toString() {
+ return "gear: "+Integer.toString(gear)+
+ " cadence: "+Integer.toString(cadence)+
+ " speed: "+Integer.toString(speed);
+ }
+} // end class Bicycle
+
+// Use `extends` to extend a class
+class PennyFarthing extends Bicycle {
+ // (Penny Farthings are those bicycles with the big front wheel.
+ // They have no gears.)
+
+ public PennyFarthing(int startCadence, int startSpeed){
+ // Call the parent constructor with super
+ super(startCadence, startSpeed, 0);
+ }
+
+ // You should mark a method you're overriding with an @annotation
+ @Override
+ public void setGear(int gear) {
+ gear = 0;
+ }
+
+}
+
+```
+
+## Further Reading
+
+Other Topics To Research:
+
+* [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+
+* [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+
+* [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)
+
+* The links provided are just to get an understanding of the topic, feel free to google and find specific examples
diff --git a/lua.html.markdown b/lua.html.markdown
index 66ebf6bd..4df57a92 100644
--- a/lua.html.markdown
+++ b/lua.html.markdown
@@ -2,6 +2,7 @@
language: lua
author: Tyler Neylon
author_url: http://tylerneylon.com/
+filename: learnlua.lua
---
```lua
diff --git a/php.html.markdown b/php.html.markdown
index 753f6ab1..75bbd214 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -2,19 +2,16 @@
language: php
author: Malcolm Fell
author_url: http://emarref.net/
+filename: learnphp.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 ?>.
-
-## [Comments](http://www.php.net/manual/en/language.basic-syntax.comments.php)
-
```php
-<?php
+<?php // PHP code must be enclosed with <?php ? > tags
+
+// If your php file only contains PHP code, it is best practise
+// to omit the php closing tag.
// Two forward slashes start a one-line comment.
@@ -24,27 +21,36 @@ configured to respect the [short open tags](http://www.php.net/manual/en/ini.cor
Surrounding text in slash-asterisk and asterisk-slash
makes it a multi-line comment.
*/
-```
-
-## [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.
+// Use "echo" or "print" to print output
+print('Hello '); // Prints "Hello " with no line break
-### Scalars
+// () are optional for print and echo
+echo "World\n"; // Prints "World" with a line break
+// (all statements must end with a semicolon)
-```php
+// Anything outside <?php tags is echoed automatically
+?>Hello World Again!
<?php
+
+/************************************
+ * Types & Variables
+ */
+
+// Variables begin with the $ symbol.
+// A valid variable name starts with a letter or underscore,
+// followed by any number of letters, numbers, or underscores.
+
// Boolean values are case-insensitive
-$boolean = true; // or TRUE or True
+$boolean = true; // or TRUE or True
$boolean = false; // or FALSE or False
// Integers
-$integer = 1234; // decimal number
-$integer = -123; // a negative number
-$integer = 0123; // octal number (equivalent to 83 decimal)
-$integer = 0x1A; // hexadecimal number (equivalent to 26 decimal)
+$int1 = 19; // => 19
+$int2 = -19; // => -19
+$int3 = 019; // => 15 (a leading 0 denotes an octal number)
+$int4 = 0x0F; // => 15 (a leading 0x denotes a hex literal)
// Floats (aka doubles)
$float = 1.234;
@@ -52,28 +58,30 @@ $float = 1.2e3;
$float = 7E-10;
// Arithmetic
-$sum = $number + $float;
-$difference = $number - $float;
-$product = $number * $float;
-$quotient = $number / $float;
+$sum = 1 + 1; // 2
+$difference = 2 - 1; // 1
+$product = 2 * 2; // 4
+$quotient = 2 / 1; // 2
// Shorthand arithmetic
-$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
+$number = 0;
+$number += 1; // Increment $number by 1
+echo $number++; // Prints 1 (increments after evaluation)
+echo ++$number; // Prints 3 (increments before evalutation)
+$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'
+$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
-// Escape special characters with backslash
-$escaped = "This contains a \t tab character.";
+// Special characters are only escaped in double quotes
+$escaped = "This contains a \t tab character.";
+$unescaped = 'This just contains a slash and a t: \t';
// Enclose a variable in curly braces if needed
-$money = "I have $${integer} in the bank."
+$money = "I have $${number} in the bank.";
// Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners
$nowdoc = <<<'END'
@@ -81,35 +89,40 @@ Multi line
string
END;
+// Heredocs will do string interpolation
$heredoc = <<<END
Multi line
$sgl_quotes
-END; // Nowdoc syntax is available in PHP 5.3.0
+END;
-// Manipulation
-$concatenated = $sgl_quotes . $dbl_quotes;
-```
+// String concatenation is done with .
+echo 'This string ' . 'is concatenated';
-### Compound
-```php
-<?php
+/********************************
+ * Arrays
+ */
-// Arrays
-$array = array(1, 2, 3);
-$array = [1, 2, 3]; // As of PHP 5.4
-$string = ["One", "Two", "Three"];
-$string[0]; // Holds the value "One";
+// All arrays in PHP are associative arrays (hashmaps),
// Associative arrays, known as hashmaps in some languages.
-$associative = ["One" => 1, "Two" => 2, "Three" => 3];
-$associative["One"]; // Holds the value 1
-```
-## Output
+// Works with all PHP versions
+$associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
-```php
-<?php
+// PHP 5.4 introduced a new syntax
+$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
+
+echo $associative['One']; // prints 1
+
+// List literals implicitly assign integer keys
+$array = ['One', 'Two', 'Three'];
+echo $array[0]; // => "One"
+
+
+/********************************
+ * Output
+ */
echo('Hello World!');
// Prints Hello World! to stdout.
@@ -121,133 +134,129 @@ print('Hello World!'); // The same as echo
echo 'Hello World!';
print 'Hello World!'; // So is print
-echo 100;
-echo $variable;
-echo function_result();
+$paragraph = 'paragraph';
+
+echo 100; // Echo scalar variables directly
+echo $paragraph; // or variables
// If short open tags are configured, or your PHP version is
// 5.4.0 or greater, you can use the short echo syntax
-<?= $variable ?>
-```
-
-## [Operators](http://www.php.net/manual/en/language.operators.php)
-
-### Assignment
-
-```php
+?>
+<p><?= $paragraph ?></p>
<?php
$x = 1;
$y = 2;
-$x = $y; // A now contains the same value sa $y
-$x = &$y;
-// $x 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 the same value as $y
+$z = &$y;
+// $z now contains a reference to $y. Changing the value of
+// $z will change the value of $y also, and vice-versa.
+// $x will remain unchanged as the original value of $y
-### Comparison
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
-```php
-<?php
+
+/********************************
+ * Logic
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// assert throws a warning if its argument is not true
// 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.
-$a <> $b // TRUE if $a is not equal to $b after type juggling.
-$a < $b // TRUE if $a is strictly less than $b.
-$a > $b // TRUE if $a is strictly greater than $b.
-$a <= $b // TRUE if $a is less than or equal to $b.
-$a >= $b // TRUE if $a is greater than or equal to $b.
+assert($a == $b); // equality
+assert($c != $a); // inequality
+assert($c <> $a); // alternative inequality
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
// The following will only be true if the values match and are the same type.
-$a === $b // TRUE if $a is equal to $b, and they are of the same type.
-$a !== $b // TRUE if $a is not equal to $b, or they are not of the same type.
-1 == '1' // TRUE
-1 === '1' // FALSE
-```
+assert($c === $d);
+assert($a !== $d);
+assert(1 == '1');
+assert(1 !== '1');
-## [Type Juggling](http://www.php.net/manual/en/language.types.type-juggling.php)
-
-Variables can be converted between types, depending on their usage.
-
-```php
-<?php
+// Variables can be converted between types, depending on their usage.
$integer = 1;
-echo $integer + $integer; // Outputs 2;
+echo $integer + $integer; // => 2
$string = '1';
-echo $string + $string;
-// Also outputs 2 because the + operator converts the strings to integers
+echo $string + $string; // => 2 (strings are coerced to integers)
$string = 'one';
-echo $string + $string;
+echo $string + $string; // => 0
// 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.
+// Type casting can be used to treat a variable as another type
-```php
-$boolean = (boolean) $integer; // $boolean is true
+$boolean = (boolean) 1; // => true
$zero = 0;
-$boolean = (boolean) $zero; // $boolean is false
+$boolean = (boolean) $zero; // => false
+// There are also dedicated functions for casting most types
$integer = 5;
$string = strval($integer);
-// There are also dedicated functions for casting most types
$var = null; // Null value
-```
-## [Control Structures](http://www.php.net/manual/en/language.control-structures.php)
-### If Statements
+/********************************
+ * Control Structures
+ */
-```php
-<?php
-
-if (/* test */) {
- // Do something
+if (true) {
+ print 'I get printed';
}
-if (/* test */) {
- // Do something
+if (false) {
+ print 'I don\'t';
} else {
- // Do something else
+ print 'I get printed';
}
-if (/* test */) {
- // Do something
-} elseif(/* test2 */) {
- // Do something else, only if test2
+if (false) {
+ print 'Does not get printed';
+} elseif(true) {
+ print 'Does';
}
-if (/* test */) {
- // Do something
-} elseif(/* test2 */) {
- // Do something else, only if test2
+$x = 0;
+if ($x === '0') {
+ print 'Does not print';
+} elseif($x == '1') {
+ print 'Does not print';
} else {
- // Do something default
+ print 'Does print';
}
+
+// This alternative syntax is useful for templates:
?>
-<?php if (/* test */): ?>
+<?php if ($x): ?>
This is displayed if the test is truthy.
<?php else: ?>
This is displayed otherwise.
<?php endif; ?>
-```
-
-### Switch statements
-```php
<?php
-switch ($variable) {
- case 'one':
- // Do something if $variable == 'one'
- break;
+// Use switch to save some logic.
+switch ($x) {
+ case '0':
+ print 'Switch does type coercion';
+ break; // You must include a break, or you will fall through
+ // to cases 'two' and 'three'
case 'two':
case 'three':
// Do something if $variable is either 'two' or 'three'
@@ -256,199 +265,231 @@ switch ($variable) {
// Do something by default
}
-```
-
-### Loops
-
-```php
-<?php
-
+// While, do...while and for loops are probably familiar
$i = 0;
while ($i < 5) {
echo $i++;
-}
+}; // Prints "01234"
+
+echo "\n";
$i = 0;
do {
echo $i++;
-} while ($i < 5);
+} while ($i < 5); // Prints "01234"
+
+echo "\n";
for ($x = 0; $x < 10; $x++) {
- echo $x; // Will echo 0 - 9
-}
+ echo $x;
+} // Prints "0123456789"
+
+echo "\n";
-$wheels = ["bicycle" => 2, "car" => 4];
+$wheels = ['bicycle' => 2, 'car' => 4];
+// Foreach loops can iterate over arrays
+foreach ($wheels as $wheel_count) {
+ echo $wheel_count;
+} // Prints "24"
+
+echo "\n";
+
+// You can iterate over the keys as well as the values
foreach ($wheels as $vehicle => $wheel_count) {
echo "A $vehicle has $wheel_count wheels";
}
-// This loop will stop after outputting 2
+echo "\n";
+
$i = 0;
while ($i < 5) {
- if ($i == 3) {
- break; // Exit out of the while loop and continue.
+ if ($i === 3) {
+ break; // Exit out of the while loop
}
echo $i++;
-}
+} // Prints "012"
-// This loop will output everything except 3
-$i = 0;
-while ($i < 5) {
- if ($i == 3) {
+for ($i = 0; $i < 5; $i++) {
+ if ($i === 3) {
continue; // Skip this iteration of the loop
}
- echo $i++;
-}
-```
+ echo $i;
+} // Prints "0124"
-## Functions
-Functions are created with the ```function``` keyword.
-
-```php
-<?php
+/********************************
+ * Functions
+ */
-function my_function($my_arg) {
- $my_variable = 1;
+// Define a function with "function":
+function my_function () {
+ return 'Hello';
}
-// $my_variable and $my_arg cannot be accessed outside of the function
-```
-
-Functions may be invoked by name.
+echo my_function(); // => "Hello"
-```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.
-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
+function add ($x, $y = 1) { // $y is optional and defaults to 1
+ $result = $x + $y;
+ return $result;
}
-// Functions may be nested to limit scope
-function outer_function ($arg_1 = null) { // $arg_1 is optional
- function inner_function($arg_2 = 'two') { // $arg_2 will default to 'two'
- }
-}
+echo add(4); // => 5
+echo add(4, 2); // => 6
-// inner_function() does not exist and cannot be called until
-// outer_function() is called
-```
+// $result is not accessible outside the function
+// print $result; // Gives a warning.
+
+// Since PHP 5.3 you can declare anonymous functions;
+$inc = function ($x) {
+ return $x + 1;
+};
-This enables [currying](http://en.wikipedia.org/wiki/Currying) in PHP.
+echo $inc(2); // => 3
-```php
function foo ($x, $y, $z) {
echo "$x - $y - $z";
}
+// Functions can return functions
function bar ($x, $y) {
+ // Use 'use' to bring in outside variables
return function ($z) use ($x, $y) {
foo($x, $y, $z);
};
}
$bar = bar('A', 'B');
-$bar('C');
-```
+$bar('C'); // Prints "A - B - C"
-### [Variable](http://www.php.net/manual/en/functions.variable-functions.php)
+// You can call named functions using strings
+$function_name = 'add';
+echo $function_name(1, 2); // => 3
+// Useful for programatically determining which function to run.
+// Or, use call_user_func(callable $callback [, $parameter [, ... ]]);
-```php
-<?php
-
-$function_name = 'my_function_name';
+/********************************
+ * Includes
+ */
-$function_name(); // will execute the my_function_name() function
+/*
```
-
-### [Anonymous](http://www.php.net/manual/en/functions.anonymous.php)
-
-Similar to variable functions, functions may be anonymous.
-
```php
<?php
+// PHP within included files must also begin with a PHP open tag.
-function my_function($callback) {
- $callback('My argument');
-}
+include 'my-file.php';
+// The code in my-file.php is now available in the current scope.
+// If the file cannot be included (e.g. file not found), a warning is emitted.
-my_function(function ($my_argument) {
- // do something
-});
+include_once 'my-file.php';
+// If the code in my-file.php has been included elsewhere, it will
+// not be included again. This prevents multiple class declaration errors
-// Closure style
-$my_function = function() {
- // Do something
-};
+require 'my-file.php';
+require_once 'my-file.php';
+// Same as include(), except require() will cause a fatal error if the
+// file cannot be included.
-$my_function();
-```
+// Contents of my-include.php:
+<?php
-## [Classes](http://www.php.net/manual/en/language.oop5.php)
+return 'Anything you like.';
+// End file
-Classes are defined with the ```class``` keyword.
+// Includes and requires may also return a value.
+$value = include 'my-include.php';
-```php
-<?php
+// Files are included based on the file path given or, if none is given,
+// the include_path configuration directive. If the file isn't found in
+// the include_path, include will finally check in the calling script's
+// own directory and the current working directory before failing.
+/* */
-class MyClass {
- const MY_CONST = 'value';
- static $staticVar = 'something';
- public $property = 'value'; // Properties must declare their visibility
-}
+/********************************
+ * Classes
+ */
-echo MyClass::MY_CONST; // Outputs "value";
+// Classes are defined with the class keyword
-final class YouCannotExtendMe {
-}
-```
+class MyClass
+{
+ const MY_CONST = 'value'; // A constant
-Classes are insantiated with the ```new``` keyword. Functions are referred to as
-methods if they belong to a class.
+ static $staticVar = 'static';
-```php
-<?php
+ // Properties must declare their visibility
+ public $property = 'public';
+ public $instanceProp;
+ protected $prot = 'protected'; // Accessible from the class and subclasses
+ private $priv = 'private'; // Accessible within the class only
+
+ // Create a constructor with __construct
+ public function __construct($instanceProp) {
+ // Access instance variables with $this
+ $this->instanceProp = $instanceProp;
+ }
-class MyClass {
- function myFunction() {
+ // Methods are declared as functions inside a class
+ public function myMethod()
+ {
+ print 'MyClass';
}
- final function youCannotOverrideMe() {
+ final function youCannotOverrideMe()
+ {
}
- public static function myStaticMethod() {
+ public static function myStaticMethod()
+ {
+ print 'I am static';
}
}
-$cls = new MyClass(); // The parentheses are optional.
+echo MyClass::MY_CONST; // Outputs 'value';
+echo MyClass::$staticVar; // Outputs 'static';
+MyClass::myStaticMethod(); // Outputs 'I am static';
-echo MyClass::$staticVar; // Access to static vars
+// Instantiate classes using new
+$my_class = new MyClass('An instance property');
+// The parentheses are optional if not passing in an argument.
-echo $cls->property; // Access to properties
+// Access class members using ->
+echo $my_class->property; // => "public"
+echo $my_class->instanceProp; // => "An instance property"
+$my_class->myMethod(); // => "MyClass"
-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.
+// Extend classes using "extends"
+class MyOtherClass extends MyClass
+{
+ function printProtectedProperty()
+ {
+ echo $this->prot;
+ }
-```php
-<?php
+ // Override a method
+ function myMethod()
+ {
+ parent::myMethod();
+ print ' > MyOtherClass';
+ }
+}
+
+$my_other_class = new MyOtherClass('Instance prop');
+$my_other_class->printProtectedProperty(); // => Prints "protected"
+$my_other_class->myMethod(); // Prints "MyClass > MyOtherClass"
+
+final class YouCannotExtendMe
+{
+}
-class MyClass {
+// You can use "magic methods" to create getters and setters
+class MyMapClass
+{
private $property;
public function __get($key)
@@ -462,16 +503,13 @@ class MyClass {
}
}
-$x = new MyClass();
+$x = new MyMapClass();
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
+// Classes can be abstract (using the abstract keyword) or
+// implement interfaces (using the implements keyword).
+// An interface is declared with the interface keyword.
interface InterfaceOne
{
@@ -480,90 +518,112 @@ interface InterfaceOne
interface InterfaceTwo
{
- public function doSomething();
+ public function doSomethingElse();
}
abstract class MyAbstractClass implements InterfaceOne
{
+ public $x = 'doSomething';
}
-class MyClass extends MyAbstractClass implements InterfaceTwo
+class MyConcreteClass extends MyAbstractClass implements InterfaceTwo
{
+ public function doSomething()
+ {
+ echo $x;
+ }
+
+ public function doSomethingElse()
+ {
+ echo 'doSomethingElse';
+ }
}
+
// Classes can implement more than one interface
class SomeOtherClass implements InterfaceOne, InterfaceTwo
{
+ public function doSomething()
+ {
+ echo 'doSomething';
+ }
+
+ public function doSomethingElse()
+ {
+ echo 'doSomethingElse';
+ }
}
-```
-### [Namespaces](http://www.php.net/manual/en/language.namespaces.rationale.php)
-By default, classes exist in the global namespace, and can be explicitly called with a backslash.
+/********************************
+ * Traits
+ */
+// Traits are available from PHP 5.4.0 and are declared using "trait"
+
+trait MyTrait
+{
+ public function myTraitMethod()
+ {
+ print 'I have MyTrait';
+ }
+}
+
+class MyTraitfulClass
+{
+ use MyTrait;
+}
+
+$cls = new MyTraitfulClass();
+$cls->myTraitMethod(); // Prints "I have MyTrait"
+
+
+/********************************
+ * Namespaces
+ */
+
+// This section is separate, because a namespace declaration
+// must be the first statement in a file. Let's pretend that is not the case
+
+/*
+```
```php
<?php
+// By default, classes exist in the global namespace, and can
+// be explicitly called with a backslash.
+
$cls = new \MyClass();
-```
-```php
-<?php
+
+// Set the namespace for a file
namespace My\Namespace;
class MyClass
{
}
+// (from another file)
$cls = new My\Namespace\MyClass;
-```
-
-Or from within another namespace.
-
-```php
-<?php
+//Or from within another namespace.
namespace My\Other\Namespace;
use My\Namespace\MyClass;
$cls = new MyClass();
-```
-Or you can alias the namespace;
-
-```php
-<?php
+// Or you can alias the namespace;
namespace My\Other\Namespace;
use My\Namespace as SomeOtherNamespace;
$cls = new SomeOtherNamespace\MyClass();
-```
-
-### [Traits](http://www.php.net/manual/en/language.oop5.traits.php)
-
-Traits are available since PHP 5.4.0 and are declared using the ```trait``` keyword.
-
-```php
-<?php
-trait MyTrait {
- public function myTraitMethod()
- {
- // Do something
- }
-}
-
-class MyClass
-{
- use MyTrait;
-}
+*/
-$cls = new MyClass();
-$cls->myTraitMethod();
```
## More Information
@@ -573,3 +633,5 @@ Visit the [official PHP documentation](http://www.php.net/manual/) for reference
If you're interested in up-to-date best practices, visit [PHP The Right Way](http://www.phptherightway.com/).
If you're coming from a language with good package management, check out [Composer](http://getcomposer.org/).
+
+For common standards, visit the PHP Framework Interoperability Group's [PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/python.html.markdown b/python.html.markdown
index 463556d9..59a0b85c 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -2,6 +2,7 @@
language: python
author: Louie Dinh
author_url: http://ldinh.ca
+filename: learnpython.py
---
Python was created by Guido Van Rossum in the early 90's. It is now one of the most popular
@@ -15,7 +16,7 @@ to Python 2.x. Look for another tour of Python 3 soon!
```python
# Single line comments start with a hash.
-""" Multiline strings can we written
+""" Multiline strings can be written
using three "'s, and are often used
as comments
"""
@@ -86,10 +87,26 @@ not False #=> True
# A newer way to format strings is the format method.
# This method is the preferred way
"{0} can be {1}".format("strings", "formatted")
+# You can use keywords if you don't want to count.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")
# None is an object
None #=> None
+# Don't use the equality `==` symbol to compare objects to None
+# Use `is` instead
+"etc" is None #=> False
+None is None #=> True
+
+# The 'is' operator tests for object identity. This isn't
+# very useful when dealing with primitive values, but is
+# very useful when dealing with objects.
+
+# None, 0, and empty strings/lists all evaluate to False.
+# All other values are True
+0 == False #=> True
+"" == False #=> True
+
####################################################
## 2. Variables and Collections
@@ -103,16 +120,12 @@ print "I'm Python. Nice to meet you!"
some_var = 5 # Convention is to use lower_case_with_underscores
some_var #=> 5
-# Accessing a previously unassigned variable is an exception
-try:
- some_other_var
-except NameError:
- print "Raises a name error"
+# Accessing a previously unassigned variable is an exception.
+# See Control Flow to learn more about exception handling.
+some_other_var # Raises a name error
# if can be used as an expression
-some_var = a if a > b else b
-# If a is greater than b, then a is assigned to some_var.
-# Otherwise b is assigned to some_var.
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
# Lists store sequences
li = []
@@ -135,10 +148,7 @@ li[0] #=> 1
li[-1] #=> 3
# Looking out of bounds is an IndexError
-try:
- li[4] # Raises an IndexError
-except IndexError:
- print "Raises 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.)
@@ -163,13 +173,11 @@ li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
# Examine the length with len
len(li) #=> 6
+
# Tuples are like lists but are immutable.
tup = (1, 2, 3)
tup[0] #=> 1
-try:
- tup[0] = 3 # Raises a TypeError
-except TypeError:
- print "Tuples cannot be mutated."
+tup[0] = 3 # Raises a TypeError
# You can do all those list thingies on tuples too
len(tup) #=> 3
@@ -177,7 +185,7 @@ tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
tup[:2] #=> (1, 2)
2 in tup #=> True
-# You can unpack tuples into variables
+# You can unpack tuples (or lists) 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
@@ -206,13 +214,12 @@ filled_dict.values() #=> [3, 2, 1]
"one" in filled_dict #=> True
1 in filled_dict #=> False
-# Trying to look up a non-existing key will raise a KeyError
-filled_dict["four"] #=> KeyError
+ # Looking up a non-existing key is a KeyError
+filled_dict["four"] # KeyError
# Use get method to avoid the KeyError
filled_dict.get("one") #=> 1
filled_dict.get("four") #=> None
-
# The get method supports a default argument when the value is missing
filled_dict.get("one", 4) #=> 1
filled_dict.get("four", 4) #=> 4
@@ -228,13 +235,13 @@ empty_set = set()
some_set = set([1,2,2,3,4]) # filled_set is now set([1, 2, 3, 4])
# Since Python 2.7, {} can be used to declare a set
-filled_set = {1 2 2 3 4} # => {1 2 3 4}
+filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
# Add more items to a set
filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5}
# Do set intersection with &
-other_set = set{3, 4, 5, 6}
+other_set = {3, 4, 5, 6}
filled_set & other_set #=> {3, 4, 5}
# Do set union with |
@@ -255,7 +262,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
# Let's just make a variable
some_var = 5
-# Here is an if statement. INDENTATION IS SIGNIFICANT IN PYTHON!
+# 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."
@@ -275,6 +282,18 @@ prints:
for animal in ["dog", "cat", "mouse"]:
# You can use % to interpolate formatted strings
print "%s is a mammal" % animal
+
+"""
+`range(number)` returns a list of numbers
+from zero to the given number
+prints:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print i
"""
While loops go until a condition is no longer met.
@@ -298,12 +317,6 @@ try:
except IndexError as e:
pass # Pass is just a no-op. Usually you would do recovery here.
-# Works for Python 2.7 and down:
-try:
- raise IndexError("This is an index error")
-except IndexError, e: # No "as", comma instead
- pass
-
####################################################
## 4. Functions
@@ -341,16 +354,17 @@ def all_the_args(*args, **kwargs):
print kwargs
"""
all_the_args(1, 2, a=3, b=4) prints:
- [1, 2]
+ (1, 2)
{"a": 3, "b": 4}
"""
-# You can also use * and ** when calling a function
+# When calling functions, you can do the opposite of varargs/kwargs!
+# Use * to expand tuples and use ** to expand kwargs.
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
-foo(*args) # equivalent to foo(1, 2, 3, 4)
-foo(**kwargs) # equivalent to foo(a=3, b=4)
-foo(*args, **kwargs) # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args) # equivalent to foo(1, 2, 3, 4)
+all_the_args(**kwargs) # equivalent to foo(a=3, b=4)
+all_the_args(*args, **kwargs) # equivalent to foo(1, 2, 3, 4, a=3, b=4)
# Python has first class functions
def create_adder(x):
@@ -420,9 +434,42 @@ j.get_species() #=> "H. neanderthalensis"
# Call the static method
Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Modules
+####################################################
+
+# You can import modules
+import math
+print math.sqrt(16) #=> 4
+
+# You can get specific functions from a module
+from math import ceil, floor
+print ceil(3.7) #=> 4.0
+print floor(3.7) #=> 3.0
+
+# You can import all functions from a module.
+# Warning: this is not recommended
+from math import *
+
+# You can shorten module names
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Python modules are just ordinary python files. You
+# can write your own, and import them. The name of the
+# module is the same as the name of the file.
+
+
```
## Further Reading
-Still up for more? Try [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+Still up for more? Try:
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
diff --git a/r.html.markdown b/r.html.markdown
index e19eaeb8..2cf63288 100644
--- a/r.html.markdown
+++ b/r.html.markdown
@@ -2,21 +2,23 @@
language: R
author: e99n09
author_url: http://github.com/e99n09
-
+filename: learnr.r
---
R is a statistical computing language. It has lots of good built-in functions for uploading and cleaning data sets, running common statistical tests, and making graphs. You can also easily compile it within a LaTeX document.
-```r
+```python
# Comments start with hashtags.
# You can't make a multi-line comment per se,
# but you can stack multiple comments like so.
-###################################################################################
+# Hit COMMAND-ENTER to execute a line
+
+#########################
# The absolute basics
-###################################################################################
+#########################
# NUMBERS
@@ -122,9 +124,9 @@ myFunc <- function(x) {
# Called like any other R function:
myFunc(5) # => [1] 19
-###################################################################################
+#########################
# Fun with data: vectors, matrices, data frames, and arrays
-###################################################################################
+#########################
# ONE-DIMENSIONAL
@@ -133,7 +135,7 @@ vec <- c(8, 9, 10, 11)
vec # => [1] 8 9 10 11
# The class of a vector is the class of its components
class(vec) # => [1] "numeric"
-# If you vectorize items of different classes, weird coersions happen
+# If you vectorize items of different classes, weird coercions happen
c(TRUE, 4) # => [1] 1 4
c("dog", TRUE, 4) # => [1] "dog" "TRUE" "4"
@@ -258,7 +260,7 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
# LISTS (MULTI-DIMENSIONAL, POSSIBLY RAGGED, OF DIFFERENT TYPES)
# Finally, R has lists (of vectors)
-list1 <- list(time = 1:40, price = c(rnorm(40,.5*list1$time,4))) # generate random
+list1 <- list(time = 1:40, price = c(rnorm(40,.5*list1$time,4))) # random
list1
# You can get items in the list like so
@@ -266,9 +268,9 @@ list1$time
# You can subset list items like vectors
list1$price[4]
-###################################################################################
+#########################
# The apply() family of functions
-###################################################################################
+#########################
# Remember mat?
mat
@@ -289,15 +291,17 @@ apply(mat, MAR = 2, myFunc)
# [3,] 11 23
# Other functions: ?lapply, ?sapply
+# Don't feel too intimidated; everyone agrees they are rather confusing
+
# The plyr package aims to replace (and improve upon!) the *apply() family.
install.packages("plyr")
require(plyr)
?plyr
-###################################################################################
+#########################
# Loading data
-###################################################################################
+#########################
# "pets.csv" is a file on the internet
pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv")
@@ -306,14 +310,14 @@ head(pets, 2) # first two rows
tail(pets, 1) # last row
# To save a data frame or matrix as a .csv file
-write.csv(pets, "pets2.csv") # to make a new .csv file in the working directory
+write.csv(pets, "pets2.csv") # to make a new .csv file
# set working directory with setwd(), look it up with getwd()
# Try ?read.csv and ?write.csv for more information
-###################################################################################
-# Plots and tests
-###################################################################################
+#########################
+# Plots
+#########################
# Scatterplots!
plot(list1$time, list1$price, main = "fake data")