python第六天学习总结

Posted 2020-11-18

1.递归函数：自己调用自己
count = 0
def func():
global count
count += 1
print(count)
func()

func() #默认递归深度998，可通过sys.setrecursionlimit(100000)修改
##用递归解决年龄问题
d:比c大两岁 4 age(3)+2
c:比b大两岁 3 age(2)+2
b:比a大两岁 2 age(1)+2
a:今年23 1 23
def age(n):
if n == 1:
return 23
else:
return age(n-1) + 2

2.二分查找
l1 = [2,3,5,10,15,16]
##不能改变列表的大小，所以需要调整每次的起始位置
def two_search(l,aim,start=0,end=None):
end = len(l) - 1 if end is None else end
if end >= start:
mid_index = (end - start) // 2 + 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]:
return mid_index
else:
return ‘没有此值‘
else:
return ‘没有此值‘
print(two_search(l1,15))

3.面向对象
类：具有相同属性和技能的一类事物
对象：实例化的一个类，是类的具体体现
class Person: #class定义类的关键字 Person类名，首字母大写
‘‘‘
类的注释内容
‘‘‘
animal = ‘高级动物‘ #静态变量
soup = ‘有思想‘
def init(self,name,sex,eye): #构造方法
self.name = name
self.sex = sex
self.eye = eye
print(111)
def work(self): #动态变量，动态方法，方法
print(‘工作‘)

##通过类查看静态变量，动态变量（一般不通过类查看，一般都通过对象查看和操作）
#类操作静态变量
###类名.dict方法（只能查看，不能增删改）
print(Person.dict) #查看全部
print(Person.dict[‘animal‘]) #查看具体的
###类名.变量名 可增删改查
print(Person.animal) #查看具体的
Person.kind = ‘有性格‘ #增加一个变量
Person.animal = ‘低等动物‘ #修改原有变量
del Person.kind #删除一个变量

#类操作方法
###类名.dict[方法名]()
print(Person.dict‘work‘) #操作work方法
###类名.方法名
Person.work(1)

对象： 类名() 实例化一个对象
p1 = Person(‘aa‘,‘男‘,18) #只要实例化一个对象，自动触发__init___
#实例化一个对象，在内存中产生一个对象空间。
#自动执行init方法，并将这个空间对象传给self
#通过构造方法里的代码给空间对象添加一些属性，并返回给对象

##通过对象查看静态变量，动态变量
#对象操作属性变量
###对象.dict方法（只能查看,不能增删改）
print(p1.dict) #查看p1的属性
###对象.变量名 可增删改查
print(p1.name) #查看name属性
p1.color = ‘黄皮肤‘ #增加一个属性
p1.name = ‘cc‘ #改变一个原有属性
print(p1.animal) #访问类的静态变量

#对象操作方法
###对象.方法名()
p1.work() #操作work方法
###类名.方法名(对象)
Person.work(p1) #操作work方法

4.类空间和对象空间
class Person:
animal = ‘高级动物‘ # 静态变量
soup = ‘有思想‘ # 静态变量
def init(self,name,age,sex,): # 构造方法
self.age = age
self.name = name # 属性 self.name属性名
self.sex = sex

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

p1 = Person(‘aa‘,18，男‘) #实例化一个对象
print(p1.name) #在对象空间查找
print(p1.animal) #通过对象空间的指示牌从类空间查找

5.组合
给一个类对象的属性 封装 另一个类的对象
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 -= self.ad
    print(‘%s×××了%s,%s还剩%s血量‘ %(self.nickname,p.nickname,p.nickname,p.hp))
def weapon_attack(self,wuqi):
    self.wuqi = wuqi

class Weapon: #定义一个类
def init(self,name,ad):
self.name = name
self.ad = ad

def fight(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) #定义一个实例化对象
aa = Game_person(‘aa‘,‘男‘,100,10) #定义一个实例化对象
fuzi = Weapon(‘斧子‘,60) #定义一个实例化对象
ts.attack(aa) #对象调用方法
aa.weapon_attack(fuzi) #aa调用weapon_attack方法将fuzi对象封装到aa的属性中
aa.wuqi.fight(aa,ts) #aa.wuqi=fuzi aa.wuqi.fight(aa,ts)=fuzi..fight(aa,ts)

6.继承
##面向对象三大特点：封装 继承 多态
class Animal: #父类 基类
soup = ‘灵魂‘
def init(self,varieties, sex, color):
self.varieties = varieties
self.sex = sex
self.color = color

class Cat(Animal):
pass

class Dog(Animal):
pass

cat1 = Cat(‘波斯猫‘, ‘公‘, ‘橘黄‘) #子类 派生类
dog1=Dog(‘泰迪‘,‘公‘,‘黑色‘) #子类 派生类

##类分为两种：新式类，经典类。但是python3x中只有新式类，继承object类的类称为新式类，python3x 中，所有的类都默认继承object类。python2x中默认为经典类
新式类 ：遵循的广度优先
经典类 ：遵循的深度优先
继承：单继承，多继承

##个性化封装同时继承父类的属性
class Animal:
soup = ‘灵魂‘
def init(self,varieties, sex, color):
self.varieties = varieties
self.sex = sex
self.color = color
def eat(self):
print(‘吃‘)

class Bird(Animal):
def init(self,varieties, sex, color,fly):
# Animal.init(self,varieties, sex, color,) # 执行父类的方法第一种方式（不常用）
# super(Animal,self).init(varieties, sex, color,) # 执行父类的方法第二种方式
super().init(varieties, sex, color,) # 执行父类的方法第二种方式 省略写法（常用）
self.fly = fly # 个性化的封装
def eat(self):
super().eat()
print(‘鸟吃‘) # 个性化的封装

b1 = Bird(‘鹦鹉‘,‘公‘, ‘绿色‘,800)
b1.eat() #先执行父类的方法，然后执行自己的方法

##单继承：一条线
class A:

def func(self):
    print(‘A‘)

class B(A):
pass
def func(self):
print(‘B‘)

class C(B):
pass
def func(self):
print(‘C‘)

c1 = C()
c1.func() #C--B--A

##多继承:钻石继承（新式类） 用最少的次数查找全部的类
class A:
def func(self):
print(‘A‘)

class B(A):
pass
def func(self):
print(‘B‘)

class C(A):
pass
def func(self):
print(‘C‘)

class D(B,C):
pass

d1 = D()
d1.func() #B--C--A
print(D.mro()) #打印查找顺序

##多继承:深度优先（经典类，Python2x中默认为经典类，可通过继承object修改）
class A:
def func(self):
print(‘A‘)

class B(A):
pass
def func(self):
print(‘B‘)

class C(A):
pass
def func(self):
print(‘C‘)

class D(B,C):
pass

d1 = D()
d1.func() #B--A--C