style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="387"
data-original-width="688"
height="180"
src="https://blogger.googleusercontent.com/img/a/AVvXsEjhOKpKJJMCr6Fje-i7lYG24FgUBfiwJlGNzhKIutK_OmWVpjy-i8vNDZpCmgrjudod17cieRKR4KVQif0SkbsauN6uDj28KI1lMK_CPcGxRPPee-Uyqu67MeFH22buDmfmyUe_owAe8I_NztcoRD3cFGWCMN6E9jQBtqn-tGBQ-SNz4utSA5I-DYlP=s320"
width="320"
/>
Welcome back!
>In this chapter, we are going to learn data types in Python. >
Before we start, I want to tell you something that we are going to advance
level from this chapter, so be careful and do practice regularly.
Best Regards from,
Msbtenote :),
Data types in Python:
>Booleans are either True or False. >
Numbers can be integers(1,2),float(2.3,4.3),fractions(1/2,3/2) or even
complex numbers.
Strings are sequences of Unicode characters (e.g., an HTML
document)
>Lists are ordered sequences of values. >
>Tuples are ordered, immutable sequences of values. >
>Sets are unordered bags of values. >
>Dictionaries are unordered bags of key-value pairs. >
>Immutable types
Strings and tuples are immutable, which means once we create them, we
can not change them.
Lists, sets, and dictionaries are mutable, which means we can add,
remove elements from them.
>
crossorigin="anonymous"
src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-9869442004118280"
>
data-ad-client="ca-pub-9869442004118280"
data-ad-format="auto"
data-ad-slot="3195394695"
data-full-width-responsive="true"
style="display: block;"
>
String:
>Strings are amongst the most popular types in Python. >
>We can create them simply by enclosing characters in quotes. >
>Python treats single quotes the same as double-quotes. >
>Creating a string is simple as assigning the value to a variable. >
Python does not support a character type. These are treated as strings
of length one, thus also considered a substring.
To access each character, use the square brackets along with the index.
We can access a specific element using an integer index that counts from
the front of the sequence(starting at zero).
Counting backward-We can count from the end of the string using negative
numbers also.
Index out of range-If we try to access an element that does not exist,
Python will throw an error!
>
style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="542"
data-original-width="1265"
height="137"
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjQSJrMjcrNWRmPt5XHe6msUnltDmS4OFiRFmvxOV2kSq0w2nbD4q3YRvtepNuD9iGOJ5DoUlPbNgDaQryYhThAb97iMm7CENxUEtDaj5zgwEf0VQ4IoJp1JAR2pmUUsnj4i4X0YeihplA/s320/Screenshot-_216_.webp"
width="320"
/>
Easy traversals-The for loop: Python makes string traversals easy with
a for a loop.
Grabbing slice from a string-The slice operator clips out part of a
sequence; it works a lot like a range function but with colons that
separate the start and the endpoint. >[Syntax- start: end: step] >
Slices-Default values for blanks: If one leaves the "Start" part
blank, it assumes you want zero. If one leaves the "end" blank, it
assumes you want until the end of the string.
>
style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="534"
data-original-width="1165"
height="147"
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEilDweiGEUYtoq-2TT9yBlq3YtGr53Rpd_m133W0oOqY0f4BiA0a1t2GYHNG0XxKBwlQYUdd9in-ovnw-dOU9HsDnML39w-mqtePQLBh4Qv_RHwNiwGWfLC1CRdImjangHgoZUuqDort_g/s320/Screenshot-_218_.webp"
width="320"
/>
>String methods:
format()-The string format() method formats the given string into the
more excellent output in Python.
>Index ()-Returns the index of the substring. >
>Count ()-Return occurrences of a substring in a string. >
>Find ()-Returns the index of the first occurrence of a substring. >
>Is lower()-Checks if all alphabets in the string are in lowercase >
>isupper()-Checks if all alphabets in the string are in uppercase. >
>Lower ()-Returns a lowercased string. >
>Upper ()-Returns an uppercased string. >
>Swap case()-Swap uppercase characters to lowercase, vice-versa. >
>Capitalize ()-Converts the first character to a capital letter. >
>Strip ()-Removes leading characters. >
>Strip ()-Removes trailing characters. >
>isalnum()-Checks alphanumeric characters. >
>Is numeric()-Checks numeric characters. >
>
style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="534"
data-original-width="1121"
height="152"
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgRgszLa0HL0uMb0Jz2b3kaeHVZy5SKnv7SMMVkAK_TpARpmawkI3GMgsbNLAE-Udha9IHAP1Jq-pj-sJSq9JCxIbqUUT3cuUnHP6s5JkZGUCgA6BEDMIdCyBOZAob7vMLp9kW1QC3O6fw/s320/Screenshot-_222_.webp"
width="320"
/>
>
style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="534"
data-original-width="1204"
height="142"
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhiToTee2ovNEj0o_rPpyZbeDeviHr9k6n_uc1sYIcuSpXQvmXMmm1HUC_OxBo_1KOWxUnxBFJ7BYSQ2K61Mop2tyXOW6BHBqLv71FN7y_gg65zWjw-ZA0cAMlmgR7JOMk4E3-k43Wo7Y8/s320/Screenshot-_223_.webp"
width="320"
/>
>
style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="529"
data-original-width="1269"
height="133"
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhoTqRZ-eqrOG-PgUSewd_PRzT3N8fmbsu91VsIxeK5z8J6otPfLsyK8CNlIPXZw7qHpGn3UpTu2AXyLVbc7u0sBc0SgwfbXHFf79pKU-wY9_dmFpzt44b_LNLQhkYQD-OUkfiC14QAhao/s320/Screenshot-_224_.webp"
width="320"
/>
List:
A list is a data structure that holds an ordered collection of items,
i.e., you can store a sequence of items in a
list.
The List of items should be enclosed in square brackets so that Python
understands that you are specifying a list.
Once you have created a list, you can add, remove or search for items in
the List.
Since we can add and remove items, we say that a list is a mutable data
type, i.e., this type can be altered.
>How to use a list?
A list is represented using square brackets [] and is created by
providing values separated by ",."
List allow duplicates values.
List contains an ordered set of elements. Hence it can be accessed by
using an index that starts from zero.
>Index values greater than range, then an error is generated. >
>A reverse index is also possible just as a string. >
>An empty list can be created in two different ways. >
>Elements in the List can be updated since the List is mutable. >
>
style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="519"
data-original-width="1162"
height="143"
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjfz93P4IR6BHvz6F-jw4iYHcEZXVkrGgG8h-lv4fr8wz6YSXNZC-4-7aFE0l-AnAGMDjLX6awNAkzv5aiMEEUfakcnddD0kYt9CbUuj4qBlO1fq6eGwccu3BtYjM5dCFkNZZcGP7hyphenhyphen7X4/s320/Screenshot-_228_.webp"
width="320"
/>
>
style="margin-left: 1em; margin-right: 1em;"
>
data-original-height="408"
data-original-width="1027"
height="127"
src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiU3Uo8RE5La3oX9ptIlmuqjd4IVQzao_Z0P4yyYEuy-kDuSLD12UUFBi0kWLqw8FToSjxIFrfM60JzR16e0Sm2zBXb1bB1wDnPNho66bYgp6fo-dO-p5dbH8Bi8-U5PXH5iZ0w4HO5w2M/s320/Screenshot-_229_.webp"
width="320"
/>
List assignment and equivalence:- List assignment is used to assign
all the elements of a list to another list.
Here, memory is allocated for both objects separately. This is called
deep copy.
Whereas here, the same memory is used. This is called shallow copy.
List comparison and slicing:- List elements or List as a whole also
can be compared.
>List slicing is the same as string slicing. >
List class methods:- Since a list is a class, it has many methods
attached. We can check all methods using the help function.
>Operator overloaded and len() function. >
>Add a new element to the list-append, extend, insert. >
>Aggregate methods- max,min,sum,count,index. >
>Delete element from list- del,pop,remove. >
List class methods- Sorting,out-place sorting,in-place
sorting.Reverse,out-place reverse,in-place reverse.
a=[1,2,3]
b=a
b[1]=30
print(b)
print(a)
Output=[1, 30, 3]
Output=[1, 30, 3]
a=[1,2,3]
b=list(a)
print(b)
b[1]=10
print(b)
print(a)
Output=[1, 10, 3]
Output=[1, 2, 3]
a=[1,2,3,4,5,6,7,8,9]
a[1:5]
a[:6]
a[3:]
a[2:9:2]
[3, 5, 7, 9]
a=[1,2,3]
x=[2,1,1]
a[1]==x[2]
a==x
a is greater than x
Output=True
List Methods
l1=[1,2,3,4]
print(l1)
Output=[1, 2, 3, 4]
a=[5,6,7,8]
print(a)
Output=[5, 6, 7, 8]
print(b)
b=l1+a
print(b)
Output=[1, 2, 3, 4, 5, 6, 7, 8]
print(c)
c=b*2
print(c)
Output=[1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8]
print(c)
x=len(c)
print(x)
Output=16
d=[1,2,3,4]
print(d)
Output=[1, 2, 3, 4]
e=[2,4,6,8]
print(e)
Output=[2, 4, 6, 8]
d.append(30)
print(d)
Output=[1, 2, 3, 4, 30]
d.append(e)
print(d)
Output=[1, 2, 3, 4, 30, [2, 4, 6, 8]]
d.extend(e)
print(d)
Output=[1, 2, 3, 4, 30, [2, 4, 6, 8], 2, 4, 6, 8]
d.insert(2,3)
print(d)
d.insert(2,3)
print(d)
Output=[1, 2, 3, 3, 4, 30, [2, 4, 6, 8], 2, 4, 6, 8]
h1=[2,3,4,5]
print(h)
Output=[2, 3, 4, 5]
h2=[1,2,3,4]
print(h1)
Output=[1, 2, 3, 4]
del h1[1]
print(h1)
Output=[2, 4, 5]
del l1
print(l1)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
in
----> 1 l1
NameError: name 'l1' is not defined
l1=[1,2,3,4]
print(l1)
Output=[1, 2, 3, 4]
x=l1.pop()
print(x)4
print(l1)
Output=[1, 2, 3]
x=l1.pop(2)
print(x)3
print(l1)
Output=[1, 2]
l1.remove(2)
print(l1)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
in
----> 1 l1.remove(2)
2 l1
ValueError: list.remove(x): x not in list
del l1
l1=[1,2,3,8,4,5,6,7,8]
print(l)
Output=[1, 2, 3, 8, 4, 5, 6, 7, 8]
max(l1)
Output=8
min(l1)
Output=1
sum(l1)
Output=36
l1.count(8)
Output=1
l1.index(8)
Output=7
l1.index(8,2,5)
Output=3
del l1
del l1
l1=[11,33,55,44,22]
print(l1)
Output=[11,33,55,44,22]
Out place sorting
l2=sorted(l1)
print(l2)
Output=[11, 22, 33, 44, 55]
In place sorting
l1.sort()
print(l1)
Output=[11, 22, 33, 44, 55]
l1.sort(reverse=true) l1
l1.sort(reverse=True)
print(l1)
Output=[55, 44, 33, 22, 11]
del l2
l2=[45,65,78,12]
l3=l2[::-1]
print(l3)
Output=[12, 78, 65, 45]
l2.reverse
print(l2)
Output=[45, 65, 78, 12]
List membership operation: Since the List is a sequence, we can use a
simple loop for selecting each element one by one.
>We can directly check if the element is a part of a given list. >
Nested list-List can have List itself s its element. We can update the
element of a list.
Joining List into string-The join () method returns a string in which a
string separator has joined elements of a sequence.
Splitting strings into list-The split () method returns a list of
strings after breaking the given string by the specified separator. If
the separator is not provided, then any whitespace is a separator.
List comprehension-It is used for creating a new list from other
iterables.
Iterables-Is the object capable of returning its member one at a time.
As list comprehension returns a list, they consist of brackets
containing the expression that needs to be executed for each element and
the for loop to iterate over each element.
>You can find standard numbers from two lists using for loop. >
>Combine the different numbers from the two given lists. >
>
crossorigin="anonymous"
src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-9869442004118280"
>
data-ad-client="ca-pub-9869442004118280"
data-ad-format="auto"
data-ad-slot="3195394695"
data-full-width-responsive="true"
style="display: block;"
>
l1 = [2,3,4,5]
l1
[2, 3, 4, 5]
for i in l1:
print(l1)
Output=[2, 3, 4, 5]
[2, 3, 4, 5]
[2, 3, 4, 5]
[2, 3, 4, 5]
x=4
if x in l1:
print(x,"is the element of ",l1)
else:
print(x,"is not the elemnet of",l1)
Output=4 is the element of [2, 3, 4, 5]
del x
x=[[1,2,3,4],[5,6,7,8]]
print(x)
Output=[[1, 2, 3, 4], [5, 6, 7, 8]]
for i in x:
print(i)
for j in i:
print(j)
Output=[1, 2, 3, 4]
1
2
3
4
[5, 6, 7, 8]
5
6
7
8
del y
y=[[[2],[2,3,4],[6,5],[[3],[2,5]]]]
print(y)
Output=[[[2], [2, 3, 4], [6, 5], [[3], [2, 5]]]]
x[0][2]=66
print(x)
Output=[[1, 2, 66, 4], [5, 6, 7, 8]]
Splitting string into list
s="This is a string"
print(s)
Output='This is a string'
l=s.split()
print(l)
Output=['This', 'is', 'a', 'string']
l=s.split(' ',2)
print(l)
Output=['This', 'is', 'a string']
s1="10,20,30,40"
l2=s1.split(",")
print(l2)]
Output=['10', '20', '30', '40']
l3=" ".join(s)
print(l3)
Output='T h i s i s a s t r i n g'
l4='-'.join(s)
print(l4)
Output='T-h-i-s- -i-s- -a- -s-t-r-i-n-g'
del l
del l2
del l3
del l4
l1=[2,3,4,5]
print(l1)
Output=[2, 3, 4, 5]
s1=[]
for n in l1:
s1.append(n**2)
print(s1)
[4, 9, 16, 25]
l1=[2,3,4,5]
s1=[n**2 for n in l1]
print(s1)
Output=[4, 9, 16, 25]
l1=[1,2,3,4]
l2=[2,3,4,5]
print(l1)
Output=[1, 2, 3, 4]
print(l2)
Output=[2, 3, 4, 5]
common_num=[a for a in l1 if a in l2]
print(common_num)
Output=[2, 3, 4]
different_num=[(a,b) for a in l1 for b in l2 if a!=b]
print(different_num)
Output=[(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 2), (3, 4), (3, 5), (4, 2), (4, 3), (4, 5)]
Tuple
Tuples are used to hold together multiple objects. Think of them as
similar to lists but without the extensive functionality that the list
class gives you.
One prominent feature of tuples is that they are immutable, i.e., you
cannot modify tuples.
Tuples are usually used in cases where a statement or a user-defined
function can safely assume that the collection of values, i.e., the
tuple of values used, will not change.
>
Tuple Creation >
Tuples are defined by specifying items separated by commas
within an optional pair of parentheses.
A tuple with only a single element is defined by specifying an item
with a comma within an optional pair of parentheses.
>Tuple Manipulation
- Tuples are immutable,
>Tuples elements can be accessed by indexing and slicing
methods. >
>Tuples Unpacking
>Unpacking allows assigning multiple values at a time. >
>Tuples unpacking is also applicable to loops. >
t1=(1,2,3,4)
print(t1)
print(type(t1))
Output=(1, 2, 3, 4)'tuple'>
t2=(2)
print(type(t2))
Output= 'int'>
t3=(2,)
print(type(t3))
Output= 'tuple'>
UNPACKING OF TUPLE
t4=(2,'b',3.4,6,(1,2))
print(type(t4))
Output= 'tuple'>
i1,i2,i3,i4,i5=t4
print(i1,i2,i3,i4,i5)
Output=2 b 3.4 6 (1, 2)
i6,i7=i5
print(i6,i7)
Output=1 2
T1=[(2,3),(4,5),(6,7)]
for x in T1:
print(x)
Output=(2, 3)
(4, 5)
(6, 7)
for x,y in (2,3):
print(x,y)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
----> 1 for x,y in (2,3):
2 print(x,y)
TypeError: cannot unpack non-iterable int object
for x in t4:
print(x,type(x))
Output=2 'int'>
b 'str'>
3.4 'float'>
6 'int'>
(1, 2) 'tuple'>
x1='b'
x1 in t4
Output=True
x2='a'
x2 in t4
Output=False
a=10
b=20
print(a,b)
Output=10 20
c=a+b
print(c)
Output=30
a=(10,20,30)
b=(40,50,60)
c=a+b
print(c)
Output=(10, 20, 30, 40, 50, 60)
Sets
A set is an unordered list of elements identified by curly braces.
- It is mutable like List.
>It can only contain unique elements. >
>Duplicates are eliminated in the set. >
Set does not support indexing.
>Set Class Methods
>Creation method=set(),clear(),add(),update() >
>Deletion methods=discard (without error), remove() , pop() >
>You can perform boolean operations on sets. >
Let's see in our examples:
Sets
x={"VIshal","Pranay","Swapnil"}
print(x)
Output={'Pranay', 'Swapnil', 'VIshal'}
print(type(x))
Output='set'>
cset={11,22,11}
print(cset)
Output={11, 22}
s1=set()
print(s1)
Output=set()
s2=set((2,3,4))
print(type(s2))
s2.clear()
Output= 'set'>
s2.clear
Output=function set.clear>
print(s2)
Output=set()
s1={2,3,4}
print(s1)
Output={2, 3, 4}
s1.add(20)
print(s1)
Output={2, 3, 4, 20}
s1.add(20,30)
print(s1)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
----> 1 s1.add(20,30)
2 s1
TypeError: add() takes exactly one argument (2 given)
s1.update((20,30))
print(s1)
Output={2, 3, 4, 20, 30}
s1={2,3,4}
s1.discard(2)
print(s1)
Output={3, 4}
s1.discard(20)
print(s1)
Output={3, 4}
s2={2,3,4}
s2.remove(2)
print(s2)
Output={3, 4}
s2.remove(20)
print(s2)
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
in
----> 1 s2.remove(20)
2 s2
KeyError: 20
s3={2,3,4}
s3.pop()
Output=2
print(s3)
Output={3, 4}
a=set((23,33,33,23,45,67,56,67,45))
print(a)
Output={33, 67, 45, 23, 56}
l=[23,33,33,23,45,67,56,67,45]
a=set(l)
print(a)
Output={33, 67, 45, 23, 56}
Boolean operations on Sets
aset={11,22,33}
bset={12,23,33}
print(aset|bset)
Output={33, 22, 23, 11, 12}
print(aset.union(bset))
Output={33, 22, 23, 11, 12}
#Intersection of Two sets
print(aset&bset)
Output={33}
print(aset.intersection(bset))
Output={33}
#Difference
print(aset-bset)
Output={11, 22}
print(aset.difference(bset))
Output={11, 22}
#SYmetric difference
print(aset^bset)
Output={11, 12, 22, 23}
print(aset.symmetric_difference(bset))
Output={11, 12, 22, 23}
Dictionary
A dictionary is like an address book where you can find the address or
contact details by knowing only their name, i.e., we associate keys
(name) with values (details).
Note that the key must be unique, just like you cannot find out the
correct information if you have two persons with the exact same name.
One can use only immutable objects (like strings) for the keys of a
dictionary but can use either immutable or mutable objects for the
dictionary's values.
This basically translates to saying that you should use only simple
objects for keys.
Pairs of keys and values are specified in a dictionary by using the
notation
>d = { key1: value1, key2: value2}
Notice that the key-value pairs are separated by a colon, and the pairs
are separated by commas, and all this is enclosed in a pair of curly
braces.
Remember that key-value pairs in a dictionary are not ordered in any
manner. If you want a particular order, then you will have to sort them
yourself before using it.
The dictionaries that we will be using are instances/objects of the dict
class.
>Dictionary Basic Methods
>New key: value pair addition and update of value. >
>Keys have to be immutable data types only. >
>Basic methods= len(), del(), get(), update() and pop(). >
You will get this after seeing the example and performing it by
yourself.
Dictionary
d1={}
print(d1)
Output={}
d2=dict()
print(d2)
Output={}
d1={'a':3,'b':4}
print(d1)
Output={'a': 3, 'b': 4}
print(type(d1))
Output='dict'>
d1={3}
print(d1)
print(type(d1))
Output={3}
'set'>
d1=dict([('a',3),('b',4)])
print(type(d1))
print(d1)
Output= 'dict'>
{'a': 3, 'b': 4}
d2=dict([['a',3],['b',4]])
print(type(d2))
print(d2)
Output= 'dict'>
{'a': 3, 'b': 4}
d1={1:'a',2:'b'}
print(d1)
Output={1: 'a', 2: 'b'}
d1[5]='g'
print(d1)
Output={1: 'a', 2: 'b', 5: 'g'}
d1[1]='g'
print(d1)
Output={1: 'g', 2: 'b', 5: 'g'}
d={1:'a',1:'b'}
print(d)
Output={1: 'b'}
d={(1,3):'a',1:'b'}
print(d)
Output={(1, 3): 'a', 1: 'b'}
d={[1,3]:'a',1:'b'}
print(d)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
----> 1 d={[1,3]:'a',1:'b'}
2 d
TypeError: unhashable type: 'list'
d={1:'a',2:'b'}
print(d)
Output={1: 'a', 2: 'b'}
x=len(d)
print(x)
Output=1
del d
print(d)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
in
----> 1 d
NameError: name 'd' is not defined
d={1:'a',2:'b'}
print(d)
Output={1: 'a', 2: 'b'}
for i in d:
print(i)
Output=1
2
d.keys()
dict_keys([1, 2])
for i in d.keys():
print(i)
Output=1
2
d.values()
dict_values(['a', 'b'])
for i in d.values():
print(i)
Output=a
b
d.items()
dict_items([(1, 'a'), (2, 'b')])
for i,j in d.items():
print(i,j)
Output=1 a
2 b
d={1:'a',2:'b'}
print(d)
Output={1: 'a', 2: 'b'}
d[1]='c'
print(d)
Output={1: 'c', 2: 'b'}
d={1:'a',2:'b'}
print(d)
Output={1: 'a', 2: 'b'}
d1=d.copy()
print(d1)
Output={1: 'a', 2: 'b'}
d1[1]='c'
print(d1)
Output={1: 'c', 2: 'b'}
print(d)
Output={1: 'a', 2: 'b'}
d={1:'a',2:'b'}
print(d)
Output={1: 'a', 2: 'b'}
print(d.get(1))
Output=a
print(d.get(5))
Output=None
print(d.get(5,'No key'))
print(d)
Output=No key
{1: 'a', 2: 'b'}
d2={3:'c',4:'d'}
print(d2)
Output={3: 'c', 4: 'd'}
d.update(d2)
print(d2)
print(d)
Output={3: 'c', 4: 'd'}
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
print(d)
Output={2: 'b', 3: 'c', 4: 'd'}
d1={1:'a',2:'b',3:'c'}
print(d1)
Output={1: 'a', 2: 'b', 3: 'c'}
k=d1.pop(1)
print(k)
Output='a'
print(d1)
Output={2: 'b', 3: 'c'}
k=d1.pop(5,'No key')
print(k)
Output='No key'
print(d1)
Output={2: 'b', 3: 'c'}
d={y:y*2 for y in range(5)}
print(d)
Output={0: 0, 1: 2, 2: 4, 3: 6, 4: 8}
x={'a':[4,5,6],'b':(11,22,{'c':9})}
print(x)
Output={'a': [4, 5, 6], 'b': (11, 22, {'c': 9})}
x['a'][1]=55
print(x)
Output={'a': [4, 55, 6], 'b': (11, 22, {'c': 9})}
x['b'][2]['c']=99
print(x)
Output={'a': [4, 55, 6], 'b': (11, 22, {'c': 99})}
>In the next chapter, we will start with advanced concepts. >
So stay tuned!
THANK YOU! >
crossorigin="anonymous"
src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-9869442004118280"
>
data-ad-client="ca-pub-9869442004118280"
data-ad-format="auto"
data-ad-slot="3195394695"
data-full-width-responsive="true"
style="display: block;"
>
Comments
Post a Comment
If you have any query, please let us know