利用python打印楊輝三角

用python打印楊輝三角

介紹

楊輝三角，是初高中時候的一個數列，其核心思想就是說生成一個數列，該數列中的每一個元素，都是之前一個數列中，同樣位置的元素和前一個元素的和。

正好在python中，也就是生成一個列表，該列表中的元素，都是之前列表的同樣位置的元素和前一個元素的和。在這里，我想到的方法是通過迭代來進行計算，因為每一個數列的生成，都是需要前一個數列作為基礎。

實現方式

首先，需要實現第N個楊輝三角的列表生成，通過分析整個楊輝三角，除了第一個和第二個數列意外，其他的都是可以通過迭代的方式進行生成的。具體的函數如下：

def Traingle(x):
    '''定義楊輝三角的函數，即下一行的第N個元素，是本行的第N個元素和第N-2個元素的和，最后返回一個列表'''
    x = int(x)
    Traingle_list = []
    if x == 1:
        Traingle_list = [1]
    elif x == 2:
        Traingle_list = [1,1]
    else:
        Traingle_list_temp = Traingle(x-1)#獲取上一行三角列表
        Traingle_list = [1,1]
        temp = 1
        while temp <= x-2:
            Traingle_list.insert(temp,Traingle_list_temp[temp]+Traingle_list_temp[temp-1])
            temp += 1

    return Traingle_list

在上面的函數中，1和2比較好理解，因為比較簡單，從第3個開始，都是要先獲取前一個數列，然后利用循環的方式，在對應的位置上，進行插入，插入的元素，即為前一個數列中，同樣位置和之前一個元素的和。同時需要注意的是，由於列表索引和初始列表的原因，第一個元素和最后一個元素是不用插入的，所以最后一個元素是x-1，最多插入到x-2的位置。

返回的結果是一個列表，可以直接進行調用打印。

為了是楊輝三角看上去比較有規律，在打印的時候需要做一下處理，比如居中顯示。我能想到的辦法是利用字符串的居中顯示，先將列表轉化成為字符串，然后對整個字符串進行居中顯示。

在處理數據的過程中，由於數字越加越大，所以每個元素的長度也不一樣，居中顯示如果固定死了，對於后面的列表，就顯得不好看。所以在處理的過程中，默認先取出最大的列表中的最大元素，然后計算該元素的長度，所有列表中的每一個元素，都按照該元素的長度進行居中補齊，這樣就保證了所有列表的所有元素，長度都是固定相同的，看上去就能好看一些。

另外，由於整個列表的長度，由列表轉化成為的字符串來限定的，字符串，由元素和空格組成，元素是固定長度的，空格是固定個數的，有N個元素，就有N-1個空格。所以定義一個打印的函數，對楊輝三角的輸出進行打印，具體如下：

def PrintTringle(x):
    '''
    打印楊輝三角，其中利用到的是字符串居中顯示，周圍填充空格，但是由於不確定得到的結果的長度，所以需要得到整個列表中最大的那個元素，然后計算該元素的長度，利用該長度，為每一個楊輝三角的值進行填充劇中。
    :param x:
    :return:
    '''
    n = 1
    x = int(x)
    # 獲取最大的元素，判斷列表最大的元素的長度
    if x % 2 == 0:
        max_item = Traingle(x)[int(x/2)]
    else:
        max_item = Traingle(x)[int((x+1)/2)]
    max_length = len(str(max_item))
    while n <= x :
        list = Traingle(n)
        string = ''
        tem = 0
        # 對每一列楊輝三角進行處理，轉化成為字符串，拼接
        while tem < len(list):
            if tem == 0:
                string = str(list[tem]).center(max_length)
            else:
                string = string + ' ' + str(list[tem]).center(max_length)
            tem += 1
        # 打印處理，每一列的元素有N個，空格用N+1
        print(string.center((max_length+1)*x-1))
        n += 1

在調用該函數的時候，只需要輸入一個參數，正整數，就可以打印出整個楊輝三角到一定長度的完整序列，並且邏輯展示排列。比如打印20個。

PrintTringle(20)

                                                       1                                                           
                                                    1     1                                                        
                                                 1     2     1                                                     
                                              1     3     3     1                                                  
                                           1     4     6     4     1                                               
                                        1     5     10    10    5     1                                            
                                     1     6     15    20    15    6     1                                         
                                  1     7     21    35    35    21    7     1                                      
                               1     8     28    56    70    56    28    8     1                                   
                            1     9     36    84   126   126    84    36    9     1                                
                         1     10    45   120   210   252   210   120    45    10    1                             
                      1     11    55   165   330   462   462   330   165    55    11    1                          
                   1     12    66   220   495   792   924   792   495   220    66    12    1                       
                1     13    78   286   715   1287  1716  1716  1287  715   286    78    13    1                    
             1     14    91   364   1001  2002  3003  3432  3003  2002  1001  364    91    14    1                 
          1     15   105   455   1365  3003  5005  6435  6435  5005  3003  1365  455   105    15    1              
       1     16   120   560   1820  4368  8008 11440 12870 11440  8008  4368  1820  560   120    16    1           
    1     17   136   680   2380  6188 12376 19448 24310 24310 19448 12376  6188  2380  680   136    17    1        
 1     18   153   816   3060  8568 18564 31824 43758 48620 43758 31824 18564  8568  3060  816   153    18    1     
1     19   171   969   3876 11628 27132 50388 75582 92378 92378 75582 50388 27132 11628  3876  969   171    19    1  

以上顯示，受頁面排版的影響，顯示不全，其實在終端中是可以正常顯示的。