Skip to content
Snippets Groups Projects
Commit 403ffc14 authored by Anna Meyer's avatar Anna Meyer
Browse files

lec 13 notes

parent 024050ed
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
sum23/lecture_materials/11_JSON/lec_11_json_notes.ipynb 0 → 100644
+ 645
− 0
View file @ 403ffc14
%% Cell type:markdown id:1d888215 tags:
# JSON
%% Cell type:markdown id:7ccf358c tags:
### Learning Objectives:
- Interpret JSON formatted data and recognize differences between JSON and Python
- Deserialize data from JSON for use in Python programs (read)
- Serialize data into JSON for long term storage (write)
%% Cell type:code id:5990f3d6 tags:
``` python
import csv
# TODO: import json module
import json
```
%% Cell type:code id:5662ace1 tags:
``` python
# Deserialize
def read_json(path):
with open(path, encoding = "utf-8") as f: # f is a varaible
return json.load(f) # f represents data in the JSON file (dict, list, etc)
# Serialize
def write_json(path, data):
with open(path, 'w', encoding = "utf-8") as f:
json.dump(data, f, indent = 2)
```
%% Cell type:markdown id:a35312c9 tags:
### Example 1: Sum of numbers (simple JSON)
%% Cell type:code id:d241dc5c tags:
``` python
# TODO 1: Create a new "numsA.json".
# Add the list [1, 2, 3, 4] to "numsA.json" file.
# Use jupyter notebook to create and edit the new file
# TODO 2: Use input built-in function go get JSON file name from user
# Read the JSON file using read_json; capture return value into a variable
my_nums = read_json('nums.json')
# TODO 3: Print type of data returned by function that reads JSON file.
print(type(my_nums))
# TODO 4: Using Python built-in function sum(...), calculate total of numbers in numsA.json, print the total.
sum(my_nums['numsA'])
# TODO 5: Create a new JSON file "numsB.json" and try out the following data:
# [-1, 10, 4,]
# Does that work?
# Change the data to [-1, 10, 4] and try to run the program by providing input as numsB.json
# TODO 6: Create a new JSON file "simple.json" and try out the following data.
# What kind of error do you get with this?
# Fix the error by commenting the line of code that causes the error!
# 3.14
# True
# true
# 'hello'
# "hello"
```
%% Output
<class 'dict'>
73
%% Cell type:markdown id:e830f23f tags:
### Example 2: Score Tracker
%% Cell type:code id:d7655636 tags:
``` python
my_str = "the quick brown fox"
my_str.split(" ")
```
%% Output
['the', 'quick', 'brown', 'fox']
%% Cell type:code id:10e00558 tags:
``` python
player_details = input("Enter player name and score: ")
# TODO 1: extract player name and score into variables
player_name = player_details.split(" ")[0]
player_score = int(player_details.split(" ")[1])
# TODO 2: Define an empty "scores" dictionary to keep track of players'
# scores.
# KEY: player name VALUE: player scores list
scores = dict()
input_file = "score_history.json"
# TODO 3: Check if player name is a key in the scores dictionary.
# If not, create a new key for player name and value as empty list
# to keep track of that player's scores.
if not player_name in scores:
scores[player_name] = []
# TODO 4: Add player's score to the player's list in scores dictionary
scores[player_name].append(player_score)
# TODO 5: Create a "score_history.json" file and popluate that file with
# empty dictionary {}
write_json("score_history.json", {})
# TODO 6: Read "score_history.json" to populate initial "scores" dict,
# instead of the empty dict created in TODO 2.
scores = read_json("score_history.json")
print(scores)
# copying this here
if not player_name in scores:
scores[player_name] = []
# TODO 4: Add player's score to the player's list in scores dictionary
scores[player_name].append(player_score)
# TODO 7: Calculate average score for that player
# print("Average score for {} is {}."???)
total = 0
count = 0
for score in scores[player_name]:
total += score
count += 1
avg_score = total/count
print("Average score for {} is {}".format(player_name,str(avg_score)))
# TODO 8: At the end of the program, write the updated scores from dict
# into the "score_history.json" file
write_json("score_history.json", scores)
# That's it, now you have a program that helps you keep track
# of player scores permanently.
```
%% Output
Enter player name and score: anna 10
{}
Average score for anna is 10.0
%% Cell type:markdown id:b920d6e0 tags:
### Example 3: Kiva.com Micro-lending site
Many Web Sites have APIs that allow you to get their data.
%% Cell type:code id:dc891f5a tags:
``` python
# TODO: read "kiva.json"
kiva_dict = read_json("kiva.json")
# TODO: explore the type of the data structure returned by read_json
type(kiva_dict)
```
%% Output
dict
%% Cell type:markdown id:e29310b6 tags:
How to explore an unknown JSON?
- If you run into a `dict`, try `.keys()` method to look at the keys of the dictionary, then use lookup process to explore further
- If you run into a `list`, iterate over the list and print each item
%% Cell type:code id:31fe630f tags:
``` python
kiva_dict.keys()
# TODO: lookup the value corresponding to the key data
type(kiva_dict['data'])
kiva_dict['data'].keys()
# TODO: you know what to do next ... explore type again
type(kiva_dict['data']['lend'])
kiva_dict['data']['lend'].keys()
type(kiva_dict['data']['lend']['loans'])
kiva_dict['data']['lend']['loans'].keys()
type(kiva_dict['data']['lend']['loans']['values'])
```
%% Output
list
%% Cell type:code id:e09b064f tags:
``` python
kiva_dict['data']['lend']['loans']['values']
```
%% Output
[{'name': 'Polikseni',
'description': "Polikseni is 70 years old and married. She and her husband are both retired and their main income is a retirement pension of $106 a month for Polikseni and disability income for her husband of $289 a month. <br /><br />Polikseni's husband, even though disabled, works in a very small shop as a watchmaker on short hours, just to provide additional income for his family and to feel useful. Polikseni's husband needs constant medical treatment due to his health problems. She requested another loan, which she will use to continue paying for the therapy her husband needs. With a part of the loan, she is going to pay the remainder of the previous loan.",
'loanAmount': '1325.00',
'geocode': {'city': 'Korce',
'country': {'name': 'Albania',
'region': 'Eastern Europe',
'fundsLentInCountry': 9051250}}},
{'name': 'Safarmo',
'description': "Safarmo is 47 years old. She lives with her husband and her children in Khuroson district. <br /><br />Safarmo is a seamstress. She has been engaged in sewing for 10 years. She learned this activity with help of her mother and elder sister. <br /><br />Safarmo's sewing machine is old and she cannot work well. Her difficulty is lack of money. That’s why she applied for a loan to buy a new modern sewing machine. <br /><br />Safarmo needs your support.",
'loanAmount': '1075.00',
'geocode': {'city': 'Khuroson',
'country': {'name': 'Tajikistan',
'region': 'Asia',
'fundsLentInCountry': 64243075}}},
{'name': 'Elizabeth',
'description': 'Elizabeth is a mom blessed with five lovely children, who are her greatest motivation in life. She lives in the Natuu area of Kenya. Elizabeth is one of the most hardworking women in sub-Saharan Africa. Being a mother and living in a poor country has never been an excuse for Elizabeth, who has practiced mixed farming for the past few years.<br /><br />The cultural expectations in her area contribute to the notion that men should support their families. However, Elizabeth works independently for the success of her children. She perseveres because she wants to provide a better future for them.<br /><br />Elizabeth has always loved farming. She is a very proud farmer and enjoys milking her dairy cows. Elizabeth keeps poultry and grows crops, but she has not been making a good profit because of poor farming inputs. <br /><br />Elizabeth will use this loan to buy farm inputs and purchase high-quality seeds and good fertilizer to improve her crop production. Modern farming requires the use of modern techniques, and, therefore, using high-quality seeds will assure her of a bumper harvest and increased profit levels.<br /><br />Elizabeth is very visionary. Her goal for the season is to boost her crop production over the previous year.',
'loanAmount': '800.00',
'geocode': {'city': 'Matuu',
'country': {'name': 'Kenya',
'region': 'Africa',
'fundsLentInCountry': 120841775}}},
{'name': 'Ester',
'description': 'Ester believes that this year is her year of prosperity. Ester is a hardworking, progressive and honest farmer from a very remote village in the Kitale area of Kenya. This area is very fertile, with favorable weather patterns that support farming activities. Ester is happily married and the proud mother of lovely children. Together, they live on a small piece of land that she really treasures. Her primary sources of income are eggs and milk.<br /><br />Although this humble and industrious mother makes a profit, she faces the challenge of not being able to produce enough to meet the readily available market. Therefore, she is seeking funds from Kiva lenders to buy farm inputs such as good fertilizer and good-quality seeds. Through this loan, Ester should double her production, and this will translate into increased income. She then intends to save more money in the future so that she can develop her farming.<br /><br />One objective that Juhudi Kilimo aims at fulfilling is increasing the ease of accessing farm inputs and income-generating assets for farmers. Through the intervention of Juhudi Kilimo and Kiva, inputs such as fertilizers and pesticides have become more accessible to its members than buying a bottle of water. Ester is very optimistic and believes this loan will change her life completely.',
'loanAmount': '275.00',
'geocode': {'city': 'Kitale',
'country': {'name': 'Kenya',
'region': 'Africa',
'fundsLentInCountry': 120841775}}},
{'name': 'Cherifa',
'description': 'Cherifa is married, 57 years old with two children. She caters and also sells the local drink. She asks for credit to buy the necessities, in particular bags of anchovies, bags of maize and bundles of firewood. She wants to have enough income to run the house well.',
'loanAmount': '875.00',
'geocode': {'city': 'Agoe',
'country': {'name': 'Togo',
'region': 'Africa',
'fundsLentInCountry': 13719125}}}]
%% Cell type:code id:2a0b65d5 tags:
``` python
kiva_dict['data']['lend']['loans']['values'][0].keys()
```
%% Output
dict_keys(['name', 'description', 'loanAmount', 'geocode'])
%% Cell type:code id:b6cb9c28 tags:
``` python
# TODO: iterate over loans_list and print every borrower's name, loan amount and country details
for person_dict in kiva_dict['data']['lend']['loans']['values']:
borrower_name = person_dict['name']
loan_amount = person_dict['loanAmount']
country_details = person_dict['geocode']
print("Borrower name:", borrower_name)
print("Loan amount: $", loan_amount, sep = "")
print("Country details:", country_details)
print("------------------------------------------------------------------------------------------------")
```
%% Output
Borrower name: Polikseni
Loan amount: $1325.00
Country details: {'city': 'Korce', 'country': {'name': 'Albania', 'region': 'Eastern Europe', 'fundsLentInCountry': 9051250}}
------------------------------------------------------------------------------------------------
Borrower name: Safarmo
Loan amount: $1075.00
Country details: {'city': 'Khuroson', 'country': {'name': 'Tajikistan', 'region': 'Asia', 'fundsLentInCountry': 64243075}}
------------------------------------------------------------------------------------------------
Borrower name: Elizabeth
Loan amount: $800.00
Country details: {'city': 'Matuu', 'country': {'name': 'Kenya', 'region': 'Africa', 'fundsLentInCountry': 120841775}}
------------------------------------------------------------------------------------------------
Borrower name: Ester
Loan amount: $275.00
Country details: {'city': 'Kitale', 'country': {'name': 'Kenya', 'region': 'Africa', 'fundsLentInCountry': 120841775}}
------------------------------------------------------------------------------------------------
Borrower name: Cherifa
Loan amount: $875.00
Country details: {'city': 'Agoe', 'country': {'name': 'Togo', 'region': 'Africa', 'fundsLentInCountry': 13719125}}
------------------------------------------------------------------------------------------------
%% Cell type:markdown id:26b4c70c tags:
### Let's write student information dataset into various JSON files
%% Cell type:code id:c120d0eb tags:
``` python
# inspired by https://automatetheboringstuff.com/2e/chapter16/
def process_csv(filename):
exampleFile = open(filename, encoding="utf-8")
exampleReader = csv.reader(exampleFile)
exampleData = list(exampleReader)
exampleFile.close()
return exampleData
survey_data = process_csv('cs220_survey_data.csv')
cs220_header = survey_data[0]
cs220_data = survey_data[1:]
```
%% Cell type:code id:47cb92e9 tags:
``` python
def cell(row_idx, col_name):
"""
Returns the data value (cell) corresponding to the row index and
the column name of a CSV file.
"""
col_idx = cs220_header.index(col_name)
val = cs220_data[row_idx][col_idx]
# handle missing values, by returning None
if val == '':
return None
# handle type conversions
if col_name in ["Age",]:
return int(val)
return val
```
%% Cell type:code id:9a84cfb8 tags:
``` python
def bucketize(bucket_column):
"""
generates and returns bucketized data based on bucket_column
"""
# Key: unique bucketize column value; Value: list of lists (rows having that unique column value)
buckets = dict()
for row_idx in range(len(cs220_data)):
row = cs220_data[row_idx]
col_value = cell(row_idx, bucket_column)
if col_value not in buckets:
# create a new bucket when there is no existing bucket
buckets[col_value] = []
buckets[col_value].append(row)
return buckets
# TODO: create lecture based buckets and store result into lecture_buckets
lec_buckets = bucketize('Lecture')
# TODO: What is the type of lec_buckets? A dictionary of lists
type(lec_buckets)
type(lec_buckets['LEC001'])
# TODO: write lec_buckets into a JSON file called "lecture_cs220_data.json"
write_json("lecture_cs220_data.json", lec_buckets)
# TODO: create major based buckets and store result into major_buckets
# TODO: write major_buckets into a JSON file called "major_cs220_data.json"
```
%% Cell type:code id:cf1a8133 tags:
``` python
```
%% Cell type:code id:f36a584a tags:
``` python
def transform(header, data):
"""
Transform data into a list of dictionaries
"""
transformed_data = [] #should be defined outside the for loop, because it stores the entire data
for row in data:
#should be defined inside the for loop, because it represents one row as a dictionary
row_dict = {} # Key: header; Value: data
for idx in range(len(row)):
row_dict[header[idx]] = row[idx]
transformed_data.append(row_dict)
return transformed_data
transformed_data = transform(cs220_header, cs220_data)
# TODO: What is the type of transformed_data? A ______ of _________
# TODO: write transformed_data into a JSON file called "cs220_survey_data.json"
```
%% Cell type:markdown id:5279cdab tags:
### Self-practice: explore real-world JSON
### Weather for UW-Madison campus
%% Cell type:code id:7a4efc8c tags:
``` python
# TODO: read "weather.json"
# TODO: explore the type of the data structure returned by read_json
# display the data from "weather.json"
```
%% Cell type:code id:c1b98641 tags:
``` python
# TODO: display the keys of the weather.json dict
# TODO: lookup the value corresponding to the 'properties'
# TODO: you know what to do next ... explore type again
```
%% Cell type:code id:ca457052 tags:
``` python
# TODO: display the keys of the properties dict
# TODO: lookup the value corresponding to the 'periods'
# TODO: you know what to do next ... explore type again
```
%% Cell type:code id:34f6dfa4 tags:
``` python
# TODO: extract periods list into a variable
# TODO: iterate over loans_list and print every periods's startTime, endTime, temperature, and temperatureUnit
for period_dict in periods_list:
print("Start time:", start_time)
print("End time:", end_time)
print("Temperature: {} degree {}".format(temperature, temperature_unit))
print("------------------------------------------------------------------------------------------------")
```
sum23/lecture_materials/12_Objects/lec_12_objects_references_notes.ipynb 0 → 100644
+ 925
− 0
View file @ 403ffc14
%% Cell type:markdown id: tags:
# Objects and references
%% Cell type:code id: tags:
``` python
# import statements
from collections import namedtuple
```
%% Cell type:markdown id: tags:
### Review 1: What is the type of: {}
1. set
2. dict
%% Cell type:code id: tags:
``` python
type({})
```
%% Output
dict
%% Cell type:markdown id: tags:
### Review 2: If S is a string and L is a list, which line definitely fails?
1. S[-1] = "."
2. L[len(S)] = S
%% Cell type:code id: tags:
``` python
# s[-1] = "." will fail since strings are immutable
```
%% Cell type:code id: tags:
``` python
# Scenario 1: length of S is less than length of L
# This would work.
S = "abcde"
print(len(S))
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
L[len(S)] = S
L
```
%% Output
5
[1, 2, 3, 4, 5, 'abcde', 7, 8, 9, 10]
%% Cell type:code id: tags:
``` python
#Scenario 2: length of S is greater than length of L
# This wouldn't work!
S = "abcdefghijklmnopqrstuvwxyz"
print(len(S))
L = [1, 2, 3, 4, 5]
L[len(S)] = S
```
%% Output
26
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
Cell In[3], line 6
4 print(len(S))
5 L = [1, 2, 3, 4, 5]
----> 6 L[len(S)] = S
IndexError: list assignment index out of range
%% Cell type:markdown id: tags:
### Review 3: Which type is immutable?
1. str
2. list
3. dict
%% Cell type:code id: tags:
``` python
# strings are immutable
list = [1,2,3]
list[0] = 5
```
%% Cell type:markdown id: tags:
### Learning objectives:
- Explain the difference between objects and references, and stack and heap.
- primitive data types (int, float, str, bool) are objects in Python
- Understand new mental model for state (v2)
- incorporates objects and references
- Determine the side effects that occur when modifying parameters.
- Use tuples to store immutable sequences of values.
- creating custom types (syntax, purpose - to store user-defined data objects):
- namedtuple (immutable)
%% Cell type:markdown id: tags:
## Objects vs references
Observations:
- objects have a "life of their own" beyond variables or even function frames
- here there are dict and list objects (others are possible)
- references show up two places: as variables and values in data structures
- all primitive values (int, str, float, bool) are objects too in Python
<div>
<img src="attachment:Objects_references.png" width="600"/>
</div>
Questions:
- why do we need this more complicated model?
- how can we create new types of objects?
- how can we compare objects and references?
- how can we copy objects to create new objects?
%% Cell type:markdown id: tags:
## Determine the side effects that occur when modifying parameters.
- Rule 1: during variable assignment, new variable references whatever is being referenced by the variable on the RHS.
- Rule 2: parameters reference whatever is being referenced by the argument variables.
### Copy the examples below into Python Tutor and trace the code
%% Cell type:code id: tags:
``` python
# Example 1: Reassigning parameters
def f(x):
x *= 3
print("f:", x)
num = 10
f(num)
print("after:", num)
```
%% Cell type:code id: tags:
``` python
# Example 2: Modifying a list
def f(items):
items.append("!!!")
print("f:", items)
words = ['hello', 'world']
f(words)
print("after:", words)
```
%% Cell type:code id: tags:
``` python
# Example 3: Reassign new list
def f(items):
items = items + ["!!!"]
print("f:", items)
words = ['hello', 'world']
f(words)
print("after:", words)
```
%% Cell type:code id: tags:
``` python
# Example 4: in-place sort
def first(items):
return items[0]
def smallest(items):
items.sort()
return items[0]
numbers = [4,5,3,2,1]
print("first:", first(numbers))
print("smallest:", smallest(numbers))
print("first:", first(numbers))
```
%% Cell type:code id: tags:
``` python
# Example 5: sorted sort
def first(items):
return items[0]
def smallest(items):
items = sorted(items)
return items[0]
numbers = [4,5,3,2,1]
print("first:", first(numbers))
print("smallest:", smallest(numbers))
print("first:", first(numbers))
```
%% Cell type:markdown id: tags:
In summary, write one good thing and bad thing about lists being mutable
%% Cell type:code id: tags:
``` python
# good thing - flexibility to change the list object directly from inside a function
# bad thing - accidental list object modification! What if you don't want anyone to
# modify your list object?
```
%% Cell type:markdown id: tags:
## Tuple data structure
- immutable version of lists
<div>
<img src="attachment:Tuples.png" width="600"/>
</div>
%% Cell type:code id: tags:
``` python
scores = [32, 55, 72, 91] # a list is a mutable sequence
scores[-1] = 100
print(scores)
```
%% Output
[32, 55, 72, 100]
%% Cell type:code id: tags:
``` python
some_tuple = (7, 4, -3) # a tuple is an immutable sequence
# Indexing
print("First val is:", some_tuple[0])
# Slicing
print("Subset tuple is:", some_tuple[1:3])
# For loop
for val in some_tuple:
print(val)
# Cannot mutate
some_tuple[2] = 4 # TypeError
```
%% Output
First val is: 7
Subset tuple is: (4, -3)
7
4
-3
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[2], line 14
11 print(val)
13 # Cannot mutate
---> 14 some_tuple[2] = 4 # TypeError
TypeError: 'tuple' object does not support item assignment
%% Cell type:code id: tags:
``` python
# Can tuples be sorted? TODO: discuss with your neighbor.
some_tuple.sort() # AttributeError
```
%% Output
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[3], line 3
1 # Can tuples be sorted? TODO: discuss with your neighbor.
----> 3 some_tuple.sort() # AttributeError
AttributeError: 'tuple' object has no attribute 'sort'
%% Cell type:code id: tags:
``` python
# What about using sorted function?
print(some_tuple)
new_list = sorted(some_tuple)
print(new_list)
```
%% Output
(7, 4, -3)
[-3, 4, 7]
%% Cell type:markdown id: tags:
### What are the key features of tuples?
%% Cell type:code id: tags:
``` python
# 1. immutable
# 2. indexing
# 3. slicing
# 4. for loops
```
%% Cell type:markdown id: tags:
#### (1+2) ---> is this a tuple or specifying operator precedence?
%% Cell type:code id: tags:
``` python
type( (1+2) )
```
%% Output
int
%% Cell type:markdown id: tags:
#### So how do we create a tuple of size 1 (1+2,)?
%% Cell type:code id: tags:
``` python
type( (1+2,) )
```
%% Output
tuple
%% Cell type:markdown id: tags:
### Usecase for tuples:
1. storing immutable data, for example: student netid or campus ID
2. can be used as dictionary keys (recall that we cannot use lists as dictionary keys)
%% Cell type:code id: tags:
``` python
# Fails with TypeError
buildings = {
[0,0]: "Comp Sci",
[0,2]: "Psychology",
[4,0]: "Noland",
[1,8]: "Van Vleck" }
```
%% Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[7], line 2
1 # Fails with TypeError
----> 2 buildings = {
3 [0,0]: "Comp Sci",
4 [0,2]: "Psychology",
5 [4,0]: "Noland",
6 [1,8]: "Van Vleck" }
TypeError: unhashable type: 'list'
%% Cell type:code id: tags:
``` python
# Works with tuple as keys
buildings = {
(0,0): "Comp Sci",
(0,2): "Psychology",
(4,0): "Noland",
(1,8): "Van Vleck" }
buildings
```
%% Output
{(0, 0): 'Comp Sci',
(0, 2): 'Psychology',
(4, 0): 'Noland',
(1, 8): 'Van Vleck'}
%% Cell type:markdown id: tags:
#### Reference: https://www.w3schools.com/python/python_tuples.asp
%% Cell type:markdown id: tags:
## Custom types
%% Cell type:markdown id: tags:
### Can you spot the bug - v1?
%% Cell type:code id: tags:
``` python
people = [
{"Fname": "Alice", "lname": "Anderson", "age": 30},
{"fname": "Bob", "lname": "Baker", "age": 31},
]
p = people[1]
print("Hello " + p["Fname"] + " " + p["lname"])
```
%% Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
Cell In[11], line 6
1 people = [
2 {"Fname": "Alice", "lname": "Anderson", "age": 30},
3 {"fname": "Bob", "lname": "Baker", "age": 31},
4 ]
5 p = people[1]
----> 6 print("Hello " + p["Fname"] + " " + p["lname"])
KeyError: 'Fname'
%% Cell type:markdown id: tags:
### What is the fix - v1?
%% Cell type:code id: tags:
``` python
# make the capitalization consistent
```
%% Cell type:markdown id: tags:
### Can you spot the bug - v2?
%% Cell type:code id: tags:
``` python
people = [
("Alice", "Anderson", 30),
("Bob", "Baker", 31),
]
p = people[1]
print("Hello " + p[1] + " " + str(p[2]))
```
%% Output
Hello Bob 31
%% Cell type:markdown id: tags:
### What is the fix - v2?
%% Cell type:code id: tags:
``` python
# use p[0] instead of p[1] to get the person's first name
```
%% Cell type:markdown id: tags:
## namedtuple
- need to import using: from collections import namedtuple
<div>
<img src="attachment:namedtuple.png" width="500"/>
</div>
%% Cell type:code id: tags:
``` python
# Create custom type
Person = namedtuple("Person", ["fname", "lname", "age"])
# Create object instance of custom type
p1 = Person("Alice", "Anderson", 30) # positional arguments
p2 = Person(age = 30, fname = "Alice", lname = "Anderson") # keyword arguments
# Create another Person object
p3 = Person("Peter", "Parker", 30)
# Access attributes of custom type
print("Hello " + p1.fname + " " + p1.lname)
```
%% Output
Hello Alice Anderson
%% Cell type:code id: tags:
``` python
# make a list of Persons
people_list = [ p1, p2, p3, Person("Bob", "Meyer", 50)]
```
%% Cell type:code id: tags:
``` python
# print out people
print(people_list, end = "\n\n\n")
# say hello to each person
for p in people_list:
print("Hello", p.fname)
```
%% Output
[Person(fname='Alice', lname='Anderson', age=30), Person(fname='Alice', lname='Anderson', age=30), Person(fname='Peter', lname='Parker', age=30), Person(fname='Bob', lname='Meyer', age=50)]
Hello Alice
Hello Alice
Hello Peter
Hello Bob
%% Cell type:code id: tags:
``` python
# write a function to find the average age of the Persons in people
# Practice
def avg_age(p_list):
"""
computes average age for a list of Person objects
"""
count = 0
total = 0
for p in p_list:
count += 1
total += p.age
return total / count
avg_age(people_list)
```
%% Output
35.0
%% Cell type:markdown id: tags:
### What are the key features of namedtuples?
%% Cell type:code id: tags:
``` python
# 1. immutable
# 2. creates custom types
```
%% Cell type:code id: tags:
``` python
# namedtuples, like all tuples, are immutable
p1.fname = 'Anna'
```
%% Output
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[27], line 1
----> 1 p1.fname = 'Anna'
AttributeError: can't set attribute
%% Cell type:code id: tags:
``` python
# need to provide all arguments, can't have default values like with functions
Person_V2 = namedtuple("Person_V2", ['fname', 'lname', 'age'=20])
p4 = Person_V2("anna", "meyer")
```
%% Output
Cell In[29], line 1
Person_V2 = namedtuple("Person_V2", ['fname', 'lname', 'age'=20])
^
SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of '='?
%% Cell type:markdown id: tags:
#### Self-check: create Student custom type with name, lecture, major, age, and pizza_topping
%% Cell type:code id: tags:
``` python
# Person = namedtuple("Person", ["fname", "lname", "age"])
Student = namedtuple("Student", ["name", "lecture", "major", "age", "pizza_topping"])
```
%% Cell type:markdown id: tags:
#### If you were successful then the cell below should run without errors
%% Cell type:code id: tags:
``` python
# \ helps to split a long line into two lines of code
some_student = Student(name = "Cindy", lecture = "LEC001", major = "Computer Science", \
age = 18, pizza_topping = "pineapple")
print(str(some_student.age) + " year old student named " + some_student.name + \
" is taking CS220/CS319 " + some_student.lecture + ", majoring in " + \
some_student.major + ". They like " + some_student.pizza_topping + \
" on their pizza.")
```
%% Output
18 year old student named Cindy is taking CS220/CS319 LEC001, majoring in Computer Science. They like pineapple on their pizza.
%% Cell type:code id: tags:
``` python
```
sum23/lecture_materials/13_Copying/lec_13_Copying_notes.ipynb 0 → 100644
+ 592
− 0
View file @ 403ffc14
Source diff could not be displayed: it is too large. Options to address this: view the blob.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment