面向对象编程

#! /usr/bin/env python
# -*- coding:utf-8 -*-

# 一切事物皆对象。
# 面向对象编程
# 定义：  class  类名：
#               def 方法（self,参数。。。）：
#                   。。。
# 使用：类名创建对象
#       调用类中的方法时，self就是类本身（对象），一个形参，python内部传递

# 面向对象编程特征：封装、继承、多态
# 1.封装:创建类对象时自动执行类的__init__方法，所以在此方法中完成具体封装的操作
#   即使用构造方法进行初始化

class stu:

    def __init__(self,sex):
        self.name = "jerry"
        self.sex = sex

stu1 = stu("boy")
stu2 = stu("Gral")

print(stu1.name)
print(stu2.name)
print(stu2.sex)

　　

# 2.继承: 子类拥有父类所有的功能
#        子类中有父类同个功能时，即子类重写了父类此功能
#        可以多继承（java没有啊，好厉害）：当继承的多个父类中有同一功能，优先使用继承顺序在前的
#         若 A（B,C）,B(D),C(E),功能查找顺序为 A-B-D-C-E
#

class Person:
    def sm(self):
        print(self.Name + "是个中国人")

class student(Person):

    def __init__(self,name,sex,age):
        self.Name = name
        self.Sex = sex
        self.Age = age
    def call(self):
        print("年龄："+self.Age + ",性别：" + self.Sex)

tom = student("Tom","男",'18')
tom.sm()
tom.call()

class China:

    def sm(self):
        print(self.Name + "是炎黄子孙")

class People(China,Person):
    def __init__(self,name,sex,age):
        self.Name = name
        self.Sex = sex
        self.Age = age
    def call(self):
        print("年龄："+self.Age + ",性别：" + self.Sex)

www = People("Rose","女",'20')
www.sm()

　　

# 3.多态：
#  python 不支持重载（方法名相同，参数不同）


# 4.查看类对象中是否有某成员

r = hasattr(People,'sm')
print(r)

　　

# 5.利用反射查找成员

# 导入模块
modul = __import__('People',fromlist=True)
#在模块中找到类
class_name = getattr(modul,'China')
#根据类创建对象
obj = class_name('山东','Tom')
#在对象找到方法并执行
fuc = getattr(obj,'sm')
fuc()

　　

# 6.静态成员变量：将类对象中共同的东西保存一份在类中,使用类访问
#   静态方法 @staticmethod，使用类访问

class province:
    country  = "China" # 静态属性
    def __init__(self,name):
        self.Name = name
    # 静态方法
    @staticmethod
    def say():
        print("www.baidu.com")
    # 类方法(参数为当前类的类名)
    @classmethod
    def show(cls):
        print("sino",cls)


pro1 = province("shandong")
print(pro1.country)# 使用对象访问静态属性
province.say()# 使用类访问静态方法
province.show()# 使用类访问类方法

　　

# 7.修饰符：两种，公有和私有
#  私有：前面加上两个下划线，可以在类内部被调用

class Foo:
    ox = "www" # 公有静态属性
    __xo = "mmm" # 私有静态属性

    def __init__(self):
        self.name = "ketty"
    def say(self):
        print(self.__xo)
    def __call__(self, *args, **kwargs):
        print("call")
        return 1
    def __getitem__(self, item):
        print(item, type(item))

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print('del',key)
    def __iter__(self):
        yield 1
        yield 2
        yield 3
obj = Foo()
print(Foo.ox)
obj.say()

　　

# 8.特殊方法：__init__; __del__; __call__;
# __getitem__; __setitem__; __del__;

r = Foo()() # 先执行__init__方法，再执行__call__方法，将__call__方法的返回值给r
m = Foo()
m['value'] #对象后面加中括号，执行__getitem__方法
m["key"] = 123 # 执行对象的__setitem__方法
del m['key'] # 执行对象的__delitem__方法

m[1:7:2] # 对象切片也是调用__getitem__方法，将1:7:2封装成一个slice对象传入方法
# 同理 切片赋值调用__setitem__,切片删除调用__delitem__
m[1:3] = [1,2,3]

　　

# 9.__dict__ 获取对象中的成员

print(Foo.__dict__) # 类Foo中的成员：方法和属性

obj = Foo()
print(obj.__dict__) # 对象obj中的成员

# 10. __iter__: 如果执行for循环对象时，自动会执行对象的__iter__方法
# 若能迭代成功，表明对象中实现了__iter__方法

n = Foo()
for i in n:
    print(i)