Python 63個內置函數

超級詳解|Python 63個內置函數

python內置了一些非常精巧且強大的函數,對初學者來說,一般不怎麼用到,但是偶爾會碰到,我也是用了一段時間python之後才發現,哇還有這麼好的函數,每個函數都非常經典,而且經過嚴格測試,使用內置函數,不用自己閉門造車,並且代碼簡潔易讀了很多,真是方便又實用,值得花時間進行體系化研究學習。

01、abs()

描述:返回數字絕對值或複數的模

語法:abs( x )

參數:x 數值表達式。

案例:

<code>abs(-6)
6

abs(5j+4)
6.4031242374328485/<code>

02、all()

描述:接受一個迭代器,如果迭代器(元組或列表)的所有元素都為真,那麼返回True,否則返回False,元素除了是 0、空、None、False 外都算 True。

注意:空元組、空列表返回值為True,這裡要特別注意。

語法:all(iterable)

參數:iterable -- 元組或列表

案例:

<code>all([1,0,3,6])
False

all([1,9,3,6])
True

all(['a', 'b', '', 'd'])
False


all([]) #空列表為真
True

all(()) #空元組為真

True/<code>

03、any()

描述:接受一個迭代器,如果迭代器裡有一個元素為真,那麼返回True,否則返回False,元素除了是 0、空、None、False 外都算 True。

語法:any(iterable)

參數:iterable -- 元組或列表

案例:

<code>any([0,0,0,[]])
False

any([0,0,1])
True

any((0, '', False))
False

any([]) # 空列表
False

any(()) # 空元組
False/<code>

04、ascii()

描述:ascii() 函數返回任何對象(字符串,元組,列表等)的可讀版本。

ascii() 函數會將所有非 ascii 字符替換為轉義字符:

å 將替換為 \\\\xe5。

語法:ascii(object)

參數:object--對象,可以是元組、列表、字典、字符串、set()創建的集合。

案例:

<code>ascii('中國')
"'\\\\\\u4e2d\\\\\\u56fd'"

ascii('新冠肺炎')
"'\\\\\\u65b0\\\\\\u51a0\\\\\\u80ba\\\\\\u

ascii("My name is Ståle")
"'My name is St\\\\\\xe5le'"

print(ascii((1,2))) #元組
(1, 2)
print(type(ascii((1,2))))
<class>

print(ascii([1,2])) #列表
[1, 2]
print(type(ascii([1,2])))
<class>

print(ascii('?')) #字符串,非 ASCII字符,轉義
'\\\\uff1f'
print(type(ascii("?")))
<class>

print(ascii({1:2,'name':5})) #字典
{1: 2, 'name': 5}
print(type(ascii({1:2,'name':5})))
<class>/<class>/<class>/<class>/<code>


05、bin()

描述:bin() 返回一個整數 int 或者長整數 long int 的二進制表示。將十進制轉換為二進制

語法:bin(x)

參數:x -- int 或者 long int 數字

案例:

<code>bin(2)
'0b10'

bin(20)
'0b10100'/<code>

06、oct()

描述:將十進制轉換為八進制

語法:oct(x)

參數:x -- 整數。

案例:

<code>oct(8)
'0o10'

oct(43)
'0o53'/<code>

07、hex()

描述:hex() 函數用於將10進制整數轉換成16進制,以字符串形式表示。

語法:hex(x)

參數:x -- 10進制整數。

案例:

<code>將十進制轉換為十六進制
hex(43)

'0x2b'#43等於2B

hex(15)
'0xf'/<code>

08、bool()

描述:測試一個對象是True, 還是False.bool 是 int 的子類。

語法:class bool([x])

參數:x -- 要進行轉換的參數。

案例:

<code>bool([0,0,0])
True

bool([])
False

issubclass(bool, int) # bool 是 int 子類
True/<code>

09、bytes()

描述:將一個字符串轉換成字節類型

語法:class bytes([source[, encoding[, errors]]])

參數:

  • 如果 source 為整數,則返回一個長度為 source 的初始化數組;
  • 如果 source 為字符串,則按照指定的 encoding 將字符串轉換為字節序列;
  • 如果 source 為可迭代類型,則元素必須為[0 ,255] 中的整數;
  • 如果 source 為與 buffer 接口一致的對象,則此對象也可以被用於初始化 bytearray。
  • 如果沒有輸入任何參數,默認就是初始化數組為0個元素。

案例:

<code>s = "apple"
bytes(s,encoding='utf-8')
b'apple'


bytes([1,2,3,4])
b'\\\\x01\\\\x02\\\\x03\\\\x04'/<code>


10、str()

描述:str() 函數將對象轉化為適於人閱讀的形式。將字符類型、數值類型等轉換為字符串類型

語法:class str(object='')

參數:object -- 對象。

案例:

<code>integ = 100
str(integ)
'100'


dict = {'baidu': 'baidu.com', 'google': 'google.com'};
str(dict)
"{'baidu': 'baidu.com', 'google': 'google.com'}"
/<code>


11、callable()

描述:判斷對象是否可以被調用,能被調用的對象就是一個callable 對象,對於函數、方法、lambda 函式、 類以及實現了 __call__ 方法的類實例, 它都返回 True。

語法:callable(object)

參數:object -- 對象

案例:

<code>callable(0)
False

def add(x, y):
return x + y

callable(add)
True/<code>

12、chr()

描述:chr() 用一個範圍在 range(256)內的(就是0~255)整數作參數,返回一個對應的字符。

語法:chr(i)

參數:i -- 可以是10進制也可以是16進制的形式的數字。

案例:

<code>查看十進制整數對應的ASCII字符 

chr(65)
'A'
可以參考4案例中的表/<code>

13、ord()

描述:查看某個ascii對應的十進制數

語法:ord(c)

參數:c -- 字符。

案例:

<code>ord('A')
65


ord('~')
126/<code>

14、classmethod()

描述:classmethod 修飾符對應的函數不需要實例化,不需要 self 參數,但第一個參數需要是表示自身類的 cls 參數,可以來調用類的屬性,類的方法,實例化對象等。

語法:classmethod

參數:無

案例:

<code>class Sample(object):
bar = 1
def fun1(self):
print ('foo')


@classmethod
def fun2(cls):
print ('fun2')
print (cls.bar)
cls().fun1() # 調用 foo 方法

Sample.fun2() # 不需要實例化
fun2
1
foo/<code>

15、compile()

描述:compile() 函數將一個字符串編譯為字節代碼。

語法:compile(source, filename, mode[, flags[, dont_inherit]])

參數:

  • source -- 字符串或者AST(Abstract Syntax Trees)對象。。
  • filename -- 代碼文件名稱,如果不是從文件讀取代碼則傳遞一些可辨認的值。
  • mode -- 指定編譯代碼的種類。可以指定為 exec, eval, single。
  • flags -- 變量作用域,局部命名空間,如果被提供,可以是任何映射對象。。
  • flags和dont_inherit是用來控制編譯源碼時的標誌

案例:

<code>將字符串編譯成python能識別或可以執行的代碼,也可以將文字讀成字符串再編譯。
s = "print('helloworld')"
r = compile(s,"<string>", "exec")

r
<code> at 0x000000000F819420, file "<string>", line 1>
exec(r)
helloworld
str = "for i in range(0,5): print(i)"
c = compile(str,'','exec') # 編譯為字節代碼對象
c
<code> at 0x000001EB82C91ED0, file "", line 1>
exec(c)
0
1
2
3
4/<code>/<string>/<code>/<string>/<code>

16、complex()

描述:創建一個複數

語法:class complex([real[, imag]])

參數:

  • real -- int, long, float或字符串;
  • imag -- int, long, float;

案例:

<code>complex(1,2)
(1+2j)


complex('1')
(1+0j)/<code>

complex("1+2j")

(1+2j)

17、delattr()

描述:

刪除對象的屬性

語法:delattr(object, name)

參數:

  • object -- 對象。
  • name -- 必須是對象的屬性。

案例:

<code>class Coordinate:
x = 10
y = -5
z = 0

point1 = Coordinate()


print('x = ',point1.x)
x = 10
print('y = ',point1.y)
y = -5
print('z = ',point1.z)
z = 0
delattr(Coordinate, 'z')

print('--刪除 z 屬性後--')


print('z = ',point1.z)# 觸發錯誤
AttributeError: 'Coordinate' object has no attribute 'z'


dir(Coordinate)
['__class__
省略部分

'x',
'y'/<code>

18、dict()

描述:創建數據字典

語法:

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

參數:

  • **kwargs -- 關鍵字
  • mapping -- 元素的容器。
  • iterable -- 可迭代對象。

案例:

<code>#創建空字典
dict()
{}

#傳入關鍵字
dict(a='a', b='b', t='t')
{'a': 'a', 'b': 'b', 't': 't'}

# 映射函數方式來構造字典

dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'three': 3, 'two': 2, 'one': 1}


#可迭代對象方式來構造字典
dict([('one', 1), ('two', 2), ('three', 3)])
{'three': 3, 'two': 2, 'one': /<code>

19、dir()

描述:dir() 函數不帶參數時,返回當前範圍內的變量、方法和定義的類型列表;帶參數時,返回參數的屬性、方法列表。如果參數包含方法__dir__(),該方法將被調用。如果參數不包含__dir__(),該方法將最大限度地收集參數信息。

語法:dir([object])

參數:object -- 對象、變量、類型。

案例:

<code>dir()   #  獲得當前模塊的屬性列表
['In',
'Out',
'_',
'__',
'___',
'__builtin__',

'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_ih',
'_ii',
'_iii',
'_oh',
'exit',
'get_ipython',
'quit']

dir([ ])# 查看列表的方法
dir(list())# 查看列表的方法


['__add__',
'__class__',
'__contains__',
'__delattr__',
'__delitem__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
'__gt__',
'__hash__',
'__iadd__',
'__imul__',
'__init__',
'__init_subclass__',
'__iter__',
'__le__',
'__len__',
'__lt__',
'__mul__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',

'__reversed__',
'__rmul__',
'__setattr__',
'__setitem__',
'__sizeof__',
'__str__',
'__subclasshook__',
'append',
'clear',
'copy',
'count',
'extend',
'index',
'insert',
'pop',
'remove',
'reverse',
'sort']


print(dir(str))#獲取所有的方法
print(dir(list))#獲取所有的方法
print(dir(dict))#獲取所有的/<code>

不帶參數時返回當前範圍內的變量,方法和定義的類型列表;帶參數時返回參數的屬性,方法列表。


20、divmod()

描述:divmod() 函數把除數和餘數運算結果結合起來,返回一個包含商和餘數的元組(a // b, a % b)。

語法:divmod(a, b)

參數:a: 數字--被除數

b: 數字--除數

案例:

<code>divmod(11,3)
(3, 2)


divmod(20,4)
(5, 0)/<code>

21、enumerate()

描述:enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列,同時列出數據和數據下標,一般用在 for 循環當中。返回一個可以枚舉的對象,該對象的next()方法將返回一個元組。

語法:enumerate(sequence, [start=0])

參數:sequence -- 一個序列、迭代器或其他支持迭代對象。

start -- 下標起始位置。

案例:

<code>L = ['Spring', 'Summer', 'Fall', 'Winter']


enumerate(L)
<enumerate>#生成的額迭代器,無法直接查看


list(enumerate(L))#列表形式,可以看到內部結構,默認下標從0開始


[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

list(enumerate(L, start=1)) #下標從 1 開始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]


for i,v in enumerate(L):
print(i,v)
0 Spring
1 Summer
2 Fall
3 Winter


for i,v in enumerate(L,1):
print(i,v)


1 Spring
2 Summer
3 Fall
4 Winter


s = ["a","b","c"]

for i ,v in enumerate(s,2):
print(i,v)
2 a
3 b
4 c


普通的 for 循環
i = 0
seq = ['one', 'two', 'three']
for element in seq:
print (i, seq[i])
i+= 1
0 one
1 two
2 three



在看一個普通循環的對比案例
for 循環使用 enumerate

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print (i, element)

0 one
1 two
2 three


seq = ['one', 'two', 'three']
for i, element in enumerate(seq,2):
print (i, element)
2 one
3 two/<enumerate>/<code>

22、eval()

描述:將字符串str 當成有效的表達式來求值並返回計算結果取出字符串中內容

語法:eval(expression[, globals[, locals]])

參數:

  • expression -- 表達式。
  • globals -- 變量作用域,全局命名空間,如果被提供,則必須是一個字典對象。
  • locals -- 變量作用域,局部命名空間,如果被提供,可以是任何映射對象。

案例:

<code>s = "1 + 3 +5"
eval(s)
9


#要統計圖片的數量
str1 = "['https://ww1.sin5n.jpg', 'https://ww1.siqk4he.jpg']"
len(eval(str1))
2


len(str1)
5/<code>

23、exec()

描述:執行儲存在字符串或文件中的Python語句,相比於 eval,exec可以執行更復雜的 Python 代碼。

語法:exec(object, globals, locals)

參數:

  • object-- 要執行的表達式。
  • globals -- 可選。包含全局參數的字典。
  • locals -- 可選。包含局部參數的字典。

案例:

<code>執行字符串或compile方法編譯過的字符串,沒有返回值
s = "print('helloworld')"
r = compile(s,"<string>", "exec")
exec(r)
helloworld


x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20
exec(expr)
exec(expr, {'x': 1, 'y': 2})
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})

func()
60
33

34/<string>/<code>

24、filter()

描述:filter() 函數用於過濾序列,過濾掉不符合條件的元素,返回由符合條件元素組成的新列表。

該接收兩個參數,第一個為函數,第二個為序列,序列的每個元素作為參數傳遞給函數進行判斷,然後返回 True 或 False,最後將返回 True 的元素放到新列表中。

過濾器,構造一個序列,等價於:[ item for item in iterables if function(item)]

在函數中設定過濾條件,逐一循環迭代器中的元素,將返回值為True時的元素留下,形成一個filter類型數據。

語法:filter(function, iterable)

參數:

  • function -- 判斷函數。
  • iterable -- 可迭代對象。

案例:

<code>fil = filter(lambda x: x>10,[1,11,2,45,7,6,13])
fil
<filter>
list(fil)
[11, 45, 13]


def is_odd(n):
return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))
[1, 3, 5, 7, 9]/<filter>/<code>

25、float()

描述:將一個字符串或整數轉換為浮點數

語法:class float([x])

參數:x -- 整數或字符串

案例:

<code>float(3)
3.0


float('123') # 字符串
123.0/<code>

26、format()

描述:Python2.6 開始,新增了一種格式化字符串的函數 str.format(),它增強了字符串格式化的功能。基本語法是通過 {}: 來代替以前的 % 。使用format()來格式化字符串時,使用在字符串中使用{}作為佔位符,佔位符的內容將引用format()中的參數進行替換。可以是位置參數、命名參數或者兼而有之。

format 函數可以接受不限個參數,位置可以不按順序。

語法:format(value, format_spec)

參數:

案例:

<code># 位置參數
'{}:您{}購買的{}到了!請下樓取快遞。'.format('快遞小哥','淘寶','快遞')

'快遞小哥:您淘寶購買的快遞到了!請下樓取快遞。'




#給批量客戶發短息
n_list=['馬雲','馬化騰','麻子','小紅','李彥宏','二狗子']
for name in n_list:
print('{0}:您淘寶購買的快遞到了!請下樓取快遞!'.format(name))
馬雲:您淘寶購買的快遞到了!請下樓取快遞!
馬化騰:您淘寶購買的快遞到了!請下樓取快遞!
麻子:您淘寶購買的快遞到了!請下樓取快遞!
小紅:您淘寶購買的快遞到了!請下樓取快遞!
李彥宏:您淘寶購買的快遞到了!請下樓取快遞!
二狗子:您淘寶購買的快遞到了!請下樓取快遞!

#名字進行填充
for n in n_list:
print('{0}:您淘寶購買的快遞到了!請下樓取快遞!'.format(n.center(3,'*')))

*馬雲:您淘寶購買的快遞到了!請下樓取快遞!
馬化騰:您淘寶購買的快遞到了!請下樓取快遞!
*麻子:您淘寶購買的快遞到了!請下樓取快遞!
*小紅:您淘寶購買的快遞到了!請下樓取快遞!

李彥宏:您淘寶購買的快遞到了!請下樓取快遞!
二狗子:您淘寶購買的快遞到了!請下樓取快遞!


'{0}, {1} and {2}'.format('gao','fu','shuai')
'gao, fu and shuai'


x=3
y=5
'{0}+{1}={2}'.format(x,y,x+y)


# 命名參數
'{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai')
'gao, fu and shuai'


# 混合位置參數、命名參數
'{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao')
'fu, shuai and gao'


#for循環進行批量處理
["vec_{0}".format(i) for i in range(0,5)]
['vec_0', 'vec_1', 'vec_2', 'vec_3', 'vec_4']


['f_{}'.format(r) for r in list('abcde')]
['f_a', 'f_b', 'f_c', 'f_d',/<code>

27、frozenset()

描述:frozenset() 返回一個凍結的集合,凍結後集合不能再添加或刪除任何元素。

語法:class frozenset([iterable])

參數:iterable -- 可迭代的對象,比如列表、字典、元組等等。

案例:

<code>創建一個不可修改的集合。
frozenset([1,1,3,2,3])
frozenset({1, 2, 3})/<code>

28、getattr()

描述:獲取對象的屬性

語法:getattr(object, name[, default])

參數:

  • object -- 對象。
  • name -- 字符串,對象屬性。
  • default -- 默認返回值,如果不提供該參數,在沒有對應屬性時,將觸發 AttributeError。

案例:

<code>class Age(object):
age = 1

my_a = Age()
getattr(my_a, 'age') # 獲取屬性 bar 值
1
getattr(my_a, 'age1')
'Age' object has no attribute 'age1'/<code>


29、gobals()

描述: 函數會以字典類型返回當前位置的全部全局變量。

語法:globals()

參數:無

案例:

<code>a='runoob'
print(globals()) # globals 函數返回一個全局變量的字典,包括所有導入的變量。
/<code>

30、hasattr()

描述:函數用於判斷對象是否包含對應的屬性。

語法:hasattr(object, name)

參數:

  • object -- 對象。
  • name -- 字符串,屬性名。

案例:

<code>class Coordinate:
x = 10
y = -5
z = 0

point1 = Coordinate()
print(hasattr(point1, 'x'))
True
print(hasattr(point1, 'y'))
True
print(hasattr(point1, 'z'))
True
print(hasattr(point1, 'no')) # 沒有該屬性
False/<code>

31、hash()

描述:返回對象的哈希值

語法:hash(object)

參數:object -- 對象;

案例:

<code>hash() 函數可以應用於數字、字符串和對象,不能直接應用於 list、set、dictionary。

在 hash() 對對象使用時,所得的結果不僅和對象的內容有關,還和對象的 id(),也就是內存地址有關。

class Test:
def __init__(self, i):
self.i = i
for i in range(10):
t = Test(1)
print(hash(t), id(t))


hash(point1)
16294976


hash('返回對象的哈希值')
4919828709165481160


hash() 函數的用途
hash() 函數的對象字符不管有多長,返回的 hash 值都是固定長度的,也用於校驗程序在傳輸過程中
是否被第三方(木馬)修改,如果程序(字符)在傳輸過程中被修改hash值即發生變化,如果沒有被

修改,則 hash 值和原始的 hash 值吻合,只要驗證 hash 值是否匹配即可驗證程序是否帶木馬(病毒)。

name1='正常程序代碼'
name2='正常程序代碼帶病毒'

print(hash(name1)) # -3048480827538126659
print(hash(name2)) # -9065726187242961328/<code>

32、help()

描述:返回對象的幫助文檔

語法:help([object])

參數:object -- 對象

案例:

<code>help('sys')             # 查看 sys 模塊的幫助
help('str') # 查看 str 數據類型的幫助
a = [1,2,3]
help(a) # 查看列表 list 幫助信息

help(a.append) # 顯示list的append方法的幫助

/<code>

33 、id()

描述:id() 函數返回對象的唯一標識符,標識符是一個整數。CPython 中 id() 函數用於獲取對象的內存地址。

語法:id([object])

參數:object -- 對象。

案例:

<code>返回對象的內存地址
a = 'runoob'
id(a)
260316720/<code>

34、input()

描述:Python3.x 中 input() 函數接受一個標準輸入數據,返回為 string 類型。獲取用戶輸入內容

語法:input([prompt])

參數:prompt: 提示信息

案例:

<code>a = input("input:")
input:1234
print(a)
123/<code>

35、int()

描述:int() 函數用於將一個字符串或數字轉換為整型。 x可能為字符串或數值,將x 轉換為一個普通整數。如果參數是字符串,那麼它可能包含符號和小數點。如果超出了普通整數的表示範圍,一個長整數被返回。

語法:int(x, base =10)

參數:

  • x -- 字符串或數字。
  • base -- 進制數,默認十進制。

案例:

<code>int('12',16)
18



int('12',10)
12/<code>

36、isinstance()

描述:isinstance() 函數來判斷一個對象是否是一個已知的類型,類似 type()。

isinstance() 與 type() 區別:

type() 不會認為子類是一種父類類型,不考慮繼承關係。

isinstance() 會認為子類是一種父類類型,考慮繼承關係。

如果要判斷兩個類型是否相同推薦使用 isinstance()。

語法:isinstance(object, classinfo)

參數:

  • object -- 實例對象。
  • classinfo -- 可以是直接或間接類名、基本類型或者由它們組成的元組。

案例:

<code>a = 2
isinstance (a,int)
True
isinstance (a,str)
False
isinstance (a,(str,int,list))#是元組中的一個返回 True
True/<code>

37、issubclass()

描述:issubclass() 方法用於判斷參數 class 是否是類型參數 classinfo 的子類。如果class是classinfo類的子類,返回True:

語法:issubclass(class, classinfo)

參數:

  • class -- 類。
  • classinfo -- 類。

案例:

<code>class A:
pass
class B(A):
pass

print(issubclass(B,A)) # 返回 True/<code>

38、iter()

描述:iter() 函數用來生成迭代器。

語法:iter(object[, sentinel])

參數:

  • object -- 支持迭代的集合對象。
  • sentinel -- 如果傳遞了第二個參數,則參數 object 必須是一個可調用的對象(如,函數),此時,iter 創建了一個迭代器對象,每次調用這個迭代器對象的__next__()方法時,都會調用 object。返回一個可迭代對象, sentinel可省略,sentinel 理解為迭代對象的哨兵,一旦迭代到此元素,立即終止:

案例:

<code>lst = [1,3,5]
iter(lst)
<list>


for i in iter(lst):
print(i)
1

3
5 /<list>/<code>

39、len()

描述:len() 函數返回對象(字符、列表、元組等)長度或項目個數。

語法:len(s)

參數:s -- 對象。

案例:

<code>#字典的長度
dic = {'a':1,'b':3}
len(dic)
2


#字符串長度
s='aasdf'
len(s)
5


#列表元素個數
l = [1,2,3,4,5]
len(l)
/<code>

40、list()

描述:list() 函數創建列表或者用於將元組轉換為列表。

語法:list( tup )

參數:tup -- 要轉換為列表的元組。

案例:

<code>atuple = (123, 'xyz', 'zara', 'abc')
aList = list(atuple)


aList
[123, 'xyz', 'zara', 'abc']/<code>


41、map()

描述:map() 會根據提供的函數對指定序列做映射。返回一個將 function 應用於 iterable 中每一項並輸出其結果的迭代器

語法:map(function, iterable, ...)

參數:

  • function -- 函數
  • iterable -- 一個或多個序列

案例:

<code>def square(x) :            # 計算平方數
return x ** 2
list(map(square, [1,2,3,4,5])) # 計算列表各個元素的平方
[1, 4, 9, 16, 25]


list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函數
[1, 4, 9, 16, 25]


# 提供了兩個列表,對相同位置的列表數據進行相加
list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
[3, 7, 11, 15, 19]


list(map(lambda x: x%2==1, [1,3,2,4,1]))
[True, True, False, False, Tru/<code>

42、max()

描述:max() 方法返回給定參數的最大值,參數可以為序列。

語法:max( x, y, z, .... )

參數:

  • x -- 數值表達式。
  • y -- 數值表達式。
  • z -- 數值表達式。

案例:

<code>最大值:
max(3,1,4,2,1)
4


di = {'a':3,'b1':1,'c':4}
max(di)
'c'/<code>

43、min()

描述:min() 方法返回給定參數的最小值,參數可以為序列。

語法:min( x, y, z, .... )

參數:

  • x -- 數值表達式。
  • y -- 數值表達式。
  • z -- 數值表達式。

案例:

<code>min(80, 100, 1000)
80
min([80, 100, 1000])
80/<code>

44、memoryview()

描述:memoryview() 函數返回給定參數的內存查看對象(Momory view)。返回由給定實參創建的“內存視圖”對象, Python 代碼訪問一個對象的內部數據,只要該對象支持緩衝區協議 而無需進行拷貝

語法:memoryview(obj)

參數:obj -- 對象

案例:

<code>v = memoryview(bytearray("abcefg", 'utf-8'))
v[1]
98
v[-1]
98
v[1:4]
<memory>
v[1:4].tobytes()
b'bce'/<memory>/<code>

45、next()

描述:next() 返回迭代器的下一個項目。next() 函數要和生成迭代器的iter() 函數一起使用。

語法:next(iterator[, default])

參數:

  • iterator -- 可迭代對象
  • default -- 可選,用於設置在沒有下一個元素時返回該默認值,如果不設置,又沒有下一個元素則會觸發 StopIteration 異常。

案例:

<code>it = iter([5,3,4,1])
next(it)

5

next(it)
3

next(it)
4/<code>

46、object()

描述:Object類是Python中所有類的基類,如果定義一個類時沒有指定繼承哪個類,則默認繼承object類。返回一個沒有特徵的新對象。object 是所有類的基類。

語法:object()

參數:無

案例:無

47、open()

描述:open() 函數用於打開一個文件,創建一個 file 對象,相關的方法才可以調用它進行讀寫。

語法:open(name[, mode[, buffering]])

參數:

  • name : 一個包含了你要訪問的文件名稱的字符串值。
  • mode : mode 決定了打開文件的模式:只讀,寫入,追加等。所有可取值見如下的完全列表。這個參數是非強制的,默認文件訪問模式為只讀(r)。
  • buffering : 如果 buffering 的值被設為 0,就不會有寄存。如果 buffering 的值取 1,訪問文件時會寄存行。如果將 buffering 的值設為大於 1 的整數,表明了這就是的寄存區的緩衝大小。如果取負值,寄存區的緩衝大小則為系統默認。

模式

描述

r

以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。

rb

以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。

r+

打開一個文件用於讀寫。文件指針將會放在文件的開頭。

rb+

以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。

w

打開一個文件只用於寫入。如果該文件已存在則打開文件,並從開頭開始編輯,即原有內容會被刪除。如果該文件不存在,創建新文件。

wb

以二進制格式打開一個文件只用於寫入。如果該文件已存在則打開文件,並從開頭開始編輯,即原有內容會被刪除。如果該文件不存在,創建新文件。

w+

打開一個文件用於讀寫。如果該文件已存在則打開文件,並從開頭開始編輯,即原有內容會被刪除。如果該文件不存在,創建新文件。

wb+

以二進制格式打開一個文件用於讀寫。如果該文件已存在則打開文件,並從開頭開始編輯,即原有內容會被刪除。如果該文件不存在,創建新文件。

a

打開一個文件用於追加。如果該文件已存在,文件指針將會放在文件的結尾。也就是說,新的內容將會被寫入到已有內容之後。如果該文件不存在,創建新文件進行寫入。

ab

以二進制格式打開一個文件用於追加。如果該文件已存在,文件指針將會放在文件的結尾。也就是說,新的內容將會被寫入到已有內容之後。如果該文件不存在,創建新文件進行寫入。

a+

打開一個文件用於讀寫。如果該文件已存在,文件指針將會放在文件的結尾。文件打開時會是追加模式。如果該文件不存在,創建新文件用於讀寫。

ab+

以二進制格式打開一個文件用於追加。如果該文件已存在,文件指針將會放在文件的結尾。如果該文件不存在,創建新文件用於讀寫。

file 對象方法

file.read([size]):size 未指定則返回整個文件,如果文件大小 >2 倍內存則有問題,f.read()讀到文件尾時返回""(空字串)。

file.readline():返回一行。

file.readlines([size]) :返回包含size行的列表, size 未指定則返回全部行。

for line in f: print(line ):通過迭代器訪問。

f.write("hello\\n"):如果要寫入字符串以外的數據,先將他轉換為字符串。

f.tell():返回一個整數,表示當前文件指針的位置(就是到文件頭的比特數)。

f.seek(偏移量,[起始位置]):用來移動文件指針。

    • 偏移量: 單位為比特,可正可負
    • 起始位置: 0 - 文件頭, 默認值; 1 - 當前位置; 2 - 文件尾

f.close() 關閉文件

案例:

<code>f=open('test.txt',encoding='utf-8')   #打開文件
data=f.read()#文件操作
print(data)
f.close() #關閉文件


/<code>

48、pow()

描述:pow() 方法返回 xy(x的y次方) 的值。函數是計算x的y次方,如果z在存在,則再對結果進行取模,其結果等效於pow(x,y) %z

語法:pow(x, y[, z])

參數:

  • x -- 數值表達式。
  • y -- 數值表達式。
  • z -- 數值表達式。

案例:

<code>pow(10, 2)
100


pow(4,3,5)
4
等價於4**3%5
/<code>


49、print()

描述:打印對象,此函數不解釋

語法:

參數:

案例:


50、property()

描述:property()

函數的作用是在新式類中返回屬性值。

語法:class property([fget[, fset[, fdel[, doc]]]])

參數:

  • fget -- 獲取屬性值的函數
  • fset -- 設置屬性值的函數
  • fdel -- 刪除屬性值函數
  • doc -- 屬性描述信息

案例:

<code>暫不解釋/<code>

51、range()

描述:range() 函數可創建一個整數列表,一般用在 for 循環中。

語法:range(start, stop[, step])

參數:

  • start: 計數從 start 開始。默認是從 0 開始。例如range(5)等價於range(0, 5);
  • stop: 計數到 stop 結束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]沒有5
  • step:步長,默認為1。例如:range(0, 5) 等價於 range(0, 5, 1)

案例:

<code>list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list(range(1, 11)) # 從 1 開始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]


for i in range(5):
print(i)
0
1
2
3
/<code>

52、reversed()

描述:

reversed 函數返回一個反轉的迭代器。

語法:reversed(seq)

參數:seq -- 要轉換的序列,可以是 tuple, string, list 或 range。

案例:

<code>#反轉列表
rev = reversed([1,4,2,3,1])
list(rev)
[1, 3, 2, 4, 1]


for i in rev:
print(i)
1
3
2
4
1


#反轉字符串
rev = reversed('我愛中國')
list(rev)
['國', '中', '愛', '我']


for i in rev:
print(i)


愛/<code>

53、round()

描述:round() 函數返回浮點數x的四捨五入值。

語法:round( x [, n] )

參數:

  • x -- 數值表達式。
  • n --代表小數點後保留幾位

案例:

<code>round(10.0222222, 3)
10.022

/<code>

54、set()

描述:set() 函數創建一個無序不重複元素集,可進行關係測試,刪除重複數據,還可以計算交集、差集、並集等。

語法:

class set([iterable])

參數:iterable -- 可迭代對象對象;

案例:

<code>#返回一個set對象,可實現去重:
a = [1,4,2,3,1]
set(a)
{1, 2, 3, 4}/<code>

55、slice()

描述:slice() 函數實現切片對象,主要用在切片操作函數里的參數傳遞。返回一個表示由 range(start, stop, step) 所指定索引集的 slice對象

語法:

class slice(stop)

class slice(start, stop[, step])

參數:

  • start -- 起始位置
  • stop -- 結束位置
  • step -- 間距

案例:

<code>a = [1,4,2,3,1]
a[slice(0,5,2)] #等價於a[0:5:2]
[1, 2, 1]

/<code>

56、sorted()

描述:sorted() 函數對所有可迭代的對象進行排序操作。

sort 與 sorted 區別:

sort 是應用在 list 上的方法,sorted 可以對所有可迭代的對象進行排序操作;list 的 sort 方法返回的是對已經存在的列表進行操作,無返回值,而內建函數 sorted 方法返回的是一個新的 list,而不是在原來的基礎上進行的操作。

語法:sorted(iterable, key=None, reverse=False)#cmp 3.x已經沒有了

參數:

  • iterable -- 可迭代對象。
  • key -- 主要是用來進行比較的元素,只有一個參數,具體的函數的參數就是取自於可迭代對象中,指定可迭代對象中的一個元素來進行排序。
  • reverse -- 排序規則,reverse = True 降序 , reverse = False 升序(默認)。

案例:

<code>a = [5,7,6,3,4,1,2]
b = sorted(a) # 保留原列表
a
[5, 7, 6, 3, 4, 1, 2]
b
[1, 2, 3, 4, 5, 6, 7]

#利用key
L=[('b',2),('a',1),('c',3),('d',4)]


sorted(L, key=lambda x:x[1])
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]


#按年齡排序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2])
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]


#按降序
sorted(students, key=lambda s: s[2], reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

#降序排列
a = [1,4,2,3,1]
sorted(a,reverse=True)
[4, 3, 2, 1, 1]/<code>

57、staticmethod

描述:staticmethod 返回函數的靜態方法。該方法不強制要求傳遞參數,如下聲明一個靜態方法:

語法:

class C(object):

@staticmethod

def f(arg1, arg2, ...):

...

以上實例聲明瞭靜態方法 f,從而可以實現實例化使用 C().f(),當然也可以不實例化調用該方法 C.f()

參數:

案例:

<code>class C(object):
@staticmethod
def f():
print('runoob');

C.f(); # 靜態方法無需實例化
cobj = C()
cobj.f() # 也可以實例化後調用/<code>


58 、str()

描述:返回一個 str版本的 object,str 是內置字符串 class

語法:class str(object='')

參數:object -- 對象。

案例:

<code>dict = {'runoob': 'runoob.com', 'google': 'google.com'};
str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"/<code>


59、sum()

描述:sum() 方法對系列進行求和計算。

語法:

sum(iterable[, start])

參數:

  • iterable -- 可迭代對象,如:列表、元組、集合。
  • start -- 指定相加的參數,如果沒有設置這個值,默認為0。

案例:

<code>a = [1,4,2,3,1]
sum(a)
11

sum(a,10) #求和的初始值為10
21/<code>

60、super()

描述:super() 函數是用於調用父類(超類)的一個方法。

super 是用來解決多重繼承問題的,直接用類名調用父類方法在使用單繼承的時候沒問題,但是如果使用多繼承,會涉及到查找順序(MRO)、重複調用(鑽石繼承)等種種問題。

MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。

語法:super(type[, object-or-type])

參數:

  • type -- 類。
  • object-or-type -- 類,一般是 self

案例:

<code>class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3
3/<code>


61、tuple()

描述: 元組 tuple() 函數將列表轉換為元組。

語法:tuple( iterable )

參數:iterable -- 要轉換為元組的可迭代序列。

案例:

<code>tuple([1,2,3,4])
(1, 2, 3, 4)

tuple({'a':2,'b':4}) #針對字典 會返回字典的key組成的tuple
('a', 'b')/<code>

62、type()

描述:type() 函數如果你只有第一個參數則返回對象的類型,三個參數返回新的類型對象。

isinstance() 與 type() 區別:

  • type() 不會認為子類是一種父類類型,不考慮繼承關係。
  • isinstance() 會認為子類是一種父類類型,考慮繼承關係。

如果要判斷兩個類型是否相同推薦使用 isinstance()。

語法:

type(object)

type(name, bases, dict)

參數:

  • name -- 類的名稱。
  • bases -- 基類的元組。
  • dict -- 字典,類內定義的命名空間變量。

案例:

<code>type([2])
list


type({0:'zero'})
dict


x = 1
type( x ) == int # 判斷類型是否相等
True

# 三個參數
class X(object):
a = 1


X = type('X', (object,), dict(a=1)) # 產生一個新的類型 X
X
__main_/<code>


63、zip()

描述:zip() 函數用於將可迭代的對象作為參數,將對象中對應的元素打包成一個個元組,然後返回由這些元組組成的對象,這樣做的好處是節約了不少的內存。

我們可以使用 list() 轉換來輸出列表。

如果各個迭代器的元素個數不一致,則返回列表長度與最短的對象相同,利用 * 號操作符,可以將元組解壓為列表。

語法:zip([iterable, ...])

參數:iterable 一個或多個迭代器

案例:

<code>創建一個聚合了來自每個可迭代對象中的元素的迭代器: 

x = [3,2,1]
y = [4,5,6]
list(zip(y,x))
[(4, 3), (5, 2), (6, 1)]


#搭配for循環,數字與字符串組合
a = range(5)
b = list('abcde')
[str(y) + str(x) for x,y in zip(a,b)]
['a0', 'b1', 'c2', 'd3', 'e4']


list1 = [2,3,4]
list2 = [5,6,7]
for x,y in zip(list1,list2):
print(x,y,'--',x*y)
2 5 -- 10
3 6 -- 18
4 7 -- 28


#元素個數與最短的列表一致
list(zip(x,b))
[(3, 'a'), (2, 'b'), (1, 'c')]


#與 zip 相反,zip(* ) 可理解為解壓,返回二維矩陣式
a1, a2 = zip(*zip(a,b))
a1
(0, 1, 2, 3, 4)
a2
('a', 'b', 'c', 'd', 'e'
/<code>


超級詳解|Python 63個內置函數


分享到:


相關文章: