# argmax, argmin argsort and quick sort | 快速排序

This Saturday class we went over indexing and ordering a group of items by their sorted indices. For those who are more advanced, please go over the section on quick sort.

For example,

>> import numpy as np
>>> packpack =np.array([‘snack’,’book’,’pen’,’eraser’,’apple’])
# Position of the biggest word (alphabetically)
`>>> np.argmax(packpack)`

[out]: 0
# Position of the smallest word (alphabetically)
`>>> np.argmin(packpack)`

[out]: 4

# Position of the words if we are to sort them alphabetically
`>>> np.argsort(packpack)`

[out]: array([4, 1, 3, 2, 0], dtype=int64)

Now let us sort them:
`>>> packpack[np.argsort(packpack)]`

[out]: array([‘apple’, ‘book’, ‘eraser’, ‘pen’, ‘snack’], dtype='<U6′)

Then we tried sorting numbers:

numbers = np.array([2,3,5,7,1,4,6,15,5,2,7,9,10,15,9,17,12])
`>>> numbers[np.argsort(numbers)]`

[out]: array([ 1, 2, 2, 3, 4, 5, 5, 6, 7, 7, 9, 9, 10, 12, 15, 15, 17])

Finally we dig deeper: how do you really sort things fast systematically? Using quick sort!

# Learning Swift | 学习Swift

This weekend we started our first lesson on Swift. Swift is the language used by Apple across its products.

The class first tried using XCode, which is Apple’s IDE for Swift. But not every child is familiar with the Mac. So we switched to a learn Swift phone app, which worked well. But the class really love Swift Playground.  It is like Scratch to them.  The difference is that: we are going to make an app in two months using Swift.

The kids enjoyed programming a lot!  They didn’t want to stop.

The only minor issue is that it only works on iPads.

# Ipython Shell Keyboard shortcuts 键盘快捷键 （Kuàijié jiàn)

In this past weekend’s coding class we practice keyboard ⌨ shortcuts in the interactive Python shell (Ipython).

Since most of the students are learning typing ⌨, practicing these keyboard shortcuts actually help them learn typing by reinforcing memory of where the keys are.

The keyboard shortcuts allows you to minimize finger movements on the keyboard, which means you don’t even have to lift your hand ✋ for the “Backspace”, ‘Home’, ‘End’ or arrow keys (most of the time).    Spend 15 minutes per day practicing these.  Pretty soon, you will be a fast coder.

keystroke Action
`Ctrl-a` Move cursor to the beginning of the line
`Ctrl-e` Move cursor to the end of the line
`Ctrl-b` or the left arrow key Move cursor back one character
`Ctrl-f` or the right arrow key Move cursor forward one character

👦Text Entry

Keystroke Action
Backspace key Delete previous character in line
`Ctrl-d` Delete next character in line
`Ctrl-k` Cut text from cursor to end of line
`Ctrl-u` Cut text from beginning of line to cursor
`Ctrl-y` Yank (i.e. paste) text that was previously cut
`Ctrl-t` Transpose (i.e., switch) previous two characters

🐞Command History

Keystroke Action
`Ctrl-p` (or the up arrow key) Access previous command in history
`Ctrl-n` (or the down arrow key) Access next command in history
`Ctrl-r` Reverse-search through command history

🐳Miscellaneous

Keystroke Action
`Ctrl-l` Clear terminal screen
`Ctrl-c` Interrupt current Python command
`Ctrl-d` Exit IPython session

The shortcuts are referenced from  Python Data Science Handbook.   As its author Jake Vanderplas says, these shortcuts are not inherent in Ipython shell itself, but are based on GNU Readline library.

# Use snippets to code faster | snippet 加速编程

Today’s weekend programming lesson we covered how to save code snippets in a code editor, such as Sublime Test 3 (ST) and Visual Studio Code (code).

🙂 You can save these chunks of code so next time you wouldn’t have to type it again.

Until NeuralLink or other developments that can help us bypass typing all together, we want to find ways to save ourselves time from typing code.   Using snippet is a must for children, who may not be great at typing.   Here is how to do it in Sublime Test 3 (ST) and Visual Studio Code (code).

😎Sublime Test:
Tools – > Developer -> New Snippet.

😎VS Code:
`Shift` + `Control` + `p`

😎 Shift + Control + F: to search for a string in your folder (perhaps the name of the snippet you saved).

💡Write the snippet that can be used by the code editor:

Snippets are json files. Use this ➡ web app, or some packages, or write json if you prefer to put the code into the json format.

Explaining .json snippet in VS Code:

• The first set of “” encloses the name of the snippet (call it anything you like).
• Prefix defines a prefix used in the IntelliSense drop down. For example, if you have a snippet for plotting, you may want to prefix it with “plot”.
• body is the snippet content.
• Note that: \$1, \$2 for tab stops
• Description is the description.  When you start typing the prefix of a snippet, its description will come up.

By the way, to quickly see what are the keyboard shortcuts are available in VS Code:

Ctrl + Shift + p

# Logit transform | 分数对数转换

After we discussed logarithm (‘log’) last week, we explored a bit on some commonly used methods that have log embedded in them.   For example, the logit function, or logit transform (using the “natural” logarithm).   We explained its definition by the following Python code.

>>> epsilon=0.001
>>> def logit(c):
>>>  d = np.log((c+epsilon)/(1+ epsilon-c))
>>>  return d

The following is the inverse, which is to bring what was transformed back to what it was before.

>>> def inverse_logit(a):
>>>  b = ((1+ epsilon)*np.exp(a) – epsilon)/(np.exp(a)+1)
>>>  return b

>> print(logit(0.1)) #-2.1883847407670785
>>> print(inverse_logit(logit(0.1))) #0.09999999999999999

It is much more revealing on what the logit transform is doing by looking at some pictures of how this works.  See how fast when it is transformed!   Why it is stretched instead of being shrunk?  We know that taking log is to do division multiple times (recall log10 of a number is how many times it needs to divide by 10 in order to become 1).     But when it applies to numbers between 0 and 1, it gives us the opposite effect.  A positive small number less than one has to divide by 10 negative times to become 1.  For example, 0.01 needs to be divided by 10 negative two times to be restored to 1.  That’s why you see that y axis we have negatives.

On the other hand, we also have positives in the y-axis.  That’s because about half of the numbers `(c+epsilon)/(1+ epsilon-c)` (the odds) are large positive numbers.  Play around with it and you will surely get it.

>> x = np.linspace(0,1,1000)
>>> y = logit(x)
>>> plt.scatter(x=x, y=y, alpha=0.3)
>>> title =”logit transform”
>>> plt.title(“%s”%title)
>>> plt.xlabel(“numbers between 0 and 1 (inclusive”)
>>> plt.ylabel(“after logit transform”)
>>> plt.xlim(-6, 6)
>>> plt.ylim(-6, 6)
>>> plt.draw()

Look at the same plot with the axis scaled differently:

# zero, one and two | 零，一，二

It is not easy for a young child to comprehend multiplication by 1, as how they are taught in school is often the robotic multiplication table.   She or he can very quickly answer mutiplications by 2, or 3.    Because of this, questions like “what is the product of 1,2, 3, 4” (i.e. 4 factorial) can get a wide range of answers because the number “1” confuses the young mind.

Pychologist says that an infant learns the number 2 before the number 1.   And we can see why: with 2, there is something to compare against, like two fingers.  If there is only one finger, there is no variation, it is confusing.

When we teach multiplication, don’t forget to show that math is an integral part of the real world around us.   It is invented to simplify addition.  Multiply by 1 means just the thing itself.  Multiply by 2 means adding two of this thing together.  Multiply by 3 means adding three of the thing together.  The thing can be a bag of candies or the footage of a home.

Finally, we should show children how to use computers (not calculators) to do computations.   While a question like “give me the sum from 1 to 199” can be solved within seconds with math tricks, a slightly different question “give me the product from 1 to 199” won’t work with the same trick.  But if you know how to make the computer do the job, you can still answer it within seconds.

# Logarithm | 对数

As we had explored in previous classes, division is subtraction again and again and again, multiplication is adding again and again.  Exponentiation is multiply again and again and again— They are all inventions to simplify repeated computation.

So is the invention of logarithm: taking log is division again and again and again.   They were invented by John Napier who was a Scottish mathematician, physicist, and astronomer  in 1614 as a means to simplify calculations.

🙂 Today’s  Python numpy class summary:

Log10 means how many times divide by 10 will return you to 1. log10(100) will give you 2 because 100 divide by 10 twice returns us to one.
>>> np.log10(100)
One trillion divide by 10 twelve times returns it to 1.
>>> np.log10(1000000000000)

>>> np.linspace(0.0, 3.0, num=4)
Out: array([0., 1., 2., 3.])

>>> np.logspace(0.0, 3.0, num=4)
Out: array([   1.,   10.,  100., 1000.])

>>> np.linspace(0.0, 12.0, num=13)
Out: array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.])
>>> np.logspace(0.0, 12.0, num=13)
Out: array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07, 1.e+08, 1.e+09, 1.e+10, 1.e+11, 1.e+12])

Bonus:  Did you know that Engineers and scientists used to use a tool called “slide rule” (计算尺) to do logarithmic computations until 1970s when electronic computer and calculators came into use.  You should go and check it out if any of your grandparents have one of these.

# Find if something is also somewhere else (contd) | 找一找那里是不是也有

Today’s class we continued the game of finding matches.  We expanded from numbers to names.

Let’s pretend that there is a room out there that has the following famous people:

And another room with these famous people:

room2 = pd.Series([‘Isaac Newton’, ‘Thomas Edison’,’Mary Somerville’,’Matilda’,’Ada Lovelace’])

These two rooms are in building:

building = pd.concat([room1, room2], axis=1)

building.columns= [‘room1′,’room2’]

room1            room2
0     Grace Hopper     Isaac Newton
1  Albert Einstein    Thomas Edison
3     Emmy Noether          Matilda

Now we want to find a list of people “who” in the building and the rooms.

Are they in room 1?

`np.isin(who, room1)`
Out: array([ True,  True,  True])

Are they in room2?

`np.isin(who, room2)`

Out: array([False, False,  True])

Are they in the building?

`np.isin(who, building)`
Out: array([ True,  True,  True])

We are constantly comparing things.  How to compare is a very tricky and interesting subject.  You should look up the source code of the function in1d and see how it does it.

# Find if something is also somewhere else | 找一找那里是不是也有

In today’s class we played a game: finding the numbers in a group that are also in another group. As usual, we started simple using numpy (np).   Here is the summary:

`score1 = np.array([0, 1, 3, 5, 10,3])`

`score2 = np.array([2,3])`

We use the inld function from numpy to do the matching and counting:
`np.in1d(score1,score2)`

`score1[np.in1d(score1,score2)]`

Our result is:

array([3, 3])

There is another way to do this:

`np.array([item in score2 for item in score1])`

array([False, False,  True, False, False,  True])

score1[np.array([item in score2 for item in score1])]

will give you exactly the same answer.   Try it.

For very large groups of numbers or words, what we’ve just learned will work just as well.

Please practice and turn in the homework.

# Count non-zeros using numpy.count_nonzero | 数非零数

Today our class practiced making the computer count number of non-zero numbers using the numpy library from Python.  This can be useful if you have a ton of numbers.

`import numpy as np; import pandas as pd`

`some_array = np.array([[0,1,7,0,0],[3,0,0,2,19]])`

array([[ 0,  1,  7,  0,  0],
[ 3,  0,  0,  2, 19]])

`np.count_nonzero(some_array)`

5

`np.count_nonzero(some_array,  axis=0) ` Count across the rows, i.e. count along the column

array([1, 1, 1, 1, 1], dtype=int64)

`np.count_nonzero(some_array,  axis=1) ` Count across the columns, i.e. count along the row

array([2, 3], dtype=int64)

`d = {'Basket1': [3, 0], 'Basket2': [3, 4]}`
`df = pd.DataFrame(data=d, index=['Apple','Chips'])`

# Count the number of non-zeros across the rows
`pd.Series(np.count_nonzero(df, axis=0), index=df.columns.tolist())`

This was the result we got.