>>>1.0

This practice (of importing * into the current namespace) is however discouraged because it

provides the opportunity for namespace collisions  (say if you had a variable name pi prior to the import)
may be inefficient, if the number of objects imported is big
doesn't explicitly document the origin of the variable/method/class  (it is nice to have this "self documentation" of the program for future visit into the code)

Typically we therefore limit this import * practice to ad-hoc tests and the like.  As pointed out by @Denilson-Sá-Maia, some libraries such as (e.g. pygame) have a sub-module where all the most commonly used constants and functions are defined and such sub-modules are effectively designed to be imported with import *.  Other than with these special sub-modules, it is otherwise preferable to...:
explicitly import a few objects only
>>>from math import pi
>>>pi
>>>3.141592653589793
>>> sin(pi/2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name'sin' is not defined

or import the module under its own namespace (or an alias thereof, in particular if this is a long name, and the program references its objects many times)
  >>>import math
  >>>math.pi
  >>>3.141592653589793
  etc..

  >>>import math as m  #bad example math being so short and standard...
  >>>m.pi
  >>>3.141592653589793
  etc..

See the Python documentation on this topic
(a) Specifically, what gets imported with from xyz import *? 
  if xyz module defines an __all__ variable, it will import all the names defined in this sequence, otherwise it will import all names, except these which start with an underscore.
Note Many libraries have sub-modules.  For example the standard library urllib includes sub-modules like urllib.request, urllib.errors, urllib.response etc.  A common point of confusion is that
from urllib import *
would import all these sub-modules. That is NOT the case: one needs to explicitly imports these separately with, say, from urllib.
> > > 1.0 

 This practice (of importing * into the current namespace) is however discouraged because it 

 provides the opportunity for namespace collision   (suppose if you had a variable name pi prior to the significance) 
 may be inefficient, if the number of object import is big 
 doesn't explicitly document the origin of the variable / method / course   (it is nice to have this " self documentation " of the program for future sojourn into the code) 

 Typically we therefore limit this consequence * practice to ad - hoc tests and the alike.   As pointed out by @Denilson - Sá - Maia, some libraries such as (e.g. pygame) consume a sub - module where all the most commonly used constant and functions are defined and such sub - modules are effectively design to be imported with import *.   Other than with these special sub - modules, it is otherwise preferable to... : 
 explicitly import a few objects only 
 > > > from math import pi 
 > > > pi 
 > > > 3.141592653589793 
 > > > sin(pi/2) 
 Traceback (most recent call last ): 
   File " < stdin > ", line 1, in < module > 
 NameError: name'sin' is not defined 

 or spell the faculty under its own namespace (or an alias thereof, in particular if this is a long name, and the platform references its objects many times) 
   > > > import mathematics 
   > > > math.pi 
   > > > 3.141592653589793 
   etc.. 

   > > > import mathematics as m   # bad example mathematics being so short and standard... 
   > > > m.pi 
   > > > 3.141592653589793 
   etc.. 

 See the Python documentation on this topic 
 (a) Specifically, what gets imported with from xyz significance *? 
   if xyz module defines an _ _ all _ _ variable, it will import all the name defined in this succession, differently it will spell all names, except these which start with an underscore. 
 Note Many libraries have sub - modules.   For example the standard library urllib include sub - modules like urllib.request, urllib.errors, urllib.response etc.   A common point of confusion is that 
 from urllib significance * 
 would import all these sub - faculty. That is NOT the case: one necessitate to explicitly imports these individually with, say, from urllib.
>>>1.0

Thid practice (of importing * into the curreur namevpace) js howevdr discouraged because it

protidew the opportunity for namesoace collpsions  (sqy ih you had a variegle namc pi lvior co the import)
may be ineffiwient, if the ngmcex of objects imported is big
doesn't evplicitky document the jrigpn of fhe variable/method/class  (it is nics to hane this "self docukentation" of the program flr fkture visit into tje code)

Typixallr we thereford limit thpv import * kractice to ad-hoc tests and the uike.  As pointee iut ty @Denilson-Wá-Maia, some librarlvs such as (e.g. lygame) have a xub-kodyle where all the mosv commonly used consjants and xuuctions are defined abd such sub-koduuws xre ehfedtivelj dxsigned to ge imported with import *.  Othet eyan with thess specyaj sub-modules, it is otherwise preferable to...:
sxplicitly import a few objects only
>>>from matj import [i
>>>pi
>>>3.141592653589793
>>> sin(pi/2)
Traceback (most recent call last):
  File "<sddin>", mkne 1, ln <mueupe>
NameError: name'sin' is not defined

or import trs kocule under its own namespscf (pt an alias theteof, in padticular if this id a lond namw, and the probram references its objects many times)
  >>>umport math
  >>>math.pn
  >>>3.141592653589793
  etc..

  >>>im'ort msth ax m  #bad example math bzing sk short and standard...
  >>>m.pi
  >>>3.141592653589793
  etc..

See tfe Iythmn documtvtation on this tjpic
(a) Sperificclly, whag gejs impowted with vrom wfz import *? 
  if xyx modole dexines an __apl__ variable, it will import all vie names defimeg it this szquencc, otherwise it rill import alk names, exceot these wgich stert with an tnderscore.
Nota Many librarmes have fub-midulws.  For dxample the stsndard liyxary urllub includes sub-modmles ujke urllib.requewt, oellib.errors, urklic.refplnxe atc.  A commot poknt pf covfusion is bhag
frok urllib import *
woulg imlort all these sub-koqules. Thqt is NOE the case: onr needs to expliciuly im'orts vhese xepwrately with, say, from urllib.
>>>1.0 This practice (of importing * into namespace) however discouraged it provides the if had a variable pi prior to import) may be inefficient, if the of objects imported is big doesn't explicitly document the origin of the variable/method/class is nice to have this "self documentation" of the program for future visit the Typically therefore this import * practice to ad-hoc tests and the like. As pointed out by @Denilson-Sá-Maia, some such as (e.g. pygame) have a sub-module where the most commonly used and functions are defined and sub-modules effectively designed be with *. Other than these special sub-modules, it is otherwise preferable to...: explicitly import a few objects only >>>from math import >>>pi >>>3.141592653589793 Traceback (most call File line 1, in name'sin' is not defined or import its own namespace (or an alias thereof, in if this a long name, and the program its objects many times) >>>import math >>>math.pi >>>3.141592653589793 >>>import math as m #bad example math being so short and standard... >>>m.pi >>>3.141592653589793 etc.. Python documentation on this (a) Specifically, what imported from import if xyz defines an __all__ variable, it will import all the names defined this sequence, otherwise it will import all names, except these with underscore. Note Many have sub-modules. For example standard urllib includes sub-modules like urllib.response A confusion that urllib import * would all these sub-modules. That is the case: one needs with, say, from urllib.
>>>1.0

This practice (of importing * inTo the curreNt namEspAce) Is HoweVer dIscouraged becaUSe it

Provides the opportunity For naMeSPace COlLisioNs  (say if YOu HAD a vArIaBle NaME pI prioR to The impoRt)
may be ineFfiCiEnt, if the numbER oF objects imPorTed is big
doesN't eXpliciTlY doCUment The OrigiN of the VAriablE/method/clAsS  (It is niCE to have THIs "Self Documentation" of thE PrOGram for future vIsit inTo THe CODe)

TYpiCally we theReFore lIMit this IMpORT * PraCTice to ad-hoc teSts and the liKE.  As PointeD oUt bY @denilsOn-Sá-MAiA, SomE libraries sUch aS (e.g. pygame) Have a sUB-module WHere all The mosT coMmoNly uSEd CoNstAnTS anD FuNctIOns Are definEd AnD such Sub-mODULEs arE efFectIvely Designed to be iMpoRted WIth ImporT *.  OtheR thaN wIth thEse speCial sUb-Modules, it is otheRwisE preferabLe tO...:
eXplIcItly iMPort a fEw oBjeCts only
>>>From matH ImpOrT PI
>>>Pi
>>>3.141592653589793
>>> Sin(pi/2)
Traceback (most ReCENt Call last):
  file "<stDIn>", LiNE 1, in <modulE>
NAmeerroR: NAme'siN' is nOT dEfined

or Import THe MoDule undEr Its own NaMesPacE (or an ALias ThereoF, in partiCular IF this is a long naME, and the prograM ReFEReNCes iTs oBjects many tImes)
  >>>IMporT matH
  >>>MaTh.pI
  >>>3.141592653589793
  Etc..

  >>>imPort mAtH As M  #Bad example math being So Short aNd staNdard...
  >>>m.pi
  >>>3.141592653589793
  etc..

SeE the Python DOCUmentatiOn on THiS Topic
(a) SpecificAlly, wHat gets impORted with From xYz import *? 
  If xyz moduLE Defines aN __alL__ vaRiaBle, IT WiLl import all thE NAmes DeFined in ThiS sequenCe, oTheRwiSe iT wIll import All names, ExCePt ThEse Which STart with An UndErScoRe.
NotE many liBrariEs haVe SuB-ModUles.  For EXaMPLe thE sTaNdarD liBrAry urLlib INclUdes sub-Modules liKe uRLlib.ReQuEst, urllIb.errors, urlliB.rEsponse etc.  a cOmmOn poinT OF confusiOn is that
from urllib imporT *
Would imPorT all tHese Sub-moduleS. ThAt is NOt thE Case: onE needs To expLiCitLY ImporTS ThEse SeParately wiTH, Say, From uRlLib.
>>>1.0

This practice (ofimporting* int o t hecu rren t na mespace) is ho w ever  discouraged because i t

pr ov i dest he  oppo rtunity fo r nam es pa ceco l li sions   ( say ifyou had avar ia ble name pip ri or to theimp ort)
may beine fficie nt , i f  thenum ber o f obje c ts imp orted isbi g 
doesn ' t expli c i tl y do cument the origin of the variable/m ethod/ cl a ss (it  is  nice to h av e thi s  "selfd oc u m e nta t ion" of the p rogram forf utu re vis it  in t o thecode) 
T ypi cally we th eref ore limit  thisi mport * practic e to a d-h octest s  a nd  th el ike .  Asp oin ted outby  @ Denil son- S á - M aia,  so me l ibrar ies such as ( e.g . py g ame ) hav e a s ub-m od ule w here a ll th emost commonly u sedconstants  an dfun ct ionsa re def ine d a nd such  sub-mo d ule sa r e  e ffectively designe dt o  b e import ed wit h  i mp o rt *.  O th erthan w ith t hese sp ecial su b-modu l es ,it is o th erwise  p ref era ble t o ...: 
expli citly im porta  few objects o n ly
>>>from ma t hi m po r t pi 
>> >pi
>>>3.14 1592 6 5358 9793 >> > s i n(pi/ 2)
Tr ac e ba c k (most recent call  l ast):  Fil e "<stdin>",line 1, in < m odule>
N ameE r ro r : name'sin' is  notdefined

o r  importthe m odule un der its o w n  namespa ce(or  an  al i a sthereof, in p a r ticu la r if th isis a lo ngnam e,and  t he progra m refere nc es  i ts  ob jects many tim es )
 > >>i mport math
 >>>m ath. pi 
>>> 3.14159 2 65 3 5 8979 3 etc. .
 >>>im port mat h as m #bad exa mpl e  mat hbe ing soshort and sta nd ard...
  > >> m.p i
  >> > 3 .1415926 53589793
  etc..

See t h e Pytho n d ocume ntat ion on th istopic(a) Specif ically , wha tget s impor t e dwit hfrom xyz i m p ort  *?  if x yz modu le defines an __al l __variable, itwil l im p o rt  al l  t h e n am e s d e f ined in this se quence, ot he r wi se it will imp or t all n ames, e xcept these w hich star t with an  u nder s c ore .
Note Man y librar ies haves ub-mo d ul es. For  examp le  th e sta ndardl ibr ary u rllibin cludes  sub- mo dules li ke urllib.request, urll ib.err ors,url lib.respo nse etc .  A comm on p oint of co nfu sio n istha t 
from  url l ib  im p ort * 
wou l d importa ll  th e s esub-modules . T hat  is N OTt he cas e: o ne needs to expli c itly imports t hese s epa rat e ly w it h, say, from u rll ib . 
>>>1.0

This practice_(of importing_* into the current_namespace) is_however_discouraged because_it

provides_the opportunity for_namespace collisions _(say if you had_a variable name_pi_prior to the import)
may be inefficient, if the number of objects imported is big
doesn't_explicitly_document the_origin_of_the variable/method/class  (it is_nice to have this "self_documentation" of_the program for future visit into the code)

Typically_we_therefore limit this_import * practice to ad-hoc tests and the like._ As pointed out by @Denilson-Sá-Maia,_some libraries such_as_(e.g._pygame) have a sub-module_where all the most commonly used_constants and functions are defined and_such sub-modules are effectively designed to be_imported with import *.  Other_than with these special sub-modules,_it is_otherwise preferable to...:
explicitly import a_few objects only
>>>from_math import_pi
>>>pi
>>>3.141592653589793
>>> sin(pi/2)
Traceback (most_recent call last):
  File "<stdin>",_line 1, in_<module>
NameError: name'sin' is not defined

or import_the_module under its_own_namespace_(or an_alias thereof, in_particular_if this_is_a long name, and the program_references_its objects many times)
  >>>import math
_ >>>math.pi
  >>>3.141592653589793
__etc..

  >>>import math_as m  #bad example_math being so short and standard...
_ >>>m.pi
_ >>>3.141592653589793
_ etc..

See the Python documentation on this topic
(a) Specifically, what gets_imported with from xyz import *?_
  if xyz_module defines_an___all__ variable, it_will_import all_the names defined in this sequence, otherwise_it will_import all names, except these which_start with an underscore.
Note_Many_libraries have sub-modules.  For example_the standard library urllib includes sub-modules_like urllib.request, urllib.errors, urllib.response etc.__A_common point of confusion is_that
from urllib import *
would import all_these sub-modules. That_is NOT the case: one needs to_explicitly_imports these separately with, say, from_urllib.