python基础

面向对象

  1. 定义一个狗类和一个人类：

    狗拥有属性：姓名、性别和品种 拥有方法：叫唤

    人类拥有属性：姓名、年龄、狗 拥有方法：遛狗

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    class Dog:

        def __init__(self,name,sex,variety):
            self.name = name
            self.sex = sex
            self.variety = variety

        @classmethod
        def cry_out(cls):
            print("叫唤")


    dog1 = Dog('小白','母狗','阿拉斯加')
    print(dog1.name,dog1.sex,dog1.variety)
    Dog.cry_out()

    class Person:

        def __init__(self, name, age, dog):
            self.name = name
            self.age = age
            self.dog = dog

        @classmethod
        def walk_the_dog(self):
            print("遛狗")

    p1 = Person("小明",'18','小白')
    print(p1.name,p1.age,p1.dog)
    Person.walk_the_dog()

  2. 定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Rectangle:
        def __init__(self,length,width):
            self.length = length
            self.width = width

        def area(self):
            return self.length * self.width

        def perimeter(self):
            return self.length * 2 + self.width * 2

    r1 = Rectangle(2,3)

    print(f'r1的面积是{r1.area()}周长是{r1.perimeter()}')

  3. 定义一个二维点类，拥有属性：x坐标、y坐标 拥有方法：求当前点到另外一个点的距离

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    """方法1"""
    class TwoDimensionalPoint:
        def __init__(self,x,y):
            self.x = x
            self.y = y

        def distance(self,x,y):
            return ((self.x - x) ** 2 + (self.y - y) ** 2) ** 0.5

    P1 = TwoDimensionalPoint(0,0)

    print(P1.distance(1,2))

    """方法2"""
    class TwoDimensionalPoint:
        def __init__(self,x,y):
            self.x = x
            self.y = y

        def distance(self,other):
            return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5

    P1 = TwoDimensionalPoint(0,0)
    P2 = TwoDimensionalPoint(1,2)
    print(P1.distance(P2))

  4. 定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    class Circle:
        pi = 3.14
        def __init__(self,radius,center=None):
            self.radius = radius
            self.center = center


        def area(self):
            return Circle.pi * self.radius ** 2

        def perimeter(self):
            return Circle.pi * self.radius * 2

        def external(self,other):
            P = ((self.center[0] - other.center[0])**2 + (self.center[1] - other.center[1])**2) ** 0.5
            if P == self.radius + other.radius:
                return '是外切'
            else:
                return "不是外切"

    C1 = Circle(3)
    print(f'圆C1的面积是{C1.area()}周长是{C1.perimeter()}')

    C1 = Circle(3,(1,2))
    C2 = Circle(6,(5,6))

    print(C1.external(C2))

  5. 定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Segment:
        def __init__(self,begin,end):
            self.begin = begin
            self.end = end

        def length(self):
            return ((self.begin[0] - self.end[0])**2 + (self.begin[1] - self.end[1])**2) ** 0.5

    S1 = Segment((0,0),(3,4))

    print(S1.length())