首页 / PYTHON / python学习笔记
python学习笔记
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了python学习笔记,小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含14041字,纯文字阅读大概需要21分钟。
内容图文
![python学习笔记](/upload/InfoBanner/zyjiaocheng/840/50a7c360608d492196074e6da4b34faa.jpg)
2018-11-2
1.类的抽象:拥有相同(相似)属性和行为的对象可抽象出一个类(一般名词都是类)
2.方法的第一个形参必定是self
class Cat:
def drink(self): # 方法的第一个形参必须是self
print('cat drink')
def eat(self, food): # 如果要写我们自己的参数,一定在self之后
print('cat eat %s' % food)
3.创建对象 (不同对象的方法彼此独立,互不干扰)
xiaobai = Cat() # 创建对象 对象名 = 类名()
xiaobai.drink() # cat drink 调用方法 对象名.方法名()
xiaobai.eat('fish') # cat eat fish 调用方法时不需要为self传值
4.添加属性 (不同对象的属性彼此独立,互不干扰)
xiaobai = Cat() # 创建对象 对象名 = 类名()
xiaobai.name = '伊丽莎白' # 添加属性,对象名.属性名=属性值
print('xiaobai 的 name is ', xiaobai.name) # 使用属性,对象名.属性名
5. def talk(self): # self接收了调用方法的对象
print('how are you,my name is %s' % self.name)
xiaobai.talk() # how are you,my name is 伊丽莎白 xiaobai.talk(xiaobai) 解释器会自动把调用方法的对象作为第一个实参来传递
xiaohei.talk() # how are you,my name is black
6.魔法方法:只要按照特定的命名在类里写出方法,恰当的时机就会执行方法
①两侧各有两个下划线。__init__()
②魔法方法由官方定义好,我们不能乱写
7.定义类à创建对象à执行__init__()方法à赋值给对象名à使用对象名调用方法
8.def __init__(self): # 创建对象时自动执行
self.name = '伊丽莎白'
def __str__(self): # 打印对象时自动执行 必须有返回值 return 且返回值一定是字符串
return 'my name is %s' %self.name
def __del__(self): # 对象销毁时执行 用于验证对象是否被销毁
print('del exec')
# 创建对象
xiaobai = Cat()
del xiaobai
print('程序结束了') # del exec 程序结束了
xiaobai = Cat()
cat1 = xiaobai
del xiaobai
print('程序结束了') # 程序结束了 del exec
2018-11-6
9.小项目(烤地瓜)
class SweetPotato:
def __init__(self):
'''初始化地瓜属性'''
self.cooked_level = 0 # 烤熟程度
self.cooked_string = '生的' # 烤熟程度描述
self.condiments = [] # 调料列表
def __str__(self):
'''返回地瓜的描述信息'''
return '这个地瓜目前已经 %d 分熟了,状态为 %s ,调料有 %s' % (self.cooked_level, self.cooked_string, self.condiments)
def cook(self, time):
'''增加烤熟的程度'''
self.cooked_level += time
# 修改描述信息
# 0-3 生的 >3 半生不熟 >5烤好了 >8 烤成木炭了
if self.cooked_level < 3:
self.cooked_string = '生的'
elif self.cooked_level < 5:
self.cooked_string = '半生不熟'
elif self.cooked_level < 8:
self.cooked_string = '烤好了'
else:
self.cooked_string = '烤成渣了'
def add_condiment(self, item):
'''添加调料'''
self.condiments.append(item)
# 拿一个地瓜
digua = SweetPotato()
print(digua)
# 烤地瓜
digua.cook(2) # alt + enter 创建方法
print(digua)
digua.cook(1)
print(digua)
digua.cook(2)
print(digua)
digua.cook(1)
print(digua)
digua.cook(2)
print(digua)
digua.cook(1)
print(digua)
# 添加调料
digua.add_condiment('孜然')
print(digua)
digua.add_condiment('芥末')
print(digua)
输出:
这个地瓜目前已经 0 分熟了,状态为 生的 ,调料有 []
这个地瓜目前已经 2 分熟了,状态为 生的 ,调料有 []
这个地瓜目前已经 3 分熟了,状态为 半生不熟 ,调料有 []
这个地瓜目前已经 5 分熟了,状态为 烤好了 ,调料有 []
这个地瓜目前已经 6 分熟了,状态为 烤好了 ,调料有 []
这个地瓜目前已经 8 分熟了,状态为 烤成渣了 ,调料有 []
这个地瓜目前已经 9 分熟了,状态为 烤成渣了 ,调料有 []
这个地瓜目前已经 9 分熟了,状态为 烤成渣了 ,调料有 ['孜然']
这个地瓜目前已经 9 分熟了,状态为 烤成渣了 ,调料有 ['孜然', '芥末']
10.小项目(存放家具)
class House:
'''房子类'''
def __init__(self, area):
'''初始化房间属性'''
self.area = area # 房间大小
self.items = [] # 存放的家具
def __str__(self):
'''房间的描述信息'''
name = ''
for item in self.items:
name += item.name + ','
return '房间大小为 %d 平米,存放的家具有 %s ' % (self.area, name)
def add_item(self, item):
'''放一个家具到房间里'''
if self.area >= item.size:
self.items.append(item)
self.area -= item.size
else:
print('房子剩余空间不同')
class Bed:
'''床类'''
def __init__(self, name, size):
'''初始化床的信息'''
self.name = name
self.size = size
def __str__(self):
'''返回床的描述信息'''
return '%s 的大小为 %d 平米' % (self.name, self.size)
# 买房
house = House(300)
print(house)
# 买床
hbc = Bed('寒冰床', 4)
print(hbc)
# 把床放到房间里
# house.item = hbc
# print(house.item)
house.add_item(hbc)
print(house)
# 再添加一张床
byc = Bed('白玉床', 299)
house.add_item(byc)
print(house)
运行结果:
房间大小为 300 平米,存放的家具有
寒冰床 的大小为 4 平米
房间大小为 296 平米,存放的家具有 寒冰床,
房子剩余空间不同
房间大小为 296 平米,存放的家具有 寒冰床,
2018-11-8
1.多继承-父类同名方法的处理
class Ma(object):
def run(self):
print('马跑得快')
def walk(self):
print('马走不远')
class Lv(object):
def walk(self):
print('驴走得远')
class LuoZi(Lv, Ma):
pass
luozi = LuoZi()
luozi.run()
luozi.walk() # 当父类有同名方法,会根据__mro__ 算法来确定调用哪一个父类的方法
# print(LuoZi.__mro__) # 使用__mro__魔法属性,可以查看一个类查找方法的顺序
Ma.walk(luozi) # 强制调用指定父类的功能: 父类名.方法名(子类对象)
2. # 有时候,重写之后发现父类方法仍有执行的价值,可以强制调用父类方法
# 1.父类名.父类方法(self)一般适用于多继承
# Animal.__init__(self)
# 2.super(子类名, self).父类方法() 一般使用于单继承
super(Cat, self).__init__()
# 3.super().父类方法() 一般只在python3 可用
super().__init__()
2018-11-9
1.多态:处理不同类之间的关系。继承处理父子类之间的关系
2.类对象是解释器创建的。它是实例对象的公有部分
class Person(object):
def __init__(self, name):
self.name = name
def drink(self):
print('能喝东西')
def eat(self, food):
print('能吃', food)
zs = Person('张三') # zs是实例对象 实例对象的属性是实例属性,实例属性彼此独立,互不干扰
ls = Person('李四') # 实例对象,使用我们自己定义的类创建的对象
zs.drink()
ls.eat('包子')
3.类属性:一个类中所有实例对象共享
class Person(object):
num = 0 # 类属性
# print('初始化了num')
def __init__(self, name):
self.name = name
# 1.global num
# 1.num += 1
Person.num += 1 # 修改类属性 类名.类属性 = 属性值
def drink(self):
print('能喝东西')
def eat(self, food):
print('能吃', food)
# print('程序开始')
# 1.num = 0
zs = Person('张三') # zs是实例对象 实例对象的属性是实例属性,实例属性彼此独立,互不干扰
ls = Person('李四') # 实例对象,使用我们自己定义的类创建的对象
zs.num = 100 # 使用实例对象修改类属性,实际上是添加了一个新的实例属性
print('创建了 %d 个对象' % zs.num) # 使用实例对象也可以访问类属性
print('创建了 %d 个对象' % Person.num) # 使用类属性 类名.类属性 推荐方式
4.实例方法、类方法、静态方法
class Person(object):
__num = 0 # 类属性
def __init__(self, name):
self.name = name
Person.__num += 1
# 实例方法
def drink(self): # 方法的第一个形参必定是self,也就是调用方法的实例对象,叫做实例方法
print('能喝东西')
# def get_num(self): # 因为有self形参,所以是实例方法,下面Person在调用该方法是要传入一个对象
# return Person.__num
# 类方法
@classmethod # 装饰器,语法糖
def get_num(cls): # 类方法,在方法上写一个@classmethod,则方法的第一个形参必定是类对象
'''类方法一般用于处理类属性'''
return cls.__num
# 静态方法
@staticmethod
def add2num(a, b): # 静态方法,在方法上写@staticmethod,则这个方法没有任何强制性的形参,否则,a表示的self对象
print(a + b)
zs = Person('张三')
ls = Person('李四')
# zs.drink() # 调用实例方法 实例对象.方法名
print('创建了 %d 个对象' % Person.get_num()) # 调用类方法 类对象.类方法
Person.add2num(11, 22) # 调用静态方法 类对象.静态方法()
5.__new__方法:创建对象时执行,__init__前执行。pass后不能创建对象。
class Person(object):
def __new__(cls): # 创建对象时执行,__init__前执行
'''
__new__当创建对象的时候回自动执行,可以用来控制一个类是否能创建新的实例对象
控制不能创建对象:方法里什么都不做就可以
控制能创建新对象:使用object的__new__方法创建新实例对象,并返回
'''
obj = object.__new__(cls)
print('new----obj', obj)
return obj
def __init__(self):
print('init----self', self)
self.name = '张三'
print('程序开始')
p = Person()
print('p=', p)
6.__new__方法传参
# class Person(object):
# def __new__(cls, command):
# if command:
# obj = object.__new__(cls)
# return obj
# def __init__(self, command):
# self.name = '张三'
# p = Person(True)
# print('p=', p)
# class Person(object):
# def __new__(cls, *args): # 不定长参数*args
# print('new---args', args)
# obj = object.__new__(cls)
# return obj
# def __init__(self, name, age, sex):
# self.name = name
# self.age = age
# self.sex = sex
# p = Person('zs', 16, 'male')
# print('p=', p)
class Person(object):
# 给__init__的参数,__new__方法也会接收到
# 一般情况下,__new__方法都会使用不定长参数
def __new__(cls, *args,**kwargs): # 不定长参数*args
print('new---args', args,' kwargs=', kwargs)
obj = object.__new__(cls)
return obj
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
p = Person('zs', 16, sex='male')
print('p=', p)
7.单例模式:确保某个类只有一个实例
class Person(object):
instance = None # 记录创建的对象
def __new__(cls, *args, **kwargs): # cls指代当前对象
if cls.instance == None: # 只有当instance没有值的时候才创建新对象 cls.instance == None 等价于 Persons.instance == None
cls.instance = object.__new__(cls)
return cls.instance
def __init__(self, name):
self.name = name
zs = Person('zs')
ls = Person('lc')
print(zs)
print(ls)
输出结果,他俩的地址是一样的,因为是一个对象
8.单例模式的完善:虽然上面是一个对象,但是当初始化对象给name赋值时,名字是可变的,这样不容易看出是一个对象,因为每次实例化时,都会先执行__new__,再执行__init__,__init__方法给每个实例化的对象属性赋值,所以要加一个判断。
class Person(object):
instance = None # 记录创建的对象
is_first_run = True # True 表示第一次创建对象
def __new__(cls, *args, **kwargs): # cls指代当前对象
if cls.instance == None: # 只有当instance没有值的时候才创建新对象 cls.instance == None 等价于 Persons.instance == None
cls.instance = object.__new__(cls)
return cls.instance
def __init__(self, name=''): # 第一次创建对象时执行 name=''实例化时可以不传值
if Person.is_first_run == True:
self.name = name
Person.is_first_run = False
def set_name(self, new_name): # 要修改单例模式的属性,可以使用set方法,因为它们是同一个对象
self.name = new_name
zs = Person('zs')
print(zs.name) #zs
ls = Person('lc')
ls.set_name('ls') #通过方法修改属性
print(ls.name) #ls
9.小项目(反恐精英)------类与类之间的交互
class Gun(object):
'''枪类'''
def __init__(self, model, damage):
'''初始化枪的属性'''
self.model = model # 型号
self.damage = damage # 杀伤力
self.bullet_count = 0 # 剩余子弹数量
def __str__(self):
'''返回枪的描述信息'''
return '%s 的杀伤力为 %d ,剩余子弹数量为 %d' % (self.model, self.damage, self.bullet_count)
def add_bullet(self, count):
self.bullet_count += count
def shoot(self, enemy):
'''射击敌人,造成伤害'''
if self.bullet_count <= 0:
print('已经没有子弹了')
return # 有时候可以直接写个return用于打断函数的执行
# 扣除一颗子弹
self.bullet_count -= 1
# 对敌人造成伤害
# print('%s 射中 %s,造成伤害 %d' % (self.model, enemy, self.damage))
enemy.hurt(self.damage)
class Player(object):
'''玩家类'''
def __init__(self, name, hp=100):
'''初始化玩家属性'''
self.name = name
self.hp = hp
self.gun = None
def __str__(self):
'''返回玩家的描述信息'''
if self.hp <= 0:
return '%s 已经死亡' % self.name
if not self.gun:
return '%s 目前的血量为 %d , 没有枪' % (self.name, self.hp)
return '%s 目前的血量为 %d , 使用的枪为 [%s]' % (self.name, self.hp, self.gun)
def take_gun(self, gun):
'''玩家拿枪'''
self.gun = gun
def fire(self, enemy):
'''玩家开枪射击'''
# print('%s 使用 [%s] 射中了 [%s]' % (self.name, self.gun, enemy))
self.gun.shoot(enemy)
# enemy.hurt(10)
def hurt(self, damage): # 这里的self传进来的是enemy对象
'''玩家受到伤害被扣血'''
self.hp -= damage
print(self)
def test():
'''单独的测试两个类的功能'''
# 测试枪
# 生成枪
ak47 = Gun('AK47', 99)
print(ak47)
# 添加子弹
ak47.add_bullet(1)
print(ak47)
# # 设计敌人
# ak47.shoot('zs')
# print(ak47)
# ak47.shoot('zs')
# print(ak47)
# ak47.shoot('zs')
# print(ak47)
print('-------------')
# 测试玩家
# 生成玩家
police = Player('警察', 120)
# print(police)
# 玩家拿枪
police.take_gun(ak47)
print(police)
# 玩家开枪
badman = Player('土匪')
print(badman)
police.fire(badman)
test()
def main():
'''游戏主逻辑'''
# 生成两个玩家
police = Player('警察')
print(police)
badman = Player('土匪')
print(badman)
# 生成一把枪
k98 = Gun('98K', 98)
print(k98)
# 玩家拿枪
police.take_gun(k98)
print(police)
# 玩家开枪
police.fire(badman)
police.fire(badman)
k98.add_bullet(5)
print(police)
police.fire(badman)
police.fire(badman)
police.fire(badman)
# main()
2018-11-12
1.python2和python3的区别
2.Flask程序运行过程
①当客户端想要获取资源时,一般会通过浏览器发起HTTP请求
②此时,web服务器会把来自客户端的所有请求都交给Flask程序实例
③程序实例使用Werkzeug来做路由分发(URL请求和视图函数之间的对应关系)
在Flask程序中,路由的实现一般是通过程序实例的装饰器实现
④Flask调用视图函数后,可以返回两种内容
字符串内容:将视图函数的返回值作为响应的内容,返回给客户端(浏览器)
HTML模板内容:获取到数据后,把数据传入HTML模板文件中,模板引擎负责渲染数据,然后返回响应数据给客户端(浏览器)
内容总结
以上是互联网集市为您收集整理的python学习笔记全部内容,希望文章能够帮你解决python学习笔记所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。