計算機就是一台用來計算機的機器，人讓計算機干什麼計算機就得干什麼！
需要通過計算機的語言來控制計算機（編程語言）！
計算機語言其實和人類的語言沒有本質的區別，不同點就是交流的主體不同！
計算機語言發展經歷了三個階段：
機器語言
- 機器語言通過二進制編碼來編寫程序
- 執行效率好，編寫起來太麻煩
符號語言（匯編）
- 使用符號來代替機器碼
- 編寫程序時，不需要使用二進制，而是直接編寫符號
- 編寫完成後，需要將符號轉換為機器碼，然後再由計算機執行
符號轉換為機器碼的過程稱為匯編
- 將機器碼轉換為符號的過程，稱為反匯編
- 匯編語言一般只適用於某些硬件，兼容性比較差
高級語言
- 高級語言的語法基本和現在英語語法類似，並且和硬件的關系沒有那麼緊密了
- 也就是說我們通過高級語言開發程序可以在不同的硬件系統中執行
- 並且高級語言學習起來也更加的容易，現在我們知道的語言基本都是高級語言
- C、C++、C#、Java、JavaScript、Python 。。。
計算機只能識別二進制編碼（機器碼），所以任何的語言在交由計算機執行時必須要先轉換為機器碼，
也就是像 print('hello') 必需要轉換為類似 1010101 這樣的機器碼
根據轉換時機的不同，語言分成了兩大類：
編譯型語言
- C語言
- 編譯型語言，會在代碼執行前將代碼編譯為機器碼，然後將機器碼交由計算機執行
- a(源碼) --編譯--> b(編譯後的機器碼)
- 特點：
執行速度特別快
跨平台性比較差
解釋型語言
- Python JS Java
- 解釋型語言，不會在執行前對代碼進行編譯，而是在執行的同時一邊執行一邊編譯
- a（源碼）--解釋器--> 解釋執行
- 特點：
執行速度比較慢
跨平台性比較好
Python是解釋型語言
Python（英國發音：/ˈpaɪθən/ 美國發音：/ˈpaɪθɑːn/），是一種廣泛使用的高級編程語言，屬於通用型編程語言，由吉多·范羅蘇姆創造，第一版發布於1991年。可以視之為一種改良（加入一些其他編程語言的優點，如面向對象）的LISP。作為一種解釋型語言，Python的設計哲學強調代碼的可讀性和簡潔的語法（尤其是使用空格縮進劃分代碼塊，而非使用大括號或者關鍵詞）。相比於C++或Java，Python讓開發者能夠用更少的代碼表達想法。不管是小型還是大型程序，該語言都試圖讓程序的結構清晰明了。
Life is short you need Python （人生苦短，我用Python）
Python的用途：
WEB應用
Facebook 豆瓣 。。。
爬蟲程序
科學計算
自動化運維
大數據（數據清洗）
雲計算
桌面軟件/游戲
人工智能
。。。
開發環境搭建就是安裝Python的解釋器
Python的解釋器分類：
CPython（官方）
用c語言編寫的Python解釋器
PyPy
用Python語言編寫的Python解釋器
IronPython
用.net編寫的Python解釋器
Jython
用Java編寫的Python解釋器
步驟：
1.下載安裝包 python-3.6.5.exe
- 3.x
- 2.x
2.安裝（傻瓜式安裝）
3.打開命令行窗口，輸入python 出現如下內容
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 16:07:46) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
當我們通過命令行來輸入Python，所進入到的界面就是Python的交互界面
結構：
版本和版權聲明：
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 16:07:46) [MSC v.1900 32 bit (Intel)] 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！
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中使用#來表示注釋，#後的內容都屬於注釋，注釋的內容將會被解釋器所忽略
我們可以通過注釋來對程序進行解釋說明，一定要養成良好的編寫注釋的習慣
注釋要求簡單明了，一般習慣上#後邊會跟著一個空格
字面量就是一個一個的值，比如：1，2，3，4，5，6，‘HELLO’
字面量所表示的意思就是它的字面的值，在程序中可以直接使用字面量
變量（variable）變量可以用來保存字面量，並且變量中保存的字面量是不定的
變量本身沒有任何意思，它會根據不同的字面量表示不同的意思
一般我們在開發時，很少直接使用字面量，都是將字面量保存到變量中，通過變量來引用字面量
數據類型指的就是變量的值得類型，也就是可以為變量賦哪些值
數值
整型
布爾值
浮點型
復數
字符串
空值
- Python是一門面向對象的語言
- 一切皆對象！
- 程序運行當中，所有的數據都是存儲到內存當中然後再運行的！
- 對象就是內存中專門用來存儲指定數據的一塊區域
- 對象實際上就是一個容器，專門用來存儲數據
- 像我們之前學習的數值、字符串、布爾值、None都是對象
- 參考 圖1
- 每個對象中都要保存三種數據
- id（標識）
> id用來標識對象的唯一性，每一個對象都有唯一的id
> 對象的id就相當於人的身份證號一樣
> 可以通過id()函數來查看對象的id
> id是由解析器生成的，在CPython中，id就是對象的內存地址
> 對象一旦創建，則它的id永遠不能再改變
- type（類型）
> 類型用來標識當前對象所屬的類型
> 比如：int str float bool 。。。
> 類型決定了對象有哪些功能
> 通過type()函數來查看對象的類型
> Python是一門強類型的語言，對象一旦創建類型便不能修改
- value（值）
> 值就是對象中存儲的具體的數據
> 對於有些對象值是可以改變的
> 對象分成兩大類，可變對象 不可變對象
可變對象的值可以改變
不可變對象的值不能改變，之前學習的對象都是不可變對象
- 參考 圖2
練習：嘗試自己畫一下對象的內存結構。
- 對象並沒有直接存儲到變量中，在Python中變量更像是給對象起了一個別名
- 變量中存儲的不是對象的值，而是對象的id（內存地址），
當我們使用變量時，實際上就是在通過對象id在查找對象
- 變量中保存的對象，只有在為變量重新賦值時才會改變
- 變量和變量之間是相互獨立的，修改一個變量不會影響另一個變量
- 參考 圖3
- 所謂的類型轉換，將一個類型的對象轉換為其他對象
- 類型轉換不是改變對象本身的類型，而是根據當前對象的值創建一個新對象
- 運算符可以對一個值或多個值進行運算或各種操作
- 比如 + 、-、= 都屬於運算符
- 運算符的分類：
1.算術運算符
2.賦值運算符
3.比較運算符（關系運算符）
4.邏輯運算符
5.條件運算符（三元運算符）
01.基本概念.py
print('hello','哈哈','abc')
print(123)
print('bcd')
a = 20
print(a)
02.基本語法.py
print('he\
aaa\
aaa')
# 這是一個打印語句，請你看見了不要慌張
# 這是一個注釋
# 注釋會被解釋器所忽略
# print(123+456) 這行代碼被注釋了，將不會執行
print('abc') # 這是一個單行注釋
03.變量和標識符.py
# 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)
04.數值.py
# 在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)
05.字符串.py
# 字符串(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)
06.格式化字符串.py
# 格式化字符串
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'a = {
a}')
# 練習 創建一個變量保存你的名字，然後通過四種格式化字符串的方式
# 在命令行中顯示，歡迎 xxx 光臨！
07.復制字符串.py
# 創建一個變量來保存你的名字
name = '孫悟空'
# 使用四種方式來輸出，歡迎 xxx 光臨
# 拼串
print('歡迎 '+name+' 光臨！')
# 多個參數
print('歡迎',name,'光臨！')
# 占位符
print('歡迎 %s 光臨！'%name)
# 格式化字符串
print(f'歡迎 {
name} 光臨！')
# 字符串的復制（將字符串和數字相乘）
a = 'abc'
# * 在語言中表示乘法
# 如果將字符串和數字相乘，則解釋器會將字符串重復指定的次數並返回
a = a * 20
print(a)
08.布爾值和空值.py
# 布爾值（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)
09.類型檢查.py
# 通過類型檢查，可以檢查只能值（變量）的類型
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'>
10.類型轉換.py
# 類型轉換四個函數 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))
11.算術運算符.py
# 算術運算符
# + 加法運算符（如果是兩個字符串之間進行加法運算，則會進行拼串操作）
# - 減法運算符
# * 乘法運算符（如果將字符串和數字相乘，則會對字符串進行復制操作，將字符串重復指定次數）
# / 除法運算符，運算時結果總會返回一個浮點類型
# // 整除，只會保留計算後的整數位，總會返回一個整型
# ** 冪運算，求一個值的幾次冪
# % 取模，求兩個數相除的余數
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)
12.賦值運算符.py
# 賦值運算符
# = 可以將等號右側的值賦值給等號左側的變量
# += 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)
13.關系運算符.py
# 關系運算符
# 關系運算符用來比較兩個值之間的關系，總會返回一個布爾值
# 如果關系成立，返回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))
14.邏輯運算符.py
# 邏輯運算符
# 邏輯運算符主要用來做一些邏輯判斷
# 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
print(result)
15.條件運算符.py
# 條件運算符（三元運算符）
# 語法： 語句1 if 條件表達式 else 語句2
# 執行流程：
# 條件運算符在執行時，會先對條件表達式進行求值判斷
# 如果判斷結果為True，則執行語句1，並返回執行結果
# 如果判斷結果為False，則執行語句2，並返回執行結果
# 練習：
# 現在有a b c三個變量，三個變量中分別保存有三個數值，
# 請通過條件運算符獲取三個值中的最大值
# 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)
16.運算符的優先級.py
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)
# 邏輯運算符（補充）
# 邏輯運算符可以連著使用
result = 1 < 2 < 3 # 相當於 1 < 2 and 2 < 3
result = 10 < 20 > 15
print(result)
