Understanding Tuples and Dictionaries in Computing Sequences

 
15-110: Principles of
Computing
 
Sequences- Part IV (Tuples and Dictionaries)
Lecture 15, October 23, 2018
 
Mohammad Hammoud
Carnegie Mellon University in Qatar
 
Today…
 
Last Session:
Sequences- Part III (Matrix Operations as an Application on Lists)
 
Today’s Session:
Sequences- Part IV:
Tuples
Dictionaries
 
 
Tuples
 
Tuples are very similar to lists, but they are 
immutable
 (i.e.,
unchangeable)
 
Tuples are written with round brackets as follows:
 
 
t1 = (1, 2, 3)
t2 = (“a”, “b”, “c”, ”d”)
t3 = (200, “A”, [4, 5], 3.2)
print(t1)
print(t2)
print(t3)
Tuples
 
Like lists, tuples can:
Contain any and different types of elements
Contain duplicate elements (e.g., (1, 1, 2))
Be indexed exactly in the same way (i.e., using the [] brackets)
Be sliced exactly in the same way (i.e., using the [::] notation)
Be concatenated (e.g., t = (1, 2, 3) + (“a”, “b”, “c”))
Be repeated (e.g., t = (“a”, “b”) * 10)
Be nested (e.g., t = ((1, 2), (3, 4), ((“a”, “b”, ”c”), 3.4))
Be passed to a function, but will result in 
pass-by-value
 and not 
pass-by-
reference
 outcome since it is immutable
Be iterated over
 
 
 
Examples
 
t1 = ("a", "b", "c")
print(t1[::-1])
t2 = ("a", "b", "c")
t3 = t1 + t2
print(t3)
t3 = t3 * 4
print(t3)
for i in t3:
    print(i, end = " ")
print()
This will print the elements of t1 in 
a 
reversed order
, but will not change 
t1 itself since it is immutable
This will concatenate t1 and t2 and
assign the result to t3 (again, t1 and
t2 will be unchanged since they are
immutable)
This will repeat t3 four times and
assign the result to t3. Hence,
t3 will be 
overwritten
 (i.e.,  NOT
changed in place- because it is
immutable-, but redefined with a
new value)
Examples
 
t4 = ((1, 2, 3), ("a", "b", "c"))
for j in t4:
    for k in j:
        print(k,end = " ")
    print()
This is an example of nesting, where 
a matrix with 2 rows and
3 columns is created. The first row 
includes the elements 1, 2, and 3. 
The second row includes the elements 
“a”, “b”, and “c”.
This 
outer loop 
iterates over each
element in t4; that is, it gets first the
element (1, 2, 3) and second the
element (“a”, “b”, “c”)
This 
inner loop 
iterates over each
element read by the outer loop; that
is, it first iterates over the elements
of the element (1, 2, 3), and second
it iterates over the elements of the
element (“a”, “b”, “c”)
Examples
 
def func1(t):
    t = t * 2
t = (1, 2, 3)
print(t)
func1(t)
print(t)
This will output (1, 2, 3)
This will also output (1, 2, 3) since
tuples are immutable, hence, will
always exhibit a passed-by-value
behavior
This change on 
t
 remains 
local
 to the function
since a value of 
t
 was passed and not a 
reference
 to it
Using Functions with Tuples
 
You can also use functions with tuples
 
 
 
t1 = (1, 2, 3, 1, 5, 1)
print(t1.count(1))
print(t1.index(1))
The count(
x
) function returns the number of 
elements with the specified value 
x
 (e.g., 
x
 is 1 
in this example)
The index(
x
) function returns the index of the
first  element
 with the specified value 
x
 (e.g., x
is 1 in this example)
 
Output:
3
0
In fact, Python has only these two built-in functions that can be used
on tuples
Towards Dictionaries
 
Lists and tuples hold elements with 
only integer
 
indices
 
 
 
 
So in essence, each element has an 
index
 (or a 
key
) which can 
only
 be
an integer, and a 
value
 which can be of any type (e.g., in the above
list/tuple, the first element has key 0 and value 45)
What if we want to store elements with non-integer indices (or 
keys
)?
 
 
 
Integer
Indices
Dictionaries
 
In Python, you can use a dictionary to store elements with 
keys of any
types
 (not necessarily only integers like lists and tuples) and 
values of
any types
 as well
 
 
 
The above dictionary can be defined in Python as follows:
       dic = {
"NUM"
:45, 
1000
:"coding", 
2000
:4.5, 
3.4
:7, 
"XXX"
:89}
 
 
keys of different types
Each element is a 
key
:value
 pair, and elements are separated by commas
 
key
 
value
 
Values of different types
Dictionaries
 
In summary, dictionaries:
Can contain any and different types of elements (i.e., keys and values)
Can contain only 
unique
 keys but duplicate values
 
 
 
 
 
 
Can be indexed 
but only 
through keys (i.e., dic2[“a”] will return 1 but dic2[0]
will return an error since there is no element with key 0 in dic2 above)
 
 
 
 
Output: {'a': 2, 'b': 2}
dic2 = {"a":1, "a":2, "b":2}
print(dic2)
 
The element “a”:2 will override the element “a”:1
because only ONE element can have key “a”
Dictionaries
 
In summary, dictionaries:
CANNOT be concatenated
CANNOT be repeated
Can be nested (e.g., d = {"first":{1:1}, "second":{2:"a"}}
Can be passed to a function and will result in a 
pass-by-reference
 and not
pass-by-value
 behavior since it is 
immutable
 
(like lists)
 
 
 
 
Output:
{'first': {1: 1}, 'second': {2: 'a'}}
{'first': [1, 2, 3], 'second': {2: 'a'}}
def func1(d):
    d["first"] = [1, 2, 3]
dic = {"first":{1:1},
"second":{2:"a"}}
print(dic)
func1(dic)
print(dic)
Dictionaries
In summary, dictionaries:
Can be iterated over
 
Output:
dic = {"first": 1, "second": 2, "third": 3}
for i in dic:
    print(i)
 
How to get the values?
 
first
second
third
 
ONLY the keys will be returned.
Dictionaries
In summary, dictionaries:
Can be iterated over
 
Output:
dic = {"first": 1, "second": 2, "third": 3}
for i in dic:
    print(
dic[
i
]
)
 
1
2
3
 
Values can be accessed via indexing!
Adding Elements to a Dictionary
 
How to add elements to a dictionary?
By indexing the dictionary via a key and assigning a corresponding value
 
 
 
 
Output:
dic = {"first": 1, "second": 2, "third": 3}
print(dic)
dic["fourth"] = 4
print(dic)
 
{'first': 1, 'second': 2, 'third': 3}
{'first': 1, 'second': 2, 'third': 3, 'fourth': 4}
Adding Elements to a Dictionary
How to add elements to a dictionary?
By indexing the dictionary via a key and assigning a corresponding value
 
Output:
dic = {"first": 1, "second": 2, "third": 3}
print(dic)
dic[”second"] = 4
print(dic)
 
{'first': 1, 'second': 2, 'third': 3}
{'first': 1, 'second’: 
4
, 'third': 3}
 
If the key already exists,
the value will be overridden
Deleting Elements to a Dictionary
 
How to delete elements in a dictionary?
By using 
del
 
 
 
Output:
dic = {"first": 1, "second": 2, "third": 3}
print(dic)
dic["fourth"] = 4
print(dic)
del
 dic["first"]
print(dic)
 
{'first': 1, 'second': 2, 'third': 3}
{'first': 1, 'second': 2, 'third': 3, 'fourth': 4}
{'second': 2, 'third': 3, 'fourth': 4}
Deleting Elements to a Dictionary
How to delete elements in a dictionary?
Or by using the function 
pop(key)
 
Output:
dic = {"first": 1, "second": 2, "third": 3}
print(dic)
dic["fourth"] = 4
print(dic)
dic.pop(“first”)
print(dic)
 
{'first': 1, 'second': 2, 'third': 3}
{'first': 1, 'second': 2, 'third': 3, 'fourth': 4}
{'second': 2, 'third': 3, 'fourth': 4}
Dictionary Functions
 
Many other functions can also be used with dictionaries
 
 
 
Dictionary Functions
 
Many other functions can also be used with dictionaries
 
 
 
Next Lecture…
 
Practice on Tuples and Dictionaries
 
 
Slide Note
Embed
Share

Tuples are immutable data structures similar to lists, written with round brackets. They can contain different types of elements, be sliced and indexed similarly to lists, concatenated, repeated, nested, and passed by value to functions. Examples show how tuples operate and differentiate from lists.This will print the elements of t1 in a reversed order, but will not change t1 itself since it is immutable. This will concatenate t1 and t2 and assign the result to t3, without altering the original tuples. Through nesting examples, a matrix is created and elements are iterated over. Tuples remain local to functions when passed as values.


Uploaded on Jul 28, 2024 | 1 Views


Download Presentation

Please find below an Image/Link to download the presentation.

The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author. Download presentation by click this link. If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.

E N D

Presentation Transcript


  1. 15-110: Principles of Computing Sequences- Part IV (Tuples and Dictionaries) Lecture 15, October 23, 2018 Mohammad Hammoud Carnegie Mellon University in Qatar

  2. Today Last Session: Sequences- Part III (Matrix Operations as an Application on Lists) Today s Session: Sequences- Part IV: Tuples Dictionaries

  3. Tuples Tuples are very similar to lists, but they are immutable (i.e., unchangeable) Tuples are written with round brackets as follows: t1 = (1, 2, 3) t2 = ( a , b , c , d ) t3 = (200, A , [4, 5], 3.2) print(t1) print(t2) print(t3)

  4. Tuples Like lists, tuples can: Contain any and different types of elements Contain duplicate elements (e.g., (1, 1, 2)) Be indexed exactly in the same way (i.e., using the [] brackets) Be sliced exactly in the same way (i.e., using the [::] notation) Be concatenated (e.g., t = (1, 2, 3) + ( a , b , c )) Be repeated (e.g., t = ( a , b ) * 10) Be nested (e.g., t = ((1, 2), (3, 4), (( a , b , c ), 3.4)) Be passed to a function, but will result in pass-by-value and not pass-by- reference outcome since it is immutable Be iterated over

  5. Examples This will print the elements of t1 in a reversed order, but will not change t1 itself since it is immutable t1 = ("a", "b", "c") print(t1[::-1]) t2 = ("a", "b", "c") t3 = t1 + t2 print(t3) t3 = t3 * 4 print(t3) This will concatenate t1 and t2 and assign the result to t3 (again, t1 and t2 will be unchanged since they are immutable) This will repeat t3 four times and assign the result to t3. Hence, t3 will be overwritten (i.e., NOT changed in place- because it is immutable-, but redefined with a new value) for i in t3: print(i, end = " ") print()

  6. Examples This is an example of nesting, where a matrix with 2 rows and 3 columns is created. The first row includes the elements 1, 2, and 3. The second row includes the elements a , b , and c . t4 = ((1, 2, 3), ("a", "b", "c")) for j in t4: for k in j: print(k,end = " ") print() This outer loop iterates over each element in t4; that is, it gets first the element (1, 2, 3) and second the element ( a , b , c ) This inner loop iterates over each element read by the outer loop; that is, it first iterates over the elements of the element (1, 2, 3), and second it iterates over the elements of the element ( a , b , c )

  7. Examples This change on t remains local to the function since a value of t was passed and not a reference to it def func1(t): t = t * 2 t = (1, 2, 3) print(t) func1(t) print(t) This will output (1, 2, 3) This will also output (1, 2, 3) since tuples are immutable, hence, will always exhibit a passed-by-value behavior

  8. Using Functions with Tuples You can also use functions with tuples The count(x) function returns the number of elements with the specified value x (e.g., x is 1 in this example) t1 = (1, 2, 3, 1, 5, 1) print(t1.count(1)) print(t1.index(1)) The index(x) function returns the index of the first element with the specified value x (e.g., x is 1 in this example) Output: 3 0 In fact, Python has only these two built-in functions that can be used on tuples

  9. Towards Dictionaries Lists and tuples hold elements with only integer indices 45 Coding 4.5 7 89 0 1 2 3 4 Integer Indices So in essence, each element has an index (or a key) which can only be an integer, and a value which can be of any type (e.g., in the above list/tuple, the first element has key 0 and value 45) What if we want to store elements with non-integer indices (or keys)?

  10. Dictionaries In Python, you can use a dictionary to store elements with keys of any types (not necessarily only integers like lists and tuples) and values of any types as well 45 Coding 4.5 7 89 NUM 1000 2000 3.4 XXX keys of different types Values of different types The above dictionary can be defined in Python as follows: dic = {"NUM":45, 1000:"coding", 2000:4.5, 3.4:7, "XXX":89} key value Each element is a key:value pair, and elements are separated by commas

  11. Dictionaries In summary, dictionaries: Can contain any and different types of elements (i.e., keys and values) Can contain only unique keys but duplicate values dic2 = {"a":1, "a":2, "b":2} print(dic2) Output: {'a': 2, 'b': 2} The element a :2 will override the element a :1 because only ONE element can have key a Can be indexed but only through keys (i.e., dic2[ a ] will return 1 but dic2[0] will return an error since there is no element with key 0 in dic2 above)

  12. Dictionaries In summary, dictionaries: CANNOT be concatenated CANNOT be repeated Can be nested (e.g., d = {"first":{1:1}, "second":{2:"a"}} Can be passed to a function and will result in a pass-by-reference and not pass-by-value behavior since it is immutable (like lists) def func1(d): d["first"] = [1, 2, 3] Output: {'first': {1: 1}, 'second': {2: 'a'}} {'first': [1, 2, 3], 'second': {2: 'a'}} dic = {"first":{1:1}, "second":{2:"a"}} print(dic) func1(dic) print(dic)

  13. Dictionaries In summary, dictionaries: Can be iterated over dic = {"first": 1, "second": 2, "third": 3} for i in dic: print(i) first second third ONLY the keys will be returned. Output: How to get the values?

  14. Dictionaries In summary, dictionaries: Can be iterated over dic = {"first": 1, "second": 2, "third": 3} for i in dic: print(dic[i]) 1 2 3 Values can be accessed via indexing! Output:

  15. Adding Elements to a Dictionary How to add elements to a dictionary? By indexing the dictionary via a key and assigning a corresponding value dic = {"first": 1, "second": 2, "third": 3} print(dic) dic["fourth"] = 4 print(dic) {'first': 1, 'second': 2, 'third': 3} {'first': 1, 'second': 2, 'third': 3, 'fourth': 4} Output:

  16. Adding Elements to a Dictionary How to add elements to a dictionary? By indexing the dictionary via a key and assigning a corresponding value dic = {"first": 1, "second": 2, "third": 3} print(dic) dic[ second"] = 4 print(dic) If the key already exists, the value will be overridden {'first': 1, 'second': 2, 'third': 3} {'first': 1, 'second : 4, 'third': 3} Output:

  17. Deleting Elements to a Dictionary How to delete elements in a dictionary? By using del dic = {"first": 1, "second": 2, "third": 3} print(dic) dic["fourth"] = 4 print(dic) del dic["first"] print(dic) Output: {'first': 1, 'second': 2, 'third': 3} {'first': 1, 'second': 2, 'third': 3, 'fourth': 4} {'second': 2, 'third': 3, 'fourth': 4}

  18. Deleting Elements to a Dictionary How to delete elements in a dictionary? Or by using the function pop(key) dic = {"first": 1, "second": 2, "third": 3} print(dic) dic["fourth"] = 4 print(dic) dic.pop( first ) print(dic) Output: {'first': 1, 'second': 2, 'third': 3} {'first': 1, 'second': 2, 'third': 3, 'fourth': 4} {'second': 2, 'third': 3, 'fourth': 4}

  19. Dictionary Functions Many other functions can also be used with dictionaries Function Description dic.clear() dic.copy() dic.items() Removes all the elements from dictionary dic Returns a copy of dictionary dic Returns a list containing a tuple for each key-value pair in dictionary dic dic.get(k) dic.keys() Returns the value of the specified key k from dictionary dic Returns a list containing all the keys of dictionary dic dic.pop(k) Removes the element with the specified key k from dictionary dic

  20. Dictionary Functions Many other functions can also be used with dictionaries Function Description dic.popitem() dic.values() Removes the last inserted key-value pair in dictionary dic Returns a list of all the values in dictionary dic

  21. Next Lecture Practice on Tuples and Dictionaries

More Related Content

giItT1WQy@!-/#giItT1WQy@!-/#giItT1WQy@!-/#giItT1WQy@!-/#giItT1WQy@!-/#