week03day05(类和对象)

一. 类(class)

1. 定义类(创建类)

•  类就是分类，类别；就是对拥有相同属性或者相同功能对象的集合。
• 对象：对象就是这个概念的具体表现。 例如人就是类，我和具体的某一个人就是人类的对象。保温杯是类，我的保温杯就是对象

'''
语法：
class 类名:
     类的说明文档
     类的内容


说明：
class            -    关键字，固定写法
类名              -  由程序员自己命名（采用大驼峰命名方式）
类的说明文档：     -   本质就是多行注释
类的内容：        -    包含属性和方法
                     1. 属性：定义在类的变量，分为类属性和对象属性
                     2.方法： 定义在类中的函数，分为对象方法、类方法和静态方法
'''

class A:
    pass
# A 就是类

2. 创建对象

'''
语法：类名()

'''
x1 = A()
print(x1)

3.方法

1. 对象方法、类方法、静态方法：

'''
1. 对象方法：
 a.如何定义： 直接定义在类中的函数就是对象方法
 b.怎么调用： 对象方法要通过对象来调用     对象.xxx()
 c. 特点：   通过对象调用对象方法的时候默认参数self不需要传参，系统会自动将对象传给self()，谁调用
self就是谁



2. 类方法：
a.如何定义： 在定义函数前加 @classmethod
b.怎么调用： 通过类去调用   - 类名.xxx()
c.特点： 有个默认参数cls，调用类方法的时候默认参数cls不需要传参，系统会自动将当前类传给cls(谁调用就指向谁)



3. 静态方法：
a. 如何定义：在定义函数前加 @staticmethod
b. 如何调用：通过类去调用   - 类名.xxx()
c.特点：没有默认参数



'''
class A:
    def func1(self): #
        print('对象方法')
        print(f"self:{self}")

    @classmethod
    def func2(cls):
        print('类方法')

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

# 创建A的对象到a1中
a1 = A()
a2= A()
print(f"a1:{a1}") #a1:<__main__.A object at 0x7f87f0041e80>
print(f"a2:{a2}") #a2:<__main__.A object at 0x7f87f0041d90>

# 通过对象调用对象方法
a1.func1() #self:<__main__.A object at 0x7f87f0041e80>
a2.func1() #self:<__main__.A object at 0x7f87f0041d90>


# 通过对象调用对象方法
a1.func1()
a2.func1()

A.func2()
A.func3()

2.魔法方法：

a.魔法方法是类自带的方法，这种方法有两个特点：

• 方法名是以_ _开头并且以_ _ 结尾
• 不同的魔法方法会在特定的场景下自动调用

3. _ _ init _ _ 方法

'''

__init__方法： 每次创建类的对象的时候，系统就会自动调用这个类的__init__方法
注意： 创建类的对象的时候需不需要参数需要几个参数由类中的 __init__方法决定。

'''
class B:
    def __init__(self,x,y=2):
        print(f'x:{x},y:{y}')
        print('init方法')
b1 = B(100)
# 这里的x 和 y 决定需要给两个实参，但是y=2已经给了默认值了，所以给一个两个位置参数都可以，
#也可以直接命名比如 x=200，y=10

4. 属性

    1.属性定义：

•    定义在类中的变量

    2. 类属性、对象属性

'''
1.类属性
定义：直接定义在类中的变量就是类属性，又叫字段
怎么使用：通过类去使用类属性     --   类名.xxx
什么时候去用： 如果属性的值不会因为对象不同而不一样就用类属性

2. 对象属性
定义： 以 'self.xxx = 值' 的方式定义在 __init__方法中。
怎么使用： 通过对象去使用对象属性     - 对象.xxx
什么时候使用： 如果属性的值会因为对象不同而不一样就要对象属性
'''

class A:
    #x就是类属性（在外面用不了这个x）
    x=10

    #y和z就是对象属性
    def __init__(self):
        self.y =20
        self.z =30
A.x = 100
print(A.x)
print(A)

#创建A类的对象
a1 = A()
#通过对象使用对象的属性
print(a1.y,a1.z)
#修改对象属性
a1.y =50
print(a1.y)


class Circle:
    pi = 3.1415926

    def __init__(self):
        self.r = 1

    def area(self):
        # 在对象方法中实现函数的功能如果需要对象属性通过self来提供。
        return Circle.pi * self.r **2

    def zhouchang(self):
        return Circle.pi * 2 * self.r

c1 = Circle()
c1.r = 10

c2 = Circle()
c2.r = 5
print(c1.area())
print(c2.area())
print(c1.zhouchang())

3. 对象属性默认值以及 ‘repr’ 方法。

class B:
    def __init__(self,y,z):
        self.x = 10
        self.y =y
        self.z =z

### 打印类的对象的时候会自动调用__repr__方法，这个方法中的self是当前打印对象；返回值必须是字符串，这个字符串是打印结果
    def __repr__(self):
        # return f'x:{self.x},y:{self.y},z:{self.z}'
        return str(self.__dict__)


b1 = B(20,30)
print(b1)

5. 继承

1.定义 ：

• 让子类直接拥有父类的属性和方法

'''
class 类名(父类1，父类2，.... ):
    类的说明文档
    类的内容

object是python的基类，python中所以的类都是直接或者间接的继承这个类
如果定义类的时候没有指定类的父类，这个类的父类就是object
'''
class A:
    x = 100

    def __init__(self):
        self.m = 200
        self.n = 300

    def func1(self):
        print('a中的对象方法')

    @classmethod
    def func2(cls):
        print('a的类方法')

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

class B(A):
    pass
    def __init__(self):
        super.__init__() #调用父类的__init__()
        self.age = 18


print(B.x)