#! /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)
