DEV Community: Gowtham

Python - Operators, Functions & Function Arguments

Gowtham — Sun, 01 Nov 2026 05:36:31 +0000

1.Operators in Python

Operators are special symbols or keywords used to perform operations on variables and values.

Python has different types of operators.

A.Arithmetic Operators

Arithmetic operators are used to perform mathematical calculations.

B.Comparison Operators

Comparison operators are used to compare two values. They return either True or False.

C.Logical Operators

Logical operators are used to combine multiple conditions.

Python has three logical operators:

1.and – Returns True if both conditions are true.

2.or – Returns True if at least one condition is true.

3.not – Reverses the result.

Example:

age = 20

print(age > 18 and age < 30)
print(age < 18 or age == 20)
print(not(age > 18))

Output:

True
True
False

D.Assignment Operators

Assignment operators are used to assign values to variables.

E.Membership Operators

Membership operators are used to check whether a value exists in a sequence.

1.in – Checks whether a value exists.

2.not in – Checks whether a value does not exist.

Example:

fruits = ["apple", "banana", "mango"]

print("apple" in fruits)
print("orange" not in fruits)

Output:

True
True

F.Identity Operators

Identity operators are used to check whether two variables refer to the same object.

1.is – Returns True if both refer to the same object.

2.is not – Returns True if they refer to different objects.

Example:

a = [1, 2, 3]
b = a

print(a is b)

Output:

True

G.Bitwise Operators

2.Functions in Python

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

Functions help us avoid writing the same code repeatedly and make programs easier to understand.

Python provides two main ways to work with functions:

Built-in functions
User-defined functions

A.Built-in Functions

Built-in functions are already available in Python. We can use them directly without defining them.

Some common built-in functions are:

B.User-Defined Functions

User-defined functions are functions created by programmers to perform specific tasks.

We use the def keyword to create a function.

Syntax:

def function_name():
# Statements

Example:

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

greet()

Output:

Hello, Welcome to Python!

Here:

def is used to define a function.
greet is the function name.
greet() is used to call the function.

3.Function Arguments in Python

Function arguments are values passed to a function when calling it. They allow us to send information to a function.

Let's understand the different types of function arguments.

A.Positional Arguments

In positional arguments, values are passed according to the order of parameters.

Example:

def student(name, age):
print("Name:", name)
print("Age:", age)

student("Gowtham", 20)

Output:

Name: Gowtham
Age: 20

Here, "Gowtham" is passed to name, and 20 is passed to age.

B.Keyword Arguments

In keyword arguments, we pass values using parameter names. The order does not matter.

Example:

def student(name, age):
print("Name:", name)
print("Age:", age)

student(age=20, name="Gowtham")

Output:

Name: Gowtham
Age: 20

C.Default Arguments

Default arguments have predefined values. If we don't pass a value, Python uses the default value.

Example:

def greet(name="Friend"):
print("Hello", name)

greet()
greet("Gowtham")

Output:

Hello Friend
Hello Gowtham

D.Variable-Length Arguments

Sometimes, we don't know how many arguments will be passed to a function. Python supports variable-length arguments.

1.*args

*args allows us to pass multiple positional arguments to a function.

def add(*numbers):
print(sum(numbers))

add(10, 20)
add(10, 20, 30, 40)

Output:

30
100

2.**kwargs

**kwargs allows us to pass multiple keyword arguments to a function. These arguments are stored as a dictionary.

def student(**details):
print(details)

student(name="Gowtham", age=20, city="Chennai")

Output:

{'name': 'Gowtham', 'age': 20, 'city': 'Chennai'}

Java - Constructor & Constructor Overloading

Gowtham — Sat, 31 Oct 2026 16:41:09 +0000

1.Constructor in Java:

A constructor is a special member of a class that is used to initialize objects.

A constructor is automatically called when an object is created using the new keyword.

Important Features of Constructors

The constructor name must be the same as the class name.
A constructor does not have a return type, not even void.
It is called automatically when an object is created.
Constructors can have parameters.
Constructors can be overloaded.

Example:

`class Student {

Student() {
    System.out.println("Constructor Called!");
}

public static void main(String[] args) {
    Student s1 = new Student();
}

Output:

Constructor Called!

Explanation:

Student is the class name.
Student() is the constructor.
new Student() creates an object.
The constructor is automatically executed when the object is created.

2.Types of Constructors in Java

Java constructors are commonly explained using two categories:

1.Default Constructor

If we do not write any constructor in a class, the Java compiler provides a default constructor.

It initializes instance variables with their default values.

Example:

`class Student {
int age;
String name;

public static void main(String[] args) {
    Student s1 = new Student();

    System.out.println(s1.age);
    System.out.println(s1.name);
}

Output:

0
null

Here, Java provides a default constructor because we did not define any constructor.

Note: If we write our own constructor, the compiler does not automatically provide a default constructor.

2.No-Argument Constructor

A no-argument constructor is a constructor written by the programmer that does not accept any parameters.

Example:

`class Student {

Student() {
    System.out.println("Welcome to Java!");
}

public static void main(String[] args) {
    Student s1 = new Student();
}

Output:

Welcome to Java!

Here, Student() is a programmer-defined no-argument constructor.

3.Parameterized Constructor

A parameterized constructor accepts arguments to initialize object values.

Example:

`class Student {
String name;
int age;

Student(String n, int a) {
    name = n;
    age = a;
}

void display() {
    System.out.println(name);
    System.out.println(age);
}

public static void main(String[] args) {
    Student s1 = new Student("Gowtham", 20);
    s1.display();
}

Output:

Gowtham
20

Explanation:

Student(String n, int a) is a parameterized constructor.
name = n assigns the name.
age = a assigns the age.
new Student("Gowtham", 20) creates an object and passes values to the constructor.

3.Constructor Overloading in Java:

Constructor overloading means creating multiple constructors in the same class with different parameter lists.

It allows us to initialize objects in different ways.

Example:

`class Student {

String name;
int age;

Student() {
    name = "Unknown";
    age = 0;
}

Student(String n) {
    name = n;
    age = 18;
}

Student(String n, int a) {
    name = n;
    age = a;
}

void display() {
    System.out.println(name + " " + age);
}

public static void main(String[] args) {

    Student s1 = new Student();
    Student s2 = new Student("Gowtham");
    Student s3 = new Student("Arun", 21);

    s1.display();
    s2.display();
    s3.display();
}

Output:

Unknown 0
Gowtham 18
Arun 21

Explanation:

In this example, we have created three constructors:
Student() – No-argument constructor.
Student(String n) – Constructor with one parameter.
Student(String n, int a) – Constructor with two parameters.
Java automatically selects the matching constructor based on the arguments passed when creating an object.

6.Advantages of Constructor Overloading

Flexibility: Create objects with different initial values.

Code reusability: Avoid repeating initialization logic.

Easy to use: Choose a constructor based on the available information.

Better organization: Keep object initialization inside the class.

Python - Variables, Reserved Words & Data Types

Gowtham — Thu, 29 Oct 2026 15:50:23 +0000

1.Variables in Python

A variable is a name used to store a value in a program. In Python, we don't need to declare the variable type explicitly. Python automatically identifies the type of value.

Example

`name = "Gowtham"
age = 20
price = 99.5

print(name)
print(age)
print(price)`

Output:

Gowtham
20
99.5

In this example:

name stores a string value.
age stores an integer value.
price stores a floating-point value.
Rules for Naming Variables
A variable name can contain letters, numbers, and underscores.
A variable name must not start with a number.
Variable names are case-sensitive.
Spaces are not allowed in variable names.
Reserved words cannot be used as variable names.
Valid variable names:
name = "Python"
age = 20
student_name = "Ravi"
Invalid variable names:
2name = "Ravi" # Starts with a number
student name = "Ravi" # Contains a space
class = 10 # Reserved word

2.Reserved Words in Python

Reserved words, also called keywords, are words that have special meanings in Python. They are used to define the structure and behavior of a program.

We cannot use these keywords as variable names or function names.

Common Python Keywords

3.Data Types in Python

A data type specifies the kind of value stored in a variable. Python provides several built-in data types.

1.Numeric Types

Integer (int) — Stores whole numbers.

age = 20 print(age)

Float (float) — Stores decimal numbers.

price = 99.5 print(price)

Complex (complex) — Stores complex numbers.

number = 2 + 3j print(number)

2.String (str)

A string stores text inside single or double quotation marks.

name = "Python" print(name)

Output:

Python

3.Boolean (bool)

A Boolean represents either True or False.

is_student = True print(is_student)

Output:

True

4.List (list)

A list stores multiple items in a single variable. Lists are ordered and mutable, meaning their contents can be changed.

fruits = ["apple", "banana", "mango"] print(fruits)

5.Tuple (tuple)

A tuple stores multiple items. Unlike lists, tuples cannot be changed after creation.

colors = ("red", "green", "blue") print(colors)

6.Set (set)

A set stores unique values and does not guarantee a fixed order.

numbers = {1, 2, 3, 3} print(numbers)

The duplicate value 3 is stored only once.

7.Dictionary (dict)

A dictionary stores information as key-value pairs.

`student = {
"name": "Ravi",
"age": 20
}

print(student["name"])`

Output:

Ravi

8.None Type (NoneType)

None represents the absence of a value.

result = None print(result)

Output:

None

Java - Methods & Method Overloading

Gowtham — Wed, 28 Oct 2026 17:55:36 +0000

1.Method in Java:

A method is a block of code that performs a specific task. We can call a method whenever we need to execute that task.

Methods help us avoid repeating the same code multiple times.

Example:

`public class Main {

static void greet() {
    System.out.println("Hello, Welcome to Java!");
}

public static void main(String[] args) {
    greet();
}

Output:

Hello, Welcome to Java!

Explanation

static allows us to call the method using the class without creating an object.
void means the method does not return a value.
greet() is the method name.
System.out.println() displays the message.
greet(); calls the method.

2.Types of Methods in Java

Methods can be categorized in different ways. Two common types are:

1.Predefined Methods

Predefined methods are already provided by Java's libraries.

Example:

`public class Main {
public static void main(String[] args) {
System.out.println("Hello Java!");

    int result = Math.max(10, 20);
    System.out.println(result);
}

Output:

Hello Java!
20

Here, println() and Math.max() are predefined methods.

2.User-Defined Methods

User-defined methods are created by programmers to perform specific tasks.

Example:

`public class Main {

static void add() {
    int a = 10;
    int b = 20;

    System.out.println(a + b);
}

public static void main(String[] args) {
    add();
}

Output:

Here, add() is a user-defined method.

3.Methods with Parameters and Return Values:

A method can accept parameters and return a result.

Example:

`public class Main {

static int add(int a, int b) {
    return a + b;
}

public static void main(String[] args) {
    int result = add(10, 20);
    System.out.println(result);
}

Output:

Explanation

int a and int b are parameters.
return a + b; returns the sum.
add(10, 20) calls the method with two arguments.
The returned result is stored in the result variable.

4.Method Overloading in Java:

Method overloading means creating multiple methods with the same name but different parameter lists within the same class.

The methods can have different numbers of parameters or different parameter types.

Method overloading makes code easier to understand because related operations can share the same method name.

Example 1: Different Number of Parameters

`public class Main {

static int add(int a, int b) {
    return a + b;
}

static int add(int a, int b, int c) {
    return a + b + c;
}

public static void main(String[] args) {
    System.out.println(add(10, 20));
    System.out.println(add(10, 20, 30));
}

Output:

30
60

Here, both methods have the name add, but one accepts two parameters and the other accepts three.

Java selects the appropriate method based on the arguments supplied.

Example 2: Different Parameter Types

`public class Main {

static int display(int a) {
    return a;
}

static double display(double a) {
    return a;
}

public static void main(String[] args) {
    System.out.println(display(10));
    System.out.println(display(10.5));
}

Output:

10
10.5

The first method accepts an int, while the second accepts a double.

Important: Changing only the return type is not enough to overload a method. The parameter list must be different.

5.Advantages of Methods and Method Overloading:

Code reusability: Write code once and call it multiple times.
Readability: Give meaningful names to operations.
Less duplication: Avoid writing similar code repeatedly.
Flexibility: Method overloading supports different input types and numbers of arguments.
Easy maintenance: Organize programs into smaller, manageable parts.

Python - Introduction

Gowtham — Tue, 27 Oct 2026 07:05:28 +0000

What Is Python?

Python is a popular, high-level programming language known for its simple syntax and readability. It was created by Guido van Rossum and first released in 1991.

Python is easy to learn, making it a great choice for beginners who want to start their programming journey.

Python is used in web development, data science, artificial intelligence, machine learning, automation, and many other fields.

Why Should We Learn Python?

There are several reasons to learn Python:

Easy to Learn: Python has simple and readable syntax.
Beginner-Friendly: You can write programs with fewer lines of code.
Versatile: Python can be used for many different types of applications.
Large Community: Many developers share tutorials, libraries, and solutions.
Open Source: Python is free to use.

First Python Program

Let's write our first Python program!

print("Hello, World!")

Output:

Hello, World!

The print() function displays text or other values on the screen.

Basic Features of Python

Python provides several useful features:

1. Simple Syntax

Python code is easy to read and understand.

name = "Gowtham" print(name)

Output:

Gowtham

2. Variables

Variables are used to store data.

`name = "Python"
age = 35

print(name)
print(age)`

3. Data Types

Python supports different types of data, including:

int — Integer numbers, such as 10
float — Decimal numbers, such as 10.5
str — Text, such as "Hello"
bool — Boolean values, such as True and False
list — A collection of items, such as [1, 2, 3]
dict — Data stored as key-value pairs, such as {"name": "Gowtham"}

4. Cross-Platform

Python works on different operating systems, including Windows, Linux, and macOS.

Where Is Python Used?

Python is widely used in different areas of technology:
Web Development: Building websites and web applications.
Data Science: Analyzing and understanding data.
Artificial Intelligence: Developing intelligent applications.
Machine Learning: Building systems that learn from data.
Automation: Automating repetitive tasks.
Game Development: Creating simple games and game tools.

Java - Variables & Objects

Gowtham — Sun, 25 Oct 2026 16:24:22 +0000

Variable in Java:

A variable is a named storage location used to hold a value of a particular data type.

For example:

int age = 20;
String name = "Gowtham";

Here:

int is the data type.
age is the variable name.
20 is the value stored in the variable.
String is the type used to represent text.
name is the variable name.
"Gowtham" is the text value.

Types of Variables in Java

Java has three main categories of variables based on where they are declared.

1. Local Variable

A local variable is declared inside a method, constructor, or block.

void display() {
int age = 20;
System.out.println(age);
}

2. Instance Variable

An instance variable is declared inside a class but outside methods. Each object has its own instance fields.

class Student {
String name = "Gowtham";
int age = 20;
}

3. Static Variable

A static variable belongs to the class rather than to individual objects.

class Student {
static String college = "ABC College";
}

The static variable college is shared at the class level.

Object in Java?

An object is an instance of a class.

A class defines the data and behaviors that its objects can have.

For example, Student can be a class, while individual students can be represented by objects of that class.

Example

`class Student {
String name;
int age;

void display() {
    System.out.println(name);
    System.out.println(age);
}

}

public class Main {
public static void main(String[] args) {
Student s1 = new Student();

    s1.name = "Gowtham";
    s1.age = 20;

    s1.display();
}

Output:

Gowtham
20

Explanation

Student is the class.
s1 is a reference variable.
new Student() creates a new Student object.
s1.name assigns a name to the object.
s1.age assigns an age to the object.
s1.display() calls the object's method.

Java - OOP, Class & Data Types

Gowtham — Fri, 23 Oct 2026 17:26:12 +0000

1.OOP in Java:

OOP stands for Object-Oriented Programming.

It is a programming approach based on classes and objects. It helps us organize code, reuse functionality, and manage complex programs.

Java supports four main OOP principles:

Encapsulation: Combining data and methods in a class and controlling access to the data.

Inheritance: Creating a new class based on an existing class.

Polymorphism: Allowing the same interface or method name to have different behaviors.

Abstraction: Hiding implementation details and exposing essential functionality.

2.Class in Java:

A class is a blueprint for creating objects.

It defines the data and behaviors that its objects can have.

Example

`class Student {
String name = "Gowtham";
int age = 20;

void display() {
    System.out.println(name);
    System.out.println(age);
}

}

`In this example:

Student is the class name.
name and age are instance variables.
display() is a method.

We can create an object of the class and call its method:

public class Main { public static void main(String[] args) { Student s1 = new Student(); s1.display(); } }

Output:

Gowtham
20

Here, s1 refers to the Student object.

3.Data Types in Java:

Java - Introduction

Gowtham — Thu, 22 Oct 2026 17:22:34 +0000

Introduction

Java is one of the most popular programming languages in the world. It is a high-level, object-oriented programming language used to develop different types of applications.

Java was developed by James Gosling and his team at Sun Microsystems. It was officially released in 1995. Today, Java is maintained by Oracle.

Java is widely used in web development, enterprise applications, backend development, and many other areas of software development.

If you are a beginner who wants to learn programming, Java is a good language to start with.

What Is Java?

Java is a general-purpose programming language designed to help developers build reliable, secure, and portable applications.

One of Java's most important features is:

"Write Once, Run Anywhere."

This means that Java programs can run on different operating systems, such as Windows, Linux, and macOS, provided a compatible Java Virtual Machine (JVM) is available.

Why Should We Learn Java?

There are several reasons to learn Java:

Easy to Learn

Java has a structured syntax that helps beginners understand programming concepts step by step.

Platform Independent

Java code is compiled into bytecode, which can run on any compatible JVM.

Object-Oriented Programming

Java supports object-oriented programming concepts such as classes, objects, inheritance, polymorphism, and encapsulation.

Secure

Java provides language and platform features that help developers build secure applications.

Multithreading

Java supports multithreading, allowing applications to perform multiple tasks concurrently.

Large Community

Java has a large developer community, so beginners can find tutorials, documentation, and solutions to common problems.

Features of Java

Some important features of Java include:
Simple and readable syntax
Object-oriented programming
Platform independence
Portability
Security features
Multithreading support
Automatic memory management
Robust exception handling

These features make Java useful for developing applications of different sizes.

Where Is Java Used?

Java is used in many areas of software development.

Web Development: Building server-side applications.

Enterprise Applications: Developing large business systems.

Android Development: Java is used in Android applications, alongside other supported languages.

Banking Systems: Developing financial and transaction-processing applications.

Desktop Applications: Creating applications with graphical user interfaces.

Cloud Applications: Building backend services and distributed systems.

First Java Program

Let's write our first Java program.

public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }

Output

Hello, World!

Explanation

public class HelloWorld: Declares a class named HelloWorld.

public static void main(String[] args): Defines the main method, which is the entry point when the program is launched using the standard Java launcher.

System.out.println(): Prints text to the console.

"Hello, World!": The message displayed on the screen.

This simple program is the first step toward understanding Java programming.

What Is JVM, JRE, and JDK?

JVM (Java Virtual Machine)
The JVM executes Java bytecode.
JRE (Java Runtime Environment)
The JRE traditionally refers to the components needed to run Java applications, including the JVM and supporting libraries.
JDK (Java Development Kit)
The JDK provides the tools needed to develop Java applications, including the Java compiler and runtime components.

In modern Java development, installing a JDK is the standard way to get started.