Python基礎學習（二）

来源:https://www.cnblogs.com/skywlj1106/archive/2019/01/23/10311634.html
-Advertisement-
Play Games

Python函數總結 一、函數的基本用法 函數是對程式邏輯進行結構化或是過程化的一種編程方法，其是組織好的，可重覆使用的，用來實現單一，或者相同功能的代碼段。 函數提高了應用點的模塊性和代碼的重覆利用率 本質：函數是對功能的封裝 形式參數：簡稱形參，本質是一個沒有值的變數 ​ 實際參數：簡稱實參，本 ...


Python函數總結

一、函數的基本用法

1、概念：

函數是對程式邏輯進行結構化或是過程化的一種編程方法，其是組織好的，可重覆使用的，用來實現單一，或者相同功能的代碼段。

函數提高了應用點的模塊性和代碼的重覆利用率

本質：函數是對功能的封裝

形式參數：簡稱形參，本質是一個沒有值的變數 ​ 實際參數：簡稱實參，本質是常量，變數或者表達式 ​ 傳參：實參給形參賦值的過程

而實參的類型取決於形參的需要

2、函數定義：
  def  函數名(參數1，參數2，參數3.。。。):
          函數體
          return 返回值

註：a、函數命名遵循標識符規則，做到見名知意，小駝峰命名法、

b、參數1，參數2，參數3.....形式參數，不同的參數之間使用逗號隔開，參數的數量沒有限制，依據具體的需求決定參數的數量

c、函數體：被封裝的功能

d、return：結束函數，將返回值返回給調用者，也可單獨使用

e、返回值可為常量、變數、表達式

3、返回值

返回值：表示一個函數執行完畢之後得到的結果

註：對於return語句不帶參數，則返回一個None

4、調用

函數的調用：實質就是函數入棧出棧的過程

即：函數的入棧：函數被調用；函數的出棧：函數被調用完畢

註：在函數調用的過程要註意避免出現死迴圈

5、變數的作用域

變數的作用域：指變數可以被訪問的範圍

作用域的劃分：

L：（local）局部作用域

E：（Enclosing）函數作用域（閉包）

G：（Global）全局作用域

B：（Built-in）內置作用域

變數的查找規則（變數重名）：

python中變數的作用域由大到小，依次為內建（built_in B) >全局（glbal G）> 函數的閉包外（enclosing E）> 局部（local L）

註：在變數重名情況下在函數內部訪問變數時使用就近原則。

如果將全局變數的名字聲明在一個函數體內的時候，全局變數的名字能被局部變數給覆蓋掉，此時我們就需要使用global或者nonlocal來聲明變數了。

  #1.變數不重名
  num1 = 10    #全局作用域
  ​
  def outer():
      num2 = 20    #函數作用域
      def inner():
          num3 = 30  #局部作用域
          print(num1,num2,num3)
      return inner
  ​
  f = outer()
  f()
  # global:全局的
  # 全局變數
  num1 = 4
  def func1():
     # 聲明num1是全局變數的num1
      global  num1
      print(num1)   #4
   
  num1 = 20
  func1()
  ​
  a = 10
  def test():
      global  a
      a = a + 1
      print(a)   #UnboundLocalError: local variable 'a' referenced before assignment
      
  test()
  ​
  ​
  # nonlocal：不是局部的
  # nonlocal；前提條件：必須使用在閉包中
  x = 0  # 全局作用域
  def outer():
      x = 1       # 函數作用域
      def inner():
         # 將一個局部作用域的變數聲明為不是局部的，局部----》函數
          nonlocal x
          x = 2   #局部作用域
          print("inner:",x)
          
  #在外部函數中調用內部函數
  nner()
  print("outer:",x)
  outer()
  print("global:",x)

 

6、參數

1、參數的傳遞：

參數的傳遞有值傳遞和引用傳遞

值傳遞：傳遞不可變類型的數據，例：num、string、tuple等；在值傳遞時，形參的改變並不會影響實參

引用傳遞：傳遞可變類型的數據，例：list、dict、set等；形參的改變會影響實參的使用

在函數中參數傳遞的是對象的引用

  #引用傳遞：傳遞列表或者字典時，如果改變引用的值，就修改了原始的對象
  def check(l):
          print(l)
          print(id(l))
          l.append([1, 23, 2, 3, 4])
          return l
      
  l = [1, 2, 3, 4]
  print(check(l))
  print(id(l))
  ​
  '''
  [1, 2, 3, 4]
  2902500909320
  [1, 2, 3, 4, [1, 23, 2, 3, 4]]
  2902500909320
  '''
  #值傳遞：當傳遞不可變對象時，如果改變引用變數的值，只是創建了不同的對象，原始對象並沒有改變。
  ​
  def check(s):
      print(s)
      print(id(s))
      s = "i am test"
      print(id(s))
      return s
  ​
  s = "This is a test"
  print(check(s))
  print(s)
  ​
  '''
  This is a test
  2418424029424
  2418424029488
  i am test
  This is a test
  ​
  ​

2、參數的類型：

a、必須參數：必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。

  def printme( str ):
     "列印任何傳入的字元串"
      print str
      return
   
  #調用printme函數
  printme()

b、關鍵字參數：允許實參的順序和形參的順序不一致，因為Python解釋器會根據關鍵字參數的名稱自動的匹配

  def show2(name,age):
      print("name:%s age:%d" % (name,age))
  ​
  show2(name="jack",age=47)
  # 註：關鍵字參數使用在實參列表中，不要求順序保持一致
  show2(age=36,name="fadj")
  # 註：在實參列表中，可以不全部設置為關鍵字參數
  show2("zhangsan",age=15)
  ​
  # 註：關鍵字參數只能出現在實參列表的後面
  def show3(a,b,c):
      print(a,b,c)
  ​
  show3(1,4,4)
  show3(a=3,c=5,b=5)
  show3(45,b=9,c=18)
  #show3(a=45,9,18)  #SyntaxError: positional argument follows keyword argument

c、預設參數：調用函數的時候，如果沒有傳遞參數，則使用預設值【default】

  #註意1：預設參數體現在形參列表中
  def func3(name="abc",age=18):
   print("name:%s age:%d" % (name, age))
  #註意2：使用了預設參數，則可以選擇不傳參，使用的預設值,如果傳參，則相當於給形參重新賦值
  func3()
  func3("jack",19)
  #註意3：關鍵字參數和預設參數可以結合使用
  func3(name="jack",age=19)
  func3("jack",age=19)
  ​
  #註意4：形參列表可以不全部設置為預設參數，只要吃部分設置，則預設參數出現在形參列表的後面
  #報錯：SyntaxError: non-default argument follows default argument
  # def show4(name="abc",age):
  #     print("name:%s age:%d" % (name, age))
  # show4("bob",18)
  ​
  print("hello")

d、不定長參數：可以處理比聲明時更多的參數

  #a.*,一般寫法為*args
  def text1(*num):
      print(num)
      for n in num:
          print(n)
          
  # *不定長參數被當做元組處理，num形參名其實就是元組名
  text1(10)
  text1(10,4,54,65,65,7)
  # 可以傳一個元組，但是，元組被當做一個整體全部傳參
  text1((54,4,64))
  ​
  # 一般情況下，將不定長參數設置在形參列表的最後
  def text2(*num3,num1,num2):
      print(num1,num2,num3)
  ​
  # 如果不定長參數出現在形參列表的前面或者中間，則可以藉助於關鍵字參數傳參
  #text2(12,43,43)
  text2(12,34,num1=35,num2=59)
  ​
  # 在形參列表，不定長參數最好只出現一個
  #錯誤演示
  # def text3(*num3,num2,*num1):
  #     print(num1,num2,num3)
  # text3(43,53,num2=10,5,5,4)
  ​
  ​
  #b.**,一般寫法為**kwargs
  def text4(**num3):
   print(num3)
  ​
  #註意1：**,被當做字典處理，傳參的時候，需要以key=value的方式進行傳參
  text4(x=26,y=17)
  ​
  #註意2:在形參列表中使用**，保證出現在後面
  ​
  """
  使用場景：單例設計模式
  def text(*args,**kwargs):
  ​
  總結：
  a.必需參數使用最多，其次是不定長參數
  b.關鍵字參數和預設參數最多使用在系統函數中
  """
7、匿名函數

lambda表達式：python中的匿名函數主要用來處理一些簡單邏輯表達式的封裝，使用lambda關鍵字

優點：不占用記憶體，提高代碼的運行速度

一般格式為：

var = lambda args:表達式

例如：

f = lambda x,y:x+y
#該函數的調用結果為 冒號後的表達式所表達的結果
print(f(1,2))

二、函數進階

1、概念【特殊用法】：

1、變數可以指向函數

x = abs(-35)
print(x)   # 35

# 一個普通的變數可以指向一個函數，該變數就可以被當做函數調用
f = abs
print(f)
print(f(-100))

def check():
 	print("check")

check()
f1 = check
f1()

2、函數也可以作為變數名

# 本質：函數名就是一個指向函數的變數
print(abs(-28))
# abs = "hello"
# print(abs(-7))

3、函數作為參數使用

# 調用形參中的函數，必須和原函數保持一致【註意是否需要傳遞參數】
def test(a,b,fun):
 	return fun(a) + fun(b)   #abs(43) + abs(-27)
print(test(43,-27,abs))  #fun = abs

def test1(s1,s2,func):
 	return func(s1) + func(s2)
print(test1("hello","gajghj",len))
2、閉包：

在函數內部定義了另一個函數，即存在外部函數和內部函數

閉包【closure】：在外部函數中定義一個內部函數，並且外部函數的返回值是內部函數的引用。

# 普通函數
def show():
    print("1111")
 	return  num1

# 閉包
def outter():
 	def inner():
     	print("inner")
 	return inner

f = outter()   #f = inner
f()

# 在閉包設置參數,a和b兩個變數被稱為自由變數【臨時變數】
# 閉包的優點：在外部函數中定義的變數，在內部函數可以直接訪問
def outer1(a):
 	b = 10
	def inner1():
     	print(a + b)
	return inner1

f1 = outer1(23)  #f1 = inner1
f1()


# 內部函數設置參數
def outer2(a):
 	b = 10
 	def inner2(c):
     	print(a + b + c)
	return inner2

f2 = outer2(23)
f2(12)

 

3、裝飾器：

裝飾器【Decorator】：使其他函數在不需要做任何代碼的變動下，為函數添加功能，裝飾器的返回值也是一個函數。

本質：裝飾器的本質就是一個閉包，其作用是將一個函數作為參數，返回另一個函數

裝飾器函數運行在函數定義的時候

裝飾器需要返回一個可執行的對象

裝飾器返回的可執行對象要相容函數f的參數

import  time
#1.簡單的裝飾器
def test():
 	print("hello")
# func就是需要被裝飾的函數
def outer(func):
 	def inner():
     	# 增加新功能
    	print("new~~~~")
     	# 調用原函數
    	func()
 	return  inner

f1 = outer(test)
f1()

# 練習：書寫裝飾器，計算test函數執行的時間
def outer(func):
 	def inner():
     	t1 = time.time()
        func()
		t2 = time.time()
		print(t2 - t1)
	return  inner
f1 = outer(test)
f1()

#2.帶有參數的裝飾器
def getAge(age):
 	print(age)
# getAge(10)
# getAge(-36)
# 註意：被裝飾的函數有參數，inner不一定需要設置參數，只有當需要在inner內部對參數進行操作的時候，則需要同步
def wrapper1(func):
 	def inner(a):
     #數據的校驗
     	if a < 0:
         	a = -a
        func(a)
 	return  inner

f = wrapper1(getAge)
f(10)
f(-36)


# 使用裝飾器語法糖
# 註意：使用@，必須保證裝飾器存在的情況下，才能給函數增加功能
def wrapper2(func):
 	def inner(a):
     	# 數據的校驗
     	if a < 0:
         	a = -a
		 func(a)
	return inner

@wrapper2
def getAge1(age):
 	print(age)
    
getAge1(-19)

# 參數為不定長參數的裝飾器
# 使用場景：一個裝飾器可以同時作用於多個不同函數的情況
def wrapper3(func):
 	def inner(*args,**kwargs):
     	# 新增的功能
     	print("abc")
     #調用原函數
     	func(*args,**kwargs)
 	return  inner

@wrapper3
def test(a,b):
     print(a,b)

test(10,20)

@wrapper3
def test1():
 print("gsjrg")

test1()

# 多個裝飾器作用於同一個函數
def wrapper11(func):
 	def inner(*args,**kwargs):
     	# 新增的功能
     	print("裝飾器~~~~11")
     	# 調用原函數
     	func(*args,**kwargs)
 	return  inner

def wrapper22(func):
 	def inner(*args,**kwargs):
     	# 新增的功能
     	print("裝飾器~~~~22")
     	# 調用原函數
     	func(*args,**kwargs)
 	return  inner

@wrapper11    # func:check
@wrapper22      # func:被wrapper11裝飾之後的函數
def check():
 	print("check")

check()
#總結：多個裝飾器作用於同一個函數的時候，從上往下依次執行，但是，原函數只被調用一次
4、偏函數

通過設定預設參數，可以降低調用的難度，偏函數也可以起到這樣的作用

概念：對函數的參數做一些控制的函數

註意：偏函數一般不需要自己定義，直接使用【functools模塊其中提供了偏函數的使用】

import  functools


print(int("23534"))
# print(int("abc345"))  #ValueError: invalid literal for int() with base 10: 'abc345'

# 在int中有一個預設參數base，用來指明當前數據的進位
print(int("110"))
print(int("110",base=10))
print(int("1010",base=2))
print(int("1010",2))
# 自定義一個函數，設置一個預設參數base，預設值設置為2
def int2(x,base=2):
 	return int(x,base)

print(int2("1010"))
print(int2("1010",10))

# 系統的functools模塊中提供了偏函數的實現
# 參數：已經存在的函數名   預設參數
int3 = functools.partial(int,base=2)
print(int3("1110"))
print(int3("1110",base=10))

# 思想：根據一個已經存在的函數，通過修改該函數參數的預設值，生成一個新的函數，被稱為偏函數

三、高階函數

1、filter():過濾

"""
filter(function,iterable)  通過一定的條件過濾可迭代對象中的元素

工作原理：把傳入的函數依次作用於可迭代對象的每一個元素，根據返回的布爾值【True或者False】決定是否保留元素
如果返回True，則表示需要保留該元素；如果返回False，則表示需要過濾掉該元素
"""
# 將列表中的偶數篩選出來
list1 = [1,2,3,4,5,6,7,8]
# 自定義【追加】
newList1 = []
for num in list1:
 	if num % 2 == 0:
    	 newList1.append(num)
print(newList1)
# 自定義【刪除】
newList2 = list1.copy()
for num in newList2:
  	if num % 2 == 1:
     	newList2.remove(num)
print(newList2)

#方式三：列表生成式
newList3 = [num for num in list1 if num % 2 == 0]
print(newList3)

# filter
def func(num):
	# 保留偶數元素
 	if num % 2 == 0:
     	return True
	# 過濾奇數元素
 	return False

newList4 = list(filter(func,list1))
print(newList4)

# 將愛好為"無"的數據剔除掉
data = [['姓名', '愛好', '年齡'],['tom', '無', 10],['jack', '唱歌', 28]]
def func2(s):
 	if s == "無":
     	return False
	 return  True
for line in data:
  	result = list(filter(func2,line))
  	print(result)

2、map()：映射

"""
map(function,Iterable)  會根據的函數對指定的序列做出映射
function：函數
iterable：可迭代對象，序列
工作原理：函數會以序列中的每一個元素作為參數，返回包含函數的功能的新列表
功能：將傳入的函數依次作用於序列中的每一個元素，並把結果作為新的iterable返回
"""
# 計算列表中各個元素的平方
list1 = [1,2,3,4,5]
# 自定義
newList1 = []
for num in list1:
 	newList1.append(num ** 2)
print(newList1)

# 列表生成式
newList2 = [num ** 2 for num in list1]
print(newList2)

# 生成器
newList3 = list((num ** 2 for num in list1))
print(newList3)

# map[def定義的函數]
def func(x):
  return  x ** 2

result = map(func,list1)
print(result)
print(type(result))
newList4 = list(result)
print(newList4)

"""
傳給map的函數的要求：
 a.參數只能有一個【預設將可迭代對象的一個元素傳遞給該函數】
 b.該函數必須有返回值，否則得到的可迭代對象中的元素為None
"""
#方式五：map[匿名函數]
newList5 = list(map(lambda x:x ** 2,list1))
print(newList5)

# 已知有一個整數列表，將轉換為字元串列表
#例如：[2,3,4,5]------>['2','3','4','5']   str()
list2 = [2,3,4,5]
newL1 = []
for num in list2:
 	newL1.append(str(num))
print(newL1)
newL2 = [str(num) for num in list2]
newL3 = list((str(num) for num in list2))
newL4 = list(map(str,list2))
print(newL4)

reduce()：迭代【累積】

from functools import reduce
"""
導入模塊：functools
reduce(function,iterable):函數會對序列中的元素進行累積
功能：用傳給reduce的函數先序列中的第1,2個元素進行操作，
用得到的結果和第3個元素進行操作，用得到的結果和第4個元素進行操作。。。。

舉例：
f,[a,b,c,d]
reduce(f,[a,b,c,d])
工作原理：f(f(f(a,b),c),d),類似於遞歸
"""

# 計算一個整數列表中元素的和
# 一：自定義
list1 = [1,2,3,4,5]
total = 0
for num in list1:
 	total += num
print(total)

# 二：reduce【def定義函數】
def mySum(x,y):
 return x + y
result0 = reduce(mySum,list1)
print(result0)
"""
mySum(1,2)---->3
mySum(3,3)---->6
mySum(6,4)---->10
mySum(10,5)---->15
"""

# 三：reduce[匿名函數]
result1 = reduce(lambda x,y:x + y,list1)
print(result1)
"""
函數的註意事項：
 a.必須有兩個參數
 b.必須設置返回值【報錯：TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'】
"""

# 將[1,3,5,7,9]轉換為整數13579
list2 = [1,3,5,7,9]
def func(x,y):
 	return  x * 10 + y

result3 = reduce(func,list2)
print(result3)

# 自定義一個函數，實現str轉換為int的函數  int(xx)
def charToNum(s):
 # 自定義字元串和整型之間的映射關係
 	digits = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6}
  return digits[s]

# 需求：“24356”------》24356
# a.產生映射關係
r0 = list(map(charToNum,"24356"))
print(r0)
#b.使用reduce累積
r1 = reduce(func,r0)
print(r1)
print(type(r1))

r2 = reduce(func,map(charToNum,"23456"))
print(r2)

 


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

-Advertisement-
Play Games
更多相關文章
  • 對於條件語句的程式編寫問題
    今天在寫條件語句時，一老出錯 自認為程式上是沒什麼問題的，所以將逗號去掉試試看 得出了正確的值，很意外，然後多試了幾次之後，逗號也可以輸入了 原來我誤把中文輸入法的逗號輸入到scanf中，而運行時又用英文輸入法 然後得出來的總結就是，scanf函數中必須用自己制定的格式，輸入，輸出。 ...
  • 併發編程的目標與挑戰
    If I had only one hour to save the worlds,I would spend fifty five minutes defining the problem,and only five minutes finding the solution. 如果我只有1小時拯救 ...
  • 漫步人生路之Python旅途(九)百日築基
    函數名的使用: 函數名可以作為值,賦值給變數 函數名可以作為參數傳參給函數. 函數名可以作為返回值 函數名可以作為元素存儲在容器里 閉包:在嵌套函數內,使用外層局部變數(非全局變數)就是一個閉包,閉包可以多層嵌套.閉包的優點: 避免局部變數不被外界修改 函數生命周期延長 節省開闢空間,銷毀空間的時間 ...
  • 【分散式緩存系列】集群環境下Redis分散式鎖的正確姿勢
    一、前言 在上一篇文章中，已經介紹了基於Redis實現分散式鎖的正確姿勢，但是上篇文章存在一定的缺陷——它加鎖只作用在一個Redis節點上，如果通過sentinel保證高可用，如果master節點由於某些原因發生了主從切換，那麼就會出現鎖丟失的情況： 於是，客戶端1和客戶端2同時持有了同一個資源的鎖 ...
  • 如果你不懂電腦語言，那麼就請你不要說你是學電腦的！！好丟人。。。
    如果你不懂電腦語言，那麼就請你不要說你是學電腦的！！好丟人的。。。今天然我帶你深入瞭解真正的電腦語言！ 編程語言可分為三種：高級語言、彙編語言、機器語言。 1、什麼是高級語言？ 高級語言：它是把高級語言的基本結構和語句與低級語言的實用性結合起來的工作單元。 常見的高級語言：Java、C、C++ ...
  • 【MyBatis】MyBatis實現CRUD操作
    1、實現基本CRUD功能 使用MyBatis對數據完整的操作，也就是CRUD功能的實現。根據之前的內容，要想實現CRUD，只需要進行映射文件的配置。 範例：修改EmpMapper.xml文件，實現CRUD 此時已經完成了映射文件的配置。就可以利用SqlSession類對象完成具體的操作，方法如下： ...
  • Java開發筆記（五十二）對象的類型檢查
    前面介紹了類的多態性，來自於雞類的實例chicken，既能用來表達公雞實例，也能用來表達母雞實例。可是這導致了一個問題，假如在call方法內部需要手工判斷輸入參數屬於公雞實例還是母雞實例，那該如何是好？所謂“雄兔腳撲朔，雌兔眼迷離，雙兔傍地走，安能辨我是雄雌”，固然編譯器在運行之時能夠自動判斷這是哪 ...
  • 計算組合數
    輸入兩個整數 n,m ，求在 m 個數中取 n 個數的方案總數： 1 var 2 n,m:longint; 3 function c(n,m:longint):qword; 4 var 5 i:longint; 6 begin 7 c:=1; 8 for i:=1 to n do 9 c:=c*(m ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類