python基础（对象初识）

一、 初识对象：

　　类 ：具有相同方法和属性的一类事物

　　　　类成员：静态属性，静态方法，类方法，对象方法，property方法

　　　　对象成员：对象属性

　　1.1 类名可以调用所有定义在类中的名字：
　　　　属性
　　　　方法

　　1.2 实例化的过程 ：
　　　　1.开辟了一块空间，创造了一个self变量来指向这块空间
　　　　2.调用init,自动传self参数，其他的参数都是按照顺序传进来的
　　　　3.执行init
　　　　4.将self自动返回给调用者

　　1.3 认识一个类：

　　

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):
        pass

    def 方法名2(self):
        pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

　　1.3 创建一个类：

　　

# 创建一个类

class Person(object):      # 大写字母开头
    def __init__(self, name, hp, ad, sex):
        print('执行我啦！')

        # 静态变量 这个类中的变量 是所有的对象共享的值
        var1 = 1000

        # 添加实例属性(对象属性)方法一：
        self.name = name
        self.hp = hp
        self.ad = ad
        self.sex = sex

        # 添加实例属性方法二：
        self.__dict__['name'] = name
        self.__dict__['hp'] = hp
        self.__dict__['ad'] = ad
        self.__dict__['sex'] = sex

        # 实例属性字典，self给每个实例对象开辟一个单独的内存空间
        print(self.__dict__)


    # 创建一个方法(动态属性)：
    def eat(self):
        print('{} 吃了一个鸡腿'.format(self.name))


# 创建一个实例对象
alex = Person('alex', 200, 10, 'aa')  # 类名()就等于在执行Person.__init__()

print(alex.name)   # 获取实例属性方法一
print(alex.__dict__['name'])  # 获取实例属性方法二
print(alex.hp)

alex.hobby = 'singsong'  # 也可以通过对象名在类的外部增加新的属性
alex.hp = 305   # 也可以在类的外部通过对象名来修改属性的值

del alex.ad            # 删除属性

　　1.4 类属性：

　　

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

　　1.5 类的方法中调用小实例：

　　

# 游戏(人狗大战)小实例：

class Person:
    def __init__(self, name, hp, ad, sex):
        self.name = name
        self.hp = hp
        self.ad = ad
        self.sex = sex

    def fight(self, dog):
        print('这是fight方法')
        dog.hp -= self.ad
        print('{}攻击了{}，{}丢了{}血'.format(self.name, dog.name, dog.name, self.ad))

class Dog:
    def __init__(self, name, hp, ad, kind):
        self.name = name
        self.hp = hp
        self.ad = ad
        self.kind = kind

    def bite(self, person):
        print('这是bite方法')
        person.hp -= self.ad
        print('{}攻击了{}，{}丢了{}血'.format(self.name, person.name, person.name, self.ad))


alex = Person('alex', 200, 10, 'male')
ha = Dog('hei', 220, 20, 'bite')

alex.fight(ha)
ha.bite(alex)

 

二、面对对象的组合用法：

　　2.1 类的加载顺序：

　　　　定义：
　　　　　　类内部一个缩进的所有代码都是在py文件从上到下解释的时候就已经被执行了
　　　　　　类属性和方法空间加载完成后，类名指针指向开辟的内存空间
　　　　　　类中的代码永远是从上到下依次执行的

　　　　示例：

# 加载顺序实例：

class A:
    country = 'China'
    print(country)
    def __init__(self):
        print('执行我了')

    def func(self):
        print('1111111')

    def func(self):
        print('2222222')
A.country = 'English'
a = A()   # China
a.func()   # 2222222

　　2.2 命名空间：

　　　　定义：

　　　　　　类 和 对象 存储分别存在各自的命名空间中
　　　　　　对象获取属性时，先在自己内存空间获取属性，没有则通过类指针去类里面获取属性或者方法
　　　　　　属性直接赋值操作不改变类属性，直接在对象新创建一个属性
　　　　　　查看的类的静态变量时，通过对象与类名查看方法时是相同的，修改类的静态变量一般通过类名修改

　　　　实例化(对象)加载顺序：
　　　　　　实例化加载时，新开辟一个实例化的内存空间，加载完成后内存地址空间指针指向实例化对象
　　　　　　实例化加载类中方法时，实例化加载的内存空间存在一个类指针指向类中的属性内存空间地址
　　　　与函数的对比：
　　　　　　函数加载时，函数名指针指向加载的内存空间，内存空间中对函数变量开辟新的内存空间

　　　　　　类加载时，先开辟内存空间，再通过类名指针指向类内存空间地址

　　　　示例：

　　

# 命名空间的变量修改方法：

# 只要是对一个对象.名字直接赋值，那么就是在这个对象的空间内创建了新的属性
class Student:
    country = 'China'
    def __init__(self,name):
        self.name = name

zhang = Student('张尧')
zou = Student('邹路')

print(zhang.country)
# 在操作静态变量的时候应该尽量的使用类名来操作而不是使用对象名
Student.country = '法国人'
print(zhang.country)
zhang.country = '日本人'   # 给一个对象添加了一个属性

print(zou.country)
print(zhang.country)


# 如果是对于可变数据类型的静态变量 操作的是这个数据内部的内容，也可以使用对象来调用
class Student:
    lis = [0]
    def __init__(self,name):
        self.name = name


b1 = Student('Lisa')
b2 = Student('Andy')

print(Student.lis)  # 类查看静态变量
print(b1.lis)  # 对象查看静态变量
print(b2.lis)  # 对象查看静态变量
b1.lis[0] += 1  # 通过对象修改静态变量的值

print(b2.lis[0])  # 对象通过可变类型变量进行修改值
b1.lis = [123]   # 对象不能通过名字进行修改赋值，只能创建一个新的属性
print(b2.lis)   # [1]

# 总结：
    # 只要是对一个对象.名字直接赋值，那么就是在这个对象的空间内创建了新的属性
    # 只要是对一个可变的数据类型内部的变化，那么仍然是所有的对象和类共享这个改变的成果

　　2.3 组合：

　　　　耦合：

　　　　　　耦合性（英语：Coupling，dependency，或称耦合力或耦合度）是一种软件度量，是指一程序中，模块及模块之间信息或参数依赖的程度

　　　　　　低耦合性是结构良好程序的特性，低耦合性程序的可读性及可维护性会比较好

　　　　组合：

　　　　　　组合就是一个类中使用到另一个类，从而把几个类拼到一起。组合的功能也是为了减少重复代码

　　　　　　减小程序的紧耦合程度，实现松散耦合，使程序变得灵活通用

　　　　示例1：

　　

# 圆形面积的公式和类中方法：

from math import pi

class Circle:
    def __init__(self, r):
        self.r = r

    def area(self):
        return pi * self.r ** 2

    def perimeter(self):
        return 2 * pi * self.r

# 圆环类
class Ring:
    def __init__(self, r1, r2):
        c1 = Circle(r1)
        c2 = Circle(r2)
        if r1 >= r2:
            self.outer = c1       # 组合
            self.inner = c2       # 组合
        else:
            self.inner = c1       # 组合
            self.outer = c2       # 组合

    def area(self):
        return self.outer.area() - self.inner.area()

    def perimeter(self):
        return self.outer.perimeter() + self.inner.perimeter()


c1 = Ring(3, 2)
ar = c1.area()
pe = c1.perimeter()

print(ar)  # 圆环面积
print(pe)  # 圆环周长

　　　　示例 2：

　　

# 日期和类中方法：
class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def date(self):
        return '%s-%s-%s' % (self.year, self.month, self.day)


class Student:
    def __init__(self, name, num, birth, in_school, start_day):
        self.name = name
        self.num = num
        self.birth = birth  # 组合
        self.in_school = in_school  # 组合
        self.start_day = start_day  # 组合


d1 = Date(1999, 10, 27)  # birth
d2 = Date(2019, 1, 9)   # in_school
d3 = Date(2019, 2, 9)  # start_day
feng = Student('冯磊', 10086, d1, d2, d3)

# 组合获取属性
print(feng.birth.year)
print(feng.birth.month)
print(feng.birth.day)
print(feng.birth.date())

# 修改属性
feng.start_day.month += 1  # 开学时间晚一个月
print(feng.start_day.date())