s22day6笔记
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 人理解函数，神理解递归。
# 自己用自己。
#一般递归100多次，都没有解决的问题，放弃递归。
# def func():
# print(111)
# def func1():
# print(666)
# func1()
# func1()
# count = 0
#
# def func1():
# global count
# count += 1
# print(count)
# func1()
#
# func1()
# 默认递归深度：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))
"""
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
"""
def age(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))
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 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 = 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 '没有此值'
#
# print(two_search(l,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))
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#len
# s1 = 'fjdsklfjds'
# count = 0
# for i in s1:
# count += 1
# print(count)
#
# l1 = [1 ,2, 3, 4, 5]
# count = 0
# for i in l1:
# count += 1
# print(count)
# def my_len(argv):
# count = 0
# for i in argv:
# count += 1
# return count
# 面向对象
#实际工作中，python 都是面向对象，写代码，或者 面向对象+函数写代码。
# def add(path,mode,content):
# pass
#
# def remove(path,mode,content):
# pass
#
# def update(path,mode,content):
# pass
#
# def select(path,mode,content):
# pass
#
# add('文件名','a','内容')
# remove('文件名','a','内容')
# update('文件名','a','内容')
# select('文件名','a','内容')
# 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()
# f1.remove()
# 面向对象编程：上帝式思维。
class Person: # class 关键字，定义了一个类
'''
类里面的所有内容
'''
animal = '高级动物'
soup = '有思想'
def work(self):
print('人会工作....')
# 什么类？
#类：是具有相同属性和技能的一类事物。
#对象：实例化的一个类，是类的具体体现。
# 猫就是类，我家楼下那只小花，这是一个对象。
#鸡是类，山里一只野鸡，是一个对象。
#狗是一类，我家邻居养了一只泰迪，叫日天，一对象。
#男神是一类，太白就是一个对象。
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__)
# 对象： 类名() 实例化一个对象
# p1 = Person() # p1 对象，实例化对象，类名()过程就叫做实例化。
# p2 = Person()
# Person.work()
# 只要实例化一个对象，自动触发__init___
# 内部进行三步：
# 1，实例化一个对象，在内存中产生一个对象空间。
# 2，自动执行init方法，并将这个空间对象。 <__main__.Person object at 0x0000000001F5ABE0> 传给self
# 3，通过构造方法里的代码给空间对象添加一些属性，并返回给对象。
# p1 = Person('峰哥','男','大眼睛',176,170)
# # print(p1.__dict__)
# p2 = Person('小白','女','眼睛',163,103)
# print(p1)
# 对象如何调用查看静态变量，动态变量
# 对象操作属性变量有两种方式：
# 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)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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('人会工作....')
# p1 = Person('alex','女','小眼睛',178,160)
# print(p1.name)
# print(p1.__dict__)
# print(p1.eye)
# print(p1.animal)
# print(p1.work())
# p1.work('IT')
# print(p1.__dict__)
# self 约定俗称叫self 不能改变。
# 通过实例化对象查找属性，先从对象空间找，没有则通过类对象指针从 类空间找。
'''
练习一：在终端输出如下信息
小明，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()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#组合：给一个类对象的属性 封装 另一个类的对象。
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)
# 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)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#面向对象三大特点：
# 封装，继承，多态。
#继承：可以有效的节省代码。
# 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
#
# class Rabbit(Animal):
# pass
# class Animal:
# def 吃(self):
# pass
#
# def 喝(self):
# pass
#
# def 拉(self):
# pass
#
# def 撒(self):
# print('fdsagdsf')
# #
# #
# #
# class Cat(Animal):
#
# def climb(self):
# print('爬树')
#
#
#
# class Dog(Animal):
#
# def see_door(self):
# print ('看门')
# cat1 = Cat('波斯猫', '公', '橘黄')
# print(cat1.soup)
# print(cat1.__dict__)
# 这就叫继承：
# Animal 父类，基类。
#Cat 子类,派生类，
#内部怎么执行的？
class A:
pass
a1 = A()
# object
# python3x 中，所有的类都默认继承object类,继承object类的类称为新式类。
# 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('猫吃饭')
#
# 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('鸟该吃饭了....')
#
# cat1 = Cat('波斯猫', '公', '橘黄')
# cat1.eat()
#问题一：
# 执行顺序，所以执行 猫吃饭.
#问题二：
# 猫，鸟，都有自己独立属性，如何使用共同的属性并且使用独立的属性。
# b1 = Bird('鹦鹉','公', '绿色',800)
# # print(b1.__dict__)
# 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()
# 多继承 钻石继承
# 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())
# 经典类：深度优先
#Python2 中默认是经典类，如果改成新式类 就让 类(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()
# class A:
# def func(self):
# print('A')
# def __init__(self):
# self.func()
#
# class B(A):
# def func(self):
# print('B')
# b1 = B()
