[PY3]——基本語法

Jelly_lyj發表於2017-03-18

Python3基本語法-xmind圖

常量/變數

1. 常量：一旦賦值就不可再改變。不能對它重新賦值。python不存在常量
2. 字面常量：一個單獨出現的量，未賦值給任何變數或常量
3. 變數:

i=3
print(i)
3

型別系統

1. python是動態型別語言：指的是變數可以重新賦值為其他型別

In [5]: i=4;type(i)
Out[5]: int
In [6]: i='4';type(i)
Out[6]: str

2. python是強型別語言：強型別指的是不同型別之間不能相互計算

In [7]: 4+'4'
TypeError: unsupported operand type(s) for +: 'int' and 'str'

3. python中一切都是引用，所以一切都是指標

4. python的基本型別：

(1)int整型：python裡面可以說int型沒有溢位，而只受限於實體記憶體

In [8]: i=1000000000000000000000000000000000000000000000000000000000000000000000
   ...: 000000000000000000000000000000000000000000000000000000000000000000000000
In [9]: type(i)
Out[9]: int
In [10]: i**2
Out[10]: 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

(2)float浮點型：(py3裡面沒有double型別)，浮點型會損失精度

In [11]: type(1.0)
Out[11]: float
In [12]: type(3.14159)
Out[12]: float

(3)bool布林型：True Flase
(4)none：None指的是沒有指向任何記憶體

運算子

1. 算術運算子：

# 算術運算子只能對int和float運算,int會隱式轉換成float
# +  加
    In [5]: 1+1.0
    Out[5]: 2.0

# -  減
    In [6]: 1-2
    Out[6]: -1

# *  乘
    In [11]: 2*3
    Out[11]: 6

# /  自然除(結果都是float型)
    In [1]: 3/2
    Out[1]: 1.5
    In [2]: type(3/2)
    Out[2]: float

# // 取整除(結果取整故都是int型)
    In [3]: 3//2
    Out[3]: 1
    In [4]: type(3//2)
    Out[4]: int

# ** 求冪
    In [12]: 2**3
    Out[12]: 8

# %  取模
    In [19]: 4%3
    Out[19]: 1

2. 比較運算子

# 比較運算返回值都是bool型
#    >   大於
#    <   小於
#    == 等於
#    !=  不等於
#    >= 大於等於
#    <= 小於等於
In [20]: type(1>2)
Out[20]: bool

In [21]: 1>2
Out[21]: False

In [22]: 1<2
Out[22]: True

In [23]: 1!=2
Out[23]: True

3. 邏輯運算子

# or  或
# and 且
# not 非
# 邏輯運算子的運算元與返回值都是bool型別
In [24]: True or False
Out[24]: True

In [25]: True and False
Out[25]: False

In [26]: not True
Out[26]: False

In [27]: type(True or False)
Out[27]: bool

# 所有參與邏輯運算的運算元都會隱式轉換成bool型別，其中0和None會隱式轉換為False、非0則隱式轉換為True
In [31]: 0 or 1  //0=Flase or 1=True
Out[31]: 1       //非0=True

# 邏輯運算的短路操作：從左到右執行，當左邊的計算已經可以直接得出結果時，將停止計算，提前返回
In [32]: def true():
             print('True')
             return True
In [34]: def false():
             print('False')
             return False
         
In [35]: true() or false()    
True                           //or運算時左邊為true已可以得到結果，故只執行了true()
Out[35]: True

In [36]: false() and true()
False                         //and運算時左邊為false已可以得到結果，故只執行了false()
Out[36]: False

In [37]: false() or true()   //左邊還不能得到結果的時候，true()和false()都執行了
False
True
Out[37]: True

4. 成員運算子

#用於判斷一個元素是否在容器中（和集合型別有關）
# in       在
# not in 不在
In [43]: 3 in [1,2,3,5]
Out[43]: True

In [46]: 'a' not in 'love python'
Out[46]: True

In [47]: 10 in (0,2,8,11)
Out[47]: False

In [44]: 10 in {0,2,8,11}
Out[44]: False

# 集合的成員運算遠高於其他線性結構做成員運算

# 列子1：
In [49]: lst=list(range(1000000));
In [50]: s=set(range(1000000));

In [51]: %%timeit
    ...: -1 in lst
100 loops, best of 3: 13.1 ms per loop

In [52]: %%timeit
    ...: -1 in s
The slowest run took 28.53 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 3: 44.6 ns per loop

#例子2：
In [53]: lst2=list(range(100))
In [54]: s2=set(range(100))

In [55]: %%timeit
    ...: -1 in lst2
1000000 loops, best of 3: 1.36 us per loop

In [56]: %%timeit
    ...: -1 in s2
The slowest run took 26.28 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 3: 46.3 ns per loop

# 通過下面的例子我們可以得到如下結論：
# 做成員運算時，
#   *集合的時間複雜度是O(1),其效率和集合的規模無關 ==>當規模大時我們轉化為集合來做運算效率會高很多
#   *線性結構的複雜度是O(n),其效率和列表的規模有關 ==>當規模小時其實線性結構的效率未必不會更好

5. 身份運算子

# 物件導向

6. 位運算子

# 位運算子是直接操作二進位制的
# <<
# >>
# &
# |
# ^

7. 賦值運算子

# 賦值運算子是可以和算術運算子、比較運算子、位運算子一起使用   
In [12]: a=1+2;print(a);type(a)
3
int

In [13]: a=1>2;print(a);type(a)
False
bool

In [14]: a=True or False;print(a);type(a)
True
bool

8. 運算子優先順序

算術運算子>比較運算子>邏輯運算子
可以通過使用括號來改變優先順序

程式結構

1. 順序結構

2. 分支結構

（1）單分支（2）雙分支

（3）多分支

# 單分支    
開始    
if 條件:        
   操作    
結束
In [1]: a=5
In [2]: if a<10:
           print('a less then 10')

# 雙分支雙分支結構裡，永遠只有一個分支會被執行    
開始    
if 條件:        
   操作1    
else:        
   操作2    
結束
In [3]: a=5
In [4]: if a<10:
            print(a,'less then 10')
        else:
            print(a,'great then 10')

# 多分支多分支結構裡，永遠只有0個或1個分支會執行條件只能是bool型別或者是可以隱式轉化為bool型別的
In [5]: a=50
In [6]: if a<10:
            print('a<10')
        elif a<20:
            print('a<20')
        elif a<30:
            print('a<30')
        else
           print('a>30')

3. 迴圈

（1）while迴圈（2）for in迴圈

# 一定要有某種機制修改調製使其退出迴圈，通常是在迴圈體裡修改條件
# for in 迴圈裡永遠不要修改可迭代物件（）
# 如何選擇使用哪種迴圈？
   對已知的可迭代物件做遍歷，選擇for in
   對未知的條件做迴圈，選擇while

# while迴圈    
開始    
while 條件:        
      操作    
結束
In [18]: i=0
In [19]: while i<10:
             print(i)
             i+=2        
0
2
4
6
8

# for in迴圈    
開始    
for 元素 in 可迭代物件:        
    操作    
結束
In [62]: for i in range(0,10,2):
             print(i)
         
0
2
4
6
8

4. 提前終止與跳過

# break 和 continue只針對最近的一層
# break和continue只能用在迴圈裡

# break
In [66]: for i in range(0,3):
    ...:     for j in range(0,5):
    ...:         if j>2:
    ...:             break
    ...:         print('i={},j={}'.format(i,j))
    ...:
i=0,j=0
i=0,j=1
i=0,j=2
i=1,j=0
i=1,j=1
i=1,j=2
i=2,j=0
i=2,j=1
i=2,j=2

# continue
In [67]: for i in range(0,3):
    ...:     for j in range(0,5):
    ...:         if j!=2:
    ...:             continue
    ...:         print('i={},j={}'.format(i,j))
    ...:
i=0,j=2
i=1,j=2
i=2,j=2

5. else子句(python中else可以和迴圈語句一起使用)

# 當迴圈沒有被break（被中斷/提前退出）時，會執行else子句
In [68]: for i in range(0,5):
    ...:     pass
    ...: else:
    ...:     print('not exit')
    ...:
not exit

In [69]: for i in range(0,5):
    ...:     continue
    ...: else:
    ...:     print('not exit')
    ...:
not exit

In [70]: for i in range(0,5):
    ...:     break
    ...: else:
    ...:     print('not exit')
    ...:

[PY3]——基本語法

常量/變數

型別系統

運算子

程式結構

相關文章