概述
一、面向对象的简述
面向对象
需要有意义的面向对象的代码，不是有了类就是面向对象
核心：类 ，对象方法：设计层面
函数：程序运行，过程是一种称谓
变量：数据成员
二、面向对象分类：
（1）面向过程
（2）面向对象
面向过程 面向对象(oop:object oriented programming)
面向过程：---侧重于怎么做？
1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤和过程，不注重职责分工
2.如果需求复杂，代码变得非常复杂
3.开发复杂的项目的时候，没有固定的套路，开发难度很大
面向对象：----侧重于谁来做？
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责--要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
3.需要在面向过程的基础上，再学习一些面向对象的语法
面向过程--->侧重于怎么做？
面向对象--->测中于谁来做？
面向对象有两个核心的概念
类：是一类具有相同特征或行为的事物的一个统称
对象：由类创建出来的一个具体的存在
类和对象的关系：先有类再有对象
类是模板 对象是根据这个模板创建出来的
类只需要有一个 对象可以有多个
类：属性(这一类事务的共同信息) 和 方法(你能完成的动作)
1.类名：这类事物的名字(大驼峰命名法)
大驼峰命名法：
1.每个单词的首字母大写
2.单词与单词之间没有下划线
2.属性:这个类创建出来的对象有什么特征
3.方法:这个类创建出来的对象有什么行为
类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类
属性和方法的确定
对 对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法
提示：需求中没有涉及的属性或方法在设计类时，不需要考虑
小明今年18岁 身高1.80 每天早上要跑步，会去吃东西
小张今年17岁 身高1.85 小张不跑步 小张喜欢吃东西
class Person:
name
age
hight
run
eat
一只黄颜色的狗叫大黄
看见陌生人汪汪叫
看见主人摇尾巴
class Dog:
color
name
shout
shake
"""
# 定义一个猫类
class Cat:
def eat(self):
print('%s 爱吃鱼' %(self.name))
def drink(self):
print('猫要喝水')
hellokitty = Cat()
hellokitty.name = 'apple'
print(hellokitty.name)
print(hellokitty)
hellokitty.eat()
hellokitty.drink()
tom = Cat()
tom.name = 'Tom'
print(tom.eat())
print(tom.drink())
结果：
/opt/python3/bin/python3 /root/PycharmProjects/1127/博客.py
apple
<__main__.Cat object at 0x7f76efbd39e8>
apple 爱吃鱼
猫要喝水
Tom 爱吃鱼
None
猫要喝水
None
"""
self:
哪一个对象调用的方法，self就是哪一个对象的引用(指向对象的内存地址空间)
在调用方法的时候，程序员就不需要传递self参数(定义的时候，第一个参数必须是self)
""" 
三、类与对象
对象：对象是现实世界或者思维世界中的实体在计算机中的反映，
它将数据以及这些数据上的操作封装在一起类：一类事物的统称，对象是类具体化的产物，也就是实例化
不同的对象有什么不同特点：比如年龄，姓名
class Student():
name = ''
age = 0
def do_homework(self):
print('homework')
student1 = Student()
student1.do_homework()
student2 = Student()
student2.do_homework()
student3 = Student()
student3.do_homework()
print(id(student1))
print(id(student2))
print(id(student3))
四、构造函数
1.初始化方法：__init__():
class Student():
name = ''
age = 0
def __init__(self,name,age): #初始化方法
#构造函数
self.name = name
self.age = age
print('student')
# return 'student'
def do_homework(self):
print('homework')
student1 = Student('harry',18)
print(student1.name)
print(student1.age)
2.字符串方法__str__():
class Dog():
def __init__(self,name):
self.name = name
def __str__(self):
#必须返回一个字符串
return '这是 %s' %(self.name)
Gofei = Dog('旺财')
print(Gofei)
self:哪一个对象调用的方法，self就是哪一个对象的引用
在类封装的方法内部，self就表示当前调用方法的对象自己
self.name（属性名） = 形参 接收外部传递的参数
class Cat():
def __init__(self,new_name):
print('这是一个初始化方法')
self.name = new_name
def eat(self):
print('%s爱吃鱼' %self.name)
cat = Cat('tom')
print(cat.name)
hello_kitty = Cat('hk')
print(hello_kitty.name)
hello_kitty.eat()
实例：栈操作
class Stack():
def __init__(self):
self.stack = []
#进栈
def push(self,value):
self.stack.append(value)
return True
#出栈
def pop(self):
#先判断栈是否为空
if self.stack:
item = self.stack.pop()
return item
else:
return False
#栈顶元素
def top(self):
if self.stack:
return self.stack[-1]
else:
return False
#栈的长度
def length(self):
return len(self.stack)
#查看栈元素
def view(self):
return ','.join(self.stack)
s = Stack()
s.push('1')
s.push('2')
print(s.view())
item = s.pop()
print(item)
print(s.view())
五、封装
1.将属性和方法封装到一个抽象的类中
2.外界使用类创建对象，对象调用方法
3.对象方法的细节都被封装在类的内部
"""
需求
1.李雷体重75.0公斤
2.李雷每次跑步会减肥0.5公斤
3.李雷每次吃东西体重会增加1公斤
需求
1.李雷和韩梅梅都爱跑步
2.韩梅梅体重45.0公斤
3.李雷体重75.0公斤
4.每次跑步都会减少0.5公斤
5.每次吃东西都会增加1公斤
"""class Person():
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我的名字叫 %s 体重是 %.2f' %(self.name,self.weight)
def run(self):
print('%s爱跑步' %self.name)
self.weight -= 0.5 #每跑一次步瘦0.5公斤
def eat(self):
print('%s吃东西' %self.name)
self.weight += 1 #每吃一次+1公斤
Lilei = Person('李雷',75.0)
Lilei.run()
print(Lilei)
Lilei.eat()
print(Lilei)
六、继承
1、继承
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同的代码不需要重复的写
子类继承自父类，可以直接享受父类中已经封装好的方法
子类中应该根据职责，封装子类特有的属性和方法
class Animal():
def eat(self):
print('吃')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal): #继承动物类
def shout(self):
print('喵')
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.shout()
2、
子类可以继承父类的所有属性和方法
继承具有传递性，子类拥有父类的父类的属性和方法 class Animal():
def eat(self):
print('吃')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def shout(self):
print('喵')
class Hellokitty(Cat):
def speak(self):
print('我会说日语')
class Dog(Animal):
def bark(self):
print('汪')
kt = Hellokitty()
kt.speak()
kt.shout()
kt.eat()
kt.sleep()
3、
当父类方法不能满足子类的需求时？可以对方法进行重写
1.覆盖父类的方法
2.对父类的方法进行扩展
如果子类中，重写了父类的方法
在运形时，只会调用在子类中重写的方法
class Animal():
def eat(self):
print('吃')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def shout(self):
print('喵') #父类被重写的方法不会执行
class Hellokitty(Cat):
def speak(self):
print('我可以说日语')
def shout(self):
print('@#$%%@$#@#@$')
kt = Hellokitty()
kt.shout()
4、多继承
多继承：方法一样时会覆盖B方法
class A():
def test(self):
print('A --- test方法')
def demo(self):
print('A --- demo方法')
class B():
def test(self):
print('B --- test 方法')
def demo(self):
print('B --- demo方法')
class C(A,B): #只会继承A类
pass
c = C()
c.test()
c.demo()
七、新式类和经典类
"""
新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法
，可以使用dir函数查看
新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在python3.X中定义的类时，如果没有指定父类，会默认使用object作>为基类--python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基>类
为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object
"""
八、多态
子类和父类存在相同方法时，子类会覆盖父类方法
运行时总会调用子类方法
class Animal(object):
def run(self):
print('running...') #父类方法被覆盖
def cry(self):
print('crying...')
class Dog(Animal):
def run(self):
print('dog running...')
def eat(self):
print('dog eating...')
class Cat(Animal):
def run(self):
print('cat running...')
cat = Cat()
cat.run()
dog = Dog()
dog.run()
实例（二）
图书馆管理系统
"""
图书管理系统
1.查询图书
2.增加图书
3.借阅图书
4.归还图书
5.退出系统
"""# 书：书名，作者，状态，位置
# 管理系统：
class Book(object):
def __init__(self, name, author, status, bookindex):
self.name = name
self.author = author
self.status = status
self.bookindex = bookindex
def __str__(self):
if self.status == 1:
stats = '未借出'
elif self.status == 0:
stats = '已借出'
else:
stats = '状态异常'
return '书名: 《%s》 作者: %s 状态: <%s> 位置: %s'
% (self.name, self.author, stats, self.bookindex)
class BookManage(object):
books = []
def start(self):
self.books.append(Book('python', 'guido', 1, 'ISO9001'))
self.books.append(Book('c', '谭浩强', 1, 'NFS8102'))
self.books.append(Book('java', 'westos', 1, 'PKA7844'))
# 0:借出 1：存在
# python 1
# c 1
# java 1
def Menu(self):
self.start()
while True:
print("""
图书管理系统
1.查询图书
2.增加图书
3.借阅图书
4.归还图书
5.退出系统
""")
choice = input('请选择：')
if choice == '1':
self.showAllBook()
elif choice == '2':
self.addBook()
elif choice == '3':
self.borrowBook()
elif choice == '4':
self.returnBook()
elif choice == '5':
print('欢迎下次使用...')
exit()
else:
print('请输入正确选择')
continue
def showAllBook(self):
for book in self.books:
print(book)
def addBook(self):
name = input('图书名称:')
self.books.append(Book(name, input('作者:'), 1, input('存储位置:')))
print('图书《%s》增加成功' % name)
def checkBook(self, name):
for book in self.books:
if book.name == name:
return book
else:
return None
def borrowBook(self):
name = input('借阅图书名称: ')
ret = self.checkBook(name)
print(ret)
if ret != None:
if ret.status == 0:
print('书籍《%s》已经借出' % name)
else:
ret.status = 0
print('书籍《%s》借阅成功' % name)
else:
print('书籍《%s》不存在' % name)
def returnBook(self):
name = input('归还图书名称:')
ret = self.checkBook(name)
if ret != None:
if ret.status == 0:
ret.status = 1
print('书籍《%s》归还成功' % name)
print(ret)
else:
print('书籍《%s》未借出' % name)
else:
print('书籍《%s》不存在' % name)
manager = BookManage()
manager.Menu()
练习题0
"""
给定一个仅包含数字 2-9 的字符串，
返回所有它能表示的字母组合。
给出数字到字母的映射如下
（与电话按键相同）。注意 1 不对应任何字母
输入：”23”
输出：[“ad”, “ae”, “af”, “bd”,
“be”, “bf”, “cd”, “ce”, “cf”].
说明：尽管上面的答案是按字典序排列的，
但是你可以任意选择答案输出的顺序
"""
def phpneLetter(digits):
if not digits:
return []
keyboard = {
'2':'abc',
'3':'def',
'4':'ghi',
'5':'jkl',
'6':'mno',
'7':'pqrs',
'8':'tuv',
'9':'wzyz'
}
res = []
if len(digits) == 0:
return []
if len(digits) == 1:
return keyboard[digits]
resule = phpneLetter(digits[1:])
print(resule)
for i in resule:
for j in keyboard[digits[0]]:
res.append((j+i))
return res
print(phpneLetter('34'))
"""
https://github.com/pyecharts/pyecharts
pyecharts模块是用来绘制图形的模块，
其中的Line是绘制折线图的，
如果想要绘制散点图则导入Scatter。
我们要绘制折线图，所以导入的是Line。
先创建两个空列表，一个用来存储时间变化，
一个用来存储CPU占有率的变化，然后打开之前存好的信息，
并遍历文件的每一行内容，将内容添加到列表中，
之后对列表中的内容进行绘图就OK
"""
import random
from pyecharts.charts import Line
import pyecharts.options as opts
# 获取折线图需要绘制的数据信息;
x = []
y = []
with open('cpu.txt') as f: # 以读的方式打开文件
for line in f: # 依次遍历文件的每一行内容
time, per = line.split() # 返回时间和对应时间
# 的cpu占有率
x.append(time)
y.append(per)
# 添加x和y对应的点;
line = (
Line()
.add_xaxis(x)
.add_yaxis("", y)
.set_global_opts(title_opts=opts.
TitleOpts(title="Cpu占有率散点图"))
)
# 将折线图信息保存到文件中;
line.render()
"""
实现用python获取系统信息cpu占有率并将其变换绘制成
折线图
psutil模块是专门获取系统信息的模块，
在该模块里有一个cpu_percent()方法是用
来获取系统CPU占有率的。我们每隔1s
获取一次CPU占有率，并将获取到的信息存储
在指定文件中，
将其保存起来，本案例中我将文件命名为cpu.txt
"""
# 1.获取系统cpu占有率信息
import psutil
import time
# 隔一秒绘制CPU的占有率; 如何持久化保存?
# 如何将时间和对应的cpu占有率匹配
while True:
# 获取当前时间和cpu占有率
t = time.localtime()
cur_time = '%d:%d:%d' %(t.tm_hour,t.tm_min,t.tm_sec)
cpu_res = psutil.cpu_percent()
print(cpu_res)
# 保存到文件中
with open('cpu.txt','a+') as f:
f.write('%s %sn' %(cur_time,cpu_res))
time.sleep(1)9:18:46 0.0
9:18:47 9.8
9:18:48 4.3
9:18:49 2.0
9:18:50 1.2
9:18:51 2.0
9:18:52 1.5
9:18:53 1.5
9:18:54 2.0
9:18:55 1.7
9:18:56 1.0
9:18:57 2.0
9:18:58 1.5
9:18:59 8.0
老师笔记：
05.sys模块之参数的获取.py
import os
import sys
# print(sys.argv)
# # 获取脚本传递的第一个参数
# print(sys.argv[0])
# 获取脚本传递的第二个参数
# print(sys.argv[1])
print(sys.version)
# if sys.version[0] == '2':
# print('runnning in python2...')
# elif sys.version[0] == '3':
# print('running in python3...')
# 返回模块的搜索路径 初始pythonpath环境变量
# print(sys.path)
#
# # 可以实现跨平台
# print(sys.platform)
# if sys.platform == 'linux':
# os.system('ifconfig')
# else:
# os.system('ipconfig')
import os
import itchat
@itchat.msg_register(itchat.content.TEXT,isFriendChat=True)
def text_reply(msg):
if msg['ToUserName'] == 'filehelper':
# 获取要执行的命令内容
command = msg['Content']
# 让电脑执行命令代码
# 如果返回值为0 执行成功
if os.system(command) == 0:
res = os.popen(command).read()
result = '[返回值]-命令执行成功,执行结果:n' + res
itchat.send(result,'filehelper')
else:
result = '[返回值]-命令%s执行失败,请重新测试' %(command)
itchat.send(result,'filehelper')
itchat.auto_login()
itchat.run()
import itchat #第三方模块 需要网络下载
import time
# 1.给手机助手发消息
itchat.auto_login()
# while True:
# # 给手机微信助手发消息
# #itchat.send('hello',toUserName='filehelper')
# itchat.send_file('/etc/passwd',toUserName='filehelper')
# time.sleep(1)
# 2.统计你的好友的男女比例
friends = itchat.get_friends()
# print(friends)
info = {}
for friends in friends[1:]:
if friends['Sex'] ==1:
info['male'] = info.get('male',0) + 1
elif friends['Sex'] == 2:
info['female'] = info.get('female',0) + 1
else:
info['other'] = info.get('other',0) + 1
print(info)
"""
在python中执行shell命令
判断命令十是否这行成功
# 返回值是0 执行成功
# 返回值不是0 执行不成功
"""
import os
a = print(os.system('ls'))
print(a)
# print(os.system('hostnameeeeeee'))
res = os.popen('hostname').read()
print(res)
初始化方法：
"""
初始化方法：
类名() 就可以创建一个对象
类名()创建对象的时候 python解释器会执行哪些操作
1.为对象在内存中分配空间--创建对象
2.自动调用初始化方法为对象的属性设置初始值
这个初始化方法是内置方法，是专门用来定义一个类具有哪些属性
"""
class Cat:
def __init__(self,new_name):
#print('这是一个初始化方法')
self.name = new_name
def eat(self):
print('%s 吃' %(self.name))
def drink(self):
print('喝')
tom = Cat('Tom')
tom.eat()
hk = Cat('hellokitty')
hk.eat()
__str__:在python中，使用print输出对象变量的时候
默认情况下这个变量引用的对象是由哪一个类创建的对象及其在内存中的地址
如果在开发中 希望使用print输出变量的时候，能够打印自定义内容
就可以利用__str__这个内置的方法
class Cat:
def __init__(self,name):
self.name = name
def __str__(self):
# 返回必须是一个字符串
return '我是 %s' %(self.name)
tom = Cat('tom')
print(tom)
addr = id(tom)
print(addr)
# 十六进制
print('%x' %(addr))
# 十进制
print('%d' %(addr))
__del__:如果希望对象被销毁之前 再做一些事情
可以使用__del__
当一个对象被从内存中销毁前(del 对象)
会自动的调用__del__内置方法
class Cat:
def __init__(self,name):
self.name = name
print('%s 来了' %(self.name))
def __del__(self):
print('%s 走了' %(self.name))
tom = Cat('tom')
print(tom.name)
del tom
print('*' * 50)
print(tom.name)
栈:先进后出 入栈 出栈(pop) 取栈顶元素
判断栈是否为空 显示栈元素
[] [1,2]
队列:先进先出 [1,2]
class Stack:
def __init__(self):
self.stack = []
def push(self,value):
"""
:param value: 入栈元素
:return:
"""
self.stack.append(value)
return True
def pop(self):
# 判断栈是否为空
if self.stack:
# 获取出栈元素 并返回
item = self.stack.pop()
return item
else:
return False
def top(self):
if self.stack:
return self.stack[-1]
else:
return False
def length(self):
return len(self.stack)
def view(self):
return ','.join(self.stack)
s = Stack()
s.push('1')
s.push('2')
print(s.view())
item = s.pop()
print(item)
"""
封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象(因为类不能直接使用)的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部
需求
1.小明体重75.0公斤
2.小明每次跑步都会减肥0.5公斤
3.小明每次吃东西体重都会增加1公斤
需求
1.小明和小美都爱跑步
2.小美体重45.0公斤
2.每次跑步都会减肥0.5公斤
3.每次吃东西体重都会增加1公斤
"""
class Person:
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我的名字叫 %s 体重是 %.2f' %(self.name,self.weight)
def run(self):
print('%s 去跑步～～～' %(self.name))
self.weight -= 0.5
def eat(self):
print('%s 吃东西～～～' %(self.name))
self.weight += 1
a = Person('小明',89)
a.run()
a.eat()
print(a)
b = Person('lily',50)
b.eat()
b.run()
print(b)
"""
需求：
1.房子有户型,总面积和家具名称列表
新房子是没有家具的
2.家具有名字和占地面积，其中
eg:占地 6平方米
3.将以上三件家具添加到房子中
4.打印房子的时候，要求输出：户型 总面积 剩余面积 家具名称列表
"""
class HosuseItem:
# 初始化方法
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '[%s] 占地 %.2f' %(self.name,self.area)
class House:
def __init__(self, house_type, area):
self.house_type = house_type
self.area = area
# 剩余面积
self.free_area = area
self.item_list = []
def __str__(self):
return '户型:%sn总面积:%.2f[剩余:%.2f]n家具:%s'
% (self.house_type
, self.area, self.free_area
, self.item_list)
def add_item(self, item):
# 1.判断家具的面积
if item.area > self.free_area:
print('%s 的面积太大，无法添加' %(item.name))
return
# 要将家具的名称添加到列表中去
self.item_list.append(item.name)
# 计算剩余面积
self.free_area -= item.area
# 创建家具
bed = HosuseItem('床',400)
print(bed)
chest = HosuseItem('chest',2)
print(chest)
table = HosuseItem('桌子',4.5)
print(table)
# 创建房子对象
my_home = House('三室一厅',150)
# 将家具添加到房子里面去
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)
"""
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
"""
class Gun:
def __init__(self,model):
self.model = model
self.bullet_count = 0
def add_bllet(self,count):
self.bullet_count += count
def shoot(self):
if self.bullet_count <=0:
print('%s 没有子弹了...' %(self.model))
return
self.bullet_count -= 1
print('%s-----%s' %(self.model,self.bullet_count))
class Soldier:
def __init__(self,name):
self.name = name
self.gun = None
def fire(self):
if self.gun == None:
print('%s没有枪...' %(self.name))
return
self.gun.add_bllet(50)
self.gun.shoot()
ak47 = Gun('ak47')
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
ryan.fire()
class Book(object):
def __init__(self, name, author, state, bookIndex):
self.name = name
self.author = author
# 0:借出 1：未借出
self.state = state
self.bookIndex = bookIndex
# 打印对象时自动调用;str(对象)
def __str__(self):
return "书名:<%s> 状态:<%s>" % (self.name, self.state)
class BookManage(object):
books = []
def start(self):
"""图书管理初始化"""
b1 = Book('python', 'Guido', 1, "INS888")
self.books.append(b1)
self.books.append(Book('java', 'hello', 1, "IGS888"))
self.books.append(Book('c', 'westos', 1, "INS880"))
def Menu(self):
self.start()
while True:
print("""
图书管理系统
1. 查询
2. 增加
3. 借阅
4. 归还
5. 退出
""")
choice = input("Choice:")
if choice == "1":
pass
elif choice == '2':
self.addBook()
elif choice == '3':
self.borrowBook()
else:
print("清输入正确的选择!")
def addBook(self):
name = input("书名：")
self.books.append(Book(name, input("作者:"), 1, input("书籍位置:")))
print("添加图书%s成功!" % (name))
def borrowBook(self):
name = input("借阅书籍名称:")
ret = self.checkBook(name)
if ret != None:
if ret.state == 0:
print("书籍《%s》已经借出" % (name))
else:
ret.state = 0
print("借阅%s成功" % (name))
else:
print("书籍《%s》不存在!" % (name))
def checkBook(self, name):
"""查找书籍是否存在"""
for book in self.books:
# book: Book类创建的对象
# book.name;
if book.name == name:
# 返回book对象
return book
else:
return None
bookManage = BookManage()
bookManage.Menu()
redis
import time
import redis
# redis.Redis(host='localhost',port=6379)
# conn = redis.Redis()
# conn.set('name','westos',3)
# print(conn.get('name'))
# print('等待3s...')
# time.sleep(3)
# print(conn.get('name'))
pool = redis.ConnectionPool(host='localhost',port=6379)
conn = redis.Redis(connection_pool=pool)
conn.set('name','粉条',4) #4代表的是失效时间，单位为s
# 默认返回的是bytes类型，
# 如果需要转换 要解码为utf-8编码格式
print(conn.get('name').decode('utf-8'))
print('等待3s...')
time.sleep(3)
print(conn.get('name'))
import time
import redis
pool = redis.ConnectionPool(host='localhost',port=6379)
conn = redis.Redis(connection_pool=pool)
conn.set('name','fentiao',3)
conn.set('age',10,3)
conn.set('score',100,3)
print(conn.get('name'))
# print(conn.get('movie'))
# 获取所有的key值
print(conn.keys())
print(len(conn.keys()))
# 当前redis数据库中数据条数
print(conn.dbsize())
# 删除指定的k-v
conn.delete('score')
print('正在删除key...')
print(conn.get('score'))
print('清除前：',conn.keys())
# 清除redis里面所有的k-v
conn.flushall()
print('清除后:',conn.keys())
import redis
pool = redis.ConnectionPool(host='localhost',port=6379)
conn = redis.Redis(connection_pool=pool)
# 选择集合存储
conn.sadd('python','user1')
conn.sadd('python','user2')
conn.sadd('python','user3')
conn.sadd('movie','user1')
conn.sadd('movie','user4')
conn.sadd('movie','user2')
# 获取某个课程的成员
print(conn.smembers('python'))
print(conn.smembers('movie'))
# 获取两个课程共同的成员
print(conn.sinter('python','movie'))
# 获取全部的成员
print(conn.sunion('python','movie'))
"""
封装：根据职责将属性和方法封装到一个抽象的类中
继承：实现代码的重用 相同的代码不需要重复的写
"""
class Animal:
def eat(self):
print('吃...')
def drink(self):
print('喝...')
def run(self):
print('跑...')
def sleep(self):
print('睡...')
class Cat(Animal):
# def eat(self):
# print('吃...')
# def drink(self):
# print('喝...')
# def run(self):
# print('跑...')
# def sleep(self):
# print('睡...')
def call(self):
print('喵喵～')
class Dog(Animal):
def bark(self):
print('汪汪～')
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()
wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()
"""
继承具有传递性
当父类方法不能满足子类的需求的时候
可以对方法进行重写
1.覆盖父类的方法
2.对父类的方法进行扩展
"""
class Animal:
def eat(self):
print('吃...')
def drink(self):
print('喝...')
def run(self):
print('跑...')
def sleep(self):
print('睡...')
class Cat(Animal):
def call(self):
print('喵喵～')
class HelloKitty(Cat):
def sepak(self):
print('我可以说日语')
def call(self):
# 调用原本在父类中封装的方法
#super().call()
# Cat.call(self) #python2.x
print('$@#%@%@')
kt = HelloKitty()
kt.eat()
kt.run()
kt.sepak()
kt.call()
"""
类的结构
术语--实例
1.使用面向对象开发，第一步是设计类
2.使用 类名() 创建对象，创建对象的动作有两步
1.在内存中为对象分配空间
2.调用初始化方法__init___ 为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在--实例
因此：
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时：
1.对象各自拥有自己的实例属性
2.调用对象的方法，可以通过self
访问自己的属性
调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中之有一份，在调用方法时，
需要把对象的引用传递到方法内部
"""
class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print('$@$#$#$@#$')
self.hungry = False
else:
print('No thank')
# 在鸟类的基础上
class SongBird(Bird):
def __init__(self):
super().__init__()
self.sound = 'AAAAAaaa!!!'
def sing(self):
print(self.sound)
bird = SongBird()
bird.eat()
bird.sing()
"""
新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，
可以使用dir函数查看
新式类：以object为基类的类
经典类 不以object为基类的类
在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类--
python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基类
为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object
"""
[root@foundation0 ~]# python
Python 2.7.5 (default, Aug 2 2016, 04:20:16)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> class A:
... pass
...
>>> dir(A)
['__doc__', '__module__']
>>> class B(object):
... pass
...
>>> dir(B)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
[dd@foundation0 ~]$ /usr/local/python3/bin/python3
Python 3.6.4 (default, Aug 10 2018, 11:14:49)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> class A:
... pass
...
>>> dir(A)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
>>> class B(object):
... pass
...
>>> dir(B)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
"""
class A(object):
pass
class A:
def test(self):
print('A----test方法')
def demo(self):
print('A-----demo方法')
class B:
def test(self):
print('B---test方法')
def demo(self):
print('B---demo方法')
class C(B,A):
pass
c = C()
c.test()
c.demo()
"""
多态(以封装和继承为前提)
不同的子类对象调用相同的方法 产生不同的结果
"""
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print('%s 开心的玩～' %(self.name))
class Gaofei(Dog):
# 父类的方法不能满足子类的需求 重写game方法
def game(self):
print('%s和米老鼠玩～～' %(self.name))
class Person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print('%s和%s开心的玩' %(self.name,dog.name))
dog.game()
# 创建一个狗对象
wangcai = Dog('大黄')
wangcai2 = Gaofei('高飞')
# 创建一个人对象
xiaoming = Person('小明')
xiaoming.game_with_dog(wangcai)
"""
类属性:针对类定义的属性 使用赋值语句在class关键字下可以定义类属性
类方法：针对类定义的方法 在类方法内部可以直接访问类属性或掉用其他的类方法
"""
class Toy(object):
# 使用赋值语句定义属性 记录所有的玩具数量
count = 0
def __init__(self, name):
self.name = name
# 让类属性+1
Toy.count += 1
@classmethod
def show_toy_count(cls):
print('玩具对象的数量 %d' % (cls.count))
# 创建玩具对象
# toy1 = Toy('乐高')
# toy2 = Toy('泰迪熊')
Toy.show_toy_count()
class Cat(object):
@staticmethod
def call():
print('喵喵')
# 通过类名.方法名 调用静态方法
Cat.call()
# 不需要创建对象 直接就可以调用
"""
单例设计模式
设计模式
设计模式是前人工作的总结和提炼，通常，被人们广泛流传的设计模式都
是针对某一特定问题的成熟解决方案
使用设计模式是为了可重用代码，让代码更容易被他人理解，
保证代码可靠性
单例设计模式
目的：让类创建对象，在系统中只有唯一的一个实例(对象)
每一次执行类名()返回的对象
内存地址是相同的
# 怎么保证 这些对象只有一个？
__new__方法:
========================================================================
我们用 类名. 的方式创建对象的时候，python解释器会帮我们做两件事情，
是哪两件事情呢？
1.为对象分配空间 2.对象初始化
=======================================================================
使用类名()创建对象时，python的解释器首先会调用__new__方法为对象分配空间
__new__是一个由object基类提供的内置的静态方法，主要有两个作用：
在内存中为对象分配空间
返回对象的引用
python的解释器获得对象的引用后，将引用作为第一个参数，传递给__init__方法
#__new__：负责给对象分配空间 __init__(初始化方法)负责给对象初始化
我们要重写new方法，使用类名()创建对象的时候，返回的都是同一个地址
=========================================================
重写__new__方法的代码非常固定：
继承自父类方法
返回父类方法调用_new__方法的结果
重写__new__方法一定要return object.__new__(cls)
否则python的解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法
"""
class MusicPlayer(object):
instance = None
def __new__(cls, *args, **kwargs):
print('创建对象 分配空间')
# 1.创建对象的时候 new方法会被自动调用
# instance = object.__new__(cls)
# return instance #返回的就是对象的引用
# 判断类属性是否为None
if cls.instance is None:
# 调用父类的方法 为第一个对象分配空间
cls.instance = object.__new__(cls)
return cls.instance
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)
import pymysql
class TransferMoney(object):
# 构造方法
def __init__(self,conn):
self.conn = conn
self.cur = conn.cursor()
def transfer(self,source_id,target_id,money):
# 1.判断两个银行卡号是否存在
# 2.判断source_id是否有足够的钱
# 3.source_id扣钱
# 4.target_id加钱
if not self.check_account_avaialbe(source_id):
raise Exception("账户不存在")
if not self.check_account_avaialbe(target_id):
raise Exception("账户不存在")
if self.has_enough_money(source_id, money):
try:
self.reduce_money(source_id, money)
self.add_money(target_id, money)
except Exception as e:
print("转账失败:", e)
self.conn.rollback()
else:
self.conn.commit()
print("%s给%s转账%s金额成功" % (source_id,
target_id, money))
def check_account_avaialbe(self, acc_id):
"""判断帐号是否存在， 传递的参数是银行卡号的id"""
select_sqli = "select * from bankData where id=%d;" % (acc_id)
print("execute sql:", select_sqli)
res_count = self.cur.execute(select_sqli)
# res_count:返回数据记录数，只要有一条记录存在，
# 就证明账户存在
if res_count == 1:
return True
else:
return False
def has_enough_money(self, acc_id, money):
"""判断acc_id账户上金额> money"""
# 查找acc_id存储金额?
select_sqli = "select money from bankData where id=%d;" % (acc_id)
print("execute sql:", select_sqli)
self.cur.execute(select_sqli) # ((100, 100), )
# 获取查询到的金额钱数
# acc_moneys = self.cur.fetchone()
# print(acc_moneys)
acc_money = self.cur.fetchone()[0]
print(acc_money)
# 判断
if acc_money >= money:
return True
else:
return False
def add_money(self, acc_id, money):
update_sqli = "update bankData set money=money+%d where id=%d" % (money, acc_id)
print("add money:", update_sqli)
self.cur.execute(update_sqli)
def reduce_money(self, acc_id, money):
update_sqli = "update bankData set money=money-%d where id=%d" % (money, acc_id)
print("reduce money:", update_sqli)
self.cur.execute(update_sqli)
# 析构方法
def __del__(self):
self.cur.close()
self.conn.close()
# 1. 连接数据库，
conn = pymysql.connect(
host='localhost',
user='root',
password='redhat',
db='westos',
charset='utf8',
autocommit=True, # 如果插入数据，， 是否自动提交? 和conn.commit()功能一致。
)
trans = TransferMoney(conn)
#trans.add_money(100,200)
# trans.transfer(100,200,10)
#trans.has_enough_money(100,270)
最后
以上就是激昂大山为你收集整理的python中面向对象的全部内容，希望文章能够帮你解决python中面向对象所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复