[py]python面向对象基础01

最新推荐文章于 2021-02-09 08:35:08 发布

txjjjjj

最新推荐文章于 2021-02-09 08:35:08 发布

阅读量323

点赞数

本文链接：https://blog.csdn.net/iiiiher/article/details/77315297

版权

py面向对象基础

认识类成员

给对象添加属性

class person:
    def say(self):
        print("person say")

p=person()
p.name="alice"
print(p.name)

#alice

class的构造函数—另一种添加属性方法

class people:
    def __init__(self,age,tel):
        self.name = "alice"
        self.age=age
        self.tel=tel

    def show(self):
        print(("name:%s  age:%d tel:%s")%(self.name,self.age,self.tel))
p=people(22,13823746140)
p.show()

self代表: 正在调用它的对象

class people:
    def show(self):
        print(self)

p = people()

p.show()
print(p)

# <__main__.people object at 0x0000000001DCBE10>
# <__main__.people object at 0x0000000001DCBE10>

class xx:
    类变量
    构造方法
    类方法

创建实例
访问属性
    类属性的访问
    对象属性的访问
             修改emp1.age = 8
             删除del emp1.age

定义一个员工类

class Employee:
    '所有员工的基类'

    # 类变量,他的值所有实例之间共享, 外部通过 Employee.empCount 访问
    empCount = 0

    # 构造方法
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1
    # 类方法
    def displayCount(self):
        print "total employee is %d" % (Employee.empCount)

    def displaySalary(self):
        print "Name: %s , salary: %s" % (self.name, self.salary)

# 初始化属性
emp1 =  Employee("allen",10000)
emp2 =  Employee("bob",20000)

# 实例调用类方法
emp1.displaySalary()
emp2.displaySalary()

# 通过类名调用 类变量
print Employee.empCount

执行结果

Name: allen , salary: 10000
Name: bob , salary: 20000


2

类中的一些内置方法

dict
doc
class
name

继承–实现代码封装

调用子类构造方法
调用子类方法
调用父类方法
父类属性

这里写的还是较为清晰

http://blog.csdn.net/zhoudaxia/article/details/23341261

类的继承

class Animal:

    def eat(self):
        print "%s 吃 " %self.name

    def drink(self):
        print "%s 喝 " %self.name

    def shit(self):
        print "%s 拉 " %self.name

    def pee(self):
        print "%s 撒 " %self.name


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed ＝ '猫'

    def cry(self):
        print '喵喵叫'

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'

    def cry(self):
        print '汪汪叫'


# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

多继承

执行父类的构造方法–深度优先(新式类)

class D(object):

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

原生支持多态

其他语言

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'


# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""

    print obj.show()

s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

python中.

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj)

python与鸭子类型
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

#coding=utf-8  
class Duck:  
    def quack(self):  
        print "Quaaaaaack!"  

class Bird:  
    def quack(self):  
        print "bird imitate duck."  

class Doge:  
    def quack(self):  
        print "doge imitate duck."  

def in_the_forest(duck):  
    duck.quack()  ## 向鸭子一样做事情

duck = Duck()  
bird = Bird()  
doge = Doge()  
for x in [duck, bird, doge]:  
    in_the_forest(x)

Quaaaaaack!
bird imitate duck.
doge imitate duck.

不是很理解鸭子类型.

面向对象的应用场景:

1.多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码

class SqlHelper:

    def __init__(self, host, user, pwd):

        self.host = host
        self.user = user
        self.pwd = pwd

    def 增(self):
        # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接

    def 删(self):
        # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接

    def 改(self):
        # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接

    def 查(self):
    # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接# do something

2.需要创建多个事物，每个事物属性个数相同，但是值的需求
如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同

class Person:

    def __init__(self, name ,age ,blood_type):

        self.name = name
        self.age = age
        self.blood_type = blood_type


    def detail(self):
        temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
        print temp

zhangsan = Person('张三', 18, 'A')
lisi = Person('李四', 73, 'AB')
yangwu = Person('杨五', 84, 'A')

类和对象在内存中存储图

参考: http://www.cnblogs.com/wupeiqi/p/4766801.html

字段

普通字段静态字段

由上图可是：

静态字段在内存中只保存一份
普通字段在每个对象中都要保存一份
应用场景：通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段

class Province:

    # 静态字段
    country ＝ '中国'

    def __init__(self, name):

        # 普通字段
        self.name = name


# 直接访问普通字段
obj = Province('河北省')
print obj.name

# 直接访问静态字段
Province.country

方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
类方法：由类调用；至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
静态方法：由类调用；无默认参数；

class Foo:

    def __init__(self, name):
        self.name = name

    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """

        # print self.name
        print '普通方法'

    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """

        print '类方法'

    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""

        print '静态方法'


# 调用普通方法
f = Foo()
f.ord_func()

# 调用类方法
Foo.class_func()

# 调用静态方法
Foo.static_func()

相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。

不同点：方法调用者不同、调用方法时自动传入的参数不同。

类的特殊成员

参考:http://www.cnblogs.com/wupeiqi/p/4766801.html

__module__
__init__

__call__
__dict__

__str__


__getitem__
__setitem__
__len__

__iter__

getitem,setitem,len,delitem

参考:
http://blog.csdn.net/yuan_j_y/article/details/9317817

class DictDemo:  
    def __init__(self,key,value):  
        self.dict = {}  
        self.dict[key] = value  
    def __getitem__(self,key):  
        return self.dict[key]  
    def __setitem__(self,key,value):  
        self.dict[key] = value  
    def __len__(self):  
        return len(self.dict)  
dictDemo = DictDemo('key0','value0')  
print(dictDemo['key0']) #value0  
dictDemo['key1'] = 'value1'  
print(dictDemo['key1']) #value1  
print(len(dictDemo)) #2  

del obj['k1']

txjjjjj

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
[py]python面向对象基础01

py面向对象基础给对象添加属性class person: def say(self): print("person say")p=person()p.name="alice"print(p.name)#aliceclass的构造函数—另一种添加属性方法class people: def __init__(self,age,tel): self.na
复制链接

扫一扫