python導入語句根據,python中,導入模塊的語句

本文目錄一覽：

• 1、python中pil如何導入？
• 2、python中導入turtle庫的語句是什麼
• 3、python導入模塊的方法有哪些
• 4、Python導入模塊問題
• 5、萬字乾貨，Python語法大合集，一篇文章帶你入門
• 6、Python 中的import 機制

python中pil如何導入？

PIL是python的第三方圖像處理庫，我們可以值cmd使用pip install pillow命令安裝pil庫，下面我們就來看一下如何導入pil庫。

python中可以使用import導入pil模塊：

主要有以下兩種導入方法：

import 模塊名1 [as 別名1], 模塊名2 [as 別名2]，…：使用這種語法格式的 import 語句，會導入指定模塊中的所有成員（包括變數、函數、類等）。不僅如此，當需要使用模塊中的成員時，需用該模塊名（或別名）作為前綴，否則 Python 解釋器會報錯。

from 模塊名 import 成員名1 [as 別名1]，成員名2 [as 別名2]，…： 使用這種語法格式的 import 語句，只會導入模塊中指定的成員，而不是全部成員。同時，當程序中使用該成員時，無需附加任何前綴，直接使用成員名（或別名）即可。

更多Python知識請關注Python自學網。

python中導入turtle庫的語句是什麼

import turtle 導入模塊

turtle.shape(“turtle”) 顯示海龜

turtle.Screen(.bgcolor(“color”)) 設置背景顏色

turtle.left() 向左轉

turtle.right() 向右轉

turtle.forward() 向前移動

python導入模塊的方法有哪些

方法一

import modname

模塊是指一個可以交互使用，或者從另一Python 程序訪問的代碼段。只要導入了一個模塊，就可以引用它的任何公共的函數、類或屬性。模塊可以通過這種方法來使用其它模塊的功能。

用import語句導入模塊，就在當前的名稱空間(namespace)建立了一個到該模塊的引用.這種引用必須使用全稱，也就是說，當使用在被導入模塊中定義的函數時，必須包含模塊的名字。所以不能只使用 funcname，而應該使用 modname.funcname

方法二

from modname import funcname

from modname import fa, fb, fc

或者

from modname import *

與第1種方法的區別：funcname 被直接導入到本地名字空間去了，所以它可以直接使用，而不需要加上模塊名的限定* 表示，該模塊的所有公共對象(public objects)都被導入到 當前的名稱空間，也就是任何只要不是以」_」開始的東西都會被導入。

modname沒有被定義，所以modname.funcname這種方式不起作用。並且，如果funcname如果已經被定義，它會被新版本（該導入模塊中的版本）所替代。如果funcname被改成指向其他對象，modname不能不會覺察到。

建議:

1)如果你要經常訪問模塊的屬性和方法，且不想一遍又一遍地敲入模塊名，使用 from module import

2)如果你想要有選擇地導入某些屬性和方法，而不想要其它的，使用 from module import

3)如果模塊包含的屬性和方法與你的某個模塊同名，你必須使用import module來避免名字衝突

4)盡量少用 from module import * ，因為判定一個特殊的函數或屬性是從哪來的有些困難，並且會造成調試和重構都更困難。

方法三

內建函數__import__()

除了前面兩種使用import關鍵字的方法以外，我們還可以使用內建函數 __import__() 來導入 module。兩者的區別是，import 後面跟的必須是一個類型(type)，而__import__() 的參數是一個字元串，這個字元串可能來自配置文件，也可能是某個表達式計算結果。例如：

mymodule = __import__ (』module_name』)

附註:

1)模塊的內容都放在一個模塊文件中，如 mymodule 的內容應該放在PYTHONPATH 目錄下的一個mymodule.py中，C實現的除外

2)包可以將幾個模塊名稱空間組織起來, 如A.b 就表示在包A中的一個子模塊b

可以單獨導入某一個子模塊，如Python文檔中給出的例子

import sound.effects.echo

這樣必須使用全稱對裡面的對象進行引用，如

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

還可以使用下面的語句來載入echo子模塊

from Sound.Effects import echo

它在沒有包前綴的情況下也可以使用， 所以它可以如下方式調用：

echo.echofilter(input, output, delay=0.7, atten=4)

不主張從一個包或模塊中用import * 導入所有模塊，因為這樣的通常會導致可讀性很差。

from Package import specific_submodule的用法並沒有錯，實際上這還是推薦的用法，除非導入的模塊需要使用其它包中的同名子模塊(the importing module needs to use submodules with the same name from different packages).

綜上所述，一般情況應該使用import , 但有幾個例外

1)module文檔告訴你要用from-import的

2)導入一個包組件。需要一個包裡面的某個子模塊，一般用from A.b import c比import A.b.c 更方便 且不會冒混淆的危險.

Python導入模塊問題

Python是一種面向對象的編程語言，裡面包含有豐富強大的庫，想要學習Python開發，首先需要學習如何導入模塊或包。下面就跟大家一起討論下Python導入模塊的幾種方法：

常規導入

最常用的導入方式，大概是這樣的：

import sys

只需要使用 import ，然後指定希望導入的模塊或包即可。用這種方法導入的好處是可以一次性導入多個包或模塊：

import os, sys, time

雖然這節省了空間，但是卻違背了Python風格指南。 Python風格指南建議將每個導入語句單獨成行 。

有時在導入模塊時，你想要重命名這個模塊。這個功能很容易實現：

import sys as system

print(system.platform)

上面的代碼將我們導入的 sys 模塊重命名為 system 。我們可以按照和以前一樣的方式調用模塊的方法，但是可以用一個新的模塊名。也有某些子模塊必須要使用點標記法才能導入。

import urllib.error

這個情況不常見，但是對此有所了解總是沒有壞處的。

使用from語句導入

有時我們只想要導入一個模塊或庫中的某個部分。那麼Python是如何實現這點：

from functools import lru_cache

上面這行代碼可以讓你直接調用 lru_cache 。如果按常規方式導入 functools ，那麼就必須像這樣調用 lru_cache ：

functools.lru_cache(*args)

根據實際的使用場景，上面的做法可能是更好的。在複雜的代碼庫中，能夠看出某個函數是從哪裡導入的這點很有用的。不過，如果你的代碼維護的很好，模塊化程度高，那麼只從某個模塊中導入一部分內容也是非常方便和簡潔的。

當然，你還可以使用from方法導入模塊的全部內容，就像這樣：

from os import *

這種做法在少數情況下是挺方便的，但是這樣也會打亂你的命名空間。問題在於，你可能定義了一個與導入模塊中名稱相同的變數或函數，這時如果你試圖使用

os 模塊中的同名變數或函數，實際使用的將是你自己定義的內容。因此，你最後可能會碰到一個相當讓人困惑的邏輯錯誤。

標準庫中我唯一推薦全盤導入的模塊只有Tkinter 。

如果你正好要寫自己的模塊或包，有人會建議你在 __init__.py 文件中導入所有內容，讓模塊或者包使用起來更方便。我個人更喜歡顯示地導入，而非隱式地導入。

你也可以採取折中方案，從一個包中導入多個項：

from os import path, walk, unlinkfrom os import uname, remove

在上述代碼中，我們從 os 模塊中導入了5個函數。你可能注意到了，我們是通過多次從同一個模塊中導入實現的。當然，如果你願意的話，你也可以使用圓括弧一次性導入多個項：

from os import (path, walk, unlink, uname,

remove, rename)

這是一個有用的技巧，不過你也可以換一種方式：

from os import path, walk, unlink, uname, \

remove, rename

上面的反斜杠是Python中的續行符，告訴解釋器這行代碼延續至下一行。

相對導入

PEP 328 介紹了引入相對導入的原因，以及選擇了哪種語法。具體來說，是使用句點來決定如何相對導入其他包或模塊。這麼做的原因是為了避免偶然情況下導入標準庫中的模塊產生衝突。這裡我們以PEP 328中給出的文件夾結構為例，看看相對導入是如何工作的：

my_package/

__init__.py

subpackage1/

__init__.py

module_x.py

module_y.py

subpackage2/

__init__.py

module_z.py

module_a.py

在本地磁碟上找個地方創建上述文件和文件夾。在頂層的 __init__.py 文件中，輸入以下代碼：

from . import subpackage1from . import subpackage2

接下來進入 subpackage1 文件夾，編輯其中的 __init__.py 文件，輸入以下代碼：

from . import module_xfrom . import module_y

現在編輯 module_x.py 文件，輸入以下代碼：

from .module_y import spam as ham

def main():

ham()

最後編輯 module_y.py 文件，輸入以下代碼：

def spam():

print(‘spam ‘ * 3)

打開終端， cd 至 my_package 包所在的文件夾，但不要進入 my_package 。在這個文件夾下運行Python解釋器。我使用的是IPython，因為它的自動補全功能非常方便：

In [1]: import my_package

In [2]: my_package.subpackage1.module_xOut[2]: module

‘my_package.subpackage1.module_x’ from

‘my_package/subpackage1/module_x.py’

In [3]: my_package.subpackage1.module_x.main()spam spam spam

相對導入適用於你最終要放入包中的代碼。如果你編寫了很多相關性強的代碼，那麼應該採用這種導入方式。

你會發現PyPI上有很多流行的包也是採用了相對導入 。還要注意一點，如果你想要跨越多個文件層級進行導入，只需要使用多個句點即可。不過， PEP

328建議相對導入的層級不要超過兩層 。

還要注意一點，如果你往 module_x.py 文件中添加了 if __name__ == 『__main__』 ，然後試圖運行這個文件，你會碰到一個很難理解的錯誤。編輯一下文件，試試看吧！

from . module_y import spam as ham

def main():

ham()

if __name__ == ‘__main__’:

# This won’t work!

main()

現在從終端進入 subpackage1 文件夾，執行以下命令：

python module_x.py

如果你使用的是Python 2，你應該會看到下面的錯誤信息：

Traceback (most recent call last):

File “module_x.py”, line 1, in module

from . module_y import spam as hamValueError: Attempted relative import in non-package

如果你使用的是Python 3，錯誤信息大概是這樣的：

Traceback (most recent call last):

File “module_x.py”, line 1, in module

from . module_y import spam as hamSystemError: Parent module ” not loaded, cannot perform relative import

這指的是， module_x.py 是某個包中的一個模塊，而你試圖以腳本模式執行，但是 這種模式不支持相對導入 。

如果你想在自己的代碼中使用這個模塊，那麼你必須將其添加至Python的導入檢索路徑（import search path）。最簡單的做法如下：

import syssys.path.append(‘/path/to/folder/containing/my_package’)import my_package

注意，你需要添加的是 my_package 的上一層文件夾路徑，而不是 my_package 本身。原因是 my_package 就是我們想要使用的包，所以如果你添加它的路徑，那麼將無法使用這個包。

我們接下來談談可選導入。

可選導入（Optional imports）

如果你希望優先使用某個模塊或包，但是同時也想在沒有這個模塊或包的情況下有備選，你就可以使用可選導入這種方式。這樣做可以導入支持某個軟體的多種版本或者實現性能提升。以 github2包 中的代碼為例：

try:

# For Python 3

from http.client import responsesexcept ImportError: # For Python 2.5-2.7

try:

from httplib import responses # NOQA

except ImportError: # For Python 2.4

from BaseHTTPServer import BaseHTTPRequestHandler as _BHRH

responses = dict([(k, v[0]) for k, v in _BHRH.responses.items()])

lxml 包也有使用可選導入方式：

try:

from urlparse import urljoin

from urllib2 import urlopenexcept ImportError:

# Python 3

from urllib.parse import urljoin

from urllib.request import urlopen

正如以上示例所示， 可選導入的使用很常見，是一個值得掌握的技巧 。

局部導入

當你在局部作用域中導入模塊時，你執行的就是局部導入。如果你在Python腳本文件的頂部導入一個模塊，那麼你就是在將該模塊導入至全局作用域，這意味著之後的任何函數或方法都可能訪問該模塊。例如：

import sys # global scope

def square_root(a):

# This import is into the square_root functions local scope

import math

return math.sqrt(a)

def my_pow(base_num, power):

return math.pow(base_num, power)

if __name__ == ‘__main__’:

print(square_root(49))

print(my_pow(2, 3))

這裡，我們將 sys 模塊導入至全局作用域，但我們並沒有使用這個模塊。然後，在 square_root 函數中，我們將 math

模塊導入至該函數的局部作用域，這意味著 math 模塊只能在 square_root 函數內部使用。如果我們試圖在 my_pow 函數中使用

math ，會引發 NameError 。試著執行這個腳本，看看會發生什麼。

使用局部作用域的好處之一，是你使用的模塊可能需要很長時間才能導入，如果是這樣的話，將其放在某個不經常調用的函數中或許更加合理，而不是直接在全局作

用域中導入。老實說，我幾乎從沒有使用過局部導入，主要是因為如果模塊內部到處都有導入語句，會很難分辨出這樣做的原因和用途。

根據約定，所有的導入語句都應該位於模塊的頂部 。

導入注意事項

在導入模塊方面，有幾個程序員常犯的錯誤。這裡我們介紹兩個。

循環導入（circular imports）

覆蓋導入（Shadowed imports，暫時翻譯為覆蓋導入）

先來看看循環導入。

循環導入

如果你創建兩個模塊，二者相互導入對方，那麼就會出現循環導入。例如：

# a.pyimport b

def a_test():

print(“in a_test”)

b.b_test()

a_test()

然後在同個文件夾中創建另一個模塊，將其命名為 b.py 。

import a

def b_test():

print(‘In test_b”‘)

a.a_test()

b_test()

如果你運行任意一個模塊，都會引發 AttributeError 。這是因為這兩個模塊都在試圖導入對方。簡單來說，模塊 a 想要導入模塊 b

，但是因為模塊 b 也在試圖導入模塊 a （這時正在執行），模塊 a 將無法完成模塊 b

的導入。我看過一些解決這個問題的破解方法（hack），但是 一般來說，你應該做的是重構代碼，避免發生這種情況 。

覆蓋導入

當你創建的模塊與標準庫中的模塊同名時，如果你導入這個模塊，就會出現覆蓋導入。舉個例子，創建一個名叫 math.py 的文件，在其中寫入如下代碼：

import math

def square_root(number):

return math.sqrt(number)

square_root(72)

現在打開終端，試著運行這個文件，你會得到以下回溯信息（traceback）：

Traceback (most recent call last):

File “math.py”, line 1, in module

import math

File “/Users/michael/Desktop/math.py”, line 6, in module

square_root(72)

File “/Users/michael/Desktop/math.py”, line 4, in square_root

return math.sqrt(number)AttributeError: module ‘math’ has no attribute ‘sqrt’

這到底是怎麼回事？其實，你運行這個文件的時候，Python解釋器首先在當前運行腳本所處的的文件夾中查找名叫 math

的模塊。在這個例子中，解釋器找到了我們正在執行的模塊，試圖導入它。但是我們的模塊中並沒有叫 sqrt 的函數或屬性，所以就拋出了

AttributeError 。

萬字乾貨，Python語法大合集，一篇文章帶你入門

這份資料非常純粹，只有Python的基礎語法，專門針對想要學習Python的小白。

Python中用#表示單行注釋，#之後的同行的內容都會被注釋掉。

使用三個連續的雙引號表示多行注釋，兩個多行注釋標識之間內容會被視作是注釋。

Python當中的數字定義和其他語言一樣：

我們分別使用+, -, *, /表示加減乘除四則運算符。

這裡要注意的是，在Python2當中，10/3這個操作會得到3，而不是3.33333。因為除數和被除數都是整數，所以Python會自動執行整數的計算，幫我們把得到的商取整。如果是10.0 / 3，就會得到3.33333。目前Python2已經不再維護了，可以不用關心其中的細節。

但問題是Python是一個 弱類型 的語言，如果我們在一個函數當中得到兩個變數，是無法直接判斷它們的類型的。這就導致了同樣的計算符可能會得到不同的結果，這非常蛋疼。以至於程序員在運算除法的時候，往往都需要手工加上類型轉化符，將被除數轉成浮點數。

在Python3當中撥亂反正，修正了這個問題，即使是兩個整數相除，並且可以整除的情況下，得到的結果也一定是浮點數。

如果我們想要得到整數，我們可以這麼操作：

兩個除號表示 取整除 ，Python會為我們保留去除餘數的結果。

除了取整除操作之外還有取餘數操作，數學上稱為取模，Python中用%表示。

Python中支持 乘方運算 ，我們可以不用調用額外的函數，而使用**符號來完成：

當運算比較複雜的時候，我們可以用括弧來強制改變運算順序。

Python中用首字母大寫的True和False表示真和假。

用and表示與操作，or表示或操作，not表示非操作。而不是C++或者是Java當中的, || 和！。

在Python底層， True和False其實是1和0 ，所以如果我們執行以下操作，是不會報錯的，但是在邏輯上毫無意義。

我們用==判斷相等的操作，可以看出來True==1， False == 0.

我們要小心Python當中的bool()這個函數，它並不是轉成bool類型的意思。如果我們執行這個函數，那麼 只有0會被視作是False，其他所有數值都是True ：

Python中用==判斷相等，表示大於，=表示大於等於， 表示小於，=表示小於等於，!=表示不等。

我們可以用and和or拼裝各個邏輯運算：

注意not，and，or之間的優先順序，其中not and or。如果分不清楚的話，可以用括弧強行改變運行順序。

關於list的判斷，我們常用的判斷有兩種，一種是剛才介紹的==，還有一種是is。我們有時候也會簡單實用is來判斷，那麼這兩者有什麼區別呢？我們來看下面的例子：

Python是全引用的語言，其中的對象都使用引用來表示。is判斷的就是 兩個引用是否指向同一個對象 ，而==則是判斷兩個引用指向的具體內容是否相等。舉個例子，如果我們把引用比喻成地址的話，is就是判斷兩個變數的是否指向同一個地址，比如說都是沿河東路XX號。而==則是判斷這兩個地址的收件人是否都叫張三。

顯然，住在同一個地址的人一定都叫張三，但是住在不同地址的兩個人也可以都叫張三，也可以叫不同的名字。所以如果a is b，那麼a == b一定成立，反之則不然。

Python當中對字元串的限制比較松， 雙引號和單引號都可以表示字元串 ，看個人喜好使用單引號或者是雙引號。我個人比較喜歡單引號，因為寫起來方便。

字元串也支持+操作，表示兩個字元串相連。除此之外，我們把兩個字元串寫在一起，即使沒有+，Python也會為我們拼接：

我們可以使用[]來查找字元串當中某個位置的字元，用 len 來計算字元串的長度。

我們可以在字元串前面 加上f表示格式操作 ，並且在格式操作當中也支持運算，比如可以嵌套上len函數等。不過要注意，只有Python3.6以上的版本支持f操作。

最後是None的判斷，在Python當中None也是一個對象， 所有為None的變數都會指向這個對象 。根據我們前面所說的，既然所有的None都指向同一個地址，我們需要判斷一個變數是否是None的時候，可以使用is來進行判斷，當然用==也是可以的，不過我們通常使用is。

理解了None之後，我們再回到之前介紹過的bool()函數，它的用途其實就是判斷值是否是空。所有類型的 默認空值會被返回False ，否則都是True。比如0，””，[], {}, ()等。

除了上面這些值以外的所有值傳入都會得到True。

Python當中的標準輸入輸出是 input和print 。

print會輸出一個字元串，如果傳入的不是字元串會自動調用__str__方法轉成字元串進行輸出。 默認輸出會自動換行 ，如果想要以不同的字元結尾代替換行，可以傳入end參數：

使用input時，Python會在命令行接收一行字元串作為輸入。可以在input當中傳入字元串，會被當成提示輸出：

Python支持 三元表達式 ，但是語法和C++不同，使用if else結構，寫成：

上段代碼等價於：

Python中用[]表示空的list，我們也可以直接在其中填充元素進行初始化：

使用append和pop可以在list的末尾插入或者刪除元素：

list可以通過[]加上下標訪問指定位置的元素，如果是負數，則表示 倒序訪問 。-1表示最後一個元素，-2表示倒數第二個，以此類推。如果訪問的元素超過數組長度，則會出發 IndexError 的錯誤。

list支持切片操作，所謂的切片則是從原list當中 拷貝 出指定的一段。我們用start: end的格式來獲取切片，注意，這是一個 左閉右開區間 。如果留空表示全部獲取，我們也可以額外再加入一個參數表示步長，比如[1:5:2]表示從1號位置開始，步長為2獲取元素。得到的結果為[1, 3]。如果步長設置成-1則代表反向遍歷。

如果我們要指定一段區間倒序，則前面的start和end也需要反過來，例如我想要獲取[3: 6]區間的倒序，應該寫成[6:3:-1]。

只寫一個:，表示全部拷貝，如果用is判斷拷貝前後的list會得到False。可以使用del刪除指定位置的元素，或者可以使用remove方法。

insert方法可以 指定位置插入元素 ，index方法可以查詢某個元素第一次出現的下標。

list可以進行加法運算，兩個list相加表示list當中的元素合併。 等價於使用extend 方法：

我們想要判斷元素是否在list中出現，可以使用 in關鍵字 ，通過使用len計算list的長度：

tuple和list非常接近，tuple通過()初始化。和list不同， tuple是不可變對象 。也就是說tuple一旦生成不可以改變。如果我們修改tuple，會引發TypeError異常。

由於小括弧是有改變優先順序的含義，所以我們定義單個元素的tuple， 末尾必須加上逗號 ，否則會被當成是單個元素：

tuple支持list當中絕大部分操作：

我們可以用多個變數來解壓一個tuple：

解釋一下這行代碼：

我們在b的前面加上了星號， 表示這是一個list 。所以Python會在將其他變數對應上值的情況下，將剩下的元素都賦值給b。

補充一點，tuple本身雖然是不可變的，但是 tuple當中的可變元素是可以改變的 。比如我們有這樣一個tuple：

我們雖然不能往a當中添加或者刪除元素，但是a當中含有一個list，我們可以改變這個list類型的元素，這並不會觸發tuple的異常：

dict也是Python當中經常使用的容器，它等價於C++當中的map，即 存儲key和value的鍵值對 。我們用{}表示一個dict，用:分隔key和value。

對 。我們用{}表示一個dict，用:分隔key和value。

dict的key必須為不可變對象，所以 list、set和dict不可以作為另一個dict的key ，否則會拋出異常：

我們同樣用[]查找dict當中的元素，我們傳入key，獲得value，等價於get方法。

我們可以call dict當中的keys和values方法，獲取dict當中的所有key和value的集合，會得到一個list。在Python3.7以下版本當中，返回的結果的順序可能和插入順序不同，在Python3.7及以上版本中，Python會保證返回的順序和插入順序一致：

我們也可以用in判斷一個key是否在dict當中，注意只能判斷key。

如果使用[]查找不存在的key，會引發KeyError的異常。如果使用 get方法則不會引起異常，只會得到一個None ：

setdefault方法可以 為不存在的key 插入一個value，如果key已經存在，則不會覆蓋它：

我們可以使用update方法用另外一個dict來更新當前dict，比如a.update(b)。對於a和b交集的key會被b覆蓋，a當中不存在的key會被插入進來：

我們一樣可以使用del刪除dict當中的元素，同樣只能傳入key。

Python3.5以上的版本支持使用**來解壓一個dict：

set是用來存儲 不重複元素 的容器，當中的元素都是不同的，相同的元素會被刪除。我們可以通過set()，或者通過{}來進行初始化。注意當我們使用{}的時候，必須要傳入數據，否則Python會將它和dict弄混。

set當中的元素也必須是不可變對象，因此list不能傳入set。

可以調用add方法為set插入元素：

set還可以被認為是集合，所以它還支持一些集合交叉並補的操作。

set還支持 超集和子集的判斷 ，我們可以用大於等於和小於等於號判斷一個set是不是另一個的超集或子集：

和dict一樣，我們可以使用in判斷元素在不在set當中。用copy可以拷貝一個set。

Python當中的判斷語句非常簡單，並且Python不支持switch，所以即使是多個條件，我們也只能 羅列if-else 。

我們可以用in來循環迭代一個list當中的內容，這也是Python當中基本的循環方式。

如果我們要循環一個範圍，可以使用range。range加上一個參數表示從0開始的序列，比如range(10)，表示[0, 10)區間內的所有整數：

如果我們傳入兩個參數，則 代表迭代區間的首尾 。

如果我們傳入第三個元素，表示每次 循環變數自增的步長 。

如果使用enumerate函數，可以 同時迭代一個list的下標和元素 ：

while循環和C++類似，當條件為True時執行，為false時退出。並且判斷條件不需要加上括弧：

Python當中使用 try和except捕獲異常 ，我們可以在except後面限制異常的類型。如果有多個類型可以寫多個except，還可以使用else語句表示其他所有的類型。finally語句內的語法 無論是否會觸發異常都必定執行 ：

在Python當中我們經常會使用資源，最常見的就是open打開一個文件。我們 打開了文件句柄就一定要關閉 ，但是如果我們手動來編碼，經常會忘記執行close操作。並且如果文件異常，還會觸發異常。這個時候我們可以使用with語句來代替這部分處理，使用with會 自動在with塊執行結束或者是觸發異常時關閉打開的資源 。

以下是with的幾種用法和功能：

凡是可以使用in語句來迭代的對象都叫做 可迭代對象 ，它和迭代器不是一個含義。這裡只有可迭代對象的介紹，想要了解迭代器的具體內容，請移步傳送門：

Python——五分鐘帶你弄懂迭代器與生成器，夯實代碼能力

當我們調用dict當中的keys方法的時候，返回的結果就是一個可迭代對象。

我們 不能使用下標來訪問 可迭代對象，但我們可以用iter將它轉化成迭代器，使用next關鍵字來獲取下一個元素。也可以將它轉化成list類型，變成一個list。

使用def關鍵字來定義函數，我們在傳參的時候如果指定函數內的參數名， 可以不按照函數定義的順序 傳參：

可以在參數名之前加上*表示任意長度的參數，參數會被轉化成list：

也可以指定任意長度的關鍵字參數，在參數前加上**表示接受一個dict：

當然我們也可以兩個都用上，這樣可以接受任何參數：

傳入參數的時候我們也可以使用*和**來解壓list或者是dict：

Python中的參數 可以返回多個值 ：

函數內部定義的變數即使和全局變數重名，也 不會覆蓋全局變數的值 。想要在函數內部使用全局變數，需要加上 global 關鍵字，表示這是一個全局變數：

Python支持 函數式編程 ，我們可以在一個函數內部返回一個函數：

Python中可以使用lambda表示 匿名函數 ，使用:作為分隔，:前面表示匿名函數的參數，:後面的是函數的返回值：

我們還可以將函數作為參數使用map和filter，實現元素的批量處理和過濾。關於Python中map、reduce和filter的使用，具體可以查看之前的文章：

五分鐘帶你了解map、reduce和filter

我們還可以結合循環和判斷語來給list或者是dict進行初始化：

使用 import語句引入一個Python模塊 ，我們可以用.來訪問模塊中的函數或者是類。

我們也可以使用from import的語句，單獨引入模塊內的函數或者是類，而不再需要寫出完整路徑。使用from import *可以引入模塊內所有內容（不推薦這麼干）

可以使用as給模塊內的方法或者類起別名：

我們可以使用dir查看我們用的模塊的路徑：

這麼做的原因是如果我們當前的路徑下也有一個叫做math的Python文件，那麼 會覆蓋系統自帶的math的模塊 。這是尤其需要注意的，不小心會導致很多奇怪的bug。

我們來看一個完整的類，相關的介紹都在注釋當中

以上內容的詳細介紹之前也有過相關文章，可以查看：

Python—— slots ，property和對象命名規範

下面我們來看看Python當中類的使用：

這裡解釋一下，實例和對象可以理解成一個概念，實例的英文是instance，對象的英文是object。都是指類經過實例化之後得到的對象。

繼承可以讓子類 繼承父類的變數以及方法 ，並且我們還可以在子類當中指定一些屬於自己的特性，並且還可以重寫父類的一些方法。一般我們會將不同的類放在不同的文件當中，使用import引入，一樣可以實現繼承。

我們創建一個蝙蝠類：

我們再創建一個蝙蝠俠的類，同時繼承Superhero和Bat：

執行這個類：

我們可以通過yield關鍵字創建一個生成器，每次我們調用的時候執行到yield關鍵字處則停止。下次再次調用則還是從yield處開始往下執行：

除了yield之外，我們還可以使用()小括弧來生成一個生成器：

關於生成器和迭代器更多的內容，可以查看下面這篇文章：

五分鐘帶你弄懂迭代器與生成器，夯實代碼能力

我們引入functools當中的wraps之後，可以創建一個裝飾器。裝飾器可以在不修改函數內部代碼的前提下，在外面包裝一層其他的邏輯:

裝飾器之前也有專門的文章詳細介紹，可以移步下面的傳送門：

一文搞定Python裝飾器，看完面試不再慌

不知道有多少小夥伴可以看到結束，原作者的確非常厲害，把Python的基本操作基本上都囊括在裡面了。如果都能讀懂並且理解的話，那麼Python這門語言就算是入門了。

如果你之前就有其他語言的語言基礎，我想本文讀完應該不用30分鐘。當然在30分鐘內學會一門語言是不可能的，也不是我所提倡的。但至少通過本文我們可以做到熟悉Python的語法，知道大概有哪些操作，剩下的就要我們親自去寫代碼的時候去體會和運用了。

根據我的經驗，在學習一門新語言的前期，不停地查閱資料是免不了的。希望本文可以作為你在使用Python時候的查閱文檔。

最後，我這裡有各種免費的編程類資料，有需要的及時私聊我，回復”學習”，分享給大家，正在發放中…………

Python 中的import 機制

解釋器 在執行語句時，遵循作用域原則。因為這和作用域有關係， 如果在頂層導入模塊，此時它的作用域是全局的；如果在函數內部導入了模塊，那它的作用域只是局部的 ，不能被其它函數使用。如果其它函數也要用到這個模塊，還需要再次導入比較麻煩。

在用import語句導入模塊時最好按照這樣的順序：

絕對路徑 就是文件的真正存在的路徑，是指從硬碟的根目錄(盤符)開始，進行一級級目錄指向文件。

相對路徑 就是以當前文件為基準進行一級級目錄指向被引用的資源文件。

以下是常用的表示當前目錄和當前目錄的父級目錄的標識符

形如from moduleB import ClassB語句，根據Python內部import機制，執行細分步驟：

總結：from moduleB import ClassB有兩個過程，先from module，後import ClassB。

當然將moduleA.py語句 from moduleB import ClassB改為：import moduleB，將在第二次執行moduleB.py語句from moduleA import ClassA時報錯：ImportError: cannot import name 『classA』

在一個文件下同時有 init .py文件、和其他模塊文件時，該文件夾即看作一個包（package）。包的導入 和模塊導入基本一致，只是導入包時，會執行這個 init .py，而不是模塊中的語句。

而且，如果只是單純地導入包【形如：import xxx】，而包的 init .py中有沒有明確地的其他初始化操作，則：此包下的模塊 是不會被自動導入的。當然該包是會成功導入的，並將包名稱放入當前.py的Local命名空間中。

參考文章：

Python中import機制

Python 3.x可能是史上最詳解的【導入（import）】

在Python中以絕對路徑或者相對路徑導入文件的方法

Python的模塊引用和查找路徑