作用域 整數 數組 set集合 b- 之前 and 每次 bytes

字符串

一個個字符組成的有序的序列，時字符的集合
使用單引，雙引，三引 引住的字符序列
字符時不可變的對象

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

python的set，和字典的詳細使用方法，以及部分習題