当前位置： 首页 > news >正文

s22day6笔记

news 来源：原创 2024/5/19 12:29:11

#!/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()

 

转载于:https://www.cnblogs.com/zzp1991/p/9185457.html

相关文章：

  • BZOJ5093 [Lydsy1711月赛]图的价值 【第二类斯特林数 + NTT】
  • 【大数据Spark_SparkSQL系列_1】Spark SQL基础（五星重要）
  • bool值的底层应用场景
  • hihocoder:#1082 : 然而沼跃鱼早就看穿了一切（用string）
  • js中提示框闪退问题
  • Web站点抓取工具webhttrack
  • 在rabbitmq操作页面上添加队列、交换器及绑定示图
  • Windows10远程报错:由于CredSSP加密Oracle修正
  • dedecms四张表对应关系
  • Confluence 6 恢复一个站点问题解决
  • js寻路算法
  • C++公有继承、保护继承和私有继承
  • jmeter3.0+ant1.10+jenkins实现接口自动化并发送邮件
  • malloc(0)分配多少内存？（译文）
  • MATLAB生成正弦波
  • ES6指北【2】—— 箭头函数
  • 2018以太坊智能合约编程语言solidity的最佳IDEs
  • Angular 响应式表单之下拉框
  • Consul Config 使用Git做版本控制的实现
  • css系列之关于字体的事
  • React Transition Group -- Transition 组件
  • springboot_database项目介绍
  • vue从入门到进阶：计算属性computed与侦听器watch（三）
  • 复杂数据处理
  • 技术攻略】php设计模式(一)：简介及创建型模式
  • 聚类分析——Kmeans
  • 微信端页面使用-webkit-box和绝对定位时，元素上移的问题
  • 物联网链路协议
  • 线性表及其算法（java实现）
  • 用jquery写贪吃蛇
  • Redis4.x新特性 -- 萌萌的MEMORY DOCTOR
  • 智能情侣枕Pillow Talk，倾听彼此的心跳
  • ​​​​​​​ubuntu16.04 fastreid训练过程
  • #1014 : Trie树
  • （1/2）敏捷实践指南 Agile Practice Guide （[美] Project Management institute 著）
  • (day6) 319. 灯泡开关
  • (MIT博士）林达华老师－概率模型与计算机视觉”
  • （Oracle）SQL优化技巧（一）：分页查询
  • （SpringBoot）第二章：Spring创建和使用
  • （板子）A* astar算法，AcWing第k短路+八数码 带注释
  • （第一天）包装对象、作用域、创建对象
  • （二）linux使用docker容器运行mysql
  • （离散数学）逻辑连接词
  • （一）SpringBoot3---尚硅谷总结
  • （转）nsfocus-绿盟科技笔试题目
  • ****** 二 ******、软设笔记【数据结构】-KMP算法、树、二叉树
  • .net framework 4.0中如何 输出 form 的name属性。
  • .NET 解决重复提交问题
  • .Net 知识杂记
  • .NET 中使用 TaskCompletionSource 作为线程同步互斥或异步操作的事件
  • .vimrc php,修改home目录下的.vimrc文件，vim配置php高亮显示
  • @Bean有哪些属性
  • @EnableWebMvc介绍和使用详细demo
  • [ vulhub漏洞复现篇 ] Hadoop-yarn-RPC 未授权访问漏洞复现
  • [ vulhub漏洞复现篇 ] JBOSS AS 5.x/6.x反序列化远程代码执行漏洞CVE-2017-12149