字符串
一個個字符組成的有序的序列，時字符的集合 使用單引，雙引，三引 引住的字符序列 字符時不可變的對象
bytes定義
bytes不可變字節序列 使用b前綴定義 只允許基本ASCII使用字符形式 支持索引 返回對應的數，int類型
bytearray定義
字節數組 可變 append 可在尾部追加元素 insert 在指定索引位置插入元素 extend 將一個可迭代的整數集合追加到當前bytearray pop(index=-01) 從指定索引上移除元素，默認從尾部移除 remove（value） 找到第一個value移除，找不到拋出VlaueError異常 上述方法若需要使用int類型，值在【0，255】 clear（）清空bytearray reverse（）反轉bytearray ，就地修改 編碼： 字符串按照不同的字符集編碼encode返回字節序列bytes 字節序列按照不同的字符集解碼decode返回字符串
線性結構
可迭代 for...in len可以獲取其長度 可以通過索引訪問 可以切片
切片
通過索引區間訪問線性結構的一段數據 sequence[start：stop]，表示返回[start，stop]區間的子序列 支持負索引 strat為0可以省略 stop為末尾，可以省略 超過上界（右邊界），取到末尾；超過下屆（左邊界），取其開頭 strat一定要在stop的左邊 [：] 表示從頭到尾，全部元素被取出，等效於copy( )方法
封裝和結構
解構
把線性結構的元素解開，並順序的賦給其他變量 左邊接納的變量數要和右邊解開的數目一致
python3 的解構
使用 *變量名接收 不能單獨使用
被 *變量名 收集后組成一個列表
丟棄變量
不成文的約定，不是標准 如果不關心一個變量，可以定位這個變量的名字為__ __是一個合法的標識符，也可以作為一個有效的數量使用，但是定義成下划線就是希望不被使用，除非明確知道這個數據需要使用
_這變量本身無任何語義，沒有任何可讀性，
python中有很多庫都是用這個變量，使用十分廣泛，在不明確變量作用域的情況下，使用_和庫中的_沖突
練習
lst=list(range(10)) 取出第二個，第四個，倒數第二個
_,sec，_,F,*_,n,_=lst
從lst=[1,(2,3,4),5]中，提取4出來
_,(*_,a),_=lst
從JAVA_HOME=/usr/bin，返回變量名和路徑
s='JAVA_HOME=/usr/bin'
name,_path=s.prtition('=')
總結：
解構，是python中提供的很好的功能，可以方便的提取復雜數據解構的值
配合_的使用，會更加便利
set
可變的，無序的，不重復的元素的集合
set是可迭代的
set可以用來去重
set的元素是要求必須可以hash的
目前已學過的不可hash的類型有 list、set
元素不可以被索引
set增加
add(value)
增加一個元素到set中
如果元素存在，什么都不做
update（*others）
合並其他元素到set集合中來
參數others必須是可迭代對象
就地修改
set刪除
remove（elem）
從set中移除一個數
元素不存在，會拋出KeyError錯誤: 通過hash值查找，直接刪除對應hash值的數
discard（elem）
從set中移除一個元素
元素不存在，不會拋錯誤
pop( )-->item
不可以刪除指定數值
移除並返回任意的元素，
空集返回KeyError異常
clear( )
移除所有元素
set的修改和查詢
修改：
要么刪除，要么加入新的元素，沒有修改
查詢：
非線性結構，無法索引
遍歷：
可迭代所有元素
成員運算符：
in和not in 可以判斷元素是否在set中
set和線性結構
線性結構的查詢時間復雜度都是O(n)，隨着數據規模增大，耗時增加
ser、dict等結構，內部使用hash值作為key，時間復雜度可以為O(1)，查詢時間和數據規模無關
可hash
數值型 int、float、complex
布爾型 True、False
字符串 string、bytes
tuple
None
以上都是不可變類型，成為可hash類型，hashable
set的元素必須是可hash的
集合
基本概念
全集
所有元素的集合，如實數集，所有實數組成的集合就是全集
子集
一個集合A所有元素都在另一個集合B內,A是B的子集，B是A的超集
真子集和真超集
A是B的子集，且A不等於B，A就是B的真子集，B是A的真超集
並集： 多個集合合並的結果
交集：多個集合的公共部分
差集： 集合中出去和其他集合公共部分
並集
將兩個集合A和B所有的元素合並到一起，組成的元素乘坐集合A與集合B的並集
比較運算： union（*others）
union用法：
返回和多個集合合並后的新集合（如圖所示A與B的相交部分）、
”|“： union的代表符號
update（*others）： 和多個集合合並，就地修改
update的用法：
= : update的代表符號
交集：
集合A和B由所有屬於A且屬於B的元素組成的集合（如下圖所示）：
intersection(*others)
返回多個集合的交集（如下圖所示）：
& ：intersection的代表符號
intersection_update(*others)
獲取和多個集合的交集，並就地修改
&= ：intersection_updated 的表示符號
差集
差集
集合A和B，由所有屬於A且不屬於B的元素組成的集合（如圖所示）：
diffrernce(*others)的用法
返回多個集合的差集
— ： 表示為 difference的符號
difference_(update):
獲取和多個集合的差集並就地修改
—= : 表示為difference_(update)的符號
對稱差集
對稱差集：
集合A和B，由所有不屬於A和B的交集元素組成的集合，記作(A-B)U(B-A):
symmetric_differece(other)
返回和另一個集合的差集
”^“ 表示為symmetric_differece的表示符號
symmetric_differece_update(other)
獲取另一個集合的差集並就地修改
”^=“ 表示為symmetric_differece_update(other)的使用符號
issubset(other)、<=：
判斷當前集合是否是另一個集合的子集
set1<set2:
判斷set1是否是set2的真子集
issuperset(other)、>=
判斷set1是否是set的真超集
isdisjoint(other)
當前集合和另一個集合沒有交集；沒有交集，返回True
集合練習：
共同好友；
你的好友A,B,C 他的好友C,B,D， 求共同好友：
交集問題： {'A','B','C'}.intersection({'B','C','D'})
微信群提醒：
XXX與群里其他人都不是微信朋友關系
並集：userid in (A|B|C|...)==FLASE, A , B , C等是好友的並集，用戶ID不在這個並集中，說明他和任何人都不是朋友
權限判斷：
有一個API，要求同時具備A,B,C權限才能訪問，用戶權限B,C,D，判斷該用戶能否訪問該API
API集合為A，權限集合為P；A-P={},AP為空集，說明 P包含A
A.issubset（P）也行，A是P的子集
A&P=A也可以
有一個API，要求具備A,B,C任意一項權限就可訪問，用戶權限B,C,D ，判斷該用戶能否訪問該API
一個總任務列表，儲存所有任務，一個完成的任務列表。找出未完成的任務
設所有的工作為ALL，已完成的工作為COMPLETED 用所有的減去已完成的得出未完成的
集合練習:
隨機產生2組各個數字的列表，如下要求：
每個數字取值范圍[10,20]
統計20個數字中，一共有多少個不同的數字？
2組中，不重復的數字有幾個？分別是什么？
2組中，重復的數字有幾個？分別是什么？
答案依次為：
字典
字典：
字典為 key-vlaue 鍵值對的數據的集合；字典是可變的，無序的，key不重復
字典的定義，初始化：
字典常用的用法為 ： dict(**kwargs) 使用name=value 對一個字典初始化
dict（可迭代，**kwarg）使用可迭代對象和name=value對構造字典，不過可迭代對象的元素必須是一個二元結構
dict(mapping,**kwarg)使用一個字典構造另外一個字典
d={'a':10,'b':20,'c':None,'d':[1,2,3]}
字典元素的訪問：
d[key]： 返回key對應的值value；key不存在拋KeyError異常
get(key,[,default])： 返回key對應的值value，key不存在返回缺省值，如果沒有設置缺省值返回None
setdefault（key[,default]）：返回key對應的值value，key不存在，添加kv對.值為default，並返回default，如果default沒有設置，缺省為None
字典增加和修改：
d[key]=value ：將key對應的值修改為value（新值），key不存在添加新的kv對
update([other])-->None：
使用另一個字典的kv對更新本字典；key不存在，就添加；key存在，覆蓋已經存在的key對應的值；就地修改
字典刪除：
pop(key[,default]):
key存在，移除它，並返回他的value
key不存在，返回給定的default
default未設置，key不存在則排除KeyError異常
popitem（）
移除並返回一個任意的鍵值對
字典為空，拋出KeyError異常
clear() 清空字典
字典刪除：
del語句
字典練習：
第二題：
import random
randomnumber=[]
countlist=[]
randomdict={}
sortlist=[]
for p in range(100):
randomnumber.append(random.randrange(-1000,1000))
countlist.append(randomnumber.count(randomnumber[p]))
randomdict[randomnumber[p]]=countlist[p]
for k,v in randomdict.items():
sortlist.append((k,v))
sortlist.sort()
print(sortlist)
輸出結果：
習題一：
nums=input('>>>')
count_list=[]
sort_list={}
sort_list1=[]
for i in range(len(nums)):
count_list.append(nums.count(nums[i]))
sort_list[nums[i]]=count_list[i]
for k,v in sort_list.items():
sort_list1.append((k,v))
print(sort_list1)
輸出結果：
習題三：
import random
s1=[]
same_alpha=[]
count_list={}
diff_alpha=[]
alpha='abcdefghijklmnopqrstuvwxyz'
for _ in range(100):
s1.append(random.choice(alpha)+random.choice(alpha))
same_alpha.append(s1.count(s1[_]))
count_list[s1[_]]=same_alpha[_]
#進行排序
for k,v in count_list.items():
diff_alpha.append((k,v))
diff_alpha.sort(reverse=True)
print(diff_alpha)
輸出結果為：
選擇排序：
選擇排序使用方法
簡單選擇排序：
屬於選擇排序，兩兩比較大小，找出最大值和最小值；被放在固定的位置，固定位置一般在某一端
結果分為升序和降序
降序：n個數由左至右，索引從0到-1，兩兩依次比較，並記錄最大值，此輪所有數比較完畢，將最大數和索引0數比較，如果最大數就是索引1，不交換；第二輪由1開始比較，找到最大值，將它和索引1位置交換，如果他就在索引1則不叫喚，依次類推，每次左邊都會固定下一個大數
升序：
和降序相反
簡單排序總結：
簡單排序需要 數據一輪輪比較，並在每一輪中發現極值
沒有辦法知道當前輪是否已經達到排序要求，但可以知道極值是否在目標索引位置上
遍歷次數1，....，n-1和n（n-1）/2
時間復雜度為O(n的平方)
減少了交換次數，提高了效率，性能略好於冒泡法
選擇排序練習：
將上述列表第二列利用選擇排序進行排序
m_list=[[1,9,8,5,6,7,4,3,2],
[6,5,8,7,9,4,2,1,3],
[9,8,7,6,5,4,3,2,1]]
nums = m_list[1]
length=len(nums)
print(nums)
for i in range(length):
maxindex=i
for j in range(i+1,length):
if nums[maxindex] < nums[j]:
maxindex = j
# print(nums)
if i != maxindex: #第二次判斷兩個索引是否相等，若相等則說明該值已是最大，無需進行下面的命令操作，否則則進行下面的程序
tmp = nums[maxindex] #將列表中最大的值賦給另一個參數
nums[maxindex]=nums[i] #將列表中maxindex索引的值刷新為i索引的值
nums[i]=tmp #將列表中i的索引的值刷新為tmp的最大值
print(nums)
輸出結果為：
回顧之前所學知識，並以新的所學知識做一些以前的習題：
求楊輝三角的第5列的第4個值
m=5
k=4
traingle=[]
for i in range(m):
row=[1]
traingle.append(row)
for j in range(1,i):
if i == 0:
continue
row.append(traingle[i-1][j-1]+traingle[i-1][j])
row.append(1)
traingle.append(row)
print(traingle)
print(traingle[m-1][k-1])
習題二：
lst=[[1,2,3],[4,5,6],[7,8,9]]
for i in range(len(lst)): #依次循環3個列表
for j in range(i): #本次循環的是列表中的索引值
lst[i][j],lst[j][i]=lst[j][i],lst[i][j] #將列表的值進行交換
print(lst)
for k in lst: #重新排序
print(k)
輸出結果為：
習題3：
firstlist=[[1,2,3],[4,5,6]] #創建一個包含兩列數的列表
secondlist=[] #創建一個空列表
m=len(firstlist) #將第一個列表的長度輸出給m
for i in range(m+1): #
secondlist.append([0]*m)#循環三次，並開辟3個介為0的子列表
print(secondlist)
print(firstlist)
for i in range(m): #
for j in range(m+1): #利用兩層循環來讀取索引上的數值
secondlist[j][i]=firstlist[i][j] # 將對應索引上的值進行交換
print(secondlist)
輸出結果為:
習題三：
隨機生成10個數字；
每個數字的取值范圍不超過20
分別統計重復與不重復的數字有幾個：
import random
nums=[]
for _ in range(10):
nums.append(random.randrange(21))
print('nums1={}'.format(nums))
print()
隨機生成10個20以內的數字
————————————————————————
length=len(nums)
samenums=[]
diffnums=[]
states = [0]*length
for i in range(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
if flag: #有重復
samenums.append(nums[i])
states[i]=1
else:
diffnums.append(nums[i])
print("Same numbers={1},counter={0}".format(len(samenums),samenums))
print("different numbers={1},counter={0}".format(len(diffnums),diffnums))
print(list(zip(states,nums)))
本文轉載