01.結構 - Python控制結構 if 條件語句

希望系統性學習一門編程語言的朋友請關注我，本專欄后續會持續分享優質文章。

介紹

本篇為第五篇介紹Python知識的文章，本篇也開始接觸到該門語言的邏輯語法部分，這一部分在編程語言中使用很廣泛，小到一段語句，大到一個模塊里面都有很多邏輯判斷語句，所以很有必要細致的去理解它，并將他的一些常用格式熟記于心，好了開始我們下面的文章。

重要事項

本節主要編寫的為Python語句中if語句的編寫要求：

語句格式 - if語句編寫格式要求
語句邏輯 - if語句的主要邏輯結構

演示過程

依然要調出我們系統的CMD命令
進入Python環境的交互界面
編寫一段if語句程序，來體驗邏輯語句的功能

>>>
>>> if 1 > 2:
...           print('a')
...      else:
...           print('b')
...
b
>>>

本段程序為一個簡單的 if...else 語句，這個語句主要是進行二個數做大小的判斷，得出的結果為一個bool值，if語句在bool值為True時執行打印字符a，為False時執行打印字符b，通過這樣一段代碼我們就可以大概的看到if語句的執行條件，執行過程等情況。

重點詳解

針對 if 結構語言本專欄做了以下細致的總結，大家可以細致的體會其語法作用。

語句格式

if語句的基本語法如下所示：

if condition:
      # 如果條件為True，則執行這里的代碼塊
      # 可以有多行代碼
else:
      # 如果條件為False，則執行這里的代碼塊
      # 可以有多行代碼

在if語句中，condition是一個表達式，可以是返回True或False的任何東西。

常見的比較運算符包括：

>：大于
<：小于
>=：大于等于
<=：小于等于
==：等于
!=：不等于

多個條件：

你也可以使用邏輯運算符組合多個條件：

and：與，兩個條件都為True時結果為True
or：或，兩個條件中有一個為True時結果為True
not：非，將True變為False，將False變為True

語句結構

單向分支結構：

if <條件表達式>:
     執行語句
     ...

雙向分支結構：

if <條件表達式>:
     執行語句
     ...
else:
     執行語句
     ...

多分支結構：

if <條件表達式>:
     執行語句
     ...
elif <條件表達式>:
     執行語句
     ...
else:
     執行語句
     ...

存在多個elif語句時，Python會按照順序逐個檢查每個條件，執行第一個滿足條件的代碼塊，然后跳過其他條件的檢查。如果前面的elif條件滿足了，那么后面的elif語句就不會再被執行。

嵌套分支結構：

if <條件表達式>:
     if <條件表達式>:
         執行語句
         ...
     else:
         執行語句
         ...
else:
      if <條件表達式>:
         執行語句
         ...
      else:
         執行語句
         ...

注意：每一層的縮進格式要統一，否則可能會導致意想不到的情況。

參考

Python官方手冊 - https://docs.python.org/zh-cn/3/reference/compound_stmts.html#the-if-statement

讓優質的技術更自由、開放的傳播，我是「技術小劍客」歡迎你的關注和留言。

介：和大家一起探討一下優雅代碼

一、好代碼的定義

談到好代碼，我的第一想法就是優雅，那我們如何該寫出好的代碼，讓閱讀的人感受到優雅呢？首先簡單探討一下優雅代碼的定義

關于好代碼的定義，各路大神都給出了自己的定義和見解

整潔的代碼如同優美的散文。—— Grady Booch
任何一個傻瓜都能寫出計算機可以理解的代碼。唯有寫出人類容易理解的代碼，才是優秀的程序員。—— Martin Fowler

首先要達成一致，我們寫的代碼，除了用于機器執行產生我們預期的效果之外，更多的時候是給人讀的，可能是后續的維護人員，更多時候是一段時間后的作者本人，因此優雅面向不同的用戶有兩層含義的解讀

對人而言，代碼的整潔，清晰的邏輯
對機器而言，準確性、執行性能、異常處理機制等

這次，我們就來聊一聊，什么代碼是優雅的代碼，怎樣寫出優雅的代碼

二、代碼整潔

1. 有意義的命名

簡單說就是類、方法、變量的命名要名副其實，要能描述清晰自己的職責。一個好的命名能輸出更多的信息，它會告訴你，它為什么存在，它是做什么事的，應該怎么使用。一個簡單的衡量標準是，如果命名完仍需要注釋來補充語義，那就不是名副其實；

選個好名字要花時間，但省下的時間的時間比花掉的多，一旦發現有更好的名稱，就換掉舊的。

舉個栗子

public List<int[]> getItem() {
    List<int[]> list1=new ArrayList<int[]>();
    for (int[] x: theList)
        if (x[0]==4)
            list1.add(x);
    return list1;
}

整體邏輯沒啥問題，讀完之后，就有很多問題在腦海中產生

1. theList中是存儲什么東西的數組？
2. theList第一個值是做什么的？
3. 值4的意義又是什么？
4. 返回的列表該怎么使用？

代碼應該體現所處的情景，比方說上述的代碼所處情景是我們正在開發一種掃雷游戲，盤面是名為theList的單元格列表，那就將其名稱改為gameBoard。

盤面上每個單元格都用一個簡單數組表示。零下標條目是一種狀態值，而這種狀態值為4代表“已標記”。只要改為有意義的名稱，代碼就得到了改進。

更進一步，不用int數組來表示單元格，而是另寫一個類。該類包括一個名副其實的函數（稱為isFlagged），從而掩蓋住哪個魔術數4，得到新的函數版本。

public List<Cell> getFlaggedCells() {
  List<Cell> flaggedCells=new ArrayList<Cell>();
  for (Cell cell : gameBoard)
    if (cell.isFlagged())
      flaggedCells.add(cell);
  return flaggedCells;
}

2. 優雅的注釋

實際上，只要我們的代碼有足夠的表達力，能清晰的通過命名來做到名副其實，就不太需要注釋，或者根本不需要；注釋的存在往往是彌補我們無法用代碼清晰表達意圖的情況。可以想象一下，每次自己發現需要寫注釋的時候，是什么心態，擔心此處代碼明天自己看不懂或者別人看不懂，那有沒有考慮用更好的語義的代碼來替代。

但盡管有注釋，也有好有壞，有時候注釋也會撒謊，通常注釋存在的越久，就離其描述的代碼越遠，變得越來越離譜；因為代碼在變動在迭代，在注釋和代碼間可能會插入新的代碼，舊代碼我們通常copy來copy去，分離又重組，但注釋一般不會修改，就會造成注釋和描述的代碼分離，對閱讀者造成更大的迷惑。

我們在需要寫注釋的時候就要告訴自己，能不能用代碼來進行描述。以下是一些壞代碼的注釋bad case

1. 一些被注釋掉的代碼
//something code
//something code
2. 位置標記
//begin
someting code;
//end
3. 簽名標記
/** add by xiaoli*/
4. 非公用方法的javadoc
/**
* doSomething
*/
private void doSomething(){
}
5. 日志式注釋
/** add xx
* update sometimes
* update sometimes
* update sometimes
*/
6. 誤導性注釋
//此處怎樣xx

3. 優雅的函數

3.1 務必要短小

方法應該有多短小？沒有明確約束，idea也不會限制你，但通常我們的方法不該長于一屏，至少多于一屏或者橫向外溢到屏幕以外最直觀的就會造成可讀性體驗差，讀了下面忘記上面，左右拖拽等。對大多數筆記本來說一屏大概就30行左右。短小精簡的方法要比30行短很多，比如

public String renderPageWithSetupAndTeardowns(Page page, boolean isSuite) throws Exception{
  if(isTestPage(page)){
        includeSetupAndTeardownPages(page,isSuite);
    }
    return page.getHtml();
}

if語句、else語句、while語句等，其中的代碼應該只有一行，

改行通常是一個調用語句，這樣不但能保持短小，還可以給調用方法命名一個有說明性的名字，進一步增加代碼的可讀性

3.2 只做一件事

一事精，便可動人。這個普世法則甚至適用于各種場合。像設計原則的單一職責模式，讓類只有一個職責。如果一個類有一個以上的職責，這些職責就耦合在了一起。這會導致邏輯混亂，設計耦合。當一個職責發生變化時，可能會影響其它的職責。

另外，多個職責耦合在一起，會影響復用性。針對方法而言更是如此。方法作為程序的原子單元，保持單一會有效提升復用性。那怎么判斷一個方法是否只做了一件事。最簡單的規則就是看看該方法是否能在拆出一個方法，且拆出去的方法是不同于該方法的詮釋和實現。但是要注意同一方法的邏輯層級務必要一致。

3.3 抽象層級一致

抽象層級一致也是對方法只做一件事的更高要求，抽象層級不一致的代碼一定是做了多件事。

我們讀代碼通常是自頂向下閱讀，我們想讓每個方法后面都跟著位于下一層級的方法，這樣我們可以依著抽象層級向下閱讀了。我們也需要這樣閱讀代碼，先有整體在展示細節，這種叫向下規則。這也是保持方法短小，確保只做一件事的訣竅。一旦方法中混雜不同的抽象層級，會讓人很迷惑，因為沒辦法這個方法中判斷某個表達式是基礎概念還是細節，更惡劣的是，一旦細節與基礎概念混雜，更多的細節就會糾纏不清，舉例子我們想寫一個冰凍大象的需求

//把大象裝進冰箱
public void frozenElephant(){
    //1. 捕捉大象
    //2. 運輸大象
    //3. 打開冰箱
    //4. 放入大象
    //5. 關閉冰箱
}

這個例子的1.2兩步就不是一個層級的邏輯，是屬于更高層級的抽象。3.4.5都是將大象放入冰箱的步驟，屬于低層級的抽象。可以將代碼拆分為如下實現，將高抽象層級的代碼聚合提取出來，細節在分別單獨實現，如下

public void frozenElephant(){
    //1. 捕捉大象
    catchElephant();
    //2. 運輸大象
    transportElephant();
    //將大象放入冰箱
    putElephantInRefrigerator();
}
public void catchElephant(){
}
public void transportElephant(){
}
public void putElephantInRefrigerator(){
    //打開冰箱
    //放入大象
    //關閉冰箱
}

3.4 使用異常替代返回錯誤碼

針對錯誤碼的判斷會導致更深層次的嵌套結構，返回錯誤碼就意味著要求調用者跟著處理錯誤，如下

if(deletePage()==OK){
    if(registry.deleteReference(page.name)==OK){
        if(configKeys.deleteKey(page.name.makeKey)==OK){
            logger.log("page deleted")
        }else{
            logger.log("configKey not deleted")
        }
    }else{
        logger.log("deleteReference from registry failed")
    }
}else{
    logger.log("delete failed")
    return Error;
}

一般我們還需要將try/Catch代碼塊給抽離出去，另外形成方法。防止代碼塊過多搞亂代碼結構，分不清錯誤處理還是正常流程。同時因為方法只做一件事，錯誤處理就是一件事，因此錯誤處理的方法不應該在做其他事，也就是如果一個方法中有try關鍵字，那try就是方法的開頭。catch/finally代碼塊后面也不應該再有內容，如下

try{
    deletePage(page);
    registry.deleteReference(page.name);
    configKeys.deleteKey(page.name.makeKey);
}catch(Exception e){
    logger.log(e.getMessage());
}

3.5 使用第三方庫

比如Lombok組件通過注解的方式，在編譯時自動為屬性生成構造器、getter/setter、equals、hashcode、toString方法舉例如下：

比如Apache Commons系列組件給我們提供了關于字符串、集合、IO操作等工具方法。這些組件是個大寶庫，提供了不少輪子

beanUtils	JavaBean進行各種操作，克隆對象、屬性等等
codec	處理常用的編碼方法的工具類包，例如DES、SHA1、MD5、Base64等.
collections	java集合框架操作
configuration	java應用程序的配置管理類庫
io	io工具的封裝
lang	Java基本對象方法的工具類包如StringUtils、ArrayUtils等等.
logging	提供的日志接口
net	提供了客戶端和服務器端的數據驗證框架

三、代碼重構

重構是對軟件內部結構的一種調整，目的是在不改變軟件可觀察行為的前提下，提高其可理解性，降低其修改成本。

在重構之前一定要知道，一旦開始對類和方法進行重構，就需要事前有完備的單元測試用例來保障重構的準確性，每次重構之后都要去執行對應的單元測試用例，驗證重構的正確性！

1. 識別代碼的壞味道

1.1 重復的代碼

如果在一個以上的地點看到相同的代碼結構，可以肯定的是，想辦法抽線出來合而為一，代碼會變得更好。一般包含幾個點的重復

最單純的重復代碼就是“同一個類的兩個函數含有相同的表達式”。這時候需要做的就是采用提煉函數提煉出重復的代碼，然后讓這兩個地點都調用被提煉出來的那一段代碼
如果重復代碼只是相似而不是完全相同，需要先嘗試用移動語句重組代碼順序，把相似的部分放在一起以便提煉。
如果重復的代碼段位于同一個超類的不同子類中，可以使用函數上移來避免在兩個子類之間互相調用。

1.2 過長的函數

遵循這樣一條原則：每當感覺需要以注釋來說明點什么的時候，就把需要說明的東西寫進一個獨立函數中，并以其用途（而非實現手法）命名，可以對一組甚至短短一行代碼做這件事。哪怕替換后的函數調用動作比函數自身還長，只要函數名稱能夠解釋其用途，就要毫不猶豫地那樣做，關鍵不在于函數的長度，而在于函數“做什么”和“如何做”之間的語義距離。

百分之九十九的場合里，要把函數變短，只需使用提煉函數。找到函數中適合集中在一起的部分，將它們提煉出來形成一個新函數。
如果函數內有大量的參數和臨時變量，最終就會把許多參數傳遞給被提煉出來的新函數，導致可讀性幾乎沒有任何提升。此時可以經常運用以查詢取代臨時變量來消除這些臨時元素。引入參數對象和保持對象完整則可以將過長的參數列表變得更簡潔一些。
如果有多個switch語句基于同一個條件進行分支選擇，就應該使用以多態取代條件表達式。

1.3 數據的可變性

對數據的修改經常導致出乎意料的結果和難以發現的bug。在一處更新數據，卻沒有意識到軟件中的另一處期望著完全不同的數據，于是出現難以預料的bug，往往比較難排查（需要排查數據流轉的整體鏈路），這就需要一些方法用于約束對數據的更新，降低數據可變性的風險。

可以用封裝變量來確保所有數據更新操作都通過很少幾個函數來進行，使其更容易統一監控和演進
如果一個變量在不同時候被用于存儲不同的東西，可以使用拆分變量將其拆分為各自不同用途的變量，從而避免危險的更新操作。
使用移動和提煉函數盡量把邏輯從處理更新操作的代碼中搬移出來，將業務處理邏輯代碼與執行數據更新操作的代碼分開。

1.4 模塊單一職責

所謂模塊化，就是力求將代碼分出區域，最大化區域內部的交互、最小化跨區域的交互。但是經常出現一個函數跟另一個模塊中的函數或者數據交流格外頻繁，遠勝于與所處模塊內部的交流，這就是模塊功能不單一的典型情況。

總看到某個函數為了計算某個值，從另一個對象那兒調用半打的取值函數。如果這個函數需要跟這些數據待在一起，那就使用移動功能把它移過去。
一個函數往往會用到幾個模塊的功能，那么它究竟該被置于何處呢？原則是：判斷哪個模塊擁有的此函數使用的數據最多，然后就把這個函數和那些數據擺在一起。如果先以提煉函數將這個函數分解為數個較小的函數并分別置放于不同類中，上面的步驟就會比較容易完成。
Strategy模式和Visitor模式是為了對抗發散式變化，但也能解決單一職責問題，最根本的原則是：將總是一起變化的東西放在一塊兒。數據和引用這些數據的行為總是一起變化的，如果有特殊情況，我們就搬移那些行為，保持變化始終只在一地發生。

點擊查看原文，獲取更多福利！

https://developer.aliyun.com/article/1117703?utm_content=g_1000366324

版權聲明：本文內容由阿里云實名注冊用戶自發貢獻，版權歸原作者所有，阿里云開發者社區不擁有其著作權，亦不承擔相應法律責任。具體規則請查看《阿里云開發者社區用戶服務協議》和《阿里云開發者社區知識產權保護指引》。如果您發現本社區中有涉嫌抄襲的內容，填寫侵權投訴表單進行舉報，一經查實，本社區將立刻刪除涉嫌侵權內容。

、流程控制

1. 作用：控制代碼的執行順序

2. 分類

2.1順序結構：從上到下依次執行代碼語句

2.2選擇結構：

1. if語句

簡單if結構

if(條件表達式){
    表達式成立時執行的代碼段
}

注意 : 除零值以外，其他值都為真，以下條件為假值false

if(0){}
if(0.0){}
if(""){} //空字符串
if(undefined){}
if(NaN){}
if(null){}

特殊寫法 : { }可以省略,一旦省略，if語句只控制其后的第一行代碼

2. if - else結構：

if(條件表達式){
//條件成立時執行
}else{
//條件不成立時選擇執行
}

3.多重分支結構：

if(條件1){
      //條件1成立時執行
  }else if(條件2){
      //條件2成立時執行
  }else if(條件3){
      //條件3成立時執行
  }...else{
      //條件不成立時執行
  }

2. switch語句：

語法 :

switch(value){
case 值1 :
//value與值1匹配全等時,執行的代碼段
break; //結束匹配
case 值2 :
//value與值2匹配全等時,執行的代碼段
break;
case 值3 :
    //value與值3匹配全等時,執行的代碼段
break;
default:
//所有case匹配失敗后默認執行的語句
break;
}

使用時要注意的：

1. switch語句用于值的匹配，case用于列出所有可能的值；只有switch()表達式的值與case的值匹配全等時，才會執行case對應的代碼段
2. break用于結束匹配，不再向后執行；可以省略，break一旦省略，會從當前匹配到的case開始，向后執行所有的代碼語句，直至結束或碰到break跳出
3. default用來表示所有case都匹配失敗的情況，一般寫在末尾，做默認操作
4. 多個case共用代碼段
          case 值1:
          case 值2:
          case 值3:
          //以上任意一個值匹配全等都會執行的代碼段

3.循環結構：

作用根據條件，重復執行某段代碼

1. while循環：

定義循環變量;
  while(循環條件){
  條件滿足時執行的代碼段
  更新循環變量;
}

2. do-while循環：

do{
循環體;
更新循環變量
}while(循環條件);

while 與do-while循環的區別 :

while 循環先判斷循環條件，條件成立才執行循環體

do-while 循環不管條件是否成立，先執行一次循環體

3. for 循環

for(定義循環變量;循環條件;更新循環變量){
    循環體;
}

循環控制 :

break 強制結束循環

continue 結束當次循環，開始下一次循環循環嵌套 : 在循環中嵌套添加其他循環

二、函數

函數的作用：封裝一段待執行的代碼

語法：

 //函數聲明
  function 函數名(參數列表){
      函數體
      return 返回值;
  }
  //函數調用
  函數名(參數列表);

使用： 函數名自定義，見名知意，命名規范參照變量的命名規范。普通函數以小寫字母開頭，用于區分構造函數(構造函數使用大寫字母開頭，定義類)

三，匿名函數

匿名函數：省略函數名的函數。

語法為：

匿名函數自執行

(function (形參){
 
})(實參);

定義變量接收匿名函數：

var fn=function (){};
fn(); //函數調用

四，作用域

JavaScript 中作用域分為全局作用域和函數作用域，以函數的{ }作為劃分作用域的依據

1，全局變量和全局函數

只要在函數外部使用 var 關鍵字定義的變量，或函數都是全局變量和全局函數，在任何地方都可以訪問

所有省略 var 關鍵字定義的變量，一律是全局變量

2，局部變量/局部函數

在函數內部使用 var 關鍵字定義的變量為局部變量，函數內部定義的函數也為局部函數，只能在當前作用域中使用，外界無法訪問

3，作用域鏈局部作用域中訪問變量或函數，首先從當前作用域中查找，當前作用域中沒有的話，向上級作用域中查找，直至全局作用域

作者：YJ-TX

原文：https://www.cnblogs.com/yjtxin/p/12969576.html

在線咨詢

上一篇：CSS3 border-image-outset 屬
下一篇：維護太累了！2024年，我們還需要前端框架嗎

您的項目需求

*請認真填寫需求信息，我們會在24小時內與您取得聯系。

整合營銷服務商