Pythonfunctions on Janusworx

A Hundred Days of Code, Day 015 - Python, Advanced Functions, Done!

feedback@janusworx.com (Mario Jason Braganza) — Fri, 24 Jul 2020 11:32:03 +0530

Delving deeper into Python functions and learning more about them, using Reuven Lerner’s Advanced Python Functions Course

Notes
#

The co_* series of attributes inside the __code__ attribute inside most functions gives a wealth of information about a function.
- For example, looking up the argcount attribute for some function hello, with hello.__code__.co_argcount will give us the number of arguments hello takes.
- And doing a hello.__code__.co_varnames will give us a tuple of all the local variables in a function
- hello.__code__.co_code contains the compiled bytecode for the function.
  - Importing the disassembler import dis and running it on the bytecode, dis.dis(hello) will show us what’s in there.
- hello.__code__.co_flags keeps a track of whether the function has * arguments or not via a binary switch. (It holds many parameters, one of which is the on/off switch for *args)
  - if said switch is set, the function checks for such arguments at runtime and turns them into a tuple to process.
  - they are set for *args via the hello.__code__co_argcount switch (0/1) and for keyword arguments with the hello.__code__.co_kwonlyargcount switch.
the __defaults__ attribute keeps all the functions default variable values. If I don’t supply a value to some parameter, the function will look in here, to see if a default value exists. hello.__defaults__ could hold a last name default, for example, if I want my hello function to work even if no last name was supplied, and it actually expected a full name.
- do not use mutable defaults. an empty list or dictionary for example.
- set the default to None first in such case and then create the list when the function runs at runtime.
The last thing I learnt about were nested functions.
- I can nest them two/three/as many levels deep as I wish. Practically, most folks do two or three.
- When an inner function takes the variables of its enclosure and does something with it and returns stuff…? those kinds of functions are called closures.

Learning / Feedback/ Experiences from doing exercises
#

The course so far is Reuven making simple functions and then breaking them down and explaining functionality in painstaking detail.
Reuven is an awesome teacher! I would gush about him every post, but then it would get too much 😂. So once per course is good
I kept looking at the disassembled code and wondering, what language it was. I still don’t know. My ‘educated’ guess is that it is a level of standard pseudo-assembly code for some phantom standardised processor. Once I had that mental model in mind though, all of it started making a lot more sense. This brought memories of Z80 assembly, I learnt in the mid 90s
This was fun to do! Onwards to Advanced Objects!

Read all about my Python Functions journey here

A Hundred Days of Code, Day 010 - Python Functions, Basics Done!

feedback@janusworx.com (Mario Jason Braganza) — Fri, 17 Jul 2020 19:36:18 +0530

Today was hard!

Notes
#

‘*args’

way to get multiple arguments without having to assign placeholders for them
it scoops up all the arguments and gives it to the function in a tuple. I could then loop over it with for.
I just put * in front of one of my placholders et voilà, def example_func(*catch_everything)
I can define placeholders to catch specific arguments, but those need to be before my ‘*args’.
Edge Case: I could have my arguments in a list/tuple already. I can just add the structure with a * in front of it and Python will unpack it for me. If I have a list, catch_me_if_you_can=[1,2,4] then I can pass the elements individually, as arguments with a def example_func(*[catch_me_if_you_can])
Another kinda frequent edge case: ‘*args’ catches everything that is unassigned. so if i have something with a default value, it will get trampled by the data from my args. Best thing to do is to set the default after the ‘*args’ like so, example_func(a, *args, b=10)

Keyword Arguments

Normally in the form of name = value
Kinda like addressing lists vs dictionaries. Where instead of an index, I can now call an argument with a name.
So I can go def name(FirstName='', LastName='') and then put in stuff in whatever order I want to like name(LastName='Brontë', FirstName='Emily'. Pretty handy!
Try not to mix and match positional and keyword arguments. Python looks for positional arguments first, then keyword arguments. So if you have them, then the positional arguments have to come first!

‘**kwargs’

these scoop up keywords arguments into a dictionary. I can do everything with this, just like any other dictionary
I just put * in front of one of my placholders et voilà encore, def example_func(**catch_everything)

Combining Arguments

Arguments in decreasing order. Stick to the order as far as possible.
- mandatory parameters (no defaults)
- optional parameters (with defaults)
- *args
- **kwargs (with and without defaults)
Use them for different kinds of input

Variable scopes

Just because I have indentation, with an if or an else or a for, does not mean that I change a variable’s scope. Variables within those indented blocks could still be global, or the scope of the thing above
The slight exception is the variable within comprehensions. Variables inside them, have their own private scope
The scope changes, mainly, when we define functions. Generally …
- If I am in a function, I’m in a local scope
- If I am out of it, I’m in a global scope
- with some exceptions
So always think, am I in a function body … or not? (excepting comprehensions)
When Python looks for variable values it looks in the LEGB sequence. (left to right).
- Local (starts here if I’m in a function)
- Enclosing
- Global (starts here if I’m not in a function, rather in the main body of the program)
- Built-in
The globals function will have all the global variables for the program. It’s a dict with variable names as keys and the variable assignments as values
The locals function will have all the local variables for a function in the program, when it runs. It’s also a dict with variable names as keys and the variable assignments as values or I could also look at the function_name.code.co_varnames to peek at the local stuff
- Parameters to a function are also local variables.
- I should define my local variables, before I use them in a function, or I get an UnboundLocalError
- If I want to use and modify a global variable in a function, I should declare it at the beginning of my function. For example, if I have a global variable x, and I want to use it in a function, then I say global x in the beginning of the function.
- I can mutate elements of global variable, if they are mutable structures. As in, I cannot change list A to another set of entries, but I can append to list A, or delete items from list A. As long as you are not assigning to a variable, rather using object methods, you should be ok.
The built-ins scope, houses many things that are needed by Python, but are not reserved keywords. Stuff like list. I can use it to create lists, but it’s not reserved. I can redefine it if I want to (or more commonly redefine it by mistake)
- This feels like one of the few places, Python allows me to shoot myself in the foot.
- Do a dir(__builtins__) and review the names every now and then, and don’t use them in your code.

Kinda Advanced Stuff

While I said, they were verbs, functions can alse be nouns. I can just pass them as objects to other functions or elsewhere.
I can pass a function as an argument as in the case of sorted(someIterableofPositiveNegativeNumbers, key=abs) where I am passing the abs function as a keyword to the sorted function, which then uses abs to get the absolute values of the numbers first and then sorts them according to those values.
I can collect arguments for the inner functions I call with *args and **kwargs and then pass to them again with *args and **kwargs.
I can also take some data as an argument along with a function and apply that function to that data. Like I did above. The main function I create acts like some glue program. This process of applying function to data, is called mapping and the functions I create to do this are map functions. Python has a built in map function.
I can create functions, plop them into a dictionary and then call them as needed in my actual function, by accessing the dictionary keys and supplying arguements. This approach is called a dispatch table

Learning / Feedback/ Experiences from doing exercises
#

Getting used to the way, Python behaves. And beginning to love its consistency for the most part.
I write slow, step by step code. while it works, Reuven’s solutions are short and make me go, oh why did I not think of that? Maybe optimised thinking will come with time?
I have to use Python tutor a lot to get what is actually happening.
I’ve learnt to just dive in blind when begining to write programs. The more I think about stuff, the more I feel, like I can’t do this. So I just start. And build it line by line, error by error. And more often than not, it solves it self. Optimised solutions present themselves after I have the rough and ready solution done. “Aah! I could’ve written it this way”
And I am done with the introduction to functions! Hurrah! This course stretched me a bit, and showed me I still have a ways to go.

Read all about my Python functions journey here

A Hundred Days of Code, Day 009 - Python Functions, Basics

feedback@janusworx.com (Mario Jason Braganza) — Thu, 16 Jul 2020 16:12:47 +0530

Started up with learning about Python function basics, today. Notes follow. Using the Lerner pool of wisdom, as usual.

Why do we need functions?

DRY (Don’t Repeat Yourself), because we can take stuff that is repeatable, assign it a nickname and just call that nickname over and over, instead of tediously writing all that stuff over and over and over
If want to modify something, I can just call it (by the nickname) and then add my little spice to it. Like I have the recipe to an omlette written down somewhere, I can then just add a little note with secret ingredients at the bottom of that recipe to create a better or a different omlette.

Functions are objects.

We can think of them as verbs

Parentheses in Python (at the end of functions) basically mean, I want to execute, this here thing, on the left

I can run help on a function to get some information about it.
help(str.upper)

We don’t tack parentheses on the function, when I am lookif for its help, because I don’t want to run the darned thing.

Creating/Defining a function

We define a function using the def keyword. It’s followed by the name you want to call it by, followed by parantheses terminated by a colon
- def hello():
- This is actually a two step thing, even though I’ve always thought of it as one.
  - first, I create a function object.
  - then, I assign it a name.
- Functions in Python (unlike other languages), have the same name space as the rest of our Python program. I cannot have a function called x and also a variable called x

Returning results

Similar to math functions, even Python functions return values after running them
The default is None, unless you actually, explicity tell the function to return something
If you want to catch the results of what you are doing with the function, remember to return it.
A function can return whatever you want. statements, values, other functions etc.
Which is good and all, but remember to do this with intent. I ought to think about what I want to return and document it well
If I am returning multiple values of varying types, it comes back as a tuple. Not as different objects. I need to unpack them and assign them to multiple values explicity

Documenting Functions

The help function needs something to read and tell the user about what our functions do. Ergo …
Use docstrings (Documentation Strings) to do it.
- What are docstrings? If the first line in a function is a string, then that string is seen by the help system as a docstring and used for documentation.
- Use triple quotes around the string. I can have multiple lines in there
- The convention is to document what a function receives (the input), what it returns (the output) and what it modifies.

 def hello():
		"""This is it! The docstring! This will help me figure out what the hello function does!
		or more seriously
		expects: No arguments
		modifies: Nothing
		returns: A friendly greeting
		"""
		return 'Hello, hello :)

**Arguments**

Functions need stuff to work with.
We supply them using arguments.
Just a fancy name for the data we pass along to the function.
E.g. If a function returns a fancy format of our name, there must be some mechanism to pass our name across to the function. Arguments are how we do it. We don’t actually argue with the programe :P

A function can take any number of arguments. We just put them between the parentheses, seperated by commas

Positional Arguments
```
def hello(first, second):
 print(f'Hello, {first} and {last}')
```
- In the code above, I can call the function with hello('Tyche','Hestia') and it will assign Tyche to first and Hestia to second, because I typed them in that order.
- These are called positional arguments
- When I define a number of arguments, I need to pass all the arguments along. I can’t make space for two and pass only one or none.
- I can supply defaults, so that if the user does not supply all the arguments, the default is used in its place
- If some arguments cannot have defaults and are a must, they must come before the ones that are optional and can have defaults.
- How does Python know, how many to expect?
  - When Python defines the function, it records the definition and makes a note of what it needs to run the function properly
    - If I look at the guts of the hello function with a hello.__code__.co_argcount it’ll tell me, it has recorded two.
    - If I supply defaults, they are recorded in a seperate place called hello.__defaults__ and it supplies the requisite information, so the argcount always stays at the required number of arguments

A little dazed today, so calling it quits early.

Learning / Feedback/ Experiences from doing exercises
#

I keep looking for elegant, one statement like solution to problems and get frustrated. Reuven then shows up with a brutally efficient solution that has four if statements. I should remember to be more workmanlike, before I turn craftsman

Read all about my Python functions journey here

Pythonfunctions on Janusworx

A Hundred Days of Code, Day 015 - Python, Advanced Functions, Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 010 - Python Functions, Basics Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 009 - Python Functions, Basics

Learning / Feedback/ Experiences from doing exercises #

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Learning / Feedback/ Experiences from doing exercises
#