Data types - use Technical Quotient

Array types and conversions between types

1. Remember

Which function is used to create an array of integers with data type uint8?

np.arange(3, dtype=np.uint8)

Correct; np.arange(3, dtype=np.uint8) creates an array of integers [0, 1, 2] with data type uint8.

np.linspace(0, 2, dtype=np.float64)

Incorrect; np.linspace(0, 2, dtype=np.float64) is for creating linearly spaced floating-point numbers.

np.zeros(3, dtype=np.int32)

Incorrect; np.zeros(3, dtype=np.int32) creates an array of zeros with data type int32.

np.full(3, 1, dtype=np.int64)

Incorrect; np.full(3, 1, dtype=np.int64) creates an array filled with the specified value (1) with data type int64.

2. Understand

How does specifying dtype='f' in np.array([1, 2, 3], dtype='f') affect the resulting array?

Keeps the numbers as integers but changes their format to binary.

Incorrect; the format change to binary is not a visible effect of specifying dtype.

Converts the integers to floating-point numbers with float32 precision.

Correct; specifying dtype='f' converts integers to floating-point numbers with float32 precision.

Leaves the numbers as integers without any conversion.

Incorrect; specifying dtype='f' explicitly converts the numbers to floating-point.

Converts the array to a float64 data type.

Incorrect; dtype='f' specifically refers to float32, not float64.

3. Apply

You have an array z = np.array([10, 20, 30]) and want to convert its data type to float64. Which method correctly achieves this conversion?

z = np.array([10, 20, 30], dtype=np.float64)\nprint(z.dtype)

Incorrect; it creates an array with dtype=np.float64 initially, not converting an existing one.

z = np.array([10, 20, 30])\nz.astype(np.float64)\nprint(z.dtype)

Incorrect; although z.astype(np.float64) is used, the result is not assigned back to z, so z.dtype remains unchanged.

z = np.array([10, 20, 30])\nfloat(z)\nprint(z.dtype)

Incorrect; using float(z) attempts to convert the array z itself to a single float value, which is not valid for NumPy arrays and will result in a TypeError. The .astype() method is the correct approach for converting the data type of an array.

z = np.array([10, 20, 30])\nz = z.astype('float64')\nprint(z.dtype)

Correct; it converts z to float64 and assigns the result back to z, effectively changing its type.

4. Analyze

You are working on a dataset consisting of pixel values ranging from 0 to 255. Initially, the dataset is loaded as integers (int32). However, to normalize the data for a machine learning model, you need to convert the data to a range between 0.0 and 1.0 (float64). You decide to use the .astype() method to accomplish this. After conversion, you plan to divide each element by 255 to achieve normalization. What is the importance of converting the dataset to float64 before normalization?

Allows the pixel values to remain integers for image processing.
Increases the speed of calculations in the normalization process.

Incorrect; converting to float64 generally does not increase calculation speed; it ensures precision.

Decreases the memory usage by storing smaller numbers.

Incorrect; converting to float64 actually increases memory usage per element compared to int32, but it's necessary for accurate normalization.

Ensures accurate division and prevents data loss by supporting fractional results.

Correct; converting to float64 allows for fractional results, ensuring accurate normalization without data loss.

5. Understand

What is an example of how the bitsize of a NumPy data type, like numpy.int_, affects its usage when interfacing with C or Fortran code?

All NumPy data types have fixed bitsizes, ensuring consistent interfacing across different platforms.
Bitsize only affects the speed of computations, not compatibility with low-level code.
It determines the numerical range of the data type, but has no effect on interfacing with C or Fortran.
Depends on the platform's architecture, impacting memory allocation and data precision.

Correct; the bitsize of a data type like numpy.int_ can vary (e.g., 32-bit vs. 64-bit) depending on the platform, which affects how memory is allocated and managed when interfacing with low-level code, potentially impacting data precision and compatibility.

7. Understand

What happens when you specify a dtype of "U5" for an array containing the strings "hello" and "world!"?

The string "world!" is truncated to "world".

Correct; specifying "U5" truncates strings longer than 5 characters.

An error is thrown due to the string exceeding the specified length.
The dtype is automatically adjusted to fit the longest string.
The array is padded with null bytes to fit "world!".

Incorrect; zero-padding is used for byte strings ("S" dtype), not for Unicode strings.

8. Apply

You want to create an array with the words "hello" and "world!" ensuring no truncation and with one character of padding. Which code snippet correctly achieves this?

import numpy as np\nwords = ["hello", "world!"]\narray = np.array(words, dtype="U7")\nprint(array)

import numpy as np\nwords = ["hello", "world"]\narray = np.array(words, dtype="S7")\nprint(array.tobytes())

import numpy as np\nwords = ["hello", "world!"]\narray = np.array(words, dtype="V7")\nprint(array)

import numpy as np\nwords = ["hello", "world!"]\narray = np.array(words, dtype="U5")\nprint(array)

Incorrect; The second snippet truncates "world!" to "world".

9. Analyze

You are working on a project involving the storage of sensor data strings that vary in length, with the longest being "temperature: -20.5C". To ensure no data is truncated and to allow for future slightly longer strings, you decide to use a fixed-width string type with padding. Considering the need for efficient storage and retrieval without loss of information, including potential trailing null bytes, which dtype and width should you use and why?

dtype="U20" to accommodate the current and slightly longer strings with efficient Unicode storage.
dtype="V22" for flexible storage of arbitrary byte sequences, including trailing nulls, without risk of truncation.

Correct; dtype="V22" offers the flexibility needed to store strings with varying lengths, including the ability to handle trailing null bytes explicitly, catering to the project's requirements for exact data representation and future-proofing against slightly longer strings.

dtype="S20" to ensure compatibility with systems expecting byte strings, adding null byte padding.
dtype="U18" assuming that only the characters need to be counted, not including potential future padding.