PYTHON学习笔记-DAY-7

  1. 面向对象高级语法部分

    1. 静态方法、类方法、属性方法
    2. 类的特殊方法
    3. 反射
  2. 异常处理
  3. 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 ‘NoneType‘>, <class ‘__main__.Dog‘>

#属性方法的传参
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))  #<class ‘NoneType‘>, <class ‘__main__.Dog‘>

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__)#<class ‘__main__.School‘>   表示当前操作的对象的类是什么
#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))#>>>>>>><class ‘__main__.School‘>
print(type(School))#>>>>>>>>>>>>>>>>>><class ‘type‘>

#那么,创建类就可以有两种方式:

#普通
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 进行【打开】【读写】【关闭】

#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()
时间: 2024-11-07 11:27:29

PYTHON学习笔记-DAY-7的相关文章

OpenCV之Python学习笔记

OpenCV之Python学习笔记 直都在用Python+OpenCV做一些算法的原型.本来想留下发布一些文章的,可是整理一下就有点无奈了,都是写零散不成系统的小片段.现在看 到一本国外的新书<OpenCV Computer Vision with Python>,于是就看一遍,顺便把自己掌握的东西整合一下,写成学习笔记了.更需要的朋友参考. 阅读须知: 本文不是纯粹的译文,只是比较贴近原文的笔记:         请设法购买到出版社出版的书,支持正版. 从书名就能看出来本书是介绍在Pytho

python学习笔记12-模块使用

python学习笔记12-模块使用 模块os,sys 什么是模块? 模块os,sys 模块是Python组织代码的一种基本方式 一个Python脚本可以单独运行,也可以导入到另外一个脚本运行,用import hello语句来导入,不用加入.py 什么是Python的 包? Python的模块可以按照目录组织为包 创建一个包的步骤: 创建一个名字为包名的目录 在改目录下创建一个__init__.py文件 根据需要,在该目录下存放脚本文件或已编译的扩展及子包 import pack.m1,pack.

python学习笔记2—python文件类型、变量、数值、字符串、元组、列表、字典

python学习笔记2--python文件类型.变量.数值.字符串.元组.列表.字典 一.Python文件类型 1.源代码 python源代码文件以.py为扩展名,由pyton程序解释,不需要编译 [[email protected] day01]# vim 1.py #!/usr/bin/python        print 'hello world!' [[email protected] day01]# python 1.py hello world! 2.字节代码 Python源码文件

Python学习笔记--未经排版

Python 学习笔记 Python中如何做到Print() 不换行 答:Print("输出内容",end='不换行的分隔内容'),其中end=后面为2个单引号 注:在Python 2.x中,Print "输出内容", 即在输出内容后加一逗号 Python中 is 和 == 的区别 答:Python中的对象包含三要素:id.type.value 其中id用来唯一标识一个对象,type标识对象的类型,value是对象的值 is判断的是a对象是否就是b对象,是通过id来

Python学习笔记_Python对象

Python学习笔记_Python对象 Python对象 标准类型 其他内建类型 类型对象和type类型对象 Python的Null对象None 标准类型操作符 对象值的比较 对象身份比较 布尔类型 标准类型的内建函数 typeObj cmpobj1 obj2 strobj reprobj typeobj isinstanceobj 标准类型的分类 存储模型 更新模型 访问模型 不支持的类型 Python学习笔记_Python对象 首先来理解一个通俗的含义,什么是对象?其实对象无论在什么语言里面

OpenCV for Python 学习笔记 三

给源图像增加边界 cv2.copyMakeBorder(src,top, bottom, left, right ,borderType,value) src:源图像 top,bottem,left,right: 分别表示四个方向上边界的长度 borderType: 边界的类型 有以下几种: BORDER_REFLICATE # 直接用边界的颜色填充, aaaaaa | abcdefg | gggg BORDER_REFLECT # 倒映,abcdefg | gfedcbamn | nmabcd

python 学习笔记 14 -- 常用的时间模块之datetime

书接上文,前面我们讲到<常用的时间模块之time>,这次我们学习datetime -- 日期和时间值管理模块 使用apihelper 查看datetime 模块,我们可以看到简单的几项: date       ---  日期对象,结构为date(year, month, day) time       ---  时间值对象,结构为 time([hour[, minute[, second[, microsecond[, tzinfo]]]]]).时间对象所有的参数都是可选的.tzinfo 可以

python 学习笔记 6 -- 异常处理

当你的程序中出现某些 异常的 状况的时候,异常就发生了.例如,当你想要读某个文件的时候,而那个文件不存在.或者在程序运行的时候,你不小心把它删除了. 那么如果你是在IDE中运行,一个错误发生,异常会被打引出来,这便是未处理异常:当异常发生时,如果没有代码去关注和处理它,这些异常会传给置在Python中的缺省处理,他会输出一些调试信息并且终止运行.如果是在IDE中,这不是什么大事,但是如果是Python程序运行中的异常,它会导致整个程序终止,对于这些情况可以使用异常来处理. 1.try..exce

python 学习笔记 3 -- 数据结构篇上

数据结构是可以处理一些 数据 的 结构 .或者说,它们是用来存储一组相关数据的.在Python中有三种内建的数据结构--列表.元组和字典.本文主要对这三种数据类型以及相关的使用做介绍,以例子的形式演示更加容易理解! 1.列表(List) 列表是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目.在Python中,你在每个项目之间用逗号分割. 列表中的项目应该包括在**方括号**中,这样Python就知道你是在指明一个列表.一旦你创建了一个列表,你可以添加.删除或是搜索列表中的

python 学习笔记 3 -- 数据结构篇下

5.引用 当你创建一个对象并给它赋一个变量的时候,这个变量仅仅 引用 那个对象,而不是表示这个对象本身!也就是说,变量名指向你计算机中存储那个对象的内存.这被称作名称到对象的绑定.eg. [python] view plaincopy # -*- coding: utf-8 -*- shoplist = ['apple', 'mango', 'carrot', 'banana'] print "we copy the shoplist to mylist directly \"with