一. python包和模塊

本文轉載自查看原文 2019-05-14 01:33 489 第六篇 python包

一.模塊

#這是aa.py文件

print('啦啦啦啦啦啦啦啦')

money=1000

def read1():
    print('bb->read1->money',money)

def read2():
    print('bb->read2 calling read1')
    read1()

def change():
    global money
    money=0

這是bb.py文件 # 方式一
"""
import aa #只在第一次導入時才執行my_module.py內代碼,此處的顯式效果是只打印一次'from the my_module.py',當然其他的頂級代碼也都被執行了,只不過沒有顯示效果.
import aa
import aa
import aa
# python的優化手段是：第一次導入后就將模塊名加載到內存了，
# 后續的import語句僅是對已經加載大內存中的模塊對象增加了一次引用，
# 不會重新執行模塊內的語句"""


# 方式二
"""
#測試一:money與aa.money不沖突
每個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，
把這個模塊的名稱空間當做全局名稱空間，這樣我們在編寫自己的模塊時，
就不用擔心我們定義在自己模塊
中全局變量會在被導入時，與使用者的全局變量沖突
#bb.py
import aa
money=10
print(aa.money)
'''
啦啦啦啦啦啦啦啦
1000
'''
"""

# 方式三
"""
#測試二：read1與aa.read1不沖突
#demo.py
import aa
def read1():
    print('這是本地模塊哈哈哈')
aa.read1()
read1()
'''啦啦啦啦啦啦啦啦
bb->read1->money 1000
這是本地模塊哈哈哈
'''
"""

# 方式四
"""
執行bb.change()操作的全局變量money仍然是aa中的
#demo.py
import aa
money=1
aa.change()
print(aa.money)
print(money)
'''
啦啦啦啦啦啦啦啦
0
1
'''"""
# 1.為源文件(aa模塊)創建新的名稱空間，在aa中定義的函數和方法若是使用到了global時訪問的就是這個名稱空間。
# 2.在新創建的命名空間中執行模塊中包含的代碼，見初始導入import aa


# 方式五
"""import aa as c    #  給引入aa的模塊給aa模塊 取一個別名  c
    print(c.money)
"""


# 方式六
"""
# 導入的函數read1，執行時仍然回到aa.py中尋找全局變量money
from aa import read1
money=8222
read1()
'''
啦啦啦啦啦啦啦啦
bb->read1->money 1000
'''
"""

# 方式七
"""
#測試二:導入的函數read2，執行時需要調用read1(),仍然回到aa.py中找read1()
#demo.py
from aa import read2
def read1():
    print('==========')
read2()
'''
啦啦啦啦啦啦啦啦
bb->read2 calling read1
bb->read1->money 1000
'''
"""

# 方式八
"""
#測試三:導入的函數read1，被當前位置定義的read1覆蓋掉了
#demo.py
from aa import read1
def read1():
    print('==========')
read1()
'''
啦啦啦啦啦啦啦啦
==========
'''
"""

# 方式九
"""# 要特別強調的一點是：python中的變量賦值不是一種存儲操作，而只是一種綁定關系
from aa import money,read1
money=100 #將當前位置的名字money綁定到了100
print(money) #打印當前的名字
read1() #讀取aa中的名字money,仍然為1000
'''
啦啦啦啦啦啦啦啦
100
bb->read1->money 1000
'''
"""

# 方式十
"""
# 多模塊導入
from aa import (read1,read2,money)
print(money)
"""


# 方式十一
"""
# *  全部導入
from aa import * #將模塊my_module中所有的名字都導入到當前名稱空間
print(money)
print(read1)
print(read2)
print(change)
啦啦啦啦啦啦啦啦
1000
<function read1 at 0x000001B65DE2BBF8>
<function read2 at 0x000001B65DE2BA60>
<function change at 0x000001B65DE2BC80>
"""

自定義模塊導入死循環即解決方法

二. 模塊搜索文件路徑模塊的搜索路徑指的就是在導入模塊時需要檢索的文件夾

先從內存中已經導入的模塊中尋找
內置的模塊
環境變量sys.path中找

 1 先從內存中已經導入的模塊中尋找
 2 內置的模塊



3 環境變量sys.path中找

三包

，第一是直接作為腳本執行，第二是import到其他的python腳本中被調用（模塊重用）執行。

因此if __name__ == 'main': 的作用就是控制這兩種情況執行代碼的過程，在if __name__ == 'main':

下的代碼只有在第一種情況下（即文件作為腳本直接執行）才會被執行，而import到其他腳本中是不會被執行的。

1. __name__=='__main__'：

def aa():
    print("111111")
cc=10000

def lo():
    print("222222222222222222222")
print(__name__)
# __main__
# 當我們執行這個模塊的時候 __name__=='__main__'
# 當我我們去執行其他模塊 在其他模塊中引用這個模塊的時候 __name__=="模塊名字"
if __name__=='__main__':
       lo()
       aa()
       print(cc)

# 222222222222222222222
# 111111
# 10000

2. module from.....import ... from.....import *

這是module.py文件 # 一個.py就是一個模塊

def sayGood():
    print("my name is veary good")


def sayNice():
    print("my name is veary good")

def sayHandsome():
    print("my name is veary good")
t1=1000000000000000

這是執行文件aa.py """
           方法一

import  module
# 自定義模塊  后面不加.py后綴
# 注意 一個模塊只會引入一次 不管你執行了 多次 import 防止模塊多次引入
# 使用模塊中的內容:
#        格式: 模塊名 函數名/變量
module.sayHandsome()   # my name is veary good
module.sayGood()      # my name is veary good
module.sayNice()     # my name is veary good
print(module.t1)     # 1000000000000000

# 引用函數模塊
sayHandsome()

sayGood()

sayNice()

"""


"""
        方法二
from.......import*語句
# 作用：把一個模塊中所有的內容導入 當前命名空間

# from module import *#最好不要過多使用

sayGood()  
"""



        # 方法三

# from.......import語句
#     作用:從模塊中導入一個指定的部分到當前命名空間

#     格式: from module import name[,[name2]]            

#      意思從modul這個模塊里導入那個功能模塊
from module import sayGood ,sayNice,sayHandsome


# 程序內容的函數可以將模塊中的同名函數覆蓋
# def sayGood():
#     print("*********************")

sayGood()   # my name is veary good

sayNice()   # my name is veary good

sayHandsome()  #my name is veary good

3. __init__.py

思考: 如果不同的人編寫的模塊同名怎么辦
解決: 為了解決模塊命名的沖突引入了按目錄來組織模塊的方法這個模塊稱為包
特點: 引入了包以后只要頂層的包不與其他人發生沖突那么模塊都不會與別人的發生沖突

Python中的包
包是一個分層次的文件目錄結構，它定義了一個由模塊及子包，和子包下的子包等組成的 Python 的應用環境。
簡單來說，包就是文件夾，但該文件夾下必須存在 __init__.py 文件, 該文件的內容可以為空。__init__.py
用於標識當前文件夾是一個包。
考慮一個在 package_runoob 目錄下的 runoob1.py

a目錄下的aa.py

執行文件

# runoob2.py、__init__.py 文件，test.py 為測試調用包的代碼，目錄結構如下：
import a.aa
import a.xi
a.aa.sayGood()  
# 333333333333333333333333333330000000

a.xi.bb()

b.aa.aa()
# 111111111111111111111111111111111111111

4. 相對路徑包 這種不能在包里面使用只能在外面使用

目錄結構