[19/09/16-星期一] Python的運算符和條件判斷語句

時間 2019-11-16

標籤星期一 python 運算符條件判斷語句欄目 Python 简体版

原文原文鏈接

1、運算符iphone

(1)算術運算符函數

　　 + 加法運算符（若是是兩個字符串之間進行加法運算，則會進行拼串操做）優化

　　　　　　a = 10 + 5 　　計算編碼

　　　　　　a = 'hello' + ' ' + 'world' 　　拼串spa

　　 - 減法運算符命令行

　　　　　　a = 10 - 5 　　計算code

　　　　　　a = 5 - True 　　bool型也是int型，沒有錯誤，輸出4對象

　　　　　　a = a - 2 用變量a的值減去2，而後再賦值給ablog

　　　　　 a = 'hello' - 'h' 　　TypeError，類型錯誤排序

　　 * 乘法運算符（若是將字符串和數字相乘，則會對字符串進行復制操做，將字符串重複指定次數）

　　　　　　a = 5 * 5

　　 / 除法運算符，運算時結果總會返回一個浮點類型，區別於Java，c

　　　　　　a = 10 / 5 輸出2.0

　　　　　　a = 5 / 2　輸出2.5

　　　　　　 a = 5 / 0 ZeroDivisionError: division by zero，除數不能爲0

　　　　　　a = 10 / 3　　除不盡，輸出3.333333335 近似值

　　 // 整除，只會保留計算後的整數位，總會返回一個整型。

　　　　　　a = 10 // 3 輸出3

　　　　　　a = 5 // 2 　　輸出2

　　 ** 冪運算，求一個值的幾回冪。

　　　　　　a = 2 ** 2　　輸出4

　　　　　　a = 10 ** 5　　10的5次冪輸出100000

　　　　　　a = 16 ** 0.5 　　求16的平方根輸出4

　　 % 取模，求兩個數相除的餘數

　　　　　　a = 10 % 5 輸出 0

　　　　　　a = 10 % 4 輸出 2

　　　　　　a = 10 % 3 輸出 1

　　　　　　a = 10 % 2 輸出 0

(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　　取餘

(3)關係運算符

　　關係運算符用來比較兩個值之間的關係，總會返回一個布爾值，若是關係成立，返回True，不然返回False

　　> 比較左側值是否大於右側值　　result = 10 > 20 輸出 False

　　 >= 比較左側的值是否大於或等於右側的值　　result = 10 >= 10 輸出 True； result = 2 > True 輸出 True

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

　　 < 比較左側值是否小於右側值

　　 <= 比較左側的值是否小於或等於右側的值

　　 == 比較兩個對象的值是否相等

　　　　result = 1 == 1　　 # True

　　　　result = 'hello' == 'hello'　　 # True

　　　　result = 'abc' == 'bcd' 　　# False

　　　　result = 'abc' != 'bcd' 　　# True

　　　　result = 1 == True　　 # True

　　 != 比較兩個對象的值是否不相等

　　　　相等和不等比較的是對象的值，而不是id

　　 is 比較兩個對象是不是同一個對象，比較的是對象的id

　　 is not 比較兩個對象是否不是同一個對象，比較的是對象的id

　　　　result = 1 is True # False

　　　　result = 1 is not True # True

　　　擴展：

　　　　result = '2' > '1' # True

　　　　result = '2' > '11' # True

　　　　在Python中能夠對兩個字符串進行大於（等於）或小於（等於）的運算，當對字符串進行比較時，實際上比較的是字符串的Unicode編碼

　　比較兩個字符串的Unicode編碼時，是逐位比較的，利用該特性能夠對字符串按照字母順序進行排序，可是對於中文來講意義不是特別大

　　注意：若是不但願比較兩個字符串的Unicode編碼，則須要將其轉換爲數字而後再比較

　　　　result = 'a' > 'b' # False

　　　　result = 'c' < 'd' # True

　　　　result = 'ab' > 'b' # False

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

(4)邏輯運算符

　　邏輯運算符主要用來作一些邏輯判斷

　　　　 not 邏輯非　　能夠對符號右側的值進行非運算

　　　　　　對於布爾值，非運算會對其進行取反操做，True變False，False變True，對於非布爾值，非運算會先將其轉換爲布爾值，而後再取反

　　　　and 邏輯與　　能夠對符號兩側的值進行與運算

　　　　　　只有在符號兩側的值都爲True時，纔會返回True，只要有一個False就返回False

　　　　　　與運算是找False的，Python中的與運算是短路的與，若是第一個值爲False，則再也不看第二個值。

　　　　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

　　　　　　False or print('你猜我出來嗎？') 第一個值爲False，繼續看第二個，因此打印語句執行
　　　　　　True or print('你猜我出來嗎？') 第一個值爲True，不看第二個，因此打印語句不執行

　　　其餘：非布爾值的與或運算　當咱們對非布爾值進行與或運算時，Python會將其當作布爾值運算，最終會返回原值　　　　　　

　　與運算的規則，與運算是找False的，若是第一個值是False，則直接返回第一個值，不然返回第二個值。

　　或運算的規則，或運算是找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

(5)條件運算符

　　語法：語句1 if 條件表達式 else 語句2

　　條件運算符在執行時，會先對條件表達式進行求值判斷，若是判斷結果爲True，則執行語句1，並返回執行結果。不然執行語句2

　　 print('a的值比較大！') if a > b else print('b的值比較大！')

　　 max = a if a > b else b，若是a>b成立，執行語句1: max=a,把a的值賦值給變量max，如果不成立執行語句2：max=b，b賦值給max

(6)優先級

　　結合數學常識，先乘除後加減，實在不行加小括號。表格中越往下優先級越高。

　　and的優先級高於or . 1 or 2 and 3 輸出爲1 等價於 1 or （2 and 3）

　　邏輯運算符能夠連着使用。result = 1 < 2 < 3 　　至關於 1 < 2 and 2 < 3

2、條件判斷語句

　　（1）if語句

# 條件判斷語句（if語句）
# 語法：if 條件表達式 : 
#           代碼塊
# 執行的流程：if語句在執行時，會先對條件表達式進行求值判斷，
#   若是爲True，則執行if後的語句
#   若是爲False，則不執行
# 默認狀況下，if語句只會控制緊隨其後的那條語句，若是但願if能夠控制多條語句，
#   則能夠在if後跟着一個代碼塊
# 代碼塊
#   代碼塊中保存着一組代碼，同一個代碼塊中的代碼，要麼都執行要麼都不執行
#   代碼塊就是一種爲代碼分組的機制
#   若是要編寫代碼塊，語句就不能緊隨在:後邊，而是要寫在下一行
#   代碼塊以縮進開始，直到代碼恢復到以前的縮進級別時結束
#   魯迅說過：
#       世上原本沒有路，走的人多了天然就有了！
#       xxxx
#   yyyy....
# 縮進有兩種方式，一種是使用tab鍵，一種是使用空格（四個）
#   Python的官方文檔中推薦咱們使用空格來縮進
#   Python代碼中使用的縮進方式必須統一
#   "translate_tabs_to_spaces": true,     

# if False : print('你猜我出來麼？')

num = 10
# if num > 10 : print('num比10大！')
# print('誰也管不了我')

if False :
    print(123)
    print(456)
    print(789)
    print(101112)
# print('hello')

num = 28

# 可使用邏輯運算符來鏈接多個條件，
#   若是但願全部條件同時知足，則須要使用and
#   若是但願只要有一個條件知足便可，則須要使用or
# if num > 10 and num < 20 :
#     print('num比10大,num比20小！')

# if 10 < num < 20 :
#     print('num比10大,num比20小！')

# 在命令行讓用戶輸入一個用戶名，獲取用戶輸入，並進行判斷
# 若是用戶輸入的用戶名是admin，則顯示歡迎管理員光臨
# 若是用戶輸入的是其餘的用戶名，則什麼也不作

# input()函數
# 該函數用來獲取用戶的輸入
# input()調用後，程序會當即暫停，等待用戶輸入
#   用戶輸入完內容之後，點擊回車程序纔會繼續向下執行
#   用戶輸入完成之後，其所輸入的的內容會以返回值得形式返回
#   注意：input()的返回值是一個字符串
#   input()函數中能夠設置一個字符串做爲參數，這個字符串將會做爲提示文字顯示
# a = input('請輸入任意內容：')
# print('用戶輸入的內容是:',a)
# input()也能夠用於暫時阻止程序結束

# 獲取用戶輸入的用戶名
username = input('請輸入你的用戶名:')
# 判斷用戶名是不是admin
if username == 'admin' :
    print('歡迎管理員光臨！')

# 讓用戶在控制檯中輸入一個年齡
# age = int(input('請輸入你的年齡：'))

# 若是用戶的年齡大於18歲，則顯示你已經成年了
# if age >= 18 :
#     print('你已經成年了~~~')

# if-else語句
# 語法： 
#   if 條件表達式 :
#       代碼塊
#   else :
#       代碼塊
# 執行流程：
#   if-else語句在執行時，先對if後的條件表達式進行求值判斷
#       若是爲True，則執行if後的代碼塊
#       若是爲False，則執行else後的代碼塊

age = 7
if age > 17 :
    print('你已經成年了~~')
else :
    print('你還未成年~~')

　　（2）if-elif-if語句

# if-elif-else語句
# 語法：
#   if 條件表達式 :
#       代碼塊
#   elif 條件表達式 :
#       代碼塊
#   elif 條件表達式 :
#       代碼塊
#   elif 條件表達式 :
#       代碼塊
#   else :
#       代碼塊
#       
# 執行流程：
#   if-elif-else語句在執行時，會自上向下依次對條件表達式進行求值判斷，
#       若是表達式的結果爲True，則執行當前代碼塊，而後語句結束
#       若是表達式的結果爲False，則繼續向下判斷，直到找到True爲止
#       若是全部的表達式都是False，則執行else後的代碼塊
#   if-elif-else中只會有一個代碼塊會執行

age = 210

# if age > 200 :
#     print('活着可真沒勁呢！')
# elif age > 100 :
#     print('你也是老大不小了！')
# elif age >= 60 :
#     print('你已經退休了！')
# elif age >= 30 :
#     print('你已是中年了！')
# elif age >= 18 :
#     print('你已經成年了！')
# else :
#     print('你仍是個小孩！')

age = 68

if age >= 18 and age < 30 :
    print('你已經成年了！')
elif age >= 30 and age < 60 :
    print('你已經中年了！')
elif age >= 60 :
    print('你已經退休了！')

練習

# 練習1：
#     編寫一個程序，獲取一個用戶輸入的整數。而後經過程序顯示這個數是奇數仍是偶數。
# 獲取用戶輸入的整數
# num = int(input('請輸入一個任意的整數：'))

# # 顯示num是奇數仍是偶數
# if num % 2 == 0 :
#     print(num , "是偶數")
# else :
#     print(num , '是奇數')


# 練習2：
#     編寫一個程序，檢查任意一個年份是不是閏年。
#     若是一個年份能夠被4整除不能被100整除，或者能夠被400整除，這個年份就是閏年
# year = int(input('請輸入一個任意的年份:'))
# # 檢查這個年份是不是閏年
# # year % 4 == 0 and year % 100 != 0 or year % 400 == 0
# if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 :
#     print(year,'是閏年')
# else :
#     print(year,'是平年')

# 練習3：
#     我家的狗5歲了，5歲的狗至關於多大年齡的人呢？
#     其實很是簡單，狗的前兩年每年至關於人類的10.5歲，而後每增長一年就增長四歲。
#     那麼5歲的狗相等於人類的年齡就應該是10.5+10.5+4+4+4 = 33歲 

#     編寫一個程序，獲取用戶輸入的狗的年齡，而後經過程序顯示其至關於人類的年齡。
#     若是用戶輸入負數，請顯示一個提示信息  核心代碼 print("狗的年齡是：",2*10.5+(year-2)*4)

# dog_age = float(input('請輸入狗的年齡：'))
# like_person_age = 0
# 檢查用戶輸入的是不是負數
# if dog_age < 0 :
#     print('你的輸入不合法！')
# # 若是狗的年齡在兩歲如下（包含兩歲）
# elif dog_age <= 2 :
#     # 直接將當前的年齡乘以10.5
#     like_person_age = dog_age * 10.5
# # 若是狗的年齡在兩歲以上
# else :
#     # 計算前兩歲至關於人類的年紀
#     like_person_age = 2 * 10.5
#     # 計算超過兩歲的部分相對於人類的年紀，並進行相加
#     like_person_age += ( dog_age - 2 ) * 4

# if dog_age > 0 :
#     print(dog_age,'歲的狗，年紀至關於',like_person_age,'歲的人')
#     

# 在if也能夠去嵌套if，代碼塊是能夠嵌套的，每增長一個縮進的級別，代碼塊就低一級
# 檢查用戶的輸入是否合法
# if dog_age > 0 :
#     # 若是狗的年齡在兩歲如下（包含兩歲）
#     if dog_age <= 2 :
#         # 直接將當前的年齡乘以10.5
#         like_person_age = dog_age * 10.5
#     # 若是狗的年齡在兩歲以上
#     else :
#         # 計算前兩歲至關於人類的年紀
#         like_person_age = 2 * 10.5
#         # 計算超過兩歲的部分相對於人類的年紀，並進行相加
#         like_person_age += ( dog_age - 2 ) * 4

#     print(dog_age,'歲的狗，年紀至關於',like_person_age,'歲的人')
# else :
#     print('請輸入一個合法的年齡！')


# 練習4：
#     從鍵盤輸入小明的期末成績:
#         當成績爲100時，'獎勵一輛BMW'
#         當成績爲[80-99]時，'獎勵一臺iphone'
#         當成績爲[60-79]時，'獎勵一本參考書'
#         其餘時，什麼獎勵也沒有

# 獲取小明的成績
# score = float(input('請輸入你的期末成績(0-100)：'))

# # 打印分割線
# print("="*40)

# # 檢查用戶的輸入是否合法
# if 0 <= score <= 100 :
#     # 判斷髮給的獎勵
#     if score == 100 :
#         print('寶馬，拿去玩！')
#     elif score >= 80 :
#         print('蘋果手機，拿去玩！')
#     elif score >= 60 :
#         print('參考書，拿去玩！')
#     else :
#         print('棍子一根！')
# else :
#     # 用戶輸入的不合法，彈出一個友好提示
#     print('你輸入的內容不合法，拉出去斃了！')


# 練習5：
#     你們都知道，男大當婚，女大當嫁。那麼女方家長要嫁女兒，固然要提出必定的條件：
#         高：180cm以上; 富:1000萬以上; 帥:500以上;
#         若是這三個條件同時知足，則:'我必定要嫁給他'
#         若是三個條件有爲真的狀況，則:'嫁吧，比上不足，比下有餘。'
#         若是三個條件都不知足，則:'不嫁！'

# 獲取用戶的三個數據，身高、財富、顏值
height = float(input('請輸入你的身高(釐米):'))
money = float(input('請輸入你的財富(萬):'))
face = float(input('請輸入你的顏值(平方釐米):'))

# 判斷到底嫁不嫁
# 若是這三個條件同時知足，則:'我必定要嫁給他'
if height > 180 and money > 1000 and face > 500 :
    print('我必定要嫁給他！')
# 若是三個條件有爲真的狀況，則:'嫁吧，比上不足，比下有餘。'
elif height > 180 or money > 1000 or face > 500 :
    print('嫁吧，比上不足，比下有餘。')
# 若是三個條件都不知足，則:'不嫁！'
else :
    print('不嫁！')

　　（3）循環語句

# 循環語句
# 循環語句可使指定的代碼塊重複指定的次數
# 循環語句分紅兩種，while循環 和 for循環
# while循環
# 語法：
#   while 條件表達式 :
#       代碼塊
#   else :
#       代碼塊
# 執行流程：
#   while語句在執行時，會先對while後的條件表達式進行求值判斷，
#       若是判斷結果爲True，則執行循環體（代碼塊），
#       循環體執行完畢，繼續對條件表達式進行求值判斷，以此類推，
#       直到判斷結果爲False，則循環終止，若是循環有對應的else，則執行else後的代碼塊

# 條件表達式恆爲True的循環語句，稱爲死循環，它會一直運行，慎用！
# while True :
#     print('hello')

# 循環的三個要件（表達式）
# 初始化表達式，經過初始化表達式初始化一個變量
# i = 0

# # 條件表達式，條件表達式用來設置循環執行的條件
# while i < 10 :
#     print(i)
#     # 更新表達式，修改初始化變量的值
#     i += 1

# 建立一個執行十次的循環
i = 0
while i < 10 :
    i += 1
    print(i,'hello')
else :
    print('else中的代碼塊')

練習

# 求100之內全部的奇數之和
# 獲取全部100之內數
# i = 0
# # 建立一個變量，用來保存結果
# result = 0
# while i < 100 :
#     i += 1
#     # 判斷i是不是奇數
#     if i % 2 != 0:
#         result += i

# print('result =',result)

# 獲取100之內全部的奇數
# i = 1
# while i < 100:
#     print(i)
#     i += 2

# 求100之內全部7的倍數之和，以及個數
i = 7 
# 建立一個變量，來保存結果
result = 0
# 建立一個計數器，用來記錄循環執行的次數
# 計數器就是一個變量，專門用來記錄次數的變量
count = 0
while i < 100:
    # 爲計數器加1
    count += 1
    result += i
    i += 7    

print('總和爲：',result,'總數量爲:',count)

# 水仙花數是指一個 n 位數（n≥3 ），它的每一個位上的數字的 n 次冪之和等於它自己（例如：1**3 + 5**3 + 3**3 = 153）。
# 求1000之內全部的水仙花數

# 獲取1000之內的三位數
i = 100
while i < 1000:

    # 假設，i的百位數是a，十位數b，個位數c
    # 求i的百位數
    a = i // 100
    # 求i的十位數
    # b = i // 10 % 10  b=(i%100)//10
    b = (i - a * 100) // 10  
    # 求i的個位數字
    c = i % 10
    # print(i , a , b , c)
    
    # 判斷i是不是水仙花數
    if a**3 + b**3 + c**3 == i :
        print(i)
    i += 1

# 獲取用戶輸入的任意數，判斷其是不是質數。
num = int(input('輸入一個任意的大於1的整數：'))

# 判斷num是不是質數，只能被1和它自身整除的數就是質數
# 獲取到全部的可能整除num的整數
i = 2
# 建立一個變量，用來記錄num是不是質數，默認認爲num是質數
flag = True
while i < num:
    # 判斷num可否被i整除
    # 若是num能被i整除，則說明num必定不是質數
    if num % i == 0 :
        # 一旦進入判斷，則證實num不是質數，則須要將flag修改成false
        flag = False
    i += 1

if flag :
    print(num,'是質數')
else :
    print(num,'不是質數')

# 在控制檯中打印以下圖形
# *****
# *****
# *****
# *****
# *****
# 

# 建立一個循環來控制圖形的高度
# 循環嵌套時，外層循環沒執行一次，內存循環就要執行一圈
# i = 0
# while i < 5:
#     # 建立一個內層循環來控制圖形的寬度
#     j = 0
#     while j < 5:
#         print("* ",end='') #end=''表示不換行
#         j += 1
#     print()
#     i += 1

#
# *     j<1   i=0
# **    j<2   i=1   
# ***   j<3   i=2
# ****  j<4   i=3
# ***** j<5   i=4
# 
# *****
# ****
# ***
# **
# *
i = 0
while i < 5:
    j = 0
    while j < i + 1:
        print("* ",end='')
        j += 1
    print()
    i += 1

# 練習1：
#   打印99乘法表
#   1*1=1
#   1*2=2 2*2=4
#   1*3=3 2*3=6 3*3=9
#   ...                 9*9=81

# 建立一個外層循環來控制圖形的高度
i = 0
while i < 9:
    i += 1
    
    # 建立一個內層循環來控制圖形的寬度
    j = 0
    while j < i:
        j += 1
        print(f"{j}*{i}={i*j} ",end="")

    print()

# 求100之內全部的質數
# 建立一個循環，求1-100之內全部的數
i = 2
while i <= 100:
    
    # 建立一個變量，記錄i的狀態，默認認爲i是質數
    flag = True

    # 判斷i是不是質數
    # 獲取全部可能成爲i的因數的數
    j = 2 
    while j < i:
        # 判斷i可否被j整除
        if i % j == 0:
            # i能被j整除，證實i不是質數，修改flag爲False
            flag = False
        j += 1
    # 驗證結果並輸出
    if flag :
        print(i)   

    i += 1

# break
# break能夠用來當即退出循環語句（包括else）
# continue
# continue能夠用來跳過當次循環
# break和continue都是隻對離他最近的循環起做用
# pass
# pass是用來在判斷或循環語句中佔位的，沒有任何實際意義。

# 建立一個5次的循環
# i = 0
# while i < 5:
#     if i == 3:
#         break
#     print(i)
#     i += 1
# else :
#     print('循環結束')

# i = 0
# while i < 5:
#     i += 1
#     if i == 2:
#         continue
#     print(i)
# else :
#     print('循環結束')

i = 0
if i < 5:
    pass

# 模塊，經過模塊能夠對Python進行擴展，相似於Java中外置擴展包。
# 引入一個time模塊，來統計程序執行的時間
from time import *
# time()函數能夠用來獲取當前的時間，返回的單位是秒
# 獲取程序開始的時間
# 優化前：
#   10000個數 12.298秒
#   100000個數 沒有結果
# 第一次優化
#   10000個數 1.577秒
#   100000個數 170.645秒
# 第二次優化
#   10000個數 0.068秒
#   100000個數 1.646秒
#
# 36的因數
#   2 18
#   3 12
#   4 9
#   6 6
#   
begin = time()

i = 2
while i <= 100000:
    flag = True
    j = 2 
    while j <= i ** 0.5: #優化2 i開方
        if i % j == 0:
            flag = False
            # 一旦進入判斷，則證實i必定不是質數，此時內層循環沒有繼續執行的必要
            # 使用break來退出內層的循環
            break  #優化1 跳出循環
        j += 1
    if flag :
        # print(i)  
        pass
    i += 1

# 獲取程序結束的時間
end = time()

# 計算程序執行的時間
print("程序執行花費了：",end - begin , "秒")