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
  • 下麵是一個標準的IDistributedCache用例: public class SomeService(IDistributedCache cache) { public async Task<SomeInformation> GetSomeInformationAsync (string na ...
  • 這個庫提供了在啟動期間實例化已註冊的單例,而不是在首次使用它時實例化。 單例通常在首次使用時創建,這可能會導致響應傳入請求的延遲高於平時。在註冊時創建實例有助於防止第一次Request請求的SLA 以往我們要在註冊的時候實例單例可能會這樣寫: //註冊: services.AddSingleton< ...
  • 最近公司的很多項目都要改單點登錄了,不過大部分都還沒敲定,目前立刻要做的就只有一個比較老的項目 先改一個試試手,主要目標就是最短最快實現功能 首先因為要保留原登錄方式,所以頁面上的改動就是在原來登錄頁面下加一個SSO登錄入口 用超鏈接寫的入口,頁面改造後如下圖: 其中超鏈接的 href="Staff ...
  • Like運算符很好用,特別是它所提供的其中*、?這兩種通配符,在Windows文件系統和各類項目中運用非常廣泛。 但Like運算符僅在VB中支持,在C#中,如何實現呢? 以下是關於LikeString的四種實現方式,其中第四種為Regex正則表達式實現,且在.NET Standard 2.0及以上平... ...
  • 一:背景 1. 講故事 前些天有位朋友找到我,說他們的程式記憶體會偶發性暴漲,自己分析了下是非托管記憶體問題,讓我幫忙看下怎麼回事?哈哈,看到這個dump我還是非常有興趣的,居然還有這種游戲幣自助機類型的程式,下次去大玩家看看他們出幣的機器後端是不是C#寫的?由於dump是linux上的程式,剛好win ...
  • 前言 大家好,我是老馬。很高興遇到你。 我們為 java 開發者實現了 java 版本的 nginx https://github.com/houbb/nginx4j 如果你想知道 servlet 如何處理的,可以參考我的另一個項目: 手寫從零實現簡易版 tomcat minicat 手寫 ngin ...
  • 上一次的介紹,主要圍繞如何統一去捕獲異常,以及為每一種異常添加自己的Mapper實現,並且我們知道,當在ExceptionMapper中返回非200的Response,不支持application/json的響應類型,而是寫死的text/plain類型。 Filter為二方包異常手動捕獲 參考:ht ...
  • 大家好,我是R哥。 今天分享一個爽飛了的面試輔導 case: 這個杭州兄弟空窗期 1 個月+,面試了 6 家公司 0 Offer,不知道問題出在哪,難道是杭州的 IT 崩盤了麽? 報名面試輔導後,經過一個多月的輔導打磨,現在成功入職某上市公司,漲薪 30%+,955 工作制,不咋加班,還不捲。 其他 ...
  • 引入依賴 <!--Freemarker wls--> <dependency> <groupId>org.freemarker</groupId> <artifactId>freemarker</artifactId> <version>2.3.30</version> </dependency> ...
  • 你應如何運行程式 互動式命令模式 開始一個互動式會話 一般是在操作系統命令行下輸入python,且不帶任何參數 系統路徑 如果沒有設置系統的PATH環境變數來包括Python的安裝路徑,可能需要機器上Python可執行文件的完整路徑來代替python 運行的位置:代碼位置 不要輸入的內容:提示符和註 ...