### Archive

Posts Tagged ‘numpy’

## Python: Random Pixel Color – P2

Learning : Python, Math
Subject: Random Coloring Pixels

[NOTE: To keep the code as simple as we can, We WILL NOT ADD any user input Varevecations. Assuming that our user will Enter the right inputs.]

Our last post about Random Pixel Color, we generate a Numpy Array of Row, Coloum and color then we Plot it on the screen [Read the Post Here], now in this post we will use some Math consepts to try if we can get some patterns out of ramdom Function.
Our Tools: In this post we will use the following:
1. Jupyter-NoteBook.
2. numpy.
3. random.
4. matplotlib.
5. PIL or Pillow.

In this version we will use “Fibonacci Sequence” Fibonacci Sequence is the sum of the two preceding ones, starting from 0 and 1 such as [1, 1, 2, 3, 5, 8, 13 … n], in our code we will have three variables:
cw: canvas width,
ch: canvas hight,
offset: the offset will be the value that will reset the Fibonacci Sequence to 1.

So, if we run the application, we will generate three numbers that will present the colors R,G,B (Will be Generated ONE time) then for each pixcel in (cw*ch) we will calculate a v as Fibonacci Sequence from fs1 =1, fs2 = 1 here is the code:
v = fs1 + fs2
fs1,fs2 = fs2, v

this value v will be added to the colors r,g,b (on each pixcel) untill the v is grater the the offset numbre that we pass to the Function. If v > offset then we will re-set the fs1 = 1, fs2 = 1,.. Here is the Code ..

Here are some Out-put

The above is just 25×25 and i change the offset, feel free to download the code and change the numbers .. see what you will get …

..:: Have Fun with Coding ::.. 🙂 Follow me on Twitter..

## Python: Random Pixel Color

Learning : Python, Math
Subject: Random Coloring Pixels

[NOTE: To keep the code as simple as we can, We WILL NOT ADD any user input Varevecations. Assuming that our user will Enter the right inputs.]

Last week I start reading and studying about “Image Processing”, in some point I was reading about converting an image to Array of numbers, and re-converting that Array back to an Image, at that moment popped into my mind what if we just generate an Array with random numbers and then show it as an Image.

In this article we will write a first simple Function to generate a random numbers presenting the three main color Red, Blue and Green; then storing the numbers in an Array then using matplotlib library to display the Image.

Our Tools: In this post we will use the following:
1. Jupyter-NoteBook.
2. numpy.
3. random.
4. matplotlib.
5. PIL or Pillow.

Coding I am user Jupyter NoteBook on samsung Tab S4. First we will do all imports we need as:
from PIL import Image
import numpy as np, matplotlib.pyplot as plt
import random
%matplotlib inline

Now, we will write a Function called rand_color, we will run a nested for loop to generate the Row and Column (width and height) and in/for each row we will generate thee numbers of colors range(0,255) as one pixel and storing them in an array, then we display the Array using:
Image.fromarray and plt.imshow(). Here is the Code ..

The above is just 25×25 image with random color pixels, this is the first function using default random, in coming posts we will use some Math variables [such: log,sin], constants [such: pi, golden ratio] to see if we can get a pattern from random.

..:: Have Fun with Coding ::.. 🙂 Follow me on Twitter..

## Python: Numpay – P3

Learning : Python Numpy – P3
Subject: numpy array and some basic commands

The numpy lessons and basic commands will take us to plotting the data and presenting the numbers using the numpy and plot packages, but first we need to do more practices on arrays and functions in the numpy.

To get a row or a column from the array we use:

```# Generate a 5x5 random array:
ar = np.random.randint(10,60, size=(5,5))
print('\n A random generated array 5x5 is: \n',ar)

# get the rows from 1 to 3 (rows 1 and 2):
print('\n  The rows from 1 to 3 is: \n',ar[1:3])

# get row 1 and row 3:
print('\n  The row 1 and row 2 is: \n',ar,ar)

# get the column 1 and column 3:
print('\n  The column 1 and column 3: \n',ar[:,[1,3]])

[Output]:
A random generated array 5x5 is:
[[59 43 46 44 39]
[16 15 14 19 22]
[59 16 33 59 19]
[21 15 51 41 28]
[48 46 58 33 19]]

The rows from 1 to 3 is:
[[16 15 14 19 22]
[59 16 33 59 19]]

The row 1 and row 2 is:
[16 15 14 19 22]
[21 15 51 41 28]

The column 1 and column 3:
[[43 44]
[15 19]
[16 59]
[15 41]
[46 33]]
```

To change a value in the array we give the position and new value as:

```# Generate a 5x5 random array:
ar = np.random.randint(10,60, size=(5,5))
print('\n A random generated array 5x5 is: \n',ar)
print('\n Value in position (1,1):',ar)
# Re-set the value in position (1,1) to 55
ar = 55
print('\n The array ar\n',ar)

code
[Output]:

A random generated array 5x5 is:
[[39 53 34 59 30]
[33 10 42 20 36]
[10 37 20 35 28]
[26 18 14 41 24]
[48 22 19 18 44]]

Value in position (1,1): 10

The array ar
[[39 53 34 59 30]
[33 55 42 20 36]
[10 37 20 35 28]
[26 18 14 41 24]
[48 22 19 18 44]]
```

If we have a one dimension array with values, and we want to create another array with values after applying a certain conditions, such as all values grater than 7.

```# Create 1D array of range 10
ar = np.arange(10)
print(ar)

# ar_g7 is a sub array from ar of values grater then 7
ar_g7= np.where(ar >7)
print('ar_g7:'ar_g7)

[Output]:
[0 1 2 3 4 5 6 7 8 9]
ar_g7:(array([8, 9]),)
```

If we want to pass a 3×3 array and then we want the values to be changed to (1) if it is grater than 7 and to be (0) if it is less than 7.

```# Generate a 3x3 array of random numbers.
ar2 = np.random.randint(1,10, size =(3,3))
print(ar2)

# Change any value grater than 7 to 1 and if less than 7 to 0.
ar_g7= np.where(ar2 >7, 1 ,0)
print('ar_g7:',ar_g7)

[Output]:
[[6 4 2]
[8 5 1]
[5 2 8]]

ar_g7:
[[0 0 0]
[1 0 0]
[0 0 1]]
```

Also we can say if, the value in the array is equal to 6 or 8 then change it to -1.

```# Generate array of 3x3
ar2 = np.random.randint(1,10, size =(3,3))
print(ar2)

# If the = 6 or 8 change it to (-1)
ar_get_6_8_value= np.where((ar2 == 6) |( ar2==8), -1 ,ar2)
print('ar_get_6_8_value:',ar_get_6_8_value)

[Output]:
[[3 4 8]
[1 9 3]
[5 6 6]]

ar_get_6_8_value:
[[ 3  4 -1]
[ 1  9  3]
[ 5 -1 -1]]
```

We can get the index location of the certain conditions values, and then we can print it out.

```# # Generate array of 3x3

ar_less_6= np.where((ar2 < 6) )
print('ar_less_6 locations:',ar_less_6)

# print out the values on those locations.
print('ar_less_6 values: ',ar2[ar_less_6])
[Output]:
[[6 1 9]
[1 8 6]
[6 9 2]]

ar_less_6 locations: (array([0, 1, 2]), array([1, 0, 2]))
ar_less_6 values :[1 1 2]

```

:: numpy Sessions ::

 Sessions 1 Sessions 2 Sessions 3 Sessions 4 Follow me on Twitter..

## Python: Numpay – P2

Learning : Python Numpy – P2
Subject: Two Dimensional array and some basic commands

In real mathematics word we mostly using arrays with more than one dimensions, for example with two dimension array we can store a data as

So let’s start, if we want to create an array with 24 number in it starting from 0 to 23 we use the command np.range. as bellow :

``` # We are using np.range to create an array of numbers between (0-23)

m_array = np.arange(24)
print(m_array)
[Output]:
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

```

And if we want the array to be in a range with certain incriminating amount we may use this command:

``` # Create array between 2-3 with 0.1 interval

m_array = np.arange(2, 3, 0.1)
print(m_array)
[Output]:
[ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9]

```

Now if we want to create an array say 3×3 fill with random numbers from (0-10) we use random function in numpy as bellow:

``` # create 3x3 Array with random numbers 0-10
m_array = np.random.randint(10, size=(3,3))
print(m_array)
[Output]:
[[6 0 7]
[1 9 8]
[5 8 9]]
```

And if we want the random number ranges to be between two numbers we use this command:

```# Array 3x3 random values between (10-60)
m_array = np.random.randint(10,60, size=(3,3))
[Output]:
[[11 23 50]
[36 44 18]
[56 24 30]]
```

If we want to reshape the array; say from 4×5 (20 element in the array) we can reshape it but with any 20-element size. Here is the code:

```# To crate a randome numbers in an array of 4x5 and numbers range 10-60.
m_array = np.random.randint(10,60, size=(4,5))
print(m_array)

# We will reshape the 4x5 to 2x10
new_shape = m_array.reshape(2,10)
print ('\n   Tne new 2x10 array:\n',new_shape)
[Output]:
[[37 11 56 18 42]
[17 12 22 16 42]
[47 29 17 47 35]
[49 55 43 13 11]]

Tne new 2x10 array:
[[37 11 56 18 42 17 12 22 16 42]
[47 29 17 47 35 49 55 43 13 11]]

```

Also we can convert a list to an array,

```# Convert a list l=([2,4,6,8]) to a 1D array
# l is a list with [2,4,6,8] values.
l=([2,4,6,8])
print('  l= ',l)
# Convert it to a 1D array.
ar = np.array(l)
print('\n  Type of l:',type(l),', Type of ar:',type(ar))
print('  ar = ',ar)

[Output]:
l=  [2, 4, 6, 8]
Type of: class'list'  , Type of ar: class 'numpy.ndarray'
ar =  [2 4 6 8]
```

If we want to add a value to all elements in the array, we just write:

```# Adding 9 to each element in the array

print('ar:',ar)
ar = ar + 9

[Output]:
ar:  [2 4 6 8]
ar after adding 9: [11 13 15 17]
```

:: numpy Commands::

 Command Comments and Outputs my_array = np.array([1,2,3,4,5]) Create an array with 1 to 5 integer len(my_array) Get the array length np.sum(my_array) get the sum of the elements in the array my_array = np.array([1,2,3,4,5]) print(np.sum(my_array)) [Output]: 15 np.max(my_array) # Get the maximum number in the array my_array = np.array([1, 2, 3,4,5]) max_num = np.max(my_array) [Output]: 5 np.min(my_array) # Get the minimum number in the array my_array = np.array([1, 2, 3,4,5]) min_num = np.min(my_array) [Output]: 1 my_array = np.ones(5) Output: [ 1., 1., 1., 1., 1.] create array of 1s (of length 5) np.ones(5) Output: [ 1., 1., 1., 1., 1.] m_array = np.arange(24) print(m_array) # To create an array with 23 number. [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23] m_array = np.arange(2, 3, 0.1) print(m_array) # Create an array from 2 to 3 with 0.1 interval value increments. [ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9] m_array = np.random.randint(10, size=(3,3)) print(m_array) # Create a 3×3 array with random numbers between (0,10) [[6 0 7] [1 9 8] [5 8 9]] m_array = np.random.randint(10,60, size=(3,3)) # Create a 3×3 array with random numbers between (10,60) [[11 23 50] [36 44 18] [56 24 30]] # Create a 4×5 array with random numbers. m_array = np.random.randint(10,60, size=(4,5)) # Reshape m_array from 4×5 to 2×10 new_shape = m_array.reshape(2,10) print(m_array) print(new_shape) # m_array 4×5 [[37 11 56 18 42] [17 12 22 16 42] [47 29 17 47 35] [49 55 43 13 11]] # Tne new 2×10 array: [[37 11 56 18 42 17 12 22 16 42] [47 29 17 47 35 49 55 43 13 11]] # convert a list to array: l=[2,4,6,8] ar = np.array(l) # check data type for l and ar: print(‘\n Type of l:’,type(l),’, Type of ar:’,type(ar)) [Output]: l = [2, 4, 6, 8] ar = [2, 4, 6, 8] Type of l: class ‘list,’, Type of ar: class ‘numpy.ndarray’ # Adding 9 to each element in the array ar = ar + 9 [11 13 15 17]

:: numpy Sessions ::

 Sessions 1 Sessions 2 Sessions 3 Sessions 4

:: Some Code output ::

 Create array with 24 numbers (0-23). Reshape array to 4×6. Create random array of numbers (0-10), size 3×3. Reshape 4×5 array to 2×10. Convert list to array.  Follow me on Twitter..

## Python: Numpay – P1

Learning : Python Numpy – P1
Subject: Numpay and some basic commands

In coming several posts I will talk about the numpay library and how to use some of its functions. So first what is numpy? Definition: NumPy is a library for the Python programming language, adding support for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays. Also known as powerful package for scientific computing and data manipulation in python. As any library or package in python we need to install it on our device (we will not go through this process)

Basic commands in numpy: First of all we need to import it in our code. so we will use

`  import numpy as np`

To create a 1 dimensional array we can use verey easy way as:

```  # create an array using numpy array function.
my_array = np.array([1, 2, 3,4,5])```

Later we will create a random array of numbers in a range.

Now, to get the length of the array we can use len command as

```
len(my_array)
Output: 5
```

To get the sum of all elements in the array we use..

`np.sum(my_array)`

And to get the maximum and minimum numbers in the array we use ..

``` # Get the maximum and minimum numbers in the array
my_array = np.array([1, 2, 3,4,5])
np.max(my_array)
[Output]: 5

np.min(my_array)
[Output]: 1
```

Some time we may need to create an array with certain Number of elements only one’s, to do this we can use this commands:

```#create array of 1s (of length 5)
np.ones(5)
Output: [ 1.,  1.,  1.,  1.,  1.]
```

The default data type will be float, if we want to change it we need to pass the the ‘dtype’ to the command like this :

```#create array of 1s (of length 5) as integer:
np.ones(5, dtype = np.int)
Output: [ 1,  1,  1,  1,  1]
```

Code output:

So far we work on a one dimensional array, in the next post we will cover some commands that will help us in the arrays with multiple dimensions.

:: numpy Commands::

 Command comment my_array = np.array([1,2,3,4,5]) Create an array with 1 to 5 integer len(my_array) Get the array length np.sum(my_array) get the sum of the elements in the array my_array = np.array([1,2,3,4,5]) print(np.sum(my_array)) [Output]: 15 np.max(my_array) # Get the maximum number in the array my_array = np.array([1, 2, 3,4,5]) max_num = np.max(my_array) [Output]: 5 np.min(my_array) # Get the minimum number in the array my_array = np.array([1, 2, 3,4,5]) min_num = np.min(my_array) [Output]: 1 my_array = np.ones(5) Output: [ 1., 1., 1., 1., 1.] create array of 1s (of length 5) np.ones(5) Output: [ 1., 1., 1., 1., 1.]

:: numpy Sessions ::

 Sessions 1 Sessions 2 Sessions 3 Sessions 4