如何使用靜態(tài)方法，類方法或者抽象方法

方法是作為類的屬性（attribute）存儲(chǔ)的函數(shù)。你可以以下面的方式聲明和獲取函數(shù)：

創(chuàng)新互聯(lián)建站長(zhǎng)期為上1000家客戶提供的網(wǎng)站建設(shè)服務(wù)，團(tuán)隊(duì)從業(yè)經(jīng)驗(yàn)10年，關(guān)注不同地域、不同群體，并針對(duì)不同對(duì)象提供差異化的產(chǎn)品和服務(wù)；打造開放共贏平臺(tái)，與合作伙伴共同營(yíng)造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為運(yùn)城企業(yè)提供專業(yè)的成都網(wǎng)站設(shè)計(jì)、網(wǎng)站建設(shè)、外貿(mào)網(wǎng)站建設(shè)，運(yùn)城網(wǎng)站改版等技術(shù)服務(wù)。擁有10余年豐富建站經(jīng)驗(yàn)和眾多成功案例,為您定制開發(fā)。

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是一個(gè)非綁定的方法。這又指什么呢？很快我們就會(huì)知道，試著調(diào)用一下：

Pizza.get_size()

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

這里我們不能調(diào)用這個(gè)方法是因?yàn)樗鼪]有被綁定到任一Pizza的實(shí)例上。一個(gè)方法需要一個(gè)實(shí)例作為它第一個(gè)參數(shù)（在Python 2中它必須是對(duì)應(yīng)類的實(shí)例；在Python 3中可以是任何東西）。我們現(xiàn)在試試：

Pizza.get_size(Pizza(42))

42

現(xiàn)在可以了！我們?cè)囉靡粋€(gè)實(shí)例作為get_size方法的第一個(gè)參數(shù)調(diào)用了它，所以一切變得很美好。但是你很快會(huì)同意，這并不是一個(gè)很漂亮的調(diào)用方法的方式；因?yàn)槊看挝覀兿胝{(diào)用這個(gè)方法都必須使用到類。并且，如果我們不知道對(duì)象是哪個(gè)類的實(shí)例，這種方式就不方便了。

所以，Python為我們準(zhǔn)備的是，它將類Pizza的所有的方法綁定到此類的任何實(shí)例上。這意味著類Pizza的任意實(shí)例的屬性get_size是一個(gè)已綁定的方法：第一個(gè)參數(shù)是實(shí)例本身的方法。

Pizza(42).get_size

bound method Pizza.get_size of __main__.Pizza object at 0x10314b310

Pizza(42).get_size()

42

如我們預(yù)期，現(xiàn)在不需要提供任何參數(shù)給get_size，因?yàn)樗呀?jīng)被綁定（bound），它的self參數(shù)是自動(dòng)地設(shè)為Pizza類的實(shí)例。下面是一個(gè)更好的證明：

m = Pizza(42).get_size

m

bound method Pizza.get_size of __main__.Pizza object at 0x10314b350

m()

42

因此，你甚至不要保存一個(gè)對(duì)Pizza對(duì)象的飲用。它的方法已經(jīng)被綁定在對(duì)象上，所以這個(gè)方法已經(jīng)足夠。

但是如何知道已綁定的方法被綁定在哪個(gè)對(duì)象上？技巧如下：

m = Pizza(42).get_size

m.__self__

__main__.Pizza object at 0x10314b390

m == m.__self__.get_size

True

易見，我們?nèi)匀槐４嬷粋€(gè)對(duì)對(duì)象的引用，當(dāng)需要知道時(shí)也可以找到。

在Python 3中，歸屬于一個(gè)類的函數(shù)不再被看成未綁定方法（unbound method），但是作為一個(gè)簡(jiǎn)單的函數(shù)，如果要求可以綁定在對(duì)象上。所以，在Python 3中原理是一樣的，模型被簡(jiǎn)化了。

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

靜態(tài)方法

靜態(tài)方法是一類特殊的方法。有時(shí)，我們需要寫屬于一個(gè)類的方法，但是不需要用到對(duì)象本身。例如：

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作為一個(gè)非靜態(tài)的方法也可以work，但是給它一個(gè)self的參數(shù)將沒有任何作用。這兒的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不需要對(duì)每個(gè)實(shí)例化的Pizza對(duì)象實(shí)例化一個(gè)綁定的方法。綁定的方法同樣是對(duì)象，創(chuàng)建它們需要付出代價(jià)。這里的靜態(tài)方法避免了這樣的情況：

降低了閱讀代碼的難度：看到@staticmethod便知道這個(gè)方法不依賴與對(duì)象本身的狀態(tài)；

允許我們?cè)谧宇愔兄剌dmix_ingredients方法。如果我們使用在模塊最頂層定義的函數(shù)mix_ingredients，一個(gè)繼承自Pizza的類若不重載cook，可能不可以改變混合成份（mix_ingredients）的方式。

類方法

什么是類方法？類方法是綁定在類而非對(duì)象上的方法！

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一下。

不管你如何使用這個(gè)方法，它總會(huì)被綁定在其歸屬的類上，同時(shí)它第一個(gè)參數(shù)是類本身（記住：類同樣是對(duì)象）

何時(shí)使用這種方法？類方法一般用于下面兩種：

1. 工廠方法，被用來創(chuàng)建一個(gè)類的實(shí)例，完成一些預(yù)處理工作。如果我們使用一個(gè)@staticmethod靜態(tài)方法，我們可能需要在函數(shù)中硬編碼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())

靜態(tài)方法調(diào)靜態(tài)方法：如果你將一個(gè)靜態(tài)方法分解為幾個(gè)靜態(tài)方法，你不需要硬編碼類名但可以使用類方法。使用這種方式來聲明我們的方法，Pizza這個(gè)名字不需要直接被引用，并且繼承和方法重載將會(huì)完美運(yùn)作。

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)

抽象方法

抽象方法在一個(gè)基類中定義，但是可能不會(huì)有任何的實(shí)現(xiàn)。在Java中，這被描述為一個(gè)接口的方法。

所以Python中最簡(jiǎn)單的抽象方法是：

class Pizza(object):

def get_radius(self):

raise NotImplementedError

任何繼承自Pizza的類將實(shí)現(xiàn)和重載get_radius方法，否則會(huì)出現(xiàn)異常。這種獨(dú)特的實(shí)現(xiàn)抽象方法的方式也有其缺點(diǎn)。如果你寫一個(gè)繼承自Pizza的類，忘記實(shí)現(xiàn)get_radius，錯(cuò)誤將會(huì)在你使用這個(gè)方法的時(shí)候才會(huì)出現(xiàn)。

Pizza()

__main__.Pizza object at 0x106f381d0

Pizza().get_radius()

Traceback (most recent call last):

File "stdin", line 1, in module

File "stdin", line 3, in get_radius

NotImplementedError

有種提前引起錯(cuò)誤發(fā)生的方法，那就是當(dāng)對(duì)象被實(shí)例化時(shí)，使用Python提供的abc模塊。

import abc

class BasePizza(object):

__metaclass__ = abc.ABCMeta

@abc.abstractmethod

def get_radius(self):

"""Method that should do something."""

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

BasePizza()

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

混合靜態(tài)方法、類方法和抽象方法

當(dāng)我們構(gòu)建類和繼承關(guān)系時(shí)，終將會(huì)碰到要混合這些方法decorator的情況。下面提幾個(gè)tip。

記住聲明一個(gè)類為抽象類時(shí)，不要冷凍那個(gè)方法的prototype。這是指這個(gè)方法必須被實(shí)現(xiàn)，不過是可以使用任何參數(shù)列表來實(shí)現(xiàn)。

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

這個(gè)是合法的，因?yàn)镃alzone完成了為BasePizza類對(duì)象定義的接口需求。就是說，我們可以把它當(dāng)作一個(gè)類方法或者靜態(tài)方法來實(shí)現(xiàn)，例如：

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

這樣做同樣爭(zhēng)取，并且完成了與BasePizza抽象類達(dá)成一致的需求。get_ingredients方法不需要知道對(duì)象，這是實(shí)現(xiàn)的細(xì)節(jié)，而非完成需求的評(píng)價(jià)指標(biāo)。

因此，你不能強(qiáng)迫抽象方法的實(shí)現(xiàn)是正常的方法、類方法或者靜態(tài)方法，并且可以這樣說，你不能。從Python 3開始（這就不會(huì)像在Python 2中那樣work了，見issue5867），現(xiàn)在可以在@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

不要誤解：如果你認(rèn)為這是強(qiáng)迫你的子類將get_ingredients實(shí)現(xiàn)為一個(gè)類方法，那就錯(cuò)了。這個(gè)是表示你實(shí)現(xiàn)的get_ingredients在BasePizza類中是類方法而已。

在一個(gè)抽象方法的實(shí)現(xiàn)？是的！在Python中，對(duì)比與Java接口，你可以在抽象方法中寫代碼，并且使用super()調(diào)用：

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（簡(jiǎn)書作者）

原文鏈接：

著作權(quán)歸作者所有，轉(zhuǎn)載請(qǐng)聯(lián)系作者獲得授權(quán)，并標(biāo)注“簡(jiǎn)書作者”。

怎樣使用MIX函數(shù)計(jì)算最暢銷產(chǎn)品銷售額！急急急??！

IF條件函數(shù)，=if（AB,1,0）如果AB，則顯示1，否則顯示0；

round四舍五入函數(shù)，=round（A2,1）A2單元格四舍五入，保留一位小數(shù)；

MIX是不是打錯(cuò)了，應(yīng)該是MIN吧，取一組數(shù)中最小值，=min（A:A）取A列中最小值；

MAX與MIN相反，取一組數(shù)中最大值，=max（A:A）取A列中最大值

如何串聯(lián)python知識(shí)點(diǎn)

1）避免‘\n'等特殊字符的兩種方式：

a）利用轉(zhuǎn)義字符‘\'b）利用原始字符‘r' print r'c:\now'

2）單行注釋，使用一個(gè)#，如：

#hello Python多行注釋，使用三個(gè)單引號(hào)（或三個(gè)雙引號(hào)），如：'''hello pythonhello world'''或"""hello pythonhello world"""另外跨越多行的字符串。也可以使用三個(gè)單引號(hào)或三個(gè)雙引號(hào)，如：'''......'''或者"""......"""

3）字符串中嵌入雙引號(hào)等特殊符號(hào)

a）利用轉(zhuǎn)義字符‘\'b）使用單引號(hào)括起這個(gè)字符串。print ('i l"o"ve fis.com')

4）條件分支：

if condition: 條件為真執(zhí)行的操作 else: 條件為假執(zhí)行的操作 if condition: action elif condition: action else: action python可以有效避免“懸掛else”（if else對(duì)應(yīng)關(guān)系出錯(cuò)）條件表達(dá)式（三元操作符） small = x if xy else y 如果xy ,small=x.否則small=y斷言assert：當(dāng)這個(gè)關(guān)鍵字后面的條件為假，程序自動(dòng)崩潰并拋出異常 assert 34 可以利用他置入檢查點(diǎn)

5）while條件:

條件為真執(zhí)行的操作 for 目標(biāo) in 表達(dá)式：循環(huán)體 例：favorite='fishc' for i in favorite: print(i,end='') range([start,] stop[,step=1])生成一個(gè)從start參數(shù)的值到stop參數(shù)值的數(shù)字序列 break：終止當(dāng)前循環(huán)體。跳到外層程序continue:終止本輪循環(huán)，開始下一輪循環(huán)（if condition true）

6）and邏輯操作符可以將任意表達(dá)式連接在一起，并得到一個(gè)布爾類型值

7）引入外援:

a）random模塊b）randint(),返回一個(gè)隨機(jī)的整數(shù)import random 或 from random import randint()secret=random.randint(1,10)

8）python數(shù)據(jù)類型

a）數(shù)值類型:整型、布爾類型、浮點(diǎn)型、e記法（1.5e10）b）類型轉(zhuǎn)換： int()轉(zhuǎn)換為整數(shù) str()轉(zhuǎn)換為字符串 float()轉(zhuǎn)換為浮點(diǎn)數(shù)c）獲取關(guān)于類型的信息： type()函數(shù) a=520 type(a) isinstance()函數(shù) a=12 isinstance(a,int) ---返回true isinstance(a,str) --返回false

9）Python值常用操作符

+ - * / % **（冪運(yùn)算） //(地板除法,結(jié)果偏小)比較操作符 = =邏輯操作符 and or not 優(yōu)先級(jí)： 冪運(yùn)算** 正負(fù)號(hào) + - 算術(shù)操作符 * / // + - 比較操作符 = 邏輯擦作福 not and or

10）列表--可以把整數(shù)、浮點(diǎn)數(shù)、字符串等打包在一起。數(shù)組卻不能

創(chuàng)建一個(gè)普通列表： member = ['小甲魚','小布丁','黑夜']創(chuàng)建一個(gè)混合列表： mix=[1,'小甲魚'，3.12，[1,2,3]]創(chuàng)建空列表： empty=[]向列表添加元素： append(): member.append('福祿娃')--只能添加一個(gè)。末尾添加 extend(): member.extend(['test','test1'])--只能以列表形式添加.末尾添加 insert(): member.insert(1,'牡丹')--第一位插入牡丹列表中獲取元素：使用索引index。 mix[1]列表中刪除元素：使用remove()。 mix.remove('小甲魚') 使用del。 del mix[3]/mix 使用pop()。 mix.pop()/mix.pop(1)列表切片：使用slice。 mix[1:4]/mix[1:]/mix[:4]列表操作符：,and,+,*,in/not in列表的小伙伴：dir(list) mix.count('小甲魚') mix.index('小甲魚')列表逆序：使用reverse。 mix.reverse()列表排序：使用sort。 mix.sort() mix.sort(func,key) mix.sort(reverse=True)

11）元組---不可改變的列表

和列表的主要不同點(diǎn)：a）創(chuàng)建和訪問一個(gè)元組： 大部分用（）/, ；列表用[]b）元組不可修改數(shù)值c）更新和刪除一個(gè)元組：temp = temp[:2] + ('test3',) + temp[2:] del tempd）IN/NOT IN，關(guān)系操作符，邏輯操作符，乘號(hào)操作符，連接操作符

12）字符串的各種內(nèi)置方法

str1='i love fishc.com'a=str1[:6] + '插入的字符串'+str1[6:]capitalize()： str2.capitalize()casefold()---全部小寫 str2.casefold()center(width)--居中，不足空格填充count(sub[,start[,end]])--返回sub在string中出現(xiàn)的次數(shù)endswith(sub[,start[,end]])--以sub結(jié)束？startswith(prefix[,start[,end]])--以prefix開頭expandtabs([tabsize=8])--將tab鍵轉(zhuǎn)換為空格find(sub[,start[,end]])--sub是否在字符串中出現(xiàn)rfind(sub)...index(sub[,start[,end]])--跟sub一樣，不過會(huì)產(chǎn)生異常rindex(sub..).....istitle()/isupper()/ljust(width)/lower()/strip()/title()/lower()join(sub):以字符串做分隔符，分割subpartion(sub):找到子字符串sub，把字符串分成一個(gè)3元組replace(old,new[,count])split(sep=none,maxsplit=-1)--不帶參數(shù)以空格做分隔符swapcase()--字符串大小寫翻轉(zhuǎn)zfill(width)--返回長(zhǎng)度為width的字符串，不夠補(bǔ)充空格

13）字符串格式化 replacement

"{0} love {1}.{2:.2f}".format("i","fishc",3.1424)"{a} love .{c}".format(a="i",b="fishc",c="com")"{0} love .{c}".format("i",b="fishc",c="com")格式化符號(hào)含義： %c:格式化字符及其ASCII碼 '%c %c %c' % (97,98,99) %s:格式化字符串 %d:格式化整數(shù) %o:格式化無符號(hào)八進(jìn)制數(shù) %x:格式化無符號(hào)十六進(jìn)制數(shù) %X:...(大寫) %f:格式化定點(diǎn)數(shù)，可指定小數(shù)點(diǎn)后的精度 %e:用科學(xué)技術(shù)發(fā)格式化定點(diǎn)數(shù)===%E %g:根據(jù)值的大小決定使用%f或%e===%G格式化操作符輔助命令： m.n ：m是顯示的最小總寬度，n是小數(shù)位精度 - ：用于左對(duì)齊 + ：在正數(shù)面前添加正號(hào) # ：在八進(jìn)制面前顯示0，在十六進(jìn)制面前顯示0x 0 ：空格用0填充字符串轉(zhuǎn)義字符 \a:發(fā)出系統(tǒng)響鈴聲 \b、\t、\n

14）序列

列表、元組和字符串的共同點(diǎn)： a）都可以通過索引 b）索引值從零開始內(nèi)置方法： list（）--help--轉(zhuǎn)換為序列 list() a=list() list(iterable) b='i love fishc.com' b=list(b) tuple([iterable])--把一個(gè)可迭代對(duì)象轉(zhuǎn)換為元組 b=tuple(b) str(obj)--把obj對(duì)象轉(zhuǎn)換為字符串 len(obj)--返回obj的長(zhǎng)度 max(序列/元組) / min(序列/元組) sum(iterable[,start=0])--返回序列iterable。。的總和 sorted(序列/元組)--排序 reversed(序列/元組)--返回一個(gè)迭代器對(duì)象 list(reversed(序列/元組))--返回序列 enumerate(序列/元組)--返回一個(gè)迭代器對(duì)象 list(enumerate(序列/元組))--返回?cái)?shù)組形式列表 zip（a,b）--合并成以元組形式的列表 list(zip(a,b))

15）函數(shù)

定義：def Myfunction(): print('this is my first function')調(diào)用：Myfunction()函數(shù)的參數(shù)： def Myfunction(name,age): print(name+age+'test') Myfunction('gncao'，‘a(chǎn)ge')函數(shù)的返回值: return value形參（parameter）：函數(shù)定義時(shí)的參數(shù)實(shí)參（argument）：實(shí)際傳遞的參數(shù)函數(shù)文檔：在函數(shù)中實(shí)現(xiàn)在函數(shù)體中用 '' 或 #查看函數(shù)文檔: a） functionname.__doc__ （四個(gè)下劃線） b） help(functionname)關(guān)鍵字參數(shù)：避免參數(shù)出亂 def Myfunction(words,name): ...... Myfunction(words='words123',name='name123') 默認(rèn)參數(shù): def Myfunction(name='name123',words='words123') ...... 收集參數(shù)：在參數(shù)前面加上*號(hào) def test(*params): print('參數(shù)的長(zhǎng)度是:',len(params)) print('第二個(gè)參數(shù)是:',params[1]) test(1,'小甲魚',2,4,5,6,7) def test(*params,exp): print('參數(shù)的長(zhǎng)度是:',len(params),exp) print('第二個(gè)參數(shù)是:',params[1]) test(1,'小甲魚',23,4,2,5,7,exp=0)

16）函數(shù)有返回值，過程沒有返回值

17）函數(shù)變量作用域（可見性）

局部：local--函數(shù)內(nèi)部定義的變量，局部可用全局：global--全局可訪問當(dāng)在函數(shù)內(nèi)部試圖修改全局變量時(shí)，則會(huì)在函數(shù)內(nèi)部新建一個(gè)跟 全局變量名相同的局部變量

18）內(nèi)嵌函數(shù)和閉包

global關(guān)鍵字： def myfun(): global count -全局變量 count=10 print(count)內(nèi)嵌函數(shù): def fun1(): print('fun1()正在被調(diào)用...') def fun2(): print('fun2()正在被調(diào)用') fun2()只能通過fun1()訪問fun2()閉包:在一個(gè)內(nèi)部函數(shù)中，對(duì)外部函數(shù)的變量的引用。成內(nèi)部函數(shù)為閉包 def funx(x): def funy(y): return x * y return funy調(diào)用方式: i=funx(8) i(5) 或 funx(4)(5) 通過關(guān)鍵字nonlocal可以使得內(nèi)部函數(shù)調(diào)用外部函數(shù)變量。 def fun1(): x=5 def fun2(): nonlocal x x*=x return x return fun2()

19，遞歸：

recursion（） def fac(n): if n==1: return 1 else: return n*fac(n-1) number=int(input('請(qǐng)輸入一個(gè)整數(shù):')) result=fac(number) print('%d 的階乘是：%d' % (number,result)) 迭代方法：def fab(n): n1=1 n2=1 n3=1 if n 1: print('輸入有錯(cuò)') return -1 while ( n-20 ): n3=n2+n1 n1=n2 n2=n3 n-=1 return n3 result=fab(20)if result != -1: print('總共有%d對(duì)小兔子誕生：' % result) 遞歸方法：def fab(n): if n 1: print('error') return -1 if n==1 or n==2: return 1 else: return fab(n-1) + fab(n-2) result=fab(20)print('總共有%d對(duì)兔子誕生' % result) 但是遞歸的效率比較低

20）字典（key-value）映射/序列例1：dict1={'李寧':'一切皆有可能','耐克':'just do it','阿迪達(dá)斯':'impossible is nothing'} print('李寧的口號(hào)是:',dict1['李寧']) 例2:dict3=dict((('f',70),('i',105))) 例3:dict4=dict(小甲魚='編程改變世界',test='test')dict4['小甲魚']='修改小甲魚對(duì)應(yīng)的value' --如果沒有該KEY，則會(huì)自動(dòng)添加一個(gè)KEY 字典的內(nèi)建方法:a）dict2['key']--訪問字典的元素b）fromkeys(s[,v]) --創(chuàng)建或查詢keydict1.fromkeys((1,2,3)){1: None, 2: None, 3: None}dict1.fromkeys((1,2,3),'number'){1: 'number', 2: 'number', 3: 'number'}c）keys()--dict.keys() --打印出dict的所有keyvalues()--dict.values() --打印出dict的所有valueitems()--dict.items() --打印出dict所有(key,value)get()-- dict.get(key) --打印key對(duì)應(yīng)的valuedict.get(key,'text')--打印key對(duì)應(yīng)的value，如果不存在，則打印textin操作符 -- key in dict2clear() --dict.clear() --清空dict的數(shù)據(jù)copy() --b=a.copy() --拷貝字典id(a)--查看idpop(key) -- dict.pop(key) --彈出keypopitem() --dict.popitem() --隨機(jī)彈出keysetdefault() --dict.setdefault(key) --新建keyupdate() --dict.update(dict) --更新字典

python音樂循環(huán)播放怎么實(shí)現(xiàn)

import pygame ---導(dǎo)庫

pygame.mixer.init()---初始化

pygame.mixer.music.load(歌曲名稱)---加載歌曲

pygame.mixer.music.play(-1)---播放歌曲

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

方法在Python中是如何工作的

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

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的一個(gè)未綁定方法。這是什么意思呢？很快我們就會(huì)知道答案：

Python

Pizza.get_size()

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

我們不能這么調(diào)用，因?yàn)樗€沒有綁定到Pizza類的任何實(shí)例上，它需要一個(gè)實(shí)例作為第一個(gè)參數(shù)傳遞進(jìn)去（Python2必須是該類的實(shí)例，Python3中可以是任何東西），嘗試一下：

Python

Pizza.get_size(Pizza(42))

42

Pizza.get_size(Pizza(42))

42

太棒了，現(xiàn)在用一個(gè)實(shí)例作為它的的第一個(gè)參數(shù)來調(diào)用，整個(gè)世界都清靜了，如果我說這種調(diào)用方式還不是最方便的，你也會(huì)這么認(rèn)為的；沒錯(cuò)，現(xiàn)在每次調(diào)用這個(gè)方法的時(shí)候我們都不得不引用這個(gè)類，如果不知道哪個(gè)類是我們的對(duì)象，長(zhǎng)期看來這種方式是行不通的。

那么Python為我們做了什么呢，它綁定了所有來自類_Pizza的方法以及該類的任何一個(gè)實(shí)例的方法。也就意味著現(xiàn)在屬性get_size是Pizza的一個(gè)實(shí)例對(duì)象的綁定方法，這個(gè)方法的第一個(gè)參數(shù)就是該實(shí)例本身。

Python

Pizza(42).get_size

bound method Pizza.get_size of __main__.Pizza object at 0x7f3138827910

Pizza(42).get_size()

42

和我們預(yù)期的一樣，現(xiàn)在不再需要提供任何參數(shù)給_get_size，因?yàn)樗呀?jīng)是綁定的，它的self參數(shù)會(huì)自動(dòng)地設(shè)置給Pizza實(shí)例，下面代碼是最好的證明：

Python

m = Pizza(42).get_size

m()

42

更有甚者，你都沒必要使用持有Pizza對(duì)象的引用了，因?yàn)樵摲椒ㄒ呀?jīng)綁定到了這個(gè)對(duì)象，所以這個(gè)方法對(duì)它自己來說是已經(jīng)足夠了。

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

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

顯然，該對(duì)象仍然有一個(gè)引用存在，只要你愿意你還是可以把它找回來。

在Python3中，依附在類上的函數(shù)不再當(dāng)作是未綁定的方法，而是把它當(dāng)作一個(gè)簡(jiǎn)單地函數(shù)，如果有必要它會(huì)綁定到一個(gè)對(duì)象身上去，原則依然和Python2保持一致，但是模塊更簡(jiǎn)潔：

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

靜態(tài)方法

靜態(tài)方法是一類特殊的方法，有時(shí)你可能需要寫一個(gè)屬于這個(gè)類的方法，但是這些代碼完全不會(huì)使用到實(shí)例對(duì)象本身，例如：

Python

class Pizza(object):

@staticmethod

def mix_ingredients(x, y):

return x + y

def cook(self):

return self.mix_ingredients(self.cheese, self.vegetables)

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

Python不再需要為Pizza對(duì)象實(shí)例初始化一個(gè)綁定方法，綁定方法同樣是對(duì)象，但是創(chuàng)建他們需要成本，而靜態(tài)方法就可以避免這些。

Python

Pizza().cook is Pizza().cook

False

Pizza().mix_ingredients is Pizza.mix_ingredients

True

Pizza().mix_ingredients is Pizza().mix_ingredients

True

可讀性更好的代碼，看到@staticmethod我們就知道這個(gè)方法并不需要依賴對(duì)象本身的狀態(tài)。

可以在子類中被覆蓋，如果是把mix_ingredients作為模塊的頂層函數(shù)，那么繼承自Pizza的子類就沒法改變pizza的mix_ingredients了如果不覆蓋cook的話。

類方法

話雖如此，什么是類方法呢？類方法不是綁定到對(duì)象上，而是綁定在類上的方法。

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

無論你用哪種方式訪問這個(gè)方法，它總是綁定到了這個(gè)類身上，它的第一個(gè)參數(shù)是這個(gè)類本身（記?。侯愐彩菍?duì)象）。

什么時(shí)候使用這種方法呢？類方法通常在以下兩種場(chǎng)景是非常有用的：

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

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())

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

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)

抽象方法

抽象方法是定義在基類中的一種方法，它沒有提供任何實(shí)現(xiàn)，類似于Java中接口(Interface)里面的方法。

在Python中實(shí)現(xiàn)抽象方法最簡(jiǎn)單地方式是：

Python

class Pizza(object):

def get_radius(self):

raise NotImplementedError

任何繼承自_Pizza的類必須覆蓋實(shí)現(xiàn)方法get_radius，否則會(huì)拋出異常。

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

Python

Pizza()

__main__.Pizza object at 0x7fb747353d90

Pizza().get_radius()

Traceback (most recent call last):

File "stdin", line 1, in module

File "stdin", line 3, in get_radius

NotImplementedError

還有一種方式可以讓錯(cuò)誤更早的觸發(fā)，使用Python提供的abc模塊，對(duì)象被初始化之后就可以拋出異常：

Python

import abc

class BasePizza(object):

__metaclass__ = abc.ABCMeta

@abc.abstractmethod

def get_radius(self):

"""Method that should do something."""

使用abc后，當(dāng)你嘗試初始化BasePizza或者任何子類的時(shí)候立馬就會(huì)得到一個(gè)TypeError，而無需等到真正調(diào)用get_radius的時(shí)候才發(fā)現(xiàn)異常。

Python

BasePizza()

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

混合靜態(tài)方法、類方法、抽象方法

當(dāng)你開始構(gòu)建類和繼承結(jié)構(gòu)時(shí)，混合使用這些裝飾器的時(shí)候到了，所以這里列出了一些技巧。

記住，聲明一個(gè)抽象的方法，不會(huì)固定方法的原型，這就意味著雖然你必須實(shí)現(xiàn)它，但是我可以用任何參數(shù)列表來實(shí)現(xiàn)：

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

這樣是允許的，因?yàn)镃alzone滿足BasePizza對(duì)象所定義的接口需求。同樣我們也可以用一個(gè)類方法或靜態(tài)方法來實(shí)現(xiàn)：

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

這同樣是正確的,因?yàn)樗裱橄箢怋asePizza設(shè)定的契約。事實(shí)上get_ingredients方法并不需要知道返回結(jié)果是什么，結(jié)果是實(shí)現(xiàn)細(xì)節(jié)，不是契約條件。

因此，你不能強(qiáng)制抽象方法的實(shí)現(xiàn)是一個(gè)常規(guī)方法、或者是類方法還是靜態(tài)方法，也沒什么可爭(zhēng)論的。從Python3開始（在Python2中不能如你期待的運(yùn)行，見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

別誤會(huì)了，如果你認(rèn)為它會(huì)強(qiáng)制子類作為一個(gè)類方法來實(shí)現(xiàn)get_ingredients那你就錯(cuò)了，它僅僅表示你實(shí)現(xiàn)的get_ingredients在BasePizza中是一個(gè)類方法。

可以在抽象方法中做代碼的實(shí)現(xiàn)？沒錯(cuò)，Python與Java接口中的方法相反，你可以在抽象方法編寫實(shí)現(xiàn)代碼通過super()來調(diào)用它。（譯注：在Java8中，接口也提供的默認(rèn)方法，允許在接口中寫方法的實(shí)現(xiàn)）

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()

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

python里面元組是什么意思？

↑↑↑點(diǎn)擊上方藍(lán)字，回復(fù)資料，10個(gè)G的驚喜

作者：陳tooyoung@阿里云Python訓(xùn)練營(yíng) 博客地址：

Python 是一種通用編程語言，其在科學(xué)計(jì)算和機(jī)器學(xué)習(xí)領(lǐng)域具有廣泛的應(yīng)用。如果我們打算利用 Python 來執(zhí)行機(jī)器學(xué)習(xí)，那么對(duì) Python 有一些基本的了解就是至關(guān)重要的。本 Python 入門系列體驗(yàn)就是為這樣的初學(xué)者精心準(zhǔn)備的。

列表的定義

列表的創(chuàng)建

向列表中添加元素

刪除列表中的元素

獲取列表中的元素

列表的常用操作符

列表的其他方法

元組

創(chuàng)建和訪問一個(gè)元組

更新和刪除一個(gè)元組

元組相關(guān)的操作符

內(nèi)置方法

解壓元組

列表

簡(jiǎn)單數(shù)據(jù)類型

整型

浮點(diǎn)型

布爾型

容器數(shù)據(jù)類型

列表

元組

字典

集合

字符串

列表的定義

列表是有序集合，沒有固定大小，能夠保存任意數(shù)量任意類型的 Python 對(duì)象，語法為[元素1, 元素2, ..., 元素n]。

關(guān)鍵點(diǎn)是「中括號(hào) []」和「逗號(hào) ,」

中括號(hào) 把所有元素綁在一起

逗號(hào) 將每個(gè)元素一一分開

列表的創(chuàng)建 創(chuàng)建一個(gè)普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(x, type(x))

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x = [2, 3, 4, 5, 6, 7]

print(x, type(x))

# [2, 3, 4, 5, 6, 7]

利用range()創(chuàng)建列表x = list(range(10))

print(x, type(x))

# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x = list(range(1, 11, 2))

print(x, type(x))

# [1, 3, 5, 7, 9]

x = list(range(10, 1, -2))

print(x, type(x))

# [10, 8, 6, 4, 2]

利用推導(dǎo)式創(chuàng)建列表x = [0] * 5

print(x, type(x))

# [0, 0, 0, 0, 0]

x = [0 for i in range(5)]

print(x, type(x))

# [0, 0, 0, 0, 0]

x = [i for i in range(10)]

print(x, type(x))

# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x = [i for i in range(1, 10, 2)]

print(x, type(x))

# [1, 3, 5, 7, 9]

x = [i for i in range(10, 1, -2)]

print(x, type(x))

# [10, 8, 6, 4, 2]

x = [i ** 2 for i in range(1, 10)]

print(x, type(x))

# [1, 4, 9, 16, 25, 36, 49, 64, 81]

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]

print(x, type(x))

# [3, 9, 15, 21, 27, 33, 39,

注意：

由于list的元素可以是任何對(duì)象，因此列表中所保存的是對(duì)象的指針。即使保存一個(gè)簡(jiǎn)單的[1,2,3]，也有3個(gè)指針和3個(gè)整數(shù)對(duì)象。

x = [a] * 4操作中，只是創(chuàng)建4個(gè)指向list的引用，所以一旦a改變，x中4個(gè)a也會(huì)隨之改變。

x = [[0] * 3] * 4

print(x, type(x))

# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

x[0][0] = 1

print(x, type(x))

# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]

a = [0] * 3

x = [a] * 4

print(x, type(x))

# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

x[0][0] = 1

print(x, type(x))

# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]

創(chuàng)建一個(gè)混合列表mix = [1, 'lsgo', 3.14, [1, 2, 3]]

print(mix, type(mix))

# [1, 'lsgo', 3.14, [1, 2, 3]]

創(chuàng)建一個(gè)空列表empty = []

print(empty, type(empty)) # []

列表不像元組，列表內(nèi)容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、刪除 (remove,pop) 這些操作都可以用在它身上。

向列表中添加元素

list.append(obj)在列表末尾添加新的對(duì)象，只接受一個(gè)參數(shù)，參數(shù)可以是任何數(shù)據(jù)類型，被追加的元素在 list 中保持著原結(jié)構(gòu)類型。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.append('Thursday')

print(x)

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']

print(len(x)) # 6

此元素如果是一個(gè) list，那么這個(gè) list 將作為一個(gè)整體進(jìn)行追加，注意append()和extend()的區(qū)別。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.append(['Thursday', 'Sunday'])

print(x)

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]

print(len(x)) # 6

list.extend(seq)在列表末尾一次性追加另一個(gè)序列中的多個(gè)值（用新列表擴(kuò)展原來的列表）

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.extend(['Thursday', 'Sunday'])

print(x)

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']

print(len(x)) # 7

嚴(yán)格來說append是追加，把一個(gè)東西整體添加在列表后，而extend是擴(kuò)展，把一個(gè)東西里的所有元素添加在列表后。

list.insert(index, obj)在編號(hào)index位置插入obj。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.insert(2, 'Sunday')

print(x)

# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']

print(len(x)) # 6

刪除列表中的元素

list.remove(obj)移除列表中某個(gè)值的第一個(gè)匹配項(xiàng)

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.remove('Monday')

print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']

list.pop([index=-1])移除列表中的一個(gè)元素（默認(rèn)最后一個(gè)元素），并且返回該元素的值

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

y = x.pop()

print(y) # Friday

y = x.pop(0)

print(y) # Monday

y = x.pop(-2)

print(y) # Wednesday

print(x) # ['Tuesday', 'Thursday']

remove和pop都可以刪除元素，前者是指定具體要?jiǎng)h除的元素，后者是指定一個(gè)索引。

del var1[, var2 ……]刪除單個(gè)或多個(gè)對(duì)象。

如果知道要?jiǎng)h除的元素在列表中的位置，可使用del語句。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

del x[0:2]

print(x) # ['Wednesday', 'Thursday', 'Friday']

獲取列表中的元素

通過元素的索引值，從列表獲取單個(gè)元素，注意，列表索引值是從0開始的。

通過將索引指定為-1，可讓Python返回最后一個(gè)列表元素，索引 -2 返回倒數(shù)第二個(gè)列表元素，以此類推。

x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]

print(x[0], type(x[0])) # Monday

print(x[-1], type(x[-1])) # ['Thursday', 'Friday']

print(x[-2], type(x[-2])) # Wednesday

切片的通用寫法是start : stop : step

"start :"

以step為 1 (默認(rèn)) 從編號(hào)start往列表尾部切片。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(x[3:]) # ['Thursday', 'Friday']

print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']

": stop"

以step為 1 (默認(rèn)) 從列表頭部往編號(hào)stop切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']

print(week[:-3]) # ['Monday', 'Tuesday']

"start : stop"

以step為 1 (默認(rèn)) 從編號(hào)start往編號(hào)stop切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[1:3]) # ['Tuesday', 'Wednesday']

print(week[-3:-1]) # ['Wednesday', 'Thursday']

- "start : stop : step"

以具體的step從編號(hào)start往編號(hào)stop切片。注意最后把step設(shè)為 -1，相當(dāng)于將列表反向排列。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[1:4:2]) # ['Tuesday', 'Thursday']

print(week[:4:2]) # ['Monday', 'Wednesday']

print(week[1::2]) # ['Tuesday', 'Thursday']

print(week[::-1])

# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

" : "

復(fù)制列表中的所有元素（淺拷貝）。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[:])

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

淺拷貝與深拷貝list1 = [123, 456, 789, 213]

list2 = list1

list3 = list1[:]

print(list2) # [123, 456, 789, 213]

print(list3) # [123, 456, 789, 213]

list1.sort()

print(list2) # [123, 213, 456, 789]

print(list3) # [123, 456, 789, 213]

list1 = [[123, 456], [789, 213]]

list2 = list1

list3 = list1[:]

print(list2) # [[123, 456], [789, 213]]

print(list3) # [[123, 456], [789, 213]]

list1[0][0] = 111

print(list2) # [[111, 456], [789, 213]]

print(list3) # [[111, 456], [789, 213]]

列表的常用操作符

等號(hào)操作符：==

連接操作符+

重復(fù)操作符*

成員關(guān)系操作符in、not in

「等號(hào) ==」，只有成員、成員位置都相同時(shí)才返回True。

列表拼接有兩種方式，用「加號(hào) +」和「乘號(hào) *」，前者首尾拼接，后者復(fù)制拼接。

list1 = [123, 456]

list2 = [456, 123]

list3 = [123, 456]

print(list1 == list2) # False

print(list1 == list3) # True

list4 = list1 + list2 # extend()

print(list4) # [123, 456, 456, 123]

list5 = list3 * 3

print(list5) # [123, 456, 123, 456, 123, 456]

list3 *= 3

print(list3) # [123, 456, 123, 456, 123, 456]

print(123 in list3) # True

print(456 not in list3) # False

前面三種方法（append,extend,insert）可對(duì)列表增加元素，它們沒有返回值，是直接修改了原數(shù)據(jù)對(duì)象。 而將兩個(gè)list相加，需要?jiǎng)?chuàng)建新的 list 對(duì)象，從而需要消耗額外的內(nèi)存，特別是當(dāng) list 較大時(shí)，盡量不要使用 “+” 來添加list。

列表的其它方法

list.count(obj)統(tǒng)計(jì)某個(gè)元素在列表中出現(xiàn)的次數(shù)

list1 = [123, 456] * 3

print(list1) # [123, 456, 123, 456, 123, 456]

num = list1.count(123)

print(num) # 3

list.index(x[, start[, end]])從列表中找出某個(gè)值第一個(gè)匹配項(xiàng)的索引位置

list1 = [123, 456] * 5

print(list1.index(123)) # 0

print(list1.index(123, 1)) # 2

print(list1.index(123, 3, 7)) # 4

list.reverse()反向列表中元素

x = [123, 456, 789]

x.reverse()

print(x) # [789, 456, 123]

list.sort(key=None, reverse=False)對(duì)原列表進(jìn)行排序。

key-- 主要是用來進(jìn)行比較的元素，只有一個(gè)參數(shù)，具體的函數(shù)的參數(shù)就是取自于可迭代對(duì)象中，指定可迭代對(duì)象中的一個(gè)元素來進(jìn)行排序。

reverse-- 排序規(guī)則，reverse = True降序，reverse = False升序（默認(rèn)）。

該方法沒有返回值，但是會(huì)對(duì)列表的對(duì)象進(jìn)行排序。

x = [123, 456, 789, 213]

x.sort()

print(x)

# [123, 213, 456, 789]

x.sort(reverse=True)

print(x)

# [789, 456, 213, 123]

# 獲取列表的第二個(gè)元素

def takeSecond(elem):

return elem[1]

x = [(2, 2), (3, 4), (4, 1), (1, 3)]

x.sort(key=takeSecond)

print(x)

# [(4, 1), (2, 2), (1, 3), (3, 4)]

x.sort(key=lambda a: a[0])

print(x)

# [(1, 3), (2, 2), (3, 4), (4, 1)]

元組

「元組」定義語法為：(元素1, 元素2, ..., 元素n)

小括號(hào)把所有元素綁在一起

逗號(hào)將每個(gè)元素一一分開

創(chuàng)建和訪問一個(gè)元組

Python 的元組與列表類似，不同之處在于tuple被創(chuàng)建后就不能對(duì)其進(jìn)行修改，類似字符串。

元組使用小括號(hào)，列表使用方括號(hào)。

元組與列表類似，也用整數(shù)來對(duì)它進(jìn)行索引 (indexing) 和切片 (slicing)。

t1 = (1, 10.31, 'python')

t2 = 1, 10.31, 'python'

print(t1, type(t1))

# (1, 10.31, 'python')

print(t2, type(t2))

# (1, 10.31, 'python')

tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)

print(tuple1[1]) # 2

print(tuple1[5:]) # (6, 7, 8)

print(tuple1[:5]) # (1, 2, 3, 4, 5)

tuple2 = tuple1[:]

print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)

創(chuàng)建元組可以用小括號(hào) ()，也可以什么都不用，為了可讀性，建議還是用 ()。

元組中只包含一個(gè)元素時(shí)，需要在元素后面添加逗號(hào)，否則括號(hào)會(huì)被當(dāng)作運(yùn)算符使用。

x = (1)

print(type(x)) #

x = 2, 3, 4, 5

print(type(x)) #

x = []

print(type(x)) #

x = ()

print(type(x)) #

x = (1,)

print(type(x)) #

print(8 * (8)) # 64

print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)

創(chuàng)建二維元組。

x = (1, 10.31, 'python'), ('data', 11)

print(x)

# ((1, 10.31, 'python'), ('data', 11))

print(x[0])

# (1, 10.31, 'python')

print(x[0][0], x[0][1], x[0][2])

# 1 10.31 python

print(x[0][0:2])

# (1, 10.31)

更新和刪除一個(gè)元組week = ('Monday', 'Tuesday', 'Thursday', 'Friday')

week = week[:2] + ('Wednesday',) + week[2:]

print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

元組有不可更改 (immutable) 的性質(zhì)，因此不能直接給元組的元素賦值，但是只要元組中的元素可更改 (mutable)，那么我們可以直接更改其元素，注意這跟賦值其元素不同。

t1 = (1, 2, 3, [4, 5, 6])

print(t1) # (1, 2, 3, [4, 5, 6])

t1[3][0] = 9

print(t1) # (1, 2, 3, [9, 5, 6])

元組相關(guān)的操作符

等號(hào)操作符：==

連接操作符+

重復(fù)操作符*

成員關(guān)系操作符in、not in

「等號(hào) ==」，只有成員、成員位置都相同時(shí)才返回True。

元組拼接有兩種方式，用「加號(hào) +」和「乘號(hào) *」，前者首尾拼接，后者復(fù)制拼接。

t1 = (123, 456)

t2 = (456, 123)

t3 = (123, 456)

print(t1 == t2) # False

print(t1 == t3) # True

t4 = t1 + t2

print(t4) # (123, 456, 456, 123)

t5 = t3 * 3

print(t5) # (123, 456, 123, 456, 123, 456)

t3 *= 3

print(t3) # (123, 456, 123, 456, 123, 456)

print(123 in t3) # True

print(456 not in t3) # False

內(nèi)置方法

元組大小和內(nèi)容都不可更改，因此只有count和index兩種方法。

t = (1, 10.31, 'python')

print(t.count('python')) # 1

print(t.index(10.31)) # 1

count('python')是記錄在元組t中該元素出現(xiàn)幾次，顯然是 1 次

index(10.31)是找到該元素在元組t的索引，顯然是 1

解壓元組

解壓（unpack）一維元組（有幾個(gè)元素左邊括號(hào)定義幾個(gè)變量）

t = (1, 10.31, 'python')

(a, b, c) = t

print(a, b, c)

# 1 10.31 python

解壓二維元組（按照元組里的元組結(jié)構(gòu)來定義變量）

t = (1, 10.31, ('OK', 'python'))

(a, b, (c, d)) = t

print(a, b, c, d)

# 1 10.31 OK python

如果你只想要元組其中幾個(gè)元素，用通配符「*」，英文叫 wildcard，在計(jì)算機(jī)語言中代表一個(gè)或多個(gè)元素。下例就是把多個(gè)元素丟給了rest變量。

t = 1, 2, 3, 4, 5

a, b, *rest, c = t

print(a, b, c) # 1 2 5

print(rest) # [3, 4]

如果你根本不在乎 rest 變量，那么就用通配符「*」加上下劃線「_」。

t = 1, 2, 3, 4, 5

a, b, *_ = t

print(a, b) # 1 2

分享標(biāo)題：關(guān)于mix函數(shù)python的信息
文章源于：http://aaarwkj.com/article6/hsodig.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供外貿(mào)建站、微信小程序、網(wǎng)站排名、品牌網(wǎng)站制作、網(wǎng)頁設(shè)計(jì)公司、虛擬主機(jī)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來源： 創(chuàng)新互聯(lián)