HG BLOGS

Tkinter and Api

2025-01-10T12:00:00.001+05:30

Document

Tkinter and Api

In this blog, we'll walk through the basics of Tkinter, how to interact with APIs. Whether you're a beginner or looking to brush up on your programming skills, this guide will set you on the right path to mastering Python and Tkinter.

Tkinter

Tkinter is like a special set of tools that helps you build that program. It gives you the building blocks – like buttons, boxes, and labels – and lets you put them together to create a program that looks nice and is easy to use.

Widgets of Tkinter

Label

This is used to display text or images. For instance, you can use Label to show the current temperature, weather conditions, or the name of the city.

        
          
 from tkinter import Label
            
 label = Label(root, text="Temperature: 25°C")
 label.pack()

Entry

This widget allows users to enter a single line of text. You can use it to let users input a city name or ZIP code to get weather information.

        
           
 from tkinter import Entry
            
 entry = Entry(root)
 entry.pack()

Button

Buttons can be used to trigger actions when clicked, like fetching weather data.

         
  from tkinter import Button

  button = Button(root, text="Get Weather", command=fetch_weather)
  button.pack()

Text

This widget is useful for displaying multiple lines of text, such as weather details for different days or additional weather information.

        
   from tkinter import Text

   text = Text(root)
   text.pack()

Api(Application Programming Interface)

An API (Application Programming Interface) is like a bridge that allows different software systems to communicate with each other.

Interaction: APIs define how software components should interact. For example, a weather app might use an API to get weather data from a weather service.
Requests and Responses: APIs operate through requests and responses, much like a conversation. Your app sends a request to an API, and the API sends back the response with the required data.
Formats: Most APIs use common data formats like JSON or XML, making it easier for different systems to understand the data shared.

Recursion In Python

2025-01-03T12:00:00.001+05:30

Document

Recursion

Recursion involves a function calling itself directly or indirectly to solve a problem by breaking it down into simpler and more manageable parts.

Python Recursive Function

In Python, a recursive function is defined like any other function, but it includes a call to itself.

                
def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))

Basic Structure of Recursive Fucntion

                
def recursive_function(parameters):


    if base_case_condition:


    return base_result


    else:


    return recursive_function(modified_parameters)

Advantages:

Easier to Understand: For some problems, like navigating through a tree-like structure, recursive solutions can be much easier to grasp and write compared to using loops.
Shorter Code: Often, you can express complex logic more concisely with recursion, leading to shorter and potentially more readable code.

Disadvantages:

Uses More Memory: Each time a function calls itself, it uses a bit of memory to keep track of where it was before. This can add up quickly, especially for deeply nested recursive calls.
Can be Slower: The overhead of making function calls can sometimes make recursive solutions run slower than equivalent solutions using loops.

Examples

Fibonnaci Series Using Recursion

        
def fibonacci(n):
if n <= 1:
    return n
else:
    return fibonacci(n-1) + fibonacci(n-2)
          
         
result = fibonacci(6)
print(f"6th Fibonacci number is: {result}")

Factorial Using Recursion

        
def factorial(n):

if n == 0:
    return 1
else:
    return n * factorial(n-1)

result = factorial(5) 
print(f"Factorial of 5 is: {result}")

Functions in Python

2024-12-27T12:00:00.001+05:30

Document

Functions

The functions in python can be defined as the reusable block of codes that perform a certain task. Before we start defining functions ourselves, we’ll look at some of Python’s built-in functions. Let’s start with the most well-known built-in function, called print:

            
>>> print('Hello, readers!')
 Hello, readers!
 >>> print(15)
 15

Creating python functions

In programming language there are certain syntax we need to follow and python is not an exception

    
def function_name:
  #statements
  return

Advantages of using functions

A Python function can be defined once and used many times. So it aids in code reuse: you don’t want to write the same code more than once. Functions are a great way to keep your code short, concise, and readable. By giving a function a well-chosen name, your code will become even more readable because the function name directly explains what will happen. This way, others (or future you) can read your code, and without looking at all of it, understand what it’s doing anyway because of the well-chosen function names.

Return values

A function can return a value. This value is often the result of some calculation or operation. In fact, a Python function can even return multiple values. We can make this more interesting by allowing an argument to be passed to our function. Again we define a function with def, but we add a variable name between the parentheses:

            
 >>> def say_hi(name):
      print('Hi', name)
>>> say_hi('chiku')
Hi chiku

Our function now accepts a value, which gets assigned to the variable name. We call such variables the parameter, while the actual value we provide (‘Chiku’) is called the argument.

Variable scope

The variable name only exists inside our function. We say that the variable’s scope name is limited to the function say_hi, meaning it doesn’t exist outside of it.

Scope

The visibility of a variable is called scope. The scope defines which parts of your program can see and use a variable.
If we define a variable at the so-called top level of a program, it is visible in all places.

                
>>> def say_hi():
...    print("Hi", name)
...    answer = "Hi"
...
>>> name = 'Chiku'
 >>> say_hi()
 Hi Chiku
 >>> print(answer)
Traceback (most recent call last):
 File "", line 1, in

NameError: name 'answer' is not defined say_hi was able to use the variable name, as expected, because it’s a top-level variable: it is visible everywhere. However, answer, defined inside say_hi, is not known outside of the function and causes a NameError. Python gives us an informative and detailed error: “name ‘answer’ is not defined.”

Sets in python

2024-12-20T12:00:00.000+05:30

Document

SETS

Sets are an ideal choice for representing a group of unique values as a single entity. They offer several key characteristics: they do not allow duplicate elements, they do not preserve the order of insertion, and they do not support indexing or slicing. While the order of elements may not be guaranteed, sets can be sorted for specific purposes. This makes sets useful for tasks like removing duplicates from a list or performing set operations like union, intersection, and difference.

            
    s={10,20,30,40}
    print(s) 
               
     Ouput:{10,20,30,40}

Important set functions

add(x):

When we want to add individual element to the set we use add()

            
    ex:
    s={10,20,30}
    s.add(40);
    print(s) #{40, 10, 20, 30}

update(x,y,z):

when we want to add multiple elements to the set we use update()

            
ex:
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
                
x.update(y)
                
 print(x)

Output:
{'google', 'microsoft', 'apple', 
'banana', 'cherry'}

Copy()

This set function is used when we want to copy the set

            
ex:
s={10,20,30}
s1=s.copy()
print(s1)

pop()

It removes and returns some random element from the set.

            
ex:
fruits = {"apple", "banana", "cherry"}
                
fruits.pop()
                
print(fruits)
                
output:
{'apple', 'cherry'}

remove()

The remove set function is used to remove the specified element from the set . If in case the element is not present in the set it returns keyerror.

            
ex:
s={40,10,30,20}
s.remove(30)
                
output:
{40,10,20}

Mathematical operation in set

union():

We can use this function to return all the elements present in the set

            
ex:
x={10,20,30,40}
y={30,40,50,60}
print(x.union(y)) 
#{10, 20, 30, 40, 50, 60}
print(x|y) #{10, 20, 30, 40, 50, 60}

Intersection()

The intersection() is used to return the common element present in the sets.

            
ex:
x={10,20,30,40}
y={30,40,50,60}
print(x.intersection(y)) #{40, 30}
print(x&y) #{40, 30}

Difference():

The difference() is used to return the elements presents in x and not in y

            
x={10,20,30,40}
y={30,40,50,60}
print(x.difference(y)) #{10, 20}
    print(x-y) #{10, 20}
print(y-x) #{50, 60}

List and Tuple in Python

2024-12-13T12:00:00.003+05:30

Document

List

A list is a data type in Python used to store a collection of items. Lists are mutable, which means we can modify their contents after they are created.The data in the list is stored in the square brackets.

                        
    lst = [1,2,3,4,5]

Accessing the elements of the list

The elemnts of the list can be accessed by two methods

By Indexing
By Slice Operator

Indexing

            
    lst = [1,2,3,4]
    print(lst.[0])
    output:1

Slice operator

        
    list = list1[start:stop:step]

start ==>it indicates the index where slice has to startdefault value is 0
stop ===>It indicates the index where slice has to end default value is max allowed index of list ie length of the list
step ==>increment value default value is 1

        
    n=[1,2,3,4,5,6,7,8,9,10]
    print(n[2:7:2])
    print(n[4::2])
    print(n[3:7])
    print(n[8:2:-2])
     print(n[4:100])

Tuple

Tuples are used to store multiple items in a single variable. A tuple is an immutable collection of data, meaning its elements cannot be changed once it's created. Tuples are written within parentheses.The tuple can also be defined as the read only version of the list as once the tuple is created we cannot make any changes in it.

        
    tup =(1,2,3,4,5)

Tuple creation

t=() creation of empty tuple
t=(10,) t=10, creation of single valued tuple ,parenthesis are optional,should ends with comma
t=10,20,30 t=(10,20,30) creation of multi values tuples & parenthesis are optional

Accessing the elements of the Tuple

By Indexing
By Slice Operator

Indexing

        
    t=(10,20,30,40,50,60)
    print(t[0]) #10
    print(t[-1]) #60
    print(t[100]) IndexError: tuple index out of range

Slice Operator

        
    t=(10,20,30,40,50,60)
    print(t[2:5])
    print(t[2:100])
    print(t[::2])

   Output
   (30, 40, 50)
   (30, 40, 50, 60)
   (10, 30, 50)

Difference b/w List and tuple

List	Tuple
List is a Group of Comma separated Values within Square Brackets and Square Brackets are mandatory.	Tuple is a Group of Comma separated Values within Parenthesis and Parenthesis are optional.
List Objects are Mutable i.e. once we creates List Object we can perform any changes in that Object.	Tuple Objeccts are Immutable i.e. once we creates Tuple Object we cannot change its content.
If the Content is not fixed and keep on changing then we should go for List.	If the content is fixed and never changes then we should go for Tuple.
List Objects can not used as Keys for Dictionries because Keys should be Hashable and Immutable	Tuple Objects can be used as Keys for Dictionries because Keys should be Hashable and Immutable.

Follow on LinkedIn

Strings and String Operations In Python

2024-12-06T00:00:00.002+05:30

Document

Strings

The string is defined as any set of characters within either single quote or the double quotes.

        
    ex:
    s='Notes'
    s="Notes"

HOW TO ACESS CHARCTERS OF THE STRING

There are two ways to access the characters in the string

By Indexing
By Slice Operator

Indexing

        
     s = "Notes"

    print(s[0])
    Output:N
            
    print(s[1])
    Output:o
            
    print(s[2])
    Output:t
            
    print(s[3])
    Output:e
            
    print(s[4])
     Output:s

Slice Operators

Syntax: s[begin:end:step]

Begin: From where the we have to consider the slicing of the string
End: From where the slicing of the string will end at index -1
Step: It is the incremented value

    
ex: s='Notes'
    print(s[0:2:1])
    Output: No
    print(s[1:2])
    Output: o

Mathematical Operators in String

We can use Two types of mathematical Operators in String

'+' For concatenate
'*' For multiplication

Note : Both the arguments should be in string to concanecate and to multiply

len() Built in Function

We can use the len() function to find the number of characters present in the string

    
ex:
    s= "Notes"
    print(len(s))
    Output: 5

Finding Substring

We can use four methods to find the string

For forward Direction -> index() ,find()
For backward Direction -> rindex() ,rfind()

find()

    
ex:
 s="notes"
 print(s.find("e"))
 Ourput:3

Index()

The index method is same as find() the only difference is that it returns Value error if the required character o string is not

Replacing the String with another String

    
 ex:
 s1= "notes"
 s2 = print(s1.replace('notes','hello'))

Splitting of the Strings

We can also split the strings by using split()

    
ex: s = 'python is a very good language'
s1 = s.split()
print(s1)

Joining of the Strings

    
ex:
s= ('My' ,'notes', 'are', 'very', 'good')
s1 = '-'.join(s)
print(s1)

Changing the case of the Strings

1. upper()===>To convert all characters to upper case
2. lower() ===>To convert all characters to lower case
3. swapcase()===>converts all lower case characters to upper case and all upper case characters to lower case
4. title() ===>To convert all character to title case. i.e first character in every word should be upper case and all remaining characters should be in lower case.
5. capitalize() ==>Only first character will be converted to upper case and all remaining characters can be converted to lower case

Follow on LinkedIn

For Loop and While Loop in Python

2024-11-29T12:00:00.002+05:30

Document

For Loop

A for loop is a control flow statement that allows you to execute a block of code repeatedly for a specified number of times. It's particularly useful when you know in advance how many times you want the loop to iterate.

Example:


    for i in range(6):
         print(i)

While Loop

A while loop is another control flow statement that executes a block of code repeatedly as long as a certain condition is true. It's useful when you don't know the exact number of iterations in advance.

Example:


    i=0
    while i<11:
     print(9*i)
     i+=1

Follow on LinkedIn

Conditional Statements In Python

2024-11-22T12:00:00.002+05:30

Document

Conditional Statements

One of the most Crucial thing in programming is decision making It is required to give direction to the code.

These are some operators which are used with conditional Statements.

Equals (==)->

We use it to check if a variable is equal to another variable. For example, m == n.

Not Equals (!=)->

To check if a variable is not equal to another variable. For example, m != n.

Greater Than (>)->

To check if a variable is greater than another variable. For example, m > n.

Less Than (<) ->

To check if a variable is less than another variable. For example, m < n.

Greater Than or Equal to->

To assess if a variable is greater than or equal to another variable. For example, m >= n.

Less Than or Equal to->

To evaluate if a variable is less than or equal to another variable. For example, m <= n.

FOUR TYPES OF CONDITIONAL STATEMENTS

Conditional Statements

If Statement

Nested If statement

If-else statement

If-elif-else Statement

if Conditional Statement

The if conditional statement is the simplest conditional statement in python programming In if conditional statement the code will execute if the given condition is true otherwise it will move forward in the program.

              
      x = 5
      if x == 5:
          print("True")
      
      Output: True

If else conditional statement

"In an if-else conditional statement, the code within the if block is executed if the given condition is True. If the condition is False, the code within the else block is executed instead."

              
      x = 5
      if x == 4:
          print("True")
      else:
          print("False")
      
      Output: False

Nested if conditional statement

"Nested if statements allow you to create complex decision-making structures in Python. By placing one if statement within another, you can execute different code blocks based on multiple conditions. However, excessive nesting can make code less readable and harder to maintain.

              
 x = 10
 y = 20
      
 if x > 5:
     if y > 15:
         print("Both x and y are greater")
     else:
         print("x is greater than 5, 
         but y is not greater than 15")
 else:
     print("x is not greater than 5")

 Output: Both x and y are greater than
      their respective values

if-elif-else Conditional Statement

"This conditional statement operates as follows: if the if condition evaluates to True, the code within its block is executed. Otherwise, if an else block is present, its code is executed instead."

              
      a = 7
      b = 9
      c = 10
      
      if a >= b and a >= c:
          print("a is greatest")
      elif b >= a and b >= c:
          print("b is greatest")
      else:
          print("c is greatest")

      Output:  is greatest

Follow on LinkedIn

Typecasting and Operator Precedency

2024-11-15T12:00:00.017+05:30

Document

Type Casting

Typecasting is one of the key feature in python. Type casting is a fundamental concept in Python that involves converting one data type to another.
There are two primary methods:

Typecasting

Implicit Typecasting

Explicit Typecasting

In this blog we will learn about how to typecast different variables or data.

Implicit Type Casting

Python automatically performs implicit type casting in certain situations to prevent data loss. For instance, when dividing two integers, Python implicitly converts the result to a float to maintain precision.

For ex - While dividing two integers number the interpreter implicitly converts the variable x into float


     x = 5
     y = 2
     div = x / y
     print(div)  # Output: 2.5

Explaination:

Here we have assigned the values to variable x and y
The variable x has the value 5 and the variable y has the value 2
Now in the next line of code we have defined a variable Div in which we have assign the divison of x/y
Now here the interpreter will implicitly convert the x variable into float data type
In the last line of code we have print the output which is in the float data type

Explicit Type Casting

In explicit type casting, the programmer manually converts a data type using built-in functions like int(), float(), str(), bool(), and tuple(). This is often necessary when working with user input or when precise data type conversions are required.

For example -> if we use the input in-built function in python by default it gives the value in string data type so a user can do explicit type casting by using any of the functions.


    a = input("Enter a number: ") 
    b = int(a) 
    print(b)

In this example, the input() function returns a string. To perform arithmetic operations, we explicitly convert the input string to an integer using the int() function.

Explaination:

In these codes of line two variables are defined which are taking input from the users the variable a and the variable b
here in output we can see that when we print the variable a the output is in string variable
But in next line of code for variable b the user has explicity type cast the input into integer
Hence we can see a integer output.

Operator Precedence and Associativity

Operator Precedence:

In Python, operator precedence determines the order in which operators are evaluated in an expression containing multiple operators. When the Python interpreter encounters such an expression, it evaluates the operators in a specific, hierarchical order.

Operator Associativity:

While operator precedence helps resolve the order of different operators, associativity comes into play when an expression contains operators of the same precedence level. Associativity defines the direction (left-to-right or right-to-left) in which these operators are evaluated.

Python Operator Precedence and Associativity Table

Operator	Precedence	Associativity
() [] {}	Highest	Left-to-right
**	High	Right-to-left
*, /, //, %	High	Left-to-right
+, -	Medium	Left-to-right
<<, >>, &	Medium	Left-to-right
^, \|	Low	Left-to-right
<, <=, >, >=, ==, !=	Low	Left-to-right
not	Low	Right-to-left
and	Low	Left-to-right
or	Lowest	Left-to-right

Follow on LinkedIn

Operators in Python

2024-11-08T12:00:00.002+05:30

Document

Operators

In Python, operators are special symbols that perform specific operations on values and variables.

Arithmetic Operators

Arithmetic operators are symbols used to perform basic mathematical operations on numerical values. These operations include addition, subtraction, multiplication, division, modulus, floor division, and exponentiation.

Operator	Description	Example
+	Addition	x + y
-	Subtraction	x - y
*	Multiplication	x * y
/	Division	x / y
%	Modulus	x % y
**	Exponentiation	x ** y
//	Floor Division	x // y

Comparison Operators

Comparison operators are used to compare two values and return a Boolean value (True or False). They are essential for making decisions and controlling the flow of your program

Operator	Description	Example
==	Equal to	x == y
!=	Not equal to	x != y
>	Greater than	x > y
<	Less than	x < y
>=	Greater than or equal to	x >= y
<=	Less than or equal to	x <= y

Assignment Operators

Assignment operators are used to assign values to variables

Operator	Description	Example
=	Assign value	x = y
+=	Add and assign	x += y
-=	Subtract and assign	x -= y
*=	Multiply and assign	x *= y
/=	Divide and assign	x /= y
%=	Modulus and assign	x %= y
**=	Exponentiate and assign	x **= y
//=	Floor divide and assign	x //= y

Logical Operators

Logical operators are used to combine conditional statements and return a Boolean value (True or False). They are essential for making decisions and controlling the flow of your program.

Operator	Description	Example
and	Logical AND	x and y
or	Logical OR	x or y
not	Logical NOT	not x

Bitwise Operators

Bitwise operators work on bits of an integer. They are used to manipulate individual bits within a binary representation of a number.

Operator	Description	Example
&	Bitwise AND	x & y
\|	Bitwise OR	x \| y
^	Bitwise XOR	x ^ y
~	Bitwise NOT	~x
<<	Left shift	x << y
>>	Right shift	x >> y

Identity Operators

Identity operators are used to compare the objects, not if they are equal, but if they are actually the same object, with the same memory location.

Operator	Description	Example
is	Returns True if both variables refer to the same object	x is y
is not	Returns True if both variables do not refer to the same object	x is not y

Membership Operators

Membership operators are used to test whether a value or variable is found in a sequence (such as a string, list, tuple, set, or dictionary).

Operator	Description	Example
in	Returns True if a value is present in a sequence	x in y
not in	Returns True if a value is not present in a sequence	x not in y

Follow on LinkedIn

Python Basics

2024-11-01T11:34:00.004+05:30

Document

PYTHON

"Python is a high-level programming language. It is also known as an interpreted language because it executes code line by line, rather than compiling the entire program at once."

The Variables are used to hold the values of different data types in Python. There are primarily two types of variables in most programming languages. The local variable and the Global variable.

Variable

Local Variable

Global Variable

Local variable

The local varible is only defined with in the the specific functions. The local variable in a program doesn't hold any value outside the function in a program.

                        x=10

                        y=20

                        def add(a,b):

                         c=a+b

                          return c

                        sum=add(x,y)

                        print(sum)

                        // here the variables a,b are local variables

Global Variable

The Global Variable is the variable which is defined for the whole program it will work in every function.

                        x=10

                        y=20

                        def add(a,b):

                         c=a+b

                          return c

                        sum=add(x,y)

                        print(sum)

                        // Here the variables x and y are global variables

Data Types

"Data types define the kind of value a variable can hold. They determine the operations that can be performed on the variable.A variable can be of numeric data type(int,float,complex),String Data type etc.

"In Python, you don't need to explicitly declare the data type of a variable, unlike in languages like C and C++."

There are mainly 6 Types of Data type:

Data Types

Numeric

String

List

Boolean

Tuple

Dictionary

Numeric Data Type

Numeric data types represent numbers. They are further classified into two categories:

Integer: Whole numbers (e.g., 10, -5, 0)
Float: Decimal numbers (e.g., 3.14, -2.5)

String Data Type

A sequence of characters enclosed in single or double quotes.

Example: "Hello, World!"

Boolean Data Type

Represents either True or False.

Example: True, False

List Data Type

An ordered collection of items, enclosed in square brackets.

Example: [1, 2, 3, "apple", "banana"]

Dictionary Data Type

An unordered collection of key-value pairs, enclosed in curly braces.

Example: {"name": "Alice", "age": 30, "city": "New York"}

Tuple Data Type

An ordered, immutable collection of items, enclosed in parentheses.

Example: (10, 20, 30, "Python")

Follow on LinkedIn

HG BLOGS

Tkinter and Api

HG Blogs

Tkinter and Api

Tkinter

Widgets of Tkinter

Label

Entry

Button

Text

Api(Application Programming Interface)

Recursion In Python

HG Blogs

Recursion

Python Recursive Function

Basic Structure of Recursive Fucntion

Advantages:

Disadvantages:

Examples

Functions in Python

HG Blogs

Functions

Creating python functions

Advantages of using functions

Advantages of using functions

Return values

Variable scope

Scope

Sets in python

HG Blogs

SETS

Important set functions

add(x):

update(x,y,z):

Copy()

pop()

remove()

Mathematical operation in set

union():

Intersection()

Difference():

List and Tuple in Python

HG Blogs

List

Accessing the elements of the list

Indexing

Slice operator

Tuple

Tuple creation

Accessing the elements of the Tuple

Indexing

Slice Operator

Difference b/w List and tuple

Strings and String Operations In Python

HG Blogs

Strings

HOW TO ACESS CHARCTERS OF THE STRING

Indexing

Slice Operators

Mathematical Operators in String

len() Built in Function

Finding Substring

find()

Index()

Replacing the String with another String

Splitting of the Strings

Joining of the Strings

Changing the case of the Strings

For Loop and While Loop in Python

HG Blogs

For Loop

Example:

While Loop

Example:

Conditional Statements In Python

HG Blogs

Conditional Statements

Equals (==)->

Not Equals (!=)->

Greater Than (>)->