DEV Community: bhavesh jadhav

Building a Simple ATM System in Python: A Casual Walkthrough

bhavesh jadhav — Sun, 02 Jun 2024 20:43:13 +0000

Hey everyone,

So, I wanted to share with you all how I put together this simple ATM system in Python. It's nothing fancy, but it gets the job done!

First off, I set up a couple of dictionaries to keep track of card numbers, PINs, and account balances. It looks something like this:

import time

# Dictionary to store card numbers and corresponding PINs
cardsWithPin = {123456789: 123, 987654321: 345, 234567890: 567, 345678901: 789}

# Dictionary to store card numbers and corresponding account balances
cardsWithAmt = {123456789: 50000, 987654321: 5000, 234567890: 7890, 345678901: 100000}

Then, I created functions for different operations like checking balance, withdrawing money, and depositing money. Here's a snippet of that:

# Function to check account balance
def checkBalance(cardNo):
    print(f"Current Balance: Rs.{cardsWithAmt.get(cardNo)}/-")
    time.sleep(0.6)

# Function to withdraw money
def withdraw(cardNo):
    print(f"Initial Balance:Rs.{cardsWithAmt.get(cardNo)}/-")
    try: 
        withdrawAmt=int(input("Enter amount you want to withdraw: "))
        if(cardsWithAmt[cardNo]>=withdrawAmt):
            cardsWithAmt[cardNo]=cardsWithAmt.get(cardNo, 0)-withdrawAmt
            time.sleep(0.6)
            print(f"RS. {withdrawAmt}/- Withdraw Successfully...")
            print(f"Remaining Amount: Rs.{cardsWithAmt[cardNo]}/-")
            time.sleep(0.6)
        else:
            time.sleep(1)
            print("Insufficient Balance...")
            time.sleep(0.6)
    except ValueError:
        print("Please Enter Integer Value...")

# Function to deposit money
def deposit(cardNo):
    print(f"Initial Balance:Rs.{cardsWithAmt.get(cardNo)}/-")
    try:
        dipositAmt=int(input("Enter amount you want to deposit:"))
        time.sleep(0.6)
        cardsWithAmt[cardNo] = cardsWithAmt.get(cardNo,0)+ dipositAmt
        print(f"Rs.{dipositAmt}/-are deposited successfully...")
        print(f"Current Balance:Rs.{cardsWithAmt.get(cardNo)}/-")
        time.sleep(0.6)
    except ValueError:
        print("Please Enter Integer Value...")

# Main ATM system function
def atmSystem():
    # Some code here...

The atmSystem function is where the magic happens. It handles the whole ATM experience, from logging in to performing transactions and quitting the system.

def atmSystem():
    print("======================WELCOME==========================")
    # Some code here...

And that's pretty much it! It's a straightforward program that does what it's supposed to do. Of course, there's always room for improvement, but for now, I'm happy with how it turned out.

Feel free to take a look at the full code and play around with it. If you have any suggestions for improvements or cool features to add, I'm all ears!

Catch you later!

And here's the complete code:

import time
cardsWithPin={123456789:123,987654321:345,234567890:567,345678901:789}
cardsWithAmt={123456789:50000,987654321:5000,234567890:7890,345678901:100000}

def checkBalance(cardNo):
    print(f"Current Balance: Rs.{cardsWithAmt.get(cardNo)}/-")
    time.sleep(0.6)

def withdraw(cardNo):
    print(f"Initial Balance:Rs.{cardsWithAmt.get(cardNo)}/-")
    try: 
        withdrawAmt=int(input("Enter amount you want to withdraw: "))
        if(cardsWithAmt[cardNo]>=withdrawAmt):
            cardsWithAmt[cardNo]=cardsWithAmt.get(cardNo, 0)-withdrawAmt
            time.sleep(0.6)
            print(f"RS. {withdrawAmt}/- Withdraw Successfully...")
            print(f"Remaining Amount: Rs.{cardsWithAmt[cardNo]}/-")
            time.sleep(0.6)
        else:
            time.sleep(1)
            print("Insufficient Balance...")
            time.sleep(0.6)
    except ValueError:
        print("Please Enter Integer Value...")



def deposit(cardNo):
    print(f"Initial Balance:Rs.{cardsWithAmt.get(cardNo)}/-")
    try:
        dipositAmt=int(input("Enter amount you want to deposit:"))
        time.sleep(0.6)
        cardsWithAmt[cardNo] = cardsWithAmt.get(cardNo,0)+ dipositAmt
        print(f"Rs.{dipositAmt}/-are deposited successfully...")
        print(f"Current Balance:Rs.{cardsWithAmt.get(cardNo)}/-")
        time.sleep(0.6)
    except ValueError:
        print("Please Enter Integer Value...")

def atmSystem():
    print("======================WELLCOME==========================")
    try:
        cardNo=int(input("Enter your card number:"))
        if cardNo not in cardsWithPin:
            print("Invalid card no...")
            return
        pin=int(input("Enter pin: "))
        if cardsWithPin.get(cardNo)!=pin:
            print("Invalid pin...")
            return
    except ValueError:
        print("Card Number and Pin should always INTEGER")
        return
    time.sleep(0.5)
    print("Login Successfull...")
    time.sleep(0.4)

    while True: 
        print("""Please select any option:
            1).Deposit
            2).Withdraw
            3).Check Balance
            4).Quit
                """)
        operation=int(input("Select option: "))
        match(operation):
            case 1:
                print("You selected Money Deposit...")
                deposit(cardNo)
            case 2:
                print("You selected Withdraw...")
                withdraw(cardNo)
            case 3:
                print("You selected Check Balance...")
                checkBalance(cardNo)
            case 4:
                time.sleep(0.3)
                print("Thank you for using the ATM. Goodbye!")
                return
            case _: 
                print("Invalid option")
                time.sleep(0.6)

atmSystem()

Feel free to copy and paste it into your Python environment and give it a try! Let me know if you have any questions or suggestions.

Important Terminologies in JavaScript

bhavesh jadhav — Fri, 31 May 2024 20:59:52 +0000

1. Function Statement

A function statement is a simple way of creating a function:

function a() {
  console.log("a called");
}

This simple way of creating a function is known as a function statement.

2. Function Expression

A function expression is when a function acts like a value of a variable:

var b = function() {
  console.log("b called");
};

3. Difference Between Function Statement and Function Expression

The major difference between these two is hoisting:

a(); // Output: "a called"
b(); // Output: TypeError

function a() {
  console.log("a called");
}

var b = function() {
  console.log("b called");
};

In this code, during the hoisting phase (the memory allocation phase), a is assigned its function definition. But in the case of a function expression, b is treated like any other variable and is assigned undefined initially. Until the code hits b = function(), b remains undefined. Therefore, calling b() before its definition results in an error. This is the major difference between a function statement and a function expression.

4. Function Declaration

A function declaration is nothing but a function statement. Function declaration and function statement are the same things:

function a() {
  console.log("a called");
}

5. Anonymous Function

An anonymous function is a function without a name:

function() {
  // Code
}

Anonymous functions do not have their own identity. Creating an anonymous function like this will give you a syntax error:

function() {
  // Code
}

Because an anonymous function looks like a function statement but has no name, according to the ECMAScript specification, functions should always have a name. Therefore, function () {} is invalid syntax. Anonymous functions are used where functions are used as values:

var b = function() {
  console.log("b called");
};

6. Named Function Expression

A named function expression is like a function expression but with a name:

var b = function xyz() {
  console.log("b called");
};

If you call b(), it works, but calling xyz() will give an error. xyz is not defined in the outer scope; it is only available inside the function itself:

var b = function xyz() {
  console.log(xyz);
};

b(); // Prints the function definition
xyz(); // ReferenceError: xyz is not defined

7. Difference Between Parameters and Arguments

Parameters are the names listed in the function definition, while arguments are the values passed to the function when it is invoked:

function a(param1, param2) {
  console.log("hello");
}

a(1, 2); // 1 and 2 are the arguments

8. First-Class Function:

The ability to use a function as a value is known as a first-class function. The ability of a function to be used as a value and passed as an argument to another function, or returned from a function, is known as a first-class function. This ability is known as a first-class function. For example:

var b = function(x) {
  console.log(x);
};

b(function() {
  console.log("Anonymous function");
});

function xyz() {
  console.log("Named function");
}

b(xyz);

var c = function() {
  return function() {
    console.log("Returned anonymous function");
  };
};

console.log(c()());

First-class functions allow us to treat functions like any other value, also referred to as "first-line citizens."

9. Callback Functions

Callback functions are first-class citizens in JavaScript. This means you can take a function and pass it into another function, and when you do so, the function you pass into another function is known as a callback function. Callback functions are very powerful in JavaScript. They give us access to the asynchronous world in a synchronous single-threaded language. Due to callbacks, we can do asynchronous things in JavaScript:

function x(callback) {
  console.log("x");
  callback();
}

x(function y() {
  console.log("y");
});

If you call a function and pass a function into another function, the passed function is the callback function. This function is known as a callback function because it is called back later in the code. You give the responsibility of this function to another function. For example:

setTimeout(function() {
  console.log("timer");
}, 5000);

function x(y) {
  console.log("x");
  y();
}

x(function y() {
  console.log("y");
});

JavaScript has just one call stack, also known as the main thread. Everything executed inside your page is executed through the call stack only. If any operation blocks the call stack, it is known as blocking the main thread. For example, if your function x() had a very heavy operation that takes around 20 to 30 seconds to complete, by that time, because JavaScript has only one call stack, it won't be able to execute any other function inside the code. That means everything will be blocked on the code. This is why we should never block our main thread. We should always try to use asynchronous operations for tasks that take time, just like using setTimeout:

setTimeout(function() {
  console.log("timer");
}, 5000);

function x(y) {
  console.log("x");
  y();
}

x(function y() {
  console.log("y");
});

Using web APIs, setTimeout, and callback functions, we can achieve asynchronous operations in JavaScript..

We know how to use these concepts practically, but we often don't know the terminologies. If an interviewer asks what a function expression is, we might get stuck because we don't know the term. A function expression is when a function acts like a value of a variable:

var b = function() {
  console.log("b called");
};

However, we use this type of syntax many times in JavaScript coding without knowing what it's called.

Understanding Closures in JavaScript

bhavesh jadhav — Wed, 29 May 2024 19:37:10 +0000

Closures in JavaScript can seem like a complex concept, but they are fundamental to understanding how the language works. In essence, a closure is a function bundled together with its lexical environment. This means that a function, along with the variables it was declared with, forms a closure. This bundled structure allows the function to access those variables even after it has been executed outside its original scope.

Uses of Closures

Closures are incredibly powerful and versatile, and they have several practical applications in JavaScript:

Module Design Pattern: Encapsulating private data.
Currying: Creating functions with preset arguments.
Functions like Once: Ensuring a function is called only once.
Memoization: Caching results of expensive function calls.
Maintaining State in Async World: Managing state across asynchronous operations.
SetTimeouts: Delaying execution of code.
Iterators: Generating sequences of values.

Example: `setTimeout` and Closures

Consider the following example to understand how setTimeout interacts with closures:

function x() {
    var i = 1;
    setTimeout(function() {
        console.log(i);
    }, 3000);
    console.log("Namaste JavaScript");
}
x();

In this example, many might think that JavaScript’s setTimeout will wait before executing the callback function. However, JavaScript does not wait. It prints "Namaste JavaScript" first, then waits for 3000 milliseconds before printing the value of i. The callback function forms a closure, remembering the reference to i, and after the timer expires, it logs the value of i.

Common Pitfall

Let’s examine a common mistake when using setTimeout inside a loop:

function x() {
    for (var i = 1; i <= 5; i++) {
        setTimeout(function() {
            console.log(i);
        }, i * 1000);
    }
    console.log("Namaste JavaScript");
}
x();

You might expect this code to print "Namaste JavaScript" followed by 1, 2, 3, 4, 5, each after a second. However, the output is "Namaste JavaScript" followed by 6 five times. Why does this happen?

Explanation:

Due to closure, all setTimeout callbacks remember the reference to i, not its value. By the time the timers expire, the loop has completed, and i equals 6. All callbacks then log the final value of i.

Fixing the Issue

To fix this issue, use let instead of var:

function x() {
    for (let i = 1; i <= 5; i++) {
        setTimeout(function() {
            console.log(i);
        }, i * 1000);
    }
    console.log("Namaste JavaScript");
}
x();

Here, let creates a new block-scoped variable i for each iteration, resulting in the desired output: "Namaste JavaScript", then 1, 2, 3, 4, 5 each after a second.

Achieving the Same Without `let`

If you must use var, you can create a new scope using a function:

function x() {
    for (var i = 1; i <= 5; i++) {
        (function(i) {
            setTimeout(function() {
                console.log(i);
            }, i * 1000);
        })(i);
    }
    console.log("Namaste JavaScript");
}
x();

In this version, the immediately invoked function expression (IIFE) creates a new scope, capturing the value of i for each iteration. This ensures each setTimeout callback logs the correct value.

Conclusion

Closures are a powerful feature in JavaScript that allow functions to remember their lexical environment. Understanding closures and how they work with asynchronous code, such as setTimeout, is crucial for mastering JavaScript. By leveraging closures, you can write more robust and maintainable code.

By understanding and using closures effectively, you can tackle complex programming challenges in JavaScript with confidence and ease. Happy coding!

Understanding JavaScript Blocks and Scope

bhavesh jadhav — Tue, 28 May 2024 20:29:32 +0000

Blocked in JavaScript

A block, or compound statement, in JavaScript is defined by the curly braces {}. It is used to group multiple statements together. For example:

{
    let a = 10;
    console.log(a);
}

Why Do We Need to Group Statements?

We group multiple statements together in a block so that we can use them where JavaScript expects a single statement. For example:

if (true) console.log("Hello");

This is valid JavaScript syntax, as JavaScript expects a single statement after the if condition. But if we need to execute multiple statements when the if condition is true, we use a block:

if (true) {
    var a = 10;
    console.log(a);
}

Block Scope

Block scope refers to the variables and functions that we can access inside the block. For example:

{
    var a = 10;
    let b = 20;
    const c = 30;
}
console.log(a); // Accessible
console.log(b); // Not accessible
console.log(c); // Not accessible

Here, var a is accessible outside the block because var has a global or function scope. However, let and const are not accessible outside the block because they have block scope.

What is Shadowing in JavaScript?

Shadowing occurs when a variable declared within a certain scope (e.g., inside a block) has the same name as a variable declared in an outer scope. The inner variable shadows the outer variable:

var a = 100;
{
    var a = 10; // This shadows the variable outside the block
    let b = 20;
    const c = 30;
    console.log(a); // Prints 10
}
console.log(a); // Prints 10, the value is modified by the inner var

In the case of let and const, shadowing behaves differently because they have block scope:

let b = 100;
{
    var a = 10;
    let b = 20; // This shadows the outer let variable
    const c = 30;
    console.log(b); // Prints 20
}
console.log(b); // Prints 100, because let has block scope

Illegal Shadowing

Illegal shadowing occurs when a let variable is shadowed by a var variable inside the same block:

let a = 20;
{
    var a = 20; // Illegal shadowing, causes an error
}

However, the reverse is allowed:

var a = 20;
{
    let a = 30; // This is allowed
}

Reason for Reverse Allowance

The reason the reverse is allowed (var outside and let inside) is due to the scoping rules of JavaScript. var has function or global scope, meaning it can be accessed throughout the entire function or globally. let and const, however, have block scope, meaning they are only accessible within the block they are defined in. Therefore, defining a let or const inside a block does not interfere with the var outside the block, allowing the code to be valid.

Shadowing in Function Scope

Shadowing also applies to function scopes. However, since var has function scope, it behaves differently:

let a = 20;
function x() {
    var a = 20; // This is allowed
}

In this case, the var declaration inside the function does not affect the let variable outside the function.

Conclusion

Understanding blocks, block scope, and variable shadowing is crucial for writing efficient and bug-free JavaScript code. Properly managing scope and avoiding illegal shadowing can help prevent unexpected behaviors and maintain code clarity.

Understanding the Scope Chain, Scope, and Lexical Environment in JavaScript

bhavesh jadhav — Tue, 28 May 2024 20:26:24 +0000

JavaScript's handling of variables and functions can be intricate, but grasping the concepts of scope, the scope chain, and the lexical environment is essential for writing efficient and bug-free code. In this blog post, we'll explore these fundamental concepts in detail.

What is Scope?

Scope defines where you can access a specific variable or function in your code. It determines the visibility of variables and is directly dependent on the lexical environment. There are three types of scope in JavaScript:

Global Scope: Variables declared outside any function or block. They can be accessed from anywhere in the code.
Function Scope: Variables declared inside a function. They are not accessible outside the function.
Block Scope: Variables declared inside a block (with let or const). They are confined to the block in which they are declared.

What is the Lexical Environment?

A lexical environment is created whenever an execution context is created. It consists of the local memory along with the lexical environment of its parent (lexical parent).

Example of Lexical Environment

function a() {
    c();
    function c() {
        console.log(b);
    }
}
var b = 10;
a();

Call Stack and Lexical Environment

Let's make a call stack diagram for the above problem:

Global Execution Context:
- b is declared and initialized with 10.
- a is declared.
Function a Execution Context:
- c is declared.
Function c Execution Context:
- console.log(b) prints 10 as it looks up the scope chain to find b.

The lexical environment is the local memory combined with the lexical environment of its parent. In the example, c() is lexically sitting inside a(), which is lexically inside the global context.

What is the Scope Chain?

The scope chain is a chain of all lexical environments and parent references. It determines the order in which variables are accessed. When a function is called, the JavaScript engine first looks for the variable in the local scope, then moves up the scope chain to the parent scope, continuing until the global scope is reached.

Example of Scope Chain

var globalVar = 'I am global';

function outerFunction() {
    var outerVar = 'I am from outerFunction';

    function innerFunction() {
        var innerVar = 'I am from innerFunction';
        console.log(innerVar);   // I am from innerFunction
        console.log(outerVar);   // I am from outerFunction
        console.log(globalVar);  // I am global
    }

    innerFunction();
}

outerFunction();

Hoisting with `let` and `const`

Variables declared with let and const are hoisted, but unlike var, they are not initialized until their definition is evaluated. This creates a "temporal dead zone" from the start of the block until the initialization is complete.

Temporal Dead Zone

The temporal dead zone (TDZ) is the period between when a variable is hoisted and when it is initialized. Accessing a variable in the TDZ results in a ReferenceError.

Example of Temporal Dead Zone

console.log(a); // Uncaught ReferenceError: Cannot access 'a' before initialization
let a = 5;

In this example, a is in the TDZ from the start of the block until it is initialized with 5.

Summary

Understanding scope, the scope chain, and the lexical environment is fundamental for mastering JavaScript. Here's a quick recap:

Scope: Defines where you can access variables and functions.
Lexical Environment: Local memory plus the lexical environment of the parent.
Scope Chain: The chain of lexical environments determining variable access order.
Hoisting: let and const are hoisted but not initialized, creating a temporal dead zone.

With this knowledge, you can write more predictable and maintainable JavaScript code. Happy coding!

This post provides an in-depth look at these crucial concepts, helping you understand how JavaScript manages scope and variable accessibility. Feel free to share your thoughts and questions in the comments below!

Understanding JavaScript Execution Context

bhavesh jadhav — Tue, 28 May 2024 20:17:55 +0000

JavaScript is a synchronous, single-threaded language. This might sound complex, but let's break it down to understand what it really means and how it affects the way JavaScript executes code.

JavaScript: Synchronous and Single-Threaded

In JavaScript, being single-threaded means it can execute one command at a time. This is in contrast to multi-threaded languages, which can handle multiple tasks simultaneously. Imagine you have a single line at a grocery store checkout – each person (or task) waits for their turn to be processed.

When we say JavaScript is synchronous and single-threaded, it means:

One Command at a Time: JavaScript can handle only one task at a time. It starts a task, completes it, and then moves on to the next one.
Specific Order: The tasks are executed in the order they appear in the code. JavaScript will not jump to the next task until the current one is completed.

Execution Context

An execution context is the environment in which JavaScript code is executed. There are two types of execution contexts in JavaScript:

Global Execution Context: This is the default context where your code starts execution. It creates a global object (like window in browsers) and sets up the this keyword to refer to this global object.
Function Execution Context: Whenever a function is called, a new execution context is created for that function. It has its own space for variables and function-specific data.

How It Works

When your JavaScript code runs, the JavaScript engine creates an execution context and manages the order of operations using a stack called the Call Stack. Here's a simplified view:

Global Execution Context: When your script starts, the global execution context is created and pushed onto the call stack.
Function Call: When a function is invoked, a new function execution context is created and pushed onto the call stack.
Function Completion: Once a function completes its execution, its context is popped off the stack, and the control returns to the previous context.

Example

Let's look at a simple example to see this in action:

function first() {
    console.log("First function");
}

function second() {
    console.log("Second function");
    first();
    console.log("Second function again");
}

second();
console.log("Global context");

Execution Order:

Global context starts.
second() function is called.
second() execution context is pushed onto the stack.
console.log("Second function") runs.
first() function is called inside second().
first() execution context is pushed onto the stack.
console.log("First function") runs inside first().
first() execution context is popped off the stack.
console.log("Second function again") runs.
second() execution context is popped off the stack.
console.log("Global context") runs.

Conclusion

Understanding that JavaScript is synchronous and single-threaded is crucial for writing efficient code. It helps you anticipate the order of execution and manage how your functions interact. By grasping the concept of execution contexts and the call stack, you can better debug and optimize your JavaScript applications.

DEV Community: bhavesh jadhav

Building a Simple ATM System in Python: A Casual Walkthrough

Important Terminologies in JavaScript

1. Function Statement

2. Function Expression

3. Difference Between Function Statement and Function Expression

4. Function Declaration

5. Anonymous Function

6. Named Function Expression

7. Difference Between Parameters and Arguments

8. First-Class Function:

9. Callback Functions

Understanding Closures in JavaScript

Uses of Closures

Example: setTimeout and Closures

Common Pitfall

Explanation:

Fixing the Issue

Achieving the Same Without let

Conclusion

Understanding JavaScript Blocks and Scope

Blocked in JavaScript

Why Do We Need to Group Statements?

Block Scope

What is Shadowing in JavaScript?

Illegal Shadowing

Reason for Reverse Allowance

Shadowing in Function Scope

Conclusion

Understanding the Scope Chain, Scope, and Lexical Environment in JavaScript

What is Scope?

What is the Lexical Environment?

Example of Lexical Environment

Call Stack and Lexical Environment

What is the Scope Chain?

Example of Scope Chain

Hoisting with let and const

Temporal Dead Zone

Example of Temporal Dead Zone

Summary

Understanding JavaScript Execution Context

JavaScript: Synchronous and Single-Threaded

Execution Context

How It Works

Example

Conclusion

Example: `setTimeout` and Closures

Achieving the Same Without `let`

Hoisting with `let` and `const`