spam函數python,spam函數

享學課堂淺談Python序列內建函數都有哪些

1、Python類型操作符和內建函數總結

目前成都創新互聯已為近千家的企業提供了網站建設、域名、網頁空間、網站托管運營、企業網站設計、坡頭網站維護等服務，公司將堅持客戶導向、應用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協力一起成長，共同發展。

表4.5列出了所有操作符和內建函數，其中操作符順序是按優先級從高到低排列的。同一種灰度的操作符擁有同樣的優先級。注意在operator模塊中有這些（和絕大多數Python)操作符相應的同功能的函數可供使用。

表4.5 標準類型操作符和內建函數

操作符/函數

描 述

結 果a

字符串表示

``

對象的字符串表示

str

內建函數

cmp(obj1, obj2)

比較兩個對象

int

repr(obj)

對象的字符串表示

str

str(obj)

對象的字符串表示

str

type(obj)

檢測對象的類型

type

值比較

小于

bool

大于

bool

=

小于或等于

bool

=

大于或等于

bool

==

等于

bool

!=

不等于

bool

不等于

bool

對象比較

is

是

bool

is not

不是

bool

布爾操作符

not

邏輯反

bool

and

邏輯與

bool

or

邏輯或

bool

2、Python數值類型操作符和內建函數

一、工廠函數

數值工廠函數總結類（工廠函數） 操作

bool(obj) b 返回obj對象的布爾值，也就是 obj.__nonzero__()方法的返回值。

int(obj, base=10) 　 返回一個字符串或數值對象的整數表 示， 類似string.atoi();

從Python 1.6起， 引入了可選的進制參數。

long(obj, base=10) 返回一個字符或數據對象的長整數表 示，類似string.atol(),

從Python1.6起， 引入了可選的進制參數 float(obj) ，

返回一個字符串或數據對象的浮點數 表示，類似string.atof()。

complex(str) or返回一個字符串的復數表示，或 者根據給定的實數，

complex(real, imag=0.0) 　（及一個可選 的虛數部分）生成一個復數對象。

二、內建函數

1、分類

Python 有五個運算內建函數用于數值運算：

abs(num), coerce(num1,num2), divmod(num1,num2), pow(num1,num2,mod=1)和 round(flt,ndig=0)

其中abs()返回給定參數的絕對值。如果參數是一個復數， 那么就返回math.sqrt(num.real2 + num.imag2).

coerce()是一個數據類型轉換函數，不過它的行為更像一個運算符.數coerce（）為程序員提供了不依賴Python 解釋器，而是自定義兩個數值類型轉換的方法。對一種新創建的數值類型來說， 這個特性非常有用.函數coerce()僅返回一個包含類型轉換完畢的兩個數值元素的元組.

divmod()內建函數把除法和取余運算結合起來, 返回一個包含商和余數的元組.對整數來說，它的返回值就是地板除和取余操作的結果.對浮點數來說，返回的商部分是math.floor(num1/num2)，對復數來說，商部分是ath.floor((num1/num2).real).

pow()它和雙星號 （**）運算符都可以進行指數運算.不過二者的區別并不僅僅在于一個是運算符，一個是內建函數.在Python 1.5 之前，并沒有 ** 運算符,內建函數pow()還接受第三個可選的參數，一個余數參數.如果有這個參數的， pow() 先進行指數運算，然后將運算結果和第三個參數進行取余運算.這個特性主要用于密碼運算，并且比 pow(x,y) % z 性能更好， 這是因為這個函數的實現類似于C 函數pow(x,y,z).

round()用于對浮點數進行四舍五入運算。它有一個可選的小數位數參數.如果不提供小數位參數， 它返回與第一個參數最接近的整數（但仍然是浮點類型）.第二個參數告訴round 函數將結果精確到小數點后指定位數.

2、函數int()/round()/math.floor()它們之間的不同之處：

函數 int()直接截去小數部分.（返回值為整數）

函數 floor()　得到最接近原數但小于原數的整數.（返回值為浮點數）

函數 round() 得到最接近原數的整數.（返回值為浮點數）

3、進制轉換函數:

返回字符串表示的8 進制和16 進制整數,它們分別是內建函數：

oct()和 hex(). oct(255)='0377'/hex(255)='0xff'

函數chr()接受一個單字節整數值(0到255)，返回一個字符串(ASCII)，其值為對應的字符.chr(97)='a'

函數ord()則相反，它接受一個字符(ASCII 或 Unicode)，返回其對應的整數值.ord('A')=65

3、Python字符串函數

(一)標準類型操作符和標準內建函數

1)、標準類型操作符

,,=,=,==,!=,對象值得比較

注：做比較時字符串是按ASCII值的大小來比較的

is 對象身份比較

and,or,not 布爾類型

2）標準內建函數

type(obj)

cmp(obj1,obj2)

str(obj)和repr(obj) 或反引號運算符(``) 可以方便的以字符串的方式獲取對象的

內容、類型、數值屬性等信息。str()函數得到的字符串可讀性好， 而repr()函數得到的字符

串通常可以用來重新獲得該對象, 通常情況下 obj == eval(repr(obj)) 這個等式是成立的

isinstance(obj,type) 判斷對象的類型

(二)序列操作

1、序列操作

字符串屬于序列對象，可以使用所有序列的操作和函數

切片 [] [:] [::]

簡單總結：

*索引（S[i])獲取特定偏移的元素。

——第一個元素偏移為0

——（S[0])獲取第一個元素。

——負偏移索引意味著從最后或右邊反向進行計數

——（S[-2])獲取倒數第二個元素（就像S[len(s)-2]一樣

*分片[S[i:j]提取對應的部分作為一個序列

——右邊界不包含在內

——分片的邊界默認為0和序列的長度，如果沒有給出的話S[:]

——（S[1:3])獲取了從偏移為1，直到但不包括偏移為3的元素

——（S[1:])獲取從偏移為1到末尾之間的元素

——（S[:3])獲取從偏移為0直到但不包括偏移為3的元素

——（S[:-1])獲取從偏移為0直到但不包括最后一個元素之間的元素

——（S[:])獲取從偏移為0到末尾之間的元素,這有效地實現了頂層S拷貝

拷貝了一個相同值，但是是不同內存區域的對象。對象字符串這樣不可變的對象不是很有用，但是對于可以實地修改的對象來說很有用。

比如列表。

擴展分片：第三個限制值 【步進】

完整形式：X[I:J:K]:這標識索引X對象的元素，從偏移為I直到J-1，每隔K元素索引一次。第三個限制值，K，默認為1

實例

Python Code

1

2

3

4

5

S='abcdefghijk'

S[1:10]

'bcdefghij'

S[1:10:2]

'bdfhj

也可以使用負數作為步進。

分片表達式

Python Code

1

2

"hello"[::-1]

'olleh'

通過負數步進，兩個邊界的意義實際上進行了反轉。

3、成員操作符 in ，not in

返回布爾值True 或False

可以使用string模塊來判斷輸入字符的合法性，可見成品中的idcheck.py

4、字符串連接

+ 連接字符串 ‘name’+' '+'jin'

字符串格式化 '%s %s' % ('name','jin')

join()方法 ' '.join(('name','jin')) ' '.join(['name','jin'])

5、刪除清空字符串

del aString

aString=''

(三)、序列函數

序列類型函數

len(str) 返回字串的長度

enumerate(iter):接受一個可迭代對象作為參數，返回一個enumerate

max(str)/min(str):max()和min()函數對其他的序列類型可能更有用,但對于string類型它們能很好地運行,返回最大或者最小的字符(按照ASCII 碼值排列),

zip([it0, it1,... itN]) 返回一個列表，其第一個元素是it0,it1,...這些元素的第一個元素組成的一個元組，第二個...,類推.

reversed(seq)c 接受一個序列作為參數,返回一個以逆序訪問的迭代器(PEP 322)

sorted(iter,func=None,key=None,reverse=False) 接受一個可迭代對象作為參數，返回一個有序的列表;可選參數func,key 和reverse 的含義跟list.sort()內建函數的參數含義一樣.

注意：

sorted等需要在原處修改的函數無法用在字符串對象，但可以產生新的對象

sum處理的對象是數字，不能用在字符串

sorted(s)

['a', 'e', 'e', 'g', 'g', 'g', 'o']

(四)只適合于字符串類型的函數

1)raw_input()函數

內建的raw_input()函數使用給定字符串提示用戶輸入并將這個輸入返回，下面是一個使

用raw_input()的例子:

user_input = raw_input("Enter your name: ")

prin user_input

2)str() and unicode()

str()和unicode()函數都是工廠函數，就是說產生所對應的類型的對象.它們接受一個任

意類型的對象，然后創建該對象的可打印的或者Unicode 的字符串表示. 它們和basestring 都

可以作為參數傳給isinstance()函數來判斷一個對象的類型

3)chr(), unichr(), and ord()

chr()函數用一個范圍在range(256)內的(就是0 到255)整數做參數,返回一個對應的字符.unichr()跟它一樣，只不過返回的是Unicode 字符

ord()函數是chr()函數(對于8 位的ASCII 字符串)或unichr()函數(對于Unicode 對象)

的配對函數,它以一個字符(長度為1 的字符串)作為參數,返回對應的ASCII 數值，或者Unicode

數值，如果所給的Unicode 字符超出了你的Python 定義范圍,則會引發一個TypeError 的異常

(五)、只適用于字符串的操作符

1、格式化操作符 %

字符串格式化符號

格式化字符 轉換方式

%c 轉換成字符(ASCII 碼值，或者長度為一的字符串)

%ra 優先用repr()函數進行字符串轉換

%s 優先用str()函數進行字符串轉換

%d / %i 轉成有符號十進制數

%ub 轉成無符號十進制數

%ob 轉成無符號八進制數

%xb/%Xb (Unsigned)轉成無符號十六進制數(x/X 代表轉換后的十六進制字符的大

小寫)

%e/%E 轉成科學計數法(e/E 控制輸出e/E)

%f/%F 轉成浮點數(小數部分自然截斷)

%g/%G %e 和%f/%E 和%F 的簡寫

%% 輸出%

格式化操作符輔助指令

符號 作用

* 定義寬度或者小數點精度

- 用做左對齊

+ 在正數前面顯示加號( + )

sp 在正數前面顯示空格

# 在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決于

用的是'x'還是'X')

0 顯示的數字前面填充‘0’而不是默認的空格

% '%%'輸出一個單一的'%'

(var) 映射變量(字典參數)

m.n m 是顯示的最小總寬度,n 是小數點后的位數(如果可用的話)

2、字符串模板: 更簡單的替代品

由于新式的字符串Template 對象的引進使得string 模塊又重新活了過來，Template 對象

有兩個方法,substitute()和safe_substitute().前者更為嚴謹,在key 缺少的情況下它會報一

個KeyError 的異常出來，而后者在缺少key 時，直接原封不動的把字符串顯示出

3、原始字符串操作符( r/R )

字符串抑制轉義r'帶特殊符號的字串'

myfile=open(r'C:\new\text.data','w')

4、Unicode 字符串操作符( u/U )

u'abc' U+0061 U+0062 U+0063

u'\u1234' U+1234

u'abc\u1234\n' U+0061 U+0062 U+0063 U+1234 U+0012

(六)字符串對象的方法：

1、刪減

T2.lstrip() 移除字符串前面字符（默認空格），返回字符串

T2.rstrip() 移除字符串后面字符（默認空格），返回字符串

T2.strip() 移除字符串前后面空格，返回字符串 默認空格，可以其他字符 S.strip('"')

2、切割

partition(sep),

rpartition(sep),

splitlines([keepends]),#把S按照行分割符分為一個list，keepends是一個bool值，如果為真每行后而會保留行分割符

split([sep [,maxsplit]]),#以sep為分隔符，把S分成一個list。maxsplit表示分割的次數。默認的分割符為空白字符

rsplit([sep[,maxsplit]]) #從右到左切割

備注：

partition()函數族是2.5版本新增的方法。它接受一個字符串參數，并返回一個3個元素的 tuple 對象。

如果sep沒出現在母串中，返回值是 (sep, ‘’, ‘’)；

否則，返回值的第一個元素是 sep 左端的部分，第二個元素是 sep 自身，第三個元素是 sep 右端的部分。

S.partition(';')

('', ';', ' generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n')

參數 maxsplit 是分切的次數，即最大的分切次數，所以返回值最多有 maxsplit+1 個元素。

s.split() 和 s.split(‘ ‘)的返回值不盡相同

' hello world!'.split()

['hello', 'world!']

' hello world!'.split(' ')

['', '', 'hello', '', '', 'world!']

S.split('\n',3)

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n']

超過最大切割個數后面的全部為一個元素

按行切割

S

'; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n'

S.splitlines()

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2', 'nameserver 178.79.131.110', 'nameserver 202.96.199.133']

產生差異的原因在于當忽略 sep 參數或sep參數為 None 時與明確給 sep 賦予字符串值時 split() 采用兩種不同的算法。

對于前者，split() 先去除字符串兩端的空白符，然后以任意長度的空白符串作為界定符分切字符串

即連續的空白符串被當作單一的空白符看待；

對于后者則認為兩個連續的 sep 之間存在一個空字符串。因此對于空字符串（或空白符串），它們的返回值也是不同的：

''.split()

[]

''.split(' ')

['']

3、變形

lower(),#全部小寫

upper(),#全部小寫

capitalize(),#首字母大寫

swapcase(),#大小寫交換

title()#每個單詞第一個大寫,其他小寫

備注

因為title() 函數并不去除字符串兩端的空白符也不會把連續的空白符替換為一個空格，

所以建議使用string 模塊中的capwords(s)函數，它能夠去除兩端的空白符，再將連續的空白符用一個空格代替。

Python Code

1

2

3

4

' hello world!'.title()

' Hello World!'

string.capwords(' hello world!')

'Hello World!'

4、連接

join(seq)

join() 函數的高效率（相對于循環相加而言），使它成為最值得關注的字符串方法之一。

它的功用是將可迭代的字符串序列連接成一條長字符串，如：

conf = {'host':'127.0.0.1',

... 'db':'spam',

... 'user':'sa',

... 'passwd':'eggs'}

';'.join("%s=%s"%(k, v) for k, v in conf.iteritems())

'passswd=eggs;db=spam;user=sa;host=127.0.0.1'

S=''.join(T) #使用空字符串分割把字符列表轉換為字符串

5、查找

count( sub[, start[, end]]),#計算substr在S中出現的次數

find( sub[, start[, end]]),#返回S中出現sub的第一個字母的標號，如果S中沒有sub則返回-1。start和end作用就相當于在S[start:end]中搜索

index( substr[, start[, end]]),#與find()相同，只是在S中沒有substr時，會返回一個運行時錯誤

rfind( sub[, start[,end]]),#返回S中最后出現的substr的第一個字母的標號，如果S中沒有substr則返回-1，也就是說從右邊算起的第一次出現的substr的首字母標號

rindex( sub[, start[, end]])

T2.find('ie') 字符串方法調用：搜索

find()----找到的第一個符合字符的index

rfind()-----找到最后一個符合的字符的index

備注：

find()函數族找不到時返回-1，index()函數族則拋出ValueError異常。

另，也可以用 in 和 not in 操作符來判斷字符串中是否存在某個模板

6、替換

replace(old, new[,count]),#把S中的oldstar替換為newstr，count為替換次數。這是替換的通用形式，還有一些函數進行特殊字符的替換

translate(table[,deletechars]) #使用上面的函數產后的翻譯表，把S進行翻譯，并把deletechars中有的字符刪掉

備注：

replace()函數的 count 參數用以指定最大替換次數

translate() 的參數 table 可以由 string.maketrans(frm, to) 生成

translate() 對 unicode 對象的支持并不完備，建議不要使用

7、判定

isalnum(),#是否全是字母和數字，并至少有一個字符

isalpha(),是否全是字母，并至少有一個字符

isdigit(),是否全是數字，并至少有一個字符 ，如果是全數字返回True,否則返回False

islower(),#S中的字母是否全是小寫

isupper(),#S中的字母是否是大寫

isspace(),#是否全是空白字符，并至少有一個字符

istitle(),S是否是首字母大寫的

startswith(prefix[, start[, end]]), #是否以prefix開頭

endswith(suffix[,start[, end]]),#以suffix結尾

備注：

這些函數都比較簡單，顧名知義。需要注意的是*with()函數族可以接受可選的 start, end 參數，善加利用，可以優化性能。

另，自 Py2.5 版本起，*with() 函數族的 prefix 參數可以接受 tuple 類型的實參，當實參中的某人元素能夠匹配，即返回 True。

8、填充

字符串在輸出時的對齊：

center(width[, fillchar]), 字符串中間對齊

ljust(width[, fillchar]), 字符串左對齊，不足部分用fillchar填充，默認的為空格

rjust(width[, fillchar]), 字符串右對齊，不足部分用fillchar填充，默認的為空格

zfill(width), 把字符串變成width長，并在右對齊，不足部分用0補足

expandtabs([tabsize])把字符串中的制表符（tab）轉換為適當數量的空格。

fillchar 參數指定了用以填充的字符，默認為空格

zfill的z為zero的縮寫,顧名思義,是以字符0進行填充，用于數值輸出

expandtabs()的tabsize 參數默認為8。它的功能是把字符串中的制表符（tab）轉換為適當數量的空格。

9、編碼

encode([encoding[,errors]]),

decode([encoding[,errors]])

這是一對互逆操作的方法，用以編碼和解碼字符串。因為str是平臺相關的，它使用的內碼依賴于操作系統環境，

而unicode是平臺無關的，是Python內部的字符串存儲

Python函數注解使用有哪些注意事項呢？

函數注解是關于用戶自定義的函數的完全可選的、隨意的元數據信息。

1.無論 Python 本身或者標準庫中都沒有使用函數注解；本節只是描述了語法。第三方的項目是自由地為文檔，類型檢查，以及其它用途選擇函數注解。

2.注解是以字典形式存儲在函數的 __annotations__ 屬性中，對函數的其它部分沒有任何影響。參數注解（Parameter annotations）是定義在參數名稱的冒號后面，緊隨著一個用來表示注解的值得表達式。返回注釋（Return annotations）是定義在一個 - 后面，緊隨著一個表達式，在冒號與 - 之間。下面的示例包含一個位置參數，一個關鍵字參數，和沒有意義的返回值注釋:

def f(ham: 42, eggs: int = 'spam') - "Nothing to see here":

... print("Annotations:", f.__annotations__)

... print("Arguments:", ham, eggs)

...

f('wonderful')

Annotations: {'eggs':

, 'return': 'Nothing to see here', 'ham': 42}

Arguments: wonderful spam

python內建函數

其實安裝python包會自帶一個有問號標示“？”的"Python Manuals"可以仔細閱讀一下，也可作幫助文檔的。

介紹Python的內建函數和異常.許多內建函數的細節及特性可以在這里找到.

內建函數

本節介紹的函數在解釋器中總是可用的,他們被包含在 __builtin__ 模塊里.另外每個模塊的 __builtins__ 屬性經常指的是這個模塊(除了當在restricted execution環境下運行時).

_(下劃線)

默認情況下,變量 _ 用于在交互模式下表示最近一個表達式的運行結果.

參閱 sys.displayhook (118)

__import__(name [, globals [, locals [, fromlist]]])

import語句通過調用這個函數來導入模塊. name是包含模塊名字的字符串, globals是一個可選的定義全局名稱空間的字典, locals是定義局部名稱空間的字典, fromlist是from語句目標的列表.例如, import spam語句會調用__import__('spam', globals(), locals(), []) ,而from spam import foo 語句會調用 __import__('spam', globals(), locals(), ['foo']). 如果模塊名在包名字之后(如foo.bar)而且fromlist為空時,就返回對應的模塊對象.如果fromlist不為空,則只會返回最頂級的包.

這個函數是一個低等級的模塊載入接口.它并不執行import語句的所有步驟(通常情況下局部名稱空間并不會隨模塊中包含對象的名稱引用的改變而改變.這個函數可以由用戶來重新定義,這樣為import語句加入新的行為.默認的執行并不會檢查locals參數,而globals只用于決定包的內容(這些參數可以使 __import__()能夠完整地訪問全局和局部名稱空間)

abs(x)

返回x的絕對值

apply(func [, args [, keywords]])

對可調用對象func執行函數調用. args是一個包含固定位置參數的元組, keywords是包含關鍵參數的字典. apply()函數也可以寫做func(*args ,**keywords ).

buffer(sequence [, offset [, size]])

創建一個新的緩沖器對象.緩沖器通常是一個序列(如字符串)的字節導向序列.緩沖器和字符串在許多地方是相同的,但是它不支持字符串方法,而且也不能使用string模塊的函數.

callable(object)

當object為可調用對象時返回True,否則返回False

chr(i)

將一個0到255的整數轉換為一個字符.

cmp(x,y)

比較x和y. x y返回負數; x== y返回零; x y返回整數.它可以比較任意兩個對象并返回結果,即使有時候對象的比較豪無意義(例如比較文件對象).在某些環境下,這樣的比較會引發異常.

coerce(x,y)

將x和y值轉換為同一個數值類型并作為一個元組返回.(第三章,類型和對象)

compile(string, filename, kind)

使用exec()或eval()將字符串編譯為代碼對象. filename is a string containing the name of the file in which the string was defined. kind為'exec'時代表一個表達式的序列, 'eval'代表一個表達式, 'single'代表一個運行語句.

complex(real [, imag])

創建一個復數

delattr(object, attr)

刪除對象的一個屬性, attr是一個字符串.與 del object.attr相同

dir([object])

返回包含屬性名稱的列表.它們來自對象的 __dict__, __methods__,以及 __members__ 屬性.如果沒有傳遞給它參數,則會返回當前的local symbol table

divmod(a,b)

返回一個包含商和余數的元組.對于整數,將返回(a / b , a % b ),對于浮點數,將返回(math.floor(a / b ), a % b )

eval(expr [, globals [, locals]])

計算一個表達式的值. expr是一個字符串或由compile()創建的一個代碼對象. globals和locals為操作定義的全局和局部名稱空間,當省略時,表達式將在調用時的名稱空間計算.

execfile(filename [, globals [, locals]])

運行文件filename中的語句. globals和locals定義了文件運行的全局和局部名稱空間,當省略時,文件將在調用時的名稱空間運行.這個函數不能在一個函數主體里使用,因為它與內嵌范圍不相容.

filter(function, list)

使用func()函數來過濾s中的元素.使func返回值為false的元素被丟棄,其它的存入filter函數返回的列表中.如果function是None,則list中值為False的元素就被刪除.

float(x)

將x轉換為浮點數

getattr(object, name [, default])

返回一個對象的屬性. name是一個字符串. default是一個可選的值,代表當沒有這個屬性時返回的值. 與 object.name 結果相同

globals()

返回一個與全局名稱空間對應的字典

hasattr(object, name)

返回object是否有name屬性,布爾值

hash(object)

返回一個對象的整數哈希值(如果可能).兩個相等對象的哈希值是相同的.模塊沒有定義一個哈希值.

hex(x)

將一個整數或長整數轉換為一個十六進制的字符串

id(object)

返回一個對象的整數id

input([prompt])

相當于eval(raw_input(prompt ))

int(x [, base])

將一個數字或字符串轉換為整數. 可選參數base代表從字符串轉換時的基礎/根據

intern(string)

Checks to see whether string is contained in an internal table of strings. If found, a copy of the internal string is returned. If not, string is added to the internal table and returned. This function is primarily used to get better performance in operations involving dictionary lookups. Interned strings are never garbage-collected. Not applicable to Unicode strings.

isinstance(object, classobj)

檢查object是否是classobj的事例或子類.也可用于檢查類型

issubclass(class1, class2)

檢查class1是否是class2的子類(派生類)

注意: issubclass(A , A )返回True

len(s)

返回序列s中包含的條目數目

list(s)

返回一個包含序列s中條目的新列表

locals()

返回一個與調用時局部名稱空間相對應的字典

long(x [, base])

將一個數字或字符串轉換為長整數,可選參數base代表從字符串轉換時的基礎/根據

map(function, list, ...)

將序列list中的每個元素傳遞給function函數做參數,函數的返回值組成列表并返回.如果提供給多個列表,則函數應包含有多個參數,每個參數從不同的列表獲得.如果函數為None,則默認為 identity function(?身份函數).如果None映射到多個列表,則返回一個包含元組的列表,元組的每個元素分別來自各個列表.如果有必要,短的列表將使用None來擴充到與最長列表長度相等. map可以使用list comprehensions 來代替.例如map(function , alist ),可以使用[function (x) for x in alist ]來代替

參閱 zip (105).

max(s [, args, ...])

單個參數時,返回序列s中的最大值.多個參數時,返回值最大的參數

min(s [, args, ...])

單個參數時,返回序列s中的最小值.多個參數時,返回值最小的參數

oct(x)

將一個整數或者長整數轉換為八進制字符串

open(filename [, mode [, bufsize]])

打開文件filename并返回一個文件對象(第十章,運行環境). mode代表文件打開的模式. 'r' 表示讀, 'w' 表示寫, 'a' 表示在文件末尾添加內容. 還有一種更新模式,你只要在讀寫模式后增加一個'+'就可以使用這種模式,如'r+' 或 'w+'.當一個文件以更新模式打開,你就可以對這個文件進行讀寫操作.只要在任何讀取操作之前刷新所有的輸出緩沖就不會有問題.如果一個文件以 'w+' 模式打開,它的長度就度截為 0.當mode省略時,將會使用'w'模式.bufsize參數指定了緩沖行為, 0代表無緩沖,1代表行緩沖,其他正數代表一個大約的字節緩沖器大小,負數代表使用系統默認緩沖器大小(也是默認行為)

ord(c)

返回單個字符c的整數順序值.普通字符返回[0,255]中的一個值,Unicode字符返回 [0,65535]中的一個值

pow(x, y [, z])

返回x ** y ,如果z存在返回(x ** y ) % z

range([start,] stop [, step])

返回一個從start到stop的整數序列, step代表步進,默認值為1. start默認值為0.負數的step可以創建一個遞減的整數序列

參閱xrange (105)

raw_input([prompt])

從標準輸入(sys.stdin)中讀取一行,并把它作為字符串返回.如果提供了prompt,它將首先打印到標準輸出(sys.stdout).當讀取到一個EOF時,就會引發一個EOFError異常.如果readline模塊被導入,那么這個函數會使用它來提供更高級的功能

reduce(func, seq [, initializer])

函數從一個序列收集信息,然后只返回一個值(例如求和,最大值,等).它首先以序列的前兩個元素調用函數,再將返回值和第三個參數作為參數調用函數,依次執行下去,返回最終的值. func函數有且只有兩個參數.在seq為空時,將使用初始值initializer.

reload(module)

重新導入一個已經導入的模塊. module必須是一個已經存在的模塊對象.一般情況下并不鼓勵使用這個函數,除了在調試的時候.

當一個模塊重導入時,定義它的全局名稱空間的字典依然存在.Thus, definitions in the old module that aren’t part of the newly reloaded module are retained.模塊可以利用這個來檢查他們是否已經被導入.

重導入一個使用C編寫的模塊通常是不合法的

If any other modules have imported this module by using the from statement, they’ll continue to use the definitions in the previously imported module. This problem can be avoided by either reissuing the from statement after a module has been reloaded or using fully qualified names such as module.name .

如果有使用以前模塊中類創建的實例,它們將繼續使用以前的模塊

repr(object)

返回一個對象的標準字符串表示.與向后的引號 `object` 相同.大多數情況下,返回的字符串可以使用eval()來再次創建這個對象.

round(x [, n])

Returns the result of rounding the floating-point number x to the closest multiple of 10 to the power minus n . If n is omitted, it defaults to 0. If two multiples are equally close, rounding is done away from 0 (例如, 0.5 is rounded to 1.0 and -0.5 is rounded to -1.0).

setattr(object, name, value)

設置一個對象的屬性. name是一個字符串. 相當于object.name = value .

slice([start,] stop [, step])

返回一個代表指定數列中一個整數的切片對象.切片對象也可以有擴展切片操作語句來產生.(第三章,序列和映射方法)

str(object)

返回表示對象的可打印形式的字符串.與print語句產生的字符串相同.

tuple(s)

從序列s中創建一個元組.如果s已經是一個元組,則返回s

type(object)

返回object的類型,它是一個types模塊中定義type類型

參閱isinstance (102)

unichr(i)

將一個0到65535的整數轉換為一個Unicode字符

unicode(string [, encoding [, errors]])

將string轉換為Unicode字符串. encoding指定了string的數據編碼,它被省略時,將使用sys.getdefaultencoding(). errors指定編碼錯誤處理方式.('strict', 'ignore', 或 'replace' .參閱第三章和第九章中有關Unicode內容)

vars([object])

返回object的 symbol table (通常在object的__dict__屬性).如果沒有給它提供參數,則返回對應當前局部名稱空間的字典.

xrange([start,] stop [, step])

和range函數相似,但返回的是一個XRangeType對象.它生成一個迭代器,就是只有用那個數時才臨時通過計算提供值,而不是全部儲存它們.這樣在處理大的數列時能節省大量的內存.

zip(s1 [, s2 [,..]])

用來將幾個序列組合成一個包含元組的序列,序列中的每個元素t[i ] = (s1[i ], s2[i ], ..., sn[i ]).結果與最短序列的長度相等.

python如何獲取函數的參數名

我這里用的是IDLE（我自己也覺得有點低端），Python3（2應該也可以）

help()

Welcome to Python 3.7's help utility!

If this is your first time using Python, you should definitely check out

the tutorial on the Internet at .

Enter the name of any module, keyword, or topic to get help on writing

Python programs and using Python modules. To quit this help utility and

return to the interpreter, just type "quit".

To get a list of available modules, keywords, symbols, or topics, type

"modules", "keywords", "symbols", or "topics". Each module also comes

with a one-line summary of what it does; to list the modules whose name

or summary contain a given string such as "spam", type "modules spam".

help sum

Help on built-in function sum in module builtins:

sum(iterable, start=0, /)

Return the sum of a 'start' value (default: 0) plus an iterable of numbers

When the iterable is empty, return the start value.

This function is intended specifically for use with numeric values and may

reject non-numeric types.

解釋一下：先在Shell輸入help()，它就會問你你要哪個函數的說明。然后你輸入對應函數（比如sum），就可以看到這一行：sum(iterable, start=0, /)，也就是說你要先輸入iterable參數，start可以選擇輸入（有默認值）。

或者還有一種方法：用的時候直接輸入函數加上左括號 比如sum( 然后你就可以看到下面有一個框，然后按照說明寫就好了。如果不小心不見了，就可以把左括號去掉再重新輸入，就可以再看到這個框啦！

python如何寫 spam=10

spam=10

這本身就是一行合法的python代碼，意為創建（若已存在則覆蓋原變量）一個名為spam的int類型變量并賦值為10。

題主的意圖是這樣嗎？

Python 里為什么函數可以返回一個函數內部定義的函數

“在Python中，函數本身也是對象”

這一本質。那不妨慢慢來，從最基本的概念開始，討論一下這個問題：

1. Python中一切皆對象

這恐怕是學習Python最有用的一句話。想必你已經知道Python中的list, tuple, dict等內置數據結構，當你執行：

alist = [1, 2, 3]

時，你就創建了一個列表對象，并且用alist這個變量引用它：

當然你也可以自己定義一個類:

class House(object):

def __init__(self, area, city):

self.area = area

self.city = city

def sell(self, price):

[...] #other code

return price

然后創建一個類的對象：

house = House(200, 'Shanghai')

OK，你立馬就在上海有了一套200平米的房子，它有一些屬性(area, city)，和一些方法(__init__, self)：

2. 函數是第一類對象

和list, tuple, dict以及用House創建的對象一樣，當你定義一個函數時，函數也是對象：

def func(a, b):

return a+b

在全局域，函數對象被函數名引用著，它接收兩個參數a和b，計算這兩個參數的和作為返回值。

所謂第一類對象，意思是可以用標識符給對象命名，并且對象可以被當作數據處理，例如賦值、作為參數傳遞給函數，或者作為返回值return 等

因此，你完全可以用其他變量名引用這個函數對象：

add = func

這樣，你就可以像調用func(1, 2)一樣，通過新的引用調用函數了：

print func(1, 2)

print add(1, 2) #the same as func(1, 2)

或者將函數對象作為參數，傳遞給另一個函數：

def caller_func(f):

return f(1, 2)

if __name__ == "__main__":

print caller_func(func)

可以看到，

函數對象func作為參數傳遞給caller_func函數，傳參過程類似于一個賦值操作f=func；

于是func函數對象，被caller_func函數作用域中的局部變量f引用，f實際指向了函數func；cc

當執行return f(1, 2)的時候，相當于執行了return func(1, 2)；

因此輸出結果為3。

3. 函數對象 vs 函數調用

無論是把函數賦值給新的標識符，還是作為參數傳遞給新的函數，針對的都是函數對象本身，而不是函數的調用。

用一個更加簡單，但從外觀上看，更容易產生混淆的例子來說明這個問題。例如定義了下面這個函數：

def func():

return "hello,world"

然后分別執行兩次賦值：

ref1 = func #將函數對象賦值給ref1

ref2 = func() #調用函數，將函數的返回值("hello,world"字符串)賦值給ref2

很多初學者會混淆這兩種賦值，通過Python內建的type函數，可以查看一下這兩次賦值的結果：

In [4]: type(ref1)

Out[4]: function

In [5]: type(ref2)

Out[5]: str

可以看到，ref1引用了函數對象本身，而ref2則引用了函數的返回值。通過內建的callable函數，可以進一步驗證ref1是可調用的，而ref2是不可調用的：

In [9]: callable(ref1)

Out[9]: True

In [10]: callable(ref2)

Out[10]: False

傳參的效果與之類似。

4. 閉包LEGB法則

所謂閉包，就是將組成函數的語句和這些語句的執行環境打包在一起時，得到的對象

聽上去的確有些復雜，還是用一個栗子來幫助理解一下。假設我們在foo.py模塊中做了如下定義：

#foo.py

filename = "foo.py"

def call_func(f):

return f() #如前面介紹的，f引用一個函數對象，然后調用它

在另一個func.py模塊中，寫下了這樣的代碼：

#func.py

import foo #導入foo.py

filename = "func.py"

def show_filename():

return "filename: %s" % filename

if __name__ == "__main__":

print foo.call_func(show_filename) #注意：實際發生調用的位置，是在foo.call_func函數中

當我們用python func.py命令執行func.py時輸出結果為：

chiyu@chiyu-PC:~$ python func.py

filename:func.py

很顯然show_filename()函數使用的filename變量的值，是在與它相同環境(func.py模塊)中定義的那個。盡管foo.py模塊中也定義了同名的filename變量，而且實際調用show_filename的位置也是在foo.py的call_func內部。

而對于嵌套函數，這一機制則會表現的更加明顯：閉包將會捕捉內層函數執行所需的整個環境：

#enclosed.py

import foo

def wrapper():

filename = "enclosed.py"

def show_filename():

return "filename: %s" % filename

print foo.call_func(show_filename) #輸出：filename: enclosed.py

實際上，每一個函數對象，都有一個指向了該函數定義時所在全局名稱空間的__globals__屬性：

#show_filename inside wrapper

#show_filename.__globals__

{

'__builtins__': module '__builtin__' (built-in), #內建作用域環境

'__file__': 'enclosed.py',

'wrapper': function wrapper at 0x7f84768b6578, #直接外圍環境

'__package__': None,

'__name__': '__main__',

'foo': module 'foo' from '/home/chiyu/foo.pyc', #全局環境

'__doc__': None

}

當代碼執行到show_filename中的return "filename: %s" % filename語句時，解析器按照下面的順序查找filename變量：

Local - 本地函數(show_filename)內部，通過任何方式賦值的，而且沒有被global關鍵字聲明為全局變量的filename變量；

Enclosing - 直接外圍空間(上層函數wrapper)的本地作用域，查找filename變量(如果有多層嵌套，則由內而外逐層查找，直至最外層的函數)；

Global - 全局空間(模塊enclosed.py)，在模塊頂層賦值的filename變量；

Builtin - 內置模塊(__builtin__)中預定義的變量名中查找filename變量；

在任何一層先找到了符合要求的filename變量，則不再向更外層查找。如果直到Builtin層仍然沒有找到符合要求的變量，則拋出NameError異常。這就是變量名解析的：LEGB法則。

總結：

閉包最重要的使用價值在于：封存函數執行的上下文環境；

閉包在其捕捉的執行環境(def語句塊所在上下文)中，也遵循LEGB規則逐層查找，直至找到符合要求的變量，或者拋出異常。

5. 裝飾器語法糖(syntax sugar)

那么閉包和裝飾器又有什么關系呢？

上文提到閉包的重要特性：封存上下文，這一特性可以巧妙的被用于現有函數的包裝，從而為現有函數更加功能。而這就是裝飾器。

還是舉個例子，代碼如下：

#alist = [1, 2, 3, ..., 100] -- 1+2+3+...+100 = 5050

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

我們定義了一個函數lazy_sum，作用是對alist中的所有元素求和后返回。alist假設為1到100的整數列表：

alist = range(1, 101)

但是出于某種原因，我并不想馬上返回計算結果，而是在之后的某個地方，通過顯示的調用輸出結果。于是我用一個wrapper函數對其進行包裝：

def wrapper():

alist = range(1, 101)

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

return lazy_sum

lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函數對象

if __name__ == "__main__":

lazy_sum() #5050

這是一個典型的Lazy Evaluation的例子。我們知道，一般情況下，局部變量在函數返回時，就會被垃圾回收器回收，而不能再被使用。但是這里的alist卻沒有，它隨著lazy_sum函數對象的返回被一并返回了(這個說法不準確，實際是包含在了lazy_sum的執行環境中，通過__globals__)，從而延長了生命周期。

當在if語句塊中調用lazy_sum()的時候，解析器會從上下文中(這里是Enclosing層的wrapper函數的局部作用域中)找到alist列表，計算結果，返回5050。

當你需要動態的給已定義的函數增加功能時，比如：參數檢查，類似的原理就變得很有用：

def add(a, b):

return a+b

這是很簡單的一個函數：計算a+b的和返回，但我們知道Python是 動態類型+強類型 的語言，你并不能保證用戶傳入的參數a和b一定是兩個整型，他有可能傳入了一個整型和一個字符串類型的值：

In [2]: add(1, 2)

Out[2]: 3

In [3]: add(1.2, 3.45)

Out[3]: 4.65

In [4]: add(5, 'hello')

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()

---- 1 add(5, 'hello')

/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)

1 def add(a, b):

---- 2 return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

于是，解析器無情的拋出了一個TypeError異常。

動態類型：在運行期間確定變量的類型，python確定一個變量的類型是在你第一次給他賦值的時候；

強類型：有強制的類型定義，你有一個整數，除非顯示的類型轉換，否則絕不能將它當作一個字符串(例如直接嘗試將一個整型和一個字符串做+運算)；

因此，為了更加優雅的使用add函數，我們需要在執行+運算前，對a和b進行參數檢查。這時候裝飾器就顯得非常有用：

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):

return a + b

def checkParams(fn):

def wrapper(a, b):

if isinstance(a, (int, float)) and isinstance(b, (int, float)): #檢查參數a和b是否都為整型或浮點型

return fn(a, b) #是則調用fn(a, b)返回計算結果

#否則通過logging記錄錯誤信息，并友好退出

logging.warning("variable 'a' and 'b' cannot be added")

return

return wrapper #fn引用add，被封存在閉包的執行環境中返回

if __name__ == "__main__":

#將add函數對象傳入，fn指向add

#等號左側的add，指向checkParams的返回值wrapper

add = checkParams(add)

add(3, 'hello') #經過類型檢查，不會計算結果，而是記錄日志并退出

注意checkParams函數：

首先看參數fn，當我們調用checkParams(add)的時候，它將成為函數對象add的一個本地(Local)引用；

在checkParams內部，我們定義了一個wrapper函數，添加了參數類型檢查的功能，然后調用了fn(a, b)，根據LEGB法則，解釋器將搜索幾個作用域，并最終在(Enclosing層)checkParams函數的本地作用域中找到fn；

注意最后的return wrapper，這將創建一個閉包，fn變量(add函數對象的一個引用)將會封存在閉包的執行環境中，不會隨著checkParams的返回而被回收；

當調用add = checkParams(add)時，add指向了新的wrapper對象，它添加了參數檢查和記錄日志的功能，同時又能夠通過封存的fn，繼續調用原始的add進行+運算。

因此調用add(3, 'hello')將不會返回計算結果，而是打印出日志：

chiyu@chiyu-PC:~$ python func.py

WARNING:root:variable 'a' and 'b' cannot be added

有人覺得add = checkParams(add)這樣的寫法未免太過麻煩，于是python提供了一種更優雅的寫法，被稱為語法糖：

@checkParams

def add(a, b):

return a + b

這只是一種寫法上的優化，解釋器仍然會將它轉化為add = checkParams(add)來執行。

6. 回歸問題

def addspam(fn):

def new(*args):

print "spam,spam,spam"

return fn(*args)

return new

@addspam

def useful(a,b):

print a**2+b**2

首先看第二段代碼：

@addspam裝飾器，相當于執行了useful = addspam(useful)。在這里題主有一個理解誤區：傳遞給addspam的參數，是useful這個函數對象本身，而不是它的一個調用結果；

再回到addspam函數體：

return new 返回一個閉包，fn被封存在閉包的執行環境中，不會隨著addspam函數的返回被回收；

而fn此時是useful的一個引用，當執行return fn(*args)時，實際相當于執行了return useful(*args)；

最后附上一張代碼執行過程中的引用關系圖，希望能幫助你理解：

標題名稱：spam函數python,spam函數
文章來源：http://m.kartarina.com/article46/hddohg.html

成都網站建設公司_創新互聯，為您提供靜態網站、微信小程序、網頁設計公司、標簽優化、網站營銷、軟件開發

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯