phplambda

‘壹’ 如何将where条件的lambda表达式 转成 sql where语句

你的服务器上有Sudo用户 ：您可以按照创建使用sudo权限的用户CentOS 7初始服务器设置指南 。
LAMP环境 ：ownCloud需要Web服务器，数据库和php才能正常工作。 设置LAMP（Linux，Apache，MySQL和PHP）服务器满足所有这些要求。 按照本指南安装和配置这个软件。
要充分利用一切ownCloud所提供的功能，请确保安装以下PHP模块： php-gd ， php-intl ， php-mbstring ， php-process ，和php-xml 。

‘贰’ 用php求0—7所能组成的奇数个数，每一步最好写个注释，谢谢

求0-7所能组成的奇数个数

fromitertoolsimportproct

count=len(filter(lambdax:x%2,range(8)))
foriinrange(2,9):
forjinproct(range(8),repeat=i):
ifj[0]>0andj[-1]%2:
count+=1

printcount

‘叁’ python与php的异同，和各自的优缺点

相同点: 都是动态类型的解释型高级脚本语言。

不同点既各自优缺点：
PHP名称的含义是“超文本预处理器”。
仅则一个名称就说明了PHP的着重点，也是长处
1、文本处理。text，意味擅长所有的文本处理
2、超文本处理，HyperText，意味尤其擅长HTML超文本标记语言的文本处理。
3、超文本预处理，HyperText Preprocessor,一个“预”字，意味擅长HTTP超文本传输协议之上的服务端上的所有应用的处理。
也就是说,PHP有个互联网专门化的方向，现在专门化也是所有行业的趋势。

Python比较通用，就是什么都能干一点。能做WEB相关的但没有php那么专门化和无微不至。
语法简洁，由于为了通用，python的数据结构工具也比较轻量级一点，实现复杂算法的资源开销比PHP稍低，裸运行的速度也比php稍快。但在网络应用上，这点速度差距在网络IO面前都可以忽略不计。 python作为通用脚本，也广泛被嵌入/捆绑入一些3D工具、绘图工具、数学工具、游戏中作为高级流程部分的描述。

语法方面，PHP的语法属于C系，继承了C++和java的很多历史优点。
Python的语法，吸收了一些现代语言元素，比如靠缩进决定层次、lambda表达式，数列产生器，一级函数对象。

2个都值得学习掌握！

‘肆’ PHP版本问题：我现在还可以用PHP5以前的版本做网站开发么（还没开始学PHP）

建议不要用以前版本了，假如用以前的PHP，还要配早期的MYSQL、APACHE等，有些功能会实现不了，比如Zend Framework，而且好多函数已经不能用了，全局变量也变了，何必学一些已经过时的东西呢

‘伍’ Python与php比起来有什么优势

Python是通用目的的编程语言，它的使用面积非常广泛，不仅仅可以做网络编程，还可以做很多其他应用，可以应用于图像处理上，工程计算和科学分析上;由于能够快速构建原型系统而闻名于世。
Python比PHP好在哪里?
1、Python是通用型的编程语言，属于全才，PHP则比较局限性，主要针对Web开发;
2、Python是面向对象的语言，而PHP从PHP5.0才有了面向对象的支持;
3、Python有强大的扩展库;
4、Python的网络架构比PHP要好;
5、Python的可读性比PHP强;
6、Python的调试工具更简单、更好用;
7、Python的模块管理更好;
8、Python支持事件导向型的编程设计;
9、Python支持lambda，这点要强于PHP;
总体来讲，Python是一门非常高级的编程语言，语法清晰、简单易懂、容易入门，零基础的首选。

‘陆’ aws lambda 支持php吗

1.AWS Lambda 代码的版本控制与其他所有应用程序的都是一样的。AWSLambda控制台的快速JavaScript函数编程方式是广受程序员青睐的文本编辑器或行内编辑器，这一点是颇具吸引力的。当然，当用户通过函数版本进行应用概念测试以及迭代运行时，这个脚本程序就可以在开发环境中正常运行。但是，它并不适于部署生产代码。管理人员应当拥有函数和部署包的版本控制副本，当用户希望使用这些副本来包括附属库时，尤是如此。
2.AWS Lambda在条件许可的情况下，应再次使用身份验证和访问管理策略。AWS Lambda 的函数需要调用和执行角色；而其执行角色需要一个访问和信任的策略。访问策略会授予用户操作资源的权限——即，从简单存储服务（S3）bucket中进行读或写操作的权利。执行策略会指定由谁来承担相关角色。再次使用之前在其它程序中已设定并使用的访问策略是合乎逻辑的。但是，这里要特别注意过度特权。如果你的函数只需要从S3 bucket中读取数据，那么也就无须向其赋予写操作权限的访问策略。尽管AWS Lambda函数是很小，但是管理人员仍然需要考虑其安全性的最佳实践，例如最小特权原则。
3.删除不再需要的AWS Lambda函数。通过使用版本控制代码，管理人员可以从其中的版本中恢复过来。当用户的函数完成运行时，请不要忘记调用context.done()函数。如果用户没有调用这个函数，那么用户的函数将继续运行并随之产生额外的费用。
4.监控AWS Lambda 函数的调用和执行。通过使用CloudWatch，管理人员能够跟踪请求时间段、请求计数以及执行错误计数。他们还可以通过AWS的管理控制台、CloudWatch或者AWS命令行来查看 Lambda CloudWatch的参数指标。CloudWatch还可以帮助进行代码调试——在函数中插入记录语句、运行函数以及之后在CloudWatch日志文件中查看程序的运行结果。[1]

出现背景
编辑
AWS Lambda首次亮相的新进展是Alexa Skill Kit API，该API可以做到开发者在Echo beta程序中能够鼓捣的一切。Echo采集语音识别并拥有一个非常自然的文本到语音的转换程序。但它并不是完美的，它缺乏一些最终用户可能想要的基本任务。
ASK API让开发人员可以编写软件响应用户在Echo上的输入并将结果以语音的方式输出给用户。使用ASK，开发者需要一个Echo的API来调用函数，但是他们也可以使用AWS Lambda。那意味着如果该软件没有被使用，那就没有开销。[2]

服务功能
编辑

使用MySQL、Lambda和浏览器应用程序
如果开发人员正在使用Lambda 服务、AWS SDK以及Java脚本程序来开发无服务器的网络应用程序，使用DynamoDB作为后端数据库，那么就不应该有任何问题。但是，为了使用一个诸如MySQL或Amazon Aurora这样的关系型数据库，可创建一个桥型应用程序或者打开RDS MySQL实例。这可以打开MySQL，一个用于实现零日漏洞的臭名昭着目标以防进一步的攻击。一般情况下，在一个开发端口上运行MySQL实例是一个糟糕的安全措施。
但是，运行Lambda服务是一个伟大的方法，它去除了一个后端，用户就不需要编写验证MySQL的中间层，并为在Lambda外进行访问提供了一个安全的方法。幸运的是，将Lambda功能置于VPC中可让开发人员配置安全组并确保MySQL集群只使用特定Lambda功能。此举可显着减少曝光并确保MySQL实例得到合适保护。
确保只有授权用户能够访问Lambda功能仍然是非常重要的，但是很幸运使用亚马逊Cognito和IAM角色可以很容易地确保其安全性。

针对Lambda功能的调度功能
另一项改善就是提供了调度AWS Lambda功能的能力。这使得开发人员能够定期允许后台任务以取代使用任务实例或诸如Cloud Cron之类的工具来运行脚本程序。Lambda服务还增加了它的最长运行时间至五分钟。
例如，如果一家公司需要定期从博客网站读取RSS订阅，那么他们就可以在AWS Lambda中通过触发一个自动调度功能来排队读取博客列表中的所有待读取订阅内容，从而实现这一功能。该公司就可以安排主机功能每隔若干个小时从DynamoDB读取数据，然后针对每一个博客触发Lambda函数读取订阅。
由于目前Lambda对设置了100个并发函数调用的限制，该公司就需要首先对这些调用进行排队处理。但是一旦AWS取消了这一限制，那么用户就可以通过主机调度函数触发这些调用。

支持Python
AWS Lambda目前支持Python，如果你正在现有环境中使用Python，那么这一点是非常重要的。但是，这也暗示AWS将在未来增加对额外编程语言的支持——甚至可能是对Docker的支持

‘柒’ 什么是lambda表达式

lambda表达式，也可称为closure（闭包），通常是在需要一个函数，但又不想费神去命名一个函数的场合下使用，也就是指匿名函数。由于其几乎被所有主流开发语言支持。
是java8新引入的一种语法，是一种紧凑的传递代码的方式。

使用lambda表达式可以使代码变的更加简洁紧凑。

lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

以下是lambda表达式的重要特征:
可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

PHP 5.3

PHP5.3增加了Lambda的支持，对于接受回调函数的PHP函数来说，lambda表达式非常方便。比如使用array_map函数遍历数组，并将回调结果重新赋值给数字各元素。

Javascript

javascript中的lambda表达式通常称为匿名函数，如果你使用过jquery库，那么你肯定知道匿名函数，这里主要作为回调函数使用。

‘捌’ php怎么实例化有依赖注入的类

PHP依赖注入的理解。分享给大家供大家参考，具体如下：
看Laravel的IoC容器文档只是介绍实例，但是没有说原理，之前用MVC框架都没有在意这个概念，无意中在phalcon的文档中看到这个详细的介绍，感觉豁然开朗，复制粘贴过来，主要是好久没有写东西了，现在确实很懒变得！
首先，我们假设，我们要开发一个组件命名为SomeComponent。这个组件中现在将要注入一个数据库连接。
在这个例子中，数据库连接在component中被创建，这种方法是不切实际的，这样做的话，我们将不能改变数据库连接参数及数据库类型等一些参数。
class SomeComponent {
/**
* The instantiation of the connection is hardcoded inside
* the component so is difficult to replace it externally
* or change its behavior
*/
public function someDbTask()
{
$connection = new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
// ...
}
}
$some = new SomeComponent();
$some->someDbTask();
为了解决上面所说的问题，我们需要在使用前创建一个外部连接，并注入到容器中。就目前而言，这看起来是一个很好的解决方案：
class SomeComponent {
protected $_connection;
/**
* Sets the connection externally
*/
public function setConnection($connection)
{
$this->_connection = $connection;
}
public function someDbTask()
{
$connection = $this->_connection;
// ...
}
}
$some = new SomeComponent();
//Create the connection
$connection = new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
//Inject the connection in the component
$some->setConnection($connection);
$some->someDbTask();
现在我们来考虑一个问题，我们在应用程序中的不同地方使用此组件，将多次创建数据库连接。使用一种类似全局注册表的方式，从这获得一个数据库连接实例，而不是使用一次就创建一次。
class Registry
{
/**
* Returns the connection
*/
public static function getConnection()
{
return new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
}
}
class SomeComponent
{
protected $_connection;
/**
* Sets the connection externally
*/
public function setConnection($connection){
$this->_connection = $connection;
}
public function someDbTask()
{
$connection = $this->_connection;
// ...
}
}
$some = new SomeComponent();
//Pass the connection defined in the registry
$some->setConnection(Registry::getConnection());
$some->someDbTask();
现在，让我们来想象一下，我们必须在组件中实现两个方法，首先需要创建一个新的数据库连接，第二个总是获得一个共享连接：
class Registry
{
protected static $_connection;
/**
* Creates a connection
*/
protected static function _createConnection()
{
return new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
}
/**
* Creates a connection only once and returns it
*/
public static function getSharedConnection()
{
if (self::$_connection===null){
$connection = self::_createConnection();
self::$_connection = $connection;
}
return self::$_connection;
}
/**
* Always returns a new connection
*/
public static function getNewConnection()
{
return self::_createConnection();
}
}
class SomeComponent
{
protected $_connection;
/**
* Sets the connection externally
*/
public function setConnection($connection){
$this->_connection = $connection;
}
/**
* This method always needs the shared connection
*/
public function someDbTask()
{
$connection = $this->_connection;
// ...
}
/**
* This method always needs a new connection
*/
public function someOtherDbTask($connection)
{
}
}
$some = new SomeComponent();
//This injects the shared connection
$some->setConnection(Registry::getSharedConnection());
$some->someDbTask();
//Here, we always pass a new connection as parameter
$some->someOtherDbTask(Registry::getConnection());
到此为止，我们已经看到了如何使用依赖注入解决我们的问题。不是在代码内部创建依赖关系，而是让其作为一个参数传递，这使得我们的程序更容易维护，降低程序代码的耦合度，实现一种松耦合。但是从长远来看，这种形式的依赖注入也有一些缺点。
例如，如果组件中有较多的依赖关系，我们需要创建多个setter方法传递，或创建构造函数进行传递。另外，每次使用组件时，都需要创建依赖组件，使代码维护不太易，我们编写的代码可能像这样：
//Create the dependencies or retrieve them from the registry
$connection = new Connection();
$session = new Session();
$fileSystem = new FileSystem();
$filter = new Filter();
$selector = new Selector();
//Pass them as constructor parameters
$some = new SomeComponent($connection, $session, $fileSystem, $filter, $selector);
// ... or using setters
$some->setConnection($connection);
$some->setSession($session);
$some->setFileSystem($fileSystem);
$some->setFilter($filter);
$some->setSelector($selector);
我想，我们不得不在应用程序的许多地方创建这个对象。如果你不需要依赖的组件后，我们又要去代码注入部分移除构造函数中的参数或者是setter方法。为了解决这个问题，我们再次返回去使用一个全局注册表来创建组件。但是，在创建对象之前，它增加了一个新的抽象层：
class SomeComponent
{
// ...
/**
* Define a factory method to create SomeComponent instances injecting its dependencies
*/
public static function factory()
{
$connection = new Connection();
$session = new Session();
$fileSystem = new FileSystem();
$filter = new Filter();
$selector = new Selector();
return new self($connection, $session, $fileSystem, $filter, $selector);
}
}
这一刻，我们好像回到了问题的开始，我们正在创建组件内部的依赖，我们每次都在修改以及找寻一种解决问题的办法，但这都不是很好的做法。
一种实用和优雅的来解决这些问题，是使用容器的依赖注入，像我们在前面看到的，容器作为全局注册表，使用容器的依赖注入做为一种桥梁来解决依赖可以使我们的代码耦合度更低，很好的降低了组件的复杂性：
class SomeComponent
{
protected $_di;
public function __construct($di)
{
$this->_di = $di;
}
public function someDbTask()
{
// Get the connection service
// Always returns a new connection
$connection = $this->_di->get('db');
}
public function someOtherDbTask()
{
// Get a shared connection service,
// this will return the same connection everytime
$connection = $this->_di->getShared('db');
//This method also requires a input filtering service
$filter = $this->_db->get('filter');
}
}
$di = new Phalcon\DI();
//Register a "db" service in the container
$di->set('db', function(){
return new Connection(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "invo"
));
});
//Register a "filter" service in the container
$di->set('filter', function(){
return new Filter();
});
//Register a "session" service in the container
$di->set('session', function(){
return new Session();
});
//Pass the service container as unique parameter
$some = new SomeComponent($di);
$some->someTask();
现在，该组件只有访问某种service的时候才需要它，如果它不需要，它甚至不初始化，以节约资源。该组件是高度解耦。他们的行为，或者说他们的任何其他方面都不会影响到组件本身。我们的实现办法
Phalcon\DI 是一个实现了服务的依赖注入功能的组件，它本身也是一个容器。
由于Phalcon高度解耦，Phalcon\DI 是框架用来集成其他组件的必不可少的部分，开发人员也可以使用这个组件依赖注入和管理应用程序中不同类文件的实例。
基本上，这个组件实现了 Inversion of Control 模式。基于此，对象不再以构造函数接收参数或者使用setter的方式来实现注入，而是直接请求服务的依赖注入。这就大大降低了整体程序的复杂性，因为只有一个方法用以获得所需要的一个组件的依赖关系。
此外，这种模式增强了代码的可测试性，从而使它不容易出错。
在容器中注册服务
框架本身或开发人员都可以注册服务。当一个组件A要求调用组件B（或它的类的一个实例），可以从容器中请求调用组件B，而不是创建组件B的一个实例。
这种工作方式为我们提供了许多优点：
我们可以更换一个组件，从他们本身或者第三方轻松创建。
在组件发布之前，我们可以充分的控制对象的初始化，并对对象进行各种设置。
我们可以使用统一的方式从组件得到一个结构化的全局实例
服务可以通过以下几种方式注入到容器：
//Create the Dependency Injector Container
$di = new Phalcon\DI();
//By its class name
$di->set("request", 'Phalcon\Http\Request');
//Using an anonymous function, the instance will lazy loaded
$di->set("request", function(){
return new Phalcon\Http\Request();
});
//Registering directly an instance
$di->set("request", new Phalcon\Http\Request());
//Using an array definition
$di->set("request", array(
"className" => 'Phalcon\Http\Request'
));
在上面的例子中，当向框架请求访问一个请求数据时，它将首先确定容器中是否存在这个”reqeust”名称的服务。
容器会反回一个请求数据的实例，开发人员最终得到他们想要的组件。
在上面示例中的每一种方法都有优缺点，具体使用哪一种，由开发过程中的特定场景来决定的。
用一个字符串来设定一个服务非常简单，但缺少灵活性。设置服务时，使用数组则提供了更多的灵活性，而且可以使用较复杂的代码。lambda函数是两者之间一个很好的平衡，但也可能导致更多的维护管理成本。
Phalcon\DI 提供服务的延迟加载。除非开发人员在注入服务的时候直接实例化一个对象，然后存存储到容器中。在容器中，通过数组，字符串等方式存储的服务都将被延迟加载，即只有在请求对象的时候才被初始化。
//Register a service "db" with a class name and its parameters
$di->set("db", array(
"className" => "Phalcon\Db\Adapter\Pdo\Mysql",
"parameters" => array(
"parameter" => array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "blog"
)
)
));
//Using an anonymous function
$di->set("db", function(){
return new Phalcon\Db\Adapter\Pdo\Mysql(array(
"host" => "localhost",
"username" => "root",
"password" => "secret",
"dbname" => "blog"
));
});
以上这两种服务的注册方式产生相同的结果。然后，通过数组定义的，在后面需要的时候，你可以修改服务参数：
$di->setParameter("db", 0, array(
"host" => "localhost",
"username" => "root",
"password" => "secret"
));
从容器中获得服务的最简单方式就是使用”get”方法，它将从容器中返回一个新的实例：
$request = $di->get("request");
或者通过下面这种魔术方法的形式调用：
$request = $di->getRequest();
Phalcon\DI 同时允许服务重用，为了得到一个已经实例化过的服务，可以使用 getShared() 方法的形式来获得服务。
具体的 Phalcon\Http\Request 请求示例：
$request = $di->getShared("request");
参数还可以在请求的时候通过将一个数组参数传递给构造函数的方式：
$component = $di->get("MyComponent", array("some-parameter", "other"));

‘玖’ this.Load += (sender, e) =>{}在php中是什么意思

php？你写错了吧？这个是C#的lambda语法
this.Load += (sender, e) =>{}
这个写法类似于：

void aaa(Object sender, EventArgs e){
// 没有代码的空方法
}

this.Load += aaa;

‘拾’ Python语言真的会取代php语言么这俩种语言竞争优劣，大家谈谈呗~~~~

python和PHP都是动态语言，属于脚本类语言。两种语言都是以易于使用为特点，不过python的特征比PHP丰富，有较强的OOP支持，而且支持lambda语法。

从语言上来说，PHP就表现得较为落后，没有先进的特征，OOP特征支持很弱。所以说python会取代PHP也有道理的。

不过PHP目前还是拥有相当大的开源资源，例如最佳开源CMS drupal就是基于PHP的。而python在WEB上的资源并没有PHP的丰富。所以说取代也不是短时间能做到的。