人生苦短，我用 Python！
大家好，最近有一些朋友問我有沒有一些 Python 實戰小案例。今天我整理排版了一遍，給大家分享一下。喜歡記得點讚、收藏、關注。
整理了60個Python小例子，拿來即用！
一、 數字1 求絕對值絕對值或複數的模
#公眾號：快學PythonIn[1]:abs(-6)Out[1]:62 進制轉化十進制轉換為二進制：
In[2]:bin(10)Out[2]:'0b1010'十進制轉換為八進制：
In[3]:oct(9)Out[3]:'0o11'十進制轉換為十六進制：
In[4]:hex(15)Out[4]:'0xf'3 整數和ASCII互轉十進制整數對應的ASCII字符
In[1]:chr(65)Out[1]:'A'查看某個ASCII字符對應的十進制數
In[1]:ord('A')Out[1]:654 元素都為真檢查所有元素都為真，返回True，否則為False
In[5]:all([1,0,3,6])Out[5]:FalseIn[6]:all([1,2,3])Out[6]:True5 元素至少一個為真檢查至少有一個元素為真返回True，否則False
In[7]:any([0,0,0,[]])Out[7]:FalseIn[8]:any([0,0,1])Out[8]:True6 判斷是真是假測試一個對象是True, 還是False.
In[9]:bool([0,0,0])Out[9]:TrueIn[10]:bool([])Out[10]:FalseIn[11]:bool([1,0,1])Out[11]:True7 創建複數創建一個複數
In[1]:complex(1,2)Out[1]:(1+2j)8 取商和餘數分別取商和餘數
In[1]:divmod(10,3)Out[1]:(3,1)9 轉為浮點類型將一個整數或數值型字符串轉換為浮點數
In[1]:float(3)Out[1]:3.0如果不能轉化為浮點數，則會報ValueError:
In[2]:float('a')#ValueError:couldnotconvertstringtofloat:'a'10 轉為整型int(x, base =10) , x可能為字符串或數值，將x 轉換為一個普通整數。如果參數是字符串，那麼它可能包含符號和小數點。如果超出了普通整數的表示範圍，一個長整數被返回。
In[1]:int('12',16)Out[1]:1811 次冪base為底的exp次冪，如果mod給出，取余
In[1]:pow(3,2,4)Out[1]:112 四捨五入四捨五入，ndigits代表小數點後保留幾位：
In[11]:round(10.0222222,3)Out[11]:10.022In[12]:round(10.05,1)Out[12]:10.113 鏈式比較i=3print(1<i<3)#Falseprint(1<i<=3)#True二、 字符串14 字符串轉字節字符串轉換為字節類型
In[12]:s="apple"In[13]:bytes(s,encoding='utf-8')Out[13]:b'apple'15 任意對象轉為字符串In[14]:i=100In[15]:str(i)Out[15]:'100'In[16]:str([])Out[16]:'[]'In[17]:str(tuple())Out[17]:'()'16 執行字符串表示的代碼將字符串編譯成python能識別或可執行的代碼，也可以將文字讀成字符串再編譯。
In[1]:s="print('helloworld')"In[2]:r=compile(s,"<string>","exec")In[3]:rOut[3]:<codeobject<module>at0x0000000005DE75D0,file"<string>",line1>In[4]:exec(r)helloworld17 計算表達式將字符串str 當成有效的表達式來求值並返回計算結果取出字符串中內容
In[1]:s="1+3+5"...:eval(s)...:Out[1]:918 字符串格式化格式化輸出字符串，format(value, format_spec)實質上是調用了value的__format__(format_spec)方法。
In[1]:print("iam{0},age{1}".format("tom",18))Out[1]:iamtom,age18
三、 函數19 拿來就用的排序函數排序：
In[1]:a=[1,4,2,3,1]In[2]:sorted(a,reverse=True)Out[2]:[4,3,2,1,1]In[3]:a=[{'name':'xiaoming','age':18,'gender':'male'},{'name':'...:xiaohong','age':20,'gender':'female'}]In[4]:sorted(a,key=lambdax:x['age'],reverse=False)Out[4]:[{'name':'xiaoming','age':18,'gender':'male'},{'name':'xiaohong','age':20,'gender':'female'}]20 求和函數求和：
In[181]:a=[1,4,2,3,1]In[182]:sum(a)Out[182]:11#公眾號：快學PythonIn[185]:sum(a,10)#求和的初始值為10Out[185]:2121 nonlocal用於內嵌函數中關鍵詞nonlocal常用於函數嵌套中，聲明變量i為非局部變量；如果不聲明，i+=1表明i為函數wrapper內的局部變量，因為在i+=1引用(reference)時,i未被聲明，所以會報unreferenced variable的錯誤。
defexcepter(f):i=0t1=time.time()defwrapper():try:f()exceptExceptionase:nonlocalii+=1print(f'{e.args[0]}:{i}')t2=time.time()ifi==n:print(f'spendingtime:{round(t2-t1,2)}')returnwrapper22 global 聲明全局變量先回答為什麼要有global，一個變量被多個函數引用，想讓全局變量被所有函數共享。有的夥伴可能會想這還不簡單，這樣寫：
i=5deff():print(i)defg():print(i)passf()g()f和g兩個函數都能共享變量i，程序沒有報錯，所以他們依然不明白為什麼要用global.
但是，如果我想要有個函數對i遞增，這樣：
defh():i+=1h()此時執行程序，bang, 出錯了！拋出異常：UnboundLocalError，原來編譯器在解釋i+=1時會把i解析為函數h()內的局部變量，很顯然在此函數內，編譯器找不到對變量i的定義，所以會報錯。
global就是為解決此問題而被提出，在函數h內，顯式地告訴編譯器i為全局變量，然後編譯器會在函數外面尋找i的定義，執行完i+=1後，i還為全局變量，值加1：
i=0defh():globalii+=1h()print(i)23 交換兩元素defswap(a,b):returnb,aprint(swap(1,0))輸出：
24 操作函數對象In[31]:deff():...:print('i'mf')...:In[32]:defg():...:print('i'mg')...:In[33]:[f,g][1]()i'mg創建函數對象的list，根據想要調用的index，方便統一調用。
25 生成逆序序列list(range(10,-1,-1))#[10,9,8,7,6,5,4,3,2,1,0]第三個參數為負時，表示從第一個參數開始遞減，終止到第二個參數(不包括此邊界)
26 函數的五類參數使用例子python五類參數：位置參數，關鍵字參數，默認參數，可變位置或關鍵字參數的使用。
deff(a,*b,c=10,**d):print(f'a:{a},b:{b},c:{c},d:{d}')默認參數c不能位於可變關鍵字參數d後.
調用f:
In[10]:f(1,2,5,width=10,height=20)a:1,b:(2,5),c:10,d:{'width':10,'height':20}可變位置參數b實參後被解析為元組(2,5);而c取得默認值10; d被解析為字典.
再次調用f:
In[11]:f(a=1,c=12)a:1,b:(),c:12,d:{}a=1傳入時a就是關鍵字參數，b,d都未傳值，c被傳入12，而非默認值。
注意觀察參數a, 既可以f(1),也可以f(a=1)其可讀性比第一種更好，建議使用f(a=1)。如果要強制使用f(a=1)，需要在前面添加一個星號:
deff(*,a,**b):print(f'a:{a},b:{b}')此時f(1)調用，將會報錯：TypeError: f() takes 0 positional arguments but 1 was given
只能f(a=1)才能OK.
說明前面的*發揮作用，它變為只能傳入關鍵字參數，那麼如何查看這個參數的類型呢？藉助python的inspect模塊：
In[22]:forname,valinsignature(f).parameters.items():...:print(name,val.kind)...:aKEYWORD_ONLYbVAR_KEYWORD可看到參數a的類型為KEYWORD_ONLY，也就是僅僅為關鍵字參數。
但是，如果f定義為：
deff(a,*b):print(f'a:{a},b:{b}')查看參數類型：
In[24]:forname,valinsignature(f).parameters.items():...:print(name,val.kind)...:aPOSITIONAL_OR_KEYWORDbVAR_POSITIONAL可以看到參數a既可以是位置參數也可是關鍵字參數。
27 使用slice對象生成關於蛋糕的序列cake1：
In[1]:cake1=list(range(5,0,-1))In[2]:b=cake1[1:10:2]In[3]:bOut[3]:[4,2]In[4]:cake1Out[4]:[5,4,3,2,1]再生成一個序列：
In[5]:fromrandomimportrandint...:cake2=[randint(1,100)for_inrange(100)]...:#同樣以間隔為2切前10個元素，得到切片d...:d=cake2[1:10:2]In[6]:dOut[6]:[75,33,63,93,15]你看，我們使用同一種切法，分別切開兩個蛋糕cake1,cake2. 後來發現這種切法極為經典，又拿它去切更多的容器對象。
那麼，為什麼不把這種切法封裝為一個對象呢？於是就有了slice對象。
定義slice對象極為簡單，如把上面的切法定義成slice對象：
perfect_cake_slice_way=slice(1,10,2)#去切cake1cake1_slice=cake1[perfect_cake_slice_way]cake2_slice=cake2[perfect_cake_slice_way]In[11]:cake1_sliceOut[11]:[4,2]In[12]:cake2_sliceOut[12]:[75,33,63,93,15]與上面的結果一致。
對於逆向序列切片，slice對象一樣可行：
a=[1,3,5,7,9,0,3,5,7]a_=a[5:1:-1]named_slice=slice(5,1,-1)a_slice=a[named_slice]In[14]:a_Out[14]:[0,9,7,5]In[15]:a_sliceOut[15]:[0,9,7,5]頻繁使用同一切片的操作可使用slice對象抽出來，復用的同時還能提高代碼可讀性。
28 lambda 函數的動畫演示有些讀者反映，lambda函數不太會用，問我能不能解釋一下。
比如，下面求這個lambda函數：
defmax_len(*lists):returnmax(*lists,key=lambdav:len(v))有兩點疑惑：
調用上面函數，求出以下三個最長的列表：
r=max_len([1,2,3],[4,5,6,7],[8])print(f'更長的列表是{r}')程序完整運行過程，動畫演示如下：
結論：
創建數據字典
In[1]:dict()Out[1]:{}In[2]:dict(a='a',b='b')Out[2]:{'a':'a','b':'b'}In[3]:dict(zip(['a','b'],[1,2]))Out[3]:{'a':1,'b':2}In[4]:dict([('a',1),('b',2)])Out[4]:{'a':1,'b':2}30 凍結集合創建一個不可修改的集合。
In[1]:frozenset([1,1,3,2,3])Out[1]:frozenset({1,2,3})因為不可修改，所以沒有像set那樣的add和pop方法
31 轉為集合類型返回一個set對象，集合內不允許有重複元素：
In[159]:a=[1,4,2,3,1]In[160]:set(a)Out[160]:{1,2,3,4}32 轉為切片對象classslice(start,stop[,step])
返回一個表示由 range(start, stop, step) 所指定索引集的 slice對象，它讓代碼可讀性、可維護性變好。
In[1]:a=[1,4,2,3,1]In[2]:my_slice_meaning=slice(0,5,2)In[3]:a[my_slice_meaning]Out[3]:[1,2,1]33 轉元組tuple()將對象轉為一個不可變的序列類型
In[16]:i_am_list=[1,3,5]In[17]:i_am_tuple=tuple(i_am_list)In[18]:i_am_tupleOut[18]:(1,3,5)五、 類和對象34 是否可調用檢查對象是否可被調用
In[1]:callable(str)Out[1]:TrueIn[2]:callable(int)Out[2]:TrueIn[18]:classStudent():...:def__init__(self,id,name):...:self.id=id...:self.name=name...:def__repr__(self):...:return'id='+self.id+',name='+self.name...In[19]:xiaoming=Student('001','xiaoming')In[20]:callable(xiaoming)Out[20]:False如果能調用xiaoming(), 需要重寫Student類的__call__方法：
In[1]:classStudent():...:def__init__(self,id,name):...:self.id=id...:self.name=name...:def__repr__(self):...:return'id='+self.id+',name='+self.name...:def__call__(self):...:print('Icanbecalled')...:print(f'mynameis{self.name}')...:In[2]:t=Student('001','xiaoming')In[3]:t()Icanbecalledmynameisxiaoming35 ascii 展示對象調用對象的__repr__方法，獲得該方法的返回值，如下例子返回值為字符串
>>>classStudent():def__init__(self,id,name):self.id=idself.name=namedef__repr__(self):return'id='+self.id+',name='+self.name調用：
>>>xiaoming=Student(id='1',name='xiaoming')>>>xiaomingid=1,name=xiaoming>>>ascii(xiaoming)'id=1,name=xiaoming'36 類方法classmethod裝飾器對應的函數不需要實例化，不需要self參數，但第一個參數需要是表示自身類的 cls 參數，可以來調用類的屬性，類的方法，實例化對象等。
In[1]:classStudent():...:def__init__(self,id,name):...:self.id=id...:self.name=name...:def__repr__(self):...:return'id='+self.id+',name='+self.name...:@classmethod...:deff(cls):...:print(cls)37 動態刪除屬性刪除對象的屬性
In[1]:delattr(xiaoming,'id')In[2]:hasattr(xiaoming,'id')Out[2]:False38 一鍵查看對象所有方法不帶參數時返回當前範圍內的變量、方法和定義的類型列表；帶參數時返回參數的屬性，方法列表。
In[96]:dir(xiaoming)Out[96]:['__class__','__delattr__','__dict__','__dir__','__doc__','__eq__','__format__','__ge__','__getattribute__','__gt__','__hash__','__init__','__init_subclass__','__le__','__lt__','__module__','__ne__','__new__','__reduce__','__reduce_ex__','__repr__','__setattr__','__sizeof__','__str__','__subclasshook__','__weakref__','name']39 動態獲取對象屬性獲取對象的屬性
In[1]:classStudent():...:def__init__(self,id,name):...:self.id=id...:self.name=name...:def__repr__(self):...:return'id='+self.id+',name='+self.nameIn[2]:xiaoming=Student(id='001',name='xiaoming')In[3]:getattr(xiaoming,'name')#獲取xiaoming這個實例的name屬性值Out[3]:'xiaoming'40 對象是否有這個屬性In[1]:classStudent():...:def__init__(self,id,name):...:self.id=id...:self.name=name...:def__repr__(self):...:return'id='+self.id+',name='+self.nameIn[2]:xiaoming=Student(id='001',name='xiaoming')In[3]:hasattr(xiaoming,'name')Out[3]:TrueIn[4]:hasattr(xiaoming,'address')Out[4]:False41 對象門牌號返回對象的內存地址
In[1]:id(xiaoming)Out[1]:9823420842 isinstance判斷_object_是否為類_classinfo_的實例，是返回true
In[1]:classStudent():...:def__init__(self,id,name):...:self.id=id...:self.name=name...:def__repr__(self):...:return'id='+self.id+',name='+self.nameIn[2]:xiaoming=Student(id='001',name='xiaoming')In[3]:isinstance(xiaoming,Student)Out[3]:True43 父子關係鑑定In[1]:classundergraduate(Student):...:defstudyClass(self):...:pass...:defattendActivity(self):...:passIn[2]:issubclass(undergraduate,Student)Out[2]:TrueIn[3]:issubclass(object,Student)Out[3]:FalseIn[4]:issubclass(Student,object)Out[4]:True如果class是classinfo元組中某個元素的子類，也會返回True
In[1]:issubclass(int,(int,float))Out[1]:True44 所有對象之根object 是所有類的基類
In[1]:o=object()In[2]:type(o)Out[2]:object45 創建屬性的兩種方式返回 property 屬性，典型的用法：
classC:def__init__(self):self._x=Nonedefgetx(self):returnself._xdefsetx(self,value):self._x=valuedefdelx(self):delself._x#使用property類創建property屬性x=property(getx,setx,delx,"I'mthe'x'property.")使用python裝飾器，實現與上完全一樣的效果代碼：
classC:def__init__(self):self._x=None@propertydefx(self):returnself._x@x.setterdefx(self,value):self._x=value@x.deleterdefx(self):delself._x46 查看對象類型classtype(name,bases,dict)
傳入一個參數時，返回object的類型：
In[1]:classStudent():...:def__init__(self,id,name):...:self.id=id...:self.name=name...:def__repr__(self):...:return'id='+self.id+',name='+self.name...:In[2]:xiaoming=Student(id='001',name='xiaoming')In[3]:type(xiaoming)Out[3]:__main__.StudentIn[4]:type(tuple())Out[4]:tuple47 元類xiaoming,xiaohong,xiaozhang都是學生，這類群體叫做Student.
Python 定義類的常見方法，使用關鍵字class
In[36]:classStudent(object):...:passxiaoming,xiaohong,xiaozhang是類的實例，則：
xiaoming=Student()xiaohong=Student()xiaozhang=Student()創建後，xiaoming 的__class__屬性，返回的便是Student類
In[38]:xiaoming.__class__Out[38]:__main__.Student問題在於，Student類有__class__屬性，如果有，返回的又是什麼？
In[39]:xiaoming.__class__.__class__Out[39]:type哇，程序沒報錯，返回type
那麼，我們不妨猜測：Student類，類型就是type
換句話說，Student類就是一個對象，它的類型就是type
所以，Python 中一切皆對象，類也是對象
Python 中，將描述Student類的類被稱為：元類。
按照此邏輯延伸，描述元類的類被稱為：_元元類_，開玩笑了~ 描述元類的類也被稱為元類。
聰明的朋友會問了，既然Student類可創建實例，那麼type類可創建實例嗎？如果能，它創建的實例就叫：類 了。你們真聰明！
說對了，type類一定能創建實例，比如Student類了。
In[40]:Student=type('Student',(),{})In[41]:StudentOut[41]:__main__.Student它與使用class關鍵字創建的Student類一模一樣。
Python 的類，因為又是對象，所以和xiaoming，xiaohong對象操作相似。支持：
元類，確實使用不是那麼多，也許先了解這些，就能應付一些場合。就連 Python 界的領袖Tim Peters都說：
「元類就是深度的魔法，99%的用戶應該根本不必為此操心。
六、工具48 枚舉對象返回一個可以枚舉的對象，該對象的next()方法將返回一個元組。
In[1]:s=["a","b","c"]...:fori,vinenumerate(s,1):...:print(i,v)...:1a2b3c49 查看變量所占字節數In[1]:importsysIn[2]:a={'a':1,'b':2.0}In[3]:sys.getsizeof(a)#占用240個字節Out[3]:24050 過濾器在函數中設定過濾條件，迭代元素，保留返回值為True的元素：
In[1]:fil=filter(lambdax:x>10,[1,11,2,45,7,6,13])In[2]:list(fil)Out[2]:[11,45,13]51 返回對象的哈希值返回對象的哈希值，值得注意的是自定義的實例都是可哈希的，list,dict,set等可變對象都是不可哈希的(unhashable)
In[1]:hash(xiaoming)Out[1]:6139638In[2]:hash([1,2,3])#TypeError:unhashabletype:'list'52 一鍵幫助返回對象的幫助文檔
In[1]:help(xiaoming)HelponStudentinmodule__main__object:classStudent(builtins.object)|Methodsdefinedhere:||__init__(self,id,name)||__repr__(self)||Datadescriptorsdefinedhere:||__dict__|dictionaryforinstancevariables(ifdefined)||__weakref__|listofweakreferencestotheobject(ifdefined)53 獲取用戶輸入獲取用戶輸入內容
In[1]:input()aaOut[1]:'aa'54 創建迭代器類型使用iter(obj, sentinel), 返回一個可迭代對象, sentinel可省略(一旦迭代到此元素，立即終止)
In[1]:lst=[1,3,5]In[2]:foriiniter(lst):...:print(i)...:135In[1]:classTestIter(object):...:def__init__(self):...:self.l=[1,3,2,3,4,5]...:self.i=iter(self.l)...:def__call__(self):#定義了__call__方法的類的實例是可調用的...:item=next(self.i)...:print("__call__iscalled,fowhichwouldreturn",item)...:returnitem...:def__iter__(self):#支持迭代協議(即定義有__iter__()函數)...:print("__iter__iscalled!!")...:returniter(self.l)In[2]:t=TestIter()In[3]:t()#因為實現了__call__，所以t實例能被調用__call__iscalled,whichwouldreturn1Out[3]:1In[4]:foreinTestIter():#因為實現了__iter__方法，所以t能被迭代...:print(e)...:__iter__iscalled!!13234555 打開文件返回文件對象
In[1]:fo=open('D:/a.txt',mode='r',encoding='utf-8')In[2]:fo.read()Out[2]:'\ufefflifeisnotsolong,\nIusePythontoplay.'mode取值表：
56 創建range序列range(stop)
range(start, stop[,step])
生成一個不可變序列：
In[1]:range(11)Out[1]:range(0,11)In[2]:range(0,11,1)Out[2]:range(0,11)57 反向迭代器In[1]:rev=reversed([1,4,2,3,1])In[2]:foriinrev:...:print(i)...:1324158 聚合迭代器創建一個聚合了來自每個可迭代對象中的元素的迭代器：
In[1]:x=[3,2,1]In[2]:y=[4,5,6]In[3]:list(zip(y,x))Out[3]:[(4,3),(5,2),(6,1)]In[4]:a=range(5)In[5]:b=list('abcde')In[6]:bOut[6]:['a','b','c','d','e']In[7]:[str(y)+str(x)forx,yinzip(a,b)]Out[7]:['a0','b1','c2','d3','e4']59 鏈式操作fromoperatorimport(add,sub)defadd_or_sub(a,b,oper):return(addifoper=='+'elsesub)(a,b)add_or_sub(1,2,'-')#-160 對象序列化對象序列化，是指將內存中的對象轉化為可存儲或傳輸的過程。很多場景，直接一個類對象，傳輸不方便。
但是，當對象序列化後，就會更加方便，因為約定俗成的，接口間的調用或者發起的 web 請求，一般使用 json 串傳輸。
實際使用中，一般對類對象序列化。先創建一個 Student 類型，並創建兩個實例。
classStudent():def__init__(self,**args):self.ids=args['ids']self.name=args['name']self.address=args['address']xiaoming=Student(ids=1,name='xiaoming',address='北京')xiaohong=Student(ids=2,name='xiaohong',address='南京')導入 json 模塊，調用 dump 方法，就會將列表對象 [xiaoming,xiaohong]，序列化到文件 json.txt 中。
importjsonwithopen('json.txt','w')asf:json.dump([xiaoming,xiaohong],f,default=lambdaobj:obj.__dict__,ensure_ascii=False,indent=2,sort_keys=True)生成的文件內容，如下：
[{"address":"北京","ids":1,"name":"xiaoming"},{"address":"南京","ids":2,"name":"xiaohong"}]來源：https://github.com/jackzhenguo/python-small-examples
長按或掃描下方二維碼，後台回覆：加群，即可申請入群。一定要備註：來源+研究方向+學校/公司，否則不拉入群中，見諒！
（長按三秒，進入後台）
推薦閱讀
留言列表