python 面向对象编程tcp_python面向对象、类、socket网络编程

类和对象

python3统一了类与类型的概念；类==类型；从一组对象中提取相似的部分就是类；特征与技能的结合体就叫做对象；

类的功能：

初始实例化；

属性引用；

1、数据属性；

2、函数属性；

对于一个实例来说，只一种功能：属性引用；

示例：

class Garen:

camp = 'Demacia'

def __init__(self,nickname,aggresivity,life_value):

self.nickname = nickname #gl.nickname=nickname

self.aggrv=aggresivity

self.life_value=life_value

def attack(self,enemy): #定义技能,就是一个函数；

print('is attacking',self,enemy)

gl=Garen('草丛伦'，82，100) #Garen.__init__(gl,'草丛伦',82,100)

print(Garen.camp) #调用属性；

print(Garen.__init__) #返回函数

print(Garen.attack) #返回函数

#对于一个实例来说，只一种功能：属性引用；对于实例本身来说只拥有数据属性；

print(gl.nickname)

print(gl.aggrv)

print(gl.life_value)

print(gl.camp)

print(gl.attack) #返回绑定方法；

print(Garen.attack) #通过类来调用自己的函数属性； 返回函数

Garen.attack(1,2)

gl.attack('a') #Garen.attack(gl.'a')

类就是函数与数据的结合体；

对象的交互：

class Garen:

camp = 'Demacia'

def __init__(self,nickname,aggresivity,life_value):

self.nickname = nickname #gl.nickname=nickname

self.aggrv=aggresivity

self.life_value=life_value

def attack(self,enemy): #定义技能,就是一个函数；

print('is attacking',self,enemy)

class Riven:

camp="Noxus"

def __init__(self,nickname,aggresivity,life_value):

self.nickname = nickname #gl.nickname=nickname

self.aggrv=aggresivity

self.life_value=life_value

def attack(self,enemy): #定义技能,就是一个函数；

print('is attacking',self,enemy)

enemy.life_value=self.aggrv # g1.life_value-=r1.aggrv

g1 = Garen('草丛伦'，82，100)

r1 = Riven('锐',50,200)

r1.attack(g1)

类：

class Chinese:

dang='gongchandang' #共同特点

def __init__(self,name,age,gender): #私有特点

self.name=name

self.age=age

self.gender=gender

def talk(self): #共有的功能

print('=====>')

p1 = Chinese('egon',18,'female') #创建实例；现实中先有具体的实例，再定义类；

p1. #p1.表示在调用实例自己；在调用p1的属性；

print(p1.x) #先在p1自己里面找；def__init__，如果没有则再找类，类没有就报错；

例：print(p1.dang)

继承：

单继承

多继承

查看继承：

SubClass1.__bases__

示例：

class A:

pass

class B(A):

pass

print(B.__bases__)

print(A.__bases__) #默认继承object；

(,)

(,)

A没有object就叫做新式类；pytho3中所有类都叫做新式类；python2中叫经典类；

示例：

class Animal:

start='earth'

def __init__(self,name,age,gender):

self.name=name

self.age=age

self.gender=gender

def run(self):

print('running')

def talk(self):

print('talking')

class People(Animal):

def piao(self): #设计独特的技能

preint('is piaoing')

class Pig(Animal):

pass

p1=People('alex',1000,'female')

#pig1=Pig()

print(p1.start)

print(p1.running)

print(p1.name)

继承与重用性；

继承用来解决代码的重用性；父类不能调用子类的功能；

继承顺序

深度优先

从左到右 python2

广度优先

python3

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如

>>> F.mro() #等同于F.__mro__

[, , , , , , ]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。

而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1.子类会先于父类被检查

2.多个父类会根据它们在列表中的顺序被检查

3.如果对下一个类存在两个合法的选择,选择第一个父类

示例：

class Hero:

def __init__(self,nickname,aggresivity,life_value):

self.nickname = nickname #gl.nickname=nickname

self.aggrv=aggresivity

self.life_value=life_value

def attack(self,enemy): #定义技能,就是一个函数；

print('is attacking',self,enemy)

enemy.life_value=self.aggrv # g1.life_value-=r1.aggrv

class Garen(Hero):

camp = 'Demacia'

def fly(self):

print('is flying')

def attack(self):

print('attacking')

class Riven(Hero):

camp="Noxus"

g1 = Garen('草丛伦'，30，10)

g1.fly()

r1=Riven('xxx',230,30)

r1.attack()

组合与重用性；

组合：

一个对象的数据属性是另外一个对象；

继承表达‘是’的关系，组合表达‘有’的关系；

示例：

class Teacher:

def __init__(self.name):

self.name=name

self.birth=Date(1999,1,25) #实例属性来自于另外一个类；

self.course=Course('python',11000,'4months')

class Course:

def __init__(self,name,price,period):

self.name=name

self.price=price

self.period=period

class Date:

def __init__(self,year,month,day):

self.year=year

self.month=month

self.day=day

t1 = Teacher('egon')

print(t.birth.year)

接口与归一化设计：

接口：

就是一堆函数的结合体；只定义一堆技能；

归一化示例：

class ALLFile: #接口类 接口功能只定义名称，而不去实现功能，具体实现在子类中；

def read(self): #接口函数

pass

def write(self):

pass

class Text(ALLFile):

def read(self):

print('text read')

def write(self):

print('text write')

class Sata(ALLFile):

def read(self):

print('sata read')

def write(self):

print('sata write')

t=Text()

s=Sata()

t.read()

t.write()

s.read()

s.write()

抽象类：

import abc #来实现抽象类；

class ALLFile(metaclass=abc.ABCMeta): #抽象类 只是用来被别人继承，不能被调用；

def test(self):

print('testing')

@abc.abstractmethod

def read(self): #接口函数

pass

@abc.abstractmethod #表示让子类必须实现；子类不指明会报错；

def write(self):

pass

class Text(ALLFile):

def read(self):

print('text read')

def write(self):

print('text write')

t=Text()

多态与多态性：

多态：

是一类事物的多种状态；同一种事物的不同形态，如序列类型包含字符串，列表，元组；

多态性：

优点：

程序的灵活性；

程序的扩展性；

示例：

def func(obj):

print(obj.__len__())

func(s)

func(l)

func(t)

示例：

class Animal:

def talk(self):

print('talking')

class Dog(Animal):

def talk(self): #设计独特的技能

preint('say wqangwang')

class Pig(Animal):

print('say aoao')

class Cat(Animal):

def talk(self):

print('cat talking')

p1 = People()

pig1=Pig()

D1=Dog()

c=Cat()

以上为多态,程序的实现者

def func(obj):

obj.talk()

func(p1)

func(pig1)

func(D1)

func(c)

以上为多态性；程序的使用者，不能改变代码；

封装：

数据的封装；

保护隐私；

方法的封装；

主要隔离复杂度；

封装两个层面；

示例：

class Foo:

x=1

def __init__(self,name,money):

self.name=name

self.__money=money #相当于_Foo__money

def get_money(self):

print(self.__money)

self.__spam()

def __spam(self): #_Foo__spam 变形在定义时只会执行一次；后来赋值不会变形；

print('from spam')

f=Foo('alex',20000)

f.get_money

print(f.__dict__)

print(Foo.__dict__)

对于第一层面的封装(隐藏)，类名.和实例名.就是访问隐藏属性的接口(或者叫入口)

对于第二层面的封装(隐藏)，

示例：

class A:

def spam(self):

print("A.spam")

def test(self):

print('A.test')

self.spam()

class B(A):

pass

b1=B()

b1.test()

二、

class A:

def __spam(self): #_A__spam

print("A.spam")

def test(self):

print('A.test')

self.__spam() #self._A_spam

class B(A):

def __spam(self): #_B_spam

print('B.spam')

b1=B()

b1.test()

特性：

用来提供接口的一种方式；

示例：

class A:

def __init__(self.name):

self.__name=name

@property #相当于C++中get

def name(self):

return self.__name

@name.setter #相当于C++中set

def name(self,value):

if not isinstance(value,str):

raise TypeError('%s must be str'%value)

print('++++++?')

self.__name=value

@name.deleter

def name(self):

print('======>')

raise AttributeError('can not delete')

a=A('egon')

print(a.name)

a.name=2

print(a.name)

del a.name

子类调用父类的方法：

当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次(注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表)

示例：

class People:

def __init__(self,name,age,gender):

self.name=name

self.age=age

self.gender=gender

def test(self):

print('from A.test')

class Teacher(People):

def __init__(self,name,age,gender,level):

People.__init__(self,name,age,gender)

self.level=level

t=Teacher('egon',18,'female','teach')

print(t.level)

二、super()

class People:

def __init__(self,name,age,gender):

self.name=name

self.age=age

self.gender=gender

def test(self):

print('from A.test')

class Teacher(People):

def __init__(self,name,age,gender,level):

#People.__init__(self,name,age,gender)

super.__init__(name,age,gender)

self.level=level

t=Teacher('egon',18,'female','teach')

print(t.level)

具体的编程方法先出现；

面向对象的软件开发：

1、面向对象分析；

2、面向对象设计；

3、面向对象编程；

4、面向对象测试；

5、面向对象维护；

示例：

class Foo:

def __init__(self,name):

self.name=name

def __call__(self,*args,**kwargs):

print('========>')

f=Foo('egon')

f()

反射：

示例：

class Foo:

def __init__(self,name):

self.nae=name

def func(self):

print('func')

print(hasattr(Foo,'func'))

f=Foo('egon')

print(hasattr(f,'x'))

f.x=1

print(getattr(f,'x'))

print(getattr(Foo,'func'))

if hasattr(f,'func')

aa=getattr(f,'func')

aa()

print(getattr(f,'y',None))

#f.y=1 #f y 1

setattr(f,'y') #设定值；

print(f.__dict__)

delattr(f,'y')

print(f.__dict__)

socker

用于C/S架构；

用户态

内核态

套接字发展史及分类；

基于文件类型的套接字家族

示例：

服务端：

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机

phone.bind(('127.0.0.1',8080)) #插入卡

phone.listen(5) #开机

conn, addr=phone.accept() #接电话 建立连接，客户端地址；

print('tcp的连接',conn)

print('客户端的地址',addr)

data = conn.recv(1024) #接收1024个字节； 收消息

print('from client msg :%s' %data)

conn.send(data.upper()) #发消息；

conn.close() #挂电话

phone.close() #关手机

客户端：

import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(('127.0.0.1',8080)) #拨通电话；

client.send('hello'.encode('utf-8'))

data=client.recv(1024)

print(data)

client.close()