day17-面向对象

面向对象基础

1.编程思想

编程思想：面向过程编程、函数式编程、面向对象编程

编程实现功能：123*4…*10

面向过程编程

s = 1
for x in range(1,11):
    s *= x
print(s)

# 函数式编程：
from math import factorial
print(factorial(10))
print(factorial(5))

class Math:
    @staticmethod
    def factorial(mun:int):
        s = 1
        for x in range(1,mun+1):
            s *= x
        return s

2.面向对象

1.什么是类，什么是对象

'''
什么是类：拥有相同功能相同属性的对象的集合 (抽象的概念)
什么是对象：对象是类的实例  (具体的事物)

从生活的角度理解类和对象：
人是类，余婷就是对象，骆浩是另外一个对象
杯子是类，我的杯子就是对象

'''

2.创建类和对象

'''
1）创建类 - 就是用代码描述清楚这个类是拥有那些相同功能（函数）那些相同属性（变量）的对象集合
语法：
 class 类名：
    类的说明文档
    类的内容
    
说明：
class  -  关键字：固定写法
类名   -  程序员自己命名：
        要求：标识符，不是关键字
        规范：见名知义：驼峰式命名，并且第一个字母大写：不使用系统函数名、类名、模块名
：    -  固定写法
类的说明文档  - 多行注释
类的类容  - 包含属性和方法
           属性：类属性（类的字段）、对象属性
           方法：对象方法、类方法、静态方法
    
注：方法是定义在类中的函数

2） 创建对象
语法：
类名()

'''


# 创建类
class Person:
    """类的说明文档"""
    # 属性
    # 方法
    def edt(self):
        print('吃东西！')


# 创建对象
p1 = Person()
print(p1)

p2 = Person()
print(p2)

3.对象方法

1.什么是对象方法

1）怎么定义

直接定义在类中的函数就是对象方法

2）怎么调用：通过‘对象’. 的形式来调用

3）特点：

有默认参数self，这个参数在调用的时候不用传参，系统会自动将当前对象传给self。

class Student:
    # study是一个对象方法
    def study(self):
        print('学习')
        print(f'self:{self}')


    def eat(self, food):
        print(f'吃{food}')



stu1 = Student()
print(stu1)
stu1.study()

stu1.eat('米饭')

4.init方法

1.__init__方法 - 初始化方法

1）构造方法：函数名和类名相同来创建对象的函数就是构造函数（构造方法）

python的构造函数不需要程序员自习写，创建类的时候系统会自动创建类的构造函数

2）初始化方法：

a.当通过创建对象的时候系统会自动调用__init__方法

b.在调用构造函数创建对象的时候，需不需要参数，需要几个参数看对应的__init__方法self以外

有没有额外的参数，有几个额外的参数

c.成需要在类中添加__init__的方法的时候只需要保证方法名是init有默认参数self就可以

形参和函数体可以根据情况随便添加

补充：前后都有两个下划线的方法又叫魔法方法，这里方法不需要程序员去调用，在特定情况下会被自动调用

class Dog:
    def __init__(self, x):
        print('初始化方法')


p1 = Dog(10)  # 初始化方法
p2 = Dog(20)

5.属性

1.属性

1）类属性

a.怎么定义：直接定义在类中的变量

b.怎么使用：通过类.的方式来使用

c.什么时候用：属性值不会因为对象不同而不同

2）对象属性

a.怎么定义：以‘self。’属性名 = 值得形式定义在init__方法中

b.怎么舒勇：以‘对象。’得方式来使用

c.什么时候使用：属性值会因为对象不同而不一样得时候使用对象属性

class Circle:
    # a 是类属性
    a = 10
    # pi 是类属性
    pi = 3.1415926
    # radius就是对象属性

    def __init__(self):
        self.radius = 1



c1 = Circle()
# 使用对象属性
print(c1.radius)


print(Circle.a)


# 2.对象属性的初始值
'''没有默认值需要传参'''


class Person:
    def __init__(self, name, gender='男'):
        self.name = name
        self.gender = gender
        self.age = 0


p1 = Person('小明')
p2 = Person('张三')
p3 = Person('张三', '女')


print(p1.name, p1.gender)
print(p2.name, p2.gender)
print(p3.name, p3.gender)

# 3. 在对象方法中对象属性的使用

class Circle:
    pi = 3.1415926

    def __init__(self, radius):
        self.radius = radius

    def aren(self):
        # 如果在实现对象方法的功能的时候需要用到对象属性，由self来提供这个对象属性
        # return 圆周率 × 圆半径的平方
        return Circle.pi * self.radius ** 2

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



c1 = Circle(2)
c2 = Circle(4)

print(c1.aren())
print(c2.aren())


print(c1.perimeter())
print(c2.perimeter())

6.方法

1.方法 - 定义在类中的函数

1）对象方法

a.怎么定义 ： 直接定义在类中

b.怎么调用 ： 对象.

c.特点 ：有个默认参数self，self不用传参，谁调用self就指向谁

d.什么时候使用 ：如果实现函数的功能需要用到对象属性，就将定义成对象方法

2）类方法

a.怎么定义 ：定义函数前加装饰器@classmethod这样定义的函数就是类方法

b.怎么调用 ：类.的方式调用

c.特点 ：有个默认参数cls，调用的时候不用传参，系统自动将当前类传给cls

d.什么时候使用 ：在不需要对象属性的前提下，需要类

3）静态方法

a.怎么定义 ：定义函数前加装饰器@staticmethod

b.怎么调用 ：类.

c.特点 ：没有默认参数

d.什么时候使用 ：在不需要对象属性的前提下，也不需要类

class A:
    def func1(self):
        print('对象方法')

    @classmethod
    def func2(cls):
        print(f'cls:{cls}')
        print('类方法')
        b = cls()
        print(f'b:{b}')

    @staticmethod
    def func3():
        print('静态方法')


a = A()
a.func1()

print(f'A:{A}')
A.func2()

A.func3()

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

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

class Dog:
    def __init__(self, name1='大黄', sex='男', var='阿拉斯加'):
        self.name1 = name1
        self.sex = sex
        self.var = var

    def func1(self):
        print('叫唤')

a = Dog()
a.func1()

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

class Mankind:
    def __init__(self, name='吴亦凡', age='30', dog='阿拉斯加'):
        self.name = name
        self.age = age
        self.dog = dog

    def func2(self):
        print('遛狗')

walk = Mankind()
walk.func2()

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

   ​

   class Rectangle:
       def __init__(self, long, wide):
           self.long = long
           self.wide = wide
   
       def perimeter(self):
           return (self.long + self.wide)*2
   
       def area(self):
           return self.long * self.wide
   
   Y = Rectangle(19,10)
   print(Y.area())
   

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

   class TwoKind:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       def distance(self, x1, y1):
           return ((self.x-x1)**2+(self.y-y1)**2)**0.5
   
   
   i = TwoKind()
   print(i.distance())
   

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

   class Circle:
       pi = 3.1415926
   
       def __init__(self, r, x, y):
           self.r = r
           self.center = (x, y)
   
       def perimeter(self):
           return self.pi * (self.r*2)
   
       def area(self):
           return self.pi * (self.r**2)
   
       def exterior(self, r1, x1, y1):
           if self.r+r1 == ((self.center[0]-x1)**2+(self.center[1]-y1)**2)**0.5:
               return True
           return False
   

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

   class Segment:
       def __init__(self, x, x2):
           self.x = x
           self.x2 = x2
   
       def length(self):
           return self.x2-self.x
   
   
   Y = Segment(2, 10)
   print(Y.length())