• Shuffle
    Toggle On
    Toggle Off
  • Alphabetize
    Toggle On
    Toggle Off
  • Front First
    Toggle On
    Toggle Off
  • Both Sides
    Toggle On
    Toggle Off
  • Read
    Toggle On
    Toggle Off
Reading...
Front

Card Range To Study

through

image

Play button

image

Play button

image

Progress

1/76

Click to flip

Use LEFT and RIGHT arrow keys to navigate between flashcards;

Use UP and DOWN arrow keys to flip the card;

H to show hint;

A reads text to speech;

76 Cards in this Set

  • Front
  • Back
List :
A Python data type that holds an ordered collection of values, which can be of any type. This is equivalant to an "array" in many other languages. Python lists are "mutable," implying that they can be changed once created.
>> x = [1, 2, 3, 4]
>> y = ['spam', 'eggs']
>> x
[1, 2, 3, 4]
>> y
['spam','eggs']

>> y.append('mash')
>> y
['spam', 'eggs', 'mash']

>> y += ['beans']
>> y
['spam', 'eggs', 'mash', 'beans']
Slice:
A pythonic way of extracting "slices" of a list using a special bracket notation that specifies the start and end of the section of the list you wish to extract. Leaving the beginning value blank indicates you wish to start at the beginning of the list, leaving the ending value blank indicates you wish to go to the end of the list. Using a negative value references the end of the list (so that in a list of 4 elements, -1 means the 4th element). Slicing always yields another list, even when extracting a single value.
>> # Specifying a beginning and end:
>> x = [1, 2, 3, 4]
>> x[2:3]
[3]

>> # Specifying start at the beginning and end at the second element
>> x[:2]
[1, 2]

>> # Specifying start at the next to last element and go to the end
>> x[-2:]
[3, 4]

>> # Specifying start at the beginning and go to the next to last element
>> x[:-1]
[1, 2, 3]

>> # Specifying a step argument returns every n-th item
>> y = [1, 2, 3, 4, 5, 6, 7, 8]
>> y[::2]
[1, 3, 5, 7]

>> # Return a reversed version of the list ( or string )
>> x[::-1]
[4, 3, 2, 1]

>> # String reverse
>> my_string = "Aloha"
>> my_string[::-1]
"aholA"
Variables:
Variables are assigned values using the '=' operator, which is not to be confused with the '==' sign used for testing equality. A variable can hold almost any type of value such as lists, dictionaries, functions.
>> x = 12
>> x
12
Functions:
Python builds functions using the syntax: def function_name(variable): Functions can be stand-alone or can return values. Functions can also contain other functions.
def add_two(a, b):
c = a + b
return c

# or without the interim assignment to c
def add_two(a, b):
return a + b
Tuples:
A Python data type that holds an ordered collection of values, which can be of any type. Python tuples are "immutable," meaning that they cannot be changed once created.
>> x = (1, 2, 3, 4)
>> y = ('spam', 'eggs')

>> my_list = [1,2,3,4]
>> my_tuple = tuple(my_list)
>> my_tuple
(1, 2, 3, 4)
List Comprehensions:
Convenient ways to generate or extract information from lists. List Comprehensions will take a general form such as: [item for item in List if Condition]
>> x_list = [1,2,3,4,5,6,7]
>> even_list = [num for num in x_list if (num % 2 == 0)]
>> even_list
[2,4,6]

>> m_list = ['AB', 'AC', 'DA', 'FG', 'LB']
>> A_list = [duo for duo in m_list if ('A' in duo)]
>> A_list
['AB', 'AC', 'DA']
Sets:
Sets are collections of unique but unordered items. It is possible to convert certain iterables to a set. {"this", "is", "a", "set"}
>> new_set = {1, 2, 3, 4, 4, 4,'A', 'B', 'B', 'C'}
>> new_set
{'A', 1, 'C', 3, 4, 2, 'B'}

>> dup_list = [1,1,2,2,2,3,4,55,5,5,6,7,8,8]
>> set_from_list = set(dup_list)
>> set_from_list
{1, 2, 3, 4, 5, 6, 7, 8, 55}
Dictionaries:
Dictionaries, like sets, contain unique but unordered items. The big difference is the concept of "keys" to retrieve "values"; "keys" can be strings, integers or tuples (or anything else hashable), but the "values" that they map to can be any data type.
>> my_dict = {}
>> content_of_value1 = "abcd"
>> content_of_value2 = "wxyz"
>> my_dict.update({"key_name1":content_of_value1})
>> my_dict.update({"key_name2":content_of_value2})
>> my_dict
{'key_name1':"abcd", 'key_name2':"wxyz"}
>> my_dict.get("key_name2")
"wxyz"
Strings:
Strings store characters and have many built-in convenience methods that let you modify their content.
>> my_string1 = "this is a valid string"
>> my_string2 = 'this is also a valid string'
>> my_string3 = 'this is' + ' ' + 'also' + ' ' + 'a string'
>> my_string3
"this is also a string"
The len() Function:
Using len(some_object) returns the number of _top-level_ items contained in the object being queried.
>> my_list = [0,4,5,2,3,4,5]
>> len(my_list)
7

>> my_string = 'abcdef'
>> len(my_string)
6
Single Line Comments:
Augmenting code with human readable descriptions can help document design decisions.
# this is a single line comment.
Multi-line Comments:
Some comments need to span several lines, use this if you have more than 4 single line comments in a row.
'''
this is
a multi-line
comment, i am handy for commenting out whole
chunks of code very fast
'''
Print:
A function to display the output of a program. Using the parenthesized version is arguably more consistent.
>> # this will work in all modern versions of Python
>> print("some text here")
"some text here"

>> # but this only works in Python versions lower than 3.x
>> print "some text here too"
"some text here too"
The range() Function:
The range() function returns a list of integers, the sequence of which is defined by the arguments passed to it.
argument variations:
range(terminal)
range(start, terminal)
range(start, terminal, step_size)

EX:
>> [i for i in range(4)]
[0, 1, 2, 3]

>> [i for i in range(2, 8)]
[2, 3, 4, 5, 6, 7]

>> [i for i in range(2, 13, 3)]
[2, 5, 8, 11]
For Loops:
Python provides a clean iteration syntax. Note the colon and indentation.
>> for i in range(0, 3):
>> print(i*2)
0
2
4

>> m_list = ["Sir", "Lancelot", "Coconuts"]
>> for item in m_list:
>> print(item)
Sir
Lancelot
Coconuts

>> w_string = "Swift"
>> for letter in w_string:
>> print(letter)
S
w
i
f
t
While Loops:
A While loop permits code to execute repeatedly until a certain condition is met. This is useful if the number of iterations required to complete a task is unknown prior to flow entering the loop.
>> looping_needed = True
>>
>> while looping_needed:
>> # some operation on data
>> if condition:
>> looping_needed = False
The str() Function:
Using the str() function allows you to represent the content of a variable as a string, provided that the data type of the variable provides a neat way to do so. str() does not change the variable in place, it returns a 'stringified' version of it.
>> # such features can be useful for concatenating strings
>> my_var = 123
>> my_var
123

>> str(my_var)
'123'

>> my_booking = "DB Airlines Flight " + str(my_var)
>> my_booking
'DB Airlines Flight 123'
raw_input():
function that enables user to insert their string
EX:
print "Halt!"
user_reply = raw_input("Who goes there!")
print "You may pass.",user_reply

>>Halt!!
>>Who goes there! BOB
>>You may pass.BOB
WHAT HAPPENS:

number = input("Type in a number: ")
text = raw_input("Type in a string: ")
print "number =", number
print "number is a", type(number)
print "number * 2 =", number * 2
print "text =", text
print "text is a", type(text)
print "text * 2 =", text * 2
>>Type in a number: 4
>>Type in a string: Hello
>>number = 4
>>number is a <type 'int'>
>>number * 2 = 8
>>text = Hello
>>text is a <type 'str'>
>>text * 2 = HelloHello
input():
function that enables user to insert their number
number = input("Type in a number: ")
Using functions as arguments in other functions
def fxy(f, x, y):
return f(x) + f(y)

def square(x):
return x*x

print fxy(square, 3, 4)


Result:
>>25

Breakdown: 3**2 + 4**2
a function to compute the sum of first and last
elements of the given list.
def add_ends(x):
"""Computes the sum of first and last element of the given list `x`.

>>> add_ends([1, 2, 3, 4, 5])
6
>>> add_ends([4, 5, 6])
10
>>> add_ends([2])
4
"""
return x[0]+x[-1]
'in' Operator :
can be used to test if an element is present in a list.
x = [1, 2, 3, 4]
print 3 in x
print 9 in x
print 7 not in x

>>> True
>>> False
>>> True
a function add_element that takes a list and a number as arguments and
adds the number to the list if that number is not already present in the list.
def add_element(values, n):
if n not in values:
values.append(n)
return values
Write a function product to compute product of a list of numbers.
def product(numbers):
result = 1
for n in numbers:
result *= n
return result

Examples of how this runs:
"""Computes product of a list of numbers.

>>> product([2, 3])
6
>>> product([1, 2, 3, 4])
24
>>> product([5, 6, 7])
210
>>> product(range(1, 11))
3628800
"""
function squares that takes a list of numbers as arguments and
returns a new list containing squares of each of the elements in the given list.
def squares(numbers):
result = []
for n in numbers:
result.append(n*n)
return result

Example of this:

"""Computes squares of numbers in the given list.

>>> squares([1, 2, 3])
[1, 4, 9]
>>> squares(range(10))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> sum(squares(range(100)))
328350
"""
sort method
x.sort()
method is used to sort a list.
x = [2, 8, 3, 4]
x.sort()
print x

>>> [2, 3, 4, 8]
sorted method
y = sorted(x)
The built-in function sorted works like the sort method, but returns a new sorted list, without modifying the original.
x = [2, 8, 3, 4]
y = sorted(x)
print x, y

>>> [2, 8, 3, 4] [2, 3, 4, 8]
Distinguish method vs. a built in function
Examples with sort & sorted:
function has curly braces after it:
b = [9,4,5,7,1]
x = sorted(b)
print x
>>>[1, 4, 5, 7, 9]
method has .'dot' notation:
a = [5,2,1,9,4]
a.sort()
print a
>>>[1, 2, 4, 5, 9]
key:

'key' argument evaluates to another function ,which you can pass into another functions argument
Example ordering a list with 'key' argument:

students = [["Alice", 40], ["Bob", 64], ["Charlie", 58], ["Dave", 43]]

def get_marks(student):
"""Returns the marks of the student.

Each student record is a list of 2 elements name and marks.
"""
return student[1]

print sorted(students, key=get_marks)

>>> [['Alice', 40], ['Dave', 43], ['Charlie', 58], ['Bob', 64]]
Classes
A basic class consists only of the class keyword, the name of the class, and the class from which the new class inherits in parentheses.

EX: class NewClass(object):
# Class magic here
Why use classes?
Python is an object-oriented programming language, which means it manipulates programming constructs called objects. You can think of an object as a single data structure that contains data as well as functions
EX:
class Fruit(object):
"""A class that makes various tasty fruits."""
def __init__(self, name, color, flavor, poisonous):
self.name = name
self.color = color
self.flavor = flavor
self.poisonous = poisonous

lemon = Fruit("lemon", "yellow", "sour", False)
Classes: __init__() function
__init__() function is required for classes, & it's used to initialize the objects it creates. __init__() always takes at least one argument, 'self' , that refers to the object being created.
Classes: self
self is the first parameter passed in the __init__() function. self refers to the object being created hence the reason it's called 'self' since the object being created its identity.
Class Syntax:
•call class then class name (parameter):
• then create a function def__init with 'self' as the 1st parameter comma then 2nd parameters.
•call self.name = name and self.occupation = occupation
•create a new variable and have it equal to your example object and use built in parameters to build your objects parameters.
class Animal(object):
def __init__(self, name):
self.name = name

zebra = Animal("Jeffrey")
print zebra.name
printing objects spaced with commas.
EX:
print zebra.name, zebra.age, zebra.is_hungry
print giraffe.name, giraffe.age, giraffe.is_hungry
print panda.name, panda.age, panda.is_hungry
To print all the objects use object name'.'object then comma ... continued
Scope: variables are accessible to all parts of a Python program at all times. When dealing with classes, you can have variables that are available everywhere (global variables), variables that are only available to members of a certain class (member variables), and variables that are only available to particular instances of a class (instance variables).
Note that each individual animal gets its own name and age (since they're all initialized individually), but they all have access to the member variable is_alive, since they're all members of the Animal class.

class Animal(object):
"""Makes cute animals."""
is_alive = True
def __init__(self, name, age):
self.name = name
self.age = age

zebra = Animal("Jeffrey", 2)
giraffe = Animal("Bruce", 1)
panda = Animal("Chad", 7)
Methods:
When a class has its own functions, those functions are called methods. You've already seen one such method: __init__().
Example shows a method called 'description'

class Animal(object):
"""Makes cute animals."""
is_alive = True
def __init__(self, name, age):
self.name = name
self.age = age
def description():
print self.name
print self.age

hippo = Animal("Jerry",12)
print hippo.description
Importing specific names from a module.
from modulename import name1, name2, name 3
The Module search path

Exactly where Python looks for modules is defined in a variable called path, which you
can access through a module called sys.
Enter the following:

>>> import sys
>>> sys.path
_list of directories in the search path_
reloading modules
imp.reload(module)
Member variables:
Variables declared inside objects. You can create new instances of that object which borrow the member variable.
Ex shows health variable:


class Animal(object):
"""Makes cute animals."""
is_alive = True
health ="good"
def __init__(self, name, age):
self.name = name
self.age = age
def description():
print self.name
print self.age

hippo = Animal("Jerry",12)
sloth = Animal("Gus",800)
ocelot = Animal("Fausto",34)
print hippo.health
print sloth.health
print ocelot.health
Inheritance:
the process by which one class takes on the attributes and methods of another, and it's used to express an is-a relationship. For example, a Panda is a bear, so a Panda class could inherit from a Bear class.
inheritance works like this:

class DerivedClass(BaseClass)

where the derived class is the new class you're making and the base class is the class from which that new class inherits.
Super Class:
Accessing parent class methods when you're working in a subclass object and you want to reference the parent objects class method.

________________________________________________________
The syntax looks like this:

class DerivedClass(Base):
def some_method(self):
super(DerivedClass, self).meth()

Where meth() is a method from the base class.
-- Base Class
class Employee(object):
def __init__(self, employee_name):
self.employee_name = employee_name
def calculate wage(self , hours):
self.hours = hours
return hours * 20.00
-- SubClass
class PartTimeEmployee(Employee):
def calculate_wage(self, hours):
self.hours = hours
return hours * 12
def full_time_wage(self, hours):
retrun super(PartTimeEmployee, self).calculate_wage(hours)

milton = PartTimeEmployee("Milton")
print milton.full_time_wage(10)
Instantiate(create a subcopy of) a Class:
you create your class with:

•class ClassName(object): *'object' is required in parenthesis because you're creating an object class
•define your __def__init method with self as first parameter.
In your instantiated object, the data you put in the parmeters aka paranthesis, is the data you created in your class that is similar in syntax to:
self.'var name' = var name.
self.'var name2' = var name2

Also you can then call the methods by using dot notation.
So class.method()
File I/O : File Input Output

Syntax : f = open("output.txt", "w")
Syntax Eplanation : This told Python to open output.txt in "w" mode ("w" stands for "write"). We stored the result of this operation in a file object, f.
You can open files in write-only mode ("w"), read-only mode ("r"), read and write mode ("r+"), and append mode ("a", which adds any new data you write to the file to the end of the file).
File Access Modes:
"r" Read from a text file
"w" Write to a text file
"a" Append text file
"r+" Read from and write to a text file
"w+" Write to and read from a text file.
"a+" Append and read from a text file.
Use open function : var = open("text file.txt", "r")

use close function at the end: text file.close()
Private names and functions in modules.

from module import * to import almost all names
from a module. The exception to this is that names in the module beginning with an
underscore
To fix that:

from modtest import _g
>>> _g(5)
5
Adding modules to the system path

>>import sys

>> sys.path

... this returns the resulting places the system path will search for modules
Once you get the path from the result of sys.path, you can concatenate a path of your own.

EX.

>>sys.path
>> [ '/Users/name/Documents']
>> sys.path = [ '/Users/name/Documents', '/Users/name/Google Drive']
>>sys.path
>> [ '/Users/name/Documents', '/Users/name/Google Drive']

Now Google drive is part of the python system path.
Running Scripts on Unix/Linux and Mac
First line of script should be like this:

#! /usr/bin/env python3.1
File Reading:
syntax : my_file.read()
my_file = open("output.txt","r")
print my_file.read()
my_file.close()

1.Declare a variable, my_file, and set it equal to the file object returned by open()ing output.txt.

2.Read from it using read(). (Use the "r" mode when calling open, since you're just reading from the file.) Use a print statement so you can see the result of reading from your file.

3.Make sure to close() your file when you're done with it! All kinds of doom will happen if you don't.
File Writing:
syntax: my_file.write("Data to be written")
my_list = [i**2 for i in range(1,11)]

my_file = open("output.txt", "r+")

for i in my_list:
my_file.write(str(i) + "\n")
my_file.close()
File Closing:
syntax: .close()
Closing a file is important! If you don't do this Python won't read or open your file because it holds this in memory buffer.
Open & Close files without using .open() or .close() methods.

You may not know this, but file objects contain a special pair of built-in methods: __enter__() and __exit__(). The details aren't important, but what is important is that when a file object's __exit__() method is invoked, it automatically closes the file. How do we invoke this method? With with and as.

The syntax looks like this:with open("file", "mode") as variable:
# Read or write to the file
with open("text.txt", "w") as textfile:
textfile.write("Success!")

Result: Success!
Validating whether a file is closed:
How can we test this?
Python file objects have a closed attribute which is True when the file is closed and False otherwise.
with open("text.txt","w") as my_file:
my_file.write("Hello!")

if my_file.close() == False:
my_file.close()
print my_file.closed


Return: True
Where to place your own modules
 Place your modules into one of the directories that Python normally searches
for modules.
 Place all the modules used by a Python program into the same directory as the
program.
 Create a directory (or directories) that will hold your modules, and modify the
sys.path variable so that it includes this new directory.
Changing and or editing the current working directory
>> import os
>> os.getcwd # returns the current working directory

>>> os.listdir(os.curdir) # returns the items in directory
>>> os.chdir(folder) #change current working directory
API requests:

import urlopen from urllib2

use urlopen: google = urlopen(www.google.com)
getting a request: response = google.read()
limiting characters on request: response[20:50]
print request
,
4 HTTP Verbs(Methods)

So when we sent our GET request to placekitten.com using urlopen(), we retrieved information. When you add to or update your blog, you're sending POST or PUT requests; when you delete a tweet, there goes a DELETE request.
GET: retrieves information from the specified source.
POST: sends new information to the specified source.
PUT: updates existing information of the specified source.
DELETE: removes existing information from the specified source.
MAKING A POST:
Using the Requests library, you can make a POST request by using the requests.post() method. You aren't just GETting data with a POST - you can pass your own data into the request as well, like so:
requests.post("http://placekitten.com/", data="myDataToPost")
import requests

body = {'Name': 'Eric', 'Age': '26'}

# Make the POST request here, passing body as the data:
response = requests.post("http://codecademy.com/learn-http/", data=body)

########## Example request #############
# POST /learn-http HTTP/1.1
# Host: www.codecademy.com
# Content-Type: text/html; charset=UTF-8
# Name=Eric&Age=26
String Formatting:

%s - String (or any object with a string representation, like numbers)
%d - Integers
%f - Floating point numbers
%.<number of digits>f - Floating point numbers with a fixed amount of digits to the right of the dot.
%x/%X - Integers in hex representation (lowercase/uppercase)
# This prints out "John is 23 years old."
name = "John"
age = 23
print "%s is %d years old." % (name, age)
Hello John Doe . Your current balance is $53.44 .
name = "John Doe"
balance = 53.44

print "Hello %s . Your current balance is $%.2f ." % (name, balance)
Using 'else' in loops
You can use 'else' in loops by using break or continue.

EX:
tries = 0

while tries < 3:
password = raw_input("Password: ")
if password == "I<3Bieber":
break
else:
tries +=1
else:
print "Suspicious activity. The authorities have been alerted."

EX:phrase = "it marks the spot"
for letter in phrase:
if letter == "X":
break
else:
print "There was no 'X' in the phrase"
Way to create infinite loops
while True:
use CTRL+SPACE to view all the methods of a string object , then write a script that returns the lower-case version of a string
hello = "hi"

hello. [hit ctrl+space]
Control the flow of loops & if statements with 'break' & 'flow'
break : allows you to break out of a loop

continue : skips item and continues
Using graceful Errors with try/except pair.

Ex: int("hello")

ValueError: invalid literal for int() with base 10: 'not a number'
try:
number = int(raw_input("Enter an integer: "))
except ValueError:
print "That was not an integer."

everything inside of the “try”
block is run normally. If no error occurs, the code skips over the “except” block and
continues running normally.
Since we said “except ValueError”, however, if the
program encounters a ValueError , we jump down to the “except” block and run everything there.
Using if while loops.
# 5.6.2 coin_toss.py
# Simulate the results of a series of coin tosses and track the results

from __future__ import division
from random import randint

flips = 0
trials = 10000

for trial in range(0, trials):
flips += 1 # first flip
if randint(0, 1) == 0: # flipped tails on first flip
while randint(0, 1) == 0: # keep flipping tails
flips += 1
flips += 1 # finally flipped heads
else: # otherwise, flipped heads on first flip
while randint(0, 1) == 1: # keep flipping heads
flips += 1
flips += 1 # finally flipped tails

print flips / trials
SUCCESSFUL COPYING OF LISTS CONTENT

Copying a list into another list is intuitive:

Here's why:
>>> animals = ["lion", "tiger", "frumious Bandersnatch"]
>>> large_cats = animals
>>> large_cats.append("Tigger")
>>> print animals
['lion', 'tiger', 'frumious Bandersnatch', 'Tigger']
>>>

You changed the original animal string object. Because animals and large_cats point to the same object.
Successful way of copying a list to another object.

large_cats = animals[:]

The"[:]" is the same technique used to retrieve a subset of the list over some range, in this case everything.
Tuple packing and unpacking.

Packing: When we assign a list of objects to a new object.

Unpacking: When we retrieve the individual values from a tuple.
Packing:
>>> coordinates = 4.21,9.29
>>> print coordinates
>>>(4.21, 9.29)

Unpacking:
>>>x,y = coordinates
>>> print x
4.21
>>> print y
9.29
Tuple packing and unpacking part II
>>> browsers = 'chrome','firefox','safari','opera','explorer'
>>> a,b,c,d,e = browsers
>>> print a
chrome
>>> print d
opera
>>> print e
explorer
>>> print browsers
('chrome', 'firefox', 'safari', 'opera', 'explorer')
>>>
Opening files with 'with' keyword.

When we say"with X as Y" we are defining the variable Y to be the result of running X

When opening files with 'with' keyword , we don't have to .close() it after because 'with' holds it only until it runs.
EX of using with open:

with open("hello.txt", "r") as myInputFile:
for line in myInputFile.readlines():
print line,
Naming multiple variables in a 'with' statement if you want to open multiple files at once.
with open("hello.txt", "r") as myInput, open("hi.txt", "w") as myOutput:
for line in myInput.readlines():
Read & write modes:

open('hello.txt','r') = read mode

open('hello.txt','w') = write mode

open('hello.txt','a') = append mode

open('hello.txt', 'r+') = both reading & writing

open('hello.txt,'ra+') = both read & append
Reading from a file and writing to another:

with open("hello.txt", "r") as myInput, open("hi.txt", "w") as myOutput:
for line in myInput.readlines():
myOutput.write(line)
open more complicated folder structures
myInputFile = open("C:/My Documents/useless text file/hello.txt", "r")

*Open files in specific directories. Use forward slash as backsplashes are used for escape sequences.

Other way to perform is :

myName = r"C:\My Documents\useless text files\hello.txt"
Getting all files & subfolders of a specific directory:

use of os.walk() which will allow to return specific results from (folder, subfolders, file names) as tuples
EX:
import os

myPath = "C:/-----/------/-----/----/"

for currentFolder, subfolders, fileNames in os.walk(myPath):

for fileName in fileNames:
print os.path.join(currentFolder, fileName)


Result EX:

>>>
C:/Users/denigf/Desktop/REAL PYTHON/CHP 1/Real Python files/Course materials/Chapter 7/Practice files/images\one more image.jpg

C:/Users/denigf/Desktop/REAL PYTHON/CHP 1/Real Python files/Course materials/Chapter 7/Practice files/images\png file - not a gif.jpg

C:/Users/denigf/Desktop/REAL PYTHON/CHP 1/Real Python files/Course materials/Chapter 7/Practice files/images\additional files\.BridgeCache

C:/Users/denigf/Desktop/REAL PYTHON/CHP 1/Real Python files/Course materials/Chapter 7/Practice files/images\additional files\.BridgeCacheT

C:/Users/denigf/Desktop/REAL PYTHON/CHP 1/Real Python files/Course materials/Chapter 7/Practice files/images\additional files\one last image.jpg