python开发学习 day24 面向对象

www.cnblogs.com/linhaifeng/articles/6182264.html

http://egon09.bolg.51cto.com/9161406/1842475

 

类：把一类事物的相同的特征和动作整合到一起就是类

　　类是一个抽象的概念

 

对象：就是基于类而创建的一个具体的事物（具体存在的）

　　　特征和动作的整合

 

一、面向对象编程 示例

# name='元昊'
#
# gender='母'
#
# type='藏獒'

#狗的特征
dog1={
    'name':'元昊',
    'gender':'母',
    'type':'藏獒'
}
dog2={
    'name':'alex',
    'gender':'母',
    'type':'腊肠',
}
person1={
    'name':'武sir',
    'gender':'母',
    'type':'人'
}

# def dog(name,gender,type):
#     # 狗的动作
#     def jiao(dog):
#         print('一条狗[%s]，汪汪汪' % dog['name'])
#     def chi_shi(dog):
#         print('一条[%s] 正在吃屎' % dog['type'])
#     dog1 = {
#         'name':name,
#         'gender': gender,
#         'type': type,
#         'jiao':jiao,
#         'chi_shi':chi_shi,
#     }
#     return dog1
# d1=dog('元昊','母','中华田园犬')
# d2=dog('alex','母','藏敖')
# print(d1)
# print(d2)
# d1['jiao'](d1)
# d2['chi_shi'](d2)


# jiao(dog1)
# chi_shi(dog1)
# chi_shi(dog2)
#
# jiao(person1)

def dog(name,gender,type):
    # 狗的动作
    def jiao(dog):
        print('一条狗[%s]，汪汪汪' % dog['name'])
    def chi_shi(dog):
        print('一条[%s] 正在吃屎' % dog['type'])
    def init(name,gender,type):
        dog1 = {
            'name':name,
            'gender': gender,
            'type': type,
            'jiao':jiao,
            'chi_shi':chi_shi,
        }
        return dog1
    return init(name,gender,type)

d1=dog('元昊','母','中华田园犬')
d2=dog('alex','母','藏敖')
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2)

def school(name,addr,type):
    def init(name, addr, type):
        sch = {
            'name': name,
            'addr': addr,
            'type': type,
            'kao_shi': kao_shi,
            'zhao_sheng': zhao_sheng,
        }
        return sch
    def kao_shi(school):
        print('%s 学校正在考试' %school['name'])
    def zhao_sheng(school):
        print('%s %s 正在招生' %(school['type'],school['name']))
    return  init(name,addr,type)

s1=school('oldboy','沙河','私立学校')
print(s1)
print(s1['name'])

s1['zhao_sheng'](s1)

s2=school('清华','北京','公立学校')

print(s2)
print(s2['name'],s2['addr'],s2['type'])
s2['zhao_sheng'](s2)

 

二、面向对象 的展示

#用面向对象编程独有的语法class去实现面向对象设计
class Dog:
    def __init__(self,name,gender,type):
        self.name=name
        self.gender=gender
        self.type=type

    def bark(self):
        print('一条名字为[%s]的[%s],狂吠不止' %(self.name,self.type))

    def yao_ren(self):
        print('[%s]正在咬人' %(self.name))

    def chi_shi(self):
        print('[%s]正在吃屎' %(self.type))


dog1=Dog('alex','female','京巴')
print(dog1.__dict__)
# dog2=Dog('wupeiqi','female','腊肠')
# dog3=Dog('yuanhao','female','藏獒')
#
# dog1.bark()
# dog2.yao_ren()
# dog3.chi_shi()

 

三、函数 与 类的声明

函数与类的声明相似

 

#函数的声明

def functionName(args):

　　'函数文档字串'

　　函数体

 

----

类的声明.     ----规范 类名首字母大写

'''

class 类名：

　　'类的文档字串'

　　类体

'''

#我们创建一个类

class Data:
pass

#用类的Data实例出一个对象d1
d1=Data()

 

四、经典类和新式类

大前提

1.只有在python2中才分经典类和新式类，在3中统一都是新式类

2.新式类和经典类声明的最大不同在于，所有新式类必须继承至少一个父类

3.所有类甭管是否显示声明父类，都有一个默认继承object父类（先记住，讲继承时会讲）

 

在python2中的区分

经典类

class 类名:

　　pass

----

新式类

class 类名(父类):

　　pass

-----

在3中，上面两种方式都是新式类

 

五、属性

类是用来描述一类事物，类的对象指的是这一类事物中的一个个体

是事物就要有属性，属性分为：

1.数据属性： 即变量

2.函数属性：即函数，在面向对象里通常称为方法

注意：类和对象均用点来访问自己的属性

 

5.1

---类的相关知识

# class Chinese:
#     '这是一个中国人的类'
#     pass
#
# print(Chinese)
#
# #实例化到底干了什么？
# p1=Chinese() #实例化
# print(p1)


'''
1.数据属性
2.函数属性
'''

class Chinese:
    '这是一个中国人的类'
    dang='共产'
    def sui_di_tu_tan():
        print('朝着墙上就是一口痰')
    def cha_dui(self):
        print('插到了前面')
#
# print(Chinese.dang)
# Chinese.sui_di_tu_tan()
# Chinese.cha_dui('元昊')
#
# # print(dir(Chinese))
# # print(Chinese.__dict__) #查看属性字典
# print(Chinese.__dict__['dang'])
# Chinese.__dict__['sui_di_tu_tan']()
# Chinese.__dict__['cha_dui'](1)
print(Chinese.__name__)
print(Chinese.__doc__)
print(Chinese.__module__)

 ===================================

 

 5.2

查看类的属性

dir() 查出的是一个名字列表

类名.__dict__:查处的是一个字典，key为属性名，value为属性值

 

 ===================================

 

特殊的类属性

chinese.__name__

chinese.__doc__

chinese.__module__

 ===================================

实例化

p1=chinese()

 

构造函数

类是数据属性和函数属性的结合，描述的是一类事物

这类事物的具体表现就是一个实例\对象，比方说中国人是一个类，而你就是这个类的实例

你除了有中国人这个数据属性外，还有名字，年龄，性别等数据属性

如何为实例定制数据属性，可以使用一个内置方法__init__(),该方法，在类（）实例化时会自动执行

class ChinesePeople:
    '我们是中国人，我们骄傲的活着，我们不服任何事和物'
    giverment='共_'

    def __init__(self, name,age,gender): #实例化的过程可以简单的理解为执行该函数的过程，实例本身会当作参数传递给self（这是默认的步骤）
        self.name=name
        self.age=age
        self.gender=gender
    
    def su_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

#person1= ChinesePeople() #会报错
                                          #自动执行__init__方法，而这个需要参数
                                           #这些参数应该写在类名后面的括号里，然后由
                                            #类传给__init__函数，也就是说，传给类的参数
                                               #就是传给__init__的参数

person1= ChinesePeople('alex','100','female')

print(person1.__dict__)

 

====================

5.3  类属性与对象（实例）属性

正本清源：：有人说实例是类产生的，所以实例肯定能访问到类的属性，然后就没有说为什么-----大大大傻逼===》类的作用域（同函数）

属性有增删改查

类属性的增删改查

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.__dict__)

#查看
# print(p1.name)
# print(p1.play_ball)

#增加
p1.age=18
print(p1.__dict__)
print(p1.age)

#不要修改底层的属性字典
# p1.__dict__['sex']='male'
# print(p1.__dict__)
# print(p1.sex)

#修改
p1.age=19
print(p1.__dict__)
print(p1.age)

#删除
del p1.age
print(p1.__dict__)

 

实例属性的增删改查

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.__dict__)

#查看
# print(p1.name)
# print(p1.play_ball)

#增加
p1.age=18
print(p1.__dict__)
print(p1.age)

#不要修改底层的属性字典
# p1.__dict__['sex']='male'
# print(p1.__dict__)
# print(p1.sex)

#修改
p1.age=19
print(p1.__dict__)
print(p1.age)

#删除
del p1.age
print(p1.__dict__)

 

 就不信玩不蒙你

# class Chinese:
#     country='China'
#     def __init__(self,name):
#         self.name=name
#
#     def play_ball(self,ball):
#         print('%s 正在打 %s' %(self.name,ball))
# p1=Chinese('alex')
# print(p1.country)
# p1.country='日本'
# print('类的--->',Chinese.country)
# print('实例的',p1.country)


# country='中国'
# class Chinese:
#     def __init__(self,name):
#         self.name=name
#
#     def play_ball(self,ball):
#         print('%s 正在打 %s' %(self.name,ball))
# p1=Chinese('alex')
# # print(p1.country)



# country='中国'
# class Chinese:
#     def __init__(self,name):
#         self.name=name
#
#     def play_ball(self,ball):
#         print('%s 正在打 %s' %(self.name,ball))
#
# def shi_li_hua():
#     name=input('>>: ')
#     p1=Chinese(name)
#     # print(p1.country)
#     print(p1.name)
# shi_li_hua()



country='中国－－－－－－－－－－－－－－－－－－－'
class Chinese:
    country='中国'
    def __init__(self,name):
        self.name=name
        print('--->',country)

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

print(Chinese.__dict__)
print(Chinese.country)
p1=Chinese('alex')
# print('实例--------》',p1.country)



# Chinese.
# p.

 

换个姿势搞你

# class Chinese:
#     country='China'
#     def __init__(self,name):
#         self.name=name
#
#     def play_ball(self,ball):
#         print('%s 正在打 %s' %(self.name,ball))
# p1=Chinese('alex')
#
# print(p1.country)
# p1.country='Japan'
# print(Chinese.country)

class Chinese:
    country='China'
    l=['a','b']
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.l)
# p1.l=[1,2,3]
# print(Chinese.l)
# print(p1.__dict__)
p1.l.append('c')
print(p1.__dict__)
print(Chinese.l)