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；

(<class '__main__.A'>,)
(<class '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__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,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()