```
sentence = "Hello, 1Cademy!
first_char = sentence[0]    # python is zero-indexed 
last_char = sentence[-1]   # a negative index counts from the back of the sequence, one-indexed

print(sentence[4])    # prints 'o'
print(sentence[-3])   # prints 'm'
```

Indexing examples

Strings are created in Python by surrounding text in single, double, or triple quotes. They are arrays of bytes which represent Unicode characters. 

Unlike languages such as Java and C++, there isn't a character data type and therefore, to represent 1 character you would have a string with length 1.

Strings

In Python, a sequence refers to any ordered set. This includes strings, lists and tuples. All sequences can be sliced, indexed into, and are iterable.

University of Michigan - Ann Arbor

University of Illinois at Urbana-Champaign

Values can be classified into different classes, known as data types:
- Integer (int) - 1, 4, 7, 24, 578, etc.
- Float (float) - 2.2, 2.59, 3.14159, etc.
- String (str) - *Any combination of characters in quotes
- List (list) - An ordered, mutable collection of items
- Tuple (tuple) - An ordered, immutable collection of items
- Dictionary (dict) - An unordered collection of data with keys and values
- Boolean (bool) - True or False
 
The terms "data type" and "class" are often used interchangeably.

Data Types in Python

https://runestone.academy/runestone/books/published/fopp/index.html

Runestone: Foundations of Python Programming

Use the ```type()``` function to get the type of an object in Python. 
For example, 
```print(type(4))``` 
outputs ```<class 'int'>```.

Getting the type of an object

- Expressions are any combination of data types to be evaluated. Evaluating an expression results in values/objects. Expressions can also be evaluated into or set to values. 
- Asking Python to print an expression will result in the interpreter attempting to evaluate the expression and display the result

Expressions in Python 

Sequences

An object is mutable if its data can be changed after initialization. Inversely, an object is immutable if its data cannot be changed after creation. Lists are mutable, and tuples are immutable. This makes lists better suited for data which we anticipate will be modified. However, tuples (but not lists) can serve as dictionary keys. In addition to lists, dictionary objects are also mutable.

In Python, most data types are immutable, such as integers, floats, strings, tuples and booleans. Immutable data types are faster to use in code, but their values can only be changed by creating a copy of the object to be altered. 

Mutability

In Python, the type() function is used to return the class (data type) of an object. For example:
```python
print(type(66))
print(type("hello there"))
print(type(["General", "Kenobi"]))
```
will print:
<class 'int'>
<class 'str'>
<class 'list'>

type() Function

In Python, lists are indexed collections, so they can contain multiple items with the same value; duplicates are allowed. For example, a list can hold the string "cherry" twice without raising an error. Permitting duplicate members is a defining property of lists (and tuples), unlike sets, which store only unique members.

Duplicate Values in a List

If you want to specify the data type of an object, you can use constructor functions like str(), float(), list(), and tuple().

Example:
x = list(("apple", "banana", "cherry"))

The example above will turn the sequence into a list

Assigning a Python Object to Have a Certain Type

Python has 4 collection data types:
- lists - Ordered, mutable collection of items allowing duplicate members
- tuples - Ordered, immutable collection of items allowing duplicate members
- sets - Unordered, unindexed collection of items not allowing duplicate members
- dictionaries - Ordered, mutable collection of items not allowing duplicate members


Python Collections

Data types in a program are likely to be allocated into memory when encountered in a program. Python's interpreter includes the Python memory manager, which handles how data types are stored and tracked in memory. The user has no control over this process. Memory allocation for each new variable is performed on demand by the Python memory manager automatically.

Memory Allocation

While Python natively provides built-in data types such as booleans, floats, and integers, NumPy offers additional specialized data types. These are often referred to by single-character codes:
- `i`: integer
- `b`: boolean
- `u`: unsigned integer
- `f`: float
- `c`: complex float
- `m`: timedelta
- `M`: datetime
- `O`: object
- `S`: string
- `U`: unicode string
- `V`: void (fixed chunk of memory for other types)

Learn Before

Related

Learn After