Python自定義排序及我實際遇到的一些題目實例

来源:https://www.cnblogs.com/welan/archive/2022/05/07/16243852.html
-Advertisement-
Play Games

寫在前面，本文主要介紹Python基礎排序和自定義排序的一些規則，如果都比較熟悉，可以直接翻到第三節，看下實際的筆試面試題中關於自定義排序的應用。 一、基礎排序 排序是比較基礎的演算法，與很多語言一樣，Python也提供了對列表的排序方法和內建排序函數。 1、兩種排序方式 方式一： li = [1, ...


寫在前面，本文主要介紹Python基礎排序和自定義排序的一些規則，如果都比較熟悉，可以直接翻到第三節，看下實際的筆試面試題中關於自定義排序的應用。

一、基礎排序

排序是比較基礎的演算法，與很多語言一樣，Python也提供了對列表的排序方法和內建排序函數。

1、兩種排序方式

方式一：

li = [1, 3, 4, 9, 0]
li.sort()  # 提供方法

方式二：

li = [1, 3, 4, 9, 0]
li = sorted(li)  # 提供方法

兩種方式都可以實現對列表元素的排序，從接受參數更能看出兩者區別和相同點。

  • sort(key=None, reverse=False)
  • sorted(iterable, key, reverse)

2、不同點

（1）：sort()屬於列表對象特有的排序方法，因此調用方法直接在列表本身進行修改，返回值為None或者說無需返回值。
（2）： sorted()屬於python提供內建函數，無需導入可直接用，而從接受對象來看，sorted()方法可以直接接受iterable可迭代對象，因此作用對象更廣泛，包括字元串，元組甚至字典都可以，返回一個列表，如下所示

test_string = "dvsegh"
print(sorted(test_string)) # 輸出['d', 'e', 'g', 'h', 's', 'v']
test_tuple = (5, 4, 3, 2, 1)
print(sorted(test_tuple)) # 輸出[1, 2, 3, 4, 5]
test_list = [5, 4, 3, 2, 1]
print(sorted(test_list)) # 輸出[1, 2, 3, 4, 5]
test_dic = {1:"a", 2:"b", 0:"z"}
print(sorted(test_dic)) # 輸出[0, 1, 2]，字典的key作為排序結果返回

（3）：對於Python3.x中的sort()無法函數自定義排序規則後面會說到。

3、相同點

（1）：都支持reverse反轉操作，參數reverse接收布爾類型，比如reverse=True，則表示排序結果逆序。

li = [1, 3, 4, 9, 0]
li.sort(reverse=True)
print(li)  # [9, 4, 3, 1, 0]

（2）： 都支持關鍵函數排序，也就是key參數指定排序規則，參數的接收值為一個函數，該函數可以接收一個參數並返回一個值用來比較，如下，len接收字元串，返回長度作為比較值。

test_string = "Hello World Welcome to My City"
print(sorted(test_string.split(" "), key=len))  # 根據字元串長度排序
# 輸出：['to', 'My', 'City', 'Hello', 'World', 'Welcome']
print(sorted(test_string.split(" "), key=str.lower))  # 根據小寫之後的字典序排序  
# 輸出：['City', 'Hello', 'My', 'to', 'Welcome', 'World']

test_list = [-5, 4, 0, 2, 1]
print(sorted(test_list, key=abs))  # 根據絕對值排序 
# 輸出：[0, 1, 2, 4, -5]

（3）：更廣泛的可以使用lambda表達式來完成更複雜排序。如下對二維列表多級排序

li = [
    [3 ,5],
    [5 ,0],
    [5 ,6],
    [3 ,-1],
    [2, 9]
]
# 多級排序
# 根據第一個元素從小打到排列，當第一個元素相等，按照第二個元素從大到小排列
li.sort(key=lambda x: (x[0], -x[1])) 
print(li)
#  輸出 [[2, 9], [3, 5], [3, -1], [5, 6], [5, 0]]

也或者可以根據複雜對象的某些屬性排序。對對象根據屬性進行排序

# 學生對象，包括年齡，身高體重等
class Student:
    def __init__(self, age, height, weight):
        self.age = age
        self.height = height
        self.weight = weight

s1 = Student(18, 180, 75)
s2 = Student(19, 175, 80)
s3 = Student(17, 176, 70)
s4 = Student(18, 177, 65)
s5 = Student(19, 180, 65)

# 班級里有很多學生
classes = [s1, s2, s3, s4, s5]
# 根據學生的年齡排序
classes.sort(key=lambda s: s.age)
for stu in classes:
    print("stu age: %d, height: %d, weight: %d" % (stu.age, stu.height, stu.weight))
    
輸出：
stu age: 17, height: 176, weight: 70
stu age: 18, height: 180, weight: 75
stu age: 18, height: 177, weight: 65
stu age: 19, height: 175, weight: 80
stu age: 19, height: 180, weight: 65

從以上排序結果中相同年齡的學生還保持排序前的相對順序，說明sort()排序也是穩定排序，sort()底層是基於合併排序和插入排序集合的一種更高效排序演算法。以上是使用lambda表達式指定排序規則，也可以使用operator中提供的其他更加簡潔的方式。

# 同樣適用上述的Student例子
from operator import itemgetter, attrgetter

# 實現根據學生年齡排序
print(sorted(classes, key=attrgetter('age')))
print(sorted(classes, key=itemgetter(1)))
# 實現多級排序 新根據身高，再根據年齡排序
sorted(classes, key=attrgetter('height', 'age'))

二、排序進階

其他語言中普遍提供的有cmp函數，也就是自定義更高級函數作為排序規則。而在python3.x中sort()不在支持cmp自定義函數比較，想要使用cmp，則需要是使用sorted()，並額外的做一些包裝。

1、舉例

比如，同樣使用如上的Student例子，想要完成自定義排序規則，比如首先按照年齡大小排序，當年齡相同的時候按照體重逆序排序，如果體重也相同則按照身高逆序排序。

from functools import cmp_to_key

def func(stu1, stu2):
    # 年齡相同
    if stu1.age == stu2.age:
        # 體重相同 安裝身高逆序
        if stu1.weight == stu2.weight:
            return stu2.height - stu1.height
        else: # 體重不同，逆序排序
            return stu2.weight - stu1.weight
    else: # 年齡不同，則按照年齡排序
        return stu1.age - stu2.age

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

s1 = Student(18, 180, 55)
s2 = Student(19, 175, 80)
s3 = Student(17, 162, 70)
s4 = Student(18, 177, 65)
s5 = Student(19, 180, 65)
s6 = Student(16, 160, 55)
s7 = Student(17, 164, 70)

# 班級有7個學生
classes = [s1, s2, s3, s4, s5, s6, s7]
# 排序
classes = sorted(classes, key=cmp_to_key(func))
for stu in classes:
    print("stu age: %d, height: %d, weight: %d" % (stu.age, stu.height, stu.weight))
    
輸出結果
stu age: 16, height: 160, weight: 55
stu age: 17, height: 164, weight: 70
stu age: 17, height: 162, weight: 70
stu age: 18, height: 177, weight: 65
stu age: 18, height: 180, weight: 55
stu age: 19, height: 175, weight: 80
stu age: 19, height: 180, weight: 65

對於sorted(iterable, key=lambda x:x)，這種比較傾向於待排序的每個元素都有一個絕對的大小值作為排序標準，而有時候會絕對大小是根據兩個元素才能得出的衡量，因此可以使用如上functools.cmp_to_key構建多個元素的比較函數。cmp_to_key包裝後的自定義比較函數可以接受兩個元素，將兩個元素的對比結果作為返回值，另外註意，自定義的比較函數返回值需要是整型。

2、源碼

cmp_to_key的源碼如下

def cmp_to_key(mycmp):
    """Convert a cmp= function into a key= function"""
    class K(object):
        __slots__ = ['obj']
        def __init__(self, obj):
            self.obj = obj
        def __lt__(self, other):
            return mycmp(self.obj, other.obj) < 0
        def __gt__(self, other):
            return mycmp(self.obj, other.obj) > 0
        def __eq__(self, other):
            return mycmp(self.obj, other.obj) == 0
        def __le__(self, other):
            return mycmp(self.obj, other.obj) <= 0
        def __ge__(self, other):
            return mycmp(self.obj, other.obj) >= 0
        __hash__ = None
    return K

cmp_to_key接收myfunc，併在內部定義一個K類並返回這個K類，這個類內部完成了各種比較運算符的重載（也就是mycmp的定義的排序規則），這個類是可調用的，在參與比較的時候其實是K的對象，而在使用lambda匿名錶達式的時候使用是列表中的元素進行大小比較。如下：

li = [1, 0, 0, 8, 4]
sorted(li, key=lambda x: x)  # x代指li中的每個元素

三、真題

以下是筆試面試過程中遇到的關於一些自定義排序規則的題目。可以結合實際場景做下應用。
註：以下只給出大概代碼樣例，水平有限，不保證完全正確。

1、題目一

（1）：華為通用軟體暑期實習筆試4.13場次演算法題第一題
題乾：硬體資源分配（不花點時間，題乾都理不順.....）
有M台伺服器，每台伺服器有以下屬性：編號、CPU核數（1100）、記憶體、CPU架構（08）、是否支持NP加速的標識（0,1）。然後有一個資源分配要求，要求分配N台滿足要求的伺服器。具體如下：CPU核數>=cpuCount、記憶體>=memSize、CPU架構=cpuArch、是否支持NP加速=supportNP。其中，cpuCount、memSize、cpuArch、supportNP為這個要求輸入的分配參數。
分配時會指定優先順序策略，策略如下：
策略1：CPU優先，優先選擇CPU核數滿足分配要求並且最接近分配要求的cpuCount。如果CPU核數相同，在按記憶體滿足要求並選擇最接近memSize的伺服器分配。
策略2：記憶體優先，優先選擇記憶體滿足分配要求並且最接近分配要求的memSize。如果記憶體相同，在按cpu核數滿足要求並選擇最接近cpuCount的伺服器分配
如果兩台伺服器屬性都相同，則按伺服器編號從小到大選擇（編號不會重覆）
輸入：
第一行：伺服器數量M
接下來M行為M台伺服器屬性的數組
下一行為分配要求：最大分配數量N，分配策略strategy，cupCount，memSize，cpuArch，supportNP
其中：
1<=M<=1000
1<=N<=1000
strategy：1表示策略1,2表示策略2
1<=cpuCount<=100
10<=memSize<=1000
0<=cpuArch<=8，另外，cpuArch使用9表示所有伺服器架構都滿足分配要求
0<=supportNP<=1，另外，為2時表示無論是否支持NP加速都滿足分配要求
輸出
先輸出實際分配數量，後按照分配的伺服器編號從小到大依次輸出，以空格分開
樣例1

輸入
4
0,2,200,0,1
1,3,400,0,1
2,3,400,1,0
3,3,300,0,1
3 1 3 200 0 1
輸出
2 1 3
解釋：只有1和3滿足要求，要求分配2台伺服器，所以結果為2 1 3

樣例2

輸入
6
0,2,200,0,1
1,4,330,2,1
2,3,400,3,1
3,3,310,1,1
4,3,320,8,1
5,3,330,0,1
3 2 3 300 9 2
（這裡註意一下輸入的格式，最後一行是空格分開）
輸出
3 3 4 5
解釋：編號1~5都滿足分配要求，按策略2分配即記憶體優先，記憶體>=300並且最接近300的伺服器編號是3 4 1 5 2。
其中1和5記憶體相同，然後會比較CPU，即CPU>=3且最接近的，所以5優先於1.因此最後分配的三台伺服器是3 4 5。
輸出時先輸出數量3，再按編號排序輸出3 4 5

（2）思路自定義排序：
主要先對一些特殊情況考慮，並且不同的策略不同的排序規則，但是都類似。

inp = list(map(int, input().strip().split(" ")))
N, strategy, cpuCount, memSize, cpuArch, SupportNP = inp
# N, strategy, cpuCount, memSize, cpuArch, SupportNP = 2, 1, 3, 300, 9, 1

res = []
for item in ans:
    if cpuArch != 9 and item[3] != cpuArch:
        continue
    if SupportNP != 2 and item[4] != SupportNP:
        continue
    res.append(item)

if strategy == 1:
    res = list(filter(lambda item: item[1]>=cpuCount and item[2]>=memSize, res))
    # res = list(filter(lambda item: item[2]>=memSize, res))
    res.sort(key=lambda x: (x[1], x[2]))

    if len(res) <= N and len(res) > 0:
        tmp = [len(res)] + sorted([item[0] for item in res])
        print(" ".join([str(i) for i in tmp]))
    elif len(res) > N:
        tmp = [N] + sorted([res[i][0] for i in range(N)])
        print(" ".join([str(i) for i in tmp]))
    else:
        print(0)

elif strategy == 2:
    res = list(filter(lambda item: item[2]>=memSize and item[1]>=cpuCount, res))
    # res = list(filter(lambda item: item[1]>=cpuCount, res))
    res.sort(key=lambda x: (x[2], x[1]))

    if len(res) <= N and len(res) > 0:
        tmp = [len(res)] + sorted([item[0] for item in res])
        print(" ".join([str(i) for i in tmp]))
    elif len(res) > N:
        tmp = [N] + sorted([res[i][0] for i in range(N)])
        print(" ".join([str(i) for i in tmp]))
    else:
        print(0)

2、題目二

（1）、華為通用軟體暑期實習業務一面演算法題
Leetcode最大數：鏈接https://leetcode-cn.com/problems/largest-number/
題乾：
給定一組非負整數 nums，重新排列每個數的順序（每個數不可拆分）使之組成一個最大的整數。
示例：
輸入：nums = [3,30,34,5,9]
輸出："9534330"
（2）、三種思路
version1：
由於沒有看到nums數組的容量範圍，第一反應直接全排列，然後對每一種結果作比較。

from itertools import permutations

nums = [3, 30, 34, 5, 9]

res = set(permutations(nums))  # 全排列結果去重
res = [int("".join(list(map(str, item)))) for item in res]  # 結果拼接再類型轉換
print(max(res))  # 取最大值 輸出 9534330

但是nums這麼大範圍，使用全排列做得無用功太多了，時間和空間複雜度都不滿足。
version2：
維持一個單調隊列，隊列中的元素拼接之後保證最大，逐個遍歷當前元素，再往隊列逐個位置嘗試插入，並最終找到插入位置保持隊列的規則。

class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        queue = []
        # 逐個遍歷列表元素
        for i in range(len(nums)):
            # 隊列為空，直接入隊
            if len(queue) == 0:
                queue.append(nums[i])
                continue
            # 假定當前nums[i]放在隊尾，拼接後的值為mx
            mx_ind = -1
            mx = int("".join(list(map(str,  queue + [nums[i]]))))
            # 逐個插入隊列中，作比較，誰大
            for j in range(len(queue)):
                tmp = int("".join(list(map(str,  queue[:j] + [nums[i]] + queue[j:]))))
                if tmp > mx:
                    mx = tmp
                    mx_ind = j
            # 找到插入位置
            if mx_ind != -1:
                queue = queue[:mx_ind] + [nums[i]] + queue[mx_ind:]
            else:
                queue = queue[:] + [nums[i]]
        # 合併                
        st = "".join(list(map(str, queue)))
        # 去除首部0
        st = st.lstrip("0")
        # 如果全為0，如nums=[0, 0]，則輸出0
        if len(st) == 0:
            return "0"
        else:
            return st

執行結果：

version3：
nums中的元素的位置不是由單一的元素決定，而是根據兩個元素拼接之後的誰大決定的，如果"xy" > "yx"，那就[x, y]，否則[y, x]。因此可以使用自定義排序。

class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        from functools import cmp_to_key
        def func(a, b):
            # 當前兩元素長度相等，則按照大小排列
            if len(str(a)) == len(str(b)):
                return b - a
            else:
            # 長度不同，則根據拼接後的大小排序
                return int(str(b)+str(a)) - int(str(a)+str(b)) 
        
        nums = sorted(nums, key=cmp_to_key(func))
        
        # 突然發現這樣寫更簡潔 ，不用額外定義func   
        # nums = sorted(nums, key=cmp_to_key(lambda x, y: int(str(y)+str(x)) - int(str(x)+str(y))))

        s = "".join(list(map(str, nums)))
        s = s.lstrip("0")
        if len(s) != 0:
            return s
        else:
            return "0"

執行結果：

3、題目三

（1）、榮耀通用軟體暑期開發實習生筆試第二題
題目記不太清了，大概就是把日誌文件中的一行一行記錄根據時間戳排序，記錄是字元串，不過整個記錄中包含其他的一些無用字元串，因此要自己過濾出有用的時間戳。
實例輸入：

5 
my/2019-01-01T09:00:01
my/2019-01-01T09:00:01
abc/2018-12-24T08:00:00/test/you
1/2018-12-24T08:00:00/test/Test1
123/2018-12-24T08:00:09/test/me

說明：5表示5行記錄
輸出：

1/2018-12-24T08:00:00/test/Test1
abc/2018-12-24T08:00:00/test/you
123/2018-12-24T08:00:09/test/me
my/2019-01-01T09:00:01

說明：優先根據時間戳信息排序，時間戳滿足一定的格式XXXX-XX-XXTXX:XX:XX，T為分隔符，分割日期和時間，前半部分為日期，後半部分為時間，時間戳相同根據字元串長度排序，如果長度也相同，則按照首字母的ascii碼表比較從小到大排序，如果兩個記錄字元串完全相同，則輸出一條即可。
（2）、思路
主要還是自定義排序規則，不過對於所有記錄都要做下處理判斷是否滿足時間戳規則，以及去重
代碼如下

from functools import cmp_to_key

# 判斷記錄字元串是否符合時間戳格式
def is_time_format(s):
    if len(s) != 19:
        return False
    if s[4] != "-"  or s[7] != "-" or s[10] != "T" or s[13] != ":" or s[16] != ":":
        return False
    return True

# 自定義排序規則
def func(a, b):
    if a[0] != b[0]:
        if a[0] > b[0]:
            return 1
        else:
            return -1
    else:
        if len(a[1]) != len(b[1]):
            return len(a[1]) - len(b[1])
        else:
            return ord(a[1][0]) - ord(b[1][0])

# 處理輸入
size = int(input().strip())
time_str = []
for _ in range(size):
    # 並將記錄分割成列表暫存起來
    tmp = input().strip().split("/")
    time_str.append(tmp)

# 保存滿足時間戳的記錄
res = []
for i in range(len(time_str)):
    for j in range(len(time_str[i])):
        if is_time_format(time_str[i][j]):
            res.append([time_str[i][j],  "/".join(time_str[i])])
            break
res = sorted(res, key=cmp_to_key(func))  # 自定義排序

# 重塑結果
ans = []
for i in range(len(res)):
    if res[i][1] not in ans:
        ans.append(res[i][1])

# 處理輸出
print("\n".join(ans))

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • HMS Core地理圍欄能力助你實現指定範圍人群的精準消息推送
    精準推送是移動端產品留存階段的主要運營手段，精準推送常常會與用戶畫像緊密結合，針對用戶的喜好、畫像，採用不同策略，但基於用戶所屬區域推送消息卻很難實現。目前市面上大多數第三方消息推送服務商，在系統未深度定製的情況下，通常不支持將推送人群範圍精確到某個商圈或較小的區域，而地理圍欄技術可以很好地彌補這一 ...
  • iOS 集成WebRTC相關知識點總結
    前言 本文主要是整理了使用WebRTC做音視頻通訊時的各知識點及問題點。有理解不足和不到位的地方也歡迎指正。 對於你感興趣的部分可以選擇性觀看。 WebRTC的初始化 在使用WebRTC的庫之前，需要對WebRTC進行初始化， 用到的代碼如下： RTCInitializeSSL(); 轉定義後可以看 ...
  • vue - Vue腳手架/消息訂閱與發佈
    今天的內容有意思了，朋友們繼續對我們之前的案例完善，是這樣的我們之前是不是靠props來完成父給子，子給父之間傳數據，其實父給子最好的方法就是props但是自給父就不是了，並且今天學下來，不僅如此，組件間任何層級的關係我都可以傳數據了，兄弟之間，爺孫之間等等等等 七.瀏覽器本地存儲 1.localS ...
  • 使用ffmpeg把mp4與m3u8相互轉換的操作
    移動端瀑布流佈局是一種比較流行的網頁佈局方式，視覺上來看就是一種像瀑布一樣垂直落下的排版。每張圖片並不是顯示的正正方方的，而是有的長有的短，呈現出一種不規則的形狀。但是它們的寬度通常都是相同的 因為移動端瀑布流佈局主要為豎向瀑布流，因此本文所探討的是豎向瀑布流 特點 豎向瀑布流佈局主要有下麵幾種特點 ...
  • JS中與運算，或運算歸納理解
    可以將（ 0, null, false, undefined, NaN ）理解為數字 0 與運算： 與運算 類比四則運算中的乘法。0和任何數相乘都等於0，因此他們和其他值做與運算都等於0（等於他本身，例如：null && 'abc'，結果為 null；1414 && 0，結果為 0）。 若是兩個0 ...
  • Node.js 中的進程和線程
    線程和進程是電腦操作系統的基礎概念，在程式員中屬於高頻辭彙，那如何理解呢？Node.js 中的進程和線程又是怎樣的呢？ 一、進程和線程 1.1、專業性文字定義 進程（Process），進程是電腦中的程式關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎，進程 ...
  • 設計模式七大原則—開閉原則
    重要性 有過一些實際開發工作的朋友一定對某個場景會深有體會，那就是客戶經常會對現有的功能提出新的需求要我們改動，並且要快速完成。如果你的代碼沒有很好的遵循“開閉原則”，並且頂著工期的縮減，那我們對需求變化的修改，“往往就像在一個草稿紙上反覆的塗抹”，隨著不斷的變化修改代碼就會顯得很亂，可能到最後你連 ...
  • Volatile的學習
    首先先介紹三個性質 可見性 可見性代表主記憶體中變數更新，線程中可以及時獲得最新的值。 下麵例子證明瞭線程中可見性的問題 由於發現多次執行都要到主記憶體中取變數，所以會將變數緩存到線程的工作記憶體，這樣當其他線程更新該變數的時候，該線程無法得知，導致該線程會無限的運行下去。 public class te ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類