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 頁面如何實現動畫效果
    Web 頁面可以使用多種方式實現動畫效果，其中最常用的有兩種： CSS 動畫：通過 CSS 中的 transition 和 animation 屬性來實現動畫效果。CSS 動畫實現起來簡單，性能消耗小，支持廣泛。 JavaScript 動畫：通過 JavaScript 代碼來實現動畫效果。JavaS ...
  • CSS-@規則(At-rules)常用語法使用總結
    At-rules規則是目前CSS中一種常見的語法規則，它使用一個"@"符號加一個關鍵詞定義，後面跟上語法區塊，如果沒有則以分號結束即可。 這種規則一般用於標識文檔、引入外部樣式、條件判斷等等，本文是對該規則的使用總結。 常用規則 @import @import 主要用於從其他樣式表導入新的樣式規則， ...
  • keycloak~JWT各欄位說明及擴展欄位的方法
    jwt擴展欄位介紹 為了實現業務的定製化需求和開發人員使用的便利，對kc的JWT進行了擴展，這個擴展欄位在解析JWT之後都可以看到。 jwt的payload { "exp": 1675329802, "iat": 1675329622, "jti": "2a80e925-b9ce-464f-822d ...
  • 《領域驅動設計》：從領域視角深入倉儲（Repository）的設計和實現
    “ DDD設計的目標是關註領域模型而並非技術來創建更好的軟體，假設開發人員構建了一個SQL，並將它傳遞給基礎設施層中的某個查詢服務然後根據表數據的結構集取出所需信息，最後將這些信息提供給構造函數或者Factory，開發人員在做這一切的時候早已不把模型看做重點了，這個整個過程就變成了數據處理的風格 ”... ...
  • 函數式編程思維讀後總結與感想
    通常，不同的公司里有著不同的編碼規範，主要是從代碼得準確性、穩定性、可讀性等地方著手制定，以提高團隊成員之間的協作效率，這裡主要是列出一些常見的編碼規範。 ...
  • day01-SpringMVC基本介紹-01
    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有哪些關鍵字 Python常用的關鍵字 and, del, from, not, while, as, elif, global, or, with, assert, else, if, pass, yield, break, except, import, print, class, ...
一周排行
    -Advertisement-
    Play Games
  • （開源）都進來！簡單易懂、功能強大的許可權+可視化流程管理系統
    1、預覽地址：http://139.155.137.144:9012 2、qq群:801913255 一、前言 隨著網路的發展，企業對於信息系統數據的保密工作愈發重視，不同身份、角色對於數據的訪問許可權都應該大相徑庭。 列如 1、不同登錄人員對一個數據列表的可見度是不一樣的，如數據列、數據行、數據按鈕 ...
  • 設計模式-C#實現簡單工廠模式
    前言 上一篇文章寫瞭如何使用RabbitMQ做個簡單的發送郵件項目，然後評論也是比較多，也是準備去學習一下如何確保RabbitMQ的消息可靠性，但是由於時間原因，先來說說設計模式中的簡單工廠模式吧！ 在瞭解簡單工廠模式之前，我們要知道C#是一款面向對象的高級程式語言。它有3大特性，封裝、繼承、多態。 ...
  • Nodify學習 一：介紹與使用
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 介紹 Nodify是一個WPF基於節點的編輯器控制項，其中包含一系列節點、連接和連接器組件，旨在簡化構建基於節點的工具的過程 ...
  • 使用C#/.NET解析Wiki百科數據實現獲取歷史上的今天
    創建一個webapi項目做測試使用。 創建新控制器，搭建一個基礎框架，包括獲取當天日期、wiki的請求地址等 創建一個Http請求幫助類以及方法，用於獲取指定URL的信息 使用http請求訪問指定url，先運行一下，看看返回的內容。內容如圖右邊所示，實際上是一個Json數據。我們主要解析 大事記 部 ...
  • .NET科普：.NET簡史、.NET Standard以及C#和.NET Framework之間的關係
    最近在不少自媒體上看到有關.NET與C#的資訊與評價，感覺大家對.NET與C#還是不太瞭解，尤其是對2016年6月發佈的跨平臺.NET Core 1.0，更是知之甚少。在考慮一番之後，還是決定寫點東西總結一下，也回顧一下.NET的發展歷史。 首先，你沒看錯，.NET是跨平臺的，可以在Windows、 ...
  • Nodify學習 二：添加節點
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 添加節點（nodes） 通過上一篇我們已經創建好了編輯器實例現在我們為編輯器添加一個節點 添加model和viewmode ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（上）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
  • C# 使用模式匹配的好處,因為好用所以推薦~
    類型檢查和轉換：當你需要檢查對象是否為特定類型，並且希望在同一時間內將其轉換為那個類型時，模式匹配提供了一種更簡潔的方式來完成這一任務，避免了使用傳統的as和is操作符後還需要進行額外的null檢查。 複雜條件邏輯：在處理複雜的條件邏輯時，特別是涉及到多個條件和類型的情況下，使用模式匹配可以使代碼更 ...
  • 推薦一種批量判斷文件是否存在的快速辦法
    在日常開發中，我們經常需要和文件打交道，特別是桌面開發，有時候就會需要載入大批量的文件，而且可能還會存在部分文件缺失的情況，那麼如何才能快速的判斷文件是否存在呢？如果處理不當的，且文件數量比較多的時候，可能會造成卡頓等情況，進而影響程式的使用體驗。今天就以一個簡單的小例子，簡述兩種不同的判斷文件是否... ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（中）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
所有分類