python开发第六篇--递归函数和面对对象编程初识

时间 2021-08-12

标签 python git 编程函数设计 code orm 对象继承递归栏目 Python 繁體版

原文原文链接

递归函数

递归函数的用法：

- 递归函数：在一个函数里在调用这个函数自己。
- 递归的最大深度：998

实例

找一个函数的索引位置，递归实现python

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
def two_serarch(list,aim,start=0,end=None):
    end=len(list) -1 if end is None else end
    if end >= start:
        mid_index = (end - start) // 2 + start
        if aim > list[mid_index]:
            return two_serarch(list,aim,start=mid_index+1,end=end)
        elif aim < list[mid_index]:
            return two_serarch(list,aim,start=start,end=mid_index-1)
        elif aim == list[mid_index]:
            return mid_index
        else:
            return "没有此值"
    else:
        return "没有此值"

循环一个列表里的元素，遇到列表在循环git

def each_list(list_name):
    for i in list_name:
        if isinstance(i,list):
            each_list(i)
        else:
            print (i)

面向对象编程

初识面对对象

面向过程的程序设计的核心是过程（流水线式思惟），过程即解决问题的步骤，面向过程的设计就比如精心设计好一条流水线，考虑周全何时处理什么东西。编程

- 优势是：极大的下降了写程序的复杂度，只须要顺着要执行的步骤，堆叠代码便可。
- 缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。
- 应用场景：一旦完成基本不多改变的场景，著名的例子有Linux內核，git,以及Apache HTTP Server等。

面向对象的程序设计的核心是对象（上帝式思惟），要理解对象为什么物，必须把本身当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也能够创造出来。面向对象的程序设计比如如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题须要四我的：唐僧，沙和尚，猪八戒，孙悟空，每一个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的属性和方法），然而这并很差玩，因而如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。而后取经开始，师徒四人与妖魔鬼怪神仙互相缠斗着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。面向对象的程序:函数

- 优势是：解决了程序的扩展性。对某一个对象单独修改，会马上反映到整个体系中，如对游戏中一我的物参数的特征和技能修改都很容易。
- 缺点：可控性差，没法向面向过程的程序设计流水线式的能够很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即使是上帝也没法预测最终结果。因而咱们常常看到一个游戏人某一参数的修改极有可能致使阴霸的技能出现，一刀砍死3我的，这个游戏就失去平衡。
- 应用场景：需求常常变化的软件，通常需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

名词：类、对象、实例、实例化设计

类的相关知识

1.声明code

def functionName(args):
     '函数文档字符串'
      函数体 
'''
class 类名:
    '类的文档字符串'
    类体
'''
#咱们建立一个类
class Data:
    pass

2.属性orm

class Person:   #定义一我的类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人均可以走路，也就是有一个走路方法
        print("person is walking...")
print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

3.实例化：类名加括号就是实例化，会自动触发__init__函数的运行，能够用它来为每一个实例定制本身的特征对象

class Person:   #定义一我的类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每个角色都有本身的昵称;
        
    def walk(self):  #人均可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

4.实例化的过程就是类——>对象的过程继承

- 语法：对象名 = 类名(参数)
    1.建立一个对象，开辟一个空间
    2.自动执行__init__方法，而且对象自己传给self
    3.将传进的内容封装给对象自己

5.类属性的补充递归

一：咱们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类
类名.__bases__# 类全部父类构成的元组
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

对象的相关知识

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2
    def 方法名(self):pass
    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，表明一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，至关于调用了__init__方法
                  #括号里传参数，参数不须要传self，其余与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 便可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 便可

练习：

练习一：在终端输出以下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
class Output:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def chopp_wood(self):
        print("{name},{age}岁,{sex},上山去砍柴".format(name=self.name,age=self.age,sex=self.sex))
    def drive_car(self):
        print("{name},{age}岁,{sex},开车去东北".format(name=self.name,age=self.age,sex=self.sex))
    def health_care(self):
        print("{name},{age}岁,{sex},最爱大保健".format(name=self.name,age=self.age,sex=self.sex))
xiaoming = Output("小明",10,"男")  #实例化两个对象
laoli = Output("老李",90,"男")
xiaoming.chopp_wood()  
xiaoming.drive_car()
xiaoming.health_care()
laoli.chopp_wood()
laoli.drive_car()
laoli.health_care()

类名称空间与对象的名称空间

1.建立一个类就会建立一个类的名称空间，用来存储类中定义的全部名字，这些名字称为类的属性

- 类有两种属性：静态属性和动态属性
    1.静态属性就是直接在类中定义的变量
    2.动态属性就是定义在类中的方法
- 其中类的数据属性是共享给全部对象的
- 而类的动态属性是绑定到全部对象的

2.建立一个对象/实例就会建立一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
在obj.name会先从obj本身的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

面向对象的三大特性:继承,多态,封装

1.继承

- 继承是一种建立新类的方式，在python中，新建的类能够继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类。

python中类的继承分为：单继承和多继承

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

查看继承：

print(SubClass1.__bases__)#__base__只查看从左到右继承的第一个子类，__bases__则是查看全部继承的父类
print(SubClass2.__bases__)

若是没有指定基类，python的类会默认继承object类

print(ParentClass1.__bases__)
print(ParentClass2.__bases__)
(<class 'object'>,)
(<class 'object'>,)

2.继承的重要性

- 继承来重用代码

==========================第一部分
例如

　　猫能够：爬树、吃、喝、拉、撒

　　狗能够：看门、吃、喝、拉、撒

若是咱们要分别为猫和狗建立一个类，那么就须要为 猫 和 狗 实现他们全部的功能，伪代码以下：
 

#猫和狗有大量相同的内容
class 猫：

    def爬树(self):
        print '爬树'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 看门(self):
        print '看门'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something



==========================第二部分
上述代码不难看出，吃、喝、拉、撒是猫和狗都具备的功能，而咱们却分别的猫和狗的类中编写了两次。若是使用 继承 的思想，以下实现：

　　动物：吃、喝、拉、撒

　　   猫：爬树（猫继承动物的功能）

　　   狗：看门（狗继承动物的功能）

伪代码以下：
class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在类后面括号中写入另一个类名，表示当前类继承另一个类
class 猫(动物)：

    def爬树(self):
        print '爬树'

# 在类后面括号中写入另一个类名，表示当前类继承另一个类
class 狗(动物)：

     def 看门(self):
        print '看门'




==========================第三部分
#继承的代码实现
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爬树(self):
        print '爬树'

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'
  
    def 看门(self):
        print '看门'



# ######### 执行 #########
代码以下：

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

    def up_tree(self):
        print("爬树")


class Dog(Animal):

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

    def look_door(self):
        print("看门")

mao = Cat("二虎")
mao.eat()
mao.drink()
mao.shit()
mao.pee()
mao.up_tree()

3.Python的类继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

- 当类是经典类时，多继承状况下，会按照深度优先方式查找。
- 当类是新式类时，多继承状况下，会按照广度优先方式查找。
- 经典类和新式类，从字面上能够看出一个老一个新，新的必然包含了跟多的功能，也是以后推荐的写法，从写法上区分的话，若是 当前类或者父类继承了object类，那么该类即是新式类，不然即是经典类。
- python2默认是经典类
- python3默认是新式类

经典类继承：

class D:
    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类中么有，则继续去D类中找，若是D类中么有，则继续去C类中找，若是仍是未找到，则报错
# 因此，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程当中，一旦找到，则寻找过程当即中断，便不会再继续找了
a.bar()
经典类多继承

新式类继承：

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()
新式类多继承

经典类：首先去A类中查找，若是A类中没有，则继续去B类中找，若是B类中么有，则继续去D类中找，若是D类中么有，则继续去C类中找，若是仍是未找到，则报错
新式类：首先去A类中查找，若是A类中没有，则继续去B类中找，若是B类中么有，则继续去C类中找，若是C类中么有，则继续去D类中找，若是仍是未找到，则报错
注意：在上述查找过程当中，一旦找到，则寻找过程当即中断，便不会再继续找了
4.组合
组合指的是，在一个类中以另一个类的对象做为数据属性，称为类的组合
文字游戏：

class Game_person:
    def __init__(self,nickname,sex,hp,ad):
        self.nickname = nickname
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def attack(self,p):
        p.hp = p.hp - self.ad   #剩余血量
        print('%s攻击了%s,%s还剩%s血量'%(self.nickname,p.nickname,p.nickname,p.hp))
    def wuqi(self,wuqi):
        self.wuqi = wuqi   #tian.wuqi(wuqi1)武器类的对象封装到人的对象中当作一个属性.就叫作组合.
class Weapon:
    def __init__(self,name,ad):  #武器的名字，武器的伤害
        self.name =name
        self.ad =ad
    def fight(self,p1,p2):
        p2.hp = p2.hp - self.ad
        print('%s使用%s打了%s%s血,%s还剩%s滴血'%(p1.nickname,self.name ,p2.nickname,self.ad,p2.nickname,p2.hp))

tian = Game_person("TIAN","男",200,10)
didi = Game_person("DIDI","女",200,50)
wuqi = Weapon("鞭子",50)
tian.wuqi(wuqi)
tian.wuqi.fight(tian,didi)