Python 06
递归函数
人理解函数，神理解递归。
自己用自己。
def func1():
print(666)
func1()
func1()
------>
RecursionError: maximum recursion depth exceeded while calling a Python object
不能一直自己调用自己，影响效率。
一般递归100多次，都没有解决的问题，放弃递归。
显示打印了多少次：
count = 0
def func2():
global count
count += 1
print(count)
func2()
func2()
默认递归深度是：998
**************************************************************
改变一下递归深度：
import sys
sys.setrecursionlimit(100000)
count = 0
def func2():
global count
count += 1
print(count)
func2()
func2()
****************************************************************
第一，用递归解决一个年龄问题。
"""
alex 他比佩奇 大两岁 4 age(3)+2
佩奇 他比日天 大两岁 3 age(2)+2
日天 他比太白 大两岁 2 age(1)+2
太白：我今年23. 1
"""
def age(n):
if n ==1:
return 23
else:
return age(n-1)+2
print(age(4))
二分查找
用递归实现：
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]
#有序的不重复数字列表
print(l.index(66)) #查询到66的索引
不用index怎么查询？
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]
index = 0
for i in l:
if i == 66:
print(index)
index += 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]
for i in range(len(l)):
if l[i] == 66:
print(i)
以下用递归实现二分查找：
利用递归函数，通过二分查找方法去寻找目标值的索引
以下方法的l长度都会变，有点问题，因为切片改变了原列表，进而改变了索引
l = [2,3,5,10,15,16]
def two_search(l,aim):
mid_index = len(l)//2
if aim > l[mid_index]:
return two_search(l[mid_index +1:],aim)
elif aim < l[mid_index]:
return two_search(l[:mid_index],aim)
elif aim == l[mid_index]:
return mid_index
else:
return '没有此值'
print(two_search(l,10))
*********************************************************
l = [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(l,16))
面向对象的初识
实际工作中，python都是面向对象，写代码，或者用面向对象+函数写代码。
class File:
def __init__(self,path,mode,content):
self.path =path
self.mode =mode
self.content =content
def add(self):
pass
def remove(self):
pass
def update(self):
pass
def select(self):
pass
f1 = File('文件名','a','内容')
f1.add()
面向对象编程，上帝式思维。
class Person:#class关键字，定义了一个类
"""
类里面的所有内容
"""
animal = '高级动物' #静态变量
soul = '有思想'#静态变量
def work(self): #动态变量，动态方法，方法。
print('人会工作....')
什么是类？
类：是具有相同属性和技能的一类事物。
对象：实例化的一个类，是类的具体体现。
猫就是类，我家楼下那只小花，这是一个对象。
鸡是类，山里一只野鸡，是一个对象。
狗是一类，我家邻居养了一只泰迪，叫日天，一对象。
男神是一类，太白就是一个对象。
类名一般首字母大写，函数名不会首字母大写。
类如何调用查看静态变量，动态变量：
class Person:#class关键字，定义了一个类
"""
类里面的所有内容
"""
animal = '高级动物'
soul = '有思想'
def work(self):
print('人会工作....')
#类操作静态变量，有两种方式：
# 1.通过类名.__dict__方法，只能查看,不能增删改。
print(Person.__dict__) #__dict__双下方法
print(Person.__dict__['animal'])
Person.__dict__['name'] = 'alex' #会报错
Person.__dict__['animal'] = '低级动物'#会报错
# 2.类名.变量名 可增删改查
print(Person.animal)
print(Person.soul)
Person.kind = '有性格' #增加
print(Person.__dict__)
Person.animal = '低等动物' #改
print(Person.__dict__)
del Person.kind #删
print(Person.__dict__)
一般你想查询全部的静态变量时，用__dict__其他全部都用类名.变量名。
类操作方法，有两种方式：
1.类名.__dict__[方法名]()
print(Person.__dict__['work'](11))
2.类名.方法名
Person.work(11)
如果是类操作方法：类名.方法名（）
类名加（）实例化一个对象，并且自动触发init方法。
只要实例化一个对象，自动触发__init__,实际上内部进行了三步：
1.实例化一个对象，在内存中产生一个对象空间。
2.自动执行init方法，并将这个空间对象（内存地址）<__main__.Person object at 0x01D02450>将这个地址传给self
3.通过构造方法里的代码给空间对象添加一些属性，并返回给对象
对象如何调用查看静态变量，动态变量：
对象操作属性变量有两种方式：
1.对象.__dict__方法，只能查看，不能增删改。
class Person:#class关键字，定义了一个类
"""
类里面的所有内容
"""
animal = '高级动物'
soul = '有思想'
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('人会工作....')
# Person.work()
#p1= Person() #实例化一个对象自动触发构造方法，实例化的时候没有传参数，也不会报错
#print(p1) #将这个地址传给self
p1 = Person('峰哥','man','big','176','170')
p2 = Person('小美','girl','big','160','100')
print(p1.__dict__)
----->
666
666
{'eye': 'big', 'name': '峰哥', 'sex': 'man', 'high': '176', 'weight': '170'}
打印两个666，因为实例化了两个对象，会执行两次init方法。
2.对象.变量名，可增删改查
p1 = Person('峰哥','man','big','176','170')
print(p1.name)
print(p1,type(p1))
print(p1.eye)
p1.color = '黄皮肤' #增
print(p1.color)
----->
666
峰哥
<__main__.Person object at 0x01CF2870> <class '__main__.Person'>
big
黄皮肤
3.对象可以访问类的静态变量
class Person:#class关键字，定义了一个类
"""
类里面的所有内容
"""
animal = '高级动物'
soul = '有思想'
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('人会工作....')
p1 = Person('峰哥','man','big','176','170')
print(p1.__dict__)
print(p1.animal)
print(p1.soul)
对象操作方法有两种方式：
1.对象.方法名()
class Person:#class关键字，定义了一个类
"""
类里面的所有内容
"""
animal = '高级动物'
soul = '有思想'
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):
self.job = 'IT'
print('人会工作....')
p1 = Person('峰哥','man','big','176','170')
print(p1.__dict__)
p1.work() #不写参数也可以执行，因为实例化的时候init产生了空间，执行方法的时候会把这个空间传给self
print(p1.__dict__)
----->
666
{'eye': 'big', 'name': '峰哥', 'sex': 'man', 'high': '176', 'weight': '170'}
人会工作....
{'eye': 'big', 'name': '峰哥', 'sex': 'man', 'high': '176', 'weight': '170', 'job': 'IT'}
2.类名.方法名(对象)
class Person:#class关键字，定义了一个类
"""
类里面的所有内容
"""
animal = '高级动物'
soul = '有思想'
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)
print('人会工作....')
p1 = Person('峰哥','man','big','176','170')
Person.work(111)
p1.work()
print(p1) #self就是对象本身
Person.work(p1)
类空间，对象空间
class Person:
animal = '高级动物' #静态变量
soul = '有思想' #静态变量
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('人会工作....')
p1 = Person('alex','male','small','178','160')
print(p1.eye)
print(p1.animal)
print(p1.work())
class Person:
animal = '高级动物' #静态变量
soul = '有思想' #静态变量
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,job):
self.name='oldboy'
self.job=job
print('人会工作....')
p1 = Person('alex','male','small','178','160')
print(p1.__dict__)
print(p1.work('IT'))
print(p1.__dict__)
*********************************************************
class Person:
animal = '高级动物' #静态变量
soul = '有思想' #静态变量
name = 'taibai'
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,job):
print('人会工作....')
p1 = Person('alex','male','small','178','160')
print(p1.name) #会先在对象本身的空间去找，找不到才会通过类对象指针去类里面去找，所以打印alex
1.self约定俗称叫self，不能改变
2.通过实例化对象查找属性，先从对象空间找，没有则通过类对象指针从类空间找。
"""
练习一：在终端输出如下信息
小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
老张…
"""
利用函数方式：
def chop_wood(name,age,sex):
print('%s,%s岁,%s,上山去砍柴'%(name,age,sex))
def driver(name,age,sex):
print('%s,%s岁,%s,开车去东北'%(name,age,sex))
def healthcare(name,age,sex):
print('%s,%s岁,%s,最爱大保健' %(name, age, sex))
chop_wood('小明',12,'男')
driver('小明',12,'男')
healthcare('小明',12,'男')
chop_wood('老李',22,'男')
利用面向对象方式：
class Dayaction:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def chop_wood(self):
print('%s,%s岁,%s,上山去砍柴' % (self.name, self.age, self.sex))
def driver(self):
print('%s,%s岁,%s,开车去东北' % (self.name, self.age, self.sex))
def healthcare(self):#此处必须添加一个self，不然会把第一个参数默认为self
print('%s,%s岁,%s,最爱大保健' % (self.name, self.age, self.sex))
p1 = Dayaction('小明',15,'男')
p1.chop_wood()
p1.driver()
p1.healthcare()
面向对象省去了每次执行都要传参数
组合：给一个类对象的属性封装（赋值）给另一个类的对象：
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))
ts = Game_person('泰森','男',200,50)
barry = Game_person('太白','男',100,10)
ts.attack(barry)
barry.attack(ts)
*********************************************************
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))
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)
barry = Game_person('太白','男',100,10)
wea = Weapon('斧子',60)
wea.fight(barry,ts)#这么写不好，主体应该是人。
**********************************************************************
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,w):
self.w = w#斧子的对象
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)
barry = Game_person('太白','男',100,10)
wea = Weapon('斧子',60)#wea是斧子的对象
barry.weapon_attack(wea) #barry对象调用weapon_attack方法，方法执行的是将斧子对象wea封装到barry对象的属性中。
barry.w.fight(barry,ts)#barry.w相当于wea
面向对象三大特点：
封装，集成，多态。
继承：可以有效的节省代码。
浙公网安备 33010602011771号