diff --git a/Iterators.py b/Iterators.py
new file mode 100644
index 0000000..20a97f1
--- /dev/null
+++ b/Iterators.py
@@ -0,0 +1,35 @@
+# Iterators are objects that represent a stream of data. It returns
+# the data in the stream one at a time.
+# Any object that supports iteration is called an iterable
+
+# For loops creat iterators for you.
+# The code block below prints out each character before terminating
+# string = "1234567890"
+
+# for char in string:
+    # print(char)
+# The code block below shows the iterator in action, using the next
+# function to go through each iterator
+# my_iterator = iter(string)
+# print(my_iterator)
+# print(next(my_iterator))
+# print(next(my_iterator))
+
+list1 = ["I", "love", "oatmeal", "and", "toast"]
+n = len(list1)
+new_iter = iter(list1)
+
+# while n >= len(list1):
+#     for item in list1:
+#         print(next(new_iter))
+#         n += 1
+
+# Cleaner version
+
+for i in range(0, len(list1)):
+    next_item = next(new_iter)
+    print(next_item)
+
+for i in list1:
+    print(i)
+
diff --git a/Lists.py b/Lists.py
new file mode 100644
index 0000000..ef2165f
--- /dev/null
+++ b/Lists.py
@@ -0,0 +1,30 @@
+# Lists in python can be a sequence of strings as well
+# as a sequence of lists.
+# Lists are defined by use of square brackets []
+
+# The code block below prints out each game on a seperate line, along with an
+# append to the list; which adds Halo 5 as the fifth game
+haloGames_list = ["Halo 1", "Halo 2", "Halo 3", "Halo 4"]
+haloGames_list.append("Halo 5")
+for game in haloGames_list:
+    print("This game is " + game)
+
+# Lists can also be concatenated, meaning the lists can be added together
+# Here we take the haloGames_list and add in all the games that did not
+# follow Master Chief
+moreHalo_List = ["Halo Reach", "Halo 3 ODST", "Halo Wars"]
+allHalo = haloGames_list + moreHalo_List
+# allHalo.sort() # You can sort lists as well using the .sort() function however,
+# the function does not return numbers. If you need to return the values, use the
+# sorted() function with the variable you want to return inside the parenthesis
+print(allHalo)
+
+# The .count function is used in this code block to count the periods in the ip
+# address that was entered by the user
+ip = input("Please enter an IP address:")
+print(ip.count("."))
+
+# even = [2, 4, 6, 8]
+# # another_even = even
+# # another_even.sort(reverse=True)
+# # print(even)
diff --git a/Ranges.py b/Ranges.py
new file mode 100644
index 0000000..ac48cd2
--- /dev/null
+++ b/Ranges.py
@@ -0,0 +1,51 @@
+# Ranges are a built in type in python 3
+print(range(100))
+my_list = list(range(10))
+print(my_list)
+
+# Ranges can be used to build lists
+even = list(range(0, 10, 2))
+odd = list(range(1, 10, 2))
+print(even)
+print(odd)
+
+# Ranges don't support all operations that can be performed on sequences
+# Multiplication and concatenation or appending are not supported
+
+# The code below shows you behind the scenes of ranges:
+# The .index function shows you the position of a character within
+# the range whereas inputting brackets with a number shows the character
+# at said index.
+my_string = "abcdefghijklmnopqrstuvwxyz"
+print(my_string.index('e'))
+print(my_string[4])
+
+small_decimals = range(0, 10)
+print(small_decimals)
+print(small_decimals.index(3))
+
+# When ranges have the same output, they are considered equivalent.
+# Example below: even though both ranges are different, they output the same
+# set of numbers
+for i in range(0, 5, 2):
+    print(i)
+for i in range(0, 6, 2):
+    print(i)
+print(range(0, 5, 2) == (range(0, 6, 2)))
+
+# When slicing backwards with ranges, the start and stop values must be reversed
+# for the ranges to work the way they are intended.
+# Example: The first range will not print out anything because it has already reached
+# the end of the range (zero). Whereas the second range will print something out
+
+for i in range(0, 100, -5):
+    print(i)
+for i in range(100, 0, -5):
+    print(i)
+
+# Stepping backwards in a string can also be used for printing strings
+# in reverse:
+backwardsString = "gnirts sdrawkcab a si sihT"
+print(backwardsString[::-1])
+
+
diff --git a/Tuples.py b/Tuples.py
new file mode 100644
index 0000000..0fa9c42
--- /dev/null
+++ b/Tuples.py
@@ -0,0 +1,56 @@
+# In Python, Tuples are similar to lists except that they are immutable.
+# Meaning they can't be changed or appended; you would receive an error
+# in doing so.
+
+# Tuples can be defined with or without parenthesis, except for when
+# syntax requires it like in the 3rd example.
+# The first and third examples are tuples, signified by the square
+# brackets that are printed
+t = "a", "b", "c"
+print(t)
+
+print("a", "b", "c")
+print(("a", "b", "c"))
+
+# Tuples can be printed over multiple lines: you can do this by adding
+# square brackets containing the step in the tuple
+lotrOne = "The Lord of the Rings", "The Fellowship of the Ring", 1
+lotrTwo = "The Lord of the Rings", "The Two Towers", 2
+lotrThree = "The Lord of the Rings", "The Return of the King", 3
+
+print(lotrThree)
+print(lotrThree[0])
+print(lotrThree[1])
+print(lotrThree[2])
+# Lists are intended (although not enforced) to contain items of the same type.
+# Tuples are intended to hold items of different types.
+
+# Right hand sides of equations are evaluated first before the left hadn
+# side of the equation is.
+# Therefore you can assign a number or string to multiple variables
+# or assign multiple numbers/strings to multiple variables at once.
+# The example below shows how the values assigned are the same/correspond with
+# their variables across the board.
+a = b = c = d = 12
+print(a)
+print(c)
+a, b, c, d = 2, 4, 6, 8
+print(a)
+print(c)
+print(a, c)
+print(b, d)
+print(a, b, c, d)
+
+# Tuples can also be "unpacked", allowing for multiple use of the items it contains
+# Example: The code block below "unpacks" the tuple and assigns variables
+# to the items in the tuple. The variables are then printed out using the
+# print function
+
+series, movie, movieNum = lotrTwo
+print(series)
+print(movie)
+print("Movie No. {}".format(movieNum))
+
+# You can also put a tuple within a tuple, and you can unpack that as well
+# Tuples can also contain lists as well. The lists it contains can
+# be updated.
