joeyajames/udemy_data_structures
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7f2424ce241f253a6704b6caba94b491bf0b2923
udemy_data_structures/Section_1/Python Data Structures.ipynb

1216 lines
23 KiB
Plaintext
Raw Normal View History

initial upload of all course files
2019-05-01 22:08:49 -07:00
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Intro to Python Data Structures\n",
"Strings, Lists, Tuples, Sets, Dicts \n",
"Created in Python 3.7 \n",
"© Joe James, 2019.\n",
"\n",
"## Sequences: String, List, Tuple\n",
"****\n",
"[Documentation](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range) \n",
"**indexing** - access any item in the sequence using its index. \n",
"Indexing starts with 0 for the first element."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"g\n",
"cow\n",
"Kevin\n"
]
}
],
"source": [
"# string\n",
"x = 'frog'\n",
"print (x[3])\n",
"\n",
"# list\n",
"x = ['pig', 'cow', 'horse']\n",
"print (x[1])\n",
"\n",
"# tuple\n",
"x = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(x[0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**slicing** - slice out substrings, sublists, subtuples using indexes. \n",
"[start : end+1 : step]"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"omp\n",
"opt\n",
"puter\n",
"compu\n",
"r\n",
"ter\n",
"comput\n"
]
}
],
"source": [
"x = 'computer'\n",
"print(x[1:4])\n",
"print(x[1:6:2])\n",
"print(x[3:])\n",
"print(x[:5])\n",
"print(x[-1])\n",
"print(x[-3:])\n",
"print(x[:-2])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**adding / concatenating** - combine 2 sequences of the same type by using +"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"horseshoe\n",
"['pig', 'cow', 'horse']\n",
"('Kevin', 'Niklas', 'Jenny', 'Craig')\n"
]
}
],
"source": [
"# string\n",
"x = 'horse' + 'shoe'\n",
"print(x)\n",
"\n",
"# list\n",
"y = ['pig', 'cow'] + ['horse']\n",
"print(y)\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny') + ('Craig',)\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**multiplying** - multiply a sequence using *"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bugbugbug\n",
"[8, 5, 8, 5, 8, 5]\n",
"(2, 4, 2, 4, 2, 4)\n"
]
}
],
"source": [
"# string\n",
"x = 'bug' * 3\n",
"print(x)\n",
"\n",
"# list\n",
"y = [8, 5] * 3\n",
"print(y)\n",
"\n",
"# tuple\n",
"z = (2, 4) * 3\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**checking membership** - test whether an item is or is not in a sequence."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"False\n",
"True\n"
]
}
],
"source": [
"# string\n",
"x = 'bug'\n",
"print('u' in x)\n",
"\n",
"# list\n",
"y = ['pig', 'cow', 'horse']\n",
"print('cow' not in y)\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print('Niklas' in z)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**iterating** - iterating through the items in a sequence"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n",
"8\n",
"3\n",
"0 7\n",
"1 8\n",
"2 3\n"
]
}
],
"source": [
"# item\n",
"x = [7, 8, 3]\n",
"for item in x:\n",
" print(item)\n",
" \n",
"# index & item\n",
"y = [7, 8, 3]\n",
"for index, item in enumerate(y):\n",
" print(index, item)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**number of items** - count the number of items in a sequence"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n",
"3\n",
"4\n"
]
}
],
"source": [
"# string\n",
"x = 'bug'\n",
"print(len(x))\n",
"\n",
"# list\n",
"y = ['pig', 'cow', 'horse']\n",
"print(len(y))\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(len(z))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**minimum** - find the minimum item in a sequence lexicographically. \n",
"Alpha or numeric types, but cannot mix types."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"b\n",
"cow\n",
"Craig\n"
]
}
],
"source": [
"# string\n",
"x = 'bug'\n",
"print(min(x))\n",
"\n",
"# list\n",
"y = ['pig', 'cow', 'horse']\n",
"print(min(y))\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(min(z))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**maximum** - find the maximum item in a sequence lexicographically. \n",
"Alpha or numeric types, but cannot mix types."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"u\n",
"pig\n",
"Niklas\n"
]
}
],
"source": [
"# string\n",
"x = 'bug'\n",
"print(max(x))\n",
"\n",
"# list\n",
"y = ['pig', 'cow', 'horse']\n",
"print(max(y))\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(max(z))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**sum** - find the sum of items in a sequence. \n",
"Entire sequence must be numeric."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"27\n",
"20\n",
"80\n"
]
}
],
"source": [
"# string -> error\n",
"# x = [5, 7, 'bug']\n",
"# print(sum(x)) # generates an error\n",
"\n",
"# list\n",
"y = [2, 5, 8, 12]\n",
"print(sum(y))\n",
"print(sum(y[-2:]))\n",
"\n",
"# tuple\n",
"z = (50, 4, 7, 19)\n",
"print(sum(z))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**sorting** - returns a new list of items in sorted order. \n",
"Does not change the original list."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['b', 'g', 'u']\n",
"['cow', 'horse', 'pig']\n",
"['Craig', 'Jenny', 'Kevin', 'Niklas']\n"
]
}
],
"source": [
"# string\n",
"x = 'bug'\n",
"print(sorted(x))\n",
"\n",
"# list\n",
"y = ['pig', 'cow', 'horse']\n",
"print(sorted(y))\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(sorted(z))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**sorting** - sort by second letter \n",
"Add a key parameter and a lambda function to return the second character. \n",
"(the word *key* here is a defined parameter name, *k* is an arbitrary variable name)."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Kevin', 'Jenny', 'Niklas', 'Craig']\n"
]
}
],
"source": [
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(sorted(z, key=lambda k: k[1]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**count(item)** - returns count of an item"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"2\n",
"1\n"
]
}
],
"source": [
"# string\n",
"x = 'hippo'\n",
"print(x.count('p'))\n",
"\n",
"# list\n",
"y = ['pig', 'cow', 'horse', 'cow']\n",
"print(y.count('cow'))\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(z.count('Kevin'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**index(item)** - returns the index of the first occurence of an item."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"1\n",
"2\n"
]
}
],
"source": [
"# string\n",
"x = 'hippo'\n",
"print(x.index('p'))\n",
"\n",
"# list\n",
"y = ['pig', 'cow', 'horse', 'cow']\n",
"print(y.index('cow'))\n",
"\n",
"# tuple\n",
"z = ('Kevin', 'Niklas', 'Jenny', 'Craig')\n",
"print(z.index('Jenny'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**unpacking** - unpack the n items of a sequence into n variables"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"pig cow horse\n"
]
}
],
"source": [
"x = ['pig', 'cow', 'horse']\n",
"a, b, c = x\n",
"print(a, b, c)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lists \n",
"****\n",
"- General purpose\n",
"- Most widely used data structure \n",
"- Grow and shrink size as needed\n",
"- Sequence type\n",
"- Sortable \n",
"\n",
"**constructors** - creating a new list"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 1, 2, 3, 4, 5, 6, 7]\n",
"[25, 36, 49, 64, 81]\n"
]
}
],
"source": [
"x = list()\n",
"y = ['a', 25, 'dog', 8.43]\n",
"tuple1 = (10, 20)\n",
"z = list(tuple1)\n",
"\n",
"# list comprehension\n",
"a = [m for m in range(8)]\n",
"print(a)\n",
"b = [i**2 for i in range(10) if i>4]\n",
"print(b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**delete** - delete a list or an item in a list"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 8, 6]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"del(x[1])\n",
"print(x)\n",
"del(x) # list x no longer exists"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**append** - append an item to a list"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 3, 8, 6, 7]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"x.append(7)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**extend** - append a sequence to a list"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 3, 8, 6, 12, 13]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"y = [12, 13]\n",
"x.extend(y)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**insert** - insert an item at a given index"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 7, 3, 8, 6]\n",
"[5, ['a', 'm'], 7, 3, 8, 6]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"x.insert(1, 7)\n",
"print(x)\n",
"x.insert(1, ['a', 'm'])\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**pop** - pops last item off list and returns item"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 3, 8]\n",
"8\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"x.pop() # pop off the 6\n",
"print(x)\n",
"print(x.pop())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**remove** - remove first instance of an item"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 8, 6, 3]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6, 3]\n",
"x.remove(3)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**reverse** - reverse the order of the list. It is an in-place sort, meaning it changes the original list."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[6, 8, 3, 5]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"x.reverse()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**sort** - sort the list in place. \n",
"Note: \n",
"sorted(x) returns a new sorted list without changing the original list x. \n",
"x.sort() puts the items of x in sorted order (sorts in place)."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[3, 5, 6, 8]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"x.sort()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**reverse sort** - sort items descending. \n",
"Use *reverse=True* parameter to the sort function."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[8, 6, 5, 3]\n"
]
}
],
"source": [
"x = [5, 3, 8, 6]\n",
"x.sort(reverse=True)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tuples\n",
"****\n",
"- Immutable (can’t add/change)\n",
"- Useful for fixed data\n",
"- Faster than Lists\n",
"- Sequence type \n",
" \n",
"**constructors** - creating new tuples."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(2,) <class 'tuple'>\n",
"(2, 4, 6) <class 'tuple'>\n"
]
}
],
"source": [
"x = ()\n",
"x = (1, 2, 3)\n",
"x = 1, 2, 3\n",
"x = 2, # the comma tells Python it's a tuple\n",
"print(x, type(x))\n",
"\n",
"list1 = [2, 4, 6]\n",
"x = tuple(list1)\n",
"print(x, type(x))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**tuples are immutable**, but member objects may be mutable."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(1, 2, 3)\n",
"([1], 3)\n",
"([1], 3, 4)\n"
]
}
],
"source": [
"x = (1, 2, 3)\n",
"# del(x[1]) # fails\n",
"# x[1] = 8 # fails\n",
"print(x)\n",
"\n",
"y = ([1, 2], 3) # a tuple where the first item is a list\n",
"del(y[0][1]) # delete the 2\n",
"print(y) # the list within the tuple is mutable\n",
"\n",
"y += (4,) # concatenating two tuples works\n",
"print(y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Sets\n",
"****\n",
"- Store non-duplicate items \n",
"- Very fast access vs Lists \n",
"- Math Set ops (union, intersect) \n",
"- Sets are Unordered \n",
" \n",
"**constructors** - creating new sets"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{3, 5}\n",
"set()\n",
"{2, 3, 4}\n"
]
}
],
"source": [
"x = {3, 5, 3, 5}\n",
"print(x)\n",
"\n",
"y = set()\n",
"print(y)\n",
"\n",
"list1 = [2, 3, 4]\n",
"z = set(list1)\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**set operations**"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{8, 3, 5}\n",
"{8, 3, 5, 7}\n",
"{8, 5, 7}\n",
"3\n",
"True\n",
"8 {5, 7}\n",
"set()\n"
]
}
],
"source": [
"x = {3, 8, 5}\n",
"print(x)\n",
"x.add(7)\n",
"print(x)\n",
"\n",
"x.remove(3)\n",
"print(x)\n",
"\n",
"# get length of set x\n",
"print(len(x))\n",
"\n",
"# check membership in x\n",
"print(5 in x)\n",
"\n",
"# pop random item from set x\n",
"print(x.pop(), x)\n",
"\n",
"# delete all items from set x\n",
"x.clear()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Mathematical set operations** \n",
"intersection (AND): set1 & set2 \n",
"union (OR): set1 | set2 \n",
"symmetric difference (XOR): set1 ^ set2 \n",
"difference (in set1 but not set2): set1 - set2 \n",
"subset (set2 contains set1): set1 <= set2 \n",
"superset (set1 contains set2): set1 >= set2"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{3}\n",
"{1, 2, 3, 4, 5}\n",
"{1, 2, 4, 5}\n",
"{1, 2}\n",
"False\n",
"False\n"
]
}
],
"source": [
"s1 = {1, 2, 3}\n",
"s2 = {3, 4, 5}\n",
"print(s1 & s2)\n",
"print(s1 | s2)\n",
"print(s1 ^ s2)\n",
"print(s1 - s2)\n",
"print(s1 <= s2)\n",
"print(s1 >= s2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Dictionaries (dict)\n",
"****\n",
"- Key/Value pairs\n",
"- Associative array, like Java HashMap\n",
"- Dicts are Unordered \n",
"\n",
"**constructors** - creating new dictionaries"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'pork': 25.3, 'beef': 33.8, 'chicken': 22.7}\n",
"{'pork': 25.3, 'beef': 33.8, 'chicken': 22.7}\n",
"{'pork': 25.3, 'beef': 33.8, 'chicken': 22.7}\n"
]
}
],
"source": [
"x = {'pork':25.3, 'beef':33.8, 'chicken':22.7}\n",
"print(x)\n",
"x = dict([('pork', 25.3),('beef', 33.8),('chicken', 22.7)])\n",
"print(x)\n",
"x = dict(pork=25.3, beef=33.8, chicken=22.7)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**dict operations**"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'pork': 25.3, 'beef': 33.8, 'chicken': 22.7, 'shrimp': 38.2}\n",
"{'pork': 25.3, 'beef': 33.8, 'chicken': 22.7}\n",
"3\n",
"{}\n"
]
}
],
"source": [
"x['shrimp'] = 38.2 # add or update\n",
"print(x)\n",
"\n",
"# delete an item\n",
"del(x['shrimp'])\n",
"print(x)\n",
"\n",
"# get length of dict x\n",
"print(len(x))\n",
"\n",
"# delete all items from dict x\n",
"x.clear()\n",
"print(x)\n",
"\n",
"# delete dict x\n",
"del(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**accessing keys and values in a dict** \n",
"Not compatible with Python 2."
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_keys(['pork', 'beef', 'chicken'])\n",
"dict_values([25.3, 33.8, 22.7])\n",
"dict_items([('pork', 25.3), ('beef', 33.8), ('chicken', 22.7)])\n",
"True\n",
"False\n"
]
}
],
"source": [
"y = {'pork':25.3, 'beef':33.8, 'chicken':22.7}\n",
"print(y.keys())\n",
"print(y.values())\n",
"print(y.items()) # key-value pairs\n",
"\n",
"# check membership in y_keys (only looks in keys, not values)\n",
"print('beef' in y)\n",
"\n",
"# check membership in y_values\n",
"print('clams' in y.values())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**iterating a dict** - note, items are in random order."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"pork 25.3\n",
"beef 33.8\n",
"chicken 22.7\n",
"pork 25.3\n",
"beef 33.8\n",
"chicken 22.7\n"
]
}
],
"source": [
"for key in y:\n",
" print(key, y[key])\n",
" \n",
"for k, v in y.items():\n",
" print(k, v)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Reference in New Issue Copy Permalink