python学习笔记——5. 类与面向对象

#关于python类的封装
class People():
    haha = 100
    def __init__(self, name, age, id):
        self.id = id
        self.age = age
        self.name = name
    def say(self):
        print("My name is", self.name)
        print("My age  is", self.age)
        print("My id   is", self.id)
        print("My sex  is", self.sex)
    def fit(self):
        self.sex = 'man'

ss = People("wanglaosan",3, '22')
ss.sex = 'man'
# 这个地方是python特性，在类外可以通过调用类实例的方式创建实例中的新属性
ss.say()
ls = People("yanglaoer", 10, '200')
ls.fit()
#python解释器读取代码是由上到下读取的，但是如果你不调用相应的函数，函数就不会生效，在此处，若你不
#调用fit()，则ls的sex属性不会被创建
ls.say()

print(People.haha)
ls.haha = 2
#这个地方相当于类的实例对象修改了对应属性的值，且因为实例化后和原类没什么关系了，故后面直接修改类
#属性值时实例里面相应值不会改
#实例对象属性和原类的属性关系类似于局部变量和全局变量的关系
People.haha = 10000
print(People.haha)
print(ls.haha)
delattr(ls, 'haha')
#这个地方起到删除属性的作用，若你类中有相应属性，则实例删除相应属性后，实例相应属性的值等于类中属
#性的值
#若类中没有相应属性，该属性是实例中自己添加的，那么删除后这个属性不会存在，再调用会报错
print(ls.haha)

#私有属性
#  class A():
#     __slots__ = {"name", "age", "sex"}
#     #__slots__的作用是限制class 的属性，在本class中只能添加name, age, sex三个属性，但这个特
#性对继承的子类没影响
#     def __init__(self, name, age, sex):
#         self.name = name
#         self.age  = age
#         self.sex  = sex
# a = A()
# a.cMethod()
#
# class B():
#     def __init__(self, name, age):
#         __age = age
#         name = name
#在这个类中，__age是私有属性。类外或子类都不能调用，只有类内和对象中能调用
#python中变量名前加双“_”的都为私有属性




# #多态
# class Cat():
#     def jiao(self):
#         print("miaomiao")
# class Dog():
#     def jiao(self):
#         print("wangwang")
# def jiao(object):
#     object.jiao()
# #此处向“jiao”函数中传入object，然后object调用Cat类和Dog类都有的"jiao"函数。
# #这里的object能代指一切实例对象，可缩写为obj
# a = Dog()
# b = Cat()
# jiao(a)
# jiao(b)



#继承
# class C():
#     def __init__(self, name):
#         self.name = name
# class D(C):
#     def __init__(self, name, age):
#         self.age = age
#         super().__init__(name)
#     def say(self):
#         print("My name is", self.name, "My age is %s"%self.age)
# b = D("yanglaosan", 19)
# b.say()

# class C():
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
# class D(C):
#
#     def say(self):
#         print("My name is", self.name, "\nMy age is %s"%self.age)
# b = D("yanglaosan", 19)
# b.say()

#
# class St():
#     def __new__(cls, *args, **kwargs):
#         print("First place")
#         return object.__new__(cls)
#     #__new__()函数是作用在init方法之前的，可理解为调用init函数的方法
#     def __init__(self, name):
#         print("Second place")
#         self.name = name
# a = St("Hi")

from mt import *

======================================更新线=================================================

# 定义一个继承object的类
class Human(object):

    # 类属性，被所有此类的实例共用。
    species = "H. sapiens"

    # 构造方法，当实例被初始化时被调用。注意名字前后的双下划线，这是表明这个属性或方法对Python有
#特殊意义，但是允许用户自行定义。
    # 你自己取名时不应该用这种格式。
    def __init__(self, name):
        # 将参数分配给该实例对象的name属性
        self.name = name

    # 实例方法，第一个参数总是self，就是这个实例对象
    def say(self, msg):
        return "{name}: {message}".format(name=self.name, message=msg)

    # 类方法，被所有此类的实例共用。第一个参数是这个类对象。
    @classmethod
    def get_species(cls):
        return cls.species

    # 静态方法。调用时没有实例或类的绑定。
    @staticmethod
    def grunt():
        return "*grunt*"


# 构造一个实例
i = Human(name="Ian")
print(i.say("hi"))     # 印出 "Ian: hi"

j = Human("Joel")
print(j.say("hello"))  # 印出 "Joel: hello"

# 调用一个类方法
i.get_species()   # => "H. sapiens"

# 改一个共用的类属性
Human.species = "H. neanderthalensis"
i.get_species()   # => "H. neanderthalensis"
j.get_species()   # => "H. neanderthalensis"

# 调用静态方法
Human.grunt()   # => "*grunt*"

#写一个支持迭代的类
class Iterable:
    def _inti_(self, x):
        self.x = x
    def __iter__(self):
        return self
    def _next_(self):
        self.x + 1
        return self.x
#Iterable既是一个可迭代对象（因为它实现了__iter__方法），又是一个迭代器（因为实现了__next__方法）。
# 实例变量x用户维护迭代器内部的状态。
# 每次调用next()方法的时候做两件事：为下一次调用next()方法修改状态, 为当前这次调用生成返回结果

python学习笔记——5. 类与面向对象

猜你喜欢