面向对象编程语言
类:一个模板(人类),抽象的
对象:存在的,eg:张三,李四
属性:表示对象所有的特征:鼻子,眼睛,嘴巴
方法:表示这类物体能做的事情:吃饭,睡觉,也就是定义在类中·的·函数
定义类:class: 类
from collections import Counter
例子: str, list, dict, Counter(内置的)
object代表是, 人类继承于哪一个类, 如果不知道继承哪个类, 就写object;
class 人类(object):
# print('hello')
# 构造方法(魔术方法), 当创建对象的时候(有实例化对象), 自动执行的函数
def __init__(self, name, age, gender):
# python解释器自动将对象传给self这个形参.
# 看self到底是什么东西?
# 将对象与该对象的属性绑定在一起.
# 调用对象的属性两种方式:
# - 张三.name
# - self.name
self.name = name # 属性
self.age = age # 属性
self.gender = gender # 属性
print(self) # 实质上是一个对象, <__main__.人类 object at 0x7f4fdc4864a8>
# 方法(在类里面定义的函数, 叫做方法)
def eat(self):
print("%s 正在吃饭..." %(self.name))
#创建对象---根据模板(类)创建对象(真实存在)
张三 = 人类("张三", 10, 'male')
#对象的属性
print(张三.name)
print(张三.age)
print(张三.gender)
#对象执行方法
张三.eat()
类的私有属性和私有方法
类的私有属性: __private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。 在类内部的方法中使用时 self.__private_attrs
类的方法: 在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同, 类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。 self 的名字并不是规定死的(因为是形参),也可以使用 其他,但是最好还是按照约定是用 self。
类的私有方法 __private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 , 不能在类的外部调用 self.__private_methods
class People(object):
def __init__(self,name,age,gender, money):
self.name = name
self.age = age
self.gender = gender
self.__money = money
def __play(self):
print("王者荣耀正在进行时......")
向杰 = People('向杰', 10, 'male', 1000000)
print(向杰.gender)
应用:栈的数据结构
入栈(push), 出栈(pop), 栈顶元素(top), 栈的长度(length), 判断栈是否为空(isempty) ,显示栈元素(view)
操作结果: 入栈2次, 出栈1次 ,显示最终栈元素
class Stack(object):
# 构造函数
def __init__(self):
self.stack = [ ]
def push(self, value):
self.stack.append(value)
return True
def pop(self):
# 判断栈是否为空
if self.stack:
# 获取出栈元素, 并返回
item = self.stack.pop()
return item
else:
return False
def top(self):
if self.stack:
return self.stack[-1]
else:
return False
def length(self):
return len(self.stack)
def isempty(self):
return self.stack==[]
def view(self):
return ",".join(self.stack)
s = Stack()
s.push('1')
s.push('2')
s.push('3')
s.push('4')
item = s.pop()
print(s.view())
第二个特性之继承
父类与子类
from io import TextIOWrapper
class Animals(object):
def __init__(self,name,age):
self.name=name
self.age=age
def eat(self):
print('eating...')
class Dog(Animals): #Dog没有构造方法时,执行Animals的构造方法
def __init__(self,name,age,gender):
# self.name=name
# self.age=age
#执行Dog的父类的构造方法
super(Dog,self).__init__(name,age)
self.gender=gender
def eat(self):
print(self.name)
print(self.gender)
super(Dog,self).eat()
d1 = Dog("大黄", 30,'male')
print(d1.name)
print(d1.age)
##如果子类没有的属性和方法, 则去父类找, 如果父类也没有, 就报错。
d1.eat()
d1 = Dog("大黄", 3, 'male')
print(d1.name)
print(d1.age)
print(d1.gender)
class Animals(object):
def __init__(self, name, __age):
self.name = name
# 私有属性, 在类的内部都是可以访问的, 类的外部或者子类都不可以访问
self.__age = __age
# 私有方法
def __info(self):
print(self.__age)
class Dog(Animals):
def __init__(self, name, __age, power):
super(Dog, self).__init__(name, __age)
self.power = power
# 父类的私有属性, 子类的方法是不能查看与操作
def drink(self):
print(self.__age)
# 父类的私有方法, 子类是不能查看与操作
def info(self):
super(Dog, self).__info()
a = Animals('redhat', 12)
d = Dog('westos', 12, 100)
print(d.name)
多继承
经典类
class Person1:
pass
p1 = Person1()
print(p1)
新式类
class Person2(object):
pass
p2 = Person2()
print(p2)
在python2中既有新式类也有经典类;
经典类的继承算法: 深度优先算法
新式类的继承算法: 广度优先算法
在python3中全部是新式类
class D:
def test(self):
print("D test")
class C(D):
pass
# def test(self):
# print("C test")
class B(D):
pass
# def test(self):
# print("B test")
class A(B,C):
pass
# def test(self):
# print("A test")
a = A()
a.test()
面向对象的反射机制
1.如果知道对象拥有的属性和方法.
print(dir(str))
f=open('/tmp/passwd')
print(dir(f))
2.判断对象所属的类
print(type('hello'))
class Student(object):
"""
这是Student类的帮助文档
"""
def __init__(self,name,age):
self.name=name
self.age=age
def get_score(self):
return 'score'
def get_grade(self):
return 'grade'
s1=Student('lijia',20)
print(type(s1))
print(isinstance(s1,Student))
print(isinstance('lijia',Student))
3.根据对象可以获取的内容
print(s1.__class__)
print(s1.__dict__)
print(s1.__doc__)
4.hasattr,getattr,setattr,delattr
hasattr:判断对象是否包含对应的属性或者方法名
print(hasattr(s1,'name'))
print(hasattr(s1,'__age')) #私有属性和私有方法不能判断
print(hasattr(s1,'score'))
print(hasattr(s1,'get_score'))
print(hasattr(s1,'set_score'))
getattr:用于返回对象的属性值或者方法名对应的方法体
print(getattr(s1,'name'))
print(getattr(s1,'__age','no attr'))
print(getattr(s1,'get_score','no method'))#获取方法名,如果要执行,直接调用即可
print(s1,'set_score','no method')
setattr:修改某个属性的值
setattr(s1,'name','westos')
print(getattr(s1,'name'))
添加某个属性及对应的值
setattr(s1,'score',90)
print(getattr(s1,'score'))
修改方法
def get_score1():
return '这是修改的方法内容'
setattr(s1,'get_score','get_score1')
print(getattr(s1,'get_score'))
def set_score():
return '这是添加的方法'
添加方法
setattr(s1,'set_score',set_score)
print(getattr(s1,'set_score'))
print(getattr(s1,'set_score')())
delattr
delattr(s1,'name')
print(hasattr(s1,'name'))
print(hasattr(s1,'set_score'))
delattr(s1,'set_score')
print(hasattr(s1,'set_score'))
反射机制的应用场景
class Web(object):
def newarticles(self):
return '<h1>newarticles</h1>'
def watchers(self):
return '<h1>watchers</h1>'
def news(self):
return '<h1>news</h1>'
def ai(self):
return '<h1>ai</h1>'
flask=Web()
def run():
url=input('url:')
# if url=='news':
# return flask.news()
# elif url=='ai':
# return flask.ai()
# else:
# return '<h1>404<h1>'
#如果方法多的话,以上方法比较麻烦,以下操作比较简单
if hasattr(flask,url):
return getattr(flask,url)()
else:
return '<h1>404</h1>'
if __name__=='__main__':
while True:
print(run())
反射机制与动态导入
def run():
#'/bbs/index'; modules='bbs, func='index'
modules,func=input('url:').split('/')[-2:]
#导入一个包含变量的模块名,其中obj是模块的别名
obj=__import__('lib.'+module)
# 判断模块中是否有指定的方法, 如果有, 则执行代码, 如果没有, 404报错;
print(obj)
print(modules)
print(obj.index())
if hasattr(obj, func):
fun = getattr(obj, func)
return fun()
else:
return "404: 页面找不到"
import lib.bbs
import lib.bbs as obj
obj.index()
lib.bbs.index()
if hasattr(flask, url):
return getattr(flask, url)()
else:
return "<h1>404</h1>"
if __name__ == "__main__":
while True:
print(run())