Python学习笔记（十三）format()数字格式化 和 内置函数(25-52)

format()数字格式化

下表展示了 str.format() 格式化数字的多种方法：

>>> print("{:.2f}".format(3.1415926))

3.14

^, <, > 分别是居中、左对齐、右对齐，后面带宽度，

: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；

  （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

实例

#!/usr/bin/python 

# -*- coding: UTF-8 -*- 

print ("{} 对应的位置是 {{0}}".format("runoob"))

输出结果为：

runoob 对应的位置是 {0}

# 25、frozenset()：
'''
描述：
    返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法：
    frozenset([iterable])
参数：
    iterable--可迭代的对象，比如列表、字典、元组等等。
返回值：
    返回新的frozenset对象，如果不提供任何参数，默认会生成空集合
'''
print(frozenset())
# frozenset()
a = frozenset(range(10))    # 生成一个新的不可变集合
print(a)
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset('runoob')     # 创建不可变集合
print(b)
# frozenset({'r', 'o', 'u', 'n', 'b'})
'''
为什么需要冻结的集合（即不可变的集合）呢？
因为在集合的关系中，有的集合中的元素是另一个集合的情况，但是普通集合（set）本身是可变的，
那么它的实例就不能存放在另一个集合中（set中的元素必须是不可变类型）。
所以，frozenset提供了不可变的集合的功能，当集合不可变时，
它就满足了作为集合中的元素的要求，就可以放在另一个集合中了。
'''


# 26、getattr()：
'''
描述：
    用于返回一个对象属性值
语法：
    getattr(object, name[, default])
参数：
    object--对象
    name--字符串，对象属性
    default--默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError
返回值：
    返回对象属性值
'''
class A(object):
    bar = 11

a = A()
print(getattr(a, 'bar'))    # 获取类属性bar的值
# print(getattr(a, 'bar2'))   # 属性bar2不存在，触发异常AttributeError: 'A' object has no attribute 'bar2'
print(getattr(a, 'bar2', -1))   # 属性bar2不存在，但设置了默认值-1，返回值为-1

class A():
    def set(self, a, b):
        x = a
        a = b
        b = x
        print(a, b)

a = A()
c = getattr(a, 'set')
c(a='1', b='2')     # 打印结果：2 1
##### 看不懂 #####


# 27、globals()：
'''
描述：
    以字典类型返回当前位置的全部全局变量。对比locals()函数
语法：
    globals()
参数：
    无
返回值：
    以字典类型返回当前位置的全部全局变量
'''
print(globals())    # globals函数返回一个全局变量的字典，包括所有导入的变量
# {'__name__': '__main__', '__doc__': '\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001D272980910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Project/Pycharm/Project1/review1.py', '__cached__': None, 'A': <class '__main__.A'>, 'Coordinate': <class '__main__.Coordinate'>, 'point1': <__main__.Coordinate object at 0x000001D2745EB2E0>, 'a': <__main__.A object at 0x000001D2745EBE50>, 'b': frozenset({'u', 'o', 'b', 'n', 'r'}), 'c': <bound method A.set of <__main__.A object at 0x000001D2745EBE50>>, 'zipped': <zip object at 0x000001D274601E80>, 'a1': (1, 2, 3), 'a2': (4, 5, 6), 'b1': (1, 2, 3), 'b2': (4, 5, 6), 'seasons': ['Spring', 'Summer', 'Autumn', 'Winter'], 'i': 4, 'seq': ['one', 'two', 'three', 'four'], 'element': 'four', 'x': 10, 'n': 81, 'expr': '\nz = 30\nsum = x + y + z\nprint(sum)\n', 'func': <function func at 0x000001D2729661F0>, 'list1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'is_odd': <function is_odd at 0x000001D2745EA670>, 'tmplist': <filter object at 0x000001D2745EBC70>, 'newlist': [1, 4, 9, 16, 25, 36, 49, 64, 81, 100], 'math': <module 'math' (built-in)>, 'is_sqr': <function is_sqr at 0x000001D2745EA700>, 'site': {'name': '', 'url': 'www.com'}, 'my_list': ['', 'www..com'], 'AssignValue': <class '__main__.AssignValue'>, 'my_value': <__main__.AssignValue object at 0x000001D2745EBC40>}


# 28、hasattr()：
'''
描述：
    用于判断对象是否包含对应的属性
语法：
    hasattr(object, name)
参数：
    object--对象
    name--字符串，属性名
返回值：
    如果对象有该属性返回True，否则返回False
'''
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，没有该属性


# 29、hash()：
'''
描述：
    用于获取一个对象（字符串或数值等）的哈希值
语法：
    hash(object)
参数：
    object--对象
返回值：
    返回对象的哈希值
'''
print(hash('test'))  # 字符串，结果3138493826556676253
print(hash(123456789))  # 数字，结果123456789
print(hash(str([1, 2, 3]))) # 集合，结果3084751386921177152
print(hash(str(sorted({'a': 1}))))  # 字典，结果-2240541016805128389


# 30、help()：
'''
描述：
    用于查看函数或模块用途的详细说明
语法：
    help([object])
参数：
    object--对象
返回值：
    返回对象帮助信息
'''
help('sys')     # 查看sys模块的帮助
# ......显示帮助信息......
help('str')     # 查看str模块的帮助
# ......显示帮助信息......
a = [1, 2, 3]   # 查看列表list帮助信息
help(a)
# ......显示帮助信息......
help(a.append)  # 显示list的append方法的帮助
# ......显示帮助信息......

# 31、hex()：
'''
描述：
    用于将一个指定数字转换为16进制数
语法：
    hex(x)
参数：
    x--一个整数
返回值：
    返回一个字符串，以0x开头
'''
print(hex(255))      # 0xff
print(hex(-42))      # -0x2a
print(hex(12))       # 0xc
print(type(hex(12))) # <class 'str'>


# 32、id()：
'''
描述：
    id()函数返回对象的唯一标识符，标识符是一个整数。
    CPython中id()函数用于获取对象的内存地址。
语法：
    id([object])
参数：
    object--对象
返回值：
    返回对象的内存地址
'''
a = 'runoob'
print(id(a))    # 2604293190192
b = 1
print(id(b))    # 140719388104352


# 33、input()：
'''
描述：
    Python3.x中input()函数接收一个标准输入数据，返回string类型。

    注意：在Python3.x中raw_input()和input()进行了整合，去除了raw_input()，仅保留了
    input()函数，其接收任意性输入，将所有输入默认为字符串处理，并返回字符串类型。
语法：
    input([prompt])
参数：
    prompt--提示信息
返回值：

'''
### input()需要输入python表达式
a = input('input: ')    # 输入整数：123
print(type(a))          # 字符串类型：<class 'str'>
b = input('input: ')    # 输入字符串表达式：runoob
print(type(b))          # 字符串类型：<class 'str'>

### input()接收多个值
# 输入三角形的三边长
a, b, c = (input('请输入三角形三边的长：').split())
a = int(a)
b = int(b)
c = int(c)
# 计算三角形的半周长p
p = (a + b + c) / 2
# 计算三角形的面积s
s = (p * (p - a) * (p - b) * (p - c)) ** 0.5
# 输出三角形的面积
result_list = [a, b, c, p, s]
print('''三角形的三边长为：{:.2f}，{:.2f}，{:.2f}
三角形的半周长p为：{:.2f}
三角形的面积s为：{:.2f}'''.format(*result_list))


# 34、int()：
'''
描述：
    用于将一个字符串或数字转换为整型
语法：
    int(x, base=10)
参数：
    x--字符串或数字
    base--进字数，默认为十进制
返回值：
    返回整型数据
'''
print(int())    # 不传入参数时，得到结果0
print(int(3))   # 3
print(int(3.6)) # 3
print(int('12', 16))    # 18，如果是带参数base的话，12要以字符串形式输入，12为16进制
print(int('0xa', 16))   # 10
print(int('10', 8))     # 8
print(int('1001', 2))   # 1001才是2进制格式，转换为十进制数字9
print(int('123', 8))    # 视123为8进制数，对应的10进制为83


# 35、isinstance()：
'''
描述：
    判断一个对象是否是一个已知的类型，类似type()。

    instance()和type()的却别：
        instance()会认为子类是一种父类类型，考虑继承关系。
        type()不会认为子类是一种父类类型，不考虑继承关系。

    如果要判断两个类型是否相同，推荐使用isinstance()。
语法：
    isinstance(object, classinfo)
参数：
    object--实例对象
    classinfo--可以是直接或间接类名、基本类型或者由它们组成的元组。

    对于基本类型来说，classinfo可以是--int, float, bool, complex, str(字符串), list, dict(字典), set, tuple
    要注意的是，classinfo的字符串是str而不是string，字典也是简写dict
返回值：
    如果对象的类型与参数二的类型（classinfo）相同则返回True，否则返回False。
'''
a = 2
print(isinstance(a, int))               # True
print(isinstance(a, str))               # False
print(isinstance(a, (str, int, list)))  # 是元组中的一个，返回True
print('---------------')
# type()与isinstance()区别：
class A:
    pass

class B(A):
    pass

print(isinstance(A(), A))   # True
print(type(A()) == A)       # True
print(isinstance(B(), A))   # True，考虑继承关系
print(type(B()) == A)       # False，不考虑继承关系


# 36、issubclass()：
'''
描述：
    用于判断参数class是否是类型参数classinfo的子类
语法：
    issubclass(class, classinfo)
参数：
    class--类
    classinfo--类
返回值：
    如果class是classinfo的子类则返回True，否则返回False
'''
class A:
    pass

class B(A):
    pass

print(issubclass(B, A))     # True


# 37、iter()：
'''
描述：
    用来生成迭代器
语法：
    iter(object[, sentinel])    sentinel标记，哨兵，守卫，放哨
参数：
    object--支持迭代的集合对象
    sentinel--如果传递了第二个参数，则参数object必须是一个可调用的对象（如函数），此时，
        iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用object。
返回值：
    迭代器对象
'''
lst = [1, 2, 3]
for i in iter(lst):
    print(i)


# 38、len()：
'''
描述：
    返回对象(字符、列表、元组等)长度或项目个数

    len()是内置函数，返回对象的长度（元素个数）。
    实参可以是序列（如string、bytes、tuple、list或range等）
    也可以是集合（如dictionary、set或frozenset等）。
    len()不是字符串类的方法。
语法：
    len(s)
参数：
    s--对象
返回值：
    返回对象长度
'''
str = 'runoob'
print(len(str))     # 字符串长度 6
lst = [1, 2, 3, 4, 5]
print(len(lst))     # 列表元素个数 5


# 39、list()：
'''
描述：
    用于将元组或字符串转换为列表。
    注意：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是()，列表是[]
语法：
    list(seq)
参数：
    seq--要转换为列表的元组或字符串
返回值：
    返回列表
'''
tuple1 = (123, 'Google', 'Runoob', 'Taobao')
print('元组元素：', tuple1)
# 元组元素： (123, 'Google', 'Runoob', 'Taobao')
list1 = list(tuple1)
print('列表元素：', list1)
# 列表元素： [123, 'Google', 'Runoob', 'Taobao']

str = 'hello world'
print('字符串：', str)
# 字符串： hello world
list2 = list(str)
print('列表元素：', list2)
# 列表元素： ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']


# 40、locals()：
'''
描述：
    locals()函数会以字典类型返回当前位置的全部局部变量。对比globals()函数
    对于函数，方法，lambda表达式，类，以及实现了__call__方法的类实例，它都返回True。
语法：
    locals()
参数：
    无
返回值：
    返回字典类型的局部变量
'''
print(locals())
# {'__name__': '__main__', '__doc__': '\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001E9BAAAF910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Project/Pycharm/Project1/review1.py', '__cached__': None}
print(globals())
# {'__name__': '__main__', '__doc__': '\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001E9BAAAF910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Project/Pycharm/Project1/review1.py', '__cached__': None}

def runoob(arg):    # 两个局部变量：arg、z
    z = 1
    print(locals())
    # {'arg': 4, 'z': 1}
    print(globals())
    # {'__name__': '__main__', '__doc__': '\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002758D87F910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Project/Pycharm/Project1/review1.py', '__cached__': None, 'runoob': <function runoob at 0x000002758D8661F0>}

runoob(4)


# 41、map()：
'''
描述：
    map()函数会根据提供的函数对指定序列做映射。
    第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次
    function函数返回值的新列表
语法：
    map(function, iterable, ...)
参数：
    function--函数
    iterable--一个或多个序列
返回值：
    返回一个迭代器
'''
def square(x):  # 计算平方数
    return x ** 2

print(map(square, [1, 2, 3, 4, 5]))    # 计算列表中各个元素的平方
# <map object at 0x000001DE5EFFB6D0>   # 返回迭代器
print(list(map(square, [1, 2, 3, 4, 5]))) # 使用list()转换为列表
# [1, 4, 9, 16, 25]
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用lambda匿名函数
# [1, 4, 9, 16, 25]


# 42、max()：
'''
描述：
    返回给定参数的最大值，参数可以为序列
语法：
    max(x, y, z, ...)
参数：
    x--数值表达式
    y--数值表达式
    z--数值表达式
返回值：
    返回给定参数的最大值
'''
print('max(80, 100, 1000):',max(80, 100, 1000))
print('max(-20, 100, 400):',max(-20, 100, 400))
print('max(-80, -20, -10):',max(-80, -20, -10))
print('max(0, -100, -400):',max(0, -100, -400))


# 43、min()：
'''
描述：
    返回给定参数的最小值，参数可以为序列
语法：
    min(x, y, z, ...)
参数：
    x--数值表达式
    y--数值表达式
    z--数值表达式
返回值：
    返回给定参数的最小值
'''
print('max(80, 100, 1000):',max(80, 100, 1000))
print('max(-20, 100, 400):',max(-20, 100, 400))
print('max(-80, -20, -10):',max(-80, -20, -10))
print('max(0, -100, -400):',max(0, -100, -400))


# 44、memoryview()：
'''
描述：
    返回给定参数的内存查看对象（memory view）。
    所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，
    在不需要复制对象的基础上允许Python代码访问。
语法：
    memoryview(obj)
参数：
    obj--对象
返回值：
    返回元组列表
'''
### Python2.x应用：
v = memoryview('abcdef')
print(v[1])     # b
print(v[-1])    # f
print(v[1:4])   # <memory at 0x00000000033399D8>
print(v[1:4].tobytes()) # bcd
print(v[1:4].tolist())  # [98, 99, 100]

### Python3.x应用：
v = memoryview(bytearray('abcdef', 'utf-8'))
print(v[1])     # 98
print(v[-1])    # 102
print(v[1:4])   # <memory at 0x000001E231C69340>
print(v[1:4].tobytes()) # b'bcd'
print(v[1:4].tolist())  # [98, 99, 100]


# 45、next()：
'''
描述：
    next()返回迭代器的下一个项目
    next()函数要和生成迭代器的iter()函数一起使用。
语法：
    next(iterable[, default])
参数：
    iterable--可迭代对象
    default--可选，用于设置在没有下一个元素时的默认返回值，
        如果不设置且又没有下一个元素，则会触发StopIteration异常。
返回值：
    返回迭代器的下一个项目
'''
# 首先获得Iterator对象：
ite = iter([1, 2, 3, 4, 5])
# 循环：
while True:
    try:
        # 获得下一个值：
        x = next(ite)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        print('没有可返回的元素！')
        break
'''打印结果
1
2
3
4
5
没有可返回的元素！'''
# y = next(ite)   # 报出异常：StopIteration


# 46、object()：
'''
描述：
    创建一个空对象
    不能向这个对象添加新的属性或方法。
    这个对象是所有类的基础，它拥有所有类默认的内置属性和方法。
语法：
    object()
参数：
    无参数
返回值：
    返回一个空对象
'''
# help(object())  # 查看object()函数的帮助
x = object()
print(x)
# <object object at 0x0000027DED394FE0>
print(dir(x))   # 查看对象x的属性、方法列表
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']


# 47、oct()：
'''
描述：
    将一个整数转换成8进制字符串，8进制以0o作为前缀表示
语法：
    oct(x)
参数：
    x--整数
返回值：
    返回8进制字符串
'''
print(oct(10))  # 0o12
print(oct(20))  # 0o24
print(oct(15))  # 0o17


# 48、open()：
'''
描述：
    Python open()函数用于打开一个文件，并返回文件对象。
    在对文件进行处理过程中都需要使用到这个函数，
    如果该文件无法被打开，则会抛出OSError异常。
    
    注意：
        使用open()函数一定要保证关闭文件对象，即调用close()函数。
        open()函数常用形式是接收两个参数：文件名（file）和模式（mode）
语法：
    open(file, mode='r')
    open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数：
    file--必选，文件路径（相对路径或绝对路径）
    mode--可选，文件打开模式
    buffering--设置缓冲
    encoding--一般使用utf8
    errors--报错级别
    newline--区分换行符
    closefd--传入的file参数类型
    opener--
mode参数：
    默认为t模式（文本模式），如果要以二进制模式打开，加上b
    
    t--文本模式（默认）
    x--写模式，新建一个文件，如果该文件已存在则会报错
    b--二进制模式
    +--打开一个文件进行更新（可读可写）
    U--通用换行模式（不推荐）
    r--以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式
    rb--以只读、二进制格式打开一个文件。文件指针将会放在文件的开头，这是默认模式，一般用于非文本文件如图片等。
    r+--打开一个文件用于读写。文件指针将会放在文件的开头
    rb+--以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
    w--打开一个文件只用于写入。如果该文件已存在则打开文件，并从头开始编辑，即原有内容会被删除。如果该文件不存在，则创建新文件。
    wb--以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编写，即原有内容会被删除。如果该文件不存在，则创建新文件。一般用于非文本文件如图片等。
    w+--打开一个文件用于读写。如果该文件已存在则打开文件，并从头开始编辑，即原有内容会被删除。如果该文件不存在，则创建新文件。
    wb+--以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从头开始编辑，即原有内容会被删除。如果该文件不存在，则创建新文件。一般用于非文本文件如图片等。
    a--打开一个文件用于追加。如果该文件已经存在，文件指针将会放在文件的结尾，也就是说，新的内容会被写入到已有内容之后。如果该文件不存在，则创建新文件进行写入。
    ab--以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾，也就是说，新的内容会被写入到已有内容之后。如果该文件不存在，则创建新文件进行写入。
    a+--打开一个文件用于读写。如果该我呢见已存在，文件指针将会放在文件的结尾。文件打开时为追加模式。如果文件不存在，则创建新文件用于读写。
    ab+--以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，则创建新文件用于读写。
返回值：
    <_io.TextIOWrapper name='users.txt' mode='r' encoding='cp936'>
'''
f = open('users.txt')
print(f)
# <_io.TextIOWrapper name='users.txt' mode='r' encoding='cp936'>
print(f.read())
# admin:Qwer1234
# test:test123


# 49、ord()：
'''
描述：
    ord()函数是chr()函数（对于8位的ASCII字符串）的配对函数，它以一个字符串（Unicode字符）
    作为参数，返回对应的ASCII数值，或者Unicode数值。
语法：
    odr(c)
参数：
    c--字符
返回值：
    返回值是对应的十进制整数
'''
print(ord('a')) # 97
print(ord('A')) # 65


# 50、pow()：
'''
描述：
    pow()方法返回x^y（x的y次方）的值
语法：
    math模块pow()方法的语法：
        import math
        
        math.pow(x, y)
    内置的pow()方法的语法：
        pow(x, y[, z])
    函数是机选x的y次方，如果z存在，则再对结果进行取模，其结果等效于pow(x, y) % z
注意：
    pow()通过内置的方法直接调用，内置方法会把参数作为整型int，
    而math模块则会把参数转换为浮点型float。
参数：
    x--数值表达式
    y--数值表达式
    z--数值表达式
返回值：
    返回x^y（x的y次方）的值
'''
import math     # 导入math模块

# 使用math模块的pow()函数
print('math.pow(100, 2):', math.pow(100, 2))    # math.pow(100, 2): 10000.0
print('math.pow(100, -2):', math.pow(100, -2))  # math.pow(100, -2): 0.0001
print('math.pow(2, 4):', math.pow(2, 4))        # math.pow(2, 4): 16.0
# 使用内置的pow()函数
print('pow(100, 2):', pow(100, 2))   # pow(100, 2): 10000
print('pow(100, -2):', pow(100, -2)) # pow(100, -2): 0.0001
print('pow(2, 4):', pow(2, 4))       # pow(2, 4): 16


# 51、print()：
'''
描述：
    用于打印输出，最常见的一个函数
    在Python3.3版增加了flush关键字参数。
    print()在Python3.x是一个函数，在Python2.x只是一个关键字，不是函数
语法：
    print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
参数：
    objects--复数，表示可以一次输出多个对象。输出多个对象时，需要使用逗号（,）分隔。
    sep--分隔符，用来间隔多个对象，默认是一个空格。
    end--结尾符，用来设定以什么结尾，默认是一个换行符\n，可以换成其他字符串。
    file--要写入的文件对象。
    flush--输出是否被缓存，通常决定于file，但如果flush关键字参数为True，流会被强制刷新。
返回值：
    无
'''
print(123456789)            # 123456789
print(type(123456789))      # <class 'int'>
print('hello world')        # hello world
print(type('hello world'))  # <class 'str'>
print('www', ' ', 'com', sep='.')  # 设置分隔符


### 使用flush参数生成一个Loading的效果
import time

print('--- RUNOOB EXAMPLE ：Loading 效果---')
print('Loading', end='')
for i in range(3):
    print('.', end='', flush=True)
    time.sleep(0.5)
print()

# 52、property()：
'''
https://www.runoob.com/python/python-func-property.html
http://c.biancheng.net/view/2286.html
描述：
    在新式类中返回属性值
语法：
    属性名 = property([fget=None[, fset=None[, fdel=None[, docstring=None]]]])
参数：
    fget--获取属性值的函数
    fset--设置属性值的函数
    fdel--删除属性值函数
    docstring--文档字符串，即属性描述信息，用于说明此函数的作用
    
    在使用 property() 函数时，以上 4 个参数可以仅指定第 1 个、或者前 2 个、或者前 3 个，当前也可以全部指定。也就是说，property() 函数中参数的指定并不是完全随意的。
返回值：
    返回新式类属性
'''
class C(object):
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")
'''
如果c是C的实例化，则c.x将触发getter， c.x = value触发setter， del c.x触发deleter。
如果给定doc参数，其将称为这个属性值的
'''
class CLanguage:
    # 构造函数
    def __init__(self, n):
        self.__name = n

    # 设置name属性值的函数
    def setname(self, n):
        self.__name = n
    # 访问name属性值的函数
    def getname(self):
        # 注意：
        # 由于getname()方法中需要返回name属性，如果使用self.name的话，其本身又被调用getname()，这样会陷入死循环。
        # 为了避免这种情况，程序中的name属性不能是公有属性，必须是私有属性__name或受保护的属性_name，
        # 否则将产生死循环并报错RecursionError: maximum recursion depth exceeded。
        return self.__name
    # 删除name属性值的函数
    def delname(self):
        self.__name = 'attribute has been deleted!'
        # 或
        # del self.__name   # 使用该语句则抛出异常：AttributeError: 'CLanguage' object has no attribute '_CLanguage__name'

    # 为name属性配置property()函数
    name = property(getname, setname, delname, '此处为property函数的docstring说明...')

# 调取说明文档的2种方式
print(CLanguage.name.__doc__)   # 此处为property函数的docstring说明...
help(CLanguage.name)
'''
打印结果：
Help on property:

    此处为property函数的docstring说明...
'''
clang = CLanguage('C语言中文网')
# 调用getname()方法，获取属性值__name
print(clang.name)   # C语言中文网

# 调用setname()方法，设置属性值__name
clang.name = 'Python教程'
print(clang.name)   # Python教程

# 调用delname()方法，删除属性值__name
del clang.name
print(clang.name)   # property has been deleted!
'''
当然，property()函数也可以少传入几个参数，以上面程序为例，我们可以将property()函数修改如下
    name = property(getname, setname)
这意味着，name是一个可读写的属性，但不能删除，因为property()函数中并没有为name配置用于该属性的函数方法。
也就是说，即便Clanguage类中设计有delname()函数，这种情况也不能用来删除name属性，否则会报错AttributeError: can't delete attribute。

同理，还可以像如下这样使用property()函数：
    name = property(getname)    # name属性可读、不可写、不可删除
    name = property(getname, setname, delname)  # name属性可读、可写、可删除，但没有说明文档
'''