Python知識點總結大全(二)

sorted() 排序函數

sorted(iterable, *,key=None,reverse=False)

sort 與 sorted 區別：

sort 是應用在 list 上的方法，sorted 可以對所有可迭代的對象進行排序操作。

list 的 sort 方法返回的是對已經存在的列表進行操作，無返回值，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。

1.接收一個字典

#  生成一個按照字典的key進行排序的新列表
>>>sorted({'k1': 10, 'k2': 100, 'k3': 30})
>>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})

['k1', 'k2', 'k3']
[1, 2, 3, 4, 5]

2.傳入key參數，參數是函數名

# key指定的函數將作用於list的每一個元素上，並根據key函數返回的結果進行排序
>>> sorted([36, 5, -12, 9, -21], key=abs) #abs是python中的內置函數，返回參數的絕對值

[5, 9, -12, -21, 36]

3.傳入reverse參數

# reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）

4.以下list做出2道題，1：按照名字排列 2：按照分數排列

L = [(‘Bob’, 75), (‘Adam’, 92), (‘Bart’, 66), (‘Lisa’, 88)]

# 第一題，按照名字排列
def by_name(t):
	return t[0] # 這裏返回的t[0]，並不是list的0號位置元素，而是list內元素的0號位置，所以，他指向的是('Bob',75)的0號位

L1 = sorted(L,key=by_name)
print (L1)

[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

# 第二題，按照分數排列
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_score(t):
    return t[1]

L2 = sorted(L, key=by_score, reverse=True)
print (L2)

[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

filter() 過濾函數

filter(function, itetable)

filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器

該接收兩個參數，第一個爲函數，第二個爲序列，序列的每個元素作爲參數傳遞給函數進行判；其中是function返回True的元素，如果function傳入None，則返回所有本身可以判斷爲True的元素

1.找到1-10中的質數

l = [x for x in range(10)]
print(list(filter(lambda x : x%2 == 0, l)))

[2,4,6,8]

2.把值大於50的由元祖組成的鍵值對過濾出來

dic = {'k1': 10, 'k2': 100, 'k3': 50, 'k4': 90}items()
# items()以列表返回可遍歷的(鍵, 值) 元組數組
print(list(filter(lambda x: x[1] > 50, dic.items()))) 

[('k2', 100), ('k4', 90)]

encode() decode() 編碼解碼函數

# encode和decode分別指編碼和解碼。在python中，Unicode類型是作爲編碼的基礎類型，
          decode                 encode
str ---------> str(Unicode) ---------> str

舉例說明

>>> u = '中文'                 # 指定字符串類型對象u 

# 不同的編碼格式得到的結果不同
>>> str1 = u.encode('gb2312')  # 以gb2312編碼對u進行編碼，獲得bytes類型對象
>>> print(str1)
b'\xd6\xd0\xce\xc4'
>>> str2 = u.encode('gbk')     # 以gbk編碼對u進行編碼，獲得bytes類型對象
>>> print(str2)
b'\xd6\xd0\xce\xc4'
>>> str3 = u.encode('utf-8')   # 以utf-8編碼對u進行編碼，獲得bytes類型對象
>>> print(str3)
b'\xe4\xb8\xad\xe6\x96\x87'


# 解碼時必須用與編碼格式相同的格式去解碼
>>> u1 = str1.decode('gb2312') # 以gb2312編碼對字符串str進行解碼，獲得字符串類型對象
>>> print('u1')
'中文'
>>> u2 = str1.decode('utf-8')  # 報錯，因爲str1是gb2312編碼的
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xd6 in position 0: invalid continuation byte

map()映射函數

map(function,iterable)

• function – 函數
• iterable – 一個或多個序列

返回一個迭代器，由每個可迭代對象符合函數條件的組成。傳送結果給這個迭代器。

一個可迭代的對象作爲參數

# 計算平方數
def square(x):
    return x ** 2

# 計算列表各個元素的平方
print(list(map(square, [1, 2, 3, 4, 5])))
 # 使用 lambda 匿名函數
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))

[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25]

兩個可迭代的對象作爲參數

# 提供了兩個列表，對相同位置的列表數據進行相加
def addition(x, y):
    return x + y

print(list(map(addition, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))
# 使用 lambda 匿名函數
print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))

[3, 7, 11, 15, 19]
[3, 7, 11, 15, 19]

內置方法__str__ __repr __

什麼是內置方法
在不是需要程序員定義，本身就存在在類中的方法就是內置方法，名字：雙下方法，魔術方法，內置方法
如：init 不需要我們主動調用，而是在實例化的時候內部自動調用的。所以雙下方法，都不需要我們直接調用，都有另外一種主動觸發他的方法

str， repr 內置方法，兩者都只能返回字符串，而且都要用return

str，什麼情況下觸發_str：
1 當你打印一個對象的時候，
2 當你使用%格式化的時候
3 str() 強轉數據類型的時候

repr ，repr是str的備胎，有str的時候執行str,沒有實現str的時候，執行repr

什麼情況觸發repr
1 repr(obj)內置函數對應的結果是repr的返回值
2 使用%r格式化的時候觸發repr

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return 'str : {}'.format(self.name)

    def __repr__(self):
        return 'repr : {}'.format(self.age)


stuList = []
stu1 = Student('張三', 18)
stu2 = Student('李四', 20)
stuList.append(stu1)
stuList.append(stu2)
for id, stu in enumerate(stuList, 1):
    print(id, stu)  # 當打印一個對象的時候 --> 1 str : 張三
    print('%s %s' % (id, stu))  # 當使用%格式化的時候 --> 1 str : 張三
    print(id, str(stu))  # str() 強轉數據類型的時候 -->1 str : 張三
    print(repr(stu))  # repr(obj)內置函數對應的結果是repr的返回值 --> repr : 18
    print('%r' % stu)  # 使用%r格式化的時候觸發repr --> repr : 18

zip() 拉鍊函數

zip(*iterables)

生成一個迭代器，它聚合了可迭代對象的每個元素。
返回一個由元組組成的迭代器，其中第i個元組包含來自每個參數序列或可迭代對象的第i個元素，當最短的可迭代對象被輸出時，該迭代器完成，

x = [1, 2, 3, 4]
y = ['one', 'two', 'three']
z = ('a', 'b', 'c', 'd')
print(list(zip(x, y, z)))

[(1, 'one', 'a'), (2, 'two', 'b'), (3, 'three', 'c')]

*zip(*iterables)函數是zip()函數的逆過程，將zip對象變成原先組合前的數據

x = [1, 2, 3, 4]
y = ['one', 'two', 'three', 'Four']
z = ['a', 'b', 'c', 'd']

n1, n2, n3 = zip(*zip(x, y, z)) # 這裏返回三個值，元祖類型，用三個變量去接收
print(x == list(n1) and y == list(n2) and z == list(n3))


True

判斷類型函數type(), isinstance(),issubclass()

• type() 如果你只有第一個參數則返回對象的類型，三個參數返回新的類型對象
• isinstance() 對象與類之間的關係， 判斷這個對象是否是這個類，這個類的子類的對象
• issubclass() # class 類 # 類與類之間的關係，判斷一個類是否是另一個類的子類，另一個類的子類的子類

type()

type(1)
<class 'int'>

isinstance()

class A:
    pass

class B:
    pass

a = A()
b = B()

print(isinstance(a, object))  # True  # 判斷a這個實例化對象是不是object的對象，由於object是所有類的父類，isinstance函數也可以判斷出來
print(isinstance(a, A))  # True   # 判斷a是否是A類的實例化對象，
print(isinstance(b, A))  # False  # 判斷b是否是A類的實例化對象
print(isinstance(a, B))  # False

issubclass()

class A:
    pass

class B(A):
    pass

class C(B):
    pass

print(issubclass(B, A))  # True  # 判斷B是否是A的子類
print(issubclass(C, A))  # True  # 還可以判斷C是否是A的子類的子類

往期推薦：
Python知識點大全(一)
Python知識點大全(二)