python工廠類

⑴ 如何使用靜態方法，類方法或者抽象方法

方法是作為類的屬性（attribute）存儲的函數。你可以以下面的方式聲明和獲取函數：
>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<unbound method Pizza.get_size>
python告訴你的是，類Pizza的屬性get_size是一個非綁定的方法。這又指什麼呢？很快我們就會知道，試著調用一下：
>>> Pizza.get_size()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)
這里我們不能調用這個方法是因為它沒有被綁定到任一Pizza的實例上。一個方法需要一個實例作為它第一個參數（在Python 2中它必須是對應類的實例；在Python 3中可以是任何東西）。我們現在試試：
>>> Pizza.get_size(Pizza(42))
42
現在可以了！我們試用一個實例作為get_size方法的第一個參數調用了它，所以一切變得很美好。但是你很快會同意，這並不是一個很漂亮的調用方法的方式；因為每次我們想調用這個方法都必須使用到類。並且，如果我們不知道對象是哪個類的實例，這種方式就不方便了。
所以，Python為我們准備的是，它將類Pizza的所有的方法綁定到此類的任何實例上。這意味著類Pizza的任意實例的屬性get_size是一個已綁定的方法：第一個參數是實例本身的方法。
>>> Pizza(42).get_size
<bound method Pizza.get_size of <__main__.Pizza object at 0x10314b310>>
>>> Pizza(42).get_size()
42
如我們預期，現在不需要提供任何參數給get_size，因為它已經被綁定（bound），它的self參數是自動地設為Pizza類的實例。下面是一個更好的證明：
>>> m = Pizza(42).get_size
>>> m
<bound method Pizza.get_size of <__main__.Pizza object at 0x10314b350>>
>>> m()
42
因此，你甚至不要保存一個對Pizza對象的飲用。它的方法已經被綁定在對象上，所以這個方法已經足夠。
但是如何知道已綁定的方法被綁定在哪個對象上？技巧如下：
>>> m = Pizza(42).get_size
>>> m.__self__
<__main__.Pizza object at 0x10314b390>
>>> m == m.__self__.get_size
True
易見，我們仍然保存著一個對對象的引用，當需要知道時也可以找到。
在Python 3中，歸屬於一個類的函數不再被看成未綁定方法（unbound method），但是作為一個簡單的函數，如果要求可以綁定在對象上。所以，在Python 3中原理是一樣的，模型被簡化了。
>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<function Pizza.get_size at 0x7f307f984dd0>
靜態方法

靜態方法是一類特殊的方法。有時，我們需要寫屬於一個類的方法，但是不需要用到對象本身。例如：
class Pizza(object):
@staticmethod
def mix_ingredients(x, y):
return x + y

def cook(self):
return self.mix_ingredients(self.cheese, self.vegetables)
這里，將方法mix_ingredients作為一個非靜態的方法也可以work，但是給它一個self的參數將沒有任何作用。這兒的decorator@staticmethod帶來一些特別的東西：
>>> Pizza().cook is Pizza().cook
False
>>> Pizza().mix_ingredients is Pizza().mix_ingredients
True
>>> Pizza().mix_ingredients is Pizza.mix_ingredients
True
>>> Pizza()
<__main__.Pizza object at 0x10314b410>
>>> Pizza()
<__main__.Pizza object at 0x10314b510>
>>>

Python不需要對每個實例化的Pizza對象實例化一個綁定的方法。綁定的方法同樣是對象，創建它們需要付出代價。這里的靜態方法避免了這樣的情況：

降低了閱讀代碼的難度：看到@staticmethod便知道這個方法不依賴與對象本身的狀態；

允許我們在子類中重載mix_ingredients方法。如果我們使用在模塊最頂層定義的函數mix_ingredients，一個繼承自Pizza的類若不重載cook，可能不可以改變混合成份（mix_ingredients）的方式。

類方法

什麼是類方法？類方法是綁定在類而非對象上的方法！
>>> class Pizza(object):
... radius = 42
... @classmethod
... def get_radius(cls):
... return cls.radius
...
>>> Pizza.get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza().get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza.get_radius is Pizza().get_radius
False
>>> Pizza.get_radius()
42
此處有問題。原文中
>>> Pizza.get_radius is Pizza().get_radius
True
還需要check一下。

不管你如何使用這個方法，它總會被綁定在其歸屬的類上，同時它第一個參數是類本身（記住：類同樣是對象）
何時使用這種方法？類方法一般用於下面兩種：
1. 工廠方法，被用來創建一個類的實例，完成一些預處理工作。如果我們使用一個@staticmethod靜態方法，我們可能需要在函數中硬編碼Pizza類的名稱，使得任何繼承自Pizza類的類不能使用我們的工廠用作自己的目的。
class Pizza(object):
def __init__(self, ingredients):
self.ingredients = ingredients

@classmethod
def from_fridge(cls, fridge):
return cls(fridge.get_cheese() + fridge.get_vegetables())

靜態方法調靜態方法：如果你將一個靜態方法分解為幾個靜態方法，你不需要硬編碼類名但可以使用類方法。使用這種方式來聲明我們的方法，Pizza這個名字不需要直接被引用，並且繼承和方法重載將會完美運作。

class Pizza(object):
def __init__(self, radius, height):
self.radius = radius
self.height = height

@staticmethod
def compute_circumference(radius):
return math.pi * (radius ** 2)

@classmethod
def compute_volume(cls, height, radius):
return height * cls.compute_circumference(radius)

def get_volume(self):
return self.compute_volume(self.height, self.radius)

抽象方法

抽象方法在一個基類中定義，但是可能不會有任何的實現。在java中，這被描述為一個介面的方法。
所以Python中最簡單的抽象方法是：

class Pizza(object):
def get_radius(self):
raise NotImplementedError

任何繼承自Pizza的類將實現和重載get_radius方法，否則會出現異常。這種獨特的實現抽象方法的方式也有其缺點。如果你寫一個繼承自Pizza的類，忘記實現get_radius，錯誤將會在你使用這個方法的時候才會出現。

>>> Pizza()
<__main__.Pizza object at 0x106f381d0>
>>> Pizza().get_radius()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
File "<stdin>", line 3, in get_radius
NotImplementedError

有種提前引起錯誤發生的方法，那就是當對象被實例化時，使用Python提供的abc模塊。

import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta

@abc.abstractmethod
def get_radius(self):
"""Method that should do something."""

使用abc和它的特類，一旦你試著實例化BasePizza或者其他繼承自它的類，就會得到TypeError

>>> BasePizza()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

混合靜態方法、類方法和抽象方法

當我們構建類和繼承關系時，終將會碰到要混合這些方法decorator的情況。下面提幾個tip。
記住聲明一個類為抽象類時，不要冷凍那個方法的prototype。這是指這個方法必須被實現，不過是可以使用任何參數列表來實現。

import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""
class Calzone(BasePizza):
def get_ingredients(self, with_egg=False):
egg = Egg() if with_egg else None
return self.ingredients + egg

這個是合法的，因為Calzone完成了為BasePizza類對象定義的介面需求。就是說，我們可以把它當作一個類方法或者靜態方法來實現，例如：

import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""

class DietPizza(BasePizza):
@staticmethod
def get_ingredients():
return None

這樣做同樣爭取，並且完成了與BasePizza抽象類達成一致的需求。get_ingredients方法不需要知道對象，這是實現的細節，而非完成需求的評價指標。
因此，你不能強迫抽象方法的實現是正常的方法、類方法或者靜態方法，並且可以這樣說，你不能。從Python 3開始（這就不會像在Python 2中那樣work了，見issue5867），現在可以在@abstractmethod之上使用@staticmethod和@classmethod了。

import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta

ingredient = ['cheese']

@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.ingredients

不要誤解：如果你認為這是強迫你的子類將get_ingredients實現為一個類方法，那就錯了。這個是表示你實現的get_ingredients在BasePizza類中是類方法而已。
在一個抽象方法的實現？是的！在Python中，對比與Java介面，你可以在抽象方法中寫代碼，並且使用super()調用：

import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
default_ingredients = ['cheese']
@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.default_ingredients
class DietPizza(BasePizza):
def get_ingredients(self):
return ['egg'] + super(DietPizza, self).get_ingredients()

文／Not_GOD（簡書作者）
原文鏈接：http://www.jianshu.com/p/880d6a3ffdde
著作權歸作者所有，轉載請聯系作者獲得授權，並標注「簡書作者」。

⑵ 自動化專業畢業後可以從事哪些工作呢就業前景又如何

自動化專業畢業後可以從事哪些工作呢？就業前景又如何？對於學生提出的這個問題，本人分享下個人的觀點，僅供參考！自動化專業就業前景還是很不錯的。可以從事自動化工程類工作、自動化設計、系統工程、機電設備自動化控制工程、數據採集、電子技術、計算機控制系統工程、人工智慧、機器人工程等。可以從事技術設計研發也可以從事維護維修等工作。

總之，自動化專業畢業後可以從事的工作還是很廣泛的，這和這個學科的特點有很大的關系，自動控制幾乎涉及各個領域。因此就業前景也相當不錯！

⑶ 一般崗位要計算機類和電子信息類,面試考什麼專業知識

考計算機知識，具體有網路，計算機基礎知識，操作系統，資料庫，程序編寫等。

主修大數據技術導論、數據採集與處理實踐（Python）、Web前/後端開發、統計與數據分析、機器學習、高級資料庫系統、數據可視化、雲計算技術、人工智慧、自然語言處理、媒體大數據案例分析、網路空間安全、計算機網路、數據結構、軟體工程、操作系統等課程。

以及大數據方向系列實驗，並完成程序設計、數據分析、機器學習、數據可視化、大數據綜合應用實踐、專業實訓和畢業設計等多種實踐環節。

主要包括：

經濟信息管理與計算機應用、信息管理與信息系統、計算機輔助設計與製造、資料庫應用與信息管理、電子商務、計算機與信息管理、辦公自動化技術、計算機控制技術、計算機輔助設計、工廠計算機集中控制。

⑷ Python中的「 @」（@）符號有什麼作用

【@】符號在python中是裝飾器的意思。
裝飾器對一個可調用對象（函數、方法、類等等）進行裝飾，它返回的也是一個可調用對象。
一般情況下，裝飾器是對被裝飾對象的修飾與增強。用現實事物類比的話，可以類比為中間商：中間商不生產產品，它將工廠生產的產品進行包裝、運輸後再銷售給顧客。裝飾器不實現核心功能，它提供對目標函數調用的封裝與強。
它裝飾的方法返回值是一個對象（BillList、Bill、List[BillDetail]等），而裝飾器【enabled_cache】的作用如它的名稱一樣：使用緩存。可以看到，這個裝飾器函數中定義了一個函數【wrapper】然後將這個wrapper作為返回值。這樣，原本調用ProctionBos.bill_with_last_week的代碼就不需要做任何改變就能享受到ProctionBos.bill_with_last_week原有的功能（得到一個BillList對象）和enabled_cache提供的附加功能（如果該對象有緩存，就不再從資料庫查詢）。

⑸ 如何在Python中使用static，class，abstract方法

方法在Python中是如何工作的

方法就是一個函數，它作為一個類屬性而存在，你可以用如下方式來聲明、訪問一個函數：

Python

>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<unbound method Pizza.get_size>

Python在告訴你，屬性_get_size是類Pizza的一個未綁定方法。這是什麼意思呢？很快我們就會知道答案：

Python

>>> Pizza.get_size()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

我們不能這么調用，因為它還沒有綁定到Pizza類的任何實例上，它需要一個實例作為第一個參數傳遞進去（Python2必須是該類的實例，Python3中可以是任何東西），嘗試一下：

Python

>>> Pizza.get_size(Pizza(42))
42

>>> Pizza.get_size(Pizza(42))
42

太棒了，現在用一個實例作為它的的第一個參數來調用，整個世界都清靜了，如果我說這種調用方式還不是最方便的，你也會這么認為的；沒錯，現在每次調用這個方法的時候我們都不得不引用這個類，如果不知道哪個類是我們的對象，長期看來這種方式是行不通的。

那麼Python為我們做了什麼呢，它綁定了所有來自類_Pizza的方法以及該類的任何一個實例的方法。也就意味著現在屬性get_size是Pizza的一個實例對象的綁定方法，這個方法的第一個參數就是該實例本身。

Python

>>> Pizza(42).get_size
<bound method Pizza.get_size of <__main__.Pizza object at 0x7f3138827910>>
>>> Pizza(42).get_size()
42

和我們預期的一樣，現在不再需要提供任何參數給_get_size，因為它已經是綁定的，它的self參數會自動地設置給Pizza實例，下面代碼是最好的證明：

Python

>>> m = Pizza(42).get_size
>>> m()
42

更有甚者，你都沒必要使用持有Pizza對象的引用了，因為該方法已經綁定到了這個對象，所以這個方法對它自己來說是已經足夠了。

也許，如果你想知道這個綁定的方法是綁定在哪個對象上，下面這種手段就能得知：

Python

>>> m = Pizza(42).get_size
>>> m.__self__
<__main__.Pizza object at 0x7f3138827910>
>>> # You could guess, look at this:
...
>>> m == m.__self__.get_size
True

顯然，該對象仍然有一個引用存在，只要你願意你還是可以把它找回來。

在Python3中，依附在類上的函數不再當作是未綁定的方法，而是把它當作一個簡單地函數，如果有必要它會綁定到一個對象身上去，原則依然和Python2保持一致，但是模塊更簡潔：

Python

>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<function Pizza.get_size at 0x7f307f984dd0>

靜態方法

靜態方法是一類特殊的方法，有時你可能需要寫一個屬於這個類的方法，但是這些代碼完全不會使用到實例對象本身，例如：

Python

class Pizza(object):
@staticmethod
def mix_ingredients(x, y):
return x + y

def cook(self):
return self.mix_ingredients(self.cheese, self.vegetables)

這個例子中，如果把_mix_ingredients作為非靜態方法同樣可以運行，但是它要提供self參數，而這個參數在方法中根本不會被使用到。這里的@staticmethod裝飾器可以給我們帶來一些好處：

Python不再需要為Pizza對象實例初始化一個綁定方法，綁定方法同樣是對象，但是創建他們需要成本，而靜態方法就可以避免這些。

Python

>>> Pizza().cook is Pizza().cook
False
>>> Pizza().mix_ingredients is Pizza.mix_ingredients
True
>>> Pizza().mix_ingredients is Pizza().mix_ingredients
True

可讀性更好的代碼，看到@staticmethod我們就知道這個方法並不需要依賴對象本身的狀態。
可以在子類中被覆蓋，如果是把mix_ingredients作為模塊的頂層函數，那麼繼承自Pizza的子類就沒法改變pizza的mix_ingredients了如果不覆蓋cook的話。

類方法

話雖如此，什麼是類方法呢？類方法不是綁定到對象上，而是綁定在類上的方法。

Python

>>> class Pizza(object):
... radius = 42
... @classmethod
... def get_radius(cls):
... return cls.radius
...
>>>
>>> Pizza.get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza().get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza.get_radius is Pizza().get_radius
True
>>> Pizza.get_radius()
42

無論你用哪種方式訪問這個方法，它總是綁定到了這個類身上，它的第一個參數是這個類本身（記住：類也是對象）。

什麼時候使用這種方法呢？類方法通常在以下兩種場景是非常有用的：

工廠方法：它用於創建類的實例，例如一些預處理。如果使用@staticmethod代替，那我們不得不硬編碼Pizza類名在函數中，這使得任何繼承Pizza的類都不能使用我們這個工廠方法給它自己用。

Python

class Pizza(object):
def __init__(self, ingredients):
self.ingredients = ingredients

@classmethod
def from_fridge(cls, fridge):
return cls(fridge.get_cheese() + fridge.get_vegetables())

調用靜態類：如果你把一個靜態方法拆分成多個靜態方法，除非你使用類方法，否則你還是得硬編碼類名。使用這種方式聲明方法，Pizza類名明永遠都不會在被直接引用，繼承和方法覆蓋都可以完美的工作。

Python

class Pizza(object):
def __init__(self, radius, height):
self.radius = radius
self.height = height

@staticmethod
def compute_area(radius):
return math.pi * (radius ** 2)

@classmethod
def compute_volume(cls, height, radius):
return height * cls.compute_area(radius)

def get_volume(self):
return self.compute_volume(self.height, self.radius)

抽象方法

抽象方法是定義在基類中的一種方法，它沒有提供任何實現，類似於Java中介面(Interface)裡面的方法。

在Python中實現抽象方法最簡單地方式是：

Python

class Pizza(object):
def get_radius(self):
raise NotImplementedError

任何繼承自_Pizza的類必須覆蓋實現方法get_radius，否則會拋出異常。

這種抽象方法的實現有它的弊端，如果你寫一個類繼承Pizza，但是忘記實現get_radius，異常只有在你真正使用的時候才會拋出來。

Python

>>> Pizza()
<__main__.Pizza object at 0x7fb747353d90>
>>> Pizza().get_radius()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
File "<stdin>", line 3, in get_radius
NotImplementedError

還有一種方式可以讓錯誤更早的觸發，使用Python提供的abc模塊，對象被初始化之後就可以拋出異常：

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

@abc.abstractmethod
def get_radius(self):
"""Method that should do something."""

使用abc後，當你嘗試初始化BasePizza或者任何子類的時候立馬就會得到一個TypeError，而無需等到真正調用get_radius的時候才發現異常。

Python

>>> BasePizza()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

混合靜態方法、類方法、抽象方法

當你開始構建類和繼承結構時，混合使用這些裝飾器的時候到了，所以這里列出了一些技巧。

記住，聲明一個抽象的方法，不會固定方法的原型，這就意味著雖然你必須實現它，但是我可以用任何參數列表來實現：

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""

class Calzone(BasePizza):
def get_ingredients(self, with_egg=False):
egg = Egg() if with_egg else None
return self.ingredients + egg

這樣是允許的，因為Calzone滿足BasePizza對象所定義的介面需求。同樣我們也可以用一個類方法或靜態方法來實現：

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""

class DietPizza(BasePizza):
@staticmethod
def get_ingredients():
return None

這同樣是正確的,因為它遵循抽象類BasePizza設定的契約。事實上get_ingredients方法並不需要知道返回結果是什麼，結果是實現細節，不是契約條件。

因此，你不能強制抽象方法的實現是一個常規方法、或者是類方法還是靜態方法，也沒什麼可爭論的。從Python3開始（在Python2中不能如你期待的運行，見issue5867），在abstractmethod方法上面使用@staticmethod和@classmethod裝飾器成為可能。

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

ingredient = ['cheese']

@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.ingredients

別誤會了，如果你認為它會強制子類作為一個類方法來實現get_ingredients那你就錯了，它僅僅表示你實現的get_ingredients在BasePizza中是一個類方法。

可以在抽象方法中做代碼的實現？沒錯，Python與Java介面中的方法相反，你可以在抽象方法編寫實現代碼通過super()來調用它。（譯註：在Java8中，介面也提供的默認方法，允許在介面中寫方法的實現）

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

default_ingredients = ['cheese']

@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.default_ingredients

class DietPizza(BasePizza):
def get_ingredients(self):
return ['egg'] + super(DietPizza, self).get_ingredients()

這個例子中，你構建的每個pizza都通過繼承BasePizza的方式，你不得不覆蓋get_ingredients方法，但是能夠使用默認機制通過super()來獲取ingredient列表。

⑹ Python設計模式：工廠方法模式

工廠，大家一般能想到的是生產產品的地方， 在設計模式中，工廠可分為：簡單工廠模式、工廠方法模式。 在前期推文 Python 簡單工廠模式 中有關於簡單工廠模式的解讀。

根據工廠的抽象程度可分為：工廠方法模式、抽象工廠模式。 該模式用於封裝和管理對象的創建，是一種創建型模式。

在簡單工廠模式中，只提供了一個工廠類，該工廠類處於對產品類進行實例化的中心位置，它知道每一個產品對象的創建細節，並決定何時實例化哪一個產品類。

簡單工廠模式最大的缺點是：當有新產品要加入到系統中時，必須修改工廠類，加入必要的處理邏輯，這違背了「開閉原則」。
在簡單工廠模式中，所有的產品都是由同一個工廠創建，工廠類職責較重，業務邏輯較為復雜，具體產品與工廠類之間的耦合度高，嚴重影響了系統的靈活性和擴展性，而工廠方法模式則可以很好地解決這一問題。因此工廠方法模式應運而生。

(1)、工廠方法模式定義一個用於創建對象的介面，但是工廠本身並不負責創建對象，而是讓子類決定將哪一個類實例化。工廠方法模式讓一個類的實例化延遲到其子類。 工廠方法的創建是通過繼承而不是通過實例化來完成的。

(2)、工廠方法模式就是簡單工廠模式的進一步抽象。由於面向對象多態性，工廠方法模式保持了簡單工廠的優點同時克服了它的缺點。工廠方法模式中，核心的工廠被提升為一個抽象類，將具體的創建工作交給他的子類完成。

這個抽象的工廠類僅規定具體工廠實現的介面，而不明確指出如何實例化一個產品類，這使得工廠方法模式允許系統在不修改原有產品結構的情況下輕松的引進新產品。

工廠方法使設計更加具有可定製性，它可以返回相同的實例或子類，而不是某種類型的對象。

前期分享的 Python 簡單工廠模式 和今天分享的Python 工廠方法模式，大家在實際應用時能解決問題滿足需求即可，可靈活變通，自由選擇，無所謂哪種設計模式更高級。

同時無論哪種設計模式，由於可能封裝了大量對象和工廠創建，當有新加入產品的需求時，需要修改已定義好的工廠相關的類，因此對於產品和工廠的擴展性不太友好，在選擇使用時利弊需要權衡一下。

⑺ 學Java好還是學Python好

Java作為長期的編程語言霸主之一，其應用涵蓋後台服務端、大數據、桌面應用等多個領域，主要領域當然是後台服務端，大部分企業對後台語言的首選還是Java，尤其是大型項目，Java相較於PHP，Python等語言的優勢還是很明顯的。所以，你只要掌握得好，別說現在Java依然如日中天，就算哪天Java真的輝煌不在了，也頂多不會那麼火爆，是不至於讓你不好找工作的。

首先當前國內行業高工資的前幾位金融、互聯網。而java就是互聯網的其中一個方向領域。回歸到大背景前提，互聯網還會一直火下去，相應的招聘崗位會持續下去，互聯網+、物聯網等都是大量需要java人才的方向。其次，我們每天都可以看到各種智能AI的出現、導致各種行業的需求量大減，比如銀行櫃員，電話客服，工廠工人等，以後的時代是逐漸機器替代人類的過程。而java的學習一定是大量需要的，可以通過java再進階到大數據、AI等其他更深層次的領域。但是同時人才的競爭，大量的人往互聯網行業邁入，那競爭的壓力一定會很大，供大於求，所以假如你要進入該行業，你要清晰定位自己是否有這方面的硬實力，是否做好准備。

java可以做太多東西了。目前所有的互聯網服務端都是採用互聯網的架構級應用，在互聯網的架構級應用中，基本都是用java做解決方案；服務端不僅服務的是傳統的互聯網應用，移動互聯網和物聯網市場的智能設備也都離不開服務端，都需要通過伺服器進行數據的傳輸，且服務端絕大多數都是由java進行開發；移動互聯網增長，物聯網增長及傳統互聯網增長，都帶來大量的java伺服器的增長。所以java的招聘需求在持續攀升；能夠實戰最重要。

⑻ python中的元類的作用

元類是類的類。類定義類的實例（即對象）的行為，而元類定義類的行為。類是元類的實例。雖然在Python中你可以對元類使用任意可調用對象（如Jerub演示），但是更好的方法是使其成為實際的類。type是Python中常見的元類。type它本身是一個類，並且是它自己的類型。你將無法type純粹使用Python 重新創建類似的東西，但是Python有點作弊。要在Python中創建自己的元類，你實際上只想將其子類化type。元類最常用作類工廠。class執行該語句時，Python首先將class語句的主體作為普通代碼塊執行。生成的名稱空間（字典）保留了將來類的屬性。通過查看待定類的基類（繼承了元類），待定類的__metaclass__屬性（如果有）或__metaclass__全局變數來確定元類。然後使用該類的名稱，基數和屬性調用該元類以實例化它。但是，元類實際上定義了類的類型，而不僅僅是它的工廠，因此你可以使用它們做更多的事情。例如，你可以在元類上定義常規方法。這些元類方法就像類方法，因為它們可以在沒有實例的情況下在類上調用，但是它們也不像類方法，因為它們不能在類的實例上被調用。type.__subclasses__()是type元類上方法的示例。你還可以定義正常的「魔力」的方法，如__add__，__iter__和__getattr__，執行或如何變化的類的行為。

⑼ python常用的幾種設計模式是什麼

python常用的幾種設計模式有：1、單例模式，確保某一個類只有一個實例；2、工廠模式，使用一個公共的介面來創建對象；3、策略模式，隨著策略對象改變內容；4、門面模式，對子系統的封裝，使得封裝介面不會被單獨提出來。

什麼是設計模式？

設計模式是一套被反復使用，多數人知道，經過分類編目的代碼設計經驗總結。

使用設計模式是為了提高代碼可重用性，可閱讀性，和可靠性。

你說理解的設計模式有幾種？

設計模式又可分為三種：創建型（單例模式）、（工廠模式），結構型，行為型（策略模式）

單例模式以及應用場景：

（1）確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例，這個類稱為單例類，單例模式是一種對象創建型模式。Windows的Task Manager（任務管理器）、Recycle Bin（回收站）、網站計數器

（2）單例模式應用的場景一般發現在以下條件下：

資源共享的情況下，避免由於資源操作時導致的性能或損耗等。如上述中的日誌文件，應用配置。控制資源的情況下，方便資源之間的互相通信。如線程池等

要點：一是某個類只能有一個實例；二是它必須自行創建這個實例；三是它必須自行向整個系統提供這個實例。

工廠模式：

提供一個創建對象的介面，不像客戶端暴露創建對象的過程，而是使用一個公共的介面來創建對象。

可以分為三種：簡單工廠 工廠方法 抽象工廠

一個類的行為或其演算法可以在運行時更改。這種類型的設計模式屬於行為型模式。

策略模式：

在策略模式中，我們創建表示各種策略的對象和一個行為隨著策略對象改變而改變的 context 對象。策略對象改變 context 對象的執行演算法。

要點：把一個個策略，也就是演算法封裝成一個一個類，任意的替換

解決的問題：避免多個if....else帶來的復雜

使用場景：系統中需要動態的在集中演算法中動態的選擇一種，

門面模式：

門面模式也叫外觀模式，定義如下：要求一個子系統的外部與其內部的通信必須通過一個統一的對象進行。門面模式提供一個高層次的介面，使得子系統更易於使用。門面模式注重「統一的對象」，也就是提供一個訪問子系統的介面。門面模式與之前說過的模板模式有類似的地方，都是對一些需要重復方法的封裝。但從本質上來說，是不同的。模板模式是對類本身的方法的封裝，其被封裝的方法也可以單獨使用；而門面模式，是對子系統的封裝，其被封裝的介面理論上是不會被單獨提出來用的。

一個對象有很多行為，如果么有選擇合適的設計模式，這些行為就需要用多重的條件判斷來實現演算法的切換，增加了代碼的復雜度。

推薦課程：Python面對對象(Corey Schafer)

⑽ Python中冷門但非常好用的內置函數

Python中有許多內置函數,不像print、len那麼廣為人知,但它們的功能卻異常強大,用好了可以大大提高代碼效率，同時提升代碼的簡潔度，增強可閱讀性

Counter

collections在python官方文檔中的解釋是High-performance container datatypes，直接的中文翻譯解釋高性能容量數據類型。這個模塊實現了特定目標的容器，以提供Python標准內建容器 dict , list , set , 和 tuple 的替代選擇。在python3.10.1中它總共包含以下幾種數據類型：

容器名簡介

namedtuple() 創建命名元組子類的工廠函數

deque 類似列表(list)的容器，實現了在兩端快速添加(append)和彈出(pop)

ChainMap 類似字典(dict)的容器類，將多個映射集合到一個視圖裡面

Counter 字典的子類，提供了可哈希對象的計數功能

OrderedDict 字典的子類，保存了他們被添加的順序

defaultdict 字典的子類，提供了一個工廠函數，為字典查詢提供一個默認值

UserDict 封裝了字典對象，簡化了字典子類化

UserList 封裝了列表對象，簡化了列表子類化

UserString 封裝了字元串對象，簡化了字元串子類化

其中Counter中文意思是計數器，也就是我們常用於統計的一種數據類型，在使用Counter之後可以讓我們的代碼更加簡單易讀。Counter類繼承dict類，所以它能使用dict類裡面的方法

舉例

#統計詞頻

fruits = ['apple', 'peach', 'apple', 'lemon', 'peach', 'peach']

result = {}

for fruit in fruits:

if not result.get(fruit):

result[fruit] = 1

else:

result[fruit] += 1

print(result)

#{'apple': 2, 'peach': 3, 'lemon': 1}下面我們看用Counter怎麼實現：

from collections import Counter

fruits = ['apple', 'peach', 'apple', 'lemon', 'peach', 'peach']

c = Counter(fruits)

print(dict(c))

#{'apple': 2, 'peach': 3, 'lemon': 1}顯然代碼更加簡單了，也更容易閱讀和維護了。

elements()

返回一個迭代器，其中每個元素將重復出現計數值所指定次。元素會按首次出現的順序返回。如果一個元素的計數值小於1，elements()將會忽略它。

>>> c = Counter(a=4, b=2, c=0, d=-2)

>>> sorted(c.elements())

['a', 'a', 'a', 'a', 'b', 'b']most_common([n])

返回一個列表，其中包含n個最常見的元素及出現次數，按常見程度由高到低排序。如果n被省略或為None，most_common()將返回計數器中的所有元素。計數值相等的元素按首次出現的順序排序：

>>> Counter('abracadabra').most_common(3)

[('a', 5), ('b', 2), ('r', 2)]這兩個方法是Counter中最常用的方法，其他方法可以參考 python3.10.1官方文檔

實戰

Leetcode 1002.查找共用字元

給你一個字元串數組words，請你找出所有在words的每個字元串中都出現的共用字元（包括重復字元），並以數組形式返回。你可以按任意順序返回答案。

輸入：words = ["bella", "label", "roller"]

輸出：["e", "l", "l"]

輸入：words = ["cool", "lock", "cook"]

輸出：["c", "o"]看到統計字元，典型的可以用Counter完美解決。這道題是找出字元串列表裡面每個元素都包含的字元，首先可以用Counter計算出每個元素每個字元出現的次數，依次取交集最後得出所有元素共同存在的字元，然後利用elements輸出共用字元出現的次數

class Solution:

def commonChars(self, words: List[str]) -> List[str]:

from collections import Counter

ans = Counter(words[0])

for i in words[1:]:

ans &= Counter(i)

return list(ans.elements())提交一下，發現83個測試用例耗時48ms，速度還是不錯的

sorted

在處理數據過程中，我們經常會用到排序操作，比如將列表、字典、元組裡面的元素正/倒排序。這時候就需要用到sorted()，它可以對任何可迭代對象進行排序，並返回列表

對列表升序操作：

a = sorted([2, 4, 3, 7, 1, 9])

print(a)

# 輸出：[1, 2, 3, 4, 7, 9]對元組倒序操作：

sorted((4,1,9,6),reverse=True)

print(a)

# 輸出：[9, 6, 4, 1]使用參數：key，根據自定義規則，按字元串長度來排序：

fruits = ['apple', 'watermelon', 'pear', 'banana']

a = sorted(fruits, key = lambda x : len(x))

print(a)

# 輸出：['pear', 'apple', 'banana', 'watermelon']all

all() 函數用於判斷給定的可迭代參數iterable中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。元素除了是 0、空、None、False外都算True。注意：空元組、空列表返回值為True。

>>> all(['a', 'b', 'c', 'd']) # 列表list，元素都不為空或0

True

>>> all(['a', 'b', '', 'd']) # 列表list，存在一個為空的元素

False

>>> all([0, 1，2, 3]) # 列表list，存在一個為0的元素

False

>>> all(('a', 'b', 'c', 'd')) # 元組tuple，元素都不為空或0

True

>>> all(('a', 'b', '', 'd')) # 元組tuple，存在一個為空的元素

False

>>> all((0, 1, 2, 3)) # 元組tuple，存在一個為0的元素

False

>>> all([]) # 空列表

True

>>> all(()) # 空元組

Trueany函數正好和all函數相反：判斷一個tuple或者list是否全為空，0，False。如果全為空，0，False，則返回False；如果不全為空，則返回True。

F-strings

在python3.6.2版本中，PEP 498提出一種新型字元串格式化機制，被稱為 「字元串插值」 或者更常見的一種稱呼是F-strings，F-strings提供了一種明確且方便的方式將python表達式嵌入到字元串中來進行格式化：

s1='Hello'

s2='World'

print(f'{s1} {s2}!')

# Hello World!在F-strings中我們也可以執行函數：

def power(x):

return x*x

x=4

print(f'{x} * {x} = {power(x)}')

# 4 * 4 = 16而且F-strings的運行速度很快，比傳統的%-string和str.format()這兩種格式化方法都快得多，書寫起來也更加簡單。

本文主要講解了python幾種冷門但好用的函數，更多內容以後會陸陸續續更新~