Python List Functions

List Functions

• len() returns the length of its argument list and is a standard Python library function
  • Example: l=[1,2,3] will return 3
• list() returns a list created from a passed argument, which should be a sequence type (string, list, tuple, etc.)
  • If no argument is passed, it creates an empty list
  • Example: a=list("hello") will output ['h','e','l','l','o']
• index() returns the index of the first matched item from the list
  • Syntax: list.index(item)
  • Example: if L=[13,18,11,16,18,14], L.index(18) will output 1
• append() adds an item to the end of the list, taking exactly one element and returning no value
  • If the item is not in the list, a ValueError exception is raised
  • Syntax: list.append(item)
  • Example: For colours=['red','green','yellow'], colours.append('blue') will output ['red', 'green', 'yellow', 'blue']
• extend() adds multiple elements to a list
  • Syntax: list.extend(list)
  • It takes a list as an argument and appends all its elements to the original list
  • Example: For t1=['a','b','c'] and t2=['d','e'], t1.extend(t2) will output ['a', 'b', 'c', 'd', 'e']
• insert() inserts elements into a list
  • Both append() and extend() insert elements at the end, whereas insert() inserts elements at a specific position
  • Syntax: list.insert(index,item)
  • Example: For t=['a','e','u'], t.insert(2,'i') will output ['a', 'e', 'i', 'u']
• pop() removes an item from the list and returns its value
  • It takes one optional argument, which is the index of the item to be deleted
  • Syntax: list.pop(index)
  • It removes an element from the specified position and returns it
  • With no index specified, it removes and returns the last item in the list
  • Example: If L=[1,2,3,4,5], val=L.pop(0) will output 1 and [2, 3, 4, 5]
  • Example: If L=[1,2,3,4,5], val=L.pop() will output 5 and [1, 2, 3, 4]
• remove() removes the first occurrence of a given item from the list
  • It takes one essential argument
  • Syntax: List.remove(value)
  • The remove() function will report an error if the item isn't in the list
  • Example: If L=['a','e','i','o','u'], L.remove('a') will output ['e', 'i', 'o', 'u']
• clear() removes all items from the list, making it empty
  • It does not return anything
  • Syntax: list.clear()
  • Example: If l=[1,2,3,4], l.clear() will output []
• count() returns the number of times an item appears in the list
  • If the item is not in the list, it returns zero
  • Syntax: list.count(item)
  • Example: If L=[13,18,20,10,18,23], L.count(18) will output 2, while L.count(28) will output 0
• reverse() reverses the order of items in the list
  • It does not create a new list
  • Syntax: List.reverse()
  • Example: If l=[1,2,3,4], l.reverse() will output [4, 3, 2, 1]
• sort() sorts the items of the list by default in increasing order
  • It does not create a new list
  • Syntax: list.sort([reverse=False/True])
  • Example: If L=[20,1,16,8,25], L.sort() will output [1, 8, 16, 20, 25]
  • To sort in descending order, use L.sort(reverse=True), which outputs [25, 20, 16, 8, 1]
• min(), max(), and sum() functions return the minimum element, maximum element, and sum of elements in a list, respectively
  • Syntax: min(list), max(list), sum(list)
  • Example: If L=[20,1,16,8,25], min(L) is 1, max(L) is 25, and sum(L) is 70

Tuple Functions

• len() returns the number of elements in the tuple
  • Syntax: len(tuple)
  • Example: If t=(1,2,3,4), len(t) will output 4
• max() returns the element from the tuple with the maximum value
  • Values in the tuple must be of the same type
  • Syntax: max(tuple)
  • Example: If t=(2,90,45,8), print(max(t)) will output 90
• min() returns the element from tuple with the minimum value
  • Values in the tuple must be of same type
  • Syntax: min(tuple)
  • Example: If t=(2,90,45,8), print(min(t)) will output 2
• sum() takes a tuple as a parameter and returns the sum of its elements
  • Example: If t=(51,2,91,6), sum(t) outputs 150
• index() returns the index of an existing element of a tuple
  • Syntax: tuple.index(item)
  • Example: If t=(1,2,3,4), t.index(3) outputs 2
• count() returns the count of an element in a given sequence
  • Syntax: tuple.count(element)
  • Example: If t=(1,2,3,1,2,4,1,2,3), t.count(2) outputs 3
• sorted() takes a tuple as an argument and returns a new sorted list with sorted elements
  • Syntax: sorted(tuple,[reverse=False])
  • This sorts in ascending order; use sorted(tuple,reverse=True) for descending order
  • Example: If t=(51,2,91,6), t1=sorted(t) will output [2, 6, 51, 91]
• tuple() is used to create tuples from different types of values
  • Syntax: tuple(Sequence)
  • Example: An empty tuple, t=() will output ()
  • Example: t=tuple("abc") will output ('a', 'b', 'c')

Dictionary Functions and Methods

• len() gets the length of the dictionary
  • It counts the key-value pairs
  • Syntax: len(dictionary)
  • Example: For d={1:20,2:30,3:40,4:50}, print(len(d)) outputs 4
• get() retrieves an item given its key
  • An error is returned if the key is not present
  • Syntax: Dictionary.get(key)
  • Example: Given d={'name':"abhay","age":18,"class":12}, d.get("age") returns 18
• items() returns all items in the dictionary as a sequence of (key, value) tuples
  • Syntax: Dictionary.items()
  • Example: Given d={1:10,2:20,3:30,4:40}, d.items() outputs dict_items([(1, 10), (2, 20), (3, 30), (4, 40)])
• keys() returns all keys in the dictionary as a sequence
  • Syntax: dictionary.keys()
  • Example: Given d={1:10,2:20,3:30,4:40}, d.keys() outputs dict_keys([1, 2, 3, 4])
• values() returns all the values in the dictionary as a sequence
  • Syntax: dictionary.values()
  • Example: Given d={1:10,2:20,3:30,4:40}, d.values() will output dict_values([10, 20, 30, 40])
• update() merges key-value pairs from a new dictionary into the original, adding or replacing as needed
  • Items in the new dictionary are added to the old one, overriding items with the same keys
  • Syntax: dictionary.update(other dictionary)
  • Example: If d={1:10,2:20,3:30} and d1={4:40,5:50}, d.update(d1) will result in d becoming {1: 10, 2: 20, 3: 30, 4: 40, 5: 50} and d1 remaining {4: 40, 5: 50}
• fromkeys() is used to create a new dictionary from a sequence
  • It contains all keys and a common value assigned to all the keys
  • Syntax: dict.fromkeys(key sequence, value)
  • Key sequence is a Python sequence containing the keys for the new dictionary
  • Example: nd=dict.fromkeys([2,4,6,8],100) outputs {2: 100, 4: 100, 6: 100, 8: 100}
• setdefault() inserts a new key-value pair
  • If the given key is not already present in the dictionary, it is added with the specified value and returns it
  • If the key is already present, the dictionary is not updated, and the current value associated with the key is returned
  • Example: If marks={1:45,2:67,3:90,4:87}, marks.setdefault(5,89) outputs 89, while marks.setdefault(4,89) outputs 87
• pop() removes and returns the dictionary element associated with the passed key
  • An error is raised if the mentioned key is not present in the dictionary
  • Personalised messages can be displayed if a key is not in the dictionary
  • Syntax: dictionary.pop(key)
  • Example: If d={1:10,2:20,3:30,4:40}, d.pop(2) outputs 20
  • Note: pop() deletes the key-value pair for the mentioned key & returns the deleted value
• popitem() returns and removes the last inserted item in the dictionary, as a (key, value) tuple
  • If the dictionary is empty, calling popitem() raises an error
  • Syntax: dictionary.popitem()
  • Example: If d={1:10,2:20,3:30,4:40}, then d.popitem() will output (4, 40)
• del is a statement used to delete a key-value pair from a dictionary
  • It does not return the deleted value
  • Syntax: del dictionary[key]
  • Example: If d={1:10,2:20,3:30,4:40}, del d[2] will result in d becoming {1: 10, 3: 30, 4: 40}
• clear() removes all items from the dictionary, making it empty
  • Syntax: dictionary.clear()
  • Example: For d={1:10,2:20,3:30,4:40}, d.clear() will result in d becoming {}
• copy() creates a shallow copy of a dictionary
  • Syntax: dictionary.copy()
  • Example: If names={1:"abhay",2:"athira",3:"chitra"}, names1=names.copy() creates a shallow copy- such that, names1=names.copy() then names1[4]="dany" will output names1 as {1: 'abhay', 2: 'athira', 3: 'chitra', 4: 'dany'} and names as {1: 'abhay', 2: 'athira', 3: 'chitra'}
• sorted() considers keys of the dictionary for sorting and returns a sorted list of dictionary keys
  • Syntax: sorted(dictionary,reverse=False)
  • It returns the keys of the dictionary sorted in descending order if reverse is set to True
  • All keys must be of the same type for this function to work
  • Example: If d={90:"abc",45:"def",2:"pqr", 92:"hij"}, then d1=sorted(d) will output [2, 45, 90, 92]
• max(), min(), and sum() functions on Dictionaries
  • Dictionary keys should be of homogenous type
  • sum() can work with dictionaries having keys that are addition compatible
  • Example: If d={1:10,2:90,80:50,75:9}, min(d) will output 1, max(d) will output 80 and sum(d) will output 158

String Built-in Functions

• len() returns the length of its argument string
  • Syntax: len(string)
  • Example: len("hello") will return 5 (total number of characters in the string)
• capitalize() returns a copy of the string with its first character capitalized
  • Syntax: string.capitalize()
  • Example: 'i love my India'.capitalize() will return 'I love my India'
• lower() returns a copy of the string converted to lowercase
  • Syntax: string.lower()
  • Example: "HELLO".lower() will return 'hello' and "hi".lower() will return 'hi'
• upper() returns a copy of the string converted to uppercase
  • Syntax: string.upper()
  • Example: 'hello'.upper() will return 'HELLO'
• count() returns the number of occurrences of a substring in a string
  • Syntax: string.count(sub[,start[,end]])
  • Example:'abracadabra'.count('ab') counts the number of 'ab's in the whole string, returning 2
• find() returns the lowest index in the string where the substring is found
  • Returns -1 if the substring is not found
  • Syntax: string.find(sub[,start[,end]])
  • Example: s="hi hello there hi hello", then s.find("hello") returns 3 and s.find("hello",10,30) returns 18
• index() returns the lowest index where the specified substring is found
  • A ValueError is raised if the substring is not found
  • Same as find() but find() returns -1 if substring is not found and index() raises a ValueError
  • Syntax: string.index(sub[,start[,end]])
  • Example: s='abcrabdcab', then s.index('ab') returns 0
• isalnum() returns True if characters in the string are alphanumeric or numbers, with at least one character; otherwise returns False
  • Syntax: string.isalnum()
  • Example: s='abc123' will return True; s='123' will also return True, and s='' will return False
• isalpha() returns True if all characters in a string are alphabetic with at least one character, and False otherwise
  • Syntax: string.isalpha()
  • Example: s='abc123' will return False; s='hello' will return True
• isdigit() returns True if all the characters in the string are digits, with at least one character; False otherwise
  • Syntax: string.isdigit()
  • Example: s='abc123' will return False; s='123' will return True
• islower() returns True if all cased characters are lowercase with at least one cased character; returns False otherwise
  • Syntax: string.islower()
  • Example: Given s='hello', s.islower() returns True and if s='HI', s.islower() returns False.
• isupper() returns True if all cased characters in the string are uppercase with at least one cased character; it returns False otherwise
  • Syntax: string.isupper()
  • Example: Given s='hello', and s1="A123"", then s.isupper() returns False and s1.isupper() returns True
• title() returns a title cased version of the string where all words start with uppercase characters and all remaining letters are in lowercase
  • Syntax: string.title()
  • Example: 'python is fun'.title() returns 'Python Is Fun'
• istitle() returns True if the string is title cased (first letter of each word in uppercase and the rest in lowercase); False otherwise
  • Syntax: string.istitle()
  • Example: 'Computer Science'.istitle() returns True
• isspace() returns True if there are only whitespace characters in the string, with at least one character; otherwise, returns False
  • Syntax: string.isspace()
  • Example: Given s=" ", prints s.isspace() outputs True; and gives s="", and s.isspace() returns False
• lstrip() returns a copy of the string with leading whitespaces removed (whitespaces from the leftmost end)
  • Syntax: string.lstrip()
  • Example: Given s=" python ", then s.lstrip() outputs "python "
• rstrip() returns a copy of the string with trailing whitespaces removed (whitespaces from the rightmost end)
  • Syntax: string.rstrip()
  • Example: Given s=" python ", then “.rstrip() outputs " python"
• strip() returns a copy of the string with both leading and trailing whitespaces removed
  • Syntax: string.strip()
  • Example: Given s=" python ", then s.strip() returns "python"
• startswith() If the string starts with the substring sub, it returns true; otherwise, it returns false
  • Syntax: string.startswith()
  • Example: "abccd".startswith("ab") returns True
• endswith() If the string ends with the substring sub, it returns true; otherwise, it returns false
  • Syntax: string.endswith()
  • Example: "abcd".endswith('d') returns True
• replace() returns a copy of the string with all occurrences of substring old replaced by new string
  • Syntax: string.replace(old,new)
  • Example: "I work for you".replace(“work”,”care") returns "I care for you"
• join() joins a string or character after each member of a string iterator
  • If the iterator is a list or tuple, the given string/character is joined with each member
  • All members of the list or tuple must be strings; otherwise, Python raises an error
  • Syntax: string.join(String iterable)
  • Example: "".join(“Hello") returns “Hell**o"
• split() splits a string based on a given string or character and returns a list containing split strings as members
  • Syntax: string.split(string/char) If no argument is provided then by default whitespace will be taken as a separator.
  • If an argument is provided, the line is divided into parts considering the given string / char as separator string / char is not included in the splitstrings
  • Example:"I Love Python".split() output ['I','Love', 'Python']
• partition() splits the string at the first occurrence of a separator and returns a tuple containing three items: the part before the separator, the separator itself, and the part after the separator if text = "I enjoy working with python" then text.partition(“working"), will return tuple (“I enjoy”,”working”,”with python”)
  • Syntax: string.partition(separator/string)