第8章 面向对象高级编程与网络编程

Posted 2020-10-04

面向对象的特征

一、多态

程序在运行的过程中，根据传递的参数的不同，执行不同的函数或者操作不同的代码，这种在运行过程中才确定调用的方式成为运行时多态

import abc

#多态：同一种事物的多种形态

class Animal: #同一类事物:动物

    def talk(self):

        pass

class People(Animal): #动物的形态之一:人

    def talk(self):

        print(‘say hello‘)

class Dog(Animal): #动物的形态之二:狗

    def talk(self):

        print(‘say wangwang‘)

class Pig(Animal): #动物的形态之三:猪

    def talk(self):

        print(‘say aoao‘)

class Cat(Animal):

    def talk(self):

        print(‘say miaomiao‘)

class Bird:

    def talk(self):

        print(‘jijiji‘)

#多态性：可以在不考虑实例类型的前提下使用实例

p1=People()

d=Dog()

p2=Pig()

c=Cat()

b=Bird()

# p1.talk()

# d.talk()

# p2.talk()

# c.talk()

# b.talk()

def Talk(animal):

    animal.talk() #p1.talk()

Talk(p1)

Talk(d)

Talk(p2)

Talk(c)

Talk(b)

二、封装

#先看如何隐藏

class Foo:

    __N=111111 #_Foo__N

    def __init__(self,name):

        self.__Name=name #self._Foo__Name=name

    def __f1(self): #_Foo__f1

        print(‘f1‘)

    def f2(self):

        self.__f1() #self._Foo__f1()

f=Foo(‘egon‘)

# print(f.__N)

# f.__f1()

# f.__Name

# f.f2()

#这种隐藏需要注意的问题：

#1：这种隐藏只是一种语法上变形操作，并不会将属性真正隐藏起来

# print(Foo.__dict__)

# print(f.__dict__)

# print(f._Foo__Name)

# print(f._Foo__N)

#2:这种语法级别的变形，是在类定义阶段发生的，并且只在类定义阶段发生

# Foo.__x=123123123123123123123123123123123123123123

# print(Foo.__dict__)

# print(Foo.__x)

# f.__x=123123123

# print(f.__dict__)

# print(f.__x)

#3:在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

class Foo:

    def __f1(self): #_Foo__f1

        print(‘Foo.f1‘)

    def f2(self):

        self.__f1() #self._Foo_f1

class Bar(Foo):

    def __f1(self): #_Bar__f1

        print(‘Bar.f1‘)

# b=Bar()

# b.f2()

#封装不是单纯意义的隐藏

#1：封装数据属性：将属性隐藏起来，然后对外提供访问属性的接口，关键是我们在接口内定制一些控制逻辑从而严格控制使用对数据属性的使用

class People:

    def __init__(self,name,age):

        if not isinstance(name,str):

            raise TypeError(‘%s must be str‘ %name)

        if not isinstance(age,int):

            raise TypeError(‘%s must be int‘ %age)

        self.__Name=name

        self.__Age=age

    def tell_info(self):

        print(‘<名字：%s 年龄：%s>‘ %(self.__Name,self.__Age))

    def set_info(self,x,y):

        if not isinstance(x,str):

            raise TypeError(‘%s must be str‘ %x)

        if not isinstance(y,int):

            raise TypeError(‘%s must be int‘ %y)

        self.__Name=x

        self.__Age=y

# p=People(‘egon‘,18)

# p.tell_info()

#

# # p.set_info(‘Egon‘,‘19‘)

# p.set_info(‘Egon‘,19)

# p.tell_info()

#2：封装函数属性：为了隔离复杂度

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱

#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做

#隔离了复杂度,同时也提升了安全性

class ATM:

    def __card(self):

        print(‘插卡‘)

    def __auth(self):

        print(‘用户认证‘)

    def __input(self):

        print(‘输入取款金额‘)

    def __print_bill(self):

        print(‘打印账单‘)

    def __take_money(self):

        print(‘取款‘)

    def withdraw(self):

        self.__card()

        self.__auth()

        self.__input()

        self.__print_bill()

        self.__take_money()

a=ATM()

a.withdraw()

三、静态属性property

# class Foo:

#     @property

#     def f1(self):

#          print(‘f1‘)

#

#

# f=Foo()

#

# # f.f1()

#

# f.f1

‘‘‘

例：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：

过轻：低于18.5

正常：18.5-23.9

过重：24-27

肥胖：28-32

非常肥胖, 高于32

　　体质指数（BMI）=体重（kg）÷身高^2（m）

　　EX：70kg÷（1.75×1.75）=22.86

‘‘‘

class People:

    def __init__(self,name,weight,height):

        self.name=name

        self.weight=weight

        self.height=height

    @property

    def bmi(self):

        return self.weight / (self.height**2)

# p=People(‘egon‘,75,1.80)

# p.height=1.86

# print(p.bmi())

# print(p.bmi)

#访问，设置，删除(了解)

class Foo:

    def __init__(self,x):

        self.__Name=x

    @property

    def name(self):

        return self.__Name

    @name.setter

    def name(self,val):

        if not isinstance(val,str):

            raise TypeError

        self.__Name=val

    @name.deleter

    def name(self):

        # print(‘=-====>‘)

        # del self.__Name

        raise PermissionError

f=Foo(‘egon‘)

# print(f.name)

#

# # f.name=‘Egon‘

# f.name=123123123213

# print(f.name)

del f.name

print(f.name)

打印对象信息__str__

class People:

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

        self.name=name

        self.age=age

        self.sex=sex

    def __str__(self): #在对象被打印时触发执行

        return ‘<name:%s age:%s sex:%s>‘ %(self.name,self.age,self.sex)

p1=People(‘egon‘,18,‘male‘)

p2=People(‘alex‘,38,‘male‘)

print(p1)

print(p2)

# l=list([1,2,3])

# print(l)

析构方法

class Foo:

    def __init__(self,x):

        self.x=x

    def __del__(self): #在对象资源被释放时触发

        print(‘-----del------‘)

        print(self)

f=Foo(100000)

del f

print(‘=======================>‘)

错误处理

常见的错误类型：

1 NameError

# aaaaa

2 ValueError

# int(‘asdfsadf‘)

3 IndexError

# l=[1,2]

# l[1000]

4 KeyError

# d={‘a‘:1}

# d[‘b‘]

5 AttributeError

# class Foo:pass

#

# Foo.x

例：

# try:

#     f=open(‘a.txt‘)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

# except StopIteration as e:

#     pass

#

#

# print(‘====>‘)

针对错误常见的处理方法

1.

# try:

#     # aaaa

#     print(‘==-==>1‘)

#     l=[]

#     l[3]

#     print(‘==-==>2‘)

#     d={}

#     d[‘x‘]

#     print(‘==-==>3‘)

# except NameError as e:

#     print(e)

# except IndexError as e:

#     print(e)

# except KeyError as e:

#     print(e)

2

# try:

#     # aaaa

#     print(‘==-==>1‘)

#     l=[]

#     l[3]

#     print(‘==-==>2‘)

#     d={}

#     d[‘x‘]

#     print(‘==-==>3‘)

# except Exception as e:

#     print(e)

# try:

#     aaaa

#     print(‘==-==>1‘)

#     # l=[]

#     # l[3]

#     # print(‘==-==>2‘)

#     # d={}

#     # d[‘x‘]

#     # print(‘==-==>3‘)

# except NameError as e:

#     print(e)

# except IndexError as e:

#     print(e)

# except KeyError as e:

#     print(e)

# except Exception as e:

#     print(e)

# else:

#     print(‘在没有错误的时候执行‘)

# finally:

#     print(‘无论有无错误，都会执行‘)

自定义错误类型

# raise TypeError(‘----‘)

# class EgonException(BaseException):

#     def __init__(self,msg):

#         self.msg=msg

#     def __str__(self):

#         return ‘<%s>‘ %self.msg

#

# raise EgonException(‘egon 的异常‘)

# l=[1,2,3]

# assert len(l) > 3

#什么时候用try ...except

#错误一定会发生，但是无法预知错误发生条件

四、网络编程

Python 提供了两个级别访问的网络服务。：

低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。

高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

什么是 Socket?

Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。

socket()函数

Python 中，我们用 socket（）函数来创建套接字，语法格式如下：

socket.socket([family[, type[, proto]]])

参数

family: 套接字家族可以使AF_UNIX或者AF_INET

type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM

protocol: 一般不填默认为0.

Socket 对象(内建)方法

函数 描述

服务器端套接字

s.bind() 绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。

s.listen() 开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。

s.accept() 被动接受TCP客户端连接,(阻塞式)等待连接的到来

客户端套接字

s.connect() 主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。

s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数

s.recv() 接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。

s.send() 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。

s.sendall() 完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

s.recvfrom() 接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

s.sendto() 发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。

s.close() 关闭套接字

s.getpeername() 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

s.getsockname() 返回套接字自己的地址。通常是一个元组(ipaddr,port)

s.setsockopt(level,optname,value) 设置给定套接字选项的值。

s.getsockopt(level,optname[.buflen]) 返回套接字选项的值。

s.settimeout(timeout) 设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）

s.gettimeout() 返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。

s.fileno() 返回套接字的文件描述符。

s.setblocking(flag) 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。

s.makefile() 创建一个与该套接字相关连的文件

简单实例

服务端

我们使用 socket 模块的 socket 函数来创建一个 socket 对象。socket 对象可以通过调用其他函数来设置一个 socket 服务。

现在我们可以通过调用 bind(hostname, port) 函数来指定服务的 port(端口)。

接着，我们调用 socket 对象的 accept 方法。该方法等待客户端的连接，并返回 connection 对象，表示已连接到客户端。

完整代码如下：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 文件名：server.py

import socket               # 导入 socket 模块

s = socket.socket()         # 创建 socket 对象

host = socket.gethostname() # 获取本地主机名

port = 12345                # 设置端口

s.bind((host, port))        # 绑定端口

s.listen(5)                 # 等待客户端连接

while True:

    c, addr = s.accept()     # 建立客户端连接。

    print ‘连接地址：‘, addr

    c.send(‘hello world！‘)

    c.close()                # 关闭连接

客户端

接下来我们写一个简单的客户端实例连接到以上创建的服务。端口号为 12345。

socket.connect(hosname, port ) 方法打开一个 TCP 连接到主机为 hostname 端口为 port 的服务商。连接后我们就可以从服务端后期数据，记住，操作完成后需要关闭连接。

完整代码如下：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 文件名：client.py

import socket               # 导入 socket 模块

s = socket.socket()         # 创建 socket 对象

host = socket.gethostname() # 获取本地主机名

port = 12345                # 设置端口好

s.connect((host, port))

print s.recv(1024)

s.close()  

现在我们打开两个终端，第一个终端执行 server.py 文件：

$ python server.py

第二个终端执行 client.py 文件：

$ python client.py 

hello world！

这是我们再打开第一个终端，就会看到有以下信息输出：

连接地址： (‘192.168.0.118‘, 62461)面向对象的特征

一、多态

程序在运行的过程中，根据传递的参数的不同，执行不同的函数或者操作不同的代码，这种在运行过程中才确定调用的方式成为运行时多态

import abc

#多态：同一种事物的多种形态

class Animal: #同一类事物:动物

    def talk(self):

        pass

class People(Animal): #动物的形态之一:人

    def talk(self):

        print(‘say hello‘)

class Dog(Animal): #动物的形态之二:狗

    def talk(self):

        print(‘say wangwang‘)

class Pig(Animal): #动物的形态之三:猪

    def talk(self):

        print(‘say aoao‘)

class Cat(Animal):

    def talk(self):

        print(‘say miaomiao‘)

class Bird:

    def talk(self):

        print(‘jijiji‘)

#多态性：可以在不考虑实例类型的前提下使用实例

p1=People()

d=Dog()

p2=Pig()

c=Cat()

b=Bird()

# p1.talk()

# d.talk()

# p2.talk()

# c.talk()

# b.talk()

def Talk(animal):

    animal.talk() #p1.talk()

Talk(p1)

Talk(d)

Talk(p2)

Talk(c)

Talk(b)

二、封装

#先看如何隐藏

class Foo:

    __N=111111 #_Foo__N

    def __init__(self,name):

        self.__Name=name #self._Foo__Name=name

    def __f1(self): #_Foo__f1

        print(‘f1‘)

    def f2(self):

        self.__f1() #self._Foo__f1()

f=Foo(‘egon‘)

# print(f.__N)

# f.__f1()

# f.__Name

# f.f2()

#这种隐藏需要注意的问题：

#1：这种隐藏只是一种语法上变形操作，并不会将属性真正隐藏起来

# print(Foo.__dict__)

# print(f.__dict__)

# print(f._Foo__Name)

# print(f._Foo__N)

#2:这种语法级别的变形，是在类定义阶段发生的，并且只在类定义阶段发生

# Foo.__x=123123123123123123123123123123123123123123

# print(Foo.__dict__)

# print(Foo.__x)

# f.__x=123123123

# print(f.__dict__)

# print(f.__x)

#3:在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

class Foo:

    def __f1(self): #_Foo__f1

        print(‘Foo.f1‘)

    def f2(self):

        self.__f1() #self._Foo_f1

class Bar(Foo):

    def __f1(self): #_Bar__f1

        print(‘Bar.f1‘)

# b=Bar()

# b.f2()

#封装不是单纯意义的隐藏

#1：封装数据属性：将属性隐藏起来，然后对外提供访问属性的接口，关键是我们在接口内定制一些控制逻辑从而严格控制使用对数据属性的使用

class People:

    def __init__(self,name,age):

        if not isinstance(name,str):

            raise TypeError(‘%s must be str‘ %name)

        if not isinstance(age,int):

            raise TypeError(‘%s must be int‘ %age)

        self.__Name=name

        self.__Age=age

    def tell_info(self):

        print(‘<名字：%s 年龄：%s>‘ %(self.__Name,self.__Age))

    def set_info(self,x,y):

        if not isinstance(x,str):

            raise TypeError(‘%s must be str‘ %x)

        if not isinstance(y,int):

            raise TypeError(‘%s must be int‘ %y)

        self.__Name=x

        self.__Age=y

# p=People(‘egon‘,18)

# p.tell_info()

#

# # p.set_info(‘Egon‘,‘19‘)

# p.set_info(‘Egon‘,19)

# p.tell_info()

#2：封装函数属性：为了隔离复杂度

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱

#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做

#隔离了复杂度,同时也提升了安全性

class ATM:

    def __card(self):

        print(‘插卡‘)

    def __auth(self):

        print(‘用户认证‘)

    def __input(self):

        print(‘输入取款金额‘)

    def __print_bill(self):

        print(‘打印账单‘)

    def __take_money(self):

        print(‘取款‘)

    def withdraw(self):

        self.__card()

        self.__auth()

        self.__input()

        self.__print_bill()

        self.__take_money()

a=ATM()

a.withdraw()

三、静态属性property

# class Foo:

#     @property

#     def f1(self):

#          print(‘f1‘)

#

#

# f=Foo()

#

# # f.f1()

#

# f.f1

‘‘‘

例：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：

过轻：低于18.5

正常：18.5-23.9

过重：24-27

肥胖：28-32

非常肥胖, 高于32

　　体质指数（BMI）=体重（kg）÷身高^2（m）

　　EX：70kg÷（1.75×1.75）=22.86

‘‘‘

class People:

    def __init__(self,name,weight,height):

        self.name=name

        self.weight=weight

        self.height=height

    @property

    def bmi(self):

        return self.weight / (self.height**2)

# p=People(‘egon‘,75,1.80)

# p.height=1.86

# print(p.bmi())

# print(p.bmi)

#访问，设置，删除(了解)

class Foo:

    def __init__(self,x):

        self.__Name=x

    @property

    def name(self):

        return self.__Name

    @name.setter

    def name(self,val):

        if not isinstance(val,str):

            raise TypeError

        self.__Name=val

    @name.deleter

    def name(self):

        # print(‘=-====>‘)

        # del self.__Name

        raise PermissionError

f=Foo(‘egon‘)

# print(f.name)

#

# # f.name=‘Egon‘

# f.name=123123123213

# print(f.name)

del f.name

print(f.name)

打印对象信息__str__

class People:

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

        self.name=name

        self.age=age

        self.sex=sex

    def __str__(self): #在对象被打印时触发执行

        return ‘<name:%s age:%s sex:%s>‘ %(self.name,self.age,self.sex)

p1=People(‘egon‘,18,‘male‘)

p2=People(‘alex‘,38,‘male‘)

print(p1)

print(p2)

# l=list([1,2,3])

# print(l)

析构方法

class Foo:

    def __init__(self,x):

        self.x=x

    def __del__(self): #在对象资源被释放时触发

        print(‘-----del------‘)

        print(self)

f=Foo(100000)

del f

print(‘=======================>‘)

错误处理

常见的错误类型：

1 NameError

# aaaaa

2 ValueError

# int(‘asdfsadf‘)

3 IndexError

# l=[1,2]

# l[1000]

4 KeyError

# d={‘a‘:1}

# d[‘b‘]

5 AttributeError

# class Foo:pass

#

# Foo.x

例：

# try:

#     f=open(‘a.txt‘)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

#     next(f)

# except StopIteration as e:

#     pass

#

#

# print(‘====>‘)

针对错误常见的处理方法

1.

# try:

#     # aaaa

#     print(‘==-==>1‘)

#     l=[]

#     l[3]

#     print(‘==-==>2‘)

#     d={}

#     d[‘x‘]

#     print(‘==-==>3‘)

# except NameError as e:

#     print(e)

# except IndexError as e:

#     print(e)

# except KeyError as e:

#     print(e)

2

# try:

#     # aaaa

#     print(‘==-==>1‘)

#     l=[]

#     l[3]

#     print(‘==-==>2‘)

#     d={}

#     d[‘x‘]

#     print(‘==-==>3‘)

# except Exception as e:

#     print(e)

# try:

#     aaaa

#     print(‘==-==>1‘)

#     # l=[]

#     # l[3]

#     # print(‘==-==>2‘)

#     # d={}

#     # d[‘x‘]

#     # print(‘==-==>3‘)

# except NameError as e:

#     print(e)

# except IndexError as e:

#     print(e)

# except KeyError as e:

#     print(e)

# except Exception as e:

#     print(e)

# else:

#     print(‘在没有错误的时候执行‘)

# finally:

#     print(‘无论有无错误，都会执行‘)

自定义错误类型

# raise TypeError(‘----‘)

# class EgonException(BaseException):

#     def __init__(self,msg):

#         self.msg=msg

#     def __str__(self):

#         return ‘<%s>‘ %self.msg

#

# raise EgonException(‘egon 的异常‘)

# l=[1,2,3]

# assert len(l) > 3

#什么时候用try ...except

#错误一定会发生，但是无法预知错误发生条件

四、网络编程

Python 提供了两个级别访问的网络服务。：

低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。

高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

什么是 Socket?

Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。

socket()函数

Python 中，我们用 socket（）函数来创建套接字，语法格式如下：

socket.socket([family[, type[, proto]]])

参数

family: 套接字家族可以使AF_UNIX或者AF_INET

type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM

protocol: 一般不填默认为0.

Socket 对象(内建)方法

函数 描述

服务器端套接字

s.bind() 绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。

s.listen() 开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。

s.accept() 被动接受TCP客户端连接,(阻塞式)等待连接的到来

客户端套接字

s.connect() 主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。

s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数

s.recv() 接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。

s.send() 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。

s.sendall() 完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

s.recvfrom() 接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

s.sendto() 发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。

s.close() 关闭套接字

s.getpeername() 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

s.getsockname() 返回套接字自己的地址。通常是一个元组(ipaddr,port)

s.setsockopt(level,optname,value) 设置给定套接字选项的值。

s.getsockopt(level,optname[.buflen]) 返回套接字选项的值。

s.settimeout(timeout) 设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）

s.gettimeout() 返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。

s.fileno() 返回套接字的文件描述符。

s.setblocking(flag) 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。

s.makefile() 创建一个与该套接字相关连的文件

简单实例

服务端

我们使用 socket 模块的 socket 函数来创建一个 socket 对象。socket 对象可以通过调用其他函数来设置一个 socket 服务。

现在我们可以通过调用 bind(hostname, port) 函数来指定服务的 port(端口)。

接着，我们调用 socket 对象的 accept 方法。该方法等待客户端的连接，并返回 connection 对象，表示已连接到客户端。

完整代码如下：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 文件名：server.py

import socket               # 导入 socket 模块

s = socket.socket()         # 创建 socket 对象

host = socket.gethostname() # 获取本地主机名

port = 12345                # 设置端口

s.bind((host, port))        # 绑定端口

s.listen(5)                 # 等待客户端连接

while True:

    c, addr = s.accept()     # 建立客户端连接。

    print ‘连接地址：‘, addr

    c.send(‘hello world！‘)

    c.close()                # 关闭连接

客户端

接下来我们写一个简单的客户端实例连接到以上创建的服务。端口号为 12345。

socket.connect(hosname, port ) 方法打开一个 TCP 连接到主机为 hostname 端口为 port 的服务商。连接后我们就可以从服务端后期数据，记住，操作完成后需要关闭连接。

完整代码如下：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 文件名：client.py

import socket               # 导入 socket 模块

s = socket.socket()         # 创建 socket 对象

host = socket.gethostname() # 获取本地主机名

port = 12345                # 设置端口好

s.connect((host, port))

print s.recv(1024)

s.close()  

现在我们打开两个终端，第一个终端执行 server.py 文件：

$ python server.py

第二个终端执行 client.py 文件：

$ python client.py 

hello world！

这是我们再打开第一个终端，就会看到有以下信息输出：

连接地址： (‘192.168.0.118‘, 62461)