bingo 发布的文章

python 基础

!/usr/bin/env python3

此处指定为python3的可执行程序,python 3版本没有向前兼容

在 Python 中空白非常重要。实际上,在每行开头的空白很重要。称之为缩进。 在行首的主要的空白(空格键和制表符)用来决定逻辑行缩进的层次,从而来决定语 句分组。
这意味着同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块

基本的输入和输出

   
   输入:   name = input("please input your name")
   
   输出:   print("your name is ",name)
   

基本编码文本格式设置为UTF-8

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

注意:

  python大小写敏感!!!
  缩进十分严格!!!
  # 是单行注释
  '''  可以作为多行注释即可。  只要没有变量引用它  它就不是字符串,变为多行注释。
  何模块代码的第一个字符串都被视为模块的文档注释

数据类型

整数(int) 不可变

十进制数非0不能以0开头。例如 0100是错误的

二进制表示:  num = 0b
八进制表示:  num = 0o
十六进制表示: num = 0x 
                                                                                                                                                                                                    

浮点数


普通表示:  num = 1.78
科学计数法: num = 1.78e5    1.78的5次方

字符串 不可变


单引号:  ' str '
双引号:  " str2 "
三引号:  '''  str  '''   三引号不用使用"\"换行符,当字符串很长的时候,通常使用单引号和双引号的时候,跨行是要加\才能跨行。使用三引号不用关心此问题

默认加反斜杠\是可以转义的,但是若想不转义,分别在前面加上r即可。例如
str =  r'str\t'    # 效果   str\t
str2 = r"str2\n"   #效果   str2\n
str3 = r''' str3\n'''  #效果 str3\n


字符串反转: 
str[::-1]  #切片法


序列化为unicode编码:   'str'.encode('UTF-8')   # 编码
反序列化unicode编码:   b'str'.decode('UTF-8')  # 解码

格式化输出1: print("you name is %s and age is %d" % (name,age))

字符串拼接使用 加号+   例如  str2 = "hello"+"world"
也可以省略加号   直接  str2 = "hello""world"

布尔值

 真:  True
 假:  False  0  0.0  [] () {} "" None
 bool类型 是int的子类 。
 bool继承自 int 所以 int+bool是可以运算的。 
 例子: True是1    False  是0  
 print (2+True) # 3  
 print(3+False) # 3 
 isinstance(obj,class_name) # 判断是否是某一个类的实例 
 is   # 判断两个的id是否一致 通过内存id判断是否是同一个引用 
 例如 a = 20   b = 20  a is b # True  

 type函数返回的是类型 而不是字符串 例如: 
       a = 20  type(a) == int # True 返回值是真 

list 数组是可变的。其实所谓的可变和不可变就是,通过list"对象" 点 通过执行方法就可以改变原来的内容。
tuple 元组是不可变的。不能对他增删改查。 不可变只能拷贝 不能修改。

空值

 空: None 
 

list(列表)

 list说白了就是可变数组:  定义  array = [1,2,3]
 求数组长度:  len(array)   

  添加元素   array.append(4)
  删除最后一个元素:  array.pop()
  获取最后一个元素:  array[-1]
  头部插入一个元素:  array.insert(0,1)
  
  常见遍历:
  for index in arr:
    print(index)
       

tuple (元组) 不可变

  tuple说白了就是不可变数组。定义 const array = (1,2,3)
  
  只定义一个单元素的元组:  tuple = (1,) #加一个逗号区分  若没有逗号则以为是tuple=1
  
  此时不能对tuple进行append  pop操作。也就是该元组已经确定了,不能修改。但是必须理解一个特殊情况。所谓的不变是指的"指向"不变
  
  例如:    arr = [1,2]
          tuple = (arr,4,5,6)
          此时  tuple[0][1] = 100  #此语句不会出错
    因为此时我并没有对tuple进行结构上的增删改,此时操作的对象是arr而不是tuple本身。 例如 tuple[4] = 5   #此时会出错   因为此时在修改tuple结构    
    

dic(字典:dictionary )

  字典说白了就是json字符串的形式,key-value.
  
  定义 :   person = {'name':'张三','age':20}
  
  获取值: person['name']
  赋值:  person['age'] = 20
  
  尝试通过key获取值:  person.get('key','default-value')
  
  遍历:
  for key,val in person.items():
    print(key,val)
  

set(特殊的字典)和dict也是成对的

  set里面只有key,没有对应的value.接收一个list作为参数,只能放入不可变数据类型,如字符串 整数,不能放入list等可变变量。
  
  set1 =   set([1,2,3])
  
  set2 = set([4,5,6])
  
  #交集   set1 & set2
  #并集   set1 | set2
  
  #尝试往set1加入一个list
  set1.add([7,8,9])     #  此时会报错                    
  
 

分支跳转和循环

if 条件 :

  if():
   #coding...
  else:
   #coding....

if 条件 : .... elif 条件 :.....else:....

循环 (for循环和while循环)

for item in items :
  #coding....
  
range(5)  #  生成一个 [0,1,2,3,4]  的序列

range(9,0)  #倒序生成  [9 8 7 6 ... 1]

while 循环

   while(true):
       #coding...
                                          

函数(function)

数据类型转 int() float() bool() str() list() tuple()
pass表示暂时让程序跑起来,后面再写。否则不写pass则出错


def  function_name(x1,x2):
      #coding....      

使用 return 返回。默认没有写return 则 retrun None

可以返回多个值。例如 return x1,x2 其实本质上是返回一个tuple
(x1,x2) 然后用变量按照位置赋值即可,类似php中的list(x1,x2) = [1,2]

默认参数: 和php用法一致。但是默认参数必须是不可变类型,如str,int,tuple.否则会出现一个怪相。

 def test(arr=[]):
     arr.append(1)
     
 调用3次test()后  会出现[1,1,1]会累加。  其实这么理解,可变参数就是引用,直接修改值,但是非可变变量类型才是浅拷贝,不会影响本身。
 
 
可变参数:    加一个*号  转换参数到function里面变为一个tuple
def function_name(*args)  :
    #coding....
 
 function_name(1,2,3,4,5)
 
 也可以直接传一个数组list进去,但是得加上一个*号
 list = [1,2,3,4,5]
 
 function_name(*list)      
 
关键词参数: 传入的值变为json形式传入
定义:

 def  function_name(name,age,**person):
 
 function_name('zhangsan',20,city="beijing",counrty="china")
 
 会出现person = {'city':'beijing','counrty':'china'}
 
 也可以组装好再传入:
 
 function_name('zhangsan',20,**person)

命名关键词字参数:

   和上面的关键词参数一样,只是限制这个json拥有哪些key的问题。例如限制只有city和counrty的key.
   
def function_name(name,age,*,city,counrty):
    pass
    
参数顺序:必选参数、默认参数、可变参数、命名关键字参数和关键字参数

 def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

 def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

所以,对于任意函数,都可以通过类似func(*args, **kw)的形式调用它,无论它的参数是如何定义的。

切片


例如针对  list  tuple  string  截取某一段的值
如 :  arr=[1,2,3,4,5]
取前三个:   arr[:3]  1,2,3   不包括最后一个下标,只包括前面的下标
取最后三个:  arr[-3:-1]
每隔n个取一个: arr[::2]  每隔2个取一个  1,3,5    

迭代


数组list  tuple  dic  str都是可以迭代的对象。dic默认迭代key,list迭代value

for key in dic

for value in list

迭代value:

for value in dic.values()

迭代key和value:

for key,value in dic.items()     

遍历数组常用方法:   #可以获取key 和val
for key,val in enumerate(list):

判断是否是某一个类的实例对象


from collections import Iterable
isinstance(obj,Itrable)  # 判断obj是否属于Itrable的子类

           

函数名也是变量。 a = abs 完全是可以的,再调用a(-1) 等同 abs(-1),也可以把函数作为参数传进去。

匿名函数和返回值可以是函数

add = lambda x:x**2

相当于定义函数:
def add(x):
  return x**2
  

特殊变量和模块


模块目录需要有 __init__.py文件 
_开头或者__开头的函数/变量是只属于该模块使用的,  对外部不可见。相对于php来说,  对每个function都有 公开和私有的说法。
 pip3安装模块 。 

pip3 install  module_name

面向对象

class的定义:

       class  Student(object):  
         pass   
         

实例化: student = Student()

类属性可以直接写:

      class Student(object):
        name = "zhangsan"

类似php自由添加属性. student.name = "zhangsan"

构造函数: self必传 self相当于this 。默认第一个参数必须是self。

def __init__(self,name,age)

访问限制: 加上__开头即可表示 private

析构函数: __del__(self):

静态方法加: @staticmethod @classmethod

初始化父类: super().__init__(参数)

使用 type(obj) #查看obj的数据类型

hasattr(obj,'attr') #测试是否有attr属性

getattr(obj,'attr_name','default_value') #获取属性值 获取方法也可以

fn = getattr(obj,'myfun')
fn() # 作用和obj.myfun()是一样的

__str__:方法类的字符串表示 类似php的__toString()

异常处理

     try:
       #coding...
     except Exception as e:
       #coding...
     finally:
       #coding...  无论如何都会执行 就算前面有exit  /  quit()都会执行
                                 
   所有的异常都是继承 BaseException.
   

raise 抛出异常

   raise Exception("错误信息") 
   
             

IO操作

  读取文件:  fp = open("1.txt","r",encoding="gb2312",errors='ignore') 
            str = fp.read()  
  
  写入内容:  "w"  会覆盖   fp.write("contents"),"a"   追加
  
      

文件目录操作 import os

 os.path  # 对路径进行操作  join  split
 
 os.mkdir
 os.removedir
 os.rename 

序列化和反序列化

      import pickle
      
       pickle.dumps(obj)  # 输出序列化字符串
       pickle.dump(obj,fp)    #将序列化内容写入文件  
       
                                                       

转为json

 
    import  json
    
    json.dumps(obj) #转为json字符串
    
    json.loads(json_str)  #转为python变量

多进程和多线程

 Linux:    import  os
           os.fork()  //派生出子进程
           os.getpid() //当前进程id
           os.getppid()  //得到父进程id
跨平台widnows:  from multiprocess import Process

              process = Process(target=execute_function,args=('参数',))
              
              process.start()  //开启进程
              
              process.join()  //执行成功后继续
              
 Pool进程池:  from mutiprocess import Pool
 
 子进程:     import subprocess
 
  进程通信:  from mutiprocess import Queue 
            import time,random,time

多线程 threading
import time,threading

t = threading.Thread(target=function_name, name='LoopThread')
t.start()
t.join()

正则表达式

import re

partten = r'^w{3}' # 正则表达式规则

re.match(partten,target_str) # 匹配

常见内置模块

datetime #处理时间
from datetime import datetime
print(datetime.now()) # 当前时间

操作MYSQL数据库
$ pip3 install PyMySQL #先安装pymysql包
$ pip3 install pymysql==0.9.0 #指定版本

1.导出目前项目用到依赖文件:

pip3 freeze > requirements.txt

文件内容如下:

altgraph==0.15
ascii==3.6
asn1crypto==0.24.0
certifi==2018.1.18
cffi==1.11.5
chardet==3.0.4

从依赖文件中导入安装依赖:

pip3 install -r requirements.

2.配置config

config = {

"host":'ip',
"port":3306,
"user":"",
"password":"password",
"charset":"utf8",
"autocommit":True #自动提交事务,
"db":"db",
"cursorclass":pymysql.cursors.DictCursor #字段的数据结构

}

connect = pymysql.connect() 获取连接对象
cursor = connect.cursor() =># 执行sql的具体对象
cursor.execute("insert into table values(%s,%s)",(name,age)) #第二个参数防注入 预编译
connect.commit() # 连接对象 commit 提交
connect.insert_id() #获取插入的id

获取执行的sql语句:cursor._excuted

常见模块:

1.文件,目录操作

2.时间(datetime模块 有一个datetime类)
2.1 当前时间 : datetime.now()
2.2 根据日期获取到时间 datetime(2014,4,5,16,24,56) 2014-4-5 16:24:56
2.3 datetime.timestamp() # 获取时间戳
2.4 时间戳转时间 datetime.fromtimestamp(10100202002)

字符串转时间 datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')

   时间格式化为字符串: 
  datetime.strftime("%Y-%m-%d %H:%M:%S")

时间加减: from datetime import timedelta
timedelta(hours=12) # 12小时 然后就是通过+ - 来算时间
3.加密 hashlib (包含 md5等等加密算法)

https://shimo.im/docs/fooucf8wa8EtAB32/
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000

php 精度计算问题

如果用php的+-/计算浮点数的时候,可能会遇到一些计算结果错误的问题,比如echo intval( 0.58100 );会打印57,而不是58,这个其实是计算机底层二进制无法精确表示浮点数的一个bug,是跨语言的,我用python也遇到这个问题。所以基本上大部 分语言都提供了精准计算的类库或函数库,比如php有BC高精确度函数库,下面达内php培训老师介绍一下一些常用的BC高精确度函数使用。

  例子

代码如下

<?php    $f = 0.58;    var_dump(intval($f * 100)); //为啥输出57?>

  为啥输出是57啊? PHP的bug么?

  我相信有很多的同学有过这样的疑问, 因为光问我类似问题的人就很多, 更不用说bugs.php.net上经常有人问…

  要搞明白这个原因, 首先我们要知道浮点数的表示(IEEE 754):

  浮点数, 以64位的长度(双精度)为例, 会采用1位符号位(E), 11指数位(Q), 52位尾数(M)表示(一共64位).

  符号位:最高位表示数据的正负,0表示正数,1表示负数。

  指数位:表示数据以2为底的幂,指数采用偏移码表示

  尾数:表示数据小数点后的有效数字.

  这里的关键点就在于, 小数在二进制的表示, 关于小数如何用二进制表示, 大家可以百度一下, 我这里就不再赘述, 我们关键的要了解, 0.58 对于二进制表示来说, 是无限长的值(下面的数字省掉了隐含的1)..

  0.58的二进制表示基本上(52位)是: 00101000111101011100001010001111010111000010100011110.57的二进制表示基本上(52位)是: 001000111101011100001010001111010111000010100011110而两者的二进制, 如果只是通过这52位计算的话,分别是:www.111cn.net

  0.58 -> 0.579999999999999960.57 -> 0.5699999999999999至于0.58 100的具体浮点数乘法, 我们不考虑那么细, 有兴趣的可以看(Floating point), 我们就模糊的以心算来看… 0.58 100 = 57.999999999

  那你intval一下, 自然就是57了….

  可见, 这个问题的关键点就是: “你看似有穷的小数, 在计算机的二进制表示里却是无穷的”

  so, 不要再以为这是PHP的bug了, 这就是这样的…..

  PHP浮点型在进行+-*%/存在不准确的问题

  例如:

  

1.

  $a = 0.1;

  $b = 0.7;

  var_dump(($a + $b) == 0.8);

  打印出来的值为 boolean false

  这是为啥?PHP手册对于浮点数有以下警告信息:

  Warning

  浮点数精度

  显然简单的十进制分数如同 0.1 或 0.7 不能在不丢失一点点精度的情况下转换为内部二进制的格式。这就会造成混乱的结果:例如,floor((0.1+0.7)*10) 通常会返回 7 而不是预期中的 8,因为该结果内部的表示其实是类似 7.9999999999…。

  这和一个事实有关,那就是不可能精确的用有限位数表达某些十进制分数。例如,十进制的 1/3 变成了 0.3333333. . .。

  所以永远不要相信浮点数结果精确到了最后一位,也永远不要比较两个浮点数是否相等。如果确实需要更高的精度,应该使用任意精度数学函数或者 gmp 函数

代码如下

<?php

$a = 0.1;
$b = 0.7;
var_dump(bcadd($a,$b,2) == 0.8);

  bcadd — 将两个高精度数字相加

  bccomp — 比较两个高精度数字,返回-1, 0, 1

  bcdiv — 将两个高精度数字相除

  bcmod — 求高精度数字余数

  bcmul — 将两个高精度数字相乘

  bcpow — 求高精度数字乘方

  bcpowmod — 求高精度数字乘方求模,数论里非常常用

  bcscale — 配置默认小数点位数,相当于就是Linux bc中的”scale=”

  bcsqrt — 求高精度数字平方根

  bcsub — 将两个高精度数字相减

  整理了一些实例

  php BC高精确度函数库包含了:相加,比较,相除,相减,求余,相乘,n次方,配置默认小数点数目,求平方。这些函数在涉及到有关金钱计算时比较有用,比如电商的价格计算。

代码如下

/**
  * 两个高精度数比较
  * 
  * @access global
  * @param float $left
  * @param float $right
  * @param int $scale 精确到的小数点位数
  * 
  * @return int $left==$right 返回 0 | $left<$right 返回 -1 | $left>$right 返回 1
  */
var_dump(bccomp($left=4.45, $right=5.54, 2));
// -1
  
 /**
  * 两个高精度数相加
  * 
  * @access global
  * @param float $left
  * @param float $right
  * @param int $scale 精确到的小数点位数
  * 
  * @return string 
  */
var_dump(bcadd($left=1.0321456, $right=0.0243456, 2));
//1.04
 
  /**
  * 两个高精度数相减
  * 
  * @access global
  * @param float $left
  * @param float $right
  * @param int $scale 精确到的小数点位数
  * 
  * @return string 
  */
var_dump(bcsub($left=1.0321456, $right=3.0123456, 2));
//-1.98
  
 /**
  * 两个高精度数相除
  * 
  * @access global
  * @param float $left
  * @param float $right
  * @param int $scale 精确到的小数点位数
  * 
  * @return string 
  */
var_dump(bcdiv($left=6, $right=5, 2));
//1.20
 
 /**
  * 两个高精度数相乘
  * 
  * @access global
  * @param float $left
  * @param float $right
  * @param int $scale 精确到的小数点位数
  * 
  * @return string 
  */
var_dump(bcmul($left=3.1415926, $right=2.4569874566, 2));
//7.71
 
 /**
  * 设置bc函数的小数点位数
  * 
  * @access global
  * @param int $scale 精确到的小数点位数
  * 
  * @return void 
  */ 
bcscale(3);
var_dump(bcdiv('105', '6.55957')); 
// 16.007

PHP 高精度手册

转载:https://www.cnblogs.com/xiezhi/p/5688029.html

PHP PSR规范

====================PSR-0(自动加载规范)=======================

PSR-0(Autoloading Standard)类自动加载规范,该规范现已废弃(Deprecated),它将由PSR-4替代。

1.一个完全合格的命名空间和类名必须遵循以下结构 "\VendorName\Namespace\ClassName"

2.每个命名空间必须有顶级的命名空间 "VendorName"

3.每个命名空间可以有任意多个子命名空间

4.每个命名空间在被文件系统加载时必须被转换为操作系统路径分隔符 (DIRECTORY_SEPARATOR)

5.每个"_"字符在"类名"中被转换为DIRECTORY_SEPARATOR。而在 PSR-4 中使用下划线没有任何特殊含义

6.符合命名标准的命名空间和类名必须以".php"结尾来加载文件

7.命名空间和类名可以由大小写字母组成,但必须对大小写敏感以保证多系统兼容性

  ***不推荐使用 - 在2014年10月21日PSR-0已被标记为过时。PSR-4现在推荐作为替代。***

====================PSR-1(基本代码规范)=======================

PSR-1(Basic Coding Standard)基本代码规范,用以确保共享的PHP代码间具有较高程度的技术互通性。

1.PHP代码源文件必须以 <?php 或 <?= 标签开始

2.PHP代码源文件必须使用不带 BOM 的 UTF-8 编码

3.一个源文件建议只用作定义类、函数、常量等声明,或者其他产生从属效应的操作(如:输出信息,修改配置文件等)

4.命名空间以及类必须符合 PSR 的自动加载规范:PSR-0 或 PSR-4

5.类的命名必须遵循 StudlyCaps 大写开头的驼峰式命名规范

6.类中的常量所有字母都必须大写,单词间用下划线分隔

7.方法名必须符合 camelCase 式的小写开头驼峰式命名规范
  • BOM(byte order mark)是 Unicode 标准的一部分,通常用于标记纯文本字节序(byte order),使得文本处理程序能够识别读入的文件使用的 Unicode 编码(UTF-8、UTF-16、UTF-32)。
  • 从属效应是指仅仅通过包含文件,不直接声明类、函数和常量而执行的逻辑操作。一份PHP源文件应该要么就只包含不产生从属效应的定义操作,要么就包含只会产生从属效应的逻辑操作,切勿同时包含两者。

====================PSR-2(代码风格规范)=======================

PSR-2(Coding Style Guide)代码风格规范,通过制定一系列规范化PHP代码的规则,以减少因代作者码风格不同而造成的阅读不便。

1.代码必须遵循 PSR-1 中的编码规范

2.代码必须使用4个空格来进行缩进,而非制表符(TAB)

3.建议每行代码字符数保持在80个以内,理论上不可多于120个,但不做硬性限制

4.每个 namespace 命名空间语句和 use 声明语句块后面必须插入一个空白行

5.类的左花括号 "{" 必须写在声明后自成一行,右花括号 "}" 也必须在类主体下自成一行

6.方法的左花括号 "{" 必须放在声明后自成一行,右花括号 "}" 也必须于主体下自成一行

7.类的属性和方法必须添加访问修饰符(private、protected、public),abstract 以及 final 必须声明在访问修饰符之前,而 static 必须声明在访问修饰符之后(例:final public static)

8.在控制结构关键字的后面必须有一个空格,而调用方法或函数时一定不能有(控制结构:if-else、switch-case、try-catch、while、foreach ...)

9.控制结构的左花括号 "{" 必须跟其处于同一行,右花括号 "}" 必须在控制结构主体之后自成一行

10.控制结构的开始左括号之后,和结束右括号之前都不可以有空格

====================PSR-3(日志接口规范)=======================

PSR-3(Logger Interface)日志接口规范,主要目的是为了让日志类库通过接收一个 LoggerInterface 对象来记录日志信息。

1.LoggerInterface 接口对外定义了八个方法,分别用来记录 RFC 5424 中定义的八个等级的日志:debug、info、notice、warning、error、critical、alert、emergency

2.第九个方法 log(),第一个参数为记录等级。可使用一个预先定义的等级常量作为参数来调用此方法,必须与直接调用以上八个方法具有相同的效果。如果传入的等级常量没有预先定义,则必须抛出 psr\Log\InvalidArgumentException 类型的异常。不推荐使用自定义的日志等级,除非你非常确定当前类库对其有所支持。

====================PSR-4(自动加载新规)=======================

PSR-4(Improved Autoloading)本规范是关于自动载入对应类的相关规范,是 PSR-0 自动加载规范的补充。

1.此处的“类”是一个泛称,它包含类、接口、traits 以及其他类似的结构

2.完全限定类名需要遵循以下结构:\<命名空间>(\<子命名空间>)*\<类名>

  * 完全限定类名必须要有一个顶级命名空间,被称为 "vendor namespace";

  * 完全限定类名可以有一个或多个子命名空间;

  * 完全限定类名必须有一个终止类名;

  * 完全限定类名中任意一部分中的下划线都没有特殊含义;

  * 完全限定类名可以由任意大小写字母组成;

  * 完全限定类名必须以大小写敏感的方式引用;

3.当根据完整的类名载入相应的文件时:

  * 完全限定类名中,连续的一个或几个子命名空间构成的命名空间前缀(不包括顶级命名空间的分隔符),至少对应着至少一个基础目录;

  * 紧接命名空间前缀后的子命名空间必须与相应的”文件基目录“相匹配,其中的命名空间分隔符将作为目录分隔符;

  * 终止类名对应一个以 .php 结尾的文件,文件名必须和终止类名大小写匹配;

4.自动加载器(autoloader)的实现不能抛出异常,不可引发任一级别错误,也不应该有返回值

更为详细的讲解,可以参考此博客

socket

什么是TCP/IP、UDP?
TCP/IP(Transmission Control Protocol/Internet Protocol)即传输控制协议/网间协议,是一个工业标准的协议集,它是为广域网(WANs)设计的。
UDP(User Data Protocol,用户数据报协议)是与TCP相对应的协议。它是属于TCP/IP协议族中的一种。

    这里有一张图,表明了这些协议的关系。

wps453C.tmp.png

  TCP/IP协议族包括运输层、网络层、链路层。现在你知道TCP/IP与UDP的关系了吧。
Socket在哪里呢?
  在图1中,我们没有看到Socket的影子,那么它到底在哪里呢?还是用图来说话,一目了然。
2.png

原来Socket在这里。
Socket是什么呢?
  Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。
你会使用它们吗?
  前人已经给我们做了好多的事了,网络间的通信也就简单了许多,但毕竟还是有挺多工作要做的。以前听到Socket编程,觉得它是比较高深的编程知识,但是只要弄清Socket编程的工作原理,神秘的面纱也就揭开了。
  一个生活中的场景。你要打电话给一个朋友,先拨号,朋友听到电话铃声后提起电话,这时你和你的朋友就建立起了连接,就可以讲话了。等交流结束,挂断电话结束此次交谈。 生活中的场景就解释了这工作原理,也许TCP/IP协议族就是诞生于生活中,这也不一定。
3.png

  先从服务器端说起。服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束。

Socket连接过程
根据连接启动的方式以及本地套接字要连接的目标,套接字之间的连接过程可以分为三个步骤:服务器监听,客户端请求,连接确认。
(1)服务器监听:是服务器端套接字并不定位具体的客户端套接字,而是处于等待连接的状态,实时监控网络状态。
(2)客户端请求:是指由客户端的套接字提出连接请求,要连接的目标是服务器端的套接字。为此,客户端的套接字必须首先描述它要连接的服务器的套接字,指出服务器端套接字的地址和端口号,然后就向服务器端套接字提出连接请求。
(3)连接确认:是指当服务器端套接字监听到或者说接收到客户端套接字的连接请求,它就响应客户端套接字的请求,建立一个新的线程,把服务器端套接字的描述发给客户端,一旦客户端确认了此描述,连接就建立好了。而服务器端套接字继续处于监听状态,继续接收其他客户端套接字的连接请求。
socket原理可以参考下面的流程图:
4.png

socket相关函数:

socket_accept() 接受一个Socket连接
socket_bind() 把socket绑定在一个IP地址和端口上
socket_clear_error() 清除socket的错误或者最后的错误代码
socket_close() 关闭一个socket资源
socket_connect() 开始一个socket连接
socket_create_listen() 在指定端口打开一个socket监听
socket_create_pair() 产生一对没有区别的socket到一个数组里
socket_create() 产生一个socket,相当于产生一个socket的数据结构
socket_get_option() 获取socket选项
socket_getpeername() 获取远程类似主机的ip地址
socket_getsockname() 获取本地socket的ip地址
socket_iovec_add() 添加一个新的向量到一个分散/聚合的数组
socket_iovec_alloc() 这个函数创建一个能够发送接收读写的iovec数据结构
socket_iovec_delete() 删除一个已经分配的iovec
socket_iovec_fetch() 返回指定的iovec资源的数据
socket_iovec_free() 释放一个iovec资源
socket_iovec_set() 设置iovec的数据新值
socket_last_error() 获取当前socket的最后错误代码
socket_listen() 监听由指定socket的所有连接
socket_read() 读取指定长度的数据
socket_readv() 读取从分散/聚合数组过来的数据
socket_recv() 从socket里结束数据到缓存
socket_recvfrom() 接受数据从指定的socket,如果没有指定则默认当前socket
socket_recvmsg() 从iovec里接受消息
socket_select() 多路选择
socket_send() 这个函数发送数据到已连接的socket
socket_sendmsg() 发送消息到socket
socket_sendto() 发送消息到指定地址的socket
socket_set_block() 在socket里设置为块模式
socket_set_nonblock() socket里设置为非块模式
socket_set_option() 设置socket选项
socket_shutdown() 这个函数允许你关闭读、写、或者指定的socket
socket_strerror() 返回指定错误号的详细错误
socket_write() 写数据到socket缓存
socket_writev() 写数据到分散/聚合数组

重点讲解:
socket_create($net参数1,$stream参数2,$protocol参数3)
    作用:创建一个socket套接字,一个网络数据流。
    返回值:一个套接字,或者是false,参数错误发出E_WARNING警告
    socket_create创建并返回一个套接字,也称作一个通讯节点。一个典型的网络连接由 2 个套接字构成,一个运行在客户端,另一个运行在服务器端。
    参数1是:网络协议,
    它的选择项就下面这三个:
    AF_INET:   IPv4 网络协议。TCP 和 UDP 都可使用此协议。一般都用这个,你懂的。
    AF_INET6:   IPv6 网络协议。TCP 和 UDP 都可使用此协议。
    AF_UNIX:   本地通讯协议。具有高性能和低成本的 IPC(进程间通讯)。
    参数2:套接字流,选项有:
    SOCK_STREAM  SOCK_DGRAM  SOCK_SEQPACKET  SOCK_RAW  SOCK_RDM。
    这里只对前两个进行解释:
    SOCK_STREAM  TCP 协议套接字。
    SOCK_DGRAM   UDP协议套接字。

    参数3:protocol协议,选项有:
    SOL_TCP:  TCP 协议。
    SOL_UDP:  UDP协议。
    
  

    关键函数2:
    socket_connect($socket参数1,$ip参数2,$port参数3)
    作用:连接一个套接字,返回值为true或者false
    参数1:socket_create的函数返回值
    参数2:ip地址
    参数3:端口号

    关键函数3:
    socket_bind($socket参数1,$ip参数2,$port参数3)
    作用:绑定一个套接字,返回值为true或者false
   参数1:socket_create的函数返回值
    参数2:ip地址
    参数3:端口号

    关键函数4:
    socket_listen($socket参数1,$backlog 参数2)
    作用:监听一个套接字,返回值为true或者false
    参数1:socket_create的函数返回值
    参数2:最大监听套接字个数

    关键函数5:
    socket_accept($socket)
    作用:接收套接字的资源信息,成功返回套接字的信息资源,失败为false
   参数:socket_create的函数返回值

    关键函数6:
    socket_read($socket参数1,$length参数2)
    作用:读取套接字的资源信息,
    返回值:成功把套接字的资源转化为字符串信息,失败为false
    参数1:socket_create或者socket_accept的函数返回值
    参数2:读取的字符串的长度

    关键函数7:
    socket_write($socket参数1,$msg参数2,$strlen参数3)
    作用:把数据写入套接字中
    返回值:成功返回字符串的字节长度,失败为false
    参数1:socket_create或者socket_accept的函数返回值
    参数2:字符串
    参数3:字符串的长度

    关键函数8:
    socket_close($socket)
    作用:关闭套接字
    返回值:成功返回true,失败为false
   参数:socket_create或者socket_accept的函数返回值

    socket_last_error($socket),参数为socket_create的返回值,作用是获取套接字的最后一条错误码号,返回值套接字code
    socket_strerror($code),参数为socket_last_error函数的返回值,获取code的字符串信息,返回值也就是套接字的错误信息。

转载:https://www.cnblogs.com/WuNaiHuaLuo/p/6107771.html
workman地址

Composer 包建立与上传

Composer 自动加载,最主要的时间里composer.json 文件. 文件内具体的字段解释 ,在官网已经有详细的解释了,附上链接 Composer 文件

自己的一个文件:

 {
  "name": "dang/dang-composer",         #包的名称,它包括供应商名称和项目名称,使用 / 分隔。
  "description": "Hello, Composer!",    #一个包的简短描述。通常这个最长只有一行。
  "type": "library",                    #包的安装类型,默认为 library。
  "require": {                          #必须的软件包列表,除非这些依赖被满足,否则不会完成安装。
    "php": ">=5.4"
  },
  "license": "MIT",                     #包的许可协议,它可以是一个字符串或者字符串数组。
  "authors": [                          #包的作者。这是一个对象数组。
    {
      "name": "dang",
      "email": "dang@hotmail.com"
    }
  ],
  "minimum-stability": "dev",           #这定义了通过稳定性过滤包的默认行为。默认为 stable(稳定)。
  "autoload": {                         #PHP autoloader 的自动加载映射。
    "psr-4": {
      "dang\\": "src/"
    }
  }
}

目录结构:

dang-composer
       -- src
           -- file_name.php
       --composer.json

本地测试包是否正常:

composer.json 文件
 {
    "name": "test/test",
    "description": "The Framework.",
    "keywords": ["framework"],
    "license": "MIT",
    "type": "dev",
    "require": {
        "dang/dang-composer":"*"
    },
    "minimum-stability": "dev",
    "repositories": {
    "local": { #本地包测试,必须
      "type": "path",
      "url": "D:/code/phpstudy/PHPTutorial/WWW/test/dang-composer"#包文件路径
    }
  },
    "prefer-stable": true
}
执行composer install -vvv安装依赖包,安装完成后vendor目录及自己的包文件

打包发布:

   在Github创建项目并提交代码;

   在Packagist输入项目地址提交包(点击submit,根据提示进行操作,如果没有账号,需要注册账号.);

   在Github配置项目,触发Packagist自动更新

自动更新的步骤:

QQ图片20180912183452.png

点击add service ,选择 packagist.
然后填写信息的时候会有一个Token让写,这个token来至Packagist网站写用户中心,有一个获取按钮,点击获取就可.

QQ图片20180912183733.png

PHP 超时和http状态处理

首先是PHP的mysql的链接方式:

PHP与MySQL的连接有三种API接口,分别是:PHP的MySQL扩展 、PHP的mysqli扩展 、PHP数据对象(PDO) ,下面针对以上三种连接方式做下总结,以备在不同场景下选出最优方案。

PHP的MySQL扩展是设计开发允许php应用与MySQL数据库交互的早期扩展。MySQL扩展提供了一个面向过程的接口,并且是针对MySQL4.1.3或者更早版本设计的。因此这个扩展虽然可以与MySQL4.1.3或更新的数据库服务端进行交互,但并不支持后期MySQL服务端提供的一些特性。由于太古老,又不安全,所以已被后来的mysqli完全取代;

PHP的mysqli扩展,我们有时称之为MySQL增强扩展,可以用于使用 MySQL4.1.3或更新版本中新的高级特性。其特点为:面向对象接口 、prepared语句支持、多语句执行支持、事务支持 、增强的调试能力、嵌入式服务支持 、预处理方式完全解决了sql注入的问题。不过其也有缺点,就是只支持mysql数据库。如果你要是不操作其他的数据库,这无疑是最好的选择。

PDO是PHP Data Objects的缩写,是PHP应用中的一个数据库抽象层规范。PDO提供了一个统一的API接口可以使得你的PHP应用不去关心具体要连接的数据库服务器系统类型,也就是说,如果你使用PDO的API,可以在任何需要的时候无缝切换数据库服务器,比如从Oracle 到MySQL,仅仅需要修改很少的PHP代码。其功能类似于JDBC、ODBC、DBI之类接口。同样,其也解决了sql注入问题,有很好的安全性。不过他也有缺点,某些多语句执行查询不支持(不过该情况很少)。

官文对于三者之间也做了列表性的比较:
20180815163422.jpg

PDO设置超时和持久化链接的方法:

    PDO::ATTR_CASE              => PDO::CASE_NATURAL, //大小写
    PDO::ATTR_ERRMODE           => PDO::ERRMODE_EXCEPTION,//错误处理
    PDO::ATTR_ORACLE_NULLS      => PDO::NULL_NATURAL,//空转换为mysql的 null
    PDO::ATTR_STRINGIFY_FETCHES => false, //字符类型转换
    PDO::ATTR_EMULATE_PREPARES  => false,
    PDO::ATTR_TIMEOUT => 30,//链接超时时间
    PDO::ATTR_PERSISTENT => true //持久化链接

查询mysql设置的各种超时参数:show global variables like “%timeout%”;
PHP高版本对mysql扩展操作php已经不在进行维护,会出现各种问题,链接阻塞等.


PHP的fast-cgi配置:

p

m = dynamic #对于专用服务器,pm可以设置为static。 #如何控制子进程,选项有static和dynamic。如果选择static,则由pm.max_children指定固定的子进程数。
如果选择dynamic,则由下开参数决定: 
pm.max_children #,子进程最大数 
pm.start_servers #,启动时的进程数 
pm.min_spare_servers #,保证空闲进程数最小值,如果空闲进程小于此值,则创建新的子进程               pm.max_spare_servers #,保证空闲进程数最大值,如果空闲进程大于此值,此进行清理 
pm.max_requests = 1000 #设置每个子进程重生之前服务的请求数. 对于可能存在内存泄漏的第三方模块来说是非常有用的. 如果设置为 ’0′ 则一直接受请求. 等同于 PHP_FCGI_MAX_REQUESTS 环境变量. 默认值: 0. 

下面4个参数的意思分别为: 
pm.max_children:静态方式下开启的php-fpm进程数量 
pm.start_servers:动态方式下的起始php-fpm进程数量 
pm.min_spare_servers:动态方式下的最小php-fpm进程数 
pm.max_spare_servers:动态方式下的最大php-fpm进程数量 
区别: 
如果dm设置为 static,那么其实只有pm.max_children这个参数生效。系统会开启设置数量的php-fpm进程。
如果dm设置为 dynamic,那么pm.max_children参数失效,后面3个参数生效。 
系统会在php-fpm运行开始 的时候启动pm.start_servers个php-fpm进程, 然后根据系统的需求动态在pm.min_spare_servers和pm.max_spare_servers之间调整php-fpm进程数 

根据自己的服务器进行进程优化,启动个数不宜太大或者太小.

php + nginx 做反向代理设置:

fastcgi_connct_timeout 60

Nginx和fastcgi进程建立连接的超时时间,默认60秒,如果超过了这个时间就断开连接。

fastcgi_read_timeout 300

和fastcgi进程建立连接后获得fastcgi进程响应的超时时间,默认60秒,如果超过了这个时间都没有获得响应就断开连接。我们经常碰到的是'504 Gateway Time-out',就是因为后端连接没有在超时时间内返回数据导致的。我们经常碰到的是'502 Bad Gateway',是因为fastcig进程报错,导致连接断开。

fastcgi_send_timeout 300

Nginx向fastcgi进程发送请求的超时时间,默认60秒,如果超过了这个时间都没有发送完就断开连接。可以通过上传比较大的文件,就会出现超时,然后就会返回'504 Gateway Time-out'。

php之 curl :

curl_setopt($ch,opt)可以设置一些超时的设置
主要包括: *(重要)CURLOPT_TIMEOUT设置cURL允许执行的最长秒数。 
          *(重要)CURLOPT_TIMEOUT_MS设置cURL允许执行的最长毫秒数。(在cURL7.16.2中被加入。从PHP5.2.3起可使用。) 
          CURLOPT_CONNECTTIMEOUT在发起连接前等待的时间,如果设置为0,则无限等待。 
          CURLOPT_CONNECTTIMEOUT_MS尝试连接等待的时间,以毫秒为单位。如果设置为0,则无限等待。在cURL7.16.2中被加入。从PHP5.2.3开始可用。 
          CURLOPT_DNS_CACHE_TIMEOUT设置在内存中保存DNS信息的时间,默认为120秒。 

php 流:
那么如何设置超时呢,PHP 流机制可以通过 default_socket_timeout 指令来配置。
流是 PHP 中很重要的一个特性,以后可以说一说,简单的理解就是在 PHP 中,不管是读取磁盘文件、HTTP 接口,都可以认为是一种流(socket/stream)。

说明下, socket/stream 的等待时间是不包括在 PHP 最大执行时间内的。
比如说在 PHP.ini 中 配置 max_execution_time = 30,max_execution_time = 20,那么这个 PHP 程序最大处理执行时间是 50 秒。

现在重点来了,原来自己认为超时时间假如为 m 秒,那么访问接口最终响应(包括网络传输时间)超过 m 秒,调用程序就会报错。实际并不是这样,只要在 m 秒数据包一直在传输,那么调用程序就不会报错。