Révisions pour TastyHints.md

kristofer a révisé ce gist 1731423729. Aller à la révision

Aucun changement

kristofer a révisé ce gist 1731423658. Aller à la révision

1 file changed, 1 insertion, 1 deletion

TastyHints.md

			@@ -114,7 +114,7 @@ for task_name, task_status in tasks.items():
114	114		We could put that loop into a function:
115	115
116	116		```python
117		-	def print_tasks(tasks):
	117	+	def display_tasks(tasks):
118	118		for task_name, task_status in tasks.items():
119	119		print("- ", task_name, task_status)
120	120		```

kristofer a révisé ce gist 1731423612. Aller à la révision

1 file changed, 2 insertions

TastyHints.md

			@@ -83,6 +83,8 @@ tasks = {} # creates an empty dictionary
83	83
84	84		tasks['Buy Milk'] = 'not yet'
85	85
	86	+	tasks['Start Lab'] = 'completed'
	87	+
86	88		# to list all the tasks
87	89
88	90		for task_name, task_status in tasks.items():

kristofer a révisé ce gist 1731423530. Aller à la révision

1 file changed, 2 insertions

TastyHints.md

			@@ -71,6 +71,8 @@ for task_name, task_status in tasks.items():
71	71
72	72		## Hint 2
73	73
	74	+	### Adding code to the class
	75	+
74	76		As we have thought about this a bit, we hit on the idea that a dictionary might work well:
75	77
76	78		```python

kristofer a révisé ce gist 1731423483. Aller à la révision

1 file changed, 16 insertions, 8 deletions

TastyHints.md

			@@ -24,14 +24,22 @@ This is the `tasks` variable.
24	24		The most important thing is the tasks you're tracking.
25	25		It tracks all the tasks, things that get added and removed.
26	26
27		-	What are the two things you want to track?
	27	+	What are the two things you want to track about each task?
28	28
29	29		- the name/title of the Task _Buy Milk_
30	30		- status of Task _complete_ or _not yet_
31	31
	32	+	That means you track `(task_name, task_status)`.
32	33		so in Python, if you have a pair things that need to be tracked together, a good possibility is a Dictionary.
33	34
34		-	Imagine a dict like this one:
	35	+	```python
	36	+	tasks = {
	37	+	"task1": "not yet",
	38	+	"task2": "completed"
	39	+	}
	40	+	```
	41	+
	42	+	Imagine some code to get a `tasks` dict with a few tasks in it:
35	43
36	44		```python
37	45
			@@ -56,8 +64,8 @@ else:
56	64
57	65		# to list all the tasks
58	66
59		-	for task_name, status in tasks.items():
60		-	print("- ", task_name, status)
	67	+	for task_name, task_status in tasks.items():
	68	+	print("- ", task_name, task_status)
61	69		```
62	70
63	71
			@@ -75,8 +83,8 @@ tasks['Buy Milk'] = 'not yet'
75	83
76	84		# to list all the tasks
77	85
78		-	for task_name, status in tasks.items():
79		-	print("- ", task_name, status)
	86	+	for task_name, task_status in tasks.items():
	87	+	print("- ", task_name, task_status)
80	88		```
81	89
82	90		Paste this block of code into the python interpreter and observe what happens.
			@@ -95,8 +103,8 @@ tasks['Walk Dog'] = 'not yet'
95	103
96	104		# to list all the tasks
97	105
98		-	for task_name, status in tasks.items():
99		-	print("- ", task_name, status)
	106	+	for task_name, task_status in tasks.items():
	107	+	print("- ", task_name, task_status)
100	108		```
101	109
102	110		We could put that loop into a function:

kristofer a révisé ce gist 1731423235. Aller à la révision

1 file changed, 4 insertions, 1 deletion

TastyHints.md

			@@ -1,8 +1,11 @@
1	1		# Tasty Lab Hints
2	2
3		-	## Hint 1
	3	+	Lab notes on getting going thru the early parts of Tasty.
	4	+
	5	+	## Hint 0
4	6
5	7		Remember start _very small_ and build outward.
	8	+	The class/program already works, run it and see.
6	9
7	10		## Hint 1
8	11

kristofer a révisé ce gist 1731423148. Aller à la révision

1 file changed, 80 insertions, 16 deletions

TastyHints.md

			@@ -1,23 +1,45 @@
1	1		# Tasty Lab Hints
2	2
	3	+	## Hint 1
3	4
4		-	## Hint 2
	5	+	Remember start _very small_ and build outward.
	6	+
	7	+	## Hint 1
	8	+
	9	+	### Modeling a series of tasks
	10	+
	11	+	If you haven't already decided how to start...
	12	+
	13	+	This is the `tasks` variable.
	14	+
	15	+	```
	16	+	Tasty class.
	17	+	:param tasks: the user tasks
	18	+	```
	19	+	(each of those `:param` things are probably instance variables (eventually))
	20	+
	21	+	The most important thing is the tasks you're tracking.
	22	+	It tracks all the tasks, things that get added and removed.
	23	+
	24	+	What are the two things you want to track?
	25	+
	26	+	- the name/title of the Task _Buy Milk_
	27	+	- status of Task _complete_ or _not yet_
5	28
6		-	If we have thought about this a bit, we might hit on the idea that a dictionary might work well:
	29	+	so in Python, if you have a pair things that need to be tracked together, a good possibility is a Dictionary.
	30	+
	31	+	Imagine a dict like this one:
7	32
8	33		```python
9	34
10	35		tasks = {} # creates an empty dictionary
11	36
12	37		tasks['Buy Milk'] = 'not yet'
13		-
14	38		tasks['Start Lab'] = 'completed'
15	39
16	40		tasks['Finish Lab'] = 'not yet'
17	41
18		-	# now there are three tasks in the dictionary
19		-
20		-	# how to test if a task is complete?
	42	+	# to test if something is done?
21	43
22	44		task_name = 'Buy Milk'
23	45
			@@ -28,6 +50,26 @@ else:
28	50		# task is 'complete'
29	51		pass
30	52
	53	+
	54	+	# to list all the tasks
	55	+
	56	+	for task_name, status in tasks.items():
	57	+	print("- ", task_name, status)
	58	+	```
	59	+
	60	+
	61	+	## Hint 2
	62	+
	63	+	As we have thought about this a bit, we hit on the idea that a dictionary might work well:
	64	+
	65	+	```python
	66	+
	67	+	tasks = {} # creates an empty dictionary
	68	+
	69	+	# add a task to the empty tasks variable
	70	+
	71	+	tasks['Buy Milk'] = 'not yet'
	72	+
31	73		# to list all the tasks
32	74
33	75		for task_name, status in tasks.items():
			@@ -38,7 +80,31 @@ Paste this block of code into the python interpreter and observe what happens.
38	80		Read the code, does it make sense how we are using the task_name as the _key_ and
39	81		the task_status as the _value_?
40	82
41		-	We need to think about how to put thse ideas _into the class Tasty_.
	83	+	Add another task, and print out the tasks dict again.
	84	+
	85	+	```python
	86	+
	87	+	tasks = {} # creates an empty dictionary
	88	+
	89	+	# add a task to the empty tasks variable
	90	+
	91	+	tasks['Walk Dog'] = 'not yet'
	92	+
	93	+	# to list all the tasks
	94	+
	95	+	for task_name, status in tasks.items():
	96	+	print("- ", task_name, status)
	97	+	```
	98	+
	99	+	We could put that loop into a function:
	100	+
	101	+	```python
	102	+	def print_tasks(tasks):
	103	+	for task_name, task_status in tasks.items():
	104	+	print("- ", task_name, task_status)
	105	+	```
	106	+
	107	+	We need to think about how to put these ideas _into the class Tasty_.
42	108		We might...
43	109
44	110		```python
			@@ -58,8 +124,8 @@ class Tasty:
58	124
59	125
60	126		def display_tasks(self):
61		-	for task_name, status in self.tasks.items():
62		-	print("- ", task_name, status)
	127	+	for task_name, task_status in self.tasks.items():
	128	+	print("- ", task_name, task_status)
63	129
64	130		```
65	131
			@@ -67,16 +133,12 @@ See how those things went from just trial code to _methods_ in the class?
67	133
68	134		Yes, and... the `self` variable is how you know that thing is a _method_ and not just a _function_.
69	135
70		-	That's an example of how I might use the rough class here.
71		-
72		-	```python
73		-	def display_tasks(self):
74		-	for task_name, status in self.tasks.items():
75		-	print("- ", task_name, status)
76		-	```
	136	+	That's an example of how I might use the rough class.
77	137
78	138		## Hint 3
79	139
	140	+	### How to handle more complex input
	141	+
80	142		Student Asks: _I'm struggling to see where we take the user input for the task name._
81	143
82	144		If we have `command = input('Tasty> ')`
			@@ -146,6 +208,8 @@ def prompt_user(self, prompt):
146	208		# split words into a list and process into two parts.
147	209		```
148	210
	211	+	## Hint 4
	212	+
149	213		### Saving/Loading to a JSON file
150	214
151	215		JSON is just a structured text format for data. Very Handy.

kristofer a révisé ce gist 1731422633. Aller à la révision

1 file changed, 73 insertions

TastyHints.md

			@@ -1,6 +1,79 @@
1	1		# Tasty Lab Hints
2	2
3	3
	4	+	## Hint 2
	5	+
	6	+	If we have thought about this a bit, we might hit on the idea that a dictionary might work well:
	7	+
	8	+	```python
	9	+
	10	+	tasks = {} # creates an empty dictionary
	11	+
	12	+	tasks['Buy Milk'] = 'not yet'
	13	+
	14	+	tasks['Start Lab'] = 'completed'
	15	+
	16	+	tasks['Finish Lab'] = 'not yet'
	17	+
	18	+	# now there are three tasks in the dictionary
	19	+
	20	+	# how to test if a task is complete?
	21	+
	22	+	task_name = 'Buy Milk'
	23	+
	24	+	if tasks[task_name] == 'not yet':
	25	+	# task is unfinished
	26	+	pass
	27	+	else:
	28	+	# task is 'complete'
	29	+	pass
	30	+
	31	+	# to list all the tasks
	32	+
	33	+	for task_name, status in tasks.items():
	34	+	print("- ", task_name, status)
	35	+	```
	36	+
	37	+	Paste this block of code into the python interpreter and observe what happens.
	38	+	Read the code, does it make sense how we are using the task_name as the _key_ and
	39	+	the task_status as the _value_?
	40	+
	41	+	We need to think about how to put thse ideas _into the class Tasty_.
	42	+	We might...
	43	+
	44	+	```python
	45	+	class Tasty:
	46	+
	47	+	def __init__(self):
	48	+	self.tasks = {}
	49	+
	50	+	def add_task(self, task_name):
	51	+	"""
	52	+	Add a new task to the user tasks.
	53	+	"""
	54	+	if task_name not in self.tasks:
	55	+	self.tasks[task_name] = "not yet"
	56	+	else:
	57	+	print("Task already added.")
	58	+
	59	+
	60	+	def display_tasks(self):
	61	+	for task_name, status in self.tasks.items():
	62	+	print("- ", task_name, status)
	63	+
	64	+	```
	65	+
	66	+	See how those things went from just trial code to _methods_ in the class?
	67	+
	68	+	Yes, and... the `self` variable is how you know that thing is a _method_ and not just a _function_.
	69	+
	70	+	That's an example of how I might use the rough class here.
	71	+
	72	+	```python
	73	+	def display_tasks(self):
	74	+	for task_name, status in self.tasks.items():
	75	+	print("- ", task_name, status)
	76	+	```
4	77
5	78		## Hint 3
6	79

kristofer a révisé ce gist 1731422341. Aller à la révision

1 file changed, 115 insertions

TastyHints.md(fichier créé)

		@@ -0,0 +1,115 @@
1	+	# Tasty Lab Hints
2	+
3	+
4	+
5	+	## Hint 3
6	+
7	+	Student Asks: _I'm struggling to see where we take the user input for the task name._
8	+
9	+	If we have `command = input('Tasty> ')`
10	+
11	+	So the `command` variable will have `exit` or whatever, after the user types something in
12	+	and taps <return>, right?
13	+
14	+	And the `new <task>` command/line when entered, will actually look like `new Buy Milk` when user types the
15	+	command to be processed by the program.
16	+
17	+	so take the string inputted and split it into a list of strings, breaking each string on the <space> character.
18	+
19	+	```python
20	+	txt = "command typed by user"
21	+
22	+	x = txt.split()
23	+
24	+	print(x)
25	+
26	+	# x will be a list: ['command', 'typed', 'by', 'user']
27	+	```
28	+
29	+	If we want to extend this to make two new strings:
30	+	- command (the first string, perhaps "new")
31	+	- and rest (the rest of the split strings glued back together with spaces in between...)
32	+
33	+	```python
34	+	txt = "new Buy Milk"
35	+	t = txt.split()
36	+	print(t) # t will be: ["new", "Buy", "Milk"]
37	+	command = t[0] # command will be "new"
38	+	rest = t[1:] # carefully: Slice the array, from t[1] to end of list
39	+	# rest will be ["Buy", "Milk"]
40	+	rest = " ".join(rest) # now rest will be "Buy Milk"
41	+	print(command, ' - ', rest)
42	+	```
43	+
44	+	and after hacking a bit in the python interpreter, you may end up with
45	+
46	+	```python
47	+	line = input(prompt)
48	+	#print(line)
49	+	while not line:
50	+	line = input(prompt) # this causes input to wait until
51	+	# line is not an empty string
52	+	words = line.split()
53	+	#print(words)
54	+	command = words[0]
55	+	#print(command)
56	+	rest = words[1:]
57	+	rest = " ".join(rest)
58	+	#print(rest)
59	+	```
60	+
61	+	and maybe the right thing to do is to change the `command = input("Tasty> ")` to something like
62	+	`command, rest = tasty.prompt_user("Tasty> ")`
63	+
64	+	then all the "words" after the "new" will be what you pull together to name the task?
65	+
66	+	so `prompt-user(self, prompt)` becomes a method which asks for the user's input
67	+	(using input(prompt))
68	+
69	+	```python
70	+	def prompt_user(self, prompt):
71	+	inp = input(prompt)
72	+	# insert the stuff up there about how to
73	+	# split words into a list and process into two parts.
74	+	```
75	+
76	+	### Saving/Loading to a JSON file
77	+
78	+	JSON is just a structured text format for data. Very Handy.
79	+
80	+	## saving? a Hint
81	+
82	+	```python
83	+	with open("saved_data.json", "w") as fp:
84	+	json.dump(self.tasks,fp)
85	+	```
86	+
87	+	## loading? a Hint
88	+
89	+	```python
90	+	with open(filename) as json_file:
91	+	self.tasks = json.load(json_file)
92	+	```
93	+
94	+	And you should embed these two ideas into a method.
95	+
96	+	When you get to the point where you are puzzling over how to save/load multiple dicts
97	+	(say, _tasks_, _trash_, and _important_),
98	+	you might consider putting all this in another dictionary and just saving that.
99	+
100	+	You still have to _load_ the one dict and then split it into three for use by the methods.
101	+	This should be done in _load tasks_ method.
102	+
103	+	The data structure might be created by
104	+
105	+	```python
106	+	dict_to_save = { "tasks": self.tasks, "trash": self.trash, "impt": self.important }
107	+	```
108	+
109	+	You can now _json.dump_ the `dict_to_save` to a file.
110	+
111	+	Loading it will be the opposite, you end up with one `loaded_dicts` which
112	+	have to be split like: `self.tasks = loaded_dicts['tasks']`
113	+
114	+
115	+	Easy Peasy

Plus récent Plus ancien