Welcome to Xin YAO's blog

• socket编程

  2018-09-12

  Python

  socket

  socket又叫套接字，就是进行数据通信两端。分为服务器套接字和客户端套接字。 套接字编程：自己写服务器或者客户端，进行数据传输。

  python对socket编程的支持：提供一个socket库（内置）

  import socket
  

  一、服务器端（socket）

  1、创建套接字对象

  def creat_server():
      """
      socket(family,type)
      a.family：确定IP协议类型
      AF_INET:ipv4（默认）
      AF_INET6:ipv6
      b.type:传输协议类型
      SOCK_STREAM:TCP协议（默认）
      SOCK_DGRAM:UDP协议
      """
      server = socket.socket()
  

  2、绑定IP地址和端口

      """
      端口：一台电脑上一个端口标记一个唯一的服务。范围0~65535,0~1014是著名端口，专门标记一个特殊服务，一般不适用。
      注意：同一端口同一时间只能绑定一个服务。
      """
      server.bind(("10.7.153.113",8080))
  

  3、监听（客户端请求）

      """
      listen(个数)
      同一时间能够连接的客户端个数。
      """
      server.listen()
  

  4、让服务器处于运行状态

      while True:
          print('监听状态！')
          """
          连接客户端（建立连接）,返回连接对象和客户端地址。
          这句代码会阻塞线程，直到有客户端来请求当前服务器为止。
          """
          connect, addr = server.accept()
  
          print(addr)
  

  5、服务器给客户端发送消息

          """
          send(data)
          date：python3中要求类型是bytes，python2中可以是字符串。
          字符串 >>>> 二进制 ：
          1、字符串.encode（编码方式）默认utf-8
          2、bytes(字符串，编码方式)默认None
          """
          connect.send('你好！'.encode())
          connect.send(bytes('你好','utf-8'))
  

  6、接收从客户端发送过来的消息

          """
          recv(bufsize)
          bufsize:每次能够接收的最大字节数
          返回值：接收到的数据（二进制）
          二进制 >>> 字符串：
          1、二进制.decode()
          2、str(二进制，编码方式)
          注意：recv方法也会阻塞线程。
          """
          recv_data = connect.recv(1024)
          print(recv_data.decode())
          print(str(recv_data, 'utf-8'))
  

  7、断开连接

          connect.close()
  

  二、客户端（socket）

  1、创建套接字对象

  import socket
  def creat_client():
      client = socket.socket()
  

  2、连接服务器

      """
      connect(服务器地址,端口)
      """
      client.connect(('10.7.153.113', 8080))
  

  3、接收服务器发送的消息

      data = client.recv(1024)
      print(data.decode(encoding='utf-8'))
  

  4、给服务器发送消息

      client.send('我是客户端~~'.encode())
  

  5、断开连接

      client.close()
  

  实例一：通信

  # 服务器端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_server():
      """写一个服务器"""
      # 1、创建套接字对象
      server = socket.socket()
  
      # 2、绑定IP地址和端口
      server.bind(("10.7.153.113",8080))
  
      # 3、监听（客户端请求）
      server.listen(5)
      print('监听状态！')
      connect, addr = server.accept()
      
      # 4、让服务器处于运行状态
      while True:
          mesag = input('服务器：')
          connect.send(mesag.encode())
  
          #6、接收从客户端发送过来的消息
          recv_data = connect.recv(1024)
          print(recv_data.decode())
  
      #7、断开连接
      connect.close()
  
  creat_server()
  
  # 客户端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_client():
      # 1、创建套接字对象
      client = socket.socket()
  
      # 2、连接服务器
      """
      connect(服务器地址)
      """
      client.connect(('10.7.153.113', 8080))
  
      while True:
          # 3、接收服务器发送的消息
          data = client.recv(1024)
          print(data.decode(encoding='utf-8'))
  
          # 4、给服务器发送消息
          mesag = input('客户端：')
          client.send(mesag.encode())
  
      # 5、断开连接
      client.close()
  
  creat_client()
  

  实例二：下载图片

  #图片服务器
  """__author__=Deathfeeling"""
  
  import socket
  
  server = socket.socket()
  server.bind(('10.7.153.113', 8082))
  server.listen(100)
  
  while True:
      connect,addr = server.accept()
  
      with open('./beauty.png','rb') as f:
          data = f.read()
      connect.send(data)
  
      connect.close()
  
  #图片客户端
  """__author__=Deathfeeling"""
  
  import socket
  
  client = socket.socket()
  client.connect(('10.7.153.113',8082))
  
  #创建一个空的二进制数据
  all_data = bytes()
  data = client.recv(1024)
  while data:
      print('正在接收~~~')
      #拼接二进制数据，得到完整的图片
      all_data += data 
      data = client.recv(1024)
  print('接收完毕！')
  #写入在本地
  with open('./new.png','wb') as f:
      f.write(all_data)
  client.close()
  

  三、网络请求

  get方法

  """__author__=Deathfeeling"""
  
  import requests
  
  # 1、准备url
  url = 'https://www.apiopen.top/satinApi?type=1&page=1'
  
  # 2、发送请求（get）
  """
  get(url,参数对应的字典)
  post(url,参数对应的字典)
  """
  response = requests.get(url)
  # requests.get('https://www.apiopen.top/satinApi',{'type'=1,'page'=1})
  # print(response)
  
  # 3、通过相应获取服务器返回的数据
  # a、获取字符串类型的数据
  print(response.text)
  
  # b、获取json的数据
  print(response.json)
  
  # c、获取二进制格式的数据
  print(response.content)
  
  # d、获取响应头（了解）
  print(response.headers)
  
  

  post类似，但是需要有对应的post接口。

  练习

  1. 客户端和服务器聊天，可以一直聊天，直到一方发送’拜拜’。然后就可以和下一个人一直聊     

  #服务端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_server():
      """写一个服务器"""
      # 1、创建套接字对象
      server = socket.socket()
  
      # 2、绑定IP地址和端口
      server.bind(("10.7.153.113",8080))
  
      # 3、监听（客户端请求）
      server.listen(5)
      print('监听状态！')
      while True:
          connect, addr = server.accept()
          # 4、让服务器处于运行状态
          while True:
              mesag = input('服务器：')
              if mesag == '拜拜':
                  print('客户端已下线！')
                  connect.close()
                  break
              else:
                  connect.send(mesag.encode())
  
              # 6、接收从客户端发送过来的消息
              recv_data = connect.recv(1024)
              if recv_data.decode() == '拜拜':
                  print('客户端已下线！')
                  break
              else:
                  print('客户端：', recv_data.decode())
  
  
  creat_server()
  
  #客户端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_client():
      # 1、创建套接字对象
      client = socket.socket()
  
      # 2、连接服务器
      """
      connect(服务器地址)
      """
      client.connect(('10.7.153.113', 8080))
      while True:
          # 3、接收服务器发送的消息
          data = client.recv(1024)
          print('服务器：', data.decode(encoding='utf-8'))
  
          # 4、给服务器发送消息
          mesag = input('客户端：')
          if mesag == '拜拜':
              client.send(mesag.encode())
              print('已下线！')
              client.close()
          else:
              client.send(mesag.encode())
  
  
  creat_client()
  

  2. 下载网络图片（https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=2808438283,4249462766&fm=26&gp=0.jpg）到本地

  """__author__=Deathfeeling"""
  import requests
  
  url = 'https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=2808438283,4249462766&fm=26&gp=0.jpg'
  pic = bytes()
  response = requests.get(url)
  pic += response.content
  with open('./pic.jpg','ab') as f:
      f.write(pic)
  

  下载的图片如下：

  Read All

  ---

• socket编程

  2018-09-12

  Python

  socket

  socket又叫套接字，就是进行数据通信两端。分为服务器套接字和客户端套接字。 套接字编程：自己写服务器或者客户端，进行数据传输。

  python对socket编程的支持：提供一个socket库（内置）

  import socket
  

  一、服务器端（socket）

  1、创建套接字对象

  def creat_server():
      """
      socket(family,type)
      a.family：确定IP协议类型
      AF_INET:ipv4（默认）
      AF_INET6:ipv6
      b.type:传输协议类型
      SOCK_STREAM:TCP协议（默认）
      SOCK_DGRAM:UDP协议
      """
      server = socket.socket()
  

  2、绑定IP地址和端口

      """
      端口：一台电脑上一个端口标记一个唯一的服务。范围0~65535,0~1014是著名端口，专门标记一个特殊服务，一般不适用。
      注意：同一端口同一时间只能绑定一个服务。
      """
      server.bind(("10.7.153.113",8080))
  

  3、监听（客户端请求）

      """
      listen(个数)
      同一时间能够连接的客户端个数。
      """
      server.listen()
  

  4、让服务器处于运行状态

      while True:
          print('监听状态！')
          """
          连接客户端（建立连接）,返回连接对象和客户端地址。
          这句代码会阻塞线程，直到有客户端来请求当前服务器为止。
          """
          connect, addr = server.accept()
  
          print(addr)
  

  5、服务器给客户端发送消息

          """
          send(data)
          date：python3中要求类型是bytes，python2中可以是字符串。
          字符串 >>>> 二进制 ：
          1、字符串.encode（编码方式）默认utf-8
          2、bytes(字符串，编码方式)默认None
          """
          connect.send('你好！'.encode())
          connect.send(bytes('你好','utf-8'))
  

  6、接收从客户端发送过来的消息

          """
          recv(bufsize)
          bufsize:每次能够接收的最大字节数
          返回值：接收到的数据（二进制）
          二进制 >>> 字符串：
          1、二进制.decode()
          2、str(二进制，编码方式)
          注意：recv方法也会阻塞线程。
          """
          recv_data = connect.recv(1024)
          print(recv_data.decode())
          print(str(recv_data, 'utf-8'))
  

  7、断开连接

          connect.close()
  

  二、客户端（socket）

  1、创建套接字对象

  import socket
  def creat_client():
      client = socket.socket()
  

  2、连接服务器

      """
      connect(服务器地址,端口)
      """
      client.connect(('10.7.153.113', 8080))
  

  3、接收服务器发送的消息

      data = client.recv(1024)
      print(data.decode(encoding='utf-8'))
  

  4、给服务器发送消息

      client.send('我是客户端~~'.encode())
  

  5、断开连接

      client.close()
  

  实例一：通信

  # 服务器端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_server():
      """写一个服务器"""
      # 1、创建套接字对象
      server = socket.socket()
  
      # 2、绑定IP地址和端口
      server.bind(("10.7.153.113",8080))
  
      # 3、监听（客户端请求）
      server.listen(5)
      print('监听状态！')
      connect, addr = server.accept()
      
      # 4、让服务器处于运行状态
      while True:
          mesag = input('服务器：')
          connect.send(mesag.encode())
  
          #6、接收从客户端发送过来的消息
          recv_data = connect.recv(1024)
          print(recv_data.decode())
  
      #7、断开连接
      connect.close()
  
  creat_server()
  
  # 客户端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_client():
      # 1、创建套接字对象
      client = socket.socket()
  
      # 2、连接服务器
      """
      connect(服务器地址)
      """
      client.connect(('10.7.153.113', 8080))
  
      while True:
          # 3、接收服务器发送的消息
          data = client.recv(1024)
          print(data.decode(encoding='utf-8'))
  
          # 4、给服务器发送消息
          mesag = input('客户端：')
          client.send(mesag.encode())
  
      # 5、断开连接
      client.close()
  
  creat_client()
  

  实例二：下载图片

  #图片服务器
  """__author__=Deathfeeling"""
  
  import socket
  
  server = socket.socket()
  server.bind(('10.7.153.113', 8082))
  server.listen(100)
  
  while True:
      connect,addr = server.accept()
  
      with open('./beauty.png','rb') as f:
          data = f.read()
      connect.send(data)
  
      connect.close()
  
  #图片客户端
  """__author__=Deathfeeling"""
  
  import socket
  
  client = socket.socket()
  client.connect(('10.7.153.113',8082))
  
  #创建一个空的二进制数据
  all_data = bytes()
  data = client.recv(1024)
  while data:
      print('正在接收~~~')
      #拼接二进制数据，得到完整的图片
      all_data += data 
      data = client.recv(1024)
  print('接收完毕！')
  #写入在本地
  with open('./new.png','wb') as f:
      f.write(all_data)
  client.close()
  

  三、网络请求

  get方法

  """__author__=Deathfeeling"""
  
  import requests
  
  # 1、准备url
  url = 'https://www.apiopen.top/satinApi?type=1&page=1'
  
  # 2、发送请求（get）
  """
  get(url,参数对应的字典)
  post(url,参数对应的字典)
  """
  response = requests.get(url)
  # requests.get('https://www.apiopen.top/satinApi',{'type'=1,'page'=1})
  # print(response)
  
  # 3、通过相应获取服务器返回的数据
  # a、获取字符串类型的数据
  print(response.text)
  
  # b、获取json的数据
  print(response.json)
  
  # c、获取二进制格式的数据
  print(response.content)
  
  # d、获取响应头（了解）
  print(response.headers)
  
  

  post类似，但是需要有对应的post接口。

  练习

  1. 客户端和服务器聊天，可以一直聊天，直到一方发送’拜拜’。然后就可以和下一个人一直聊     

  #服务端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_server():
      """写一个服务器"""
      # 1、创建套接字对象
      server = socket.socket()
  
      # 2、绑定IP地址和端口
      server.bind(("10.7.153.113",8080))
  
      # 3、监听（客户端请求）
      server.listen(5)
      print('监听状态！')
      while True:
          connect, addr = server.accept()
          # 4、让服务器处于运行状态
          while True:
              mesag = input('服务器：')
              if mesag == '拜拜':
                  print('客户端已下线！')
                  connect.close()
                  break
              else:
                  connect.send(mesag.encode())
  
              # 6、接收从客户端发送过来的消息
              recv_data = connect.recv(1024)
              if recv_data.decode() == '拜拜':
                  print('客户端已下线！')
                  break
              else:
                  print('客户端：', recv_data.decode())
  
  
  creat_server()
  
  #客户端
  """__author__=Deathfeeling"""
  
  import socket
  
  def creat_client():
      # 1、创建套接字对象
      client = socket.socket()
  
      # 2、连接服务器
      """
      connect(服务器地址)
      """
      client.connect(('10.7.153.113', 8080))
      while True:
          # 3、接收服务器发送的消息
          data = client.recv(1024)
          print('服务器：', data.decode(encoding='utf-8'))
  
          # 4、给服务器发送消息
          mesag = input('客户端：')
          if mesag == '拜拜':
              client.send(mesag.encode())
              print('已下线！')
              client.close()
          else:
              client.send(mesag.encode())
  
  
  creat_client()
  

  2. 下载网络图片（https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=2808438283,4249462766&fm=26&gp=0.jpg）到本地

  """__author__=Deathfeeling"""
  import requests
  
  url = 'https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=2808438283,4249462766&fm=26&gp=0.jpg'
  pic = bytes()
  response = requests.get(url)
  pic += response.content
  with open('./pic.jpg','ab') as f:
      f.write(pic)
  

  下载的图片如下：

  Read All

  ---

• 正则表达式

  2018-09-11

  Python

  正则表达式

  正则表达式

  正则表达式就是用来检测字符串是否满足某种规则的工具 例如：匹配手机号、邮箱、脏话检测等

  1、单字符

  python对正则表达式的支持，提供了一个内置模块：re

  fullmatch（正则表达式，字符串）：查找字符串中是否有符合正则表达式规则，不符合返回None。

  search（正则表达式，字符串）：判断整个字符串是否符合正则表达式规则，不符合返回None。

  from re import fullmatch
  

  匹配对应字符（占位）

  （1）. ：匹配一位任意字符

  re_str = r'.'   #阻止转义
  print(fullmatch(re_str,'a'))
  
  <_sre.SRE_Match object; span=(0, 1), match='a'>
  

  （2）\w：匹配一位字母、数字、下划线。 （3）\s：匹配空白字符（空格、制表符(\t)、回车(\n)等所有能产生空白的字符）。 （4）\d：匹配一个数字字符。 （5）\W：匹配一个非字母、数字、下划线（\w取反） （6）\S：匹配非空白字符 （7）\D：匹配非数字字符

  位置检测（不占位）

  （8）\b：检测是否是单词边界, \b 不占位，并且必须所在位置是单词边界，否则匹配不成功。 注意： re_str = r’when\bwhere’ print(fullmatch(re_str,’whenwhere’)） print(fullmatch(re_str,’when where’))

  re_str = r'when\b\swhere'
  print(fullmatch(re_str,'when where'))
  

  （9）\B：检测非单词边界 （10）^：检测字符串是否以给定的正则表达式开头。

  re_str = r'^sd'
  print(search(re_str,'sdwfe'))
  
  <_sre.SRE_Match object; span=(0, 2), match='sd'>
  

  （11）$：字符串是否以给定的正则表达式结束。

  re_str = r'fe$'
  print(search(re_str,'sdwfe'))
  

  2、匹配次数

  注意：次数相关的操作，只约束次数符合前的一个字符。

  在匹配次数的字符后加 ? , 表示尽可能少的次数匹配。

  （1）[]：匹配中括号中出现的任意字符，只匹配一个字符。

  re_str = r'[abc]\d\d'
  #匹陪第一个字符是否是[]中的一个字符
  print(fullmatch(re_str,'c11'))
  
  <_sre.SRE_Match object; span=(0, 3), match='c11'>
  

  减号（-） –> 在正则的中括号中的应用 [1-8] —> 代表字符集：12345678 [-18] or [18-] —> 代表字符集：‘-’、‘1’、‘8’

  （2）[^字符集]：匹配不再[]字符集中的任意一个字符。

  （3） *：匹配 * 号前的字符0次或者多次。

  re_str = r'a*b'    #a能匹配多次，b依次
  print(fullmatch(re_str, 'aaab'))
  
  <_sre.SRE_Match object; span=(0, 4), match='aaab'>
  

  re_str = r’[abc]*’ —–> ‘a’, ‘abb’, ‘accb’

  （4） +：+前的字符集至少匹配一次。 re_str：r’[1-9]+\d*’ –> 首位不是0的数字集

  （5）？：匹配 0次 或者 1次。

  （6）{N}：匹配N次。 re__str = r’\d{3}’ –> 匹配 \d 3次

  （7）{N，}：至少匹配N次。

  （8）{N，M}至少匹配N次，最多M次。（M>N）

  练习：输入用户名，必须是字母数字下划线组成，6-20位 qq必须是数字组成，不能0开头，4-11位

  from re import fullmatch
  
  name = input('请输入用户名：')
  if fullmatch(r'\w{6,20}',用户名):
      print('输入用户名合法')
  else:
      print('用户名不合法')
  QQ = input('请输入QQ：')
  if fullmatch(r'[1-9]\d{4,11}',QQ):
      print('输入QQ合法')
  else:
      print('QQ不合法')
  

  3、分支和分组

  注意：正则中的分支有短路条件 — 如果使用 | 去连接多个条件，前面的条件如果已经匹配出结果，后面就不会匹配了。

  （1）分支 |：或（相当于逻辑运算中的or）

  re_str = r'[a-zA-Z]{3}|\d{3}'
  

  | ：前后是两种条件，分别是一个整体。

  （2）分组 通过加（）来对正则条件进行分组。 a、分组

  re_str = r'([a-z]{2}\d{2}){3}'
  print(fullmatch(re_str,'ac23gd45fd77'))
  
  <_sre.SRE_Match object; span=(0, 12), match='ac23gd45fd77'>
  

  b、重复 可以通过 \数字 来重复匹配前面的分组中匹配的结果，重复位置就是 \数字 的位置，数字的值代表前面的第几个分组（数字不是重复次数）。

  re_str = r'(\d{3})-(\w{2})\1{2}\2'
  print(fullmatch(re_str,'123-aa123123aa'))
  
  <_sre.SRE_Match object; span=(0, 14), match='123-aa123123aa'>
  

  c、捕获 按照完整的正则表达式去匹配，只捕获（）中的内容。只有在 findall 方法中有效。

  re_str = r'a(\d{3})b'
  print(findall(re_str,'a786b'))
  
  ['786']
  

  4、正则表达式的转义

  正则表达式中的转义和字符串中的转义字符没有任何关系。

  在python中的字符串前加 r 阻止的是字符串转义，不能阻止正则表达式的转义。

  在正则表达式中，可以通过在有特殊意义的符号前加 “ \ ” 来表示符号本身。

  \+， \. ，*， \? ，\\，，\(，\) ……

  注意： a、只有在 [] 中两个字符中间的 - 才有特殊意义。 b、如果特殊符号放在 [] 中，是不需要转义的。 c、 \ 不管在哪儿都需要转义，^ 放在中括号前面需要转义。

  5、re 模块中的方法

  （1）、compile（正则表达式）：将正则表达式转换成正则表达式对象。

  （2）、match（正则表达式，字符串）:判断字符串开头是否能够和正则表达式匹配。匹配成功返回匹配对象，否则返回None。

  （3）、fullmatch（正则表达式，字符串）：判断整个字符串能否和正则表达式匹配。匹配成功返回匹配对象，否则返回None。 返回结果：通过对象调用方法可以取到里面的值。

  re_str = r'(\d{3})-(\w{2})\1{2}\2'
  fullmatch1 = fullmatch(re_str,'123-aa123123aa')
  <_sre.SRE_Match object; span=(0, 14), match='123-aa123123aa'>
  

  a、获取第一个分组的范围 print(fullmatch1.span(1)) —括号里面可以不写 b、获取第一个分组的起始下标 print(fullmatch1.start(1)) —对应有end方法 c、获取匹配结果对应的字符串 print(fullmatch1.group(1))

  （4）search（正则表达式，字符串） 在字符串中取查找第一个满足正则表达式要求的字串，如果找到了返回对象，否则返回None

  （5）、split（正则表达式，字符串） 按满足正则表达式的字串去切割字符串。 返回值是一个列表。

  （6）sub（正则表达式，替换字符串，被替换字符串）

  （7）findall（正则表达式， 字符串） 获取字符串中所有满足正则表达式的字串。返回值是列表 注意：分组中的捕获效果在findall中是有效的（得到分组中的内容）。

  

  Read All

  ---

• 正则表达式

  2018-09-11

  Python

  正则表达式

  正则表达式

  正则表达式就是用来检测字符串是否满足某种规则的工具 例如：匹配手机号、邮箱、脏话检测等

  1、单字符

  python对正则表达式的支持，提供了一个内置模块：re

  fullmatch（正则表达式，字符串）：查找字符串中是否有符合正则表达式规则，不符合返回None。

  search（正则表达式，字符串）：判断整个字符串是否符合正则表达式规则，不符合返回None。

  from re import fullmatch
  

  匹配对应字符（占位）

  （1）. ：匹配一位任意字符

  re_str = r'.'   #阻止转义
  print(fullmatch(re_str,'a'))
  
  <_sre.SRE_Match object; span=(0, 1), match='a'>
  

  （2）\w：匹配一位字母、数字、下划线。 （3）\s：匹配空白字符（空格、制表符(\t)、回车(\n)等所有能产生空白的字符）。 （4）\d：匹配一个数字字符。 （5）\W：匹配一个非字母、数字、下划线（\w取反） （6）\S：匹配非空白字符 （7）\D：匹配非数字字符

  位置检测（不占位）

  （8）\b：检测是否是单词边界, \b 不占位，并且必须所在位置是单词边界，否则匹配不成功。 注意： re_str = r’when\bwhere’ print(fullmatch(re_str,’whenwhere’)） print(fullmatch(re_str,’when where’))

  re_str = r'when\b\swhere'
  print(fullmatch(re_str,'when where'))
  

  （9）\B：检测非单词边界 （10）^：检测字符串是否以给定的正则表达式开头。

  re_str = r'^sd'
  print(search(re_str,'sdwfe'))
  
  <_sre.SRE_Match object; span=(0, 2), match='sd'>
  

  （11）$：字符串是否以给定的正则表达式结束。

  re_str = r'fe$'
  print(search(re_str,'sdwfe'))
  

  2、匹配次数

  注意：次数相关的操作，只约束次数符合前的一个字符。

  在匹配次数的字符后加 ? , 表示尽可能少的次数匹配。

  （1）[]：匹配中括号中出现的任意字符，只匹配一个字符。

  re_str = r'[abc]\d\d'
  #匹陪第一个字符是否是[]中的一个字符
  print(fullmatch(re_str,'c11'))
  
  <_sre.SRE_Match object; span=(0, 3), match='c11'>
  

  减号（-） –> 在正则的中括号中的应用 [1-8] —> 代表字符集：12345678 [-18] or [18-] —> 代表字符集：‘-’、‘1’、‘8’

  （2）[^字符集]：匹配不再[]字符集中的任意一个字符。

  （3） *：匹配 * 号前的字符0次或者多次。

  re_str = r'a*b'    #a能匹配多次，b依次
  print(fullmatch(re_str, 'aaab'))
  
  <_sre.SRE_Match object; span=(0, 4), match='aaab'>
  

  re_str = r’[abc]*’ —–> ‘a’, ‘abb’, ‘accb’

  （4） +：+前的字符集至少匹配一次。 re_str：r’[1-9]+\d*’ –> 首位不是0的数字集

  （5）？：匹配 0次 或者 1次。

  （6）{N}：匹配N次。 re__str = r’\d{3}’ –> 匹配 \d 3次

  （7）{N，}：至少匹配N次。

  （8）{N，M}至少匹配N次，最多M次。（M>N）

  练习：输入用户名，必须是字母数字下划线组成，6-20位 qq必须是数字组成，不能0开头，4-11位

  from re import fullmatch
  
  name = input('请输入用户名：')
  if fullmatch(r'\w{6,20}',用户名):
      print('输入用户名合法')
  else:
      print('用户名不合法')
  QQ = input('请输入QQ：')
  if fullmatch(r'[1-9]\d{4,11}',QQ):
      print('输入QQ合法')
  else:
      print('QQ不合法')
  

  3、分支和分组

  注意：正则中的分支有短路条件 — 如果使用 | 去连接多个条件，前面的条件如果已经匹配出结果，后面就不会匹配了。

  （1）分支 |：或（相当于逻辑运算中的or）

  re_str = r'[a-zA-Z]{3}|\d{3}'
  

  | ：前后是两种条件，分别是一个整体。

  （2）分组 通过加（）来对正则条件进行分组。 a、分组

  re_str = r'([a-z]{2}\d{2}){3}'
  print(fullmatch(re_str,'ac23gd45fd77'))
  
  <_sre.SRE_Match object; span=(0, 12), match='ac23gd45fd77'>
  

  b、重复 可以通过 \数字 来重复匹配前面的分组中匹配的结果，重复位置就是 \数字 的位置，数字的值代表前面的第几个分组（数字不是重复次数）。

  re_str = r'(\d{3})-(\w{2})\1{2}\2'
  print(fullmatch(re_str,'123-aa123123aa'))
  
  <_sre.SRE_Match object; span=(0, 14), match='123-aa123123aa'>
  

  c、捕获 按照完整的正则表达式去匹配，只捕获（）中的内容。只有在 findall 方法中有效。

  re_str = r'a(\d{3})b'
  print(findall(re_str,'a786b'))
  
  ['786']
  

  4、正则表达式的转义

  正则表达式中的转义和字符串中的转义字符没有任何关系。

  在python中的字符串前加 r 阻止的是字符串转义，不能阻止正则表达式的转义。

  在正则表达式中，可以通过在有特殊意义的符号前加 “ \ ” 来表示符号本身。

  \+， \. ，*， \? ，\\，，\(，\) ……

  注意： a、只有在 [] 中两个字符中间的 - 才有特殊意义。 b、如果特殊符号放在 [] 中，是不需要转义的。 c、 \ 不管在哪儿都需要转义，^ 放在中括号前面需要转义。

  5、re 模块中的方法

  （1）、compile（正则表达式）：将正则表达式转换成正则表达式对象。

  （2）、match（正则表达式，字符串）:判断字符串开头是否能够和正则表达式匹配。匹配成功返回匹配对象，否则返回None。

  （3）、fullmatch（正则表达式，字符串）：判断整个字符串能否和正则表达式匹配。匹配成功返回匹配对象，否则返回None。 返回结果：通过对象调用方法可以取到里面的值。

  re_str = r'(\d{3})-(\w{2})\1{2}\2'
  fullmatch1 = fullmatch(re_str,'123-aa123123aa')
  <_sre.SRE_Match object; span=(0, 14), match='123-aa123123aa'>
  

  a、获取第一个分组的范围 print(fullmatch1.span(1)) —括号里面可以不写 b、获取第一个分组的起始下标 print(fullmatch1.start(1)) —对应有end方法 c、获取匹配结果对应的字符串 print(fullmatch1.group(1))

  （4）search（正则表达式，字符串） 在字符串中取查找第一个满足正则表达式要求的字串，如果找到了返回对象，否则返回None

  （5）、split（正则表达式，字符串） 按满足正则表达式的字串去切割字符串。 返回值是一个列表。

  （6）sub（正则表达式，替换字符串，被替换字符串）

  （7）findall（正则表达式， 字符串） 获取字符串中所有满足正则表达式的字串。返回值是列表 注意：分组中的捕获效果在findall中是有效的（得到分组中的内容）。

  

  Read All

  ---

• 类和对象02

  2018-09-07

  Python

  类和对象

  一、内置类属性

  内置类属性就是魔法属性

  1、魔法属性

  魔法属性：属性名的前面和后面都有两个下划线。

  __name__：获取类名。.
  类的属性
  
  __class__：获取对象的类，返回类。
  对象的属性（一般不用类的属性）
  
  __dict__：将对象和类的属性及其对应的值转换成键值对存为一个字典返回。
  对象的属性（一般不用类的属性）
  
  __bases__：获取当前类的父类
  类的属性
  
  __module__：获取类所在模块对应的名字。
  类的属性
  
  __doc__：获取类的说明文档。
  类的属性
  

  **特殊的魔法属性：_slots__**：通过它存的元素的属性值来约束这个类的对象的属性。 一旦在类中给__slots__赋值，name类对象的__dict_ 属性不能用

  class Person:
      #通过__slots__中存的元素的属性值来约束这个类的对象的属性，对象的属性不能比元组里面的多.
      __slots__ = ('name','age','face')
      def __init__(self):
          self.name = 'zhangsan'
          self.age = 18
          self.face = 70
  

  2、魔法方法

  魔法方法：方法的前后都有两个下划线。

  二、私有化

  python中没有真正的私有化。 python中默认的属性和方法都是公开的。

  1、声明：

  • 类中的属性和方法都可以通过在属性名和方法名前加两个下划线，来让其变成私有的。
  • 私有的属性和方法只能在当前类中使用。

    2、私有化原理

    在前面有两个下划线的属性名和方法名的前面添加“_类名”，阻止外部直接用属性名访问。

  三、属性的保护类型 – getter 和setter

  保护类型的属性：声明对象属性的时候，在属性名前加一个下划线（_），来代表这个属性是受保护的属性。

  • 那么以后访问这个属性的时候就不要直接访问，要通过 getter（获取属性值） 和 setter（给属性赋值）。
  • 如果一个属性已经声明成保护类型的属性，那么我们就需要给这个属性添加 getter ，或者添加 setter

    1、添加 getter（获取值）

    添加 getter 就是声明一个没有参数，有一个返回值的函数。

  格式：@property

  class Car:
      def __init__(self):
          self.color = 'yellow'
          self.type = 'bike'
          #_price属性是保护类型
          self._price = 2000
  
      #给_price属性添加getter
      @property
      def price(self):  #函数名为函数体去掉下划线
          #函数体
          return self._price
  
  car1 = Car()
  #添加完getter后使用
  print(car1.price)
  

  使用场景一

  如果想要获取对象的某个属性的值之前，想要再干点儿别的事情，就可以给这个属性添加 getter 。

  使用场景二

  想要获取某个属性被使用的时刻。

  2、添加 setter（赋值）

  添加 setter 就是声明一个有一个参数，但是没有返回值的函数。 想要给一个属性添加 getter ，就必须给这个属性添加 setter

  格式：@price.setter（price是setter的值）

  class Car:
      def __init__(self):
          self.color = 'yellow'
          self.type = 'bike'
          #_price属性是保护类型
          self._price = 2000
  
      #给_price属性添加setter
      @price.setter
      def price(self, price):
          if isinstance(price, int) or isinstance(price, float):
              self._price = price
          else:
              self._price = 0
  #添加完getter后使用,实质是在调用setter方法
  car1.price = 1000
  print(car1.price)
  

  四、继承

  1、继承

  python中类可以继承，并且支持多继承。 程序的继承：就是让子类直接拥有父类的属性和方法。

  （1）、继承的语法

  class 子类（父类）：
      类的内容
  

  注意：如果申明类的时候没有写继承，那么这个类会自动继承python的基类（object）。

  （2）、能继承什么东西

  a、所有的属性和方法都可以继承__ slots__的值不会继承，但是会影响子类对象的__ dict__属性，不能获取到父类继承下来的属性。 b、私有化本质上是继承下来了，只是python使用了一个小手段（改名），看起来没有继承下来。

  2、多继承（了解）

  python中的类支持多继承，但是不建议使用。

  class 类（父类1， 父类2）：
      pass
  
  

  多继承继承的时候，子类可以拥有所有父类的所有方法和类的字段，但是只能继承第一个父类的对象的属性。

  3、多态

  多态就是指多种形态。 有继承就有多态：不同的类继承至同一个类，其实就是对这个共同的父类不同的表现方式。继承后对方法的重写也是多态的表现。

  4、封装、继承、包

  封装：一个类可以通过不同的方法对不同的功能进行封装。通过属性对不同的数据进行封装。 继承：通过继承可以让子类拥有父类的属性和方法。

  五、重写相关

  子类继承父类，拥有父类的属性和方法以后，还可以添加自己的属性和方法。

  1、在子类中添加方法和类的字段

  直接添加

  2、添加对象的属性

  • 对象的属性是通过继承父类的__ init__方法而继承下来的。
  • 如果想要在保留父类的对象的同时，添加自己的对象属性，需要在子类的__ init__方法中用使用 super（）去调用父类的__ init__方法

  3、方法的重写

  在子类中重新实现父类的方法，就是重写

  注意：使用super的时候，必须是通过super（）来代替父类，或者是父类对象

  super().number
  

  方式一：直接覆盖父类的实现。

  • 直接写和父类一样的方法名

  方式二：保留父类的功能在添加其他功能。

  def __init__(self):
      super().__init__()
      self.name = '小花'
  

  # 通过super()调用父类的方法，保留父类的功能
  def shout(self):
      super().shout()
      print('喵喵~~')
  

  ######4、类中方法的调用过程 先在当前这个类中去找，没有就去父类找，依次找到基类（object），如果都没有找到，就让程序崩溃。

  练习：

  # 写一个Person类，拥有属性name，age，sex，
  # 要求创建person对象的时候必须给name和age赋值，sex可以选择赋值
  # 再写一个Staff类继承Person类，保存所有属性，并且添加新的属性：salary，
  # 要求创建Staff类的对象的时候，只能给name必须赋值。
  class Person:
      def __init__(self, name, age, sex='boy'):
          self.name = name
          self.age = age
          self.sex = sex
  
  class Staff(Person):
      def __init__(self, name):
          super().__init__(name, 0)
          self.salary = 10000
  
  p1 = Person('xingchen', 18)
  p2 = Person('zhangsan', 20, 'girl')
  s1 = Staff('xiaohong')
  
  

  ###六、运算符的重载 如果希望类的对象支持相应的运算符操作（例如：+，-，*，/，>，<等），就必须实现相应的魔法方法，这个过程就叫运算符的重载。

  # 加操作
  def __add__(self, other):
      return self.score + other.score
  # 大于操作(重载大于方法后，不用重载小于方法，另一个功能自动取反)
  def __gt__(self, other):
      return self.score > other.score
  
  stu1 = Student('小明',18,90)
  stu2 = Student('小王',16,89)
  print(stu1 + stu2)
  print(stu1 > stu2)
  
  179
  True
  

  一般情况需要对 > 或者 < 进行重载，重载后可以通过用 sort（）方法直接对列表中的对象进行排序。

  补充： 重写魔法方法__ str__，用来定制对象的打印样式( print方法 )。 ###七、包 包：将多个模块封装到一起，就是包。包就是有一个默认文件__ init__.py的文件夹。

  格式：

  1、包.模块
  2、from 包 import 模块
  3、from 包.模块 import 方法/类/变量
  

  Read All

  ---

• 类和对象02

  2018-09-07

  Python

  类和对象

  一、内置类属性

  内置类属性就是魔法属性

  1、魔法属性

  魔法属性：属性名的前面和后面都有两个下划线。

  __name__：获取类名。.
  类的属性
  
  __class__：获取对象的类，返回类。
  对象的属性（一般不用类的属性）
  
  __dict__：将对象和类的属性及其对应的值转换成键值对存为一个字典返回。
  对象的属性（一般不用类的属性）
  
  __bases__：获取当前类的父类
  类的属性
  
  __module__：获取类所在模块对应的名字。
  类的属性
  
  __doc__：获取类的说明文档。
  类的属性
  

  **特殊的魔法属性：_slots__**：通过它存的元素的属性值来约束这个类的对象的属性。 一旦在类中给__slots__赋值，name类对象的__dict_ 属性不能用

  class Person:
      #通过__slots__中存的元素的属性值来约束这个类的对象的属性，对象的属性不能比元组里面的多.
      __slots__ = ('name','age','face')
      def __init__(self):
          self.name = 'zhangsan'
          self.age = 18
          self.face = 70
  

  2、魔法方法

  魔法方法：方法的前后都有两个下划线。

  二、私有化

  python中没有真正的私有化。 python中默认的属性和方法都是公开的。

  1、声明：

  • 类中的属性和方法都可以通过在属性名和方法名前加两个下划线，来让其变成私有的。
  • 私有的属性和方法只能在当前类中使用。

    2、私有化原理

    在前面有两个下划线的属性名和方法名的前面添加“_类名”，阻止外部直接用属性名访问。

  三、属性的保护类型 – getter 和setter

  保护类型的属性：声明对象属性的时候，在属性名前加一个下划线（_），来代表这个属性是受保护的属性。

  • 那么以后访问这个属性的时候就不要直接访问，要通过 getter（获取属性值） 和 setter（给属性赋值）。
  • 如果一个属性已经声明成保护类型的属性，那么我们就需要给这个属性添加 getter ，或者添加 setter

    1、添加 getter（获取值）

    添加 getter 就是声明一个没有参数，有一个返回值的函数。

  格式：@property

  class Car:
      def __init__(self):
          self.color = 'yellow'
          self.type = 'bike'
          #_price属性是保护类型
          self._price = 2000
  
      #给_price属性添加getter
      @property
      def price(self):  #函数名为函数体去掉下划线
          #函数体
          return self._price
  
  car1 = Car()
  #添加完getter后使用
  print(car1.price)
  

  使用场景一

  如果想要获取对象的某个属性的值之前，想要再干点儿别的事情，就可以给这个属性添加 getter 。

  使用场景二

  想要获取某个属性被使用的时刻。

  2、添加 setter（赋值）

  添加 setter 就是声明一个有一个参数，但是没有返回值的函数。 想要给一个属性添加 getter ，就必须给这个属性添加 setter

  格式：@price.setter（price是setter的值）

  class Car:
      def __init__(self):
          self.color = 'yellow'
          self.type = 'bike'
          #_price属性是保护类型
          self._price = 2000
  
      #给_price属性添加setter
      @price.setter
      def price(self, price):
          if isinstance(price, int) or isinstance(price, float):
              self._price = price
          else:
              self._price = 0
  #添加完getter后使用,实质是在调用setter方法
  car1.price = 1000
  print(car1.price)
  

  四、继承

  1、继承

  python中类可以继承，并且支持多继承。 程序的继承：就是让子类直接拥有父类的属性和方法。

  （1）、继承的语法

  class 子类（父类）：
      类的内容
  

  注意：如果申明类的时候没有写继承，那么这个类会自动继承python的基类（object）。

  （2）、能继承什么东西

  a、所有的属性和方法都可以继承__ slots__的值不会继承，但是会影响子类对象的__ dict__属性，不能获取到父类继承下来的属性。 b、私有化本质上是继承下来了，只是python使用了一个小手段（改名），看起来没有继承下来。

  2、多继承（了解）

  python中的类支持多继承，但是不建议使用。

  class 类（父类1， 父类2）：
      pass
  
  

  多继承继承的时候，子类可以拥有所有父类的所有方法和类的字段，但是只能继承第一个父类的对象的属性。

  3、多态

  多态就是指多种形态。 有继承就有多态：不同的类继承至同一个类，其实就是对这个共同的父类不同的表现方式。继承后对方法的重写也是多态的表现。

  4、封装、继承、包

  封装：一个类可以通过不同的方法对不同的功能进行封装。通过属性对不同的数据进行封装。 继承：通过继承可以让子类拥有父类的属性和方法。

  五、重写相关

  子类继承父类，拥有父类的属性和方法以后，还可以添加自己的属性和方法。

  1、在子类中添加方法和类的字段

  直接添加

  2、添加对象的属性

  • 对象的属性是通过继承父类的__ init__方法而继承下来的。
  • 如果想要在保留父类的对象的同时，添加自己的对象属性，需要在子类的__ init__方法中用使用 super（）去调用父类的__ init__方法

  3、方法的重写

  在子类中重新实现父类的方法，就是重写

  注意：使用super的时候，必须是通过super（）来代替父类，或者是父类对象

  super().number
  

  方式一：直接覆盖父类的实现。

  • 直接写和父类一样的方法名

  方式二：保留父类的功能在添加其他功能。

  def __init__(self):
      super().__init__()
      self.name = '小花'
  

  # 通过super()调用父类的方法，保留父类的功能
  def shout(self):
      super().shout()
      print('喵喵~~')
  

  ######4、类中方法的调用过程 先在当前这个类中去找，没有就去父类找，依次找到基类（object），如果都没有找到，就让程序崩溃。

  练习：

  # 写一个Person类，拥有属性name，age，sex，
  # 要求创建person对象的时候必须给name和age赋值，sex可以选择赋值
  # 再写一个Staff类继承Person类，保存所有属性，并且添加新的属性：salary，
  # 要求创建Staff类的对象的时候，只能给name必须赋值。
  class Person:
      def __init__(self, name, age, sex='boy'):
          self.name = name
          self.age = age
          self.sex = sex
  
  class Staff(Person):
      def __init__(self, name):
          super().__init__(name, 0)
          self.salary = 10000
  
  p1 = Person('xingchen', 18)
  p2 = Person('zhangsan', 20, 'girl')
  s1 = Staff('xiaohong')
  
  

  ###六、运算符的重载 如果希望类的对象支持相应的运算符操作（例如：+，-，*，/，>，<等），就必须实现相应的魔法方法，这个过程就叫运算符的重载。

  # 加操作
  def __add__(self, other):
      return self.score + other.score
  # 大于操作(重载大于方法后，不用重载小于方法，另一个功能自动取反)
  def __gt__(self, other):
      return self.score > other.score
  
  stu1 = Student('小明',18,90)
  stu2 = Student('小王',16,89)
  print(stu1 + stu2)
  print(stu1 > stu2)
  
  179
  True
  

  一般情况需要对 > 或者 < 进行重载，重载后可以通过用 sort（）方法直接对列表中的对象进行排序。

  补充： 重写魔法方法__ str__，用来定制对象的打印样式( print方法 )。 ###七、包 包：将多个模块封装到一起，就是包。包就是有一个默认文件__ init__.py的文件夹。

  格式：

  1、包.模块
  2、from 包 import 模块
  3、from 包.模块 import 方法/类/变量
  

  Read All

  ---