init commit

Author: Sentdex

22. understanding imports.py

@@ -0,0 +1,89 @@
+'''
+Now that we've used a module, statistics, it would be a good time to
+explain some import practices. As with many things in programming, there
+are many ways to import modules, but there are certainly some best
+practices.
+
+So first, when you import a module, you are basically loading that
+module into memory. Think of a module like a script. Many if not most modules
+are just a single python script. So, when you go to import it, you use the file
+name. This can help keep code clean and easy to read. Many python developers
+just program everything in 1 script. Other developers, say from a language like
+java are going to be very used to doing lots of imports with a file for each
+type of job that's happening. Just like there are many ways to import, there
+are many more ways to program.
+
+So let's talk about basic importing:
+'''
+
+# here, we have imported the entire statistics module, and we can reference
+# any of the functions within it.
+# this loads that entire module, and will run any code that is
+# set to run in the module
+# remember if name == main? Again, that's what we use to stop code
+# from running when we just want to import. 
+import statistics
+
+example_list = [5,2,5,6,1,2,6,7,2,6,3,5,5]
+
+# now, to use our import above, since we just imported statistics,
+# we must preceed any funciton wi thin statistics with a statistics.
+# so, for example, to access the mean() function within statistics:
+
+print(statistics.mean(example_list))
+
+
+# and that's it. Let's look briefly at the statistics module and the mean
+# function...c:/python34/lib/statistics  (not in site-packages)
+# take note of the package's location, we will talk more on that soon.
+# so now you see that statistics is just a python script, and mean is
+# just another function.
+
+# sometimes, you will see people who import things "as". This
+# helps to keep typing to a minimum. For example
+
+import statistics as s
+
+# above we've imported statistics as s, so when we want to reference something
+# within statistics, we just need to do s. now.
+
+print(s.mean(example_list))
+
+# What if you don't even want to type that S though? Well there's an app for that!
+# you can just import all of the functions like so:
+
+from statistics import mean
+
+# so here, we've imported the mean function only.
+
+print(mean(example_list))
+
+# and again we can do as
+
+from statistics import mean as m
+
+print(m(example_list))
+
+# what if we want to import other functions?
+
+from statistics import mean, median
+
+# here we imported 2 functions.
+
+print(median(example_list))
+
+# what if we want to use the as as well????
+
+from statistics import mean as m, median as d
+
+print(m(example_list))
+print(d(example_list))
+
+
+# What if we want to just import everything from statistics like we did initially
+# but we dont want to type the statistics because we have
+# fat fingers and this will just slow us down?.
+
+from statistics import *
+
+print(mean(example_list))

23. understanding imports 2.py

@@ -0,0 +1,3 @@
+import examplemod
+
+examplemod.ex('test')

23.-doc- examplemod.py

@@ -0,0 +1,3 @@
+
+def ex(data):
+    print(data)

24. python lists vs tuples.py

@@ -0,0 +1,53 @@
+'''
+Lets compare python lists and tuples. They are often confused.
+
+A python tuple is immutable, meaning you cannot change it. That said,
+less space is going to be required to generate a tuple, and you can use it
+for things where you don't want the tuple to change. To define a tuple, you
+either use round brackets, or no brackets. A popular use for this is multiple
+variable assignments from a function return.
+
+For example, you might see something like:
+'''
+
+def example():
+    return 15, 12
+
+x, y = example()
+print(x,y)
+
+# in the above case, we have used a tuple and cannot modify it... and
+# we definitely do not want to!
+
+
+
+'''
+A python list is mutable, and can contain just about any python data. to
+define a list, you use square brackets.
+
+'''
+
+x = [1,3,5,6,2,1,6]
+
+'''
+You can then reference the whole list like:
+'''
+print(x)
+
+# or a single element by giving its index value.
+# index values start at 0 and go up by 1 each time
+
+print(x[0],x[1])
+
+
+
+'''
+So again, a python tuple is a colleciton of data that is immutable.
+Generally the only time you will use this is when it is extremely
+important that the tuple is immutable.
+
+Then you have a python list, which is mutable and highly malleable.
+
+A tuple is defined by no containing brackets, or round brackets. A list
+is defined by square brackets. 
+'''

25. python lists.py

@@ -0,0 +1,78 @@
+'''
+Since lists are mutable, this means that we will be using lists for
+things where we might intend to manipulate the list of data, so how
+can we do that? Turns out we can do all sorts of things.
+
+We can add, remove, count, sort, search, and do quite a few other things
+to python lists. 
+'''
+
+# first we need an example list:
+
+x = [1,6,3,2,6,1,2,6,7]
+
+# lets add something.
+
+# we can do .append, which will add something to the end of the list, like:
+
+x.append(55)
+
+print(x)
+
+
+# what if you have an exact place that you'd like to put something in a list?
+
+x.insert(2,33)
+
+print(x)
+
+# so the reason that went in the 3rd place, again, is because we start
+# at the zero element, then go 1, 2.. .and so on.
+
+# now we can remove things... .remove will remove the first instance
+# of the value in the list. If it doesn't exist, there will be an error:
+
+x.remove(6)
+
+print(x)
+
+#next, remember how we can reference an item by index in a list? like:
+
+print(x[5])
+
+# well we can also search for this index, like so:
+
+print(x.index(1))
+
+# now here, we can see that it actually returned a 0, meaning the
+# first element was a 1... when we knew there was another with an index of 5.
+# so instead we might want to know before-hand how many examples there are.
+
+print(x.count(1))
+
+# so we see there are actually 2 of them
+
+# we can also sort the list:
+x.sort()
+
+print(x)
+
+
+# what if these were strings? like:
+
+y = ['Jan','Dan','Bob','Alice','Jon','Jack']
+
+y.sort()
+print(y)
+
+# noooo problemo!
+
+
+# You can also just reverse a list, but, before we go there, we should note that
+# all of these manipulations are mutating the list. keep in mind that any
+# changes you make will modify the existing variable.
+
+
+
+
+

26. python list dimension.py

@@ -0,0 +1,45 @@
+'''
+Lists that we have covered so far have all been 1 dimensional,
+but you can have lists within lists within lists within lists if you want.
+
+Often times, if you want to have lists within lists, your superior choice
+will be something like dictionaries, which we'll get to, but
+there will be times when a multi dimensional list is the best choice.
+'''
+
+x = [[2,6],[6,2],[8,2],[5,12]]
+
+# so we already know how to reference elements in a list, we can do:
+
+print(x[2])
+
+# but we can also take this deeper since we have more dimensions now:
+
+print(x[2][1])
+
+# this can go on indefinitely with very thick lists.
+# you might see how this can quickly get messy, let's consider
+# how to properly display lists in code that have multiple dimensions.
+# you might not typically hard code multi dimensional lists,
+# but it's good to know how to do it:
+
+
+y = [[5,2],
+     [6,2],
+     [3,1],
+     [12,6]
+    ]
+
+# this is slightly cleaner, and python automatically understands it:
+
+print(y)
+
+
+
+
+
+
+
+
+
+

27. reading CSV files.py

@@ -0,0 +1,75 @@
+'''
+Next up, let us cover the reading of CSV files into memory.
+
+One of the more popularly requested file types for reading into
+memory is csv files, so let us cover them.
+
+here I will just create a simple example.csv file
+
+
+
+
+'''
+import csv
+
+with open('example.csv') as csvfile:
+    readCSV = csv.reader(csvfile, delimiter=',')
+    for row in readCSV:
+        print(row)
+        print(row[0])
+        print(row[0],row[1],row[2],)
+
+
+#### next part....
+
+import csv
+
+with open('example.csv') as csvfile:
+    readCSV = csv.reader(csvfile, delimiter=',')
+    dates = []
+    colors = []
+    for row in readCSV:
+        color = row[3]
+        date = row[0]
+
+        dates.append(date)
+        colors.append(color)
+
+    print(dates)
+    print(colors)
+
+
+#### now you want to maybe ask some questions with data...
+# what day was the color green let's ask?
+
+import csv
+
+with open('example.csv') as csvfile:
+    readCSV = csv.reader(csvfile, delimiter=',')
+    dates = []
+    colors = []
+    for row in readCSV:
+        color = row[3]
+        date = row[0]
+
+        dates.append(date)
+        colors.append(color)
+
+    print(dates)
+    print(colors)
+
+    # now, remember our lists?
+
+    whatColor = input('What color do you wish to know the date of?:')
+    coldex = colors.index(whatColor)
+    theDate = dates[coldex]
+    print('The date of',whatColor,'is:',theDate)
+
+
+    #but..................... what if we enter something that is non-existent?
+    # oh noes, an error! 
+
+    
+
+
+    

27.-doc-example.csv

@@ -0,0 +1,3 @@
+1/2/2014,5,8,red
+1/3/2014,5,2,green
+1/4/2014,9,1,blue

28. multi line print.py

@@ -0,0 +1,34 @@
+'''
+So now I just briefly want to cover multi line print outs.
+I remember making beautiful print outs as sort of guis, but I would do
+print and then print out the line, then another print... and so on,
+but you can actually do multi line prints with just 1 print. So let's see:
+'''
+
+
+
+print(
+'''
+This
+is
+a
+test 
+'''
+    )
+
+print(
+'''
+So it works like a multi-line
+comment, but it will print out.
+
+You can make kewl designs like this:
+
+==============
+|            |
+|            |
+|    BOX     |
+|            |
+|            |
+==============
+'''
+    )