diff --git a/3 - Functional Programming/1.3 - Functions.tex b/3 - Functional Programming/1.3 - Functions.tex index db1bb3a..a129456 100644 --- a/3 - Functional Programming/1.3 - Functions.tex +++ b/3 - Functional Programming/1.3 - Functions.tex @@ -6,9 +6,9 @@ Because I said so. A Function allows use to assign a block of code to a name which allows us to eaily repeat the execution of that code without having to retype the code. -Consider the code. +Let us take a look at a quick example. -\begin{lstlisting}[caption={Function Candidate Example}] +\begin{lstlisting}[caption={Simply Function Example}] def PrintHello(): print ``Hello'' @@ -27,9 +27,212 @@ As you can see we are declaring a Function called \pigVar{PrintHello} with the c As may have noticed when the code gets to the declaration of the Function it does not execute the code block, instead it saves the code block for execution later when the Function name is called. To call the function we use the Function name followed by opening and closing parentheses, \pigVar{PrintHello()}. +\par -\subsection{Returns} +Be careful, some languages require that Function definitions occur before they are used, while others are more lenient. + +\subsection{Scope} +Before getting much further it is important to talk about Scope. +Scope refers to the portions of a programs where variables are accessible. +So far all of the variables we have been using in past examples belong to the same Scope. +\par + +To best explain variable Scope lets look at some examples that explain how Scope works. + +\begin{lstlisting}[caption={Scope Example 1}] +num = 5 + +if num == 5: + print num +\end{lstlisting} + +Because we are declaring \pigVar{num} outside of the If statement then that means we can have access to that variable from +within the If statement because they belong to the same Scope. + +\begin{lstlisting}[caption={Scope Example 2}] +num = 5 + +if num == 5: + another = num + 5 + +print another +\end{lstlisting} + +This program will not run properly, because we are declaring \pigVar{another} from within the Scope of the If statement +then it is not accessible outside of the If statement. +This also goes for any other Conditional or Loop statement (While,For,If-Else,Do-While,Switch,etc). +When it comes to Conditional and Loop statements the best way to think about it is that variables can go down into +code blocks but cannot come back out. +\par + +\begin{lstlisting}[caption={Scope Example 3}] +name = ``Brett'' + +def PrintHello(): + print ``Hello `` + name + +PrintHello() +\end{lstlisting} + +This program will not run properly, unlike Conditional and Loop statements, variables cannot go into the Scope of Functions. +As well, they cannot leave the Scope of Functions either, so any variables declared inside of the Function are stuck there. +\par + +Please remember, as with every other section, please refer to your languages specific rules regarding Scope as some languages break +this ``normal'' paradigm. +Scope in Javascript is odd to new comers. \subsection{Parameters} +We can use parameters to pass variables from outside the Scope of the Function into the Scope of the Function. +Lets rewrite the example (Scope Example 3) from above but this time taking into account variable Scope and using Parameters. + +\begin{lstlisting}[caption={PrintHello Parameter Example}] +def PrintHello( name ): + print ``Hello `` + name + +MyName = ``Brett'' + +PrintHello( MyName ) +\end{lstlisting} + +The output of this program will be \pigOut{Hello Brett}. +By adding the \pigVar{name} Parameter to the \pigVar{PrintHello} Function definition we are able to then pass in the +variable \pigVar{MyName} from outside of the Function Scope into the Function Scope. +\par + +To define Parameters of a Function, you simple give a list of Parameter names between the two parenthesis separated by commas. +When you define a Parameter for a Function you are requiring whoever uses that Function in the future of the program that they +must supply that many Parameters. +Let us take a look at an example Function that uses multiple Parameters. + +\begin{lstlisting}[caption={Multiple Parameters Example}] +def Sum( x, y ): + sum = x + y + print ``The Sum Is: `` + sum + +Sum( 5, 6 ) +Sum( 12 ) +\end{lstlisting} + +We are simply defining a Function that is used to sum the values of two numbers together and then printing \pigOut{The Sum Is:} followed by +the sum of the numbers. +By defining two Parameters \pigVar{x} and \pigVar{y} we are telling any users of the Function that they must supply two values into the Function. +The first example usage of \pigVar{Sum}, \pigVar{Sum( 5, 6 )} correctly calls the Function and will cause the program to output \pigOut{The Sum Is: 11}. +The Second example \pigVar{Sum( 12 )} will cause the program to fail because only one Parameter is given when two were defined. +\par + +When a Function is called and Parameters are given, the values passed into the Function are assigned to variables, inside of the Functions Scope, with the +same name given in the Function definition. +In our example above the value \pigVal{5} is passed into the Function and assigned to the variable \pigVar{x} because both are the first value and first +Parameter. +\pigVal{6} is then assigned to \pigVar{y}. + +\subsection{Returns} +We have just seen how we can use Parameters to pass values into Functions, but what if we want to pass values back out of Functions? +We would use a Return statement. +When using a Return statement you use \pigVar{return} followed by the values or variable you wish to return out of the Function. + +\begin{lstlisting}[caption={Return Example}] +def Sum( x, y ) + sum = x + y + return sum + +MySum = Sum( 5, 6 ) +print ``The Sum Is: `` + MySum +\end{lstlisting} + +This program will output \pigOut{The Sum Is: 11}. +The Function is the same as before but this time we are using \pigVar{return} to push the value assigned to \pigVar{sum} back out of the Function. +We can then assigned the output of the Function \pigVar{Sum} to a variable \pigVar{MySum} which will be equal to whatever the value that is returned is, +in this case \pigVal{11}. +When using Return statements in Functions you can then think about using Functions in the same way as you would a raw value (like a number). +\par + +When the Return statement is reached the Function stops executing and the value of the Return statement is returned. +So we can use Return statements similar in fashion to how Break statements are used to quickly stop the execution of a Function. + +\begin{lstlisting}[caption={Return to Stop Function}] +def PrintHello( name ): + if name == ``Brett'': + return + print ``Hello `` + name + +PrintHello( ``Brett'' ) +PrintHello( ``James'' ) +\end{lstlisting} + +This example program will only output \pigOut{Hello James}, because when the value \pigVal{Brett} is passed into the Function +the If statement evaluates to \pigVal{True} and the Return statement causes the Function to exit and the \pigVar{print} statement is +never reached. +\par + +A Function can also contain multiple Return statements. + +\begin{lstlisting}[caption={Multiple Return Statements}] +def SayHello( time ): + if time < 12: + return ``Good Morning'' + else: + return ``Good Afternoon'' + +print SayHello( 10 ) +print SayHello( 3 ) +\end{lstlisting} + +The output of this program will be \pigOut{Good Morning} followed by \pigOut{Good Afternoon}. +If the value passed into \pigVar{time} is less than \pigVal{12} then \pigVal{Good Morning} is returned, otherwise \pigVal{Good Afternoon} +is returned. +\par + +Side Note: I do have to mention, some people will argue with the example above and say Functions should only have a single Return statement. +For those that agree or who wish to follow this mentality I have provided the example below to show the same example above with a single Return +statement. + +\begin{lstlisting}[caption={Single Return Statement}] +def SayHello( time ): + ReturnString = null + if time < 12: + ReturnString = ``Good Morning'' + else: + ReturnString = ``Good Afternoon'' + return ReturnString + +print SayHello( 10 ) +print SayHello( 3 ) +\end{lstlisting} + +This example will output the exact same as above but it only uses a single Return statement. \subsection{Recursion} +Recursion, now this section is going to be FUN! +Please take your time reading through this chapter as it is very easy to get confused by Recursive Functions and can be difficult to wrap +your head around the first time through (I know I had issues when I first learned it). +Basically what it means for a Function to be recursive is when it makes a call to itself from within it's own code block. +The example we are going to be using is a recursive Function used calculate the factorial of a number. +The factorial of the number 6, denoted 6!, is 6 x 5 x 4 x 3 x 2 x 1 = 720. +Lets look at how this would look as a recursive Function. + +\begin{lstlisting}[caption={Recursive Factorial}] +def Factorial( num ): + if num < 1: + return 1 + else: + return num * Factorial( num - 1 ) + +print ``6! = `` + Factorial( 6 ) +\end{lstlisting} + +There are a few parts of a Recursive Function that we need to mention before diving deeping. +First off we have the actual Recursive call which is when the Function calls it's, in this Function it is +the code \pigVar{Factorial ( num - 1 )}. +Secondly, and probably the most important part, is the Base Case:\\ +\pigVar{if num < 1: + return 1}\\ +The base case tells the Function when to stop calling itself recursively, otherwise the Function will call itself +infinitely and cause an infinite loop and could crash the program. +\par + +It might not be clear to some exactly how this Function is working, how is it getting the right value back out into +the program? +Well, lets do what we can to break down the Function call \pigVar{Factorial( 6 )} down to see exactly how the program +interprets this Function. diff --git a/4 - Object Oriented Programming/1.1 - Classes and Objects.tex b/4 - Object Oriented Programming/1.1 - Classes and Objects.tex index 87968f3..ed71036 100644 --- a/4 - Object Oriented Programming/1.1 - Classes and Objects.tex +++ b/4 - Object Oriented Programming/1.1 - Classes and Objects.tex @@ -117,6 +117,11 @@ p.printName() \end{lstlisting} The output of this code would be \pigOut{brett}. +You access methods the same way as your would class properties except you include the parenthesis. +You may also notice a reference to a variable \pigVar{this} in the method definition. +This special variable is used within methods to refer to the object that the method belongs to. +So using \pigVar{this} within the method \pigVar{printName} is similar to using the variable \pigVar{p} to access +the specific instance that that method belongs to. \subsection{Special Methods} diff --git a/6 - Data Structures/1.1 - Linked Lists.tex b/6 - Data Structures/1.1 - Big O Notation.tex similarity index 100% rename from 6 - Data Structures/1.1 - Linked Lists.tex rename to 6 - Data Structures/1.1 - Big O Notation.tex diff --git a/6 - Data Structures/1.2 - Doubly Linked Lists.tex b/6 - Data Structures/1.2 - Linked Lists.tex similarity index 100% rename from 6 - Data Structures/1.2 - Doubly Linked Lists.tex rename to 6 - Data Structures/1.2 - Linked Lists.tex diff --git a/6 - Data Structures/1.3 - Stacks.tex b/6 - Data Structures/1.3 - Doubly Linked Lists.tex similarity index 100% rename from 6 - Data Structures/1.3 - Stacks.tex rename to 6 - Data Structures/1.3 - Doubly Linked Lists.tex diff --git a/6 - Data Structures/1.4 - Queues.tex b/6 - Data Structures/1.4 - Stacks.tex similarity index 100% rename from 6 - Data Structures/1.4 - Queues.tex rename to 6 - Data Structures/1.4 - Stacks.tex diff --git a/6 - Data Structures/1.5 - Hash Maps.tex b/6 - Data Structures/1.5 - Queues.tex similarity index 100% rename from 6 - Data Structures/1.5 - Hash Maps.tex rename to 6 - Data Structures/1.5 - Queues.tex diff --git a/6 - Data Structures/1.6 - Binary Trees.tex b/6 - Data Structures/1.6 - Hash Maps.tex similarity index 100% rename from 6 - Data Structures/1.6 - Binary Trees.tex rename to 6 - Data Structures/1.6 - Hash Maps.tex diff --git a/6 - Data Structures/1.7 - B-Trees.tex b/6 - Data Structures/1.7 - Binary Trees.tex similarity index 100% rename from 6 - Data Structures/1.7 - B-Trees.tex rename to 6 - Data Structures/1.7 - Binary Trees.tex diff --git a/6 - Data Structures/1.8 - B+ Trees.tex b/6 - Data Structures/1.8 - B-Trees.tex similarity index 100% rename from 6 - Data Structures/1.8 - B+ Trees.tex rename to 6 - Data Structures/1.8 - B-Trees.tex diff --git a/6 - Data Structures/1.9 - B+ Trees.tex b/6 - Data Structures/1.9 - B+ Trees.tex new file mode 100644 index 0000000..e69de29 diff --git a/Programming In General.pdf b/Programming In General.pdf index 87fc553..6073f35 100644 Binary files a/Programming In General.pdf and b/Programming In General.pdf differ diff --git a/Programming In General.tex b/Programming In General.tex index 11a2f6a..eb73162 100644 --- a/Programming In General.tex +++ b/Programming In General.tex @@ -203,36 +203,40 @@ To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/ \input{"./6 - Data Structures/Data Structures"} \vfill \pagebreak +\section{Big O Notation} +\input{"./6 - Data Structures/1.1 - Big O Notation"} +\vfill +\pagebreak \section{Linked Lists} -\input{"./6 - Data Structures/1.1 - Linked Lists"} +\input{"./6 - Data Structures/1.2 - Linked Lists"} \vfill \pagebreak \section{Doubly Linked Lists} -\input{"./6 - Data Structures/1.2 - Doubly Linked Lists"} +\input{"./6 - Data Structures/1.3 - Doubly Linked Lists"} \vfill \pagebreak \section{Stacks} -\input{"./6 - Data Structures/1.3 - Stacks"} +\input{"./6 - Data Structures/1.4 - Stacks"} \vfill \pagebreak \section{Queues} -\input{"./6 - Data Structures/1.4 - Queues"} +\input{"./6 - Data Structures/1.5 - Queues"} \vfill \pagebreak \section{Hash Maps} -\input{"./6 - Data Structures/1.5 - Hash Maps"} +\input{"./6 - Data Structures/1.6 - Hash Maps"} \vfill \pagebreak \section{Binary Trees} -\input{"./6 - Data Structures/1.6 - Binary Trees"} +\input{"./6 - Data Structures/1.7 - Binary Trees"} \vfill \pagebreak \section{B-Trees} -\input{"./6 - Data Structures/1.7 - B-Trees"} +\input{"./6 - Data Structures/1.8 - B-Trees"} \vfill \pagebreak \section{B+ Trees} -\input{"./6 - Data Structures/1.8 - B+ Trees"} +\input{"./6 - Data Structures/1.9 - B+ Trees"} \vfill \pagebreak \chapter{Algorithms}