DEV Community: PRAKASH GANGURDE

20 Linux Commands Every CS Student Should Know

PRAKASH GANGURDE — Sat, 20 Jun 2026 08:55:49 +0000

The practical commands that actually matter — with real examples for each one

By Prakash Gangurde | BCA Student | Technical Content Creator | AI • Python • Linux

Introduction

When I first opened a Linux terminal, I stared at a blinking cursor and had absolutely no idea what to do.

No buttons. No menus. Just a black screen waiting for me to type something.

If that sounds familiar — this article is for you.

Linux is not just for hackers and system administrators. As a CS student, you will encounter Linux in web servers, cloud platforms, cybersecurity, data science, and software development. The sooner you get comfortable with the terminal, the faster everything else becomes.

This article covers 20 commands I actually use — not a textbook list of every possible flag, but the ones that solve real problems you will face as a student. Each command comes with a real example, not just a definition.

Estimated reading time: 15–18 minutes
Tested on Ubuntu 22.04 LTS. Most commands work identically on any Debian-based Linux system and macOS terminal.

Before We Start — The Terminal Basics

Opening the terminal:

Ubuntu/Linux: Press Ctrl + Alt + T
macOS: Search "Terminal" in Spotlight
Windows: Use WSL (Windows Subsystem for Linux) or install Ubuntu

Reading command syntax:
When you see something like command [option] <argument>, it means:

command — the actual command to type
[option] — optional flag (in square brackets)
<argument> — required input (in angle brackets)

One rule before everything else:

Linux is case-sensitive. File.txt, file.txt, and FILE.TXT are three different files.

Navigation Commands

1. `pwd` — Print Working Directory

What it does: Shows you exactly where you are in the file system.

pwd

Output:

/home/prakash/projects

When you use it: Any time you get lost and need to know your current location. Think of it as "where am I right now?"

2. `ls` — List Directory Contents

What it does: Shows all files and folders in the current directory.

ls

Output:

Desktop  Documents  Downloads  projects  README.md

The version you will actually use:

ls -la

Output:

drwxr-xr-x  5 prakash prakash 4096 Jun 10 10:30 .
drwxr-xr-x 18 prakash prakash 4096 Jun  9 08:15 ..
-rw-r--r--  1 prakash prakash  220 Jun  9 08:15 .bash_logout
drwxr-xr-x  3 prakash prakash 4096 Jun 10 09:45 projects
-rw-r--r--  1 prakash prakash 1024 Jun 10 10:30 README.md

l gives you detailed info (permissions, size, date). a shows hidden files (files starting with .).

When you use it: Every single time you open a terminal.

3. `cd` — Change Directory

What it does: Moves you into a different folder.

cd projects          # go into the projects folder
cd ..                # go up one level
cd ~                 # go to your home directory from anywhere
cd /var/www/html     # go to an absolute path
cd -                 # go back to the previous directory

When you use it: Constantly. This is how you navigate your entire file system.

4. `mkdir` — Make Directory

What it does: Creates a new folder.

mkdir my-project              # create one folder
mkdir -p projects/python/day1 # create nested folders all at once

The -p flag is extremely useful — it creates all the parent folders if they don't exist yet.

When you use it: Every time you start a new project.

5. `clear` — Clear the Terminal Screen

What it does: Clears all the clutter from your terminal screen.

clear

Or just press Ctrl + L — same result, faster.

When you use it: When your terminal gets too messy to read.

File Operations

6. `touch` — Create an Empty File

What it does: Creates a new empty file instantly.

touch index.html
touch app.py
touch notes.txt

When you use it: Creating new files without opening an editor first.

7. `cp` — Copy Files and Folders

What it does: Copies a file or folder from one location to another.

cp app.py app_backup.py               # copy a file
cp -r projects/ projects_backup/      # copy an entire folder

The -r flag means "recursive" — required when copying folders.

When you use it: Before making big changes to a file — always keep a backup.

8. `mv` — Move or Rename Files

What it does: Moves a file to a new location OR renames it.

mv old_name.py new_name.py            # rename a file
mv app.py /home/prakash/projects/     # move a file to a different folder
mv folder1/ folder2/                  # rename a folder

When you use it: Organising files or renaming them without opening a file manager.

9. `rm` — Remove Files and Folders

What it does: Permanently deletes files or folders.

rm file.txt                  # delete a file
rm -r old_project/           # delete a folder and everything inside it

⚠️ Warning: Linux has no recycle bin. rm is permanent. Always double-check before running it. Never run rm -rf / — it deletes everything on the system.

When you use it: Cleaning up old files and project folders.

10. `cat` — Display File Contents

What it does: Prints the contents of a file directly in the terminal.

cat README.md
cat requirements.txt
cat /etc/hosts

When you use it: Quickly reading a small file without opening an editor. Also useful for checking config files.

Search and Find

11. `grep` — Search Inside Files

What it does: Searches for a specific word or pattern inside files.

grep "import" app.py                  # find all lines with "import" in app.py
grep -r "password" .                  # search for "password" in all files recursively
grep -n "def " app.py                 # show line numbers where "def " appears
grep -i "error" log.txt               # case-insensitive search

When you use it: Finding which file contains a specific function, variable, or text. I use grep -r almost every day when working on projects.

12. `find` — Find Files by Name

What it does: Searches for files and folders by name, type, or size.

find . -name "app.py"                 # find a file named app.py
find . -name "*.txt"                  # find all .txt files
find . -type d -name "node_modules"   # find all folders named node_modules
find /home -name "*.py" -size +1M     # find Python files larger than 1MB

When you use it: When you know a file exists but can't remember where you put it.

Permissions

13. `chmod` — Change File Permissions

What it does: Controls who can read, write, or execute a file.

chmod 755 script.py        # owner can read/write/execute, others can read/execute
chmod +x run.sh            # make a file executable
chmod 644 config.txt       # owner can read/write, others can only read

Understanding 755:

First digit (7) = owner: read + write + execute
Second digit (5) = group: read + execute
Third digit (5) = others: read + execute

When you use it: Any time you want to run a Python or shell script directly from the terminal, you need to make it executable with chmod +x.

14. `sudo` — Run as Administrator

What it does: Runs a command with administrator (root) privileges.

sudo apt update                       # update package list
sudo apt install python3-pip          # install software
sudo chmod 777 /var/www/html          # change permissions on system folders

When you use it: Installing software, changing system files, or running anything that requires admin access.

⚠️ Only use sudo when you actually need it. Running everything as sudo is a security risk.

Process Management

15. `ps aux` — View Running Processes

What it does: Shows all currently running processes on the system.

ps aux                                # show all processes
ps aux | grep python                  # find all running Python processes
ps aux | grep streamlit               # check if your Streamlit app is running

The | (pipe) sends the output of ps aux directly into grep — so you only see processes matching "python".

When you use it: When a script seems stuck and you need to find its process ID to stop it.

16. `kill` — Stop a Running Process

What it does: Stops a running process using its process ID (PID).

kill 1234                             # politely ask process 1234 to stop
kill -9 1234                          # force stop process 1234 immediately

To find the PID, use ps aux | grep python first, then note the number in the second column.

When you use it: When a program freezes or a server won't stop with Ctrl+C.

Networking

17. `ping` — Test Network Connection

What it does: Checks if a server or website is reachable from your machine.

ping google.com                       # test internet connection
ping 192.168.1.1                      # test connection to your router
ping -c 4 google.com                  # send exactly 4 packets then stop

When you use it: First step when diagnosing network problems. "Is the server down or is my internet down?"

18. `curl` — Transfer Data from URLs

What it does: Downloads content from a URL or sends HTTP requests.

curl https://example.com              # get the HTML of a webpage
curl -O https://example.com/file.zip  # download a file
curl -X POST https://api.example.com/data -d '{"key":"value"}'  # send a POST request

When you use it: Testing your own APIs, downloading files, or checking if a web server is responding. Essential for backend development and cybersecurity testing.

Package Management

19. `apt` — Install and Manage Software (Ubuntu/Debian)

What it does: Installs, updates, and removes software packages.

sudo apt update                       # refresh the list of available packages
sudo apt upgrade                      # upgrade all installed packages
sudo apt install python3-pip          # install a specific package
sudo apt install git                  # install git
sudo apt remove package-name          # uninstall a package

Always run sudo apt update before installing anything — this ensures you get the latest version.

When you use it: Installing any tool or software on a Linux system.

20. `history` — View Command History

What it does: Shows a numbered list of all commands you have previously run.

history                               # show all previous commands
history | grep git                    # find all git commands you've run
history | tail -20                    # show the last 20 commands
!42                                   # re-run command number 42 from history
!!                                    # re-run the last command

When you use it: When you ran a command earlier and want to run it again but can't remember exactly what you typed. Also useful for finding commands you use often.

Bonus — 3 Shortcuts That Save Time Every Day

These are not commands but keyboard shortcuts that will make your terminal life significantly faster:

Shortcut	What it does
`Ctrl + C`	Cancel the current running command immediately
`Ctrl + Z`	Pause the current process and send it to background
`Tab`	Auto-complete file names and commands — press once to complete, twice to see options
`↑ arrow`	Cycle through previous commands — faster than retyping
`Ctrl + L`	Clear the screen (same as `clear`)

The Tab key is the single most underused feature in the terminal. Get in the habit of pressing Tab after typing the first few letters of any file name — it completes the rest automatically.

Quick Reference — All 20 Commands

#	Command	What it does
1	`pwd`	Show current location
2	`ls -la`	List all files with details
3	`cd`	Change directory
4	`mkdir -p`	Create folders
5	`clear`	Clear terminal screen
6	`touch`	Create empty file
7	`cp -r`	Copy files and folders
8	`mv`	Move or rename
9	`rm -r`	Delete files and folders
10	`cat`	Read file contents
11	`grep -r`	Search inside files
12	`find`	Find files by name
13	`chmod`	Change permissions
14	`sudo`	Run as administrator
15	`ps aux`	View running processes
16	`kill`	Stop a process
17	`ping`	Test network connection
18	`curl`	Transfer data from URLs
19	`apt`	Install software
20	`history`	View command history

Try It Yourself — Challenge

Open your terminal right now and try this sequence:

mkdir linux-practice
cd linux-practice
touch hello.py
echo "print('Hello from Linux!')" > hello.py
cat hello.py
python3 hello.py
ls -la
cd ..
rm -r linux-practice

This uses 7 commands from this article in one go. If everything ran without errors — you are already comfortable with the Linux terminal.

What to Learn Next

These 20 commands are your foundation. Once you are comfortable with them, explore:

Topic	What it covers
Bash scripting	Automate tasks by writing shell scripts
File permissions in depth	Understanding `rwx` and `chmod` numbers fully
SSH	Connect to remote servers securely
Vim / Nano	Edit files directly in the terminal
Cron jobs	Schedule commands to run automatically
Networking tools	`netstat`, `nmap`, `traceroute` for deeper network analysis

Summary — What You Learned Today

✅ 5 navigation commands — move around the file system confidently
✅ 5 file operation commands — create, copy, move, delete files
✅ 2 search commands — find files and search inside them
✅ 2 permission commands — control who can access your files
✅ 2 process commands — see and stop running programs
✅ 2 networking commands — test connections and talk to servers
✅ 1 package manager — install software properly
✅ 1 history command — never retype a long command again
✅ 5 keyboard shortcuts — work faster every day

All Code on GitHub

The terminal practice script from this article is in my GitHub:

📌 GitHub Repository:
https://github.com/prakashgangurde-ux/linux-notes

Let's Connect

If this article helped you, please clap on Medium — it helps other students find it.

Drop any question in the comments — I read and reply to every one.

LinkedIn: linkedin.com/in/prakash-gangurde
GitHub: github.com/prakashgangurde-ux
Medium: medium.com/@gangurdeprakash

Next article: **How I Built an AI-Powered Network Intrusion Detection System as a BCA Student**

Written by Prakash Gangurde — BCA Student | Technical Content Creator | AI • Python • Linux

Python Functions Explained Simply

PRAKASH GANGURDE — Mon, 15 Jun 2026 09:58:00 +0000

Write reusable code blocks that make your programs cleaner and more powerful

By Prakash Gangurde | BCA Student | Technical Content Creator | AI • Python • Linux

Part 2 of the Python for Absolute Beginners series

Introduction

Imagine you are writing a program that calculates a student's grade. You write the logic once. Then you realize you need to calculate the grade again in another part of the program. Do you copy and paste the same code?

No — you use a function.

A function is a block of code you write once and can use as many times as you need. It is one of the most important concepts in programming, and once you understand it, your code will become cleaner, shorter, and far easier to read.

In this article you will learn:

What a function is and why it matters
How to define and call a function in Python
The difference between parameters and arguments
How return values work
How to use default parameters
How to build a real project using everything you learn

Estimated reading time: 12–15 minutes
This is Part 2 of the Python for Absolute Beginners series. If you have not read Part 1, start here: Python Basics for Absolute Beginners

What Is a Function?

A function is a named block of code that performs a specific task.

Think of it like a coffee machine. You press one button and it does everything — grinds the beans, heats the water, and pours the coffee. You do not need to know how it works internally. You just press the button and get the result.

In Python, a function works the same way:

You define it once (build the coffee machine)
You call it whenever you need it (press the button)

Without functions, your code looks like this — repetitive and hard to manage:

# Without functions — repeated code
student1_score = 85
if student1_score >= 90:
    print("Grade: A")
elif student1_score >= 75:
    print("Grade: B")
elif student1_score >= 60:
    print("Grade: C")
else:
    print("Grade: F")

student2_score = 72
if student2_score >= 90:
    print("Grade: A")
elif student2_score >= 75:
    print("Grade: B")
elif student2_score >= 60:
    print("Grade: C")
else:
    print("Grade: F")

With functions, the same logic becomes:

# With functions — clean and reusable
def get_grade(score):
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    elif score >= 60:
        return "C"
    else:
        return "F"

print(get_grade(85))   # B
print(get_grade(72))   # C
print(get_grade(95))   # A

Same result. Half the code. Much easier to fix if something goes wrong.

Defining a Function — The `def` Keyword

To create a function in Python, you use the def keyword.

Here is the basic structure:

def function_name():
    # code goes here

Let's write the simplest possible function:

def greet():
    print("Hello! Welcome to Python.")

To run (call) the function, you write its name followed by parentheses:

greet()

Output:

Hello! Welcome to Python.

You can call it as many times as you want:

greet()
greet()
greet()

Output:

Hello! Welcome to Python.
Hello! Welcome to Python.
Hello! Welcome to Python.

The code inside greet() runs every time you call it — without you having to rewrite it.

Important: Indentation

Python uses indentation (spaces at the start of a line) to know what belongs inside a function. Every line inside the function must be indented by 4 spaces or one Tab.

def greet():
    print("This is inside the function")   # ✅ indented — belongs to greet()

print("This is outside the function")     # ✅ no indent — runs separately

If you forget the indent, Python throws an IndentationError:

def greet():
print("Hello")   # ❌ IndentationError — not indented

This is one of the most common mistakes for beginners. Always indent your function body.

Parameters and Arguments

Right now our greet() function always prints the same message. What if we want to greet different people by name?

This is where parameters come in.

A parameter is a variable you define inside the function parentheses — it acts as a placeholder for the value that will be passed in.

def greet(name):       # name is a parameter
    print(f"Hello, {name}! Welcome to Python.")

When you call the function, you pass the actual value — this is called an argument:

greet("Prakash")       # "Prakash" is the argument
greet("Rahul")
greet("Priya")

Output:

Hello, Prakash! Welcome to Python.
Hello, Rahul! Welcome to Python.
Hello, Priya! Welcome to Python.

The difference between parameters and arguments

This confuses many beginners because tutorials use these words interchangeably. They are not the same:

def greet(name):        # name = PARAMETER (the placeholder in the definition)
    print(f"Hello, {name}!")

greet("Prakash")        # "Prakash" = ARGUMENT (the actual value you pass)

Simple way to remember:

Parameter = the placeholder when you define the function
Argument = the actual value when you call the function

Multiple parameters

A function can take more than one parameter:

def introduce(name, age, course):
    print(f"My name is {name}. I am {age} years old and studying {course}.")

introduce("Prakash", 21, "BCA")
introduce("Rahul", 20, "BSc CS")

Output:

My name is Prakash. I am 21 years old and studying BCA.
My name is Rahul. I am 20 years old and studying BSc CS.

Return Values

So far our functions print things to the screen. But what if you want a function to give you back a value that you can use later?

That is what the return keyword does.

def add(a, b):
    return a + b

When you call this function, it gives back the result:

result = add(10, 5)
print(result)          # 15

You can use the returned value directly in calculations:

total = add(10, 5) + add(3, 7)
print(total)           # 25

print vs return — understanding the difference

This trips up almost every beginner:

# Using print inside function
def add_print(a, b):
    print(a + b)       # displays the result but gives nothing back

# Using return inside function
def add_return(a, b):
    return a + b       # gives the result back to use later

# The difference:
add_print(3, 4)        # prints 7, but you can't store it
result = add_return(3, 4)   # stores 7 in result — you can use it
print(result * 2)      # 14

Rule of thumb:

Use print when you just want to display something
Use return when you want to use the result later in your program

Default Parameters

Sometimes you want a function to have a default value if no argument is passed.

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

Now you can call it two ways:

greet("Prakash")              # uses default greeting
greet("Rahul", "Good morning")  # uses custom greeting

Output:

Hello, Prakash!
Good morning, Rahul!

Default parameters must always come after regular parameters. This will cause an error:

def greet(greeting="Hello", name):   # ❌ SyntaxError
    print(f"{greeting}, {name}!")

This is correct:

def greet(name, greeting="Hello"):   # ✅ default parameter at the end
    print(f"{greeting}, {name}!")

A Note About `input()` and Types

Before we build our project, one important thing to remember from Part 1:

input() always returns a string — even if the user types a number.

age = input("Enter your age: ")
print(type(age))     # <class 'str'>  — it's text, not a number

If you want to use it as a number, convert it:

age = int(input("Enter your age: "))    # converts to integer
score = float(input("Enter score: "))   # converts to decimal number

This matters in our project below because we will be working with scores.

Real Project — Student Report Card Generator

Let us build something genuinely useful. This program uses multiple functions to generate a complete student report card.

# Student Report Card Generator
# Written by Prakash Gangurde

def get_grade(score):
    """Returns the letter grade for a given score."""
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    elif score >= 60:
        return "C"
    elif score >= 40:
        return "D"
    else:
        return "F"

def calculate_percentage(total, max_marks):
    """Calculates percentage from total marks obtained."""
    return round((total / max_marks) * 100, 2)

def get_remarks(percentage):
    """Returns remarks based on percentage."""
    if percentage >= 90:
        return "Outstanding"
    elif percentage >= 75:
        return "Excellent"
    elif percentage >= 60:
        return "Good"
    elif percentage >= 40:
        return "Needs Improvement"
    else:
        return "Please seek academic support"

def print_report(name, scores):
    """Prints a formatted report card for the student."""
    subjects = ["Python", "Linux", "Web Dev", "Cybersecurity", "Database"]
    total = sum(scores)
    max_marks = len(subjects) * 100
    percentage = calculate_percentage(total, max_marks)
    remarks = get_remarks(percentage)

    print()
    print("=" * 40)
    print("       STUDENT REPORT CARD")
    print("=" * 40)
    print(f"Name       : {name}")
    print("-" * 40)

    for subject, score in zip(subjects, scores):
        grade = get_grade(score)
        print(f"{subject:<15} {score}/100     Grade: {grade}")

    print("-" * 40)
    print(f"Total      : {total}/{max_marks}")
    print(f"Percentage : {percentage}%")
    print(f"Remarks    : {remarks}")
    print("=" * 40)

# --- Main Program ---
print("=== Student Report Card Generator ===")
print()

name = input("Enter student name: ")

print(f"\nEnter marks out of 100 for {name}:")
scores = []

subjects = ["Python", "Linux", "Web Dev", "Cybersecurity", "Database"]
for subject in subjects:
    score = int(input(f"  {subject}: "))
    scores.append(score)

print_report(name, scores)

Sample output:

=== Student Report Card Generator ===

Enter student name: Prakash Gangurde

Enter marks out of 100 for Prakash Gangurde:
  Python: 88
  Linux: 92
  Web Dev: 79
  Cybersecurity: 95
  Database: 83

========================================
       STUDENT REPORT CARD
========================================
Name       : Prakash Gangurde
----------------------------------------
Python          88/100     Grade: B
Linux           92/100     Grade: A
Web Dev         79/100     Grade: B
Cybersecurity   95/100     Grade: A
Database        83/100     Grade: B
----------------------------------------
Total      : 437/500
Percentage : 87.4%
Remarks    : Excellent
========================================

Notice what this project uses:

4 separate functions — each does one specific job
Parameters and return values
A loop to collect input
zip() to pair subjects with scores
sum() to total the scores
f-strings for clean formatting

Each function is small, focused, and reusable. This is exactly how real programs are written.

Try It Yourself — Challenge

Before moving to the next article, try this challenge:

Write a function called bmi_calculator that takes two parameters: weight (in kg) and height (in metres).
It should return the BMI value using the formula: BMI = weight / (height × height)
Then write another function called bmi_category that takes the BMI value and returns:

"Underweight" if BMI < 18.5

"Normal" if BMI is 18.5–24.9

"Overweight" if BMI is 25–29.9

"Obese" if BMI >= 30

This uses everything from this article: functions, parameters, return values, and conditions.

What to Learn Next

You now understand functions — one of the most important building blocks in programming. Here is what comes next:

Topic	What it does
Lists and Tuples	Store collections of data
Loops	Repeat actions automatically
Dictionaries	Store key-value pairs
File Handling	Read and write files
Modules	Import and use existing code

Each of these will be covered in the next articles in this series.

Summary — What You Learned Today

✅ What a function is and why it makes code better
✅ How to define a function using the def keyword
✅ The difference between parameters and arguments
✅ How return gives back values from a function
✅ How default parameters work
✅ Why indentation matters inside functions
✅ How to build a real project using multiple functions together

All Code on GitHub

Every code example from this article is in my GitHub repository:

📌 GitHub: [### Write reusable code blocks that make your programs cleaner and more powerful

By Prakash Gangurde | BCA Student | Technical Content Creator | AI • Python • Linux

Part 2 of the Python for Absolute Beginners series

Introduction

No — you use a function.

In this article you will learn:

What a function is and why it matters
How to define and call a function in Python
The difference between parameters and arguments
How return values work
How to use default parameters
How to build a real project using everything you learn

Estimated reading time: 12–15 minutes
This is Part 2 of the Python for Absolute Beginners series. If you have not read Part 1, start here: Python Basics for Absolute Beginners

What Is a Function?

A function is a named block of code that performs a specific task.

In Python, a function works the same way:

You define it once (build the coffee machine)
You call it whenever you need it (press the button)

Without functions, your code looks like this — repetitive and hard to manage:

# Without functions — repeated code
student1_score = 85
if student1_score >= 90:
    print("Grade: A")
elif student1_score >= 75:
    print("Grade: B")
elif student1_score >= 60:
    print("Grade: C")
else:
    print("Grade: F")

student2_score = 72
if student2_score >= 90:
    print("Grade: A")
elif student2_score >= 75:
    print("Grade: B")
elif student2_score >= 60:
    print("Grade: C")
else:
    print("Grade: F")

With functions, the same logic becomes:

# With functions — clean and reusable
def get_grade(score):
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    elif score >= 60:
        return "C"
    else:
        return "F"

print(get_grade(85))   # B
print(get_grade(72))   # C
print(get_grade(95))   # A

Same result. Half the code. Much easier to fix if something goes wrong.

Defining a Function — The `def` Keyword

To create a function in Python, you use the def keyword.

Here is the basic structure:

def function_name():
    # code goes here

Let's write the simplest possible function:

def greet():
    print("Hello! Welcome to Python.")

To run (call) the function, you write its name followed by parentheses:

greet()

Output:

Hello! Welcome to Python.

You can call it as many times as you want:

greet()
greet()
greet()

Output:

Hello! Welcome to Python.
Hello! Welcome to Python.
Hello! Welcome to Python.

The code inside greet() runs every time you call it — without you having to rewrite it.

Important: Indentation

Python uses indentation (spaces at the start of a line) to know what belongs inside a function. Every line inside the function must be indented by 4 spaces or one Tab.

def greet():
    print("This is inside the function")   # ✅ indented — belongs to greet()

print("This is outside the function")     # ✅ no indent — runs separately

If you forget the indent, Python throws an IndentationError:

def greet():
print("Hello")   # ❌ IndentationError — not indented

This is one of the most common mistakes for beginners. Always indent your function body.

Parameters and Arguments

Right now our greet() function always prints the same message. What if we want to greet different people by name?

This is where parameters come in.

A parameter is a variable you define inside the function parentheses — it acts as a placeholder for the value that will be passed in.

def greet(name):       # name is a parameter
    print(f"Hello, {name}! Welcome to Python.")

When you call the function, you pass the actual value — this is called an argument:

greet("Prakash")       # "Prakash" is the argument
greet("Rahul")
greet("Priya")

Output:

Hello, Prakash! Welcome to Python.
Hello, Rahul! Welcome to Python.
Hello, Priya! Welcome to Python.

The difference between parameters and arguments

This confuses many beginners because tutorials use these words interchangeably. They are not the same:

def greet(name):        # name = PARAMETER (the placeholder in the definition)
    print(f"Hello, {name}!")

greet("Prakash")        # "Prakash" = ARGUMENT (the actual value you pass)

Simple way to remember:

Parameter = the placeholder when you define the function
Argument = the actual value when you call the function

Multiple parameters

A function can take more than one parameter:

def introduce(name, age, course):
    print(f"My name is {name}. I am {age} years old and studying {course}.")

introduce("Prakash", 21, "BCA")
introduce("Rahul", 20, "BSc CS")

Output:

My name is Prakash. I am 21 years old and studying BCA.
My name is Rahul. I am 20 years old and studying BSc CS.

Return Values

So far our functions print things to the screen. But what if you want a function to give you back a value that you can use later?

That is what the return keyword does.

def add(a, b):
    return a + b

When you call this function, it gives back the result:

result = add(10, 5)
print(result)          # 15

You can use the returned value directly in calculations:

total = add(10, 5) + add(3, 7)
print(total)           # 25

print vs return — understanding the difference

This trips up almost every beginner:

# Using print inside function
def add_print(a, b):
    print(a + b)       # displays the result but gives nothing back

# Using return inside function
def add_return(a, b):
    return a + b       # gives the result back to use later

# The difference:
add_print(3, 4)        # prints 7, but you can't store it
result = add_return(3, 4)   # stores 7 in result — you can use it
print(result * 2)      # 14

Rule of thumb:

Use print when you just want to display something
Use return when you want to use the result later in your program

Default Parameters

Sometimes you want a function to have a default value if no argument is passed.

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

Now you can call it two ways:

greet("Prakash")              # uses default greeting
greet("Rahul", "Good morning")  # uses custom greeting

Output:

Hello, Prakash!
Good morning, Rahul!

Default parameters must always come after regular parameters. This will cause an error:

def greet(greeting="Hello", name):   # ❌ SyntaxError
    print(f"{greeting}, {name}!")

This is correct:

def greet(name, greeting="Hello"):   # ✅ default parameter at the end
    print(f"{greeting}, {name}!")

A Note About `input()` and Types

Before we build our project, one important thing to remember from Part 1:

input() always returns a string — even if the user types a number.

age = input("Enter your age: ")
print(type(age))     # <class 'str'>  — it's text, not a number

If you want to use it as a number, convert it:

age = int(input("Enter your age: "))    # converts to integer
score = float(input("Enter score: "))   # converts to decimal number

This matters in our project below because we will be working with scores.

Real Project — Student Report Card Generator

Let us build something genuinely useful. This program uses multiple functions to generate a complete student report card.

# Student Report Card Generator
# Written by Prakash Gangurde

def get_grade(score):
    """Returns the letter grade for a given score."""
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    elif score >= 60:
        return "C"
    elif score >= 40:
        return "D"
    else:
        return "F"

def calculate_percentage(total, max_marks):
    """Calculates percentage from total marks obtained."""
    return round((total / max_marks) * 100, 2)

def get_remarks(percentage):
    """Returns remarks based on percentage."""
    if percentage >= 90:
        return "Outstanding"
    elif percentage >= 75:
        return "Excellent"
    elif percentage >= 60:
        return "Good"
    elif percentage >= 40:
        return "Needs Improvement"
    else:
        return "Please seek academic support"

def print_report(name, scores):
    """Prints a formatted report card for the student."""
    subjects = ["Python", "Linux", "Web Dev", "Cybersecurity", "Database"]
    total = sum(scores)
    max_marks = len(subjects) * 100
    percentage = calculate_percentage(total, max_marks)
    remarks = get_remarks(percentage)

    print()
    print("=" * 40)
    print("       STUDENT REPORT CARD")
    print("=" * 40)
    print(f"Name       : {name}")
    print("-" * 40)

    for subject, score in zip(subjects, scores):
        grade = get_grade(score)
        print(f"{subject:<15} {score}/100     Grade: {grade}")

    print("-" * 40)
    print(f"Total      : {total}/{max_marks}")
    print(f"Percentage : {percentage}%")
    print(f"Remarks    : {remarks}")
    print("=" * 40)

# --- Main Program ---
print("=== Student Report Card Generator ===")
print()

name = input("Enter student name: ")

print(f"\nEnter marks out of 100 for {name}:")
scores = []

subjects = ["Python", "Linux", "Web Dev", "Cybersecurity", "Database"]
for subject in subjects:
    score = int(input(f"  {subject}: "))
    scores.append(score)

print_report(name, scores)

Sample output:

=== Student Report Card Generator ===

Enter student name: Prakash Gangurde

Enter marks out of 100 for Prakash Gangurde:
  Python: 88
  Linux: 92
  Web Dev: 79
  Cybersecurity: 95
  Database: 83

========================================
       STUDENT REPORT CARD
========================================
Name       : Prakash Gangurde
----------------------------------------
Python          88/100     Grade: B
Linux           92/100     Grade: A
Web Dev         79/100     Grade: B
Cybersecurity   95/100     Grade: A
Database        83/100     Grade: B
----------------------------------------
Total      : 437/500
Percentage : 87.4%
Remarks    : Excellent
========================================

Notice what this project uses:

4 separate functions — each does one specific job
Parameters and return values
A loop to collect input
zip() to pair subjects with scores
sum() to total the scores
f-strings for clean formatting

Each function is small, focused, and reusable. This is exactly how real programs are written.

Try It Yourself — Challenge

Before moving to the next article, try this challenge:

Write a function called bmi_calculator that takes two parameters: weight (in kg) and height (in metres).
It should return the BMI value using the formula: BMI = weight / (height × height)
Then write another function called bmi_category that takes the BMI value and returns:

"Underweight" if BMI < 18.5

"Normal" if BMI is 18.5–24.9

"Overweight" if BMI is 25–29.9

"Obese" if BMI >= 30

This uses everything from this article: functions, parameters, return values, and conditions.

What to Learn Next

You now understand functions — one of the most important building blocks in programming. Here is what comes next:

Topic	What it does
Lists and Tuples	Store collections of data
Loops	Repeat actions automatically
Dictionaries	Store key-value pairs
File Handling	Read and write files
Modules	Import and use existing code

Each of these will be covered in the next articles in this series.

Summary — What You Learned Today

✅ What a function is and why it makes code better
✅ How to define a function using the def keyword
✅ The difference between parameters and arguments
✅ How return gives back values from a function
✅ How default parameters work
✅ Why indentation matters inside functions
✅ How to build a real project using multiple functions together

All Code on GitHub

Every code example from this article is in my GitHub repository:

📌 GitHub: github.com/prakashgangurde-ux/python-basics

Let's Connect

If this article helped you, please clap on Medium — it helps other beginners find it.

Drop any question in the comments — I read and reply to every one.

LinkedIn: linkedin.com/in/prakashgangurde
GitHub: github.com/prakashgangurde-ux
Medium: medium.com/@gangurdeprakash

Next article: **Lists in Python — Store and Manage Collections of Data* *

Written by Prakash Gangurde — BCA Student | Technical Content Creator | AI • Python • Linux](https://github.com/prakashgangurde-ux/python-basics)

Let's Connect

If this article helped you, please clap on Medium — it helps other beginners find it.

Drop any question in the comments — I read and reply to every one.

LinkedIn: linkedin.com/in/prakashgangurde
GitHub: github.com/prakashgangurde-ux
Medium: medium.com/@gangurdeprakash

Next article: Lists in Python — Store and Manage Collections of Data

Written by Prakash Gangurde — BCA Student | Technical Content Creator | AI • Python • Linux

Python Basics for Absolute Beginners

PRAKASH GANGURDE — Wed, 10 Jun 2026 05:54:08 +0000

Everything you need to start writing Python code today — no experience needed

By Prakash Gangurde | Technical Content Creator | AI • Python • Linux

Introduction

Python is one of the most popular programming languages in the world — and also one of the easiest to learn.

It powers artificial intelligence, web applications, data science, automation, and cybersecurity tools. Companies like Google, Instagram, NASA, and Netflix use Python every single day. Yet the syntax is so simple that a complete beginner can write a working program in under five minutes.

I am a final-year BCA student who has been learning Python, and in this article I am sharing exactly what helped me understand the fundamentals. By the end of this guide, you will understand what Python is, how to install it, and how to write your very first programs — even if you have never written a single line of code before.

No prior experience is needed. Let's begin.

What Is Python and Why Should You Learn It?

Python is a general-purpose, high-level programming language created by Guido van Rossum and first released in 1991. The name comes not from the snake, but from the British comedy show Monty Python's Flying Circus — which tells you a lot about the fun spirit behind the language.

What makes Python special is how closely it reads like plain English. Compare this to other languages like C or Java, which have complex syntax and strict rules. Python removes most of that complexity so you can focus on solving problems rather than fighting the language itself.

What is Python used for?

Artificial Intelligence and Machine Learning — libraries like TensorFlow and PyTorch
Data Science and Analysis — libraries like Pandas and NumPy
Web Development — frameworks like Django and Flask
Automation and Scripting — automating repetitive tasks
Cybersecurity — writing tools and scripts for ethical hacking
Game Development — using libraries like Pygame

Why learn Python specifically?

It has the largest beginner community of any programming language
There are more free tutorials, courses, and resources for Python than almost anything else
It is consistently the among the most in-demand languages, especially in AI, data science, and automation in job postings for data science, AI, and software development
You can go from beginner to building real projects faster than with most other languages

If you are a student and you could only learn one programming language, Python is the right choice.

How to Install Python

Before writing any code, you need Python installed on your computer. This takes about five minutes.

Step 1 — Download Python

Go to the official website: python.org

Click on Downloads and download the latest version of Python 3 (any version starting with 3 is fine — for example, Python 3.12).

Step 2 — Install Python

Run the installer file you downloaded.

Important: On the first screen of the installer, check the box that says "Add Python to PATH" before clicking Install. If you skip this step, Python will not work correctly from the terminal.

Step 3 — Verify the installation

Open your terminal (Command Prompt on Windows, Terminal on Mac or Linux) and type:

python --version

"On Linux/macOS if this doesn't work, try python3 --version"

You should see something like:

Python 3.12.0

If you see a version number, Python is installed correctly. Congratulations.

Step 4 — Choose a code editor

You need a place to write your Python code. I recommend Visual Studio Code (VS Code) — it is free, lightweight, and used by professional developers worldwide.

Download it here: code.visualstudio.com

After installing VS Code, install the Python extension from the Extensions panel (Ctrl+Shift+X), search for "Python", and install the one by Microsoft.

Alternative — No installation needed

If you do not want to install anything right now, you can use Replit — a free online editor where you can write and run Python code directly in your browser. This is a great option to get started immediately.

Your First Python Program — Hello, World!

Every programmer's journey begins with the same program. It is a tradition.

Open VS Code, create a new file called hello.py, and type the following:

print("Hello, World!")

Now run the file. In VS Code, right-click the file and select "Run Python File in Terminal", or open the terminal and type:

python hello.py

You will see this output:

Hello, World!

That is it. You just wrote and ran your first Python program.

Let's understand what happened. print() is a function — a built-in command that tells Python to display something on the screen. Whatever you put inside the parentheses and quotation marks is what gets printed.

Try changing the message:

print("My name is Prakash and I am learning Python!")

Run it again. Python will print exactly what you wrote. Simple, clean, and powerful.

Variables and Data Types

A variable is like a labelled box. You store a value inside it and give it a name so you can use it later.

In Python, creating a variable is as simple as writing:

name = "Prakash"

Here, name is the variable. "Prakash" is the value stored inside it. The = sign assigns the value to the variable.

The four basic data types

Python has four basic types of data you will use constantly:

name = "Prakash Gangurde"    # String  — text, always inside quotes
age = 21                      # Integer — whole numbers
gpa = 8.5                     # Float   — decimal numbers
is_student = True             # Boolean — only True or False

Let's print all of them:

print(name)
print(age)
print(gpa)
print(is_student)

Output:

Prakash Gangurde
21
8.5
True

Checking the type of a variable

Python has a built-in function called type() that tells you what kind of data a variable holds:

print(type(name))        # <class 'str'>
print(type(age))         # <class 'int'>
print(type(gpa))         # <class 'float'>
print(type(is_student))  # <class 'bool'>

This is useful when you are debugging and want to understand what kind of value you are working with.

Variable naming rules

Variable names cannot have spaces — use underscores instead: first_name
They cannot start with a number: 2name is invalid, name2 is fine
They are case-sensitive: Name and name are two different variables
Use descriptive names: student_age is better than x
Python programmers typically use ****snake_case for variable names.

Getting Input from the User

So far your programs have only displayed fixed text. Let's make them interactive.

Python has a built-in function called input() that lets the user type something, and your program can use that value.

name = input("What is your name? ")
print("Hello, " + name + "!")

When you run this, the program pauses and waits for you to type. After you press Enter, it prints your greeting.

Example:

What is your name? Prakash
Hello, Prakash!

A cleaner way — f-strings

Instead of joining strings with the + operator, Python has a much cleaner method called f-strings (formatted strings). You put an f before the quotation mark, and then use curly braces {} to insert variables directly:

name = input("What is your name? ")
age = input("How old are you? ")
print(f"Hello, {name}! You are {age} years old.")

Output:

Hello, Prakash! You are 21 years old.

F-strings are the modern and preferred way to format text in Python. Get comfortable with them early.

Arithmetic and Operators

Python can perform all standard mathematical operations. This makes it extremely useful for everything from simple calculations to complex data analysis.

a = 10
b = 3

print(a + b)    # Addition       → 13
print(a - b)    # Subtraction    → 7
print(a * b)    # Multiplication → 30
print(a / b)    # Division       → 3.3333...
print(a // b)   # Floor division → 3  (no decimal)
print(a % b)    # Modulo         → 1  (remainder)
print(a ** b)   # Exponent       → 1000 (10 to the power 3)

A practical example — simple calculator

Let's combine input and arithmetic to build a tiny calculator:

num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

print(f"Addition:       {num1 + num2}")
print(f"Subtraction:    {num1 - num2}")
print(f"Multiplication: {num1 * num2}")
print(f"Division:       {num1 / num2}")

Notice we used float() to convert the input — because input() always returns text, and we need numbers to do math. This is called type conversion, and it is something you will use often.

"If you type letters instead of numbers, Python will raise a ValueError — we will cover error handling in a later article”

Try running this with different numbers. You have just built your first useful Python program.

Comments — How to Write Notes in Your Code

A comment is a line in your code that Python ignores completely. It is written for humans — for you, or anyone else reading your code — to explain what is happening.

In Python, comments start with the # symbol:

# This is a comment — Python will not run this line
print("This line will run")   # You can also add a comment at the end of a line

# Store the student's details
name = "Prakash"
age = 21

Get into the habit of writing comments. When you come back to your code after a few days, comments will remind you what each part does. When you share code on GitHub, comments help others understand your logic.

Putting It All Together — A Mini Student Profile Program

Let's combine everything you have learned into one small program:

# Student Profile Program
# Written by Prakash Gangurde

print("=== Student Profile Generator ===")
print()

# Get student information
name = input("Enter your name: ")
age = input("Enter your age: ")
course = input("Enter your course: ")
cgpa = float(input("Enter your CGPA: "))

# Display the profile
print()
print("====== YOUR PROFILE ======")
print(f"Name   : {name}")
print(f"Age    : {age} years")
print(f"Course : {course}")
print(f"CGPA   : {cgpa}")

# Check if CGPA is above average
if cgpa >= 7.0:
    print("Status : Good Standing ✓")
else:
    print("Status : Needs Improvement")

print("==========================")

Sample output:

=== Student Profile Generator ===

Enter your name: Prakash Gangurde
Enter your age: 21
Enter your course: BCA
Enter your CGPA: 8.5

====== YOUR PROFILE ======
Name   : Prakash Gangurde
Age    : 21 years
Course : BCA
CGPA   : 8.5
Status : Good Standing ✓
==========================

This program uses variables, input, f-strings, arithmetic, and even a preview of the if/else condition you will learn in the next article. Upload this to your GitHub — it is a real project.

What to Learn Next

You have covered the foundation. Here is what comes next in Python:

Topic	What it does
If / Else conditions	Make decisions in your code
Loops (for, while)	Repeat actions automatically
Functions	Organise and reuse your code
Lists and Dictionaries	Store and manage collections of data
File Handling	Read and write files
Libraries	Use powerful tools others have built

Each of these topics will be covered in the next articles in this series. Follow me on Medium so you don't miss them.

Summary — What You Learned Today

In this article you covered:

✅ What Python is and why it is the best first language to learn
✅ How to install Python and set up VS Code
✅ How to write and run your first program using print()
✅ Variables and the four basic data types
✅ Getting user input with input()
✅ Formatting output with f-strings
✅ Arithmetic operators and type conversion
✅ Writing comments in your code
✅ Building a complete mini project

Python takes consistent practice. Write at least 10–15 lines of code every day — even small programs — and you will be surprised how quickly it starts to feel natural.

All Code on GitHub

Every code example in this article is available in my GitHub repository. You can copy, run, and experiment with all of it:

GitHub : https://github.com/prakashgangurde-ux/python-basics

Let's Connect

If this article helped you, please give it a clap on Medium — it helps more beginners find it.

If any part was confusing or you have a question, drop it in the comments. I read and reply to every comment.

You can also find me on:

LinkedIn: www.linkedin.com/in/prakashgangurde
GitHub: https://github.com/prakashgangurde-ux
Medium: medium.com/@gangurdeprakash

Next article: *Python Functions Explained Simply** — how to write reusable blocks of code that make your programs cleaner and more powerful.*

Written by Prakash Gangurde — BCA Student | Technical Content Creator | AI • Python • Linux

DEV Community: PRAKASH GANGURDE

20 Linux Commands Every CS Student Should Know

The practical commands that actually matter — with real examples for each one

Introduction

Before We Start — The Terminal Basics

Navigation Commands

1. pwd — Print Working Directory

2. ls — List Directory Contents

3. cd — Change Directory

4. mkdir — Make Directory

5. clear — Clear the Terminal Screen

File Operations

6. touch — Create an Empty File

7. cp — Copy Files and Folders

8. mv — Move or Rename Files

9. rm — Remove Files and Folders

10. cat — Display File Contents

Search and Find

11. grep — Search Inside Files

12. find — Find Files by Name

Permissions

13. chmod — Change File Permissions

14. sudo — Run as Administrator

Process Management

15. ps aux — View Running Processes

16. kill — Stop a Running Process

Networking

17. ping — Test Network Connection

18. curl — Transfer Data from URLs

Package Management

19. apt — Install and Manage Software (Ubuntu/Debian)

20. history — View Command History

Bonus — 3 Shortcuts That Save Time Every Day

Quick Reference — All 20 Commands

Try It Yourself — Challenge

What to Learn Next

Summary — What You Learned Today

All Code on GitHub

Let's Connect

Python Functions Explained Simply

Write reusable code blocks that make your programs cleaner and more powerful

Introduction

What Is a Function?

Defining a Function — The def Keyword

Important: Indentation

Parameters and Arguments

The difference between parameters and arguments

Multiple parameters

Return Values

print vs return — understanding the difference

Default Parameters

A Note About input() and Types

Real Project — Student Report Card Generator

Try It Yourself — Challenge

What to Learn Next

Summary — What You Learned Today

All Code on GitHub

Introduction

What Is a Function?

Defining a Function — The def Keyword

Important: Indentation

Parameters and Arguments

The difference between parameters and arguments

Multiple parameters

Return Values

print vs return — understanding the difference

Default Parameters

A Note About input() and Types

Real Project — Student Report Card Generator

Try It Yourself — Challenge

What to Learn Next

Summary — What You Learned Today

All Code on GitHub

Let's Connect

Let's Connect

Python Basics for Absolute Beginners

Everything you need to start writing Python code today — no experience needed

Introduction

What Is Python and Why Should You Learn It?

What is Python used for?

1. `pwd` — Print Working Directory

2. `ls` — List Directory Contents

3. `cd` — Change Directory

4. `mkdir` — Make Directory

5. `clear` — Clear the Terminal Screen

6. `touch` — Create an Empty File

7. `cp` — Copy Files and Folders

8. `mv` — Move or Rename Files

9. `rm` — Remove Files and Folders

10. `cat` — Display File Contents

11. `grep` — Search Inside Files

12. `find` — Find Files by Name

13. `chmod` — Change File Permissions

14. `sudo` — Run as Administrator

15. `ps aux` — View Running Processes

16. `kill` — Stop a Running Process

17. `ping` — Test Network Connection

18. `curl` — Transfer Data from URLs

19. `apt` — Install and Manage Software (Ubuntu/Debian)

20. `history` — View Command History

Defining a Function — The `def` Keyword

A Note About `input()` and Types

Defining a Function — The `def` Keyword

A Note About `input()` and Types