python語法進階這一篇就夠了

来源:https://www.cnblogs.com/kasia/archive/2023/02/03/17090278.html
-Advertisement-
Play Games

前言 前面我們已經學習了Python的基礎語法,瞭解了Python的分支結構,也就是選擇結構、迴圈結構以及函數這些具體的框架,還學習了列表、元組、字典、字元串這些Python中特有的數據結構,還用這些語法完成了一個簡單的名片管理系統。下麵我就將介紹一下Python的一些進階語法規則,為後面更複雜的編 ...


前言

前面我們已經學習了Python的基礎語法,瞭解了Python的分支結構,也就是選擇結構、迴圈結構以及函數這些具體的框架,還學習了列表、元組、字典、字元串這些Python中特有的數據結構,還用這些語法完成了一個簡單的名片管理系統。下麵我就將介紹一下Python的一些進階語法規則,為後面更複雜的編程打下基礎。

  1. 閉包與裝飾器
    什麼是閉包、裝飾器函數、yield關鍵字

  2. python高階函數
    lambda匿名函數、reduce函數、map函數、filter過濾器函數

  3. 面向對象編程
    什麼是面向對象、對象的封裝、類的繼承、類的多態

  4. 進程與線程編程
    python中的進程與線程、多線程編程

第一章. 閉包與裝飾器

1. 什麼是閉包

# coding=utf-8
# 閉包
# def func1():
#     print ("函數1運行")
#     return func2()
# #函數1的返回值是函數2的引用
# def func2():
#     print ("函數2運行")
#     return 2
# r =func1()
# print (r)
# r2= r()  # r = func2
# print (r2)


def func1():
    print ("函數1運行")
    def func2():
        print ("函數2運行")
    func2()
    return func2()
f2 = func1()
print(f2)
f2()
  
"""
在一個函數,比如func1中的內部定義了另外一個函數function2
並且函數1(func1)的返回值是函數2(func2)的引用
這種情況,我們稱之為閉包

簡單來說就是外部函數返回內部函數的引用就叫做閉包
"""

print列印結果:

函數1運行
函數2運行
函數2運行
None

案例:龜兔賽跑

# coding=utf-8
import time
import random

# 定義跑道長度
track_length = 10
def runtime(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print (func.__name__,"運行時間是",end_time-start_time,"秒")
    return wrapper
    
@runtime
def tortoise():
    # for i in [1,2,3,4,5,6,7,8,9,10]:
    for i in range(1,track_length+1):
        print ("烏龜跑的{}米".format(i))
        time.sleep(1)
@runtime
def rabbit():
    for i in range(1,track_length + 1):
        if i % 5 == 0:
            time.sleep(random.randint(1,10))
        print ("兔子跑了{}米".format(i))
tortoise()
rabbit()

print列印結果:

烏龜跑的1米
烏龜跑的2米
烏龜跑的3米
烏龜跑的4米
烏龜跑的5米
烏龜跑的6米
烏龜跑的7米
烏龜跑的8米
烏龜跑的9米
烏龜跑的10米
tortoise 運動時間是 10.04876708984375 秒 
兔子跑了1米
兔子跑了2米
兔子跑了3米
兔子跑了4米
兔子跑了5米
兔子跑了6米
兔子跑了7米
兔子跑了8米
兔子跑了9米
兔子跑了10米
rabbit 運動時間是 9.022485494613647 秒

2. 什麼是裝飾器呢?

就是在特定條件下為某些函數再不改動函數體的時候為函數新添加一些功能,這就是裝飾器

實現原理:
基於@語法和函數閉包,將原函數封裝在閉包中,然後將函數賦值為一個新的函數(內置函數),執行函數時再在內層函數中執行閉包中的原函數

實現效果:
可以在你改變函數內部代碼和調用的前提下,實現在函數執行和執行拓展功能

適用場景:
多個函數系統統一在執行前後定義一些功能

關於前言我們瞭解這麼多就夠了,然後小編帶著大家推導出裝飾器
裝飾器:
裝飾器的寫法:
這裡我們有一個需求,我們定義了5個函數,想在5個函數執行前和執行後都列印一句話:裝飾器的學習。首先我們來寫於一下沒有裝飾器的寫法,話不多說直接上代碼:

def a():
    pass
 
 
def b():
    pass
 
 
def c():
    pass
 
 
def d():
    pass
 
 
def e():
    pass

先定義5個函數,再加上我們要列印的話:

def a():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def b():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def c():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def d():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def e():
    print("裝飾器的學習")
    pass
    print("裝飾器的學習")
 
 
a()
b()
c()
d()
e()

運行一下:

1675421215622.png

發現運行成功,但我們想如果我要修改列印的話就要都修改一次,特別麻煩,而且,這是5個函數如果是500個,我們還要一個一個的去加嗎?這就有我們的裝飾器了,首先我用裝飾器修改下,再給大家解釋。

def outer(origin):
    def inner():
        print("裝飾器的學習")
        res = origin()
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def a():
    pass
 
 
@outer
def b():
    pass
 
 
@outer
def c():
    pass
 
 
@outer
def d():
    pass
 
 
@outer
def e():
    pass
 
 
a()
b()
c()
d()
e()

運行一下:

1675421264764.png

發現這樣我們也成功了,接下來小編來個大家解釋

首先:
我們要明白@的作用,那我們的函數a來舉例子@的作用就是幫我們執行一次a=outer(a),首先python將把我們的a變成參數傳給outer函數,運行後再賦值給a,這就是@的作用。

其次給大家解釋一下自定的outer函數
我自己稱這個函數為@下函數的補丁函數,也就是裝飾器函數還是拿a函數舉例子,首先a函數變成參數傳給了我們的outer函數,outer里又嵌套了一個inner函數 ,然後將函數a賦值給res,然後用return語句返回出結果,外層函數返回inner函數,也就是將inner函數運行一次,這就是工作流程。

最後分別在各函數前加上裝飾,最後運行出結果

1675421264764.png
這就是裝飾器的寫法。

裝飾器的參數
這時我遇到一個問題如果函數內有參數而且每個函數的參數數量不同,我們應該怎末辦,先看下麵代碼

def outer(origin):
    def inner():
        print("裝飾器的學習")
        res = origin()
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def a(g, e):
    pass
 
 
@outer
def b(w):
    pass
 
 
@outer
def c(u, y, t):
    pass
 
 
@outer
def d(c):
    pass
 
 
@outer
def e():
    pass
 
 
a()
b()
c()
d()
e()

這時我們運行一下

image.png

發現報錯,是因為我們的裝飾器內沒有這兩個參數,那可以在裝飾器內設置兩個參數,但問題是,有的函數內有3個參數,而有的函數內沒有參數,那我們應該怎麼辦?

針對這個問題我們可以給裝飾器設置動態參數,先看代碼:

def outer(origin):
    def inner(*args, **kwargs):
        print("裝飾器的學習")
        res = origin(*args, **kwargs)
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def a(a1):
    print("我是一函數")
 
 
@outer
def b(a1, a2):
    print("我是二函數")
 
 
@outer
def c(a5, a6, a7):
    print("我是三函數")
 
 
a(1)
b(2, 3)
c(4, 5, 6)

因為函數太多了,小編有點麻煩就剪了幾個函數,但道理是相同的,這時我們再運行一下

1675421364035.png

這樣我們就成功了,以上就是裝飾器的寫法,接下來給大家拓展一下

裝飾器的拓展:(functools模塊)
首先給大家引入一下這時教給大家幾個魔法方法

1675421496515.png
接下來我們實戰一下

def outer(origin):
    def inner(*args, **kwargs):
        # 我是一個裝飾器函數
        print("裝飾器的學習")
        res = origin(*args, **kwargs)
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def c(a5, a6, a7):
    # 我是個函數
    print("我是三函數")
 
 
c(4, 5, 6)
print(c.__name__)
print(c.__doc__)

運行一下:
1675421532140.png

這時我們發現我要的是c函數,但給我反饋的是inner函數,這是為什麼呢?

這就是工作原理,直接就把c函數裝飾成了inner函數,那以後再工作中一定會要自己函數的名字,而不要我裝飾後的函數,這樣就可以讓我們的函數裝飾的更像,其實在以後中,都想裝飾的更像,那我們應該怎末辦?

這時就需要我們的第三方模塊functools,直接上代碼

import functools
 
 
def outer(origin):
    @functools.wraps(origin)
    def inner(*args, **kwargs):
        # 我是一個裝飾器函數
        print("裝飾器的學習")
        res = origin(*args, **kwargs)
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def c(a5, a6, a7):
    # 我是個函數
    print("我是三函數")
 
 
c(4, 5, 6)
print(c.__name__)
print(c.__doc__)

這時再運行一下

1675421572219.png

這時我們發現,我們偽裝成功了,這樣就會讓我們的裝飾更像。

裝飾器模板:
接下來送給大家裝飾器的模板,以後需要隨時ctrl+c和ctrl+v

import functools
 
 
def outer(origin):
    @functools.wraps(origin)
    def inner(*args, **kwargs):
        # 這裡書寫需要裝飾的功能
        res = origin(*args, **kwargs)
        return res
 
    return inner
    

第二章. Python高階函數

1. lambda表達式(匿名函數)

# coding=utf-8
# lambda表達式(匿名函數)
# 計算圓形的面積
# pi * r * r
# 導入數學模塊
import math
def circle_area(r):
    result = math.pi * r * r
    return result
r = circle_area(3)
print (r)
"""
lambda是一個關鍵字
冒號前邊的r是這個函數的參數
冒號後邊的是這個函數的運算邏輯
"""
result = lambda r:math.pi * r * r
r = result(3)
print (r)

def calc_function(o):
    if o == "+":
        return lambda a,b : a + b
    elif o == "-":
        return lambda a,b : a - b
    elif o == "*":
        return lambda a,b : a * b
    elif o == "/":
        return lambda a,b : a / b
f = calc_function("*")
print (f)
r = f(3,4)
print (r)

print列印結果:

28.2743338823
28.2743338823
<function <lambda> at 0x03159B70>
12

2. map自動拆分的計算函數

# coding=utf-8
# map函數
my_list = [1,2,3,4,5]
# 1
result = []
for i in my_list:
    result.append(i + 1)
print (result)

# 2
def add_one(e):
    return e + 1
r = map(add_one,my_list)
print (list(r))
def add_two(e):
    if e == 1:
        return e + 3
    elif e == 2:
        return 2 - 1
    else:
        return e
r =map(add_two,my_list)
print (list(r))
# 3
print (list(map(lambda e:e+1,my_list)))

print列印結果:

[2, 3, 4, 5, 6]
[2, 3, 4, 5, 6]
[4, 1, 3, 4, 5]
[2, 3, 4, 5, 6]

3. reduce自動堆疊計算函數

# coding=utf-8
# reduce
# 導入reduce
from functools import reduce
a =[2,4,6,8,10]
def add(x,y):
    return x + y
result = reduce(add,a)
print (result)

print (reduce(lambda x,y : x+y,a))

print列印結果:

30
30

4. filter過濾器函數

# coding=utf-8

# filter函數
letter=['a',"B",'c',"D",'e',"F"]
upper_letter = filter(lambda x: x == x.upper(),letter)
print (upper_letter)
print (list(upper_letter))

student_name = ['李元芳','李建國','莫懷羽']
print (list(filter(lambda x:x.startwith("李"),
                   student_name)))

print列印結果:

['B', 'D', 'F']
['B', 'D', 'F']
['李元芳','李建國']

第三章. 面向對象編程

1. 對象的封裝

# coding=utf-8
# 對象的封裝
# 類的概念
"""
類的名字:當名字由多個單詞構成時,我們採用駝峰命名法
就是說多個單詞,每個單詞的首字母需要大寫
這也是python的命名規則
"""
class BeautifulGirl():
    # 類的屬性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""

    # 構造函數
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("構造函數運行了")
    # 在這就叫做類的方法
    def dance(self):
        print ("美女在跳舞")

    def get_beautiful_girl(self):
        print ("這個美女的樣貌是:")
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)

# 實例化就是獲取具體對象的一個過程 new新的一個。
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"烏黑亮麗的頭髮"
                     ,"清秀的臉龐")
girl.dance()
girl.get_beautiful_girl()

girl2 = BeautifulGirl("小小的眼睛",'鼻子','嘴','頭髮','臉龐')
girl2.get_beautiful_girl()

print列印結果:

大大的眼睛
小巧的嘴唇
烏黑亮麗的頭髮
清秀的臉龐
小小的眼睛
這個美女的樣貌是:
鼻子
嘴
頭髮
臉龐

2. 類的私有屬性

# coding=utf-8
# 類的私有屬性
class BeautifulGirl():
    # 類的屬性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""
    # 這就是私有屬性,私有屬性在類的外部是不可以訪問的
    __name ="高圓圓"
    address = "河北省唐山市"
    # 構造函數
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("構造函數運行了")
    # 在這就叫做類的方法
    def dance(self):
        print ("美女在跳舞")
    def __dd(self):
        print ("美女在跳舞")

    def get_beautiful_girl(self):
        print ("這個美女的樣貌是:")

        print (self.__name)
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"烏黑亮麗的頭髮"
                     ,"清秀的臉龐")
print (girl.mouth)
print (girl.address)
# print (girl.__name)
# # 類的私有屬性可以訪問嗎?
# print (BeautifulGirl.__dict__)
# print (girl._beautiful__name)
girl.get_beautiful_girl()

print列印結果:

構造函數運行了
這個美女的樣貌是:
高圓圓
大大的眼睛
小巧的鼻子
薄薄的嘴唇
烏黑亮麗的頭髮
清秀的臉龐

3. 類中的方法

# coding=utf-8
# 類的私有屬性
class BeautifulGirl():
    # 類的屬性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""
    # 這就是私有屬性,私有屬性在類的外部是不可以訪問的
    __name ="高圓圓"
    address = "河北省唐山市"
    # 構造函數,也叫構造方法
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("構造函數運行了")
    # 在這就叫做類的方法
    def dance(self):
        print ("美女在跳舞")
    # 這個叫做私有方法
    def __dd(self):
        print ("美女在跳舞")
    # 這個叫做一般方法
    def get_beautiful_girl(self):
        print ("這個美女的樣貌是:")

        print (self.__name)
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)
    # 靜態方法
    # 靜態方法不能夠訪問類中的屬性
    @staticmethod
    def study():
        print ("美女在實習")

    # 類方法
    # 類方法是不可以訪問實例變數的,它可以訪問類變數(類的屬性
    @classmethod
    def girl_friend(cls):
        print (cls.__name)
        print (cls.address)
        print (cls.face)
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"烏黑亮麗的頭髮"
                     ,"清秀的臉龐")

# print (BeautifulGirl.__dict__)
# 這就訪問了類中的私有方法
# girl.beautifulGirl__dd()

girl.study()
BeautifulGirl.study()

# 類名,一般方法的名稱調用是會報錯的
# BeautifulGirl.dance(girl)

girl.girl_friend()
BeautifulGirl.girl_friend()
girl.get_beautiful_girl()

print列印結果:

構造函數運行了
這個美女的樣貌是:
高圓圓
河北省唐山市
高圓圓
河北省唐山市
大大的眼睛
小巧的鼻子
薄薄的嘴唇
烏黑亮麗的頭髮
清秀的臉龐

4. 類的繼承

# coding=utf-8
# 類的繼承
# 父類和子類
class Father(object):
    age = 38

    def __init__(self,name):
        self.name = name
        print ("父類的構造函數運行了")

    def father_money(self):
        print ("父親有很多錢")

    def __father_knowleger(self):
        print ("父親的知識體系")

    @staticmethod
    def study():
            print ("父親在學習")

    @classmethod
    def father_friend(cls):
            print ("父親有很多朋友")

    def face(self):
            print ("父親非常帥")
# 意味著son這個類繼承了father這個類
class Son(Father):
   def __init__(self):
       print ("子類的構造函數運行了")
# son = Son("小王")
son = Son()
# 在繼承中,子類如果有構造函數,name就不會調用弗雷德構造函數

# 在繼承中,一般的方法是可以被繼承的
son.father_money()

# 私有方法可以被繼承
# son.__father_knowleger()
son.study()
son.father_friend()

class Mother():
    def face(self):
        print ("媽媽長的很漂亮")

# 這就叫做多繼承
class Son2(Mother,Father):
    def __init__(self):
        print("2兒子的構造函數運行了")

son2 = Son2()
son2.father_money()
son2.face()
# 當多繼承的時候,多個父類擁有一個名稱的變數或方法時
# 哪個父類寫在繼承列表的前邊,子類就繼承誰的

print列印結果:

子類的構造函數運行了
父親有很多錢
父親在學習
父親有很多朋友
2兒子的構造函數運行了
父親有很多錢
媽媽長的很漂亮

5. 類的多態

# coding=utf-8
# 類的多態
# 指的是多種形態

class Animal():
    def run(self):
       print ("動物開始跑")
# 子類在繼承父類的過程中,重寫了父類中的方法
class Dog(Animal):
    def run(self):
        print ("狗狗跑")

class Cat(Animal):
    def run(self):
        print ("貓跑")

class Person(Animal):
    def run(self):
        print ("人類跑")

dog = Dog()
dog.run()

cat = Cat()
cat.run()

person = Person()
person.run()

# 多個類繼承同一個類,都重寫了父類的方法,呈現出了不同的形態

# 多態性
class A(Animal):
    pass
a = A()

def run(obj):
    obj.run()

run(dog)
run(cat)
run(person)
run(a)

print列印結果:

狗狗跑
貓跑
人類跑
狗狗跑
貓跑
人類跑
動物開始跑

6. 多進程編程

# coding=utf-8
# 多進程編程代碼演示
import time
from multiprocessing import Process
import os

def target_function():
    print ("子進程的ID:{}".format(os.getpid()))
    time.sleep(2)
if __name__== "__main__":
    print (__name__)
    print ("主進程ID:{}".format(os.getpid()))
    ps = []
    for i in range(10):
        p = Process(target_function())
        p.start()
        ps.append(p)
    # 讓主進程等待子進程進行運行完成後在停止
    for p in ps:
        p.join()

print列印結果:

__main__
主進程ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692
子進程的ID:2692

最後

訪問量破千,一起加油!

寫博客是為了記錄和分享自己的學習歷程,溫故知新!做的不好的地方歡迎指正!!!


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

-Advertisement-
Play Games
更多相關文章
  • Web 頁面可以使用多種方式實現動畫效果,其中最常用的有兩種: CSS 動畫:通過 CSS 中的 transition 和 animation 屬性來實現動畫效果。CSS 動畫實現起來簡單,性能消耗小,支持廣泛。 JavaScript 動畫:通過 JavaScript 代碼來實現動畫效果。JavaS ...
  • At-rules規則是目前CSS中一種常見的語法規則,它使用一個"@"符號加一個關鍵詞定義,後面跟上語法區塊,如果沒有則以分號結束即可。 這種規則一般用於標識文檔、引入外部樣式、條件判斷等等,本文是對該規則的使用總結。 常用規則 @import @import 主要用於從其他樣式表導入新的樣式規則, ...
  • jwt擴展欄位介紹 為了實現業務的定製化需求和開發人員使用的便利,對kc的JWT進行了擴展,這個擴展欄位在解析JWT之後都可以看到。 jwt的payload { "exp": 1675329802, "iat": 1675329622, "jti": "2a80e925-b9ce-464f-822d ...
  • “ DDD設計的目標是關註領域模型而並非技術來創建更好的軟體,假設開發人員構建了一個SQL,並將它傳遞給基礎設施層中的某個查詢服務然後根據表數據的結構集取出所需信息,最後將這些信息提供給構造函數或者Factory,開發人員在做這一切的時候早已不把模型看做重點了,這個整個過程就變成了數據處理的風格 ”... ...
  • 通常,不同的公司里有著不同的編碼規範,主要是從代碼得準確性、穩定性、可讀性等地方著手制定,以提高團隊成員之間的協作效率,這裡主要是列出一些常見的編碼規範。 ...
  • SpringMVC介紹-01 1.離線文檔 解壓 spring-5.3.8-dist.zip文件。 位置:spring-framework-5.3.8/docs/reference/html/web.html#spring-web 2.SpringMVC基本介紹 2.1SpringMVC特點&概述 ...
  • 1 簡介 我們進行Web API開發的時候,經常會使用Json格式的消息體,而Json格式非常靈活,不同的人會有不同的設計風格和實現,而JSON API提供了一套標準。但它並不提供直接實現。 Katharsis是JSON API的Java實現,使用它可以快速開發出Json based的Web介面,還 ...
  • Python有哪些關鍵字 Python常用的關鍵字 and, del, from, not, while, as, elif, global, or, with, assert, else, if, pass, yield, break, except, import, print, class, ...
一周排行
    -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版本說明 機器同時安裝了 ...