DEV Community: Michael_Maranan

Introduction to Pandas: Data Reading

Michael_Maranan — Wed, 04 Oct 2023 14:38:22 +0000

In this blog, we'll explore the process of reading and working with data using Pandas. No prior experience is necessary – we'll start from the basics and guide you through every step with simple explanations and practical examples.

By the end of this journey, you'll have the skills to effortlessly import, explore, and make sense of data from various sources. So, let's dive into it!

Topics

A. Importing and Reading Data Files
- A.1. Reading Data
- A.2. Naming Columns
- A.3. Handling Missing Values
- A.4. Using Different Separators
B. Exploring the Data
C. Saving the Data

A. Importing and Reading Data Files

Before we start, let's import our Pandas module first.

import pandas as pd

A.1. Reading Data

Reading data is a fundamental step in data analysis, and Pandas simplifies this process by offering functions for importing data from various sources, including CSV, Excel, and databases.

For this tutorial, I'm going to use a CSV file containing the following data.

John Doe,28,Male,45000,johndoe@example.com
Jane Smith,35,Female,60000,janesmith@example.com
Mike Johnson,22,Male,,mikejohnson@example.com
Emily Davis,,Female,55000,emilydavis@example.com
Chris Brown,40,,75000,chrisbrown@example.com
Anna Lee,27,Female,62000,annalee@example.com
David Clark,32,Male,68000,davidclark@example.com
Sophia Kim,29,Female,51000,sophiakim@example.com
Kevin Wilson,38,Male,,kevinwilson@example.com
Linda Johnson,45,Female,72000,lindajohnson@example.com
Robert Smith,33,Male,58000,robertsmith@example.com
Mary Wilson,,Female,62000,marywilson@example.com
William Davis,28,Male,48000,williamdavis@example.com
Jennifer Lee,29,Female,53000,jenniferlee@example.com
Michael Brown,36,Male,70000,michaelbrown@example.com
Patricia Miller,31,Female,56000,patriciamiller@example.com
James Taylor,42,Male,80000,jamestaylor@example.com
Karen Anderson,34,Female,,karenanderson@example.com
Joseph Martinez,26,Male,49000,josephmartinez@example.com

As what I mentioned earlier, Pandas has built-in functions for reading different data files. Some of these are read_csv, read_xlsx, read_html, read_json, read_sql, etc.

# filename
csv_url = "data.csv"

# reading CSV files
df = pd.read_csv(csv_url)

df

Output:

By calling the df variable, we can see the data from our source file.

A.2. Naming Columns

As you notice if we call our data table, it sets the first row of text as its column-name/header by default. But in our CSV file, we don't have a header for each column so it set the first row of data as the header. To prevent it from doing so, we can use the header argument and set it to None.

df = pd.read_csv(csv_url, header=None)
df.head()

Output:

By setting our header to None, we avoided setting the first row as header and set our header to numbers instead. To give each column a proper header name, we can use the names argument.

df = pd.read_csv(csv_url, header=None, names=["Name", "Age", "Sex", "Income", "Email"])
df.head()

Output:

A.3. Handling Missing Values

If we look back at our table, especially in the "Income" column, we will notice some of the missing data have different symbols.

df["Income"]

Output:

You can convert these symbols into NaN by mentioning it in the na_values argument.

df = pd.read_csv(
    csv_url, 
    header=None, 
    names=["Name", "Age", "Sex", "Income", "Email"], 
    na_values=["?", "_", "--"] # replaces the following character with NaN
)
df["Income"]

Output:

A.4. Using Different Separators

If you ever run into a CSV with a different separator (let's say your data file got - instead of ,), you can use the delimiter or sep argument.

df = pd.read_csv(
    csv_url, 
    header=None, 
    names=["Name", "Age", "Sex", "Income", "Email"], 
    na_values=["?", "_", "--"] # replaces the following character with NaN
    sep="-" # changes separator
)

sep and delimiter works the same.

df = pd.read_csv(
    csv_url, 
    header=None, 
    names=["Name", "Age", "Sex", "Income", "Email"], 
    na_values=["?", "_", "--"] # replaces the following character with NaN
    delimiter="-" # changes separator
)

You can often use delimiter or sep interchangeably for simple cases where a single character separates values. However, if you need to handle more complex separation patterns or use regular expressions, then sep offers more flexibility.

Here's an example of sep using a regular expression to separate by either a comma or a semicolon:

df = pd.read_csv('data.csv', sep='[,;]')

B. Exploring the Data

Pandas also have built-in methods for viewing the basic information about our data.

df.info()

Output:

The info(), from the name itself, returns the basic information about the data table, data such as Column, Dtype (data type), etc.

If you want to access the first or last few rows of the table, you can use head() and tail().

# head()
df.head()

Output:

# tail()
df.tail()

Output:

The head() returns the first rows of the data table while the tail() returns the last rows. They return 5 rows by default.

You can pass a number on both functions to specify how many rows you want to be returned.

df.head(3)

Output:

df.tail(7)

Output:

Here are some more functions that will return basic information:

df.describe() - Generate summary statistics of numeric columns.

df.describe()

Output:

df.shape - Get the dimensions of the DataFrame (rows, columns).

df.shape

Output:

df['column_name'] - Access a specific column.

df["Email"]

C. Saving Data

After processing your data, you can save it back to a file or a database using Pandas. For example, to save a DataFrame to a CSV file:

df.to_csv('new_data.csv', index=False)

The index=False argument prevents Pandas from writing the row indices to the CSV file.

Pandas provides a rich set of functions for data manipulation and analysis, making it a powerful tool for working with tabular data in Python.

In conclusion, data reading with Pandas is an essential and powerful skill for data analysts and scientists. This Python library simplifies the process of importing data from various sources, such as CSV files, Excel spreadsheets, and databases, and provides a user-friendly interface for data exploration. By mastering Pandas' data reading capabilities, professionals can efficiently load, manipulate, and analyze datasets, making it a cornerstone of practical data analysis workflows.

Converting ".ipynb" Files to Other File Format

Michael_Maranan — Thu, 28 Sep 2023 04:27:58 +0000

I love using Jupyter Notebook especially when I'm learning something new with Python. Aside from using it with Pandas, it allows me to quickly document my learnings, whereas I can take notes and write and run codes in the same file. There are times I publish these notes into blogs, so I have to convert these .ipynb files into .md files, and it is a real hassle to transfer them into another file line-by-line. So, I got curious and searched for a Python module for converting .ipynb files into other file types, and lucky there is a module for this job. It is called nbconvert module and if you don't know about this yet, here's a quick guide to using it.

Install Jupyter nbconvert (if you haven't already):

You can install nbconvert using pip:

pip install nbconvert

Convert .ipynb to .md:

You can convert a .ipynb file to .md using the following command in your terminal or command prompt:

jupyter nbconvert --to markdown your_notebook.ipynb

Replace your_notebook.ipynb with the actual name of your Jupyter Notebook file. This command will create a Markdown file with the same name as your notebook but with the .md extension.

Converting to other formats:

The nbconvert library supports converting Jupyter Notebooks to various formats, including HTML, PDF, LaTeX, and more. To convert to a different format, replace --to markdown with the format of your choice. For example:

HTML: --to html
PDF: --to pdf
LaTeX: --to latex
You can specify the output file name using the --output option, followed by the desired file name and extension.

Here's an example command to convert a .ipynb file to HTML:

jupyter nbconvert --to html your_notebook.ipynb

These commands will generate the respective output files in the same directory as your Jupyter Notebook. And that's how you can easily convert a .ipynb file into another file format.

Introduction to Pandas: Series and DataFrames

Michael_Maranan — Mon, 11 Sep 2023 14:28:58 +0000

The Pandas Series and DataFrames are some of the core elements you need for Data Analysis with Python and the Pandas library. You can both use them for data reading, storing, modifying, and more. If you want to know more about Series and DataFrames, let's jump right into it.

What are Series and What are DataFrames

Let's quickly identify first what is a series and what is a data frame. Both of them are datasets, they just have different shapes. They aren't the same, but they are very related.

The Series (pandas.Series) are datasets with 1-dimensional shapes. It is more likely an array or a list in Python. It can store any kind of object, and the cool thing is that you can customize its index with a different set of numbers (int or float) or you can also use strings (str).

On the other hand, DataFrames (pandas.DataFrames) are 2-dimensional datasets. It has rows and columns which is very useful when creating a table. As I said, series and data frames are related to each other, it is because each column in a data frame is a Series.

Using the Series

Let's import the pandas module first, then use pd.Series() to create a series.

import pandas as pd

sr = pd.Series([1, 23, 34, 24, 51, 15])

output:

Calling our variable sr will return us a Series with a default numeric index. In able to change the index, we can use the index argument when creating the Series or after the Series was made.

# customizing after a series was created
sr.index = ['q','w','e','r','t','y']
sr

output:

# customizing index while creating
sr = pd.Series(
    [1, 2, 3, 4, 5, 6],
    index=['Q', 'W', 'E', 'R', 'T', 'Y'],
    name="Number List"
)
sr

output:

You can also name your Series. A Series name acts as a column name since DataFrame columns are actually Series.

By simply calling the variable sr, we can read the whole Series. In terms of reading a specific cell of an object, we can call it using an index like how we do in ordinary Python.

>>> sr["Q"]
    1

You can also read objects using a range of indexes.

sr["Q":"T"]

output:

# other way of calling with index is using the .loc method
sr.loc["Q":"R"]

output:

We can still access object cells using a numeric index with the .iloc method.

>>> sr.iloc[2:-1]

output:

Using conditions with our Series, we can get a boolean series as an output. We can use this to read objects conditionally.

sr >= 4

output:

sr[sr >= 4]

output:

To add another object in your series, you can add an object like how we do it in Python dictionaries.

sr["U"] = 78

output:

You can also add/merge a Series with another Series using .append().

sr.append(pd.Series([33,44,55]))

output:

As you notice, the index of the older objects remains the same (strings form) and the newly merged objects have a default numeric index value. The new objects got their indices from the old Series they're in, so if we modify their index and append it to other Series, the objects will retain their old index.

sr.append(pd.Series([66,77,88], index=["I","O","P"]))

output:

However, we can reset the index of both Series by using the ignore_index argument.

sr.append(pd.Series([55,56,67], index=["a","s","d"]), ignore_index=True)

output:

Note: The modifications like append won't be saved automatically. If we call our Series, we will see there's nothing changed.

>>> sr
    Q     1
    W     2
    E     3
    R     4
    T     5
    Y     6
    U    78
    Name: Number List, dtype: int64

# saving the operations we did
sr = sr.append(pd.Series([55,56,67], index=["a","s","d"]), ignore_index=True)

output:

Using DataFrames

For dealing with a bigger set of data/objects with multiple columns, we can use DataFrames.

df = pd.DataFrame({
    "Age": [21,19,22,20,23,23,21],
    "Sex": ["M","M","F","M","F","F","M"],
    "GPA": [3.45,2.98,3.72,2.87,3.90,4.00,1.90]
}, index=["James", "Mark", "Rebecca", "David", "Lucy", "Judy", "Johnny"])

df

output:

Calling our DataFrame or Series with .head() will return the first rows of our dataset. Passing an int to this function will return the first nth rows, but will return the first 5 rows as default (if you don't pass a number). However, if you want to access the last rows, you can use the .tail() function.

# default .head() or .tail() will return 5 rows
df.head()

output:

# adding a number as an argument
df.tail(3)

output:

Like the Series, in order to access objects using a string index, we can use the .loc function, and for the numeric index, you can use .iloc.

# single accessing
df.loc["Judy"]

output:

# accessing multiple rows through range
df.iloc[1:-1]

output:

You can also specify what columns you only want to pick from them.

# return columns mentioned only
df.loc["David":"Johnny", ["Age", "Sex"]]

output:

And if we can pick a row, we can also drop a row.

df.drop(["James", "Mark"])

output:

Another thing you can use to access rows/objects is by passing a condition to the DataFrame.

# the condition we want will return a boolean value
df["GPA"] >= 3.0

output:

# the condition will return the data of only those who meet our condition
df[df["GPA"] >= 3.0]

output:

To add another column in our DataFrame, we're going to use Series. Let's create another row for our DataFrame using the condition we used earlier.

# creating new column out on an existing column
is_passed = pd.Series(df["GPA"] >= 3.0, index=df.index)

is_passed

output:

# adding the column to our DataFrame
df["Is Passed"] = is_passed

df

output:

And if you ever want to rename a column or an index, let's say you put a wrong index or want to change the name of a column, you can use the .rename() function.

df.rename(
    columns = {
        "Is Passed": "Passed GPA"
    },
    index = {
        "James": "J. Doe",
        "Mark": "M. Villar",
        "David": "D. Martinez",
    }
)

output:

Remember, all the changes won't be saved automatically unless you save it into a variable (or update its old variable).

One last thing, Pandas Series and DataFrames have more cool features. You can run pandas.Series? or pandas.DataFrame? to quickly view the documentation.

So there you have it! With Series and DataFrames in your toolkit, you've got the muscle to handle data like a pro. Whether you're diving into data for work, play, or sheer curiosity, Pandas has your back. I hope you find this blog helpful, thanks, and have a good day.

Fun Game Projects in Python

Michael_Maranan — Sat, 22 Jul 2023 11:15:00 +0000

For the last few months, I start learning about Pygame since building games seems fun doing with Python. Throughout my journey, I created some of the famous cool games which are good practices to enhance skills and knowledge with Pygame.

Topics

Why do you need CS Fundamentals in Software Development

Michael_Maranan — Fri, 12 Aug 2022 05:29:00 +0000

Intro

Software engineering is a branch of Computer Science that is responsible for creating, designing, and maintaining software apps, from web apps to local device stored software. It requires enough Computer Science skills including the basics to make the job done.

The computer science basics are the bridge for the students in learning about the Tech, for introducing them to the concepts, and also teaching them the basics skills they might use in the long run. Take note that these Computer Science basics are also applicable in other branches of Computer Science and not just to Software Engineering.

In this blog, you will be able to learn about:

The importance of CS fundamentals in Software Engineering
The CS fundamentals useful in Software Engineering
Where you can learn them

Why CS Fundamentals matters in Software Engineering

I discussed some reasons above why you need CS fundamentals. Now, we're gonna take a closer look at them.

Why CS fundamentals matter in software development

Having enough knowledge about basic skills and principles helps a lot when making software apps. One of the biggest concerns in developing an app is the speed and how much space it consumes. Luck you, most of these basic lessons focus on memory allocation and space management which helps you to identify what part of the program consumes most of the space and time and also teaches how to solve them and/or how to avoid them. Users will keep on complaining if your app is laggy. It may cause you to lose your app's users and prevent newer users to be in your app and start finding a better substitute app from it.

Advantages of knowing CS fundamentals

As I mentioned earlier, it is a foundation of knowledge in learning. With these basics, you can learn other Computer Science fields. It's like understanding the logic of programming and now you can learn new programming languages with them without hassle and hardships, unlike the first time you did it. Another thing, when you are searching for a job having no experience, most of the technical questions they might ask are from the basics. Since you are applying for an entry-level, they expect you have enough knowledge of what you are doing to make the job done. It's common sense like "how will you know about what you're doing if you don't even know the basics of your field?".

Computer Science 101

The CS Fundamentals

I list down some of the CS basics you need in Software Engineering.

Programming Languages

Learning how to write a programming language is the most important foundation you need to get started. Programming languages are the primary tools of developers. It covers understanding syntax, using various special keywords, clean coding, and more. Learning multiple programming languages is a great advantage because it gives you the flexibility to work on different projects written in different languages. Another advantage of learning multiple languages is that you can choose the language that best suits your app's needs and satisfies the requirements.

Data Structures & Algorithms

The Data structures & Algorithms are responsible for making the right sequence of solutions and data organizing. It also provides an understanding on what is the best solution set for a particular case. One of its concerns is saving memory space occupied and time consumed by using the Complexity Analysis. The Complexity Analysis has 3 tests; Big O notation (O=n) tests the worst-case of the algorithm, Big Theta notation (Θ=n) tests the average case of the algorithm, and the Big Omega notation (Ω=n) tests the best-case of the algorithm.

Debugging & Pen Testing

Project software needs to be tested and debugged. Testing helps the developers to catch the errors the user might encounter and debugging solves these caught problems so that next time another user ends up in the same scenario where the error was caught, there's no error raising up anymore. Testing and Debugging were done before releasing the app or while the team was maintaining an app. CS course may teach you simple testing scripts about how to use them. For example, Python's unittest. It is easy to learn and to use for testing a code or any software project.

Software Designing

Software Designing is the planning and designing part of the app, translating every word that describes all the parts of the software into a big-picture plan, which can be scripted into a working code. This Computer Science fundamental lesson is useful when starting an app from totally scratch, where you only have a text full of requirements.

Programming Paradigms

Programming Paradigm is a way of programming based on the language used. Every language has its way of coding. Some use more classes while others significantly use functions. A programming paradigm that mostly uses classes with applied principles and rules for classes is called Object Oriented Programming or OOP. Some of the programming languages where OOP was applicable are, Java, Python, and Ruby. On the other hand, Functional Programming mostly use functions and has rules and principles about functions. Some languages that support Functional style are Elixir, C++, and Erlang.

Programming Frameworks

The Programming Frameworks are special packages that provide ready-to-use tools for the project you are planning to build. Some examples of this are React & Node JS made from JavaScript, Django & Flask made from Python, and Laravel from PHP.

Operating Systems

Operating Systems manage the computer's memory allocation and processes. Proper knowledge about Operating Systems is important in picking the right one for machines and servers depending on their specs. If you can't find the perfect one for your machine, with the right knowledge, you can make your own OS based on Linux or any open source distro you want.

Learning CS Fundamentals

In a CS degree

Getting a Computer Science degree in college is the most preferable learning way of the most. You can get a 4-year course in a university where they will provide all the learning materials and step-by-step roadmap you need, and aside from Software Engineering, you'll be able to learn other branches of Computer Science like Data Science, Artificial Intelligence, etc. Well, this is optional. Remember we are in the information age, and there are plenty of other ways to study it. I'm gonna mention them below.

Online Courses

Getting an online boot camp or online courses is one of the best options you have. You can access them and learn remotely anytime anywhere. Online Bootcamps and Courses give you certificate as a proof you know to code which you can use when applying for a developer job position. Many of the jr. developers are fresh out from boot camps.

Books

Just like the Online Courses, books about learning Computer Science can give you enough knowledge to study. Books are effective in their own way where everything describes detailed providing many different examples for each scenario. Most universities use books as part of their learning tool these days. Except for physical books, you can also download E-books which are easy to access and carry on any place as long as you have your gadgets with you.

Conclusion

Remember that within the 7 basic lessons I mention above, you can have a head start in Software Engineering. You can also use them in other fields of Computer Science that you may find yourself interested in. If you want to get started learning more about Computer Science, you can pick between a college degree, an online course, or books. Software engineering is actually fun. It allows you to bring your creative software ideas into reality where you can not just visualize them, but also bring them to life and see their real-life purpose.

Make a Simple Employee managing app in Django with Class Based Views (With Login, Logout)

Michael_Maranan — Sat, 23 Apr 2022 15:55:09 +0000

A few months ago when I'm learning about Django class-based views, I made an app where I practice my Django skills using classes. Now, I'm here to share it in you.

Setup

Requirements
django - pip intsall django

Make a DIR with a virtual environment if you want
Run django-admin startproject projectname .
Run python manage.py startapp appname
Add app dependency in project

-I choose to name my projectname as my_project and appname as the_app. my_project and the_app is what we're gonna use for this one.



# /my_project/settings.py

INSTALLED_APPS = [
    ...,
    'the_app.apps.TheAppconfig',
]

Making app's urls.py (optional) -You can use the project's urls.py but you can make another for the app to separate it from the URLs of other apps you may add in the future. A. Create a urls.py inside the_app directory or what we have the_app, and then; ```python

/the_app/urls.py

from django.urls import path

urlpatterns = [
path('chosen url', function(), name=None), # Function-based syntax
path('chosen url', class.as_view(), name=None), # Class based syntax
]

B. Connect `my_project/urls.py` to `the_app/urls.py`
```python


# /my_project/urls.py

...
from django.urls import path, include

urlpatterns = [
    ...,
    path('', include('the_app.urls')),
]

Tip: Try to run it by python manage.py runserver and go to localhost:8000 or 127.0.0.1:8000 to see if it's working.

Make a Directory for templates
-Make a folder inside the_app named templates, and inside it, make a folder named the_app. That's where we place our templates. If you look at its order, it looks like this:
```
-/the_app/templates/the_app$

--OR--

the_app
    templates
        the_app
my_project
manage.py
```


***

## Making a Model
- Django Models are used to make tables and what they should contain (data types like string, picture, etc.). 
-Now we're making a _Person()_ model where every manager can save there the people they were in charge of. And each `Person` has a task so we also gonna make a _Task()_ model.
```python


# /the_app/models.py

from django.db import models
from django.contrib.auth.models import User

# Create your models here.
class Person(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, null=True)
    name = models.CharField(max_length=200, null=True)

    def __str__(self):
        return self.name

class Task(models.Model):
    peep = models.ForeignKey(Person, on_delete=models.CASCADE)
    task = models.CharField(max_length=200, null=True)
    is_complete = models.BooleanField(default=False)

    def __str__(self):
        return self.task

-If we look at the first argument of the Task() model we'll see that it takes the People() model as its ForeignKey, while on the other hand, the ForeignKey of People() model is the User() model. It means for every Task created will be saved to the selected People which will be saved on whoseever Manager/User is logged in.

Working with the Views

In making a Django app, you can choose what to use between Function-Based Views and Class-Based Views, and we're gonna use the Class-Based Views (CBV).

I. UserSignUp() `(FormView)`

The FormView class allows you to make new users. We're gonna make a UserSignup() view using the Formview class by inheriting it.



# /the_app/views.py

from django.views.generic.edit import FormView
from django.contrib.auth.forms import UserCreationForm

class UserSignup(FormView):
    template_name = 'the_app/signup.html'
    form_class = UserCreationForm
    redirect_authenticated_user = True

-This is how you do a simple UserSignup() view. It will work but if you want to add some functionalities for it to add another option to make the job done, it's totally fine to do it. Now let's add form_valid() for automatic logged in once an account is created.



# /the_app/views.py

class UserSignup(FormView):
    ...
    success_url = reverse_lazy('login')

    def form_valid(self, form):
        user = form.save()
        if user is not None:
            login(self.request, user)
        return super(UserSignup, self).form_valid(form)

-In Django, you can't name the class functions by random. Instead, they are HTTP calls. When you were using your app with that class, it continues the operation until the requirements you fill in was satisfied, and then it makes a call. If you had a class function with the same name as that call, it will use that function. In our situation here in UserSignup(), we just need to provide the information the form_class wants. The form_class contains the UserCreationForm which default asks for a username and password. Once you fulfill them, the UserCreationForm calls form_valid, and there is where our form_valid() function will be called.

-What we're gonna add this time is a function that disallows you to register a new account while one is still logged in.



# /the_app/views.py

...
from django.shortcuts import redirect

class UserSignup(FormView):
    ...

    def form_valid(self, form):
        ...

    def get(self, *args, **kwargs):
        if self.request.user.is_authenticated:
            return redirect('personlist')
        return super(UserSignup, self).get(*args, **kwargs)

-Our UserSignup() should look like this:

-Now let's make a page for it. Make signup.html inside the_app/templates/the_app:

-After that, let's make a URL for UserSignup() in urls.py:



# /the_app/urls.py

...
from .views import UserSignup

urlpatterns = [
    path('signup/', UserSignup.as_view(), name='signup'),
]

II. UserLogin (LoginView)

LoginView is used for signing in/logging in to the User accounts.



# /the_app/views.py

...
from django.contrib.auth.views import LoginView
from django.urls import reverse_lazy


class UserLogin(LoginView):
    template_name = 'the_app/signin.html'
    fields = '__all__'
    redirect_authenticated_user = True

    def get_success_url(self):
        return reverse_lazy('personlist')

-As if you notice, the get_success_url() function says reverse_lazy to a URL named 'personlist'. That means when logged in successfully (get_success_url call), head to the personlist URL name to access the PersonList() class. For now, we don't have a PersonList() class but we'll make one later.

-We can make a signin.html now. Remember to place it inside the the_app/templates/the_app/.

-And don't forget to link it in urls.py:



# /the_app/urls.py

...
from .views import UserLogin

urlpatterns = [
    ...,
    path('login/', UserLogin.as_view(), name='login'),
]

III. LogoutView

LogoutView is all about what you think it does. There is a simple way of making a LogoutView using only the urls.py by adding some lines of code.



# /the_app/urls.py

...
from django.contrib.auth.views import LogoutView

urlpatterns = [
    ...,
    path('logout/', LogoutView.as_view(next_page='login'), name='logout'),
]

-LogoutView.as_view() has an argument next_page which 'login' and if we look at the UserLogin() class's URL, we may notice that its name is 'login'. That means, that after we logged out, our app will automatically redirect to the login page.

IV. PersonCreate (View)

Django has a built-in class-view for this job which is the CreateView. But for some reason like wanting to add some functionalities, I'd rather choose to use the generic View function than CreateView. View is a regular class-based view without any specials to use, making it easier to modify and use if you want a super customizable class view. What is class PersonCreate() do is add an employee or a person on the User's employee list.



# /the_app/views.py

...
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import View
from django.shortcuts import render,redirect


class PersonCreate(LoginRequiredMixin,View):

    def get(self,request):
        return render(request,'the_app/person_create_form.html')

    def post(self,request):
        user = User.objects.get(username=request.user)
        my_name = request.POST.get('name')
        user.person_set.create(name=my_name)
        my_object = user.person_set.get(name=my_name).id
        return redirect('persondetail',my_object)

-If you look at the function names I use in PersonCreate(), they look like an ordinary function view. The only difference is their name was also an HTTP call.

-Make a person_create_form.html in the_app/templates/the_app.

Then the urls:



# /the_app/urls.py

...
from .views import PersonCreate

urlpatterns = [
    ...,
    path('person-create/', PersonCreate.as_view(), name='personcreate'),
]

V. PersonList (View)

PersonList() class allows us to see the employee list the User has. Django has a specific class-view for this type of work too, which is called ListView. But for the same reason as I have earlier in PersonCreate() class, I use the generic views than the ListView.



# /the_app/views.py

...
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import View
from django.shortcuts import render


class PersonList(LoginRequiredMixin,View):
    def get(self,request):
        account = User.objects.get(username=request.user)
        context = {'person_list':account}
        return render(request,'the_app/home.html',context)

-After that, let's make the_app/templates/the_app/home.html for this class view:

-And then, the theapp/urls.py:



# /the_app/urls.py

...
from .views import PersonList

urlpatterns = [
    ...,
    path('', PersonList.as_view(), name='personlist'),
]

-Let's take a look at the urlpattern of the PersonList(), you may notice that its path name is personlist. If we remember, we configure it in UserLogin() before. That means when the UserLogin() is successful, we'll be directed to the PersonList() which allows us to see the listed employees there.

VI. PersonDetail (DetailView)

Django's DetailView() class allows you to see the details (tasks) of a specific object (person/employee).



# /the_app/views.py

...
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic.detail import DetailView


class PersonDetail(LoginRequiredMixin,DetailView):
    model = Person
    context_object_name = 'person'
    template_name = 'the_app/person_detail.html'

    def get(self,*args,**kwargs):
        return super(PersonDetail, self).get(*args,**kwargs)

-It will work, but I'm about to add some functions to it for adding, modifying, or deleting tasks for every employee.



# /the_app/views.py

class PersonDetail(LoginRequiredMixin,DetailView):
    ...

    def post(self,*args,**kwargs):
        return super(PersonDetail, self).get(*args,**kwargs)

    def dispatch(self,request,pk,*args,**kwargs):
        peep = self.model.objects.get(id=pk)
        if self.request.POST.get('save'):
            for task in peep.task_set.all():
                if request.POST.get(f't{task.id}') == 'clicked':
                    task.is_complete = True
                else:
                    task.is_complete = False
                task.save()

        elif self.request.POST.get('add_item'):
            new = request.POST.get('new_item')
            peep.task_set.create(task=new, is_complete=False)

        elif request.POST.get('delete_this'):
            task_index = request.POST.get('delete_this')
            peep.task_set.get(id=task_index).delete()

        return super(PersonDetail, self).dispatch(request,*args,**kwargs)

-The dispatch call allows us to add or modify a Person's task. Look closely at dispatch() functions if-statements, those if-statements are the actions we can do on PersonDetail's page on run. If we make any of those actions, it calls the post() and now we can access the data/changes the User made using dispatch() and saving them.

-The PersonDetail() code looks exactly as this one:

-And for our template, let's make person_detail.html.

-Don't forget the urls.py:



# /the_app.urls.py
...
from .views import PersonDetail

urlpatterns = [
    ...,
    path('person-detail/pk=<int:pk>', PersonDetail.as_view(), name='persondetail'),
]

VII. PersonUpdate (UpdateView)



# /the_app/views.py

...
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic.edit import UpdateView

class PersonUpdate(LoginRequiredMixin,UpdateView):
    model = Person
    fields = ['name']
    template_name = 'the_app/person_update_form.html'
    success_url = reverse_lazy('personlist')

-This type of class-view updates the field you chosen.

-For the_app/person_update_form.html:

-For urls:



# /the_app/urls.py

...
from .views import PersonUpdate

urlpatterns = [
    ...,
    path('person-update/pk=<int:pk>', PersonUpdate.as_view(), name='personupdate'),
]

VIII. PersonDelete (DeleteView)

DeleteView does what exactly it sounds; it delete objects (person/employees.



# /the_app/views.py

...
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic.edit import DeleteView


class PersonDelete(LoginRequiredMixin,DeleteView):
    model = Person
    success_url = reverse_lazy('personlist')
    template_name = 'the_app/person_confirm_delete.html'

-For person_confirm_delete.html:

-For urls of PersonDelete():



# /the_app/urls.py

...
from .views import PersonDelete

urlpatterns = [
    ...
    path('person-delete/pk=<int:pk>', PersonDelete.as_view(), name='persondelete'),
]

And now, it's done!! you can try it by running python manage.py runserver in CLI and then open 127.0.0.1:8000 or localhost:8000 to see if it's working.

Some screenshots of the app:
Login

Signup

Home

PersonCreate

PersonDetail

Click here to see the source code.

Good day, guys!! You can reach my account for more:
Twitter: Codeit_Michael
Github: Codeit-Michael

Learn SQLite with Python in 3 minutes!!

Michael_Maranan — Sun, 10 Apr 2022 15:57:02 +0000

SQLite is a database that is written in C. It is simple and easy to use for projects. I just started using it with Python a couple of weeks ago for some sort of small projects. Today, I'm going to teach you using SQLite with Python while creating a database for the students containing their basic information. It's just a pretty quick one, so let's get started!!

Setting up

Before we start, let's just import the Python built-in SQLite module by typing import sqlite3 at the beginning of our index.py so now we can use SQLite.

# /* index.py

import sqlite3

Creating and/or Connecting to DataBase

After importing the module we need to use, it's time to connect our code to the database. To make this happen, simply type connect = sqlite.connect(dbname.db):

connect = sqlite.connect('student.db')

Once we save and run our index.py, it will automatically create and connect to the database, with the name we give in it, and has a file extension of .db. Next, we'll create a cursor that is able to fetch or upload something to the database. Add csr = connect.cursor() in our code so our index.py now should looks like this:

Create a Table

An SQLite table is where you save your data inside your DB. We're getting their basic information such as first name, last name, and age. In creating a table, follow the syntax:

# /* index.py

cursr.execute("CREATE TABLE tablename (dataname datatype)")

connect.commit() # committing changes
connect.close() # closing connections

As you notice we have some capitalized words, these are the keywords we use to create the table. In adding their data attribute, we also configure their datatype. In SQLite, we have 5 data types which are:

5 SQLite Datatypes

null => None
integer => int
real => float
text => str
blob => files (image, files, etc.)

Now, our whole code should look like this:

Notice that we create a table through our cursor, we use it also in adding, fetching, etc. And don't forget to .commit() on every end of your configuration and .close() on the end of your code.

Adding Data on Table

In adding data, you need to identify the name of the table where you want to save these objects you've uploaded. For a better understanding, you can look at this syntax:

# /* index.py

cursr.execute("INSERT INTO tablename VALUES (data)")

connect.commit() # committing changes
connect.close() # closing connections

After putting all the required fields, you can save and run the file, in that way the data will be saved into the students table in student.db.

Selecting and Fetching Data

You have 2 options in selecting the data. Select data manually or Search specific data:

Select data mannualy - also has 2 types:

A. Get everything of everyone - fetch all student data for every student
Syntax: cursr.execute("SELECT * FROM tablename")

B. Get selected of everyone - fetch fname only of the students
Syntax: cursr.execute("SELECT dataname FROM tablename")

Search specific data - use the WHERE keyword in searching. You can search object attributes or rowid to search objects. To know the rowid of an object, simply run rowIds = cursor.execute("SELECT rowid,* FROM tablename").fetchall() then print rowIds and there you can see every object's format in tuple form like (rowid, data).

Once you get the data, you can finally fetch them so you can access them, print them, or anything.

# /* index.py

print(cursr.fetchone()) # fetch 1st object only
print(cursr.fetchmany(2)) # fetch number of objects depend on range you entered
print(cursr.fetchall()) # fetch all

Update Data

Syntax: cursr.execute("UPDATE tablename SET dataname = data WHERE dataname = data")
Let's use the data and table we added earlier as an example, let's say we're updating the age of someone who has the fname of Michael to 19 in the table of students. To do that, we're using the WHERE keyword that I introduced earlier.

# /* index.py
cursr.execute("UPDATE students SET age = 19 WHERE fname = 'Michael'")

cnt.commit()
cnt.close()

Our code now looks like this:

Delete Data

The DELETE method in SQLite uses WHERE keyword to identify what object it should erase.

Delete Table

Now if you want to delete a whole table, here it is:

These are just some of the many methods and lessons of SQLite you can use. It's so fun and easy to use with Python. If you want to know more about SQLite with Python, you can check SQLite Documentation. That's the best place to know more about this tech. Thanks for reading and have a nice day!!

My Accounts
Twitter: Codeit_Michael
Github: Codeit-Michael
LinkedIn: Michael Maranan

SOFTWARE DESIGN: FROM WORDS INTO CODES PART II

Michael_Maranan — Sun, 03 Apr 2022 12:59:11 +0000

SOFTWARE DESIGN: FROM WORDS INTO CODES PART II

In the last article I wrote which is the "SOFTWARE DESIGN: FROM WRITTEN REQUIREMENTS INTO CODES PART I", I discuss making an Entity-Relationship diagram or ER diagram which is for easier analyzation and visualization of our software we are working at. In this article, I'm going to discuss how to code it in a CLI type of app using Python.

The first method I do before jumping on my IDE and starting in any part of it is I make a pseudocode of it, making it more clear and easier to think how it should be implemented in a programming language. I guess you heard about that already. I decided to make each Object a Class and its features are its attributes. To identify where to start to make pseudocode, I try thinking about how this app will work and how it flows. We’re using the same ER diagram and requirements from the last article:
requirements.md:

ER diagram:

I. `Professor` class pseudocode:

class Professor:
    # for adding a new professor in Professor-list
    def create-prof(personal-info,salary):
        professor =  personal-info,salary
        professor.save() in 'Professors-list'

    # adding subject's prof in case it don't have
    def add-subject's-prof(subject,prof-name):
        if subject and prof-name didn't really exist:
            return invalid
        if subject's 'professor' not None:
            return has prof already
        else save subject in prof-name's 'subject-list' & prof-name in subject's 'professor'

    # for computing the professor's salary
    def prof's-salary(prof-name):
        each-subject = 5000
        subject-list-length = prof-name's subjects-list length
        return eachsubject * subject-list-length

II. `Subject` class pseudocode:

class Subject:
    # for creating a new subject to Subject-list
    def create-subject(name):
        subject = name 
        subject.save() in 'Subject-list'

    # adding subject's prof in case it don't have
    def add-subject's-prof(subject,prof-name):
        if subject and prof-name didn't really exist:
            return invalid
        if subject's 'professor' not None:
            return has prof already
        else save subject in prof-name's 'subject-list' & prof-name in subject's 'professor'

    # add courses related to subject 
    def add-courses-related(subject,course-&-year):
        if subject and course-&-year didn't really exist:
            return invalid
        else save subject in prof-name's 'subject-list' & prof-name in subject's 'professor'

III. `Course` class pseudocode:

class Course:
    # making a new course
    def create-course(name,for-year):
        course-name = name,for-year
        course.save() in 'Course-list'

    # add courses related to subject 
    def add-courses-related(subject,course-&-year):
        if subject and course-&-year didn't really exist:
            return invalid
        else save subject in prof-name's 'subject-list' & prof-name in subject's 'professor'

    # enrolling students
    def add-student(student,year-&-course):
        if student and year-&-course didn't really exist:
            return invalid
        if student's course not none:
            return already enrolled
        else save student in course's student-list and course in student's course

IV. `Student` class pseudocode:

class Student:
    # add a new student
    def create-course(personal-info,course-&-year):
        if course-&-year didn't really exist:
            return invalid
        else:
            course-name = name,for-year
            course.save() in 'Course-list'

Here are some snapshots of my code. I'm not posting the whole picture of it here because it can't fit on my screen. If you want to look at my code, you can visit it here in my github.

SOFTWARE DESIGN: FROM WORDS TO CODES PART I

Michael_Maranan — Mon, 28 Mar 2022 15:54:32 +0000

In Programming, there's a situation that comes to us where we want to turn our written requirements into codes. You may find it difficult to convert lines and paragraphs of your software specs into a working code and it is totally fine. Instead of jumping ASAP on your Code Editor or IDE and think how to start it while reading in it, you can cut it into different parts where each move seems very achievable to code. Don't worry I will give you some tested and proven ideas for doing this and it is called Software Designing.

First, we need to ready our written requirements where we get all of the ideas about our software. If you already got it, then we can move to the next phase. If you don't have one yet, don't worry I have an example below so you can cast an idea out of it.

Once, we have written requirements, we can move to the next part; Identifying the Elements.

Next, we're going to extract the parts of that paragraph above that gives the main idea of our software. For better understanding, I highlighted them as what you see below and as we go through there, I'm gonna explain them.

Green round rectangles - Objects
Blue rectangles - characteristics of Objects

Since we finished identifying each class and their attributes. It's time to think about their connections and configure their relations to each other.

Before I show you the diagram I created by traversing through the written guide, let me explain to you first the elements I used that you may see on the diagram I made so you won't be confused about these symbols.

Single arrows - singular; means "not all" of the Objects are required to have relation to another one.
Double arrows - plural; means "all" of the Objects are required to have relation to another one.
Light Blue hexagons - relationships between two Objects.
Blue rectangle with broken lines - characteristics of Objects that will have value through their relationship with another one.

TIP:
In making its connections, you should ask yourself what part is the most important, and which among entities are the most independent, and which has future connections. And that's where we start creating their connections. You don't need to think so hard to figure it out. Just pick randomly and try to figure out what should be working before it, then figure out next what is after it and that's where you can build it.

This is the method I use to turn my software ideas written in a text file into a working code. This is my implementation of doing Software Design, maybe my method is not that hardcore but the point is it helps me to make my work easier to do. Now as you can see it is easier now to understand and code. Click here to see part 2.

Good day, guys!! You can check here my accounts:
Twitter: Codeit_Michael
Github: Codeit-Michael

Youtube Video Downloader using Python Django

Michael_Maranan — Sun, 06 Feb 2022 08:57:21 +0000

Last week, I found this cool python module named pytube which seems interesting to me. For those of you who don't know, pytube module is built for downloading youtube videos for free. After knowing its fundamentals and writing a simple python script, I try to make a Django app out of it. Here's how it is done.

1. Install the Requirements

First, let's install the tools we're going to use in this app:

pip install django
pip install pytube

2. Set-up the Environment

We need to make a project first. After making a directory for it, in our terminal again, run:

~/michael/YT-Saver$
# django-admin startproject <project name> .
django-admin startproject base .
# python3 manage.py startapp <app name>
python3 manage.py startapp app

Now let's configure our Django app in our Django project by listing our app's name in base/settings.py/INSTALLED_APPS so the project now can access the app:

# base/settings.py
INSTALLED_APPS = [
    ..... ,
    'app/apps/AppConfig',
]

Next, create a urls.py inside app. To connect it in our base/urls.py:

# base/urls.py
from django.urls import path,include

urlpatterns = [
    ..... ,
    path('', include('app.urls')),
]

3. Create Views

Let's start our code by making the main heart of our app, the views. On our app/views.py, add the imports:

# base/views.py
from django.views.generic import View
from pytube import Youtube
from django.shortcuts import render,redirect

And now write the main code. Let's make a class for it that takes a url but no errors if you didn't give any and returns a page:

class home(View):
    def __init__(self,url=None):
        self.url = url
        def get(self,request):
        return render(request,'app/home.html')

Next step, add a new function in it for fetching the video and for downloading it:

class home(View):
    ....

    def post(self,request):
        # for fetching the video
        if request.POST.get('fetch-vid'):
            self.url = request.POST.get('given_url')
            video = YouTube(self.url)
            vidTitle,vidThumbnail = video.title,video.thumbnail_url
            qual,stream = [],[]
            for vid in video.streams.filter(progressive=True):
                qual.append(vid.resolution)
                stream.append(vid)
            context = {'vidTitle':vidTitle,'vidThumbnail':vidThumbnail,
                        'qual':qual,'stream':stream,
                        'url':self.url}
            return render(request,'app/home.html',context)

        # for downloading the video
        elif request.POST.get('download-vid'):
            self.url = request.POST.get('given_url')
            video = YouTube(self.url)
            stream = [x for x in video.streams.filter(progressive=True)]
            video_qual = video.streams[int(request.POST.get('download-vid')) - 1]
video_qual.download(output_path='../../Downloads')
            return redirect('home')

        return render(request,'app/home.html')

So, Are should views looks like this:

4. Create Template

As we see above, we configure a home.html file. So now where, going to create it. Make a directory first inside our app directory named templates and another one inside it, named after our app which is app where we store our 'home.html' file.

'app/template/app/home.html':

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>YT Saver</title>
</head>
<body style="align-items: center;text-align: center;height: fit-content;border: 3px solid green;">
    <h2>YT SAVER</h2>
    <b><p style="color: coral;">Save your favorite youtube videos for free!!</p></b>
    <form method="post" action="">
        {% csrf_token %}
        <!-- for fetching the video -->
        <input type="text" name="given_url" value="{{url}}" placeholder="enter url..">
        <button type="submit" name="fetch-vid" value="fetch-vid">Proceed</button>

        <br>
            <h3>{{vidTitle}}</h3>
            <img src="{{vidThumbnail}}"/>
        <br>

        <!-- for downloading the video -->
        {% for x in stream %}
            {{x.resolution}} <button type="submit" name="download-vid" value="{{forloop.counter}}">Download</button>|
        {% endfor %}
        <br><br>
    </form>
</body>
</html>

5. Create Urls

Since we already set up our base/urls.py above, now we create our app/urls.py.:

from django.urls import path
from . import views

urlpatterns = [
    path('',views.home.as_view(),name="home"),
]

6. Test the app

And now, we can finally test our app. Let's run the app, open the terminal, and type:

~/michael/YT-Saver$
python manage.py runserver

Now, head to your browser and type for localhost:8000 or 'CRTL + Left click' the link at the terminal.

Note: If you're having trouble with the Pytube module about the AttributeError: 'NoneType' object has no attribute 'span', here are some discussions in Stack Overflow and Github that might be helpful for you.

Well if everything works fine, you can now enjoy downloading youtube videos for free, and access them anytime you want. For more information about the pytube module, click here. Have a nice day!!

LET'S TALK ABOUT DJANGO CBV AND FBV

Michael_Maranan — Wed, 12 Jan 2022 14:15:20 +0000

Introduction

The Django CBV (Class Based Views) and FBV (Function Based Views) are the methods you can use to handle the MVT or the Model-View-Template workflow in a Django app. From their name itself what differentiates both of them.

Django FBV

Pros
1.Beginner friendly
It is easy to study and to code. If you look on someone's FBV source code, you can understand how the job was done under the hood just by reading the lines of their code. In terms of coding it, you can do it just like how you code any python projects.
2.Name it anything you want
You can name these functions anything you want unlike CBV functions. As long as it does the job

Cons
1.You need to do every piece of your code
Bit hassle to do. You need to code all the parts.

Example of Django FBV

def TaskList(request):
    task = Task.objects.all()
    context = {'task':task}
    return render(request, 'base/tasks.html', context)

Django CBV

Pros
1.Have so many built-ins
Have so many built-ins to use instead of coding all of them unlike the FBV. Let's say you make a view for making tasks and saving it. Instead of getting its object values then save it by calling ".save()", you can simply use the built-in "CreateView", give the Model and fields, and it will automatically saves.
2.Built ins have cool features you're not expecting
Django CBV built-in like DeleteView already provides delete confirmation, all you need to do is to connect your template on your DeleteView and put some for about it.
3.Cleaner code
Since you can use many built-ins your code looks better and shorter.

Cons
1.Bit difficult to understand
Yes it is. CBV is a bit difficult compare to FBV especially when you're using built-ins and some part may look confusing.
2.Class functions should named based on calls
Like what I said earlier, you can't name its class functions base on what you want. You should base it in calls like POST, GET, etc.

class TaskList(ListView):
    model = Task
    template_name = 'base/tasks.html'
    context_object_name = 'tasks'

Tip:

I you're a beginner, it's better if you use the FBV first and be comfortable with it before moving to CBV. A lot of Django built-ins for CBV was built for the simple tasks you do in FBV and if you hop in CBV without understanding why you need them and what it will do, you will get confuse.

Conclusion

None of them are better than another one. They have their own way in doing the job. There's something FBV can do that the CBV can't and also there's something CBV can while FBV can't. You should use what standards and kind of work suits the problem.

Printing "Hello World" using Python Django Web Framework

Michael_Maranan — Mon, 06 Sep 2021 05:53:12 +0000

Django is a python framework used for making web apps. If you don't have any idea about using Django frame work, I'm going to teach you a simple command using Django, so let's get started!!

I. Install requirements

On your command line, type "pip install django" if you are using windows. If you are using Linux, installing it is a bit different. To install this on your Linux, open your terminal and type "pip3 install django".

Since I've already installed it, it says "requirement already satisfied"

II. Make your project and your app

In Django, project and app are different from each other. Django apps are the those who contains characteristics and features of you web app. On another hand, Django projects are the compiler of the Django apps. It may contain one or more apps and apps can contain one or more features. You must create your project first before your app.

To make a project, select a directory first where you want to your local django project. After selecting one on your cmd/terminal, type "django-admin startproject myProject"

"myProject" is the name of our Django project. Inside the "myProject" directory, you can see another "myProject" directory and that is our project. It also contains "db.sqlite3" which is our database & "manage.py" which we will use to control our Django project.

To make an app, inside the first "myProject" directory, type "python manage.py startapp Myapp". But since I am using linux, I'm going to use "python3 manage.py startapp myApp"

"myApp" is the name of our django app.

Now, your app should look like this:

III. Connecting our app to our project

We need to connect our app on our project to access our app directory, "myApps". To do this, head to "myPrjoect/settings.py", then find the list of "INSTALLED_APPS". List there your app by typing "myApp.apps.MyappConfig"

"MyappConfig" is a class in apps.py which is located in "myApp" directory means "myApp.apps.MyappConfig" is a path to "MyappConfig". Now, we can access everything on our app.

To access the app, we need to connect our "myProject" to our "myApp" using the urls.py.
In our "myProject/urls.py", next to other imports, type:
from myApp import views

After it head to urlpatterns and type: path('', views.home, name = "home")

By the way, the format for urlpattern is:
path('link', views.function/class views, name='name')

This urlpattern is just one of many ways to do this work but this is one of the easiest way.

Now, our "urls.py" should look like this:

IV. Modify the app views
Now the final step is to make some modification in our myApp/views.py. In views.py, type "from django.http import HttpResponse"

Then type:

V. Testing our code
We want to know it this is working so head to the terminal again and type "python manage.py runserver" if you are using windows but I'm on Linux so I'm going to use "python3" instead of python.
After running, it should look like this:

To see it in browser "CRTL" + "Left Click" link and it will direct you to your browser. And it should look like this:

DEV Community: Michael_Maranan

Introduction to Pandas: Data Reading

A. Importing and Reading Data Files

A.1. Reading Data

A.2. Naming Columns

A.3. Handling Missing Values

A.4. Using Different Separators

B. Exploring the Data

C. Saving Data

Converting ".ipynb" Files to Other File Format

Install Jupyter nbconvert (if you haven't already):

Convert .ipynb to .md:

Converting to other formats:

Introduction to Pandas: Series and DataFrames

What are Series and What are DataFrames

Using the Series

Using DataFrames

Fun Game Projects in Python

Topics

Flappy Bird

Platformer Game

Maze Game

Slide Puzzle

Checkers

Tic-Tac-Toe

Hangman

Chess Game

Why do you need CS Fundamentals in Software Development

Intro

Why CS Fundamentals matters in Software Engineering

Why CS fundamentals matter in software development

Advantages of knowing CS fundamentals

Computer Science 101

The CS Fundamentals

Programming Languages

Data Structures & Algorithms

Debugging & Pen Testing

Software Designing

Programming Paradigms

Programming Frameworks

Operating Systems

Learning CS Fundamentals

In a CS degree

Online Courses

Books

Conclusion

Make a Simple Employee managing app in Django with Class Based Views (With Login, Logout)

Setup

/the_app/urls.py

Working with the Views

I. UserSignUp() (FormView)

II. UserLogin (LoginView)

III. LogoutView

IV. PersonCreate (View)

V. PersonList (View)

VI. PersonDetail (DetailView)

VII. PersonUpdate (UpdateView)

VIII. PersonDelete (DeleteView)

Learn SQLite with Python in 3 minutes!!

Setting up

Creating and/or Connecting to DataBase

Create a Table

Adding Data on Table

Selecting and Fetching Data

Update Data

Delete Data

Delete Table

SOFTWARE DESIGN: FROM WORDS INTO CODES PART II

SOFTWARE DESIGN: FROM WORDS INTO CODES PART II

I. Professor class pseudocode:

II. Subject class pseudocode:

III. Course class pseudocode:

IV. Student class pseudocode:

SOFTWARE DESIGN: FROM WORDS TO CODES PART I

Youtube Video Downloader using Python Django

1. Install the Requirements

2. Set-up the Environment

3. Create Views

4. Create Template

5. Create Urls

I. UserSignUp() `(FormView)`

I. `Professor` class pseudocode:

II. `Subject` class pseudocode:

III. `Course` class pseudocode:

IV. `Student` class pseudocode: