python基礎-面向對象

来源:https://www.cnblogs.com/white-list/archive/2022/11/30/16846464.html
-Advertisement-
Play Games

1.面向對象 面向對象編程是在面向過程編程的基礎上發展來的，它比面向過程編程具有更強的靈活性和擴展性，所以可以先瞭解下什麼是面向過程編程： 面向過程編程的核心是過程，就是分析出實現需求所需要的步驟，通過函數一步一步實現這些步驟，接著依次調用即可，再簡單理解就是程式 從上到下一步步執行,從頭到尾的解決 ...


1.面向對象

  面向對象編程是在面向過程編程的基礎上發展來的，它比面向過程編程具有更強的靈活性和擴展性，所以可以先瞭解下什麼是面向過程編程：

  面向過程編程的核心是過程，就是分析出實現需求所需要的步驟，通過函數一步一步實現這些步驟，接著依次調用即可，再簡單理解就是程式

  從上到下一步步執行,從頭到尾的解決問題；

  而面向對象編程是把構成事物的整個需求按照特點、功能劃分，將這些存在共性的部分封裝成對象，創建對象的目的不是為了完成某一個步驟，

  而是為了描述某個事物在整個解決問題的步驟中的行為。     

  eg： 小明用美的洗衣機洗臟衣服，流程是怎樣的？

  面向過程的解決方法：

    1、執行加洗衣液方法；

    2、執行開啟洗衣機方法；

    3、執行加水方法；

    4、執行洗衣服方法；

    5、執行甩乾方法；

    6、取出衣服；

    以上就是將解決這個問題的過程拆成一個個方法，通過按順序執行方法來解決問題。

  面向對象的解決方法：

    1、可以先歸納出兩個對象：“美的洗衣機”對象和“小明”對象

    2、針對對象“美的洗衣機”加入一些它的方法：“自動註水方法”“洗衣方法”、“烘乾方法”

    3、針對對象“小明”加入他的方法：“加洗衣液方法”、“開啟洗衣機方法”、“取出衣服方法”

    4、然後執行，使用對象.動作 的方式，執行各步驟

    小明.加洗衣液

    小明.開啟洗衣機

    美的洗衣機.自動註水

    美的洗衣機.洗衣服

    美的洗衣機.烘乾

    小明.取出衣服

    解決同一個問題 ，面向對象編程就是先抽象出對象，然後用對象執行方法的方式解決問題。

 

2.類

  如果想通過面向對象編程，首先需要創建一個類(class)，才能實例化（或叫具象化）對象；

  （洗衣例子中要先有人這個類，才能有“小明”對象、先有洗衣機類，才能有“美的洗衣機”這個對象）

  類可以理解成一個模板，通過它可以創建出無數個具體實例（對象）；

  使用類的關鍵字class，來聲明類，首字母大寫，多個單詞時每個單詞首字母要大寫（駝峰命名法）；

  eg： class MyName(object): 

      (object)可以不寫，object是python中的一個通用對象，添加它後可以使用更多的內置功能；

class Test(object):
    name = 'test'   # 定義一個類屬性

    def run(self):
        print(f'{self.name}在跑步!')


xiaoming = Test()  # 實例化一個對象xiaoming
print(xiaoming.name)  # 對象xiaoming可以調用類屬性
xiaoming.run()  # 對象xiaoming可以調用類方法
'''
test
test在跑步!
'''

  類的參數self

  可以看到類的方法中預設第一個參數是self，且是必填的；（python中的self關鍵字只用於類的方法中）；

  self也是一個對象，它代表實例化變數(例子中的xiaoming)本身（xiaoming可以調用name屬性和run方法，都是self幫助找到的）

class Person(object):

    name = None  # 類屬性（也叫類實例化屬性）
    age = None

    def run(self):
        print('可以直接使用self調用類屬性')
        print('列印屬性:'+str(self.name))
        a = 'new'   # 類方法中定義的變數無self時，屬於方法中的局部變數
        print('列印局部變數:'+a)

    def work(self):
        print('利用self可直接調用類中其它類函數')
        self.run()

    def jump():
        print('不添加self參數，就不屬於類函數，就不可以被實例化的對象調用')


# 實例化一個對象xiaoming
xiaoming = Person()
# 可以直接調用類屬性（類實例化屬性）
print(xiaoming.name)  # None
# 也可為類屬性（類實例化屬性）重新賦值
xiaoming.name = 'xiaoming'
# 調用類方法, 調用時無需傳遞self參數值
xiaoming.work()
'''
利用self調用類中其它函數
可以直接使用self調用類屬性
列印屬性:xiaoming  （此時類屬性值已被實例化對象修改）
列印局部變數:new
'''
# print(xiaoming.a)  # AttributeError: 'Person' object has no attribute 'a'  方法中的局部變數不可被實例化對象調用

# 實例化另一個對象xiaohong
xiaohong = Person()
print(xiaohong.name)  # None # 對象xiaohong並不會使用到對象xiaoming修改的類屬性（類實例化屬性）值;對象修改的類屬性（類實例化屬性），只能作用於對象本身
xiaohong.jump()  # 非類函數無法被對象調用，直接報錯
'''
Traceback (most recent call last):
  File "D:\python_exercise\test_calss.py", line 44, in <module>
    xiaohong.jump()
TypeError: Person.jump() takes 0 positional arguments but 1 was given
'''
# 可以看到報錯信息是函數無參數值，卻被傳遞了一個，說明對象在調用方法時，自動傳遞了self參數，所以直接報錯了

 

3.類的構造函數

  類中的一種預設函數，用來將類實例化的同時，將參數傳入類中；（類似於函數執行時，可以傳一些參數）

  def __init__(self, a, b):

    self.a = a      # 類實例化對象的屬性

    self.b = b

  此時self.a和self.b就可以在類的各個類函數中使用了；

class Person(object):

    def __init__(self, name):
        self.name = name  # self.聲明的變數是類實例屬性

    def run(self):
        print(f"{self.name}在跑")


test = Person('x')
test.run()  # x在跑

'''
此時已經見過了類中可定義的多種變數
類下直接定義的變數，屬於類屬性、又屬於類實例化對象屬性 （可被實例化後的對象直接引用）
構造函數中self.開頭定義的屬性，屬於類實例化對象屬性，不屬於類屬性（可被實例化後的對象直接引用）（工作中多用，且多在構造函數中提前定義好）
類函數中a=''定義的變數，屬於局部變數，既不屬於類實例化對象屬性，也不屬於類屬性（不可被實例化後的對象直接引用）
'''

 

4.對象的生命周期

  一個對象從出生到消亡的過程；

  實例化對象後，會調用內置函數__init__, 此時對象生命開始，該對象會被記憶體分配一個記憶體塊；

  對象不再使用類中的方法屬性時、或整個腳本結束執行時，對象會自動調用內置函數__del__通知記憶體管家，從記憶體中釋放占用的記憶體塊，對象生命結束；

  無論是數字、字元串、列表、元組等對象，生命周期皆是如此；

  python中會讓對象自動調用__del__的操作，無需在程式中書寫；

 

  __def__所有這種書寫形式的方法，都是類的內置函數，定義類時書寫object（class Name(object)），就可以調用這些內置函數了。

 

5.私有函數和私有變數

  私有：獨有的、不公開；

  無法被實例化後的對象調用的類中的函數和變數，就是私有函數、私有變數；

  類的內部可以在類函數中調用私有函數和私有變數；

  使用場景：某一方法只希望內部業務調用使用，不希望被使用者調用；

  定義方法：在類函數、類變數前添加__ (兩個下劃線)；

class Cat(object):

    def __init__(self, name):
        self.name = name
        self.__sex = 'boy'  # 私有類實例化屬性

    def run(self):
        # 類函數可以調用私有函數
        self.__run(self.__sex)

    # 私有函數
    def __run(self, sex):
        # 私有函數可以使用類實例化屬性
        print(f'{self.name}，是個{sex}，它在跑!')


cat = Cat('ll')
cat.run()  # ll，是個boy，它在跑!
# 對象不可調用私有函數,直接報錯
# cat.__run()  # AttributeError: 'Cat' object has no attribute '__run'

# 也有可調用的方法，但既然創建了私有函數、私有變數，建議遵守使用規則
print(dir(cat))  # 列印所有類的內置函數，就可以看到私有函數的調用名了
'''
['_Cat__run', '_Cat__sex', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', 
'__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'run']
'''
cat._Cat__run('girl')  # ll，是個girl，它在跑!
print(cat._Cat__sex)  # boy

 

6.python中封裝

  python中封裝的概念：

    我們在類中把某些屬性和方法隱藏起來、定義為私有，只能在類的內部使用，外部無法訪問，或者留下少量的介面（函數）供外部訪問，就是封裝的概念；

    這樣做的目的是為了保護隱私、明確區分內外。

 

7.類的裝飾器

  裝飾器也是一種函數；

  它可以接收函數作為參數；且可以返回一個函數；

  接收一個函數，內部對其進行處理，然後返回一個新函數，動態的增強函數功能；

# 簡單梳理下裝飾器的大概由來

# 有一個業務函數print_test()
def print_test(info):
    print('業務函數'+info)
'''
此時想在執行業務函數前後增加日誌輸出,
且有多個類似的業務函數需要完成同樣的操作，
可以編寫另一個公用函數，以業務函數為參數，業務函數前後完成相應日誌輸出
'''
def add_info(func, info):
    print('開始的日誌')
    func(info)
    print('結束的日誌')

# 執行add_info
add_info(print_test, 'test')
'''
開始的日誌
業務函數test
結束的日誌
'''
# 但是這樣改變了原有的print_test(info)完成業務操作的寫法，可以藉助裝飾器寫法優化下
def add_info_new(func):
    def wrapper(*args, **kwargs):
        print('列印開始的日誌')
        func(*args, **kwargs)
        print('列印結束的日誌')
    return wrapper

print_test = add_info_new(print_test)
print_test('test')
'''
列印開始的日誌
業務函數test
列印結束的日誌
'''
# python中可以藉助@語法糖，優化上面print_test = add_info_new(print_test)的寫法

@add_info_new
def print_test_final(info):
    print('藉助語法糖的業務函數'+info)

print_test_final('test')
'''
列印開始的日誌
藉助語法糖的業務函數test
列印結束的日誌
'''

# 裝飾器調用時，也可以傳遞參數，對業務處理進行再次的判斷
def add_print_args(handle):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print('依舊執行前列印日誌')
            func(*args, **kwargs)
            print('依舊執行後列印日誌')
            if handle:
                print('額外處理')
        return wrapper
    return decorator


@add_print_args(handle=True)
def print_test_args(info):
    print('列印一下'+info)

print_test_args('test')
'''
依舊執行前列印日誌
列印一下test
依舊執行後列印日誌
額外處理
'''

'''
使用裝飾器後，被裝飾函數的元信息會被修改，例如__name__, doc等
'''
print(print_test_args.__name__)
# wrapper  （這裡也很好理解，已經被返回成新的裝飾函數了）
'''
若想保存元信息不變，
可以使用wrap庫，from functools import wraps
wraps也是一個裝飾器，它是把原函數元信息拷貝到了裝飾器函數中
'''
from functools import wraps
def add_print_wrap(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print('執行前列印')
        func(*args, **kwargs)
        print('執行後列印')
    return wrapper

@add_print_wrap
def print_test_wrap(info):
    print('業務函數'+info)

print_test_wrap('test')
print(print_test_wrap.__name__)
'''
執行前列印
業務函數test
執行後列印
print_test_wrap
'''

'''
類裝飾器
通過內置函數__call__處理額外操作
'''
class AddPrint(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print('開始的列印foo')
        self.func(*args, **kwargs)
        print('結束的列印foo')

@AddPrint
def print_test_foo(info):
    print('業務函數'+info)

print_test_foo('test')
'''
開始的列印foo
業務函數test
結束的列印foo
'''

'''
類裝飾器也可以通過傳參做額外操作
'''
class Foo(object):
    def __init__(self, handle):
        self.handle = handle

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            print('執行前操作')
            func(*args, **kwargs)
            print('執行後操作')
            if self.handle:
                print('額外操作')
        return wrapper

@Foo(handle=True)
def print_test5(info):
    print('業務操作'+info)

print_test5('test')
'''
執行前操作
業務操作test
執行後操作
額外操作
'''

  

8.幾種內置的常見裝飾器

  @classmethod

  將類的函數定義為可以不經過實例化而直接被調用；此時可以不實例化，直接調用該方法；

class Foo(object):

    def __init__(self, a):
        self.a = a

    def run(self):
        print('run')

    @classmethod
    def jump(cls):
        print('jump')
    # 此時self被替換成cls，代表類本身

# Foo.run()
'''
Traceback (most recent call last):
  File "D:\python_exercise\test5.py", line 21, in <module>
    Foo.run()
TypeError: Foo.run() missing 1 required positional argument: 'self'
因為正常我們實例化的時候，python會自動幫我們將self參數傳遞進去
此時沒有實例化，所以報錯沒有傳self參數
'''
Foo.jump()  # jump
# 類函數就可以不用實例化直接調用了

  cls函數不可引用self函數

class Foo(object):

    def __init__(self, a):
        self.a = a

    def run(self):
        print('run')

    @classmethod
    def jump(cls):
        print('jump')
        cls.run()

Foo.jump()
'''
TypeError: Foo.run() missing 1 required positional argument: 'self'
'''

  self函數可以引用cls函數

class Foo(object):

    def __init__(self, a):
        self.a = a

    def run(self):
        print('run')
        self.jump()

    @classmethod
    def jump(cls):
        print('jump')

foo = Foo('test')
foo.run()
foo.jump()   # 實例化對象也可使用cls函數
'''
run
jump
jump
'''

  @staticmethod

  將類函數定義為可以不經過實例化而直接被調用，且該函數不需要傳遞self或cls，且無法在該函數內調用其它類函數或類變數；

class Foo(object):

    def __init__(self):
        pass

    def run(self):
        print('run')
        self.jump()

    @staticmethod
    def jump():
        print('jump')

Foo.jump()  # jump
foo = Foo()
foo.jump()  # jump (也可以通過對象調用)
foo.run()  # static函數也可以被其它類函數調用
'''
run
jump
'''

  @property

  將類函數的調用免去括弧，類似於調用屬性；

class Foo(object):

    @property
    def run(self):
        print('run')


foo = Foo()
foo.run  # run

  同樣使用這種調用方法，需要傳參時，有自己的寫法；

class Foo(object):

    @property
    def run(self):
        print('run')

    @run.setter
    def run(self, info):
        print(info)


foo = Foo()
foo.run = 'test info'  # test info

 

9.類的繼承

  通過繼承，子類可以擁有父類所有的屬性和方法；

  父類不具備子類自有的屬性和方法；

  定義方法 class Child(Parent):  Child類繼承Parent類；

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

    def walk(self):
        print(f'{self.name}在行走')


class Child(Parent):
    def run(self):
        self.walk()    # 子類可以調用父類的方法
        print(f"{self.name}在跑步")   # 子類可以直接調用父類的屬性


child = Child('ll', 13)   # 繼承父類後，父類的初始化參數子類也要傳遞
child.walk()  # ll在行走 (子類實例化對象可以調用父類的方法)
child.run()
'''
ll在行走
ll在跑步
'''

  

10.類的多態

  子類繼承父類後，對於父類中的同一功能可以表現出多狀態變化（多種執行方式、結果等），且是通過子類對父類方法的重寫實現的；

class Parent(object):
    def __init__(self, name):
        self.name = name

    def walk(self):
        print('父類在行走')


class Child(Parent):

    def walk(self):
        print('子類在行走')


child = Child('兒子')
child.walk()  # 子類在行走

'''
為什麼要繼承
為了使用已經寫好的類中的方法

為什麼要多態
為了保留子類中和父類名稱相同的函數的功能
'''

 

11.python中的super函數

  在子類重新書寫父類方法時，此時想既保留父類方法的邏輯、同時增加新邏輯，就可以藉助super函數；

  用法：super(當前類，self(類的實例)).父類的方法()；python3.0時代，super()中兩個參數可以省略；

class Parent(object):
    def __init__(self, name):
        self.name = name
        print('父類構造函數'+self.name)


class Child(Parent):
    def __init__(self, name, age):
        super(Child, self).__init__(name)
        self.age = age
        print('子類新的構造函數'+str(self.age))


child = Child('xiaoming', 23)
'''
父類構造函數xiaoming
子類新的構造函數23
'''
# 例子中子類對於父類中的構造函數參數進行了擴充，在工作中很常用

 

12.類的多重繼承

  子類可以繼承多個父類；

  class Child(Parent, Parent2, Parent3...):

class Father(object):
    def run(self):
        print('父親跑')

    def walk(self):
        print('父親走')


class Mother(object):
    def run(self):
        print('母親跑')

    def sing(self):
        print('母親唱')


class Child(Father, Mother):
    pass


child = Child()
child.sing()  # 母親唱
child.run()  # 父親跑 (多個父類有重名方法時，優先繼承寫在第一位的類)
print(Child.__mro__)  # (<class '__main__.Child'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class 'object'>)
'''
__mro__ 方法可以列印類的繼承鏈
'''

  

13.類的幾個高級函數

  __str__  返回類的描述信息；

class Test(object):
    pass


test = Test()
print(test)  # <__main__.Test object at 0x00000298AC9264D0>


class Test2(object):
    def __str__(self):
        return 'this is a test class'


test2 = Test2()
print(test2)  # this is a test class

  __getattr__ 當調用的屬性或方法不存在時，會返回該方法定義的信息；

class Test(object):
    pass


test = Test()
print(test.a)  # 調用類的屬性不存在時，會直接報錯
'''
Traceback (most recent call last):
  File "D:\python_exercise\test7.py", line 14, in <module>
    print(test.a)
AttributeError: 'Test' object has no attribute 'a'
'''

class Test2(object):
    def __getattr__(self, item):
        return f'{item}不存在'


test2 = Test2()
print(test2.a)  # a不存在

  __setattr__  攔截當前類中不存在的屬性和值，並做處理；

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

    def __setattr__(self, key, value):
        print(key, value)
        # 列印所有的屬性字典
        print(self.__dict__)
        self.__dict__[key] = value
        print(self.__dict__)


test = Test('xiao', 32)
test.sex = 'boy'
print(test.sex)
'''
name xiao
{}
{'name': 'xiao'}
age 32
{'name': 'xiao'}
{'name': 'xiao', 'age': 32}
sex boy
{'name': 'xiao', 'age': 32}
{'name': 'xiao', 'age': 32, 'sex': 'boy'}
boy
'''
# 可以看到每一次生成新的屬性，都會調用__setattr__方法，無論是在構造函數，還是在實例對象test.sex = 'boy'
test.name = 'new_xiaoming'
# 也可修改原屬性的值
'''
{'name': 'new_xiaoming', 'age': 32, 'sex': 'boy'}
'''

  __call__  將實例化對象直接變成函數使用；

class Test(object):
    def __call__(self, *args, **kwargs):
        print(f'call 函數開始: {args[0]}')


test = Test()
test('test')  # call 函數開始: test
# eg: 編寫一個可以通過 對象.a.b.c() 執行的類
class Test(object):
    def __init__(self, args=''):
        print('------')
        self.args = args
        
    def __getattr__(self, item):
        print('開始的item:'+item)
        print('self.args:'+self.args)
        if self.args:
            item = f'{self.args}.{item}'
        print('後來的item:'+item)
        return Test(item)
    
    def __call__(self, *args, **kwargs):
        print('ttttt')
        
        
test = Test()
test.a.b.c()  # ttttt
'''
------
開始的item:a
self.args:
後來的item:a
------
開始的item:b
self.args:a
後來的item:a.b
------
開始的item:c
self.args:a.b
後來的item:a.b.c
------
ttttt
'''

 

總結

  


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

-Advertisement-
Play Games
更多相關文章
  • eclipse真的落後了嘛？這幾點優勢其他IDE比不上
    序言 各位好啊，我是會編程的蝸牛，作為java開發者，我們每天都要和開發工具打交道。我以前一開始入門java開發的時候，就是用的eclipse，雖然感覺有點繁瑣，但好在還能用。後來偶然間發現了IDEA，然後就漸漸被IDEA所吸引了，不過最近在做一些老項目的開發，大概是十幾年的那種技術，我發現用IDE ...
  • 十二條後端開發經驗分享，純乾貨，總有一條你不知道
    前言 本文是博主從事後端開發以來，對公司、個人項目的經驗總結，包含代碼編寫、功能推薦、第三方庫使用及優雅配置等，希望大家看到都能有所收穫 博主github地址: https://github.com/wayn111 一. 優雅的進行線程池異常處理 在Java開發中，線程池的使用必不可少，使用無返回值 ...
  • 重構後臺的django項目目錄、配置開發環境、添加環境變數
    重構項目目錄 celery_task: logs:項目運行時/開發時日誌目錄包 luffapi：項目同名文件夾 apps：項目所有應用的集合文件夾 libs：第三方類庫的保存目錄[第三方組件、模塊] - 包 media：用戶提交的文件目錄文件夾 settings：配置目錄，包含開發時的配置文件和上線 ...
  • Apache Dubbo 多語言體系再添新員：首個 Rust 語言版本正式發佈
    話說在前面，我不是小黑子~ 我是超級大黑子😏 表弟大周末的跑來我家，沒事幹天天騷擾我，搞得我都不能跟小姐姐好好聊天了，於是為了打發表弟，我決定用Python做一個小游戲來消耗一下他的精力，我思來想去，決定把他變成小黑子，於是做了一個坤坤打籃球的游戲，沒想到他還挺愛玩的~ 終於解放了，於是我把游戲寫 ...
  • 數字邏輯實驗 9 FPGA數字鐘(Verilog)
    使用腳本自動跑實驗（Ubuntu)，將實驗結果記錄在文件中，併在實驗結束之後將結果通過郵件發送到郵箱，最後在windows端自動解析成excel表格。 ...
  • Python中5大模塊的使用教程（collections模塊、time時間模塊、random模塊、os模塊、sys模塊）
    大家好，我是陶朱公Boy。 前言 上一篇文章《關於狀態機的技術選型，最後一個真心好》我跟大家聊了一下關於”狀態機“的話題。從眾多技術選型中我也推薦了一款阿裡開源的狀態機—“cola-statemachine”。 於是就有小伙伴私信我，自己項目也考慮引入這款狀態機，但網上資料實在太少，能不能系統的介紹 ...
  • Kafka牛逼在哪裡？
    一、Kafka存在哪些方面的優勢 1. 多生產者 可以無縫地支持多個生產者，不管客戶端在使用單個主題還是多個主題。 2. 多消費者 支持多個消費者從一個單獨的消息流上讀取數據，而且消費者之間互不影響。 3. 基於磁碟的數據存儲 支持消費者非實時地讀取消息，由於消息被提交到磁碟，根據設置的規則進行保存 ...
  • 10瓶毒藥其中只有一瓶有毒至少需要幾隻老鼠可以找到有毒的那瓶
    10瓶毒藥其中只有一瓶有毒至少需要幾隻老鼠可以找到有毒的那瓶 身似浮雲，心如飛絮，氣若游絲。 用二分查找和二進位位運算的思想都可以把死亡的老鼠降到最低。 其中，二進位位運算就是每一隻老鼠代表一個二進位0或1，0就代表老鼠存活，1代表老鼠死亡；根據數學運算 23 = 8、24 = 16，那麼至少需要四 ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類