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()

 

posted @ 2018-06-14 23:21  梦丶醒  阅读(91)  评论(0编辑  收藏  举报