python學習總結

一、內建函數

id 身份的唯一標示符。返回對象在內存中的地址。

hash （） 返回一個對象的哈希值

type 返回對象的類型

類型轉換。

輸入input（）函數

打印print（）函數。

len（s）給一個容器返回元素的個數。

Isinstance（）判斷是 什么類型。 ???isinstance(‘abc’,str)

Issubclass（）判斷一個類型是不是一個類型的子類。issubclass(bool,bool)

abs絕對值

max（） min（）最大值最小值，

round（） 四舍六入五取偶。不分正負數。

pow（x,y）x**y次冪函數。

divmod（x,y）等價于 tuple (x//y, x%y) ??divmod(54321,10000) ???(5, 4321)

sum(iterable[,start]) 對可迭代對象的所有數值元素求和。sum(range(1,100,2))

chr(i)返回的對應的字符。 chr(97)

ord(c)返回字符對應的數字。 ?ord(‘a’)

ascii() ?spr() ?str()

sorted()立即返回一個新的列表。

recersed(seq)是一個迭代器。翻轉。

enumrate(seq,start=0)

迭代一個序列，返回索引數字和元組構成的二元組。

迭代器和取元素，iter（iterable），next（）

Iter將一個可迭代對象封裝成一個迭代器。

Next對一個迭代器取下一個元素，如果所有人元素都取過了，再次next將會報錯，但是加上一個缺省值就不會報錯。it=iter(reversed([1,3,5]))

next(it,100)

可迭代對象，能夠通過迭代一次次返回不同的元素的對象。

所謂相同，不是指值是否相同，而是在元素的容器中是否是同一個?？梢缘俏幢赜行?，未必可索引。

可迭代的對象有list、tuple,string,bytes,bytearray,range,set,dict,生成器等。

可以使用成員操作符in ??not in ??in本質上就是在遍歷對象。3 in range(10) ??3 in (x for x in range(10))

迭代器：特殊的對象，一定是可迭代對象，具備可迭代對象的特征。

通過iter方法把一個可迭代對象封裝成迭代器。

通過next的方法，迭代迭代器對象。

生成器對象，就是迭代器對象。

zip函數。不是立即生成的。zip(range(10),range(10))

木桶原理。。

二、函數

1、函數，數學定義 y=f（x） ?y是x的函數，x是自變量。

Python函數：

由若干語句組成的語句塊，函數名稱，參數列表，組織代碼的最小參數。完成一定的功能。

2、函數的作用：

結構化編程對代碼的最基本的封裝，一般按照功能組織一段代碼。

封裝的目的是為了復用，減少冗余代碼。

代碼更加簡潔美麗、可讀易懂。

3、函數分類

內建函數：max（）

庫函數：math() ceil()等

4、函數的定義、調用。

def語句定義函數：
def 函數名（參數列表）：

函數體（代碼塊）

[return 返回值]

函數名就是標示符，命名要求一樣。

語句塊必須縮進，約定四個空格

Python的函數沒有return語句，隱士會返回一個none值。

定義中的參數列表成為形式參數，只是一種符號表達，簡稱形參。

調用：函數定義，只是聲明了一個函數，他不會被執行，需要調用。

調用方式，就是函數名加上小括號，括號內寫上參數。

調用時候的參數就是實際參數，是實實在在的傳入的值，稱為實參。

定義的時候叫做形參。

調用的時候叫做實參

def add(x,y):

result = x+y

return result

out = add(4,5)

print(out)

函數是可調用的對象，利用callable（）查詢。

調用通過函數名add加兩個參數，返回值可使用變量接收。

計算的結果，通過返回值進行返回。

必須加同類型的。復用的。

定義需要在調用前，也就是說調用的時候已經被定義過了，否則會拋出異常的。、

def add(x,y):

result = x+y

return result

out = add(‘a’,’b’)

print(out)

5、函數的參數

1）參數調用時傳入的參數要和定義的個數匹配（可變參數除外）。

位置參數

2)def f（x,y）調用時使用 f（1,3）

按照參數的定義位置順序傳入實參。

6、關鍵字參數def（x，y，z）調用使用f（x=1，y=3，z=5）

使用形參的名字來出入實參的方式，使用了形參的名字，順序可以定義的順序不一。

7、傳參

f(z=none,y=10,x=[1])

f((1,) z=6,y=4.1 )

要求位置參數必須在關鍵字參數之前，位置參數的按照位置對應的。

位置在前 關鍵字在后。

8、函數參數默認值

add()可以使用 默認使用缺省值。

參數默認值（缺省值）

定義時，在形參后跟上一個值

def add(x=4, y=5):

return x+y

測試調用 add(6, 10) 、add(6, y=7) 、add(x=5) 、add()、add(y=7)、 {add(x=5, 6)?、add(y=8,4）不可以的類型。型}

add(x=5, y=6)、add(y=5, x=6)

測試定義后面這樣的函數 def add(x=4,y)定義的時候也是不可以的。

作用：參數的默認值可以在未傳入足夠的實參的時候，對沒有給定的參數賦值為默認值

參數非常多的時候，并不需要用戶每次都輸入所有的參數，簡化函數調用

9、函數參數默認值：

 

#代碼例子

def login(host=’192.168.133.128′,port=’8888′,username=’wcl’,password=’wwww’):

print(‘{}:{}@{}/{}’.format(host, port, username, password))

login()

login(‘127.0.0.1’, 80, ‘wcl’, ‘wcl’)

login(‘127.0.0.1′, username=’root’)

login(‘localhost’, port=80,password=’com’)

login(port=80, password=’wcl’, host=’www’)

#打印出來的

192.168.133.128:8888@wcl/wwww

127.0.0.1:80@wcl/wcl

127.0.0.1:8888@root/wwww

localhost:80@wcl/com

www:80@wcl/wcl

最常用的，常見的參數放在前面。

缺省值往往都會使用。

10、可變參數

問題：有多個數沒需要累加求和。

def add（nums）：

傳入的參數是一個，可以是列表，集合或者是元組。

#代碼例子

def add(nums):

sum = 0

for i in nums:

sum+=i

return sum

add([1,2,3])

#例子

def add(nums):

sum = 0

for i in nums:

sum+=i

return sum

add((1,2,3))

1)可變參數：

一個形參可以匹配任意個參數。

位置參數的可變參數：

有多個數，在形參前面使用*標示該形參是可變參數，可以接收多個實參。

收集多個實參為一個tuple

沒有return的返回的是一個值none。

#代碼示例

def add(*nums):

sum =0

for i in nums:

sum +=i

print(sum)

add(3,5,6)

14

2)關鍵字參數的可變參數。

形參前使用**符號，表示可以接手多個關鍵字參數。

收集 的實參名稱和值組成一個字典。

不帶*號的往前放，*號多的放后面。

#代碼例子

def showconfig(**kwargs):

for k,v in kwargs.items():

print(‘{}={}’.format(k,v))

showconfig(host=’192.168.133.128′,port=’8888′,usrname=’root’,passeord=’wwww’)

#打印出的結果;

host=192.168.133.128

passeord=wwww

usrname=root

port=8888

 

#位置參數和關鍵字參數混合

def showconfig(nsername,*args,**kwsrgs):

 

#def showconfig(x,y,*args,**kwargs):

print(x)

print(y)

print(args)

print(kwargs)

showconfig(3,4,6,7,8,a=1,b=’python’)

#打印

3

4

(6, 7, 8)

{‘b’: ‘python’, ‘a’: 1}

11、可變參數的總結

有位置可變參數和關鍵字可變參數。

位置參數在可變參數的形參前面使用一個*。

關鍵字可變參數在形參前面使用兩個**。

位置可變參數和關鍵字，都可以收集如干個實參，位置參數收集形成一個tuple 關鍵字參數收集形成一個dict。

混合使用參數的時候，可變參數要放到參數列表的最后，普通參數需要放到參數列表前面，位置可變參數需要在關鍵字可變參數

12、keyword-only參數

如果在一個星號參數后，或者一個位置可變參數后，出現的普通參數，實際上已經不是普通的參數了，而是keyword-only參數.

#例子

def fn(*args,x):

print(x)

print(args)

fn(3,5,x=7)

13、def fn（*，x，y）：

*號之后，普通形參都（變成了關鍵字參數，不在是位置參數了）。都必須給出keyword-noly。

只有可變的才可以給0個，不可變對的必須給定其值。

14、def可變參數和默認值。

#例子

def fn(*args,x=5):

print(x)

print(args)

fn(1,12,4,x=3)

15、參數規則

參數列表參數一般順序是：普通參數、缺省參數，可變位置參數，keyword-only參數（可帶缺省值），可變關鍵字參數。

#代碼示例

def fn(x,y,z=3,*arg,m=4,n,**kwargs):

print(x,y,z,m,n)

print(args)

print(kwargs)

fn(1,2,n=3)

16、參數解構

不僅可以解構數據類型，還可以解構可迭代對象。

 

 

給函數提供實參的時候，可以在集合類型前面使用*或者**。

非字典類型使用*

字典類型使用**

提出出來的元素數目要和形參需要的參數一致。

#代碼練習

def add(x,y,*args):

return x+y

add(*[1,2,3,4,5])

#代碼練習

def add(x,y,*args):

return x+y

add(**{‘x’:3,’y’:5})

 

 

#結構字典

d1={‘x’:3,’y’:5}

def add(x,y,*args):

return x+y

add(*d1.keys())

#結構字典

d1={‘x’:3,’y’:5}

def add(x,y,*args):

return x+y

add(*d1.values())

 

傳參時候的方式，

結構，配參。

17、python插入式排序。

1)直接插入排序。

直接插入排序原理。

在未排序的序列中，構建一個子排序序列，直至全部數據按照要求排序完成。

將待排序的數，插入到已經排序的序列中合適的位置。

增加一個哨兵，放入待比較值，讓他和后面已經排好序的序列比較，插入合適的地方。

2）原理：增加一個哨兵位，每輪比較將待比較數放入。

哨兵依次和待比較的前一個數據比較，大的數靠右移動，找到哨兵中的值插入位置》

每一輪結束后，得到一個從開始到待比較數的位置的一個有序序列。

3)總結

最好情況，正好是升序排列，比較迭代n-1次。

最差情況，正好是降序排列，比較迭代1,2，，…..n-1即n（n-1）/2

使用兩層嵌套循環，時間復雜度O（n**2）

穩定排序算法。

使用在小規模數據比較

優化點：

如果比較操作耗時大的話，可以采用二分查找的方式來提高效率。

 

 

#代碼練習

h5=[5,6,3,7,8,9,1,2,4,0]

nums1=[0]+h5

length=len(nums1)

for i in range(2,length):

nums1[0]=nums1[i]

j=i-1

if nums1[j]>nums1[0]:

while nums1[j]>nums1[0]:

nums1[j+1]=nums1[j]

j-=1

nums1[j+1]=nums1[0]

print(nums1[1:])

18、函數的返回值及作用域

1）里面包含隱式轉換。

return只會返回一個。

ruturn 語句的本質也是打斷。

#def showplus(x):

print(x)

return x+1

showplus(5)

print會執行語句。

#def showplus(x):

print(x)

return x+1

print(x+1)

后面的print不會執行，遇到return其實就是打斷。相當于break。

#def showplus(x):

print(x)

return x+1

return x+2

只有一個返回語句，第一個返回就相當于被打斷。

2）總結

使用return語句返回“返回值”

所有函數都有返回值，如果沒有return返回語句，返回的是none.

Return 并一定是函數語句塊的最后一條語句。

一個函數存在多個return語句，但是只一條可以被執行。沒有return語句，返回的none

如果有必要，可以顯示調用return none，可以簡寫為return。

如果函數執行了return語句，函數就會返回返回值，后面的語句就不會被執行。

作用：結束函數調用，返回值。

3）函數的返回值

#def showlist():

return [1,3,5]

返回多個值

函數不能同時返回多個值，return[1,3,5]是指明返回一個列表，是一個列表對象。

return1,3,5看似是多個值，但是隱士的被封裝了。

#def showlist():

return 1,3,5

#(1, 3, 5)

X,y,z=shoulist()使用結構提取更方便。

4）函數的嵌套。

函數內可以定義函數。

 

#def f1():

def f2():

print(‘f2’)

print(‘f1’)

f2()

f1()

#調用f2()的時候就會報錯，因為f2()是在內層函數中定義的。

函數有可見范圍，這就是作用域概念。

內部函數不能直接被外部使用，會拋出nameError異常。

19、作用域。***

函數內在函數外是找不到的。

外部在內部是可見的。

概念：一個標示符的可見范圍，這就是標示符的作用域，一般指的是變量的作用范圍。

全局作用域：在整個程序運行環境中都可見。globl

局部作用域：在函數、類等內部可見。局部變量使用范圍內不能超過其所在的局部作用域。local.

#def fn1():

x=1

def fn2():

print(x)

fn2()

fn1()

#def f3():

o=65

def f4():

print(‘f4:{}’.format(o))

print(chr(o))

print(‘f3:{}’.format(o))

f4()

f3()

#f3:65

f4:65

A

 

內部函數o使用外層函數定義的o的值。

#def f3():

o=65

def f4():

o=97

print(‘f4:{}’.format(o))

print(chr(o))

print(‘f3:{}’.format(o))

f4()

f3()

#f3:65

f4:97

a

賦值即定義。

 

#

x=5

def foo():

x+=1

print(x)

foo()

本地變量x沒有被定義，就拿出使用，本地的x只是空的值。

#

x=5

def foo():

y=x+1

print(y)

foo()

本地可以，因為這樣的利用的全局變量x。

在小環境中必須重新進行定義的。

20、全局變量global

#例子

x=5

def foo():

global x

x+=1

print(x)

foo()

使用global關鍵字的變量，將foo內的x聲明為使用外部的全局作用域。

#x=5

def foo():

global x

x=10

x+=1

print(x)

foo()

利用global把x定義為了全局變量，但是內部函數在定義x=10是沒有作用的。

內部作用域使用x=5之類的賦值語句會重新定義局部變量x。如果利用global ?把x一旦聲明為全局變量，那么x=5相當于為全局作用域賦值。

global總結

x+=1這種特殊的形式產生錯誤的原因，先引用后賦值，python是賦值才算定義。才能被引用。

global的使用原則：基本不使用。

外部作用域變量會內部作用域可見，但是也不要在這個內部的局部作用域內直接使用，因為函數的目的就是為了封裝。

如果需要外部全局變量，使用函數傳參的方式。

21、閉包

自由變量：未在本地作用域中定義的變量，例如定義在內層函數外的外層函數的作用域中的變量。

閉包：就是一個概念，出現在嵌套函數中，指的是內層函數引用到了外層函數的的自自由變量，就是形成了閉包。(內層函數用到了外層函數的自由變量）

 

#def f1():

c = [0](是一個自由變量)

def f2():

c[0] +=1

return c[0]

return f2

f=f1()

print(f(),f())

print(f())

Python3中可以使用nonlocal來實現閉包

global只是在聲明的和最外部的作用。

 

使用global可以解決，但是這種使用的是全局變量，而不是閉包。

22、nonlocal

使用了nonlocal關鍵字，將變量標記在上級的局部作用域中定義，但不能不是全局作用域中定義。

 

#def counter():

count=0

def inc():

nonlocal count ?（利用nonlocal）

count +=1

return count

return inc

foo = counter()

foo()

foo()

Count是外層函數的局部變量，被內存函數引用。

內部函數使用nonlocal關鍵字聲明變量count在上級作用域中而非在本地中定義。

代碼可以運行，并形成閉包。

nonlocal不是全局作用域中的。

23、默認值作用域

#def foo(xyz=[]):

xyz.append(1)

print(xyz)

foo()

foo()

Print(xyz)#只會報錯，因為未定義變量xyz。Xyz知識本地變量。

屬性，多次打印的數值會變化。

#例子題

def foo (xyz=1):

print(xyz)

foo()

foo()

print(xyz)

Print(xyz)#只會報錯，因為未定義變量xyz。Xyz知識本地變量。

為什么第二次打印是list中元素增加呢？

因為函數也是對象，把函數的默認值放在了屬性中，這個屬性就伴隨著這個函數對象整個生命周期。 ???查看屬性：foo._defaults_

函數的地址并沒有改變，就是說函數的對象沒有變，調用它，他的屬性利用元素來保存所有的默認值。Xyz只是默認值的引用類型，引用類型的元素變動，而不是整個元組變動。

#例子。

def foo(xyz=[],u=’abc’,z=123):

xyz.append(1)

return xyz

print(foo(),id(foo))

print(foo.__defaults__)

print(foo(),id(foo))

print(foo.__defaults__)

#out

[1] 140682069694800

([1], ‘abc’, 123)

[1, 1] 140682069694800

([1, 1], ‘abc’, 123)

屬性__defaults__中使用元組保存所有位置參數默認值，他不會因為在函數體內使用了他而發生改變。

 

#例題

def foo(w,u=’abc’,*,z=123,zz=[456]):

u=’xyz’

z=789

zz.append(1)

print(w,u,z,zz)

print(foo.__defaults__)

foo(‘magedu’)

print(foo.__defaults__)

屬性__defaults__中使用元組保存所有位置參數默認值。

屬性__kwdefaults__中使用字典保存所有keyword-noly參數的默認值。

 

默認值的作用域

使用可變類型作為默認值，就可以修改這個值。

有些時候有用，有些時候特性不好，有副作用。

改變的話有兩種方法。

24、改變特性的兩個方式。

第一種方法：使用影子拷貝創建一個新的對象，永遠不能改變傳入的參數。

函數體內，不改變默認值。

xyz都是傳入參數或者默認參數的副本，如就想修改參數，無能為力。

#例題：

def foo (xyz=[],u=’abc’,z=123):

xyz = xyz[:]

xyz.append(1)

print(xyz)

foo()

print(foo.__defaults__)

foo()

print(foo.__defaults__)

foo()

foo([10])

print(foo.__defaults__)

foo([10,5])

print(foo.__defaults__)

第二種方法：通過值得判斷就可以靈活的選擇創建或者修改傳入的對象。(最常用）

很多函數 的定義，都可以看到使用None這個不可變的值作為默認參數，一種慣用方式。

使用不可變類型的默認值

如果使用缺省值None就創建一個列表

如果傳入一個列表，就修改這個列表。

#例題

def fn(xyz=None,u=’abc’,z=123):

if xyz is None:

xyz=[]

xyz.append(1)

return xyz

lst = fn()

a=foo(lst)

print(a)

#輸出結果

[1, 1]

None

25、函數的銷毀

1）全局函數銷毀

重新定義同名函數

Del語句刪除函數對象

程序結束時

#例題

def foo(xyz=[],u=’abc’,z=123):

xyz.append(1)

return xyz

print(foo(),id(foo),foo.__defaults__)

def foo(xyz=[],u=’abc’,z=123):

xyz.append(1)

return xyz

print(foo(),id(foo),foo.__defaults__)

del foo

print(foo(),id(foo),foo.__defaults__)

2）局部函數銷毀

重新在上級作用域中進行定義同名函數。

del刪除語句刪除函數對象

上級作用域銷毀時。

#試題：

def foo(xyz=[],u=’abc’,z=123):

xyz.append(1)

def inner(a=10):

pass

print(inner)

def inner(a=100):

print(xyz)

print(inner)

return inner

bar=foo()

print(id(foo),id(bar),foo.__defaults__,bar.__defaults__)

del bar

print(id(foo),id(bar),foo.__defaults__,bar.__defaults__)

26、樹

1)非線性結構，每個元素可以有多個前驅和后繼。

2)樹是n（n>=0）個元素的集合。

n=0時，稱為空樹。

樹只有一個特殊的沒有前驅的元素，稱為樹的根root。

樹中除了根節點外，其余元素只能有一個前驅，可以有零個或者多個后繼。

3)遞歸定義

樹T是n（n>=0）個元素的集合，n=0時，稱為空樹。

有且只有一個特殊元素根，剩余元素都可以被劃分為m個互不相交的集合T1、T2、T3、…..、Tm，而每個元素都是樹，稱為T的子樹。

子樹也有自己的根。

4)樹的概念

結點：樹中的數據元素。

結點的度degree：結點擁有子樹的樹木稱為度。記作d（v）。

葉子結點：結點度為0，稱為葉子結點leaf、終端結點、末端結點。

分支結點：:結點的度不為0，稱為非終端結點或分支結點。

分支：結點之間的關系

內部結點：除了根結點外的分支結點，不包括子結點。

樹的度是樹內各結點的度的最大值。D的結點度最大為3，樹的度數就是3.

孩子結點：結點的子樹的根結點成為該結點的孩子。

雙親結點：一個結點是它各子樹的根結點的雙親。

兄弟結點：具有相同雙親結點的結點：

祖先結點：祖先結點：從根結點到該結點所經分支上所有的結點。Ａ、Ｂ、Ｄ都是Ｇ的祖先結點。

子孫結點：結點的所有子樹上的結點都是該結點的子孫》Ｂ的子孫是ＤＧＨＩ

結點的層次：根結點為第一層，根的孩子為第二層，依次類推，記作Ｌ（ｖ）

樹的深度（高度Ｄepth）：樹的層次的最大值，上圖的樹深度為４

堂兄弟：雙親的同一層的結點

有序樹：結點的子樹是有順序的（兄弟有大小，有先后次序），不能交換。

無序樹:結點的子樹是有無序的，可以交換。

路徑：樹中的k個結點n1、n2、….、nk。滿足ni是n（i+1）的雙親，成為你到nk的一條路徑。就是一條線串下來的，前一個都是后一個的父（前驅）結點。 ?路徑就是一串從上到下：a到g。

路徑長度=路徑上的結點樹-1，也是分支樹。長度就是-1.

森林：m（m》=0）棵不相交的樹的集合，對于結點而言，其樹的集合就是森林。A的結點的2棵子樹的集合就是森林。

5）樹的特點

唯一的根

子樹不相交

除了根以外。每個元素只能有一個前驅，可以有零個或者多個后繼。

根結點就沒有雙親結點(前驅），葉子結點沒有孩子結點（后繼）

Vi是vj的雙親，則L（vi）=L（vi）-1，也就是雙親比孩子結點的層次小1.

堂兄弟的雙親不一定是兄弟關系。

27、二叉樹

1)每個結點最多兩棵子樹。（二叉樹不存在度數大于2的結點）

是有序樹，左子樹，右子樹是順序的，不能交換次序。

即使某個結點只有一個結點，也要確定其為左子樹還是右子樹。

2)二叉樹的五種基本形態。

空二叉樹

只有一個根結點

根結點只有左子樹

根結點只有右子樹

根結點左右都有子樹。

3)斜樹：

左斜樹，所有結點都在左結點。

右斜樹，所有結點都在右結點。

4)滿二叉樹

一顆二叉樹的所有分支結點都存在左子樹和右子樹，并且所有葉子結點只是存在最下面一層。

K為深度 ，結點總數為（2**k）-1

5）完全二叉樹：(滿二叉樹是完全二叉樹，但是完全二叉樹不一定是滿二叉樹。）

若二叉樹的深度為k,二叉樹的層數從1到k-1層的結點樹都達到了最大數,在第k層的所有的結點都集中在左邊,這就是完全二叉樹.

完全二叉樹由滿二叉樹引出.

K為深度(1<=k<=n\),則結點總數的最大值為2**k-1,當達到最大值的時候就是滿二叉樹.

6)二叉樹的性質：

性質1：在二叉樹的第i層上至多有2^i -1個結點（i》=1） #例如第二層有兩個結點.

性質2：深度為k的二叉樹,至多有2**k-1個結點,一層:2-1 ??二層 4-1=1+2+3 ?三層8-1=1+2+4=7

性質3：對任何一顆二叉樹T,如果其終端結點樹為n0,度數為2的結點為n2,則有n0=n2+1(就是葉子樹結點的樹-1就等于度數為2的結點樹.

證明:總結點數n=n1+n2+n3.

一棵樹的分支數為n-1，因為除了根結點外。其余結點都有一個分支,n0+n1+n2-1.

分支數還等于n0*0+n1*1+n2*2,n2是2分支結點所以乘以2,2*n2+n1.

可得2*n2+n1=n0+n1+n2-1=>n2=n0-1

 

7）其它性質：

高度為k的二叉樹,至少有k個結點

含有n(n>=1)的結點的二叉樹高度至多為n。

含有n(n>=1)的結點樹的二叉樹的高度至多為n，最小為math.ceil（log2（n+1）），不小于對數值的最小整數， 向上取整。層次樹是取整.

如果是8個結點,向上取整為4,為4層.

性質4:具有n個結點的完全二叉樹的深度為int(log.n)+1或者math.ceil(log2(n+1))

性質5:如果有一顆n個結點的完全二叉樹(深度為性質4),結點按照層序編號.

如果i=1,則結點i是二叉樹的根,無雙親,;如果i>1,則雙親是int（i/2），向下取整。就是子結點的編號整除2得到的就是父結點的編號，父結點如果是i，那么左孩子的結點就是2i，右結點是2i+1.

如果2i》n，則結點i無左孩子，即結點為葉子結點，否則其左孩子結點存在編號為2i

如果2i+1》n，則結點i無右孩子，不能說明結點i沒有左孩子，否則右孩子的結點存在編號為2i+1.

28、試題練習

#打印三角數字序列

def fn(n):
f1=” “.join([str(i)for i in range(n,0,-1)])
length=len(f1)
for i in range(1,n):
print(‘{:>{}}’.format(” “.join([str(j) for j in range(i,0,-1)]),length))
print(f1)
fn(12)

#打印三角數字序列

def showtail(n):
tail = ” “.join([str(i)for i in range(n,0,-1)])
print(tail)
for i in range(len(tail)):
if tail[i] == ‘ ‘:
print(‘ ‘*i,tail[i+1:])
showtail(12)

#打印輸入至少是哪個數字，返回極大值和極小值。

def fn(a,b,*args):
print(max(a,b,*args))
print(min(a,b,*args))

#插入排序

h5=[5,6,3,7,8,9,1,2,4,0]
nums=[0]+h5
length=len(nums)
for i in range(2,length):
nums[0]=nums[i]
j=i-1
if nums[j]>nums[0]:
while nums[j]>nums[0]:
nums[j+1]=nums[j]
j -=1
nums[j+1]=nums[0]
print(nums[1:])