一篇掌握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使用

如果上面几点问题都能回答上，那么可以跳过本篇文章了。本篇相关文章共三连弹。(端午节在家整理，有帮助记得点个👍，就是对我最大的肯定😘😘😘)

• 第一弹–python对象与dict互转
• 第二弹–python内置函数
• 第三弹–python魔法方法

技巧：文章内容太多如何阅读？

• 先看文章的目录(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.推荐

• iworkh博客
• iworkh网站

能读到文章最后，首先得谢谢您对本文的肯定，你的肯定是对我们的最大鼓励。

你觉本文有帮助，那就点个👍
你有疑问，那就留下您的💬
怕把我弄丢了，那就把我⭐
电脑不方便看，那就把发到你📲