python_基础2

继承覆盖:如果子类有和父类同名的方法,父类方法将被覆盖
如果需要访问父类的方法,则要调用一个为绑定类方法,明确给出子类的实例


class Manufacture:
    def __init__(self,phone,email):
        self.phone = phone
        self.email = email
class BearToy:
    def __init__(self,size,color,phone,email):
        self.size = size
        self.color = color
        self.vendor = Manufacture(phone,email)
class NewBearToy(BearToy):
    def __init__(self,size,color,phone,email,date):
        #构造父类
        super(NewBearToy,self).__init__(size,color,phone,email)
        self.date = date

类方法:
使用classmethod 装饰器 第一个参数cls表示自己

class Date:
    def __init__(self,year,month,date):
        self.year = year
        self.month = month
        self.date = date

    @classmethod
    def create_date(cls,string_date):
        #  把字符串拆分
        year, month,date = map(int,string_date.split('-'))
        instance = cls(year,month,date)
        return instance
if __name__ =='__main__':
    d1 = Date(2019,1,1,)
    print(d1)
    d2 = Date.create_date('2018-05-04')
    print(d2.date)


静态方法: 一个函数,一个方法,没有访问对象和他的字段或方法,使用staticmethod装饰器定义

class Date:
    def __init__(self,year,month,date):
        self.month = month
        self.year = year
        self.date = date
    #打印实例调用方法
    def __str__(self):
        return '<Date:%s-%s-%s>'%(self.year,self.month,self.date)
    #静态方法  类访问
    @staticmethod
    def is_date_valid(string_date):
        year,month,date = map(int,string_date.split('-'))
        return 1 <= date<=31 and 1<=month<=12 and year<3999
    def __call__(self):
        print("Date:%s-%s-%s"%(self.year,self.month,self.date))

if __name__ == '__main__':
    print(Date.is_date_valid('2018-00-04'))
    dd = Date(2018,3,2)
    #print(dd.__str__())
    print(type(dd))
    print(dd)


re模块
.          匹配任意字符(换行除外)
[...x-y...]匹配字符数组的任意字符
[^...x-y...] 匹配不在字符数组里的任意字符
\d           匹配任意数字
\w           匹配任意数字字母字符
\s            匹配空白字符
literal      匹配字符串的值
re1|re2      匹配表达式re1或re2
*            匹配前面出现表达式的0次或多次
+            匹配前面出现表达式一次或多次
?            同*
{M,N}         匹配前面出现的正则表达式至少m次至多n次

^              匹配字符串的开始
$              匹配字符串的结束
\b             匹配字符的边界
()             对正则表达式分组
\nn            匹配已保存的子组

import re
data = 'my phone number is : 1508888899999'
# .任意字符换行除外  +至少出现一次  () 对正则式分组  任意数字
#  m 是 <class '_sre.SRE_Match>
m=re.search('.+?([a-z]\s)',data)
#groups 获得字串
m.groups()
print(m.groups())
#从开头匹配
m=re.match('M',data)

#可以匹配中间
m=re.search('ph',data)
m.group()#type  str

#返回list
m=re.findall("m",data)
print(m)
#返回迭代器
m=re.finditer('m',data)
for item in m:
    print(item.group())
#返回一个正则表达式对象
patt = re.compile('m')
print(type(patt))
m = patt.match(data)
#\转移字符
mylist = re.split('\.|-','hello-world.data')
print(mylist)

#把匹配到的地方换成新的字符
m= re.sub("X",'Mr.Smith','attn:X\nDear X')
print(m)

创建tcp服务器

import threading
import time
import socket
#家族名     类型
def tcplink(sock,addr):
    print('Accept new connention from %s:%s...'%addr)
    sock.send('Wolcome!'.encode("utf-8"))
    while True:
        data = sock.recv(1024)
        time.sleep(8)
        if data.decode('utf-8') == 'exit' or not data:
            break
        print(type(data))
        sock.send("hello".encode("utf-8"))

    s.close()
    print("connection from %s:%s closed"%addr)
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 参数 tuple
s.bind(('127.0.0.1',8899))
s.listen(5)
print('waiting for connection...')
while True:
    sock,addr = s.accept()
    t = threading.Thread(target=tcplink(sock,addr))
tcp client:
cs = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
cs.connect(('127.0.0.1',8899))
cs.send()/cs.recv()
cs.close


UDP服务器
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind()
s.recvfrom()/ss.sendto()
s.close()
UDP客户端
cs.socket.socket()
cs.sendto()/cs.recvfrom()