Scribd
Upload
2 views

Python Notes Day 6

The document discusses lists and tuples in Python, highlighting that lists are mutable and use square brackets, while tuples are immutable and use parentheses. It covers key operations for lists, including appending and removing elements, as well as indexing and slicing techniques. Additionally, it introduces list comprehension for concise list creation and explains tuple packing and unpacking for managing multiple values.

Uploaded by

manikanta
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

Python Notes Day 6

The document discusses lists and tuples in Python, highlighting that lists are mutable and use square brackets, while tuples are immutable and use parentheses. It covers key operations for lists, including appending and removing elements, as well as indexing and slicing techniques. Additionally, it introduces list comprehension for concise list creation and explains tuple packing and unpacking for managing multiple values.

Uploaded by

manikanta
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 11

Today’s Topics:

list and Methods


Indexing and Slicing
List Comprehension
Tuples
Tuples packing,and unpacking

By @Curious_.programmer
Lists and Tuples
Lists and tuples in Python both store collections of items.
Lists are mutable, allowing changes like adding or removing
elements, and use square brackets (`[ ]`).

Tuples are immutable, meaning they can't be modified after


creation, and use parentheses (`( )`). Use lists for dynamic
data and tuples for fixed collections.

Lists and Methods


Lists in Python are ordered, mutable collections used to
store multiple items in a single variable. They are defined
using square brackets ([ ]) and can contain elements of
different data types, such as integers, strings, or even other
lists.
You can add, remove, or modify elements within a list,
making them highly versatile for managing dynamic
datasets.

Key Features:

Mutable: Elements can be changed, added, or removed.


Ordered: Elements have a defined order, and you can
access them using indices, starting from 0.
Basic Operations:

Create a list: my_list = [1, 2, 3, 4]


Access elements: my_list[0] (returns 1)
Modify elements: my_list[1] = "new_value"
Append elements: my_list.append(5)
Remove elements: my_list.remove(2) (removes the first
occurrence of 2)

1. append()
Adds a single element to the end of the list.
Syntax: list.append(element)
2. extend()
Extends the list by appending elements from an iterable
(like another list).
Syntax: list.extend(iterable)

3. insert()
Inserts an element at a specified position in the list.
Syntax: list.insert(index, element)

4. remove()
Removes the first occurrence of a specified element from
the list.
Syntax: list.remove(element)
5.pop()
Removes and returns the element at a specified position
(index). If no index is specified, it removes and returns
the last element.
Syntax: list.pop(index)

Indexing

Indexing in Python refers to accessing individual elements


within a sequence, such as a list, tuple, string, or other
iterable objects.

Each element in a sequence is assigned a numerical index,


starting from 0 for the first element and increasing by 1 for
each subsequent element.

Key Points:

1.Positive Indexing:

The first element has an index of 0.


The second element has an index of 1, and so on.
2. Negative Indexing:

Allows you to access elements from the end of the


sequence.
The last element has an index of -1, the second last is
-2, and so on.

3. Indexing in Strings:

Indexing works similarly with strings, where each character


has an index.

4. Out-of-Range Index:

Accessing an index that is beyond the length of the sequence


raises an IndexError.

Slicing

Slicing in Python is a technique used to access a subset of


elements from sequences like lists, tuples, or strings.

It allows you to retrieve a portion of the sequence by


specifying a start, stop, and optional step index.
start: The index where the slice begins (inclusive). If
omitted, it defaults to the beginning of the sequence
(0).
stop: The index where the slice ends (exclusive). If
omitted, it defaults to the end of the sequence.
step: The step size or interval between elements in
the slice. If omitted, it defaults to 1.

List Comprehension

List comprehension is a concise and powerful feature in


Python that allows you to create lists in a single line of
code.

It combines the process of creating and populating a list


with an expression and, optionally, one or more loops
and conditions.

Syntax:
expression: The value or operation applied to each item.
item: The variable representing the current element in the
iteration.
iterable: The collection (like a list, tuple, or range) that you
are iterating over.
condition: (Optional) A filter that decides whether the
expression should be applied to the current item.

Benefits of List Comprehension:

Concise: It reduces the lines of code needed to create


and populate lists.
Readable: Once you get familiar with the syntax, it can
be easier to read and understand.
Efficient: It often runs faster than traditional for-loop
approaches due to its optimized implementation.

Tuples and their Immutabilty

Tuples in Python are ordered collections of items, similar


to lists, but with one key difference: tuples are immutable.
This means that once a tuple is created, its elements
cannot be modified, added, or removed. This immutability
makes tuples useful for representing fixed data that
should not change throughout the program.
Key Features of Tuples:

Ordered: Like lists, tuples maintain the order of elements,


and you can access elements by their index.

Immutable: Once a tuple is created, you cannot change


its content. This includes:

Modifying elements: You cannot change the value of any


item in the tuple.

Adding elements: You cannot append or insert new items.

Removing elements: You cannot remove items from a


tuple.

Defined with Parentheses: Tuples are created by placing a


sequence of values separated by commas inside
parentheses (()).

Tuples Packing and Unpacking

Tuple packing and unpacking are two related concepts in


Python that make working with tuples more convenient
and intuitive.
Tuple Packing:
Tuple packing refers to the process of assigning multiple
values to a single tuple variable.

When you place multiple values separated by commas into a


variable, Python automatically packs them into a tuple.

Tuple Unpacking:
Tuple unpacking is the reverse process, where the values in a
tuple are extracted and assigned to individual variables.

The number of variables on the left must match the number


of elements in the tuple.
for Handwritten Notes Search
“CodeWithCurious Store” on Google

CodeWithCurious Store

You might also like