一、递归函数
一般递归100多次，都没有解决的问题，放弃递归。
默认递归深度：998
修改默认递归次数
import sys
sys.setrecursionlimit(100000) #设置十万次
count = 0
def func1():
global count
count += 1
print(count)
func1()
func1()
用递归 解决一个年龄问题。
alex 他比佩奇 大两岁。 4 age(3) + 2
佩奇 他比日天 大两岁。 3 age(2) + 2
日天 他比太白 大两岁。 2 age(1) + 2
太白：我今年23. 1 23
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,43,55,56,66,67,69,72,76]
有序的不重复数字列表
查询到66 索引
print(l.index(66)) # 方法一
不用index查询66的索引
index = 0
for i in l:
if i == 66:
print(index)
index += 1
for i in range(len(l)):
if l[i] == 66:
print(i)
利用递归函数，通过二分查找的方法寻找目标的索引
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 ‘没有此值‘
#查找16的索引
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,5))
三、面相对象初识
什么是类
类：是具有相同属性和技能的一类事物。
什么是对象
实例化的一个类，是类的具体体现。
猫就是一类，我家楼下那只小花猫，这是一个对象。（小花猫是个具体的对象）
类开头首字母 大写
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)
#self默认不用填写
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__)
PS：想查询全部的静态变量时，用__dict__
其他全部都用类名.变量名 。
类 操作 方法有两种方式
1、类名.__dict__[方法名]()
print(Person.__dict__[‘work‘](11))
2、类名.方法名
Person.work(11)
对象
类名() #实例化一个对象
p1 = Person() #p1 对象，实例化对象，类名()过程就叫做实例化。
只要实例化一个对象，自动触发__init__
内部进行三步：
1，实例化一个对象，在内存中产生一个对象空间。
2，自动执行init方法，并将这个空间对象。 <__main__.Person object at 0x0000000001F5ABE0> 传给self
3，通过构造方法里的代码给空间对象添加一些属性，并返回给对象。
p1 = Person(‘峰哥‘,‘男‘,‘大眼睛‘,176,170)
print(p1.__dict__)
666
{‘eye‘: ‘大眼睛‘, ‘name‘: ‘峰哥‘, ‘sex‘: ‘男‘, ‘high‘: 176, ‘weight‘: 170}
对象 查看 静态变量，动态变量
1、对象.__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 Person:
animal = ‘高级动物‘ # 静态变量
soup = ‘有思想‘ # 静态变量
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): # 动态变量，动态方法，方法
self.name = ‘oldboy‘
self.job = job
print(‘人会工作....‘)
#self 约定俗称叫self 不能改变。
p1 = Person(‘alex‘,‘女‘,‘小眼睛‘,178,160)
print(p1.name)
666
alex
print(p1.__dict__)
666
{‘eye‘: ‘小眼睛‘, ‘name‘: ‘alex‘, ‘sex‘: ‘女‘, ‘high‘: 178, ‘weight‘: 160}
print(p1.eye)
666
小眼睛
练习一：在终端输出如下信息
小明，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):
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))
def weapon_attack(self,武器):
self.武器 = 武器 #斧子对象
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)
fuzi = Weapon(‘斧子‘,60)
六、继承
面向对象三大特点：
封装
继承
多态
继承：单继承，多继承。
继承：可以有效的节省代码。
继承是一种创建新类的方式，在python中，
新建的类可以继承一个或多个父类，父类又可称为基类或超类，
新建的类称为派生类或子类
类分为两种：新式类，经典类。但是python3x中只有新式类。
新式类 ：遵循的广度优先。
经典类 ：遵循的深度优先。
class Animal:
soup = ‘灵魂‘
def __init__(self,varieties, sex, color):
self.varieties = varieties
self.sex = sex
self.color = color
def eat(self):
print(‘吃‘)
class Cat(Animal):
a = Animal.eat
def eat(self):
print(‘猫吃饭‘)
#Cat 继承 Animal
多继承 钻石继承
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()
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):
pass
def func(self):
print(‘D‘)
class E(C):
pass
def func(self):
print(‘E‘)
class F(D,E):
pass
def func(self):
print(‘F‘)
print(F.mro()) #mro差看继承走位
原文地址：https://www.cnblogs.com/dunkeng/p/9189802.html