python基礎-內置函數、作用域、閉包、遞歸

1.常見的內置函數

常見的內置函數:

查看內置函數：

print(dir(__builtins__))

常見函數

type() 數據類型

print() 打印

help()查看方法詳細用法

id() 查看內存地址

range() 求值范圍

len 求長度

min 求最小值

max 求最大值

sorted 排序

reversed 反向

sum 求和

abs 取絕對值的

round 四舍五入

進制轉換函數:

bin() 轉換為二進制

oct() 轉換為八進制

hex() 轉換為十六進制

ord() 將字符轉換成對應的ASCII碼值

chr() 將ASCII碼值轉換成對應的字符

補充：

#1.enumerate() #返回一個可以枚舉的對象

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

>>> li

['a', 'c', 'b']

>>> type(enumerate(li)) #枚舉類型

>>> list(enumerate(li))

[(0, 'a'), (1, 'c'), (2, 'b')]

#2.filter() #過濾器

li=[1,2,3,6,7,8]

def test(x):

return x>5

>>> list(filter(test,li)) #過濾大于5的

[6, 7, 8]

#3.map() #加工。對于參數iterable中的每個元素都應用fuction函數，并返回一個map對象

li=[1,2,3,6,7,8]

>>> list(map(lambda x:x+1,li)) #所有元素加上1

[2, 3, 4, 7, 8, 9]

#4.zip() #將對象逐一配對

>>> li=[1,2,3]

>>> li2=["a","b","c"]

>>> list(zip(li,li2))

[(1, 'a'), (2, 'b'), (3, 'c')]

>>> dict(zip(li,li2)) #轉化成字典

{1: 'a', 2: 'b', 3: 'c'}

2.函數內變量的作用域

變量的作用域與其定義的方式有關：

局部變量： 變量在函數內部定義，則變量的作用域在函數內部

全局變量：變量在函數外部定義的，則變量的作用域是全局

a=3#全局變量

def test():

b=5 #局部變量

#global：用來在函數或其他局部作用域中，聲明全局變量。 (作用于全局)

#第一種：函數內部改變全局變量

a=3#全局變量

def test():

global a#全局聲明

a+=1#需要修改全局變量，需要加global聲明

print(a)

#第二種：函數外調用函數內部變量

def test():

global b

b=4

b+=1

print(b)

>>> test()

5

>>> b

5

#nonlocal：用來在函數或其他作用域中，聲明外層(非全局)變量。(作用于局部)

#內切函數

def test():

c=2

print("外層",c)

def test1():

d=5

print("內層",d)

test1()

#nonlocal聲明

def test():

c=2

print("外層C=",c)

def test1():

d=5

print("內層D=",d)

nonlocal c #內層局部修改外層局部的時候

c+=1

print("內層C=",c)

test1()

使用global情況：

全局變量可以在函數內部訪問，但是不能改變

如果在函數內部想修改全局變量，可以用 global 來修飾變量

局部變量只能在局部進行訪問和修改。

如果在函數外部，想訪問局部變量，也可以用 global，將局部變量聲明為全局變量

使用nonlocal的情況：

當里層局部，需要修改外層局部時，需要使用nonlocal。 (如嵌套函數)

總結：

global ：函數中，需要修改全局變量時，用global

nonlocal：當里層局部，需要修改外層局部時，需要使用nonlocal。

(局部調用局部，使用nonlocal)

3.內嵌函數和閉包

#內嵌函數： 在函數內部定義函數，就是函數里面嵌套函數

閉包：一個閉包就是你調用了一個函數A，這個函數A返回了一個函數B給你。這個返回的函數B就叫做閉包。(但是B函數，一定要是嵌套在函數A里面) 。你在調用函數A的時候傳遞的參數就是自由變量。

總結：一個函數里面嵌套一個函數，調用外面這個函數，就返回里面嵌套的函數。

#閉包

def test(name):

def test1(age):

print("name=%s,age=%s"%(name,age))

return test1

>>> test("a")("15")

name=a,age=15

4.遞歸函數

遞歸： 函數調用自己本身

'''

例題：有5個人坐在一起，問第五個人多少歲？他說比第4個人大2歲。

問第4個人歲數，他說比第3個人大2歲。

問第三個人，又說比第2人大兩歲。

問第2個人，說比第一個人大兩歲。

最后問第一個人，他說是10歲。

請問第五個人多少歲？

'''

#遞歸函數

def age(n):

if(n==1):

return 10

else:

return age(n-1)+2

a=age(5)

遞歸的核心：

1.遞歸推導式

2.遞歸終止條件

5.python3函數大全

#1.abs() 絕對值或復數的模

abs(-1) >>> 1

#2.all() 接受一個迭代器，如果迭代器的所有元素都為真，那么返回True，否則返回False

all([1,2,3]) >>> True

#3.any() 接受一個迭代器，如果迭代器里有一個元素為真，那么返回True,否則返回False

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

#4.ascii() 調用對象的__repr__()方法，獲得該方法的返回值

ascii('ab') >>> "'ab'"

#5.bin() 將十進制轉換為二進制

bin(10) >>> '0b1010'

#6.bool() 測試一個對象是True還是False

bool([]) >>> False

#7.bytearray() 字節數組 字節是計算機的語言，字符串是人類語言，它們之間通過編碼表形成一一對應的關系

a = 'python'

>>> bytearray(a,'utf8')

bytearray(b'python')

>>> list(bytearray(a,'utf8'))

[112, 121, 116, 104, 111, 110]

>>> b'python'[0]

112

#8.bytes() 將一個字符串轉換成字節類型

st = 'python'

a = bytes(st,encoding='utf-8')

>>> a

b'python'

#9.callable() 判斷對象是否可以被調用，能被調用的對象就是一個callables對象，比如函數

callable(str) >>> True

#10.chr() 查看十進制數對應的ASCII字符

chr(10) >>> '\n'

#11.classmethod() 用來指定一個方法為類的方法，由類直接調用執行，只有一個cls參數,執行類的方法時，自動將調用該方法的類賦值給cls.沒有此參數指定的類的方法為實例方法

#12.compile() 將字符串編譯成python能識別或可以執行的代碼，也可以將文字讀成字符串再編譯

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

'''

將source編譯為代碼或者AST對象。代碼對象能過通過exec語句來執行或者eval()進行求值。

參數source：字符串或者AST(abstract syntax trees)對象。

參數filename：代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。

參數model：指定編譯代碼的種類。可以指定'exec', 'eval', 'single'。

參數flag和dont_inherit：這兩個參數為可選參數

'''

st = 'python'

r = compile(st,'','exec')

>>> r at 0x000001841735E810, file "", line 1>

#13.complex() 創建一個值為real + imag * j的復數或者轉化一個字符串或數為復數。如果第一個參數是字符串，則不需要指定第二個參數

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

complex('12') >>> (12+0j)

#14.copyright() 版權

#15.credits() 支持

#16.delattr() 刪除對象的屬性

#17.dict() 創建數據字典

dict(a=1) >>> {'a': 1}

#18.dir() 不帶參數時返回當前范圍內的變量，方法和定義的類型列表，帶參數時返回參數的屬性，方法列表

#19.divmod() 分別取商和余數

divmod(5,2) >>> (2, 1)

#20.enumerate() 返回一個可以枚舉的對象，該對象的next()方法將返回一個元組

li = ['a','b','c']

>>> enumerate(li)

>>> list(enumerate(li))

[(0, 'a'), (1, 'b'), (2, 'c')]

#21.eval() 1.將字符串str當成有效的表達式來求值并返回計算結果2.取出字符串中內容

>>> eval("{'a':1}")

{'a': 1}

>>> eval('1 + 2 + 3')

6

#22.exec() 執行字符串或complie方法編譯過的字符串，沒有返回值

>>> st = '''

z = 4

a = x + y + z

print(a)

'''

>>> exec(st,{'x':0,'y':0},{'y':10,'z':10})

14

>>> st = '''

a = x + y + z

print(a)

'''

>>> exec(st,{'x':0,'y':0},{'y':10,'z':10})

20

#23.exit() 退出

#24.filter() 過濾器，構造一個序列，等價于[ item for item in iterables if function(item)]，在函數中設定過濾條件，逐一循環迭代器中的元素，將返回值為True時的元素留下，形成一個filter類型數據

'''

filter(function or None, iterable) --> filter object

參數function：返回值為True或False的函數，可以為None

參數iterable：序列或可迭代對象

'''

>>> filter(lambda x:x+1,[1,2])

>>> list(filter(lambda x:x+1,[1,2]))

[1, 2]

>>> filter(lambda x:x>10,[9,12])

>>> list(filter(lambda x:x>10,[9,12]))

[12]

#25.float() 講一個字符串或整數轉換為浮點數

>>> float(11)

11.0

#26.format() 格式化輸出字符串，format(value, format_spec)實質上是調用了value的__format__(format_spec)方法

>>> format(12)

'12'

>>> format(12,'5d')

' 12'

#27.frozenset() 創建一個不可修改的集合

'''

frozenset([iterable])

set和frozenset最本質的區別是前者是可變的，后者是不可變的。當集合對象會被改變時(例如刪除，添加元素)，只能使用set，

一般來說使用fronzet的地方都可以使用set

'''

>>> frozenset([1,2,3])

frozenset({1, 2, 3})

#28.getattr() 獲取對象的屬性

'''

getattr(object, name[, default]) -> value

獲取對象object名為name的特性，如果object不包含名為name的特性，將會拋出AttributeError異常；如果不包含名為name的特性

且提供default參數，將返回default。

參數object：對象

參數name：對象的特性名

參數default：缺省返回值

'''

#29.globals() 返回一個描述當前全局變量的字典

>>> st = 'python'

>>> globals()

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': b'python', 'li': ['a', 'b', 'c'], 'i': 'zip', 'st': 'python', 'r': at 0x000001841735E810, file "", line 1>}

#30.hasattr() hasattr(object，name)判斷對象object是否包含名為name的特性(hasattr是通過調用getattr(object，name))是否拋出異常來實現的

>>> hasattr(list,'pop')

True

#31.hash() 哈希值hash(object)注意：可哈希的即不可變數據類型，不可哈希即可變數據類型

'''

如果對象object為哈希表類型，返回對象object的哈希值。哈希值為整數，在字典查找中，哈希值用于快遞比價字典的鍵。

兩個數值如果相等，則哈希值也相等

'''

>>> hash('ab')

2766084925433962145

>>> hash(12)

12

#32.help() 返回對象的幫助文檔

'''

調用內建的幫助系統，如果不包含參數，交互式幫助系統將在控制臺啟動。如果參數為字串，則可以是模塊，類，方法等名稱，并且幫助頁面將會在控制臺打印。參數也可以 為任意對象

'''

#33.hex() 將十進制轉換為十六進制

hex(16) >>> '0x10'

#34.id() 返回對象的內存地址

>>> id(1)

1726850144

#35.input() 獲取用戶輸入內容

>>> input('請輸入：')

請輸入：abc

'abc'

#36.int() 將一個字符串或數值轉換為一個普通整數

'''

int(x=0) -> integer

int(x, base=10) -> integer

如果參數是字符串，那么它可能包含符號和小數點。參數base表示轉換的基數(默認是10進制)。

它可以是[2,36]范圍內的值，或者0。如果是0，系統將根據字符串內容來解析。

如果提供了參數base，但參數x并不是一個字符串，將拋出TypeError異常；

否則，參數x必須是數值(普通整數，長整數，浮點數)。通過舍去小數點來轉換浮點數。

如果超出了普通整數的表示范圍，一個長整數被返回。

如果沒有提供參數，函數返回0

'''

>>> int('12')

12

#37.isinstance() 檢查對象是否是類的對象，返回True或False

>>> isinstance('a',str)

True

#38.issubclass() 檢查一個類是否是另一個類的子類。返回True或False issubclass(sub, super)

>>> issubclass(str,object)

True

#39.iter() 返回一個iterator對象

'''

iter(iterable) -> iterator

iter(callable, sentinel) -> iterator

'''

>>> a = iter([1,2,3])

>>> next(a)

1

>>> a = iter([1,2,3,4,5])

>>> b = iter(a.__next__,3)

>>> next(b)

1

>>> next(b)

2

>>> next(b)

Traceback (most recent call last):

File "", line 1, in

next(b)

StopIteration

#40.len() 返回對象長度，參數可以是序列類型(字符串，元組或列表)或映射類型(如字典)

>>> len([1,2,3])

3

#41.license() 軟件的歷史

#42.list() 列表構造函數

>>> list('abc')

['a', 'b', 'c']

#43.locals() 打印當前可用的局部變量的字典

>>> locals()

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': , 'b': }

#44.map() 對于參數iterable中的每個元素都應用fuction函數，并將結果作為列表返回

'''

如果有多個iterable參數，那么fuction函數必須接收多個參數，這些iterable中相同索引處的元素將并行的作為function函數的參數。

如果一個iterable中元素的個數比其他少，那么將用None來擴展改iterable使元素個數一致。

如果有多個iterable且function為None，map()將返回由元組組成的列表，每個元組包含所有iterable中對應索引處值。

'''

>>> li = [1,2,3]

>>> a = map(str,li)

>>> a

>>> list(a)

['1', '2', '3']

#45.max() 返回給定元素里最大值

>>> max(1,2,3,4)

4

#46.memoryview() 本函數是返回對象obj的內存查看對象。所謂內存查看對象，就是對象符合緩沖區協議的對象，為了給別的代碼使用緩沖區里的數據，而不必拷貝，就可以直接使用

>>> memoryview(b'aabc')

>>> list(memoryview(b'abc'))

[97, 98, 99]

#47.min() 返回給定元素里最小值 具體用法跟max()相同

>>> min([1,2,3,4])

1

#48.next() 返回一個可迭代數據結構(如列表)中的下一項

>>> a = iter([1,2,3,4])

>>> next(a)

1

#49.object() 獲取一個新的，無特性(geatureless)對象。Object是所有類的基類。它提供的方法將在所有的類型實例中共享

#50.oct() 將十進制轉換為八進制

oct(8) >>> '0o10'

#51.open() 打開文件 open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

#52.ord() 查看某個ascii對應的十進制數

ord('a') >>> 97

#53.pow() 冪函數pow(x, y, z=None, /) 冪函數,表示取x得y次冪，如果存在第三個參數z，則表示乘方結果對第三個參數取余

>>> pow(2,8)

256

>>> pow(2,8,3)

1

#54.print() 輸出函數

#55.property() 類方法可以當作屬性調用

#56.quit() 退出

#57.range() 根據需要生成一個指定范圍的數字，可以提供你需要的控制來迭代指定的次數

>>> list(range(10))

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

#58.repr() 將任意值轉換為字符串，供計時器讀取的形式

#59.reversed() 反轉，逆序對象

#60.round() 四舍五入

>>> round(1.556,2)

1.56

#61.set() 將對象轉換成集合

#62.setattr() 與getattr()相對應

#63.slice() 切片功能

>>> li = [1,2,3,4,5,6]

>>> slice(1,3,li)

slice(1, 3, [1, 2, 3, 4, 5, 6])

#64.sorted() 排序

>>> li

[1, 2, 3, 4, 5, 6]

>>> sorted(li,key = int,reverse = True)

[6, 5, 4, 3, 2, 1]

#65.staticmethod() 方便將外部函數集成到類體中,美化代碼結構,重點在不需要類實例化的情況下調用方法

#66.str() 將字符類型/數值類型等轉換為字符串類型

>>> str(12)

'12'

#67.sum() 求和

>>> sum([1,2])

3

#68.super() 調用父類的方法

#69.tuple() 元組構造函數

>>> tuple([1,2,3])

(1, 2, 3)

#70.type() 顯示對象所屬的類型

>>> type(1)

#71.vars() 本函數是實現返回對象object的屬性和屬性值的字典對象。如果默認不輸入參數，就打印當前調用位置的屬性和屬性值，相當于locals()的功能。如果有參數輸入，就只打印這個參數相應的屬性和屬性值

>>> class ob:

i = 1

>>> vars(ob)

mappingproxy({'__module__': '__main__', 'i': 1, '__dict__': , '__weakref__': , '__doc__': None})

>>> a = ob()

>>> vars(a)

{}

#72.zip() 將對象逐一配對

>>> li = [1,2,3]

>>> tu = ('a','b','c')

>>> zip(tu,li)

>>> list(zip(tu,li))

[('a', 1), ('b', 2), ('c', 3)]

>>> dict(zip(tu,li))

{'a': 1, 'b': 2, 'c': 3}

如何獲取的：

>>> li = dir(__builtins__)

>>> li = li[li.index('abs'):]

>>> for i in range(len(li)):

print('#%s.%s()'%(i+1,li[i]))

總結

以上是生活随笔為你收集整理的python函数作用域与闭包_python基础-08-内置函数、作用域、闭包、递归的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。