image
The Ultimate Drawing Course Beginner to Advanced...
$179
$79
image
User Experience Design Essentials - Adobe XD UI UX...
$179
$79
Total:
$659

Description

The problem
Most data analyst, data science, and coding courses miss a critical practical step. They don’t teach you how to work with raw data, how to clean, and preprocess it. This creates a sizeable gap between the skills you need on the job and the abilities you have acquired in training. Truth be told, real-world data is messy, so you need to know how to overcome this obstacle to become an independent data professional.
The bootcamps we have seen online and even live classes neglect this aspect and show you how to work with ‘clean’ data. But this isn’t doing you a favour. In reality, it will set you back both when you are applying for jobs, and when you’re on the job.
The solution
Our goal is to provide you with complete preparation. And this course will turn you into a job-ready data analyst. To take you there, we will cover the following fundamental topics extensively.
Theory about the field of data analytics
Basic Python
Advanced Python
NumPy
Pandas
Working with text files
Data collection
Data cleaning
Data preprocessing
Data visualization
Final practical example
Each of these subjects builds on the previous ones. And this is precisely what makes our curriculum so valuable. Everything is shown in the right order and we guarantee that you are not going to get lost along the way, as we have provided all necessary steps in video (not a single one skipped). In other words, we are not going to teach you how to analyse data before you know how to gather and clean it.
So, to prepare you for the entry-level job that leads to a data science position - data analyst - we created The Data Analyst Course.
This is a rather unique training program because it teaches the fundamentals you need on the job. A frequently neglected aspect of vital importance.
Moreover, our focus is to teach topics that flow smoothly and complement each other. The course provides complete preparation for someone who wants to become a data analyst at a fraction of the cost of traditional programs (not to mention the amount of time you will save). We believe that this resource will significantly boost your chances of landing a job, as it will prepare you for practical tasks and concepts that are frequently included in interviews.
The topics we will cover
1. Theory about the field of data analytics
2. Basic Python
3. Advanced Python
4. NumPy
5. Pandas
6. Working with text files
7. Data collection
8. Data cleaning
9. Data preprocessing
10. Data visualization
11. Final practical example
1. Theory about the field of data analytics
Here we will focus on the big picture. But don’t imagine long boring pages with terms you’ll have to check up in a dictionary every minute. Instead, this is where we want to define who a data analyst is, what they do, and how they create value for an organization.
Why learn it?
You need a general understanding to appreciate how every part of the course fits in with the rest of the content. As they say, if you know where you are going, chances are that you will eventually get there. And since data analyst and other data jobs are relatively new and constantly evolving, we want to provide you with a good grasp of the data analyst role specifically. Then, in the following chapters, we will teach you the actual tools you need to become a data analyst.
2. Basic Python
This course is centred around Python. So, we’ll start from the very basics. Don’t be afraid if you do not have prior programming experience.
Why learn it?
You need to learn a programming language to take full advantage of the data-rich world we live in. Unless you are equipped with such a skill, you will always be dependent on other people’s ability to extract and manipulate data, and you want to be
in
dependent while doing analysis, right? Also, you don’t necessarily need to learn many programming languages at once. It is enough to be very skilled at just one, and we’ve naturally chosen Python which has established itself as the number one language for data analysis and data science (thanks to its rich libraries and versatility).
3. Advanced Python
We will introduce advanced Python topics such as working with text data and using tools such as list comprehensions and anonymous functions.
Why learn it?
These lessons will turn you into a proficient Python user who is independent on the job. You will be able to use Python’s core strengths to your advantage. So, here it is not just about the topics, it is also about the depth in which we explore the most relevant Python tools.
4. NumPy
NumPy is Python’s fundamental package for scientific computing. It has established itself as the go-to tool when you need to compute mathematical and statical operations.
Why learn it?
A large portion of a data analyst’s work is dedicated to preprocessing datasets. Unquestionably, this involves tons of mathematical and statistical techniques that NumPy is renowned for. In addition, the package introduces multi-dimensional array structures and provides a plethora of built-in functions and methods to use while working with them. In other words, NumPy can be described as a computationally stable state-of-the-art Python instrument that provides flexibility and can take your analysis to the next level.
5. Pandas
The pandas library is one of the most popular Python tools that facilitate data manipulation and analysis. It is very valuable because you can use it to manipulate all sorts of information - numerical tables and time series data, as well as text.
Why learn it?
Pandas is the other main tool an analyst needs to clean and preprocess the data they are working with. Its data manipulation features are second to none in Python because of the diversity and richness it provides in terms of methods and functions. The combined ability to work with both NumPy and pandas is extremely powerful as the two libraries complement each other. You need to be capable to operate with both to produce a complete and consistent analysis independently.
6. Working with text files
Exchanging information with text files is practically how we exchange information today. In this part of the course, we will use the Python, pandas, and NumPy tools learned earlier to give you the essentials you need when importing or saving data.
Why learn it?
In many courses, you are just given a dataset to practice your analytical and programming skills. However, we don’t want to close our eyes to reality, where converting a raw dataset from an external file into a workable Python format can be a massive challenge.
7. Data collection
In the real world, you don’t always have the data readily available for you. In this part of the course, you will learn how to retrieve data from an API.
Why learn it?
You need to know how to source your data, right? To be a well-rounded analyst you must be able to collect data from outside sources. This is rarely a one-click process. This section aims at providing you with all the necessary tools to do that on your own.
8. Data cleaning
The next logical step is to clean your data. This is where you will apply the pandas skills acquired earlier in practice. All lessons throughout the course have a real-world perspective.
Why learn it?
A large part of a data analyst’s job in the real world involves cleaning data and preparing it for the actual analysis. You can’t expect that you’ll deal with flawless data sources, right? So, it will be up to you to overcome this stage and clean your data.
9. Data preprocessing
Even when your dataset is clean and in an understandable shape, it isn’t quite ready to be processed for visualizations and analysis just yet. There is a crucial step in between, and that’s data
pre
processing.
Why learn it?
Data preprocessing is where a data analyst can demonstrate how good or great they are at their job. This stage of the work requires the ability to choose the right statistical tool that will improve the quality of your dataset and the knowledge to implement it with advanced pandas and NumPy techniques. Only when you’ve completed this step can you say that your dataset is preprocessed and ready for the next part, which is data visualization.
10. Data visualization
Data visualization is the face of data. Many people look at the data and see nothing. The reason for that is that they are not creating good visualizations. Or even worse – they are creating nice graphs but cannot interpret them accurately.
Why learn it?
This part of the course will teach you how to use your data to produce meaningful insights. At the end of the day, data charts are what conveys the most information in the shortest amount of time. And nothing speaks better than a well crafted and meaningful data visualization.
11. Practical example
The course contains plenty of exercises and practical cases. In the end, we have included a comprehensive practical example that will show you how everything you have learned along the way comes nicely together. This is where you will be able to appreciate how far you have come in your journey to becoming a data analyst and starting your data career.
What you get
A program worth $1,250
Active Q&A support
All the knowledge to become a data analyst
A community of aspiring data analysts
A certificate of completion
Access to frequent future updates
Real-world training
Get ready to become a data analyst from scratch
Why wait? Every day is a missed opportunity.
Click the “Buy Now” button and become a part of our data analyst program today.
Who this course is for:
You should take this course if you want to become a Data Analyst and Data Scientist
This course is for you if you want a great career
The course is also ideal for beginners, as it starts from the fundamentals and gradually builds up your skills

What you'll learn

The course provides the complete preparation you need to become a data analyst

Fill up your resume with in-demand data skills: Python programming, NumPy, pandas, data preparation - data collection, data cleaning, data preprocessing, data visualization; data analysis, data analytics

Acquire a big picture understanding of the data analyst role

Learn beginner and advanced Python

Study mathematics for Python

We will teach you NumPy and pandas, basics and advanced

Be able to work with text files

Understand different data types and their memory usage

Learn how to obtain interesting, real-time information from an API with a simple script

Clean data with pandas Series and DataFrames

Complete a data cleaning exercise on absenteeism rate

Expand your knowledge of NumPy – statistics and preprocessing

Go through a complete loan data case study and apply your NumPy skills

Master data visualization

Learn how to create pie, bar, line, area, histogram, scatter, regression, and combo charts

Engage with coding exercises that will prepare you for the job

Practice with real-world data

Solve a final capstone project

Requirements

  • You will need a copy of Adobe XD 2019 or above. A free trial can be downloaded from Adobe.
  • No previous design experience is needed.
  • No previous Adobe XD skills are needed.

Course Content

27 sections • 95 lectures
Expand All Sections
1-Introduction to the Course
4
1.1-A Practical Example - What Will You Learn in This Course?
1.2-What Does the Course Cover?
1.3-Download All Resources
1.4-FAQ
2-Introduction to Data Analytics
5
2.1-Introduction to the World of Business and Data
2.2-Relevant Terms Explained
2.3-Data Analyst Compared to Other Data Jobs
2.4-Data Analyst Job Description
2.5-Why Python
3-Setting up the Environment
11
3.1-Introduction
3.2-Programming Explained in a Few Minutes
3.3-Programming Explained in a Few Minutes
3.4-Jupyter - Introduction
3.5-Jupyter - Installing Anaconda
3.6-Jupyter - Intro to Using Jupyter
3.7-Jupyter - Working with Notebook Files
3.8-Jupyter - Using Shortcuts
3.9-Jupyter - Handling Error Messages
3.10-Jupyter - Restarting the Kernel
3.11-Jupyter - Introduction
4-Python Basics
151
4.1-Python Variables
4.2-Python Variables - Exercise #1
4.3-Python Variables - Exercise #2
4.4-Python Variables - Exercise #3
4.5-Python Variables - Exercise #4
4.6-Python Variables
4.7-Types of Data - Numbers and Boolean Values
4.8-Numbers and Boolean Values - Exercise #1
4.9-Numbers and Boolean Values - Exercise #2
4.10-Numbers and Boolean Values - Exercise #3
4.11-Numbers and Boolean Values - Exercise #4
4.12-Numbers and Boolean Values - Exercise #5
4.13-Types of Data - Numbers and Boolean Values
4.14-Types of Data - Strings
4.15-Strings - Exercise #1
4.16-Strings - Exercise #2
4.17-Strings - Exercise #3
4.18-Strings - Exercise #4
4.19-Strings - Exercise #5
4.20-Types of Data - Strings
4.21-Basic Python Syntax - Arithmetic Operators
4.22-Arithmetic Operators - Exercise #1
4.23-Arithmetic Operators - Exercise #2
4.24-Arithmetic Operators - Exercise #3
4.25-Arithmetic Operators - Exercise #4
4.26-Arithmetic Operators - Exercise #5
4.27-Arithmetic Operators - Exercise #6
4.28-Arithmetic Operators - Exercise #7
4.29-Arithmetic Operators - Exercise #8
4.30-Basic Python Syntax - Arithmetic Operators
4.31-Basic Python Syntax - The Double Equality Sign
4.32-The Double Equality Sign - Exercise #1
4.33-Basic Python Syntax - The Double Equality Sign
4.34-Basic Python Syntax - Reassign Values
4.35-Reassign Values - Exercise #1
4.36-Reassign Values - Exercise #2
4.37-Reassign Values - Exercise #3
4.38-Reassign Values - Exercise #4
4.39-Basic Python Syntax - Reassign Values
4.40-Basic Python Syntax - Add Comments
4.41-Basic Python Syntax - Add Comments
4.42-Basic Python Syntax - Line Continuation
4.43-Line Continuation - Exercise #1
4.44-Basic Python Syntax - Indexing Elements
4.45-Indexing Elements - Exercise #1
4.46-Indexing Elements - Exercise #2
4.47-Basic Python Syntax - Indexing Elements
4.48-Basic Python Syntax - Indentation
4.49-Indentation - Exercise #1
4.50-Basic Python Syntax - Indentation
4.51-Operators - Comparison Operators
4.52-Comparison Operators - Exercise #1
4.53-Comparison Operators - Exercise #2
4.54-Comparison Operators - Exercise #3
4.55-Comparison Operators - Exercise #4
4.56-Operators - Comparison Operators
4.57-Operators - Logical and Identity Operators
4.58-Logical and Identity Operators - Exercise #1
4.59-Logical and Identity Operators - Exercise #2
4.60-Logical and Identity Operators - Exercise #3
4.61-Logical and Identity Operators - Exercise #4
4.62-Logical and Identity Operators - Exercise #5
4.63-Logical and Identity Operators - Exercise #6
4.64-Operators - Logical and Identity Operators
4.65-Conditional Statements - The IF Statement
4.66-The IF Statement - Exercise #1
4.67-The IF Statement - Exercise #2
4.68-Conditional Statements - The IF Statement
4.69-Conditional Statements - The ELSE Statement
4.70-The ELSE Statement - Exercise #1
4.71-Conditional Statements - The ELIF Statement
4.72-The ELIF Statement - Exercise #1
4.73-The ELIF Statement - Exercise #2
4.74-Conditional Statements - A Note on Boolean Values
4.75-Conditional Statements - A Note on Boolean Values
4.76-Functions - Defining a Function in Python
4.77-Functions - Creating a Function with a Parameter
4.78-Creating a Function with a Parameter - Exercise #1
4.79-Creating a Function with a Parameter - Exercise #2
4.80-Functions - Another Way to Define a Function
4.81-Another Way to Define a Function - Exercise #1
4.82-Functions - Using a Function in Another Function
4.83-Using a Function in Another Function - Exercise #1
4.84-Functions - Combining Conditional Statements and Functions
4.85-Conditional Statements and Functions - Exercise #1
4.86-Functions - Creating Functions That Contain a Few Arguments
4.87-Functions - Notable Built-in Functions in Python
4.88-Notable Built-in Functions in Python - Exercise #1
4.89-Notable Built-In Functions in Python - Exercise #2
4.90-Notable Built-In Functions in Python - Exercise #3
4.91-Notable Built-In Functions in Python - Exercise #4
4.92-Notable Built-In Functions in Python - Exercise #5
4.93-Notable Built-In Functions in Python - Exercise #6
4.94-Notable Built-In Functions in Python - Exercise #7
4.95-Notable Built-In Functions in Python - Exercise #8
4.96-Notable Built-In Functions in Python - Exercise #9
4.97-Functions
4.98-Sequences - Lists
4.99-Lists - Exercise #1
4.100-Lists - Exercise #2
4.101-Lists - Exercise #3
4.102-Lists - Exercise #4
4.103-Lists - Exercise #5
4.104-Sequences - Lists
4.105-Sequences - Using Methods
4.106-Using Methods - Exercise #1
4.107-Using Methods - Exercise #2
4.108-Using Methods - Exercise #3
4.109-Using Methods - Exercise #4
4.110-Sequences - Using Methods
4.111-Sequences - List Slicing
4.112-List Slicing - Exercise #1
4.113-List Slicing - Exercise #2
4.114-List Slicing - Exercise #3
4.115-List Slicing - Exercise #4
4.116-List Slicing - Exercise #5
4.117-List Slicing - Exercise #6
4.118-List Slicing - Exercise #7
4.119-Sequences - Tuples
4.120-Tuples - Exercise #1
4.121-Tuples - Exercise #2
4.122-Tuples - Exercise #3
4.123-Tuples - Exercise #4
4.124-Sequences - Dictionaries
4.125-Dictionaries - Exercise #1
4.126-Dictionaries - Exercise #2
4.127-Dictionaries - Exercise #3
4.128-Dictionaries - Exercise #4
4.129-Dictionaries - Exercise #5
4.130-Dictionaries - Exercise #6
4.131-Sequences - Dictionaries
4.132-Iteration - For Loops
4.133-For Loops - Exercise #1
4.134-For Loops - Exercise #2
4.135-Iteration - For Loops
4.136-Iteration - While Loops and Incrementing
4.137-While Loops and Incrementing - Exercise #1
4.138-Iteration - Create Lists with the range() Function
4.139-Create Lists with the range() Function - Exercise #1
4.140-Create Lists with the range() Function - Exercise #2
4.141-Create Lists with the range() Function - Exercise #3
4.142-Iteration - Create Lists with the range() Function
4.143-Iteration - Use Conditional Statements and Loops Together
4.144-Conditional Statements and Loops - Exercise #1
4.145-Conditional Statements and Loops - Exercise #2
4.146-Conditional Statements and Loops - Exercise #3
4.147-Iteration - Conditional Statements, Functions, and Loops
4.148-Conditional Statements, Functions, and Loops - Exercise #1
4.149-Iteration - Iterating over Dictionaries
4.150-Iterating over Dictionaries - Exercise #1
4.151-Iterating over Dictionaries - Exercise #2
5-Fundamentals for Coding in Python
6
5.1-Object-Oriented Programming (OOP)
5.2-Modules, Packages, and the Python Standard Library
5.3-Importing Modules
5.4-Introduction to Using NumPy and pandas
5.5-What is Software Documentation?
5.6-The Python Documentation
6-Mathematics for Python
11
6.1-What Is а Matrix?
6.2-Scalars and Vectors
6.3-Linear Algebra and Geometry
6.4-Arrays in Python
6.5-What Is a Tensor?
6.6-Adding and Subtracting Matrices
6.7-Errors When Adding Matrices
6.8-Transpose
6.9-Dot Product of Vectors
6.10-Dot Product of Matrices
6.11-Why is Linear Algebra Useful
7-NumPy Basics
5
7.1-The NumPy Package and Why We Use It
7.2-Installing/Upgrading NumPy
7.3-Ndarray
7.4-The NumPy Documentation
7.5-NumPy Basics - Exercise
8-Pandas - Basics
55
8.1-Introduction to the pandas Library
8.2-Installing and Running pandas
8.3-Installing and Running pandas - Exercise #1
8.4-A Note on Completing the Upcoming Coding Exercises
8.5-Installing and Running pandas - Exercise #2
8.6-Introduction to pandas Series
8.7-Introduction to pandas Series - Exercise #1
8.8-Introduction to pandas Series - Exercise #2
8.9-Introduction to pandas Series - Exercise #3
8.10-Introduction to pandas Series - Exercise #4
8.11-Introduction to pandas Series - Exercise #5
8.12-Introduction to pandas Series - Exercise #6
8.13-Introduction to pandas Series - Exercise #7
8.14-Introduction to pandas Series - Exercise #8
8.15-Introduction to pandas Series - Exercise #9
8.16-Introduction to pandas Series - Exercise #10
8.17-Working with Attributes in Python
8.18-Working with Attributes in Python - Exercise #1
8.19-Working with Attributes in Python - Exercise #2
8.20-Working with Attributes in Python - Exercise #3
8.21-Working with Attributes in Python - Exercise #4
8.22-Working with Attributes in Python - Exercise #5
8.23-Working with Attributes in Python - Exercise #6
8.24-Working with Attributes in Python - Exercise #7
8.25-Using an Index in pandas
8.26-Using an Index in pandas - Exercise #1
8.27-Using an Index in pandas - Exercise #2
8.28-Using an Index in pandas - Exercise #3
8.29-Using an Index in pandas - Exercise #4
8.30-Using an Index in pandas - Exercise #5
8.31-Label-based vs Position-based Indexing
8.32-Label-based vs Position-based Indexing - Exercise #1
8.33-Label-based vs Position-based Indexing - Exercise #2
8.34-More on Working with Indices in Python
8.35-More on Working with Indices in Python - Exercise #3
8.36-More on Working with Indices in Python - Exercise #4
8.37-More on Working with Indices in Python - Exercise #5
8.38-Using Methods in Python - Part I
8.39-Using Methods in Python - Part II
8.40-Using Methods in Python - Exercise #1
8.41-Using Methods in Python - Exercise #2
8.42-Parameters vs Arguments
8.43-Parameters vs Arguments - Exercise #1
8.44-Parameters vs Arguments - Exercise #2
8.45-The pandas Documentation
8.46-Introduction to pandas DataFrames
8.47-Creating DataFrames from Scratch - Part I
8.48-Creating DataFrames from Scratch - Exercise #1
8.49-Creating DataFrames from Scratch - Exercise #2
8.50-Creating DataFrames from Scratch - Part II
8.51-Creating DataFrames from Scratch - Exercise #3
8.52-Creating DataFrames from Scratch - Exercise #4
8.53-Creating DataFrames from Scratch - Exercise #5
8.54-Additional Notes on Using DataFrames
8.55-pandas Basics - Conclusion
9-Working with Text Files
36
9.1-Working with Files in Python - An Introduction
9.2-File vs File Object, Read vs Parse
9.3-Structured vs Semi-Structured and Unstructured Data
9.4-Data Connectivity through Text Files
9.5-Principles of Importing Data in Python
9.6-More on Text Files (*.txt vs *.csv)
9.7-Fixed-width Files
9.8-Common Naming Conventions Used in Programming
9.9-Importing Text Files in Python ( open() )
9.10-Importing Text Files in Python ( open() ) - Exercise #1
9.11-Importing Text Files in Python ( open() ) - Exercise #2
9.12-Importing Text Files in Python ( with open() )
9.13-Importing Text Files in Python ( with open() ) - Exercise #1
9.14-Importing Text Files in Python ( with open() ) - Exercise #2
9.15-Importing Text Files in Python ( with open() ) - Exercise #3
9.16-Importing Text Files in Python ( with open() ) - Exercise #4
9.17-Importing Text Files in Python ( with open() ) - Exercise #5
9.18-Importing *.csv Files with pandas - Part I
9.19-Importing *.csv Files with pandas - Part II
9.20-Importing *.csv Files with pandas - Part III
9.21-Importing Data with the "index_col" Parameter
9.22-Importing Data with NumPy - .loadtxt() vs genfromtxt()
9.23-Importing Data with NumPy - Partial Cleaning While Importing
9.24-Importing *.json Files
9.25-Prelude to Working with Excel Files in Python
9.26-Working with Excel Data (the *.xlsx Format)
9.27-Importing Data with NumPy - Exercise
9.28-An Important Exercise on Importing Data in Python
9.29-Importing Data with the pandas' "Squeeze" Method
9.30-A Note on Importing Files in Jupyter
9.31-Saving Your Data with pandas
9.32-Saving Your Data with NumPy - np.save()
9.33-Saving Your Data with NumPy - np.savez()
9.34-Saving Your Data with NumPy - np.savetxt()
9.35-Saving Your Data with NumPy - Exercise
9.36-Working with Text Files - Conclusion
10-Working with Text Data
44
10.1-Working with Text Data and Argument Specifiers
10.2-Text Data and Argument Specifiers - Exercise #1
10.3-Text Data and Argument Specifiers - Exercise #2
10.4-Text Data and Argument Specifiers - Exercise #3
10.5-Manipulating Python Strings
10.6-Manipulating Python Strings - Exercise #1
10.7-Manipulating Python Strings - Exercise #2
10.8-Manipulating Python Strings - Exercise #3
10.9-Manipulating Python Strings - Exercise #4
10.10-Manipulating Python Strings - Exercise #5
10.11-Using Various Python String Methods - Part I
10.12-Python String Methods - Exercise #1
10.13-Python String Methods - Exercise #2
10.14-Python String Methods - Exercise #3
10.15-Python String Methods - Exercise #4
10.16-Python String Methods - Exercise #5
10.17-Python String Methods - Exercise #6
10.18-Python String Methods - Exercise #7
10.19-Python String Methods - Exercise #8
10.20-Python String Methods - Exercise #9
10.21-Python String Methods - Exercise #10
10.22-Python String Methods - Exercise #11
10.23-Python String Methods - Exercise #12
10.24-Python String Methods - Exercise #13
10.25-Python String Methods - Exercise #14
10.26-Python String Methods - Exercise #15
10.27-Using Various Python String Methods - Part II
10.28-Python String Methods - Exercise #16
10.29-Python String Methods - Exercise #17
10.30-Python String Methods - Exercise #18
10.31-Python String Methods - Exercise #19
10.32-Python String Methods - Exercise #20
10.33-String Accessors
10.34-String Accessors - Exercise #1
10.35-String Accessors - Exercise #2
10.36-String Accessors - Exercise #3
10.37-String Accessors - Exercise #4
10.38-String Accessors - Exercise #5
10.39-Using the .format() Method
10.40-Using the .format() Method - Exercise #1
10.41-Using the .format() Method - Exercise #2
10.42-Using the .format() Method - Exercise #3
10.43-Using the .format() Method - Exercise #4
10.44-Using the .format() Method - Exercise #5
11-Must-Know Python Tools
21
11.1-Iterating Over Range Objects
11.2-Nested For Loops - Introduction
11.3-Triple Nested For Loops
11.4-Triple Nested For Loops - Exercise #1
11.5-Triple Nested For Loops - Exercise #2
11.6-Triple Nested For Loops - Exercise #3
11.7-Triple Nested For Loops - Exercise #4
11.8-Triple Nested For Loops - Exercise #5
11.9-Triple Nested For Loops - Exercise #6
11.10-Triple Nested For Loops - Exercise #7
11.11-List Comprehensions
11.12-List Comprehensions - Exercise #1
11.13-List Comprehensions - Exercise #2
11.14-List Comprehensions - Exercise #3
11.15-List Comprehensions - Exercise #4
11.16-List Comprehensions - Exercise #5
11.17-Anonymous (Lambda) Functions
11.18-Anonymous Functions - Exercise #1
11.19-Anonymous Functions - Exercise #2
11.20-Anonymous Functions - Exercise #3
11.21-Anonymous Functions - Exercise #4
12-Data Gathering/Data Collection
1
12.1-What is data gathering/data collection?
13-APIs (POST requests are not needed for this course)
12
13.1-Overview of APIs
13.2-GET and POST Requests
13.3-Data Exchange Format for APIs: JSON
13.4-Introducing the Exchange Rates API
13.5-Including Parameters in a GET Request
13.6-More Functionalities of the Exchange Rates API
13.7-Coding a Simple Currency Conversion Calculator
13.8-iTunes API
13.9-iTunes API: Homework
13.10-iTunes API: Structuring and Exporting the Data
13.11-Pagination: GitHub API
13.12-APIs: Exercise
14-Data Cleaning and Data Preprocessing
1
14.1-Data Cleaning and Data Preprocessing
15-pandas Series
26
15.1-Running pandas - Exercise
15.2-.unique(), .nunique()
15.3-.unique(), .nunique() - Exercise #1
15.4-.unique(), .nunique() - Exercise #2
15.5-.unique(), .nunique() - Exercise #3
15.6-.unique(), .nunique() - Exercise #4
15.7-.unique(), .nunique() - Exercise #5
15.8-.unique(), .nunique() - Exercise #6
15.9-Converting Series into Arrays
15.10-.sort_values()
15.11-.sort_values() - Exercise #1
15.12-.sort_values() - Exercise #2
15.13-.sort_values() - Exercise #3
15.14-.sort_values() - Exercise #4
15.15-Attribute and Method Chaining
15.16-Attribute and Method Chaining - Exercise #1
15.17-Attribute and Method Chaining - Exercise #2
15.18-Attribute and Method Chaining - Exercise #3
15.19-Attribute and Method Chaining - Exercise #4
15.20-Attribute and Method Chaining - Exercise #5
15.21-Attribute and Method Chaining - Exercise #6
15.22-.sort_index()
15.23-.sort_index - Exercise #1
15.24-.sort_index - Exercise #2
15.25-.sort_index - Exercise #3
15.26-.sort_index - Exercise #4
16-pandas DataFrames
6
16.1-A Revision to pandas DataFrames
16.2-Common Attributes for Working with DataFrames
16.3-Data Selection in pandas DataFrames
16.4-Data Selection - Indexing with .iloc[]
16.5-Data Selection - Indexing with .loc[]
16.6-A Few Comments on Using .loc[] and .iloc[]
17-NumPy Fundamentals
7
17.1-Indexing in NumPy
17.2-Assigning Values in NumPy
17.3-Elementwise Properties of Arrays
17.4-Types of Data Supported by NumPy
17.5-Characteristics of NumPy Functions Part 1
17.6-Characteristics of NumPy Functions Part 2
17.7-NumPy Fundamentals - Exercise
18-NumPy DataTypes
4
18.1-ndarrays
18.2-Arrays vs Lists
18.3-Strings vs Object vs Number
18.4-NumPy DataTypes - Exercise
19-Working with Arrays
5
19.1-Basic Slicing in NumPy
19.2-Stepwise Slicing in NumPy
19.3-Conditional Slicing in NumPy
19.4-Dimensions and the Squeeze Function
19.5-Working with Arrays - Exercise
20-Generating Data with NumPy
8
20.1-Arrays of 0s and 1s
20.2-"_like" functions in NumPy
20.3-A Non-Random Sequence of Numbers
20.4-Random Generators and Seeds
20.5-Basic Random Functions in NumPy
20.6-Probability Distributions in NumPy
20.7-Applications of Random Data in NumPy
20.8-Generating Data with NumPy - Exercise
21-Statistics with NumPy
9
21.1-Using Statistical Functions in NumPy
21.2-Minimal and Maximal Values in NumPy
21.3-Statistical Order Functions in NumPy
21.4-Averages and Variance in NumPy
21.5-Covariance and Correlation in NumPy
21.6-Histograms in NumPy (Part 1)
21.7-Histograms in NumPy (Part 2)
21.8-NAN Equivalent Functions in NumPy
21.9-Statistics with NumPy - Exercise
22-NumPy - Preprocessing
13
22.1-Checking for Missing Values in Ndarrays
22.2-Substituting Missing Values in Ndarrays
22.3-Reshaping Ndarrays
22.4-Removing Values from Ndarrays
22.5-Sorting Ndarrays
22.6-Argument Sort in NumPy
22.7-Argument Where in NumPy
22.8-Shuffling Ndarrays
22.9-Casting Ndarrays
22.10-Striping Values from Ndarrays
22.11-Stacking Ndarrays
22.12-Concatenating Ndarrays
22.13-Finding Unique Values in Ndarrays
23-A Loan Data Example with NumPy
15
23.1-Setting Up: Introduction to the Practical Example
23.2-Setting Up: Importing the Data Set
23.3-Setting Up: Checking for Incomplete Data
23.4-Setting Up: Splitting the Dataset
23.5-Setting Up: Creating Checkpoints
23.6-Manipulating Text Data: Issue Date
23.7-Manipulating Text Data: Loan Status and Term
23.8-Manipulating Text Data: Grade and Sub Grade
23.9-Manipulating Text Data: Verification Status & URL
23.10-Manipulating Text Data: State Address
23.11-Manipulating Text Data: Converting Strings and Creating a Checkpoint
23.12-Manipulating Numeric Data: Substitute Filler Values
23.13-Manipulating Numeric Data: Currency Change – The Exchange Rate
23.14-Manipulating Numeric Data: Currency Change - From USD to EUR
23.15-Completing the Dataset
24-The "Absenteeism" Exercise - Introduction
3
24.1-An Introduction to the "Absenteeism" Exercise
24.2-The "Absenteeism" Exercise from a Business Perspective
24.3-The Dataset
25-Solution to the "Absenteeism" Exercise
18
25.1-How to Complete the Absenteeism Exercise
25.2-Eyeball Your Data First
25.3-Note: Programming vs the Rest of the World
25.4-Using a Statistical Approach to Solve Our Exercise
25.5-Dropping the 'ID' Column
25.6-Analysis of the 'Reason for Absence' Column
25.7-Splitting the Reasons for Absence into Multiple Dummy Variables
25.8-Working with Dummy Variables - A Statistical Perspective
25.9-Grouping the Reason for Absence Columns
25.10-Concatenating Columns in a pandas DataFrame
25.11-Reordering Columns in a DataFrame
25.12-Creating Checkpoints
25.13-Working on the 'Date' Column
25.14-Extracting the Month Value from the 'Date' Column
25.15-Creating the 'Day of the Week' Column
25.16-Understanding the Meaning of 5 More Columns
25.17-Modifying the 'Education' Column
25.18-Final Remarks on the Absenteeism Exercise
26-Data Visualization
37
26.1-What Is Data Visualization and Why Is It Important?
26.2-Why Learn Data Visualization?
26.3-Choosing the Right Visualization – What Are Some Popular Approaches and Framewor
26.4-Introduction into Colors and Color Theory
26.5-Bar Chart - Introduction - General Theory and Getting to Know the Dataset
26.6-Bar Chart - How to Create a Bar Chart Using Python
26.7-Bar Chart – Interpreting the Bar Graph. How to Make a Good Bar Graph
26.8-Pie Chart - Introduction - General Theory and Dataset
26.9-Pie Chart - How to Create a Pie Chart Using Python
26.10-Pie Chart – Interpreting the Pie Chart
26.11-Pie Chart - Why You Should Never Create a Pie Graph
26.12-Stacked Area Chart - Introduction - General Theory. Getting to Know the Dataset
26.13-Stacked Area Chart - How to Create a Stacked Area Chart Using Python
26.14-Stacked Area Chart - Interpreting the Stacked Area Graph
26.15-Stacked Area Chart - How to Make a Good Stacked Area Chart
26.16-Line Chart - Introduction - General Theory. Getting to Know the Dataset
26.17-Line Chart - How to Create a Line Chart in Python
26.18-Line Chart - Interpretation
26.19-Line Chart - How to Make a Good Line Chart
26.20-Histogram - Introduction - General Theory. Getting to Know the Dataset
26.21-Histogram - How to Create a Histogram Using Python
26.22-Histogram – Interpreting the Histogram
26.23-Histogram – Choosing the Number of Bins in a Histogram
26.24-Histogram - How to Make a Good Histogram
26.25-Scatter Plot - Introduction - General Theory. Getting to Know the Dataset
26.26-Scatter Plot - How to Create a Scatter Plot Using Python
26.27-Scatter Plot – Interpreting the Scatter Plot
26.28-Scatter Plot - How to Make a Good Scatter Plot
26.29-Regression Plot - Introduction - General Theory. Getting to Know the Dataset
26.30-Regression Plot - How to Create a Regression Scatter Plot Using Python
26.31-Regression Plot – Interpreting the Regression Scatter Plot
26.32-Regression Plot - How to Make a Good Regression Plot
26.33-Bar and Line Chart - Introduction - General Theory. Getting to Know the Dataset
26.34-Bar and Line Chart - How to Create a Combination Bar and Line Graph Using Python
26.35-Bar and Line Chart – Interpreting the Combination Bar and Line Graph
26.36-Bar and Line Chart – How to Make a Good Bar and Line Graph
26.37-Data Visualization - Exercise
27-Conclusion
2
27.1-Conclusion
27.2-Bonus