Python基础精进 - Day7

反向输出从用户输入的整数

def outPrint(a):
    b = 0
    temp = a
    while temp != 0:
        b = 10 * b + temp % 10
        temp //= 10
    return b


a = int(input())
print(outPrint(a))
a = str(a)
print(a[::-1])

输入三角形三个顶点的坐标，若有效则计算三角形的面积；如坐标无效，则给出提示

# 判断输入是否是 整数,整数
def judge(a):
    res = False
    if ',' in a and len(a.split(',')) == 2:
        for i in a.split(','):
            if i.isdigit() == False:
                break
        else:
            return True
    return res

def calDistance(a, b):
    return ((a[0] - b[0])**2 + (a[1] - b[1])**2)**0.5

temp = []
for i in range(3):
    a = input(f"请输入三角形第{i+1}个顶点的坐标,仅支持正整数, 格式为:11,22\n")
    while judge(a) == False:
        a = input("格式错误请重新输入！")
    temp.append(tuple(map(float, a.split(','))))

dist = [calDistance(temp[0], temp[1]), calDistance(temp[1],temp[2]), calDistance(temp[0],temp[2])]
dist.sort()
if dist[0] + dist[1] < dist[2]:
    print("不能构成三角形")
else:
    p = sum(dist)/2
    print((p * (p-dist[0]) * (p-dist[1]) * (p-dist[2])) ** 0.5)

面向对象

类用于定义数据类型的属性和方法，对象是类的具体实体。如果说对象是一个“饼干”，类就是制造这个饼干的“模具”。一个python对象包括三个部分：id（识别码），type(对象类型)，value(对象的值，包括属性和方法)。

__init__构造方法和__new__方法

1. __init__()方法的名称和第一个参数固定，通过类名（参数列表）来调用构造函数。

def __init__(self,name,score):
    self.name = name
    self.score = score

2. 如果不定义__init__方法，系统会提供一个默认的__init__方法。

3. 实例属性一般在__init__()方法中通过如下代码定义：

        self.实例属性名 = 初始值

实例属性和实例方法 

1. 实例属性可在本类的其他实例方法中被访问，使用 self.实例属性名 访问，也可通过实例对象访问， 格式为 对象名.实例属性名

2. 定义实例方法时，第一个参数必须为self，调用实例方法时不用也不能给self传参。

类属性与类方法 

1. 类属性的定义方式：

        class 类名：

                类变量名= 初始值

在类的外面，我们可以通过 “ 类名.类变量名 ”来读写

2. 类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

        @classmethod

        def 类方法名(cls [，形参列表]) ：

                函数体

P.S.

1. @classmethod 必须位于方法上面一行

2. 第一个 cls 必须有；cls 指的就是“类对象”本身；

3. 调用类方法格式：“类名.类方法名(参数列表)”。 参数列表中，不需要也不能给 cls 传值。

4. 类方法中访问实例属性和实例方法会导致错误, 类方法中只能使用cls访问类属性。

 静态方法

静态方法通过装饰器@staticmethod 来定义，格式如下：

        @staticmethod

        def 静态方法名([形参列表]) ：

                函数体

P.S.

1. @staticmethod 必须位于方法上面一行

2. 调用静态方法格式：“类名.静态方法名(参数列表)”。

3. 静态方法中访问实例属性和实例方法会导致错误

 私有属性、保护属性和公有属性

不像java的面向对象会通过公有(public)、私有(private)和受保护(protected)的关键字来控制对类资源的访问。
python没有有效限制访问任何实例变量或方法的机制。
python规定了在变量/方法名称前加单下划线或双下划线的约定，以模拟受保护和私有访问说明符的行为。

private属性

在变量/方法前加上双下划线__使其变为私有（__private）

私有属性是为了做访问限制，是为了程序的健壮性。如果可以从外部对函数里面重要的属性进行任意修改，有可能程序崩溃只是因为一次不经意地参数修改；子类无法访问父类的私有变量、方法，私有变量只有本类的内部能直接调用，如果非要调用，可以间接通过._类名__私有变量 来调用私有变量。

class A:
    __private = "私有变量"

    def test(self):
        print("实例对象 - 类内部调用私有变量：", self.__private)
        print("类对象 - 类内部调用私有变量：", A.__private)

    @classmethod
    def class_m(cls):
        print("类方法 - 类对象 - 类内部调用私有变量：", cls.__private)

    def __test(self):
        print("私有方法")


if __name__ == "__main__":
    a = A()
    a.test()
    print("实例对象 - 外部调用私有变量", a._A__private)
    A.class_m()
    print("类对象 - 外部调用私有变量", A._A__private)
    a._A__test()
-------------
实例对象 - 类内部调用私有变量： 私有变量
类对象 - 类内部调用私有变量： 私有变量
实例对象 - 外部调用私有变量 私有变量
类方法 - 类对象 - 类内部调用私有变量： 私有变量
类对象 - 外部调用私有变量 私有变量
私有方法

 protected属性

Python的实例变量受保护的约定是在其上添加前缀_（单个下划线 _protected）
父类的protected变量，子类能继承，与公共变量没太大区别

class A:
    _protected = "受保护的变量"

    def test(self):
        print("实例属性：", self._protected)
        print("类属性：", A._protected)

    def _test(self):
        print("受保护的方法")

    @classmethod
    def test2(cls):
        print("类方法中的类属性", cls._protected)


class B(A):
    def __init__(self):
        self._protected = "子类的受保护实例变量"
        print("子类实例属性：", self._protected)


if __name__ == '__main__':
    a = A()
    a.test()
    a.test2()
    a._test()
    b = B()
-----------------
实例属性： 受保护的变量
类属性： 受保护的变量
类方法中的类属性 受保护的变量
受保护的方法
子类实例属性： 子类的受保护实例变量