day13-类和对象

作者: 2333_11f6 | 来源:发表于2018-11-21 17:37 被阅读0次

13.1 编程思想

1.编程思想：

1.面向过程编程 - 逻辑、算法
遇到问题考虑直接把逻辑思维转换成代码，解决问题
2.函数式编程 - 函数
遇到问题想到用函数解决。考虑是否有这种功能的函数。
3.面向对象编程 - 类和对象
遇到问题，就考虑是否有一个对象能帮我解决这个问题

2.类和对象

1.定义
类：就是拥有相同属性和功能的对象的集合(类是抽象的)
对象：类的实例（对象是具体的）
2.从生活的角度考虑类的对象
如果‘人’是一个类，余婷是一个对象，骆老师也是一个对象。

13.2 类的声明

1.类的声明

语法：
class 类名（父类列表）：
    类的内容

说明：
class - 声明类的关键字
类名 - 标识符，不能是关键字；采用驼峰式命名，并且首字母大写；见名知义。
（父类列表） - 继承语法；可以省略，省略时相当于（objct）即基类（祖宗类）。
类的内容 - 主要包含属性和方法

补：驼峰式命名：名字由多个单词组成，通过单词首字母大写来区分不同的单词。
方法:python中声明在类中的函数叫方法。

2.类的属性和方法

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

# 声明了一个Person类
class Person:
    """人类"""
    num = 61      # 类的字段
    age = 61      # 对象属性
    name = 123

    # 方法
    def eat(self):
        print('%s在吃饭。' % Person.name)


# Person是类（类就是类型）
print(Person)              # <class '__main__.Person'>

3.创建对象

类名（）- 创建类对应的对象

xiao_ming = Person()
# 创建Person类的对象xiao_ming
print(xiao_ming)           # <__main__.Person object at 0x000001D82796B8D0>
xiao_ming.eat()            # 123在吃饭。
print(xiao_ming.name)      # 123

12.3 对象方法

1.什么是对象方法
直接声明在类中，并且自带一个叫self的参数的函数，就是对象方法。
2.对象方法的调用 - 通过对象调用对象方法
对象.对象方法（）
3.self（当前对象）
通过对象调用对象方法时，对象方法中第一个参数self不用传参，系统会自动将当前对象传给self。哪个对象调用的self就指向谁。

注意：
当前类的对象能做的事情，self都能做。

# 创建一个Person类
class Person:
    """人类"""
    def __init__(self):
        self.name = ''
    # 声明了一个对象方法sleep
    def sleep(self):
        print('self', self)
        print('%s睡觉！' % self.name)
        self.run()                # 对象能做的，self都能做；当前对象

    def run(self):
        print('跑')


# 创建person对象p1
p1 = Person()
print('p1', p1)   # p1 <__main__.Person object at 0x0000017DADA7B4E0>
p1.sleep()        # self <__main__.Person object at 0x0000017DADA7B4E0>


p2 = Person()
p2.name = '小花'
p2.sleep()        # 小花睡觉！  跑

12.4 init方法和构造方法

0.魔法方法：python类中，用__开头及结尾的方法，就是魔法方法，魔法方法不需要主动调用，都会自动调用。
1._init_方法
a.是对象方法，可用对象调用
b.不需要自己调用，会被自动调用
c.在创建对象后，专门用来对对象做初始化。
2.构造方法
概念：函数名和类名一样的函数，就是构造方法。用于创建对象。
当我们创建类时，系统会自动创建这个类的构造方法，用来创建对象。
当我们通过构造方法创建对象时，系统会自动调用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)
# 注意
tuple1 = (10, 20)
print(*tuple1)            # 10 20

13.5 对象属性

1.什么是对象属性
a.声明在_init_方法中
b.self.属性名 = 值
c.通过对象使用: 对象.属性
d.不同的对象,属性可能不一样

语法:
self.变量名 = 值
说明:变量名就是属性名,这个变量就是对象属性

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

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


# 创建对象
p1 = Person()
# 使用对象属性
p1.name = 'ZH'
print(p1.name)      # ZH
print(p1.age)       # 0

p2 = Person()
p2.name = 'Z'
print(p1.name)      # ZH
print(p2.name)      # Z
print(p1.age)       # 0
print('='*88)


# 情况2:创建对象时,决定对象属性值
class Person:
    def __init__(self, name, age=1):
        # 这里的name和age就是Person类的对象属性.
        self.name = name
        self.age = age


# 创建对象
p1 = Person('ZH')
# 使用对象属性
# p1.name = 'ZH'
print(p1.name)      # ZH
print(p1.age)       # 1

p2 = Person('Z')
# p2.name = 'Z'
print(p1.name)      # ZH
print(p2.name)      # Z
print(p1.age)       # 1

# 修改对象属性值
p1.name = '流浪法师'
print(p1.name)         # '流浪法师'


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


class Retangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

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

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


j1 = Retangle(30, 20)
print(j1.area())                 # 600
print(j1.perimeter())                 # 100


# 练习:声明一个point类,拥有属性x,y坐标.拥有的功能是求一个点到另一个点的距离
class Point:
    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
    def distance(self, other):
        return ((self.x-other.x)**2 + (self.y-other.y)**2)**0.5


p1 = Point(1, 2)
p2 = Point(4, 6)

# p1_p2 = p1.distance(p2.x, p2.y)
# print(p1_p2)                      # 5.0
print(p1.distance(p2))              # 5.0

13.6 对象属性的增删改查

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


dog1 = Dog('旺财', '黄色', '二哈')

1.查(获取对象属性的值)

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

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

print(getattr(dog1, 'name'))              # 旺财
print(getattr(dog1, 'name1', '菜菜'))         # 菜菜

2.增\改

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

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

dog1.name = '大黄'
print(dog1.name)          # 大黄;改
dog1.sex = '母'
print(dog1.sex)           # 母;增

setattr(dog1, 'name', 'hotdog')
print(dog1.name)                             # hotdog;改
setattr(dog1, 'name2', 'roudog')
print(dog1.name2)                            #  roudog;增

3.删除

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

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

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

4.slot魔法

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

class Student:
    # Student类的对象只能有name age id sex这几个只能少,不能多
    __slots__ = ('name', 'age', 'id', 'sex')   # 限制类的属性

    def __init__(self, name,  age):
        self.name = name
        self.id = '001'
        self.age = age


stu1 = Student('小明', 18)
# stu1.neme = '666'       # 因为有slots魔法,所以不能添加
stu1.sex = '666'          # 可以添加,且不影响其他对象

13.6 类的字段和内置类属性

1.类的字段
a.声明在类中且在函数外的变量,叫做类的字段.
b.类的字段需要通过类来使用:类.字段 - 不论是在类中还是类外,都需要。
类的字段：不会因为对象不同而不一样的数据就声明为类的字段

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

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


print(Person.number)           # 61

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

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

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

    # 对象方法
    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_ - 获取类的名字(字符串)

print(Person.__name__)               # Person;获取类的名字

b._class_
对象._class_ - 获取对象对应的类(结果是一个类,类能做的它都可以做)

print(Person.__class__)        #   <class 'type'>
print(dog1.__class__)          #  <class '__main__.Dog'>

dog1 = Dog('小黑', 3, '黑色')
dog2 = dog1.__class__('小黑', 3, '黑色')  # 可以创建对象
print(dog1.__class__.__name__)  # 有一个类的对象,可以获取到类的名字

c._dict_
(了解)类._dict_ - 获取当前类的所有字段及其对应的值
(重点)对象._dict_ - 将当前对象所有的对象属性及其值转换成字典,key是属性名,value是属性值.(数据本地化必须操作)

print(Dog.__dict__)     # 获取类的所有字段和其地址组成的字典
print(dog1.__dict__)     # {'name': '小黑', 'color': 3, 'age': '黑色'}

d._bases_
类._bases_ - 获取当前类的父类(以元组形式返回,元组中的元素就是类的父类名)

print(Dog.__bases__)      # (<class 'object'>,)元组;python支持多继承,所以为元组

e._module_
类名._module_ - 获取当前类所在模块的模块名

print(Dog.__module__)  #  __main__

f._doc_
类._doc_ - 获取类的说明文档

print(Dog.__doc__)   # 说明文档:傻狗

day13-类和对象

13.1 编程思想

13.2 类的声明

12.3 对象方法

12.4 init方法和构造方法

13.5 对象属性

13.6 对象属性的增删改查

13.6 类的字段和内置类属性

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读