Python數據結構

• 一、數據結構。
• 分類：數值型，int ?浮點型 float，復數complex， bool 布爾值。
• 序列對象， 字符串str ?列表 list。 Tuple ??元祖。
• 鍵值對：集合set，字典dict。
• 數值型。
• int、float、complex。bool都是class，1,5.0,2+3j都是對象即實例。
• int 長整型，沒有大小限制，受限于內存區域的大小。
• float，有整數和小數部分組成，支持十進制和科學計數法表示，只有雙精度。
• complex。有實數和虛數部分組成，實數和虛數都是浮點數、3+4.2j。
• bool ：int的子類，僅有兩個實例，True ?和Flase，對應的1和0，可以和整數直接運算。
• 類型轉換。
• int(x)；返回一個整數.查看幫助文檔
• float(x)；返回一個浮點數
• complex(x)；返回一個復數。
• bool(x)；返回布爾值，和前面的Flase等價。
• 數字處理函數。
• 導入的math函數（import math ）(floor地板向下取整 ?ceil .天花板 向上取整數->是math模塊中的)
• int() 取整數部分。
• round()函數 四舍六入五取偶。取向他最近的偶數靠近。
• // ?正數負數全部往地板走。地板 整除且向下取整。
• min() ?max() ?pow(x,y)等于x**y。次冪。sqrt()。min（1，2，3，）比較大小的。
• 進制函數：返回的是字符串。

bin（） ?oct（） ??hex（） ??math.pi ?3.14 ???math.e

• 數據類型。數據類型判斷，返回的是類型，而不是字符串。

字符串要加單引號。

type（）

type(‘a’)

• 類型判斷

type()

isinstance(obj,class_or-tuple)

isinstance()返回布爾值。

隱式轉化。。（type（1+true+2.1））float。。type（1+True) ?int . ?????isinstance(1,int)

二、列表list。

一個隊列，一個排列整齊的隊伍，列表內的個體稱作元素，由若干元素組成列表。

元素可以是任意個對象（數字，字符串，對象，列表等）。列表內元素有順序，可以使用索引(編號在0開始)，線性的數據結構。使用[]表示。 (列表是個對象，列表內的元素也可以是個列表） 列表是可變的..(有編號未必是連續的)

1)list ?鏈表 ?queue ?stack的差異。

list ,(列表)。可以中間插隊，前后均可以插隊。線性數據結構。

queue ,(隊列)。不可以中間插隊，先進先出，后進先出都可以。線性模型。

stack. 棧。函數。只能后進先出。（羅盤子）函數中用的最多的。

鏈表：不連續的。通常是上級指向下級，下級指向上級。手拉手形式。內存中散落著。

2）列表list定義，初始化。

lsit()->new empty list

list(iterable)->

list不能一開始就定義大小。

list()可迭代對象。

lst=list

lst=[]

lst=list[2,6,9,’ab’]

lst=list(range(5))

(使用方式：list（range（1,3）[2,6,9,’ab’] )..

可索引和可迭代兩個概念。

list可迭代對象和可索引的。：

迭代（亂拿方式），索引（按照序號拿出）

3）列表的索引，也叫下標。內存上連續的空間。

正索引：從左到右，從0開始，為列表中的每一個元素編號，按照順序編號。

負索引：從右到左，從-1開始。

正索引不可以超界，否則引發異常IndexError。索引是不可以超界的。

為了理解方便，可以理解列表是從左至右排列的 。左邊是頭部，右邊是尾部，左邊是下界，右邊是上界。

列表通過索引訪問。

(lst=list(range(5)) ?lst[-5]

4）、列表查詢。

（1）、Index（value，[start,[stop]]]）（[]可以寫，可以不寫。）通過值value，從指定區間查找列表內的元素是否匹配。匹配第一個就立即返回索引。匹配不到，拋出valueErr 。 ????lst.index（1，-1）

lst.index() ?( 返回的是索引號)

使用負索引的時候必須要高度注意索引方向。

（2）、count（value）

返回列表中匹配的value的次數。lst.count(1)

（3）、時間復雜度：

index和count方法都是O（n）。建議不常用。

隨著列表元素數據規模的增大，而效率下降。

（4）、len()。

用來計數的,計算長度的。。

（5）、查看幫助：

官方幫助文檔，搜索關鍵字；

ipython中：help（keyword），，keyword可以是變量、對象、類名、函數名、方法名。

5）、列表元素修改：

索引訪問權限修改：（修改其元素值）list[index]=value ???索引不能超界。 ?lst[2]=200

6）、列表增加、插入元素。

（1)append(object)->None不會返回有效的值。 ???lst.append(200) ??加幾個元素都是依次寫。

列表尾部追加元素，返回none值。

返回none就意味著沒有新的列表產生，就地修改。

時間復雜度是O（1）

（2)insert（index，object）->None. ?????lst.insert(4,300)

在指定的索引index處插入元素object

返回None就意味著沒有新的列表產生，就地修改。

時間復雜度是O（n）

索引能超上下界嗎？

超越上屆，尾部追加。

超越下界，頭部追加。

（3)extend（iteratable）-> None ??????lst.extend(range(11,16))

將可迭代對象的元素追加進來，返回none。

就地修改。

簡單的類型，引用類型。

（4）+ -> list ?????lst +list(range(17,20))

連接操作，將兩個列表連接起來

產生新的列表，原列表不會改變。

（5)* -> list ????????[‘a1’]*5

重復操作，將本列表元素重復n次，返回新的列表本質上調用的是__add__(

7）、單支類型，復雜類型（引用類型）*3,相當于復制的是地址，(一個變，三個全部變)。

復雜類型：x = [[1,2,3]]*3

print(x)x[0][1] = 20print(x）

簡單類型：y = [1]*5

y[0] = 6

y[1] = 7

print(y)

8）列表刪除元素。

（1）remove（value）->none. ?????remove(200)

從左至右查找第一個匹配value的值，移除該元素，返回none。。。

就地修改。。。

效率。

（2）pop([index])->item. ???????????n=list(range(1,9)) ????n.pop()

不指定索引index，就從列表尾部彈出一個元素。O（1）

制定索引index，就從索引處彈出一個元素，索引超界拋出IndexErr。O（n）

（3）clear（）->none。 ????????list.clear(n)

清除列表所有元素，剩下一個空列表。慎重使用，會產生大量的垃圾，建議使用方法就是覆蓋（重新賦值）避免使用。

9）、列表其它操作。

（1)reverse()->None ???????????????n.reverse()

將列表元素反轉，返回None。

就地修改。。讀取的時候進行調頭

列表反轉的迭代器。 ??reversed(n)

for i in reversed(n):

print(i)

能夠立刻使用的的可迭代器。list(reversed(n)) 不耽誤別人使用。

迭代器是一個可迭代對象。

（2）in

判斷成員是否所在元素組里面。[3,4] in [1, 2, [3,4]]

（3)sort（key=None,reverse=Flase）->None

對列表元素進行排序，就地修改，默認升序。

reverse為True，反轉，降序。

key一個函數，指定key如何排序。

lst.sort(key=functionname)

（）括號里面有*號必須按照要求寫。

lst.sort(key=str) ???利用str函數進行排序。

lst.sort（key=int）利用int進行排序。

lst.sort(key=functionname)

sorted(lst,key=str) ?不影響原來列表，不會就地修改。生成新的列表。

10）列表復制。

（1)Shadow copy，影子拷貝，也叫淺拷貝，遇到引用類型，只是復制了一個引用而已.

lst1=lst0…只是地址相同，復制的是地址。

Copy（）-》list

Shadow copy ?返回一個新的列表。(影子復制)

Id(list)顯示的是內存地址。

遇到乘法和copy淺拷貝，只是拷貝的地址，簡單類型的就是復制，復雜類型的復制的是地址。

（2)深拷貝，copy模塊提供了deepcopy。

import copy

lst0 = [1, [2, 3, 4], 5]

lst5 = copy.deepcopy(lst0)

lst5[1][1] = 20

lst5 == lst0

淺拷貝：簡單類型元模原樣復制，引用類型復制的是地址。引用類型里面改變一個全部變。

深拷貝：簡單類型元模原樣復制，引用類型是按照地址重新復制一份。改變一個不影響另外一個。

拷貝總結：lst=[1,2,3,4]

lst1=lst ?#同一個對象。

lst2=lst.copy（）#內容相同，不同的對象，遇到引用類型不會復制對象，只會復制地址。

lst3=copy，deepcopy（lst）#內容相同，但不同的對象，如果有引用類型也會復制出不同的對象。

11）random模塊

（1）導入import random。

（2）randint（a，b）之間返回一個隨機數.

（3）choice（seq）從非空序列的元素中隨意挑選一個元素，random.choice（range（10）。random([1,3,5,7]).

（4）randrange ([start,] stop [,step]) 從指定范圍內,按照指定基數遞歸的一個集合中獲取一個隨機數，基數缺省值為1. ????random.randrange(1,7,2)

（5）random.shuffle(list) ->None 就地打亂列表元素 ?random.shuffle(lst0)

（6）sample(population, k) 從樣本空間或總體（序列或者集合類型）中隨機取出k個不同的元素，返回一個新的列表.random.sample([‘a’,’a’,’a’,’a’],2)

for i in range（10）

Print（random.randint（1,6）)

三、元組tuple

1、元組的介紹。

1）一個有序的元素組成的集合?？傻?，可索引。

使用小括號表示。（）

元組是不可變的對象。（放的對象是不可變的，不可以給予賦值）。表達形式t1=（1，）

地址不可以改變，里面的內容可以改變。元組地址不允許更改。只是只讀數據，不可以進行修改。

2）Map函數按照字符串一一轉換。字節。\n ?10 ???\r ?13

• —127，按照表比較。比較的是一個個字節。
• 有out才有返回值。

A=print() ??print只會打印到屏幕。不會給其值。

A=tuple（） ??給其值 ，但是返回的是空值。

2、元組的定義 初始化

1)定義

2)tuple() -> empty tuple

3)tuple(iterable) -> tuple initialized from iterable’s items

t = tuple() # 工廠方法

t = ()

t = tuple(range(1,7,2)) # iteratable

t = (2,4,6,3,4,2)

t = (1,) # 一個元素元組的定義，注意有個逗號

t = (1,)*5

t = (1,2,3) * 6

3、元組元素的訪問

支持索引（下標）。

正索引：從左至右，從0開始，為列表中的每一個元素編號。

負索引：從右至左，從-1開始。不可變的所以不能進行賦值。

正負索引不可以超界，否則引發異常。

元組通過索引訪問。tuple[index],index就是索引，使用中括號訪問。t[-2]

4、元組查詢

• index(value,[start,[stop]])
• count(value).
• 時間復雜度…index和count的方法都是O（n）。隨著列表數據規模的增大，而效率下降。
• len(tuple)返回元素的個數。

5、元組其它操作。

元組是只讀的，所以增，改，刪方法都沒有。

6、命名元組namedtuple，（面向對象）。

namedtuple，更改元組名字。

Import collectios

Point=collections.Namedtuple（‘_Point’，【‘x’，‘y’】）

P=Point(11,22)

(point只是標示符）

四、冒泡法。

1）屬于交換排序。

2）兩兩比較大小，交換位置。如同水泡。

3）結果分為升序和降序。

4）總結。

*冒泡法需要數據一輪輪的比較。

*可以設定一個標記判斷此輪是否有數據交換發生，如果沒有發生交換，可以結束排序，如果發生交換，繼續下一輪排序

*最差的排序情況是，初始順序與目標順序完全相反，遍歷次數1,…,n-1之和n(n-1)/2

*最好的排序情況是，初始順序與目標順序完全相同，遍歷次數n-1

*時間復雜度O(n**2)（是由于兩層循環得來的。）

*空間復雜度。O(1)

五、字符串

1）字符串是不可變的對象。（可變的是重新拼接組成的新的字符串）

• 一個個字符組成的有序的序列，是字符的集合。
• 使用單雙號、雙引號、三引號引住的字符序列。描述字符串，沒有放字符的為空字符串，長度為0，等同于None。
• Python3中字符串就是unicode—-8類型的。
• 生成新的值。Utf-8。
• 字符串定義初始化。 ?s2=”string” ??s3=”’this is a”string””’ ???s5=’c:\windows\nt’打印帶出斜杠的。
• 字符串元素訪問—–下標。
• 字符串支持使用索引訪問。 ?sql[3].
• join 把可迭代對象的一個個字符串連接起來。

可迭代對象本身元素都是字符串。 ?“string”.join(iterbale)->str

返回一個新的字符串。 ?????‘—‘.join(map(str,lst))

• map(str.lst)轉換為字符串的方式。
• 字符串+連接
• + -》str。將兩個字符串拼接在一起，返回一個新的字符串。‘a’*2
• 字符串的分割。分為兩類。
• Split() 沒有指定，盡可能多的空白字符作為一個空白分隔符?！?

Split（sep=none,maxsplit=1）。不指定分隔符的時候，默認以空白字符進行分割。

“a ??b\tc”.split() ???????從左至右

p sep 指定分割字符串，缺省的情況下空白字符串作為分隔符

p maxsplit 指定分割的次數，-1 表示遍歷整個字符串.

切的函數都是一刀兩斷。 ?????“a,b,c,d,e”.split(‘,’,2) ????????不支持正則表達式。

2)rsplit(sep=None, maxsplit=-1) -> list of strings

*從右向左

*sep 指定分割字符串，缺省的情況下空白字符串作為分隔符

* maxsplit 指定分割的次數，-1 表示遍歷整個字符串.

3)splitlines([keepends]) -> list of strings

* 按照行來切分字符串

* keepends 指的是是否保留行分隔符

* 行分隔符包括\n、\r\n、\r等

()括號里面的添加True，切割后顯示分隔符。False不顯示分隔符。

4）Partition(seq)->(head,seq,tail)切割。切割完成后返回的是三元組。

從左至右，遇到分隔符就把分隔符分割成兩部分，返回頭、分隔符、尾三部分的三元組。如果沒找到分隔符，就返回頭，2個空元素的三元組。

Seq必須界定分隔符，必須制定。

5)rpartition(seq)->(head,seq,tail),從右至左，到分隔符就把分隔符分割成兩部分，返回頭、分隔符、尾三部分的三元組。如果沒找到分隔符，就返回頭，2個空元素的三元組。

6）字符串大小寫

1)upper全是大寫。 ???lower全是小寫。 swapcase()交互式大小寫。if a.lower()=’abc’:

7）字符串排版

title() 標題的每個字母首字母都大寫。

capitalize()首個單詞大寫。

center(width[,fillchar]) ?->str ???width打印的寬度，，，fillchar填充的字符。

zfill(didth) ??width打印寬度，居右。）

8）、字符串修改。

（1)replace(old,new[,count])—->str**

字符串中查找到匹配替換為新字串，返回新的字符串。

count表示替換幾次，不指定就是全部替換。

（2)Strip（[chars]）->str

把兩頭的符合要求的字符串全部去掉。char作為集合，去掉字符集。

如果char沒有指定字符，那么就去掉兩頭的空白字符。

s=’very very very good’…..s.strip(‘ very’)

lstrip([chars]) -> str

從左開始

rstrip([chars]) -> str

從右開始

9）find();

找得到返回的是索引，未找到返回的是-1.

find(sub[, start[, end]]) -> int ???s.find(‘very’)

在指定的區間[start, end)，從左至右，查找子串sub。找到返回索引，沒找到返回-1

rfind(sub[, start[, end]]) -> int

在指定的區間[start, end)，從右至左，查找子串sub。找到返回索引，沒找到返回-1

10）字符串查找

index(sub[, start[, end]]) -> int

在指定的區間[start, end)，從左至右，查找子串sub。找到返回索引，沒找到拋出異常ValueError

rindex(sub[, start[, end]]) -> int

在指定的區間[start, end)，從左至右，查找子串sub。找到返回索引，沒找到拋出異常ValueError

• 字符串查找。
• 時間復雜度，index和count方法都是O（n）。
• 隨著列表數據規模的增大，而效率下降。
• len（string）返回字符串的長度，即字符串的個數。

11）、count(sub[, start[, end]]) -> int

在指定的區間[start, end)，從左至右，統計子串sub出現的次數。。。s.count(‘very’)

• count(sub[])->int.
• 字符串判斷：

endswith(suffix[, start[, end]]) -> bool

在指定的區間[start, end)，字符串是否是suffix結尾

startswith(prefix[, start[, end]]) -> bool

在指定的區間[start, end)，字符串是否是prefix開頭

12）、字符串判斷 is系列

isalnum() -> bool 是否是字母和數字組成 ???“abc123″.isalnum()

isalpha() 是否是字母

isdecimal() 是否只包含十進制數字

isdigit() 是否全部數字(0~9)

isidentifier() 是不是字母和下劃線開頭，其他都是字母、數字、下劃線

islower() 是否都是小寫

isupper() 是否全部大寫

isspace() 是否只包含空白字符 ??????返回的都是bool值。

Sections(有序的)(常見的面試是排序方法是冒泡法）。

13）字符串格式化。

字符串格式化是一種拼接字符串輸出樣式的手段，更靈活方便。

1）join拼接只能使用 分隔符，且要求被拼接的是可迭代的對象。

2）+拼接字符串比較方便，但是字符串需要先轉換為字符串才能拼接。

printf-style formatting，是來自于c語言風格的print輸出。

3）格式要求：占位符。。使用%和格式字符組成，例如%s，%d。

S調用str, ??r調用repr().所有對象都可以被這兩個轉換?！產’使用ascii。%

占位符中還可以插入修飾字符，例如%03d表示打印3個位置。不夠前面補0.

format % values.格式字符串和被格式化的值之間使用%分隔。

Values只能是一個對象，或者是一個和格式字符串數目相等的元組，或一個字典。

用法：”i am %01s” ?%(3,)

‘i like %s.’%’Python’

4)’%3.2f%% , 0x%x, 0X%02X’ % (89.7654, 10, 15)

可以是?元組，可以是字典。

0x ???0X只是提示符。

5）字符串格式化。

format函數格式。

“{}{***}”。format（args，kwargs）。

Args是位置參數，是一個元組。

Kwargs關鍵字參數，是一個個字典。 ??{}花括號代表占位符。{{}}表示打印花括號。

{}表示按照順序匹配位置參數，{n}標示取位置參數索引為n的值。

{****}表示在關鍵字參數中搜索名稱一致的。

6）字符串格式化。

p 位置參數

“{}:{}”.format(‘192.168.1.100’,8888)，這就是按照位置順序用位置參數替換前面的格式字符串的占位符中

p 關鍵字參數或命名參數

“{server} {1}:{0}”.format(8888, ‘192.168.1.100’, server=’Web Server Info : ‘) ，位置參數按照序號匹配，

關鍵字參數按照名詞匹配

p 訪問元素

“{0[0]}.{0[1]}”.format((‘magedu’,’com’))

p 對象屬性訪問

from collections import namedtuple

Point = namedtuple(‘Point’,’x y’)

p = Point(4,5)

“{{{0.x},{0.y}}}”.format(p)

• “{:^10x}”.format(97)居中對齊。'{0}*{1}={2:<2}’.format(3,2,2*3)
• 進制。”int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}”.format(42)

 

• 1
• a ?97

 

權重。

顯示時間的。

 

有效數字。。（）

六、bytes、bytearray

字符串是字符組成的有序序列，字符可以使用編碼來理解。

1)bytes是不可變的字節，是字節組成的有序的不可變序列。

2)bytearray 是可變的字節，是字節組成的有序的可變序列。

3）編碼與解碼

字符串按照不同的字符集編碼encode返回字節序列bytes。

encode(encoding=’utf-8’?,errors=’strict’)->bytes

b’abcdef’.replace(b’f’,b’k’)

字節序列按照不同的字符集解碼decode返回字符串

bytes.decode(encoding=”utf-8″, errors=”strict”) -> str

4）bytes定義

Bytes() 空的bytes。 Bytes（int）指定字節的bytes，被0填充。

Bytes（iterable_of_ints)->[0,255]的internet組成的可迭代的對象。

Bytes(string,encoding[,errors])->bytes等價于string。Encode（）

Bytes(bytes_or_buffer)->immutable cpoy of bytes_or_buffer從一個字節序列或者buffer復制出一個新的不可變的bytes對象。

使用b前綴定義：

只允許基本ASCII使用字符形式b’abc9’

使用16進制表示b“、x41、x61”

 

5）ASCII表。ASCII（American StandardCode for InformationInterchange，美國信息交換

標準代碼）是基于拉丁字母的一套單字節編碼系統

6）bytes操作

和str類型類似，都是不可變類型，所以方法都一樣，只不過bytes輸入是bytes，輸出也是bytes。

類方法bytes。Formhex（string）

String必須是2個字符的16進制的形式，bytes.fromhex(‘6161 09 6a 6b00’)

Hex()返回十六進制的字符串。

‘abc’.encode().hex()

索引 b‘abcdef’[2]

7）bytearray定義

定義：bytearray()空的bytearray

Bytearray(int)指的是字節的bytearray，被0填充。

Bytearray（iterable_of_ints)->bytearray[0,255]的int組成的可迭代對象。

Bytearray（string，encoding[,errors])->bytearry近似string。Encode（）不過返回可變對象，

Bytearray（bytes_or_buffer)從一個字節序列或者buffer復制出一個新的改變的對象。

B前綴的定義的類型是bytes類型。

8）byearray操作

和bytes類型方法相同。

Bytearray(b’abcdef’).replace(b’f’,b’k’)

Bytearray(b’abc’).find(b’b’)

類方法bytearray.formhex(string)

String必須是2個字符的16進制的形式。

Bytearray。Formhex(‘6162 09 60 6b00’)

hex()

返回16進制表示的字符串。

Bytearray（‘abc’.enconde（））。Hex（）

索引

Bytearray（b’abcdef’）[2]返回該字節對應的數，int類型。

9）bytearray操作。

Append（int）尾部追加一個元素。

Insert（index，int）在指定索引位置插入元素。

Extend(iterable_of_ints)將一個可迭代對象的整數集合追加到當前bytearray

Pop（index=-1）在指定索引上移除元素，默認從尾部移除。

Remove（value）找到第一個value移除，找不到拋出異常。

Clear（）清空

Reverse（）翻轉bytearray，就地修改。

10)提到字符串就得有編碼的概念。

11)字節

12)字節0-255之間。

13)可以索引的數據結構，列表，tuple ??str ??bytearray.

七、切片。

• 線性結構。

可迭代。。。for。。。In。。

len()可以獲取長度。

通過下標可以訪問?？梢郧衅?/p>

• 學過的線性結構：

列表、元組、字符串、bytes ?bytearray.

• 切片：

通過索引區間訪問線性結構的一段數據。

Sequnence[start:stop]表示返回[start,stop]區間的字序列。

支持負索引。

Start為0，可以省略

Stop為末尾，可以省略。

超過上界（右邊界），就取到末尾；超過下界（左邊界），取到開頭。

Start一定要在stop的左邊。

[:]…表示從頭至尾，全部元素被取出，等效于copy（）方法。

生產新的拷貝。

 

練習方法：’www.magedu.com'[:10] ??—-‘www.magedu’

bytearray(b’www.magedu.com’)[-4:10] ????— ?bytearray(b”)

‘www.magedu.com'[:] ?——-‘www.magedu.com’

tuple(‘www.magedu.com’)[-10:10] ?——-(‘m’, ‘a’, ‘g’, ‘e’, ‘d’, ‘u’)

list(‘www.magedu.com’)[-10:-4] ——- ?[‘m’, ‘a’, ‘g’, ‘e’, ‘d’, ‘u’]

• 切片

步長切片

[start:stop:step]

Step為步長，可以正負整數，默認是1；

Step要和start;stop同向，否則返回空序列。

練的例題：’www.magedu.com'[4:10:2]

‘mgd’

 

list(‘www.magedu.com’)[-4:-10:-2]

[‘.’, ‘d’, ‘g’]

八、練習題

1、#求100以內的素數。

b=[2]
for i in range(3,101,2):
for a in b:
if i%a==0:
break
else:
b.append(i)

2、#楊輝數列

n=6
pre=[1]
print(pre)
pre.insert(0,0)
pre.append(0)
for i in range(1,n):
newline=[]
for j in range(i+1):
val=pre[j]+pre[j+1]
newline.append(val)
print(newline)
pre=newline
pre.insert(0,0)
pre.append(0)

#第二種

c=[[1],[1,1]]
for i in range(2,6):
newline=[1]
pre=c[i-1]
for j in range(i-1):
val=pre[j]+pre[j+1]
newline.append(val)
newline.append(1)
c.append(newline)
print(c)

3、#比較三個數大小

nums=[]
for i in range(3):
nums.append(int(input(‘{}:’.format(i))))
while True:
cur=min(nums)
print(cur)
nums.remove(cur)
if len(nums)==1:
print(nums[0])
break

4、#冒泡法排序

#冒泡法排序。
nums=[0,1,3,5]
length=len(nums)
for i in range(length):
for j in range(length-i-1):
if nums[j]>nums[j+1]:
tmp=nums[j]
nums[j]=nums[j+1]
num[j+1]=tmp
print(nums)

5、#輸入5個數字，打印每個數字的位數，將這些數字排序打印，要求升序打印

nums=[]
for i in range(5):
nums.append(int(input(‘{}:’.format(i))))
length=len(str(nums[i]))
print(length)
length=len(nums)
for i in range(length):
for j in range(length-i-1):
if nums[j]>nums[j+1]:
nums[j],nums[j+1]=nums[j+1],nums[j]
print(nums)