Python Interview Questions | Fresher| Senior Developer | Technical Lead

 Python interview questions that are commonly asked to freshers:

• What is Python? Mention some key features of Python.

• What are the differences between Python 2 and Python 3?

• How do you install third-party packages in Python?

• Explain the concept of Python virtual environments.

• What are the different data types available in Python?

• Explain the difference between a list and a tuple in Python.

• How do you handle exceptions in Python? Provide an example.

• What is the purpose of the __init__ method in a Python class?

• How do you open and read a file in Python?

• What is the difference between append() and extend() methods in Python lists?

• Explain the concept of a generator in Python. How is it different from a regular function?

• What is the difference between shallow copy and deep copy in Python?

• How do you define a lambda function in Python? Provide an example.

• Explain the concept of decorators in Python. Provide an example.

• What is the difference between __str__ and __repr__ methods in Python?

• How can you remove duplicate elements from a list in Python?

• Explain the difference between a module and a package in Python.

• How do you perform unit testing in Python?

• Explain the concept of list comprehensions in Python. Provide an example.

• How do you handle file handling errors in Python?

Python interview questions that are commonly asked to senior developers:

• What is a decorator in Python? How do you use decorators?

• Explain the Global Interpreter Lock (GIL) in Python. How does it impact multi-threading?

• What are the different ways to achieve concurrency in Python?

• Explain the concept of metaclasses in Python. Provide an example.

• How do you handle memory management in Python?

• What are some common design patterns used in Python?

• Explain the concept of context managers in Python. Provide an example.

• What are some differences between a function and a method in Python?

• How do you handle large datasets in Python? Are there any libraries that can help?

• Explain the concept of closures in Python. Provide an example.

• How do you optimize the performance of a Python application?

• What is the purpose of the __slots__ attribute in a Python class?

• Explain the difference between shallow copy and deep copy in Python. When would you use each?

• How do you handle circular imports in Python?

• What are some best practices for writing clean and maintainable Python code?

• Explain the concept of generators and iterators in Python. Provide an example.

• What are some differences between the is and == operators in Python?

• How do you work with databases in Python? Are there any ORM libraries you are familiar with?

• Explain the concept of method resolution order (MRO) in Python.

• How do you handle and raise custom exceptions in Python?

Python interview questions that are commonly asked to technical leads:

As a technical lead, how do you ensure code quality and enforce coding standards in a Python project?

• Explain the concept of Python decorators. How can they be used to enhance code functionality or provide cross-cutting concerns?

• What strategies or methodologies do you follow for effective project planning and task estimation?

• How do you handle technical debt and code refactoring in a Python project?

• Describe your experience with optimizing Python code for performance. What techniques or tools have you used?

• How do you approach architectural design and system scalability in a Python application?

• Explain your experience with integrating Python applications with external systems or APIs.

• How do you ensure the security of a Python application, including handling sensitive data and preventing common vulnerabilities?

• Describe your experience with handling and resolving production issues in Python applications.

• How do you lead a development team and promote collaboration and knowledge sharing?

• Describe a situation where you faced a technical challenge or roadblock in a Python project and how you resolved it.

• Explain your experience with working in Agile or other software development methodologies.

• How do you ensure effective communication and collaboration between technical and non-technical stakeholders in a project?

• What tools or techniques do you use for automated testing and continuous integration in Python projects?

• Describe your experience with cloud platforms and deploying Python applications in a cloud environment.

• How do you ensure the maintainability and extensibility of a Python codebase as it evolves over time?

• Explain your approach to code reviews and how you provide constructive feedback to team members.

• Describe a situation where you had to make a technology or architectural decision for a Python project and the factors you considered.

• How do you mentor and guide junior developers to enhance their skills and contribute effectively to a Python project?

• What are some best practices for managing technical documentation and knowledge sharing in a Python project?

Read More

Future of Python Programming

 

The future of Python programming looks bright and promising. Python has been steadily growing in popularity over the years and has become one of the most widely used programming languages across various domains. Here are some key aspects that shape the future of Python programming:

Continued Growth: Python's popularity is expected to continue growing as more developers and organizations recognize its simplicity, readability, and versatility. It has a vast ecosystem of libraries and frameworks that make it suitable for a wide range of applications.

Data Science and Machine Learning: Python has become the go-to language for data science and machine learning. Popular libraries like NumPy, Pandas, and scikit-learn have established Python as a powerful tool for data analysis, modeling, and machine learning. With the growing demand for data-driven insights and AI solutions, Python's role in these fields is expected to expand further.

Web Development: Python's web development frameworks, such as Django and Flask, have gained significant traction in recent years. Python's simplicity and ease of use make it an attractive choice for web development projects. As web applications continue to evolve and grow in complexity, Python is likely to remain a preferred language for web development.

Artificial Intelligence and Automation: Python is heavily used in artificial intelligence (AI) and automation. Libraries like TensorFlow and PyTorch are widely adopted for building and deploying AI models. Python's flexibility and ease of integration with other technologies make it well-suited for AI-related tasks.

DevOps and Infrastructure: Python's role in DevOps and infrastructure automation is also expected to increase. Tools like Ansible, Fabric, and SaltStack leverage Python for automation and configuration management. Python's scripting capabilities and extensive library support make it a valuable language in the DevOps domain.

Education and Beginner-Friendly Nature: Python's simplicity and readability make it an excellent choice for teaching programming to beginners. Many educational institutions and coding bootcamps have adopted Python as their primary teaching language. This trend is likely to continue, fostering a growing community of Python developers.

Performance Improvements: Python's performance has been a topic of discussion, particularly in high-performance computing and real-time applications. Efforts like PyPy, Numba, and Cython have been made to optimize Python's execution speed. As these optimizations progress, Python's performance is expected to improve further.

Community and Ecosystem: Python has a vibrant and active community, contributing to its growth and development. The Python Package Index (PyPI) hosts an extensive collection of open-source libraries, enabling developers to easily leverage existing code and accelerate their development process. The community's continuous contributions and collaborations are likely to drive Python's progress.

Overall, Python's future seems promising, driven by its versatility, simplicity, and strong ecosystem. It will continue to be a popular choice for a wide range of applications, from web development and data science to AI and automation. As technology advances and new trends emerge, Python is expected to adapt and remain a relevant and influential language in the programming landscape.

Read More

What is the output of the following snippet, and why?

 What is the output of the following snippet, and why? 

x,x,y = 0,3,6 
print(x,y)

Solution:

Read More

100 Days Python Loop Challenge | Day 1 : Print Multiplication Table

 

Explanation:

Read More

100 Days Python Loop Challenge

 100 Days Python Loop Challenge 

The 100 Days of Code Python Loop Challenge is a coding challenge designed to help you improve your coding skills by coding every day for 100 days. The challenge focuses on loops in Python, which are a fundamental building block of many programs.

The challenge involves writing code every day for 100 days, with each day building on the previous day's work. The challenge provides you with a set of tasks to complete each day, with the aim of helping you to gradually build up your skills and knowledge of loops in Python.

The challenge is designed to be flexible, so you can start it at any time and work at your own pace. You can also choose to work on the challenge for more or less than 100 days, depending on your schedule and availability.

To participate in the challenge, you can join the 100 Days of Code community, which provides support and resources for participants. You can also use the #100DaysOfCode hashtag on social media to connect with other participants and share your progress.

If you are interested in improving your coding skills and learning more about loops in Python, the 100 Days of Code Python Loop Challenge is a great way to get started. 

https://bit.ly/41qPJQ1

Read More

Generate Sine , Square , Triangle and Sawtooth in Python

 

Read More

Difference between class and function in Python

 In Python, classes and functions are two fundamental programming constructs, each with its own unique purpose and characteristics.

Functions are blocks of code that take input, perform operations on that input, and then return an output. Functions can be defined and called within a program, making it possible to reuse code and simplify the development process. Functions are also useful for encapsulating logic and making code more modular, as well as improving code readability.

Classes, on the other hand, are a way to define new types of objects in Python. They provide a blueprint for creating objects that have a specific set of attributes and methods. In other words, classes define the structure and behavior of objects, and allow you to create multiple instances of those objects.

Here are some key differences between classes and functions in Python:

• Syntax: Functions are defined using the def keyword, followed by the function name and any arguments. Classes are defined using the class keyword, followed by the class name and any properties or methods.

• Purpose: Functions are primarily used to perform a specific operation and return a result. Classes, on the other hand, are used to define new types of objects with their own attributes and methods.

• Scope: Functions are typically defined at the module level, and can be called from anywhere in the module. Classes, however, are often defined within a module or within another class, and can only be accessed within that scope.

• Instances: Functions are not instantiated - they are simply called and executed as needed. Classes, on the other hand, can be instantiated to create new objects with their own properties and methods.

• Inheritance: Classes can be inherited from other classes to create new classes that inherit the properties and methods of their parent classes. Functions do not have this capability.

Overall, both classes and functions are important programming constructs in Python, but they serve different purposes and are used in different ways. Understanding the differences between classes and functions is key to writing effective Python code.

Read More

Day 150 : Laptop Notification with Python

 

Read More

Mathematical Function graphs using Python

 

Read More

What does the “yield” keyword do in python?

 In Python, the yield keyword is used to create a generator function. When a function includes a yield statement, it becomes a generator function, which returns an iterator object that can be iterated over with a loop.

The yield statement suspends the function's execution and sends a value back to the caller, but unlike return, the function state is saved, and the function can be resumed later from where it left off.

Here's an example to demonstrate the use of yield:

def countdown(num):

    while num > 0:

        yield num

        num -= 1

This generator function countdown() will return an iterator that will produce a sequence of numbers from num down to 1. We can use a for loop to iterate over the sequence:

for i in countdown(5):

    print(i)

5

4

3

2

1

Each time the yield statement is reached, the function's state is saved, and the value of num is sent back to the caller. The next time the generator is called, execution continues from where it left off, and num is decremented until it reaches zero.

Read More

7 Cool Ways To Use F-Strings In Python

 

Read More

Generator Vs List in Python

 In Python, there are two main ways to create sequences of values: using a generator or a list. While both have their uses, they have different performance characteristics and memory usage, so it's important to choose the right one for your specific use case.

A generator is a type of iterable, like a list or a tuple, but unlike a list, a generator does not store all the values in memory at once. Instead, it generates the values on-the-fly as they are requested, using a special type of function called a generator function. Generator functions use the yield keyword to return a value, but unlike a regular function that returns a value and then exits, a generator function can be resumed from where it left off, so it can continue generating values until it is done. Because generators don't store all their values in memory, they can be more memory-efficient than lists for large data sets, and can be faster for certain operations.

Here's an example of a simple generator function that generates a sequence of numbers:

def generate_numbers(n):

    for i in range(n):

        yield i

To use this generator, you would typically use it in a loop or with a function like next() to generate values one at a time:

numbers = generate_numbers(5)

print(next(numbers)) # Output: 0

print(next(numbers)) # Output: 1

print(next(numbers)) # Output: 2

print(next(numbers)) # Output: 3

print(next(numbers)) # Output: 4

A list, on the other hand, is a type of sequence that stores all its values in memory at once. Lists can be created using square brackets [] or the list() function. Lists are very versatile and can be modified, sliced, and indexed in various ways. However, because they store all their values in memory at once, they can be memory-intensive for large data sets.

Here's an example of creating a list of numbers:

numbers = [0, 1, 2, 3, 4]

To iterate over a list, you can use a for loop or various other functions and methods:

for number in numbers:

    print(number)

Both generators and lists have their advantages and disadvantages, so choosing the right one depends on the specific use case. If you have a large data set or you only need to generate values one at a time, a generator might be more memory-efficient and faster. If you need to modify the sequence, access its values multiple times, or if the data set is small enough to fit in memory, a list might be more appropriate.

Read More

7 Cool Ways To Use F-Strings In Python

 

1. Align strings with f-strings:

You can use f-strings to align strings to the left, right, or center of a field. Here's an example:

name = "Alice"

age = 30

print(f"|{name:<10}|{age:^5}|")  # Output: |Alice     | 30  |

In this example, the < character aligns the name variable to the left of a 10-character field, and the ^ character centers the age variable in a 5-character field.

2. Use f-strings with dictionary variables:

You can use f-strings with dictionary variables to create dynamic strings. Here's an example:

person = {"name": "Alice", "age": 30}

print(f"My name is {person['name']} and I'm {person['age']} years old.")  # Output: My name is Alice and I'm 30 years old.

In this example, the person variable is a dictionary with keys "name" and "age". The f-string uses the values of these keys to create a dynamic string.

3. Use f-strings to format binary and hexadecimal numbers:

You can use f-strings to format binary and hexadecimal numbers. Here's an example:

x = 42

print(f"x = {x:b}")  # Output: x = 101010

print(f"x = {x:x}")  # Output: x = 2a

In this example, the :b format specifier formats the x variable as a binary number, and the :x format specifier formats the x variable as a hexadecimal number.

4. Use f-strings to format dates and times:

You can use f-strings to format dates and times. Here's an example:

import datetime

now = datetime.datetime.now()

print(f"Today is {now:%B %d, %Y}")  # Output: Today is April 29, 2023

In this example, the %B %d, %Y format specifier formats the now variable as a string in the format Month Day, Year.

5. Use f-strings to format currency values:

You can use f-strings to format currency values. Here's an example:

salary = 50000

print(f"My salary is ${salary:,}")  # Output: My salary is $50,000

In this example, the , character formats the salary variable as a string with comma separators.

6. Use f-strings with formatted strings:

You can use f-strings with formatted strings to create complex strings. Here's an example:

name = "Alice"

age = 30

message = f"My name is {name} and I'm {age} years old."

print(f"Message length: {len(message):<10}, Message: '{message:^20}'")

# Output: Message length: 32        , Message: 'My name is Alice and I'm 30 years old.'

In this example, the f-string uses another f-string to create a complex string that includes the length of the message variable and the message itself.

7.Use f-strings to format scientific notation:

You can use f-strings to format numbers in scientific notation. Here's an example:

x = 1234567890.123456789

print(f"x = {x:e}")  # Output: x = 1.234568e+09

Read More

Return VS Yield in Python

 

In Python, return and yield are two ways to send a value back from a function or generator to its caller, but they work in different ways.

return is a statement that immediately terminates the execution of a function and returns a value to the caller. When the function is called again, it starts executing from the beginning.

Here's an example:

def square(x):

    return x * x

result = square(5)

print(result)  # Output: 25

In this example, the square() function takes an argument x and returns its square using the return statement.

On the other hand, yield is a keyword that allows a function to return a generator object, which can be used to iterate over a sequence of values. When the function is called, it executes until it reaches a yield statement, which returns a value to the caller and suspends the function's execution. The next time the function is called, it continues executing from where it left off until it reaches another yield statement or the end of the function.

Here's an example:

def squares(n):

    for i in range(n):

        yield i * i

result = squares(5)

for square in result:

    print(square)  # Output: 0 1 4 9 16

In this example, the squares() function generates a sequence of squares using a for loop and the yield statement. The result variable holds a generator object, which is then iterated over using a for loop to print the squares.

In summary, return is used to immediately terminate a function and return a value to the caller, while yield is used to create a generator object that can be iterated over to return a sequence of values one at a time.

Read More

Python Quiz | Day 78 | What is the output of following Python code ?

 

Python Quiz | Day 78 | What is the output of following Python code ?
Complete Playlist : https://t.co/ExeeauixjT pic.twitter.com/YAgKqi0M1a

— Python Coding (@clcoding) April 29, 2023

Read More

Python Quiz | Day 76 | What is the output of following Python code ?

 

Solutions :

Python Quiz | Day 76 | What is the output of following Python code ?
Complete Playlist : https://t.co/ExeeauixjT pic.twitter.com/TEio3zArGP

— Python Coding (@clcoding) April 23, 2023

Read More

Python Quiz | Day 73 | What is the output of following Python code ?

 

Solutions: 

View this post on Instagram

A post shared by Python Coding (@pythonclcoding)

Read More

Python Quiz | Day 74 | What is the output of following Python code ?

Solutions  :

Python Quiz | Day 74 | What is the output of following Python code ?
Complete Playlist : https://t.co/ExeeauixjT pic.twitter.com/dCPJruiBjc

— Python Coding (@clcoding) April 16, 2023

Read More

Python Quiz | Day 75 | What is the output of following code ?

 

Python Quiz | Day 75 | What is the output of following Python code ? Complete Playlist : https://t.co/ExeeauixjT pic.twitter.com/z4gfILNxYQ

— Python Coding (@clcoding) April 21, 2023

Read More

Object Oriented Programming in Python

 Object-oriented programming (OOP) is a programming paradigm that is based on the concept of "objects," which can contain data and code to manipulate that data. Python is an object-oriented programming language that supports OOP concepts such as inheritance, encapsulation, and polymorphism. Here are some key concepts and syntax used in Python for OOP:

Class: A class is a blueprint or template for creating objects. It defines a set of attributes and methods that the objects of that class will have.

Syntax:

class ClassName:

    # class attributes

    attribute1 = value1

    attribute2 = value2

    # class methods

    def method1(self):

        # method code

    def method2(self):

        # method code

Object: An object is an instance of a class. It has its own set of attributes and methods that were defined in the class.

Syntax:

# create an object of class ClassName

object_name = ClassName()

Method: A method is a function that is defined inside a class and can be called on an object of that class.

Syntax:

# call method1 on object_name

object_name.method1()

Attribute: An attribute is a variable that is defined inside a class and can be accessed by objects of that class.

Syntax:

# access attribute1 of object_name

object_name.attribute1

Inheritance: Inheritance is a mechanism in which a new class is created from an existing class. The new class, called the subclass or derived class, inherits the attributes and methods of the existing class, called the superclass or base class.

Syntax:

# create a subclass of superclass

class SubclassName(SuperclassName):

    # subclass attributes

    attribute3 = value3

    # subclass methods

    def method3(self):

        # method code

Polymorphism: Polymorphism is the ability of objects of different classes to be used interchangeably. It allows the same method to be called on different objects, and the behavior of the method will depend on the object it is called on.

Syntax:

# create two objects of different classes

object1 = ClassName1()

object2 = ClassName2()

# call the same method on both objects

object1.method()

object2.method()

These are some of the key concepts and syntax used in Python for OOP. By using OOP concepts, you can write modular and reusable code that is easier to maintain and understand.

Read More

Top 5 examples of Python decorators:

 @staticmethod: This decorator is used to define a static method in a class. A static method is a method that can be called on the class itself rather than on an instance of the class. Here's an example:

class MyClass:

    @staticmethod

    def my_static_method():

        print("This is a static method")

@classmethod: This decorator is used to define a class method in a class. A class method is a method that takes the class itself as its first argument rather than an instance of the class. Here's an example:

class MyClass:

    class_var = "Hello"

    

    @classmethod

    def my_class_method(cls):

        print(cls.class_var)

@property: This decorator is used to define a method as a property of a class. Properties allow you to access and set the value of an attribute of an instance of the class without explicitly calling a getter or setter method. Here's an example:

class MyClass:

    def __init__(self):

        self._x = 0

        

    @property

    def x(self):

        return self._x

    

    @x.setter

    def x(self, value):

        if value < 0:

            raise ValueError("Value must be non-negative")

        self._x = value

@log_calls: This decorator can be used to log all calls to a function. Here's an example:

def log_calls(func):

    def wrapper(*args, **kwargs):

        print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")

        result = func(*args, **kwargs)

        print(f"Finished {func.__name__}")

        return result

    return wrapper

@log_calls

def my_function(x, y):

    return x + y

@cache: This decorator can be used to cache the results of a function so that the function doesn't need to be called again with the same arguments. Here's an example:

def cache(func):

    results = {}

    def wrapper(*args):

        if args in results:

            return results[args]

        result = func(*args)

        results[args] = result

        return result

    return wrapper

@cache

def fibonacci(n):

    if n < 2:

        return n

    return fibonacci(n-1) + fibonacci(n-2)

Read More

5 awesome hidden features in Python

 Walrus operator (:=): This operator allows you to assign and return a value in the same expression. It can be particularly useful in list comprehensions or other situations where you need to assign a value to a variable and use it in a subsequent expression. Here's an example:

if (n := len(my_list)) > 10:

    print(f"List is too long ({n} elements, expected <= 10)")

Extended Iterable Unpacking: This feature allows you to unpack an iterable into multiple variables, including a "catch-all" variable that gets assigned any remaining items in the iterable. Here's an example:

first, *middle, last = my_list

In this example, first is assigned the first item in my_list, last is assigned the last item, and middle is assigned all the items in between.

Underscore as a placeholder: In interactive Python sessions, you can use the underscore (_) as a shorthand for the result of the last expression. This can be useful if you need to reuse the result of a previous command. Here's an example:

>>> 3 * 4

12

>>> _ + 5

17

slots attribute: The __slots__ attribute allows you to define the attributes of a class and their data types in advance, which can make the class more memory-efficient. Here's an example:

class MyClass:

    __slots__ = ("x", "y")

    

    def __init__(self, x, y):

        self.x = x

        self.y = y

In this example, we are defining a class with two attributes (x and y) and using the __slots__ attribute to define them in advance.

Callable instances: In Python, instances of classes can be made callable by defining a __call__ method. This can be useful if you want to create objects that behave like functions. Here's an example:

class Adder:

    def __init__(self, n):

        self.n = n

        

    def __call__(self, x):

        return self.n + x

    

add_five = Adder(5)

result = add_five(10)

print(result)  # Output: 15

In this example, we are defining a class Adder that takes a number n and defines a __call__ method that adds n to its argument. We then create an instance of Adder with n=5 and use it like a function to add 5 to 10, resulting in 15.

Read More

Creating a LOG IN form by taking image in background

In this we are going to make a Log_In form in which login filling options will be in a transparent box. And you can add your own background image also. 

Note*:- TO change the background go inside the style tag. Inside style tag go to the body and in background-image change the address of the url , give the address of the image which you want to keep in your background. Now,your image will be display on background.

 CODE:-

LOG IN

Username

Password


Foget Password?

 

  <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>LOG_IN_FORM</title>
    <style>
body{
    background-image: url('/images/flower.jpg');
    background-position-x: center;
    background-size: cover;
}
.container{
    text-align: center;
    padding: 28px ;
    margin-left: 30%;
    margin-right: 30%;
    background-color: rgb(238, 192, 234);
    border-radius: 20px;
    display: block;
    box-shadow: 0 15px 20px rgba(0,0,0,.2);
    opacity: 0.8;
}
.txt{
    background-color: rgba(223, 210, 227, 0.9);
    border-radius: 25px;
    opacity: 0.9;
    margin-left: 30%;
    margin-right: 30%;
    text-align: center;
    font-family:cursive;
    font-size:xx-large;
    
}
input[type=text] , input[type=password]
{
    width: 350px;   
    margin: 8px 0;
    padding: 12px 20px;   
    display: inline-block ;   
    border: 2px solid skyblue;
    border-radius: 9px;
    box-sizing: border-box ;
    
}
button{
    background-color: #c120ac;   
         width: 30%;  
         border-radius: 20px;
          color: black;   
          padding: 15px;   
          margin: 10px 0px;   
          border: none;   
          cursor: pointer;
}
button:hover{
    opacity: 0.7;
}
    </style>
</head>
<body>
    <h2 class="txt">
 LOG IN
    </h2>
    <form action="login.php">
        <div class="container">
            <label>Username</label> <br>
            <input type="text" name="username" placeholder="Enter Your Username" required> <br>
            <label >Password</label> <br>
            <input type="password" name="password" placeholder="Enter Your Password" required> <br>
            <button  type="submit">LOG IN</button>
            <button  type="reset">SIGN UP</button> <br>
            <a href="#">Foget Password?</a>

        </div>
    </form>
</body>
</html>

 OUTPUT:-The image in background is what I have selected in background you can choose your own it will be displayed like this only and you can change the colour of the box also inside the style tag in .txt and .container.

Read More

Fancy Hover Buttons in HTML using CSS

 In this we are going to add three types of hover button styles which will make your buttons very innovative and attractive.

1.Border Pop

2.Background Slide

3.Background Circle

 Code:-

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Fancy Buttons</title>
    <style>
        * ,*::before ,*::after{
            box-sizing: border-box;
        }
        body{
            display: flex;
            justify-content: center;
            align-items: center;
            flex-wrap: wrap;
            margin: 0;
        }
        button{
            margin: 1rem;
        }
        .btn{
            background-color: var(--background-color);
            color: #222;
            padding: .5em 1em;
            border: none;
            outline: none;
            position: relative;
            cursor: pointer;

            --background-color: #E3E3E3;
            --border-size:2px;
            --accent-color: #0af;
        }
        .btn.btn-border-pop::before{
            content: "";
            position: absolute;
            top: 0;
            left: 0;
            right: 0;
            bottom:0;
            z-index: -1;
            border: var(--border-size) solid var(--background-color);
            transition: top,left,right,bottom,100ms ease-in-out;
        }
        .btn.btn-border-pop:hover::before,
        .btn.btn-border-pop:focus::before{
            top: calc(var(--border-size)* -2);
            left: calc(var(--border-size)* -2);
            right: calc(var(--border-size)* -2);
            bottom: calc(var(--border-size)* -2);
        }
        .btn.btn-background-slide::before{
            content: "";
            position: absolute;
            top: 0;
            left: 0;
            right: 0;
            bottom: 0;
            background-color: var(--accent-color);
            z-index: -1;
            transition: transform 300ms ease-in-out;
            transform: scale(0);
            transform-origin: left;   
        }
        .btn.btn-background-slide:hover::before,
        .btn.btn-background-slide:focus::before{
        transform: scale(1);

        }

        .btn.btn-background-slide{
            z-index: 1;
            transition: color 300ms ease-in-out;
        }
        .btn.btn-background-slide:hover,
        .btn.btn-background-slide:focus{
            color: white;
        }
        .btn.btn-background-circle::before{
         content: "";
         position: absolute;
         top: 0;
         left:0;
         right:0;
         bottom: 0;
         z-index: -1;
         background-color: var(--background-color);
         border-radius: 50%;
         transition: transform 500ms ease-in-out;

         transform: scale(1.5);
        }
        .btn.btn-background-circle:hover::before,
        .btn.btn-background-circle:focus::before{
         transform:scale(0);
        }


        .btn.btn-background-circle{
            z-index:1;
            overflow: hidden;
            background-color: black;
            transition: color 500ms ease-in-out;
        }
        .btn.btn-background-circle:hover,
        .btn.btn-background-circle:focus{
              color: white;
        }

        .btn.btn-border-underline::before {
            content: "";
            color: brown;
            position: absolute;
            left: 0;
            right: 0;
            bottom: 0;
            height: var(--border-size);
            background-color: var(--accent-color);
            transform: scaleX(0);
        }

    </style>
</head>
<body>
    <button class="btn btn-border-pop">Border Pop</button>
    <button class="btn btn-background-slide">Background Slide</button>
    <button class="btn btn-background-circle">Background Circle</button>
   
</body>
</html> 

Output:-

Read More

Python Quiz | Day 40 | What is the output of following code ?

 Python Quiz | Day 40 | What is the output of following code ?

Complete Playlist : https://bit.ly/3GLnZPy

Read More

Python Quiz | Day 37 | What is the output of following code ?

 

Python Quiz | Day 37 | What is the output of following code ?

Complete Playlist : https://bit.ly/3GLnZPy

Read More

Python Quiz | Day 35 | What is the output of following code ?

 

Complete Playlist : https://bit.ly/3GLnZPy

Solution: 

Answer: D. Explanation:

The list.pop method removes an element from the list, and returns the removed element.

When used without arguments, pop removes and returns the last element of the list.

When an argument index is specified, 

li.pop(index) removes the element li[index] from li, and returns the removed element.

When li.pop(1) is executed, li[1] is removed from li, and the removed value is returned.

Here li[1] is 3. Therefore, li is modified to [2,1], and the return value from li.pop(1) is 3

Read More

Lazy Operators 🥱 --- Python

Introduction

Python is a great language to learn, but it can be hard to pick up if you’ve never programmed before. A lot of the syntax and functions are pretty weird when compared to other languages like JavaScript, Ruby or Java. Luckily, Python has some helpful built-in functions that make it easier for beginners to get started learning programming. In this blog post we will take a look at some of these functions and how they can help us become more efficient programmers in our daily lives!

#Guess the output in this case?

The following Python code is an example of lazy operators. This section shows how to use them in your own programs, but we will first use the examples provided by the python documentation:

• print(all([])) - returns all items from a list (or other iterable), without necessarily creating any copies. It's like calling len() on a list and then getting its length.

• print(any([])) - returns true if at least one item in a list satisfies some condition . For example, if you want to know whether there are any numbers greater than 10 inside [10], then it would be easier just to test each number one by one rather than doing this whole loop thingy....

print(all([]))

You can use the all() function to print all of the elements in a list. For example, this will print all numbers in the range:

print(all([1, 2, 3]))

If you want to print only one element from the list, you can use an index:

print(all(1))

print(any([]))

print(any([]))

The first line of code is the same as above, but in Python it looks for a false element. The algorithm looks for the first occurrence of a true element and, if none were found, returns False. Since the sequence is empty, there are no elements that can be true so this runs through and prints False

Explanation :

The first thing that you need to know about lazy operators is that they are lazy. This means that when we use them, we can only get the result at a later time. Here's an example:

```python

print(all([]))

print(any([]))

```The first two lines print out all elements in their operands but do not return any values, because there are no true cases present in those expressions yet. If you were expecting a set or list of tuples as an answer from these expressions and wanted to see if an element existed before returning false, then it would work just fine with these operators -- but what if I told you there was another way?

"""Function all() is a little complicated,

"""Function all() is a little complicated, but you already know how it works.

It accepts one argument and returns a list containing the items in the reversed order. This can be useful for doing things like summing up numbers or sorting them by value. It's also useful for making sure that only unique values are present in your data structures (e.g., if you have an array of dictionaries and one of them contains duplicate keys).

The problem with this function is that it requires more memory than necessary because we don't need to keep track of what order our results will be returned in; they'll always be sorted automatically by Python when they come back from our function call! That means there's no reason not removing those extra elements from both sides before feeding them into any other operation such as filter().

since it represents the concept of vacuous truth.

Since it represents the concept of vacuous truth, the all() function returns True if all elements are true. The any() function returns True if any element is true.

Like with chained lazy logical operators,

If you're looking for the first non-false element, then all([]), like lazy operators, is a function that returns True when provided with any other value.

However, since there are no false elements in an empty sequence (and since Python doesn't have built-in logic to check for nulls), print(all([])) prints True:

print([])

the algorithm is to look for the first false element,

The algorithm is to look for the first false element and, if none were found, return True. If any element of the iterable is true, then return True.

The following code snippet demonstrates how this works in Python:

and if none were found then return True.

The if statement is one of the most useful features in Python. It allows you to check whether or not an element is true, and if none were found then return True.

The following code:

if x > 0 and y < 10:

yields this output: True

Since there are no false elements in an empty sequence, print(all([])) prints True.

Since there are no false elements in an empty sequence, print(all([])) prints True.

However, there is another way to achieve this effect: we can simply use the bool() function! The boolean value of x is true if x is equal to true or false (or any other value that Python determines as being truthy). Using this check for equality will return a boolean result when called on a list containing only one element.

In function any(), it will return True if any element of the iterable is true.

The function any() is the opposite of all(). It will return True if any element in the iterable is true.

If we pass an empty list, no elements will be returned by this function.

For example:

```python print(["Hello", "World"]) # [1] print([]).any() # True```

Logical operators in Python are lazy! The algorithm looks for the first

The first thing that you need to know about lazy operators in Python is that they are the ones that evaluate only when necessary.

The example above shows how logical operators work: the first one to be evaluated is any(), which evaluates to True and then all() evaluates to True, since there are no false elements in the list. If we had another list with three elements and processed it like this (using ** operator), we would have got an empty list back! You might have noticed another thing here—that's right, both operands must be lists!

occurrence of a true element and, if none were found, returns False,

The first true element is found, and if none were found, returns False.

If you have a list of lists , then this means that it's false for every single element in the list. This can be useful for testing whether a given value is true or false (or both). For example:

>>> L = [True, False] # create an empty list

>>> L[0].append(True) # append some values to the beginning of our original list

You'll get back True!

Since the sequence is empty, there are no elements that can be true,

Since the sequence is empty, there are no elements that can be true. So, all() evaluates its argument immediately and returns True.

On the other hand, any() evaluates its argument only when you call it. This means that if you call any() with a sequence containing an element that does not exist in your dataset (for example if we were to create an empty list), then it would return False since there is nothing else for it to consider as true or false.

therefore print(any([]))prints False."""

The truth is that print(any([]))prints False."""

The reason this works is because the equality operator == returns True if both operands are equal. Therefore, any() will return True only if all elements of the iterable are true. So when we pass an empty list to any(), it will return True and then print() will print out “False” in our console!

Conclusion

Python is a dynamic, interpreted language that encourages you to think as you code. It has an elegant syntax that is easy to learn, even for complete beginners. Although it has a reputation for being slow and complicated, Python’s simplicity and dynamic nature make it an ideal language for data science projects. You can use Python to explore machine learning techniques or build web apps from scratch without having any technical knowledge of programming languages like Java or C++!

https://youtu.be/UAhDtGhx6EA

Read More

Day 103 : Where math doesn’t work again! -- Python

 

#Guess the output in this case?

a=(1 << 53)+1

print(a+1.0 > a)

#???

Read More

Day 102 : Convert CSV to JSON

 

import pandas as pd

import csv,json

data=pd.read_csv("Instagram.csv")

print(data)

print("Converted JSON file below :")

print (json.dumps(list(csv.reader(open('Instagram.csv')))))

#clcoding.com

Impressions  Home  Hashtags  Explore  Other  Saves

0         3920  2586      1028      619     56     98

1         5394  2727      1838     1174     78    194

2         4021  2085      1188        0    533     41

3         4528  2700       621      932     73    172

Converted JSON file below :

[["Impressions", "Home", "Hashtags", "Explore", "Other", "Saves"], ["3920", "2586", "1028", "619", "56", "98"], ["5394", "2727", "1838", "1174", "78", "194"], ["4021", "2085", "1188", "0", "533", "41"], ["4528", "2700", "621", "932", "73", "172"]]

​

Read More