day14笔记-ClassAndObject

一.recode

1.类的声明
类是拥有相同属性和相同功能的对象的集合

class 类名:
    类的内容

2.创建对象
对象 = 类()
3.(重点!)类中的内容:对象方法、类方法、静态方法;字段、对象属性

"""
1) 方法  -  怎么声明、特点、怎么调用、什么时候用
对象方法:直接声明在类中的函数;有默认参数self;通过对象调用;实现函数功能需要用到对象属性的时候
类方法:声明前加@classmethod;有默认参数cls;通过类调用;实现函数功能不需要对象属性,需要类相关的时候
静态方法:声明前@staticmethod;没有默认参数;通过类调用;既不需要对象属性,也不需要类相关操作

2)属性  -  怎么声明、怎么使用、什么时候用
字段:声明在类里面,函数的外面;通过类使用;不会因为对象不同而不同的属性声明成字段
对象属性:以‘self.属性=值’的形式声明在__init__方法中;通过对象使用;会因为对象不同而不同的属性声明成对象属性
"""

4.对象属性的增删改查

"""
对象.属性/getatter()  -  查
对象.属性 = 值/ setatter()  -  增、改
"""
class Person:
    number = 100

    def __init__(self):
        self.name = '小明'

    def func1(self):
        # print(Person.number)
        print(self.name)

    @classmethod
    def func2(cls):
        print('cls:',cls)
        print(cls.number)

    @staticmethod
    def func3():
        print(Person)
        print(Person.number)


p1 = Person()
p1.func1()
# Person.func2()
# Person.func3()


class Student(Person):
    pass


Person.func3()
Person.func2()
print('============')
Student.func3()
Student.func2()

二.homework

三.property1

1.内置类函数
创建类的时候,系统默认为我们添加的类的属性

class Person:
    """说明文档:人类"""
    # 类的字段
    number = 61

    # 对象属性
    def __init__(self, name, age=0, gender='女'):
        self.name = name
        self.age = age
        self.gender = gender

    # ============方法==========
    def object_func(self):
        print('对象方法: '+self.name)

    @classmethod
    def class_func(cls):
        print('类方法: ', cls.number)

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

# 系统自带的魔法,可以定制当前类的对象的打印内容.实现这个函数的时候# 要求有一个字符串类型的返回值
影响单独打印对象的效果

def __str__(self):
    return str(self.__dict__)[1:-1]

# 对象作为元素的时候的打印效果
def __repr__(self):
    return '<'+str(self.__dict__)[1:-1]+'>'

p1 = Person('小明', 18, '男')
# 1.__name__    字段
"""
类.__name__   -  获取类的名字
"""
print(Person.__name__, type(Person.__name__))   #  Person <class 'str'>

2.__doc__     字段
"""
类.__doc__    -  获取类的说明文档
"""
print(Person.__doc__)   #  人类

3.__class__    对象属性
"""
对象.__class__   -  获取对象对应的类(你这个对象是哪个类的对象)
print(p1.__class__)  #  <class '__main__.Person'>

"""
4.__dict__   字段/对象属性
"""
类.__dict__  -  获取类中所有的字段和对应的值,以字典的形式返回(了解)
对象.__dict__  -  获取对象中所有的属性和对应的值,以字典的形式返回(掌握)
"""
print(Person.__dict__)  
print(p1.__dict__)  #  {'name': '小明', 'age': 18, 'gender': '男'}

5.__module__   字段
"""
类.__module__  -  获取指定的类声明在哪个模块中,返回模块名(获取类所在的模块的__name__属性的值)
"""
print(Person.__module__)  # __main__

6.__bases__   字段
"""
类.__bases__   -  返回当前类的所有父类
"""
print(Person.__bases__)  # (<class 'object'>,)
class A(Person, int):
    pass


print(A.__bases__)

print('p1:', p1)

persons = [p1, Person('小花', 20)]
print(persons)

2.slots魔法

"""
可以通过给__slots__字符赋值来约束当前类有哪些对象属性;当在类中给__slots__赋值后,当前类的对象的__dict__属性无效
"""
class Dog:
    __slots__ = ('name', 'age', 'gender', 'name1')

    def __init__(self, name, age=0):
        self.name = name
        self.age = age
        self.gender = '公'


dog = Dog('大黄')

四.privateprotect

"""
1.高级语言
在很多的高级面向对象语言中,会将属性和方法分为公开的(在类的外部可以使用)、私有的(只能在类的内部使用,不能被继承)、受保护的(只能在类的内部使用,可以被继承)三类
2.python
python中类的内容本质上全部都是公开的。私有和公开都只是约定
1)私有化  - a.内容只能在内部使用,不能再外面使用(效果)
            b.在类中的方法名或者属性名前加'__',那么对应的属性和方法就会变成私有的(怎么私有化)
            c.当声明类的时候在名字前加'__',内部会在这个基础前面加'_类名'(私有化的本质)

2)属性保护  -  可通过在对象属性前加'_',把这个属性标记成受保护类型;为了告诉别人这个属性在使用的时候,不要直接用,而是通过getter和setter来使用
a. getter  -  获取对象的属性值之前想要干点别的事情,那么就给这个属性添加getter
第一步: 在对应的属性名前加'_'
第二步: 在@property后面声明一个函数,这个函数没有参数,有一个返回值,并且函数名是属性名去掉'_'
第三步: 获取属性值的时候,通过'对象.属性名去掉下划线'取获取属性的值

b.setter  -  给属性赋值前干别的事情,就给这个属性添加setter.(想要添加setter必须先有getter)
第一步: 在对应的属性名前加'_'
第二步: 在@getter名.setter后面声明一个函数,这个函数需要一个参数,没有返回值,并且函数名是属性去掉'_'
第三步: 给属性赋值的时候,通过'对象.属性名去掉下划线=值'的方式赋值

3.抛出异常
a.语法:
raise 异常类型

b.说明:
raise  -  关键字
异常类型  -  可以是系统提供的异常类型,也可以自定义异常类型(必须继承Exception)

4.自定义异常类型: 写一个类继承Exception,然后重写__str__方法来自定义错误信息
"""
class WeekValueError(Exception):
    def __str__(self):
        return '星期的值只能是1-7的整数!'

# ===============保护==============
class AgeError(Exception):
    def __str__(self):
        return '年龄要求是整数,并且范围在0~150!'


class Person1:
    def __init__(self):
        self._age = 0
        self._week = 6

    @property
    def age(self):
        if self._age < 18:
            return self._age, '未成年'
        elif self._age < 30:
            return self._age, '成年'
        elif self._age < 50:
            return self._age, '中年'
        else:
            return self._age, '老年'

    @age.setter
    def age(self, x):
        if not isinstance(x, int):
            raise AgeError
        elif not 0 < x <= 150:
            raise AgeError
        self._age = x

    @property
    def week(self):
        weeks = ['周1', '周2', '周3', '周4', '周5', '周6', '周日']
        return weeks[self._week - 1]

    @week.setter
    def week(self, x):
        if not isinstance(x, int):
            raise ValueError
        elif not 1 <= x <= 7:
            raise ValueError
        self._week = x


p1 = Person1()


p1.week = 1          # 本质是在调用setter对应的方法
print(p1.week)       # 本质是在调用getter对应的方法

p1.age = 100
age, jieduan = p1.age
print(age, jieduan)

# 练习: 给age属性添加getter和setter,获取年龄的时候拿到年龄值,和这个年龄对应的阶段;
# 给age赋值的时候,必须是整数,并且范围在0-150。如果不满足要求报错:AgeError
print('===============私有化==============')
# ===============私有化==============


class Person:
    __number = 61

    def __init__(self, name, age=18):
        self.name = name
        self.__age = age

    def message(self):
        print(self.__age)

    def __func1(self):
        print(self.name)


p = Person('小明')
print(p.name)
# print(p._Person__age)
p.message()

# print(Person.__number)
# p.__func1()
print(p.__dict__)

五.inherit

父类 - 被继承者, 子类 - 继承者
python中所有的类都是直接或者间接的继承object
2.怎么继承

class 子类名(父类1,父类2,...)
    类的内容

3.子类中添加内容

1)添加字段和方法,直接添加


class Person(object):
    number = 61

    def __init__(self, name, age=0, gender='男'):
        # name = '小花'
        self.name = name
        self.age = age
        self.gender = gender
        self.__num = '0001'

    def fun1(self):
        print('Person对象方法:', self.name)

    @classmethod
    def func2(cls):
        print(cls.number)

    @staticmethod
    def func3():
        print('func3')


class Student(Person):
    flag = '学生!'

    def __init__(self, name):
        # name = '小花'
        # 在子类的方法中去调用父类的方法
        super().__init__(name)     #  super().__init__('小花')
        self.study_id = 'stu001'

    def fun1(self):
        super().fun1()
        print('子类的,func1')

    def study(self):
        print('%s在学习' % self.name)


stu = Student('小花')
print(stu.__dict__)
# 使用父类继承下来的属性和方法
print(Student.number)
print(stu.name)
stu.fun1()
Student.func2()
Student.func3()


# 使用自己的属性和方法
print(Student.flag)
stu.study()


print(Person.__bases__)

推荐阅读更多精彩内容

  • 面向对象编程是JS里一个非常核心的思想,几乎所有面试的习题也都会涉及到这部分内容。这次FCC改版后的习题也单独把这...
    Nikkkki睡不醒阅读 178评论 0 0
  • 1.recode 1.1.类和对象的概念类:拥有相同属性和相同功能的对象的集合对象:类的实例1.2.类的申明 1....
    未醒的梦_19b0阅读 29评论 0 0
  • Swift1> Swift和OC的区别1.1> Swift没有地址/指针的概念1.2> 泛型1.3> 类型严谨 对...
    cosWriter阅读 3,571评论 0 12
  • 1 面向对象No6 面向对象 OO Object Oriented 编程时以对象为单元,封装数据和逻辑,以此提...
    征程_Journey阅读 242评论 0 2
  • 标签(空格分隔): 未分类 基础(相关概念) 1.元祖 元组(tuples)把多个值组合成一个复合值。元组内的值可...
    一生信仰阅读 57评论 0 0