Forem: Samita Khanduri

Getting Started with GitLab: Sign-In Guide and Beginner Tips

Samita Khanduri — Fri, 07 Feb 2025 12:42:53 +0000

Introduction

GitLab is a powerful DevOps platform that provides Git repository management, CI/CD pipelines, issue tracking, and more. It is widely used by developers for version control and project collaboration. This article will guide you on how to sign in to GitLab and provide useful tips for beginners.

How to Sign In to GitLab

Step 1: Access the GitLab Website

Go to the official GitLab website: https://gitlab.com

Step 2: Click on Sign In

On the homepage, click on the Sign In button located at the top-right corner.

Step 3: Enter Your Credentials

If you already have an account, enter your username or email and password.
If you have enabled two-factor authentication (2FA), enter the authentication code.
Click Sign in to access your dashboard.

Step 4: Sign In with Third-Party Accounts (Optional)

You can also sign in using third-party authentication services like:

Google
GitHub
Bitbucket
Azure Active Directory

Simply click the corresponding sign-in button and authorize GitLab to access your account.

Step 5: Sign Up for a New Account (If You Don’t Have One)

If you don’t have a GitLab account, click Register and fill in the required details to create a new account.

GitLab Tips for Beginners

1. Create and Clone a Repository

To create a new repository, go to Projects > New Project and follow the prompts.
To clone a repository, use the command:

  git clone <repository_url>

2. Learn Basic Git Commands

Understanding basic Git commands will help you manage your project efficiently:

git status – Check the status of your working directory.
git add . – Add all changes to the staging area.
git commit -m "your commit message" – Commit changes with a message.
git push origin main – Push your commits to the main branch.

3. Use Issues and Merge Requests

Issues help track bugs, enhancements, or any tasks related to your project.
Merge Requests (MRs) are used to review and merge changes into the main branch.

4. Explore GitLab CI/CD

GitLab has built-in Continuous Integration and Continuous Deployment (CI/CD) features. You can automate your testing and deployment by adding a .gitlab-ci.yml file to your repository.

5. Customize Your Profile

Go to Profile Settings to update your avatar, bio, and preferences.
Enable notifications to stay updated on project activities.

6. Leverage GitLab Wikis and Documentation

GitLab offers built-in wikis for project documentation. You can also refer to GitLab’s official documentation for advanced features and troubleshooting.

Conclusion

GitLab is an essential tool for developers and teams looking to streamline their workflow. By following these sign-in steps and beginner tips, you can efficiently manage your repositories and collaborate with your team. Happy coding!

Understanding Python Decorators: A Beginner’s Guide with Examples

Samita Khanduri — Mon, 27 Jan 2025 06:36:33 +0000

Understanding Python Decorators: A Beginner’s Guide with Examples

Python decorators are a powerful and versatile tool for modifying the behavior of functions or methods. They allow you to add functionality to existing code without altering its structure. In this article, we’ll break down decorators and provide simple examples to help you understand and use them effectively.

What are Decorators?

A decorator in Python is essentially a function that takes another function as an argument and extends or alters its behavior. Decorators are commonly used to add features like logging, access control, memoization, or validation to existing functions or methods.

Decorators in Python are applied using the @decorator_name syntax placed above the function definition.

Anatomy of a Decorator

A basic decorator function has the following structure:

def decorator_function(original_function):
    def wrapper_function(*args, **kwargs):
        # Code to execute before the original function
        result = original_function(*args, **kwargs)
        # Code to execute after the original function
        return result
    return wrapper_function

Applying a Decorator

You can apply a decorator to a function using the @decorator_name syntax or manually:

@decorator_function
def some_function():
    print("This is the original function.")

# Equivalent to:
# some_function = decorator_function(some_function)

Example 1: A Basic Decorator

Let’s create a simple decorator that prints a message before and after a function runs.

def simple_decorator(func):
    def wrapper():
        print("Before the function call.")
        func()
        print("After the function call.")
    return wrapper

@simple_decorator
def say_hello():
    print("Hello, World!")

say_hello()

Output:

Before the function call.
Hello, World!
After the function call.

Example 2: A Decorator with Arguments

You can create a decorator that accepts arguments by wrapping it in another function.

def repeat_decorator(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat_decorator(3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

Output:

Hello, Alice!
Hello, Alice!
Hello, Alice!

Real-Life Applications of Decorators

Decorators are extensively used in real-world scenarios. Here are some simplified practical examples:

1. Logging User Actions

You can use a decorator to log every time a user performs an action.

def log_action(func):
    def wrapper(*args, **kwargs):
        print(f"Action: {func.__name__} is being performed.")
        return func(*args, **kwargs)
    return wrapper

@log_action
def upload_file(filename):
    print(f"Uploading {filename}...")

upload_file("report.pdf")

Output:

Action: upload_file is being performed.
Uploading report.pdf...

2. Tracking Execution Time

Track how long tasks take to execute, useful for performance monitoring.

import time

def track_time(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.2f} seconds to execute.")
        return result
    return wrapper

@track_time
def download_file(file_size):
    time.sleep(file_size / 10)  # Simulate download time
    print("Download complete.")

download_file(50)

Output:

Download complete.
download_file took 5.00 seconds to execute.

3. Adding User Greetings

A decorator can personalize greetings by adding dynamic elements.

def add_greeting(func):
    def wrapper(name):
        print("Hello, welcome!")
        func(name)
    return wrapper

@add_greeting
def show_user_profile(name):
    print(f"User Profile: {name}")

show_user_profile("Alice")

Output:

Hello, welcome!
User Profile: Alice

Key Takeaways

Decorators are a powerful way to modify the behavior of functions or methods.
They can simplify repetitive tasks like logging, timing, or personalization.
Use the @decorator syntax to apply them conveniently.
Decorators can accept arguments and be nested for added flexibility.

By mastering decorators, you’ll unlock a valuable tool for writing clean and efficient Python code. Start experimenting with the examples provided to get comfortable with this concept!

Functions in Python: Exploring Tuple Unpacking

Samita Khanduri — Wed, 22 Jan 2025 12:30:01 +0000

Functions in Python are the building blocks of modular and reusable code. They enable developers to break down complex tasks into manageable pieces. One highly practical aspect of Python functions is tuple unpacking. Let's explore this concept in detail.

What is a Function?

A function is a reusable block of code designed to perform a specific task. Functions help in organizing code, reducing repetition, and improving readability. Functions can take inputs (parameters), perform operations, and return outputs.

Defining and Using a Function

Here is the basic syntax for defining a function in Python:

# Defining a function
def greet(name):
    return f"Hello, {name}!"

# Using the function
message = greet("Alice")
print(message)

In this example:

greet is the function name.
name is a parameter that the function takes as input.
The function returns a greeting message using the input name.

Function and Tuple Unpacking

Tuple unpacking is a feature in Python that allows you to assign multiple values from a tuple (or any iterable) to a corresponding number of variables in a single statement. This feature becomes particularly powerful when used in functions, enabling concise and readable code.

Tuple Unpacking in Function Arguments

When functions return multiple values as a tuple, you can unpack these values directly when calling the function. For instance:

# Function returning multiple values as a tuple
def calculate_stats(numbers):
    total = sum(numbers)
    average = total / len(numbers)
    return total, average

# Unpacking the tuple into variables
data = [10, 20, 30, 40]
total, average = calculate_stats(data)
print(f"Total: {total}, Average: {average}")

This concise unpacking eliminates the need for accessing tuple elements using indices, enhancing code readability and reducing errors.

Passing Tuples to Functions Using Unpacking

The unpacking operator * can be used to pass the contents of a tuple (or list) as arguments to a function. Here's an example:

# Function accepting multiple arguments
def greet(name, age, city):
    return f"Hello {name}, age {age}, from {city}!"

# Tuple containing arguments
args = ("Alice", 30, "New York")

# Unpacking tuple into function arguments
message = greet(*args)
print(message)

By using the unpacking operator, the tuple's elements are seamlessly mapped to the function's parameters.

Real-World Applications of Tuple Unpacking

Tuple unpacking is not just a theoretical concept; it has numerous practical applications in real-world programming. Here are some scenarios:

1. Swapping Variables

Tuple unpacking allows you to swap the values of two variables without needing a temporary variable:

# Swapping values
x, y = 10, 20
x, y = y, x
print(f"x: {x}, y: {y}")

This one-liner is more elegant and readable than using a temporary variable.

2. Iterating Over Enumerated Data

When using enumerate with loops, tuple unpacking simplifies the process of accessing both the index and the value:

# Iterating with enumerate
data = ["apple", "banana", "cherry"]
for index, value in enumerate(data):
    print(f"Index: {index}, Value: {value}")

3. Returning Multiple Values

Functions often need to return multiple results. Tuple unpacking allows the caller to handle these results conveniently:

# Function with multiple return values
def min_max(numbers):
    return min(numbers), max(numbers)

values = [3, 7, 2, 8, 4]
minimum, maximum = min_max(values)
print(f"Minimum: {minimum}, Maximum: {maximum}")

4. Unpacking Nested Data

Tuple unpacking can be extended to nested structures, making it easier to work with complex data:

# Unpacking nested data
nested_tuple = (1, (2, 3), 4)
a, (b, c), d = nested_tuple
print(f"a: {a}, b: {b}, c: {c}, d: {d}")

5. Processing CSV or Tabular Data

When processing rows of data from a CSV file, tuple unpacking can simplify handling each row:

# Processing rows of tabular data
data = [("Alice", 30, "Engineer"), ("Bob", 25, "Designer")]
for name, age, profession in data:
    print(f"Name: {name}, Age: {age}, Profession: {profession}")

Conclusion

Understanding tuple unpacking is crucial for writing efficient and maintainable Python code. Tuple unpacking simplifies argument passing, return value handling, and operations on complex data structures. By leveraging this feature effectively, you can elevate your Python programming to a new level of proficiency.

Understanding *args and **kwargs in Python

Samita Khanduri — Thu, 16 Jan 2025 13:02:29 +0000

Understanding `*args` and `**kwargs` in Python with Beginner-Friendly Examples

In Python, *args and **kwargs are powerful features that let you create flexible functions that can accept a variable number of arguments. These are especially useful when you don't know in advance how many arguments will be passed to your function.

What is `*args`?

*args allows a function to accept any number of positional arguments. These arguments are stored in a tuple.

Example:

def print_numbers(*args):
    for number in args:
        print(number)

print_numbers(1, 2, 3, 4, 5)

Output:

Here, you can pass as many numbers as you want, and they will all be printed. If no arguments are passed, args will simply be an empty tuple.

What is `**kwargs`?

**kwargs allows a function to accept any number of keyword arguments. These arguments are stored in a dictionary, where the keys are the argument names and the values are their corresponding values.

Example:

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="New York")

Output:

name: Alice
age: 25
city: New York

Here, you can pass as many key-value pairs as you want. If no keyword arguments are passed, kwargs will simply be an empty dictionary.

Combining `*args` and `**kwargs`

You can use both *args and **kwargs in the same function. This allows you to handle both positional and keyword arguments.

Example:

def describe_person(*args, **kwargs):
    print("Attributes:")
    for arg in args:
        print(f"- {arg}")

    print("\nDetails:")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

describe_person("Friendly", "Helpful", name="Bob", age=30, city="Boston")

Output:

Attributes:
- Friendly
- Helpful

Details:
name: Bob
age: 30
city: Boston

Here, *args collects positional arguments (like "Friendly" and "Helpful"), and **kwargs collects keyword arguments (like name="Bob" and age=30).

Simple Rules to Remember

Use *args when you need to pass a variable number of positional arguments.
Use **kwargs when you need to pass a variable number of keyword arguments.
The order in the function signature should always be:
- Regular positional arguments
- *args
- Default keyword arguments
- **kwargs

Practical Examples for Beginners

Example 1: A Function to Add Numbers

def add_numbers(*args):
    total = sum(args)
    print(f"The sum is: {total}")

add_numbers(1, 2, 3, 4)
add_numbers(10, 20)

Output:

The sum is: 10
The sum is: 30

Example 2: Greeting People by Name

def greet_people(**kwargs):
    for name, greeting in kwargs.items():
        print(f"{greeting}, {name}!")

greet_people(Alice="Hello", Bob="Hi", Charlie="Hey")

Output:

Hello, Alice!
Hi, Bob!
Hey, Charlie!

Example 3: Combining `*args` and `**kwargs` in a Shopping List

def shopping_list(*items, **prices):
    print("Items to buy:")
    for item in items:
        print(f"- {item}")

    print("\nPrices:")
    for item, price in prices.items():
        print(f"{item}: ${price}")

shopping_list("Apples", "Bananas", Apples=2, Bananas=1.5, Oranges=3)

Output:

Items to buy:
- Apples
- Bananas

Prices:
Apples: $2
Bananas: $1.5
Oranges: $3

Conclusion

By using *args and **kwargs, you can make your Python functions more dynamic and flexible. This is especially useful when working on programs where the number of inputs might vary. Start experimenting with these features in small projects, and you'll see how handy they can be!

Understanding Lists in Python

Samita Khanduri — Mon, 13 Jan 2025 12:19:33 +0000

What are lists

In Python, lists are one of the most versatile and widely used data structures. They are ordered sequences capable of holding elements of different data types, including integers, floats, strings, and even other lists. This flexibility, combined with their intuitive structure, makes them a cornerstone of Python programming.

Key Features of Lists

Definition and Syntax

Lists are defined using square brackets [], with elements separated by commas.

Example:

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

Heterogeneous Elements Lists can store elements of varying data types. Example:

   mixed_list = [42, "hello", 3.14, True]

Indexing and Slicing Lists support indexing (to access specific elements) and slicing (to extract sublists). Example:

   my_list = [10, 20, 30, 40, 50]
   print(my_list[2])        # Output: 30
   print(my_list[1:4])      # Output: [20, 30, 40]

Nested Lists Lists can be nested, meaning a list can contain other lists as elements. Example:

   nested_list = [1, [2, 3], [4, [5, 6]]]
   print(nested_list[1][1])  # Output: 3

Mutability Lists are mutable, allowing modification of their elements. Example:

   my_list = [1, 2, 3]
   my_list[0] = 10
   print(my_list)  # Output: [10, 2, 3]

Commonly Used List Methods

Python provides several built-in methods to manipulate lists effectively:

Appending Elements To add an element to the end of a list, use the .append() method. Note that only one element can be appended at a time. Example:

   my_list = [1, 2, 3]
   my_list.append(4)
   print(my_list)  # Output: [1, 2, 3, 4]

Removing Elements To remove the last element from a list, use the .pop() method. Example:

   my_list = [1, 2, 3, 4]
   my_list.pop()
   print(my_list)  # Output: [1, 2, 3]

Sorting Elements Use the .sort() method to arrange the elements in ascending order. Example:

   my_list = [4, 2, 3, 1]
   my_list.sort()
   print(my_list)  # Output: [1, 2, 3, 4]

Reversing Elements The .reverse() method inverts the order of elements in a list. Example:

   my_list = [1, 2, 3, 4]
   my_list.reverse()
   print(my_list)  # Output: [4, 3, 2, 1]

Practical Examples

Combining Data Lists are handy for aggregating data of various types.

   student_data = ["Alice", 23, [90, 85, 88]]
   print(f"Name: {student_data[0]}, Age: {student_data[1]}, Scores: {student_data[2]}")

Dynamic List Creation Use loops to generate or modify lists dynamically.

   squares = []
   for i in range(1, 6):
       squares.append(i ** 2)
   print(squares)  # Output: [1, 4, 9, 16, 25]

Working with Nested Data Nested lists allow for hierarchical data organization.

   matrix = [[1, 2], [3, 4], [5, 6]]
   for row in matrix:
       print(row)

Summary

Lists are a powerful and flexible data structure in Python, capable of handling diverse data types and supporting a variety of operations. Their mutability, along with built-in methods for adding, removing, sorting, and reversing elements, makes them indispensable for many programming tasks. Mastering lists is a crucial step in becoming proficient in Python!

Python Strings: Exploring string manipulation methods

Samita Khanduri — Thu, 26 Dec 2024 09:29:50 +0000

Strings in python:

String is a sequence of characters which is encapsulated inside single quotes or double quotes.

For example:

“Hello World”
‘Apple’
"What's that?"

These are what strings look like in python.

Types of strings-

1.Single line string- To write a single lined string we use either single quotes('This is a string') or double quotes("This is also a string").

Example- print('Hello world!)
         print("What's up?")
output- Hello world!
        What's up?

Multi line string- To write a multi lined string we use single triple quotes(''' ''') or double triple quotes(""" """).

Example- 
print("""We have a pet.
He is a dog.""")

output- We have a pet.
        He is a dog.

String Indexing-

Since a string is an ordered sequence, we can perform indexing on it.

Indexing allows us to grab a single character of the string and access it.

Every single character in a string has an indexed position(index) starting from 0 and ending at n-1(where n= number of characters).

H E L L O
0 1 2 3 4

Example-
my_string= “Hello”
print(my_string[3])

output - l

We can also use reverse indexing in python.

H E L L O
0 -4 -3 -2 -1

Example- 

My_string = “Hello”
print(my_string[-4])

Output - e

SLICING

Slicing allows us to grab a subsection of the string(multiple characters) aka a slice of string.

Syntax of slicing- [start:stop:step]
Where start is the numerical index value from where we have to grab the characters.
Stop is the numerical value we will jump to but not include and
Step is the size of the jump we take from start to stop.

Note- To grab all elements of string we use ::

Example-

My_string = “Hello”
print(my_string[2:4])

output- llo

String slicing will always include the starting letter to the letter before the mentioned index (n-1).

STRING PROPERTIES AND METHODS-

IMMUTABILITY- Strings are immutable which means they cannot be changed.

Example- 
name = “Sam”
name[0] = ‘P’

The above code will give an error because we can’t change strings.

CONCATENATION- We can concatenate(merge) two strings using concatenation.

Example- 
x = “Hello”
x  + “ World!”
Output- Hello World!

You can use * to multiply the number of letters.

Example- 
letter = ‘x’
letter * 10
Output- zzzzzzzzzz

Conclusion-

A string is a sequence of characters which is immutable and you can perform indexing and slicing on it because it is an ordered sequence.

Python: what is it? and why is it one of the best languages?

Samita Khanduri — Tue, 24 Dec 2024 15:45:27 +0000

What is python?

Everyone who has tried their hand at learning a programming language have come across python at least once. Python is one of the most recommended programming language and there is a good reason for that.
Python was created by Guido van Rossum and it was first released on February 20, 1991.

Why should you learn python?

There are many reasons that you should learn python and here are some of them-

Easy to understand: Python has very simple syntax. It's almost
like the English language which makes it very easy to understand even for beginners.

Small blocks of code: You can write code for anything in
very few lines in python compared to other programming languages. For example- You can write the code to add two numbers in very few lines in python, meanwhile it would take a very long code in other programming languages to do the same task.

High demand: Python is in very high demand in the job market. It is required in many fields like python development, machine learning, deep learning and many more.

Having basic knowledge of python will also give you huge benefit when it comes to learn some other skills. You would be able to learn basic machine learning easily if you have some knowledge of python beforehand.

Many available libraries: Python has so many libraries available for different kind of tasks. For example- It has numpy for numerical calculations and Pandas for data manipulation.

Open source: Python is an open source programming language which means you can use it for free without paying for a license.

Big online community: There's a big online community of python that you can refer to when in doubt. Python has been around for a long time now so whatever doubt you have, has probably been asked before, which makes learning python even easier than it is.

Conclusion:

At the end of the day, you can start with whatever language you feel most comfortable with. But python has many benefits which makes it a better choice for the beginners. If you are able to learn some basic concepts of programming using python then it would be even easier for you to learn other programming languages with tougher syntax.

Forem: Samita Khanduri

Getting Started with GitLab: Sign-In Guide and Beginner Tips

Introduction

How to Sign In to GitLab

Step 1: Access the GitLab Website

Step 2: Click on Sign In

Step 3: Enter Your Credentials

Step 4: Sign In with Third-Party Accounts (Optional)

Step 5: Sign Up for a New Account (If You Don’t Have One)

GitLab Tips for Beginners

1. Create and Clone a Repository

2. Learn Basic Git Commands

3. Use Issues and Merge Requests

4. Explore GitLab CI/CD

5. Customize Your Profile

6. Leverage GitLab Wikis and Documentation

Conclusion

Understanding Python Decorators: A Beginner’s Guide with Examples

What are Decorators?

Anatomy of a Decorator

Applying a Decorator

Example 1: A Basic Decorator

Example 2: A Decorator with Arguments

Real-Life Applications of Decorators

1. Logging User Actions

2. Tracking Execution Time

3. Adding User Greetings

Key Takeaways

Functions in Python: Exploring Tuple Unpacking

What is a Function?

Defining and Using a Function

Function and Tuple Unpacking

Tuple Unpacking in Function Arguments

Passing Tuples to Functions Using Unpacking

Real-World Applications of Tuple Unpacking

1. Swapping Variables

2. Iterating Over Enumerated Data

3. Returning Multiple Values

4. Unpacking Nested Data

5. Processing CSV or Tabular Data

Conclusion

Understanding *args and **kwargs in Python

Understanding *args and **kwargs in Python with Beginner-Friendly Examples

What is *args?

Example:

What is **kwargs?

Example:

Combining *args and **kwargs

Example:

Simple Rules to Remember

Practical Examples for Beginners

Example 1: A Function to Add Numbers

Example 2: Greeting People by Name

Example 3: Combining *args and **kwargs in a Shopping List

Conclusion

Understanding Lists in Python

What are lists

Key Features of Lists

Commonly Used List Methods

Practical Examples

Summary

Python Strings: Exploring string manipulation methods

Strings in python:

Types of strings-

String Indexing-

SLICING

STRING PROPERTIES AND METHODS-

Conclusion-

Python: what is it? and why is it one of the best languages?

What is python?

Why should you learn python?

Conclusion:

Understanding `*args` and `**kwargs` in Python with Beginner-Friendly Examples

What is `*args`?

What is `**kwargs`?

Combining `*args` and `**kwargs`

Example 3: Combining `*args` and `**kwargs` in a Shopping List