Python 是一门很灵活、很方便的语言。学起来很顺手,我们可以用它快捷的完成许多实际任务,下面是我学习python的过程中整理的基本知识点。
面向对象的编程是当今最主流的编程思想,类的三大特性:封装、继承、多态是面向对象编程的优势所在,下面是我整理的相关知识点。
# -*- coding:utf-8 -*-
__author__ = 'Microcosm'
print("关于self,它是定位实例化对象的量,类在实例化一个对象的时候,"
"self就会接收这个对象的地址,作为后续调用类属性和类方法的寻址标志")
print("--------------------封装---------------------")
# 将一类物体抽象成属性和方法的集合体
class Turtle:
def run(self):
print("我在努力的爬...")
def bite(self):
print("咬死你咬死你...")
def sleep(self):
print("睡觉了,晚安,Zzzzz")
turtle = Turtle()
turtle.run()
turtle.bite()
turtle.sleep()
print("================================================")
class Animal:
def __init__(self,name):
self.name = name
def eat(self):
print("%s 正在吃东西" % self.name)
def sleep(self):
print("%s 正在睡觉" % self.name)
a = Animal("小猫")
a.eat()
a.sleep()
b = Animal("小狗")
b.eat()
b.sleep()
print("=================================================")
class Dog:
name = '小泡泡'
age = 2
__legs = 4 # 以双下划线开头的属性或者方法是私有的
def printName(self):
print("我叫 %s" % self.name)
def printAge(self):
print("我今年 %d 岁" % self.age)
def getLegs(self):
return self.__legs
dog = Dog()
dog.printName()
dog.printAge()
dog.name = '狗蛋儿' # 直接修改属性变量值
dog.printName()
# print dog.__legs # 访问私有属性,会抛出AttriuteError的异常,但可以用下面这种方式解决
print dog._Dog__legs # Python实际上只是给私有属性换名了,也就是说这是一种伪私有
print dog.getLegs()
print("--------------------继承---------------------")
import random as r
class Fish:
def __init__(self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)
print("我的初始位置在(%d,%d)" % (self.x,self.y))
def move(self):
self.x += 1
self.y -= 1
print("向东北方向移动一步后,我现在在(%d,%d)" % (self.x, self.y))
class GoldFish(Fish):
pass
class Crop(Fish):
pass
class Salmon(Fish):
pass
class Shark(Fish):
def __init__(self): # 这里其实改写了父类的方法,也就是覆盖了它,所以不会初始化位置,只有调用父类的方法才行
Fish.__init__(self) # 方法一
# super().__init__() # 方法二,更常用,对于多重继承,都会自动调用父类的构造函数,好像是Python3的语法
self.hungry = True
def eat(self):
if self.hungry:
print("我正在吃东西^_^")
self.hungry = False
else:
print("太撑了,我吃不下了!")
fish = Fish()
fish.move()
goldfish = GoldFish()
goldfish.move()
shark = Shark()
shark.move()
shark.eat()
shark.eat()
print("=================================================")
class A:
def foo(self):
print("我是小A")
class B:
def foo(self):
print("我是小B")
def foo2(self):
print("我是小小B")
class C(A,B): # 多重继承
def foo2(self):
print("我是小C")
a = A()
a.foo()
b = B()
b.foo()
c = C()
c.foo() # 同名的父类函数,按照继承的顺序调用
c.foo2() # 子类的方法与父类同名时,会调动子类的方法
print("--------------------组合---------------------")
print("当几个对象之间的关系是横向而不是纵向时,则不适宜使用继承关系,应该使用组合关系")
class Fish:
def __init__(self,x):
self.x = x
class Turtle:
def __init__(self,x):
self.x = x
class Pool:
def __init__(self,x,y): # 将其他类的对象作为该类的属性
self.turtle = Turtle(x)
self.fish = Fish(y)
print("水池里总共有 %d 只乌龟和 %d 条鱼" %(self.turtle.x, self.fish.x))
pool = Pool(1,10)
print("--------------------多态---------------------")
print("不同的类对象调用同一个函数方法,可以有各自不同的实现,这就叫做多态,"
"就像不同的动物有各自行走的方式一样")
class Turtle:
def run(self):
print("A turtle is running!")
class Dog:
def run(self):
print("A dog is running!")
class Cat:
def run(self):
print("A cat is running!")
t = Turtle()
t.run()
d = Dog()
d.run()
c = Cat()
c.run()
print("---------------------------类、类对象、实例对象------------------------------")
class C:
count = 0
a = C()
b = C()
print a.count # 0
print b.count # 0
c = C()
c.count += 10
print c.count # 10
print a.count # 0
C.count = 100 # 静态变量,直到程序退出才会清空
print a.count # 100
print b.count # 100
print c.count # 10
del C # 删除类
print a.count # 100
#print C.count # 抛出NameError的异常
print c.count # 10
print("==========================================")
class A:
def x(self):
print("X-man")
a = A()
a.x()
a.x = 1 # 添加一个属性覆盖了类的方法
# a.x() # 抛出TypeError的异常
print("============================================")
class BB:
def printBB(self): # 这个版本的Python好像不能创建静态方法,例如: def printBB(): 就会报错
print("no zuo no die")
BB.printBB(BB()) # 这种方式也可以
BB().printBB()
print("=============================================")
class CC:
age = 1
def setXY(self,x,y):
self.x = x # 实例属性,与实例对象绑定
self.y = y
def printXY(self):
print(self.x,self.y)
print CC.age # 静态属性,可以用类名直接调用修改
dd = CC()
print dd.__dict__ # 查看实例对象的属性,发现dd是没有任何属性的
print CC.__dict__ # 查看类的属性
dd.setXY(4,5)
print dd.__dict__ # {'y': 5, 'x': 4} 这个属性只有dd这个实例对象有,这主要归功于类对象的绑定
print CC.__dict__
del CC # 删除类对象
#ee = CC() # 抛出NameError异常
dd.printXY() # 但是实例对象dd依然可以调用类的方法,
# 主要是因为类的属性和方法都是静态的,一直都在内存中,只有当程序退出时才会清空
print("=================与类相关的一些BIF===================")
# issubclass(class,classinfo) 判断class 是否是 classinfo 的子类
class A:
pass
class B(A):
pass
class C:
pass
print issubclass(B,A)
print issubclass(B,B) # 通常一个类被认为是自己的子类
print issubclass(B,C)
print issubclass(B,object) # 这个版本返回值是False
print issubclass(B,(A,C)) # True
print("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-")
# isinstance(object,classinfo) 判断object 是否是 classinfo 的实例
b1 = B()
print isinstance(b1,B) # True
print isinstance(b1,A) # True B是A的子烈
print isinstance(b1,C) # False
print isinstance(b1,(A,B,C)) # 只有b1是后面类中某一个的实例就返回True
print("=======================================")
# hasattr(object,name) 判断实例对象有没有name属性
class C:
def __init__(self,x=0):
self.x = x
c = C()
print hasattr(c,'x')
#print hasattr(c,x) #是错误的
# getattr(object,name,default) 获取name属性的值,如果不存在,则打印default提示信息
print getattr(c,'x')
#print getattr(c,'y') # 会抛出一个AttributeError的异常
print getattr(c,'y','你访问的属性不存在') # 没有异常,输出提示信息,用户体验好
# setattr(object,name,value) 设置name属性,并给它赋值为value
setattr(c,'y','hello')
print getattr(c,'y','你访问的属性不存在')
# delattr(object,name) 删除name属性
delattr(c,'y')
print getattr(c,'y','你访问的属性不存在')
# delattr(c,'y') # 已经被删除,会抛出AttributeError的异常
print("------------------property----------------------------")
# property(fget=None,fset=None,fdel=None,doc=None)
class D:
def __init__(self,size=10):
self.size = size
def getSize(self):
return self.size
def setSize(self,size):
self.size = size
def delSize(self):
del self.size
x = property(getSize,setSize,delSize) # 好像不起作用,难道是版本的问题!!!!????
c = D()
print c.getSize()
print c.x # 10
c.x = 18
print c.x
print c.getSize() # 10
print c.size # 10
c.setSize(19)
print c.getSize()
print c.size
print c.x # 18
del c.x
print c.size
print c.x