1. python中為什麼可以一直用點屬性方法
在python 的數據結構中使用. 方式獲取屬性值，其實是底層實現了__getattribute__ 魔法方法。
例如代碼如下：
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def __getattribute__(self, item):
return "{} good luck".format(item)
if __name__ == '__main__':
p=Person("tom",18)
p.age # 獲取屬性的同時就會觸發 __getattribute_
還有就是字典的取值方式 經過 [] 來取值，其實他是實現了__getitem__ 魔法方法；
你可以自定義一個類，重寫__getitem__ 這個方法來實現 屬性也可以這么取值。
2. Python 有什麼奇技淫巧
Python奇技淫巧
當發布python第三方package時, 並不希望代碼中所有的函數或者class可以被外部import, 在 __init__.py 中添加 __all__ 屬性,
該list中填寫可以import的類或者函數名, 可以起到限制的import的作用, 防止外部import其他函數或者類
#!/usr/bin/env python
# -*- coding: utf-8 -*-
frombaseimportAPIBase
fromclientimportClient
fromdecoratorimportinterface, export, stream
fromserverimportServer
fromstorageimportStorage
fromutilimport(LogFormatter, disable_logging_to_stderr,
enable_logging_to_kids, info)
__all__ = ['APIBase','Client','LogFormatter','Server',
'Storage','disable_logging_to_stderr','enable_logging_to_kids',
'export','info','interface','stream']
with的魔力
with語句需要支持 上下文管理協議的對象 , 上下文管理協議包含 __enter__ 和 __exit__ 兩個方法. with語句建立運行時上下文需要通過這兩個方法執行 進入和退出 操作.
其中 上下文表達式 是跟在with之後的表達式, 該表示大返回一個上下文管理對象
# 常見with使用場景
withopen("test.txt","r")asmy_file:# 注意, 是__enter__()方法的返回值賦值給了my_file,
forlineinmy_file:
print line
詳細原理可以查看這篇文章, 淺談 Python 的 with 語句
知道具體原理, 我們可以自定義支持上下文管理協議的類, 類中實現 __enter__ 和 __exit__ 方法
#!/usr/bin/env python
# -*- coding: utf-8 -*-
classMyWith(object):
def__init__(self):
print"__init__ method"
def__enter__(self):
print"__enter__ method"
returnself# 返回對象給as後的變數
def__exit__(self, exc_type, exc_value, exc_traceback):
print"__exit__ method"
ifexc_tracebackisNone:
print"Exited without Exception"
returnTrue
else:
print"Exited with Exception"
returnFalse
deftest_with():
withMyWith()asmy_with:
print"running my_with"
print"------分割線-----"
withMyWith()asmy_with:
print"running before Exception"
raiseException
print"running after Exception"
if__name__ =='__main__':
test_with()
執行結果如下:
__init__ method
__enter__ method
running my_with
__exit__ method
ExitedwithoutException
------分割線-----
__init__ method
__enter__ method
running before Exception
__exit__ method
ExitedwithException
Traceback(most recent call last):
File"bin/python", line34,in<mole>
exec(compile(__file__f.read(), __file__, "exec"))
File"test_with.py", line33,in<mole>
test_with()
File"test_with.py", line28,intest_with
raiseException
Exception
證明了會先執行 __enter__ 方法, 然後調用with內的邏輯, 最後執行 __exit__ 做退出處理, 並且, 即使出現異常也能正常退出
filter的用法
相對 filter 而言, map和rece使用的會更頻繁一些, filter 正如其名字, 按照某種規則 過濾 掉一些元素
#!/usr/bin/env python
# -*- coding: utf-8 -*-
lst = [1,2,3,4,5,6]
# 所有奇數都會返回True, 偶數會返回False被過濾掉
print filter(lambda x: x % 2!=0, lst)
#輸出結果
[1,3,5]
一行作判斷
當條件滿足時, 返回的為等號後面的變數, 否則返回else後語句
lst = [1,2,3]
new_lst = lst[0]iflstisnotNoneelseNone
printnew_lst
# 列印結果
1
裝飾器之單例
使用裝飾器實現簡單的單例模式
# 單例裝飾器
defsingleton(cls):
instances = dict() # 初始為空
def_singleton(*args, **kwargs):
ifclsnotininstances:#如果不存在, 則創建並放入字典
instances[cls] = cls(*args, **kwargs)
returninstances[cls]
return_singleton
@singleton
classTest(object):
pass
if__name__ =='__main__':
t1 = Test()
t2 = Test()
# 兩者具有相同的地址
printt1, t2
staticmethod裝飾器
類中兩種常用的裝飾, 首先區分一下他們
普通成員函數, 其中第一個隱式參數為 對象
classmethod裝飾器 , 類方法(給人感覺非常類似於OC中的類方法), 其中第一個隱式參數為 類
staticmethod裝飾器 , 沒有任何隱式參數. python中的靜態方法類似與C++中的靜態方法
#!/usr/bin/env python
# -*- coding: utf-8 -*-
classA(object):
# 普通成員函數
deffoo(self, x):
print "executing foo(%s, %s)"% (self, x)
@classmethod# 使用classmethod進行裝飾
defclass_foo(cls, x):
print "executing class_foo(%s, %s)"% (cls, x)
@staticmethod# 使用staticmethod進行裝飾
defstatic_foo(x):
print "executing static_foo(%s)"% x
deftest_three_method():
obj = A()
# 直接調用噗通的成員方法
obj.foo("para")# 此處obj對象作為成員函數的隱式參數, 就是self
obj.class_foo("para")# 此處類作為隱式參數被傳入, 就是cls
A.class_foo("para")#更直接的類方法調用
obj.static_foo("para")# 靜態方法並沒有任何隱式參數, 但是要通過對象或者類進行調用
A.static_foo("para")
if__name__=='__main__':
test_three_method()
# 函數輸出
executing foo(<__main__.Aobject at0x100ba4e10>, para)
executing class_foo(<class'__main__.A'>,para)
executing class_foo(<class'__main__.A'>,para)
executing static_foo(para)
executing static_foo(para)
property裝飾器
定義私有類屬性
將 property 與裝飾器結合實現屬性私有化( 更簡單安全的實現get和set方法 )
#python內建函數
property(fget=None, fset=None, fdel=None, doc=None)
fget 是獲取屬性的值的函數, fset 是設置屬性值的函數, fdel 是刪除屬性的函數, doc 是一個字元串(like a comment).從實現來看，這些參數都是可選的
property有三個方法 getter() , setter() 和 delete() 來指定fget, fset和fdel。 這表示以下這行
classStudent(object):
@property #相當於property.getter(score) 或者property(score)
defscore(self):
returnself._score
@score.setter #相當於score = property.setter(score)
defscore(self, value):
ifnotisinstance(value, int):
raiseValueError('score must be an integer!')
ifvalue <0orvalue >100:
raiseValueError('score must between 0 ~ 100!')
self._score = value
iter魔法
通過yield和 __iter__ 的結合, 我們可以把一個對象變成可迭代的
通過 __str__ 的重寫, 可以直接通過想要的形式列印對象
#!/usr/bin/env python
# -*- coding: utf-8 -*-
classTestIter(object):
def__init__(self):
self.lst = [1,2,3,4,5]
defread(self):
foreleinxrange(len(self.lst)):
yieldele
def__iter__(self):
returnself.read()
def__str__(self):
return','.join(map(str, self.lst))
__repr__ = __str__
deftest_iter():
obj = TestIter()
fornuminobj:
printnum
printobj
if__name__ =='__main__':
test_iter()
神奇partial
partial使用上很像C++中仿函數(函數對象).
在stackoverflow給出了類似與partial的運行方式
defpartial(func, *part_args):
defwrapper(*extra_args):
args = list(part_args)
args.extend(extra_args)
returnfunc(*args)
returnwrapper
利用用閉包的特性綁定預先綁定一些函數參數, 返回一個可調用的變數, 直到真正的調用執行
#!/usr/bin/env python
# -*- coding: utf-8 -*-
fromfunctoolsimportpartial
defsum(a, b):
returna + b
deftest_partial():
fun = partial(sum, 2)# 事先綁定一個參數, fun成為一個只需要一個參數的可調用變數
printfun(3)# 實現執行的即是sum(2, 3)
if__name__ =='__main__':
test_partial()
# 執行結果
5
神秘eval
eval我理解為一種內嵌的python解釋器(這種解釋可能會有偏差), 會解釋字元串為對應的代碼並執行, 並且將執行結果返回
看一下下面這個例子
#!/usr/bin/env python
# -*- coding: utf-8 -*-
deftest_first():
return3
deftest_second(num):
returnnum
action = { # 可以看做是一個sandbox
"para":5,
"test_first": test_first,
"test_second": test_second
}
deftest_eavl():
condition = "para == 5 and test_second(test_first) > 5"
res = eval(condition, action) # 解釋condition並根據action對應的動作執行
printres
if__name__ =='_
exec
exec在Python中會忽略返回值, 總是返回None, eval會返回執行代碼或語句的返回值
exec 和 eval 在執行代碼時, 除了返回值其他行為都相同
在傳入字元串時, 會使用 compile(source, '<string>', mode) 編譯位元組碼. mode的取值為 exec 和 eval
#!/usr/bin/env python
# -*- coding: utf-8 -*-
deftest_first():
print"hello"
deftest_second():
test_first()
print"second"
deftest_third():
print"third"
action = {
"test_second": test_second,
"test_third": test_third
}
deftest_exec():
exec"test_second"inaction
if__name__ =='__main__':
test_exec() # 無法看到執行結果
getattr
getattr(object, name[, default]) Return the value of
the named attribute of object. name must be a string. If the string is
the name of one of the object』s attributes, the result is the value of
that attribute. For example, getattr(x, 『foobar』) is equivalent to
x.foobar. If the named attribute does not exist, default is returned if
provided, otherwise AttributeError is raised.
通過string類型的name, 返回對象的name屬性(方法)對應的值, 如果屬性不存在, 則返回默認值, 相當於object.name
# 使用範例
classTestGetAttr(object):
test = "test attribute"
defsay(self):
print"test method"
deftest_getattr():
my_test = TestGetAttr()
try:
printgetattr(my_test,"test")
exceptAttributeError:
print"Attribute Error!"
try:
getattr(my_test, "say")()
exceptAttributeError:# 沒有該屬性, 且沒有指定返回值的情況下
print"Method Error!"
if__name__ =='__main__':
test_getattr()
# 輸出結果
test attribute
test method
命令行處理
defprocess_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
ifargvisNone:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78),
add_help_option=None)
# define options here:
parser.add_option( # customized description; put --help last
'-h','--help', action='help',
help='Show this help message and exit.')
settings, args = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
ifargs:
parser.error('program takes no command-line arguments; '
'"%s" ignored.'% (args,))
# further process settings & args if necessary
returnsettings, args
defmain(argv=None):
settings, args = process_command_line(argv)
# application code here, like:
# run(settings, args)
return0# success
if__name__ =='__main__':
status = main()
sys.exit(status)
讀寫csv文件
# 從csv中讀取文件, 基本和傳統文件讀取類似
importcsv
withopen('data.csv','rb')asf:
reader = csv.reader(f)
forrowinreader:
printrow
# 向csv文件寫入
importcsv
withopen('data.csv','wb')asf:
writer = csv.writer(f)
writer.writerow(['name','address','age'])# 單行寫入
data = [
( 'xiaoming ','china','10'),
( 'Lily','USA','12')]
writer.writerows(data) # 多行寫入
各種時間形式轉換
只發一張網上的圖, 然後差文檔就好了, 這個是記不住的
字元串格式化
一個非常好用, 很多人又不知道的功能
>>>name ="andrew"
>>>"my name is {name}".format(name=name)
'my name is andrew'
3. 如何在python中實現一個自定義的列表或字典
在很多的python庫之中，我們可以看到有的時候，庫作者會使用一些很特殊的「列表」或者「字典」。雖然他們看起來很像是一個列表或者字典，但是使用的方法卻又不一樣，這是因為那不是真的python中原本的列表和字典，而是作者自己創建的。那麼，我們如何可以創建我們自己的列表和字典呢？
前後都使用兩個下劃線的方法，一般被稱之為魔法方法，比如我們常見的 init ，就是一種魔法方法。一般來說，我們自行定義變數名的時候，不要定義很像是魔法方法的變數名。魔法方法被定義後，可以在適當的時候自動被調用，一般不需要手動對其進行調用。
在python中，實現一個序列，我們需要以下四種魔法方法
另外，一般來說，錯誤的鍵應當引發TypeError異常，而錯誤的索引應當引發IndexError異常
在python的列表中，只能夠使用數字作為索引，如果使用字元串的數字的話，那麼會引發異常。因此，我們可以嘗試一下，對原始的列表進行擴充，使其可以接受字元串作為列表的索引。
注意，這樣的自建列表，存在很多問題，幾乎全部的關於列表的方法都不能再被使用了。
為了解決正常列表的方法不能再被使用，我們可以考慮直接繼承list，以此得到普通列表的所有方法。
4. Python魔法函數（特殊函數）
Python中如何實現運算符的重載，即實現例如a+b這樣的運算符操作呢？
在C++中可以使用 operator 關鍵字實現運算符的重載。但是在Python中沒有類似這樣的關鍵字，所以要實現運算符的重載，就要用到Python的魔法函數。Python魔法函數是以雙下劃線開頭，雙下劃線結尾的一組函數。我們在類定義中最常用到的 __init__ 函數就是這樣一個魔法函數，它在創建類對象時被自動調用。
下面我們來看個簡單的例子。
上述代碼示例了幾個魔法函數的用法。 __add__ 函數對應了二元運算符+，當執行a+b語句時，python就會自動調用a. add (b)。 對於上述例子中的v1+v2+v3，則相當於調用了(v1. add(v2)). add(v3)。
代碼中還有一個在Python類定義經常使用的 __str__ 函數，當使用 str() 時會被調用。print函數對傳入的參數都調用了str()將其轉換成易讀的字元串形式，便於列印輸出，因而會調用類定義的__str__函數打出自定義的字元串。
代碼中還有一個特殊的 __call__ 函數，該函數在將對象採用函數調用方式使用時被調用, 例如v1()相當於v1. call ()。
以上就是魔法函數的基本使用方法。常見的魔法函數我們可以使用 dir() 函數來查看。
輸出結果為：
上述結果中形式為『__函數名__』的函數為魔法函數，注意有些對象也是這種形式，例如__class__, __mole__等, 這些不是魔法函數。具體的魔法函數說明可以參考Python官方說明文檔。
以上代碼在Python3.6運行通過.
5. 如何學習python知乎
對於Python的學習人員需要掌握以下技術。
1.網路編程。
網路編程在生活和開發中無處不在，哪裡有通訊就有網路，它可以稱為是一切開發的"基石"。對於所有編程開發人員必須要知其然並知其所以然，所以網路部分將從協議、封包、解包等底層進行深入剖析。
2. 爬蟲開發。
將網路一切數據作為資源，通過自動化程序進行有針對性的數據採集以及處理。爬蟲開發項目包含跨越防爬蟲策略、高性能非同步IO、分布式爬蟲等，並針對Scrapy框架源碼進行深入剖析，從而理解其原理並實現自定義爬蟲框架。
3.Web開發。
Web開發包含前端以及後端兩大部分，前端部分，帶你從"黑白"到"彩色"世界，手把手開發動態網頁;後端部分，帶你從10行代碼開始到n萬行來實現並使用自己的微型Web框架，框架講解中涵蓋了數據、組件、安全等多領域的知識，從底層了解其工作原理並可駕馭任何業內主流的Web框架。
4. IT自動化開發。
IT運維自動化是一組將靜態的設備結構轉化為根據IT服務需求動態彈性響應的策略，目的就是實現減少人工干預、降低人員成本以及出錯概率，真刀真槍的帶你開發企業中最常用的項目，從設計層面、框架選擇、靈活性、擴展性、故障處理、以及如何優化等多個層面接觸真實的且來源於各大互聯網公司真實案例，如:堡壘機、CMDB、全網監控、主機管理等。
5. 金融分析。
金融分析包含金融知識和Python相關模塊的學習，手把手帶你從金融小白到開發量化交易策略的大拿。學習內容囊括Numpy\Pandas\Scipy數據分析模塊等，以及常見金融分析策略如"雙均線"、"周規則交易"、"羊駝策略"、"Dual Thrust 交易策略"等，讓夢想照進現實，進入金融行業不再是個夢。
6. 人工智慧+機器學習。
人工智慧時代來臨，率先引入深度機器學習課程。其中包含機器學習的基礎概念以及常用知識，如:分類、聚類、回歸、神經網路以及常用類庫，並根據身邊事件作為案例，一步一步經過預處理、建模、訓練以及評估和參調等。人工智慧是未來科技發展的新趨勢，Python作為最主要的編程語言，勢必有很好的發展前景，現在學習Python也是一個很好的機會。
6. python中的__str__函數作用
__str__方法：總結
在python中方法名如果是__xxxx__()的，那麼就有特殊的功能，因此叫做「魔法」方法，當使用print輸出對象的時候，只要自己定義了__str__(self)方法，那麼就會列印從在這個方法中return的數據
例子1：如：
class Car:
def __init__(self, newWheelNum, newColor):
self.wheelNum = newWheelNum
self.color = newColor
def __str__(self):
msg = "嘿。。。我的顏色是" + self.color + "我有" + int(self.wheelNum) + "個輪胎..."
return msg
def move(self):
print('車在跑，目標:夏威夷')
BMW = Car(4, "白色")
print(BMW)
例子2：如：
class Cat:
"""定義了一個Cat類"""
#初始化對象
def __init__(self, new_name, new_age):
self.name = new_name
self.age = new_age
def __str__(self):
return "%s的年齡是:%d"%(self.name, self.age)
#方法
def eat(self):
print("貓在吃魚....")
def drink(self):
print("貓正在喝kele.....")
def introce(self):
print("%s的年齡是:%d"%(self.name, self.age))
#創建一個對象
tom = Cat("湯姆", 40)
lanmao = Cat("藍貓", 10)
print(tom)
print(lanmao)
運行結果：
湯姆的年齡是:40
藍貓的年齡是:10
7. python:matplotlib,魔法函數%matplotlib notebook，plot里style='k--o'是什麼意思呢
知乎自己看網頁鏈接：
matplotlib的plot函數接受一組X和Y坐標，還可以通過color、marker和linestyle關鍵字傳入指定的顏色、標記和線型，或者用一個表示顏色、標記和線型的格式字元串替代，兩種方法是等效的。格式字元串中color、marker和linestyle可以任意排列，如'ko--'，'k--o'，'o--k'
8. python中魔法方法加減怎麼用
Python中的列表中的元素不能直接相加減。
最佳的方式是將列表轉換成Python中的科學計算包numpy包的array類型，再進行加減。
import
numpy
as
npa
=
np.array([1,2,3,4])b
=
np.array([7,8,9,10])s
=
a
+
b
9. 【python】魔法方法 ：__getitem__ 、 __len__、__setitem__等的使用
在Python中，如果我們想實現創建類似於序列和映射的類（可以迭代以及通過[下標]返回元素），可以通過重寫魔法方法 __getitem__、__setitem__、__delitem__、__len__ 方法去模擬。
__getitem__(self,key): 返回鍵對應的值。
__setitem__(self,key,value)： 設置給定鍵的值
__delitem__(self,key): 刪除給定鍵對應的元素。
__len__(): 返回元素的數量
【注釋】只要實現了 __getitem__ 和 __len__ 方法，就會被認為是序列。
這些魔術方法的原理就是：當我們對類的屬性item進行下標的操作時，首先會被 __getitem__()、__setitem__()、__delitem__() 攔截，從而執行我們在方法中設定的操作，如賦值，修改內容，刪除內容等等。
這個方法應該以與鍵相關聯的方式存儲值，以便之後能夠使用 __setitem__ 來獲取。當然，這個對象可變時才需要實現這個方法。
舉個栗子：
定義一副撲克牌（不包括大小王），對牌進行洗牌，然後發牌。
Output：
【注意】 :我們會發現output中，輸出了： slice(1, 3, None) ，下面給出解釋。
語法：
參數說明：
slice() 函數實現切片對象，主要用在切片操作函數里的參數傳遞。
舉兩個栗子來看看：
Output:
切片原理
output
(程序員必會的 hhhhh.....)
看看slice在python3.7中是怎麼描述的:
10. python魔法，疑問
魔法方法是讓你自己改的 不改當然沒意義了 初學者說