Скачать или смотреть Python|datatypes part-3

In Python, sequence data types are used to represent an ordered collection of elements. These elements can be of any data type, and each element in the sequence has an assigned index. Here are the main sequence data types in Python:

1. Strings (`str`):

Strings represent sequences of characters and are enclosed in single (`'`) or double (`"`) quotes.

```python
my_string = "Hello, World!"
```

Strings support various methods for text manipulation and are immutable, meaning you can't change individual characters in-place.

2. Lists (`list`):

Lists are ordered and mutable collections that can contain elements of different data types.

```python
my_list = [1, 2, 3, "apple", "banana"]
```

You can modify, add, or remove elements in a list using various list methods.

3. Tuples (`tuple`):

Tuples are ordered and immutable collections, often used to represent fixed collections of elements.

```python
my_tuple = (1, 2, 3, "apple", "banana")
```

Once a tuple is created, you cannot modify its elements. Tuples are useful for situations where data should remain constant.

Common Operations on Sequences:

*Indexing:*
Access individual elements using their index. Indexing starts from 0.

```python
my_string[0] # 'H'
my_list[2] # 3
my_tuple[4] # 'banana'
```

*Slicing:*
Extract a portion of the sequence using the slicing notation (`start:stop:step`).

```python
my_string[1:5] # 'ello'
my_list[:3] # [1, 2, 3]
my_tuple[2:] # (3, 'apple', 'banana')
```

*Concatenation:*
Combine two or more sequences.

```python
combined_list = my_list + [4, 5, 6]
combined_string = my_string + " How are you?"
```

*Repetition:*
Repeat a sequence a certain number of times.

```python
repeated_list = my_list * 2
repeated_string = my_string * 3
```

*Membership Testing:*
Check if an element is present in the sequence.

```python
2 in my_list # True
'z' not in my_string # True
```

*Length:*
Get the number of elements in the sequence.

```python
len(my_tuple) # 5
```

These sequence data types provide flexibility for handling different types of data and are fundamental in Python programming. Understanding their characteristics and operations helps in efficient data manipulation and processing.