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
更多相關文章
  • 序言 各位好啊,我是會編程的蝸牛,作為java開發者,我們每天都要和開發工具打交道。我以前一開始入門java開發的時候,就是用的eclipse,雖然感覺有點繁瑣,但好在還能用。後來偶然間發現了IDEA,然後就漸漸被IDEA所吸引了,不過最近在做一些老項目的開發,大概是十幾年的那種技術,我發現用IDE ...
  • 前言 本文是博主從事後端開發以來,對公司、個人項目的經驗總結,包含代碼編寫、功能推薦、第三方庫使用及優雅配置等,希望大家看到都能有所收穫 博主github地址: https://github.com/wayn111 一. 優雅的進行線程池異常處理 在Java開發中,線程池的使用必不可少,使用無返回值 ...
  • 重構項目目錄 celery_task: logs:項目運行時/開發時日誌目錄包 luffapi:項目同名文件夾 apps:項目所有應用的集合文件夾 libs:第三方類庫的保存目錄[第三方組件、模塊] - 包 media:用戶提交的文件目錄文件夾 settings:配置目錄,包含開發時的配置文件和上線 ...
  • 話說在前面,我不是小黑子~ 我是超級大黑子😏 表弟大周末的跑來我家,沒事幹天天騷擾我,搞得我都不能跟小姐姐好好聊天了,於是為了打發表弟,我決定用Python做一個小游戲來消耗一下他的精力,我思來想去,決定把他變成小黑子,於是做了一個坤坤打籃球的游戲,沒想到他還挺愛玩的~ 終於解放了,於是我把游戲寫 ...
  • 使用腳本自動跑實驗(Ubuntu),將實驗結果記錄在文件中,併在實驗結束之後將結果通過郵件發送到郵箱,最後在windows端自動解析成excel表格。 ...
  • 大家好,我是陶朱公Boy。 前言 上一篇文章《關於狀態機的技術選型,最後一個真心好》我跟大家聊了一下關於”狀態機“的話題。從眾多技術選型中我也推薦了一款阿裡開源的狀態機—“cola-statemachine”。 於是就有小伙伴私信我,自己項目也考慮引入這款狀態機,但網上資料實在太少,能不能系統的介紹 ...
  • 一、Kafka存在哪些方面的優勢 1. 多生產者 可以無縫地支持多個生產者,不管客戶端在使用單個主題還是多個主題。 2. 多消費者 支持多個消費者從一個單獨的消息流上讀取數據,而且消費者之間互不影響。 3. 基於磁碟的數據存儲 支持消費者非實時地讀取消息,由於消息被提交到磁碟,根據設置的規則進行保存 ...
  • 10瓶毒藥其中只有一瓶有毒至少需要幾隻老鼠可以找到有毒的那瓶 身似浮雲,心如飛絮,氣若游絲。 用二分查找和二進位位運算的思想都可以把死亡的老鼠降到最低。 其中,二進位位運算就是每一隻老鼠代表一個二進位0或1,0就代表老鼠存活,1代表老鼠死亡;根據數學運算 23 = 8、24 = 16,那麼至少需要四 ...
一周排行
    -Advertisement-
    Play Games
  • Timer是什麼 Timer 是一種用於創建定期粒度行為的機制。 與標準的 .NET System.Threading.Timer 類相似,Orleans 的 Timer 允許在一段時間後執行特定的操作,或者在特定的時間間隔內重覆執行操作。 它在分散式系統中具有重要作用,特別是在處理需要周期性執行的 ...
  • 前言 相信很多做WPF開發的小伙伴都遇到過表格類的需求,雖然現有的Grid控制項也能實現,但是使用起來的體驗感並不好,比如要實現一個Excel中的表格效果,估計你能想到的第一個方法就是套Border控制項,用這種方法你需要控制每個Border的邊框,並且在一堆Bordr中找到Grid.Row,Grid. ...
  • .NET C#程式啟動閃退,目錄導致的問題 這是第2次踩這個坑了,很小的編程細節,容易忽略,所以寫個博客,分享給大家。 1.第一次坑:是windows 系統把程式運行成服務,找不到配置文件,原因是以服務運行它的工作目錄是在C:\Windows\System32 2.本次坑:WPF桌面程式通過註冊表設 ...
  • 在分散式系統中,數據的持久化是至關重要的一環。 Orleans 7 引入了強大的持久化功能,使得在分散式環境下管理數據變得更加輕鬆和可靠。 本文將介紹什麼是 Orleans 7 的持久化,如何設置它以及相應的代碼示例。 什麼是 Orleans 7 的持久化? Orleans 7 的持久化是指將 Or ...
  • 前言 .NET Feature Management 是一個用於管理應用程式功能的庫,它可以幫助開發人員在應用程式中輕鬆地添加、移除和管理功能。使用 Feature Management,開發人員可以根據不同用戶、環境或其他條件來動態地控制應用程式中的功能。這使得開發人員可以更靈活地管理應用程式的功 ...
  • 在 WPF 應用程式中,拖放操作是實現用戶交互的重要組成部分。通過拖放操作,用戶可以輕鬆地將數據從一個位置移動到另一個位置,或者將控制項從一個容器移動到另一個容器。然而,WPF 中預設的拖放操作可能並不是那麼好用。為瞭解決這個問題,我們可以自定義一個 Panel 來實現更簡單的拖拽操作。 自定義 Pa ...
  • 在實際使用中,由於涉及到不同編程語言之間互相調用,導致C++ 中的OpenCV與C#中的OpenCvSharp 圖像數據在不同編程語言之間難以有效傳遞。在本文中我們將結合OpenCvSharp源碼實現原理,探究兩種數據之間的通信方式。 ...
  • 一、前言 這是一篇搭建許可權管理系統的系列文章。 隨著網路的發展,信息安全對應任何企業來說都越發的重要,而本系列文章將和大家一起一步一步搭建一個全新的許可權管理系統。 說明:由於搭建一個全新的項目過於繁瑣,所有作者將挑選核心代碼和核心思路進行分享。 二、技術選擇 三、開始設計 1、自主搭建vue前端和. ...
  • Csharper中的表達式樹 這節課來瞭解一下表示式樹是什麼? 在C#中,表達式樹是一種數據結構,它可以表示一些代碼塊,如Lambda表達式或查詢表達式。表達式樹使你能夠查看和操作數據,就像你可以查看和操作代碼一樣。它們通常用於創建動態查詢和解析表達式。 一、認識表達式樹 為什麼要這樣說?它和委托有 ...
  • 在使用Django等框架來操作MySQL時,實際上底層還是通過Python來操作的,首先需要安裝一個驅動程式,在Python3中,驅動程式有多種選擇,比如有pymysql以及mysqlclient等。使用pip命令安裝mysqlclient失敗應如何解決? 安裝的python版本說明 機器同時安裝了 ...