python之递归函数、二分查找、面向对象、封装(6)

deffoo(n):
    print(n)
    n += 1foo(n)
foo(1)

importsys
sys.setrecursionlimit(100000)
count =0
deffunc1():
    globalcount
    count += 1
    print(count)
    func1()
func1()

"""alex 他比佩奇 大两岁。  4   age(3) + 2
佩奇 他比日天 大两岁。  3   age(2) + 2
日天 他比太白 大两岁。  2   age(1)  + 2
太白：我今年23.         1   23
"""
defage(n):
    if n == 1:
        return 23
    else:
        return age(n-1) + 2

print(age(4))
"""def age(4):
    if n == 1:
        return 23
    else:
        return age(3) + 2   23 + 2 + 2 + 2

def age(3):
    if n == 1:
        return 23
    else:
        return age(2) + 2   23 + 2 + 2
         
def age(2):
    if n == 1:
        return 23
    else:
        return age(1) + 2    23 + 2
        
def age(1):
    if n == 1:
        return 23
    else:
        return age(0) + 2

"""

defage(n):
    if n == 1:
        return 23
    else:
        age(n-1) + 2
"""def age(2):
    if n == 1:
        return 23
    else:
        age(1) + 2   23 + 2 

def age(1):
    if n == 1:
        return 23
    else:
        age(1) + 2
"""
print(age(2))

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]

i =0
for num inl:
    if num == 66:
        print(i)
    i+=1

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]

deffunc(l,aim):
    mid = (len(l)-1)//2
    ifl:
        if aim >l[mid]:
            func(l[mid+1:],aim)
        elif aim <l[mid]:
            func(l[:mid],aim)
        elif aim ==l[mid]:
            print("bingo",mid)
    else:
        print('找不到')
func(l,66)
func(l,6)

l1 = [1, 2, 4, 5, 7, 9]
def two_search(l,aim,start=0,end=None):
    end = len(l)-1 if end is None elseend
    mid_index = (end - start) // 2 +start
    if end >=start:
        if aim >l[mid_index]:
            return two_search(l,aim,start=mid_index+1,end=end)

        elif aim <l[mid_index]:
            return two_search(l,aim,start=start,end=mid_index-1)

        elif aim ==l[mid_index]:
            returnmid_index
        else:
            return '没有此值'
    else:
        return '没有此值'
print(two_search(l1,9))

deffunctionName(args):
     '函数文档字符串'函数体 


'''class 类名:
    '类的文档字符串'
    类体
'''

#我们创建一个类
classData:
    pass
声明函数vs声明类

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


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

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)  #引用人的走路方法，注意，这里不是在调用

class Person:  #class 关键字，定义了一个类
    '''类里面的所有内容
    '''animal = '高级动物' #静态变量
    soup = '有思想'  #静态变量

    def __init__(self,name,sex,eye,high,weight,):  #构造方法
self.eye = eye  #属性
        self.name =name
        self.sex =sex
        self.high =high
        self.weight =weight
        print(666)

    def work(self): #动态变量，动态方法，方法
        print(self)
        #self.job = 'IT'
        print('人会工作....')

类操作静态变量有两种方式：
1，类名.__dict__方法只能查看,不能增删改。
#print(Person.__dict__)#print(Person.__dict__['animal'])#Person.__dict__['name'] = 'alex'#Person.__dict__['animal'] = '低级动物'
 2，类名.变量名  可增删改查
#print(Person.animal)#print(Person.soup)#Person.kind = '有性格'#Person.animal = '低等动物'#del Person.kind#print(Person.__dict__)

#一般你想查询全部的静态变量时，用__dict__ 其他全部都用类名.变量名。
类操作方法有两种方式：
 1，类名.__dict__[方法名]()
#print(Person.__dict__['work'](11))
  2，类名.方法名
#Person.work(11)#如果类操作方法：类名.方法名()#只要创建一个类，里面的内容就已经加载到内存。#print(Person.__dict__)

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

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

对象操作属性变量有两种方式：
1，对象.__dict__方法只能查看,不能增删改。
#print(p1.__dict__)
2，对象.变量名  可增删改查
#print(p1.name)#print(p1.eye)#p1.color = '黄皮肤'#print(p1.color)#print(p1, type(p1))
3,可以访问类的静态变量
#print(p1.__dict__)#print(p1.animal)#print(p1.soup)#一般你想查询全部的静态变量时，用__dict__ 其他全部都用类名.变量名。

#对象操作方法有两种方式：
1,对象.方法名()
#p1.work()#print(p1)#print(p1.__dict__)
2，类名.方法名(对象)
#Person.work(111)#Person.work(p1)

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岁，男，最爱大保健

'''
defchop_wood(name,age,sex):
    print('%s，%s岁，%s，上山去砍柴'%(name,age,sex))

defdriver(name,age,sex):
    print('%s，%s岁，%s，开车去东北'%(name,age,sex))

defhealthcare(name,age,sex):
    print('%s，%s岁，%s，最爱大保健'%(name,age,sex))

chop_wood('小明',12,'男')
driver('小明',12,'男')
healthcare('小明',12,'男')
chop_wood('老李',22,'男')

=================
classDayaction:
    def __init__(self,name,age,sex):
        self.name =name
        self.age =age
        self.sex =sex

    defchop_wood(self):
        print('%s，%s岁，%s，上山去砍柴'%(self.name,self.age,self.sex))

    defdriver(self):
        print('%s，%s岁，%s，开车去东北'%(self.name,self.age,self.sex))

    defhealthcare(self):
        print('%s，%s岁，%s，最爱大保健'%(self.name,self.age,self.sex))

p1 = Dayaction('小明', 15, '男')
p1.chop_wood()
p1.driver()
p1.healthcare()

>>>id(egg.role)
4341594072
>>>id(Person.role)
4341594072

>>>egg.attack
<bound method Person.attack of <__main__.Person object at 0x101285860>>
>>>Person.attack
<function Person.attack at 0x10127abf8> 

classGame_person:
    def __init__(self,nickname,sex,hp,ad):
        self.nickname =nickname
        self.sex =sex
        self.hp =hp
        self.ad =ad
    defattack(self,p):
        p.hp -=self.ad
        print('%s攻击了%s,%s还剩%s血量'%(self.nickname,p.nickname,p.nickname,p.hp))

    defweapon_attack(self,武器):
        self.武器 = 武器 #斧子对象

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

    deffight(self,p1,p2):
        p2.hp -=self.ad
        print('%s使用%s打了%s%s血,%s还剩%s滴血'%(p1.nickname,self.name,p2.nickname,self.ad,p2.nickname,p2.hp))

ts = Game_person('泰森','男',200,50)
barry = Game_person('太白','男',100,10)
fuzi = Weapon('斧子',60)
#wea.fight(barry,ts) 这样写不好，主体应该是人#ts.attack(barry)#barry.attack(ts)
barry.weapon_attack(fuzi)
#barry对象调用weapon_attack方法，#方法执行的是将斧子对象wea封装到barry对象的属性中、#barry.武器 相当于 wea
barry.武器.fight(barry,ts)

复制代码
class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

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

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

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

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

　　猫可以：爬树、吃、喝、拉、撒

　　狗可以：看门、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
 

#猫和狗有大量相同的内容
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 '看门'




==========================第三部分
#继承的代码实现
classAnimal:

    defeat(self):
        print("%s 吃 " %self.name)

    defdrink(self):
        print ("%s 喝 " %self.name)

    defshit(self):
        print ("%s 拉 " %self.name)

    defpee(self):
        print ("%s 撒 " %self.name)


classCat(Animal):

    def __init__(self, name):
        self.name =name
        self.breed = '猫'
    def爬树(self):
        print '爬树'

classDog(Animal):

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



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

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

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

使用继承来重用代码比较好的例子

继承可以减少代码重用

classD:

    defbar(self):
        print 'D.bar'


classC(D):

    defbar(self):
        print 'C.bar'


classB(D):

    defbar(self):
        print 'B.bar'


classA(B, C):

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

经典类多继承

classD(object):

    defbar(self):
        print 'D.bar'


classC(D):

    defbar(self):
        print 'C.bar'


classB(D):

    defbar(self):
        print 'B.bar'


classA(B, C):

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

新式类多继承