programing

'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?

kingscode 2023. 1. 2. 22:44

'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?

'아까'를 사용하는 노력했습니다.import module ★★★★★★★★★★★★★★★★★」from module importPython을 시작한 지 얼마 되지 않아 베스트 프랙티스를 염두에 두고 시작하려고 합니다.

기본적으로, 누군가 자신의 경험을 공유할 수 있다면, 다른 개발자들이 어떤 것을 선호하는지, 그리고 앞으로 다른 개발자들을 피하는 가장 좋은 방법은 무엇일까요?

「」의 import module ★★★★★★★★★★★★★★★★★」from module import foo로로주주 주다다다다다가장 마음에 드는 것을 선택해, 일관되게 사용해 주세요.여기 여러분이 결정하는 데 도움이 되는 몇 가지 요점이 있습니다.

import module

장점:
- of less의 가 적음importImport. 모듈의
단점:
- 「」를 합니다.module.foo장황한 될 수 은 '테디움'을 하려면 '테디움'을 사용합니다).import module as mo 후, 「」를 입력합니다.mo.foo)

from module import foo

장점:
- 이 적고, 「」를 사용할 수 있다.foo
- 모듈의 항목에 액세스할 수 있는 추가 제어
단점:
- 의 새 .import의 표시
- .foo 어떤 것이 더 ceil()이랑 math.ceil()

두 가지 방법 중 하나를 사용할 수 있지만 사용하지 마십시오.from module import *

큰 에 대해서도, 「」라고 하는 는,import *분리할 수 없는 상태로 모듈에 접착될 수 있습니다.이 '에서 나온 에 'module'을 할 수 입니다.import더 이상은 아니지만 확신하기는 매우 어렵습니다.

모듈 쓰기와 관련된 또 다른 세부사항이 있습니다.흔한 일은 아닐지 몰라도 가끔 필요했어요

Python에서는 참조 및 이름 바인딩이 동작하기 때문에 모듈의 일부 기호(foo.bar 등)를 모듈 외부에서 업데이트하고 다른 Import 코드 "see"가 변경되도록 하려면 특정 방법으로 foo를 Import해야 합니다.예를 들어 다음과 같습니다.

모듈 foo:

bar = "apples"

모듈 a:

import foo
foo.bar = "oranges"   # update bar inside foo module object

모듈 b:

import foo           
print foo.bar        # if executed after a's "foo.bar" assignment, will print "oranges"

단, 모듈명이 아닌 심볼명을 Import 하는 경우는 동작하지 않습니다.

예를 들어 모듈a에서 이 작업을 수행할 경우:

from foo import bar
bar = "oranges"

이외의 코드는 없습니다.a 알게 될 것이다bar인 '아까'가 '아까'이기 때문에 '한다.bar 내의 '바을 준 것 뿐입니다.a 「 않았습니다.foo와 그 module object를 합니다.bar.

많은 import »import from후드 아래에서 무슨 일이 일어나는지, 그리고 그 모든 변화가 어디에 있는지 좀 더 자세히 설명하려고 합니다.

`import foo`:

( 져오기))foo현재 네임스페이스에 해당 모듈에 대한 참조를 만듭니다.다음으로 모듈 내부에서 특정 속성 또는 메서드에 액세스하기 위한 완료된 모듈 경로를 정의해야 합니다.

★foo.bar 아니다bar

`from foo import bar`:

( 져오기))foo리스트 되어 있는 를 작성합니다( 「」「」「」「」「」「」bar.foo.

★bar 아니다baz ★★★★★★★★★★★★★★★★★」foo.baz

`from foo import *`:

( 져오기))foo네임스페이스에서 에 의해 되어 있는 모든 것).__all____all__않는 경우, 「」로은 모두 존재합니다._.foo.

★bar ★★★★★★★★★★★★★★★★★」baz 아니다_qux ★★★★★★★★★★★★★★★★★」foo._qux.

이번에는 할 때 import X.Y:

>>> import sys
>>> import os.path

마크를 켜주세요.sys.modulesos ★★★★★★★★★★★★★★★★★」os.path:

>>> sys.modules['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> sys.modules['os.path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

마크를 켜주세요.globals() ★★★★★★★★★★★★★★★★★」locals()에는 '먹다'가 붙습니다.os ★★★★★★★★★★★★★★★★★」os.path:

>>> globals()['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> locals()['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> globals()['os.path']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'os.path'
>>>

에서 알 수 있는 은 「」뿐입니다.os로컬 및 글로벌네임스페이스에 삽입됩니다.따라서 다음을 사용할 수 있어야 합니다.

>>> os
<module 'os' from
  '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> os.path
<module 'posixpath' from
 '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>>

아니다path.

>>> path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'path' is not defined
>>>

" " " " "os에서는 locals()에 수 os만 아니라os.path.sys.sys.sys.sys.sys discs에 sys 에음 음음 음음 음음 음음 음음 even even sys even even even even even even even even even even even even even even

>>> del locals()['os']
>>> os
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'os' is not defined
>>> os.path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'os' is not defined
>>>

에는 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 하다에 대해서 이야기해 `import from`:

`from`:

>>> import sys
>>> from os import path

마크를 켜주세요.`sys.modulesos` ★★★★★★★★★★★★★★★★★」`os.path`:

>>> sys.modules['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> sys.modules['os.path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

그것은 에서 발견되었습니다.sys.modules요.import name

그럼 어떻게 요?locals() ★★★★★★★★★★★★★★★★★」globals()다음 중 하나:

>>> globals()['path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> locals()['path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> globals()['os']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'os'
>>>

하려면 , 이름 을 합니다.path 아니다os.path:

>>> path
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> os.path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'os' is not defined
>>>

'은 '길'에서요?locals():

>>> del locals()['path']
>>> path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'path' is not defined
>>>

에일리어스를 사용한 마지막 예:

>>> from os import path as HELL_BOY
>>> locals()['HELL_BOY']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> globals()['HELL_BOY']
<module 'posixpath' from /System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>>

또한 경로가 정의되지 않았습니다.

>>> globals()['path']
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'path'
>>>

두 가지 방법이 모두 지원되는 이유는 둘 중 하나가 다른 것보다 더 적절한 경우가 있기 때문입니다.

import module할 때 각 모듈의 많은 비트를 사용하는 경우 좋습니다.단점은 모듈명으로 각 참조를 한정해야 한다는 것입니다.
from module import ... 프리픽스 직접 할 수 Import된 아이템은 모듈명 프리픽스 없이 직접 사용할 수 있어 좋습니다.단점은 사용하는 것을 일일이 나열해야 하고, 코드상 무엇인가가 명확하지 않다는 것입니다.

어떤 코드를 사용할지는 어떤 것이 코드를 명확하게 하고 읽을 수 있는지에 따라 다르며, 개인적인 선호도와는 거의 관련이 없습니다.나는 에 기울어져 있다.import module일반적으로 코드에서는 물체나 기능이 어디서 왔는지 매우 명확하기 때문입니다. 용 i i i i를 쓴다.from module import ...코드에서 객체/함수를 많이 사용하는 경우.

저는 개인적으로 항상

from package.subpackage.subsubpackage import module

모든 것에 액세스 할 수 있습니다.

module.function
module.modulevar

그 이유는 호출이 짧은 동시에 각 루틴의 모듈 네임스페이스를 명확하게 정의하기 때문입니다.이것은 소스에서 특정 모듈의 사용을 검색해야 할 경우에 매우 유용합니다.

Import *는 네임스페이스를 오염시켜 특정 함수의 출처(어느 모듈)를 알 수 없으므로 사용하지 마십시오.

물론 두 개의 다른 패키지에 포함된 두 개의 다른 모듈에 대해 동일한 모듈 이름이 있으면 다음과 같이 문제가 발생할 수 있습니다.

from package1.subpackage import module
from package2.subpackage import module

이 경우 물론 문제가 발생하지만 패키지 레이아웃에 결함이 있다는 강한 힌트가 있으므로 다시 생각해보아야 합니다.

import module

모듈의 많은 기능을 사용하는 경우에 적합합니다.

from module import function

되는 것을 때 합니다.function.

나는 방금 이 두 방법 사이의 미묘한 차이점을 하나 더 발견했다.

모듈 If 듈foo합니다.

from itertools import count

으로 모듈 " " " 입니다.bar 사용할 수 count 되어 있는 foo에.itertools:

import foo
foo.count()

iffoo 삭제:

import itertools

실수는 여전히 가능하지만, 발생할 가능성은 낮습니다. bar[ ] :

import foo
foo.itertools.count()

을 사용하다 모듈을하지 않은 Import를 사용)에서만.from module import SomeExceptionImport가 불필요해져 삭제되었을 때 문제의 모듈은 파손되어 있었습니다.

여기에 언급되지 않은 또 다른 차이점이 있다.이것은, http://docs.python.org/2/tutorial/modules.html 에서 그대로 카피한 것입니다.

를 사용할 때 주의해 주세요.

from package import item

항목은 패키지의 하위 모듈(또는 하위 패키지)이거나 패키지에 정의된 함수, 클래스 또는 변수와 같은 다른 이름이 될 수 있습니다.Import문은 먼저 항목이 패키지에 정의되어 있는지 여부를 테스트합니다.정의되지 않은 경우 모듈로 간주하여 로드를 시도합니다.찾을 수 없으면 ImportError 예외가 발생합니다.

반대로 다음과 같은 구문을 사용하는 경우

import item.subitem.subsubitem

마지막 항목을 제외한 각 항목은 패키지여야 합니다. 마지막 항목은 모듈 또는 패키지일 수 있지만 이전 항목에 정의된 클래스, 함수 또는 변수일 수 없습니다.

저도 초보자이기 때문에 간단하게 설명하겠습니다.의 Python이 .import음음음:

1. 일반 Import:

import math

이 유형의 Import는 개인적으로 가장 좋아하는 것입니다.이 Import 기술의 유일한 단점은 모듈 기능을 사용해야 할 경우 다음 구문을 사용해야 한다는 것입니다.

math.sqrt(4)

물론 타이핑 작업도 증가하지만 초보자라면 모듈 및 관련 기능을 추적하는 데 도움이 됩니다(좋은 텍스트 편집기는 타이핑 작업을 크게 줄여주므로 권장됩니다).

다음 Import 문을 사용하면 입력 작업을 더욱 줄일 수 있습니다.

import math as m

시점에서, 「」가 아닌 「」를 사용해 주세요」를 사용해 주세요.math.sqrt() 하면 .m.sqrt().

2. 함수 Import:

from math import sqrt

이 유형의 Import는 코드가 모듈의 단일 기능 또는 소수의 기능에만 액세스할 필요가 있는 경우 가장 적합합니다.단, 모듈의 새 항목을 사용하려면 Import 문을 업데이트해야 합니다.

3. 유니버설 수입:

from math import *

입력 작업은 크게 줄지만 모듈의 다양한 함수로 코드를 채우고 사용자 정의 함수의 이름과 충돌할 수 있으므로 권장되지 않습니다. 예:

sqrt라는 이름의 함수를 가지고 있고 수학을 Import하는 경우, sqrt가 있고 math.sqrt가 있습니다.그러나 산술 Import *에서 수행할 경우 동일한 이름을 가진 두 개의 서로 다른 함수에 문제가 있습니다.출처:코덱 적

import package
import module

★★★★★★★★★★★★★★★★ import명령어를 ) Python의 sys.path " " " "__init__.py

서브패키지가 있는 경우:

import package1.package2.package
import package1.package2.module

나 파일 폴더(파일)의 내부여야 합니다.package2 하는 것package1 둘 다, 라고 하다package1 ★★★★★★★★★★★★★★★★★」package2에는 반드시 함켜 must합합 must must must must must가 포함되어야 .__init__.py파일. https://docs.python.org/2/tutorial/modules.html

★fromImport 스일 :

from package1.package2 import package
from package1.package2 import module

또는 은 파일 되며, 파일 이름 에는 패키지 또는 모듈이 포함되어 있습니다.import라고 진술하다module (오류)package)을 사용합니다.package1.package2.module한 이름으로 수 언제든지 보다 편리한 이름으로 바인딩할 수 있습니다.

a = big_package_name.subpackage.even_longer_subpackage_name.function

from 또는의 이름을 할 수 .style of import를 사용하면 style of import를 사용할 수 있습니다.

from package3.module import some_function

허용됩니다만,

import package3.module.some_function

사용할 수 없습니다.

세간에 이야기도 덧붙여서from x import *만 아니라, 와 같은 이름의 출처를 분간하기 어려울 뿐만 아니라, 이것은 Pylint와 같은 코드 체커를 제거한다.이러한 이름은 정의되지 않은 변수로 보고됩니다.

현재 디렉토리의 디렉토리 구조는 다음과 같습니다.

.  
└─a  
   └─b  
     └─c

import문은 모든 중간 이름을 기억합니다.
다음 이름은 수식이어야 합니다.

In[1]: import a.b.c

In[2]: a
Out[2]: <module 'a' (namespace)>

In[3]: a.b
Out[3]: <module 'a.b' (namespace)>

In[4]: a.b.c
Out[4]: <module 'a.b.c' (namespace)>

from ... import ...스테이트먼트에서는 Import된 이름만 기억됩니다.
이 이름은 수식할 수 없습니다.

In[1]: from a.b import c

In[2]: a
NameError: name 'a' is not defined

In[2]: a.b
NameError: name 'a' is not defined

In[3]: a.b.c
NameError: name 'a' is not defined

In[4]: c
Out[4]: <module 'a.b.c' (namespace)>

주의: 물론 Python 콘솔을 1단계에서 2단계 사이에 재시작했습니다.

저는 여기에 추가하고 싶습니다.순환 Import가 발생한 경우 Python이 Import된 모듈을 속성으로 처리하는 방법을 이해하는 것이 유용합니다.

다음과 같은 구조를 가지고 있습니다.

mod/
    __init__.py
    main.py
    a.py
    b.py
    c.py
    d.py

main.py에서 다른 Import 방식을 사용하여 다른 모듈을 Import합니다.

main.py:

import mod.a
import mod.b as b
from mod import c
import d

dis.dis는 차이를 나타냅니다(모듈명, a b c d에 주의).

  1           0 LOAD_CONST               0 (-1)
              3 LOAD_CONST               1 (None)
              6 IMPORT_NAME              0 (mod.a)
              9 STORE_NAME               1 (mod)

  2          12 LOAD_CONST               0 (-1)
             15 LOAD_CONST               1 (None)
             18 IMPORT_NAME              2 (b)
             21 STORE_NAME               2 (b)

  3          24 LOAD_CONST               0 (-1)
             27 LOAD_CONST               2 (('c',))
             30 IMPORT_NAME              1 (mod)
             33 IMPORT_FROM              3 (c)
             36 STORE_NAME               3 (c)
             39 POP_TOP

  4          40 LOAD_CONST               0 (-1)
             43 LOAD_CONST               1 (None)
             46 IMPORT_NAME              4 (mod.d)
             49 LOAD_ATTR                5 (d)
             52 STORE_NAME               5 (d)
             55 LOAD_CONST               1 (None)

최종적으로는 같은 것으로 보이지만(각 예에서 STORE_NAME은 결과입니다), 다음의 4개의 순환 Import를 고려할 필요가 있는 경우는 주의할 필요가 있습니다.

예1

foo/
   __init__.py
   a.py
   b.py

a.py:
import foo.b

b.py:
import foo.a

>>> import foo.a
>>>

이것은 동작합니다.

예2

bar/
   __init__.py
   a.py
   b.py

a.py:
import bar.b as b

b.py:
import bar.a as a

>>> import bar.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "bar\a.py", line 1, in <module>
    import bar.b as b
  File "bar\b.py", line 1, in <module>
    import bar.a as a
AttributeError: 'module' object has no attribute 'a'

주사위 없음

예3

baz/
   __init__.py
   a.py
   b.py

a.py:
from baz import b

b.py:
from baz import a

>>> import baz.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "baz\a.py", line 1, in <module>
    from baz import b
  File "baz\b.py", line 1, in <module>
    from baz import a
ImportError: cannot import name a

비슷한 문제...단, x로부터의 Import y는 x.y를 y로 Import하는 것과 동일하지 않습니다.

예4

qux/
   __init__.py
   a.py
   b.py

a.py:
import b

b.py:
import a

>>> import qux.a
>>>

이것도 작동한다.

이에 대한 제 자신의 답변은 주로 처음에 사용하는 모듈의 수에 따라 달라집니다.1개 또는 2개만 사용할 경우 파일의 나머지 키 입력을 줄일 수 있기 때문에 ...을 사용하는 경우가 많습니다.다만 여러 모듈을 사용할 경우에는 각 모듈 참조가 자기 문서화되어 있기 때문에 사용하는 것이 좋습니다.사냥할 필요 없이 각각의 상징이 어디서 왔는지 알 수 있어요

보통 저는 플레인 Import의 자기 문서 스타일을 선호하며, 그 중에서 변경만 합니다.Import는 Import하는 모듈이1개만 있어도 모듈명을 입력할 필요가 있는 횟수가 10~20개를 넘으면 실행됩니다.

놀랍게도 아무도 이야기하지 않은 중요한 차이점 중 하나는 플레인 Import를 사용하면private variable ★★★★★★★★★★★★★★★★★」private functionsimport된 모듈로부터 전송되며, from-inport 명령어에서는 사용할 수 없습니다.

이미지 코드:

설정.화이

public_variable = 42
_private_variable = 141
def public_function():
    print("I'm a public function! yay!")
def _private_function():
    print("Ain't nobody accessing me from another module...usually")

plain_displays.화이

import settings
print (settings._private_variable)
print (settings.public_variable)
settings.public_function()
settings._private_function()

# Prints:
# 141
# 42
# I'm a public function! yay!
# Ain't nobody accessing me from another module...usually

from_from_filename을 클릭합니다.화이

from settings import *
#print (_private_variable) #doesn't work
print (public_variable)
public_function()
#_private_function()   #doesn't work

Jan Wrobel이 언급했듯이, 다른 수입품의 한 측면은 수입이 공개되는 방식이다.

모듈 mymath

from math import gcd
...

mymath 사용:

import mymath
mymath.gcd(30, 42)  # will work though maybe not expected

를 Import 했을 gcd으로만, 「」, 「내부용」의 .mymath할 수 저는 이런 것을 자주 가지고 있는데, 대부분의 경우 "모듈을 깨끗하게 유지하고 싶다"

Jan Wrobel의 제안과는 별개로 이것을 좀 더 모호하게 만들자는 제안입니다.import math대신 선두의 언더스코어를 사용하여 Import 내용을 공개하지 않도록 했습니다.

# for instance...
from math import gcd as _gcd
# or...
import math as _math

대규모 프로젝트에서는 이 "베스트 프랙티스"를 통해 후속 Import에 공개되는 내용과 공개되지 않는 내용을 정확하게 제어할 수 있습니다.이를 통해 모듈을 청결하게 유지하고 일정 규모의 프로젝트를 통해 비용을 회수할 수 있습니다.

많은 분들이 대답해주셨기 때문에 열심히 하고 있습니다. :)

import module어떤 아이템에서 Import해야 하는지 모를 때 최적입니다.module이렇게 하면 문제가 발생한 항목을 모르기 때문에 문제가 발생했을 때 디버깅이 어려울 수 있습니다.
form module import <foo>Import해야 할 아이템을 알고 있을 때 가장 적합하며 필요에 따라 특정 아이템 Import를 사용하여 보다 제어할 수 있습니다.가져온 항목을 알고 있기 때문에 이 방법을 사용하면 디버깅이 쉬워질 수 있습니다.

답변이 하지 않았습니다.unittest ★★★★★★★★★★★★★★★★★」pytest를 참조해 주세요.

dr;dr

import foo이치노

하드웨이

Import(「」/「」)from foo import bar모듈로부터의 )는 개별적으로 레드-그린-리팩터 사이클을 지루하게 만듭니다.를 들어, 내 like like like like 음예 음예 음예 예예 예예 for for for for for for for for for for 。

# my_module.py

from foo import bar


class Thing:
    def do_thing(self):
        bar('do a thing')

그리고 내 시험은

# test_my_module.py

from unittest.mock import patch
import my_module


patch.object(my_module, 'bar')
def test_do_thing(mock_bar):
    my_module.Thing().do_thing()
    mock_bar.assert_called_with('do a thing')

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★, 「」를 ?Thing아, 른른른른업?★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

# my_module.py

from tools import Thing


def do_thing():
    Thing().do_thing()


# tools.py

from foo import bar


class Thing:
    def do_thing(self):
        bar('do a thing')


# test_my_module.py

from unittest.mock import patch
import my_module
import tools  # Had to import implementation file...


patch.object(tools, 'bar')  # Changed patch
def test_do_thing(mock_bar):
    my_module.do_thing()  # Changed test (expected)
    mock_bar.assert_called_with('do a thing')

쉽도를 썼기 에 가가 unfortun unfortun unfortun unfortun unfortun unfortun unfortun unfortun unfortun unfortun unfortunfrom foo import bar the the the the the the the the the the the the the the the the the the the the the the the the the the the 를 참조하기 위해 패치를 갱신해야 합니다.tools제 너무 있기 에 이를 하기 위해서는 .기본적으로 내 테스트는 구현에 대해 너무 많이 알고 있기 때문에 이 리팩터를 수행하기 위해 예상보다 훨씬 더 많은 것을 변경해야 합니다.

더 나은 접근법

「」를 사용합니다.import foo테스트에서는 모듈의 실장 방법을 무시하고 모듈 전체에 패치를 적용하기만 하면 됩니다.

# my_module.py

from tools import Thing


def do_thing():
    Thing().do_thing()


# tools.py

import foo


class Thing:
    def do_thing(self):
        foo.bar('do a thing')  # Specify 'bar' is from 'foo' module


# test_my_module.py

from unittest.mock import patch
import my_module


patch('foo')  # Patch entire foo module
def test_do_thing(mock_foo):
    my_module.do_thing()  # Changed test (expected)
    mock_foo.bar.assert_called_with('do a thing')

테스트에서 알고 있는 구현 세부 정보가 적을수록 좋습니다.이렇게 하면 더 나은 솔루션을 생각해 낼 수 있습니다(함수 대신 클래스 사용, 아이디어 분리에 추가 파일 사용 등). 리팩터를 수용하기 위해 테스트에서 변경할 필요가 줄어듭니다.

모듈 가져오기 - 모듈에서 다른 항목을 가져오기 위해 추가 작업이 필요하지 않습니다.중복 타이핑 등의 단점이 있습니다.

모듈 Import From - 입력이 적고 액세스 가능한 모듈 항목을 보다 상세하게 제어할 수 있습니다.모듈의 새 항목을 사용하려면 가져오기 명세서를 업데이트해야 합니다.

대부분 베어 함수(base64, math, os, shutil, sys, time 등)를 포함하는 빌트인 모듈도 있습니다.이러한 베어 함수를 일부 네임스페이스에 바인드하여 코드의 가독성을 향상시키는 것은 매우 좋은 방법입니다.이름 공간 없이 이러한 함수의 의미를 이해하는 것이 얼마나 더 어려운지 생각해 보십시오.

copysign(foo, bar)
monotonic()
copystat(foo, bar)

일부 모듈에 바인드되어 있는 경우보다 더 커집니다.

math.copysign(foo, bar)
time.monotonic()
shutil.copystat(foo, bar)

서로 다른 모듈 간의 경합을 피하기 위해 네임스페이스가 필요할 수 있습니다(json.load 대 peacle.load).

On the other hand there are some modules that contain mostly classes ( 컨피규레이션 파서, 날짜, 임시 파일, zip 파일, ...) and many of them make their class names self-explanatory enough:

configparser.RawConfigParser()
datetime.DateTime()
email.message.EmailMessage()
tempfile.NamedTemporaryFile()
zipfile.ZipFile()

따라서 이러한 클래스를 코드에 추가 모듈 네임스페이스와 함께 사용하는 것이 새로운 정보를 추가하는 것인지, 아니면 단순히 코드를 길게 하는 것인지에 대한 논란이 있을 수 있습니다.

비슷한 질문 게시물에 답하고 있었는데 게시물을 올리기도 전에 포스터가 삭제되었습니다.다음은 차이점을 설명하는 한 가지 예입니다.

Python 라이브러리는 하나 이상의 파일(모듈)을 가질 수 있습니다.예시의 경우,

package1
  |-- __init__.py

또는

package2
  |-- __init__.py
  |-- module1.py
  |-- module2.py

파일 기반 설계 요구사항 중 하나에 python 함수 또는 클래스를 정의할 수 있습니다.

정의합시다

func1()__init__.py아래mylibrary1 , 그리고.
foo()module2.py아래mylibrary2.

할 수 .func1() 중

import package1

package1.func1()

또는

import package1 as my

my.func1()

또는

from package1 import func1

func1()

또는

from package1 import *

func1()

중 으로 접속할 수 .foo():

import package2.module2

package2.module2.foo()

또는

import package2.module2 as mod2
'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?
mod2.foo()

또는

from package2 import module2

module2.foo()

또는

from package2 import module2 as mod2

mod2.foo()

또는

from package2.module2 import *

foo()

간단히 말해서, 이것은 프로그래머의 편의에 관한 모든 것이다.코어 레벨에서는 모듈의 모든 기능을 Import하기만 하면 됩니다.

import module: 사용시import module 이 써야 .module.method(). 또는 메서드 또는 속성을 사용할 때마다 모듈을 참조해야 합니다.

from module import all: 사용시from module import all보다 그냥 쓰면 .method()모듈을 참조하지 않습니다.

언급URL : https://stackoverflow.com/questions/710551/use-import-module-or-from-module-import

저작자표시

'programing' 카테고리의 다른 글

JFrame 아이콘 변경 방법 (0)	2023.01.02
MariaDB: 수십억 개의 레코드를 갱신하는 최적의 방법 (0)	2023.01.02
모든 좋은 PHP 개발자가 대답할 수 있는 질문 (0)	2022.12.28
Java와 C/C++ 간의 프로세스 간 통신을 위한 가장 빠른(저레이텐시) 방식 (0)	2022.12.28
mysql 날짜별 합계 그룹 선택 (0)	2022.12.28

현재글'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?

각종 프로그래밍 정보를 다루는 블로그입니다.

Spring, java, C#, javascript, jquery, c++, spring3,

Today :
Yesterday :

kingscode

'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?

'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?

`import foo`:

`from foo import bar`:

`from foo import *`:

에는 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 하다에 대해서 이야기해 `import from`:

`from`:

마크를 켜주세요.`sys.modulesos` ★★★★★★★★★★★★★★★★★」`os.path`:

sqrt라는 이름의 함수를 가지고 있고 수학을 Import하는 경우, sqrt가 있고 math.sqrt가 있습니다.그러나 산술 Import *에서 수행할 경우 동일한 이름을 가진 두 개의 서로 다른 함수에 문제가 있습니다.출처:코덱 적

예1

예2

예3

예4

설정.화이

plain_displays.화이

from_from_filename을 클릭합니다.화이

dr;dr

하드웨이

더 나은 접근법

간단히 말해서, 이것은 프로그래머의 편의에 관한 모든 것이다.코어 레벨에서는 모듈의 모든 기능을 Import하기만 하면 됩니다.

'programing' 카테고리의 다른 글

'programing'의 다른글

티스토리툴바

« 2025/01 »
일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?

'모듈 가져오기' 또는 '모듈 가져오기'를 사용하시겠습니까?

import foo:

from foo import bar:

from foo import *:

에는 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 하다에 대해서 이야기해 import from:

from:

마크를 켜주세요.sys.modulesos ★★★★★★★★★★★★★★★★★」os.path:

sqrt라는 이름의 함수를 가지고 있고 수학을 Import하는 경우, sqrt가 있고 math.sqrt가 있습니다.그러나 산술 Import *에서 수행할 경우 동일한 이름을 가진 두 개의 서로 다른 함수에 문제가 있습니다.출처:코덱 적

예1

예2

예3

예4

설정.화이

plain_displays.화이

from_from_filename을 클릭합니다.화이

dr;dr

하드웨이

더 나은 접근법

간단히 말해서, 이것은 프로그래머의 편의에 관한 모든 것이다.코어 레벨에서는 모듈의 모든 기능을 Import하기만 하면 됩니다.

'programing' 카테고리의 다른 글

'programing'의 다른글

관련글

티스토리툴바

`import foo`:

`from foo import bar`:

`from foo import *`:

에는 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 하다에 대해서 이야기해 `import from`:

`from`:

마크를 켜주세요.`sys.modulesos` ★★★★★★★★★★★★★★★★★」`os.path`: