• Strings are arrays of bytes representing Unicode characters
• However, Python does not have a character data type, a single character is simply a string with a length of 1
• Square brackets can be used to access elements of the string.

Basic Operations

    ''' string initialization '''
    # using single quote
    s1 = 'Hi. How are you?'
    # using double quote
    s2 = "Hello. How are you?"
    # using triple quote (multi-line)
    s3 = '''How
            are
            your?'''

    ''' accessing characters '''
    # using positive indexing
    print(s1[0])                                                          # H
    # using negative indexing
    print(s1[-2])                                                         # u

    ''' string slicing '''
    # [start:end] -> end not included
    print(s2[1:9])                                                        # ello. Ho
    print(s2[1:-1])                                                       # ello. How are you

    ''' update/delete character or string '''
    # string can be reinitialized or deleted, but characters cannot be updated/deleted
    s2[0] = "Y"                                                           # TypeError: 'str' object does not support item assignment
    del s2[0]                                                             # TypeError: 'str' object does not support item assignment
    s2 = "Yello. How are your?"                                           # works
    del s2                                                                # works

    ''' escape sequence '''
    # escaping same quote as in string initialization
    s4 = 'I\'m a "student"'                                               # I'm a "student"
    # escaping backquotes
    s5 = "C:\\Python\\bin\\"                                              # C:\Python\bin
    # in hex
    s6 = "This is \x47\x65\x65\x6b\x73 in \x48\x45\x58"                   # This is Geeks in HEX
    # raw string to ignore escape sequence
    s7 = r"This is \x47\x65\x65\x6b\x73 in \x48\x45\x58"                  # This is \x47\x65\x65\x6b\x73 in \x48\x45\x58

    ''' string formatting '''
    # default order
    s8 = "{} {} {}".format('abc', 'bcd', 'cde')                           # abc bcd cde
    # positional formatting
    s9 = "{1} {0} {2}".format('abc', 'bcd', 'cde')                        # bcd abc cde
    # keyword formatting
    s10 = "{b} {a} {c}".format(a='abc', b='bcd', c='cde')                 # bcd abc cde

    ''' number formatting '''
    # integer formatting
    s11 = "{0:b}".format(16)                                              # 10000
    i = 12.3456789
    print('%3.2f' % i)                                                    # 12.35
    print('%3.4f' % i)                                                    # 12.3457
    # float formatting
    s12 = "{0:e}".format(165.6458)                                        # 1.656458e+02
    # rounding off integer
    s13 = "{0:.2f}".format(1/6)                                           # 0.17
    # aligning - left, right and center
    s14 = "|{:<10}|{:^10}|{:>10}|".format('abcd', 'abcd', 'abcd')         # |abcd      |   abcd   |      abcd|
        

• The sequence of values stored in a tuple can be of any type, and they are indexed by integers.
• tuples are created by placing a sequence of values separated by 'comma' with or without the use of parentheses for grouping the data sequence.
• Faster as compared to lists.

    ''' initialization '''
    # empty tuple
    t1 = ()
    # non-empty tuple
    t2 = (10, 'abc')
    # tuple with repetition
    t3 = (0,) * 5              # (0,0,0,0,0)

    ''' accessing tuple elements '''
    # using indexing
    t2[0]                      # 10
    # using tuple unpacking
    a, b = t2                  # a = 10, b = 'abc'

    ''' concatenation '''
    # using +
    t4 = t2 + t3               # (10,'abc',0,0,0,0,0)

    ''' slicing '''
    # similar to list, [start,end,step] - default values: {start: 0, end: len(list); step: 1}
    t4[1,4]                    # ('abc',0,0)

    ''' deleting a tuple '''
    del t1
        

Methods applicable on lists

    t1 = (10,5,1,1,7,1)
    t2 = (True, True, False)
    l1 = [10,5,1]
        

l1.index(1) # 2

l1.count(1) # 3

all(t2) # False

any(t1) # True

len(t1) # 6

max(t1) # 10

min(t1) # 1

sum(t1, 0) # 25; 2nd arg: initial value of sum

sorted(t1, reverse=True) # (10,7,5,1,1,1)

tuple(l1) # (10,5,1)

• an unordered collection of data type that is iterable, mutable and has no duplicate elements.
• The major advantage of using a set, as opposed to a list, is that it has a highly optimized method for checking whether a specific element is contained in the set.
• Lists cannot be added to a set as elements because Lists are not hashable whereas Tuples can be added because tuples are immutable and hence Hashable.

    ''' initialization '''
    # empty set
    set1 = set()
    # using a list
    s1 = set([1, "abc", 9.5])            # {1,'abc',9.5}

    ''' adding elements '''
    # single element using add()
    s1.add(95)                           # {1, 'abc', 9.5, 95}
    s1.add([1,2,3])                      # not allowed
    s1.add((1,2,3))                      # {1, 9.5, (1, 2, 3), 'abc', 95}
    # multiple elements using update()
    s1.update([10, 11])                  # {1, 9.5, 10, (1, 2, 3), 11, 'abc', 95}

    ''' removing elements '''
    # single element using remove() - KeyError, if key doesn't exist
    s1.remove(11)                        # {1, 9.5, 10, (1, 2, 3), 'abc', 95}
    # single element using discard()
    s1.discard(10)                       # {1, 9.5, (1, 2, 3), 'abc', 95}
    # last element (which cannot be determined if set is unordered) using pop() - returns the element popped
    s1.pop()                             # {1, 9.5, (1, 2, 3), 'abc'}
    # remove all elements using clear()
    s1.clear()                           # {}
        

Methods applicable on set

    s1 = set([10,5,9,3,7])
    s2 = set([10,11,12])
    s3 = set([10,7,4])
        

s1.add(1) # {1,3,5,7,9,10}

s1.remove(9) # {3,5,7,10}

s1.clear() # {}

s1.copy() # {3,5,7,9,10}

s1.pop() # {5,7,9,10}

s1.update([10,11,12]) # {3,5,7,9,10,11,12}

s1.union(s2) # {3,5,7,9,10,11,12}

s1.difference(s2) # {9,3,5,7}

s1.difference_update(s2) # s1 = {3,5,7,9}

s1.discard(10) # [3,5,7,9]

s1.intersection(s3) # {10,7}

s1.append(s3) # s1 = {10,7}

s1.isdisjoint(s2) # False

s1.issubset(s2) # False

s1.issuperset(s2) # False

s1.symmetric_difference(s2) # {3,5,7,9,11,12}

s1.symmetric_difference_update(s2) # s1 = {3,5,7,9,11,12}

• Dictionary is an unordered collection of data values, which, unlike other Data Types that hold only a single value as an element, Dictionary holds key:value pair.
• Keys in a dictionary don't allow Polymorphism.
• Dictionaries have been modified to maintain insertion order with the release of Python 3.7, so they are now ordered collection of data values.

    ''' initialization '''
    # with mixed keys and values
    d1 = {"name": "abc", : "marks": [100, 92, 93], 1: "A"}
    # using dict method
    d2 = dict({1: "hi", 2: "hello"})

    ''' accessing dictionary elements '''
    # using indexing
    d1["name"]                                 # abc
    # using get()
    d1.get("name")                             # abc

    ''' updating/adding key value pairs '''
    d1["name"] = "xyz"                         # {"name": "xyz", "marks": [100, 92, 93], 1: "A"}
    d1["grade"] = "A"                          # {"name": "xyz", "marks": [100, 92, 93], 1: "A", "grade": "A"}

    ''' removing an element from a dict '''
    # using del keyword
    del d1[1]                                  # {"name": "xyz", "marks": [100, 92, 93], "grade": "A"}
    del d1["marks"][0]                         # {"name": "xyz", "marks": [92, 93], "grade": "A"}
    # using pop() method
    ele = d1.pop("grade")                      # ele = "A", d1 = {"name": "xyz", "marks": [92, 93], "grade": "A"}
    # using popitem() method
    item = d1.popitem()                        # item = ("name": "xyz"), d1 = {"marks": [92, 93], "grade": "A"}
    # using clear() method
    d1.clear()                                 # {}
        

Methods applicable on lists

    d1 = {'name': 'abc', 'subjects': ['english', 'maths', 'science'], 'grade': 'A'}
    d2 = {'name': 'bcd', 'marks': 95}
        

d2 = d1.copy() # {'name': 'abc', 'subjects': ['english', 'maths', 'science'], 'grade': 'A'}

d1.clear() # {}

val = d1.pop("name") # val = 'abc', d1 = {'subjects': ['english', 'maths', 'science'], 'grade': 'A'}

val = d1.popitem() # val = ('grade', 'A') d1 = {'name': 'abc', 'subjects': ['english', 'maths', 'science']}

val = d1.get('name') # val = 'abc'

d1.values() # ['abc', ['english', 'maths', 'science'], 'A']

str(d1) # "{'name': 'abc', 'subjects': ['english', 'maths', 'science'], 'grade': 'A'}"

d1.update(d2) # {'name': 'bcd', 'subjects': ['english', 'maths', 'science'], 'grade': 'A', 'marks': 95}

d1.keys() # ['name', 'subjects', 'grade']

d1.items() # [('name', 'abc'), ('subjects', ['english', 'maths', 'science']), ('grade', 'A')]

dict.fromkeys(["a", "b", "c"]) # {"a": None, "b": None, "c": None}

type(d1) # <class 'dict'>

len(d1) # 3

• An Array is a collection of items stored at contiguous memory locations.
• The idea is to store multiple items of the same type together. This makes it easier to calculate the position of each element by simply adding an offset to a base value
• If you create arrays using the array module, all elements of the array must be of the same type.

    # importing library
    import array as arr

    ''' initialization '''
    a = arr.array('i', [1, 2, 3])                       # i: integer
    b = arr.array('d', [2.5, 3.2, 3.3])                 # d: decimal

    ''' adding elements to an array '''
    # using insert()
    a.insert(1, 4)                                      # [1, 4, 2, 3]
    # using append()
    b.append(4.4)                                       # [2.5, 3.2, 3.3, 4.4]

    ''' accessing elements '''
    # using indexing
    a[0]                                                # 1

    ''' removing elements from the array '''
    # using pop()
    val = a.pop(2)                                      # val = 4, a = [1, 2, 3]

    ''' slicing an array '''
    b[1:3]                                              # array('d', [3.2, 3.3])

    ''' searching an element in an array '''
    b.index(3.2)                                        # 1

    ''' updating elements '''
    b[1] = 5.5                                          # [2.5, 5.5, 3.3, 4.4]

        

• The bytes() function returns a simple bytes object - It converts objects into bytes objects, or creates empty bytes object of the specified size.