Django is a widely used free, open-source, and high-level web development framework. It provides a lot of features to the developers &quot;out of the box,&quot; so development can be rapid. However, websites built from it are secured, scalable, and maintainable at the same time.
<h2 id="goal">Goal</h2>
The goal of this tutorial is to build a blog application where the blog content can be created and updated through an administration panel. Blog contents are displayed on the page and can be deleted if needed.Overall application provides CRUD(Create,Read,Update,Delete) functionality. 
This tutorial doesn&#39;t use any FrontEnd technologies like Javascript, CSS, etc. but focuses on basic yet essential concepts that are needed in every Django Web Development.
<h2 id="required-setup">Required Setup</h2>
<ol>
<li>Git Bash: The user of all operating systems can use it. All the Django related commands and Unix commands are done through it. For downloading the Git bash: <a href="https://git-scm.com/downloads">Click Me</a>.</li>
<li>Text-Editor: Any Text-Editor like Sublime Text or Visual Studio Code can be used. For the following project, <a href="https://www.sublimetext.com/">Sublime Text</a> is used.</li>
<li>Python 3: The latest version of Python can be downloaded in <a href="https://www.python.org/downloads/">Download Python</a>.</li>
</ol>
Note: You can easily follow along with this tutorial if you understand the basics of Python and know about loops, function, classes, etc., and some knowledge of bash or command line.
<h2 id="virtual-environment">Virtual Environment</h2>
Virtual Environment acts as dependencies to the Python-related projects. It works as a self-contained container or an isolated environment where all the Python-related packages and the required versions related to a specific project are installed. Since newer versions of Python, Django, or packages, etc. will roll out, through the help of a Virtual Environment, you can work with older versions that are specific to your project. In Summary, you can start an independent project related to Django of version 2.0, whereas another independent project related to Django of version 3.0 can be started on the same computer. 
Note: There are many ways of creating a Virtual Environment, but only one way is shown below.
<h2 id="steps-to-create-a-virtual-environment">Steps to create a Virtual Environment</h2>
<ol>
<li>You can create the new directory named &#39;project-blog&#39; by using &#39;mkdir&#39; command in your Desktop.</li>
<li>Change the directory to &#39;project-blog&#39; by using &#39;cd&#39; command.
 <img src="https://i.imgur.com/GfvSQUj.png"> 
</li>
<li>The virtual environment is created by using &#39;python -m venv env&#39;, where env is our virtual environment shown by &#39;ls&#39; command.
 <img src="https://i.imgur.com/CbBq40I.png"> 
</li>
<li>For Activating your Virtual Environment:
The Virtual Environment can be activated by using the &#39;source&#39; command where the &#39;Scripts&#39; folder needs to be enabled or activated.
 <img src="https://i.imgur.com/Gu15w7W.png"> 
The &#39;env&#39; will be shown in the parenthesis if you&#39;ve successfully activated your Virtual Environment. 
</li>
<li>Installing the required package:
You can use &#39;pip install django&#39; to install Django in your specific Virtual Environment.
 <img src="https://i.imgur.com/PgLbUsT.png"> </li>
</ol>
Note: Linux and Mac users need to use &#39;python3&#39; specifically in the command because Python of version 2 is already pre-installed in their computer. Also, It is preferable to use version 3 as of now Python will not support version 2 after the year 2020.
<h2 id="creating-a-django-project">Creating a Django Project</h2>
<ol>
<li>The first step is creating your project by using the &#39;django-admin startproject <code>project_name</code>&#39; command, where &#39;project_name&#39; is &#39;django_blog&#39; in your case. Also, it will generate a lot of files inside our newly created project, which you can research further in <a href="https://docs.djangoproject.com/en/3.0/intro/tutorial01/">Django documentation </a> if needed.
 <img src="https://i.imgur.com/abCcs9y.png"> </li>
<li>Change the directory to the newly created project using &#39;cd&#39; command and to view the created file using &#39;ls&#39; command.
 <img src="https://i.imgur.com/81EkZNS.png"> </li>
<li>You can run your project by using &#39;python manage.py runserver&#39;.
 <img src="https://i.imgur.com/zLcoMn5.png"> </li>
<li>The project can be viewed in your favorite browser (Google Chrome, Mozilla Firefox, etc.).You can come into your browser and type &#39;localhost:8000&#39; or &#39;127.0.0.1:8000&#39; in the URL, as shown below.
 <img src="https://i.imgur.com/wOA4abG.png"> 
Note: To get the same page as above, the server in the bash needs to be running in the background. Also, you can manually stop the server if needed by hitting &#39;Ctr+C&#39; in Windows/Linux and &#39;Cmd+C&#39; in Mac.</li>
</ol>
<h2 id="starting-the-new-project">Starting the new Project</h2>
For creating a new project in the Django, it&#39;s always a two-step process, which is shown below.
<ol>
<li>The first step is to create an app by using &#39;python manage.py startapp <code>app_name</code>&#39; command, where app_name is &#39;blog&#39; in your case.
In Django, there are many apps to the single project where each app serves as single and specific functionality to the particular project.
 <img src="https://i.imgur.com/sr5TjIf.png"> </li>
<li>The second step is to make our project let know about our newly created app by making changes to the &#39;django_blog/settings.py&#39; INSTALLED_APP section.
 <img src="https://i.imgur.com/fwaWBa1.png"></li>
</ol>
<h2 id="changing-in-our-models">Changing in our Models</h2>
Django uses &#39;SQLite&#39; as the default database, which is light and only used for small projects, which is fine for this project.
It uses &#39;Object Relational Mapper(ORM)&#39; which makes it really easy to work with the database. The actual database code is not written, whereas the database tables are created through the help of &#39;class&#39; keyword in &#39;models.py&#39;.
Inside &#39;blog/models.py&#39;, you need to create a new model named &#39;Post&#39;. This is a class that will become a database table afterward which currently inherits from &#39;models.Model&#39;. As in a standard blog, a certain &#39;Post&#39; contains a title, which will be a field called CharField. It is a text-based column and accepts mandatory argument as &#39;max_length&#39;, which happens to be 50 in your case. Also, there is another field named &#39;content&#39;, which is the TextField, which contains the detail text of the &#39;Post&#39; as in a standard blog.
The double underscore(&#39;str&#39;) method is defined, which overrides the field &#39;title&#39; and returns the name of actual &#39;title&#39; instead of some objects.
 <img src="https://i.imgur.com/od9GmHw.png">
<h3 id="making-a-migrations">Making a Migrations</h3>
&#39;python manage.py makemigrations&#39; is a first step process which reads the &#39;models.py&#39; after it&#39;s creation. It creates a new folder called &#39;migrations&#39; where there is a file named &#39;0001_initial.py&#39;, which are portable across the database.
 <img src="https://i.imgur.com/Ab0weiT.png">
<h3 id="migrating-to-the-database">Migrating to the database</h3>
This is the second step where &#39;python manage.py migrate&#39; reads the newly created folder &#39;migrations&#39; and creates the database, and it evolves the database when there is a change in the model.
 <img src="https://i.imgur.com/zh5hYWe.png">
<h3 id="registering-to-the-admin">Registering to the admin</h3>
Let&#39;s move to &#39;blog/admin.py&#39; and do an import of the models called &#39;Post&#39; by using &#39;from .models import Post&#39;. To register models to the admin, the command is &#39;admin.site.register(Post)&#39;.
 <img src="https://i.imgur.com/z7WQZD3.png">
<h3 id="creating-superuser-and-viewing-in-the-administration-panel">Creating SuperUser and Viewing in the Administration panel</h3>
You need to create a SuperUser before accessing the &#39;admin&#39; panel. To do so, use &#39;winpty python manage.py createsuperuser&#39;.
 <img src="https://i.imgur.com/k2JLU52.png"> 
Note: winpty is bash specific command used for communicating with Windows Console Programs. 
Run your server in the background in bash by command python manage.py runserver. Head over to the browser and type the following in the URL.
 <img src="https://i.imgur.com/ZEv8Qgv.png"> 
Fill out your details afterward, i.e., the username and password that you&#39;ve created earlier:
 <img src="https://i.imgur.com/lWGLVzw.png"> 
View your admin panel afterward with our newly created models &#39;Post&#39;.
 <img src="https://i.imgur.com/VVMr1EV.png"> 
Change the content of the &#39;Post&#39; by clicking the &#39;Add&#39; button. Fill out the information and &#39;Save&#39; the detail.
 <img src="https://i.imgur.com/To8du5O.png">
<h3 id="changing-in-views-and-urls">Changing in views and urls</h3>
Move to &#39;blog/views.py&#39; and make the changes as shown below. Add the function &#39;blog_list&#39;, which takes in the request. The query is made, which gets all the objects created using &#39;Post.objects.all()&#39; and save it to the post. There is a newly created dictionary as &#39;context&#39; where the object can be passed as key and obtained through template &#39;blog-list.html&#39;, which is done by returning the response with the help of render.
 <img src="https://i.imgur.com/XyzzrE2.png"> 
Make a new file called &#39;urls.py&#39; in &#39;django_blog/blog&#39; and add the following changes. There is relative import to the views &#39;blog_list&#39; also a &#39;urlpatterns&#39;, which is a list of the path to a specific page on the website. Currently, the <b'path' contains the empty string and name of the view.
 <img src="https://i.imgur.com/tkScSfm.png"> 
Let&#39;s move to &#39;django_blog/urls.py&#39; and import include and make a change to &#39;urlpatterns&#39;. Then add the path to your app URLs through include. Also, when users route through &#39;posts/&#39; then, it gets directed to our &#39;blog.urls.&#39;
<h3 id="making-and-changing-the-templates">Making and Changing the Templates</h3>
Let&#39;s make a templates folder that generally holds the &#39;HTML&#39; and contains their own templating language called &#39;Jinja2&#39;.The folder needs to name &#39;templates/blog/blog_list.html&#39;, which is the convention.
 <img src="https://i.imgur.com/ceM1ffK.png"> 
You can see below there is syntax related to &#39;HyperTextMarkup Language(HTML) where &#39;h1&#39; for big headline and an unordered list(ul) with list element li. Also, &#39; for&#39; loop syntax related to &#39;Jinja 2&#39; is used where an object called &#39;blog_list&#39; passed as key from &#39;blog/views.py&#39; with each element called &#39;list&#39; is iterated.
 <img src="https://i.imgur.com/dt5UOJC.png"> 
View the &#39;title&#39; named as &#39;First Post&#39; on the webpage.
 <img src="https://i.imgur.com/5wMbeRT.png"> 
Let&#39;s add another information from the admin panel the same as above and name your second post title as &#39;Second Post.&#39;
 <img src="https://i.imgur.com/JF96yQl.png"> 
After adding the information and reloading the homepage, the information will be updated.
 <img src="https://i.imgur.com/KSaxElq.png">
<h3 id="details-for-each-individual-post">Details for Each Individual post</h3>
You will be creating each individual page containing information regarding the post title, and it&#39;s content. The &#39;url&#39; will be &quot;localhost:8000/posts/&#39;id&#39;&quot; where id indicates the unique number or primary key attached to each &#39;Post&#39; given by Django itself. 
Let&#39;s create a function as &#39;blog_detail&#39; in &#39;blog/view.py&#39; , which accepts id as a parameter. Also, there is a query made for getting specific id only and saving to &#39;each_post&#39;. Similarly, as above, the information needed is passed as context to the &#39;blog_detail.html&#39;.
 <img src="https://i.imgur.com/lEc6Tcb.png"> 
The url in &#39;blog/urls.py&#39; is changed where path contains the &#39;<code>&lt;id&gt;</code>&#39;, which accepts the unique id in the integer form. Assume that the user comes to &#39;posts/&#39; only then sees all the posts, but when they to &#39;posts/1&#39;, they only see the information regarding the first created post.
 <img src="https://i.imgur.com/gOqq4xb.png"> 
Let&#39;s create a new file, &#39;blog/blog_detail.html&#39;, and make the following changes. Since blog_detail is passed as context, the &#39;title&#39; and &#39;content&#39; can be accessed using dot notation.
 <img src="https://i.imgur.com/tzSxKPm.png"> 
Head over to the URL of your browser and type the same thing to get individual posts. Since the &#39;id&#39; for the first information created is &#39;1&#39; where the second information is to be &#39;2&#39; and so on for newly created information.
 <img src="https://i.imgur.com/CyPpbm3.png">
<h3 id="deleting-the-post">Deleting the Post</h3>
Let&#39;s define the blog_delete, which takes in the request and the id. Also, query is made where &#39;Post.objects.get(id=id)&#39; gets the object with a unique id and save it to each_post. After that the &#39;each_post.delete()&#39; is called to delete the &#39;Post&#39;.Finally HttpResponseRedirect is imported from the &#39;django.http&#39; module where it is used to redirect the page to the &#39;/posts/&#39;
 <img src="https://i.imgur.com/GzPTVdH.png"> .
In the &#39;urls.py&#39; import &#39;blog_delete&#39; and path is set to &#39;&lt;id&gt;/delete&#39; where the id with delete at the end will remove that particular object or information.
 <img src="https://i.imgur.com/TX2GuFL.png"> 
Let&#39;s delete our post by typing the following thing in the &#39;urls.py&#39;.
 <img src="https://i.imgur.com/0xHgfzl.png"> 
At last, the page gets redirected to &#39;/posts&#39; when &#39;posts/1/delete/&#39; is called where only one post exists on the homepage.
 <img src="https://i.imgur.com/O8Jb9rJ.png">
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial!
You&#39;ve learned the basics of the Django Web Development and know about the CRUD functionality. Also, for more details in a particular topic head over to the <a href="https://docs.djangoproject.com/en/3.0/">Django Documentation.</a>
References:
<ul>
<li><a href="https://www.youtube.com/watch?v=_04toQWN5-8">Just Django</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/Introduction">Mozilla Django Introduction</a></li>
</ul>

https://www.datacamp.com/community/tutorials/web-development-django

Learn about the basics of web development using Django to build blog applications that have the (CRUD) Create, Read, Update, Delete functionality.

Python Django Tutorial. Learn the basics of Python web development with Create, Read, Update, Delete (CRUDE). Use Django to build a blog application today!

Django Tutorial: Python Web Development

Django Web Development in Python

https://www.datacamp.com/community/tutorials/conditionals-and-control-flow-in-r

Learn about relational operators for comparing R objects and logical operators for combining boolean TRUE and FALSE values. You'll also construct conditional statements.

Learn about RELATIONAL operators for comparing R OBJECTS and LOGICAL operators for combining boolean TRUE and FALSE values. You'll also construct CONDITIONAL statements.

(Tutorial) Conditionals and Control Flow in R

Conditionals and Control Flow in R

https://www.datacamp.com/community/tutorials/data-types-in-r

Learn about data types and their importance in a programming language. More specifically, learn how to use various data types like vector, matrices, lists, and dataframes in the R programming language.

Learn about R data types & structures. Find out how to use R data types like vector, matrices, lists & dataframes in our tutorial today!

R Data Types & Structures

Data Types in R

<center><a href="https://s3.amazonaws.com/assets.datacamp.com/email/other/Python+vs+R.pdf"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603467084/Tutorial__R_or_Python_for_Data_Analysis_fkkn9s.png" /></a></center> 
It&#39;s hard to know whether to use Python or R for data analysis. And that’s especially true if you&#39;re a newbie data analyst looking for the right language to start with.
But it is possible to figure out the strengths and weaknesses of both languages. One language isn’t better than the other—it all depends on your use case and the questions you’re trying to answer: What should I use for machine learning? I need a fast solution, so should I use Python or R?
Python vs. R for Data Analysis
At DataCamp, we often get emails from learners asking whether they should use Python or R when performing their day-to-day data analysis tasks. Both Python and R are among the most popular languages for data analysis, and each has its supporters and opponents. While Python is often praised for being a general-purpose language with an easy-to-understand syntax, R&#39;s functionality was developed with statisticians in mind, thereby giving it <a href="http://www.quora.com/Which-is-better-for-data-analysis-R-or-Python">field-specific advantages</a> such as great features for data visualization.
Our infographic &quot;When Should I Use Python vs. R?&quot; is for anyone interested in how these two programming languages compare to each other from a data science and analytics perspective, including their unique strengths and weaknesses. Click the image below to download the infographic and access the embedded links.
<center><a href="https://s3.amazonaws.com/assets.datacamp.com/email/other/Python+vs+R.pdf"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603890265/Python_vs_R_zerop6.pdf" /></a></center> 
For additional insight into these languages, read our blog post on <a href="https://www.datacamp.com/community/blog/when-to-use-python-or-r">Python vs. R for Data Science: What’s the Difference?</a> To explore these languages for yourself, try our <a href="https://www.datacamp.com/courses/intro-to-python-for-data-science/">Introduction to Python</a> and <a href="https://www.datacamp.com/courses/free-introduction-to-r/">Introduction to R</a> courses.

https://www.datacamp.com/community/tutorials/r-or-python-for-data-analysis

Wondering whether you should use Python or R for data analysis? You’ve come to the right place. 

Python vs. R. What is the difference between Python and R? Find a fun infographic & see why you should learn Python or R for data science today!

Infographic Python vs. R for Data Analysis?

Choosing Python or R for Data Analysis? An Infographic

A Time series is a string of data points framed or indexed in particular time periods or intervals. More specifically, it is an ordered series of data points for a variable taken at successive equally spaced out points in time. Time series analysis consists of techniques for examining and analyzing time series data in order to bring out eloquent insights from the data. It assists in acquiring an understanding of the underlying forces in the data points, which are leading to a particular trend. This further helps in predicting future data points. This is achieved by creating a model based on the previous data points in order to predict future data points.
There are mainly four factors or elements which are responsible for any variation in time series data. These factors are commonly known as components of time series analysis, and they are as follows:
<ul>
<li>Trends</li>
<li>Seasonal Movements</li>
<li>Cyclic Movements</li>
<li>Random or Irregular Movements</li>
</ul>
Some of the domains where time series can be applied are - sales forecasting, stock market analysis, inventory management, weather analysis, trend identification, etc. As suggested, before applying any tests on time series data, it is advisable to analyze the data graphically.
In this tutorial, you are going to learn time series analysis, and the following topics will be covered:
<ul>
<li>ACF and PCF</li>
<li>Moving Averages</li>
<li>Moving Average in Spreadsheets</li>
<li>Holt Linear</li>
<li>Holt Linear in Spreadsheets</li>
<li>Conclusion</li>
</ul>
<h2 id="acf-and-pcf">ACF and PCF</h2>
As the name suggests, Autocorrelation is the linear dependence of a variable with itself at two different data points in time. This function is used to determine how well the present value of the series is related to its past values. ACF takes into consideration all of the components for time series, which are - trends, seasonality, cyclic, and random (residual) while finding correlations. Hence, it’s a complete auto-correlation plot. The ACF is a good way to confirm any positive or negative trend; for a positive trend, you will see the ACF will never be going down.
Another way to determine the linear relationship between any two variables is by partial autocorrelation function. Another way to measure the correlation between two random terms x and xt-1 is to only focus on the portion of correlation, which is explained by xt and xt+1 of and eliminating the linear impact of the random variables that fall in between, xt+1,...., xt+n and then determine the correlation of the transformed random variables. This process is termed as partial autocorrelation function.
<h2 id="moving-averages">Moving Averages</h2>
Moving averages smooth the time series data to give a clear indication of where the trend is following. Moving averages help smooth the data by eliminating the noise. For calculating the moving average, you will be taking the arithmetic mean of a variable of the data. There are two types of moving averages, and they are as follows:
<ul>
<li>Simple Moving Average: Simple moving average is calculated by taking the arithmetic mean of a given set of values. For example, to calculate a basic 5-day moving average of closing prices, you would add up the closing prices from the past 5 days and then divide the result by 5. One of the key functions of the moving average is to determine the trends (<a href="https://www.coursehero.com/file/p23kn7uv/has-a-corresponding-Hadoop-Distributed-File-System-HDFS-directory-Each-table/">Source</a>).</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_1_q1bsdg.png" /></center><center><a href="https://otexts.com/fpp2/moving-averages.html">Source</a></center>&nbsp;

Where, m = 2k+1. That is, the estimate of the trend-cycle at time t is obtained by averaging values of the time series within k periods of t (<a href="https://otexts.com/fpp2/moving-averages.html">Source</a>).

 Day 1 - 30 
 Day 2 - 50 
 Day 3 -100 
 Day 4 - 40 
 Day 5 - 35 

 Simple Moving Average = 30 + 50 +100 + 40 + 35 / 5 

 = 255/5 

 = 51
- Exponential Moving Average: The exponential moving average (EMA) is a type of moving average (MA) that gives weight and emphasizes on the latest data points because simple moving averages can be manipulated if there exists a data point with spikes. Thus, the exponential moving average is also known as the exponentially weighted moving average. For example—considering the above data if you want to calculate you would be using the following formula:

 For a given series of n, Where N = 5, 

 EMA = [Last Value in the series - Second last Value ] (2 / n+1) + Second Last Value, 

 EMA = (35 - 40) (2 / 6) + 40 

 EMA = 35.33

<h2>Moving Average in Spreadsheets</h2>

Applying Simple Moving average to Electric Sales data. Let&#39;s compute the 3MA or 3-Moving Average:

1. Let’s first plot the data and see the trend.

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_2_dgst9m.png" /></center>

&nbsp;2. Add a column named Three Moving Average(3MA) and apply the formula. For 3 MA, k value would be -1, 0, 1. You take the average of three terms previous term, current term, and the next term. For the first and last term, 3MA cannot be calculated because there’s no previous term and following term, which we can consider.
&nbsp;3. We will apply the function in C3,=AVERAGE(B2: B4). This will give the value of 3 MA.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_3_r2kx5f.png" /></center>

&nbsp;4. Copy and paste this formula from cell C4 to C20. You will have values.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504462/image_4_rya9ck.png" /></center>

&nbsp;5. Now select the data and 3MA columns and plot time series. For plotting in the same graph, go to select data and add a series name 3MA. Deselect the 1st and 20th entry because, in 3MA, these values are zero and click on ok.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_5_zbj4wr.png" /></center>

Similarly, you can do for 5 MA, 7MA, etc.
<h2 id="holt-linear">Holt Linear</h2>
Until now, you have seen various methods for forecasting, but you can see that these models don’t work well on data with high variations. For instance, if you want to predict the price of bitcoin in the future, which is increasing currently, using the methods stated above wouldn’t be a good option.
If you use any of the above methods, these methods won’t consider the trend. Trend, as discussed earlier, is the component of time series data, that represents the long term movement of a time series. Thus, you require a method that can determine the trend precisely without any assumptions. Hence, you will be using Holt’s Linear Trend method.
Holt’s Linear Method is also known as the Double Exponential Smoothing Technique. This method comprises of three equations which are a forecast equation and two smoothing equations,
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_6_r4okcx.png" /></center>

For the first equation, lt is representing the evaluation of the level of time series at time t and bt is representing the evaluation of the slope of the time series at time t.
For the second equation and determining the trend of the current data, first determine the trend of the previous period, by adding bt-1 to the last smoothed value lt-1. This helps to eradicate lag and brings lt to the approximate level of the current data. Since the data can have some randomness or error term in it, in order to eradicate that error, the trend is adjusted by smoothing with β ( lt - lt-1 ), the trend in the last period, and adding that to the previous value of the trend. The last equation is used to forecast the final trend.
<h2 id="holt-linear-in-spreadsheets">Holt Linear in Spreadsheets</h2>
Let’s solve this using spreadsheets. You are taking data set from the book “Spyros G. Makridakis, Steven C. Wheelwright, Rob J Hyndman - Forecasting_ Methods and Applications-Wiley (1997)” of holt’s linear method.
<ol>
<li>To initialize the process, you require two estimates—one to get first smoothed values for L1 and the other for the value of trend b1. One alternative is to set L1 = Y1 and b1 = Y2-Y1 or (Y4-Y1)/3.
</li>
<li>At initial level you considered α = 0.501 and β = 0.072. These you need to optimize. Optimization can be done with MSE (Mean Squared Error) at whatever α and β values you get minimum MSE, consider that as your hyperparameter values.
</li>
<li>Let’s put these formulas into excel to get the forecasted values. At lag 1 (means m = 1) in third equation.
</li>
</ol>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504462/image_7_jsijd4.png" /></center>

<ol>
<li>As for the initial stage L1 = Y1 and b1 = Y2 – Y1. Let’s assign these values in excel.</li>
</ol>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_8_uun8bf.png" /></center>

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_9_c2jaca.png" /></center>

<ol>
<li>Let’s use the formulas to calculate values for L2, b2, and F2.</li>
</ol>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_10_k2hjbl.png" /></center>

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504461/image_11_dgz8eb.png" /></center>

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504462/image_12_qvszoy.png" /></center>

<ol>
<li>Now copy and paste all three formulas till the end of the data available in the file.</li>
</ol>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504462/image_13_lbejd6.png" /></center>

You will have all these values. Now, if you want to forecast for the 25th period, we should consider m = 1 and if for 26th we should consider m = 2 and so on.
<ol>
<li>Let’s calculates forecast values at different periods. </li>
</ol>
for m = 1,
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504462/image_14_rrhmvl.png" /></center>

For m=2,
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504462/image_15_qisppz.png" /></center>

Similarly, you can calculate at different periods.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1578504462/image_16_chqc6j.png" /></center>

<h2 id="conclusion">Conclusion</h2>
Congratulations, you have made it to the end of this tutorial!
In this tutorial, you have covered a lot of details about the time series analysis. You have learned ACF and PCF, moving averages, moving averages in spreadsheets, Holt Linear, and Holt Linear in spreadsheets.
Hopefully, you can now utilize the time series analysis concepts to test the hypothesis. Thanks for reading this tutorial!
If you would like to learn more in spreadsheets, check out DataCamp&#39;s <a href="https://www.datacamp.com/courses/statistics-in-spreadsheets">Introduction to Statistics in Spreadsheets</a> course.

https://www.datacamp.com/community/tutorials/time-series-analysis-with-spreadsheets

In this tutorial, you'll learn basic time-series concepts and basic methods for forecasting time series data using spreadsheets.

(Tutorial) Time Series Analysis with Spreadsheets

Time Series Analysis with Spreadsheets

https://www.datacamp.com/community/tutorials/categorical-data

Learn the common tricks to handle categorical data and preprocess it to build machine learning models!

Learn the common tricks to handle CATEGORICAL data, such as converting to numeric PANDAS or missing data and preprocess it to build MACHINE LEARNING models!

(Tutorial) Handling Categorical Data in Python

Handling Categorical Data in Python

Typically, every novice learns to write a Python script on the command line first, then moves to execute the script from the command line wherein the script is usually written in a text editor and is run from the command line.
Computers cannot understand code in the way humans write it and hence, you need an interpreter between the computer and the human written code. The job of the interpreter is to convert the code into a format that computers can then understand and process.
The interpreter processes the code in the following ways:
<ul>
<li>Processes the Python script in a sequence
</li>
<li>Compiles the code into a byte code format which is a lower-level language understood by the computers.
</li>
<li>Finally, a Python Virtual Machine (PVM) comes into the picture. The PVM is the runtime powerhouse of Python. It is a process that iterates over the instructions of your low-level bytecode code to run them one by one.
</li>
</ul>
Like Scripts, you have a have something called Module which is a Python script imported and used in another Python script.
The Python script is saved with a .py extension which informs the computer that it is a Python program script. Unlike Windows, the Unix based operating systems such as Linux and Mac come with pre-installed Python. Also, the way Python scripts are run in Windows and Unix operating systems differ.
Note: For all users, especially Windows OS users, it is highly recommended that you install <code>Anaconda</code>, which can be downloaded from <a href="https://www.anaconda.com">this website</a>. You can follow along with the instructions given in this <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-windows">DataCamp tutorial</a>, which are specific to Windows operating system.
To install <code>Python3</code> on a Windows operating system, please feel free to check out this <a href="https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-a-local-programming-environment-on-windows-10">link</a>.
Command-line interpreter for Python can be accessed on the various operating systems in the following ways:
<ul>
<li>On <code>Windows</code>, the command line is known as the command prompt which can be accessed by clicking the <code>start</code> menu and search for <code>command prompt</code>. Another way is by going to the <code>Run</code> dialog box type <code>cmd</code> and press enter (Start menu $-&gt;$ Run and type cmd). After which, if Python is installed in your C-drive then all you have to do is type C:\python36\python.exe, where python36 is the Python version (Note: This path may vary based on the directory at which Python is configured).</li>
</ul>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598150/cmd1_cmgszw.png" />
 <figcaption>(<a href="https://pythonfun.wordpress.com/2012/04/04/installing-pyserial-on-windows-7-with-python3-2/">Source</a>) </figcaption>
</figure>
</center> 

<ul>
<li>On a <code>Mac</code> system, it is very straight-forward. All you need to do is open <code>Launchpad</code> and search for <code>Terminal</code>, and in the terminal, type <code>Python</code> and boom, it will give you an output with the Python version.</li>
</ul>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598150/cmd2_jnyyar.png" />
</figure>
</center> 

<ul>
<li>Like the Mac system, accessing terminal on a <code>Linux</code> system is also very easy. Right click on the desktop and click <code>Terminal</code> and in terminal type <code>Python</code> and that&#39;s all!</li>
</ul>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598150/cmd3_rmhrog.png" />
 <figcaption>(<a href="https://mbientlab.com/tutorials/LPython3.html">Source</a>) </figcaption>
</figure>
</center> 

Note: In this tutorial, you will be learning using the Mac OS Terminal.
So without further ado, lets get started!
<h3 id="writing-the-python-script-in-terminal">Writing the Python Script in Terminal</h3>
Let&#39;s see how we can code and generate the output in the terminal itself. To accomplish this, first, you will type <code>python3</code>, which means you will be using Python3 version.
After which you can code typically as you would in a <a href="https://www.datacamp.com/community/tutorials/top-python-ides-for-2019">text editor or an IDE</a> (integrated development environment), though you will not be getting the functionalities in the terminal as you would get with an IDE.
You will start with the evergreen <code>Hello, World!</code> example and let&#39;s see how the output looks like in the terminal.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd4_semikk.png" />
</figure>
</center> 

Isn&#39;t it nice how by just opening the terminal and typing Python3 you can code in Python? Let&#39;s try some more examples.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd5_jolchp.png" />
</figure>
</center> 

One thing to notice in the above example is, without even typing the <code>print</code> statement you were able to get the output.
Let&#39;s complicate the code a bit and lets you use the <code>NumPy</code> (Numerical Python) library to create two arrays and apply a few mathematical operations on it. For a little background on numpy, it is a Python programming library which has the capability of dealing with large, multi-dimensional arrays and matrices, along with an extensive collection of high-level mathematical functions to operate on these arrays.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd6_quakfq.png" />
</figure>
</center> 

You can observe from the above figure that using numpy; you were able to create, add, and multiply two numpy arrays within the terminal. One thing to note here is that the <code>multiply</code> function in numpy does an element-wise multiplication while <code>dot</code> function takes the dot product of two matrices. To accomplish the <code>np.dot</code> command, you need to make sure that the <code>columns</code> of the first matrix are equal to the <code>rows</code> of the second matrix and hence, the <code>value error</code>.
<h3 id="running-the-py-script-from-the-terminal">Running the <code>.py</code> script from the Terminal</h3>
Running the Python script from the terminal is very simple, instead of writing the Python script in the terminal all you need to do is use a text editor like vim, emacs or notepad++ and save it with a <code>.py</code> extension. Then, open the terminal and go to the directory where the code resides and run the script with a keyword <code>python</code> followed by the script name.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd7_tsl72k.png">
</figure>
</center> 

To create the <code>terminal.py</code> file, use <code>vim</code> in the terminal with the program name as <code>vim terminal.py</code> and paste the below code in it. To save the code, press <code>esc</code> key followed by <code>wq!</code>. And finally, to run that script all you need to do is type <code>python3 terminal.py</code> and within less than a second you will see the output as shown above.
The following is the code which was used in the above <a href="http://cs231n.github.io/python-numpy-tutorial/">example</a>.
<pre><code class="lang-python">import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

# Elementwise sum; both produce the array
# [[ 6.0 8.0]
# [10.0 12.0]]
print(&quot;Output of adding x and y with a &#39;+&#39; operator:&quot;,x + y)
print(&quot;Output of adding x and y using &#39;numpy.add&#39;:&quot;,np.add(x, y))

# Elementwise difference; both produce the array
# [[-4.0 -4.0]
# [-4.0 -4.0]]
print(&quot;Output of subtracting x and y with a &#39;-&#39; operator:&quot;,x - y)
print(&quot;Output of subtracting x and y using &#39;numpy.subtract&#39;:&quot;,np.subtract(x, y))

# Elementwise product; both produce the array
# [[ 5.0 12.0]
# [21.0 32.0]]
print(&quot;Output of elementwise product of x and y with a &#39;*&#39; operator:&quot;,x * y)
print(&quot;Output of element wise product of x and y using &#39;numpy.multiply&#39;:&quot;,np.multiply(x, y))

# Elementwise division; both produce the array
# [[ 0.2 0.33333333]
# [ 0.42857143 0.5 ]]
print(&quot;Output of elementwise division x and y with a &#39;/&#39; operator:&quot;,x / y)
print(&quot;Output of elementwise division x and y using &#39;numpy.divide&#39;:&quot;,np.divide(x, y))

# Elementwise square root; produces the array
# [[ 1. 1.41421356]
# [ 1.73205081 2. ]]
print(&quot;Output of elementwise square root x using &#39;numpy.sqrt&#39;:&quot;,np.sqrt(x))
</code></pre>
<pre><code>Output of adding x and y with a &#39;+&#39; operator: [[ 6. 8.]
 [10. 12.]]
Output of adding x and y using &#39;numpy.add&#39;: [[ 6. 8.]
 [10. 12.]]
Output of subtracting x and y with a &#39;-&#39; operator: [[-4. -4.]
 [-4. -4.]]
Output of subtracting x and y using &#39;numpy.subtract&#39;: [[-4. -4.]
 [-4. -4.]]
Output of elementwise product of x and y with a &#39;*&#39; operator: [[ 5. 12.]
 [21. 32.]]
Output of element wise product of x and y using &#39;numpy.multiply&#39;: [[ 5. 12.]
 [21. 32.]]
Output of elementwise division x and y with a &#39;/&#39; operator: [[0.2 0.33333333]
 [0.42857143 0.5 ]]
Output of elementwise division x and y using &#39;numpy.divide&#39;: [[0.2 0.33333333]
 [0.42857143 0.5 ]]
Output of elementwise square root x using &#39;numpy.sqrt&#39;: [[1. 1.41421356]
 [1.73205081 2. ]]
</code></pre><h3 id="passing-command-line-arguments-to-python-script">Passing Command Line Arguments to Python Script</h3>
Command line arguments make life a lot easier, many times in production-ready code command line arguments are used. It makes the code output reproducibility efficient. For example, let&#39;s say your code has a lot of user inputs or files that are being read, then by using command line arguments you will not have to go into the code to do all of these changes in case you need to change the file name or a variable input.
To accomplish this, you will make use of the <code>sys</code> module, which is an in-built Python module. Within <code>sys</code>, you have <code>argv</code> which gives you the list of command-line arguments passed to the Python program. <code>sys.argv</code> reads the command line arguments as a list of items where the first item/element in that list can be accessed as <code>sys.argv[1]</code> while first argument, i.e., <code>sys.argv[0]</code> is always the name of the program as it was invoked.
Let&#39;s take a simple example and see how it works.
Note: The command line argument is read as a <code>string</code> by Python, so make sure to convert it as an <code>integer</code> in case you are dealing with numbers.
Much like the previous example, save the below lines of code in an editor as <code>command_line.py</code> and to run the code type <code>python3 command_line.py 10</code> where 10 is the command line argument.
<pre><code class="lang-python">import sys
num = sys.argv[1]
for i in range(int(num)):
 print (i)
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598152/cmd8_fpvufy.png" />
</figure>
</center> 

<h4 id="what-if-you-do-not-provide-any-command-line-argument-">What if you do not provide any command line argument?</h4>
You will get an error <code>list index out of range</code> which also reinforces that <code>sys.argv</code> reads as a list of items. To avoid such errors, you need <code>exceptional handling</code>, which is out of the scope for this tutorial.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598154/cmd9_ks7w3s.png" />
</figure>
</center> 

<h3 id="writing-the-output-of-python-script-to-a-file">Writing the Output of Python Script to a File</h3>
Finally, as a bonus lets see how you can save the output of the Python script in a <code>txt</code> file with using the <code>&gt;</code> key. Yes, one mere character, isn&#39;t that amazing?
You will first create a folder <code>cli</code> and move the <code>command_line.py</code> code in the <code>cli</code> folder. Then, you will check what all is there in that folder, to make sure there is no <code>txt</code> file already existing.
Then, you will type <code>python3 command_line.py 10 &gt; output.txt</code> and finally check the content of the <code>cli</code> folder. Now, you should be able to see the <code>output.txt</code> file.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598155/cmd10_l1zfq1.png" />
</figure>
</center> 

Let&#39;s open and see the content of the <code>output.txt</code> file.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598155/cmd11_bxv24q.png" />
</figure>
</center> 

Voila! From the above output, you can see that the <code>0-9</code> digits have now been written in a text file using just a <code>&gt;</code> sign.
<h1 id="conclusion">Conclusion</h1>
Congratulations on finishing the tutorial.
There is still a lot to be explored like <a href="https://www.datacamp.com/community/tutorials/gui-tkinter-python">GUI</a> based execution in Python, running Python scripts interactively, running scripts from a file manager or from an IDE. Specific to command line execution you might want to experiment on the Windows <code>command prompt</code> and see how it is different from a Unix based operating system.
Please feel free to ask any questions related to this tutorial in the comments section below.
If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.

https://www.datacamp.com/community/tutorials/running-a-python-script

Learn how you can execute a Python script from the command line, and also how you can provide command line arguments to your script.

Learn how to run a Python script from the command line. Follow our tutorial and see how you can add arguments to your scripts. Work better in the terminal today!

How to Run Python Scripts from Command Line

How to Run Python Scripts

You have probably heard of the nested functions in Python. If you know what that means then understanding inner/nested classes is nothing. We will explore some new things in the Inner or Nested classes here.
<h2 id="sections">Sections</h2>
&nbsp; 1. <a href="#IONC">Inner or Nested Classes</a>
&nbsp; 2. <a href="#WIC">Why Inner Classes</a>
&nbsp; 3. <a href="#CIC">Coding Inner Classes</a>
&nbsp; &nbsp; &nbsp; &nbsp; 3.1. <a href="#MIC">Multiple Inner Classes</a>
&nbsp; &nbsp; &nbsp; &nbsp; 3.2. <a href="#MLIC">Multilevel Inner Classes</a>
<a id="IONC"></a>
<h2 id="1-inner-or-nested-classes">1. Inner or Nested Classes</h2>
Inner or Nested Class is defined inside another class. See the structure of inner or nested classes.
<pre><code class="lang-python">## outer class
class Outer:

 ## inner class
 class Inner:
 pass

 ## multilevel inner class
 class InnerInner:
 pass

 ## another inner class
 class _Inner:
 pass

 ## ...

 pass
</code></pre>
<a id="WIC"></a>
<h2 id="2-why-inner-classes-">2. Why Inner Classes?</h2>
<ol>
<li>Grouping of two or more classes. Suppose you have two classes Car and Engine. Every Car needs an Engine. But, Engine won&#39;t be used without a Car. So, you make the Engine an inner class to the Car. It helps save code.
</li>
<li>Hiding code is another use of Nested classes. You can hide the Nested classes from the outside world.
</li>
<li>It&#39;s easy to understand the classes. Classes are closely related here. You don&#39;t have to search for the classes in the code. They are all together.
</li>
</ol>
Inner or Nested classes are not the most commonly used feature in Python. But, it can be a good feature to implement code. The code is straightforward to organize when you use the inner or nested classes.
<a id="CIC"></a>
<h2 id="3-coding-inner-class">3. Coding Inner Class</h2>
Implementing the inner or nested classes is not difficult. You can see the structure of the code <a href="#IONC">here</a>.
You can access the inner class in the outer class using the self keyword. So, you can quickly create an instance of the inner class and perform operations in the outer class as you see fit. You can&#39;t, however, access the outer class in an inner class. Let&#39;s see an example below.
<pre><code class="lang-python">class Outer:
 &quot;&quot;&quot;Outer Class&quot;&quot;&quot;

 def __init__(self):
 ## instantiating the &#39;Inner&#39; class
 self.inner = self.Inner()

 def reveal(self):
 ## calling the &#39;Inner&#39; class function display
 self.inner.inner_display(&quot;Calling Inner class function from Outer class&quot;)

 class Inner:
 &quot;&quot;&quot;Inner Class&quot;&quot;&quot;

 def inner_display(self, msg):
 print(msg)
</code></pre>
Now, you&#39;ll make the instance of the Outer class and call it&#39;s reveal() method to execute the Inner class method inner_display().
<pre><code class="lang-python">## creating an instance of the &#39;Outer&#39; class
outer = Outer()
## calling the &#39;reveal()&#39; method
outer.reveal()
</code></pre>
<pre><code>Calling Inner class function from Outer class
</code></pre>Let&#39;s see another way to access the inner class. This way is a little less efficient.
<pre><code class="lang-python">Outer().Inner().inner_display(&quot;Calling the Inner class method directly&quot;)
</code></pre>
<pre><code>Calling the Inner class method directly
</code></pre>What if you want to create an instance of the inner class outside the outer class? Can you do that? Yes, let&#39;s see how to make an instance of the inner class outside of the outer class.
<pre><code class="lang-python">outer = Outer()

## instantiating the inner class
inner = outer.Inner() ## inner = Outer().Inner() or inner = outer.inner
inner.inner_display(&quot;Just Print It!&quot;)
</code></pre>
<pre><code>Just Print It!
</code></pre><a id="MIC"></a>
<h3 id="3-1-multiple-inner-classes">3.1. Multiple Inner Classes</h3>
It is a class containing more than one inner class. You can have more than one inner class in a class. As we defined earlier, it&#39;s easy to implement multiple inner classes.
<pre><code class="lang-python">class Outer:
 &quot;&quot;&quot;Outer Class&quot;&quot;&quot;

 def __init__(self):
 ## Instantiating the &#39;Inner&#39; class
 self.inner = self.Inner()
 ## Instantiating the &#39;_Inner&#39; class
 self._inner = self._Inner()

 def show_classes(self):
 print(&quot;This is Outer class&quot;)
 print(inner)
 print(_inner)

 class Inner:
 &quot;&quot;&quot;First Inner Class&quot;&quot;&quot;

 def inner_display(self, msg):
 print(&quot;This is Inner class&quot;)
 print(msg)

 class _Inner:
 &quot;&quot;&quot;Second Inner Class&quot;&quot;&quot;

 def inner_display(self, msg):
 print(&quot;This is _Inner class&quot;)
 print(msg)

 ## ...
</code></pre>
Accessing the classes is the same as we did earlier. See the example for better understanding.
<pre><code class="lang-python">## instantiating the classes

## &#39;Outer&#39; class
outer = Outer()
## &#39;Inner&#39; class
inner = outer.Inner() ## inner = outer.inner or inner = Outer().Inner()
## &#39;_Inner&#39; class
_inner = outer._Inner() ## _inner = outer._outer or _inner = Outer()._Inner()

## calling the methods
outer.show_classes()

print()

## &#39;Inner&#39; class
inner.inner_display(&quot;Just Print It!&quot;)

print()

## &#39;_Inner&#39; class
_inner.inner_display(&quot;Just Show It!&quot;)
</code></pre>
<pre><code>This is Outer class
&lt;__main__.Outer.Inner object at 0x0000021B37962048&gt;
&lt;__main__.Outer._Inner object at 0x0000021B37962160&gt;

This is Inner class
Just Print It!

This is _Inner class
Just Show It!
</code></pre><a id="MLIC"></a>
<h2 id="3-2-multilevel-inner-classes">3.2. Multilevel Inner Classes</h2>
In multilevel inner classes, the inner class contains another class which inner classes to the previous one. You can see the structure of this hierarchy <a href="#IONC">here</a>:
<pre><code class="lang-python">class Outer:
 &quot;&quot;&quot;Outer Class&quot;&quot;&quot;

 def __init__(self):
 ## instantiating the &#39;Inner&#39; class
 self.inner = self.Inner()
 ## instantiating the multilevel &#39;InnerInner&#39; class
 self.innerinner = self.inner.InnerInner()

 def show_classes(self):
 print(&quot;This is Outer class&quot;)
 print(inner)

 ## inner class
 class Inner:
 &quot;&quot;&quot;First Inner Class&quot;&quot;&quot;

 def __init__(self):
 ## instantiating the &#39;InnerInner&#39; class
 self.innerinner = self.InnerInner()

 def show_classes(self):
 print(&quot;This is Inner class&quot;)
 print(self.innerinner)

 ## multilevel inner class
 class InnerInner:

 def inner_display(self, msg):
 print(&quot;This is multilevel InnerInner class&quot;)
 print(msg)

 def inner_display(self, msg):
 print(&quot;This is Inner class&quot;)
 print(msg)

 ## ...
</code></pre>
Let&#39;s see how to instantiate the multilevel inner class.
<pre><code class="lang-python">outer = Outer()

inner = outer.Inner()

## this is &#39;InnerInner&#39; class instance
innerinner = inner.InnerInner() ## innerinner = Outer().Inner().InnerInner()

## let&#39;s call its method inner_display
innerinner.inner_display(&quot;Just Print It!&quot;)
</code></pre>
<pre><code>This is multilevel InnerInner class
Just Print It!
</code></pre><h2 id="conclusion">Conclusion</h2>
I hope you now understand the concept of inner classes. It&#39;s now time for you to experiment with nested classes. Happy Coding :)
If you would like to learn more about classes, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/object-oriented-programming-in-python">Object-Oriented Programming in Python</a> course.

https://www.datacamp.com/community/tutorials/inner-classes-python

In this basic Python tutorial, you'll learn about why and when you should use inner classes.

Learn Python nested & inner classes. Discovery why and when you should use inner classes today!

Python Nested & Inner Classes

Inner Classes in Python

https://www.datacamp.com/community/tutorials/functions-python-tutorial

A tutorial on functions in Python that covers how to write functions, how to call them, and more!

In this tutorial, you'll learn all about Python functions. Follow steps to learn how to write and call functions in Python. Find code examples today!

Python Functions: How to Call & Write Functions

Python Functions Tutorial

https://www.datacamp.com/community/tutorials/feature-selection-python

Learn about the basics of feature selection and how to implement and investigate various feature selection techniques in Python.

Follow our tutorial and learn about feature selection with Python Sklearn. Tackle large datasets with feature selection today!

Feature Selection in Python Sklearn

Beginner's Guide to Feature Selection in Python

https://www.datacamp.com/community/tutorials/lstm-python-stock-market

Discover Long Short-Term Memory (LSTM) networks in Python and how you can use them to make stock market predictions!

Discovery LSTM (Long Short-Term Memory networks in Python. Follow our step-by-step tutorial and learn how to make predict the stock market like a pro today!

Python LSTM (Long Short-Term Memory Network) for Stock Predictions

Stock Market Predictions with LSTM in Python

https://www.datacamp.com/community/tutorials/principal-component-analysis-in-python

Learn about PCA and how it can be leveraged to extract information from the data without any supervision using two popular datasets: Breast Cancer and CIFAR-10.

Learn about PCA (principal component analysis) with Python Sklearn. Follow our step-by-step tutorial and see how to extract information from data without any supervision. See how today!

Python PCA (Principal Component Analysis) with Sklearn

Principal Component Analysis (PCA) in Python

https://www.datacamp.com/community/tutorials/markov-chains-python-tutorial

Learn about Markov Chains, their properties, transition matrices, and implement one yourself in Python!

Learn about Markov Chains and how they can be applied in this tutorial. Build your very own model using Python today!

Markov Chains in Python with Model Examples

Markov Chains in Python: Beginner Tutorial

https://www.datacamp.com/community/tutorials/probability-distributions-python

In this tutorial, you'll learn about and how to code in Python the probability distributions commonly referenced in machine learning literature.

Learn about probability distributions with Python. Understand common distributions used in machine learning today!

Probability Distributions in Python Tutorial

<center>
<a target=“_blank” href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582839819/python_4_t5pp5t.png" /></a>
</center>
SVM offers very high accuracy compared to other classifiers such as logistic regression, and decision trees. It is known for its kernel trick to handle nonlinear input spaces. It is used in a variety of applications such as face detection, intrusion detection, classification of emails, news articles and web pages, classification of genes, and handwriting recognition.
In this tutorial, you will be using scikit-learn in Python. If you would like to learn more about this Python package, I recommend you take a look at our <a href="https://www.datacamp.com/courses/supervised-learning-with-scikit-learn">Supervised Learning with scikit-learn</a> course.
SVM is an exciting algorithm and the concepts are relatively simple. The classifier separates data points using a hyperplane with the largest amount of margin. That&#39;s why an SVM classifier is also known as a discriminative classifier. SVM finds an optimal hyperplane which helps in classifying new data points. 
In this tutorial, you are going to cover following topics:
<nav>
<ul>
<li><a href="#svm">Support Vector Machines</a></li>
<li><a href="#how">How does it work?</a></li>
<li><a href="#kernels">Kernels</a></li>
<li><a href="#building">Classifier building in Scikit-learn</a></li>
<li><a href="#tuning">Tuning Hyperparameters</a></li>
<li><a href="#prosandcons">Advantages and Disadvantages</a>
</nav>
<div id="scoped-content"><style type="text/css">:target:before { content:""; display:block; height:150px; margin:-150px 0 0; } h3 {font-weight:normal; margin-top:.5em} h4 { font-weight:lighter }
</style>

</li>
</ul>
<a id="svm"></a>
<h2 id="support-vector-machines">Support Vector Machines</h2>
Generally, Support Vector Machines is considered to be a classification approach, it but can be employed in both types of classification and regression problems. It can easily handle multiple continuous and categorical variables. SVM constructs a hyperplane in multidimensional space to separate different classes. SVM generates optimal hyperplane in an iterative manner, which is used to minimize an error. The core idea of SVM is to find a maximum marginal hyperplane(MMH) that best divides the dataset into classes.
<img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1526288453/index3_souoaz.png" alt="Support Vectors"/>
<h4 id="support-vectors">Support Vectors</h4>
Support vectors are the data points, which are closest to the hyperplane. These points will define the separating line better by calculating margins. These points are more relevant to the construction of the classifier.
<h4 id="hyperplane">Hyperplane</h4>
A hyperplane is a decision plane which separates between a set of objects having different class memberships.
<h4 id="margin">Margin</h4>
A margin is a gap between the two lines on the closest class points. This is calculated as the perpendicular distance from the line to support vectors or closest points. If the margin is larger in between the classes, then it is considered a good margin, a smaller margin is a bad margin.
<a id="how"></a>
<h2 id="how-does-svm-work-">How does SVM work?</h2>
The main objective is to segregate the given dataset in the best possible way. The distance between the either nearest points is known as the margin. The objective is to select a hyperplane with the maximum possible margin between support vectors in the given dataset. SVM searches for the maximum marginal hyperplane in the following steps:
<ol>
<li>Generate hyperplanes which segregates the classes in the best way. Left-hand side figure showing three hyperplanes black, blue and orange. Here, the blue and orange have higher classification error, but the black is separating the two classes correctly.
</li>
<li>Select the right hyperplane with the maximum segregation from the either nearest data points as shown in the right-hand side figure.
</li>
</ol>
<img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1526288454/index2_ub1uzd.png" alt="Linear Separator"/>
<h4 id="dealing-with-non-linear-and-inseparable-planes">Dealing with non-linear and inseparable planes</h4>
Some problems can’t be solved using linear hyperplane, as shown in the figure below (left-hand side).
In such situation, SVM uses a kernel trick to transform the input space to a higher dimensional space as shown on the right. The data points are plotted on the x-axis and z-axis (Z is the squared sum of both x and y: z=x^2=y^2). Now you can easily segregate these points using linear separation.
<img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1526288453/index_bnr4rx.png" alt="Higher Dimension"/>
<a id="kernels"></a>
<h2 id="svm-kernels">SVM Kernels</h2>
The SVM algorithm is implemented in practice using a kernel. A kernel transforms an input data space into the required form. SVM uses a technique called the kernel trick. Here, the kernel takes a low-dimensional input space and transforms it into a higher dimensional space. In other words, you can say that it converts nonseparable problem to separable problems by adding more dimension to it. It is most useful in non-linear separation problem. Kernel trick helps you to build a more accurate classifier.
<ul>
<li>Linear Kernel
A linear kernel can be used as normal dot product any two given observations. The product between two vectors is the sum of the multiplication of each pair of input values.</li>
</ul>
<pre><code>K(x, xi) = sum(x * xi)
</code></pre><ul>
<li>Polynomial Kernel
A polynomial kernel is a more generalized form of the linear kernel. The polynomial kernel can distinguish curved or nonlinear input space.</li>
</ul>
<pre><code>K(x,xi) = 1 + sum(x * xi)^d
</code></pre>Where d is the degree of the polynomial. d=1 is similar to the linear transformation. The degree needs to be manually specified in the learning algorithm.
<ul>
<li>Radial Basis Function Kernel
The Radial basis function kernel is a popular kernel function commonly used in support vector machine classification. RBF can map an input space in infinite dimensional space.</li>
</ul>
<pre><code>K(x,xi) = exp(-gamma * sum((x – xi^2))
</code></pre>Here gamma is a parameter, which ranges from 0 to 1. A higher value of gamma will perfectly fit the training dataset, which causes over-fitting. Gamma=0.1 is considered to be a good default value. The value of gamma needs to be manually specified in the learning algorithm.
<a id="building"></a>
<h2 id="classifier-building-in-scikit-learn">Classifier Building in Scikit-learn</h2>
Until now, you have learned about the theoretical background of SVM. Now you will learn about its implementation in Python using scikit-learn.
In the model the building part, you can use the cancer dataset, which is a very famous multi-class classification problem. This dataset is computed from a digitized image of a fine needle aspirate (FNA) of a breast mass. They describe characteristics of the cell nuclei present in the image.
The dataset comprises 30 features (mean radius, mean texture, mean perimeter, mean area, mean smoothness, mean compactness, mean concavity, mean concave points, mean symmetry, mean fractal dimension, radius error, texture error, perimeter error, area error, smoothness error, compactness error, concavity error, concave points error, symmetry error, fractal dimension error, worst radius, worst texture, worst perimeter, worst area, worst smoothness, worst compactness, worst concavity, worst concave points, worst symmetry, and worst fractal dimension) and a target (type of cancer).
This data has two types of cancer classes: malignant (harmful) and benign (not harmful). Here, you can build a model to classify the type of cancer. The dataset is available in the scikit-learn library or you can also download it from the UCI Machine Learning Library.
<h4 id="loading-data">Loading Data</h4>
Let&#39;s first load the required dataset you will use.
<pre><code class="lang-python">#Import scikit-learn dataset library
from sklearn import datasets

#Load dataset
cancer = datasets.load_breast_cancer()
</code></pre>
<h4 id="exploring-data">Exploring Data</h4>
After you have loaded the dataset, you might want to know a little bit more about it. You can check feature and target names. 
<pre><code class="lang-python"># print the names of the 13 features
print(&quot;Features: &quot;, cancer.feature_names)

# print the label type of cancer(&#39;malignant&#39; &#39;benign&#39;)
print(&quot;Labels: &quot;, cancer.target_names)
</code></pre>
<pre><code>Features: [&#39;mean radius&#39; &#39;mean texture&#39; &#39;mean perimeter&#39; &#39;mean area&#39;
 &#39;mean smoothness&#39; &#39;mean compactness&#39; &#39;mean concavity&#39;
 &#39;mean concave points&#39; &#39;mean symmetry&#39; &#39;mean fractal dimension&#39;
 &#39;radius error&#39; &#39;texture error&#39; &#39;perimeter error&#39; &#39;area error&#39;
 &#39;smoothness error&#39; &#39;compactness error&#39; &#39;concavity error&#39;
 &#39;concave points error&#39; &#39;symmetry error&#39; &#39;fractal dimension error&#39;
 &#39;worst radius&#39; &#39;worst texture&#39; &#39;worst perimeter&#39; &#39;worst area&#39;
 &#39;worst smoothness&#39; &#39;worst compactness&#39; &#39;worst concavity&#39;
 &#39;worst concave points&#39; &#39;worst symmetry&#39; &#39;worst fractal dimension&#39;]
Labels: [&#39;malignant&#39; &#39;benign&#39;]
</code></pre>Let&#39;s explore it for a bit more. You can also check the shape of the dataset using shape.
<pre><code class="lang-python"># print data(feature)shape
cancer.data.shape
</code></pre>
<pre><code>(569, 30)
</code></pre>Let&#39;s check top 5 records of the feature set.
<pre><code class="lang-python"># print the cancer data features (top 5 records)
print(cancer.data[0:5])
</code></pre>
<pre><code>[[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
 1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
 6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
 1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
 4.601e-01 1.189e-01]
 [2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
 7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
 5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
 2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
 2.750e-01 8.902e-02]
 [1.969e+01 2.125e+01 1.300e+02 1.203e+03 1.096e-01 1.599e-01 1.974e-01
 1.279e-01 2.069e-01 5.999e-02 7.456e-01 7.869e-01 4.585e+00 9.403e+01
 6.150e-03 4.006e-02 3.832e-02 2.058e-02 2.250e-02 4.571e-03 2.357e+01
 2.553e+01 1.525e+02 1.709e+03 1.444e-01 4.245e-01 4.504e-01 2.430e-01
 3.613e-01 8.758e-02]
 [1.142e+01 2.038e+01 7.758e+01 3.861e+02 1.425e-01 2.839e-01 2.414e-01
 1.052e-01 2.597e-01 9.744e-02 4.956e-01 1.156e+00 3.445e+00 2.723e+01
 9.110e-03 7.458e-02 5.661e-02 1.867e-02 5.963e-02 9.208e-03 1.491e+01
 2.650e+01 9.887e+01 5.677e+02 2.098e-01 8.663e-01 6.869e-01 2.575e-01
 6.638e-01 1.730e-01]
 [2.029e+01 1.434e+01 1.351e+02 1.297e+03 1.003e-01 1.328e-01 1.980e-01
 1.043e-01 1.809e-01 5.883e-02 7.572e-01 7.813e-01 5.438e+00 9.444e+01
 1.149e-02 2.461e-02 5.688e-02 1.885e-02 1.756e-02 5.115e-03 2.254e+01
 1.667e+01 1.522e+02 1.575e+03 1.374e-01 2.050e-01 4.000e-01 1.625e-01
 2.364e-01 7.678e-02]]
</code></pre>Let&#39;s take a look at the target set.
<pre><code class="lang-python"># print the cancer labels (0:malignant, 1:benign)
print(cancer.target)
</code></pre>
<pre><code>[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 1 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 1 0 0 1 1 1 1 0 1 0 0 1 1 1 1 0 1 0 0
 1 0 1 0 0 1 1 1 0 0 1 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 1 1 1 0 1 1 0 1 1
 1 1 1 1 1 1 0 0 0 1 0 0 1 1 1 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 0 1 1 1 1 0 1
 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 1 0 1 1 0 0 1 1 0 0 1 1 1 1 0 1 1 0 0 0 1 0
 1 0 1 1 1 0 1 1 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 1 1 0 1 0 0 0 0 1 1 0 0 1 1
 1 0 1 1 1 1 1 0 0 1 1 0 1 1 0 0 1 0 1 1 1 1 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1
 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 0 1 1 1 1 0 0 0 1 1
 1 1 0 1 0 1 0 1 1 1 0 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0
 0 1 0 0 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1
 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 0 1 1
 0 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 1
 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 0 0 1 0 1 0 1 1 1 1 1 0 1 1 0 1 0 1 0 0
 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 0 0 0 0 0 0 1]
</code></pre><h4 id="splitting-data">Splitting Data</h4>
To understand model performance, dividing the dataset into a training set and a test set is a good strategy.
Split the dataset by using the function <code>train_test_split()</code>. you need to pass 3 parameters features, target, and test_set size. Additionally, you can use random_state to select records randomly.
<pre><code class="lang-python"># Import train_test_split function
from sklearn.model_selection import train_test_split

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, test_size=0.3,random_state=109) # 70% training and 30% test
</code></pre>
<h4 id="generating-model">Generating Model</h4>
Let&#39;s build support vector machine model. First, import the SVM module and create support vector classifier object by passing argument kernel as the linear kernel in <code>SVC()</code> function.
Then, fit your model on train set using <code>fit()</code> and perform prediction on the test set using <code>predict()</code>.
<pre><code class="lang-python">#Import svm model
from sklearn import svm

#Create a svm Classifier
clf = svm.SVC(kernel=&#39;linear&#39;) # Linear Kernel

#Train the model using the training sets
clf.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)
</code></pre>
<h4 id="evaluating-the-model">Evaluating the Model</h4>
Let&#39;s estimate how accurately the classifier or model can predict the breast cancer of patients.
Accuracy can be computed by comparing actual test set values and predicted values.
<pre><code class="lang-python">#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics

# Model Accuracy: how often is the classifier correct?
print(&quot;Accuracy:&quot;,metrics.accuracy_score(y_test, y_pred))
</code></pre>
<pre><code>Accuracy: 0.9649122807017544
</code></pre>Well, you got a classification rate of 96.49%, considered as very good accuracy.
For further evaluation, you can also check precision and recall of model.
<pre><code class="lang-python"># Model Precision: what percentage of positive tuples are labeled as such?
print(&quot;Precision:&quot;,metrics.precision_score(y_test, y_pred))

# Model Recall: what percentage of positive tuples are labelled as such?
print(&quot;Recall:&quot;,metrics.recall_score(y_test, y_pred))
</code></pre>
<pre><code>Precision: 0.9811320754716981
Recall: 0.9629629629629629
</code></pre>Well, you got a precision of 98% and recall of 96%, which are considered as very good values.
<a id="tuning"></a>
<h2 id="tuning-hyperparameters">Tuning Hyperparameters</h2>
<ul>
<li>Kernel: The main function of the kernel is to transform the given dataset input data into the required form. There are various types of functions such as linear, polynomial, and radial basis function (RBF). Polynomial and RBF are useful for non-linear hyperplane. Polynomial and RBF kernels compute the separation line in the higher dimension. In some of the applications, it is suggested to use a more complex kernel to separate the classes that are curved or nonlinear. This transformation can lead to more accurate classifiers.</li>
</ul>
<ul>
<li>Regularization: Regularization parameter in python&#39;s Scikit-learn C parameter used to maintain regularization. Here C is the penalty parameter, which represents misclassification or error term. The misclassification or error term tells the SVM optimization how much error is bearable. This is how you can control the trade-off between decision boundary and misclassification term. A smaller value of C creates a small-margin hyperplane and a larger value of C creates a larger-margin hyperplane.</li>
</ul>
<ul>
<li>Gamma: A lower value of Gamma will loosely fit the training dataset, whereas a higher value of gamma will exactly fit the training dataset, which causes over-fitting. In other words, you can say a low value of gamma considers only nearby points in calculating the separation line, while the a value of gamma considers all the data points in the calculation of the separation line.</li>
</ul>
<a id="prosandcons"></a>
<h2 id="advantages">Advantages</h2>
SVM Classifiers offer good accuracy and perform faster prediction compared to Naïve Bayes algorithm. They also use less memory because they use a subset of training points in the decision phase. SVM works well with a clear margin of separation and with high dimensional space. 
<h2 id="disadvantages">Disadvantages</h2>
SVM is not suitable for large datasets because of its high training time and it also takes more time in training compared to Naïve Bayes. It works poorly with overlapping classes and is also sensitive to the type of kernel used.
<h2 id="conclusion">Conclusion</h2>
Congratulations, you have made it to the end of this tutorial!
In this tutorial, you covered a lot of ground about Support vector machine algorithm, its working, kernels, hyperparameter tuning, model building and evaluation on breast cancer dataset using the Scikit-learn package. You have also covered its advantages and disadvantages. I hope you have learned something valuable!
To learn more about this type of classifiers, you should take a look at our <a href="https://www.datacamp.com/courses/linear-classifiers-in-python">Linear Classifiers in Python</a> course. It introduces other types of regression and loss functions, as well as Support Vector Machines.
I look forward to hearing any feedback or questions. You can ask the question by leaving a comment and I will try my best to answer it.

https://www.datacamp.com/community/tutorials/svm-classification-scikit-learn-python

In this tutorial, you'll learn about Support Vector Machines, one of the most popular and widely used supervised machine learning algorithms.

Learn about Support Vector Machines (SVM), one of the most popular supervised machine learning algorithms. Use Python Sklearn for SVM classification today!

community

datacamp

Data Science Tutorials