\nSection 4 ><\/a><\/p>\n
- \n
- Introduction to Python Data Types<\/li>\n
- Python Numbers<\/li>\n
- Numbers FAQ<\/li>\n
- Variable Assignments<\/li>\n
- Introduction to Strings<\/li>\n
- Indexing and slicing with Strings<\/li>\n
- String Properties and Methods<\/li>\n
- Strings FAQ<\/li>\n
- Print Formatting with Strings<\/li>\n
- Print Formatting FAQs<\/li>\n
- Lists in Python<\/li>\n
- Lists FAQ<\/li>\n
- Dictionaries in Python<\/li>\n
- Dictionaries FAQ<\/li>\n
- Tuples with Python<\/li>\n
- Sets in Python<\/li>\n
- Booleans in Python<\/li>\n
- I\/O with Basic Files in Python<\/li>\n
- Resources for More Basic Practice<\/li>\n
- Python Objects and Data Structures Assessment Test Overviews<\/li>\n
- Python Objects and Data Structures Assessment Test Solutions<\/li>\n<\/ol>\n
<\/p>\n
My Comments<\/h1>\n
Coding Conventions<\/h2>\n
Ref ‘PEP8’: https:\/\/www.python.org\/dev\/peps\/pep-0008\/<\/a><\/p>\n
Introduction to Python Data Types<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/9388518#content<\/a><\/p>\n
Overview of the values<\/p>\n
![\"\"](\"http:\/\/wiki.thomasandsofia.com\/wp-content\/uploads\/2019\/06\/datatypes.png\")
<\/a>
\n* Boolean type ‘None’ = null? It is the value returned if there is no return value….?<\/p>\nPython Numbers<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/9388520#content<\/a><\/p>\n
- \n
- % = Mod (Moulo) aka remainder\n
- \n
- 7 % 4 = 3<\/li>\n
- 50 % 5 = 0\n
- \n
- Good way to check if a value cleanly divides<\/li>\n
- Also good to check if a value is even or odd\n
- \n
- 21 % 2 = 1<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n
- ** = Exponent\n
- \n
- 2**3=8<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Coding Exercise 1<\/h2>\n
Write an expression that = 100<\/p>\n
10*10<\/p>\n
Numbers FAQ<\/h1>\n
1. What’s the difference between floating point and an integer?<\/strong><\/p>\n
An integer has no decimals in it, a floating point number can display digits past the decimal point.<\/p>\n
2. Why doesn’t 0.1+0.2-0.3 equal 0.0 ?<\/strong><\/p>\n
This has to do with floating point accuracy and computer’s abilities to represent numbers in memory. For a full breakdown, check out: https:\/\/docs.python.org\/2\/tutorial\/floatingpoint.html<\/a><\/p>\n
Variable Assignments<\/h1>\n
Naming Rules<\/h2>\n
- \n
- Cannot start with a number<\/li>\n
- Cannot contain spaces<\/li>\n
- Cannot use any of the following characters:\n
- \n
- : ‘ ” , < > \/ ? | \\ ( ) ! @ # $ % ^ & * ~ – +<\/li>\n
- Best practice all variables are lower case\n
- \n
- Exception is Global Variables which should be all CAPS<\/li>\n<\/ul>\n<\/li>\n
- Avoid using variables that have special meanings, like list<\/strong> and str<\/strong><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Variable Typing<\/h2>\n
- \n
- Python uses Dynamic Typing<\/strong>\n
- \n
- You can reassign variable to different types:\n
- \n
- my_var = 5<\/li>\n
- my_var = “hello”<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n
- Some other languages do not allow this\n
- \n
- These are known as Statically Typed<\/strong><\/li>\n
- Example for C++\n
- \n
- int my_var = 5;<\/li>\n
- my_var = “hello”;\n
- \n
- This results in an error!<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Pros and Cons to Dynamic Typing<\/h3>\n
- \n
- Pros\n
- \n
- Very easy to work with<\/li>\n
- Faster development time<\/li>\n<\/ul>\n<\/li>\n
- Cons\n
- \n
- May result in bugs for unexpected data types<\/li>\n
- Need to be aware of type()<\/strong><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
type()<\/h4>\n
- \n
- a = 5<\/li>\n
- type(a)\n
- \n
- int<\/li>\n<\/ul>\n<\/li>\n
- a = 5.1<\/li>\n
- type(a)\n
- \n
- float<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Introduction to Strings<\/h1>\n
Indexing<\/h2>\n
- \n
- Character: h e l l o<\/li>\n
- Index: 0 1 2 3 4<\/li>\n
- Reverse Index: 0 -4 -3 -2 -1<\/li>\n
- my_str = “hello”\n
- \n
- my_str[1]\n
- \n
- e<\/li>\n<\/ul>\n<\/li>\n
- my_str[-1]\n
- \n
- o<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Slicing<\/h2>\n
- \n
- Used to grab a sub-section of a string<\/li>\n
- [start:stop:step]\n
- \n
- start = start index (Default = 0<\/strong>)<\/li>\n
- stop = up to, but not including this index (Default = len())<\/li>\n
- step = ‘jump’ size (Default = 1<\/strong>)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Indexing and slicing with Strings<\/h1>\n
- \n
- ‘abcdefghijk'[2]\n
- \n
- c<\/li>\n<\/ul>\n<\/li>\n
- my_str = ‘abcdefghijk’<\/li>\n
- len(my_str)\n
- \n
- 11<\/li>\n<\/ul>\n<\/li>\n
- my_str[2]\n
- \n
- c<\/li>\n<\/ul>\n<\/li>\n
- my_str[-2]\n
- \n
- j<\/li>\n<\/ul>\n<\/li>\n
- my_str[2:] (no stop = all remaining characters)\n
- \n
- cdefghijk<\/li>\n<\/ul>\n<\/li>\n
- my_str[:3] (no start = start with 0)\n
- \n
- abc<\/li>\n<\/ul>\n<\/li>\n
- my_str[2:4]\n
- \n
- cd<\/li>\n<\/ul>\n<\/li>\n
- my_str[4:-5]\n
- \n
- ef<\/li>\n<\/ul>\n<\/li>\n
- my_str[::] (start at the beginning and go to the end)\n
- \n
- abcdefghijk<\/li>\n<\/ul>\n<\/li>\n
- my_str[::2]\n
- \n
- acegik<\/li>\n<\/ul>\n<\/li>\n
- my_str[::3]\n
- \n
- adgj<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Reversing a string<\/h3>\n
Note: When using a negative step size, the start and stop positions are also reversed<\/p>\n
- \n
- my_str[::-1] (Reverse a string)\n
- \n
- kjihgfedcba<\/li>\n<\/ul>\n<\/li>\n
- my_str[1::-1] (start = index 1, stop = through start of string, -1 = backwards)\n
- \n
- ba<\/li>\n<\/ul>\n<\/li>\n
- my_str[4:0:-1]\n
- \n
- edcb<\/li>\n<\/ul>\n<\/li>\n
- my_str[-2,7,-1]\n
- \n
- ji<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
String Properties and Methods<\/h1>\n
Immutability<\/h2>\n
You cannot directly assign new values to string indexes<\/p>\n
name = 'Sam'\r\nname[0] = 'P'<\/pre>\n
TypeError: ‘str’ object does not support item assignment<\/p>\n
Concatenation<\/h2>\n
Addition<\/h3>\n
Use a + symbol to concatenate (add together)<\/p>\n
name = 'Sam'\r\npam = 'P' + name[1:]\r\nprint(pam)<\/pre>\n
Pam<\/p>\n
Mutiplication<\/h3>\n
letter = 'z'\r\nletter = letter * 5\r\nprint(letter)<\/pre>\n
zzzzz<\/p>\n
Caution using Dynamic Types<\/h2>\n
2 + 3<\/pre>\n
5<\/p>\n
'2' + '3'<\/pre>\n
23<\/p>\n
String Objects and Methods<\/h2>\n
x = 'Hello World'\r\nprint(x.upper())\r\nprint(x)<\/pre>\n
HELLO WORLD
\nHello World<\/p>\nx = 'Hello World'\r\nx = x.upper()\r\nprint(x)<\/pre>\n
HELLO WORLD<\/p>\n
x = 'Hello World'\r\nprint(x.lower())<\/pre>\n
hello world<\/p>\n
Split<\/h3>\n
x = 'Hello World'\r\nx.split()<\/pre>\n
[‘Hello’, ‘World’]<\/p>\n
x = 'Hello World'\r\nx.split('l')<\/pre>\n[‘He’, ”, ‘o Wor’, ‘d’]<\/p>\n
<\/p>\n
<\/p>\n
Strings FAQ<\/h1>\n
Print Formatting with Strings<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/9388532#content<\/a>
\nGreat resource: https:\/\/pyformat.info\/<\/a><\/p>\n.format()<\/h2>\n
Strings<\/h3>\n
“String here {} then also {}”.format(var1, var2)<\/p>\n
print('This is an {} string'.format('INSERTED'))<\/pre>\nThis is an INSERTED string<\/p>\n
Indexing<\/h3>\n
print('The {2} {1} {0}'.format('fox', 'brown', 'quick'))<\/pre>\nThe quick brown fox<\/p>\n
print('The {0} {0} {0}'.format('fox', 'brown', 'quick'))<\/pre>\nThe fox fox fox<\/p>\n
Variables<\/h3>\n
print('The {q} {b} {f}'.format(f='fox', b='brown', q='quick'))<\/pre>\nThe quick brown fox<\/p>\n
print('The {f} {f} {f}'.format(f='fox', b='brown', q='quick'))<\/pre>\nThe fox fox fox<\/p>\n
Floating Point Numbers<\/h3>\n
value:.f<\/p>\n
result = 100\/777\r\nprint(result)\r\nprint(\"The result was {r:1.3f}\".format(r=result)\r\nprint(\"The result was {r:10.3f}\".format(r=result)<\/pre>\n0.1287001287001287
\nThe result was 0.129
\nThe result was \u00a0\u00a0\u00a0\u00a0\u00a00.129<\/p>\nPrint(f” “)<\/h2>\n
husband = 'Thomas'\r\nwife = 'Sofia'\r\nprint(f\"{husband} is married to {wife}.\")<\/pre>\nThomas is married to Sofia.<\/p>\n
Print Formatting FAQs<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/3810438#content<\/p>\n
Print Formatting FAQS<\/strong><\/p>\n
1.) I imported print from the __future__ module, now print isn’t working. What happened?<\/strong><\/p>\n
This is because once you import from the __future__ module in Python 2.7, a print statement will no longer work, and print must then use a print() function. Meaning that you must use<\/p>\n
print(‘Whatever you were going to print’)<\/strong><\/p>\n
or if you are using some formatting:<\/p>\n
print(‘This is a string with an {p}’.format(p=’insert’<\/strong>))<\/strong><\/p>\n
The __future__ module allows you to use Python3 functionality in a Python2 environment, but some functionality is overwritten (such as the print statement, or classic division when you import division).<\/p>\n
Since we are using Jupyter Notebooks, once you so the import, all cells will require the use if the print() function. You will have to restart Python or start a new notebook to regain the old functionality back.<\/p>\n
Lists in Python<\/h1>\n
Numerically indexed array containing a variety of values and objects.
\n* Lists are MUTABLE! You can change an index at will. (Unlike strings, which are immutable.)<\/p>\nhusband = 'Thomas'\r\nmy_list=[husband, 53, 'String']\r\nprint(len(my_list))\r\nprint(my_list[0])<\/pre>\n
3
\nThomas<\/p>\nSlicing and Indexing<\/h2>\n
Works EXACTLY the same as strings<\/p>\n
husband = 'Thomas'\r\nmy_list=[husband, 53, 'String']\r\nprint(my_list[:2])<\/pre>\n
[‘Thomas’, 53]<\/p>\n
Modifying Lists<\/h2>\n
Concatenate<\/h3>\n
list1 = ['one', 2, 'three']\r\nlist2 = ['4', 'Five']\r\nlist3 = list1 + list2\r\nprint(list3)<\/pre>\n
[‘one’, 2, ‘three’, ‘4’, ‘Five’]<\/p>\n
.append()<\/h3>\n
list3.append(6)\r\nprint(list3)<\/pre>\n
[‘one’, 2, ‘three’, ‘4’, ‘Five’, 6]<\/p>\n
.pop()<\/h3>\n
Removes and returns an index from list. (Default = -1)<\/p>\n
my_list = ['one', 2, 'three', '4', 'Five', 6]\r\nprint(my_list.pop())\r\nprint(my_list)<\/pre>\n
6
\n[‘one’, 2, ‘three’, ‘4’, ‘Five’]<\/p>\nmy_list = ['one', 2, 'three', '4', 'Five', 6]\r\nprint(my_list.pop(1))\r\nprint(my_list)<\/pre>\n
2
\n[‘one’, ‘three’, ‘4’, ‘Five’, 6]<\/p>\nmy_list = ['one', 2, 'three', '4', 'Five', 6]\r\nprint(my_list.pop(-2))\r\nprint(my_list)<\/pre>\n
five
\n[‘one’, ‘three’, ‘4’, 6]<\/p>\nSorting<\/h2>\n
* Sorting is ‘in place’. That is:
\nIt alters the actual array.
\nIt does NOT return a value (None)<\/p>\nalpha = ['z', 'e', 'r', 't', 'm']\r\nalpha.sort()\r\nprint(alpha)<\/pre>\n
[‘e’, ‘m’, ‘r’, ‘t’, ‘z’]<\/p>\n
alpha = ['z', 'e', 'R', 't', 'm']\r\nalpha.sort()\r\nprint(alpha)<\/pre>\n
[‘R’, ‘e’, ‘m’, ‘t’, ‘z’]<\/p>\n
alpha = ['z', 'e', 'R', 't', 'm']\r\nbeta = alpha.sort()\r\nprint(beta)\r\ntype(beta)<\/pre>\n
NoneType<\/p>\n
numlist = [3, 2, 0, 4, 1]\r\nnumlist.sort()\r\nprint(numlist)<\/pre>\n
[0, 1, 2, 3, 4]<\/p>\n
.reverse()<\/h3>\n
numlist = [3, 2, 0, 4, 1]\r\nnumlist.reverse()\r\nprint(numlist)<\/pre>\n
[1, 4, 0, 2, 3]<\/p>\n
Lists FAQ<\/h1>\n
1. How do I index a nested list? For example if I want to grab 2 from [1,1,[1,2]]?<\/strong><\/p>\n
You would just add another set of brackets for indexing the nested list, for example: my_list[2][1] . We’ll discover later on more nested objects and you will be quizzed on them later!<\/p>\n
<\/p>\n
Dictionaries in Python<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/9388536#content<\/a><\/p>\n
Dictionaries are associative arrays, i.e. key:value pairs.<\/p>\n
my_dict = {'key1':'value1', 'key1':2, 'key3':3.333, 'key4':[0, 1, 2]}<\/pre>\nDictionaries<\/p>\n
- \n
- Keys should always, but do not have to, be strings.<\/li>\n
- Grouped using curly brackets<\/li>\n<\/ul>\n
Dictionaries vs Lists<\/p>\n
- \n
- Dictionaries\n
- \n
- Objects retrieved by key name<\/li>\n
- These are unordered and cannot be sorted<\/li>\n<\/ul>\n<\/li>\n
- Lists\n
- \n
- Objects retrieved by location<\/li>\n
- Ordered sequence can be indexed or sliced.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Methods<\/h2>\n
.keys()<\/h3>\n
d = {'key1':1, 'key2':2, 'key3':'Three'}\r\nprint(d.keys())<\/pre>\ndict_keys([‘key1’, ‘key2’, ‘key3’])<\/p>\n
.values()<\/h3>\n
d = {'key1':1, 'key2':2, 'key3':'Three'}\r\nprint(d.values())<\/pre>\ndict_values([1, 2, ‘Three’])<\/p>\n
.items()<\/h3>\n
d = {'key1':1, 'key2':2, 'key3':'Three'}\r\nprint(d.items())<\/pre>\ndict_items([(‘key1’, 1), (‘key2’, 2), (‘key3’, ‘Three’)])<\/p>\n
- \n
- Notice the return sets are in parenthesis.\u00a0 These are Tuples!<\/li>\n<\/ul>\n
Working with Objects<\/h2>\n
d={'key':['b','c','a']}\r\nprint(d['key'][2].upper())<\/pre>\nA<\/p>\n
d={'key':['b','c','a']}\r\nd['key'].sort()\r\nprint(d['key'])<\/pre>\n[‘a’, ‘b’, ‘c’]<\/p>\n
<\/p>\n
Dictionaries FAQ<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/3729816#content<\/a><\/p>\n
1. Do dictionaries keep an order? How do I print the values of the dictionary in order?<\/strong><\/p>\n
Dictionaries are mappings and do not retain order! If you do want the capabilities of a dictionary but you would like ordering as well, check out the ordereddict<\/strong> object lecture later on in the course!<\/p>\n
Tuples with Python<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/9388540#content<\/a><\/p>\n
- \n
- Tuples use parenthesis: (1, 2, 3)<\/li>\n
- Similar to lists, but are immutable. Once an element is inside a tuple, it cannot be reassigned.<\/li>\n
- You can slice and index the same as a list but you cannot reorder!<\/li>\n<\/ul>\n
Tuples are useful in advanced programming for passing objects when you must ensure the data integrity.<\/p>\n
Immutability Example<\/h2>\n
t=('S', 'o', 'f', 'i','a')\r\nt[2] = 'ph'<\/pre>\n—————————————————————————
\nTypeError Traceback (most recent call last)
\nin
\n1 t=(‘S’, ‘o’, ‘f’, ‘i’,’a’)
\n—-> 2 t[2] = ‘ph’<\/p>\nTypeError: ‘tuple’ object does not support item assignment<\/p>\n
Indexing and Slicing example<\/h2>\n
t=('S', 'o', 'f', 'i','a')\r\nt[1:4]<\/pre>\n(‘o’, ‘f’, ‘i’)<\/p>\n
Methods<\/h2>\n
.count()<\/h3>\n
Counts the number of occurrences of a value in the tuple.<\/p>\n
t = ('a', 'b', 'a', 'c')\r\nt.count('a')<\/pre>\n2<\/p>\n
.index()<\/h3>\n
Returns the first index occurrance of a value<\/p>\n
t = ('a', 'b', 'a', 'c')\r\nt.index('a')<\/pre>\n0<\/p>\n
<\/p>\n
Sets in Python<\/h1>\n
https:\/\/www.udemy.com\/complete-python-bootcamp\/learn\/lecture\/9388544#content<\/a><\/p>\n
- \n
- Sets are unordered collections of unique elements\n
- \n
- There are no indexes<\/li>\n<\/ul>\n<\/li>\n
- There can only be one representative of the same object\n
- \n
- Each value in the set must be unique.\u00a0 There are no duplucates<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Set Example<\/h2>\n
myset = set()\r\nmyset<\/pre>\n
set()<\/p>\n
myset.add(1)\r\nmyset<\/pre>\n
{1}<\/p>\n
myset.add(2)\r\nmyset<\/pre>\n
{1, 2}<\/p>\n
myset.add(2)\r\nmyset<\/pre>\n
{1, 2}<\/p>\n
Usage<\/h2>\n
mylist = [1, 2, 3, 1, 2, 3, 1, 2, 3, 4]\r\nset(mylist)<\/pre>\n
{1, 2, 3, 4}<\/p>\n
set('Mississippi')<\/pre>\n{‘M’, ‘i’, ‘p’, ‘s’}
\n* Notice the values are NOT in the order they are in the array!<\/p>\nBooleans in Python<\/h1>\n
- Each value in the set must be unique.\u00a0 There are no duplucates<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- Sets are unordered collections of unique elements\n
- Notice the return sets are in parenthesis.\u00a0 These are Tuples!<\/li>\n<\/ul>\n
- Dictionaries\n
- ji<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- my_str[::-1] (Reverse a string)\n
- adgj<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- start = start index (Default = 0<\/strong>)<\/li>\n
- o<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- my_str[1]\n
- float<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- Pros\n
- This results in an error!<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- Example for C++\n
- These are known as Statically Typed<\/strong><\/li>\n
- You can reassign variable to different types:\n
- Python uses Dynamic Typing<\/strong>\n
- 2**3=8<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- % = Mod (Moulo) aka remainder\n