- Set: Its unique feature is that items are either members or not. This means duplicates are ignored:
- Mutable set: The
setcollection - Immutable set: The
frozensetcollection - Sequence: Its unique feature is that items are provided with an index position:
- Mutable sequence: The
listcollection - Immutable sequence: The
tuplecollection - Mapping: Its unique feature is that each item has a key that refers to a value:
- Mutable mapping: The
dictcollection. - Immutable mapping: Interestingly, there’s no built-in frozen mapping.
[:]: The start and stop are implied. The expressionS[:]will create a copy of sequenceS.[:stop]: This makes a new list from the beginning to just before the stop value.[start:]: This makes a new list from the given start to the end of the sequence.[start:stop]: This picks a sublist, starting from the start index and stopping just before the stop index. Python works with half-open intervals. The start is included, while the end is not included.[::step]: The start and stop are implied and include the entire sequence. The step—generally not equal to one—means we’ll skip through the list from the start using the step. For a given[start::step]: The start is given, but the stop is implied. The idea is that the start is an offset, and the step applies to that offset. For a given start, a, step, s, and a list of size |L|.[:stop:step]: This is used to prevent processing the last few items in a list. Since the step is given, processing begins with element zero.[start:stop:step]: This will pick elements from a subset of the sequence. Items prior to start and at or after stop will not be used.
a = slice(1, 2, 3)#[start:stop:step]List
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]
#operations
print(list1 + list2) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list1 * 2) # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
#append
list1.append(6) # [1, 2, 3, 4, 5, 6]
list1.extend([7, 3, 3]) # [1, 2, 3, 4, 5, 6, 7, 3, 3]
#remove
del list1[0] # [2, 3, 4, 5, 6, 7, 3, 3]
list1.remove(3) # [2, 4, 5, 6, 7, 3, 3]
list1.pop(0) # [4, 5, 6, 7, 3, 3]
#insert
list1.insert(0, 1) # [1, 4, 5, 6, 7, 3, 3]
#sort
list1.sort() # [1, 3, 3, 4, 5, 6, 7]
list1.sort(reverse=True) # [7, 6, 5, 4, 3, 3, 1]
list1.sort(key=lambda x: x % 2) # [6, 4, 7, 5, 3, 3, 1]
#reverse
list1.reverse() # [1, 3, 3, 4, 5, 6, 7]
#count
print(list1.count(3)) # 2
#clear
list1.clear() # []
#copy
list1 = [1, 2, 3, 4, 5]
list2 = list1.copy()
#unpack the list
list3=[*list1]
print(*arr)# print(1,2,3,4,5,6,7,8,9,10)ls=list(range(10))
random.shuffle(ls)
mm:typing.Callable=ls.append
mm(10)
print(ls) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]dect
Only a number, string or tuple can be used as key. All of them are immutable. You can use an object of any type as the value.
| dict[key] | Extract/assign the value mapped with key | print (d1[‘b’]) retrieves 4d1[‘b’] = ‘Z’ assigns new value to key ‘b’ |
| dict1|dict2 | Union of two dictionary objects, retuning new object | d3=d1|d2 ; print (d3){‘a’: 2, ‘b’: 4, ‘c’: 30, ‘a1’: 20, ‘b1’: 40, ‘c1’: 60} |
| dict1|=dict2 | Augmented dictionary union operator | d1|=d2; print (d1){‘a’: 2, ‘b’: 4, ‘c’: 30, ‘a1’: 20, ‘b1’: 40, ‘c1’: 60} |
d1=dict([('a', 100), ('b', 200)])
d2 = dict((('a', 'one'), ('b', 'two')))
d3=dict(a= 100, b=200)
d4 = dict(a='one', b='two')update dictionary
marks = {"Savita":67, "Imtiaz":88, "Laxman":91, "David":49}
print ("marks dictionary before update: \n", marks)
marks1 = {"Sharad": 51, "Mushtaq": 61, "Laxman": 89}
marks.update(marks1)
print (marks)#{'Savita': 67, 'Imtiaz': 88, 'Laxman': 89, 'David': 49, 'Sharad': 51, 'Mushtaq': 61}
d1.update(k1=v1, k2=v2)unpack dictionary
marks = {"Savita":67, "Imtiaz":88, "Laxman":91, "David":49}
marks1 = {"Sharad": 51, "Mushtaq": 61, "Laxman": 89}
newmarks = {**marks, **marks1}#{'Savita': 67, 'Imtiaz': 88, 'Laxman': 89, 'David': 49, 'Sharad': 51, 'Mushtaq': 61}
a,*b=[1,2,3]#1 [2, 3]delete and remove
del dict['key']
val = dict.pop(key)
dict.clear()| 1 | dict.clear()Removes all elements of dictionary dict. |
| 2 | dict.copy()Returns a shallow copy of dictionary dict. |
| 3 | dict.fromkeys()Create a new dictionary with keys from seq and values set to value. |
| 4 | dict.get(key, default=None)For key key, returns value or default if key not in dictionary. |
| 5 | dict.has_key(key)Returns true if a given key is available in the dictionary, otherwise it returns a false. |
| 6 | dict.items()Returns a list of dict’s (key, value) tuple pairs. |
| 7 | dict.keys()Returns list of dictionary dict’s keys. |
| 8 | dict.pop()Removes the element with specified key from the collection |
| 9 | dict.popitem()Removes the last inserted key-value pair |
| 10 | dict.setdefault(key, default=None)Similar to get(), but will set dict[key]=default if key is not already in dict. |
| 11 | dict.update(dict2)Adds dictionary dict2’s key-values pairs to dict. |
| 12 | dict.values()Returns list of dictionary dict’s values. |
syntaxes
for else statement
for i in arr:
if i>3:
break
print(i)
else: #executes if the loop completes without a break
print("done")T1 = (10,20,30,40)
T2 = ('one', 'two', 'three', 'four')
L1, L2 = list(T1), list(T2)
L3 = tuple(y for x in [L1, L2] for y in x)#(10, 20, 30, 40, 'one', 'two', 'three', 'four')mm=["a","b","c",1,2,3]
for m in filter(lambda x: isinstance(x, str), mm):
print(m)for m,v in vars(tt("a")).items():#vars return all attributes of object
print(m,v)ls=[1,2,3,4,5,6,7,8,9,10,11]
even= [i for i in ls if i%2==0]#only even numbersbuiltin functions
numbers = [1.0, 1.5, 2.0, 2.5]
result_1 = map(lambda x: x.is_integer(), numbers)
result_2 = (x.is_integer() for x in numbers)
result_3 = map(float.is_integer, numbers)
# [True, False, True, False]
filter(lambda x: x>10, numbers)
len(numbers)
numericList = [12, 24, 36, 48, 60, 72, 84]
print(sorted(numericList, reverse=True))#84,72,60....
sum([1,2,3,4])#10a,*b=[1,2,3]#1 [2, 3]Iterable and Iterator
from typing import *
m=[1,2,3]
mm=iter(m)
print(next(mm))#1
print(next(m))#error
print(isinstance(iter(m), Iterator))#True
print(isinstance(m, Iterator))#False
print(isinstance(m, Iterable))#True
print(isinstance(iter(m), Iterable))#Truemap object
ls=list(range(1,100,2))
ls2=[m for m in ls if m>10 & m<20]
m1=map(lambda x:x-100+3j,ls2)
ls3=list(m1)