第一份实习工作（3）笔记2

20210706笔记

a = "{'a':1,'b':2}"
b = eval(a)
print(type(b), b)  # dict {'a': 1, 'b': 2}

1.eval可以将字符串转换成字典 但是字符串里面是单引号，外边为双引号

import json
e = '{"a":1,"b":2}'
f = json.loads(e)  # str->dict
print(type(f), f)  # dict {'a': 1, 'b': 2}

2.loads可以将字符串转换成字典，但是字符串里面为双引号，外边为单引号

dumps：dict->str

loads： str -> dict

与文件结合转换之后可以存入文件中 dump：dict -> str

load：str -> dict

3.json文件按行读取

with open("C:\\Users\\Mi\\Desktop\\106data.json", 'r') as fp:
    for i in fp.readlines():
        j = json.loads(i)
        udp_socket.sendto(j.encode("utf-8"), ("127.0.0.1", 8087))

4.对于在文件读写中

a:只能写，当文件不存在时创建文件，不覆盖，追加写

a+：可读可写，当文件不存在时创建文件，不覆盖，追加写

w：只能写，当文件不存在时创建文件，覆盖

w+：可读可写，当文件不存在时创建文件，覆盖

r：只能读，当文件不存在时报错

r+：可读可写，当文件不存在时报错，覆盖

20210707笔记

test_cases1.py

1. def put_data(key,shard_id,total_value_num):插入数据(信号名，信号名所对应的shard_id，添加信号量的总数目) assert断言可以用在py中

def verify_data(key,shard_id,total_value_num):查询数据，查询到了之后直接显示。

def test_put_and_verify_immediatelly():测试插入数据以及查询数据功能。utils.kill_process()->杀死进程；time.sleep(10)->休眠十秒

def test_put_and_verify_until_memdata_exists():测试插入数据以及插入之后.mmf文件是否存在，查询数据，是否插入成功。存在会输出Get until mem_data_xxx.mmf exist

def test_put_and_verify_until_store_data_exists():测试插入数据之后存储数据的.stf文件是否存在，查询数据。存在会输出Get until store_data_xxx.stf exist

def test_put_and_verify_after_several_restart():测试是否能够重复的插入数据，显示store_data_xxx.stf exist那么之前循环插入成功。

def loop(loop_count):在input的某一行中显示从一开始就需要迭代器，返回值为True，否则为False。

153行->subprocess.Popen(),为subprocess模块定义了一个类：Popen(args,bufsize=0,)args:可以是一个字符串，可以是一个包含程序参数的列表，要执行的程序是这个列表的第一项，或者是字符串本身。返回should_stop():初始化为False。

在一些复杂的场景中，我们需要将一个进程的执行输出作为另一个进程的输入。在另一些场景中，我们需要先进入到某个输入环境，然后再执行一系列的指令等，需要使用该方法：eg: subprocess.Popen(["cat",test.txt"])

subprocess.Popen("cat test.txt"):错误，因为如果是一个字符串的话，第一个元素必须是程序的路径才可以。但是下面的这个是正确的：subprocess.Popen("cat test.txt",shell=True)因为相当于subprocess.Popen(["/bin/sh", “-c”, “cat test.txt”])

stdout：标准输出；stderr：标准错误；

universal_newlines=True,则子进程的stdout和stdrr都会被视为文本对象，并且windows 格式的行结束符（'/r/n' ）会被视为 '/n' 。

process = subprocess.Popen(['D:\environment\android-sdk_r24.4.1-windows\android-sdk-windows\platform-tools\adb.exe', 'devices'],
shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE))

等同于

process = subprocess.Popen(['adb', 'devices'], shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE))
print(process.communicate())

PIPE表示需要创建一个新的管道，如果为 None则表示不会做任何重定向的工作，子进程的文件描述会继承父进程的。另外，stderr的值还可以是STDOUT,表示子进程的标准错误也输出到标准输出。

stdout, stderr = out.communicate()  # 参数是标准输入，返回标准输出和标准出错

而且要获得程序的返回值，可以在调用Popen.communication()之后取Popen.returncode的值。

结论：如果使用subprocess.Popen,就不使用Popen.wait(),而使用Popen.communication()来等待外部命令执行结束。

Popen()对象：

poll():检查是否结束，设置返回值

wait():等待结束，设置返回值

communication()：参数是标准输入，返回标准输出和返回值。

send_siginal():发送信号（主要在Linux）下有用

terminate()：终止进程

kill():杀死进程

stdin,stdout,stderr:参数中指定PIPE时，有用

pid():进程id

returncode():进程返回值

line.strip（）：默认去掉空格，移除头尾指定的字符串。如果从开始需要迭代器if "Need to iterate from beginning" in line:should_stop=True。

logger.info("Line {}".format(line.strip()))

def test_iterator():在这个函数中调用了def loop(loop_count)函数。测试迭代器。cnt记录的应该是从哪里开始需要迭代器。loop：（循环）。

cnt = 1
should_stop = False
while should_stop == False:

​	shoule_stop = loop(cnt)

​	cnt += 1

2. logging模块：提供的日志记录函数所使用的日志器设置的日志级别是WARNING因此只有warning级别的日志或者大于它级别的日志才会输出，小于其级别的日志不会输出。级别排序依次为：debug<info<warning<error<critical

log_utils:日志工具类:def make_logger(log_path=None,log_name=None,level=logging.INFO,stream=False,stream_level = logging.WARN):

log_path->路径， log_name->日志文件名，level->INFO级别，stream->是否输出到控制台，默认不输出，stream_level->输出到控制台的最低log级别。

(1)基本使用：logging中可以选择许多消息级别，debug、info（常规信息）、warning、error、critical。通过赋予logger或者handler不同的级别，就可以只输出错误的信息到特定的记录文件，或者在调试时只记录调试信息。

import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")

运行时，控制台输出（此处设置的级别为INFO级别）：

2016-10-09 19:11:19,434 - __main__ - INFO - Start print log
2016-10-09 19:11:19,434 - __main__ - WARNING - Something maybe fail.
2016-10-09 19:11:19,434 - __main__ - INFO - Finish

我们将logger的级别改为DEBUG后输出：

2016-10-09 19:12:08,289 - __main__ - INFO - Start print log
2016-10-09 19:12:08,289 - __main__ - DEBUG - Do something
2016-10-09 19:12:08,289 - __main__ - WARNING - Something maybe fail.
2016-10-09 19:12:08,289 - __main__ - INFO - Finish

(2)RotatingFileHandler:实现日志回滚

rHandler = RotatingFileHandler("log.txt",maxBytes = 1*1024,backupCount = 3) # 最多备份三个日志文件，每个日志文件最大1K。

(3)logger:日志生成器，产生日志。Filter：日志过滤器，过滤日志。Handler：日志处理器，对日志进行格式化，并输出到指定位置（控制台或者文件）。Formater： 处理日志的格式

logger1.addHandler(handler1):绑定生成器与文件句柄

return logger:返回logger句柄。

20210708笔记

test_cases8.py

1. test_resultset_multi_keys():测试key信号量有多个的时候，没有参数且没有返回值，有assert断言。

2. test_resultset_one_key():测试key信号量只有一个的时候，没有参数且没有返回值，有assert断言。

test_cases9.py： ->UTC时间（国际协调时间）：

1. add_aggregation_rule(): 里面的subprocess.Popen([...])为执行列表里面的内容，可以是字符串或者路径，后面的参数可能为.sh的参数。把标准输出写到日志文件里面，相当于显示标准输出。

2. delete_aggregation_rule():把标准输出写到日志文件里面，相当于显示标准输出

3. put_data_1_hour():

4. verify_1s_agg():

7. test_put_and_verify_agg():

test_cases9_1.py

1. def test_put_and_verify_after_several_restart():反复测试插入数据和查询数据是否会操作成功

2. def test_put_and_verify_after_several_restart_two():cnt%20==0反复测试插入查询数据是否会成功

3. def test_put_and_verify():反复测试插入数据和查询数据是否会操作成功

4. def test_put_and_verify_two():反复测试插入数据和查询数据是否会操作成功

test_cases9_2.py

1. def put_shadow_data():subprocess模块里面Popen。将put_shadow_data写入日志，将标准输出写入日志。

2. def verify_shadow_data():查询shadow数据

3. def test_put_shadow_and_verify():测试插入shadow数据以及查询shadow数据

4. def test_put_and_verify_restart():测试多次插入和查询数据

vdata_data_pb2.py：->RPC通信

vdata_pb2.py：->RPC通信

utils.py：->RPC通讯

client.py：->RPC通信

1. def put_data_points(host_and_port,key,shard_id,values):(地址和端口，信号名，信号名所对应的id，个数) 插入数据put_data.

2 . 序列化(serialization)：将对象状态转换为可保持或者传输的格式的过程。与序列化相对的是反序列化，把已存在在磁盘或者其他介质中的对象，读取到内存中。这两个过程结合起来，可以轻松存储和传输数据.

pbrpc通讯方式（RPC通信）：1.定义通讯协议，编写一个proto文件，2.编写Server文件，3.编写Client文件

应用层：可以自定义协议-》头部+数据部分

传输层：tcp、udp—>基于端口。端口范围0-65535，0-1023为系统占用端口。ip+port标识全世界范围内独一无二的一个基于网络通信的应用程序。

网络层、数据链路层、物理层

总结json通信模块以及subprocess模块里面Popen里面参数的作用，里面第一个参数可以为命令，也可以为路径，都是以字符串的形式体现出来的。PIPE为空的管道，直接放入到新的管道里面。

例子为:其中第一个参数为命令，后面依次为标准输入和标准输出。

import subprocess

obj = subprocess.Popen('ls /root',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)  # 1命令

print(obj)

res = obj.stdout.read()
print(res)

err_res = obj.stderr.read()
print(err_res.decode('utf-8'))

 

学习日志模块部分：日志输出位置，日志格式，时间格式，日志级别。日志字典的使用，日志配置字典

20210712笔记

1. HTTP Request请求

HTTP定义了很多于服务器交互的方法

• GET 向Web服务器请求一个文件

• POST 向Web服务器发送数据，并让Web服务器进行处理。

• PUT 向Web服务器发送数据，并存储在Web服务器内部。

• HEAD 检查一个对象是否存在

• DELETE 从Web服务器上删除一个文件

• CONNECT 对通道提供支持

• TRACE 跟踪到服务器的路径

• OPTIONS 查询Web服务器的性能

可以使用一个URL地址来描述一个网络上的资源，而HTTP的GET、POST、PUT、DELETE对应着对这个资源的查、改、增、删四个操作。

20210713笔记

应用层：http、https、ftp

自定义协议需要注意的问题：

1. 两大组成部分：头部 + 数据部分

头部：放对数据的描述信息。比如：数据要发给谁、数据的类型、数据的长度

数据部分：想要发的数据

2.头部的长度必须固定

因为接收端要通过头部获取所接收数据的详细信息

传输层：tcp\udp 又称为：段

基于tcp协议通信之前：必须建立一个双向通信的链接。

C---------->S

C<--------------S

三次握手建立链接：建立链接是为了传数据做准备的，三次握手即可。

四次挥手断开链接：断开链接时，由于链接内有数据传输，所以必须分四次断开。

 

tcp是可靠传输的：因为客户端每发送一个数据过去，服务端都会回应过去。发送数据必须等到对方确认后才算完成，才会将自己内存中的数据清理掉，否则不清理。

ps：当服务端大量处于TIME_WITH状态时，意味着服务端正在经历高并发。

网络层： 包

数据链路层：帧

物理层: 交互机

与python异常相关的关键字：

关键字：	关键字说明：
raise	抛出、引发异常
try/except	捕获异常并处理
pass	忽略异常
as	定义异常实例
finally	无论是否出现异常，都执行的代码
else	如果try中的语句没有引发异常，则执行else中的代码

except Exception as e：可以捕获与程序退出sys.exit（）相关之外的所有异常。

例子1：

try:
    f = open("foo","r")
except IOError as e:
    ...
else:
    data = f.read()

例子2：

try:
	f = open("foo","r")
except IOError as e:
	...
finally:
	f.close()

Auto_test.py里面的这个函数看不懂：

def dump_object(obj):
    for descriptor in obj.DESCRIPTOR.fields:
        value = getattr(obj, descriptor.name)
        if descriptor.type == descriptor.TYPE_MESSAGE:
            if descriptor.label == descriptor.LABEL_REPEATED:
                map(dump_object, value)
            else:
                dump_object(value)
        elif descriptor.type == descriptor.TYPE_ENUM:
            enum_name = descriptor.enum_type.values[value].name
            logger.info("{full_name}: {enum_name}".format(full_name=descriptor.full_name, enum_name=enum_name))
        else:
            logger.info("{full_name}: {value}".format(full_name=descriptor.full_name, value=value))

20210714笔记

1.日志模块的使用

2.re模块（正则表达式）

有一篇比较好的博客：https://www.cnblogs.com/shenjianping/p/11647473.html

 

3.软件开发的目录规范：start.py的放置位置

4.内置函数

定义匿名函数：lambda

res = (lambda x,y:x+y)(1,2)

print(res)

20210719笔记492-506

mysql : 3306

1 mysql中的sql语句是以分号作为结束的标志

2 基本命令：

'''
show databases；

客户端连接服务端完整命令：
mysql -h 127.0.0.1 -P 3306 -uroot  -p
连接服务端的命令可以简写：
mysql -uroot  -p    (1)               show databases (2)

4.当你输入的命令不对，又不想让服务端执行并返回报错信息 可以用\c取消
 错误命令 \c
5.客户端退出，退出命令加不加分号都可以执行
	quit
	exit
6.当你连接服务端的时候 发现只输入mysql也能连接，但是你不是管理员身份，而只是一个游客模式


环境变量配置及其系统服务制作
1. 如何查看当前具体进程
	tasklist
	tasklist |findstr mysqld
	
2.如何杀死具体进程（只有在管理员cmd窗口下才能成功）
	taskkill /F /PID PID号
	
	
环境变量配置
每次启动mysql需要先切到对应的文件路径下才能操作太多繁琐
将mysql所在的文件路径添加到系统环境变量中

还是繁琐，需要起两个cmd窗口 不好
将mysql服务端制作成系统服务（开机自启动）
1. 查看当前计算机的运行进程数
	serveses.msc
将myssql制作成系统服务
	mysqld --install
移除mysql系统服务
	mysqld --remove
	
	
设置密码
	mysqladmin -uroot -p原密码 password 新密码
该命令直接在终端输入即可 无需进入客户端


忘记密码怎么做
你可以将mysql获取用户名和密码校验功能看成是一个装饰器
装饰在了客户端请求访问的功能上
我们如果将该装饰器移除 那么mysql服务端就不会校验用户名和密码了
1. 先关闭当前mysql服务端
命令行的方式启动（让mysql跳过用户名密码验证功能）
mysqld --skip-grant-tables
2. 直接以无密码的方式连接
mysql uroot -p 直接回车
3. 修改当前用户的密码
update mysql.user set password=password(123456) where user = 'root' and host = 'localhost';
# 真正存储用户表的密码字段 存储的肯定是密文
只有用户自己知道密文是什么 其他人都不知道 这样更加安全
4.立刻将修改数据刷到硬盘
flush privileges;
5.关闭当前服务端，然后以正常校验授权表的形式启动

	
'''

统一编码

• mysql默认的配置文件

  '''
  my-default.ini
  ini结尾的一般都是配置文件
  程序启动会先加载配置文件中的配置，之后才真正地启动
  
  # 需要你自己新建一个my.ini的配置文件
  
  # 验证配置是否真的是自动加载
  [mysql]
  print("HelloWorld!")
  # 修改配置文件后一定要重启服务才能生效
  
  # 统一编码的配置 无需掌握 直接拷贝即可
  [mysqld]
  character-set-server=utf-8
  collation-server=utf8_general_ci
  [client]
  default-character-set=utf8
  [mysql]
  default-character-set=utf8
  
  '''

  库的增删改查

• 针对库的增删改查(文件夹)

  # 增
  create database db1;
  create database db1 charset='gbk';
  
  # 查
  show databases;  # 查所有
  show create database db1;  # 查单个
  
  # 改
  alter database db2 charset='utf8';
  
  # 删
  drop database db2;
  

  针对表的增删改查(文件)

  # 在操作表的时候，需要指定所在的库（文件夹）
  # 查看当前所在的库的名字
  select database();
  # 切换库
  use db1;
  # 增
  create table t1(id int,name char(4));  #4可写可不写
  
  # 查
  show tables;  # 查看当前库下面所有的表名
  show create table t1;
  describle t1;  # 支持简写 desc t1;
  
  # 改
  alter table t1 modify name char(16)
  
  # 删
  drop table t1;
  

  针对数据的增删改查(一行行数据)

  # 一定要先有库，有表，然后才能操作记录
  # 增
  insert into t1 values(1,'jason');
  insert into t1 values(1,'jason'),(2,'egon'),(3,'tank');
  
  # 查
  select * from t1;  # 该命令当数据量特别大的时候不建议使用
  select id,name from t1;
  
  # 改
  update t1 set name='DSB' where id>1;
  
  # 删
  delete from t1 where id>1;
  delete from t1 where name='jaso';
  
  #将表所有的数据清空
  delete from t1;

  20210722笔记

  1.以下为监控本地计算机的cpu和内存占用率

  # -*- coding: utf-8 -*-
  import psutil
  import datetime
  import time
  
  
  # 要求：监控CPU和内存占用率
  # 监控CPU信息
  def cpu():
      cpu = psutil.cpu_count(False)  # cpu核数 默认逻辑CPU核数， False查看真实cpu核数 2
      cpu_per = int(psutil.cpu_percent(1))  # 每秒cpu使用率，（1，true） 每一核cpu的每秒使用率； 36
      print("请输出每秒的CPU使用率：")
      # print(cpu, cpu_per)
      print(cpu_per)
      return cpu_per
  
  
  # 监控内存信息
  def mem():
      mem = psutil.virtual_memory()  # 查看内存信息:(total,available,percent,used,free)
      # print("请输出当前计算机监控的内存信息：")
      # print(mem)
      mem_total = int(mem[0] / 1024 / 1024)
      mem_used = int(mem[3] / 1024 / 1024)
      mem_per = int(mem[2])
      mem_info = {
          'mem_total': mem_total,
          'mem_used': mem_used,
          'mem_per': mem_per,
      }
      return mem_info
  
  
  # 间隔一定时间(10秒)，输出当前的CPU状态信息
  def all_msg():
      msg = []
      now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')  # append之后是['2019-03-21 15:31:39']
      # now_time = datetime.datetime.strptime(now_time, '%Y-%m-%d %H:%M:%S')  # append之后是[datetime.datetime(2019, 3, 21, 15, 29, 42)]
      msg.append(now_time)  # 获取时间点 (f0)
      cpu_info = cpu()
      msg.append(cpu_info)  # cpu 使用率(f1),单位：%
      mem_info = mem()
      msg.append(mem_info['mem_per'])  # 内存使用率(f2),单位：%
      return msg
  
  
  def main():
      cnt_times = 1
      while (1):
          msg = all_msg()
          print("以下为获取计算机的时间点  and  CPU使用率%  and  内存使用率%:")
          print(msg)  # 实时打印每个十秒写入txt的数据。
          with open("C:\\Users\\Mi\\Desktop\\cs_monitor.txt", "a+") as fp:
              b = [str(i) for i in msg]
              # print(b)
              fp.write((','.join(b)) + '\n')
          cnt_times += 1
          # 每隔10秒，统计一次当前计算机的使用情况。
          time.sleep(10)
          # 统计了20000次后跳出当前循环，统计的总共时间是：20000*10/3600 ~= 55.55
          if (cnt_times > 20000):
              break
  
  
  main()
  

  pustil库：能够轻松实现获取系统运行和系统利用率（包括CPU，内存，磁盘，网络等）。它主要用来做系统监控，性能分析，进程管理。为一个跨平台库。

  datatime库：是py处理日期和时间的标准库，datatime.now(),返回当前日期和时间，其类型是datatime。也可以获取指定的日期和时间。datetime转换为timestamp。timestamp转换为datetime。str转换为datetime。datetime加减。本地时间转换为UTC时间。时区转换。

  字节：通过网络传输信息的单位，1个字节等于8位二进制。在ASCII码中，一个英文字母占一个字节空间，一个中文汉字占两个字节的空间，英文标点占一个字节，中文标点占两个字节。一个二进制的数字序列，在计算机中作为一个数字单元，一般为8位二进制数，如一个ASCII码就是一个字节。

  1千吉字节(TB) = 1024吉字节(2的40次方字节) (1TB = 1024GB)

  1吉字节(GB) = 1024兆字节(2的30次方字节) (1GB = 1024MB)

  1兆字节(MB) = 1024千字节(2的20次方字节) (1MB = 1024KB)

  1千字节(KB) = 1024字节(2的10次方字节) (1KB = 1024B)

  1字节(Byte) = 8位(bit)

  注：TB是现在电脑硬盘最大的存储单位。10TB大约等于一个人脑的存储量。

  20210726笔记

  Python调用exe文件几种不同的方法:

  Python直接调用exe的方法有几种，在使用的时候有些方法并不能直接调用执行，需要自己一个个的尝试，例如： 1.通过引入os模块

  # -*- coding:utf-8 -*-
  import os
  
  cmd = r"D:\worknote\2.exe"  #exe文件的绝对路径
  # a = os.popen(cmd).read()   # os.popen（）方法，我的不能直接调用执行
  # a = os.system(cmd)   # os.system（），我的不能直接调用执行
  a = os.startfile(cmd)   #  os.startfile（），我的直接可以调用执行，成功了
  print(type(a))
  

  2.通过引入subprocess

  import subprocess  
  import os  
  main = r"D:\worknote\2.exe"  # exe文件的绝对路径
  a = subprocess.getstatusoutput(main)    # 我这边使用subprocess.getstatusoutput()方法，还是不能直接调用执行exe文件
  print (a)
  
  

  Python如何生成exe可执行文件:

  安装pyinstaller打包工具 通常可以直接在cmd环境下执行下面的命令即可： pip install pyinstaller

  注意，有时可能会出现一堆红字，安装失败，通常是网络的原因，可以多试几次，或者换一个时段再试试。

  pyinstaller安装完成后就可以执行： pyinstaller -F heart.py (heart.py为你希望生成exe的python程序）

   打包完成后，进入到当前目录下，会发现多了__pycache__、build、dist、heart.spec这四个文件夹或者文件，只需要将dist目录下的heart.exe可执行文件拷贝到其他地方直接使用。其它的文件或者文件都是编译中间过程文件，可以直接删除。
  
    生成exe文件同时文件图标也是默认的，如果你希望改变为自定义的图标，请加-i 参数：
  
   pyinstaller -i pp.ico -F  heart.py

  图标制作可点击http://ico.duduxuexi.com/在线制作，然后下载保存即可。

  附：pyinstaller参数 -F 表示生成单个可执行文件 -D –onedir 创建一个目录，包含exe文件，但会依赖很多文件（默认选项） -w 表示去掉控制台窗口，这在GUI界面时非常有用。不过如果是命令行程序的话那就把这个选项删除吧 -c –console, –nowindowed 使用控制台，无界面(默认) -p 表示你自己自定义需要加载的类路径，一般情况下用不到 -i 表示可执行文件的图标 其他参数，可以通过pyinstaller --help查看

  1.int/float to string/array:

  C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串，下面列举了各函数的方法及其说明。 ● itoa()：将整型值转换为字符串。 ● ltoa()：将长整型值转换为字符串。 ● ultoa()：将无符号长整型值转换为字符串。 ● gcvt()：将浮点型数转换为字符串，取四舍五入。 ● ecvt()：将双精度浮点型值转换为字符串，转换结果中不包含十进制小数点。 ● fcvt()：指定位数为转换精度，其余同ecvt()。

  除此外，还可以使用sprintf系列函数把数字转换成字符串，其比itoa()系列函数运行速度慢

  2. string/array to int/float C/C++语言提供了几个标准库函数，可以将字符串转换为任意类型(整型、长整型、浮点型等)。

  ● atof()：将字符串转换为双精度浮点型值。 ● atoi()：将字符串转换为整型值。 ● atol()：将字符串转换为长整型值。 ● strtod()：将字符串转换为双精度浮点型值，并报告不能被转换的所有剩余数字。 ● strtol()：将字符串转换为长整值，并报告不能被转换的所有剩余数字。 ● strtoul()：将字符串转换为无符号长整型值，并报告不能被转换的所有剩余数字。