1.#面向对象
#抽象接口 === 抽象类
#就是架构师给你一个架子，你们去写，如果满足不了直接报错
#python2
print("python2---抽象类".center(20,'#'))
import abc #需要在python2中测试，如果直接运行会报错
#因为没有调用send方法
class Alert(object):
'''报警基类'''
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def send(self): #特指了 子类必须实现send方法
'''报警消息发送接口'''
pass
class MailAlert(Alert): #报错函数
pass
# class MailAlert(Alert): #正确函数
# def send(self,msg):
# print("-----right---",msg)
m = MailAlert()
m.send()
#m.send('hello')
print("python3---抽象类".center(20,'#'))
class Alert(object):
'''报警基类'''
def send(self): #特指了 子类必须实现send方法
'''报警消息发送接口'''
raise NotImplementedError #主动报错
# class MailAlert(Alert): #报错函数
# pass
class MailAlert(Alert): #正确函数
def send(self):
print("-----right---")
m = MailAlert()
m.send()
2.静态方法
):
def __init__(self,name):
self.name = name
def eat(self):
print("%s is eating...." % self.name)
p = person("alex")
p.eat()
print("转为静态方法".center(20,'#'))
#为了解决实例化占用内存，但是到时候会需要考虑一下是不是需要真的真么多实例
#静态方法就是不需要实例化
class person(object):
def __init__(self,name):
self.name = name
@staticmethod
def eat(name,food):#静态方法不能访问公有属性，也不能访问实例
print("%s is eating...." % name,food)
# p = person("alex") #不需要实例了
person.eat("alex","shit")
3.类方法
print("类方法".center(20,'#'))
class person(object):
name = "rain"
def __init__(self,name):
self.name = name
@classmethod #类方法
def walk(self): #类方法只能反问类的公有属性不能访问实力属性
print("%s is walking.." % self.name)
p = person("alex")
p.walk()
#所以打印出来的是rain在walk
4.属性方法
print("属性方法".center(20,'#'))
class person(object):
name = "rain"
def __init__(self,name):
self.name = name
@property #属性方法的作用是把一个方法变成一个静态属性
def talk(self):
print("%s is talking.." % self.name)
@talk.setter
def talk(self,msg):
print("set msg:",msg)
@talk.deleter
def talk(self):
print("delet talk...")
p = person("alex")
p.talk #调用不需要加()，相当于你访问的变量其实是一个方法 读取值
p.talk = "hello" #这个赋值变量在调用方法 修改值
del p.talk #这个是删除 删除值
#作用可以参考航班实例
5.其他方法
print("其他方法".center(20,'#'))
class person(object):
'''hahahahahah'''
def __init__(self,name):
self.name = name
def tell(self):
print("what do you say... %s" % self.name)
p = person("jack")
p.tell()
print(p.__doc__) #打印类的注释打印 hahahahah
print(p.__module__) #当前哪个模块 __main__表示当前的某块就在当前
print(p.__class__) #当前哪个类
#***当属性方法航班状态查询加个判断if __name__ == '__main__':
#这样的话在被调用的时候执行了以上的代码，而不被调用一下的调用
# print("字符串导入模块".center(20,'#'))
# from day import 属性方法航班状态查询
# mod = __import__('day8work.属性方法航班状态查询')
# print(mod.属性方法航班状态查询.Filght('ca980'))
6.创建类的方法
print("meta".center(20,'#'))
#普通创建类的方法
class Foo(object):
def __init__(self, name):
self.name = name
f = Foo("alex")
print(type(f)) #f 由foo foo由 type 生成
print(type(Foo))
#特殊方法创建类
def talk(self,msg):
print("%s is talking:%s" % (self.name,msg)) #里面小括号续加上，不然调用不了
def __init__(self,name):
self.name = name
dog = type('dog',(object,),{"talk":talk,"__init__":__init__})
print(dog)
d = dog("alex")
d.talk("eat")
7.异常处理基本机构种类
print("异常处理".center(20,'#'))
# while True:
# try:
# a1 = input('>>>')
# a2 = input('>>>')
# a1 = int(a1)
# a2 = int(a2)
# a3 = a1 + a2
# print(a3)
# except Exception as e:
# # print(e) #e 里面包括的错误信息
# print("你输入的错误")
#基本结构
# try:
# 代码块
# 代码块
# except Exception as e: e 其实就是exception的对象，可以使用其他名称代替
# 将错误信息写入日志文件
#复杂结构
# try:
# ...
# except:
# ...
# else: 没有错误的时候执行
# ...
# finally: 正确与否，代码肯定要执行的
# ...
#异常对象
try:
int('fdsfdsf')
except Exception as e:
print(e) #invalid literal for int() with base 10: 'fdsfdsf'
try:
li = [11,22]
li[3]
except Exception as e: #python内部将错误信息封装到e的对象中，就是exceptino
print(e) #list index out of range
#异常种类
#Exception #能将所有的异常都捕获
# ...
# 其他 只能处理某一种情况
# try:
# 代码块
# 代码块
# except ValueErroras e:
# 将错误信息写入日志文件
# except KeyError as e:
# 将错误信息写入日志文件
# except Exception as e:
# 将错误信息写入日志文件
# ValueError 可以替换Exception
# KeyError
# IOError
# IndexError
8.主动触发异常，程序分层
#主动触发异常 程序分层
try:
raise Exception('error') #主从触发将错误信息封装到e里面
except Exception as e:
print(e)
# try:
# result = fool() 拿到返回值来判断,就是没有异常，但是邮件没有发送成功
# if result:
# pass
# else:
# raise Exception('邮件发送失败')
# foo2()
# except Exception as e:
# 记录日志
9.断言
print("断言".center(20,'#'))
#ios 去打开 安卓的app是不是直接就断开了
#所以在开始之前先判断，例如系统
# assert(关键字) 条件
print(1)
assert 1==1 # assert 1==2 只显示1并且抛出错误
print(2)
10.自定义异常
print("自定义异常".center(20,'#'))
#开发一个类，来继承exception 来实现满足你自己定义的异常
class lilierror(Exception):
def __init__(self,msg):
self.msg = msg
super(lilierror,self).__init__(msg)#执行父类的构造方法
try:#如果想要打印出来msg必须加上，不然父类不知道
name = 'alex'
if name != 'lili':
raise lilierror('哈哈哈 lili我错了')
except IndexError as e:
print(e)
except lilierror as e:
print(e,e.msg) #这个就是调用类方法来显示了
except Exception as e:
print(e,1111)
#重点 1 2 3 4 5 断言和自定义异常很少用 基本代码块+主动触发异常
11.反射
#反射写法
# inp = input("请输入url") #account/login
# m,n = inp.split('/') #m account n login
# from dir import app
# action = input('>>') #可以用户输入
# # if(hasattr(app,action))：
# func =getattr(account,action)
# v = getattr(app,action)
# result = v()
# print(result)
#getattr() 专以字符串的形式去某个对象中获取指定的属性
#hasattr() 以字符串的形式去某个对象中是否含有指定的属性
#setattr(容器，名称，值) 以字符串的形式去某个对象中设置指定的属性
#delattr() 以字符串的形式去某个对象中删除指定的属性
# from dir import app
# action = input('>>') #可以用户输入
# if(hasattr(app,action))：
# func =getattr(account,action)
# result = func()
# else
# result = '404'
# print(result)
#反射最终版
#通过字符串导入模块，可以实现某块/函数 这样的话通过/分割，就可以实现直接调用
#module = __import__('dir.app',formlist=Ture) 这样的话相当于导入模块不加TRUE的话，前面是什么就是什么了
# while True:
# inp = input("请输入url")
# m,n = inp.split('/')
# try:
# module = __import__('dir.%s' % m,fromlist=True)
# if hasattr(module,n):
# func =getattr(module,n)
# result = func()
# else:
# result = 404
# except Exception as e:
# result = '500'
# print(result)
12.socket编程
#socket osi 七层 tcp 三次握手
#服务器端
#socket.socket(AF_INET,SOCK_STREAM) 先创建sock实例
#server.bind('0.0.0.0',8000) 监听Ip端口
#server.listen(5) 可以多个并列
#server.accept() 接收请求
#conn(建立链接),client_addr(地址) = server.accept()
#conn.send() 发送消息
#conn.recv() 接收消息
#server.close()
#server.send()
#客户端
# socket.socket(AF_INET,SOCK_STREAM)
# client.connect()
# client.send()
12.socket编程 c s架构
client 端的代码量
#!/usr/bin/env python
#_*_coding:utf-8_*_
# import socket
# client = socket.socket()
# client.connect(("localhost",9998))
# while True:
# msg = input(">>:").strip()
# if len(msg) == 0: continue
# client.send(msg.encode("utf-8"))
# data = client.recv(1024)
# print("来自服务器:", data)
# client.close()
#基本结构
# import socket
# client = socket.socket()
# client.connect(('localhost',8000))
# client.send(b'hello')
# date = client.recv(1024)
# print(date)
#
# #循环收发
# import socket
# client = socket.socket()
# client.connect(('localhost',8000))
# while True:
# client.send(b'hello')
# date = client.recv(1024)
# print(date)
#单循环客户发送信息
# import socket
# client = socket.socket()
# client.connect(('localhost',8000))
# while True:
# msg = input('>>>:').strip()
# if len(msg) == 0: continue
# client.send(msg.encode())
# date = client.recv(1024)
# print('laizisever',date)
#排列链接
# import socket
# client = socket.socket()
# client.connect(('localhost',8000))
# while True:
# msg = input('>>>:').strip()
# if len(msg) == 0: continue
# client.send(msg.encode())
# date = client.recv(1024)
# print('laizisever',date)
#
#调用Linux系统命令实现ssh top -bn 1
# import socket
# client = socket.socket()
# client.connect(('10.10.10.140',8002))
# while True:
# msg = input('>>>:').strip()
# if len(msg) == 0: continue
# print('to server', msg)
# client.send(msg.encode())
# date = client.recv(1024)
# print(date.decode())
#调用Linux系统命令实现ssh top -bn 1 将接收大文件数据
import socket
client = socket.socket()
client.connect(('10.10.10.140',8002))
while True:
msg = input('>>>:').strip()
if len(msg) == 0: continue
print('to server', msg)
client.send(msg.encode())
date = client.recv(1024)
print("res:",date.decode())
total_size = int(date.decode())
recevied_size = 0
res = b''
while recevied_size < total_size:
d = client.recv(1024)
res += d
recevied_size += len(d)
print("rece done----")
print(res.decode())
server 端的代码量
#!/usr/bin/env python
#_*_coding:utf-8_*_
# import socket
# server = socket.socket() #获得socket实例
#
# server.bind(("localhost",9998)) #绑定ip port
# server.listen() #开始监听
# print("等待客户端的连接...")
# conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
# print("新连接:",addr )
# while True:
# data = conn.recv(1024)
# print("收到消息:",data)
# conn.send(b"server")
# server.close()
#基本结构
# import socket
# server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# server.bind(('0.0.0.0',8000))
# server.listen(5)
# # print("hahahahaha")
# conn,client_addr = server.accept()
# print(conn,client_addr)
# date = conn.recv(1024)
# conn.send(b'woshisever')
# print(date)
# #循环收发
# import socket
# server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# server.bind(('0.0.0.0',8000))
# server.listen(5)
# conn,client_addr = server.accept()
#
# while True:
# date = conn.recv(1024)
# print('shoudao client',date)
# conn.send(b'woshisever')
#单循环收发客户端信息
# import socket
# server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# server.bind(('0.0.0.0',8000))
# server.listen(5)
# conn,client_addr = server.accept()
#
# while True:
# date = conn.recv(1024)
# print('shoudao client',date)
# conn.send(b'woshisever')
#排列链接，当一个断块，另一个可以链接
# import socket
# server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# server.bind(('0.0.0.0',8000))
# server.listen(5)
#
# while True:
# conn,client_addr = server.accept()
#
# while True:
# try:
# date = conn.recv(1024)
# print('shoudao client',date)
# conn.send(b'woshisever')
# except ConnectionResetError as e:
# print(e)
# break
#调用Linux系统命令实现ssh
# import socket
# import subprocess
# server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# server.bind(("0.0.0.0",8002))
# server.listen(5)
# print("--------listen-----------")
#
# while True:
# conn,client_addr = server.accept()
# while True:
# date = conn.recv(1024)
# print("recv from cli:",date)
# res = subprocess.Popen(date,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
# conn.send(res.stdout.read())
#调用Linux系统命令实现ssh 实现大数据返回消息
# import socket
# import subprocess
# server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# server.bind(("0.0.0.0",8002))
# server.listen(5)
# print("--------listen-----------")
#
# while True:
# conn,client_addr = server.accept()
# while True:
# date = conn.recv(1024)
# print("recv from cli:",date)
# res_obj = subprocess.Popen(date,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
# res = res_obj.stdout.read()
# conn.send(str(len(res)).encode())
# conn.send(res)
