一篇掌握python內置函數詳解(全面且有演示)

本編研究下python的內置函數(屬性/魔法方法下一篇研究)

基於python3的版本來研究，內容雖有點比較多，只要耐心看完必定有所收穫。

本文概要

1.staticmehtod和classmethod使用和區別
2.setattr、getattr、delattr、hasattr使用
3.類型轉化：int、str、float、list、dict、tuple、iter 的使用
4.isinstance、issubclass、type的使用和區別
5.format、print、open如何使用
6.sorted、reversed、max、min、len、sum使用
7.map、filter、zip使用
8.dir、call使用

如果上面幾點問題都能回答上，那麼可以跳過本篇文章了。本篇相關文章共三連彈。(端午節在家整理，有幫助記得點個👍，就是對我最大的肯定😘😘😘)

技巧：文章內容太多如何閱讀？

先看文章的目錄(TOC)，掌握文章整體脈絡
然後走馬觀花式，通篇閱讀。如果文章有用，再細細研究；文章沒用的直接忽略，找下篇。
- 如果爲了解決問題的，解決完了再細讀
- 如果學習的，收藏起來，邊學習，邊敲代碼實踐 (別copy代碼，自己敲)
收藏完，下次用的時候，記不得了，到文章直接CTRL+F查找關鍵字

這提到鏈接收藏功能，推薦下㊙鏈接管理工具🔗 裏的【我的鏈接】可以管理自己的鏈接哦 (個人鏈接屬於私人資產，所以要註冊個賬戶才能使用哦👇👇👇)

浩瀚的網絡中，你我的相遇也是種緣分，看你天資聰慧、骨骼精奇，就送你一場大造化吧，能領悟多少就看你自己了。㊙傳承之地🙇

源碼座標

1.函數表格

這先盜用下菜鳥教程裏的內置函數表格，後面會對每個詳細介紹，並進行補充

python3官網-內置函數doc

		內置函數
abs()	divmod()	input()	open()	staticmethod()
all()	enumerate()	int()	ord()	str()
any()	eval()	isinstance()	pow()	sum()
basestring()	execfile()	issubclass()	print()	super()
bin()	file()	iter()	property()	tuple()
bool()	filter()	len()	range()	type()
bytearray()	float()	list()	raw_input()	unichr()
callable()	format()	locals()	reduce()	unicode()
chr()	frozenset()	long()	reload()	vars()
classmethod()	getattr()	map()	repr()	xrange()
cmp()	globals()	max()	reverse()	zip()
compile()	hasattr()	memoryview()	round()	import()
complex()	hash()	min()	set()
delattr()	help()	next()	setattr()
dict()	hex()	object()	slice()
dir()	id()	oct()	sorted()	exec 內置表達式

下面分類來研究下每個函數

2.數學運算類

2-1.abs

abs(x)函數返回數字的絕對值。

x: 數值表達式，可以是整數，浮點數，複數。

參數可以是整型，也可以是複數

若參數是複數，則返回複數的模

演示

class MyTestCase(unittest.TestCase):
    def test_abs(self):
        a = 3.14
        b = -7.36
        c = complex(3, 4)  # 創建一個複數
        print(abs(a))  # 3.14
        print(abs(b))  # 7.36
        print(abs(c))  # 5.0

2-2.complex

complex()函數用於創建一個值爲real + imag * j的複數或者轉化一個字符串或數爲複數。如果第一個參數爲字符串，則不需要指定第二個參數。。

real: int, long, float或字符串；
imag: int, long, float；

演示

class MyTestCase(unittest.TestCase):
    def test_complex(self):
        a = complex(3, 4)
        b = complex(1)
        c = complex('3')
        d = complex("3+4j")
        print(a) # (3+4j)
        print(b) # (1+0j)
        print(c) # (3+0j)
        print(d) # (3+4j)

2-3.divmod

divmod(a, b)函數接收兩個數字類型（非複數）參數，返回一個包含商和餘數的元組(a // b, a % b)。

a: 數字，非複數。
b: 數字，非複數。

演示

class MyTestCase(unittest.TestCase):
    def test_divmod(self):
        print(divmod(3, 2))  # (1, 1)
        print(divmod(3, -2))  # (-2, -1),
        print(divmod(-3, 2))  # (-2, 1)
        print(divmod(-3, -2))  # (1, -1)
        print(divmod(3, 1.2))  # (2.0, 0.6000000000000001)

以divmod(3, -2)來分析下：

b=-2是負數，y符號要跟b保持一致，所以y也得是負數。a、b都取正數，3/2的餘數爲1，所以y=-1

以a=3爲目標,現在y=-1了，所以我們計算出b*x=4才能和y=-1相加爲3，現在b=-2，要使得b*x=4,那麼x得爲-2

2-4.類型轉化

int、float、long、char、bool、二進制、八進制、十六進制等轉化

float()函數用於將整數和字符串轉換成浮點數。
int() 函數用於將一個字符串或數字轉換爲整型。

int(x, base=10):x爲字符串或數字；base爲進制數，默認十進制。

chr() 用一個整數作參數，返回一個對應的字符。

chr(i): i 可以是 10 進制也可以是 16 進制的形式的數字，數字範圍爲 0 到 1,114,111 (16 進製爲0x10FFFF)。

bin() 返回一個整數 int 或者長整數 long int 的二進制表示。

bin(x): x爲int 或者 long int 數字

oct() 函數將一個整數轉換成8進制字符串。

oct(x): x爲整數。

hex() 函數用於將一個指定數字轉換爲 16 進制數。

hex(x): x爲整數

bool() 函數用於將整數和字符串轉換成浮點數。

bool(x): x爲要進行轉換的參數。不寫參數默認是False

更多的ascii碼可以查aascii碼錶

演示

class MyTestCase(unittest.TestCase):
    def test_float(self):
        print(float(1))  # 1.0
        print(float(-123.6))  # -123.6
        print(float('123'))  # 123.0
        
    def test_int(self):
        print(int())  # 默認0
        print(int(2))  # 2
        print(int(2.5))  # 2
        print(int('1',2))  # 1
        print(int('10',8))  # 8
        print(int('10',10))  # 10
        print(int('10',16))  # 16
        print(int('0x10',16))  # 16
        
    def test_chr(self):
        print(chr(0x30)) # 0
        print(chr(97)) # a
        
    def test_bin(self):
        print(bin(97)) # 0b1100001 
        print(bin(88)) # 0b1011000
        
    def test_oct(self):
        print(oct(97)) # 0o141
        print(oct(88)) # 0o130
        
    def test_hex(self):
        print(hex(97)) # 0x61
        print(hex(88)) # 0x58 
        
    def test_bool(self):
        print(bool()) # False
        print(bool(True)) # True
        print(bool(0)) # False
        print(bool(88)) # True
        print(issubclass(bool, int)) # True: bool 是 int 子類

2-5.pow

pow()方法返回 x^y（x的y次方）的值。

pow(x, y[, z])

函數是計算x的y次方，如果z在存在，則再對結果進行取模，其結果等效於pow(x,y) %z

math 模塊 pow() 方法的語法:

import math

math.pow( x, y )

pow() 通過內置的方法直接調用，內置方法會把參數作爲整型，而 math 模塊則會把參數轉換爲 float。

演示

class MyTestCase(unittest.TestCase):
    def test_divmod(self):
        print(pow(3, 0))  # 1 原生
        print(pow(3, 2))  # 9 原生
        print(math.pow(3, 2))  # 9.0 math的

2-6.round

round() 方法返回浮點數 x 的四捨五入值，準確的說保留值將保留到離上一位更近的一端（四捨五入）。

精度要求高的，不建議使用該函數。

演示

class MyTestCase(unittest.TestCase):
    def test_round(self):
        print(round(3))  # 3
        print(round(70.43456))  # 70
        print(round(70.50456))  #  71
        print(round(70.23456, 3))  # 70.235
        print(round(-100.000056, 3))  # -100.0

2-7.sum

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

sum(iterable[, start])

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

演示

class MyTestCase(unittest.TestCase):
    def test_sum(self):
        print(sum([1,2,3,4]))  # 10 列表
        print(sum((1,2,3,4)))  # 10 元組
        print(sum((1,2,3,4),10))  # 20

2-8.range

range()函數返回的是一個可迭代對象（類型是對象），而不是列表類型，所以打印的時候不會打印列表。
list() 函數是對象迭代器，可以把range()返回的可迭代對象轉爲一個列表，返回的變量類型爲列表。

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)

注意

range：左包括，右不包括(從start開始，stop前一個結束)

演示

class MyTestCase(unittest.TestCase):
    def test_range(self):
        print(list(range(10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        print(list(range(1, 10)))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
        print(list(range(1, 10, 2)))  # [1, 3, 5, 7, 9]
        print(list(range(10, 0, -1)))  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

3.集合類操作

3-1.format

Python2.6 開始，新增了一種格式化字符串的函數 str.format()，它增強了字符串格式化的功能。

基本語法是通過{}和:來代替以前的% 。

演示

class MyTestCase(unittest.TestCase):
    def test_formart(self):
        print("{} - {}".format('iworkh', '沐雨雲樓'))  # iworkh - 沐雨雲樓
        print("{1} - {0}".format('iworkh', '沐雨雲樓'))  # 沐雨雲樓 - iworkh
        print("{company} - {name}".format(company='iworkh', name='沐雨雲樓'))  # iworkh - 沐雨雲樓
        # 字典
        data_dic = {'company': 'iworkh', 'name': '沐雨雲樓'}
        print("網站：{company} - 名稱：{name}".format(**data_dic))  # 網站：iworkh - 名稱：沐雨雲樓
        # 列表: 說明 0[1]中的0代表是data_list，1表示list裏第一元素
        data_list1 = ['iworkh', '沐雨雲樓']
        data_list2 = ['test', 'yuxl']
        print("網站：{0[0]} - 名稱：{1[1]}".format(data_list1, data_list2))  # 網站：iworkh - 名稱：沐雨雲樓
        # 格式化
        print("{:.2f}".format(3.1415926))
        # {}的轉義
        print("{{}}是表示轉移的,{:.2%}".format(0.26))

主要關注幾點：

一個{}佔位符，兩個{}可轉義{}
可用通過數字、參數名來格式化，數據值可用是dict、也可以是list
還可以來格式化數字更多數字格式化

3-2.轉化

str() 函數將對象轉化爲適於人閱讀的形式。
iter() 函數用來生成迭代器。

iter(object[, sentinel]):
object: 支持迭代的集合對象。
sentinel: 如果傳遞了第二個參數，則參數 object 必須是一個可調用的對象（如，函數），
此時，iter 創建了一個迭代器對象，每次調用這個迭代器對象的__next__()方法時，都會調用 object。

dict() 函數用於創建一個字典。

三種創建方式

dict(**kwarg)： **kwargs是關鍵字

dict(mapping, **kwarg)：mapping是元素的容器。

dict(iterable, **kwarg)：iterable是可迭代對象。

list() 函數用於將元組或字符串轉換爲列表。

元組與列表是非常類似的，區別在於元組的元素值不能修改，元組是放在括號中，列表是放於方括號中。

tuple()

tuple( iterable ): iterable爲要轉換爲元組的可迭代序列。

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

set([iterable]): iterable是可迭代對象對象(列表、字典、元組等等)；

frozenset()

frozenset([iterable]) : iterable是可迭代對象對象(列表、字典、元組等等)；

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

sort 是應用在 list 上的方法（在原有的list上操作）
sorted 可以對所有可迭代的對象進行排序操作。(返回一個新的 list)
sorted(iterable, key=None, reverse=False)

iterable: 可迭代對象。

key:主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。

reverse : 排序規則，reverse = True 降序， reverse = False 升序（默認）。

演示

class MyTestCase(unittest.TestCase):
    def test_str(self):
        dict = {'company': 'iworkh', 'name': '沐雨雲樓'}
        print(str(dict))  # {'company': 'iworkh', 'name': '沐雨雲樓'}
        list = ['iworkh', '沐雨雲樓']
        print(str(list))  # ['iworkh', '沐雨雲樓']

    def test_iter(self):
        list = ['iworkh', '沐雨雲樓']
        print(iter(list))  # <list_iterator object at 0x000002D9B9E35D48>
        for item in iter(list):
            print(item)

        dict = {'company': 'iworkh', 'name': '沐雨雲樓'}
        print(iter(dict))  # <dict_keyiterator object at 0x0000020ACFCE07C8>
        for item_key in iter(dict):
            print("{}-{}".format(item_key, dict[item_key]))

    def test_dict(self):
        print(dict())  # 空dict {}
        print(dict(name='沐雨雲樓', age=20, sex='男'))  # {'name': '沐雨雲樓', 'age': 20, 'sex': '男'}
        list_zip = zip(['name', 'age', 'sex'], ['沐雨雲樓', 20, '男'])
        print(dict(list_zip))  # {'name': '沐雨雲樓', 'age': 20, 'sex': '男'}
        tuple_list = [('name', '沐雨雲樓'), ('age', 20), ('sex', '男')]
        print(dict(tuple_list))  # {'name': '沐雨雲樓', 'age': 20, 'sex': '男'}

    def test_list(self):
        tuple = ('iworkh', 20, '男')
        print(list(tuple))  # ['iworkh', 20, '男']
        print(list('iowrkh 沐雨雲樓'))  # ['i', 'o', 'w', 'r', 'k', 'h', ' ', '沐', '雨', '雲', '樓']

    def test_tuple(self):
        list = ['iworkh', '沐雨雲樓']
        print(tuple(list))  # ('iworkh', '沐雨雲樓')

    def test_set(self):
        set1 = {1, 2, 3}
        list = [3, 4, 5]
        set2 = set(list)
        print(set1 & set2)  # 交集：{3}
        print(set1 | set2)  # 並集：{1, 2, 3, 4, 5}
        print(set1 - set2)  # 差集：{1, 2}

    def test_frozenset(self):
        print(frozenset(range(5)))  # frozenset({0, 1, 2, 3, 4})
        list = ['iworkh', '沐雨雲樓']
        print(frozenset(list))  # frozenset({'沐雨雲樓', 'iworkh'})

    def test_sorted(self):
        list = [10, 1, 4, 3, 4]
        print(list)
        print(sorted(list)) # 返回的新list
        print(list)
        print(list.sort()) # 在原來的list上操作
        print(list)

3-3.最值

min 函數返回給定參數的最小值，參數可以爲序列。
max 函數返回給定參數的最大值，參數可以爲序列。

演示

class MyTestCase(unittest.TestCase):
    def test_min(self):
        print(min(10,2,3,4))  # 2
        print(min([10,2,3,4]))  # 2

    def test_max(self):
        print(max(10,2,3,4))  # 10
        print(max([10,2,3,4]))  # 10

3-4.enumerate

enumerate()函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。

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

sequence: 一個序列、迭代器或其他支持迭代對象。
start: 下標起始位置。

演示

class MyTestCase(unittest.TestCase):
    def test_enumerate(self):
        list_data = ['a', 'b', 'c']
        e = enumerate(list_data, 0)
        for index, item in e:
            print("{} --- {}".format(index, item))

3-5.reversed

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

演示

class MyTestCase(unittest.TestCase):
    def test_reversed(self):
        list_data = [1, 2, 3, 4]
        reversed_iter = reversed(list_data)  # 返回是iter
        print(list(reversed_iter)) # [4, 3, 2, 1]

        seqString = 'iworkh'
        print(list(reversed(seqString))) # ['h', 'k', 'r', 'o', 'w', 'i']

4.邏輯判斷

4-1.all

all() 函數用於判斷給定的可迭代參數 iterable 中的所有元素是否都爲 TRUE，如果是返回 True，否則返回 False。

元素除了是 0、空、None、False 外都算 True。

注意

空元組、空列表返回值爲True，這裏要特別注意。

語法：all(iterable)

iterable: 元組或列表。

演示

class MyTestCase(unittest.TestCase):
    def test_all(self):
        print(all([]))  # True 空list爲true
        print(all(()))  # True 空tuple爲true
        print(all((1,2,3,4)))  #True
        print(all([1,0,2])) # False，有0
        print(all(['a','','c'])) # False， 有空

4-2.any

any() 函數用於判斷給定的可迭代參數 iterable 是否全部爲 False，則返回 False，如果有一個爲 True，則返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

語法：any(iterable)

iterable – 元組或列表。

演示

class MyTestCase(unittest.TestCase):
    def test_any(self):
        print(any([]))  # False 空list爲False
        print(any(()))  # False 空tuple爲False
        print(any((0,0)))  # False 都0
        print(any(['','','']))  # False 都空
        print(any((1,2,3,4)))  #True
        print(any([0,0,2])) # True，有2
        print(any(['a','','c'])) # True， 有值

5.反射

5-1.callable

callable() 函數用於檢查一個對象是否是可調用的。

如果返回 True，object 仍然可能調用失敗；
但如果返回 False，調用對象 object 絕對不會成功。

對於函數、方法、lambda 函式、類以及實現了__call__方法的類實例, 它都返回 True。

屬性爲false

演示

#  函數
def fun_a():
    pass


# 沒有實現__call__的類A
class A:
    def method(self):
        pass


# 實現__call__的類B
class B:
    no: str = 1
    _sex: str = '男'

    def __call__(self, *args, **kwargs):
        pass


class MyTestCase(unittest.TestCase):
    def test_call(self):
        # str、list、number
        print(callable(0))  # False
        print(callable('aaaa'))  # False
        print(callable([1, 2, 3]))  # False
        print(callable((1, 2, 3)))  # False
        # 函數
        print(callable(fun_a))  # True

        # 類屬性
        print(callable(B.no))  # False 屬性
        print(callable(B._sex))  # False 屬性
        # 方法
        print(callable(A.method))  # True
        # 類
        print(callable(A))  # True
        print(callable(B))  # True
        # 對象
        a = A()
        print(callable(a))  # False 沒實現`__call__`方法
        b = B()
        print(callable(b))  # True 實現了`__call__`方法

        print(callable(b.no))  # False 屬性
        print(callable(b._sex))  # False 屬性
        pass

5-2.classmethod

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

要跟後面介紹的staticmethod區分開。

演示

class A(object):
    bar = 1
    def func1(self):
        print ('foo')

    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 調用 func1 方法


class MyTestCase(unittest.TestCase):
    def test_classmethod(self):
        A.func2()

5-3.compile

compile() 函數將一個字符串編譯爲字節代碼。

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

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

演示

class MyTestCase(unittest.TestCase):
    def test_compile(self):
        # exec
        source = "for i in range(1,5): print(i)"
        compiled_source = compile(source, '', 'exec')
        exec(compiled_source)
        # eval
        str = "3 * 4 + 5"
        compiled_eval = compile(str, '', 'eval')
        result = eval(compiled_eval)
        print(result)

exec 和eval 後面會講解

5-4.dir

dir()

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

如果參數包含方法__dir__()，該方法將被調用。如果參數不包含__dir__()，該方法將最大限度地收集參數信息。

演示

class User:
    name: str = 'iworkh'

    def say(self):
        pass

class MyTestCase(unittest.TestCase):
    def test_dir(self):
        # 空
        print(dir())
        # list
        print(dir([]))
        #  str
        print(dir('a'))
        # 對象
        print(dir(User)) #屬性和方法都出來)

只貼一個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']

5-5.delattr

delattr() 函數用於刪除屬性。

語法：delattr(object, name)

object: 對象。
name: 必須是對象的屬性

delattr(x, 'filedname') 相等於 del x.filename

演示

class MyTestCase(unittest.TestCase):
    def test_delattr(self):
        user = User()
        user.name = 'iworkh'
        user.password = 'iworkh123'
        user.age = 10
        print(user.__dict__)
        delattr(user, 'password') # 等價於 del user.password
        print(user.__dict__)

5-6.eval

eval() 函數用來執行一個字符串表達式，並返回表達式的值。

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

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

演示

class MyTestCase(unittest.TestCase):
    def test_eval(self):
        x = 8
        print(eval('x+3'))
        print(eval('7*3'))

5-7.exec

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

語法：exec(object[, globals[, locals]])

object：必選參數，表示需要被指定的Python代碼。它必須是字符串或code對象。
如果object是一個字符串，該字符串會先被解析爲一組Python語句，然後再執行（除非發生語法錯誤）。
如果object是一個code對象，那麼它只是被簡單的執行。
globals：可選參數，表示全局命名空間（存放全局變量），如果被提供，則必須是一個字典對象。
locals：可選參數，表示當前局部命名空間（存放局部變量），如果被提供，可以是任何映射對象。如果該參數被忽略，那麼它將會取與globals相同的值。

演示

class MyTestCase(unittest.TestCase):
    def test_exec(self):
        # 普通字符串
        exec('print("Hello World")')

        # 有參數，使用dict傳入
        source = """for i in range(num):
                    print ("iter time: %d" % i)
            """
        exec(source, {'num': 5})

5-8.filter

filter()函數用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，如果要轉換爲列表，可以使用 list() 來轉換。

語法：filter(function, iterable)

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

序列的每個元素作爲參數傳遞給函數進行判，然後返回 True 或 False，最後將返回 True 的元素放到新列表中。

演示

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

class MyTestCase(unittest.TestCase):
    def test_filter(self):
        list_data = list(range(1, 10))
        # lambda
        result = filter(lambda item: item % 2 == 0, list_data) # 返回的是iter
        print(list(result)) # [2, 4, 6, 8]
        # func
        result2 = filter(is_odd, list_data)
        print(list(result2)) # [1, 3, 5, 7, 9]

5-9.getattr

getattr() 函數用於返回一個對象屬性值。

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

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

演示

class MyTestCase(unittest.TestCase):
    def test_getattr(self):
        user = User()
        user.name = 'iworkh'
        user.age = 20
        getattr(user, 'name')

5-10.globals

globals() 函數會以字典類型返回當前位置的全部全局變量。

演示

global_a = 10
global_b = 'iworkh'


class MyTestCase(unittest.TestCase):
    def test_globals(self):
        # globals 函數返回一個全局變量的字典，包括所有導入的變量。
        all_globals = globals()
        print(all_globals['global_b'])

5-11.hasattr

hasattr() 函數用於判斷對象是否包含對應的屬性和方法。

語法：hasattr(object, name)

object – 對象。
name – 字符串，屬性名。

演示

class User:
    name: str
    age: int

    def say(self):
        pass


class MyTestCase(unittest.TestCase):
    def test_hasattr(self):
        user = User()
        user.name = 'iworkh'
        user.age = 120
        print(hasattr(user, 'name'))  # True 屬性
        print(hasattr(user, 'sex'))  # False
        print(hasattr(user, 'say'))  # True 方法

5-12.hash

hash()用於獲取一個對象（字符串或者數值等）的哈希值。

函數可以應用於數字、字符串和對象，不能直接應用於 list、set、dictionary。

演示

class User:
    name: str
    age: int


class MyTestCase(unittest.TestCase):
    def test_hash(self):
        print(hash(1))
        # 字符串
        print(hash("2"))
        # tuple
        print(hash((1, False, '3')))
        # dict要轉str
        print(hash(str({'name': 'iworkh', 'age': 20})))
        # 對象
        user = User()
        user.name = 'iworkh'
        user.age = 120
        print(hash(user))

5-13.id

id() 函數返回對象的唯一標識符，標識符是一個整數。

CPython 中 id() 函數用於獲取對象的內存地址。

演示

class User:
    name: str
    age: int


class MyTestCase(unittest.TestCase):
    def test_id(self):
        print(id(1))
        # 字符串
        print(id("2"))
        # tuple
        print(id((1, False, '3')))
        # list
        print(id([1, False, '3']))
        # dict
        print(id({'name': 'iworkh', 'age': 20}))
        # 對象
        user = User()
        user.name = 'iworkh'
        user.age = 120
        print(id(user))

5-14.isinstance

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

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

語法：isinstance(object, classinfo)

object – 實例對象。
classinfo – 可以是直接或間接類名、基本類型或者由它們組成的元組(只要一個滿足就返回True)。

演示

class People:
    sex: str


class User(People):
    name: str
    age: int


class MyTestCase(unittest.TestCase):
    def test_isinstance(self):
        a = 10
        print(isinstance(a, int))  # True
        print(isinstance(a, float))  # False
        print(isinstance(a, (int, float, str)))  # True 滿足一個即可
        # 對象
        print(isinstance(User(), User))  # True
        print(type(User()) == User)  # True
        print(isinstance(User(), People))  # True  isinstance考慮繼承
        print(type(User()) == People)  # False type不考慮繼承

5-15.issubclass

issubclass() 方法用於判斷參數 class 是否是類型參數 classinfo 的子類。

語法：issubclass(class, classinfo)

class – 類。
classinfo – 類。

這參數，兩個都是類。而前面介紹的isinstance參數，一個是對象，一個是類

演示

class People:
    sex: str


class User(People):
    name: str
    age: int


class MyTestCase(unittest.TestCase):
    def test_issubclass(self):
        # 對象
        print(issubclass(User, People))  # True

5-16.len

len()方法返回對象（字符、列表、元組等）長度或項目個數。

演示

class MyTestCase(unittest.TestCase):
    def test_len(self):
        # str
        print(len('iworkh'))
        # list
        print(len([1, 2, 3]))
        # tuple
        print(len((1, 2, 3)))
        # dict
        dict = {'name': 'iworkh', 'age': 10}
        print(len(dict))

5-17.locals

locals() 函數會以字典類型返回當前位置的全部局部變量。

演示

def add(a, b):
    dict = {'name': 'iworkh', 'age': 10}
    print(locals()) # {'a': 1, 'b': 3, 'dict': {'name': 'iworkh', 'age': 10}}
    return a + b


class MyTestCase(unittest.TestCase):
    def test_locals(self):
        add(1, 3)

5-18.map

map()會根據提供的函數對指定序列做映射。

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

第一個參數 function 以參數序列中的每一個元素調用 function 函數，返回包含每次 function 函數返回值的新列表。

function – 函數
iterable – 一個或多個序列

演示

class MyTestCase(unittest.TestCase):
    def test_map(self):
        list_data = [1, 2, 3, 4]
        result = map(lambda x: x * 2, list_data) # 返回iter
        print(list(result))

5-19.bytearray

bytearray() 方法返回一個新字節數組。這個數組裏的元素是可變的，並且每個元素的值範圍: 0 <= x < 256。

語法class bytearray([source[, encoding[, errors]]])

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

演示

class MyTestCase(unittest.TestCase):
    def test_bytearray(self):
        # str
        print(bytearray('abcde', 'utf-8'))

        # list
        list_data = [1, 2, 3, 4]
        print(bytearray(list_data))

5-20.memoryview

memoryview() 函數返回給定參數的內存查看對象(memory view)。

所謂內存查看對象，是指對支持緩衝區協議的數據進行包裝，在不需要複製對象基礎上允許Python代碼訪問。

語法：memoryview(obj)

返回值是元組列表。

演示

class MyTestCase(unittest.TestCase):
    def test_memoryview(self):
        # str
        ba = bytearray('abcde', 'utf-8')
        mv = memoryview(ba)
        print(mv[1])  # 98
        print(mv[1:4])  # <memory at 0x000001D28801C948>
        print(mv[1:4].tobytes())  # b'bcd'
        print(mv[-1])  # 101

        print("*" * 50)

        # list
        list_data = [1, 2, 3, 4]
        ba_list = bytearray(list_data)
        mv_list = memoryview(ba_list)
        print(mv_list[0]) # 1

5-21.next

next() 返回迭代器的下一個項目。

next() 函數要和生成迭代器的iter() 函數一起使用。

語法：next(iterator[, default])

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

演示

class MyTestCase(unittest.TestCase):
    def test_next(self):
        list_data = [1, 2, 3, 4]
        it = iter(list_data)
        while (True):
            try:
                data = next(it)
                print(data)
            except StopIteration:
                break

5-22.property

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

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

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

演示

對象裏有個私有屬性，然後通過方法來執行塞值、取值、刪除操作

通過方法調用

class User:
    _name: str

    def get_name(self):
        print('call method ... get_name')
        return self._name

    def set_name(self, value):
        print('call method ... set_name')
        self._name = value

    def del_name(self):
        print('call method ... del_name')
        del self._name


class MyTestCase(unittest.TestCase):
    def test_method(self):
        # 對象.方法
        user = User()
        user.set_name(value='iworkh')
        print(user.get_name())

通過property方式

class User:
    _name: str

    def get_name(self):
        print('call method ... get_name')
        return self._name

    def set_name(self, value):
        print('call method ... set_name')
        self._name = value

    def del_name(self):
        print('call method ... del_name')
        del self._name


    name = property(get_name, set_name, del_name, '姓名')


class MyTestCase(unittest.TestCase):

    def test_property(self):
        # property
        user2 = User()
        user2.name='iworkh'
        print(user2.name)

添加name = property(get_name, set_name, del_name, '姓名')定義

使用裝飾器

class User2:
    _name: str

    @property
    def name(self):
        """
        姓名
        """
        print('call2 method ... get_name')
        return self._name

    @name.setter
    def name(self, value):
        print('call2 method ... set_name')
        self._name = value

    @name.deleter
    def name(self):
        print('call2 method ... del_name')
        del self._name

class MyTestCase(unittest.TestCase):
    def test_anno(self):
        # property
        user2 = User2()
        user2.name = 'iworkh'
        print(user2.name)

使用@property對應的方法名name就是屬性名name，然後再對對應的setter和getter方法設置@name.setter和@name.deleter

5-23.vars

vars()函數返回對象object的屬性和屬性值的字典對象。

演示

class User:
    name: str
    age: int


class MyTestCase(unittest.TestCase):
    def test_vars(self):
        # 對象
        user = User()
        user.name = 'iworkh'
        user.age = 11
        print(vars(user)) # {'name': 'iworkh', 'age': 11}

5-24.setattr

setattr() 函數對應函數 getattr()，用於設置屬性值，該屬性不一定是存在的。

語法：setattr(object, name, value)

object – 對象。
name – 字符串，對象屬性。
value – 屬性值。

演示

class User:
    name: str
    age: int


class MyTestCase(unittest.TestCase):
    def test_setattr(self):
        # 對象
        user = User()
        user.name = 'iworkh'
        # 存在屬性賦值
        setattr(user, 'age', 20)
        print(user.age) # 20
        # 不存在屬性賦值
        setattr(user, 'sex', '男')
        print(user.sex) # 男

5-25.slice

slice() 函數實現切片對象，主要用在切片操作函數裏的參數傳遞。

語法： slice(stop)或 slice(start, stop[, step])

演示

class MyTestCase(unittest.TestCase):
    def test_type(self):
        slice_end = slice(3)
        print(slice_end)
        data = range(10)
        print(data[slice_end])

5-26.staticmethod

staticmethod 返回函數的靜態方法。

既實現實例化使用 C().f()，也可以不實例化調用該方法 C.f()。

要跟前面介紹的classmethod區分開。

區別

如果方法不需要訪問對象/類的屬性或其他方法的話，那麼使用staticmethod
如果需要方法類的屬性或其他方法的話，那麼使用classmethod
classmethod的方法第一個參數是cls

演示

class A(object):
    @staticmethod
    def add(a, b):
        return a + b


class MyTestCase(unittest.TestCase):
    def test_staticmethod(self):
        # 類調用
        print(A.add(2, 4))
        # 對象調用
        a = A()
        print(a.add(2, 6))

5-27.type

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

isinstance() 與 type() 區別：

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

語法：type(object) 或 type(name, bases, dict)

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

演示

class MyTestCase(unittest.TestCase):
    def test_type(self):
        # int
        print(type(10))  # <class 'int'>
        # list
        print(type([1, 2, 3]))  # <class 'list'>

5-28.repr

repr() 函數將對象轉化爲供解釋器讀取的形式。

不怎麼用

演示

class User:
    name: str
    age: int


class MyTestCase(unittest.TestCase):
    def test_repr(self):
        # str
        name = 'iwrokh'
        print(name)
        print(repr(name))

        # list
        list_data = [1, 2, 3, 4]
        print(list_data)
        print(repr(list_data))

        # dict
        dict = {'name': 'iworkh', 'age': 19}
        print(dict)
        print(repr(dict))

        # obj
        user = User
        user.name = 'iworkh'
        user.age = 11
        print(user)
        print(repr(user))

5-29.zip

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

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

演示

class MyTestCase(unittest.TestCase):
    def test_zip(self):
        a = [1, 2, 3]
        b = [4, 5, 6]
        c = [4, 5, 6, 7, 8]
        zip_tuple = zip(a, b)
        print(list(zip_tuple))
        print(list(zip(a, c)))  # 元素個數與最短的列表一致

        # 與 zip 相反，zip(*) 可理解爲解壓，返回二維矩陣式
        x, y = zip(*zip(a, c))  # 可以
        print(list(x))
        print(list(y))

        # m, n = zip(*zip_tuple)  # 報錯 not enough values to unpack，上面有調用了list(zip_tuple)就會報錯
        zip_tuple2 = zip(a, b)
        m, n = zip(*zip_tuple2) # 正確，沒有對zip(a, b)的結果進行list轉化
        print(list(m))
        print(list(n))

警告

使用zip(*)時候，如果參數是前面定義過的變量的話，那麼最好不要對變量做一些操作，可能導致zip(*)失敗。可以能原因，在list()的時候，對源對象進行了特殊處理，導致了後面使用zip(*)的時候失敗。

這還有一篇stackoverflow也遇到這錯。stackoverflow裏not enough values to unpack的錯誤有興趣的可以取研究下

5-30.xrange

python2 xrange() 函數用法與 range 完全相同，所不同的是生成的不是一個數組，而是一個生成器。

python3中沒有了，就用range

6.IO操作

6-1.input

input() 函數接受一個標準輸入數據，返回爲 string 類型。

演示

class MyTestCase(unittest.TestCase):
    def test_input(self):
        a = input("input:")
        print(a)

6-2.open

open()函數用於打開一個文件，並返回文件對象，在對文件進行處理過程都需要使用到這個函數，如果該文件無法被打開，會拋出 OSError。

使用 open() 函數一定要保證關閉文件對象，即調用 close() 函數。

語法：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file: 必需，文件路徑（相對或者絕對路徑）。
mode: 可選，文件打開模式(r: 讀；x:寫； a:追加；b:二進制； +:打開一個文件進行更新，可讀可寫)
buffering: 設置緩衝
encoding: 一般使用utf8
errors: 報錯級別
newline: 區分換行符
closefd: 傳入的file參數類型
opener:

默認爲文本模式，如果要以二進制模式打開，加上 b 。

演示

class MyTestCase(unittest.TestCase):
    def test_open(self):
        f = open('file_buildin_func.py')
        try:
            data = f.read()
            print(data)
        except Exception as e:
            print(e)
        finally:
            f.close()

6-3.print

print() 方法用於打印輸出，最常見的一個函數。

語法: print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

objects – 複數，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。
sep – 用來間隔多個對象，默認值是一個空格。
end – 用來設定以什麼結尾。默認值是換行符 \n，我們可以換成其他字符串。
file – 要寫入的文件對象。
flush – 輸出是否被緩存通常決定於 file，但如果 flush 關鍵字參數爲 True，流會被強制刷新。

演示

class MyTestCase(unittest.TestCase):
    def test_print(self):
        print("xxx")
        print("aaa""bbb")
        print("aaa","bbb")
        print("https://","www","iworkh","com",sep='.')

7.其他

7-1.help

help() 函數用於查看函數或模塊用途的詳細說明。

演示

class MyTestCase(unittest.TestCase):
    def test_help(self):
        help(str)
        help(list)
        list_data = [1, 2, 3]
        help(list_data)
        help(list_data.append)

7-2.import

__import__() 函數用於動態加載類和函數。

如果一個模塊經常變化就可以使用__import__()來動態載入。

演示

定義兩個模塊，供不同情況使用時候動態引用

dark類

import os

print('this is a dark theme {}'.format(id(os)))

文件路徑: theme/dark/import_dark_buildin_func.py

light類

import os

print('this is a light theme {}'.format(id(os)))

文件路徑: theme/light/import_light_buildin_func.py

測試類

class MyTestCase(unittest.TestCase):
    def test_import(self):
        theme = 'dark'
        # theme = 'light'
        if theme == 'dark':
            __import__('theme.dark.import_dark_buildin_func')
        else:
            __import__('theme.light.import_light_buildin_func')

        print('done')

8.總結

內置函數有很多，只要記得一些常用的即可，其他用的時候可以查表格即可。但是一些特殊內置函數要注意區別。

思考：

1.staticmehtod和classmethod使用和區別
2.setattr、getattr、delattr、hasattr使用
3.類型轉化：int、str、float、list、dict、tuple、iter 的使用
4.isinstance、issubclass、type的使用和區別
5.format、print、open如何使用
6.sorted、reversed、max、min、len、sum使用
7.map、filter、zip使用
8.dir、call使用

如果上面幾個問題能過回答上，那麼恭喜您，本節內容的精髓您都掌握了。

掌握上面一些常用基本夠用了，其他用的時候再出來查即可，下一篇再來看下內置屬性

9.推薦

能讀到文章最後，首先得謝謝您對本文的肯定，你的肯定是對我們的最大鼓勵。

你覺本文有幫助，那就點個👍
你有疑問，那就留下您的💬
怕把我弄丟了，那就把我⭐
電腦不方便看，那就把發到你📲