Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 49 views

    Lab#9 Arrays

    Uploaded by

    Gul sher Baloch
    NumPy is a Python library used for working with multidimensional arrays and matrices. It contains functions for linear algebra, Fourier transforms, and more. NumPy arrays are faster than regular Python lists because they store elements in contiguous blocks of memory. NumPy is commonly imported using the alias np. NumPy arrays can have multiple dimensions (0D for scalars, 1D for vectors, 2D for matrices, etc.) and elements can be accessed and sliced using indexes and ranges.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Lab#9 Arrays

    Uploaded by

    Gul sher Baloch
    49 views11 pages
    NumPy is a Python library used for working with multidimensional arrays and matrices. It contains functions for linear algebra, Fourier transforms, and more. NumPy arrays are faster than regular Python lists because they store elements in contiguous blocks of memory. NumPy is commonly imported using the alias np. NumPy arrays can have multiple dimensions (0D for scalars, 1D for vectors, 2D for matrices, etc.) and elements can be accessed and sliced using indexes and ranges.

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    NumPy is a Python library used for working with multidimensional arrays and matrices. It contains functions for linear algebra, Fourier transforms, and more. NumPy arrays are faster than regular Python lists because they store elements in contiguous blocks of memory. NumPy is commonly imported using the alias np. NumPy arrays can have multiple dimensions (0D for scalars, 1D for vectors, 2D for matrices, etc.) and elements can be accessed and sliced using indexes and ranges.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    49 views11 pages

    Lab#9 Arrays

    Uploaded by

    Gul sher Baloch
    NumPy is a Python library used for working with multidimensional arrays and matrices. It contains functions for linear algebra, Fourier transforms, and more. NumPy arrays are faster than regular Python lists because they store elements in contiguous blocks of memory. NumPy is commonly imported using the alias np. NumPy arrays can have multiple dimensions (0D for scalars, 1D for vectors, 2D for matrices, etc.) and elements can be accessed and sliced using indexes and ranges.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 11

    Lab#9: NumPy Array

    What is NumPy?
    NumPy is a Python library used for working with arrays.

    It also has functions for working in domain of linear algebra, fourier transform, and matrices.

    NumPy stands for Numerical Python.

    Why Use NumPy?


    In Python we have lists that serve the purpose of arrays, but they are slow to process.

    NumPy aims to provide an array object that is up to 50x faster than traditional Python lists.

    The array object in NumPy is called ndarray, it provides a lot of supporting functions that make
    working with ndarray very easy.

    Why is NumPy Faster Than Lists?


    NumPy arrays are stored at one continuous place in memory unlike lists, so processes can access
    and manipulate them very efficiently.

    This behavior is called locality of reference in computer science.

    This is the main reason why NumPy is faster than lists. Also it is optimized to work with latest
    CPU architectures

    Import NumPy
    Import it in your applications by adding the import keyword:

    import numpy

    Now NumPy is imported and ready to use.

    Example
    import numpy

    arr = numpy.array([1, 2, 3, 4, 5])

    print(arr)
    NumPy as np
    NumPy is usually imported under the np alias.

    alias: In Python alias are an alternate name for referring to the same thing.

    Create an alias with the as keyword while importing:

    import numpy as np

    Now the NumPy package can be referred to as np instead of numpy.

    Example
    import numpy as np

    arr = np.array([1, 2, 3, 4, 5])

    print(arr)

    Create a NumPy ndarray Object


    NumPy is used to work with arrays. The array object in NumPy is called ndarray.

    We can create a NumPy ndarray object by using the array() function.

    Example
    import numpy as np

    arr = np.array([1, 2, 3, 4, 5])

    print(arr)

    print(type(arr))

    type(): This built-in Python function tells us the type of the object passed to it. Like in above
    code it shows that arr is numpy.ndarray type.
    Dimensions in Arrays
    A dimension in arrays is one level of array depth (nested arrays).

    nested array: are arrays that have arrays as their elements.

    0-D Arrays
    0-D arrays, or Scalars, are the elements in an array. Each value in an array is a 0-D array.

    Example
    Create a 0-D array with value 42

    import numpy as np

    arr = np.array(42)

    print(arr)

    1-D Arrays
    An array that has 0-D arrays as its elements is called uni-dimensional or 1-D array.

    These are the most common and basic arrays.

    Example
    Create a 1-D array containing the values 1,2,3,4,5:

    import numpy as np

    arr = np.array([1, 2, 3, 4, 5])

    print(arr)
    2-D Arrays
    An array that has 1-D arrays as its elements is called a 2-D array.

    These are often used to represent matrix or 2nd order tensors.

    NumPy has a whole sub module dedicated towards matrix operations called numpy.mat

    Example
    Create a 2-D array containing two arrays with the values 1,2,3 and 4,5,6:

    import numpy as np

    arr = np.array([[1, 2, 3], [4, 5, 6]])

    print(arr)

    3-D arrays
    An array that has 2-D arrays (matrices) as its elements is called 3-D array.

    These are often used to represent a 3rd order tensor.

    Example
    Create a 3-D array with two 2-D arrays, both containing two arrays with the values 1,2,3 and
    4,5,6:

    import numpy as np

    arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

    print(arr)
    Check Number of Dimensions?
    NumPy Arrays provides the ndim attribute that returns an integer that tells us how many
    dimensions the array have.

    Example
    Check how many dimensions the arrays have:

    import numpy as np

    a = np.array(42)
    b = np.array([1, 2, 3, 4, 5])
    c = np.array([[1, 2, 3], [4, 5, 6]])
    d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

    print(a.ndim)
    print(b.ndim)
    print(c.ndim)
    print(d.ndim)

    Access Array Elements


    Array indexing is the same as accessing an array element.

    You can access an array element by referring to its index number.

    The indexes in NumPy arrays start with 0, meaning that the first element has index 0, and the
    second has index 1 etc.

    Example
    Get the first element from the following array:

    import numpy as np

    arr = np.array([1, 2, 3, 4])

    print(arr[0])
    Example
    Get the second element from the following array.

    import numpy as np

    arr = np.array([1, 2, 3, 4])

    print(arr[1])

    Example
    Get third and fourth elements from the following array and add them.

    import numpy as np

    arr = np.array([1, 2, 3, 4])

    print(arr[2] + arr[3])

    Access 2-D Arrays


    To access elements from 2-D arrays we can use comma separated integers representing the
    dimension and the index of the element.

    Example
    Access the 2nd element on 1st dim:

    import numpy as np

    arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])

    print('2nd element on 1st dim: ', arr[0, 1])

    Example
    Access the 5th element on 2nd dim:

    import numpy as np

    arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])

    print('5th element on 2nd dim: ', arr[1, 4])


    Access 3-D Arrays
    To access elements from 3-D arrays we can use comma separated integers representing the
    dimensions and the index of the element.

    Example
    Access the third element of the second array of the first array:

    import numpy as np

    arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

    print(arr[0, 1, 2])

    Example Explained

    arr[0, 1, 2] prints the value 6.

    And this is why:

    The first number represents the first dimension, which contains two arrays:
    [[1, 2, 3], [4, 5, 6]]
    and:
    [[7, 8, 9], [10, 11, 12]]
    Since we selected 0, we are left with the first array:
    [[1, 2, 3], [4, 5, 6]]

    The second number represents the second dimension, which also contains two arrays:
    [1, 2, 3]
    and:
    [4, 5, 6]
    Since we selected 1, we are left with the second array:
    [4, 5, 6]

    The third number represents the third dimension, which contains three values:
    4
    5
    6
    Since we selected 2, we end up with the third value:
    6
    Negative Indexing
    Use negative indexing to access an array from the end.

    Example
    Print the last element from the 2nd dim:

    import numpy as np

    arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])

    print('Last element from 2nd dim: ', arr[1, -1])

    Slicing arrays
    Slicing in python means taking elements from one given index to another given index.

    We pass slice instead of index like this: [start:end].

    We can also define the step, like this: [start:end:step].

    If we don't pass start its considered 0

    If we don't pass end its considered length of array in that dimension

    If we don't pass step its considered 1

    Example
    Slice elements from index 1 to index 5 from the following array:

    import numpy as np

    arr = np.array([1, 2, 3, 4, 5, 6, 7])

    print(arr[1:5])

    Note: The result includes the start index, but excludes the end index.


    Example
    Slice elements from index 4 to the end of the array:

    import numpy as np

    arr = np.array([1, 2, 3, 4, 5, 6, 7])

    print(arr[4:])

    Example
    Slice elements from the beginning to index 4 (not included):

    import numpy as np

    arr = np.array([1, 2, 3, 4, 5, 6, 7])

    print(arr[:4])

    Negative Slicing
    Use the minus operator to refer to an index from the end:

    Example
    Slice from the index 3 from the end to index 1 from the end:

    import numpy as np

    arr = np.array([1, 2, 3, 4, 5, 6, 7])

    print(arr[-3:-1])
    STEP
    Use the step value to determine the step of the slicing:

    Example
    Return every other element from index 1 to index 5:

    import numpy as np

    arr = np.array([1, 2, 3, 4, 5, 6, 7])

    print(arr[1:5:2])

    Example
    Return every other element from the entire array:

    import numpy as np

    arr = np.array([1, 2, 3, 4, 5, 6, 7])

    print(arr[::2])

    Slicing 2-D Arrays


    Example
    From the second element, slice elements from index 1 to index 4 (not included):

    import numpy as np

    arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

    print(arr[1, 1:4])

    Note: Remember that second element has index 1.


    Example
    From both elements, return index 2:

    import numpy as np

    arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

    print(arr[0:2, 2])

    Example
    From both elements, slice index 1 to index 4 (not included), this will return a 2-D array:

    import numpy as np

    arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

    print(arr[0:2, 1:4])

    You might also like