Python說文解字_雜談06

 1. 序列類型的分類：

　　容器類型：list、tuple，deque

　　扁平序列：str、bytes、bytearray、array.array

　　可變序列：list、dequte、bytearray、array

　　不可變序列：str、tuple、bytes

 

2. 序列的abc繼承關係：

　　魔法函數構成了協議

 

3.序列的+ +=和extend的區別：

my_list = []
my_list.append(1)
my_list.append("a")

from collections import abc

a = [1,2]
# a = list()
c = a + [3,4]
# c = a + (3,4)  # 拋異常
print(c)


# 就地加
a += [3,4]
a += (3,4)  # 能夠爲任意的序列類型
a.extend((3,4))
# def __iadd__(self, values):
#     self.extend(values)
#     return self
a.append((1,2,4))
print(a) 

　　記住：咱們知道類函數的實現是經過魔法函數來實現的。其中+號表示的是同類項的相加。

　　記住：+=和extend是同樣的，所以+=是經過__iadd__來實現extend的。

　　記住：append表示添加的是元素位置。

　　記住：不能用變量名去接收這些方法，由於沒有返回值（aa = a.extend是錯誤的）

 

4. 實現可切片的對象：

# 模式[start:end:step]
r"""
    其中，第一個數字start表示切片開始位置，默認是0
    第二個數字end表示切片截止（但不包含）位置（默認爲列表長度】
    第三個數字step表示切片的步長（默認爲1）
    當start爲0時能夠省略，當end爲列表長度時能夠省略。
    當start爲1時能夠生路，而且省略步長時能夠同時省略最後一個冒號。
    另外，當step爲負整數時，表示反向切片，這時start應該比end的值要大才行。
"""
aList = [3,4,5,6,7,9,11,13,15,17]
# 取值的操做
print(aList[::]) #返回包含原裏列表中全部元素的新列表
print(aList[::-1]) #返回包含原列表中全部元素的逆序列表
print(aList[::2]) # 隔一個取一個，獲取偶數位置的元素
print(aList[1::2]) #隔一個取一個，獲取奇數位置的元素
print(aList[3:6]) # 指定切片的開始和結束位置
print(aList[0:100]) # 切片結束位置大於列表長度時，從裏誒包尾部截斷
print(aList[100:]) # 切片開始位置大於列表長度時，返回空列表

# 賦值的操做
aList[len(aList):] = [9]
print(aList) # 在列表尾部增長元素
aList[:0] = [1,2]
print(aList) # 在列表頭部插入元素
aList[3:3] = [4]
print(aList) # 在列表中間位置插入元素
aList[:3] = [1,2]
print(aList) #替換元素列表元素，等號兩邊的裏誒包長度相同
aList[3:] = [4,5,6]
print(aList) # 等號兩邊的列表長度也能夠不相等
aList[::2] = [0] * 3  # 將元素賦值三份
print(aList) # 隔一個修改一個
aList[::2] = ['a','b','c'] # 隔一個修改一個
print(aList)
# aList[::2] = [1,2] # 左側切片不連續，等號兩邊列表長度必須相等
aList[:3] = [] #刪除列表中前3個元素
del aList[:3] # 切片元素連續
del aList[::3] # 切片元素不連續，隔一個刪一個。
print(aList)

 

import numbers
class Group:
    # 支持切片操做
    def __init__(self,group_name,company_name,staffs):
        self.group_name = group_name
        self.company_name = company_name
        self.staffs = staffs

    def __reversed__(self):
        self.staffs.reverse()

    def __getitem__(self, item):
        cls = type(self)
        if isinstance(item,slice):
            return cls(group_name=self.group_name,company_name=self.company_name,staffs=self.staffs[item])
        elif isinstance(item,numbers.Integral):
            return cls(group_name=self.group_name,company_name=self.company_name,staffs=[self.staffs[item]])

    def __len__(self):
        return len(self.staffs)

    def __iter__(self):
        return iter(self.staffs)

    def __contains__(self, item):
        if item in self.staffs:
            return True
        else:
            return False


staffs = ["bobby1","imooc","bobby2","bobby3"]
group = Group(company_name="imooc",group_name="user",staffs=staffs)
sub_group = group[:2]
print(group.staffs)
# sub_group1 = group[0]
# print(group.staffs)
# reversed(group)
# for user in group:
#     print(user)

　　記住：這是一個比較多的用魔法函數實現切片操做。

　　記住：難理解的是cls = type(self)，返回值：<class '__main__.Group'>，這是拿到類的對象 ，其實能夠改寫成下面方式

    def __getitem__(self, item):
        # cls = type(self)
        # print(type(self))
        if isinstance(item,slice):
            return Group(group_name=self.group_name,company_name=self.company_name,staffs=self.staffs[item])
        elif isinstance(item,numbers.Integral):
            return Group(group_name=self.group_name,company_name=self.company_name,staffs=[self.staffs[item]])

 

　　記住：可是這裏爲何要用type返回類對象呢？這是一種相對方式，爲的是若是更改類名能夠不用修改內部的代碼。

 

5. bisect二分迭代類型操做：

import bisect
from collections import deque

# 用來處理已排序的序列，始終用來維持已排序的序列，升序。
# 二分查找
inter_list = []
bisect.insort(inter_list,3)
bisect.insort(inter_list,2)
bisect.insort(inter_list,5)
bisect.insort(inter_list,1)
bisect.insort(inter_list,6)


print(inter_list)
# 總結：
# bisect.bisect(data,1)
# 做用，查找該數值將會插入的位置並返回，而不會插入,返回是會在那個數字以後插入
# 表示：num > .... 插入
a1 = bisect.bisect(inter_list,4)
print(a1)

# bisect_left 和 bisect_right 函數
# 該函數用入處理將會插入重複數值的狀況，返回將會插入的位置
# 第一：從左邊看num>...插入位置
# 第二：從右邊看 ... < num 出入位置。
a2 = bisect.bisect_left(inter_list,2)
print(a2)
a3 = bisect.bisect_right(inter_list,2)
print(a3)

# insort  函數 insort_left  和 insort_right
bisect.insort(inter_list,2)
print(inter_list)

 

7.數組：

# array, deque
# 數組：存儲連續的內存空間，效率很是高的。
import array
# array 和list的一個重要區別，array只能存放指定的數據類型。
# array的性能比list高。

my_array = array.array("i")
my_array.append(1)
my_array.append("abc")
print(my_array)

 

　　記住：咱們是會用 列表，何時用數組

 

8. 列表推導式、生成器表達式、字典推導式、集合推導式。

# 列表生成式（列表推導式）
# 1. 提取1-20之間的奇數
odd_list = []
for i in range(21):
    if i %2 ==1:
        odd_list.append(i)

print(odd_list)


# 列表生成式
odd_list = [i for i in range(21) if i %2 == 1 ]

# 2.邏輯複雜的狀況
def handle_item(item):
    return item * item

odd_list1 = [handle_item(i) for i in range(21) if i %2 == 1 ]

# 列表生成式性能高於列表操做。

 

　　記住：列表生成式不能太複雜了。要不就放棄了可讀性。另外列表生成式的操做高於列表操做。

 

# 生成器表達式：
odd_list = (i for i in range(21) if i %2 == 1 )
print(type(odd_list))
# <class 'generator'>
for item in odd_list:
    print(item)

　　記住：生成器經過for循環打印出來。

odd_gen = (i for i in range(21) if i %2 == 1 )

odd_list = list(odd_gen)
print(odd_list)

　　記住：生成器能夠轉回成list再打印出來也是能夠的。

 

# 字典推導式
my_dict = {"bobby1":22,"bobby2":23,"imooc":5}
reversed_dict = {value:Key for Key,value in my_dict.items()}
print(reversed_dict)
# {22: 'bobby1', 23: 'bobby2', 5: 'imooc'}

 

 

# 集合推導式
# my_set = set(my_dict.keys())
my_set = {Key for Key,value in my_dict.items()}
print(my_set)
print(type(my_set))
# <class 'set'>