类和对象
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()

  

python面向对象、类、socket网络编程的更多相关文章

  1. Python之路【第七篇】python基础 之socket网络编程

    本篇文章大部分借鉴 http://www.cnblogs.com/nulige/p/6235531.html python socket  网络编程 一.服务端和客户端 BS架构 (腾讯通软件:ser ...

  2. Python基础-week07 Socket网络编程

    一 客户端/服务器架构 1.定义 又称为C/S架构,S 指的是Server(服务端软件),C指的是Client(客户端软件) 本章的中点就是教大写写一个c/s架构的软件,实现服务端软件和客户端软件基于 ...

  3. Python学习之==>Socket网络编程

    一.计算机网络 多台独立的计算机通过网络通信设备连接起来的网络.实现资源共享和数据传递.在同一台电脑上可以将D盘上的一个文件传到C盘,但如果想从一台电脑传一个文件到另外一台电脑上就要通过计算机网络 二 ...

  4. Python中的socket网络编程(TCP/IP,UDP)讲解

    在网络编程中的一个基本组件就是套接字(socket).套接字基本上是两个端点的程序之间的"信息通道".程序可能分布在不同的计算机上,通过套接字互相发送信息.套接字包括两个:服务器套 ...

  5. python基础(15)-socket网络编程&socketserver

    socket 参数及方法说明 初始化参数 sk = socket.socket(参数1,参数2,参数3) 参数1:地址簇 socket.AF_INET IPv4(默认) socket.AF_INET6 ...

  6. python进阶之Socket 网络编程

     一:网络编程介绍   自从互联网诞生以来,现在基本上所有的程序都是网络程序,很少有单机版的程序了. 计算机网络就是把各个计算机连接到一起,让网络中的计算机可以互相通信.网络编程就是如何在程序中实现两 ...

  7. Python Socket 网络编程

    Socket 是进程间通信的一种方式,它与其他进程间通信的一个主要不同是:它能实现不同主机间的进程间通信,我们网络上各种各样的服务大多都是基于 Socket 来完成通信的,例如我们每天浏览网页.QQ ...

  8. Python Socket 网络编程 (客户端的编程)

    Socket 是进程间通信的一种方式,它与其他进程间通信的一个主要不同是:它能实现不同主机间的进程间通信,我们网络上各种各样的服务大多都是基于 Socket 来完成通信的,例如我们每天浏览网页.QQ ...

  9. day7 socket网络编程

    Python Socket网络编程 Socket是进程间通信的一种方式,它与其他进程间通信的一个主要不同是:它能实现不同主机间的进程间通信,我们网络上各种各样的服务大多都是基于Socket来完成通信的 ...

  10. Python面向对象进阶和socket网络编程-day08

    写在前面 上课第八天,打卡: 为什么坚持?想一想当初: 一.面向对象进阶 - 1.反射补充 - 通过字符串去操作一个对象的属性,称之为反射: - 示例1: class Chinese: def __i ...

随机推荐

  1. c# Winform WebBrowser的自动化模拟点击

    https://blog.csdn.net/vs920079469vs/article/details/78459025

  2. 【CSS】我的样式哪里来的?—— css的继承性

    在之前我们写css的时候,曾经出现过如下这样一种情况: 6继承性.html(head部分) <style> div { background-color: #ccc; font-size: ...

  3. Zabbix官方部署搭建

    Zabbix在企业生产环境中是用的最广泛的服务器监控软件,其功能强大.配置简单.开源免费,是企业监控软件的首选. 一.Zabbix简介   zabbix是一个基于WEB界面的提供分布式系统监视以及网络 ...

  4. 深入理解C语言-二级指针三种内存模型

    二级指针相对于一级指针,显得更难,难在于指针和数组的混合,定义不同类型的二级指针,在使用的时候有着很大的区别 第一种内存模型char *arr[] 若有如下定义 char *arr[] = {&quo ...

  5. 《ThinkPHP 5.0快速入门》 基础和路由

    一.基础: 创建项目:conposer create-project topthink/think tp5 --prefer-dist 创建项目模块:php think build --module ...

  6. JAVA -----------交互式程序

    2.6交互式程序 如果程序能在执行期间交互地从用户输入中读取数据,就可使程序每执行一次时计算出新结果,并且新结果取决于输入数据.这样的程序才具有实用性. 2.6.1 Scanner类 Scanner类 ...

  7. AttributeError: module 'unittest' has no attribute 'TestCase'

    一个自己给自己挖的坑 大家千万不要用库的名称命名,特别是刚刚入门的时候.文件夹.文件,都不要用库的名称. 一旦与库重名,就会出现这种 AttributeError. 引以为戒,以后我再这么命名,我就是 ...

  8. mysql数据库之索引与慢查询优化

    索引与慢查询优化 知识回顾:数据都是存在硬盘上的,那查询数据不可避免的需要进行IO操作 索引在MySQL中也叫做“键”,是存储引擎用于快速找到记录的一种数据结构. primary key unique ...

  9. 第五周课程总结&实验报告(四)

    第五周课程总结 本周主要学习了 1.抽象类 抽象类的定义格式 abstract class抽象类名称{ 属性; 访问权限返回值类型方法名称(参数){ //普通方法 [return返回值]; } 访问权 ...

  10. Oracle数据库弱口令解密

    1.首先我们先看下Oracle加密的格式. 接下来我们把他头和尾部删除,中间加: 通过py脚本来进行完成 转换完成后输出成这种格式 之后直接丢进kali里面,用john --w=字典文件 + 转换文件 ...