Python Data Types and Libraries: Comprehensive

Study Notes
Python Data Types
Python has several built-in data types for representing different kinds of values. Fundamental numeric
types include integers ( int ), floating-point numbers ( float ), and complex numbers ( complex ). For
text we use strings ( str ), and for binary data bytes and bytearray. Logical (True/False) values are the
Boolean type ( bool ). Together these basic types form the core of Python programs 1 2 . For example,
42 is an int , 3.14 is a float , 2+3j is a complex number, "Hello" is a str , and True is a
bool . You can always check a value’s type with the built-in type() function (e.g. type(42) yields
<class 'int'> 3 ). Note that every value in Python carries its type tag; for instance, the integer 10 is
tagged as (int) and the string 'hello' as (str) in memory 4 . Although Python is dynamically
typed (you don’t declare types explicitly), it still has distinct types under the hood 5 .

• Integers ( int ) – Whole numbers without a fractional part. Use them for counting, indexing, or
when only whole units make sense (e.g. number of items). Memory aid: “int” stands for integer.
Example: count = 5 .
• Floats ( float ) – Real numbers with decimal points. Used for measurements or calculations
needing fractions (e.g. average, temperature). Memory aid: think floating point. Example:
temperature = 98.6 .
• Complex ( complex ) – Numbers with a real and imaginary part (written with a j , e.g. 3+4j ).
Rarely used outside scientific or engineering contexts. Note: a complex value contains two floats
internally (real and imaginary parts). Example: z = 2 + 3j .
• Strings ( str ) – Textual data, enclosed in quotes ( '...' or "..." ). Strings are immutable
sequences of characters 2 . Example: name = "Alice" .
• Bytes ( bytes / bytearray ) – Binary data (immutable bytes and mutable bytearray ). Useful
for raw data like images or network packets. For example, b'\x00\xFF' is a bytes object.
• Booleans ( bool ) – Logical values, either True or False . Used for conditions and flags. Memory
aid: “bool” is short for Boolean (from logic). Example: is_valid = True .

In addition to these, Python has compound types (collections) like lists, tuples, sets, and dictionaries. A
list is an ordered, mutable sequence of items (like an array). A tuple is an ordered, immutable sequence
(fixed-size list). A set is an unordered collection of unique items. A dictionary ( dict ) stores key-value pairs
6 ; each key maps to a value (e.g. config = {"color": "green", "width": 42} where "color"
is a key). Dictionaries are extremely useful for mapping labels to data – for example, a JSON record or
configuration settings. Memory aid: a dict is like a real-life dictionary mapping words (keys) to definitions
(values).

Example: You might use an int to count apples, a float for a sensor reading, a str for
a person's name, a list to hold a collection of scores, and a dict to map user IDs to user
data. For instance:

1
 scores = [95, 88, 76] # list of integers
person = {"name": "Alice", "age": 30} # dict mapping keys to values

Here scores is a list of int s, and person is a dict with a str key and mixed types of
values.

Type Conversion: You can convert between types using built-in functions like int() , float() , str() ,
etc. For example, int("123") yields 123 . Python will automatically use the correct operations based on
types (e.g. 1 + 2 = 3 for ints, but 'a' + 'b' = 'ab' for strings) 7 .

Memory Aid/Mnemonics:
- INTeger → Integrally whole (no fractions).
- FLOAT → think of a number floating with a decimal.
- BOOL = two possibilities (T/F).
- STRing = series of characters.
- PANDAS = Panel Data; NUMPY = NUMerical Python; MATplotlib = like MATrix plotting.

Resources:
- Video: Python Data Types for Beginners – Web Dev Roadmap (YouTube) – A beginner-friendly tutorial on
Python types.
- Article: Python Data Types – W3Schools – Overview of Python’s built-in types.
- Article: Python’s Basic Data Types – Real Python – In-depth guide to each basic type 1 .

Key Python Libraries

Modern Python ecosystems rely heavily on external libraries. Here are some core libraries you’ll often use:

NumPy (Numerical Python)

Use: Fast numerical arrays and math. NumPy provides the powerful ndarray for efficient numerical
computation. Unlike Python lists, NumPy arrays are stored contiguously in memory, making operations up
to 50× faster for large datasets 8 . It includes routines for linear algebra, Fourier transforms, random
sampling, etc. NumPy stands for Numerical Python 9 , and was created by Travis Oliphant in 2005.
Example Scenario: Working with image data (stored as numeric arrays), scientific simulations, or any math-
heavy processing.
Memory Aid: Arrays of numbers; “Num” in NumPy reminds you of numbers.

Snippet: import numpy as np – here np is an alias for NumPy (a short nickname) 10 .

How to Remember: Think of NumPy when you see heavy math or multi-dimensional data
needs. It’s the foundation for many other libraries (Pandas, SciPy, scikit-learn all build on
NumPy).

2
Pandas

Use: Data manipulation and analysis. Pandas introduces data structures like Series (1D data) and
DataFrame (2D table) to Python. A DataFrame is essentially a spreadsheet-like table with rows and columns,
where each column can be a different type 11 . It simplifies tasks like loading CSVs, filtering rows, group-by
aggregations, handling missing data, and more. In fact, “Pandas” is derived from “Panel Data” and “Python
Data Analysis” 12 .
Example Scenario: Loading a CSV of sales records into df = pd.read_csv("sales.csv") , cleaning or
summarizing columns, and preparing data for visualization or modeling.
Memory Aid: Panel Data → think multi-dimensional tables.

Example:

import pandas as pd
df = pd.DataFrame({"A": [1,2,3], "B":[4,5,6]})

This creates a DataFrame df with two columns A and B . Here we passed a Python
dictionary (key "A" , value list [1,2,3] ) to pd.DataFrame . A dictionary is a collection of
key-value pairs 6 , which Pandas converts into table columns.
Why Pandas: It’s hugely popular for data tasks in domains from science to finance, because it
automates and simplifies data handling 13 . For instance, to drop rows with missing values
you can just do df = df.dropna() . Pandas’s loc and iloc attributes let you easily
select rows/columns by label or position.

Resources:
- Article: Introduction to Pandas – Learn Enough – Overview of why Pandas is essential for data science 13
14 .

- Documentation: pandas.DataFrame – PyData – Official description (“two-dimensional, size-mutable,

potentially heterogeneous tabular data” 15 ).
- Article: Pandas DataFrames – W3Schools – Simple guide with examples 11 .

Matplotlib

Use: Plotting and visualization. Matplotlib is the standard plotting library in Python for creating charts and
figures. It can make static, animated, or interactive plots. Simple plots (lines, bars, histograms, etc.) can
be drawn with just a few commands. The name hints at its Matlab roots. Matplotlib’s slogan: “Make easy
things easy and hard things possible.” 16 .
Example Scenario: Plotting a line chart of time series, a bar chart of counts, scatter plots, etc. For example,
plt.hist(data) makes a histogram of data .
Memory Aid: Think “MATrix plot lib” for plotting arrays.

Snippet:

import matplotlib.pyplot as plt

x = [1,2,3,4]; y = [10,20,25,30]

3
 plt.plot(x, y)
plt.title("Sales over time")
plt.xlabel("Month"); plt.ylabel("Sales")
plt.show()

This creates a simple line plot. The plt.show() call renders the figure window.
Why Matplotlib: It’s the backbone of Python visualization – the library under the hood of
many others (including Seaborn). It’s very flexible and can produce publication-quality
graphics 17 .

Seaborn

Use: Statistical data visualization built on Matplotlib. Seaborn provides a high-level interface for creating
attractive plots (often with just one function call), especially for statistical charts. It works seamlessly with
Pandas DataFrames and includes themes and color palettes for nicer aesthetics. For example,
sns.histplot(data=df, x="age") will draw a histogram of the "age" column. Seaborn is great for
things like boxplots, violin plots, heatmaps, and regression plots.
Key Point: “Seaborn is a Python data visualization library based on Matplotlib. It provides a high-level interface
for drawing attractive and informative statistical graphics.” 18 .
Memory Aid: Recall the sea of data – Seaborn makes sense of it visually.

Snippet: import seaborn as sns allows you to use functions like sns.barplot() ,
sns.scatterplot() , etc. For example, sns.barplot(x='A', y='B', data=df)
creates a bar chart of column B for each category A . Seaborn handles much of the plotting
details automatically (statistical estimation, confidence intervals, nice style).

SciPy

Use: Scientific computing library. SciPy builds on NumPy by adding routines for optimization, statistics,
signal processing, linear algebra, and more. It is named from “Scientific Python.” For instance, SciPy includes
functions to fit curves to data, solve differential equations, perform Fourier transforms, etc. Essentially, it
supplements NumPy with advanced algorithms.
Key Fact: “SciPy is a scientific computation library that uses NumPy underneath. SciPy stands for Scientific
Python.” 19 . Many data scientists use SciPy alongside NumPy and Pandas for numerical tasks.
Example Scenario: Using scipy.optimize.curve_fit to fit a function to data, or
scipy.stats.ttest_ind for hypothesis testing.

Scikit-Learn

Use: Machine learning library. Scikit-learn (often sklearn ) offers easy-to-use tools for predictive modeling
(classification, regression), clustering, dimensionality reduction, and more. It is built on NumPy, SciPy and
Matplotlib 20 . Key features include consistent API (fit/predict), ready access to many algorithms (SVM,
random forests, k-means, etc.), and tools for data preprocessing and model evaluation. In short, it makes
machine learning more accessible 21 .
Example Scenario: Training a classifier:

4
 from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train) # train on feature matrix X and labels y
predictions = model.predict(X_test)

Why Scikit-Learn: It’s the go-to library for traditional ML in Python. It works “out of the box” for many tasks
and includes utilities like train_test_split , pipelines, and metrics for evaluation 21 .

Summary of Libraries: Each library serves a purpose: NumPy for fast arrays and math, Pandas for tabular
data, Matplotlib/Seaborn for plotting, SciPy for scientific algorithms, scikit-learn for machine learning.
Together they form the Python Data Science stack.

Resources:
- Article: NumPy Introduction (W3Schools) – Brief intro to NumPy and its array object 9 8 .
- Tutorial: Getting Started with Pandas – OurCodingClub – Overview of what Pandas is and why it’s popular
13 .

- Documentation: Matplotlib – Official site (“Matplotlib is a comprehensive library for creating static,
animated, and interactive visualizations in Python” 17 ).
- Documentation: Seaborn – Official site (intro line 18 ).
- Article: SciPy Tutorial (W3Schools) – Intro to SciPy (namesake, relation to NumPy) 19 .
- Article: Scikit-Learn Tutorial (GeeksforGeeks) – Overview of what scikit-learn provides (easy ML interface)
21 .

Line-by-Line Code Walkthrough

Let’s examine a concrete code example to see these pieces in action and explain each part in detail:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Create a simple DataFrame

data = pd.DataFrame({
"A": [1, 2, 3],
"B": [4, 5, 6]
})

# Add a new column by doubling column A

data["A_double"] = data["A"] * 2

# Plot a bar chart of A vs B

sns.barplot(x="A", y="B", data=data)

5
plt.title("Example Plot")
plt.show()

• import numpy as np :
• import is a Python keyword that loads a module or library into your code. It tells Python to bring
in external code so you can use it 22 .
• numpy is the module name. NumPy must be installed (e.g. via pip install numpy ) to import it.
• as is a keyword that creates an alias. Here it assigns np as a shorthand name for the numpy
module 10 .

• np (short for NumPy) is now an object we can use in place of numpy . This shortens code (so we
write np.array() instead of numpy.array() ). Why alias? Many libraries use long names (like
matplotlib.pyplot ), so aliases make code cleaner. (Examples: pd for pandas , plt for
matplotlib.pyplot below.) 10

• import pandas as pd :
Similar to above, this imports the Pandas library and gives it the alias pd . Now we can use
pd.DataFrame , pd.read_csv , etc. Memory aid: think “pandas (Panel Data) as pd.”

• import matplotlib.pyplot as plt :

This imports the pyplot submodule of Matplotlib under the alias plt . pyplot provides the
plotting API (e.g. plt.plot() , plt.show() ). We alias it to plt by convention (short for plot).

• import seaborn as sns :

Imports the Seaborn library as sns . We typically use sns to call functions like sns.histplot or
sns.barplot .

• Comment # Create a simple DataFrame :

In Python, anything after # on a line is a comment – it’s ignored by the interpreter and used only for
human readers. Here it explains the next block of code.

• data = pd.DataFrame({ "A": [1, 2, 3], "B": [4, 5, 6] }) :

• data is a variable name (left side of = ). Variables in Python are like labels for values in memory
23 . Here we’re creating a new DataFrame and storing it in data .
• The = operator assigns the value on the right to the variable on the left. According to Stanford’s
explanation, “A variable is created with an assignment = sign, with the variable’s name on the left
and the value on the right.” 23 So after this line, data points to the new DataFrame.
• pd.DataFrame(...) calls the DataFrame constructor from Pandas. We pass a Python dictionary
{ ... } as the argument.
◦ The dictionary has two key-value pairs: "A": [1,2,3] and "B": [4,5,6] . A Python
dictionary is a set of key-value pairs (here keys "A" and "B" with list values) 6 . Pandas
interprets each key as a column name and each value (the list) as column data.
◦ "A" and "B" are strings (the quotes show text). The lists [1,2,3] and [4,5,6] are
Python lists. Lists are mutable sequences of values.
• After this line, data is a DataFrame with two columns: A and B. In memory it looks like a table:

6
 A B
0 1 4
1 2 5
2 3 6

• Significance: We have constructed structured data. The DataFrame stores the arrays under the
hood (NumPy arrays), but with row/column labels. We could cite that a DataFrame is a 2D, size-
mutable, tabular data structure 11 .

• data["A_double"] = data["A"] * 2 :

• data["A"] accesses column A of the DataFrame; this is a Pandas Series (like an array of
[1,2,3] ). We then multiply it by 2 , which applies element-wise multiplication, giving a new
Series [2,4,6] .
• data["A_double"] = ... assigns this result as a new column named "A_double" . The left
side data["A_double"] means “the column labeled A_double” – if it doesn’t exist, Pandas creates
it.
• Word by word: data is our DataFrame; ["A_double"] is index access using a string (dictionary-
style) to specify a column. In Python, using [] with a key retrieves a value from a dict or, in Pandas,
a column. The = then sets/overwrites that column. The right side data["A"] * 2 multiplies each
element of column A by 2.
• Why use it? This demonstrates vectorized operations: Pandas/NumPy allow applying math to whole
arrays at once (no explicit loop needed).

• Result: The DataFrame now has a third column:

A B A_double
0 1 4 2
1 2 5 4
2 3 6 6

• Comment # Plot a bar chart of A vs B : Another comment explaining the next lines.

• sns.barplot(x="A", y="B", data=data) :

• This calls Seaborn’s barplot function.

◦ sns is our alias for Seaborn.
◦ barplot(...) creates a bar chart.
• The arguments use keywords: x="A" and y="B" tell Seaborn to use column "A" for the x-axis
and "B" for the y-axis (that is, one bar for each value of A with height B). data=data passes the
DataFrame to use.
• Each part: x= and y= specify axis names; the values "A" / "B" are strings naming the
DataFrame columns. Seaborn reads the data and computes the necessary statistics (for barplot it
plots mean of y for each category of x by default).

7
 • Significance: This draws an attractive statistical chart with minimal code. Seaborn “provides a high-
level interface for drawing attractive and informative statistical graphics” 18 . We didn’t have to
manually loop over values or calculate bar heights; barplot handled it.

• plt.title("Example Plot") :

• plt is the alias for matplotlib.pyplot . The title function sets the title of the current figure
to the given string. This is a pure plotting function (not data logic).

• plt.show() :

• This renders (displays) the plot window. In many environments (scripts, terminals, notebooks) you
call plt.show() to actually display the figure. Without it, the plot may not appear.

Each line above uses specific keywords and objects. By breaking it down word-by-word, we see how Python
syntax works:
- Keywords ( import , as , from , def , etc.) have special meaning (e.g. import brings in code, as
creates an alias).
- Identifiers ( np , pd , data , A_double ) name things (modules, variables, columns).
- Literals ( 42 , [1,2,3] , "A" ) specify constant values (numbers, lists, strings).
- Operators ( = , * ) perform actions (assignment, multiplication).
- Function/attribute calls ( pd.DataFrame() , sns.barplot() , plt.show() ) invoke library
functionality.

Throughout, short, descriptive names and comments help readability. For example, naming a column
"A_double" clearly indicates it’s twice column "A" . Using conventional aliases ( pd , plt , sns )
makes code more idiomatic.

Why This Code Matters: It illustrates a simple data analysis workflow: import libraries, create/process data
(with Pandas/NumPy), and visualize results (with Seaborn/Matplotlib). Each library’s purpose is evident. In
real tasks, data might come from files or user input instead of a hard-coded dictionary, but the structure is
the same.

Memory Aids and Examples

To reinforce these concepts, here are some mnemonics and examples:

• Data Types:
• Remember “Just the basics” – start with int for whole counts, float for decimals, str for text,
bool for yes/no.
• Mnemonic: INTeger (think integral numbers), STRing (a string of characters), BOOL (Boolean).

• Example: Ages (integer), temperature in °C (float), user name (string), is_active flag (boolean).

• Python Syntax:

8
 • import X as Y : Think alias – giving a shorthand nickname to a library. (Example:
import numpy as np → now np means numpy 10 .)
• Assignment = : Think of naming boxes in memory 23 . The left side is the box’s name; the right
side is what goes in it. (E.g. x = 5 makes x point to the integer 5.)

• Indexing [] : For lists/dicts/Pandas, obj[key] accesses an element. In a dict (or DataFrame) the
key is a string; in a list the key is an index number. (E.g. data["A"] gets column A.)

• Libraries:

• NumPy ( np ) – arrays of numbers: Numerical Python. Good for math. (E.g. np.array([1,2,3]) ).
• Pandas ( pd ) – labeled tables: Python Data Analysis. Good for CSVs and tables. (E.g.
pd.read_csv("file.csv") , pd.DataFrame(...) 11 .)
• Matplotlib/Seaborn – plotting libraries. Matplotlib is low-level (control every line/axis), Seaborn is
high-level (quick stats charts) 18 .
• SciPy – Scientific Python: think stats and calculus. (E.g. scipy.optimize , scipy.stats .) 19

• Scikit-Learn ( sklearn ) – machine learning engine. “Simple tools for predictive data analysis” 20 .

• Use Cases:

• Scenario 1: You have experimental data (e.g. measurements) in a CSV. Use Pandas to load it
( pd.read_csv ), clean it ( dropna , filter ), convert types ( .astype() ), and then compute
statistics with NumPy ( np.mean , np.std ). Finally, plot results with Matplotlib/Seaborn (e.g.
sns.lineplot ).
• Scenario 2: You want to classify emails as spam or not. You might use Pandas to preprocess text
data, convert text to numeric features, then use Scikit-Learn ( sklearn ) to train a model (like
LogisticRegression ) and evaluate its accuracy.
• Memory Example: To remember the import alias: think np stands for Numpy, pd for Pandas, plt for
Matplotlib’s plt.

What Next? Recommendations for Further Learning

You now have a solid foundation in Python basics and key libraries. To go deeper and keep learning,
consider the following steps:

1. Advanced Python Concepts: Learn about functions ( def ), classes/objects, error handling ( try/
except ), list/dict comprehensions, and modules. For example, practice writing your own functions
and classes. This will make your code more modular and powerful.
2. Data Structures & Algorithms: Strengthen your fundamentals with data structures (stacks, queues,
trees) and algorithms. This will improve your problem-solving skills and is essential for technical
interviews.
3. Version Control & Environment: Learn Git/GitHub for code versioning and collaboration. Practice
using virtual environments ( venv , conda ) to manage project dependencies.
4. Build Projects: Apply what you’ve learned by creating small projects. For example, analyze a dataset
(e.g. Kaggle datasets) or build a simple web scraper. Practical experience (even small scripts) is

9
 invaluable. As one mentor says, “once you have the basics, start making something – a project will teach
you 100× more than tutorials.” (Apply learning to real tasks!)
5. Web Development: If interested in web apps, learn HTML/CSS/JavaScript and Python web
frameworks like Flask or Django 24 . Noble Desktop notes that understanding web technologies
(HTML, CSS, JS) is essential for using Python in web development careers 24 .
6. Machine Learning / Data Science: Explore libraries beyond scikit-learn, such as TensorFlow or
PyTorch for deep learning. Study statistics and probability theory to understand ML algorithms.
Noble Desktop mentions Python’s widespread use in data science and ML, and suggests libraries like
TensorFlow, SciPy, Pandas, and scikit-learn for advanced work 25 . Consider taking an online course
or tutorial on machine learning fundamentals.
7. Visualization and UX: Practice making more complex visualizations (interactive dashboards with
Plotly or Bokeh), and learn to present data effectively.

Tailored Resources:
- Noble Desktop: “What to Learn After Python” – discusses paths like web development (HTML/CSS/JS,
Django) and machine learning (TensorFlow, SciPy) 24 25 .
- Kaggle Learn – free micro-courses on pandas, machine learning, data visualization.
- LeetCode or HackerRank – for practicing coding problems and algorithms.
- Real Python tutorials – deep dives on advanced topics.
- [Official library docs] – reading NumPy/Pandas docs will further your understanding.

Summary: Keep practicing coding and exploring projects in your area of interest. Learning is iterative:
revisit concepts when needed, read docs, and experiment. With these foundations and resources, you’ll be
able to advance quickly in Python and related fields.

1 2 3 5 Basic Data Types in Python: A Quick Exploration – Real Python

https://realpython.com/python-data-types/

4 7 23 cs.stanford.edu
https://cs.stanford.edu/people/nick/py/python-var.html

6 Dictionaries in Python – Real Python

https://realpython.com/python-dicts/

8 9 Introduction to NumPy
https://www.w3schools.com/python/numpy/numpy_intro.asp

10 as | Python Keywords – Real Python

https://realpython.com/ref/keywords/as/

11 Pandas DataFrames
https://www.w3schools.com/python/pandas/pandas_dataframes.asp

12 13 14 Introduction to Pandas in Python: Uses, Features & Benefits

https://www.learnenough.com/blog/how-to-import-Pandas-in-python?srsltid=AfmBOooLZAeomS97_m-V-
MgwxqDomyqJjr18YViULya43AO-BDmHTjvh

15 pandas.DataFrame — pandas 2.3.1 documentation - PyData |

https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html

10
16 17 Matplotlib — Visualization with Python
https://matplotlib.org/

18 seaborn: statistical data visualization — seaborn 0.13.2 documentation

https://seaborn.pydata.org/

19 Introduction to SciPy
https://www.w3schools.com/python/scipy/scipy_intro.php

20 21 Learning Model Building in Scikit-learn - GeeksforGeeks

https://www.geeksforgeeks.org/machine-learning/learning-model-building-scikit-learn-python-machine-learning-library/

22 Python import Keyword

https://www.w3schools.com/python/ref_keyword_import.asp

24 25 What to Learn After Python: Next Steps

https://www.nobledesktop.com/learn/python/what-to-learn-after-python

11