import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import pyplot as plt
import seaborn as sns
df=pd.read_csv("cricket.csv")
print(df.head())
If your script is called seaborn.py and inside this script you import seaborn, the script is imported into itself and hence run twice (once at import, then for the rest of the lines).
Best solution (and general advice): Never call a script by the same name as a module you want to import.
Related
I always start my notebook with the following lines of code:
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style='ticks', color_codes=True)
I wonder if I can save such lines in a separate, say, starter.txt or starter.py file once. Start notebook by loading these libraries and setting by simply loading it as module
import starter
pd.read_excel("data.xlsx")
I tried above. The code does not complain on import statement but does not recogine pd as pandas.
What is a good way to do these things. Similary I want to write modules with functions and import all the function.
I'm pretty new to Python and I am trying to understand how import works. I have a doubt when it comes to read_csv.
We generally use the following lines when we call the read_csv function.
import pandas as pd
...
...
file=pd.read_csv(Filename)
The read_csv module is present in the module pandas.io.parsers. Why don't we mention the entire path before accessing read_csv? I mean, why not this:
import pandas.io.parsers as pd
...
...
file=pd.read_csv(Filename)
If we can access a function without giving the entire path, why do we use
import matplotlib.pyplot as plt
...
...
plt.show()
when we can just write
import matplotlib as plt
...
...
plt.show()
What I mean to ask is, are the imports used in Python codes just conventions(is the .pyplot tacked on to matplotlib.pyplot omissible?) or are there specific rules? Do we use the entire location when there's a chance of clash with other methods of the same name? Do modules in a package contain non-unique function names then?
This depends on whether the package chooses to expose some of the "deeper" functions to the package namespace. This is done through a file called __init__.py. This gives flexibility, because it allows the developer to keep chunks of the source code organized in multiple folders, but easily accessible by the user importing the package as a whole.
This also means that the "rules" for importing - whether you import matplotlib or matplotlib.pyplot - depend on the package's maintainers. Both matplotlib and matplotlib.pyplot are considered packages, because they each have a __init.py file associated with their respective folder in the source code. What you exactly you import by writing import matplotlib or import matplotlib.pyplot depends on the contents of these __init__.py files.
For example, you can see in the pandas source code that there is a filled called __init__.py at the source root, meaning it will import some names whenever you import pandas in your code. It includes the import for read_csv at around line 150:
from pandas.io.api import (
# ...
read_csv,
# ...
)
If in the main python script numpy and pandas are imported
import pandas as pd
import numpy as np
and a function is then imported from funcs.py that uses pandas
import funcs.py as fp
report = fp.generate_report(arguments)
results in an error --> NameError: name pd is not defined when function is called
Do I have to import pandas within every function that uses it in pycharm?
Most of my jupyter notebooks usually begin with a long list of common packages to import. E.g.,
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
...
Is there any way I can call all of the same packages using a function defined in another python file?
For example, I tried putting the following in util.py:
def import_usual_packages():
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
And in the main notebook:
import util
util.import_usual_packages()
so that the end effect is I can still call the usual packages without using additional namespaces, e.g.
pd.DataFrame()
At the moment this wouldn't work with what I have above. E.g. pd isn't defined.
EDIT: It's similar but not exactly the same as other questions asking about how to do a from util import *. I'm trying to put the import statements inside functions of the utility python file, not simply at the top of the file. I'm aware that I can simply put e.g. import pandas as pd at the top of the util file and then run from util import *, but that is not what I'm looking for. Putting it within functions gives me additional control. For example, I can have 2 different functions called import_usual_packages() and import_plotting_packages() within the same util file that calls different groups of packages, so that in my notebook I can simply call
import_usual_packages()
import_plotting_packages()
instead of having 10+ lines calling the same stuff everytime. This is purely for personal use so I don't care about if other people don't understand what's going on (in fact, that might be a good thing in some circumstances).
With some slight modifications your method can work. In util.py
def import_usual_packages():
global pd, np # Make the names pd & np global
import pandas as pd
import numpy as np
And in main.py
import utils
utils.import_usual_packages()
utils.pd.DataFrame() # access via the utils namespace
This is definitely not the cleanest approach though.
I would like to create a function that contains all my imports statement, :
def imports():
import pandas as pd
import numpy as np
etc...
save it in a .py file as a module and call that function from my Jupyter Notebook.
This is simply to unclutter the Notebook. However it seems it doesnt work to create a function containing import statements? (I'm receiving errors NameError: name 'pd' is not defined ). Anyone knows why?
Instead, put into your module all the import statements you want and as you'd normally put them
contents_of_your_module.py
import pandas as pd
import numpy as np
import itertools
import seaborn as sns
Then you import from Jupyter
from contents_of_your_module import *
Or, you can create a namespace for your module and do this
import contents_of_you_module as radar
And then you can access all the modules via your name space
radar.pd.DataFrame
import pandas as pd creates a variable pd. In your case, the variable is local to the function and not visible outside. Declare the shortcuts to the imported modules as global variables:
def imports():
global pd, np
import pandas as pd
import numpy as np
In general, I would say that it's a very bad practice to do what you want to do. If you want to do exactly what you describe you can't do it in a pythonic way.
But this is a solution that probably would work:
Pretend you have a module called imports.py, that should handle all your imports:
File: imports.py:
import numpy as np
import pandas as pd
The you can have a function in your program.
def do_funky_import_from():
from imports import *