PYTHON 面向对象笔记

蔚落 2023-10-11 09:26 12阅读 0赞

1 def jiao(dog):
     2     print("%s叫了起来"%dog["name"])
     3 def chi(dog):
     4     print("一条%s狗[%s]正在吃饭"%(dog["gender"],dog["name"]))
     5 
     6 dog1 = {
     7     "name":"旺财",
     8     "pinzhong":"藏獒",
     9     "gender":"公"
    10 }
    11 dog2 = {
    12     "name":"旺财",
    13     "pinzhong":"藏獒",
    14     "gender":"母"
    15 }
    16 person1 = {
    17     "name":"李雷",
    18     "nationality":"汉",
    19     "gender":"male"
    20 }
    21 person2 = {
    22     "name":"韩梅梅",
    23     "nationality":"傣族",
    24     "gender":"female"
    25 }
    26 jiao(dog1) #旺财叫了起来
    27 chi(person1) #一条male狗[李雷]正在吃饭

上面例子中我们有2个函数,分别定义了狗这个物种的吃和叫的功能.

同时又创建了4个对象.由于4个对象分别有相同的name和gender属性.因此原本只是用在狗这个对象上的函数竟然可以用人的对象传参进去调用.所以这种程序设计的问题就很明显.当然我们可以考虑在对象中加入属性:狗 属性:人,经过判断后哦再判断调用哪个函数.但是这样程序的运行效率就不高了.如果不用判断,直接把狗的函数和狗的对象捆绑一起,那么人的对象的形参就无法传入狗的函数,我们可以用作用域的概念来实现

1 def dog():
     2     def jiao(dog):
     3         print("%s叫了起来"%dog["name"])
     4     def chi(dog):
     5         print("一条%s狗[%s]正在吃饭"%(dog["gender"],dog["name"]))
     6     dog1 = {
     7         "name":"旺财",
     8         "pinzhong":"藏獒",
     9         "gender":"公"
    10     }
    11     dog2 = {
    12         "name":"旺财",
    13         "pinzhong":"藏獒",
    14         "gender":"母"
    15     }
    16 person1 = {
    17     "name":"李雷",
    18     "nationality":"汉",
    19     "gender":"male"
    20 }
    21 person2 = {
    22     "name":"韩梅梅",
    23     "nationality":"傣族",
    24     "gender":"female"
    25 }
    26 
    27 #整个叫和吃的函数都被包裹到DOG函数内.从外部无法直接调用这2个方法.
    28 # 如果要调用只能用dog()实现了狗只能调用狗的函数
    29 # jiao(dog1) 
    30 # chi(person1)

实现了第一步,不同对象的函数调用问题.但是因为DOG对象都被保函在DOG函数体内,同时要注意到函数体内包含了2条狗的对象.实际情况中可能不止2条狗,所以不能这么写死. 所以需要用作用域的规则向内部传递形参,同时能够从外部的形参创建狗的对象数据

1 def dog(name,pingzhong,gender):
     2     def jiao(dog):
     3         print("%s叫了起来"%dog["name"])
     4     def chi(dog):
     5         print("一条%s狗[%s]正在吃饭"%(dog["gender"],dog["name"]))
     6     dog = {
     7         "name":name,
     8         "pinzhong":pingzhong,
     9         "gender":gender,
    10         "jiao":jiao,
    11         "chi":chi
    12     }
    13     return dog
    14 
    15 person1 = {
    16     "name":"李雷",
    17     "nationality":"汉",
    18     "gender":"male"
    19 }
    20 person2 = {
    21     "name":"韩梅梅",
    22     "nationality":"傣族",
    23     "gender":"female"
    24 }
    25 
    26 d = dog("旺财","哈士奇","公")
    27 print(d) 
    28 #输出结果{'name': '旺财', 'pinzhong': '哈士奇', 'gender': '公', 'jiao': <function dog.<locals>.jiao at 0x0000020F0204A950>, 'chi': <function dog.<locals>.chi at 0x0000020F0204A9D8>}
    29 d["chi"](d)

利用作用域以及作用域向内部传参的规则,可以形参上写入狗对象的属性,然后调用dog内部的字典创建对象,并将函数的内存地址给变量d,再通过读取字典形式调用里面的方法,并把d作为形参传入.

对于内部的对象dog的字典,也可以写入函数体内,这样格式更加工整,内部函数分工更明确

1 def dog(name,pingzhong,gender):
     2     def jiao(dog):
     3         print("%s叫了起来"%dog["name"])
     4     def chi(dog):
     5         print("一条%s狗[%s]正在吃饭"%(dog["gender"],dog["name"]))
     6     def init(name,pingzhong,gender): #这样写功能更明确, init作为狗对象属性的初始化
     7         dog = {
     8             "name": name,
     9             "pinzhong": pingzhong,
    10             "gender": gender,
    11             "jiao": jiao,
    12             "chi": chi
    13         }
    14         return dog ##
    15     ret = init(name,pingzhong,gender)
    16     return ret
    17 
    18 person1 = {
    19     "name":"李雷",
    20     "nationality":"汉",
    21     "gender":"male"
    22 }
    23 person2 = {
    24     "name":"韩梅梅",
    25     "nationality":"傣族",
    26     "gender":"female"
    27 }
    28 
    29 d = dog("旺财","哈士奇","公")
    30 print(d)
    31 d["chi"](d)

基本到这里就是一个比较完美的面向对象的写法.里面的person对象也无法应用到DOG里去调用.DOG里的内部函数都是灵活的调用的.

这里的DOG就是类的概念.

转载于:https://www.cnblogs.com/Young-shi/p/11326617.html