Python基础学习之内置函数（完整版）

亦凉 2022-12-11 09:10 338阅读 0赞

# Python基础学习之内置函数 #

Python3.5版本中的68个内置函数，按顺序逐个进行了自认为详细的解析，现在是时候进行个总结了。为了方便记忆，将这些内置函数进行了如下分类：

### 文章目录 ###

*  Python基础学习之内置函数
 *   *  1. 数学运算(7个)
     *   *  1.1 abs()，求绝对值
         *  1.2 divmod()，求商和余数
         *  1.3 max()，求最大值
         *  1.4 min()，求最小值
         *  1.5 pow()，求幂运算
         *  1.6 round()，四舍五入
         *  1.7 sum()，求和
     *  2. 类型转换(24个)
     *   *  2.1 bool()，布尔转换
         *  2.2 int()，整型转换
         *  2.3 float()，浮点型转换
         *  2.4 complex()，复数
         *  2.5 str()，字符串转换
         *  2.6 bytearray()，字节数组
         *  2.7 bytes()，不可变字节数组
         *  2.8 memoryview()，内存查看
         *  2.9 ord()，字符 --> ASC
         *  2.10 chr() ，ASC --> 字符
         *  2.11 bin()，转换成二进制
         *  2.12 oct()，转换成八进制
         *  2.13 hex()，转换成十六进制
         *  2.14 tuple()，创建元组
         *  2.15 list()，创建列表
         *  2.16 dict()，创建字典
         *  2.17 set()，创建集合
         *  2.18 frozenset()，创建不可变集合
         *  2.19 enumerate()，创建枚举对象
         *  2.20 range()，创建range对象
         *  2.21 iter()，创建可迭代对象
         *  2.22 slice()，创建切片对象
         *  2.23 super()，继承
         *  2.24 object()，创建对象
     *  3. 序列操作(8个)
     *   *  3.1 all()，all运算
         *  3.2 any()，any运算
         *  3.3 filter()，过滤可迭代对象
         *  3.4 map()，对可迭代对象中每个元素运算
         *  3.5 next()，迭代对象中的下一个
         *  3.6 reversed()，返序
         *  3.7 sorted()，排列
         *  3.8 zip()，列表 --> 字典
     *  4. 对象操作(9个)
     *   *  4.1 help()，帮助文件
         *  4.2 dir()，属性列表
         *  4.3 id()，唯一标识符
         *  4.4 hash()，哈希值
         *  4.5 type()，对象类型
         *  4.6 len()，对象长度
         *  4.7 ascii()，可打印字符串
         *  4.8 format()，格式化显示
         *  4.9 vars()，局部变量和值
     *  5. 反射操作(8个)
     *   *  5.1 \_\_import\_\_()，动态导入模块
         *  5.2 isinstance()，判断实例
         *  5.3 issubclass()，判断子类
         *  5.4 hasattr()，判断属性
         *  5.5 getattr()，获取属性
         *  5.6 setattr() ，设置属性
         *  5.7 delattr()，删除属性
         *  5.8 callable()，对象是否可调用
     *  6. 作用域变量操作(2个)
     *   *  6.1 globals()，全局变量 & 值
         *  6.2 locals()，局部变量 & 值
     *  7. 交互操作(2个)
     *   *  7.1 print()，打印输出
         *  7.2 input()，用户输入
     *  8. 文件操作(1个)
     *   *  8.1 open()，打开文件
     *  9. 编译执行(4个)
     *   *  9.1 compile()，编译代码
         *  9.2 eval()，执行动态表达式
         *  9.3 exec()，执行动态语句
         *  9.4 repr()，字符串表现形式
     *  10. 装饰器(3个)
     *   *  10.1 property()，属性装饰器
         *  10.2 classmethod()，类装饰器
         *  10.3 staticmethod()，静态方法装饰器

## 1. 数学运算(7个) ##

### 1.1 abs()，求绝对值 ###

求数值的绝对值

abs(-10)   # 输出：10

### 1.2 divmod()，求商和余数 ###

求两个数值的商和余数

# divmod
    divmod(10 , 3)  # 输出：(3, 1)
    divmod(10.1,3)  # 输出：(3.0, 1.0999999999999996)
    divmod(-10,4)   # 输出：(-3, 2)

### 1.3 max()，求最大值 ###

求最大值

max(1,2,3)     # 传入3个参数 取3个中较大者；输出：3
    max('1234')    # 传入1个可迭代对象，取其最大元素值；输出：'4'
    max(-1,0)     # 数值默认去数值较大者；输出：0
    max(-1,0,key = abs)  # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者；输出：-1

### 1.4 min()，求最小值 ###

求最小值

min(1, 2, 3)    # 传入3个参数 取3个中较小的；输出：1
    min('1234')     # 传入1个可迭代对象，取其最小元素值；输出：'1'
    min(-1,-2)      # 数值默认去数值较小者；输出：-2
    min(-1,-2,key = abs)  # 传入了求绝对值函数，则参数都会进行求绝对值后再取较小者；输出：-1

### 1.5 pow()，求幂运算 ###

求两个数的幂运算

pow(2, 3)    # 2^3 = 8

### 1.6 round()，四舍五入 ###

对数值进行四舍五入

round(1.131415926,1)  # 输出：1.1
    round(1.131415926,5)  # 输出：1.13142

### 1.7 sum()，求和 ###

求数值的和

# 传入可迭代对象
    sum((1,2,3,4))    # 输出：10
    # 元素类型必须是数值型
    sum((1.5,2.5,3.5,4.5))    # 输出：12.0
    sum((1,2,3,4),-10)    # 输出：0

## 2. 类型转换(24个) ##

### 2.1 bool()，布尔转换 ###

根据传入的参数的逻辑值创建一个新的布尔值

bool() # 未传入参数；输出：False
    bool(0) # 数值0、空序列等值为False；输出：False
    bool(1)  # 输出：True

### 2.2 int()，整型转换 ###

根据传入的参数创建一个新的整数

int() #不传入参数时，得到结果0；输出：0
    int(3) # 输出：3
    int(3.6) # 输出：3

### 2.3 float()，浮点型转换 ###

根据传入的参数创建一个新的浮点数

float() # 不提供参数的时候，返回:0.0
    float(3)   # 返回:3.0
    float('3')    # 返回:3.0

### 2.4 complex()，复数 ###

根据传入参数创建一个新的复数

complex() # 当两个参数都不提供时，返回复数 0j。
    complex('1+2j') # 传入字符串创建复数，输出：(1+2j)
    complex(1,2) # 传入数值创建复数，输出：(1+2j)

### 2.5 str()，字符串转换 ###

返回一个对象的字符串表现形式(给用户)

str()  # 返回：''
    str(None)  # 输出：'None'
    str('abc')    # 输出：'abc'
    str(123)    # 输出：'123'

### 2.6 bytearray()，字节数组 ###

根据传入的参数创建一个新的字节数组，不怎么用；

bytearray('中文','utf-8')    # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

### 2.7 bytes()，不可变字节数组 ###

根据传入的参数创建一个新的不可变字节数组

bytes('中文','utf-8')    # b'\xe4\xb8\xad\xe6\x96\x87'

### 2.8 memoryview()，内存查看 ###

根据传入的参数创建一个新的内存查看对象

v = memoryview(b'abcefg')
    v[1]    # 输出：98
    v[-1]   # 输出：103

### 2.9 ord()，字符 --> ASC ###

返回Unicode字符对应的整数

ord('a')    # 输出：97

### 2.10 chr() ，ASC --> 字符 ###

返回整数所对应的Unicode字符

chr(97)    # 输出：'a'

### 2.11 bin()，转换成二进制 ###

将整数转换成2进制字符串

bin(3)  # 输出：'0b11'

### 2.12 oct()，转换成八进制 ###

将整数转化成8进制数字符串

oct(10)   # 输出：'0o12'

### 2.13 hex()，转换成十六进制 ###

将整数转换成16进制字符串

hex(15)  # 输出：'0xf'

### 2.14 tuple()，创建元组 ###

根据传入的参数创建一个新的元组

tuple()    # 不传入参数，创建空元组; 输出：()
    tuple('121')  # 传入可迭代对象。使用其元素创建新的元组；输出: ('1', '2', '1')

### 2.15 list()，创建列表 ###

根据传入的参数创建一个新的列表

list() # 不传入参数，创建空列表；输出：[] 
    list('abcd') # 传入可迭代对象，使用其元素创建新的列表；输出：['a', 'b', 'c', 'd']

### 2.16 dict()，创建字典 ###

根据传入的参数创建一个新的字典

dict() # 不传入任何参数时，返回空字典。返回：{}
    dict(a = 1,b = 2) # 可以传入键值对创建字典。返回：{'b': 2, 'a': 1}
    dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。返回：{'b': 2, 'a': 1}
    dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。返回：{'b': 2, 'a': 1}

### 2.17 set()，创建集合 ###

根据传入的参数创建一个新的集合

set() # 不传入参数，创建空集合；输出：set()
    set(range(10)) # 传入可迭代对象，创建集合；输出：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

### 2.18 frozenset()，创建不可变集合 ###

根据传入的参数创建一个新的不可变集合

a = frozenset(range(10))   # 输出：frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

### 2.19 enumerate()，创建枚举对象 ###

根据可迭代对象创建枚举对象

seasons = ['Spring', 'Summer', 'Fall', 'Winter']   
    list(enumerate(seasons))    # 输出：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    
    list(enumerate(seasons, start=1)) # 指定起始值，输出：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

### 2.20 range()，创建range对象 ###

根据传入的参数创建一个新的range对象

a = range(10)
    b = range(1,10)
    c = range(1,10,3)
    a,b,c # 分别输出a,b,c，输出：(range(0, 10), range(1, 10), range(1, 10, 3))
    list(a),list(b),list(c) # 分别输出a,b,c的元素;输出：([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

### 2.21 iter()，创建可迭代对象 ###

根据传入的参数创建一个新的可迭代对象

a = iter('abcd') #字符串序列
    print(a)    # 输出：<str_iterator object at 0x03FB4FB0>
    next(a)    # 输出：'a'
    next(a)    # 输出：'b'
    next(a)    # 输出：'c'
    next(a)    # 输出：'d'
    next(a)    # 由于后面没有元素了，所以会报错；报错内容如下：
    # Traceback (most recent call last):
    # File "<pyshell#29>", line 1, in <module>
    # next(a)
    # StopIteration

### 2.22 slice()，创建切片对象 ###

根据传入的参数创建一个新的切片对象

slice(5)    # 输出：slice(None, 5, None)
    slice(2,5)    # 输出：slice(2, 5, None)
    slice(1,10,3)   # 输出：slice(1, 10, 3)

### 2.23 super()，继承 ###

根据传入的参数创建一个新的子类和父类关系的代理对象

#定义父类A
    class A(object):
        def __init__(self):
            print('A.__init__')
    
    #定义子类B，继承A
    class B(A):
        def __init__(self):
            print('B.__init__')
            super().__init__()
    
    #super调用父类方法
    b = B()
    
    print(b)    # 输出：
    # B.__init__
    # A.__init__
    # <__main__.B object at 0x0000025B3398C160>

### 2.24 object()，创建对象 ###

创建一个新的object对象

a = object()

## 3. 序列操作(8个) ##

### 3.1 all()，all运算 ###

判断可迭代对象的每个元素是否都为True值

all([1,2]) # 列表中每个元素逻辑值均为True，返回True; 输出：True
    all([0,1,2]) #列表中0的逻辑值为False，返回False；
    all(()) # 空元组，输出：True
    all({ }) # 空字典，输出：True

### 3.2 any()，any运算 ###

判断可迭代对象的元素是否有为True值的元素

any([0,1,2]) # 列表元素有一个为True，则返回True
    any([0,0]) # 列表元素全部为False，则返回False
    any([]) # 空列表,输出: False
    any({ }) # 空字典,输出: False

### 3.3 filter()，过滤可迭代对象 ###

使用指定方法过滤可迭代对象的元素

a = list(range(1,10)) #定义序列, 输出 a 为：[1, 2, 3, 4, 5, 6, 7, 8, 9]
    def if_odd(x): # 定义奇数判断函数
        return x % 2 == 1
    
    list(filter(if_odd , a)) # 筛选序列中的奇数，输出：[1, 3, 5, 7, 9]

### 3.4 map()，对可迭代对象中每个元素运算 ###

使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

a = map(ord,'abcd')    # 此时，a为：<map object at 0x03994E50>
    list(a)    # 对字符串'abcd' 分别计算ord(), 输出为：[97, 98, 99, 100]

### 3.5 next()，迭代对象中的下一个 ###

返回可迭代对象中的下一个元素值

### 3.6 reversed()，返序 ###

反转序列生成新的可迭代对象

a = reversed(range(10)) # 传入range对象
    list(a) # 输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

### 3.7 sorted()，排列 ###

对可迭代对象进行排序，返回一个新的列表

a = ['a','b','d','c','B','A']
    sorted(a)  # 默认按字符ascii码排序，输出：['A', 'B', 'a', 'b', 'c', 'd']
    sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样；输出：['a', 'A', 'b', 'B', 'c', 'd']

### 3.8 zip()，列表 --> 字典 ###

聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

x = [1,2,3] #长度3
    y = [4,5,6,7,8] #长度5
    list(zip(x,y)) # 取最小长度3，输出： [(1, 4), (2, 5), (3, 6)]

## 4. 对象操作(9个) ##

### 4.1 help()，帮助文件 ###

返回对象的帮助信息

### 4.2 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']

### 4.3 id()，唯一标识符 ###

返回对象的唯一标识符

a = 'kai'
    id(a)   # 输出：2332201834456

### 4.4 hash()，哈希值 ###

获取对象的哈希值

hash('good good study')  # 输出：6003936519601954108

### 4.5 type()，对象类型 ###

返回对象的类型，或者根据传入的参数创建一个新的类型

type(10)    # 输出：<class 'int'>
    type('10')     # 输出：<class 'str'>

### 4.6 len()，对象长度 ###

返回对象的长度

len('abcd') # 字符串,返回：4
    len(bytes('abcd','utf-8')) # 字节数组，返回：4
    len((1,2,3,4)) # 元组,返回：4
    len([1,2,3,4]) # 列表,返回：4
    len(range(1,5)) # range对象,返回：4
    len({ 'a':1,'b':2,'c':3,'d':4}) # 字典，,返回：4
    len({ 'a','b','c','d'}) # 集合，,返回：4
    len(frozenset('abcd')) #不可变集合，,返回：4

### 4.7 ascii()，可打印字符串 ###

返回对象的可打印表字符串表现方式

ascii(1)     # 输出：'1'
    ascii('&')    # 输出："'&'"
    ascii(9000000)    # 输出：'9000000'
    ascii('中文') #非ascii字符 # 输出："'\\u4e2d\\u6587'"

### 4.8 format()，格式化显示 ###

格式化显示值

# 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
    format(3,'b') #转换成二进制，输出：'11'
    format(97,'c') # 转换unicode成字符，输出：'a'
    format(11,'d') # 转换成10进制，输出：'11'
    format(11,'o') # 转换成8进制，输出：'13'
    format(11,'x') # 转换成16进制 小写字母表示，输出：'b'
    format(11,'X') # 转换成16进制 大写字母表示，输出：'B'
    format(11,'n') # 和d一样，输出：'11'
    format(11) # 默认和d一样，输出：'11'
    
    # 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
    format(314159267,'e') # 科学计数法，默认保留6位小数，输出：'3.141593e+08'
    format(314159267,'0.2e') # 科学计数法，指定保留2位小数，输出：'3.14e+08'
    format(314159267,'0.2E') # 科学计数法，指定保留2位小数，采用大写E表示，输出：'3.14E+08'
    format(314159267,'f') # 小数点计数法，默认保留6位小数，输出：'314159267.000000'
    format(3.14159267000,'f') # 小数点计数法，默认保留6位小数，输出：'3.141593'
    format(3.14159267000,'0.8f') # 小数点计数法，指定保留8位小数，输出：'3.14159267'
    format(3.14159267000,'0.10f') # 小数点计数法，指定保留10位小数，输出：'3.1415926700'
    format(3.14e+1000000,'F')  # 小数点计数法，无穷大转换成大小字母，输出：'INF'
    
    # g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
    format(0.00003141566,'.1g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，输出：'3e-05'
    format(0.00003141566,'.2g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点，输出：'3.1e-05'
    format(0.00003141566,'.3g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点，输出：'3.14e-05'
    format(0.00003141566,'.3G') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写，输出：'3.14E-05'
    format(3.1415926777,'.1g') # p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点，输出：'3'
    format(3.1415926777,'.2g') # p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点，输出：'3.1'
    format(3.1415926777,'.3g') # p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点，输出：'3.14'
    format(0.00003141566,'.1n') # 和g相同，输出：'3e-05'
    format(0.00003141566,'.3n') # 和g相同，输出：'3.14e-05'
    format(0.00003141566) # 和g相同，输出：'3.141566e-05'

### 4.9 vars()，局部变量和值 ###

返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

class A(object):
        pass
    a = A()
    
    print(a.__dict__)    # 输出：{}
    print(vars(a))    # 输出：{}
    a.name = 'Kim'
    print(a.__dict__)    # 输出：{'name': 'Kim'}
    print(vars(a))    # 输出：{'name': 'Kim'}

## 5. 反射操作(8个) ##

### 5.1 **import**()，动态导入模块 ###

动态导入模块

index = __import__('index')
    index.sayHello()

### 5.2 isinstance()，判断实例 ###

判断对象是否是类或者类型元组中任意类元素的实例

isinstance(1,int)   # 输出：True
    isinstance(1,str)    # 输出：False
    isinstance(1,(int,str))    # 输出：True

### 5.3 issubclass()，判断子类 ###

判断类是否是另外一个类或者类型元组中任意类元素的子类

issubclass(bool,int)    # 输出：True
    issubclass(bool,str)      # 输出：False
    issubclass(bool,(str,int))     # 输出：True

### 5.4 hasattr()，判断属性 ###

检查对象是否含有属性

class Student:
        def __init__(self, name):
            self.name = name
    
    s = Student('Aim')
    hasattr(s, 'name')  # a含有name属性,True
    hasattr(s, 'age')   # a不含有age属性,False

### 5.5 getattr()，获取属性 ###

获取对象的属性值

class Student:
        def __init__(self, name):
            self.name = name
    
    s = Student('Aim')
    hasattr(s, 'name')  # a含有name属性,True
    hasattr(s, 'age')   # a不含有age属性,False
    
    getattr(s, 'name')   # 存在属性name，返回: Aim
    getattr(s,'age',0)   # 不存在属性age，但提供了默认值，返回默认值0;
    getattr(s,'age')     # 不存在属性age，没有默认值，则会报错；AttributeError: 'Stduent' object has no attribute 'age'

### 5.6 setattr() ，设置属性 ###

设置对象的属性值

class Student:
        def __init__(self,name):
            self.name = name
    
    a = Student('Kim')
    a.name    # 输出：'Kim'
    setattr(a,'name','Bob')    # 修改name
    a.name   # 输出：'Bob'

### 5.7 delattr()，删除属性 ###

删除对象的属性

#定义类A
    class A:
        def __init__(self,name):
            self.name = name
        def sayHello(self):
            print('hello',self.name)
    
    #测试属性和方法
    a.name    # 输出：'小麦'
    a.sayHello()    # 输出： hello 小麦
    
    #删除属性
    delattr(a,'name')
    a.name    # 报错：'A' object has no attribute 'name'

### 5.8 callable()，对象是否可调用 ###

检测对象是否可被调用

class B:  # 定义类B
        def __call__(self):
            print('instances are callable now.')
    
    callable(B)  # 类B是可调用对象，输出：True
    b = B()  # 调用类B
    callable(b)  # 实例b是可调用对象，输出：True
    b()  # 调用实例b成功，输出：instances are callable now.

## 6. 作用域变量操作(2个) ##

### 6.1 globals()，全局变量 & 值 ###

返回当前作用域内的全局变量和其值组成的字典

globals()  # 直接可以调用，查看当前的全局变量和其值组成的字典；

### 6.2 locals()，局部变量 & 值 ###

返回当前作用域内的局部变量和其值组成的字典

locals()  # 直接可以调用，查看当前的局部变量和其值组成的字典；

## 7. 交互操作(2个) ##

### 7.1 print()，打印输出 ###

向标准输出对象打印输出

print(1,2,3)    # 输出：1 2 3
    print(1,2,3,sep = '+')    # 输出：1+2+3
    print(1,2,3,sep = '+',end = '=?')    # 输出：1+2+3=?

### 7.2 input()，用户输入 ###

读取用户输入值

s = input('please input your name:')  # 代码运行到此，就需要用户进行输入；

## 8. 文件操作(1个) ##

### 8.1 open()，打开文件 ###

使用指定的模式和编码打开文件，返回文件读写对象

# t为文本读写，b为二进制读写
    a = open('test.txt','rt')
    a.read()    # 输出：'some text'
    a.close()

## 9. 编译执行(4个) ##

### 9.1 compile()，编译代码 ###

将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

#流程语句使用exec
    code1 = 'for i in range(0,10): print (i)'
    compile1 = compile(code1,'','exec')
    exec (compile1)

### 9.2 eval()，执行动态表达式 ###

执行动态表达式求值

eval('1+2+3+4')     # 输出：10

### 9.3 exec()，执行动态语句 ###

执行动态语句块

exec('a=1+2')  # 执行语句，

### 9.4 repr()，字符串表现形式 ###

返回一个对象的字符串表现形式(给解释器)

a = 'some text'
    str(a)    # 输出：'some text'
    repr(a)    # 输出："'some text'"

## 10. 装饰器(3个) ##

### 10.1 property()，属性装饰器 ###

标示属性的装饰器

class C:
        def __init__(self):
            self._name = ''
    
        @property
        def name(self):
            """i'm the 'name' property."""
            return self._name
    
        @name.setter
        def name(self, value):
            if value is None:
                raise RuntimeError('name can not be None')
            else:
                self._name = value
    
    c = C()
    
    print(c.name)    # 访问属性,输出为''
    
    c.name = 'Kim'  # 设置属性
    print(c.name)  # 访问属性，输出为：Kim
    
    c.name = None  # 设置属性时进行验证
    # 弹出错误： RuntimeError: name can not be None
    
    del c.name  # 删除属性，不提供deleter则不能删除

### 10.2 classmethod()，类装饰器 ###

标示方法为类方法的装饰器

class C:
        @classmethod
        def f(cls, arg1):
            print(cls)
            print(arg1)
    
    C.f('类对象调用类方法')
    # 输出如下：
    # <class '__main__.C'>
    # 类对象调用类方法
    
    c = C()
    c.f('类实例对象调用类方法')
    # 输出如下：
    # <class '__main__.C'>
    # 类实例对象调用类方法

### 10.3 staticmethod()，静态方法装饰器 ###

标示方法为静态方法的装饰器

# 使用装饰器定义静态方法
    class Student(object):
        def __init__(self, name):
            self.name = name
    
        @staticmethod
        def sayHello(lang):
            print(lang)
            if lang == 'en':
                print('Welcome!')
            else:
                print('你好！')
    
    Student.sayHello('en')  # 类调用,'en'传给了lang参数
    # 输出如下：
    # en
    # Welcome!
    
    b = Student('Kim')
    b.sayHello('zh')  # 类实例对象调用,'zh'传给了lang参数
    # 输出如下：
    # zh
    # 你好

本文参考地址：https://blog.csdn.net/oaa608868/article/details/53506188?utm\_medium=distribute.pc\_relevant.none-task-blog-title-9&spm=1001.2101.3001.4242