- 面向对象高级语法部分
- 静态方法、类方法、属性方法
- 类的特殊方法
- 反射
- 异常处理
- Socket开发基础
1.1 静态方法,类方法,属性方法
# Author AlleyYu
# 静态方法
#
通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里可以通过self.调用实例变量或类变量,但静态方法是不可以访问实例变量或类变量的,一个不能访问实例变量和类变量的方法,其实相当于跟类本身已经没什么关系了,它与类唯一的关联就是需要通过类名来调用这个方法
# class Dog(object):
# def __init__(self,name,food):
# self.name=name
# self.__food=food
# @ staticmethod
# def eat(self):
# print(‘%s is eating %s‘%(self.name,self.__food))
#
#
# d1=Dog(‘bark‘,‘baozi‘)
# d1.eat(d1)
#类方法 #A is eating pizza 类方法通过@classmethod装饰器实现,类方法和普通方法的区别是, 类方法只能访问类变量,不能访问实例变量
# class Dog(object):
# name=‘A‘
# food=‘pizza‘
# def __init__(self,name,food):
# self.name=name
# self.food=food
# @ classmethod
# def eat(self):
# print(‘%s is eating %s‘%(self.name,self.food))
#
#
# d1=Dog(‘bark‘,‘baozi‘)
# d1.eat()
#属性方法
# class Dog(object):
# def __init__(self,name,food):
# self.name=name
# self.__food=food
# @ property
# def eat(self):
# print(‘%s is eating %s‘%(self.name,self.__food))
# d1=Dog(‘bark‘,‘baozi‘)
# d1.eat
# print(type(d1.eat),type(d1)) #,
#属性方法的传参
class Dog(object):
def __init__(self,name,food):
self.name=name
self.__food=food
@ property
def eat(self):
print(‘%s is eating %s‘%(self.name,self.__food))
@eat.setter
def eat(self, food):
print(‘set value to food‘, food)
self.__food = food
@eat.deleter
def eat(self):
del self.__food
print("del the attibute")
d1=Dog(‘bark‘,‘baozi‘)
d1.eat
d1.eat=‘pizza‘#传递参数时候调用setter
d1.eat=‘Pie‘
del d1.eat #删除的时候调用deleter
d1.eat
#print(type(d1.eat),type(d1)) #,
1.2 类的特殊成员方法
# Author AlleyYu
class School(object):
‘‘‘这是一个学校类‘‘‘
CourseListAll = [‘go‘, ‘python‘, ‘linux‘]
def __init__(self,name,addr):
self.name=name
self.addr=addr
def enroll(object):
print(‘%s 学生注册‘,object.name )
def hire(object):
print(‘%s 老师入职‘, object.name)
def __str__(self):
return (‘alley‘)
def __getitem__(self, key):
print(‘__getitem__‘,key)
def __setitem__(self, key, value):
print(‘__setitem__‘,key,value)
def __delitem__(self, key):
print(‘__delitem__‘,key)
s1=School(‘51CTO‘,‘Beijing‘)
#print (s1.__doc__) # 表示类的描述信息 >>>>这是一个学校类
print (s1.__module__)# __main__ 表示当前操作的对象在那个模块
print (s1.__class__)# 表示当前操作的对象的类是什么
#s1.__init__()#构造方法,通过类创建对象时,自动触发执行。
#s1.__del__#析构方法,当对象在内存中被释放时,自动触发执行。
print(s1.__dict__ ) #查看类或对象中的所有成员 {‘name‘: ‘51CTO‘, ‘addr‘: ‘Beijing‘}
print(s1) #如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值。 alley
results=s1[‘k1‘] ## 自动触发执行 __getitem__
s1[‘k2‘]=‘alley‘# # 自动触发执行 __setitem__
del s1[‘k2‘]
#Python中一切事物都是对象。
#S1对象是School类的一个实例,School类对象是 type 类的一个实例
print(type(s1))#>>>>>>>
print(type(School))#>>>>>>>>>>>>>>>>>>
#那么,创建类就可以有两种方式:
#普通
class Foo(object):
def func(self):
print(‘alley‘)
#特殊
#type第一个参数:类名
#type第二个参数:当前类的基类
#type第三个参数:类的成员
def func(self):
print(‘alley‘)
Foo = type(‘Foo‘, (object,), {‘func‘: func})
@@@@@@ metaclass 详解文章:http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python 得票最高那个答案写的非常好
1.3反射
通过字符串映射或修改程序运行时的状态、属性、方法, 有以下4个方法:
# Author AlleyYu
def run():
print(‘running‘)
class Dog(object):
def __init__(self,name,food):
self.name=name
self.__food=food
def eat(self):
print(‘%s is eating %s‘%(self.name,self.__food))
def talk(self):
print(‘%s is ing %s‘ % (self.name, self.__food))
d1=Dog(‘Bug‘,‘pizza‘)
choice=input(‘>>>‘).strip()
print(hasattr(d1,choice))
if hasattr(d1,choice):
getattr(d1,choice)()
else:
setattr(d1,choice,run)
vew=getattr(d1,choice)
vew()
delattr(d1,choice)
print(d1.__class__)
class Foo(object):
def __init__(self):
self.name = ‘wupeiqi‘
def func(self):
return ‘func‘
obj = Foo()
# #### 检查是否含有成员 ####
hasattr(obj, ‘name‘)
hasattr(obj, ‘func‘)
# #### 获取成员 ####
getattr(obj, ‘name‘)
getattr(obj, ‘func‘)
# #### 设置成员 ####
setattr(obj, ‘age‘, 18)
setattr(obj, ‘show‘, lambda num: num + 1)
# #### 删除成员 ####
delattr(obj, ‘name‘)
delattr(obj, ‘func‘)
2.异常处理
# Author AlleyYu
list=[‘a‘,‘b‘]
dic={‘name‘: ‘dog‘}
#常见异常
# AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
# IOError 输入/输出异常;基本上是无法打开文件
# ImportError 无法引入模块或包;基本上是路径问题或名称错误
# IndentationError 语法错误(的子类) ;代码没有正确对齐
# IndexError 下标索引超出序列边界,比如当x只有三个元素,却试图访问x[5]
# KeyError 试图访问字典里不存在的键
# KeyboardInterrupt Ctrl+C被按下
# NameError 使用一个还未被赋予对象的变量
# SyntaxError Python代码非法,代码不能编译(个人认为这是语法错误,写错了)
# TypeError 传入对象类型与要求的不符合
# UnboundLocalError 试图访问一个还未被设置的局部变量,基本上是由于另有一个同名的全局变量,
# 导致你以为正在访问它
# ValueError 传入一个调用者不期望的值,即使值的类型是正确的
# try :
# list[3]
# dic[‘class‘]
#
# except IndexException as e:
# print(e)
# except Exception as e:
# print(‘未知错误‘,e)
# else:
# print("一切正常")
# 未捕获到异常,程序直接报错
s1 = ‘hello‘
try:
int(s1)
except IndexError as e:
print(e)
#所以,写程序时需要考虑到try代码块中可能出现的任意异常,可以这样写:
s1 = ‘hello‘
try:
int(s1)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
except ValueError as e:
print(e)
#万能异常
#在python的异常中,有一个万能异常:Exception,他可以捕获任意异常,即:
s1 = ‘hello‘
try:
int(s1)
except Exception as e:
print(e)
#异常其他结构
try:
# 主代码块
pass
except KeyError as e:
# 异常时,执行该块
pass
else:
# 主代码块执行完,执行该块
pass
finally:
# 无论异常与否,最终执行该块
pass
#主动触发异常
try:
raise Exception(‘错误了。。。‘)
except Exception as e:
print(e)
#自定义异常
class alleyError(Exception):
def __init__(self, msg):
self.message = msg
try :
raise alleyError(‘数据库连接错误‘)
except alleyError as e:
print(e)
3.socket 编程
socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO、打开、关闭)
socket和file的区别:
- file模块是针对某个指定文件进行【打开】【读写】【关闭】
- socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】
![技术分享](https://img.php1.cn/3cd4a/1eebe/cd5/bdd1ca32a69bc8b2.webp)
#client
import socket
client=socket.socket()
client.connect((‘localhost‘,8080))
client.send(b‘heeloo worls ‘)
data=client.recv(1024)
print(‘rec>>‘,data)
client.close()
#server
import socket
server=socket.socket()
server.bind((‘localhost‘,8080))
server.listen()
conn,addr=server.accept()
print(conn,addr)
data=conn.recv(1024)
conn.send(data.upper())
print(‘rec>>‘,data)
server.close()
PYTHON学习笔记-DAY-7