綜下所述：有兩個知識點：

（1）sys.path

import sys
sys.path 
這個打印出來匯入的模組，搜尋的路徑，需要要新增的話，
sys.path.append('../')的形式新增。

(2)reload(test)

import 後，程式執行過程中更改，函式並不會更改，如果要重新整理函式
from imp import *
reload(test)
才會重新載入test.py函式。

（3）迴圈匯入
a.py b.py
a 與 b 相互以呼叫，這樣就會出現迴圈匯入的問題。
在設計的初始階段，應該避免這種呼叫方法。
（4）== 與 is
== 判斷，值 是否相等
is 判斷是否是同一個東西
c=a ,是引用傳遞，
id(a) 檢視a物件的記憶體地址。
（5）深拷貝、淺拷貝

淺拷貝
    a=[11,22,33]
    b=a
深拷貝
    import copy
    a=[11,22,33]
    c=copy.deepcopy(a)
    copy.copy()
         可變型別：copy第一層(列表【】)
         不可變型別：不copy (元組())
    copy.deepcopy()
        可變型別和不可變型別，都copy
        如果有引用，繼續copy.

（6）進位制、位運算

（7）原碼、反碼、補碼

（8）位運算，&

左移*2   5<<1   10
右移/2    10>>1   5
按位與 &       全1才1，否則0 ，逐位進行與運算。
按位或 |       全0才0，否則1    
按位異或    ^       相同為1，不同為0 
取反      ~       取相反 
 

（9）property

方式一：
    class Test(object):
        def __init__(self):
            self.__num=100
        def getNum(self):
            return self.__num
        def setNum(self,newValue):
            self.__num=newValue
        num=property(getNum,setNum)
    t=Test()
    print(t.num)
    t.num=200
    print(t.num)
  方式二：裝飾器
    class Test(object):
        def __init__(self):
            self.__money=0
        @property
        def money(self):
            return self.__money
        @money.setter
        def money(self,value):
            if isinstance(value,int):
                self.__money=value
            else:
                return "error value type".
    t=Test()
    print(t.money)
    t.money=200
    print(t.money)
    
 

1.知識點

匯入
迴圈匯入
作用域
== is
深copy,淺 copy
禁制，位運算
私有化
其他的知識點

2.import匯入模組

import xxx
=>ImportError :No module named 'xxx'

import sys
sys.path
=>打印出列表。顯示，匯入包時，搜尋的路徑。
sys.path
['',
'/usr/lib/python35.zip',
...]
這是一個列表，列表支援append .

sys.path.append('/home') .新增home路徑到sys.path的查詢路徑上。

import .匯入之後的模組，如果執行Python後就會一直用之前import 的內容，這個時候，如果程式發生了變化，import 的內容，
不會發生變化。

(2)重新載入：
如果在程式執行的過程中，要重新載入程式：
from imp import *
reload(test)

3.迴圈匯入
a.py
b.py
a要匯入b，b還要匯入a的情況。

一大半的錯誤，都是自己剛開始的時候，沒有注意到錯誤引起的。
b.py
def b():
    print("------b-----")
a.py
from b import b
def a():
    print("-------a---")
    b()
a()
然後執行呼叫，python a.py
就會輸出了，之前一直報錯，EOLError ,for why ,because i forget the "" of b function .

1. == 與 is
   a=[11,22,33]
   b=[11,22,33]
   a==b
   True
   a is b
   False
   c=a
   c is a
   True
   id(a) 140664155920392
   id(b) 140664155926664
   id(c) 140664155920392

   c=a ,傳遞的是a的記憶體的引用。實際指向同一個東西。
   如果這個時候，a的內容更改，會重新建立列表。
   這時候 c is a False .即c 和 a 將不再是同1個東西。

   a=100
   b=100
   a ==b True
   a is b True .
   a=10000
   b=10000
   a=b True
   a is b False
   在python 中，如果值在-126-127之間，則is 的時候是相同的，除此之外是不相同的。
   5.深拷貝、淺拷貝

   淺拷貝：引用地址的傳遞，沒有開闢新記憶體建立。
   a=[11,22,33]
   b=a
   a is b
   True
   深拷貝：將物件的記憶體內容重新建立，如果有引用，引用的物件也重新建立。
   import copy
   a=[11,22,33]
   c=copy.deepcopy(a)
   這個是深copy,id(a)!=id(b)
   a=[11,22,33,44],此時，b也會更改為[11,22,33,44]
   c不會更改
   深拷貝：（copy.deepcopy()--如果裡面有引用，就接著copy）
   a=[11,22,33]
   b=[44,55,66]
   c=[a,b]
   d=c
   e=copy.deepcopy(c)

    a.append(44)
    d
    [[11,22,33,44],[44,55,66]]
    e
    [[11,22,33],[44,55,66]]
    元組，和列表，都會發生copy變化。

   深拷貝：(copy.copy()--僅copy第一層。是可變型別，copy一層， 不可變型別，不copy)
   a=[1,2,3]
   b=[4,5,6]
   c=[a,b]
   e=copy.copy(c)
   a.append(4)
   c
   [[1,2,3,4],[4,5,6]]
   e
   [[1,2,3,4],[4,5,6]]
   如果是列表【】，第一層是copy 的。
   如果是元組（），第一層不copy .
   元組特點：（不可變型別）copy可以判斷是否是可變型別。
   6.進位制、位運算

   進位制

    十進位制、二進位制、八進位制、十六進位制

   轉換

7.原碼、反碼、補碼

1個位元組有8位
1B=8bit

0000    0000    0000    0001
第一個0 用來表示符號。（0為正，1為負）

+2
0000    0000    0000    0010
-2
1000    0000    0000    0010

+1 與 -1 相加
0000    0000    0000    0001
1000    0000    0000    0001
=》
1000    0000    0000    0010
結果是-2 .是錯誤的。

規則：
正數： 原碼  =  反碼  = 補碼
負數： 反碼  = 符號位不變.其他取反
      補碼  =  反碼 + 1
      原碼  = 補碼的符號為不變--》資料位取反+1
補碼相加

溢位：
CPU小模組，加法比較快。減法慢。

十進位制轉二進位制：bin(18) 0b10010
十進位制轉八進位制：oct(18) 0o22
十進位制轉十六進位制：hex(18) 0x12

十六進位制轉十進位制：int('0x12',16)
八進位制轉換十進位制：int('0o22',8)

8.位運算

對數值，進行bit位運算。

乘法運算：
    轉換成二進位制，往左移動。每移動一次，乘以2。而且效率很高。
問：如何快速對兩個值，進行相乘？
    左移和右移動，速度很快，效率很高。

5<<1    10
5<<3    40
10>>1   5

位移運算子：>> ,<< 
<<,>> 位運算作用：快速進行乘法和除法。
2*3 
    2<<1 +2

運算，都是對補碼，進行運算。
~9  ==-10 
9的原碼：0000   1001
9的補碼：0000   1001    
對補碼取反：1111  0110
轉成原碼：1000   1010
就是 -10 .        

9.私有化

__init__() 無法訪問，私有化。
python中 ”__“代表私有化。

如果子類，繼承了原來的類，那麼子類，不能訪問原來的類的私有化的屬性。
（1）
__屬性    私有屬性
__方法    私有方法
    私有屬性，私有方法，類外面，不能用
    子類，不能繼承的。子類不能直接呼叫。
（2）
屬性
方法
    公有變數
（3）
__屬性__
__方法__
    系統提供的方法，自己不要寫這樣的符號
（4）
_屬性
_方法
    模組內可用，模組外不能用。私有化屬性和方法。
    from somemodule import * .
    禁止匯入，類內部和子類可以用。
    名字重整
    __xx__ 系統的方法
    _x: 類內部可訪問方法。

10.property

class Test(object):
    def __init__(self):
        self.__num=100
    def getNum(self):
        return self.__num
    def setNum(self,newNum):
        self.__num=newNum
t=Test()
print(t.num)
t.num=200
print(t.num)

property的作用，相當於對方法進行了封裝，開發者對屬性設定資料的時候更加方便。
（1）property用法一：
    class Test(object):
        def __init__(self):
            self.__num=100  
        def getNum(self):
            return self.__num   
        def setNum(self,newNum):
            self.__num=value
        num=property(getNum,setNum)
    t=Test()
    print(t.num)
    t.mum=200
    print(t.num)
(2)property用法二
    class Test(object):
        def __init__(self):
            self.__money=0
        @property
        def money(self):
            return self.__money
        @money.setter
        def money(self,value):
            if isinstance(value,int):
                self.__money=value
            else:
                print("error:not int type")