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

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

#用id(expression a) == id(expression b)來判斷兩個表達式的結(jié)果是不是同一個對象的想法是有問題的#只有你能保證對象不會被銷毀的前提下，你才能用 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操作

線性結(jié)構(gòu)

切片

練習(xí)：

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

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：根據(jù)楊輝三角的定理：第m行的第k個數(shù)可表示為C（m-1，k-1），即為從m-1個不同的元素中取k-1個元素的組合數(shù)。

#利用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]))#上例測試效率：

練習(xí)2

#方法1，常規(guī)寫法

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函數(shù)創(chuàng)建索引

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)

練習(xí)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：考慮能否一次性開辟好空間目標矩陣的內(nèi)存空間？如果能夠一次性開辟好空間目標矩陣內(nèi)存空間，那么原矩陣的元素直接移動到轉(zhuǎn)置矩陣的對稱坐標就行了#在原有矩陣上改動，牽扯到增加元素和減少元素，有些麻煩，所以，定義一個新的矩陣輸出

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)

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

練習(xí)4

#思路：利用類似linux中位圖的思想來記錄當前標記數(shù)字是否重復(fù)出現(xiàn)

importrandom

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

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

length=len(nums)

samenums=[] #記錄相同的數(shù)字

diffnums=[] #記錄不同的數(shù)字

states=[0]*length #記錄不同的索引異同狀態(tài)

for i inrange(length):

flag= False #該狀態(tài)表示沒有重復(fù)

if states[i]==1:continue

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

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命令

特殊變量

魔術(shù)方法

封裝和解構(gòu)

解構(gòu)(unpack)

Python3的解構(gòu)

丟棄變量

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小結(jié)：

解構(gòu)，是Python提供的很好的功能，可以方便的提取復(fù)雜數(shù)據(jù)結(jié)構(gòu)的值。

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

集set

set定義初始化

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

set的元素

set增加

set刪除

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

set修改、查詢

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

set成員運算符的比較

可以看出set集合查詢效率跟數(shù)據(jù)規(guī)模無關(guān)！

set和線性結(jié)構(gòu)

集合

集合運算

解題思路：

集合練習(xí)

#利用集合來解決

簡單選擇排序

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

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

#二元選擇排序（降序）#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]:#元素相同說明已經(jīng)有序

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("比較次數(shù)：{0} 交換次數(shù)：{1}".format(count_iter,count_swap))

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

簡單選擇排序總結(jié)

字典dict

字典dict定義初始化

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

字典元素的訪問

字典的增加和修改

字典刪除

字典遍歷

字典練習(xí)

waitting...

標準庫datetime

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

標準庫time

Python解析式、生成器

列表解析

注意一下下列情況：

列表解析進階

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

列表解析練習(xí)

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)]

生成器表達式

結(jié)果會報異常：first和second都為None！

集合解析式

字典解析式

總結(jié)

內(nèi)建函數(shù)

可迭代對象

迭代器

迭代器不一定是生成器，但生成器本質(zhì)是迭代器！

字典練習(xí)

#按統(tǒng)計次數(shù)降序輸出

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=" ")

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。