PY01-02:Python數(shù)據(jù)運(yùn)算與流程控制

非常傳統(tǒng)的題目，計(jì)算機(jī)語(yǔ)言的三大核心語(yǔ)法要素的一部分：
??1. 運(yùn)算符；
??2. 流程控制；
同時(shí)建立程序的概念。

主題二：數(shù)據(jù)運(yùn)算與流程控制

目標(biāo)

  • 應(yīng)用目標(biāo)

    • 階段實(shí)戰(zhàn)：利用各種計(jì)算、條件控制、循環(huán)控制等知識(shí)，實(shí)現(xiàn)各種圖形繪制應(yīng)用程序；
    • 綜合實(shí)戰(zhàn)：
      • 完成股票信息的完整數(shù)據(jù)查詢。
      • 完成完整的信息輸入模塊。

  • 資費(fèi)管理系統(tǒng)


    字符界面的系統(tǒng)

  • 股票信息查詢系統(tǒng)


    字符界面的查詢系統(tǒng)

  • 技能目標(biāo)

    • 1. 能實(shí)現(xiàn)流程復(fù)雜的應(yīng)用模塊
    • 2. 基本技術(shù)應(yīng)用能力。
      • 能使用運(yùn)算符；
      • 能根據(jù)條件控制流程；
      • 能在開(kāi)發(fā)中使用循環(huán)控制程序流程；
      • 能在循環(huán)中停止程序的循環(huán)流程；

  • 知識(shí)點(diǎn)目標(biāo)

    • 1. 掌握運(yùn)算符語(yǔ)法、功能與應(yīng)用；
      • 掌握算術(shù)運(yùn)算符號(hào)；
      • 掌握條件運(yùn)算符號(hào)；
      • 掌握邏輯運(yùn)算符號(hào)；
      • 掌握位運(yùn)算符號(hào)；
      • 掌握復(fù)合運(yùn)算符號(hào)；
      • 掌握其他運(yùn)算符號(hào)；
      • 掌握表達(dá)式與運(yùn)算符號(hào)的優(yōu)先級(jí)；
      • 掌握常見(jiàn)數(shù)據(jù)的運(yùn)算；
        • 數(shù)值運(yùn)算；
        • 邏輯值運(yùn)算；
        • 序列值運(yùn)算；
        • 字符串值運(yùn)算；
        • 字典值運(yùn)算；
        • 集合值運(yùn)算；
      • 掌握調(diào)用符號(hào)；
      • 掌握函數(shù)調(diào)用符號(hào)；
    • 2. 掌握程序流程控制的語(yǔ)法與流程控制過(guò)程
      • 掌握條件控制的語(yǔ)法-if；
      • 掌握條件控制的應(yīng)用-if；
      • 掌握循環(huán)控制的語(yǔ)法-while；
      • 掌握循環(huán)控制的應(yīng)用-while；
      • 掌握循環(huán)控制的語(yǔ)法-for；
      • 掌握循環(huán)控制的應(yīng)用-for；
      • 掌握循環(huán)中斷控制語(yǔ)法-continue與break；
      • 了解其他流程控制語(yǔ)法；

運(yùn)算符語(yǔ)法、功能與應(yīng)用

??掌握好運(yùn)算符號(hào)，從四個(gè)方面掌握：

  • 運(yùn)算符號(hào)的使用語(yǔ)法
  • 運(yùn)算符號(hào)的功能（作用）
  • 運(yùn)算符號(hào)參與運(yùn)算的數(shù)據(jù)要求（數(shù)據(jù)類型，數(shù)據(jù)個(gè)數(shù)）
  • 運(yùn)算符號(hào)的返回?cái)?shù)據(jù)類型

??特別需要注意的是，在某些運(yùn)算中，還存在數(shù)據(jù)類型轉(zhuǎn)換。

算術(shù)運(yùn)算符號(hào)

  1. 語(yǔ)法

    • 算術(shù)運(yùn)算都是二目運(yùn)算（需要兩個(gè)數(shù)據(jù)值參與運(yùn)算）

    • 數(shù)據(jù)1 運(yùn)算符 數(shù)據(jù)2

    • 說(shuō)明：運(yùn)算符在中間，數(shù)據(jù)在運(yùn)算符兩邊（前面的數(shù)據(jù)成為：被運(yùn)算數(shù)【比如：被加數(shù)】，后面成為運(yùn)算數(shù)【比如：加數(shù)】），這種運(yùn)算的表達(dá)方式，也稱表達(dá)式，俗稱中繼表達(dá)式。

  2. 算術(shù)運(yùn)算的運(yùn)算符

    • + ：加運(yùn)算
    • - ：減運(yùn)算
    • *：乘運(yùn)算
    • / ：除運(yùn)算
    • //：整除運(yùn)算
    • %：求余運(yùn)算
    • **：冪運(yùn)算（指數(shù)運(yùn)算，乘方運(yùn)算）
# 熟悉運(yùn)算符的功能與使用語(yǔ)法
print(20 + 30)
print(40 - 30)
print(10 * 5)
print(17 / 5)
print(18 // 7)
print(25 % 6)
print(8 ** 2)

50
10
50
3.4
2
1
64
  1. 運(yùn)算數(shù)的數(shù)據(jù)類型
  • 加減法
    • 對(duì)整數(shù)，小數(shù) ，邏輯值，復(fù)數(shù)都可以運(yùn)算。
    • 邏輯值True=1，F(xiàn)alse=0
    • 所有運(yùn)算的結(jié)果與數(shù)學(xué)知識(shí)一致。
# + - 
print(30 + 30)
print(30 + 88.88)
print(30 + True)
print(30 + (30 + 45.8J) )
print(False + True )

60
118.88
31
(60+45.8j)
1

  • 乘除法

    • 對(duì)整數(shù)，小數(shù) ，邏輯值，復(fù)數(shù)都可以運(yùn)算。

    • 邏輯值True=1，F(xiàn)alse=0

    • 所有運(yùn)算的結(jié)果與數(shù)學(xué)知識(shí)一致。

    • 注意：除法中除數(shù)不能為0。

# 乘除
print(30 * 30)
print(30 * 88.88)
print(30 * True)
print(30 * (30 + 45.88888J) )
print(False * True )
print("---------------")
print(30 / 30)
print(30 / 88.88)
print(30 / True)
print(30 / (30 + 45.8J) )
print(False / True )

900
2666.3999999999996
30
(900+1376.6664j)
0
---------------
1.0
0.33753375337533753
30.0
(0.3002361857994957-0.45836057698723004j)
0.0
  • 整除

    • 對(duì)整數(shù)，小數(shù) ，邏輯值都可以運(yùn)算，對(duì)復(fù)數(shù)不能運(yùn)算，因?yàn)閺?fù)數(shù)不能取整（floor運(yùn)算）

    • 邏輯值True=1，F(xiàn)alse=0

    • 所有運(yùn)算的結(jié)果與數(shù)學(xué)知識(shí)一致。

    • 注意：整除中除數(shù)不能為0。

# 整除
print(30 // 30)
print(30 // 88.88)
print(30 // True)
# print((30 + 45J) // 5 )    # TypeError: can't take floor of complex number.
print(False // True )

print(86.8 // 67.8)

1
0.0
30
0
1.0
  • 乘方

    • 對(duì)整數(shù)，小數(shù) ，邏輯值，復(fù)數(shù)都可以運(yùn)算

    • 邏輯值True=1，F(xiàn)alse=0

    • 所有運(yùn)算的結(jié)果與數(shù)學(xué)知識(shí)一致。

# 整除
print(30 ** 2)
print(30 ** 2.5)
print(30 ** True)
print((30 + 45J) ** 3 )    # TypeError: can't take floor of complex number.
print(False ** True )

print(86.8 ** 67.8)
print(2 ** (4.3 + 3J))

900
4929.503017546495
30
(-155250+30375j)
0
2.7017015190288315e+131
(-9.592967312139688+17.20460459222708j)
  1. 返回類型
    ??邏輯值作為整數(shù)在處理；返回類型的規(guī)則
  • 整數(shù) op 整數(shù) -> 整數(shù)（op：+ - * // % **）
  • 整數(shù) / 整數(shù) -> 小數(shù) (就算能整除，也是小數(shù))
print(type(16/3))   

<class 'float'>
  • 整數(shù) op 小數(shù) -> 小數(shù)
  • 小數(shù) op 小數(shù) -> 小數(shù) 
print(type(4.5//3.5))
print(type(4//3.0))
print(type(4//3))

<class 'float'>
<class 'float'>
<class 'int'>
  • 整數(shù) op 復(fù)數(shù) -> 復(fù)數(shù)
  • 小數(shù) op 復(fù)數(shù) -> 復(fù)數(shù)
  • 提示：復(fù)數(shù)有可能虛部為 0
print(23 * (4 + 5J))
print( (4 + 5J) / (4 + 5J))

print( (4 + 5J) * (4 - 5J) )

(92+115j)
(1+0j)
(41+0j)
  • 對(duì)序列的運(yùn)算

    • 列表包含三類：元組，列表，字符串

    • 有列表支持的算術(shù)運(yùn)算

      • 復(fù)制：整數(shù) * 列表： 整數(shù) * 列表 或者 列表 * 整數(shù)
      • 連接：列表 + 列表： 列表 + 列表

    • 其他的運(yùn)算符都不支持

    • 注意：只有同類型才能連接

print( (1, 2, 3) * 3 )
print( 3 * (1, 2, 3))
print( [1, 2, 3] * 3 )
print( 3 * [1, 2, 3])
print('hello'* 3 )
print( 3 * 'world')

print( [1, 2, 3] + [4, 5, 6])
# print( (1, 2, 3) + [4, 5, 6])    # 不同類型：TypeError: can only concatenate tuple (not "list") to tuple
print( (1, 2, 3) + (1, 2, 3))
print( 'hello' + 'world')
# print( 3 * {1, 2, 3})     # unsupported operand type(s) for *: 'int' and 'set'

(1, 2, 3, 1, 2, 3, 1, 2, 3)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
[1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
hellohellohello
worldworldworld
[1, 2, 3, 4, 5, 6]
(1, 2, 3, 1, 2, 3)
helloworld
  • 對(duì)字典/集合的運(yùn)算
    • 算術(shù)運(yùn)算中的任何運(yùn)算符，都不支持對(duì)字典/集合的運(yùn)算；
dt = {'name': 'Louis', 'age': 20}
print(dt + dt)   # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'


---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-128-d6eb1a53c94e> in <module>()
      1 dt = {'name': 'Louis', 'age': 20}
----> 2 print(dt + dt)   # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'


TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
  • 關(guān)于@運(yùn)算
    • 在Python中提供了一個(gè) @ 運(yùn)算，我們總是把他歸為算術(shù)運(yùn)算，實(shí)際這個(gè)運(yùn)算對(duì)內(nèi)置類型都沒(méi)有實(shí)現(xiàn)，但這個(gè)運(yùn)算符提供了Python的發(fā)展方向與期望的強(qiáng)項(xiàng)：數(shù)值計(jì)算。因?yàn)檫@個(gè)運(yùn)算是面向大學(xué)線性代數(shù)中的運(yùn)算：內(nèi)積運(yùn)算。
    • 該運(yùn)算方式在NumPy提供了實(shí)現(xiàn)。
import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
a @ b

32

關(guān)系運(yùn)算符號(hào)；

  1. 語(yǔ)法

    • 關(guān)系運(yùn)算是二目運(yùn)算
    • 運(yùn)算數(shù) 關(guān)系運(yùn)算符 運(yùn)算數(shù)

  2. 條件運(yùn)算的運(yùn)算符

    • < ：小于比較運(yùn)算
    • <= ：小于等于比較運(yùn)算
    • > ：大于比較運(yùn)算
    • >= ：大于等于比較運(yùn)算
    • == ：相等比較運(yùn)算
    • != ：不等比較運(yùn)算

  3. 返回的類型

    • 返回類型都是邏輯型。
print(45 < 50)
print(45 <= 50)
print(45 > 50)
print(45 >= 50)
print(45 == 50)
print(45 != 50)

True
True
False
False
False
True
  1. 運(yùn)算數(shù)的數(shù)據(jù)類型
  • 整數(shù)，小數(shù)，邏輯類型

    • 數(shù)值類型的比較容易理解

    • 數(shù)值類型包含True。

    • 注意：不支持復(fù)數(shù)的比較（這個(gè)符合我們高中的數(shù)學(xué)知識(shí)）

print(True > False)

True
  • 所以類型
    • 所有類型都支持 ： == 與 !=
    • 這兩個(gè)關(guān)系運(yùn)算符，在不同數(shù)據(jù)類型的實(shí)現(xiàn)的含義不同。
      • 對(duì)大部分對(duì)象而言，指的是兩個(gè)變量是否是同一個(gè)內(nèi)存空間。
      • 對(duì)數(shù)值類型而言，指的是內(nèi)容值是否相等。
      • 對(duì)數(shù)值類型而言，首先判斷類型是否相同，然后再判定值是否相同。（默認(rèn)實(shí)現(xiàn)：地址相等判定）
print((4 + 5J)==complex(4 , 5))
print((4 + 5J)!=(4 + 5J))


True
False

print([1,2,3] == [1, 2, 3])
print([1,2,3] == (1, 2, 3))

True
False

# 類型同，值同，但變量的內(nèi)存空間不同（地址不同）
a = {1, 2, 3}
b = set([1, 2, 3])
print('0X%X'%id(a), '0X%X'%id(b) )
print(a == b)


0X111655748 0X111E85AC8
True

# 另外一種對(duì)象相同，返回的不是邏輯類型，而是邏輯數(shù)組。
import numpy as np
a = np.array([1,2,3])
b = np.array([1,2,3])
print(a==b)

[ True  True  True]

# 地址相等
class A:
    pass

oa = A()
ob = A()
print(oa == ob)   # 判定的是地址相等

False
  • 序列類型
    • 按照字典排序比較，返回除相等外的第一個(gè)元素的比較結(jié)果。
    • 這種比較基本上沒(méi)有意義，如果想實(shí)現(xiàn)比較，需要自己實(shí)現(xiàn)。
print( [6,3,5] <= [6, 2, 5] )
print( [6,2,5] <= [6, 2, 5] )
print( [6,3,5] <= [6, 2, 5,] )
print( [6,2,5] <= [6, 2, 5, 0] )
print('hello' <= 'hEllo')    # 每個(gè)字符作為ASCII碼比較

False
True
False
True
False

邏輯運(yùn)算符號(hào)；

  1. 語(yǔ)法

    • 邏輯運(yùn)算有二目運(yùn)算，也有一目運(yùn)算
    • 二目運(yùn)算：運(yùn)算數(shù) 邏輯運(yùn)算符 運(yùn)算數(shù)
    • 一目運(yùn)算：邏輯運(yùn)算符 運(yùn)算數(shù)

  2. 邏輯運(yùn)算的運(yùn)算符

    • 二目運(yùn)算：and or
    • 一目運(yùn)算：not

  3. 邏輯運(yùn)算返回值

    • 返回：邏輯類型
print(True and False)
print(True or False)
print(not False)

False
True
True
  1. 邏輯運(yùn)算的數(shù)據(jù)類型
    • 實(shí)際上邏輯值是0與1兩個(gè)整數(shù)表示，在Python的邏輯運(yùn)算中，其他類型會(huì)自動(dòng)轉(zhuǎn)換為邏輯類型后，進(jìn)行邏輯運(yùn)算。
  • 整數(shù)的邏輯運(yùn)算
    • 所有整數(shù)當(dāng)成邏輯值處理（0：False，非0：True）
print(not -2)
print(not -0)
print(2 and -2)
print(2 or -2)
print(2 and False )
print(2 or False )

False
True
-2
2
False
2
  • 小數(shù)的邏輯運(yùn)算
    • 小數(shù)與整數(shù)一樣，也直接作為邏輯值使用（0：False，非0：True）
print(not 2.0 )
print(not 0.0 )
print(2.5 and -0.0)
print(1.8 or -2.3)
print(2.8 and False )
print(2.8 or False )

False
True
-0.0
1.8
False
2.8
  • 字符串的邏輯運(yùn)算
    • 字符串也當(dāng)成邏輯值處理：（''：False，非''：True）
print(not 'hello')
print(not '')
print('' and 'world')         #第一個(gè)為False，返回第一個(gè)
print('Hello' and 'world')         #第一個(gè)為True，返回第二個(gè)
print('hello' or 'world')     
# 為什么不直接返回True或者False。

False
True

world
hello
  • 列表的邏輯運(yùn)算
    • 列表也當(dāng)成邏輯值處理：（[]，()：False，非[]：True）
    • 元組(0)也是當(dāng)作False處理。這個(gè)與元組的語(yǔ)法有關(guān)。
print(not [] )
print(not [0] )
print([1, 2, 3] and -0.0)
print(1.8 or [1,2,3])
print(2.8 and [1,2,3] )
print('--------------')
print(not () )
print(not (0) )
print(not (0,2,3))
print((1, 2, 3) and -0.0)
print(1.8 or (1,2,3))
print(2.8 and (1,2,3) )

True
False
-0.0
1.8
[1, 2, 3]
--------------
True
True
False
-0.0
1.8
(1, 2, 3)
  • 字典與集合的邏輯運(yùn)算
    • 字典也當(dāng)成邏輯值處理：（{}：False，非{}：True）
print(not {})
print(not {0})
print({1, 2, 3} and -0.0)
print(1.8 or {1,2,3})
print(2.8 and {1,2,3} )

True
False
-0.0
1.8
{1, 2, 3}
  • 對(duì)象的邏輯運(yùn)算
    對(duì)象作為邏輯值使用：對(duì)象不存在None表示False，對(duì)象存在表示True
class  A:
    pass

a = A()
print(not a)
# 對(duì)象默認(rèn)為True

False
  • 無(wú)窮大與非數(shù)值，None的邏輯運(yùn)算
    • 無(wú)窮大與非數(shù)值默認(rèn)是True（因?yàn)榉?）
    • None當(dāng)作False使用。
nan = float('NaN')
inf = float('Inf')
n = None
print(not n)
print(not nan)   
print(not inf)

True
False
False
  • 在其他的一些實(shí)現(xiàn)中，也可能實(shí)現(xiàn)邏輯運(yùn)算發(fā)，其運(yùn)算規(guī)則需要看實(shí)現(xiàn)文檔。
import numpy as np
na = np.array([1,2,3])
print(na)
print(not na.all())   # 多值，產(chǎn)生歧義：ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

# ndarray數(shù)組對(duì)象，不能直接做邏輯值使用，需要做處理。

[1 2 3]
False

位運(yùn)算符號(hào)

  • 位運(yùn)算符分成兩類：
    • 位移運(yùn)算符：對(duì)數(shù)據(jù)的位進(jìn)行移動(dòng)，從而改變數(shù)據(jù)的值。
    • 位算術(shù)運(yùn)算符：對(duì)數(shù)據(jù)的位進(jìn)行且，或，異或，否運(yùn)算。

位移運(yùn)算符號(hào)

  1. 語(yǔ)法：

    • 位移運(yùn)算符是二目運(yùn)算符
    • 語(yǔ)法： 被位移數(shù) 位移運(yùn)算符 位移的位數(shù)

  2. 位移運(yùn)算的運(yùn)算符

    • << ：左移
    • >> ：右移
print(10<<2)
print(10>>2)
print(10<<1000)

40
2
107150860718626732094842504906000181056140481170553360744375038837035105112493612249319837881569585812759467291755314682518714528569231404359845775746985748039345677748242309854210746050623711418779541821530464749835819412673987675591655439460770629145711964776865421676604298316526243868372056680693760
  1. 運(yùn)算類型

    • 位移的位數(shù)必須是整數(shù)，不支持小數(shù)

    • 邏輯值可以當(dāng)成整數(shù)處理True當(dāng)成1，F(xiàn)alse當(dāng)成0

    • 被位移數(shù)也必須是整數(shù)

    • 因?yàn)槠渌麛?shù)據(jù)位移會(huì)破壞數(shù)據(jù)類型與數(shù)據(jù)結(jié)構(gòu)。

print(10<<True) 
# print(10<<2.0)   錯(cuò)誤
# print(2.0<<2)   錯(cuò)誤
print(True<<2)

20
4
  1. 返回類型
    • 位移返回類型與被位移的整數(shù)一樣的類型。

位算術(shù)運(yùn)算符號(hào)

  1. 語(yǔ)法

    • 位算術(shù)運(yùn)算符，也分成單目運(yùn)算與二目運(yùn)算：
    • 二目位算術(shù)運(yùn)算：整數(shù) 位運(yùn)算符 整數(shù)
    • 單目位算術(shù)運(yùn)算：整數(shù) 位運(yùn)算符

  2. 位算術(shù)運(yùn)算的運(yùn)算符

    • 單目運(yùn)算：
      • ~：每個(gè)位取反
    • 二目運(yùn)算：
      • &：每個(gè)位做且運(yùn)算（都是1，為1，否則為0）
      • | ：每個(gè)位做或運(yùn)算（一個(gè)為1，為1，否則為0）
      • ^：每個(gè)位做異或運(yùn)算（同為0，不同為1）
  1. 返回類型：
    • 返回的也是整數(shù)（可以當(dāng)邏輯值使用）
print(10 & 5)
print(10 | 5)
print(10 ^ 5)
print(~ 5)

0
15
15
-6
  1. 位運(yùn)算的經(jīng)典應(yīng)用
    • IP計(jì)算：IP地址是4字節(jié)整數(shù)，一般表示成數(shù)點(diǎn)格式：192.168.1.128
    • 顏色計(jì)算：顏色就是一個(gè)像素，在計(jì)算機(jī)種使用4字節(jié)整數(shù)表示（這是模擬全真色，還有其他格式），可以通過(guò)位運(yùn)算取出R，G，B，Alpha四個(gè)顏色分量。
r = 200
g = 100
b = 20
a = 255
print("把三原色+透明度合成一個(gè)像素：", r<< 24 | g << 16 | b << 8 | a)

把三原色+透明度合成一個(gè)像素： 3362002175

color = 3362002175
print('紅色：', color >> 24)
print('綠色：', color >> 16 & 255)
print('藍(lán)色：', color >> 8 & 255)
print('透明：', color & 255)

紅色： 200
綠色： 100
藍(lán)色： 20
透明： 255

field1 = 192
field2 = 168
field3 = 1
field4 = 128
print("表示IP地址的整數(shù)", field1<< 24 | field2 << 16 | field3 << 8 | field4)

表示IP地址的整數(shù) 3232235904

ip = 3232235904
field1 = ip >> 24 & 255
field2 = ip >> 16 & 255
field3 = ip >> 8 & 255
field4 = ip >> 0 & 255
print(F'IP地址數(shù)點(diǎn)格式：{field1}.{field2}.{field3}.{field4}')


IP地址數(shù)點(diǎn)格式：192.168.1.128

復(fù)合運(yùn)算符號(hào)；

  • 符合運(yùn)算指的是：=與前面某些運(yùn)算符號(hào)結(jié)合的運(yùn)算符號(hào)。有點(diǎn)人成為增值運(yùn)算；

  1. 語(yǔ)法：

    • 被運(yùn)算變量 符合運(yùn)算符 運(yùn)算數(shù)

  2. 復(fù)合運(yùn)算的運(yùn)算符號(hào)

    • += ：遞加

    • -= ：遞減

    • *= ：遞乘

    • /= ：遞除

    • //= ：遞整除

    • %= ：遞求余

    • **= ：遞冪

    • @= ：遞內(nèi)積（Python對(duì)內(nèi)置類型沒(méi)有實(shí)現(xiàn)）

    • &= ：遞位且

    • |= ：遞位或

    • ^= ：遞位異或

    • >>= ：遞右移

    • <<= ：遞左移

- **注意：** 符合運(yùn)算符號(hào)有一個(gè)顯著的特征：
    - 被運(yùn)算數(shù)必須是變量（因?yàn)?有賦值的含義，這個(gè)只對(duì)變量有效）。對(duì)數(shù)值無(wú)效。
  1. 復(fù)合運(yùn)算符的運(yùn)算說(shuō)明：
    • a +=2 效果上等價(jià)于 a = a + 2，其他依次類推。
    • 性能上復(fù)合運(yùn)算比對(duì)等的單一運(yùn)算要好（運(yùn)算量要少）。
i = 20
i += 20
# 3 += 20    # 錯(cuò)誤

其他運(yùn)算符號(hào)；

- ()：優(yōu)先級(jí)運(yùn)算，參數(shù)傳遞等。
- []：下標(biāo)運(yùn)算
- .：成員調(diào)用運(yùn)算
- in：列表元素判定運(yùn)算（使用與序列：tuple，list，string, set）
- is：判定兩個(gè)變量是否同一個(gè)內(nèi)存
- 值1  if   條件  else   值2：條件表達(dá)式運(yùn)算
- + -除了在二目運(yùn)算作為加減運(yùn)算，如果作為一目運(yùn)算表示取正與負(fù)

print(8 * (2 + 3 ))  # 改變優(yōu)先級(jí)
print((1,2,3,4)[1])    # 取列表中的第二個(gè)元素
import math
print(math.pi)     # 調(diào)用math模塊的成員：圓周率
print( 20 in [1 ,2, 3, 20, 4])
print( 20 in {1 ,2, 3, 20, 4})
print( 'name' in {'name':'Louis', 'age':20 })   # 對(duì)key判定
print( 20 in {'name':'Louis', 'age':20 })      # 不對(duì)value判定
print( 20 is '20')
print( 'ok' if 20>30 else 'not ok' )

a = 20
print(+a)
print(-a)

40
2
3.141592653589793
True
True
True
False
False
not ok
20
-20

表達(dá)式與運(yùn)算符號(hào)的優(yōu)先級(jí)；

  1. 運(yùn)算符可以多個(gè)連續(xù)使用，形成表達(dá)式。
1 + 3 * 2 / 5**2-10 % 3 == 1 +3 

False
  1. 表達(dá)式因?yàn)槭褂枚鄠€(gè)運(yùn)算符，每個(gè)運(yùn)算符存在運(yùn)算的優(yōu)先級(jí)情況。
    • 下面是運(yùn)算優(yōu)先級(jí)
運(yùn)算符說(shuō)明 Python運(yùn)算符 優(yōu)先級(jí)
'expression,...' 字符串轉(zhuǎn)換 24
{key:datum,...} 字典顯示 23
[expression,...] 列表顯示 22
(experession,...) 綁定或元組顯示 21
f(arguments...) 函數(shù)調(diào)用 20
索引運(yùn)算符 x[index]或x[index:index2[:index3]] 18、19
屬性訪問(wèn) x.attrbute 17
乘方 ** 16
按位取反 ~ 15
符號(hào)運(yùn)算符 +或- 14
乘、除 *、/、//、% 13
加、減 +、- 12
位移 >>、<< 11
按位與 & 10
按位異或 ^ 9
按位或 | 8
比較運(yùn)算符 ==、!=、>、>=、<、<= 7
is運(yùn)算符 is、is not 6
in運(yùn)算符 in、not in 5
邏輯非 not 4
邏輯與 and 3
邏輯或 or 2
  1. 定制運(yùn)算優(yōu)先級(jí)
    • 上面的優(yōu)先級(jí)是Python解釋器默認(rèn)優(yōu)先級(jí)。
    • 可以使用（）優(yōu)先級(jí)運(yùn)算符，改變上述運(yùn)算的優(yōu)先級(jí)。
(1 + 3) * 2 / (5**(2-10 % 3) ) == (1 + 3) 

False

下標(biāo)運(yùn)算

  • 下標(biāo)運(yùn)算主要在序列數(shù)據(jù)類型的運(yùn)算中使用，用來(lái)定位序列中的元素。

  • 語(yǔ)法：

    • 序列數(shù)據(jù)值[開(kāi)始位置：結(jié)束位置：步長(zhǎng)]；

    • 其中的位置從0開(kāi)始。

    • 下面是具體的使用方式。

  • 按照位置取列表中的值

v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print (v1[1])
print (v2[2])
print (v3[1])
# 修改值
# v1[1]=88   # 元組只取值，不賦值
v2[1]=88
# v3[1]='X'  # 字符串只取值，不賦值
print(v1)
print(v2)
print(v3)
# 釋放值
# del v1[1]    # 元組值不能修改
del v2[1]
# del v3[1]     # 字符串值不能修改
print(v2)

2
3
b
(1, 2, 3, 4, 5, 6, 7, 8)
[1, 88, 3, 4, 5, 6, 7, 8]
abcdefgh
[1, 3, 4, 5, 6, 7, 8]
  • 取區(qū)間的值
    • 區(qū)間使用的是[ ... )
v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print (v1[1:4])    # 不包含位置4
print (v2[1:4])
print (v3[1:4])

(2, 3, 4)
[2, 3, 4]
bcd
  • 指定步長(zhǎng)
v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print (v1[1:6:2])    # 不包含位置4
print (v2[1:6:2])
print (v3[1:6:2])
v2[1:6:2]= [77,88,99]   #長(zhǎng)度要匹配
print(v2)

(2, 4, 6)
[2, 4, 6]
bdf
[1, 77, 3, 88, 5, 99, 7, 8]
  • 負(fù)值的使用
    • 其中的開(kāi)始位置，結(jié)束位置，步長(zhǎng)都可以取負(fù)值，負(fù)值表示位置計(jì)算從結(jié)束位置開(kāi)始
v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print(v1[-1])

print(v1[-5:-1])    # 從倒數(shù)第5個(gè)，到倒數(shù)第1個(gè)
print(v1[-1:-5:-1])   # 從倒數(shù)第1個(gè)，到倒數(shù)第5個(gè)。反序。

8
(4, 5, 6, 7)
(8, 7, 6, 5)
  • 下標(biāo)中的默認(rèn)值
    • 下標(biāo)中每一個(gè)值可以使用默認(rèn)值
v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
#print(v1[])   # 必須要一個(gè)值

print(v1[:])    # 開(kāi)始位置，默認(rèn)是0，結(jié)束位置默認(rèn)是-1的下一個(gè)。
print(v1[::])   # 步長(zhǎng)默認(rèn)是1。

print(v1[2:])    # 開(kāi)始位置，默認(rèn)是0，結(jié)束位置默認(rèn)是-1的下一個(gè)。
print(v1[:3:])   # 步長(zhǎng)默認(rèn)是1。


print(v1[::2])   # 步長(zhǎng)默認(rèn)是1。
print(v1[::-1])   # 步長(zhǎng)默認(rèn)是1。

(1, 2, 3, 4, 5, 6, 7, 8)
(1, 2, 3, 4, 5, 6, 7, 8)
(3, 4, 5, 6, 7, 8)
(1, 2, 3)
(1, 3, 5, 7)
(8, 7, 6, 5, 4, 3, 2, 1)

成員調(diào)用符號(hào)

  • 運(yùn)算符. 有兩個(gè)使用場(chǎng)景

    • . 用于包與模塊的路徑。
    • .用于對(duì)象的成員調(diào)用。

  • 語(yǔ)法：

    • 包.包
    • 包.模塊
    • 模塊.類或者模塊.函數(shù)或者模塊.變量
    • 對(duì)象 .成員
import math
print(math.pi)
print(math.sin(math.pi/60))

3.141592653589793
0.05233595624294383

from datetime import  *
dt = date.today()
print(dt.year)
print(dt.month)
print(dt.day)

2019
3
6

函數(shù)調(diào)用符號(hào)；

- 語(yǔ)法
    返回值變量 =  函數(shù)名(參數(shù)，參數(shù)，參數(shù) ，......)

from math import *
print(sin(3.14159262/6))

0.49999999515173094

程序流程控制的語(yǔ)法與流程控制過(guò)程

  • 程序的執(zhí)行是按照代碼的先后執(zhí)行的（線性性），需要的時(shí)候，可以改變程序執(zhí)行的流程，我們稱為流程控制。
  • 常規(guī)來(lái)說(shuō)，在語(yǔ)言層面可以控制程序的流程提供兩種改變方式：
    • 執(zhí)行還是不執(zhí)行：根據(jù)條件選在是否執(zhí)行，我們稱為條件控制
    • 反復(fù)執(zhí)行：根據(jù)條件反復(fù)執(zhí)行指定的代碼。我們稱為循環(huán)控制
      • 循環(huán)的結(jié)束，我們稱為中斷控制。
  • 條件控制與循環(huán)控制的語(yǔ)法：

    • 使用是塊的方式控制,語(yǔ)法：-塊頭 + 塊體

    • 塊頭：每種類型的塊頭都不一樣。

    • 塊體：由代碼構(gòu)成，所有代碼縮行數(shù)相同的代碼都是同一個(gè)塊體。直到縮行數(shù)不同，表示當(dāng)前塊結(jié)束，另外一個(gè)塊開(kāi)始。

    • 注意：默認(rèn)Python程序有一個(gè)頂層塊，頂層塊是不用縮行的。

掌握條件控制的語(yǔ)法-if；

  1. 語(yǔ)法一：一個(gè)塊構(gòu)成
    • 條件控制頭 ：if 邏輯值 ：
    • 說(shuō)明：條件為真，塊得到執(zhí)行。條件為假，塊不會(huì)執(zhí)行。
if  True :
    print('被執(zhí)行---1')
    print('被執(zhí)行---2')

被執(zhí)行---1
被執(zhí)行---2

if False : # 不會(huì)被執(zhí)行
print('被執(zhí)行---1')
print('被執(zhí)行---2')

  1. 語(yǔ)法二：兩個(gè)塊構(gòu)成
    if 邏輯值 :
        語(yǔ)句
         ...
    else:
        語(yǔ)句
        ....

  • 說(shuō)明：

    • else塊不能單獨(dú)使用，必須與if塊一起使用。if塊可以不使用else塊。
    • 當(dāng)if為假執(zhí)行else的塊，真就執(zhí)行if的塊。
if  True :
    print('被執(zhí)行---1')
    print('被執(zhí)行---2')
else:
    print('被執(zhí)行---其他1')
    print('被執(zhí)行---其他2')

被執(zhí)行---1
被執(zhí)行---2

if  False:
    print('被執(zhí)行---1')
    print('被執(zhí)行---2')
else:
    print('被執(zhí)行---其他1')
    print('被執(zhí)行---其他2')

被執(zhí)行---其他1
被執(zhí)行---其他2
  1. 語(yǔ)法三：
if 邏輯值:
    語(yǔ)句
     ...
elif 邏輯值:
    語(yǔ)句
    ...
elif 邏輯值:
    語(yǔ)句
    ...
...


a = 80
if a==100:
    print('滿分')
elif a >=90:
    print('優(yōu)秀')
elif a >=80:
    print('良')    
elif a >=70:
    print('中')
elif a >=60:
    print('及格')
elif a<60:
    print('不及格')

良
  1. 語(yǔ)法四：
if 邏輯值:
    語(yǔ)句
     ...
elif 邏輯值:
    語(yǔ)句
    ...
elif 邏輯值:
    語(yǔ)句
    ...
else:
    ...


a = 40
if a==100:
    print('滿分')
elif a >=90:
    print('優(yōu)秀')
elif a >=80:
    print('良')    
elif a >=70:
    print('中')
elif a >=60:
    print('及格')
else:
    print('不及格')

不及格

掌握條件控制的應(yīng)用-if；

??除了直接使用邏輯值，還可以使用如下形式的邏輯值，會(huì)自動(dòng)轉(zhuǎn)換。

  1. 使用關(guān)系運(yùn)算
    • 因?yàn)殛P(guān)系運(yùn)算直接返回邏輯值
a = input('輸入選擇 (ok： 接受，其他：不接受) ')
if a == 'ok':
    print('你選擇了接受！')
else:
    print('你選擇了拒絕！')

輸入選擇 (ok： 接受，其他：不接受) ok
你選擇了接受！
  1. 直接使用數(shù)值，對(duì)象作為條件
    • 這些數(shù)值對(duì)象可以直接轉(zhuǎn)換為邏輯條件
a = input('輸入選擇 (任何輸入： 接受，不輸入：不接受) ')
if a :
    print('你選擇了接受！')
else:
    print('你選擇了拒絕！')

輸入選擇 (任何輸入： 接受，不輸入：不接受) 
你選擇了拒絕！

a =(1,2,3,4)
if a :
    print('你選擇了接受！')
else:
    print('你選擇了拒絕！')

你選擇了接受！

a = 20
if a :
    print('你選擇了接受！')
else:
    print('你選擇了拒絕！')

你選擇了接受！
  • 使用in，is等運(yùn)算符
a = input('輸入選擇 (只能選擇1，2，3，4) ')
if type(a) is str:
    print('輸入的是str')
else:
    print('輸入的是非str')

輸入選擇 (只能選擇1，2，3，4) 1
輸入的是str

a = input('輸入選擇 (只能選擇1，2，3，4) ')
if a in ('1' , '2', '3', '4'):
    print('選擇正確')
else:
    print('選擇不對(duì)')

輸入選擇 (只能選擇1，2，3，4) 1
選擇正確
  • 使用not改變條件
a = input('輸入選擇 (只能選擇1，2，3，4) ')
print(a)
if a not in ('1' , '2', '3', '4'):
    print('選擇不對(duì)')
else:
    print('選擇正確')

輸入選擇 (只能選擇1，2，3，4) 1
1
選擇正確

a = input('輸入選擇 (只能選擇1，2，3，4) ')
print(a)
if not a in ('1' , '2', '3', '4'):
    print('選擇不對(duì)')
else:
    print('選擇正確')

輸入選擇 (只能選擇1，2，3，4) 4
4
選擇正確

掌握循環(huán)控制的語(yǔ)法-while；

??while用來(lái)對(duì)塊中代碼循環(huán)執(zhí)行。

  1. 語(yǔ)法一：
    while  邏輯值:
        語(yǔ)句
        ...
  • 注意：

    • 邏輯值為True，就執(zhí)行塊，塊執(zhí)行完畢，再重新回到while，繼續(xù)判定邏輯值是否為True。

    • 邏輯值為False，塊就不執(zhí)行。

    • 與if的差別在于：

      • if執(zhí)行完塊，就繼續(xù)執(zhí)行。
      • while執(zhí)行完塊，會(huì)回到while處繼續(xù)判定。
i = 10 
while I:
    print(i)
    
    i -= 1

10
9
8
7
6
5
4
3
2
1
  1. 語(yǔ)法二：

while 邏輯值:
    語(yǔ)句
    ....
else:
    語(yǔ)句
    ....
  • 當(dāng)while的條件為False，else會(huì)得到執(zhí)行。
  • 說(shuō)明：
    • while支持else，但不支持與elif塊配合。
i = 10 
while i != 0:
    print(i)
    
    i -= 1
else:
    print('循環(huán)沒(méi)有執(zhí)行了')

10
9
8
7
6
5
4
3
2
1
循環(huán)沒(méi)有執(zhí)行了

掌握循環(huán)控制的應(yīng)用-while；

  1. while中的條件使用其他非邏輯值
i = 10 
while I:
    print(i)
    
    i -= 1
else:
    print('循環(huán)沒(méi)有執(zhí)行了')

10
9
8
7
6
5
4
3
2
1
循環(huán)沒(méi)有執(zhí)行了
  1. while中只有一個(gè)語(yǔ)句行
    • 如果一行，可以在while于else后面直接寫語(yǔ)句
    • 為了在一行上，編寫多個(gè)語(yǔ)句，可以使用；分隔。
i = 10 
while i:print(i);i -= 1
else:print('循環(huán)沒(méi)有執(zhí)行了')

10
9
8
7
6
5
4
3
2
1
循環(huán)沒(méi)有執(zhí)行了

# 只有一行才能在while后面直接寫，多行不行。
i = 10 
while i:print(i)
    i -= 1
else:print('循環(huán)沒(méi)有執(zhí)行了')

  File "<ipython-input-19-db0f5eefeb21>", line 4
    i -= 1
    ^
IndentationError: unexpected indent
  1. 避免陷入死循環(huán)
    • 需要使用變量來(lái)控制while后的條件改變，并有機(jī)會(huì)得到True的值。
    • 一般為了避免while死循環(huán)，有如下編程套路
      • 在while外面定義一個(gè)變量，并設(shè)置一個(gè)初始值
      • 在while的邏輯值處，就是用該變量產(chǎn)生。
      • 在while內(nèi)部，根據(jù)情況，改變變量，需要退出，就讓變量的值改變，以至于使得while邏輯值處的條件得到False的結(jié)果。
i = 0
while i <=10 :
    print(i)
    i += 1

0
1
2
3
4
5
6
7
8
9
10

掌握循環(huán)控制的語(yǔ)法-for；

  • for是專門對(duì)列表與字段等可以迭代的數(shù)據(jù)設(shè)計(jì)的專用循環(huán)語(yǔ)句。
  1. 語(yǔ)法一：
for  標(biāo)識(shí)字  in  序列數(shù)據(jù):
    語(yǔ)句
    ......
  • for執(zhí)行流程說(shuō)明：
    • for語(yǔ)句每次會(huì)從序列數(shù)據(jù)開(kāi)始位置取一個(gè)值，并使用標(biāo)識(shí)字定義各一個(gè)標(biāo)量，把取出的值存入變量，然后執(zhí)行塊中語(yǔ)句。
    • 當(dāng)塊語(yǔ)句執(zhí)行完畢，會(huì)回到for位置，并取第二個(gè)值放入定義的變量，然后重復(fù)執(zhí)行塊中語(yǔ)句；
    • ....
    • 直到序列數(shù)據(jù)中數(shù)據(jù)都取玩位置，直接跳出塊執(zhí)行。
# 循環(huán)list
for  d in [1,2,3,4]:
    print(d)

1
2
3
4

# 循環(huán)字符串
for  d in 'abcdefg':
    print(d)

a
b
c
d
e
f
g

# 循環(huán)元組
for  d in (1,2,3,4):
    print(d)

# 元組的另外表示
for  d in 1,2,3,4:
    print(d)

1
2
3
4
1
2
3
4

# 循環(huán)集合
for  d in {1,2,3,4}:
    print(d)

1
2
3
4

# 循環(huán)字典
for  d in {'name': 'louis','age':18}:
    print(d)

name
age

# 循環(huán)呢字典的值
v = {'name': 'louis','age':18}
for  d in v:
    print(d, v[d], sep=':')

name:louis
age:18
  1. for語(yǔ)法二：

for 變量 in 序列:
    語(yǔ)句
    ......
else:
    語(yǔ)句
    ......
  • 說(shuō)明：
    • 當(dāng)列表循環(huán)完畢后，else得到執(zhí)行。
# 循環(huán)list
for  d in [1,2,3,4]:
    print(d)
else:
    print('循環(huán)結(jié)束。')

1
2
3
4
循環(huán)結(jié)束。

掌握循環(huán)控制的應(yīng)用-for；

  1. 使用range創(chuàng)建序列
    • Python提供了一個(gè)函數(shù)，用來(lái)創(chuàng)建序列。
 | -  range(stop) -> range object
 | -  range(start, stop[, step]) -> range object

# 創(chuàng)建序列范圍： [ 0 - 4 )
for v in range(4):
    print(v)

0
1
2
3

# 創(chuàng)建序列范圍： [ start - end )
for v in range(1, 5):
    print(v)

1
2
3
4

# 創(chuàng)建序列范圍： [ start - end ), step = 2
for v in range(1, 5, 2):
    print(v)

1
3

掌握循環(huán)中斷控制語(yǔ)法-continue與break；

??為了結(jié)束循環(huán)，目前只有等到每次循環(huán)結(jié)束，重新判定循環(huán)條件。Python語(yǔ)言提供了在循環(huán)中，可以直接結(jié)束循環(huán)的語(yǔ)法，使用特殊的語(yǔ)句完成。

break與continue的理解與使用

  1. 中斷循環(huán)的兩種方式：

    • 直接結(jié)束循環(huán)
    • 結(jié)束當(dāng)前次循環(huán)后面代碼的執(zhí)行，重新開(kāi)始循環(huán)的條件判別。

  2. 循環(huán)的中斷的語(yǔ)法：

    • break ：直接結(jié)束循環(huán)；
    • continue ：結(jié)束當(dāng)前循環(huán)；

  3. 注意：中斷語(yǔ)句只能用于循環(huán)：for與while，不能用于其他塊中。

# break的使用
for  v in range(5):
    print(v)
    break
    print('break后')

0

# continue的使用
for  v in range(5):
    print(v)
    continue
    print('break后')

0
1
2
3
4

在多重循環(huán)中使用break與continue

??Python的中斷語(yǔ)句與其他語(yǔ)言有些差異，不提供標(biāo)簽，用來(lái)中斷到指定位置。
??對(duì)于多重循環(huán)來(lái)說(shuō)，中斷只影響到最近的循環(huán)，對(duì)外層循環(huán)沒(méi)有影響，需要單獨(dú)寫代碼使用中斷繼續(xù)中斷。

# continue的在多層循環(huán)中使用
for y in range(3):
    print('外層:', y)
    for x in range(3):
        print('\t內(nèi)層:', x)
        continue
        print('\t內(nèi)層后')
    print('外層后')
        

外層: 0
    內(nèi)層: 0
    內(nèi)層: 1
    內(nèi)層: 2
外層后
外層: 1
    內(nèi)層: 0
    內(nèi)層: 1
    內(nèi)層: 2
外層后
外層: 2
    內(nèi)層: 0
    內(nèi)層: 1
    內(nèi)層: 2
外層后

for y in range(3):
    print('外層:', y)
    for x in range(3):
        print('\t內(nèi)層:', x)
        break
        print('\t內(nèi)層后')
    print('外層后')

外層: 0
    內(nèi)層: 0
外層后
外層: 1
    內(nèi)層: 0
外層后
外層: 2
    內(nèi)層: 0
外層后

了解其他流程控制語(yǔ)法；

  • 其他影響流程執(zhí)行的方式還有：
      1. 結(jié)束程序：
    sys.exit(狀態(tài)碼)
      1. 結(jié)束函數(shù)模塊
    return 值
      1. 對(duì)象自動(dòng)釋放
    with   ...  :
    語(yǔ)句
    ...
      1. 異常發(fā)生
    try:
    語(yǔ)句
    ......
catch ...: :
    語(yǔ)句
    ....
finally:
    語(yǔ)句
    ......

階段應(yīng)用實(shí)戰(zhàn)

  1. 任務(wù)描述
    • 使用循環(huán)與條件實(shí)現(xiàn)集合圖形的輸出
    • 使用循環(huán)與條件實(shí)現(xiàn)反復(fù)輸入，直到滿足條件才結(jié)束輸入。
    • 顯示系統(tǒng)某個(gè)目錄下的文件列表
  2. 關(guān)聯(lián)知識(shí)點(diǎn)：
    • 變量定義
    • 輸入語(yǔ)句
    • 輸出語(yǔ)句
    • 類型轉(zhuǎn)換
    • 數(shù)據(jù)運(yùn)算（算術(shù)、比較、邏輯計(jì)算等）
    • 循環(huán)控制
    • 條件控制
    • 循環(huán)中斷控制
    • 數(shù)學(xué)思維方式

綜合應(yīng)用實(shí)戰(zhàn)

  1. 實(shí)現(xiàn)一個(gè)錄入模塊，提示是否繼續(xù)錄入，根據(jù)選擇，來(lái)決定繼續(xù)錄入，還是退出錄入。

  2. 實(shí)現(xiàn)股票歷史數(shù)據(jù)反復(fù)查詢，并顯示多條歷史數(shù)據(jù)。


    查詢系統(tǒng)的界面要求

思考題目

  1. 判定下面語(yǔ)法是否正確
a = 1
b = 2
a++b
a++++++++b

3
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書(shū)系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

友情鏈接更多精彩內(nèi)容