什麼是計算機語言

計算機就是一臺用來計算的機器，人讓計算機幹什麼計算機就得幹什麼！
需要通過計算機的語言來控制計算機（程式語言）！
計算機語言其實和人類的語言沒有本質的區別，不同點就是交流的主體不同！
計算機語言發展經歷了三個階段：
    機器語言
        - 機器語言通過二進位制編碼來編寫程式
        - 執行效率好，編寫起來太麻煩

    符號語言（彙編）
        - 使用符號來代替機器碼
        - 編寫程式時，不需要使用二進位制，而是直接編寫符號
        - 編寫完成後，需要將符號轉換為機器碼，然後再由計算機執行
            符號轉換為機器碼的過程稱為彙編
        - 將機器碼轉換為符號的過程，稱為反彙編
        - 組合語言一般只適用於某些硬體，相容性比較差

    高階語言
        - 高階語言的語法基本和現在英語語法類似，並且和硬體的關係沒有那麼緊密了
        - 也就是說我們通過高階語言開發程式可以在不同的硬體系統中執行
        - 並且高階語言學習起來也更加的容易，現在我們知道的語言基本都是高階語言
        - C、C++、C#、Java、JavaScript、Python 。。。
 

編譯型語言和解釋型語言

計算機只能識別二進位制編碼（機器碼），所以任何的語言在交由計算機執行時必須要先轉換為機器碼，
    也就是像 print('hello') 必需要轉換為類似 1010101 這樣的機器碼

根據轉換時機的不同，語言分成了兩大類：
    編譯型語言
        - C語言
        - 編譯型語言，會在程式碼執行前將程式碼編譯為機器碼，然後將機器碼交由計算機執行
        - a(原始碼) --編譯--> b(編譯後的機器碼)
        - 特點：
            執行速度特別快
            跨平臺性比較差

    解釋型語言
        - Python JS Java
        - 解釋型語言，不會在執行前對程式碼進行編譯，而是在執行的同時一邊執行一邊編譯
        - a（原始碼）--直譯器--> 解釋執行
        - 特點：
            執行速度比較慢
            跨平臺性比較好
 

Python的介紹

Python是解釋型語言

Python（英國發音：/ˈpaɪθən/ 美國發音：/ˈpaɪθɑːn/），是一種廣泛使用的高階程式語言，屬於通用型程式語言，由吉多·範羅蘇姆創造，第一版釋出於1991年。可以視之為一種改良（加入一些其他程式語言的優點，如面向物件）的LISP。作為一種解釋型語言，Python的設計哲學強調程式碼的可讀性和簡潔的語法（尤其是使用空格縮排劃分程式碼塊，而非使用大括號或者關鍵詞）。相比於C++或Java，Python讓開發者能夠用更少的程式碼表達想法。不管是小型還是大型程式，該語言都試圖讓程式的結構清晰明瞭。

Life is short you need Python （人生短暫，我用Python）

Python的用途：
    WEB應用
        Facebook 豆瓣 。。。
    爬蟲程式
    科學計算
    自動化運維
    大資料（資料清洗）
    雲端計算
    桌面軟體/遊戲
    人工智慧
    。。。
 

Python開發環境搭建

開發環境搭建就是安裝Python的直譯器
Python的直譯器分類：
    CPython（官方）
        用c語言編寫的Python直譯器
    PyPy
        用Python語言編寫的Python直譯器
    IronPython
        用.net編寫的Python直譯器
    Jython
        用Java編寫的Python直譯器

步驟：
    1.下載安裝包 python-3.9.6.exe
        - 3.x
        - 2.x
    2.安裝（傻瓜式安裝）
    3.開啟命令列視窗，輸入python 出現如下內容
	Python 3.9.6 (tags/v3.9.6:db3ff76, Jun 28 2021, 15:26:21) [MSC v.1929 64 bit (AMD64)] on win32
	Type "help", "copyright", "credits" or "license" for more information.
	>>>

Python的互動介面

當我們通過命令列來輸入Python，所進入到的介面就是Python的互動介面
結構：
    版本和版權宣告：
	Python 3.9.6 (tags/v3.9.6:db3ff76, Jun 28 2021, 15:26:21) [MSC v.1929 64 bit (AMD64)] on win32
	Type "help", "copyright", "credits" or "license" for more information.

	命令提示符：
	>>>

    在命令提示符後可以直接輸入Python的指令！輸入完的指令將會被Python的直譯器立即執行！

    安裝Python的同時，會自動安裝一個Python的開發工具IDLE，通過IDLE也可以進入到互動模式
    但是不同的是，在IDLE中可以通過TAB鍵來檢視語句的提示。
    IDLE實際上就是一個互動介面，但是他可以有一些簡單的提示，並且可以將程式碼儲存

互動模式只能你輸入一行程式碼，它就是執行一行，所以他並不適用於我們日常的開發！
    僅可以用來做一些日常的簡單的測試！

我們一般會將Python程式碼編寫到一個py檔案中，然後通過python指令來執行檔案中的程式碼

練習：
    自己嘗試建立一個py檔案，並向檔案中寫入python列印語句（print...）
        然後執行該檔案。
    如果你的系統的副檔名無法修改，請嘗試自行baidu！

print('hello','哈哈','abc')
print(123)
print('bcd')

a = 20
print(a)

Python和Sublime的整合

1.在Sublime中執行Python程式碼，ctrl + b 自動在Sublime內建的控制檯中執行
    這種執行方式，在某些版本的Sublime中對中文支援不好，並且不能使用input()函式

2.使用SublimeREPL來執行python程式碼
    安裝完成，設定快捷鍵，希望按f5則自動執行當前的Python程式碼，在下圖位置貼上如下程式碼
    { "keys": ["f5"], "caption": "SublimeREPL:Python","command": "run_existing_window_command", "args":{"id": "repl_python_run","file": "config/Python/Main.sublime-menu"}},

幾個概念

1.表示式
    表示式就是一個類似於數學公式的東西
    比如：10 + 5   8 - 4
    表示式一般僅僅用了計算一些結果，不會對程式產生實質性的影響
    如果在互動模式中輸入一個表示式，直譯器會自動將表示式的結果輸出

2.語句
    在程式中語句一般需要完成某種功能，比如列印資訊、獲取資訊、為變數賦值。。。
    比如：
        print()
        input()
        a = 10
    語句的執行一般會對程式產生一定的影響
    在互動模式中不一定會輸出語句的執行結果

3.程式（program）
    程式就是由一條一條的語句和一條一條的表示式構成的。

4.函式（function）
    函式就是一種語句，函式專門用來完成特定的功能
    函式長的形如：xxx()
    函式的分類：
        內建函式
            - 由Python直譯器提供的函式，可以在Python中直接使用
        自定義函式
            - 由程式設計師自主的建立的函式
    當我們需要完成某個功能時，就可以去呼叫內建函式，或者自定義函式。
    函式的兩個要素：
        引數
            - ()中的內容就是函式的引數
            - 函式中可以沒有引數，也可以有多個引數，多個引數之間使用,隔開
        返回值
            - 返回值是函式的返回結果，不是所有的函式都有返回值

基本語法

1.在Python中嚴格區分大小寫
2.Python中的每一行就是一條語句，每條語句以換行結束
3.Python中每一行語句不要過長（規範中建議每行不要超過80個字元）
    "rulers":[80],
4.一條語句可以分多行編寫，多行編寫時語句後邊以\結尾
5.Python是縮排嚴格的語言，所以在Python中不要隨便寫縮排即空格
6.在Python中使用#來表示註釋，#後的內容都屬於註釋，註釋的內容將會被直譯器所忽略
    我們可以通過註釋來對程式進行解釋說明，一定要養成良好的編寫註釋的習慣
    註釋要求簡單明瞭，一般習慣上#後邊會跟著一個空格

print('he\
aaa\
aaa')

# 這是一個列印語句，請你看見了不要慌張
# 這是一個註釋
# 註釋會被直譯器所忽略
# print(123+456) 這行程式碼被註釋了，將不會執行
print('abc') # 這是一個單行註釋

字面量和變數

字面量就是一個一個的值，比如：1，2，3，4，5，6，‘HELLO’
    字面量所表示的意思就是它的字面的值，在程式中可以直接使用字面量

變數（variable）變數可以用來儲存字面量，並且變數中儲存的字面量是不定的
    變數本身沒有任何意思，它會根據不同的字面量表示不同的意思

一般我們在開發時，很少直接使用字面量，都是將字面量儲存到變數中，通過變數來引用字面量

變數和識別符號

# Python中使用變數，不需要宣告，直接為變數賦值即可
a = 10

# 不能使用沒有進行過賦值的變數
# 如果使用沒有賦值過的變數，會報錯 NameError: name 'b' is not defined
# print(b)

# Python是一個動態型別的語言，可以為變數賦任意型別的值，也可以任意修改變數的值
a = 'hello'

# print(a)

# 識別符號
# 在Python中所有可以自主命名的內容都屬於識別符號
# 比如：變數名、函式名、類名
# 識別符號必須遵循識別符號的規範
#   1.識別符號中可以含有字母、數字、_，但是不能使用數字開頭
#       例子：a_1 _a1 _1a
#   2.識別符號不能是Python中的關鍵字和保留字
#       也不建議使用Python中的函式名作為識別符號,因為這樣會導致函式被覆蓋
#   3.命名規範：
#       在Python中注意遵循兩種命名規範：
#           下劃線命名法
#               所有字母小寫，單詞之間使用_分割
#               max_length min_length hello_world xxx_yyy_zzz
#           帕斯卡命名法（大駝峰命名法）
#               首字母大寫，每個單詞開頭字母大寫，其餘字母小寫
#               MaxLength MinLength HelloWorld XxxYyyZzz
#
#   如果使用不符合標準的識別符號，將會報錯 SyntaxError: invalid syntax
#   練習：嘗試自己定義幾個變數（複雜一些，嘗試不同的命名法），然後列印一些變數
#           通過搜尋引擎搜尋還有哪些其他的命名規範
_b123 = 20
# print(_b123)

# print = 123
# print(print)

資料型別

資料型別指的就是變數的值得型別，也就是可以為變數賦哪些值
數值
    整型
        布林值
    浮點型
    複數
字串
空值

數值

# 在Python數值分成了三種：整數、浮點數（小數）、複數
# 在Python中所有的整數都是int型別
a = 10
b = 20
# Python中的整數的大小沒有限制，可以是一個無限大的整數
# c = 999999999999999999999999999999999999999999999 ** 100

# 如果數字的長度過大，可以使用下劃線作為分隔符
c = 123_456_789

# d = 0123 10進位制的數字不能以0開頭
# 其他進位制的整數，只要是數字列印時一定是以十進位制的形式顯示的
# 二進位制 0b開頭
c = 0b10 # 二進位制的10
# 八進位制 0o開頭
c = 0o10
# 十六進位制 0x開頭
c = 0x10

# 也可以通過運算子來對數字進行運算，並且可以保證整數運算的精確
c = -100
c = c + 3

# 浮點數（小數），在Python中所有的小數都是float型別
c = 1.23
c = 4.56

# 對浮點數進行運算時，可能會得到一個不精確的結果
c = 0.1 + 0.2 # 0.30000000000000004

print(c)

字串

# 字串(str)
# 字串用來表示一段文字資訊，字串是程式中使用的最多的資料型別
# 在Python中字串需要使用引號引起來

s = 'hello'
# s = abc # 字串必須使用引號引起來，不使用不是字串
# 引號可以是雙引號，也可以是單引號，但是注意不要混著用
s = 'hello'
s = "hello"
# s = 'hello" 引號不能混合使用  SyntaxError: EOL while scanning string literal

# 相同的引號之間不能巢狀
# s = "子曰:"學而時習之，樂呵樂呵！""
s = '子曰:"學而時習之，樂呵樂呵！"'

# 長字串
# 單引號和雙引號不能跨行使用
s = '鋤禾日當午，\
汗滴禾下土，\
誰知盤中餐，\
粒粒皆辛苦'

# 使用三重引號來表示一個長字串 ''' """
# 三重引號可以換行，並且會保留字串中的格式

s = '''鋤禾日當午，
汗滴禾下土，
誰知盤中餐，
粒粒皆辛苦'''

# 轉義字元
# 可以使用 \ 作為轉義字元，通過轉義字元，可以在字串中使用一些特殊的內容
# 例子：
#   \' 表示 '
#   \" 表示 "
#   \t 表示 製表符
#   \n 表示 換行符
#   \\ 表示 反斜槓\
#   \uxxxx  表示Unicode編碼
s = "子曰:\"學而時習之，\\\\n樂呵樂呵！\""

s = '\u2250'
print(s)

格式化字串

# 格式化字串
a = 'hello'

# 字串之間也可以進行加法運算
# 如果將兩個字串進行相加，則會自動將兩個字串拼接為一個
a = 'abc' + 'haha' + '哈哈'
# a = 123 
# 字串只能不能和其他的型別進行加法運算，如果做了會出現異常 TypeError: must be str, not int
# print("a = "+a) # 這種寫法在Python中不常見
a = 123
# print('a =',a)

# 在建立字串時，可以在字串中指定佔位符
# %s 在字串中表示任意字元
# %f 浮點數佔位符
# %d 整數佔位符
b = 'Hello %s'%'孫悟空'
b = 'hello %s 你好 %s'%('tom','孫悟空')
b = 'hello %3.5s'%'abcdefg' # %3.5s字串的長度限制在3-5之間
b = 'hello %s'%123.456
b = 'hello %.2f'%123.456
b = 'hello %d'%123.95
b = '呵呵'

# print('a = %s'%a)

# 格式化字串，可以通過在字串前新增一個f來建立一個格式化字串
# 在格式化字串中可以直接嵌入變數
c = f'hello {a} {b}'

print(f'c = {c}')

# 練習 建立一個變數儲存你的名字，然後通過四種格式化字串的方式
#   在命令列中顯示，歡迎 xxx 光臨！
sun_name = '%s'%'孫小夥'
print('① '+'hello '+ sun_name +' 光臨')
print('②','hello',sun_name,'光臨')
print('③ hello %s 光臨'%sun_name)
sun = f'④ hello {sun_name} 光臨'
print(f'{sun}')

複製字串

# 建立一個變數來儲存你的名字
name = '孫悟空'

# 使用四種方式來輸出，歡迎 xxx 光臨
# 拼串
print('歡迎 '+name+' 光臨！')
# 多個引數
print('歡迎',name,'光臨！')
# 佔位符
print('歡迎 %s 光臨！'%name)
# 格式化字串
print(f'歡迎 {name} 光臨！')

# 字串的複製（將字串和數字相乘）
a = 'abc'
# * 在語言中表示乘法
# 如果將字串和數字相乘，則直譯器會將字串重複指定的次數並返回
a = a * 20

print(a)

布林值和空值

# 布林值（bool）
# 布林值主要用來做邏輯判斷
# 布林值一共有兩個 True 和 False
# True表示真 False表示假
a = True
a = False
# print('a =',a)

# 布林值實際上也屬於整型，True就相當於1，False就相當於0
# print(1 + False)

# None（空值）
# None專門用來表示不存在
b = None
print(b)

型別檢查

# 通過型別檢查，可以檢查指定值（變數）的型別

a = 123 # 數值
b = '123' # 字串

# print('a =',a)
# print('b =',b)

# type()用來檢查值的型別
# 該函式會將檢查的結果作為返回值返回，可以通過變數來接收函式的返回值
c = type('123')
c = type(a)
# print(type(b))
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello'))  # <class 'str'>
print(type(None)) # <class 'NoneType'>

物件（object）

- Python是一門面向物件的語言
- 一切皆物件！
- 程式運行當中，所有的資料都是儲存到記憶體當中然後再執行的！
- 物件就是記憶體中專門用來儲存指定資料的一塊區域
- 物件實際上就是一個容器，專門用來儲存資料
- 像我們之前學習的數值、字串、布林值、None都是物件
- 參考 下圖

物件的結構

- 每個物件中都要儲存三種資料
    - id（標識）
        > id用來標識物件的唯一性，每一個物件都有唯一的id
        > 物件的id就相當於人的身份證號一樣
        > 可以通過id()函式來檢視物件的id
        > id是由解析器生成的，在CPython中，id就是物件的記憶體地址
        > 物件一旦建立，則它的id永遠不能再改變

    - type（型別）
        > 型別用來標識當前物件所屬的型別
        > 比如：int str float bool 。。。
        > 型別決定了物件有哪些功能
        > 通過type()函式來檢視物件的型別
        > Python是一門強型別的語言，物件一旦建立型別便不能修改


    - value（值）
        > 值就是物件中儲存的具體的資料
        > 對於有些物件值是可以改變的
        > 物件分成兩大類，可變物件 不可變物件
            可變物件的值可以改變
            不可變物件的值不能改變，之前學習的物件都是不可變物件
    - 參考 下圖

練習：嘗試自己畫一下物件的記憶體結構。

變數和物件

- 物件並沒有直接儲存到變數中，在Python中變數更像是給物件起了一個別名
- 變數中儲存的不是物件的值，而是物件的id（記憶體地址），
    當我們使用變數時，實際上就是在通過物件id在查詢物件
- 變數中儲存的物件，只有在為變數重新賦值時才會改變
- 變數和變數之間是相互獨立的，修改一個變數不會影響另一個變數

- 參考 下圖

型別轉換

- 所謂的型別轉換，將一個型別的物件轉換為其他物件
- 型別轉換不是改變物件本身的型別，而是根據當前物件的值建立一個新物件

# 型別轉換四個函式 int() float() str() bool()
# int() 可以用來將其他的物件轉換為整型
# 規則：
#   布林值：True -> 1   False -> 0
#   浮點數：直接取整，省略小數點後的內容
#   字串：合法的整數字符串，直接轉換為對應的數字
#           如果不是一個合法的整數字符串，則報錯 ValueError: invalid literal for int() with base 10: '11.5'
#   對於其他不可轉換為整型的物件，直接丟擲異常 ValueError
# float() 和 int()基本一致，不同的是它會將物件轉換為浮點數
# str() 可以將物件轉換為字串
#  True -> 'True'
#  False -> 'False'
#  123 -> '123'
#  。。。
# bool() 可以將物件轉換為布林值，任何物件都可以轉換為布林值
#   規則：對於所有表示空性的物件都會轉換為False，其餘的轉換為True
#       哪些表示的空性：0 、 None 、 '' 。。。

a = True

# 呼叫int()來將a轉換為整型
# int()函式不會對原來的變數產生影響，他是物件轉換為指定的型別並將其作為返回值返回
# 如果希望修改原來的變數，則需要對變數進行重新賦值
a = int(a)

a = False
a = int(a)

a = '123'
a = int(a)

a = 11.6
a = int(a)

a = '11.5'
# a = int(a)

a = None
# a = int(a)

a = 1
a = float(a)

a = False
a = float(a)

a = 123
a = str(a)

a = None
a = bool(a)

print('a =',a)
print('a的型別是',type(a))
# b = 456
# print('hello'+str(b))

運算子(操作符)

- 運算子可以對一個值或多個值進行運算或各種操作
- 比如 + 、-、= 都屬於運算子
- 運算子的分類：
    1.算術運算子
    2.賦值運算子
    3.比較運算子（關係運算符）
    4.邏輯運算子
    5.條件運算子（三元運算子）

1.算術運算子

# 算術運算子
# + 加法運算子（如果是兩個字串之間進行加法運算，
則會進行拼串操作）
# - 減法運算子
# * 乘法運算子（如果將字串和數字相乘，則會對字串進行
複製操作，將字串重複指定次數）
# / 除法運算子，運算時結果總會返回一個浮點型別
# // 整除，只會保留計算後的整數位，總會返回一個整型
# ** 冪運算，求一個值的幾次冪
# % 取模，求兩個數相除的餘數

a = 10 + 5 # 計算
a = 'hello' + ' ' + 'world' # 拼串

a = 10 - 5 # 計算
a = 5 - True 
a = a - 2 # 用變數a的值減去2，然後再賦值給a
# a = 'hello' - 'h' TypeError

a = 5 * 5

a = 10 / 5
a = 5 / 2
# a = 5 / 0 ZeroDivisionError: division by zero
a = 10 / 3
a = 10 // 3
a = 5 // 2 

a = 2 ** 2
a = 10 ** 5
a = 16 ** 0.5 # 求16的平方根

a = 10 % 5 # 0
a = 10 % 4 # 2
a = 10 % 3 # 1
a = 10 % 2 # 0

print("a =",a)

2.賦值運算子

# 賦值運算子
# = 可以將等號右側的值賦值給等號左側的變數
# +=  a += 5 相當於 a = a + 5 
# -=  a -= 5 相當於 a = a - 5 
# *=  a *= 5 相當於 a = a * 5 
# **= a **= 5 相當於 a = a ** 5 
# /=  a /= 5 相當於 a = a / 5 
# //= a //= 5 相當於 a = a // 5 
# %=  a %= 5 相當於 a = a % 5 
a = 10
# a = a + 5
# a += 5
a -= 5
a *= 5
a **= 2
a /= 25
a = 25.0 # 在對浮點數做算術運算時，結果也會返回一個浮點數
a //= 5
a = 5
a %= 4

print('a =',a)

3.比較運算子（關係運算符）

# 關係運算符
# 關係運算符用來比較兩個值之間的關係，總會返回一個布林值
# 如果關係成立，返回True，否則返回False
# > 比較左側值是否大於右側值
# >= 比較左側的值是否大於或等於右側的值
# < 比較左側值是否小於右側值
# <= 比較左側的值是否小於或等於右側的值
# == 比較兩個物件的值是否相等
# != 比較兩個物件的值是否不相等
#   相等和不等比較的是物件的值，而不是id
# is 比較兩個物件是否是同一個物件，比較的是物件的id
# is not 比較兩個物件是否不是同一個物件，比較的是物件的id
result = 10 > 20 # False
result = 30 > 20 # True
result = 30 < 20 # False
result = 10 >= 10 # True

result = 2 > True # True
# result = 2 > '1' TypeError: '>' not supported 
between instances of 'int' and 'str'

# 0032 > 0031
result = '2' > '1' # True
result = '2' > '11' # True

# 在Python中可以對兩個字串進行大於（等於）或小於（等於）的運算，
#   當對字串進行比較時，實際上比較的是字串的Unicode編碼
#   比較兩個字串的Unicode編碼時，是逐位比較的
#   利用該特性可以對字串按照字母順序進行排序，但是對於中文來說意義不是特別大
#   注意：如果不希望比較兩個字串的Unicode編碼，則需要將其轉換為數字然後再比較
#   0061 > 0062
result = 'a' > 'b' # False
result = 'c' < 'd' # True
result = 'ab' > 'b' # False

# print(int('2') > int('11'))

result = 1 == 1 # True
result = 'hello' == 'hello' # True
result = 'abc' == 'bcd' # False
result = 'abc' != 'bcd' # True
result = 1 == True # True
result = 1 is True # False
result = 1 is not True # True
print('result =',result)
print(id(1),id(True))

4.邏輯運算子

# 邏輯運算子
# 邏輯運算子主要用來做一些邏輯判斷
# not 邏輯非
#   not可以對符號右側的值進行非運算
#       對於布林值，非運算會對其進行取反操作，True變False，False變True
#       對於非布林值，非運算會先將其轉換為布林值，然後再取反
#
# and 邏輯與
#   and可以對符號兩側的值進行與運算
#    只有在符號兩側的值都為True時，才會返回True，只要有一個False就返回False
#    與運算是找False的
#    Python中的與運算是短路的與，如果第一個值為False，則不再看第二個值
#
# or 邏輯或
#   or 可以對符號兩側的值進行或運算
#    或運算兩個值中只要有一個True，就會返回True
#    或運算是找True的
#    Python中的或運算是短路的或，如果第一個值為True，則不再看第二個值
#
# 練習：
#   嘗試一下對布林值進行三種邏輯運算
#   嘗試對非布林值進行三種邏輯運算，並觀察返回的結果
#

a = True
a = not a # 對a進行非運算

a = 1
a = ''
a = not a
# print('a =',a)

result = True and True # True
result = True and False # False
result = False and True # False
result = False and False # False

# print(result)

# True and print('你猜我出來嗎？') 第一個值是True，會看第二個值，所以print()會執行
# False and print('你猜我出來嗎？')第一個值是False，不會看第二個值，所以print()不會執行


result = True or True # True
result = True or False # True
result = False or True # True
result = False or False # False

# print(result) 
# False or print('你猜我出來嗎？') 第一個值為False，繼續看第二個，所以列印語句執行
# True or print('你猜我出來嗎？') 第一個值為True，不看第二個，所以列印語句不執行

# 非布林值的與或運算
#   當我們對非布林值進行與或運算時，Python會將其當做布林值運算，最終會返回原值
#   與運算的規則
#       與運算是找False的，如果第一個值是False，則不看第二個值
#       如果第一個值是False，則直接返回第一個值，否則返回第二個值
#   或運算的規則
#       或運算是找True的，如果第一個值是True，則不看第二個值
#       如果第一個值是True，則直接返回第一個值，否則返回第二個值

# True and True
result = 1 and 2 # 2
# True and False
result = 1 and 0 # 0
# False and True
result = 0 and 1 # 0
# False and False
result = 0 and None # 0

# True or True
result = 1 or 2 # 1
# True or False
result = 1 or 0 # 1
# False or True
result = 0 or 1 # 1
# False or False
result = 0 or None # None

# 邏輯運算子可以連著使用
result = 1 < 2 < 3 # 相當於 1 < 2 and 2 < 3
result = 10 < 20 > 15

print(result)

5.條件運算子（三元運算子）

# 條件運算子（三元運算子）
# 語法： 語句1 if 條件表示式 else 語句2
# 執行流程：
#   條件運算子在執行時，會先對條件表示式進行求值判斷
#       如果判斷結果為True，則執行語句1，並返回執行結果
#       如果判斷結果為False，則執行語句2，並返回執行結果

# print('你好') if False else print('Hello')

a = 30
b = 50

# print('a的值比較大！') if a > b else print('b的值比較大！')
# 獲取a和b之間的較大值
max = a if a > b else b
print(max)

# 練習：
#   現在有a b c三個變數，三個變數中分別儲存有三個數值，
#       請通過條件運算子獲取三個值中的最大值
a = 70
b=50
c=30
max = a if a > (b if b > c else c)  else  (b if b > c else c)
print(max)

總結：運算子的優先順序

a = 40
b = 50
c = 30

# 通過條件運算子獲取三個值中的最大值
# max = a if a > b else b
# max = max if max > c else c

max = a if (a > b and a > c) else (b if b > c else c) # 不推薦這麼使用
# max = a if (b < a > c) else (b if b > c else c)

# print(max)

# 運算子的優先順序
# 和數學中一樣，在Python運算也有優先順序，比如先乘除 後加減
# 運算子的優先順序可以根據優先順序的表格來查詢，
#   在表格中位置越靠下的運算子優先順序越高，優先順序越高的越優先計算
#   如果優先順序一樣則自左向右計算
#  關於優先順序的表格，你知道有這麼一個東西就夠了，千萬不要去記
#  在開發中如果遇到優先順序不清楚的,則可以通過小括號來改變運算順序
a = 1 + 2 * 3

# 一樣 and高 or高
# 如果or的優先順序高，或者兩個運算子的優先順序一樣高
#   則需要先進行或運算，則運算結果是3
# 如果and的優先順序高，則應該先計算與運算
#   則運算結果是1
a = 1 or 2 and 3

# print(a)