DEV Community: sridhar n

Python Day 8 – Pure vs Impure Functions, Local vs Global

sridhar n — Sat, 14 Nov 2026 02:23:22 +0000

Today we looked at pure and impure functions, and at where variables actually live.

Pure function

def spend_for_shopping(amount):
    total = 10000
    total = total - amount
    return total

print(spend_for_shopping(1200))   # 8800, every single time

A pure function:

Always gives the same output for the same input
Doesn't change anything outside itself

Impure function

total = 10000

def eat_outside(amount):
    return total - amount

total = eat_outside(300)
print(total)   # 9700
total = eat_outside(300)
print(total)   # 9400

Same input (300), different output each time, because the function depends on total, which lives outside it and keeps changing.

Another thing I didn't expect: printing counts as a side effect too.

def display(no):
    print(no + 10)

It changes the outside world (your screen), so technically it's impure. Same goes for anything that uses the current time:

from datetime import datetime

def display_time():
    print("Current Time =", datetime.now().strftime("%H:%M:%S"))

Call it twice and you get two different outputs.

Local vs global variables

Local: declared inside a function (parameters count too). It only exists inside that function.

def eat(amount):
    total = 500         # local
    return total - amount

Global: declared outside any function. Every function can read it.

total = 100000          # global
def eat(amount):
    return total - amount

Try this:

total = 100
def check(no1):
    print(total - no1)

check(10)      # 90
print(total)   # 100
print(no1)     # NameError: no1 is local to check()

The `global` keyword

If you want to modify a global variable inside a function, you need global:

total = 100
def spend(amount):
    global total
    total = total - amount

spend(30)
print(total)   # 70

Without global, Python assumes you're creating a new local variable.

Python Day 7 – The / and * in Function Definitions

sridhar n — Sat, 14 Nov 2026 02:12:47 +0000

First, positional vs keyword arguments

Positional arguments are matched by their position (order).

def intro(name, age):
    print(name, "is", age, "years old")

intro("Sridhar", 26)   # Sridhar is 26 years old
intro(26, "Sridhar")   # 26 is Sridhar years old

The first value goes to name and the second goes to age. Swap the order and you get the wrong result.

Keyword arguments are matched by their name, so the order doesn't matter.

intro(name="Sridhar", age=26)   # Sridhar is 26 years old
intro(age=26, name="Sridhar")   # Sridhar is 26 years old

You can mix the two, but positional ones must come first:

intro("Sridhar", age=26)    # works
intro(name="Sridhar", 26)   # SyntaxError: positional argument follows keyword argument

Normally Python lets you pass an argument either way. The / and * symbols let you force one style.

`/` → positional-only arguments

def calculate(a, b, /):
    print(a + b)

calculate(10, 20)        # works, prints 30
calculate(a=10, b=20)    # TypeError

Anything before / has to be passed by position. You can't use the name.

`*` → keyword-only arguments

def calculate(a, *, b):
    print(a + b)

calculate(a=10, b=20)    # works
calculate(10, b=20)      # works
calculate(10, 20)        # TypeError

Anything after * has to be passed by name.

Quick way to remember it:

/ → "everything before me is positional only"
* → "everything after me is keyword only"

Functions can return things

def play():
    teamA = 300
    teamB = 290
    if teamA > teamB:
        return "Winner Trophy"
    else:
        return "Runner Trophy"

hand = play()
print(hand)   # Winner Trophy

return hands a value back to whoever called the function.

The career part

What I took away from it:

AI tools (Claude, Copilot, etc.) are making some jobs easier, but companies still want people who understand code, not just people who can generate it.
Interviews still test flow charts, pseudocode and algorithms. Logic matters more than syntax.
Build proof of your interest. Write blogs (that's why I'm on dev.to), go to tech meetups, talk to technical people.
Learn the fundamentals properly (Python, Java, databases). That's what lasts.

So here I am, blogging.

Python Day 5 – Functions, Explained With Cricket

sridhar n — Sat, 14 Nov 2026 02:09:34 +0000

What is a function?

Think about "playing cricket". It's actually a bunch of steps:

Invite friends
Take the bat and ball
Go to the ground
Toss
Bat or field

One name, many steps inside. That's a function:

A set of instructions (a block of code) that does a specific task, and has a name.

How to create one

You use the def keyword (short for definition).

def welcome():
    print("Welcome To Python3")

welcome()
welcome()
welcome()

Write it once, call it as many times as you want.

Python uses indentation instead of { } to mark what's inside the function. Get the spacing wrong and you'll get an error.

Things I noted

You can have many functions in the same file
If two functions have the same name, the latest definition wins
You have to define a function before you call it
You only call the ones you need

def add():
    print(5 + 10)

def subtract():
    print(10 - 5)

add()   # only this runs

Why use functions?

Reuse the same code
Easier to maintain
More readable
Modular, better organised
Easier to test and debug

Parameters and arguments

def add(no1, no2):      # no1, no2 are parameters
    print(no1 + no2)

add(100, 200)           # 100, 200 are arguments

Function overloading?

In Java you can have add(a, b) and add(a, b, c) side by side. In Python, the second definition just replaces the first, so plain overloading doesn't work.

Built-ins like print() and bin() are functions too, just predefined ones.

Python Day 4 – Bitwise, Shift and Ternary Operators

sridhar n — Sat, 14 Nov 2026 02:06:09 +0000

Today we finished operators and got a quick look at the full list of Python datatypes.

Datatypes in Python

int, float, complex, bool, str, bytes, bytearray, range, list, tuple, set, frozenset, dict.

Side note: Python ints have no size limit. You can store something like 675765345617234516823719832618361836128736817368173618273187 without any problem.

Bitwise operators

print(4 & 5)  # 4
print(4 | 5)  # 5
print(4 ^ 5)  # 1

XOR (^) gives True only when the two bits are different:

a	b	a ^ b
T	T	F
T	F	T
F	T	T
F	F	F

The `~` (tilde) mystery

print(~4)   # -5
print(~0)   # -1
print(~-1)  # 0

Why -5? Because negative numbers are stored in 2's complement form. The leftmost bit (MSB) is the sign: 0 means positive, 1 means negative.

How to get -5 from 5:

5 in binary → 00000101
Flip every bit → 11111010
Add 1 → 11111011 ← that's -5

A shortcut to remember: ~n = -(n+1)

Shift operators

print(4 >> 1)  # 2
print(4 << 1)  # 8
print(4 << 2)  # 16
print(4 << 3)  # 32

Shifting left by 1 doubles the number. Shifting right by 1 halves it.

Ternary (conditional) operator

A one-line if/else:

no1, no2 = 10, 20
result = 100 if no1 > no2 else 200
print(result)   # 200

You can even nest them to find the biggest of three numbers. It works, but it's hard to read:

no1, no2, no3 = 1000, 200, 30
bigger = no3 if no3 > no2 and no3 > no1 else no2 if no2 > no1 else no1
print(bigger)   # 1000

Special operators

is, is not → identity
in, not in → membership

Python Day 3 – Operators (and a Few Surprises)

sridhar n — Sat, 14 Nov 2026 02:03:37 +0000

Day 3 was all about operators. Some of the results caught me off guard.

Arithmetic operators

no1, no2 = 10, 3
print(no1 + no2)   # 13
print(no1 - no2)   # 7
print(no1 * no2)   # 30
print(no1 / no2)   # 3.3333333333333335
print(no1 // no2)  # 3   (floor division)
print(no1 % no2)   # 1   (remainder)
print(no1 ** no2)  # 1000 (power)

Fun one: you can multiply a string.

name = "sridhar"
print(name * 3)   # sridhar sridhar sridhar

And dividing by zero gives a ZeroDivisionError, for both / and //.

Relational (comparison) operators

>, <, >=, <=, ==, !=

Strings are compared in dictionary order:

print('ajith' < 'ajithkumar')   # True

Booleans are numbers underneath: True is 1, False is 0.

print(False < True)   # True

Operator chaining was new to me:

no1, no2, no3 = 100, 200, 300
print(no3 > no2 > no1)   # True
print(no3 > no2 < no1)   # False (200 < 100 is false)

Logical operators: `and`, `or`, `not`

This one surprised me. and doesn't always return True or False:

print(10 and 20)       # 20
print(not 'Vishnu')    # False
print(not '')          # True

A non-empty string counts as True and an empty string counts as False.

Assignment shortcuts

no1 = 5
no1 += 10   # same as no1 = no1 + 10
no1 -= 10
no1 *= 10
no1 **= 2

Bitwise (just a teaser)

print(4 & 5)  # 4
print(4 | 5)  # 5

Bits = binary digits.

Python Day 2 – Identifiers, Keywords and a First Look at Datatypes

sridhar n — Sat, 14 Nov 2026 01:58:29 +0000

Day 2 was about naming things, the words Python keeps for itself, and what kind of data we can store.

Identifiers (aka variables)

A name in a Python program is called an identifier or variables.

name = 'sanjay'
doubt = True
questions = 5

Rules:

Letters (upper or lower case) are allowed
Digits are allowed, but not at the start (1name is invalid)
Underscore _ is allowed

Underscores also carry a meaning by convention:

_name → treat it as private
__name → strongly private
__name__ → special, reserved for Python's own use

Python doesn't actually enforce private like Java does. It just trusts you. That ties into the Zen of Python (try import this). My favourite line: "If the implementation is hard to explain, it's a bad idea."

Zen of Python

And = is the assignment operator. It takes the value on the right and gives it to the name on the left.

Reserved words (keywords)

Some words already mean something to Python, so you can't use them as variable names. You can list them like this:

import keyword
print(keyword.kwlist)
print(len(keyword.kwlist))

You'll see things like if, else, while, for, def, return, True, False, None.

IDE or not?

Our trainer said beginners should skip heavy IDEs like PyCharm for now and just use IDLE or a simple editor. On servers you usually won't have an IDE anyway. Fair point.

Datatypes

Everything a computer stores is binary in the end. Even the letter 'a' is a number underneath:

bin()

print(ord('a'))       # 97
print(bin(ord('a')))  # 0b1100001

The basic types:

int: -3, 0, 42
float: 0.2, -1.5
complex: 3+4j
str: text
bool: True / False

Python Day 1 – Why Python, and What Even Is It?

sridhar n — Sat, 14 Nov 2026 01:48:01 +0000

So I started a Python course, and I'm going to write down what I learn each day here. Mostly for me, but maybe it helps someone else too.

What is Python?

Python is a general purpose, high level programming language. "High level" just means it's easy for humans to read. Compare this:

no1 = 10
no2 = 20
print(no1 + no2)

with assembly, which is much closer to what the machine understands:

MOV AL, 10
MOV BL, 15
ADD AL, BL

Yeah. I'll take Python.

Where is Python used?

Pretty much everywhere:

Data Science, ML, AI (handles huge data well)
Web apps (Django, Flask)
Desktop apps, scripting, automation
Games, IoT, network programming

A bit of history

Python came out in 1991 (Java in 1995)
Python 2 in 2000, Python 3 in December 2008
Python 3 isn't fully backward compatible with Python 2, which is why everyone just uses Python 3 now

Compiled vs Interpreted

Compilation = translate the whole program at once
Interpretation = translate line by line

Python is an interpreted language. There are also different implementations: CPython (the normal one, written in C), Jython (Java), IronPython (.NET), PyPy.

Pros and cons we discussed

Good: simple, open source, interpreted, extensible, high level, platform independent, dynamically typed.

Not so good: slower than C/C++/Java, uses more memory, type errors show up only at runtime, and it's not really used for mobile apps.

Small fun thing to try:

import sys
print(sys.copyright)

That's Day 1.