Chapter 3 notes:
+Functions
>Functions are like mini programs, and you can make your own.
>>Create one by DEF [FUNCTION NAME]() then indent under it.
>Copying straight code to use elsewhere, then any changes you make will have to be repeated for each copy.
>>The custom function feature allows you to change the code at one part and have it be reflected everywhere, since the function is called instead of static code.
>Deduplication is the term for consolidating code to make it look nicer. In other words, getting rid of duplicated/copy-pasted code.
>A parameter is a variable that a function calls. But this means that the parameter is bound to the call, not the function. So if you try to reuse the same parameter, you’re gonna have a bad time.
>>Exa: If you call Alice and Bob for the name variable, you'll get an error if you try again, since name isn’t bound to anything.
>Return Value is the value that a function call evaluates to.
>RETURN statement is useful for DEF because it’ll give a static answer. See Magic8Ball.py for more.
+None value
>Represents absence of a value(duh)
>Only value of the NoneType data type.
>>Other languages call this things like null, nil, undefined
>Must be type with a capital N
>Print() basically always contains the None value, because it doesn't need to return anything. Since Print(), like all functions, needs to return a value, the value-that-isn't-a-value None works just fine.
>>Also why WHILE and FOR loops implicitly end with CONTINUE statements.
>>RETURN statement without a value gives NONE
+Keyword Arguments and Print()
>Position is Paramount in function calls. Random.randint(1, 10) will pick a number between 1-10, but random.randint(10, 1) gives an error.
>So what about keyword arguments?
>>Defined by keyword before then in function calls.
>>Mostly used for optional stuff
>>>Exa: print() can have END or SEP
>>>>END for end of argument, SEP for between arguments to separate them.
>>>>>END makes the space after a line go away. So two lines of print() would have them on two lines when running, but having end='’ be the end of the first print contents, the second line is immediately placed there. Hello World on two lines is then HelloWorld.
>>>>Normally you have spaces between each argument of print()…
>>>>>Exa: Print('cats', 'dogs') would be “cats dogs”
>>>>But if you put SEP after the end…
>>>>>Print('cats', 'dogs', sep=',')  you get “cats,dogs”
#Would print('cats', 'dogs', sep=', ') give “cats, dogs”? Must check at home.
##Yep.
+Local and Global Scope
>Parameters/variables assigned within a function are LOCAL SCOPES. Assigned outside of a function? GLOBAL SCOPE. LOCAL VARIABLE and GLOBAL VARIABLE, same. Variable can’t be both at same time.
>>But there can be, say, two things assigned to the Spam variable; as long as they’re global and local varients.
>SCOPE is a container for variables. When it’s destroyed, the values are forgotten. This also applies to when the program shuts down.
#Does this explain why None==spam is true up there?
>Whenever a function is called, a global scope is created, so any variables made only exist in the function.
>Properties of scope:
>>Code in global(not a function) cannot use local(a function's scope
>>Opposite is true for local scope; can access global variables
>>Local scopes can’t share variables with each other
>>Same name for variables in different scopes, see above.
>Python does just have everything be a global variables so when code modifies a variable it only affects that instance; the only interaction with the larger program as a whole is the parameters/output. Makes troubleshooting a lot easier when it’s just a few lines of code giving difficulties instead of trying to parse what global variable is causing the trouble.
>>For this reason, generally a bad idea to rely on global variables if you have a large program.
+Local scopes can't use variables in other local scopes
>Refer to spam99.py for this bit
>>Defines things then runs the last bit of code. However, eggs still ultimately prints as 99 instead of 0 because the eggs variable in the def spam() is separate from the one in def bacon(). And although bacon() is called after eggs is set to 99 in spam(), spam()'s egg variable is still the same as it was, since Bacon's Egg variable was destroyed when it finished, just like how spam()'s egg variable is destroyed when that's finished.
#However, putting print(eggs) in an extra line under where it was defined as 0 ultimately outputs 0, then 99 on a new line.
+Global variables used by local scopes
>Example sets up a global variable without defining a local one, so program automatically uses the global variable
+Conflicting global and local variable names and how to sort them
>Book recommends avoiding this if possible…but if you really want to…
>Refer to sameName.py for this bit
>>Three variables all named eggs
>>>When spam () is called it creates eggs locally
>>>Bacon() makes another local one
>>>Egg='global' on it’s own makes a global one
#This program kind of works in reverse. Things are first defined, but not called. The executor of this program is the final lines of code, which calls bacon()(the previous block of code above), which in turn calls spam()(the first lines of code).
##Is all code like this, defining things and then executing them after? These notes, for example, are the reverse, where things are “executed” and then defined.
#What I don’t get is why def bacon() is indented and def spam() isn’t. Does that even matter? Check when at home.
+The Global Statement
>You can modify global variables with a global statement. Putting the global statement(exa: global eggs) makes the same variable indicate it’s the global one, so changing ‘eggs’ would change the global ‘eggs’ instead of making a local ‘eggs'.
>>See sameName2.py
>Ways to tell if a variable is local or global:
>>If it’s being used globally(outside functions) then global, a GLOBAL statement for that variable is present then global, variable is used in assignment statement in a function then local, and if the variable isn’t used in an assignment statement, then global.
>>>See sameName3.py for more info.
>local and global variables named the same are mutually exclusive within functions; you can’t use a local one and then a global one within the same function, and vice versa.
>See sameName4.py for this bit
>>Uhhhhhh why doesn’t it pull the global variable for eggs here and instead gives an error? I thought that isn’t what’s supposed to happen, as per above.
>>>Seems to be because Python recognizes that there’s a call for a local ‘eggs’ but it doesn’t have local eggs set to anything yet. So it tries to pull the local variable and gets an error. Swapping the eggs assignment and print fixes this issue, but, as expected, pulls the local variable and not the global one.
>”Black box” tangent
>>All you really need to know about functions are the inputs and the outputs. Apparently this is how most programming is done. And, judging by how the random import was done earlier…yeah. In addition, the self-sufficient nature of local variables almost ensures that the function won’t even mess up globals.
>Error/exception handling
>>Normally if you get an error(otherwise known as an exception), your program quits out. To avoid that…
>>See zeroDivide.py for more info.
>>>ZeroDivisionError is…exactly that.
>>>You can prevent errors from crashing your program with a TRY clause, paired with an EXCEPT clause. TRY is for potential trouble code, and if an error happens, it skips to the EXCEPT clause to see what to do.
>>>You can put TRY/EXCEPT clauses anywhere, where it’ll be caught within a function or without, with all the attributes that entails. Of note here is that when used within a function, the function can still be used later if it crashed, while outside of a function, like the print() example, it will move on to the next line after the EXCEPT clause, skipping everything else. Presumably it does the same with the function too, but it doesn’t really matter since the function is repeated every line.
+Guessing Game Program
>Ahhhh so many lines! ;_;
>See guessTheNumber.py for more info
>Program is pretty self explanatory and doesn’t show anything new, just synthesizes it all.
>>You definitely couldn’t have made this on your own without way too many iterations.
>>This does show, however, that ranges can be used to count user input. Here, it limits guesses to 6 times to guess the right number, and does a double BREAK(instead of BREAK to IF) if the number isn’t guessed in 6 times.
>Interesting note here that friend brought up: FOR loops are for loops that you know have a limited number of loops, while WHILE loops are for an unknown quantity(ongoing, I guess?)
End chapter 3 notes