bytes、bytearray

#思考下面例子：

a = 1b=aprint(a == b)#True

print(a is b)#True

print(id(a) is id(b))#False

print(id(a) == id(b))#True

1. id()：獲取的是對象在內存中的地址2. is：比對2個變量的對象引用（對象在內存中的地址，即id() 獲得的值）是否相同。如果相同則返回True，否則返回False。換句話說，就是比對2個變量的對象引用是否指向同一個對象。3. ==：比對2個變量指向的對象的內容是否相同。

參考：https://segmentfault.com/q/1010000015117621

#用id(expression a) == id(expression b)來判斷兩個表達式的結果是不是同一個對象的想法是有問題的#只有你能保證對象不會被銷毀的前提下，你才能用 id 來比較兩個對象

print(id(a.__init__) == id(a.zhuangshi))#True

z =a.__init__x=a.zhuangshiprint(id(z) == id(x))#False

print(id(1)is id(1))#False

print(id(1) == id(1))#False

參考：https://www.jianshu.com/p/Rvkrdb

bytes定義

bytes操作

bytearray定義

bytearray操作

線性結構

切片

練習：

#要求m行k個元素#思路1：m行有m個元素，k不能大于m，這個需求需要保存m行的數據，那么可以使用一個嵌套機構[[],[],[]]

triangle=[]

m=5k=4

for i in range(m):#0~4#楊輝三角每行都是以1開頭

row=[1]

triangle.append(row)if i==0:continue

for j in range(1,i):

row.append(triangle[i-1][j-1]+triangle[i-1][j])

row.append(1)print(triangle)print(triangle[m-1][k-1])#上例測試效率：

#思路2：根據楊輝三角的定理：第m行的第k個數可表示為C（m-1，k-1），即為從m-1個不同的元素中取k-1個元素的組合數。

#利用c(n,r)=n!/(r!(n-r)!)

m=9k=5n= m-1r= k-1d= n-r

targets= [] #r,n-r,n

factorial=1

for i in range(1,n+1):

factorial*=iif i==r:

targets.append(factorial)if i==d:

targets.append(factorial)if i==n:

targets.append(factorial)print(targets[2]//(targets[0]*targets[1]))#上例測試效率：

練習2

#方法1，常規寫法

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

count=0for i inrange(len(matrix)):for j in range(i):#j

matrix[i][j]=matrix[j][i]

count+=1

print(matrix)#方法2：利用enumerate函數創建索引

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

count=0for i,row inenumerate(matrix):for j inenumerate(row):if i

matrix[i][j]=matrix[j][i]

count+=1

print(matrix)

練習3

#思路1：首先新建一個空的列表tm，掃描matrix第一行，在tm的第一列從上至下附加，然后在第二列附加，以此列推。

matrix = [[1,2],[3,4],[5,6]]

tm=[]for row inmatrix:for index,col inenumerate(row):if len(tm)

tm.append([])

tm[index].append(col)print(tm)#思路2：考慮能否一次性開辟好空間目標矩陣的內存空間？如果能夠一次性開辟好空間目標矩陣內存空間，那么原矩陣的元素直接移動到轉置矩陣的對稱坐標就行了#在原有矩陣上改動，牽扯到增加元素和減少元素，有些麻煩，所以，定義一個新的矩陣輸出

matrix = [[1,2,3],[4,5,6]]

tm=[[0 for col in range(len(matrix))]for row inrange(len(matrix[0]))]

count=0for i,row inenumerate(tm):for j,col inenumerate(row):

tm[i][j]=tm[j][i]

count+=1

print(matrix)print(tm)print(count)

#考慮上面兩種方法的時間效率比較：(對于大矩陣運算，方法二效率更高一些)#測試發現，其實只要增加到4*4的矩陣，方法二的優勢就開始了。#矩陣規模越大，先開辟空間比后append的效率高！

練習4

#思路：利用類似linux中位圖的思想來記錄當前標記數字是否重復出現

importrandom

nums=[]for _ in range(10):

nums.append(random.randrange(1,21))

length=len(nums)

samenums=[] #記錄相同的數字

diffnums=[] #記錄不同的數字

states=[0]*length #記錄不同的索引異同狀態

for i inrange(length):

flag= False #該狀態表示沒有重復

if states[i]==1:continue

for j in range(i+1,length):#對每一個數將其與之前的數進行比較

if states[j]==1:continue

if nums[i]==nums[j]:

flag=True

states[j]=1

ifflag:

samenums.append(nums[i])

states[i]=1

else:

diffnums.append(nums[i])print(samenums)print(diffnums)

IPython的使用

幫助

shell命令

特殊變量

魔術方法

封裝和解構

解構(unpack)

Python3的解構

丟棄變量

lst=list(range(10))

_,sec,_four,*_,2tail,_=lst

#題目1

_,(*_,a),_=lst#題目2

s="JAVA_HOME=/usr/bin"name,_,path=s.partition('=')#題目3

lst = [1,9,8,5,6,7,4,3,2]for i inrange(len(lst)):

flag=Falsefor j in range(len(lst)-i-1):if(lst[j+1]

lst[j+1],lst[j]=lst[j],lst[j+1]

flag=Trueif notflag:break小結：

解構，是Python提供的很好的功能，可以方便的提取復雜數據結構的值。

配合_的使用，會更加順利。

集set

set定義初始化

初始化set的時候，里面的元素不能是可變類型，如list，bytearray等

set的元素

set增加

set刪除

注意這里的remove是根據hash值來找到元素并移除的！所以時間復雜度是O(1).

set修改、查詢

這個效率相當于用索引訪問順序結構！時間復雜度為O(1)。

set成員運算符的比較

可以看出set集合查詢效率跟數據規模無關！

set和線性結構

集合

集合運算

解題思路：

集合練習

#利用集合來解決

簡單選擇排序

簡單選擇排序代碼實現(一)

簡單選擇排序代碼實現(二)

#二元選擇排序（降序）#lst = [9,2,1,4,5,7,6,8,3]

lst=[1,1,1,1,1,1,1]print("原序列:",lst)

length=len(lst)

count_swap=0

count_iter=0for i in range(length//2):

maxindex=i

minindex= -i-1

#minorginindex = minindex

for j in range(i+1,length-i):#!!!

count_iter += 1

if lst[maxindex]

maxindex=j

count_swap+= 1

if lst[minindex]>lst[-j-1]:

minindex= -j-1count_swap+= 1

if lst[minindex] == lst[maxindex]:#元素相同說明已經有序

break

if i !=maxindex:

lst[maxindex],lst[i]=lst[i],lst[maxindex]#如果minindex的索引被交換過(即剛好最大值的索引和最小值的索引交換過)，則需要更新！

if i == minindex+length:

minindex=maxindexif (-i-1) != minindex or (-i-1+length) !=minindex:

lst[minindex], lst[-i-1] = lst[-i-1], lst[minindex]print("排序后：",lst)print("比較次數：{0} 交換次數：{1}".format(count_iter,count_swap))

使用二元排序的時候需要注意幾點：1.相比于(一元)簡單選擇排序，我們需要再添加一個變量來記錄極值的下標。2.如果兩個極值的下標索引只要有一個被交換過則我們需要注意更新另一個極值的下標索引。3.如果使用了負索引來記錄下標，則在比較判斷時我們需要注意索引不能為負。

簡單選擇排序總結

字典dict

字典dict定義初始化

#上述紅色標記才是最為常用的初始化格式

字典元素的訪問

字典的增加和修改

字典刪除

字典遍歷

字典練習

waitting...

標準庫datetime

注意：total_seconds()是屬于timedelta對象的方法！

標準庫time

Python解析式、生成器

列表解析

注意一下下列情況：

列表解析進階

輸出都是[(5,24),(6,24)]

列表解析練習

1.　　[x**2 for x in range(1,11)]2.　　lst=[1,4,9,16,2,5,10,15]

[lst[i]+lst[i+1] for i in range(len(lst)-1)]3.　 [print("{}*{}={:<3}{}".format(j,i,i*j,'\n' if i==j else ''),end='' )for i in range(1,10) for j in range(1,i+1)]4 　　["{:>04}.{}".format(i,''.join([chr(random.randint(97,123))for _ in range(10)]))for i in range(1,101)]

生成器表達式

結果會報異常：first和second都為None！

集合解析式

字典解析式

總結

內建函數

可迭代對象

迭代器

迭代器不一定是生成器，但生成器本質是迭代器！

字典練習

#按統計次數降序輸出

importrandom

random_alphatable= [''.join([chr(random.randint(97,122))for _ in range(2)])for _ in range(1,101)]

dict_count={}for i inrandom_alphatable:if i not indict_count:

dict_count[i]= 1

else:

dict_count[i]+= 1

#即按字典的value排序

res = sorted(dict_count.items(),key=lambda items:items[1],reverse=True)print(type(res))for i inres:print(i,end=" ")

總結

以上是生活随笔為你收集整理的python内置数据结构_Python基础知识2-内置数据结构(下)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。