python入門之內置數據結構入門
阿新 • • 發佈：2017-09-25
python
分類（大部分操作為 int和字符串）
數值型
int整型 folat浮點型 complex復數（實虛數組成） bool布爾值（為int的子類，僅有true和，false）
序列對象
字符串str
列表list
鍵值對
集合set
字典dict
數字的處理函數
round（）四舍六入五取偶 地板向下floor（），天花板向上ceil（） int（）取整數部分，和//整除一樣
取大小常用
min（[1,3,5]） 1 max（[1,3,5]） 5 pow（5,2）開平方 25
進制函數，返回是字符串
bin（）2進制 oct（）八進制 hex（）十進制 math.pi=π
類型判斷
type 返回類型，不是字符串 isintance 返回布爾值 isintance（a（int,str）） 返回值為 true
列表list
*列表是可變的 list的符號為 [] 元素可以是任意對象（字符串，數字，對象，列表等） 是一個有序的整齊的隊伍 用[ ]來表示，是線性的數據結構，列表內元素有順序，可以使用索引 列表list定義，初始化 列表不能一開始就定義大小
列表索引訪問
索引 也叫下表 有正負索引，不可超界，否則會異常indexerror 正索引從0開始，為列表中每一個元素編號，負索引從右到做從-1開始 列表為從左到右排列的，左邊為頭，右邊為尾，左邊為上，右邊為下
列表通過索引訪問
list[index]，index就是索引，使用括號中訪問 如 lst=[2,567] list[1]就會顯示 lst[567]
列表查詢
index（value，[ start,[stop]]）
index 通過值value，從指定區間查找匹配元素，匹配第一個元素就會返回索引，
匹配不到就會跳出valueerror
count（value）
返回列表中匹配value 的次數
時間復雜度
index和count都是O(n)
隨著列表數據規模增大，效率下降
len（list）
返回列表內的個數列表增加，插入元素
append
列表尾部追加，返回none
就地修改
時間復雜度為O(n)insert
在指定索引位置插入元素 就地修改 時間復雜度O(1) 超越上界，尾部追加，超越下界，頭部追加
列表增加，插入元素
extend 將可叠代對象元素追加進來 就地修改 +- 連接操作，將兩個列表連接起來 產生新的列表，原列表不變 *重復操作，將本列表元素重復n次，返回新的列表
列表刪除元素
remove 從左到右查找第一個匹配的值，移除該元素 就地修改 效率低O(n) pop 不指定索引，從尾部彈出 指定索引，從索引處彈出一個元素 取尾部效率快=O(1) clear 清除列表所有元素，只剩一個空列表 jc垃圾回收
反轉
reversed
將列表元素反轉，並返回值
就地修改
sort(key=none,reverse=false)排序
對列表元素進行排序，就地修改，默認升序
reverse為true，反轉，降序
key一個函數，指定key如何排序
lst.sort(key=functionname)
可以使用key進行字符與字符串的排序in
可以用來測試該元素是否在列表內，並返回布爾值 pass語句，占位語句！
以上操作應考慮效率問題，
列表的復制
shadow copy（影子拷貝) 淺拷貝，只是復制一個引用而已
深拷貝
lst=copy.deepcopy(lst0) copy模塊提供了deepcopy 會拷貝引用類型到拷貝目錄下並和源列表不幹擾
隨機數（偽隨機數）
random模塊 randint（a,b）返回[a,b]之間 的整數 choice（seq），從非空序列的元素中隨機挑選一個整數 randrange（[start，]stop[，step]）前閉後開模式；從指定基數遞增的集合中獲取一個隨機數為1，基數的缺省值為1 random.shuffle(list) 沒有返回，就地打亂列表元素
冒泡法
屬於交換排序。兩兩比較，並互相交換位置，結果分為升序和降序排列 升序從左至右排列，編號從0開始到n-1 降序則和升序相反
字符串
一個有序的序列，是字符的集合。能使用引號，三雙引號 ，是不可變對象 是unicode類型 字符串定義 初始化 賦值即定義 字符串元素訪問，下標 支持索引訪問，有序的字符集合，字符序列，可叠代
字符串分割
split（sep=none,maxsplit1）
由左至右
sep制定分割字符串，默認使用空白字符為分割符
maxspilt 制定分割的次數，-1表示遍歷整個字符串rsplit
由右至左
sep制定分割字符串，默認使用空白字符為分割符
maxspilt 制定分割的次數，-1表示遍歷整個字符串splitlines（【keepends】
按照行來切分字符串
keepends 指的是是否保留行分割符
行分隔符值得是是否包括\n 、\r\n 、 \r等元組tuple
由（）小括號表示
一個有序序列
元組不可變對象
元組的定義，一個對象加上（1，）逗號，兩個（1，2）以上不需要追加逗號
元組元素的訪問
支持正負索引，可一通過所以訪問；tuple（index）：index就是索引
元組查詢
index 索引查找，count 返回次數
時間復雜度：
index和count都是O（n）
len（tuple）：長度查詢元組 只讀，所以增改，刪除，追加都不可操作
命名元組
元組名稱 namedtuple（類的名稱，定義字段：以逗號或空格分割的字符串或者是字段的列表） namedtuple在模塊的使用方法； from collections import namedtuple 元祖名=namedtuple（‘元祖子類名‘，[ ]）
例子：
設置一個元祖名為Student的元祖數據，其中包兩個字符串
Student=namedtuple(‘student‘,‘name age‘)
開始給組賦值
設tom=Student（‘tom‘， 20）
設jarry=Student （ ‘jerry‘ , 18）
賦值完成後 輸入 tom.name 或者 tom.age 會顯示出該成員的名字或者年齡字符串分割（常用）
partition（sep）
由左至右，遇到分隔符就把字符串分割成兩部分，返回頭，分隔符，尾部三元組
如果沒有找到分割符，就返回頭、2個空元素的三元組
sep 分割字符串 必須指定
rpartition(sep)
由右至左，
由左至右，遇到分隔符就把字符串分割成兩部分，返回頭，分隔符，尾部三元組
如果沒有找到分割符，就返回頭、2個空元素的三元組字符串大小寫
upper（）
全大寫
lower（）
全小寫
swapcase（）
交互大小寫字符串排版
center（sep） 默認空格填充
zfill(sep) 打印寬度，居右，左邊用0填充
title（） 標題的每個單詞都大寫字符串修改
字符串不可變，對字符串的修改會返回一個新的字符串 replace（old,new[,count]） 字符串中找到匹配替換為新子串，返回新字符串 count表示替換幾次，默認替換全部
字符串修改
strip（[指定字符]）（常用於去除用戶在頭尾輸入的非法字符）
若沒有指定去除什麽字符，將會從字符兩頭去除非法字符
lstrip
從左開始去除
rstrip
從右開始去除字符串朝找
find（sub[，start[,end]]）
在指定區間，由左至右查找子串sub，找到第一個對應的字符返回索引，沒找到返回-1
rfind（sub[，start[,end]]）
在指定區間，由右至左查找子串sub，找到第一個對應的字符返回索引，沒找到返回-1字符串查找
index（sub[,start[,end]]）
在指定區間內由左至右查找子串，找到返回索引，沒找到報錯
rindex（sub[,start[,end]]）
在指定區間內由右至左查找子串，找到返回索引，沒找到報錯字符串查找
時間復雜度
index和count都是O(n)
隨著列表數據規模增大，效率下降
len(string)
返回字符串的長度count（sub[,start[,end]]）
在指定區間由左至右統計子串sub出現的次數
字符串判斷->返回布爾值
endswith（suffix[,start[,end]]）
在指定區間，字符串是否是suffix結尾
stratswith（prefix[,start[,end]]）
在指定區間，字符串是否是prefix結尾字符串格式化
字符串輸出用‘’+‘’拼接 非字符串先轉後拼接 join拼接只能使用分隔符，且拼接對象是可叠代對象
格式要求
占位符：使用%和格式字符組成，例如%s、%d等
s調用str（），r會調用repr（），所有對象都可以被這兩個轉換
占位符中還可以插入修飾字符，例如%03d表示打印3個位置，不夠前面補0
format % valus ,格式字符串和被格式的值之間使用%分隔
valus 只能是一個對象字符串格式化
format函數格式化字符串語法
‘{}{xxx}‘.format(*args,**kwargs)
args是位置參數，是一個元組
kwargs是關鍵字參數，是一個字典
大括號表示占位符
{}表示按照順序匹配位置參數，{n}表示取位置索引為n的值
{xxx}表示在關鍵字參數中搜索名稱一致的
{{}}表示打印大括號位置參數
“{}：{}".format(‘192.168.1.100‘8888） 按照位置順序替換前面格式字符串中的占位符關鍵字參數或命名參數
"{server}{1}:{0}".format（8888,‘192.168.1.100‘,server=’web server info：‘，位置參數按照序號匹配 關鍵字按照名詞匹配訪問元素
“{0[0]}.{0[1]}.format((‘magedu‘.‘com‘))”
對象屬性訪問
from collections import namedtuple
Point=namedtuple(‘Point‘,‘x y‘)
p=Point(4,5)
"{{{0.x},{0.y}}}".format(p)對齊
常用對齊的符號有 <(左對齊)，>(右對齊)，^(默認居中，兩端補空格)，*^（默認居中兩端補*）
例子
作為一名python開發人員應使用format函數格式化字符串
本周習題：
求100以內的素數並打印出列表，最後顯示列表的值
#應用模塊
import math
#求一百以內的素數並列表，所以賦值給一個n為100
n=100
#設一個初始列表由2開始
lst=[2]
#利用for循環語句進行第一外循環3~n
for i in range(3,n):
#利用第二層循環進行lst值的循環
for j in (lst):
#如果i的值能整除lst的值；
if i%j==0:
#則跳出循環並中斷循環；
break
#否則
else:
#不能整除循環內的數列則被添加到lst中
lst.append(i)
#最後打印出lst列表中的所有內容
print(lst)由上得出的結果為
求楊輝三角前6行的值並添加到list列表中，並顯示列表中的值
有圖可知其規律為：下一列的值，為上一次兩次相加的和，1n1 1n+1n+11
#先設出楊輝三角的lst值[1][1，1]
lst=[[1],[1,1]]
#取前6的數列為n
n=6
#依次取出2到n裏的值
for i in range(2,n):
#從list的第三個元素到第n個元素的列表
pre=lst[i-1]
#在行首添加一個[1]
cur=[1]
#依次取出0到i-1的數值
for j in range(0,i-1):
#在cur的列表中追加(j與j+1)的數值
cur.append(pre[j]+pre[j+1])
#最後再在上一個命令執行完畢的數值後添加一個1
cur.append(1)
#最後將cur列表的值逐加到lst列表當中
lst.append(cur)
# cur.pop(int(i/2))
#在循環外打印出lst列表的值
print(lst)得出的結果為
若不設定lst的固定值則可以：
triangle=[]
n=6
for i in range(0,6):
if i==0:
triangle=[[1]]
else:
pre=triangle[i-1]
cur=[1]
for j in range(0,i-1):
cur.append(pre[j]+pre[j+1])
cur.append(1)
triangle.append(cur)
print(triangle)以上輸出結果為
效率型取十萬以內的質數並查看其所耗時間
import math
import datetime
n=100000
pn=[]
count=0
start=datetime.datetime.now()
flag=True
for i in range(2,n):
for j in pn:
count+=1
if i%j==0:
flag=False
break
if j>=math.ceil(math.sqrt(i)):
flag=True
break
if flag:
pn.append(i)
time=(datetime.datetime.now()-start).total_seconds()
print(pn)
print(time)
print(len(pn))
print(count)結果為：pn值，計算時間，列表數值個數，計算總次數
依次接收用戶輸入的三個數，並進行排序
方法1：
如何利用sort的方法對list的值進行排序
nums=[] #設定一個新列表
out=None #默認輸出為空
for i in range(3):
nums.append(int(input(‘>>>‘)))
nums.sort() #直接用sort對nums列表裏的數值進行排序
print(nums) #最後打印出nums的數值得出的結果為升序排序
方法二：
使用max進行排序
使用max進行排序
lst=[1,2,3] #創建一個列表，列表的值為1，2，3
使用max進行排序
lst=[1,2,3] #創建一個列表，列表的值為1，2，3
m=[] #創建一個空列表
for i in range(3):
m.append(max(lst)) #將lst的值升序排列追加進m列表中
lst.remove(max(lst))#依次刪除lst中的最大的值
print(m) #最後打印出m列表方法三
使用冒泡法進行排序
如何利用python的排序方法進行對列表的排序
nums_list=[[1,9,8,5,6,7,4,3,2],
[1,2,3,4,5,6,7,8,9],
[1,2,3,4,5,6,7,9,8]]
nums=nums_list[0] # 取出第一個列表的數值
length=len(nums)
flag=False #設置一個標記
for i in range(length):
flag=False #當輸出length的值時，將flag的值更新為假
for j in range(length-i-1):
if nums[j]>nums[j+1]: #利用判斷對list中的索引的值進行比較
tmp=nums[j] #如果lsit的第一個值比第二個值大，則會將此值利用pop進行排序
nums[j]=nums[j+1]
nums[j+1]=tmp
flag=True #當上面的程序產生更換時，這裏的flag的值就會更新為真了
if flag==False: # 如果flag的值等於假，也就是list的值沒有發生變化時為假，會立即跳出循環，並開始下數的循環
break
# nums.reverse() 翻轉nums列表的值呈倒敘打印
print(nums)print(nums)的結果為：
冒泡法總結：
屬於交換排序 兩兩比較，並交換位置，結果為升序或者倒敘排列 升序： 從索引0開始，由左至右進行比較，如果該值大於後值將會與後值交換位置。如果後數比前數大，則不交換。並繼續向後比較，直到該列表中的值全部依次比較完畢，此時若前面的值為最大的值，應在排序過後會被交換到列表中的最右側為末尾的值。當進行第二輪比較時，由於上一次比較最右側為最大值，所以下一輪的比較將會-1次比較次數
降序：
與升序的排序方式相反，其余一樣 冒泡法的時間復雜度為 O(n的2次方)
用戶輸入一個數字
判斷時幾位數
打印每一位數字及其重復的次數
依次打印出每一位數字，順序 個 十 百 千 萬...位
num=‘‘
#數字輸入的簡單判斷
while True:
num=input(‘Input a positive number>>>‘).strip().lstrip(‘0‘)
if num.isdigit():
break
print("the length of {} is {}.".format(num,len(num)))
#倒敘打印第一種
for i in range(len(num),0,-1):
print(num[i-1],end=‘ ‘)
print()#倒敘打印第二種
for i in reversed(num):
print(i,end=‘ ‘)
print()#利用負索引打印
for i in range(len(num)):
print(num[-i-1],end=‘ ‘)
print( )判斷0-9的數字再字符串中出現的數字，每一次叠代都是使用count，都屬於O(n)復雜度
counter=[0]*10
for i in range(10): #10*n
counter[i]= num.count(str(i))
if counter[i]:
print("the count of {} is {}".format(i,counter[i]))
print(‘~‘*20)#叠代字符串本身的字符
counter=[0]*10 #創建數值為10個0的列表
for x in num: # 依次讀取num裏的數
i=int(x) # 將x的值轉為字符串並賦給i
if counter[i]==0: #如果counter的第i項為0；
counter[i]=num.count(x) #那麽第i項就等於該數的次數
print("the count of {} is {}.".format(x,counter[i]))
print(‘~‘*20)輸入5個數字，打印出每個數字的位數，並將這些數字升序打印
#叠代字符串本身的字符
counter=[0]*10
for x in num:
i = int(x)
counter[i]+=1 #再counter的第i個索引處補1
for i in range(len(counter)): #叠代出counter的長度的數
if counter[i]: #如果counter不為真，則繼續執行下面的命令
print("the count of {} is {}.".format(i,counter[i]))#使用sort進行排序
nums=[] #創建一個空列表
while len(nums)<5: # 循環
num=input("please input a number:").strip().lstrip(‘0‘)
if not num.isdigit(): #如果他不是數字，則不會執行下面的命令
break #如果他是數字，則繼續下面的命令
print(‘the length of {} is {}‘.format(num,len(num)))#打印出這個數和他的位度
nums.append(int(num)) #並將num轉為整型並追加到nums中
#最後打印出nums列表
lst=nums.copy() #將nums列表的值復制給lst中
lst.sort() #就地排序
print(lst)
#使用冒泡法進行排序
for i in range(len(nums)):
flag=False
for j in range(len(nums)-i-1):
if nums[j]>nums[j+1]:
tmp=nums[j]
nums[j]=nums[j+1]
nums[j+1]=tmp
flag = True
if not flag:
break
print(nums)以上兩種方法都是呈升序打印
最後補上以上關於是否返回none的辨識方法
本文出自 “12575894” 博客，請務必保留此出處http://12585894.blog.51cto.com/12575894/1968221
python入門之內置數據結構入門