美文网首页
day13 类和对象

day13 类和对象

作者: 落幕丶丶 | 来源:发表于2018-11-28 20:39 被阅读0次

1.编程思想

1.面向过程编码 - 逻辑、算法
遇到问题,考虑直接把逻辑思维转换成代码,解决问题

2.函数式编程 - 函数
遇到问题,就考虑是否有一个这种功能的函数

3.面向对象编程 - 类和对象
遇到问题,就考虑是否有一个对象能够帮我解决这个问题

num = 10
num2 = 20
# print(num2 + num)
# def yt_sum():

2.类和对象

1.定义
类: 就是拥有相同属性和相同功能的对象的集合(类是抽象的)
对象: 类的实例(对象是具体的)

2.从生活的角度考类的对象
如果是人是一个类, 余婷是一个对象, 骆老师也是一个对象
如果电脑是一个类, 我桌上的这台电脑就是一个对象



类: 就是拥有相同属性和相同功能的对象的集合(类是抽象的)

对象: 类的实例(对象是具体的)

1.类的声明

语法:
class 类名(父类列表):
类的内容

说明:
class - 声明类的关键字
类名 - 标识符,不能是关键字(要求!);
采用驼峰式命名,并且首字母大写;
见名知义
(父类列表) - 继承语法;可以省略,省略的时候相当于(objct)
类的内容 - 主要包含属性和方法

补:驼峰式命名:名字由多个单词组成,通过单词首字母大写来区分不同的单词
studentName
userName
userId
方法:声明在类中函数就是方法

2. 属性和方法

类中的属性 - 指的是在类中声明的变量;分为类的字段和对象属性
类中的方法 - 指的是在类中声明的函数;分为对象方法,类方法和静态方法

# 声明了一个Person类
class Person:
    """人类"""
    # 属性
    num = 61

    # 方法
    def eat(self):
        print('人在吃饭!')


# Person是类(类就是类型)
print(Person)

3.创建对象
类名() --> 创建类对应的对象

# 创建Person类的对象xiao_ming
xiao_ming = Person()
print(xiao_ming)


对象方法

1.什么是对象方法

直接声明在类中,并且自带一个叫self的参数的函数

2.对象方法的调用 - 通过对象调用对象方法

对象.对象方法()

3.self (当前对象)

通过对象调用对象方法的时候,对象方法中的第一个参数self不用传参,
系统会自动将当前对象传给self。
哪个对象调用的,self就指向谁。

注意:当前类的对象能做的事情,self都能够做

# 声明Person类
class Person:
    """人类"""

    # 声明了一个对象方法sleep
    def sleep(self, a):
        # self = p1, a = 10
        print('self:', self)
        print('睡觉!', a)
        self.run()

    def run(self):
        # self=p1
        print('跑')


#  创建Person的对象p1
p1 = Person()
print('p1:', p1)
p1.sleep(10)


init方法和构造方法

1.魔法方法

python类中,用开头并且是结尾的方法,就是魔法方法。
魔法方法不需要主动调用,都是自动调用的

2.init方法

a.是对象方法
b.不需要自己调用,会被自动调用
c.专门用来对对象进行初始化的

3.构造方法

概念:函数名和类名一样的函数,就是构造方法
当我们创建类的时候,系统会自动创建这个类的构造方法,用来创建对象。
当我们通过构造方法创建对象的时候,系统会自动调用init方法来对创建好的对象进行初始化

注意:当init方法中除了self以外如果需要别的参数,那么这些参数是通过构造方法来传的参
只要调用了构造方法,就会产生新的对象。(想要对象,调用构造方法)

class Person(object):
    def __init__(self, name, age=0):
        print('self', self)
        print('init方法', name)

def Person(*args, *kwargs):
在堆中开辟空间创建对象
对象.init(
args, **kwargs)
return 对象

p0 = Person('abc', 10)

p1 = Person('abc', 10)
print('p1:', p1)


p2 = Person('123', age=20)
print('p2:', p2)
# p3 = Person()
p3 = p1


# 模拟构造方法和init方法
def __init__(a, b):
    print('自己实现', a, b)


def Person1(*args, **kwargs):
    # args = (10, 20)
    print('创建对象')
    __init__(*args, **kwargs)

    print('返回对象')


Person1(10, 20)


对象属性

1.什么是对象属性

a.声明在init方法中
b.self.属性名 = 值
c.通过对象使用: 对象.属性

语法:
self.变量名 = 值

说明:变量名就是属性名, 这个变量就是对象属性

2.什么样的属性应该声明称对象属性

如果属性的值会因为对象不同而不一样,那这样的属性就应该声明成对象属性。反之就声明称类的字段

# 情况一:所有对象属性创建的时候都使用一个固定的默认值
class Person:
    def __init__(self):
        # 这儿的name和age就是Person类的对象属性
        self.name = '张三'
        self.age = 0


# 创建对象
p1 = Person()

# 使用对象属性
print(p1.name)
p1.name = '李四'
print(p1.name)

p2 = Person()
p2.name = '小红'
print(p2.name, p1.name)


# 情况二:创建对象的时候,决定对象属性的值
class Person:
    def __init__(self, name1, age=1):
        self.name = name1
        self.age = age


p11 = Person('小红')
p12 = Person('小花', 0)
print(p11.age, p12.age)  # 1 0
print(p11.name, p12.name)  # 小红  小花

# 修改对象属性的值
p11.name = '老王'
print(p11.name)


# 练习:声明一个矩形类
"""
属性: 长和宽
方法: 求面积和求周长
"""


class Rect:
    def __init__(self, length1, width1):
        self.length = length1
        self.width = width1

    # 一个对象方法需不需要除了self以外的其他参数,
    # 看实现这个函数的功能需不需要除了属性以外的其他数据
    def area(self):
        # self = r1
        return self.length * self.width

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


r1 = Rect(10, 20)
print(r1.area())

r2 = Rect(3, 4)
print(r2.area())


# 练习:声明一个Point类,拥有属性x坐标和y坐标。功能:求两个点之间的距离
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 求当前点到另外一个点的距离
    def distance(self, other):
        """
        求两个点的距离
        :param other: Point对象
        :return: 距离
        """
        # self = p1  other = p2
        return ((self.x - other.x)**2 + (self.y - other.y)**2)**0.5


# 创建点p1
p1 = Point(0, 0)
print(p1.x, p1.y)
# 创建点p2
p2 = Point(3, 4)

# 求p1到p2的距离
print(p1.distance(p2))


class Dog:
    def __init__(self, name, color, type=None):
        self.name = name
        self.color = color
        self.type = type


dog1 = Dog('旺财', '黄色', '二哈')
dog2 = Dog('才才', '黑色', '土狗')
1.查(获取对象属性的值)

"""
获取指定对象指定属性的值
a.对象.属性 - 属性不存在的时候会报错
b.getattr(对象, 属性名, 默认值) - 属性不存在的时候,如果设置了默认值,程序不崩溃,而是返回默认值

print(dog1.name)
# print(dog1.name1)  # AttributeError: 'Dog' object has no attribute 'name1'

print(getattr(dog1, 'color'))
print(getattr(dog1, 'name1', None))
2.增、改

"""
a.对象.属性 = 值
b.setattr(对象, 属性名, 值)

注意:属性存在的时候,对应的功能是修改属性的值。当属性不存在的时候是添加属性

dog1.name = '大黄'    # 修改
print(dog1.name)

dog1.sex = '公'    # 添加
print(dog1.sex)

setattr(dog1, 'name', '热狗')  # 修改
print(dog1.name)

setattr(dog1, 'name2', '肉狗')  # 添加
print(dog1.name2)
3.删除

a. del 对象.属性
b. delattr(对象, 属性名)

del dog1.name
# print(dog1.name)    # AttributeError: 'Dog' object has no attribute 'name'

delattr(dog1, 'color')
# print(dog1.color)  # AttributeError: 'Dog' object has no attribute 'color'

注意: 对象属性的增删改查,都是针对指定的那一个对象,不会影响其他对象

4.slots魔法

slots是用来约束当前这个类有哪些对象属性

class Student:
    # Student类的对象只能有name,study_id,age和sex属性
    __slots__ = ('name', 'study_id', 'age', 'sex')

    def __init__(self, name, age):
        self.name = name
        self.study_id = '001'
        self.age = age
        # self.sex = ''


stu1 = Student('夏明', 18)
# stu1.neme = '小明'
stu1.sex = '男'


类的字段和内置类属性

1.类的字段

a.直接声明在类里面,函数的外面的变量就是类的字段
b.类的字段需要通过类来使用: 类.字段 - (不管是在类里面还是类的外面都一样)

不会因为对象不同而不一样的数据就声明成类的字段

class Person:
    # 声明了一个字段number
    number = 61

    def show_number(self):
        print('人类的数量:%d' % Person.number)


print(Person.number)
Person().show_number()
2.内置类属性

内置属性就是声明类的时候,类中已经声明好的属性(包含类的字段和对象的属性)

class Dog:
    """说明文档:狗类"""
    # 类的字段
    type = '犬科'

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

    # 对象方法
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    # 类方法
    @classmethod
    def shout(cls):
        print('汪汪汪~~~~')

    # 静态方法
    @staticmethod
    def bite():
        print('狗咬人!!!')


dog1 = Dog('小黑', 3, '黑色')

# a.__name__
"""
类.__name__  - 获取类的名字(字符串)
"""
class_name = Person.__name__
print(class_name, type(class_name))

# with open(Person.__name__+'.json', 'w') as f:
#     pass

# b.__class__
"""
对象.__class__  - 获取对象对应的类(结果是一个类,原来类能做的事情它都可以做)
"""
aa = dog1.__class__

d1 = Dog()
d2 = aa()
print(d1, d2)

print(Dog.type)
print(aa.type)

print(dog1.__class__.__name__)   # 获取对象对应的类的名字

# c.__dict__
"""
(了解)类.__dict__   - 获取当前类的所有的类的字段及其对对应的值
(重点)对象.__dict__ - 将当前对象所有的对象属性及其值转换成字典,key是属性名,value是属性的值
"""
print(Dog.__dict__)
print(dog1.__dict__)

# d.__base__
"""
类.__bases__ - 获取当前类的父类(以元祖的形式返回,元祖中的元素就是类的父类)
"""
print(Dog.__bases__)

# e.__module__
"""
类.__module__  - 获取当前类所在的模块的模块名
"""
print(Dog.__module__)
print(int.__module__)

# f.__doc__
"""
类.__doc__  - 获取类的说明文档
"""
print(Dog.__doc__)
print(int.__doc__)

相关文章

  • day13 类和对象

    1.编程思想 1.面向过程编码 - 逻辑、算法遇到问题,考虑直接把逻辑思维转换成代码,解决问题 2.函数式编程 -...

  • day13 类和对象

    编程思想 1.面向过程编程 - 逻辑、算法遇到问题,直接吧逻辑思维转换成代码解决问题 2.函数式编程 - 面向对象...

  • day13类和对象

    1. 类的定义 1.1 什么是类、什么是对象 官方定义类就是拥有相等功能和相同的属性的对象的集合 -- 抽象的对...

  • day13 总结 - 类和对象

    01.recode 一.json数据 1.json数据:a.只有一个数据 b.数据类型是json支持的类型 2....

  • Day13(类和对象)作业

    1.声明一个电脑类: 属性:品牌、颜色、内存大小方法: 打游戏、写代码、看视频a.创建电脑类的对象,然后通过对象点...

  • day13 - 类和对象(作业)

    1.声明一个电脑类: 属性:品牌、颜色、内存大小 方法:打游戏、写代码、看视频a.创建电脑类的对象,然后通过对象点...

  • day13 - 类和对象(总结)

    1.recode 1.1.json数据:a.只有一个数据 b.数据类型是json支持的类型1.2.json数据转p...

  • Java基本类型的包装

    package day13; /* 基本数据类型对象包装类。 byte Byte short short int ...

  • Day13类和对象的总结

    总结:1.编程思想2.类的声明3.对象方法4.init方法和构造方法5.对象属性6.对象属性的增删改查7.类的字段...

  • 对象、类对象和元类对象

    http://www.tuicool.com/articles/mmyuUr http://blog.csdn.n...

网友评论

      本文标题:day13 类和对象

      本文链接:https://www.haomeiwen.com/subject/ucezqqtx.html