Quantcast
Channel: 技术杂谈 –静觅
Viewing all 277 articles
Browse latest View live

微信公众号文章爬取之:微信自动化

0
0

本文转载自:陈文管的博客-微信公众号文章爬取之:微信自动化

本文内容详细介绍微信公众号历史文章自动化浏览脚本的实现,配合服务端对公众号文章数据爬取来实现微信公众号文章数据的采集。服务端爬取实现见:微信公众号文章爬取之:服务端数据采集

背景:在团队的学习方面需要每周收集开发方面的博客文章,汇总输出每周的技术周报。周报小组成员收集的文章大多数是来自微信公众号,公众号的内容相对网页博客内容质量还是比较高的。既然数据的来源是确定的,收集汇总的流程是确定的,那么就把这个流程自动化,把人工成本降低到0。

一、方案选取

1、数据源选取

主要是爬取的数据来源选取,网上资料看的较多是爬取搜狗微信的内容,但是第三方平台(包括新榜、清博等 )的公众号文章数据更新做不到实时,而且数据也不全,还要和各种反爬措施斗智斗勇,浪费时间精力的事情划不来。最直接的方式当然是直接爬取微信公众号历史文章里面的内容。

在前期预研主要参考的资料是知乎专栏:微信公众号内容的批量采集与应用 

上面的方案是借助阿里巴巴开源的AnyProxy工具,AnyProxy作为一个中间人在微信客户端和服务器之间的交互过程中做数据截获和转发。获取到公众号文章的实际链接地址之后转发到自己的服务器进行保存,整个数据采集的自动化程度较大取决于微信客户端的自动化浏览实现。

2、自动化方案选取

如果是比较简单的安卓应用自动化操作的实现,一般直接使用AccessibilityService就行,UIAutomator也是基于AccessibilityService来实现的,但是AccessibilityService不支持WebView的操作,因为微信公众号历史文章页面是用WebView来加载的,要实现自动化必须同时支持安卓原生和WebView两个上下文环境的操作。

经过现有的几个自动化方案实现对比,最便利又具备极佳扩展性的方案就是使用Appium

  •     Appium是开源的移动端自动化测试框架;
  •     支持Native App、Hybird App、Web App;
  •     支持Android、iOS、Firefox OS;
  •     跨平台,可以在Mac,Windows以及Linux系统上;
  •     用Appium自动化测试不需要重新编译App;
  •     支持Java、python、ruby、C#、Objective C、PHP等主流语言;

更多资料参考:Android自动化测试框架

公众号文章爬取系统架构图
公众号文章爬取系统架构图

二、Appium安装配置(Mac)

Appium程序的安装,我这边不是使用brew命令安装的方式,直接从BitBucket下载Appium安装包,也可以从Github上下载。这边使用BitBucket 1.5.3版本。

Appium1.5.0之后的版本,需要在终端安装doctor,在终端输入命令:npm install -g appium-doctor,安装完毕之后,在终端输入命令:appium-doctor,查看所需的各个配置是否都已经安装配置完毕。下面是我这边在终端输出得到的结果:

info AppiumDoctor Appium Doctor v.1.4.3
info AppiumDoctor ### Diagnostic starting ###
info AppiumDoctor  ✔ The Node.js binary was found at: /Users/chenwenguan/.nvm/versions/node/v8.9.3/bin/node
info AppiumDoctor  ✔ Node version is 8.9.3
info AppiumDoctor  ✔ Xcode is installed at: /Library/Developer/CommandLineTools
info AppiumDoctor  ✔ Xcode Command Line Tools are installed.
info AppiumDoctor  ✔ DevToolsSecurity is enabled.
info AppiumDoctor  ✔ The Authorization DB is set up properly.
WARN AppiumDoctor  ✖ Carthage was NOT found!
info AppiumDoctor  ✔ HOME is set to: /Users/chenwenguan
WARN AppiumDoctor  ✖ ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ JAVA_HOME is NOT set!
WARN AppiumDoctor  ✖ adb could not be found because ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ android could not be found because ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ emulator could not be found because ANDROID_HOME is NOT set!
WARN AppiumDoctor  ✖ Bin directory for $JAVA_HOME is not set
info AppiumDoctor ### Diagnostic completed, 7 fixes needed. ###
info AppiumDoctor 
info AppiumDoctor ### Manual Fixes Needed ###
info AppiumDoctor The configuration cannot be automatically fixed, please do the following first:
WARN AppiumDoctor - Please install Carthage. Visit https://github.com/Carthage/Carthage#installing-carthage for more information.
WARN AppiumDoctor - Manually configure ANDROID_HOME.
WARN AppiumDoctor - Manually configure JAVA_HOME.
WARN AppiumDoctor - Manually configure ANDROID_HOME and run appium-doctor again.
WARN AppiumDoctor - Add '$JAVA_HOME/bin' to your PATH environment
info AppiumDoctor ###
info AppiumDoctor 
info AppiumDoctor Bye! Run appium-doctor again when all manual fixes have been applied!
info AppiumDoctor 

上面打叉的都是没配置好的,在终端输入命令安装Carthage :brew install carthage

输入命令查看JDK安装路径:/usr/libexec/java_home -V

1.8.0_60, x86_64: "Java SE 8" /Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home
/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home

需要把上面的路径配置到环境变量中,ANDROID_HOME就是Android SDK的安装路径。

输入命令打开配置文件: open ~/.bash_profile,在文件中添加如下内容:

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home  
export PATH=$JAVA_HOME/bin:$PATH  
export ANDROID_HOME=/Users/chenwenguan/Library/Android/sdk 

输入命令让配置立即生效:source ~/.bash_profile

更多安装配置资料可参考:Mac上搭建Appium环境过程以及遇到的问题

TIPS

在首次使用Appium时可能会出现一个错误:

Could not detect Mac OS X Version from sw_vers output: '10.13.2

在终端输入命令:

grep -rl "Could not detect Mac OS X Version from sw_vers output" /Applications/Appium.app/

得到如下结果:

/Applications/Appium.app//Contents/Resources/node_modules/appium-support/lib/system.js
/Applications/Appium.app//Contents/Resources/node_modules/appium-support/build/lib/system.js
/Applications/Appium.app//Contents/Resources/node_modules/appium/node_modules/appium-support/lib/system.js
/Applications/Appium.app//Contents/Resources/node_modules/appium/node_modules/appium-support/build/lib/system.js

打开上面四个路径下的文件,添加当前的Appium版本参数,具体内容可参考:在Mac OS 10.12 上安装配置appium

三、具体代码实现

预研资料主要参考这篇博文:Appium 微信 webview 的自动化技术

自动化实现的原理就是通过ID或者模糊匹配找到相应的控件,之后对这个控件做点击、滑动等操作。如果要对微信WebView做自动化,必须能够获取到WebView里面的对象,如果是Android原生的控件可以通过AndroidStudio里面的Android Device Monitor来查看控件的id、类名等各种属性。

1、Android原生控件属性参数值的获取

在AndroidStudio打开Monitor工具:Tools->Android->Android Device Monitor

按照下图的步骤查看控件的ID等属性,后续在代码实现中会用到。

Android Device Monitor
Android Device Monitor

2、WebView属性参数值的获取

如果是在安卓真机上,需要打开WebView的调试模式才能读取到WebView的各个属性,在微信里面可以在任意聊天窗口输入debugx5.qq.com,这是微信x5内核调试页面,在信息模块中勾选打开TBS内核Inspector调试功能。

微信X5内核调试页面
微信X5内核调试页面

之后还要在真机上安装Chrome浏览器,如果是在虚拟机上无需做此操作。

接下来在Chrome浏览器中输入:chrome://inspect ,我这边使用的是虚拟机,真机上也一样,进入到公众号历史文章页面,这边就会显示相应可检视的WebView页面,点击inspect,进入到Developer Tools页面。

chrome inspect页面
chrome inspect页面

如果进入到Developer Tools页面显示一片空白,是因为chrome inspect需要加载 https://chrome-devtools-frontend.appspot.com 上的资源,所以需要翻墙,把appstop.com 加入翻墙代理白名单,或者直接全局应用翻墙VPN,具体可参考:使用chrome remote debug时打开inspect时出现一片空白

下面是美团技术团队历史文章列表的详细结构信息,具体的文章列表项在weui-panel->weui-panel__bd appmsg_history_container->js_profile_history_container->weui_msg_card_list路径下。

Chrome inspect查看WebView详细内容
Chrome inspect查看WebView详细内容

继续展开节点查看文章详细结构信息,这边可以看到每篇文章的ID都是以“WXAPPMSG100″开头的,类名都是“weui_media_box”开头,一开始的实现是通过模糊匹配ID来查找历史文章列表项数据,但在测试过程中出现来一个异常,后来发现,如果是纯文本类型的文章,也就是只有一段话的文章,它是没有ID的,所以不能通过ID来模糊匹配。

公众号历史文章列表项详细结构
公众号历史文章列表项详细结构

之后就把现有的四种公众号文章类型都找来出来,找它们的共性,虽然ID不一定有,但是class类型值一定有,四种类型值如下,这样就可以通过class类型值来匹配查找数据了。

* weui_media_box appmsg js_appmsg : 文章
 * weui_media_box text js_appmsg : 文本
 * weui_media_box img js_appmsg : 图片
* weui_media_box appmsg audio_msg_primary js_appmsg playing : 语音

3、具体代码实现

整体自动化是按照如下顺序:通讯录页面->点击公众号进入公众号列表页面->公众号列表项选择一个点击->公众号页面->公众号消息页面->点击“全部消息”进入公众号历史文章页面->根据设置的时间类型(一周之内、一个月之内、一年之内或者全部)逐个点击历史文章列表项,完毕之后返回公众号列表页面,继续下一个公众号浏览的操作;

1)初始化

private static AndroidDriver getDriver() throws MalformedURLException {
        DesiredCapabilities capability = new DesiredCapabilities();
         capability.setCapability("platformName", "emulator-5554");
         capability.setCapability("platformVersion", "4.4.4");
         capability.setCapability("deviceName", "MuMu");
         /**
          * 真机上platformName使用"Android"
          */
         /*
         capability.setCapability("platformName", "Android");
         capability.setCapability("platformVersion", "6.0");
         capability.setCapability("deviceName", "FRD-AL00");
         */
         capability.setCapability("unicodeKeyboard","True");
         capability.setCapability("resetKeyboard","True");
         capability.setCapability("app", "");
         capability.setCapability("appPackage", "com.tencent.mm");
         capability.setCapability("appActivity", ".ui.LauncherUI");
         capability.setCapability("fastReset", false);
         capability.setCapability("fullReset", false);
         capability.setCapability("noReset", true);
         capability.setCapability("newCommandTimeout", 2000);
         /**
          * 必须加这句,否则webView和native来回切换会有问题
          */
         capability.setCapability("recreateChromeDriverSessions", true);
         /**
          * 关键是加上这段
          */
         ChromeOptions options = new ChromeOptions();
         options.setExperimentalOption("androidProcess", "com.tencent.mm:tools");
         capability.setCapability(ChromeOptions.CAPABILITY, options);
         String url = "http://127.0.0.1:4723/wd/hub";
         mDriver = new AndroidDriver<>(new URL(url), capability);
         return mDriver;
     }

如果是虚拟机则platformName使用具体的虚拟机名称,如果是真机使用“Android”,platformVersion和deviceName可以使用工程安装APK之后查看详细信息,对应的参数就是显示的系统版本和设备名称。

设备信息
设备信息

URL参数是在Appium里面设置的,确保”http://127.0.0.1:4723/wd/hub”字符串中的服务器地址和端口与Appium设置一致。

Appium URL参数设置
Appium URL参数设置
2)列表滑动和元素获取

不管是WebView还是Android原生ListView的滑动都需要在Android原生上下文环境下操作driver.context(“NATIVE_APP”); 滑动操作都可以通过如下代码实现,通过滑动前后的PageSource对比可以知道列表是否已经滑动到底部。

     /**
      * 滑动列表加载下一页数据
      *
      * @param driver
      * @return
      * @throws InterruptedException
      */
     private static boolean isScrollToBottom(AndroidDriver driver) throws InterruptedException {
         int width = driver.manage().window().getSize().width;
         int height = driver.manage().window().getSize().height;
         String beforeswipe = driver.getPageSource();
         driver.swipe(width / 2, height * 3 / 4, width / 2, height / 4, 1000);
         /**
          * 设置8s超时,网络较差情况下时间过短加载不出内容
          */
         mDriver.manage().timeouts().implicitlyWait(8000, TimeUnit.MILLISECONDS);
         String afterswipe = driver.getPageSource();
         /**
          * 已经到底部
          */
         if (beforeswipe.equals(afterswipe)) {
             return true;
         }
         return false;
     }

TIPS:

如果是Android原生的ListView读取到的数据是在屏幕上显示的数据,超过屏幕的数据是获取不到的,如果是WebView的列表获取的数据是所有已加载的数据,不管是否在屏幕显示范围内。

获取公众号列表数据逻辑代码如下,”com.tencent.mm:id/a0y”是具体的公众号名称TextView的ID。

List<WebElement> elementList = mDriver.findElementsById("com.tencent.mm:id/a0y");

获取历史文章列表数据逻辑代码如下,div是节点,上面说到公众号四种类型的文章都是以’weui_media_box’类名开头的,通过模糊匹配class类名以’weui_media_box’开始的元素来过滤出所有的公众号文章列表项。

List<WebElement> msgHistory = driver.findElements(By.xpath("//div[starts-with(@class,'weui_media_box')]"));

3)元素定位方式

如果一定需要模糊匹配就使用By.xpath()的方式,因为Android APK应用如果有增加或减少了布局字符串资源或者控件,编译之后生成的ID可能会不一样,这边说的ID是指通过Android Device Monitor查看的布局ID,不是实际的布局代码控件id,布局控件id除非命名改动,否则不会变化。所以不同版本的微信客户端生成的ID很可能会不一样,如果要批量实现自动化最好使用模糊匹配的方式,但By.xpath()方式查找定位元素是遍历页面的所有元素,会比较耗时,也容易出现异常。

在测试过程中执行

driver.findElement(By.xpath("//android.widget.ImageView[@content-desc='返回']")).click();

时候经常出现如下错误,改为

driver.findElementById("com.tencent.mm:id/ht").click();

异常消失,猜测原因就是因为By.xpath()方法查找比较耗时导致。

org.openqa.selenium.WebDriverException: An unknown server-side error occurred while processing the command. (WARNING: The server did not provide any stacktrace information)
 Command duration or timeout: 1.41 seconds
 Build info: version: '2.44.0', revision: '76d78cf', time: '2014-10-23 20:02:37'
 System info: host: 'wenguanchen-MacBook-Pro.local', ip: '30.85.214.6', os.name: 'Mac OS X', os.arch: 'x86_64', os.version: '10.13.2', java.version: '1.8.0_112-release'
 Driver info: io.appium.java_client.android.AndroidDriver
 Capabilities [{appPackage=com.tencent.mm, noReset=true, dontStopAppOnReset=true, deviceName=emulator-5554, fullReset=false, platform=LINUX, deviceUDID=emulator-5554, desired={app=, appPackage=com.tencent.mm, recreateChromeDriverSessions=true, noReset=true, dontStopAppOnReset=true, deviceName=MuMu, fullReset=false, appActivity=.ui.LauncherUI, platformVersion=4.4.4, automationName=Appium, unicodeKeyboard=true, fastReset=false, chromeOptions={args=[], extensions=[], androidProcess=com.tencent.mm:tools}, platformName=Android, resetKeyboard=true}, platformVersion=4.4.4, webStorageEnabled=false, automationName=Appium, takesScreenshot=true, javascriptEnabled=true, unicodeKeyboard=true, platformName=Android, resetKeyboard=true, app=, networkConnectionEnabled=true, recreateChromeDriverSessions=true, warnings={}, databaseEnabled=false, appActivity=.ui.LauncherUI, locationContextEnabled=false, fastReset=false, chromeOptions={args=[], extensions=[], androidProcess=com.tencent.mm:tools}}]
 Session ID: 592813d6-7c6e-4a3c-8183-e5f93d1d3bf0
  at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
  at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
  at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
  at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
  at org.openqa.selenium.remote.ErrorHandler.createThrowable(ErrorHandler.java:204)
  at org.openqa.selenium.remote.ErrorHandler.throwIfResponseFailed(ErrorHandler.java:156)
  at org.openqa.selenium.remote.RemoteWebDriver.execute(RemoteWebDriver.java:599)
  at io.appium.java_client.DefaultGenericMobileDriver.execute(DefaultGenericMobileDriver.java:27)
  at io.appium.java_client.AppiumDriver.execute(AppiumDriver.java:1)
  at io.appium.java_client.android.AndroidDriver.execute(AndroidDriver.java:1)
  at org.openqa.selenium.remote.RemoteWebDriver.findElement(RemoteWebDriver.java:352)
  at org.openqa.selenium.remote.RemoteWebDriver.findElementByXPath(RemoteWebDriver.java:449)
  at io.appium.java_client.DefaultGenericMobileDriver.findElementByXPath(DefaultGenericMobileDriver.java:99)
  at io.appium.java_client.AppiumDriver.findElementByXPath(AppiumDriver.java:1)
  at io.appium.java_client.android.AndroidDriver.findElementByXPath(AndroidDriver.java:1)
  at org.openqa.selenium.By$ByXPath.findElement(By.java:357)
  at org.openqa.selenium.remote.RemoteWebDriver.findElement(RemoteWebDriver.java:344)
  at io.appium.java_client.DefaultGenericMobileDriver.findElement(DefaultGenericMobileDriver.java:37)
  at io.appium.java_client.AppiumDriver.findElement(AppiumDriver.java:1)
  at io.appium.java_client.android.AndroidDriver.findElement(AndroidDriver.java:1)
  at com.example.AppiumAutoScan.getArticleDetail(AppiumAutoScan.java:335)
  at com.example.AppiumAutoScan.launchBrowser(AppiumAutoScan.java:96)
  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  at java.lang.reflect.Method.invoke(Method.java:498)
  at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
  at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
  at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
  at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
  at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
  at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
  at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
  at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
  at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
  at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
  at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
  at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
  at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
  at org.junit.runner.JUnitCore.run(JUnitCore.java:157)
  at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:117)
  at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:42)
  at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:262)
  at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:84)
  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  at java.lang.reflect.Method.invoke(Method.java:498)
  at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)

如果容易出现如下异常,则是因为页面的内容还未加载完毕,可以通过

mDriver.manage().timeouts().implicitlyWait(8000, TimeUnit.MILLISECONDS);

方法设置下超时等待时间,等待页面内容加载完毕,具体超时时间可自己调试看看设置一个合适的值。

org.openqa.selenium.StaleElementReferenceException: stale element reference: element is not attached to the page document
   (Session info: webview=33.0.0.0)
   (Driver info: chromedriver=2.20.353124 (035346203162d32c80f1dce587c8154a1efa0c3b),platform=Mac OS X 10.13.2 x86_64) (WARNING: The server did not provide any stacktrace information)
 Command duration or timeout: 2.41 seconds
 For documentation on this error, please visit: http://seleniumhq.org/exceptions/stale_element_reference.html
 Build info: version: '2.44.0', revision: '76d78cf', time: '2014-10-23 20:02:37'
 System info: host: 'wenguanchen-MacBook-Pro.local', ip: '30.85.214.81', os.name: 'Mac OS X', os.arch: 'x86_64', os.version: '10.13.2', java.version: '1.8.0_112-release'
 Driver info: io.appium.java_client.android.AndroidDriver
 Capabilities [{appPackage=com.tencent.mm, noReset=true, dontStopAppOnReset=true, deviceName=emulator-5554, fullReset=false, platform=LINUX, deviceUDID=emulator-5554, desired={app=, appPackage=com.tencent.mm, recreateChromeDriverSessions=true, noReset=true, dontStopAppOnReset=true, deviceName=MuMu, fullReset=false, appActivity=.ui.LauncherUI, platformVersion=4.4.4, automationName=Appium, unicodeKeyboard=true, fastReset=false, chromeOptions={args=[], extensions=[], androidProcess=com.tencent.mm:tools}, platformName=Android, resetKeyboard=true}, platformVersion=4.4.4, webStorageEnabled=false, automationName=Appium, takesScreenshot=true, javascriptEnabled=true, unicodeKeyboard=true, platformName=Android, resetKeyboard=true, app=, networkConnectionEnabled=true, recreateChromeDriverSessions=true, warnings={}, databaseEnabled=false, appActivity=.ui.LauncherUI, locationContextEnabled=false, fastReset=false, chromeOptions={args=[], extensions=[], androidProcess=com.tencent.mm:tools}}]
 Session ID: b5e933e1-0ddf-421d-9144-e423a7bb25b1
  at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
  at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
  at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
  at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
  at org.openqa.selenium.remote.ErrorHandler.createThrowable(ErrorHandler.java:204)
  at org.openqa.selenium.remote.ErrorHandler.throwIfResponseFailed(ErrorHandler.java:156)
  at org.openqa.selenium.remote.RemoteWebDriver.execute(RemoteWebDriver.java:599)
  at io.appium.java_client.DefaultGenericMobileDriver.execute(DefaultGenericMobileDriver.java:27)
  at io.appium.java_client.AppiumDriver.execute(AppiumDriver.java:1)
  at io.appium.java_client.android.AndroidDriver.execute(AndroidDriver.java:1)
  at org.openqa.selenium.remote.RemoteWebElement.execute(RemoteWebElement.java:268)
  at io.appium.java_client.DefaultGenericMobileElement.execute(DefaultGenericMobileElement.java:27)
  at io.appium.java_client.MobileElement.execute(MobileElement.java:1)
  at io.appium.java_client.android.AndroidElement.execute(AndroidElement.java:1)
  at org.openqa.selenium.remote.RemoteWebElement.getText(RemoteWebElement.java:152)
  at com.example.AppiumAutoScan.getArticleDetail(AppiumAutoScan.java:294)
  at com.example.AppiumAutoScan.launchBrowser(AppiumAutoScan.java:110)
  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  at java.lang.reflect.Method.invoke(Method.java:498)
  at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
  at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
  at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
  at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
  at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
  at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
  at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
  at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
  at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
  at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
  at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
  at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
  at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
  at org.junit.runner.JUnitCore.run(JUnitCore.java:157)
  at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:117)
  at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:42)
  at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:262)
  at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:84)
  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  at java.lang.reflect.Method.invoke(Method.java:498)
  at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)

更多元素定位方法可参考官网:

http://selenium-python.readthedocs.io/locating-elements.html#locating-by-id

4)chromedriver相关问题

在2017年6月微信热更新升级了X5内核之后,真机上切换到WebView上下文环境就出问题了,具体见这篇博文的评论Appium 微信 webview 的自动化技术 和 Appium 微信小程序,driver.context (“WEBVIEW_com.tencent.mm:tools”) 切换 webview 报错 看评论是通过降低chromedriver版本的方式来避免异常,但是在试过降低版本到20之后还是不行,更新到最新的版本也不行,于是放弃在真机上实现自动化,在模拟器中跑起来的速度也还可以接受。

在真机上跑的时候,切换到WebView上下文环境,程序控制台输出no such session异常,异常信息如下:

org.openqa.selenium.remote.SessionNotFoundException: no such session
   (Driver info: chromedriver=2.21.371459 (36d3d07f660ff2bc1bf28a75d1cdabed0983e7c4),platform=Mac OS X 10.13.2 x86_64) (WARNING: The server did not provide any stacktrace information)
 Command duration or timeout: 14 milliseconds
 Build info: version: '2.44.0', revision: '76d78cf', time: '2014-10-23 20:02:37'
 System info: host: 'wenguanchen-MacBook-Pro.local', ip: '192.168.1.102', os.name: 'Mac OS X', os.arch: 'x86_64', os.version: '10.13.2', java.version: '1.8.0_112-release'
 Driver info: io.appium.java_client.android.AndroidDriver
 Capabilities [{appPackage=com.tencent.mm, noReset=true, dontStopAppOnReset=true, deviceName=55CDU16C07009329, fullReset=false, platform=LINUX, deviceUDID=55CDU16C07009329, desired={app=, appPackage=com.tencent.mm, recreateChromeDriverSessions=True, noReset=true, dontStopAppOnReset=true, deviceName=FRD-AL00, fullReset=false, appActivity=.ui.LauncherUI, platformVersion=6.0, automationName=Appium, unicodeKeyboard=true, fastReset=false, chromeOptions={args=[], extensions=[], androidProcess=com.tencent.mm:tools}, platformName=Android, resetKeyboard=true}, platformVersion=6.0, webStorageEnabled=false, automationName=Appium, takesScreenshot=true, javascriptEnabled=true, unicodeKeyboard=true, platformName=Android, resetKeyboard=true, app=, networkConnectionEnabled=true, recreateChromeDriverSessions=True, warnings={}, databaseEnabled=false, appActivity=.ui.LauncherUI, locationContextEnabled=false, fastReset=false, chromeOptions={args=[], extensions=[], androidProcess=com.tencent.mm:tools}}]
 Session ID: e2e50190-398b-4fa2-bc66-db1097201e3f
  at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
  at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
  at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
  at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
  at org.openqa.selenium.remote.ErrorHandler.createThrowable(ErrorHandler.java:204)
  at org.openqa.selenium.remote.ErrorHandler.throwIfResponseFailed(ErrorHandler.java:162)
  at org.openqa.selenium.remote.RemoteWebDriver.execute(RemoteWebDriver.java:599)
  at io.appium.java_client.DefaultGenericMobileDriver.execute(DefaultGenericMobileDriver.java:27)
  at io.appium.java_client.AppiumDriver.execute(AppiumDriver.java:272)
  at org.openqa.selenium.remote.RemoteWebDriver.getPageSource(RemoteWebDriver.java:459)
  at com.example.AppiumAutoScan.getArticleDetail(AppiumAutoScan.java:238)
  at com.example.AppiumAutoScan.launchBrowser(AppiumAutoScan.java:78)
  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  at java.lang.reflect.Method.invoke(Method.java:498)
  at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
  at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
  at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
  at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
  at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
  at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
  at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
  at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
  at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
  at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
  at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
  at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
  at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
  at org.junit.runner.JUnitCore.run(JUnitCore.java:157)
  at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:117)
  at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:42)
  at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:262)
  at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:84)
  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  at java.lang.reflect.Method.invoke(Method.java:498)
  at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)

在Appium端输出的异常信息如下:

[debug] [AndroidDriver] Found webviews: ["WEBVIEW_com.tencent.mm:tools","WEBVIEW_com.tencent.mm"]
[debug] [AndroidDriver] Available contexts: ["NATIVE_APP","WEBVIEW_com.tencent.mm:tools","WEBVIEW_com.tencent.mm"]
[debug] [AndroidDriver] Connecting to chrome-backed webview context 'WEBVIEW_com.tencent.mm:tools'
[debug] [Chromedriver] Changed state to 'starting'
[Chromedriver] Set chromedriver binary as: /Applications/Appium.app/Contents/Resources/node_modules/appium/node_modules/appium-android-driver/node_modules/appium-chromedriver/chromedriver/mac/chromedriver
[Chromedriver] Killing any old chromedrivers, running: pkill -15 -f "/Applications/Appium.app/Contents/Resources/node_modules/appium/node_modules/appium-android-driver/node_modules/appium-chromedriver/chromedriver/mac/chromedriver.*--port=9515"
[Chromedriver] No old chromedrivers seemed to exist
[Chromedriver] Spawning chromedriver with: /Applications/Appium.app/Contents/Resources/node_modules/appium/node_modules/appium-android-driver/node_modules/appium-chromedriver/chromedriver/mac/chromedriver --url-base=wd/hub --port=9515 --adb-port=5037
[Chromedriver] [STDOUT] Starting ChromeDriver 2.21.371459 (36d3d07f660ff2bc1bf28a75d1cdabed0983e7c4) on port 9515
Only local connections are allowed.
[JSONWP Proxy] Proxying [GET /status] to [GET http://127.0.0.1:9515/wd/hub/status] with no body
[Chromedriver] [STDERR] [warn] kq_init: detected broken kqueue; not using.: Undefined error: 0
[JSONWP Proxy] Got response with status 200: "{\"sessionId\":\"\",\"stat...
[JSONWP Proxy] Proxying [POST /session] to [POST http://127.0.0.1:9515/wd/hub/session] with body: {"desiredCapabilities":{"ch...
[JSONWP Proxy] Got response with status 200: {"sessionId":"166cee263fc87...
[debug] [Chromedriver] Changed state to 'online'
 [MJSONWP] Responding to client with driver.setContext() result: null
 [HTTP] <-- POST /wd/hub/session/82b9d81c-f725-473d-8d55-ddbc1f92c100/context 200 903 ms - 76 
 [HTTP] --> GET /wd/hub/session/82b9d81c-f725-473d-8d55-ddbc1f92c100/context {}
 [MJSONWP] Calling AppiumDriver.getCurrentContext() with args: ["82b9d81c-f725-473d-8d55-d...
 [MJSONWP] Responding to client with driver.getCurrentContext() result: "WEBVIEW_com.tencent.mm:tools"
 [HTTP] <-- GET /wd/hub/session/82b9d81c-f725-473d-8d55-ddbc1f92c100/context 200 2 ms - 102 
 [HTTP] --> GET /wd/hub/session/82b9d81c-f725-473d-8d55-ddbc1f92c100/source {}
 [MJSONWP] Driver proxy active, passing request on via HTTP proxy
 [JSONWP Proxy] Proxying [GET /wd/hub/session/82b9d81c-f725-473d-8d55-ddbc1f92c100/source] to [GET http://127.0.0.1:9515/wd/hub/session/166cee263fc8757cbcb5576a52f7229e/source] with body: {}
 [JSONWP Proxy] Got response with status 200: "{\"sessionId\":\"166cee263...
 [JSONWP Proxy] Replacing sessionId 166cee263fc8757cbcb5576a52f7229e with 82b9d81c-f725-473d-8d55-ddbc1f92c100
 [HTTP] <-- GET /wd/hub/session/82b9d81c-f725-473d-8d55-ddbc1f92c100/source 200 8 ms - 220

如果要替换chromedriver的版本,可以从Appium上输出的Log信息找到chromedriver的路径,在终端依次执行如下命令打开chromedriver所在的文件夹。

cd /Applications/Appium.app/Contents/Resources/node_modules/appium/node_modules/appium-android-driver/node_modules/appium-chromedriver/chromedriver/mac/
open .

相应的chromedriver和Chrome版本对应信息和下载地址可以参考:

selenium之 chromedriver与chrome版本映射表

5)程序使用的JAR包

自动化脚本程序要跑起来需要两个压缩包,java-client-3.1.0.jar 和 selenium-server-standalone-2.44.0.jar ,试过使用这两个JAR包的最新版本,会有一些奇奇怪怪的问题,这两个版本的JAR包够用了。

java-client-3.1.0.jar 可以从Appium官网下载:

http://appium.io/downloads.html

selenium-server-standalone-2.44.0.jar 可以从selenium官网下载:

http://selenium-release.storage.googleapis.com/index.html

6)虚拟机

我这边使用的是网易MuMu虚拟机,基于Android 4.4.4平台,在我自己的Mac上跑着没问题,同一个版本安装到公司的Mac上就跑不起来,一打开就崩。后面虚拟机自动升级到了Android6.0.1,脚本跑了就有异常,而且每次打开的时候经常卡死在加载页面,system so库报异常。所以最好还是基于Android4.X的版本上运行脚本,Mac上没有一个通用稳定的虚拟机,自己下几个看看是否能用,个人测试各类型的虚拟机结果如下:

1)网易MuMu:在Mac上还是比较好用的,但是最新的版本是6.0.1,初始化经常卡死,无法回退到4.4.4平台版本,脚本在Android6.0平台上切换到WebView的上下文环境异常,升级ChromeDriver版本和Appium版本也无法解决此问题。

2)GenyMotion:微信安装之后无法打开,一直闪退,页面滑动在Mac上巨难操作。

3)天天模拟器:下载的DMG安装文件根本无法打开。

4)夜神模拟器:还是比较好用的,但是Appium adb无法连上虚拟机,从Log来看一直在重启adb, 最后程序中断。

5)逍遥安卓:没有Mac版本。

6)BlueStack:无法安装,安装过程中异常退出,多次重试还是一样。

综上,如果是在Mac上运行虚拟机,目前测试有效的是网易MuMu 基于Android 4.4.4 平台的版本,其他版本和虚拟机都有各种问题。

另:附上Android WebView 历史版本下载地址(需要翻墙):

https://cn.apkhere.com/app/com.google.android.webview

WebView 和对应的ChromeDriver版本见Appium GitHub chromedriver说明文档:

https://github.com/appium/appium/blob/master/docs/en/writing-running-appium/web/chromedriver.md 

7)编译IDE

不做Android开发的可以下载Eclipse IDE,在Eclipse下运行Java程序还比较方便,拷贝工程源码中的三份文件即可

java-client-3.1.0.jar 
selenium-server-standalone-2.44.0.jar  
AppiumWeChatAuto/appiumauto/src/main/java/com/example/AppiumAutoScan.java

Eclipse IDE下载地址:

http://www.eclipse.org/downloads/packages/

Java版本和对应的Eclipse IDE版本参考:

http://wiki.eclipse.org/Eclipse/Installation

8)GitHub工程源码

源码GitHub地址:

https://github.com/wenguan0927/AppiumWeChatAuto

运行Android工程查看设备信息的时候Edit Configurations切换到app,运行自动化脚本的时候切换到AppiumAutoScan。支持按最近一周,一个月,一年或爬取所有历史文章,checkTimeLimit()传入不同限制时间类型的参数即可。

四、参考资料

Appium 官方文档:http://appium.io/docs/cn/about-appium/intro/

Appium 常用API

Appium自动化测试–使用Chrome调试模式获取App混合应用H5界面元素

Appium 微信 webview 的自动化技术

Appium Girls 学习手册

Appium:轻松玩转app+webview混合应用自动化测试

Appium 微信小程序,driver.context (“WEBVIEW_com.tencent.mm:tools”) 切换 webview 报错

Appium 事件监听

妙用AccessibilityService黑科技实现微信自动加好友拉人进群聊

Appium自动化测试Android

Windows下部署Appium教程(Android App自动化测试框架搭建)

微信、手Q、Qzone之x5内核inspect调试解决方案

selenium之 chromedriver与chrome版本映射表

(Android开发自测)在Mac OS 10.12 上安装配置appium

辅助功能 AccessibilityService笔记

转载请注明:静觅 » 微信公众号文章爬取之:微信自动化


阿里新开发了一款神器,零基础也能轻松做出酷炫动效!

0
0

阿里作为中国互联网企业的标杆,不仅一直在为广大人民群众提供快捷便利的服务。也不断引领行业,在各个专业领域,给专业人员提供了优质的工具与服务。对设计师而言,无论是每年一度的 UCAN大会,还是 Kitchen、语雀、Ant Design 等设计开发工具,都给广大设计师带来很大的便利。

而最近,阿里又推出了一款基于 Lottie 的动效设计平台 ── 犸良。能够快速生成设计师想要的动态效果,并交付给开发,极大地提高了设计效率和设计还原度。

犸良是什么?

它是一个积累了很多通用动效素材的平台,让不会动效的同学们也能基于动效库和素材库快速生成一个通用动效创意,你只需要简单地编辑图片、颜色或者文字即可。同时平台集成了以 Lottie 为代表的动效技术,让曾经令人苦恼的安装包大小和性能问题一并解决。

△ 官网: https://design.alipay.com/emotion

犸良的应用场景

犸良支持全平台 iOS、Android、H5、小程序。无论是营销展位、活动页面、空状态还是产品icon。犸良编辑器对接投放平台,一站式完成动效创意制作和投放。

丰富的动效素材能够满足多种场景需要。

犸良怎么用?

方式一:基于模版直接制作(适用于设计师进行动态banner制作)

  1. 选择模版
  2. 从动画仓库选择动画进行当前动画的替换
  3. 通过替换图片或修改颜色来自定义动画
  4. 自定义模板文字内容
  5. 选择模板背景图片
  6. 完成编辑选择是否带背景(banner模版默认带背景)
  7. 导出成功下载 json

方式二:自定义画布制作(适用于设计师进行模板覆盖不到的动效应用场景)

使用犸良一分钟做出来的效果,大家感受下:

体验感受

综合体验了一下犸良,相对于鹿班人工智能随意撸图。猛良其实是一款基于人工的动效模板网站。所有的动态效果都是设计师提前做好的。基于 Lottie 的特性,将可编辑的属性进行模块化。

说到这里有些设计师可能有疑问了,Lottie 究竟是什么?在优设已经有相关文章介绍的比较全面了,这里就不赘述了,阅读链接: http://www.uisdc.com/tag/lottie/ 。

简言之 Lottie 就是一个快速将 AE 中设计的动效快速调出,并且开发可以直接调用的动效库。

Lottie 的原理是将矢量图形和动态效果通过代码实现,复杂的图形导出图片资源。最终生成 json 文件+图片资源。犸良所做的就是,将 json 里的颜色属性提取出来,用户可以从外部修改。同样只需要替换图片资源,就可以让用户自己设计的图形根据 json 写好的运动方式来展示。如果你把一只移动的猪替换成猫了,那么你看到的效果就是一只移动的猫。

而它的文字编辑功能,我觉得就比较神奇了。因为 Lottie 貌似不能从外部修改字体,应该是阿里自己写的。如果有知道的同学也欢迎解惑。因为我们在实际工作中经常遇到这样的问题,就是如果动效包含文本了,需要适配国际化,就没法从外部修改语言。如果能解决这个问题,将会减少很多麻烦。

从现有的素材来看,其主要应用场景还是电商和运营方面。相信未来会增加更多的素材和应用场景。希望以后能够开放出让设计师可以将自己做的动效分享出来供大家使用,或者提供优质付费内容也是不错的选择。

就个人的工作经验来看,Lottie 还是有丰富的应用场景的。比如可以做动态图标、动态闪屏页、表情贴纸、直播礼物、空白页、动态banner……

其实 Lottie 官方社区也有很多的动效资源,都是来自全世界的设计师上传的,大家可以去下载参考,如果要商用,可能需要联系作者。

△ 附上链接: https://lottiefiles.com/popular

本文资料,很多都是来自语雀的分享。再次感谢相关人员的辛勤付出。大家可以在此处查看犸良的完整介绍: https://www.yuque.com/dapolloali/news/ui43vg 。

再次附上官网: https://design.alipay.com/emotion

因为犸良是基于 Lottie 的工具,所以有相关基础的设计师很容易上手。还不了解的同学也可以在各大设计网站搜索到。

欢迎关注作者的微信公众号:「懿凡设计」

本文原文:https://www.uisdc.com/alibaba-emotion

转载请注明:静觅 » 阿里新开发了一款神器,零基础也能轻松做出酷炫动效!

未来,你可能会主动点开这种广告

0
0

首先,这篇文章不是一个广告。

但你可能已经要被这个时代无处不在的洗脑广告逼疯了。

大街小巷贴满的纸皮广告、商场和电梯里循环播放的电子屏广告、电脑上避不开关不掉停不了的网页广告…… 某招聘软件和某旅拍公司的循环怒吼式视频让人生理性地记住了它,但心理上可能想把相关人员关电梯里让它们把这条广告看一万遍。

▲ 图片来自:「伯爵旅拍」广告截图

广告的形式不断在变化,从广播、平面、视频,到 H5、直播,部分广告会以新颖的形式和优质的内容取胜,但人们看广告一直都是被动接受的过程。

上周蜘蛛侠上映,索尼在 Snapchat 上 推出了 AR 活动宣传 ,为了贴合「英雄远征」的主题,索尼让蜘蛛侠「出现」在世界各地的地标处,比如纽约的熨斗大厦、伦敦的白金汉宫、巴黎的艾菲尔铁塔,只要你将自拍镜头对准建筑,就可以看到蜘蛛侠在屏幕上摆动。

▲图片来自:mobilemarketingmagazine

它让人们愿意看蜘蛛侠的广告,同时也让广告成了一种主动参与的过程。

接下来要讲的,就是未来这一种我们会主动点开的——VR 广告。

当广告变成了一种「真实」的体验

我们看现在的广告,有一种潜意识默认的原则,就是注意力只给它们 3 秒钟。

但现在的 VR 广告,是给你无限的时间,让你自己去体验。

AR 火起来,还是被 2015 年 Snapchat 的搞怪 AR 滤镜,以及 2016 年的神奇宝贝 GO 带动,这也改变了市场营销对 AR 的看法,让 AR 开始在广告界生根发芽。

宜家是首批尝试购买 AR 技术并以此宣传的公司之一。

在 IKEA Place app 中 ,人们可以看到新款家具实际摆放在家里的样子,以判断它们是不是有足够空间布局放置、颜色风格是否和周围环境搭调,这可以帮宜家提高客户满意度以及降低产品退回率。

随后苹果发布了 ARkit 技术,Google、Facebook、亚马逊等大公司也在 2017 年和 2018 年期间发布了自己 AR 软件开发套件,以支持日后 AR 技术的发展。

Facebook 去年就为广告商提供了 展示产品的新方式 ,让人们在新闻流中看到品牌广告时,能够通过前置摄像头对比自己戴上太阳镜等配饰、甚至穿各种衣服的样子。现在 Facebook 也一直在通过各个平台包括 Instagram 扩大购物范围和增值产品。

除了家居服饰,美容时尚等行业也开始尝试利用 AR 营销,主要是为了弥补线上和线下的差距。

两周前,人们已经能在 YouTube 上一边看美妆博主的化妆教程,一边在分屏之下跟着博主一起涂口红试色,这个名为 AR Beauty Try-On 的功能 由 Google 推出,M・A・C 是第一个跟上这项 AR 广告的品牌。测试结果发现,人们愿意花费超过 80 秒的时间去体验虚拟唇膏色调。

甚至当你逛淘宝店,在前几周 天猫旗舰店升级的  2.0 版本,能直接让你像逛线下实体店一样逛线上 3D 商店、参观漫游,每家店铺展示内容也因人而异。

而且,你还可以实地进入 AR 广告之中。

在汽车行业,宝马、保时捷、丰田等汽车品牌都成为了 AR 广告的追随者。

丰田上个月给 2020 年卡罗拉 推出了 AR 移动广告 ,人们可以 360 度全方位观看车内视图和功能,以及固定在一个地方的 3D 数字模型,甚至还可以在车内行走。这能让购买者更简单地了解车辆的技术特性,也有助于在购买车辆前对其预先认证。

这种自然而直观的方式,不仅让人们和品牌建立起更真实的关系,与以往广告最大的不同就是,人们还能随时参与、持续互动,并响应内容。

我们可以拿回看广告的主动权

现在,我们自己可以掌控广告。

目前我们 能看到的 AR 广告 ,主要包括被赞助的拍照滤镜镜头、应用软件和游戏内的 AR 广告单元,信息流内的 AR 广告单元等。

之前是广告「邀请」我们看,没有任何协商。但现在我们「侵入」广告,去满足自己的好奇心。广告变成了一个工具,我们通过它与我们喜欢的品牌获得联系。

这种形式现在也让 AR 广告成为当今市场上破坏性最小的广告单元之一。

▲  图片来自:unsplash

另外,AR 广告已经不再是单独的一个内容,而是进入我们的真实生活,或者进入其它我们沉浸的内容之中——广告本身就是商品的展示位,不会再有其它如美化特效、夸张视觉等因素插入和干扰。

而且这些 AR 广告最初打开的阀门,就掌握在消费者手上。

因为 AR 广告现在都需要申请对其相机/设备的访问,在非相机优先的应用中,也需要申请特定权限,因此你完全可以选择你需要的内容,并与之开始进一步互动。

▲ 图片来自: Cyber Infrastructure

可以说,AR 就是有史以来最强大的故事叙述媒体。它的互动带来的「响应式特色」,就是它最大的优势。

Unity 技术的 AR / VR 广告创新 负责人 Tony Parisi 说 :

响应性 AR 广告是一种更加友好,不那么令人生畏的方法,这些广告能够提高客户的选择率,同时通过控制权来提高用户的舒适度。

尽管 AR 广告现在还不足以吸引大多数用户,人们似乎更觉得这只是消费者的一种自我意淫。

但实际上幸运的是,现在它背后有一批最大的科技公司在支持和推动,这就让更多设计师有机会去创造更好的 AR 广告环境,更多品牌有空间去施放更大的营销活动。

Google、苹果、Facebook 这样的大平台仍然主导着 AR 领域及其营销的发展。这些科技公司还和零售商 组成了一个小组 ,为用于增强现实购物的 3D 图像创建一套通用标准。

▲ Google 推出名为 Swirl 的沉浸式显示,消费者可以 360 度查看、旋转、放大、缩小商品

在这个背景之下,市场研究公司 Markets and Markets 的数据 预计,到明年 AR 将拥有 10 亿用户,到 2022 年将达到 22 亿美元的广告支出。

AR 广告进入我们的生活将会更加快速,而我们掌握的主动权也会越来越多,正如以色列最大的互联网公司 IronSource 首席设计官 Dan Greenberg 所认为的 :

我们不断研究如何在广告中为用户提供尽可能多的选择的方法。因为给用户提供更多控制权,才是创建真正个性化移动体验的关键。

AR 会是下一个广告形态

数字广告总体上正朝着更丰富、更身临其境、更多选择的方向发展,消费者正在被置于互动体验的中心。

根据 Gartner 的估计 ,随着 5G 高速移动服务的推出,明年它将推动 AR 购物增长到 1 亿消费者。

▲  图片来自:unsplash

因为在高速运行的网络下,开发者不仅能够创造更高质量的 3D 可视化技术,消费者也能获得更多形式的沉浸式体验,品牌也能将其购物平台更多扩展到商店和传统网站之外的移动设备上,而且广告也不会再只限于移动设备的小屏幕。

还可以预见的是,5G 网络之下数据信息密度也会迅速加大,除了文本,还有图像、视频,人们接受的购物信息无疑更广、更深、更繁杂,而 AR 能够降低广告的感知成本,让人们消费数字内容将更简便和直观。

▲  图片来自:unsplash

但现在 AR 广告还未普及的主要问题,就在于它的成本和技术。

比起其他广告形式来说,其实它的投入成本并不低。Digiday 指出 单一的广告体验 可能需要花费 5,000 到 30,000 美元甚至更多才能正常开发,投资回报率也很难衡量。

而近阶段虽然 AR 技术发展很快,但 5G 手机还刚推出第一批,5G 网络也并未稳定普及,这也是影响 AR 广告现在扩大规模的关键因素——没有与之匹配的设备。另外,比起其它开发多年的其它形式的广告,AR 广告迭代和优化也还不太灵活,并非广告商们信手就可捏来。

▲  图片来自:unsplash

AR 热潮刚刚开始真正起飞,我们现在看到的只是关于 AR 能带来什么以及它能做些什么的一瞥。不过苹果 2017 年推出 ARKit 时,首席执行官蒂姆・库克在 财报电话会议上就指出 AR 将成为「主流」:

虽然我们现在还只触及冰山一角,但它将永久改变我们使用技术的方式。

而这个未来正在靠近。Digi-Capital 预计在未来五年内 AR 广告的市场价值将达到 830 亿美元。而且下一代移动设备,还会为我们带来更多新的可能性。

折叠手机的柔性屏幕将能让 AR 广告拥有更多形式;内置投影仪的手机,能让 AR 广告用更大的位置呈现,当广告变成了一种看电影的方式,这对广告商也意味着有更多的空间来宣传。

▲ 图片来自: satzuma

但无论何种新的形式,接下来,当我们沉迷于自己所选的 AR 广告体验中无法自拔,会不会更加停不下来「买买买」呢?

我开始觉得这是一篇关于 AR 的沉浸式广告了。

原文:https://www.ifanr.com/1230440

转载请注明:静觅 » 未来,你可能会主动点开这种广告

知识付费的发展趋势

0
0

现代人都普遍比较焦虑,越来越多的人感到生活压力很大,在一二线城市不少白领人士更是已是患上“知识焦虑症”:这年头知识信息迭代太快,学习跟不上,别人懂的自己都不懂,总感觉自己欠缺的很多,没有技术和专长不知未来靠什么生存,担心自己长期落后他人从而被社会淘汰,从而产生了一种对未来不确定的心理恐惧。

于是,他们就急于渴求,希望能在短时间内学习大量知识希望从根本上解决自己的实际问题,拼命利用碎片化时间学习补充欠缺知识,不断完善自己的知识体系。这时知识付费的出现,正好满足了他们这些刚性需求。

再加上2018年前以逻辑思维为主一批内容供应商到处鼓吹和贩卖知识焦虑,在这种风气影响下连身边的很多小伙伴都购买了大量知识付费产品,但一年下来却发现这些知识根本没有学会几个,内容良莠不齐,服务跟不上,就算能坚持学完下来还是什么都不会,焦虑依然存在 。甚至更多人觉得其实知识付费就是一场骗局,从本质上来说知识付费并没有解决任何的问题,表面上只是缓解了一些焦虑,在短时间内让一些人自我感觉良好,实则上只是自欺欺人而已。

于是,一些感觉被欺骗的用户纷纷发声,对某些知识付费大号和机构更是愤怒抨击,在这些负面影响下这两年知识付费其实已逐渐降温并遭遇爆冷,甚至还有一些负面声音在说: 在线知识付费的寒冬是不是要来临了?

其实不然,纵观当下市场发展态势知识付费的前景仍然是广阔的,竞争激烈程度仍方兴未艾,当人们对知识的盲目消费退烧后,知识付费更多的是回归服务价值, 核心需求有两方面 : 一方面是为了提升欠缺的知识让自己具有更多的市场竞争力,另一方面也希望自己花钱买的知识付费产品是一些真正有帮助的东西,可帮自己迎来一个不错的未来。所以,知识付费的下一阶段必然聚焦于如何让学习用户获得真正有效的学习效果。

那么,知识付费下半场风口到底会吹去哪? 好学豚认为这一领域的大方向以后的发展趋势大致有如下特征:

趋势一:内容下沉,回归有价值的真实内容

1、职场技能

在知识付费领域和在整个教育市场体系里,职场技能都是最刚需的内容板块,从最早的电算会计化到后来的英语类培训,再到如今一些以工具为代表的设计、办公技能、IT编程等等培训,无一不彰显着其旺盛的生命力。 究其根本原因,这是因为它能够切实解决职场人士的实际需求,所以职场技能内容才会一直火爆,繁荣至今仍在蓬勃发展。

2、知识拓展

知识拓展是近年来兴起的版块内容,也是互联网上传播特别广泛的内容。以得到为代表,邀请行业细分领域的专业人士,按照标准的生产流程来生产较高质量的内容,帮助拓广知识的视野从而实现专家指路的效果。不容忽视的是,知识拓展的内容从今天来看存在较大的局限,很难解决用户的实际问题,学习效果也很难得到保证;如何打磨出更加直击用户痛点的产品,需要更多的探索和尝试。

3、兴趣爱好

在线教育领域,兴趣爱好的内容已经有了长足发展。用户的痛点正在逐渐从追求高大上、财务自由这些虚伪的概念转型到享受生活:提 升生活趣味让自己活得更舒服。兴趣爱好内容之所以能生命力如此旺盛,最大因素要得益于其以兴趣为导向,学习者本身并不会有太高的学习结果诉求,更多的是在学习之中获得的乐趣以及对授课老师的认同。

趋势二:后续服务提升,注重全流程效果

今后知识付费需要做好三个关键点的平衡:碎片化学习、学习规模和学习效果,这三者缺一不可。根据业内行家的实践和推断,下一阶段知识付费的标配服务模式将会是1+1+N模式,能较好地实现以上三个关键点的平衡。

第一个“1”代表的是标准化的课程: 这个课程将会以“图文”、“视频”或“音频”形式进行展现,让学习者完成自学。这个“1”满足了碎片化学习的随时随地性,给予了学习者最大限度的自由度,同时也满足了由于学习规模日益扩大而带来的各种问题。

第二个“1”代表的是在线训练营: 就是把线下的集中学习模式搬到线上,开展一段时间的在线集中训练,通过学习流程、学习氛围、学习评估的三位一体运作,从而使学习效果得以达成。总体做法是把所有参与训练营的学员,分成不同的小组,然后配定相应老师。每个学员在学习过程中都需要完成相应作业,然后交给老师进行批改和点评。整个训练营阶段会有实战练习,根据学习者的自身情况或使用真实的案例来进行实战,进而帮助学习者实现学以致用。同时,老师需要对每个学习者进行阶段性评分,在学习完成时要进行总体评估;老师还需要针对小组学习效果进行展示和相应氛围的营造。

最后一个“N”则代表通过科技的力量,实现多种教学辅助手段 :比如老师和学员之间的交互,老师批量布置和批改作业,对学员进行评分和评估,给积极学习者一些奖励等等,所有这些辅助手段,将会让老师和学员之间的交互更紧密,让学习效率更高、让学习流程更完整、学习模式更人性,从而最终达到提升学习效果的目的。

趋势三:更多垂直领域的小KOL将通过工具类平台输出产品

垂直领域的小KOL,他们标签清晰、价值点明确,用户深度认可,反倒更容易突围,甚至可以脱离平台,通过好学豚这类工具就可以完成知识店铺的搭建。而且因为他们有很强的用户沉淀能力,所以也更有动力参与。长期来看,小KOL通过线上虚拟产品输出知识将会成为一个新的趋势。

趋势四:一线城市受众有限,二、三线城市女性用户价值开始受到重视

一线城市对于知识付费产品的承载能力是有限的,据观察主流付费用户都不是一线白领,而是二三线城市的宝妈。她们更愿意在知识上付钱,也愿意分享课程,赚取一定分成。

互联网独角兽的发展规律一再地证明二三线城市的女性是主力消费群体,知识付费也不会逃离这个规律,现在很多母婴类课程、女性个人提升课程、陪伴式励志课程、情商人际关系类课程销量都很不错。这是一个巨大的市场空窗,目前市场上的多数知识付费平台还忽视了二三线城市的用户,电商平台和垂直大号也还没有真正介入这一行业,这个空窗很有可能下一家知识付费独角兽企业崛起的机会。

针对以上趋势,好学豚知识付费平台也正在进行多方面的尝试,希望能把握住这些新的市场机会迎来爆发性增长,对于当下的知识付费从业者来说既是一个巨大的挑战,也是突围而出成为新独角兽企业的机会。

原文:https://www.iyiou.com/p/104850.html

转载请注明:静觅 » 知识付费的发展趋势

JavaScript 实用窍门总结

0
0

简评:一开始 JavaScript 只是为网页增添一些实时动画效果,现在 JS 已经能做到前后端通吃了,而且还是年度流行语言。本文分享几则 JS 小窍门,可以让你事半功倍 ~

1. 删除数组尾部元素

一个简单方法就是改变数组的length值:

const arr = [11, 22, 33, 44, 55, 66];
// truncanting
arr.length = 3;
console.log(arr); //=> [11, 22, 33]
// clearing
arr.length = 0;
console.log(arr); //=> []
console.log(arr[2]); //=> undefined

2. 使用对象解构(object destructuring)来模拟命名参数

如果需要将一系列可选项作为参数传入函数,你很可能会使用对象(Object)来定义配置(Config)。

doSomething({ foo: 'Hello', bar: 'Hey!', baz: 42 });
function doSomething(config) {
  const foo = config.foo !== undefined ? config.foo : 'Hi';
  const bar = config.bar !== undefined ? config.bar : 'Yo!';
  const baz = config.baz !== undefined ? config.baz : 13;
  // ...
}

不过这是一个比较老的方法了,它模拟了 JavaScript 中的命名参数。

在 ES 2015 中,你可以直接使用对象解构:

function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 }) {
  // ...
}

让参数可选也很简单:

function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 } = {}) {
  // ...
}

3. 使用对象解构来处理数组

可以使用对象解构的语法来获取数组的元素:

const csvFileLine = '1997,John Doe,US,john@doe.com,New York';
const { 2: country, 4: state } = csvFileLine.split(',');

4. 在 Switch 语句中使用范围值

可以这样写满足范围值的语句:

function getWaterState(tempInCelsius) {
  let state;

  switch (true) {
    case (tempInCelsius <= 0): 
      state = 'Solid';
      break;
    case (tempInCelsius > 0 && tempInCelsius < 100): 
      state = 'Liquid';
      break;
    default: 
      state = 'Gas';
  }
  return state;
}

5. await 多个 async 函数

在使用 async/await 的时候,可以使用 Promise.all 来 await 多个 async 函数

await Promise.all([anAsyncCall(), thisIsAlsoAsync(), oneMore()])

6. 创建 Pure objects

你可以创建一个 100% pure object,它不从Object中继承任何属性或则方法(比如constructor, toString()等)

const pureObject = Object.create(null);
console.log(pureObject); //=> {}
console.log(pureObject.constructor); //=> undefined
console.log(pureObject.toString); //=> undefined
console.log(pureObject.hasOwnProperty); //=> undefined

7. 格式化 JSON 代码

JSON.stringify除了可以将一个对象字符化,还可以格式化输出 JSON 对象

const obj = { 
  foo: { bar: [11, 22, 33, 44], baz: { bing: true, boom: 'Hello' } } 
};
// The third parameter is the number of spaces used to 
// beautify the JSON output.
JSON.stringify(obj, null, 4); 
// =>"{
// =>    "foo": {
// =>        "bar": [
// =>            11,
// =>            22,
// =>            33,
// =>            44
// =>        ],
// =>        "baz": {
// =>            "bing": true,
// =>            "boom": "Hello"
// =>        }
// =>    }
// =>}"

8. 从数组中移除重复元素

通过使用集合语法和 Spread 操作,可以很容易将重复的元素移除:

const removeDuplicateItems = arr => [...new Set(arr)];
removeDuplicateItems([42, 'foo', 42, 'foo', true, true]);
//=> [42, "foo", true]

9. 平铺多维数组

使用 Spread 操作平铺嵌套多维数组:

const arr = [11, [22, 33], [44, 55], 66];
const flatArr = [].concat(...arr); //=> [11, 22, 33, 44, 55, 66]

不过上面的方法仅适用于二维数组,但是通过递归,就可以平铺任意维度的嵌套数组了:

function flattenArray(arr) {
  const flattened = [].concat(...arr);
  return flattened.some(item => Array.isArray(item)) ? 
    flattenArray(flattened) : flattened;
}

const arr = [11, [22, 33], [44, [55, 66, [77, [88]], 99]]];
const flatArr = flattenArray(arr); 
//=> [11, 22, 33, 44, 55, 66, 77, 88, 99]

希望这些小技巧能帮助你写好 JavaScript ~

原文:https://zhuanlan.zhihu.com/p/37493249

转载请注明:静觅 » JavaScript 实用窍门总结

介绍 5 个实用的 Ajax 库

0
0

在这篇文章中,我们将介绍一些用于AJAX调用的最好的JS库,包括jQuery,Axios和Fetch。欢迎查看代码示例!

AJAX是用来对服务器进行异步HTTP调用的一系列web开发技术客户端框架。 AJAX即Asynchronous JavaScript and XML(异步JavaScript和XML)。AJAX曾是web开发界的一个常见名称,许多流行的JavaScript小部件都是使用AJAX构建的。例如,有些特定的用户交互(如按下按钮)会异步调用到服务器,服务器会检索数据并将其返回给客户端——所有这些都不需要重新加载网页。

AJAX的现代化重新引入

JavaScript已经进化了,现在我们使用前端库和/或如React、Angular、Vue等框架构建了动态的网站。AJAX的概念也经历了重大变化,因为现代异步JavaScript调用涉及检索JSON而不是XML。有很多库允许你从客户端应用程序对服务器进行异步调用。有些进入到浏览器标准,有些则有很大的用户基础,因为它们不但灵活而且易于使用。有些支持promises,有些则使用回调。在本文中,我将介绍用于从服务器获取数据的前5个AJAX库。

Fetch API

Fetch API是XMLHttpRequest的现代替代品,用于从服务器检索资源。与XMLHttpRequest不同的是,它具有更强大的功能集和更有意义的命名。基于其语法和结构,Fetch不但灵活而且易于使用。但是,与其他AJAX HTTP库区别开来的是,它具有所有现代Web浏览器的支持。Fetch遵循请求-响应的方法,也就是说,Fetch提出请求并返回解析到Response对象的promise。

你可以传递Request对象来获取,或者,也可以仅传递要获取的资源的URL。下面的示例演示了使用Fetch创建简单的GET请求。

fetch('https://www.example.com', {
        method: 'get'
    })
    .then(response => response.json())
    .then(jsonData => console.log(jsonData))
    .catch(err => {
            //error block
     })

正如你所看到的,Fetch的then方法返回了一个响应对象,你可以使用一系列的then 进行进一步的操作。我使用.json() 方法将响应转换为JSON并将其输出到控制台。

假如你需要POST表单数据或使用Fetch创建AJAX文件上传,将会怎么样?此时,除了Fetch之外,你还需要一个输入表单,并使用FormData库来存储表单对象。

var input = document.querySelector('input[type="file"]')
var data = new FormData()
data.append('file', input.files[0])
data.append('user', 'blizzerand')
fetch('/avatars', {
    method: 'POST',
    body: data
})

你可以在官方的Mozilla web文档中阅读更多关于Fetch API的信息。

Axios

Axios是一个基于XMLHttpRequest而构建的现代JavaScript库,用于进行AJAX调用。它允许你从浏览器和服务器发出HTTP请求。此外,它还支持ES6原生的Promise API。Axios的其他突出特点包括:

  • 拦截请求和响应。
  • 使用promise转换请求和响应数据。
  • 自动转换JSON数据。
  • 取消实时请求。

要使用Axios,你需要先安装它。

npm install axios

下面是一个演示Axios行动的基本例子。

// Make a request for a user with a given ID
axios.get('/user?ID=12345')
  .then(function (response) {
    console.log(response);
  })
  .catch(function (error) {
    console.log(error);
  });

与Fetch相比,Axios的语法更简单。让我们做一些更复杂的事情,比如我们之前使用Fetch创建的AJAX文件上传器。

var data = new FormData();
   data.append('foo', 'bar');
   data.append('file', document.getElementById('file').files[0]);
   var config = {
        onUploadProgress: function(progressEvent) {
          var percentCompleted = Math.round( (progressEvent.loaded * 100) / progressEvent.total );
        }
    };
    axios.put('/upload/server', data, config)
      .then(function (res) {
        output.className = 'container';
        output.innerHTML = res.data;
      })
      .catch(function (err) {
        output.className = 'container text-danger';
        output.innerHTML = err.message;
      });

Axios更具可读性。Axios也非常受React和Vue等现代库的欢迎。

jQuery

jQuery曾经是JavaScript中的一个前线库,用于处理从AJAX调用到操纵DOM内容的所有事情。虽然随着其他前端库的“冲击”,其相关性有所降低,但你仍然可以使用jQuery来进行异步调用。

如果你之前使用过jQuery,那么这可能是最简单的解决方案。但是,你将不得不导入整个jQuery库以使用$.ajax方法。虽然这个库有特定于域的方法,例如$.getJSON,$.get和$.post,但是其语法并不像其他的AJAX库那么简单。以下代码用于编写基本的GET请求。

$.ajax({
  url: '/users',
  type: "GET",
  dataType: "json",
  success: function (data) {
      console.log(data);
  }
  fail: function () {
      console.log("Encountered an error")
  }
});

jQuery好的地方在于,如果你有疑问,那么你可以找到大量的支持和文档。我发现了很多使用FormData()和jQuery进行AJAX文件上传的例子。下面是最简单的方法:

var formData = new FormData();
formData.append('file', $('#file')[0].files[0]);
$.ajax({
       url : 'upload.php',
       type : 'POST',
       data : formData,
       processData: false,  // tell jQuery not to process the data
       contentType: false,  // tell jQuery not to set contentType
       success : function(data) {
           console.log(data);
           alert(data);
       }
});

SuperAgent

SuperAgent是一个轻量级和渐进式的AJAX库,更侧重于可读性和灵活性。SuperAgent还拥有一个温和的学习曲线,不像其他库。它有一个针对Node.js API相同的模块。SuperAgent有一个接受GET、POST、PUT、DELETE和HEAD等方法的请求对象。然后你可以调用.then(),.end()或新的.await()方法来处理响应。例如,以下代码为使用SuperAgent的简单GET请求。

request
   .post('/api/pet')
   .send({ name: 'Manny', species: 'cat' })
   .set('X-API-Key', 'foobar')
   .set('Accept', 'application/json')
   .then(function(res) {
      alert('yay got ' + JSON.stringify(res.body));
   });

如果你想要做更多的事情,比如使用此AJAX库上传文件,那该怎么做呢? 同样超级easy。

request
   .post('/upload')
   .field('user[name]', 'Tobi')
   .field('user[email]', 'tobi@learnboost.com')
   .field('friends[]', ['loki', 'jane'])
   .attach('image', 'path/to/tobi.png')
   .then(callback);

如果你有兴趣了解更多关于SuperAgent的信息,那么它们有一系列很不错的文档来帮助你开始这个旅程。

Request——简化的HTTP客户端

Request库是进行HTTP调用最简单的方法之一。结构和语法与在Node.js中处理请求的方式非常相似。目前,该项目在GitHub上有18K个星,值得一提的是,它是可用的最流行的HTTP库之一。 下面是一个例子:

var request = require('request');
request('http://www.google.com', function (error, response, body) {
  console.log('error:', error); // Print the error if one occurred
  console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
  console.log('body:', body); // Print the HTML for the Google homepage.
});

结论

从客户端进行HTTP调用在十年前可不是一件容易的事。前端开发人员不得不依赖于难以使用和实现的XMLHttpRequest。现代的库和HTTP客户端使得用户交互、动画、异步文件上传等前端功能变得更加简单。

我个人最喜欢的是Axios,因为我觉得它更易读更赏心悦目。你也可以忠于Fetch,因为它文档化良好且有标准化的解决方案。

你个人最喜欢的AJAX库是哪个? 欢迎各位分享你的看法。

转载请注明:静觅 » 介绍 5 个实用的 Ajax 库

JavaScript API 设计原则详解

0
0

前言

本篇博文来自一次公司内部的前端分享,从多个方面讨论了在设计接口时遵循的原则,总共包含了七个大块。系卤煮自己总结的一些经验和教训。本篇博文同时也参考了其他一些文章,相关地址会在后面贴出来。很难做到详尽充实,如果有好的建议或者不对的地方,还望不吝赐教斧正。

一、接口的流畅性

好的接口是流畅易懂的,他主要体现如下几个方面:

1.简单

操作某个元素的css属性,下面是原生的方法:

document.querySelector('#id').style.color = 'red';

封装之后

function a(selector, color) {
  document.querySelector(selector).style.color = color
}
a('#a', 'red');

从几十个字母长长的一行到简简单单的一个函数调用,体现了api设计原则之一:简单易用。

2.可阅读性

a(‘#a’, ‘red’)是个好函数,帮助我们简单实用地改变某个元素,但问题来了,如果第一次使用该函数的人来说会比较困惑,a函数是啥函数,没有人告诉他。开发接口有必要知道一点,大多数人都是懒惰的(包括卤煮自己),从颜色赋值这个函数来说,虽然少写了代码,但是增加了单词字母的个数,使得它不再好记。每次做这件事情的时候都需要有映射关系: a—->color. 如果是简单的几个api倒是无所谓,但是通常一套框架都有几十甚至上百的api,映射成本增加会使得程序员哥哥崩溃。 我们需要的就是使得接口名称有意义,下面我们改写一下a函数:

function letSomeElementChangeColor(selector, color) {
  document.querySelectorAll(selector, color).style.color = color; }

letSomeElementChangeColor相对于a来说被赋予了现实语言上的意义,任何人都不需要看说明也能知道它的功能。

3.减少记忆成本

我们刚刚的函数太长了,letSomeElementChangeColor虽然减少了映射成本,有了语言上的意义,但是毫无疑问增加了记忆成本。要知道,包括学霸在内,任何人都不喜欢背单词。不仅仅在此处,原生获取dom的api也同样有这个问题: document.getElementsByClassName; document.getElementsByName; document.querySelectorAll;这些api给人的感觉就是单词太长了,虽然他给出的意义是很清晰,然而这种做法是建立在牺牲简易性和简忆性的基础上进行的。于是我们又再次改写这个之前函数

function setColor(selector, color) {
 xxxxxxxxxxxx
}

在语言意义不做大的变化前提下,缩减函数名称。使得它易读易记易用。

4.可延伸

所谓延伸就是指函数的使用像流水一样按照书写的顺序执行形成执行链条:

document.getElementById('id').style.color = 'red';
document.getElementById('id').style.fontSize = '12px';
document.getElementById('id').style.backgourdColor = 'pink';

如果我们需要实现像以上有强关联性的业务时,用我们之前的之前的方法是再次封装两个函数 setFontSize, setbackgroundColor; 然后执行它们 setColor(‘id’, ‘red’);setFontSiez(‘id’, ’12px’); setbackgroundColor(‘id’, ‘pink’); 显然,这样的做法没有懒出境界来;id元素每次都需要重新获取,影响性能,失败;每次都需要添加新的方法,失败; 每次还要调用这些方法,还是失败。下面我们将其改写为可以延伸的函数 首先将获取id方法封装成对象,然后再对象的每个方法中返回这个对象:

function getElement(selector) {
  this.style = document.querySelecotrAll(selector).style;
}

getElement.prototype.color = function(color) {
  this.style.color = color;
  return this;
}
getElement.prototype.background = function(bg) {
  this.style.backgroundColor = bg;
  return this;
}
getElement.prototype.fontSize = function(size) {
  this.style.fontSize = size;
  return this;
}

//调用
var el = new getElement('#id')
el.color('red').background('pink').fontSize('12px');

简单、流畅、易读,它们看起来就像行云流水一样,即在代码性能上得到了提升优化,又在视觉上悦目。后面我们会在参数里面讲到如何继续优化。

所以,大家都比较喜欢用jquery的api,虽然一个$符号并不代表任何现实意义,但简单的符号有利于我们的使用。它体现了以上的多种原则,简单,易读,易记,链式写法,多参处理。

nightmare:

document.getElementById('id').style.color = 'red';
document.getElementById('id').style.fontSize = '12px';
document.getElementById('id').style.backgourdColor = 'pink';

dream:

$('id').css({color:'red', fontSize:'12px', backgroundColor:'pink'})

二、一致性

1.接口的一致性

相关的接口保持一致的风格,一整套 API 如果传递一种熟悉和舒适的感觉,会大大减轻开发者对新工具的适应性。 命名这点事:既要短,又要自描述,最重要的是保持一致性 “在计算机科学界只有两件头疼的事:缓存失效和命名问题” — Phil Karlton 选择一个你喜欢的措辞,然后持续使用。选择一种风格,然后保持这种风格。

Nightmare:

setColor,
letBackGround
changefontSize
makedisplay

dream:

setColor;
setBackground;
setFontSize
set.........

尽量地保持代码风格和命名风格,使别人读你的代码像是阅读同一个人写的文章一样。

三、参数的处理

1.参数的类型

判断参数的类型为你的程序提供稳定的保障

//我们规定,color接受字符串类型
function setColor(color) {
  if(typeof color !== 'string') return;
dosomething
}

2.使用json方式传参

使用json的方式传值很多好处,它可以给参数命名,可以忽略参数的具体位置,可以给参数默认值等等 比如下面这种糟糕的情况:

function fn(param1, param2...............paramN)

你必须对应地把每一个参数按照顺序传入,否则你的方法就会偏离你预期去执行,正确的方法是下面的做法。

function fn(json) {
//为必须的参数设置默认值
   var default = extend({
    param: 'default',
    param1: 'default'
    ......
   },json)
}

这段函数代码,即便你不传任何参数进来,他也会预期运行。因为在声明的时候,你会根据具体的业务预先决定参数的缺省值。

四、可扩展性

软件设计最重要的原则之一:永远不修改接口,而是去扩展它!可扩展性同时会要求接口的职责单一,多职责的接口很难扩展。 举个栗子:

//需要同时改变某个元素的字体和背景
// Nightmare:
function set(selector, color) {
  document.querySelectroAll(selector).style.color = color;
  document.querySelectroAll(selector).style.backgroundColor = color;
}

//无法扩展改函数,如果需要再次改变字体的大小的话,只能修改此函数,在函数后面填加改变字体大小的代码

//Dream
function set(selector, color) {
  var el = document.querySelectroAll(selector);
  el.style.color = color;
  el.style.backgroundColor = color;
  return el;
}

//需要设置字体、背景颜色和大小
function setAgain (selector, color, px) {
  var el = set(selector, color)
  el.style.fontSize = px;
  return el;
}

以上只是简单的添加颜色,业务复杂而代码又不是你写的时候,你就必须去阅读之前的代码再修改它,显然是不符合开放-封闭原则的。修改后的function是返回了元素对象,使得下次需要改变时再次得到返回值做处理。

2.this的运用

可扩展性还包括对this的以及call和apply方法的灵活运用:

function sayBonjour() {
  alert(this.a)
}

obj.a = 1;
obj.say = sayBonjour;
obj.say();//1
//or
sayBonjour.call||apply(obj);//1

五、对错误的处理

1.预见错误

可以用 类型检测 typeof 或者try…catch。 typeof 会强制检测对象不抛出错误,对于未定义的变量尤其有用。

2.抛出错误

大多数开发者不希望出错了还需要自己去找带对应得代码,最好方式是直接在console中输出,告诉用户发生了什么事情。我们可以用到浏览器为我们提供的api输出这些信息:console.log/warn/error。你还可以为自己的程序留些后路: try…catch。

function error (a) {
  if(typeof a !== 'string') {
    console.error('param a must be type of string')
  }
}

function error() {
  try {
    // some code excucete here maybe throw wrong
  }catch(ex) {
    console.wran(ex);
  }
}

六、可预见性

可预见性味程序接口提供健壮性,为保证你的代码顺利执行,必须为它考虑到非正常预期的情况。我们看下不可以预见的代码和可预见的代码的区别用之前的setColor

//nighware
function set(selector, color) {
  document.getElementById(selector).style.color = color;
}

//dream
zepto.init = function(selector, context) {
  var dom
  // If nothing given, return an empty Zepto collection
  if (!selector) return zepto.Z()
  // Optimize for string selectors
  else if (typeof selector == 'string') {
    selector = selector.trim()
    // If it's a html fragment, create nodes from it
    // Note: In both Chrome 21 and Firefox 15, DOM error 12
    // is thrown if the fragment doesn't begin with <
    if (selector[0] == '<' && fragmentRE.test(selector))
      dom = zepto.fragment(selector, RegExp.$1, context), selector = null
    // If there's a context, create a collection on that context first, and select
    // nodes from there
    else if (context !== undefined) return $(context).find(selector)
    // If it's a CSS selector, use it to select nodes.
    else dom = zepto.qsa(document, selector)
  }
  // If a function is given, call it when the DOM is ready
  else if (isFunction(selector)) return $(document).ready(selector)
  // If a Zepto collection is given, just return it
  else if (zepto.isZ(selector)) return selector
  else {
    // normalize array if an array of nodes is given
    if (isArray(selector)) dom = compact(selector)
    // Wrap DOM nodes.
    else if (isObject(selector))
      dom = [selector], selector = null
    // If it's a html fragment, create nodes from it
    else if (fragmentRE.test(selector))
      dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null
    // If there's a context, create a collection on that context first, and select
    // nodes from there
    else if (context !== undefined) return $(context).find(selector)
    // And last but no least, if it's a CSS selector, use it to select nodes.
    else dom = zepto.qsa(document, selector)
  }
  // create a new Zepto collection from the nodes found
  return zepto.Z(dom, selector)
}

以上是zepto的源码,可以看见,作者在预见传入的参数时做了很多的处理。其实可预见性是为程序提供了若干的入口,无非是一些逻辑判断而已。zepto在这里使用了很多的是非判断,这样做的好处当然是代码比之前更健壮,但同时导致了代码的冗长,不适合阅读。总之,可预见性真正需要你做的事多写一些对位置实物的参数。把外部的检测改为内部检测。是的使用的人用起来舒心放心开心。呐!做人嘛最重要的就是海森啦。

七、注释和文档的可读性

一个最好的接口是不需要文档我们也会使用它,但是往往接口量一多和业务增加,接口使用起来也会有些费劲。所以接口文档和注释是需要认真书写的。注释遵循简单扼要地原则,给多年后的自己也给后来者看:

//注释接口,为了演示PPT用
function commentary() {
  //如果你定义一个没有字面意义的变量时,最好为它写上注释:a:没用的变量,可以删除
  var a;

  //在关键和有歧义的地方写上注释,犹如画龙点睛:路由到hash界面后将所有的数据清空结束函数
  return go.Navigate('hash', function(){
    data.clear();
  });
}

最后

推荐markdown语法书写API文档,github御用文档编写语法。简单、快速,代码高亮、话不多说上图

卤煮在此也推荐几个在线编辑的网站。诸君可自行前往练习使用。

https://www.zybuluo.com/mdeditor

http://mahua.jser.me/

参考博文

前端头条-javascript的api设计原则

原文:http://www.cnblogs.com/constantince/p/5580003.html

转载请注明:静觅 » JavaScript API 设计原则详解

Python3 模拟登录并爬取表格数据

0
0

本节主要内容有:

  • 通过requests库模拟表单提交
  • 通过pandas库提取网页表格

上周五,大师兄发给我一个网址,哭哭啼啼地求我:“去!把这个网页上所有年所有县所有作物的数据全爬下来,存到Access里!”

我看他可怜,勉为其难地挥挥手说:“好嘞,马上就开始!”

目标分析

大师兄给我的网址是这个:https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg

打开长这样:

根据我学爬虫并不久的经验,通常只要把年月日之类的参数附加到url里面去,然后用requests.get拿到response解析html就完了,所以这次应该也差不多——除了要先想办法获得具体有哪些年份、地名、作物名称,其他部分拿以前的代码稍微改改就能用了,毫无挑战性工作,生活真是太无聊了

点击 View Summary 后出现目标网页长这样

那个大表格的数据就是目标数据了,好像没什么了不起的——

有点不对劲

目标数据所在网页的网址是这样的:https://www.ctic.org/crm/?action=result ,刚刚选择的那些参数并没有作为url的参数啊!网址网页都变了,所以也不是ajax

这和我想象的情况有巨大差别啊

尝试获取目标页面

让我来康康点击View Summary这个按钮时到底发生了啥:右键View Summary检查是这样:

实话说,这是我第一次遇到要提交表单的活儿。以前可能是上天眷顾我,统统get就能搞定,今天终于让我碰上一个post了。

点击View Summary,到DevTools里找network第一条:

不管三七二十一,post一下试试看

import requests

url = 'https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg'
headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
           'AppleWebKit/537.36 (KHTML, like Gecko) '
           'Chrome/74.0.3729.131 Safari/537.36',
           'Host': 'www.ctic.org'}
data = {'_csrf': 'SjFKLWxVVkkaSRBYQWYYCA1TMG8iYR8ReUYcSj04Jh4EBzIdBGwmLw==',
        'CRMSearchForm[year]': '2011',
        'CRMSearchForm[format]': 'Acres',
        'CRMSearchForm[area]': 'County',
        'CRMSearchForm[region]': 'Midwest',
        'CRMSearchForm[state]': 'IL',
        'CRMSearchForm[county]': 'Adams',
        'CRMSearchForm[crop_type]': 'All',
        'summary': 'county'}
response = requests.post(url, data=data, headers=headers)
print(response.status_code)

果不其然,输出400……我猜这就是传说中的cookies在搞鬼吗?《Python3网络爬虫实战》只看到第6章的我不禁有些心虚跃跃欲试呢!

首先,我搞不清cookies具体是啥,只知道它是用来维持会话的,应该来自于第一次get,搞出来看看先:

response1 = requests.get(url, headers=headers)
if response1.status_code == 200:
    cookies = response1.cookies
    print(cookies)

输出:

<RequestsCookieJar[<Cookie PHPSESSID=52asgghnqsntitqd7c8dqesgh6 for www.ctic.org/>, <Cookie _csrf=2571c72a4ca9699915ea4037b967827150715252de98ea2173b162fa376bad33s%3A32%3A%22TAhjwgNo5ElZzV55k3DMeFoc5TWrEmXj%22%3B for www.ctic.org/>]>

Nah,看不懂,不看不管,直接把它放到post里试试

response2 = requests.post(url, data=data, headers=headers, cookies=cookies)
print(response2.status_code)

还是400,气氛突然变得有些焦灼,我给你cookies了啊,你还想要啥?!

突然,我发现一件事:post请求所带的data中那个一开始就显得很可疑的_csrf我仿佛在哪儿见过?

那个我完全看不懂的cookies里好像就有一个_csrf啊!但是两个_csrf的值很明显结构不一样,试了一下把data里的_csrf换成cookies里的_csrf确实也不行。

但是我逐渐有了一个想法:这个两个_csrf虽然不相等,但是应该是匹配的,我刚刚的data来自浏览器,cookies来自python程序,所以不匹配!

于是我又点开浏览器的DevTools,Ctrl+F搜索了一下,嘿嘿,发现了:



这三处。

第一处那里的下一行的csrf_token很明显就是post请求所带的data里的_csrf,另外两个是js里的函数,虽然js没好好学但也能看出来这俩是通过post请求获得州名和县名的,Binggo!一下子解决两个问题。

为了验证我的猜想,我打算先直接用requests获取点击View Summary前的页面的HTML和cookies,将从HTML中提取的csrf_token值作为点击View Summarypost请求的data里的_csrf值,同时附上cookies,这样两处_csrf就应该是匹配的了:

from lxml import etree
response1 = requests.get(url, headers=headers)
cookies = response1.cookies
html = etree.HTML(response1.text)
csrf_token = html.xpath('/html/head/meta[3]/@content')[0]
data.update({'_csrf': csrf_token})
response2 = requests.post(url, data=data, headers=headers, cookies=cookies)
print(response2.status_code)

输出200,虽然和Chrome显示的302不一样,但是也表示成功,那就不管了。把response2.text写入html文件打开看是这样:

Yeah,数据都在!说明我的猜想是对的!那一会再试试我从没用过的requests.Session()维持会话,自动处理cookies

尝试pandas库提取网页表格

现在既然已经拿到了目标页面的HTML,那在获取所有年、地区、州名、县名之前,先测试一下pandas.read_html提取网页表格的功能。

pandas.read_html这个函数时在写代码时IDE自动补全下拉列表里瞄到的,一直想试试来着,今天乘机拉出来溜溜:

import pandas as pd
df = pd.read_html(response2.text)[0]
print(df)

输出:

Yeah!拿到了,确实比自己手写提取方便,而且数值字符串自动转成数值,优秀!

准备所有参数

接下来要获取所有年、地区、州名、县名。年份和地区是写死在HTML里的,直接xpath获取:

州名、县名根据之前发现的两个js函数,要用post请求来获得,其中州名要根据地区名获取,县名要根据州名获取,套两层循环就行

def new():
    session = requests.Session()
    response = session.get(url=url, headers=headers)
    html = etree.HTML(response.text)
    return session, html

session, html = new()
years = html.xpath('//*[@id="crmsearchform-year"]/option/text()')
regions = html.xpath('//*[@id="crmsearchform-region"]/option/text()')
_csrf = html.xpath('/html/head/meta[3]/@content')[0]
region_state = {}
state_county = {}
for region in regions:
    data = {'region': region, '_csrf': _csrf}
    response = session.post(url_state, data=data)
    html = etree.HTML(response.json())
    region_state[region] = {x: y for x, y in
                            zip(html.xpath('//option/@value'),
                                html.xpath('//option/text()'))}
    for state in region_state[region]:
        data = {'state': state, '_csrf': _csrf}
        response = session.post(url_county, data=data)
        html = etree.HTML(response.json())
        state_county[state] = html.xpath('//option/@value')

啧啧,使用requests.Session就完全不需要自己管理cookies了,方便!具体获得的州名县名就不放出来了,实在太多了。然后把所有年、地区、州名、县名的可能组合先整理成csv文件,一会直接从csv里读取并构造post请求的data字典:

remain = [[str(year), str(region), str(state), str(county)] 
         for year in years for region in regions
         for state in region_state[region] for county in state_county[state]]
remain = pd.DataFrame(remain, columns=['CRMSearchForm[year]',
                                       'CRMSearchForm[region]',
                                       'CRMSearchForm[state]',
                                       'CRMSearchForm[county]'])
remain.to_csv('remain.csv', index=False)
# 由于州名有缩写和全称,也本地保存一份
import json
with open('region_state.json', 'w') as json_file:
        json.dump(region_state, json_file, indent=4)

我看了一下,一共49473行——也就是说至少要发送49473个post请求才能爬完全部数据,纯手工获取的话大概要点击十倍这个数字的次数……

正式开始

那么开始爬咯

import pyodbc
with open("region_state.json") as json_file:
    region_state = json.load(json_file)
data = pd.read_csv('remain.csv')
# 读取已经爬取的
cnxn = pyodbc.connect('DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};'
                      'DBQ=./ctic_crm.accdb')
crsr = cnxn.cursor()
crsr.execute('select Year_, Region, State, County from ctic_crm')
done = crsr.fetchall()
done = [list(x) for x in done]
done = pd.DataFrame([list(x) for x in done], columns=['CRMSearchForm[year]',
                                                      'CRMSearchForm[region]',
                                                      'CRMSearchForm[state]',
                                                      'CRMSearchForm[county]'])
done['CRMSearchForm[year]'] = done['CRMSearchForm[year]'].astype('int64')
state2st = {y: x for z in region_state.values() for x, y in z.items()}
done['CRMSearchForm[state]'] = [state2st[x]
                                for x in done['CRMSearchForm[state]']]
# 排除已经爬取的
remain = data.append(done)
remain = remain.drop_duplicates(keep=False)
total = len(remain)
print(f'{total} left.n')
del data

# %%
remain['CRMSearchForm[year]'] = remain['CRMSearchForm[year]'].astype('str')
columns = ['Crop',
           'Total_Planted_Acres',
           'Conservation_Tillage_No_Till',
           'Conservation_Tillage_Ridge_Till',
           'Conservation_Tillage_Mulch_Till',
           'Conservation_Tillage_Total',
           'Other_Tillage_Practices_Reduced_Till15_30_Residue',
           'Other_Tillage_Practices_Conventional_Till0_15_Residue']
fields = ['Year_', 'Units', 'Area', 'Region', 'State', 'County'] + columns
data = {'CRMSearchForm[format]': 'Acres',
        'CRMSearchForm[area]': 'County',
        'CRMSearchForm[crop_type]': 'All',
        'summary': 'county'}
headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
           'AppleWebKit/537.36 (KHTML, like Gecko) '
           'Chrome/74.0.3729.131 Safari/537.36',
           'Host': 'www.ctic.org',
           'Upgrade-Insecure-Requests': '1',
           'DNT': '1',
           'Connection': 'keep-alive'}
url = 'https://www.ctic.org/crm?tdsourcetag=s_pctim_aiomsg'
headers2 = headers.copy()
headers2 = headers2.update({'Referer': url,
                            'Origin': 'https://www.ctic.org'})
def new():
    session = requests.Session()
    response = session.get(url=url, headers=headers)
    html = etree.HTML(response.text)
    _csrf = html.xpath('/html/head/meta[3]/@content')[0]
    return session, _csrf
session, _csrf = new()
for _, row in remain.iterrows():
    temp = dict(row)
    data.update(temp)
    data.update({'_csrf': _csrf})
    while True:
        try:
            response = session.post(url, data=data, headers=headers2, timeout=15)
            break
        except Exception as e:
            session.close()
            print(e)
            print('nSleep 30s.n')
            time.sleep(30)
            session, _csrf = new()
            data.update({'_csrf': _csrf})

    df = pd.read_html(response.text)[0].dropna(how='all')
    df.columns = columns
    df['Year_'] = int(temp['CRMSearchForm[year]'])
    df['Units'] = 'Acres'
    df['Area'] = 'County'
    df['Region'] = temp['CRMSearchForm[region]']
    df['State'] = region_state[temp['CRMSearchForm[region]']][temp['CRMSearchForm[state]']]
    df['County'] = temp['CRMSearchForm[county]']
    df = df.reindex(columns=fields)
    for record in df.itertuples(index=False):
        tuple_record = tuple(record)
        sql_insert = f'INSERT INTO ctic_crm VALUES {tuple_record}'
        sql_insert = sql_insert.replace(', nan,', ', null,')
        crsr.execute(sql_insert)
        crsr.commit()
    print(total, row.to_list())
    total -= 1
else:
    print('Done!')
    crsr.close()
    cnxn.close()

注意中间有个try...except..语句,是因为不定时会发生Connection aborted的错误,有时9000次才断一次,有时一次就断,这也是我加上了读取已经爬取的排除已经爬取的原因,而且担心被识别出爬虫,把headers写的丰富了一些(好像并没有什么卵用),并且每次断开都暂停个30s并重新开一个会话

然后把程序开着过了一个周末,命令行里终于打出了Done!,到Access里一看有816288条记录,心想:下次试试多线程(进程)和代理池。


周一,我把跑出来的数据发给大师兄,大师兄回我:“好的”。

隔着屏幕我都能感受到滔滔不绝的敬仰和感激之情,

一直到现在,大师兄都感动地说不出话来。

转载请注明:静觅 » Python3 模拟登录并爬取表格数据


七分钟全面了解位运算

0
0

位运算是我们在编程中常会遇到的操作,但仍然有很多开发者并不了解位运算,这就导致在遇到位运算时会“打退堂鼓”。实际上,位运算并没有那么复杂,只要我们了解其运算基础和运算符的运算规则,就能够掌握位运算的知识。接下来,我们一起学习位运算的相关知识。

程序中的数在计算机内存中都是以二进制的形式存在的,位运算就是直接对整数在内存中对应的二进制位进行操作。

注意:本文只讨论整数运算,小数运算不在本文研究之列

位运算的基础

我们常用的 35 等数字是十进制表示,而位运算的基础是二进制。即人类采用十进制,机器采用的是二进制,要深入了解位运算,就需要了解十进制和二进制的转换方法和对应关系。

二进制

十进制转二进制时,采用“除 2 取余,逆序排列”法:

  1. 用 2 整除十进制数,得到商和余数;
  2. 再用 2 整除商,得到新的商和余数;
  3. 重复第 1 和第 2 步,直到商为 0;
  4. 将先得到的余数作为二进制数的高位,后得到的余数作为二进制数的低位,依次排序;

排序结果就是该十进制数的二进制表示。例如十进制数 101 转换为二进制数的计算过程如下:

101 % 2 = 50 余 1
50 % 2 = 25 余 0
25 % 2 = 12 余 1
12 % 2 = 6 余 0
6 % 2 = 3 余 0
3 % 2 = 1 余 1
1 % 2 = 0 余 1

逆序排列即二进制中的从高位到低位排序,得到 7 位二进制数为 1100101,如果要转换为 8 位二进制数,就需要在最高位补 0。即十进制数的 8 位二进制数为 01100101

其完整过程如下图所示:

有网友整理了常见的进制与 ASCII 码对照表,表内容如下:

ASCII 控制字符

ASCII 可显示字符

补码

现在,我们已经了解到二进制与十进制的换算方法,并拥有了进制对照表。但在开始学习位运算符之前,我们还需要了解补码的知识。

数值有正负之分,那么仅有 01 的二进制如何表示正负呢?

人们设定,二进制中最高位为 0 代表正,为 1 则代表负。例如 0000 1100 对应的十进制为 12,而 1000 1100 对应的十进制为 -12。这种表示被称作原码。但新的问题出现了,原本二进制的最高位始终为 0,为了表示正负又多出了 1,在执行运算时就会出错。举个例子,1 + (-2) 的二进制运算如下:

0000 0001 + 1000 0010 
= 1000 0011
= -3

这显然是有问题的,问题就处在这个代表正负的最高位。接着,人们又弄出了反码(二进制各位置的 01 互换,例如 0000 1100 的反码为 1111 0011)。此时,运算就会变成这样:

0000 0001 + 1111 1101
= 1111 1110
# 在转换成十进制前,需要再次反码
= 1000 0001 
= -1

这次好像正确了。但它仍然有例外,我们来看一下 1 + (-1)

0000 0001 + 1111 + 1110
= 1111 1111
= 1000 0000
= -0

零是没有正负之分的,为了解决这个问题,就搞出了补码的概念。补码是为了让负数变成能够加的正数,所以 负数的补码= 负数的绝对值取反 + 1,例如 -1 的补码为:

-1 的绝对值 1
= 0000 0001 # 1 的二进制原码
= 1111 1110 # 原码取反
= 1111 1111 # +1 后得到补码

-1 补码推导的完整过程如下图所示:

反过来,由补码推导原码的过程为 原码 = 补码 - 1,再求反。要注意的是,反码过程中,最高位的值不变,这样才能够保证结果的正负不会出错。例如 1 + (-6)1 + (-9) 的运算过程如下:

# 1 的补码 + -6 的补码
0000 0001 + 1111 1010
= 1111 1011 # 补码运算结果
= 1111 1010 # 对补码减 1,得到反码
= 1000 0101 # 反码取反,得到原码
= -5 # 对应的十进制

# 1 的补码 + -9 的补码
0000 0001 + 1111 0111
= 1111 1000 # 补码运算结果
= 1111 0111 # 对补码减 1,得到反码
= 1000 1000 # 反码取反,得到原码
= -8 # 对应的十进制

要注意的是,正数的补码与原码相同,不需要额外运算。也可以说,补码的出现就是为了解决负数运算时的符号问题。

人生苦短 我用 Python。

崔庆才|静觅 邀请你关注微信公众号:进击的Coder

运算符介绍

位运算分为 6 种,它们是:

名称 符号
按位与 &
按位或 |
按位异或 ^
按位取反 ~
左移运算 <<
右移运算 >>

按位与

按位与运算将参与运算的两数对应的二进制位相与,当对应的二进制位均为 1 时,结果位为 1,否则结果位为 0。按位与运算的运算符为 &,参与运算的数以补码方式出现。举个例子,将数字 5 和数字 8 进行按位与运算,其实是将数字 5 对应的二进制 0000 0101 和数字 8 对应的二进制 0000 1000 进行按位与运算,即:

0000 0101
&
0000 1000

根据按位与的规则,将各个位置的数进行比对。运算过程如下:

0000 0101
&
0000 1000
---- ----
0000 0000

由于它们对应位置中没有“均为 1 ”的情况,所以得到的结果是 0000 0000。数字 58 按位与运算的完整过程如下图:

将结果换算成十进制,得到 0,即 5&8 = 0

按位或

按位或运算将参与运算的两数对应的二进制位相或,只要对应的二进制位中有 1,结果位为 1,否则结果位为 0。按位或运算的运算符为 |,参与运算的数以补码方式出现。举个例子,将数字 3 和数字 7 进行按位或运算,其实是将数字 3 对应的二进制 0000 0011和数字 7 对应的二进制 0000 0111 进行按位或运算,即:

0000 0011
|
0000 0111

根据按位或的规则,将各个位置的数进行比对。运算过程如下:

0000 0011
|
0000 0111
---- ----
0000 0111

最终得到的结果为 0000 0111。将结果换算成十进制,得到 7,即 3|7 = 7

按位异或

按位异或运算将参与运算的两数对应的二进制位相异或,当对应的二进制位值不同时,结果位为 1,否则结果位为 0。按位异或的运算符为 ^,参与运算的数以补码方式出现。举个例子,将数字 12 和数字 7 进行按位异或运算,其实是将数字 12 对应的二进制 0000 1100 和数字 7 对应的二进制 0000 0111 进行按位异或运算,即:

0000 1100
^
0000 0111

根据按位异或的规则,将各个位置的数进行比对。运算过程如下:

0000 1100
^
0000 0111
---- ----
0000 1011

最终得到的结果为 0000 1011。将结果换算成十进制,得到 11,即 12^7 = 11

按位取反

按位取反运算将二进制数的每一个位上面的 0 换成 11 换成 0。按位取反的运算符为 ~,参与运算的数以补码方式出现。举个例子,对数字 9 进行按位取反运算,其实是将数字 9 对应的二进制 0000 1001 进行按位取反运算,即:

~0000 1001
= 0000 1001 # 补码,正数补码即原码
= 1111 1010 # 取反
= -10

最终得到的结果为 -10。再来看一个例子,-20 按位取反的过程如下:

~0001 0100
= 1110 1100 # 补码
= 0001 0011 # 取反
= 19

最终得到的结果为 19。我们从示例中找到了规律,按位取反的结果用数学公式表示:
$$
~x = -(x + 1)
$$
我们可以将其套用在 9-20 上:

~9 = -(9 + 1) = -10
~(-20) = -((-20) + 1) = 19

这个规律也可以作用于数字 0 上,即 ~0 = -(0 + 1) = -1

左移运算

左移运算将数对应的二进位全部向左移动若干位,高位丢弃,低位补 0。左移运算的运算符为 <<。举个例子,将数字 5 左移 4 位,其实是将数字 5 对应的二进制 0000 0101 中的二进位向左移动 4 位,即:

5 << 4
= 0000 0101 << 4
= 0101 0000 # 高位丢弃,低位补 0
= 80

数字 5 左移 4 位的完整运算过程如下图:

最终结果为 80。这等效于:
$$
5 (2) ^4
$$
也就是说,左移运算的规律为:
$$
x << n = x
(2) ^ n
$$

右移运算

右移运算将数对应的二进位全部向右移动若干位。对于左边的空位,如果是正数则补 0,负数可能补 01 (Turbo C 和很多编译器选择补 1)。右移运算的运算符为 >>。举个例子,将数字 80 右移 4 位,其实是将数字 80 对应的二进制 0101 0000 中的二进位向右移动 4 位,即:

80 >> 4
= 0101 0000 >> 4
= 0000 0101 # 正数补0,负数补1 
= 5

最终结果为 5。这等效于:
$$
80 \div (2)^4
$$
也就是说,右移运算的规律为:
$$
x >> n = x \div (2) ^ n
$$
要注意的是,不能整除时,取整数。这中除法取整的规则类似于 PYTHON 语言中的地板除。

超酷人生 我用 Rust

韦世东|奎因 邀请你关注微信公众号:Rust之禅

位运算的应用

在掌握了位运算的知识后,我们可以在开发中尝试使用它。坊间一直流传着位运算的效率高,速度快,但从未见过文献证明,所以本文不讨论效率和速度的问题。如果正在阅读文章的你有相关文献,请留言告知,谢谢。

判断数字奇偶

通常,我们会通过取余来判断数字是奇数还是偶数。例如判断 101 的奇偶用的方法是:

# python
if 101 % 2:
    print('偶数')
else:
    print('奇数')

我们也可以通过位运算中的按位与来实现奇偶判断,例如:

# python
if 101 & 1:
    print('奇数')
else:
    print('偶数')

这是因为奇数的二进制最低位始终为 1,而偶数的二进制最低为始终为 0。所以,无论任何奇数与 10000 0001 相与得到的都是 1,任何偶数与其相与得到的都是 0

变量交换

在 C 语言中,两个变量的交换必须通过第三个变量来实现。伪代码如下:

# 伪代码
a = 3, b = 5
c = a
a = b
b = a
--------
a = 5, b = 3

在 PYTHON 语言中并没有这么麻烦,可以直接交换。对应的 PYTHON 代码如下:

# python
a, b = 3, 5
a, b = b, a
print(a, b)

代码运行结果为 5 3。但大部分编程语言都不支持 PYTHON 这种写法,在这种情况下我们可以通过位运算中的按位异或来实现变量的交换。对应的伪代码如下:

# 伪代码
a = 3, b = 5
a = a ^ b
b = a ^ b
a = a ^ b

最后,a = 5, b = 3。我们可以用 C 语言和 PYTHON 语言进行验证,对应的 PYTHON 代码如下:

# python
a, b = 3, 5
a = a ^ b
b = a ^ b
a = a ^ b
print(a, b)

代码运行结果为 5 3,说明变量交换成功。对应的 C 代码如下:

#include<stdio.h>
void main()
{
    int a = 3, b = 5;
    printf("交换前:a=%d , b=%dn",a,b);
    a = a^b;
    b = a^b;
    a = a^b;
    printf("交换后:a=%d , b=%dn",a, b);           
}

代码运行结果如下:

交换前:a=3 , b=5
交换后:a=5 , b=3

这说明变量交换成功。

求 x 与 2 的 n 次方乘积

设一个数为 x,求 x2n 次方乘积。这用数学来计算都是非常简单的:
$$
x * (2) ^ n
$$
在位运算中,要实现这个需求只需要用到左移运算,即 x << n

取 x 的第 k 位

即取数字 x 对应的二进制的第 k 位上的二进制值。假设数字为 5,其对应的二进制为 0000 0101,取第 k 位二进制值的位运算为 x >> k & 1。我们可以用 PYTHON 代码进行验证:

# python
x = 5  # 0000 0101
for i in range(8):
    print(x >> i & 1)

代码运行结果如下:

1
0
1
0
0
0
0
0

这说明位运算的算法是正确的,可以满足我们的需求。

判断赋值

if a == x:
    x = b
else:
    x = a

等效于 x = a ^ b ^ x。我们可以通过 PYTHON 代码来验证:

# python
a, b, x = 6, 9, 6
if a == x:
    x = b
else:
    x = a
print(a, b, x)

代码运行结果为 699,与之等效的代码如下:

# python
a, b, x = 6, 9, 6
x = a ^ b ^ x
print(a, b, x)

这样就省去了 if else 的判断语句。

代替地板除

二分查找是最常用的算法之一,但它有一定的前提条件:二分查找的目标必须采用顺序存储结构,且元素有序排列。例如 PYTHON 中的有序列表。二分查找的最优复杂度为 O(1),最差时间复杂度为 O(log n)。举个例子,假设我们需要从列表 [1, 3, 5, 6, 7, 8, 12, 22, 23, 43, 65, 76, 90, 543] 中找到指定元素的下标,对应的 PYTHON 代码如下:

# python
def search(lis: list, x: int) -> int:
    """非递归二分查找
    返回指定元素在列表中的索引
    -1 代表不存在"""
    mix_index = 0
    max_index = len(lis) - 1
    while mix_index <= max_index:
        midpoint = (mix_index + max_index) // 2
        if lis[midpoint] < x:
            mix_index = mix_index + 1
        elif lis[midpoint] > x:
            max_index = max_index - 1
        else:
            return midpoint
    return -1

lists = [1, 3, 5, 6, 7, 8, 12, 22, 23, 43, 65, 76, 90, 543]
res = search(lists, 76)
print(res)

在取列表中间值时使用的语句是 midpoint = (mix_index + max_index) // 2,即地板除,我们可以将其替换为 midpoint = (mix_index + max_index) >> 1 最终得到的结果是相同的。这是因为左移 1位 等效于乘以 2,而右移 1 位等效于除以 2。这样的案例还有很多,此处不再赘述。

至此,我们已经对位运算有了一定的了解,希望你在工作中使用位运算。更多 Saoperation 和知识请扫描下方二维码。

转载请注明:静觅 » 七分钟全面了解位运算

一看就懂,Python 日志 logging 模块详解及应用

0
0

日志概述

百度百科的日志概述

Windows网络操作系统都设计有各种各样的日志文件,如应用程序日志,安全日志、系统日志、Scheduler服务日志、FTP日志、WWW日志、DNS服务器日志等等,这些根据你的系统开启的服务的不同而有所不同。我们在系统上进行一些操作时,这些日志文件通常会记录下我们操作的一些相关内容,这些内容对系统安全工作人员相当有用。比如说有人对系统进行了IPC探测,系统就会在安全日志里迅速地记下探测者探测时所用的IP、时间、用户名等,用FTP探测后,就会在FTP日志中记下IP、时间、探测所用的用户名等。

我映像中的日志

查看日志是开发人员日常获取信息、排查异常、发现问题的最好途径,日志记录中通常会标记有异常产生的原因、发生时间、具体错误行数等信息,这极大的节省了我们的排查时间,无形中提高了编码效率。

日志分类

我们可以按照输出终端进行分类,也可以按照日志级别进行分类。输出终端指的是将日志在控制台输出显示和将日志存入文件;日志级别指的是 Debug、Info、WARNING、ERROR以及CRITICAL等严重等级进行划分。

Python 的 logging

logging提供了一组便利的日志函数,它们分别是:debug()、 info()、 warning()、 error() 和 critical()。logging函数根据它们用来跟踪的事件的级别或严重程度来命名。标准级别及其适用性描述如下(以严重程度递增排序):

每个级别对应的数字值为
CRITICAL:50,ERROR:40,WARNING:30,INFO:20,DEBUG:10,NOTSET:0。
Python 中日志的默认等级是 WARNING,DEBUG 和 INFO 级别的日志将不会得到显示,在 logging 中更改设置。

日志输出

输出到控制台

使用 logging 在控制台打印日志,这里我们用 Pycharm 编辑器来观察:

import logging

logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')


从上图运行的结果来看,的确只显示了 WARNING 级别的信息,验证了上面的观点。同时也在控制台输出了日志内容,默认情况下 Python 中使用 logging 模块中的函数打印日志,日志只会在控制台输出,而不会保存到日文件。

有什么办法可以改变默认的日志级别呢?

当然是有的,logging 中提供了 basicConfig 让使用者可以适时调节默认日志级别,我们可以将上面的代码改为:

import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')

在 basicConfig 中设定 level 参数的级别即可。

思考:如果设定级别为 logging.INFO,那 DEBUG 信息能够显示么?

保存到文件

刚才演示了如何在控制台输出日志内容,并且自由设定日志的级别,那现在就来看看如何将日志保存到文件。依旧是强大的 basicConfig,我们再将上面的代码改为:

import logging

logging.basicConfig(level=logging.DEBUG, filename='coder.log', filemode='a')
logging.debug('崔庆才丨静觅、韦世东丨奎因')
logging.warning('邀请你关注微信公众号【进击的 Coder】')
logging.info('和大佬一起coding、共同进步')


在配置中填写 filename (指定文件名) 和 filemode (文件写入方式),控制台的日志输出就不见了,那么 coder.log 会生成么?


在 .py 文件的同级目录生成了名为 coder.log 的日志。

通过简单的代码设置,我们就完成了日志文件在控制台和文件中的输出。那既在控制台显示又能保存到文件中呢?

强大的 logging

logging所提供的模块级别的日志记录函数是对logging日志系统相关类的封装

logging 模块提供了两种记录日志的方式:

  • 使用logging提供的模块级别的函数
  • 使用Logging日志系统的四大组件

这里提到的级别函数就是上面所用的 DEBGE、ERROR 等级别,而四大组件则是指 loggers、handlers、filters 和 formatters 这几个组件,下图简单明了的阐述了它们各自的作用:


日志器(logger)是入口,真正工作的是处理器(handler),处理器(handler)还可以通过过滤器(filter)和格式器(formatter)对要输出的日志内容做过滤和格式化等处理操作。

四大组件

下面介绍下与logging四大组件相关的类:Logger, Handler, Filter, Formatter。

Logger类

Logger 对象有3个工作要做:

1)向应用程序代码暴露几个方法,使应用程序可以在运行时记录日志消息;
2)基于日志严重等级(默认的过滤设施)或filter对象来决定要对哪些日志进行后续处理;
3)将日志消息传送给所有感兴趣的日志handlers。

Logger对象最常用的方法分为两类:配置方法 和 消息发送方法

最常用的配置方法如下:

关于Logger.setLevel()方法的说明:

内建等级中,级别最低的是DEBUG,级别最高的是CRITICAL。例如setLevel(logging.INFO),此时函数参数为INFO,那么该logger将只会处理INFO、WARNING、ERROR和CRITICAL级别的日志,而DEBUG级别的消息将会被忽略/丢弃。

logger对象配置完成后,可以使用下面的方法来创建日志记录:


那么,怎样得到一个Logger对象呢?一种方式是通过Logger类的实例化方法创建一个Logger类的实例,但是我们通常都是用第二种方式–logging.getLogger()方法。

logging.getLogger()方法有一个可选参数name,该参数表示将要返回的日志器的名称标识,如果不提供该参数,则其值为’root’。若以相同的name参数值多次调用getLogger()方法,将会返回指向同一个logger对象的引用。

关于logger的层级结构与有效等级的说明:

    logger的名称是一个以'.'分割的层级结构,每个'.'后面的logger都是'.'前面的logger的children,例如,有一个名称为 foo 的logger,其它名称分别为 foo.bar, foo.bar.baz 和 foo.bam都是 foo 的后代。
    logger有一个"有效等级(effective level)"的概念。如果一个logger上没有被明确设置一个level,那么该logger就是使用它parent的level;如果它的parent也没有明确设置level则继续向上查找parent的parent的有效level,依次类推,直到找到个一个明确设置了level的祖先为止。需要说明的是,root logger总是会有一个明确的level设置(默认为 WARNING)。当决定是否去处理一个已发生的事件时,logger的有效等级将会被用来决定是否将该事件传递给该logger的handlers进行处理。
    child loggers在完成对日志消息的处理后,默认会将日志消息传递给与它们的祖先loggers相关的handlers。因此,我们不必为一个应用程序中所使用的所有loggers定义和配置handlers,只需要为一个顶层的logger配置handlers,然后按照需要创建child loggers就可足够了。我们也可以通过将一个logger的propagate属性设置为False来关闭这种传递机制。

Handler

Handler对象的作用是(基于日志消息的level)将消息分发到handler指定的位置(文件、网络、邮件等)。Logger对象可以通过addHandler()方法为自己添加0个或者更多个handler对象。比如,一个应用程序可能想要实现以下几个日志需求:

1)把所有日志都发送到一个日志文件中;
2)把所有严重级别大于等于error的日志发送到stdout(标准输出);
3)把所有严重级别为critical的日志发送到一个email邮件地址。
这种场景就需要3个不同的handlers,每个handler复杂发送一个特定严重级别的日志到一个特定的位置。

一个handler中只有非常少数的方法是需要应用开发人员去关心的。对于使用内建handler对象的应用开发人员来说,似乎唯一相关的handler方法就是下面这几个配置方法:


需要说明的是,应用程序代码不应该直接实例化和使用Handler实例。因为Handler是一个基类,它只定义了素有handlers都应该有的接口,同时提供了一些子类可以直接使用或覆盖的默认行为。下面是一些常用的Handler:

Formater

Formater对象用于配置日志信息的最终顺序、结构和内容。与logging.Handler基类不同的是,应用代码可以直接实例化Formatter类。另外,如果你的应用程序需要一些特殊的处理行为,也可以实现一个Formatter的子类来完成。

Formatter类的构造方法定义如下:

logging.Formatter.__init__(fmt=None, datefmt=None, style='%')

该构造方法接收3个可选参数:

  • fmt:指定消息格式化字符串,如果不指定该参数则默认使用message的原始值
  • datefmt:指定日期格式字符串,如果不指定该参数则默认使用”%Y-%m-%d %H:%M:%S”
  • style:Python 3.2新增的参数,可取值为 ‘%’, ‘{‘和 ‘$’,如果不指定该参数则默认使用’%’

Filter

Filter可以被Handler和Logger用来做比level更细粒度的、更复杂的过滤功能。Filter是一个过滤器基类,它只允许某个logger层级下的日志事件通过过滤。该类定义如下:

class logging.Filter(name='')
    filter(record)

比如,一个filter实例化时传递的name参数值为’A.B’,那么该filter实例将只允许名称为类似如下规则的loggers产生的日志记录通过过滤:’A.B’,’A.B,C’,’A.B.C.D’,’A.B.D’,而名称为’A.BB’, ‘B.A.B’的loggers产生的日志则会被过滤掉。如果name的值为空字符串,则允许所有的日志事件通过过滤。

filter方法用于具体控制传递的record记录是否能通过过滤,如果该方法返回值为0表示不能通过过滤,返回值为非0表示可以通过过滤。

说明:

    如果有需要,也可以在filter(record)方法内部改变该record,比如添加、删除或修改一些属性。
    我们还可以通过filter做一些统计工作,比如可以计算下被一个特殊的logger或handler所处理的record数量等。

实战演练

上面文绉绉的说了(复制/粘贴)那么多,现在应该动手实践了。

现在我需要既将日志输出到控制台、又能将日志保存到文件,我应该怎么办?

利用刚才所学的知识,我们可以构思一下:

看起来好像也不难,挺简单的样子,但是实际如此吗?

在实际的工作或应用中,我们或许还需要指定文件存放路径、用随机数作为日志文件名、显示具体的信息输出代码行数、日志信息输出日期和日志写入方式等内容。再构思一下:


具体代码如下:

import os
import logging
import uuid
from logging import Handler, FileHandler, StreamHandler

class PathFileHandler(FileHandler):
    def __init__(self, path, filename, mode='a', encoding=None, delay=False):

        filename = os.fspath(filename)
        if not os.path.exists(path):
            os.mkdir(path)
        self.baseFilename = os.path.join(path, filename)
        self.mode = mode
        self.encoding = encoding
        self.delay = delay
        if delay:
            Handler.__init__(self)
            self.stream = None
        else:
            StreamHandler.__init__(self, self._open())

class Loggers(object):
    # 日志级别关系映射
    level_relations = {
        'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING,
        'error': logging.ERROR, 'critical': logging.CRITICAL
    }

    def __init__(self, filename='{uid}.log'.format(uid=uuid.uuid4()), level='info', log_dir='log',
                 fmt='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s'):
        self.logger = logging.getLogger(filename)
        abspath = os.path.dirname(os.path.abspath(__file__))
        self.directory = os.path.join(abspath, log_dir)
        format_str = logging.Formatter(fmt)  # 设置日志格式
        self.logger.setLevel(self.level_relations.get(level))  # 设置日志级别
        stream_handler = logging.StreamHandler()  # 往屏幕上输出
        stream_handler.setFormatter(format_str)
        file_handler = PathFileHandler(path=self.directory, filename=filename, mode='a')
        file_handler.setFormatter(format_str)
        self.logger.addHandler(stream_handler)
        self.logger.addHandler(file_handler)

if __name__ == "__main__":
    txt = "关注公众号【进击的 Coder】,回复『日志代码』可以领取文章中完整的代码以及流程图"
    log = Loggers(level='debug')
    log.logger.info(4)
    log.logger.info(5)
    log.logger.info(txt)

文件保存后运行,运行结果如下图所示:

日志确实在控制台输出了,再来看一下目录内是否生成有指定的文件和文件夹:

文件打开后可以看到里面输出的内容:

正确的学习方式是什么

是一步步的看着文章介绍,等待博主结论?

是拿着代码运行,跑一遍?

都不是,应该是一边看着文章,一边拿着示例代码琢磨和研究,到底哪里可以改进、哪里可以设计得更好。如果你需要文章中所用到的示例代码和流程图,那么关注微信公众号【进击的 Coder】,回复『日志代码』就可以领取文章中完整的代码以及流程图。毕竟,学习是一件勤劳的事。

参考资料:

云游道士博文

nancy05博文

转载请注明:静觅 » 一看就懂,Python 日志 logging 模块详解及应用

程序员开发必知必会之正则表达式学习资料

0
0

正则表达式30分钟入门教程(https://deerchao.net/tutorials/regex/regex.htm

本教程目标:30分钟内让你明白正则表达式是什么,并对它有一些基本的了解,让你可以在自己的程序或网页里使用它。

正则表达式 必知必会(https://www.zybuluo.com/Yano/note/475174

Zjmainstay学习笔记 | 正则表达式(http://www.zjmainstay.cn/regexp

《精通正则表达式 第三版》

  1. 最后,推荐一本动物书《精通正则表达式 第三版》

【顺手提供】精通正则表达式:第三版 PDF (高清-中文-带标签)

关注本公众号【离不开的网】,后台回复 “ 正则pdf ” 即可。

相关好文推荐

  1. 想精通正则表达式 这几个正则表达式学习资料及工具你必须有 :https://www.cnblogs.com/3rocks/p/11212724.html

  2. 菜鸟教程-正则表达式 :https://www.runoob.com/regexp/regexp-tutorial.html

  3. 正则表达式速查表 :https://www.jb51.net/article/67634.htm

  4. 细说python正则表达式 :https://www.jianshu.com/p/147fab022566

  5. 路人甲的关于正则表达式 :https://zhuanlan.zhihu.com/p/21341872?refer=passer

  6. 最全的常用正则表达式大全——包括校验数字、字符、一些特殊的需求等等 :http://www.cnblogs.com/zxin/archive/2013/01/26/2877765.html

  7. 深入理解正则表达式 :https://www.cnblogs.com/China3S/archive/2013/11/30/3451971.html

原文链接:https://mp.weixin.qq.com/s/CGSUJntKtvOrV1o-R2GrRw

来源公众号:离不开的网

转载请注明:静觅 » 程序员开发必知必会之正则表达式学习资料

Python 爬虫利器之 Pyppeteer 的用法

0
0

如果大家对 Python 爬虫有所了解的话,想必你应该听说过 Selenium 这个库,这实际上是一个自动化测试工具,现在已经被广泛用于网络爬虫中来应对 JavaScript 渲染的页面的抓取。

但 Selenium 用的时候有个麻烦事,就是环境的相关配置,得安装好相关浏览器,比如 Chrome、Firefox 等等,然后还要到官方网站去下载对应的驱动,最重要的还需要安装对应的 Python Selenium 库,确实是不是很方便,另外如果要做大规模部署的话,环境配置的一些问题也是个头疼的事情。

那么本节就介绍另一个类似的替代品,叫做 Pyppeteer。注意,是叫做 Pyppeteer,不是 Puppeteer。Puppeteer 是 Google 基于 Node.js 开发的一个工具,有了它我们可以通过 JavaScript 来控制 Chrome 浏览器的一些操作,当然也可以用作网络爬虫上,其 API 极其完善,功能非常强大。 而 Pyppeteer 又是什么呢?它实际上是 Puppeteer 的 Python 版本的实现,但他不是 Google 开发的,是一位来自于日本的工程师依据 Puppeteer 的一些功能开发出来的非官方版本。

在 Pyppetter 中,实际上它背后也是有一个类似 Chrome 浏览器的 Chromium 浏览器在执行一些动作进行网页渲染,首先说下 Chrome 浏览器和 Chromium 浏览器的渊源。

Chromium 是谷歌为了研发 Chrome 而启动的项目,是完全开源的。二者基于相同的源代码构建,Chrome 所有的新功能都会先在 Chromium 上实现,待验证稳定后才会移植,因此 Chromium 的版本更新频率更高,也会包含很多新的功能,但作为一款独立的浏览器,Chromium 的用户群体要小众得多。两款浏览器“同根同源”,它们有着同样的 Logo,但配色不同,Chrome 由蓝红绿黄四种颜色组成,而 Chromium 由不同深度的蓝色构成。

总的来说,两款浏览器的内核是一样的,实现方式也是一样的,可以认为是开发版和正式版的区别,功能上基本是没有太大区别的。

Pyppeteer 就是依赖于 Chromium 这个浏览器来运行的。那么有了 Pyppeteer 之后,我们就可以免去那些繁琐的环境配置等问题。如果第一次运行的时候,Chromium 浏览器没有安全,那么程序会帮我们自动安装和配置,就免去了繁琐的环境配置等工作。另外 Pyppeteer 是基于 Python 的新特性 async 实现的,所以它的一些执行也支持异步操作,效率相对于 Selenium 来说也提高了。

那么下面就让我们来一起了解下 Pyppeteer 的相关用法吧。

安装

首先就是安装问题了,由于 Pyppeteer 采用了 Python 的 async 机制,所以其运行要求的 Python 版本为 3.5 及以上。

安装方式非常简单:

pip3 install pyppeteer

好了,安装完成之后我们命令行下测试下:

>>> import pyppeteer

如果没有报错,那么就证明安装成功了。

快速上手

接下来我们测试下基本的页面渲染操作,这里我们选用的网址为:http://quotes.toscrape.com/js/,这个页面是 JavaScript 渲染而成的,用基本的 requests 库请求得到的 HTML 结果里面是不包含页面中所见的条目内容的。

为了证明 requests 无法完成正常的抓取,我们可以先用如下代码来测试一下:

import requests
from pyquery import PyQuery as pq

url = 'http://quotes.toscrape.com/js/'
response = requests.get(url)
doc = pq(response.text)
print('Quotes:', doc('.quote').length)

这里首先使用 requests 来请求网页内容,然后使用 pyquery 来解析页面中的每一个条目。观察源码之后我们发现每个条目的 class 名为 quote,所以这里选用了 .quote 这个 CSS 选择器来选择,最后输出条目数量。

运行结果:

Quotes: 0

结果是 0,这就证明使用 requests 是无法正常抓取到相关数据的。因为什么?因为这个页面是 JavaScript 渲染而成的,我们所看到的内容都是网页加载后又执行了 JavaScript 之后才呈现出来的,因此这些条目数据并不存在于原始 HTML 代码中,而 requests 仅仅抓取的是原始 HTML 代码。

好的,所以遇到这种类型的网站我们应该怎么办呢?

其实答案有很多:

  • 分析网页源代码数据,如果数据是隐藏在 HTML 中的其他地方,以 JavaScript 变量的形式存在,直接提取就好了。
  • 分析 Ajax,很多数据可能是经过 Ajax 请求时候获取的,所以可以分析其接口。
  • 模拟 JavaScript 渲染过程,直接抓取渲染后的结果。

而 Pyppeteer 和 Selenium 就是用的第三种方法,下面我们再用 Pyppeteer 来试试,如果用 Pyppeteer 实现如上页面的抓取的话,代码就可以写为如下形式:

import asyncio
from pyppeteer import launch
from pyquery import PyQuery as pq

async def main():
    browser = await launch()
    page = await browser.newPage()
    await page.goto('http://quotes.toscrape.com/js/')
    doc = pq(await page.content())
    print('Quotes:', doc('.quote').length)
    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

运行结果:

Quotes: 10

看运行结果,这说明我们就成功匹配出来了 class 为 quote 的条目,总数为 10 条,具体的内容可以进一步使用 pyquery 解析查看。

那么这里面的过程发生了什么?

实际上,Pyppeteer 整个流程就完成了浏览器的开启、新建页面、页面加载等操作。另外 Pyppeteer 里面进行了异步操作,所以需要配合 async/await 关键词来实现。

首先, launch 方法会新建一个 Browser 对象,然后赋值给 browser,然后调用 newPage 方法相当于浏览器中新建了一个选项卡,同时新建了一个 Page 对象。然后 Page 对象调用了 goto 方法就相当于在浏览器中输入了这个 URL,浏览器跳转到了对应的页面进行加载,加载完成之后再调用 content 方法,返回当前浏览器页面的源代码。然后进一步地,我们用 pyquery 进行同样地解析,就可以得到 JavaScript 渲染的结果了。

另外其他的一些方法如调用 asyncio 的 get_event_loop 等方法的相关操作则属于 Python 异步 async 相关的内容了,大家如果不熟悉可以了解下 Python 的 async/await 的相关知识。

好,通过上面的代码,我们就可以完成 JavaScript 渲染页面的爬取了。

在这个过程中,我们没有配置 Chrome 浏览器,没有配置浏览器驱动,免去了一些繁琐的步骤,同样达到了 Selenium 的效果,还实现了异步抓取,爽歪歪!

接下来我们再看看另外一个例子,这个例子可以模拟网页截图,保存 PDF,另外还可以执行自定义的 JavaScript 获得特定的内容,代码如下:

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch()
    page = await browser.newPage()
    await page.goto('http://quotes.toscrape.com/js/')
    await page.screenshot(path='example.png')
    await page.pdf(path='example.pdf')
    dimensions = await page.evaluate('''() => {
        return {
            width: document.documentElement.clientWidth,
            height: document.documentElement.clientHeight,
            deviceScaleFactor: window.devicePixelRatio,
        }
    }''')

    print(dimensions)
    # >>> {'width': 800, 'height': 600, 'deviceScaleFactor': 1}
    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

这里我们又用到了几个新的 API,完成了网页截图保存、网页导出 PDF 保存、执行 JavaScript 并返回对应数据。

首先 screenshot 方法可以传入保存的图片路径,另外还可以指定保存格式 type、清晰度 quality、是否全屏 fullPage、裁切 clip 等各个参数实现截图。

截图的样例如下:

可以看到它返回的就是 JavaScript 渲染后的页面。

pdf 方法也是类似的,只不过页面保存格式不一样,最后得到一个多页的 pdf 文件,样例如下:

可见其内容也是 JavaScript 渲染后的内容,另外这个方法还可以指定放缩大小 scale、页码范围 pageRanges、宽高 width 和 height、方向 landscape 等等参数,导出定制化的 pdf 用这个方法就十分方便。

最后我们又调用了 evaluate 方法执行了一些 JavaScript,JavaScript 传入的是一个函数,使用 return 方法返回了网页的宽高、像素大小比率三个值,最后得到的是一个 JSON 格式的对象,内容如下:

{'width': 800, 'height': 600, 'deviceScaleFactor': 1}

OK,实例就先感受到这里,还有太多太多的功能还没提及。

总之利用 Pyppeteer 我们可以控制浏览器执行几乎所有动作,想要的操作和功能基本都可以实现,用它来自由地控制爬虫当然就不在话下了。

详细用法

了解了基本的实例之后,我们再来梳理一下 Pyppeteer 的一些基本和常用操作。Pyppeteer 的几乎所有功能都能在其官方文档的 API Reference 里面找到,链接为:https://miyakogi.github.io/pyppeteer/reference.html,用到哪个方法就来这里查询就好了,参数不必死记硬背,即用即查就好

开启浏览器

使用 Pyppeteer 的第一步便是启动浏览器,首先我们看下怎样启动一个浏览器,其实就相当于我们点击桌面上的浏览器图标一样,把它开起来。用 Pyppeteer 完成同样的操作,只需要调用 launch 方法即可。

我们先看下 launch 方法的 API,链接为:https://miyakogi.github.io/pyppeteer/reference.html#pyppeteer.launcher.launch,其方法定义如下:

pyppeteer.launcher.launch(options: dict = None, **kwargs) → pyppeteer.browser.Browser

可以看到它处于 launcher 模块中,参数没有在声明中特别指定,返回类型是 browser 模块中的 Browser 对象,另外观察源码发现这是一个 async 修饰的方法,所以调用它的时候需要使用 await。

接下来看看它的参数:

  • ignoreHTTPSErrors (bool): 是否要忽略 HTTPS 的错误,默认是 False。
  • headless (bool): 是否启用 Headless 模式,即无界面模式,如果 devtools 这个参数是 True 的话,那么该参数就会被设置为 False,否则为 True,即默认是开启无界面模式的。
  • executablePath (str): 可执行文件的路径,如果指定之后就不需要使用默认的 Chromium 了,可以指定为已有的 Chrome 或 Chromium。
  • slowMo (int|float): 通过传入指定的时间,可以减缓 Pyppeteer 的一些模拟操作。
  • args (List[str]): 在执行过程中可以传入的额外参数。
  • ignoreDefaultArgs (bool): 不使用 Pyppeteer 的默认参数,如果使用了这个参数,那么最好通过 args 参数来设定一些参数,否则可能会出现一些意想不到的问题。这个参数相对比较危险,慎用。
  • handleSIGINT (bool): 是否响应 SIGINT 信号,也就是可以使用 Ctrl + C 来终止浏览器程序,默认是 True。
  • handleSIGTERM (bool): 是否响应 SIGTERM 信号,一般是 kill 命令,默认是 True。
  • handleSIGHUP (bool): 是否响应 SIGHUP 信号,即挂起信号,比如终端退出操作,默认是 True。
  • dumpio (bool): 是否将 Pyppeteer 的输出内容传给 process.stdout 和 process.stderr 对象,默认是 False。
  • userDataDir (str): 即用户数据文件夹,即可以保留一些个性化配置和操作记录。
  • env (dict): 环境变量,可以通过字典形式传入。
  • devtools (bool): 是否为每一个页面自动开启调试工具,默认是 False。如果这个参数设置为 True,那么 headless 参数就会无效,会被强制设置为 False。
  • logLevel (int|str): 日志级别,默认和 root logger 对象的级别相同。
  • autoClose (bool): 当一些命令执行完之后,是否自动关闭浏览器,默认是 True。
  • loop (asyncio.AbstractEventLoop): 时间循环对象。

好了,知道这些参数之后,我们可以先试试看。

首先可以试用下最常用的参数 headless,如果我们将它设置为 True 或者默认不设置它,在启动的时候我们是看不到任何界面的,如果把它设置为 False,那么在启动的时候就可以看到界面了,一般我们在调试的时候会把它设置为 False,在生产环境上就可以设置为 True,我们先尝试一下关闭 headless 模式:

import asyncio
from pyppeteer import launch

async def main():
    await launch(headless=False)
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

运行之后看不到任何控制台输出,但是这时候就会出现一个空白的 Chromium 界面了:

但是可以看到这就是一个光秃秃的浏览器而已,看一下相关信息:

看到了,这就是 Chromium,上面还写了开发者内部版本,可以认为是开发版的 Chrome 浏览器就好。

另外我们还可以开启调试模式,比如在写爬虫的时候会经常需要分析网页结构还有网络请求,所以开启调试工具还是很有必要的,我们可以将 devtools 参数设置为 True,这样每开启一个界面就会弹出一个调试窗口,非常方便,示例如下:

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(devtools=True)
    page = await browser.newPage()
    await page.goto('https://www.baidu.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

刚才说过 devtools 这个参数如果设置为了 True,那么 headless 就会被关闭了,界面始终会显现出来。在这里我们新建了一个页面,打开了百度,界面运行效果如下:

这时候我们可以看到上面的一条提示:”Chrome 正受到自动测试软件的控制”,这个提示条有点烦,那咋关闭呢?这时候就需要用到 args 参数了,禁用操作如下:

browser = await launch(headless=False, args=['--disable-infobars'])

这里就不再写完整代码了,就是在 launch 方法中,args 参数通过 list 形式传入即可,这里使用的是 –disable-infobars 的参数。

另外有人就说了,这里你只是把提示关闭了,有些网站还是会检测到是 webdriver 吧,比如淘宝检测到是 webdriver 就会禁止登录了,我们可以试试:

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(headless=False)
    page = await browser.newPage()
    await page.goto('https://www.taobao.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

运行时候进行一下登录,然后就会弹出滑块,自己手动拖动一下,然后就报错了,界面如下:

爬虫的时候看到这界面是很让人崩溃的吧,而且这时候我们还发现了页面的 bug,整个浏览器窗口比显示的内容窗口要大,这个是某些页面会出现的情况,让人看起来很不爽。

我们可以先解决一下这个显示的 bug,需要设置下 window-size 还有 viewport,代码如下:

import asyncio
from pyppeteer import launch

width, height = 1366, 768

async def main():
    browser = await launch(headless=False,
                           args=[f'--window-size={width},{height}'])
    page = await browser.newPage()
    await page.setViewport({'width': width, 'height': height})
    await page.goto('https://www.taobao.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

这样整个界面就正常了:

OK,那刚才所说的 webdriver 检测问题怎样来解决呢?其实淘宝主要通过 window.navigator.webdriver 来对 webdriver 进行检测,所以我们只需要使用 JavaScript 将它设置为 false 即可,代码如下:

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(headless=False, args=['--disable-infobars'])
    page = await browser.newPage()
    await page.goto('https://login.taobao.com/member/login.jhtml?redirectURL=https://www.taobao.com/')
    await page.evaluate(
        '''() =>{ Object.defineProperties(navigator,{ webdriver:{ get: () => false } }) }''')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

这里没加输入用户名密码的代码,当然后面可以自行添加,下面打开之后,我们点击输入用户名密码,然后这时候会出现一个滑动条,这里滑动的话,就可以通过了,如图所示:

OK,这样的话我们就成功规避了 webdriver 的检测,使用鼠标拖动模拟就可以完成淘宝的登录了。

还有另一种方法可以进一步免去淘宝登录的烦恼,那就是设置用户目录。平时我们已经注意到,当我们登录淘宝之后,如果下次再次打开浏览器发现还是登录的状态。这是因为淘宝的一些关键 Cookies 已经保存到本地了,下次登录的时候可以直接读取并保持登录状态。

那么这些信息保存在哪里了呢?其实就是保存在用户目录下了,里面不仅包含了浏览器的基本配置信息,还有一些 Cache、Cookies 等各种信息都在里面,如果我们能在浏览器启动的时候读取这些信息,那么启动的时候就可以恢复一些历史记录甚至一些登录状态信息了。

这也就解决了一个问题:很多朋友在每次启动 Selenium 或 Pyppeteer 的时候总是是一个全新的浏览器,那就是没有设置用户目录,如果设置了它,每次打开就不再是一个全新的浏览器了,它可以恢复之前的历史记录,也可以恢复很多网站的登录信息。

那么这个怎么来做呢?很简单,在启动的时候设置 userDataDir 就好了,示例如下:

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(headless=False, userDataDir='./userdata', args=['--disable-infobars'])
    page = await browser.newPage()
    await page.goto('https://www.taobao.com')
    await asyncio.sleep(100)

asyncio.get_event_loop().run_until_complete(main())

好,这里就是加了一个 userDataDir 的属性,值为 userdata,即当前目录的 userdata 文件夹。我们可以首先运行一下,然后登录一次淘宝,这时候我们同时可以观察到在当前运行目录下又多了一个 userdata 的文件夹,里面的结构是这样子的:

具体的介绍可以看官方的一些说明,如:https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md,这里面介绍了 userdatadir 的相关内容。

再次运行上面的代码,这时候可以发现现在就已经是登录状态了,不需要再次登录了,这样就成功跳过了登录的流程。当然可能时间太久了,Cookies 都过期了,那还是需要登录的。

好了,本想把 Pyppeteer 的用法详细介绍完的,结果只 launch 的方法就介绍这么多了,后面的内容放到其他文章来介绍了,其他的内容后续文章会陆续放出,谢谢。

本节代码获取

公众号”进击的Coder”回复”Pyppeteer”即可获取本节全部代码。

转载请注明:静觅 » Python 爬虫利器之 Pyppeteer 的用法

5G时代谁领风骚:先看看2G、3G、4G时代都崛起了哪些公司?

0
0

6月6日工信部正式向中国电信、中国移动、中国联通、中国广电发放5G商用牌照。自此,中国正式进入5G商用元年。

就中国而讲,2G时代门户网站林立、社交软件初起,3G时代智能手机大战、社交类软件成为王者,4G时代直播与短视频风光无二、信息流成热话题,那5G时代谁能独领风骚?

在5G还未全面普及之前,我们回顾一下并不遥远的昨天,在2G、3G、4G的兴起时,哪些公司应运而生,成为巨头,哪些巨头又轰然倒塌,成为历史的一部分。

2G时代,QQ崛起,阿里京东起家,门户网站林立

中国互联网的发展至今也只20年有余,自20世纪90年代末,中国人从1G时代代表性手机大哥大(摩托罗拉)手机换成了2G时代代表性手机诺基亚,彼时手机不只是接打电话,增加了发短信甚至邮件的功能。

20世纪90年代末期中国,还处在纸媒、广播和电视一统天下的传统媒体时代,但经济的迅猛发展已经造成信息饥渴,彼时媒体所提供的信息无论从丰富程度还是传播速度上都很难满足用户需求。

一个从美国麻省理工学院(MIT)攻读博士学位归来的“天之骄子”带回了一个新鲜事物,由于被美国互联网的发展深深震撼,张朝阳回国创建了中国第一家门户网站——搜狐。那是在1998年,阿里巴巴还没诞生,马化腾的QQ也未问世,李彦宏还在美国硅谷,中国互联网的舞台上,也只有张朝阳和他的搜狐。

竞争对手还未成长,搜狐独享巨大的互联网红利,2000年就上市,占据着中国门户网站头部企业的位置。

同样1998年,在搜狐成立后不到10个月,王志东的新浪网于年底成立,当时的口号是在互联网上建立全球最大的华人网站。以体育新闻传播为起点的新浪迅速扩张,进阶成为综合性新闻门户。

当时中国门户网站受资本青睐的程度,以及上市的速度堪称一个时代的奇迹,新浪网虽成立晚了搜狐10个月,但却比搜狐早了3个月在纳斯达克敲钟。

与搜狐新浪以门户网站起家不同,网易1997年成立之初以搜索引擎和免费邮箱系统立身,赶上门户网站热潮席卷中国,1998年丁磊带领网易挥师北上,落户北京,公司战略也从“系统集成商”正式转向“互联网服务提供商”。自此,网易与搜狐、新浪成为中国三大门户网站。

在张朝阳、丁磊等都借互联网东风大搞门户网站捞第一波红利的时候,在深圳创业的马化腾开始琢磨做社交。马化腾与大学同学合伙成立腾讯,当时主要做“无线网络寻呼系统”,就是将互联网和寻呼机结合,使得寻呼机可以收到互联网的传唤,并且可以收看新闻乃至电子邮件等功能。

但不可逆的是当时寻呼机业务已处于颓势,1998年,身处2G时代,手机在市场上肆意生长。马化腾当机立断,转头做IM(即时通讯软件),OICQ应运而生,OICQ1999年2月10日发布了第一个版本——OICQ 99 beta build 0210,就此,颠覆未来20年中文互联网的明星产品QQ诞生了。

此后腾讯围绕QQ延展出多款产品,包括QQ宠物、QQ空间、QQ游戏等,这为腾讯带来盈利的同时留存了海量互联网用户。QQ在中国整个2G时代都占据着社交软件第一把交椅,为腾讯后续布局游戏等可以提供天然入口,这让腾讯的产品可以轻而易举地碾压竞品。

而之后改变中国互联网格局的阿里巴巴也是在2G时代诞生的。1999年,马云带领下的18为创始人创建阿里巴巴集团。2003年,淘宝网创立,作为新生事物的淘宝网出奇制胜——没和ebay易趣争抢既有的存量市场,而是收割疯狂生长的增量市场;仅仅通过1年时间,这家“倒过来看世界”的互联网公司,就成了中国网络购物市场的领军企业。

而2004年,支付宝创立,中国第三方支付模式雏形初现。值得一提的是,同年诞生的淘宝旺旺将即时聊天工具和网络购物相联系起来,是阿里巴巴做网上零售的法宝。这时候的淘宝旺旺并没有和QQ对标,还处在阿里腾讯之间还是各自领域狂奔的时代。

在2005年淘宝的成交额就突破80亿元,甚至超越了沃尔玛。

在马云创立淘宝网,大搞电商之时,在中关村卖了几年光盘的刘强东坐不住了,2004年,京东多媒体网正式开通。或许与刘强东卖3C产品起家有关,京东电子商务平台是主打3C产品,与淘宝对标的同时又有自己清晰的定位,虽然都是做电商,但同质化并不严重。

3G时代,智能手机展露头角,巨头大战社交

整个2G时代其实属于PC端互联网,2G的手机只能打电话发短信,上网很困难。但3G通信标准将信息传输率提高了一个数量级,这是一个飞跃,3G时代真正意义上而言是移动互联网的开端,从此手机打电话的功能降到了次要的位置,而数据通信,也就是上网,成为了主要功能。

乔布斯2007年拿着一款智能手机iPhone1出现,宣布苹果主宰移动互联网时代的开始。从此手机不再以功能为主,而是以应用软件(APP)为主,APP store 更是一个划时代产品,让用户可以轻而易举地购买下载所需的应用。

中国的3G时代稍晚于美国,2009年1月,工信部为中国移动、联通、电信发布3G牌照,中国从此进入3G时代。

在智能手机初探中国市场的时间节点,三星、诺基亚、HTC等占据了巨大部分江山,而中国2G时代的功能机科健、波导、海尔等相继淡出市场,国产的智能机中兴、华为、酷派、联想等完全靠三大运营商的销售渠道生存,打着性价比旗号的合约机始终比不上价格更高的三星、HTC的中低端手机。

但2011年小米的横空出世打破了这个壁垒。3G网络在中国越来越普及,彼时在国外品牌占据中国市场,而国产智能手机厂商仅能依附三大运营商销售,而当苹果手机最具冲击力的一代iPhone4席卷全球时,一个叫雷军的人拿出了他的第一代产品——小米1,冲进中国智能手机市场。

三星与HTC主流机型定价4000元,而小米1999的超高性价比+饥饿营销,搅动了中国智能手机市场,成为3G时代崛起的手机巨头,2012年2月,“屌丝”一词横空出世,有人说它是为屌丝而生,谁能想到日后它更是成为世界最年轻的500强?

如果说QQ的问世是一个偶然,那微信出道是无数竞争的结果。

移动互联网兴起,当然PC端依然沉淀着大量用户,彼时的QQ为了顾及PC端的用户,界面、功能更照顾PC端,以至于没能及时赶上移动互联网的浪潮,但一个叫张小龙的人彻底颠覆了社交。

2011年1月,微信横空出世,这款主打IM的应用程序契合3G时代的特点,可以发送文字、语音、图片、视频等,一出现就借助QQ的天然优势,并打通通信录,迅速推广,以至于后续发展成为国民软件,腾讯也借此拿到了通向移动互联网第一张门票,腾讯能成为今天的巨头公司,而且地位难以撼动,微信功不可没。

其实在腾讯布局社交之时,2G时代崛起的门户大咖搜狐、新浪也瞄准了社交这个大蛋糕。只不过新浪瞄准的是信息即时分享,而搜狐一直在拾人牙慧。新浪微博自2009年一经问世便牢牢掌控着微博头把交椅的位置,就连腾讯微博的冲击也未动摇半分。

搜狐看QQ火爆便做了搜Q,见微博火爆便做了搜狐微博,还做了社区社交“白社会”,但无一例外遭遇失败。连张朝阳本人都说,“微信微博左右扇了我两个耳光。”最近张朝阳又推出“狐友”,硬要推着石头上山的张朝阳不知还有没有气力。

而前面提到2G时代阿里推出淘宝旺旺却忙着做电商,没有正面硬刚QQ,但此时看到微信在庞大的社交领域带来的巨大流量时,马云坐不住了。2013年,阿里巴巴推出了来往,这是阿里推出的即时通讯软件,也是阿里第一款独立于电商业务之外的社交产品,其核心功能是实现熟人之间的社交。

原因是马云认为腾讯已经“侵入”了阿里的地盘,要用来往去砸微信的场子,但结果大家都知晓了。但马云并不灰心,之后用支付宝做社交还是失败,只是钉钉的成功才稍找回点面子。

另外值得一提的是,3G时代,LBS应用于地图等会对4G时代滴滴、共享单车等的崛起起到推手的作用。

4G时代,团购直播视频手游异军突起,共享出行风口正盛,巨头布局信息流

如果说1G到2G是划时代的进步,而3G的短暂存在只是一个过渡,因为短短几年后,网速产生质的飞跃的4G时代迅速到来。

3G传播速度相对2G较快,可以较好满足手机上网等需求,只是播放高清视频还是比较困难。而4G的速度几乎满足无线用户所有需求。

彼时移动互联网光速发展,大面积吞噬PC互联网流量和用户。比PC端更加便捷的移动端生活服务类应用风靡中国,O2O模式成了风口上的猪。巨头们纷纷布局,阿里有口碑网,腾讯有微团购,百度则买来糯米网,但谁也不曾想最后的赢家不是巨头而是王兴的美团网,2015年,美团网与大众点评合并,重构了O2O模式。

美团成为4G时代崛起的巨头,而腾讯依靠着微信的社交流量巨大入口也不会败,阿里则有支付宝这个生活服务类的大平台,甚至日后提出新零售概念取代O2O成为新的风口,这场大战里,仿佛只有百度掉队了,从PC互联网时代跨到移动互联网时代,百度要做的产品是在抢夺自己PC端的用户,这让百度似乎有点手足无措。

网速加快受益最大的无疑是直播与视频。2016年前后,资本涌入直播赛道,以斗鱼、虎牙、YY、熊猫、全民等为首的游戏直播平台,纷纷宣布获得融资,疯狂烧钱抢夺主播和用户,以映客、花椒等移动端为主的直播也趁势而起。

彼时直播行业一片混乱,违法违规直播大行其道,随着监管力度加大,资本退场,直播赛道也一地鸡毛,也只是留下虎牙、斗鱼等直播巨头。

4G时代网速加快的同时,运营商提速降费,这让依靠文字和图片获取信息的用户越来越不满足,短视频有着天时地利人和,在用户需求之下诞生。其中以抖音、快手为代表的的社交媒体类短视频最为火爆,而以秒拍、西瓜为代表的的新闻资讯类也广受媒体和用户欢迎,以B站为首的BBS类更是抓住了细分市场。

今年年初Vlog的流行也只是吹了一阵,现已没有当时的热度,看起来短视频的风还会继续吹下去。

2G时代的三大门户巨头搜狐新浪和网易,如今搜狐和新浪的体量与网易已不是一个级别的,新浪尚有微博撑着场面,搜狐却实实在在地掉队了,网易又是如何始终保持盈利的呢?其中一个很重要的支撑点就是网易的游戏帝国,而4G时代更让网易如虎添翼。

曾经风靡全国的PC端回合制游戏“梦幻西游”,手机版一经上线便俘获众多老玩家,这个游戏特点之一就是烧钱。一位玩梦幻的朋友告诉盒饭财经,这个游戏里,充值几万也只是低端玩家而已,动辄砸百万的大有人在,而广受女性玩家喜爱的手游阴阳师也是一个人民币玩家的游戏。

从网易公布的财报不难看出,近几年网易游戏收入占每季度总收入都超过6成,与还靠着新闻资讯的新浪搜狐不同,网易应4G时代实现业务重心迁徙,还能算是互联网一线巨头。

守着微信这个巨大流量入口的腾讯布局游戏更显得理所当然,从PC端的QQ衍生出的众多小游戏为起点,到英雄联盟的大火,3G时代的天天酷跑,再到4G移动互联网时代手游吃鸡(和平精英)、王者荣耀,腾讯在每个时代都在游戏产业上走得很稳。

目前,腾讯游戏占中国游戏市场规模的5成以上,不过与网易不同的是,腾讯一直追求的是薄利多销策略。游戏内道具价格相比网易较为低廉,能取得超过千亿的年收入,全靠用户基数众多。

在PC端流量急剧下降,移动端用户暴涨之时,广告投放方也开始思考有的放矢,PC端时代是买广告位,而4G大数据时代就是买用户,这也称为信息流广告。

信息流广告最大的优势是不浪费资源,运用大数据针对性投放,既然有利可图,便成为各大巨头争先布局的板块,而这其中最为突出的就是今日头条和百度。

说起今日头条,这个曾经“小而美”的公司今年内发展成为TMD(头条、美团、滴滴)的首字母巨头,核心是张一鸣,但也得益于4G时代的浪潮。

今日头条的大获成功最引以为傲的是算法,虽然是新闻资讯类产品,但张一鸣的主创团队全是技术,不需要文字编辑。他们只做一件事,用纯技术算法手段从海量的内容中去搜索挖掘有价值的内容,最关键的是这些内容可以根据客户的需要进行“定制化”推送。这在信息爆炸时代,人们可以摆脱浩瀚无垠的信息海洋,只读取精准定制的有价值信息。

而依靠着强大的算法,什么火他做什么。微博火,做微头条,知乎火,做悟空问答,短视频直播时代到来,做火山小视频、西瓜视频、抖音,头条系产品依靠其强大的算法打造着一个又一个爆款。

2G时代,两大电商平台阿里和京东相争,虽然不是一个体量级,但是淘宝假货风行,一度让阿里痛下决心清理商家,而这些商家顺势被一个叫黄峥的人收走了,2015年,主打社交电商的拼多多应运而生。对了,这个黄峥还跟着别人和巴菲特吃过午餐。

而拼多多背后除了创始人黄峥,腾讯是第二大股东,而微信的天然社交入口让拼多多尝够了甜头,短短三年便上市,如今月活量已超过京东直逼淘宝。很显然,腾讯非常乐见有一家公司能威胁到阿里的主业务。

前文提到,LBS的应用为4G时代的滴滴发展起到推手的作用,2012年滴滴成立以来直至2014年都是缓慢上升期。但是自2014年以后,4G手机进一步普及,滴滴迅猛发展,短短一年便成为出行当之无愧的No.1,而滴滴2014年接入微信,这为滴滴提供了天然的流量入口。

但滴滴的竞品快的接入支付宝,此时阿里与腾讯在各个重合的领域相争已是司空见惯。但当时占领市场只有一个秘诀——烧钱,各种补贴各种红包雨,滴滴快的的烧钱战略持续了相当长一段时间,直到2015年滴滴快的的合并,让出行市场成为一家独大。

如果说滴滴是划时代的出行产品,那共享单车的出现引领了一个共享经济时代。

2004年,一个年轻人连同4个校友,提出“以共享经济+智能硬件,解决最后一公里出行问题”的经营理念,创立ofo共享单车项目,起先他们通过定制,将自行车通过车身号、机械锁绑定APP的方式,提供密码解锁用车的方式,在北京大学推出这一项目。这个项目的创始人叫戴威,北京大学光华管理学院的毕业生。

2015年1月27日,做媒体出身的胡玮炜和运营大牛王晓峰,在北京成立了一家名为“北京摩拜科技有限公司“的公司,他们的愿景是“让自行车回归生活”。

自此,共享单车风口吹起,共享单车“颜色大战”一触即发。而中国互联网创投倒贴钱抢市场,等日后一家独大再赚钱的逻辑,再一次在共享单车上体现的淋漓尽致。当时也就ofo和摩拜两家独大,但风口过得似乎有些快,风口过后,一地鸡毛。摩拜卖身美团,ofo深陷押金风波半死不活,老三哈罗单车如今倒是坐收渔翁之利。

5G时代,谁又能领风骚?

2G、3G、4G时代,随着互联网的发展,一些巨头应时代而生,而一些公司没能及时跟上时代的发展而掉队,还有像腾讯阿里等长盛不衰而又相互掣肘。2G、3G已然开始退网,4G时代方兴未艾,而5G时代紧赶着来了。

5G会直接加速万物互联的进程,改变我们与世界的交互界面。除了VR游戏、无人驾驶、智能物联等应用外,移动办公、会议直播、视频监控、智能城市等都会在5G的大网络下运行。智能手机厂商忙着推出5G手机,而互联网科技巨头在推出5G应用,虽然用户还未感觉到5G的速度,但这个赛道已经热得发烫。

阿里腾讯继续两强争霸?还是迷途的百度能否东山再起?是否还有头条、美团一样突然崛起的巨头?5G时代,一切皆有可能。

来源:https://www.chinaventure.com.cn/news/83-20190726-346438.html

转载请注明:静觅 » 5G时代谁领风骚:先看看2G、3G、4G时代都崛起了哪些公司?

你还在用 os.path?快来感受一下 pathlib 给你带来的便捷吧!

0
0

相比常用的 os.path而言,pathlib 对于目录路径的操作更简介也更贴近 Pythonic。但是它不单纯是为了简化操作,还有更大的用途

概述

pathlib 是Python内置库,Python 文档给它的定义是 Object-oriented filesystem paths(面向对象的文件系统路径)。pathlib 提供表示文件系统路径的类,其语义适用于不同的操作系统。路径类在纯路径之间划分,纯路径提供纯粹的计算操作而没有I / O,以及具体路径,它继承纯路径但也提供I / O操作。

听起来有点绕?那就对了,毕竟这是直译过来的,但这并不影响我们喜爱它。
我们通过几个例子来了解它吧

举个栗子

相对于 os 模块的 path 方法,Python3 标准库 pathlib 模块的 Path 对路径的操作会更简单。

获取当前文件路径

使用 os 模块时,有两种方法可以直接获取当前文件路径:

import os

value1 = os.path.dirname(__file__)
value2 = os.getcwd()
print(value1)
print(value2)

pathlib 获取当前文件路径应该怎么写呢?

官方文档给出了建议 插眼传送

动手试一试

import pathlib

value1 = pathlib.Path.cwd()
print(value1)

它是如何实现的

文档中有介绍,它以 os.getcwd() 的形式将路径返回。我们去源码中一探究竟(Pycharm 编辑器快捷键 ctrl+鼠标左键点击即可跟进指定对象)

原来它是对 os 模块中一些对象进行了封装,看 cwd 的注释:
Return a new path pointing to the current working directory
意为:返回指向当前工作目录的新路径。

看起来也没什么特别的,但是为什么官方特意将它推出呢?

其他的封装

pathlib 封装了很多的 os path ,文档中有写明,如:

# 关系说明
 os.path.expanduser() --> pathlib.Path.home()

 os.path.expanduser() --> pathlib.Path.expanduser()

 os.stat() --> pathlib.Path.stat()

 os.chmod() --> pathlib.Path.chmod()

官网文档截图:

详细请查看官方文档:插眼传送

再举几个栗子

刚才的案例并不能说明什么,只是让我们了解到 pathlib 的构成,接下来让我们感受一下它带给我们的便捷。

获取上层/上层目录

也就是获取它爷爷的名字


os 模块的写法为:

import os

print(os.path.dirname(os.path.dirname(os.getcwd())))

如果用 pathlib 来实现:

import pathlib

print(pathlib.Path.cwd().parent.parent)

parent 就完事了,这是不是更贴近 Pythonic ? 像写英语一样写代码。

如果你只需要找到它爸爸,那就使用一次:

import pathlib

print(pathlib.Path.cwd().parent)

你还可以继续往祖辈上找:

import pathlib

print(pathlib.Path.cwd().parent.parent.parent)

相对与之前 os 模块使用的多层 os.path.dirname,使用 parent 是不是便捷很多?

路径拼接

如果你要在它爷爷辈那里拼接路径,那么你需要写这么长一串代码:

import os

print(os.path.join(os.path.dirname(os.path.dirname(os.getcwd())), "关注", "微信公众号", "【进击的", "Coder】"))

当你用 pathlib 的时候,你一定能够感受到快乐:

import pathlib

parts = ["关注", "微信公众号", "【进击的", "Coder】"]
print(pathlib.Path.cwd().parent.parent.joinpath(*parts))

而且你还可以通过增加或减少 parent 的数量,来实现它祖辈的调节,美哉。

PurePath

上面的操作大部分都通过 pathlib 中的 Path 实现,其实它还有另一个模块 PurePath。

PurePath 是一个纯路径对象,纯路径对象提供了实际上不访问文件系统的路径处理操作。有三种方法可以访问这些类,我们也称之为flavor。

上面这句话来自于官方文档,听起来还是有点绕,我们还是通过栗子来了解它吧

PurePath.match

让我们来判断一下,当前文件路径是否有符合 ‘*.py’ 规则的文件

import pathlib

print(pathlib.PurePath(__file__).match('*.py'))

很显然,我们编写代码的 coder.py 就符合规则,所以输出是 True。

为什么我要拿这个来举例呢?再深入想一下 pathlib.PurePath 后面能够跟着 match,那说明它应该是个对象,而不是一个路径字符串。为了验证这个想法,把代码改一改:

import pathlib
import os

os_path = os.path.dirname(__file__)
pure_path = pathlib.PurePath(__file__)
print(os_path, type(os_path))
print(pure_path, type(pure_path))
print(pathlib.PurePath(__file__).match('*.py'))


打印通过 os.path 获取当前路径的结果,得出一个路径字符串;而通过 pathlib.Pure 则获得的是一个 PurePosixPath 对象,并且得到的路径包括了当前文件 coder.py。

这就有点悬疑了, PurePosixPath 究竟是什么?

pathlib 可以操作两种文件系统的路径,一种是 Windows 文件系统,另一种称为非 Windows 文件系统,对应的对象是 pathlib.PurePosixPathPureWindowsPath,不过不用担心,这些类并非是指定在某些操作系统上运行才能够使用,无论你运行的是哪个系统,都可以实例化所有这些类,因为它们不提供任何进行系统调用的操作。

不提供任何进行系统调用的操作,这又是什么?真是越听越深了

文档在最开始给出了这么一段描述:

Pure paths are useful in some special cases; for example:
If you want to manipulate Windows paths on a Unix machine (or vice versa). You cannot instantiate a WindowsPath when running on Unix, but you can instantiate PureWindowsPath.
You want to make sure that your code only manipulates paths without actually accessing the OS. In this case, instantiating one of the pure classes may be useful since those simply don’t have any OS-accessing operations.

翻译:纯路径在某些特殊情况下很有用; 例如:
如果要在Unix计算机上操作Windows路径(反之亦然)。WindowsPath在Unix上运行时无法实例化,但可以实例化PureWindowsPath。
您希望确保您的代码仅操作路径而不实际访问操作系统。在这种情况下,实例化其中一个纯类可能很有用,因为那些只是没有任何操作系统访问操作。

还附上了一张图:

一下子也不是很理解,这是什么意思。不要紧,继续往下看。

对应关系

通过以上的例子我们可以感受到,它不仅封装了 os.path 相关常用方法,还集成了 os 的其他模块,比如创建文件夹 Path.mkdir。

如果你担心记不住,没关系的,文档一直都在。并且文档给我们列出了对应关系表

基本用法

Path.iterdir()  # 遍历目录的子目录或者文件

Path.is_dir()  # 判断是否是目录

Path.glob()  # 过滤目录(返回生成器)

Path.resolve()  # 返回绝对路径

Path.exists()  # 判断路径是否存在

Path.open()  # 打开文件(支持with)

Path.unlink()  # 删除文件或目录(目录非空触发异常)

基本属性

Path.parts  # 分割路径 类似os.path.split(), 不过返回元组

Path.drive  # 返回驱动器名称

Path.root  # 返回路径的根目录

Path.anchor  # 自动判断返回drive或root

Path.parents  # 返回所有上级目录的列表

改变路径

Path.with_name()  # 更改路径名称, 更改最后一级路径名

Path.with_suffix()  # 更改路径后缀

拼接路径

Path.joinpath()  # 拼接路径

Path.relative_to()  # 计算相对路径

测试路径

Path.match()  # 测试路径是否符合pattern

Path.is_dir()  # 是否是文件

Path.is_absolute()  # 是否是绝对路径

Path.is_reserved()  # 是否是预留路径

Path.exists()  # 判断路径是否真实存在

其他方法

Path.cwd()  # 返回当前目录的路径对象

Path.home()  # 返回当前用户的home路径对象

Path.stat()  # 返回路径信息, 同os.stat()

Path.chmod()  # 更改路径权限, 类似os.chmod()

Path.expanduser()  # 展开~返回完整路径对象

Path.mkdir()  # 创建目录

Path.rename()  # 重命名路径

Path.rglob()  # 递归遍历所有子目录的文件

pathlib 回顾

通过上面的几个例子,我们对 pathlib 应该有一个大体的了解,接下来再回顾一下官方给 pathlib 库的定义:

This module offers classes representing filesystem paths with semantics appropriate for different operating systems. Path classes are divided between pure paths, which provide purely computational operations without I/O, and concrete paths, which inherit from pure paths but also provide I/O operations.

释义:pathlib 提供表示文件系统路径的类,其语义适用于不同的操作系统。路径类在纯路径之间划分,纯路径提供纯粹的计算操作而没有I / O,以及具体路径,它继承纯路径但也提供I / O操作。

回顾刚才这张图,重新理解 pathlib

如果你以前从未使用过这个模块,或者只是不确定哪个类适合您的任务,那么Path很可能就是您所需要的。它为代码运行的平台实例化一个具体路径。

总结:pathlib 不单纯是对 os 中一些模块或方法进行封装,而是为了兼容不同的操作系统,它为每类操作系统定义了接口。你希望在UNIX机器上操作Windows的路径,然而直接操作是做不到的,所以为你创建了一套接口 PurePath,你可以通过接口来实现你的目的(反之亦然)

转载请注明:静觅 » 你还在用 os.path?快来感受一下 pathlib 给你带来的便捷吧!

[Python3网络爬虫开发实战] 8-验证码的识别

0
0

当今时代,许多网站为了反爬虫采用了各种各样的措施,其中之一便是使用验证码,随着技术的发展,验证码的花样也越来越多,最初可能是几个数字组合的简单的图形验证码,后来加入了英文字母和混淆曲线使得验证码更加复杂,有的网站还可能看到中文字符的验证码,使得识别愈发困难。

而后来 12306 验证码的出现又开辟了验证码的新纪元,用过 12306 的肯定多少为它的验证码头疼过,它需要我们去识别文字,然后再点击文字描述相符的图片,只有完全正确才可以验证通过。现在这种交互式验证码越来越多,如极验滑动验证码需要滑动拼合滑块才可以完成验证,点触的验证码需要完全点击正确的结果才可以完成验证,另外还有一些滑动宫格验证码,计算题验证码等等五花八门。

验证码变得越来越复杂,爬虫的工作也变得愈发艰难,有时候我们必须通过验证码的验证才可以访问页面,所以本章专门来针对验证码的识别做一下统一的讲解。

本章涉及的验证码有普通图形验证码、极验滑动验证码、点触验证码、微博宫格验证码,识别的方式和思路各有不同,了解了这几个验证码的识别方式之后,我们可以举一反三,用类似的方法识别其他类型的验证码。

转载请注明:静觅 » [Python3网络爬虫开发实战] 8-验证码的识别


[Python3网络爬虫开发实战] 8.1-图形验证码的识别

0
0

本节我们首先来尝试识别最简单的一种验证码,图形验证码,这种验证码出现的最早,现在也很常见,一般是四位字母或者数字组成的,例如中国知网的注册页面就有类似的验证码,链接为:http://my.cnki.net/elibregister/commonRegister.aspx,页面如图 8-1 所示:

图 8-1 知网注册页面

表单的最后一项就是图形验证码,我们必须完全输入正确图中的字符才可以完成注册。

1. 本节目标

本节我们就以知网的验证码为例,讲解一下利用 OCR 技术识别此种图形验证码的方法。

2. 准备工作

识别图形验证码需要的库有 Tesserocr,如果没有安装可以参考第一章的安装说明。

3. 获取验证码

为了便于实验,我们先将验证码的图片保存到本地,以供测试。

打开开发者工具,找到验证码元素,可以看到这是一张图片,它的 src 属性是 CheckCode.aspx,在这里我们直接将这个链接打开:http://my.cnki.net/elibregister/CheckCode.aspx,就可以看到一个验证码,直接右键保存下来即可,将名称命名为 code.jpg,如图 8-2 所示:

图 8-2 验证码

这样我们就可以得到一张验证码图片供下面测试识别使用了。

4. 识别测试

接下来我们新建一个项目,将验证码图片放到项目根目录下,用 Tesserocr 库来识别一下该验证码试试,代码如下:

import tesserocr
from PIL import Image

image = Image.open('code.jpg')
result = tesserocr.image_to_text(image)
print(result)

在这里我们首先新建了一个 Image 对象,然后调用了 Tesserocr 的 image_to_text() 方法,传入该 Image 对象即可完成识别,实现过程非常简单,识别结果如下:

JR42

另外 Tesserocr 还有一个更加简单的方法直接将图片文件转为字符串可以达到同样的效果,代码如下:

import tesserocr
print(tesserocr.file_to_text('image.png'))

不过经测试此种方法的识别效果不如上一种方法好。

5. 验证码处理

如上的图片识别基本没有难度,只是新建一个 Image 对象,然后调用 image_to_text() 方法即可得出图片的识别结果。

接下来我们换一个验证码试一下,命名为 code2.jpg,如图 8-3 所示:

图 8-3 验证码

重新用下面的代码测试一下:

import tesserocr
from PIL import Image

image = Image.open('code2.jpg')
result = tesserocr.image_to_text(image)
print(result)

这时可以看到如下输出结果:

FFKT

发现这次识别和实际的结果有所偏差,这是因为验证码内的多余线条干扰了图片的识别。

对于这种情况,我们还需要做一下额外的处理,如转灰度、二值化等操作。

我们可以利用 Image 对象的 convert() 方法参数传入 L 即可将图片转化为灰度图像,代码如下:

image = image.convert('L')
image.show()

传入 1 即可将图片进行二值化处理:

image = image.convert('1')
image.show()

另外我们还可以指定二值化的阈值,上面的方法采用的是默认阈值127,不过我们不能用原图直接转化,可以先转为灰度图像,然后再指定二值化阈值转化,代码如下:

image = image.convert('L')
threshold = 80
table = []
for i in range(256):
    if i < threshold:
        table.append(0)
    else:
        table.append(1)

image = image.point(table, '1')
image.show()

在这里我们指定了一个变量 threshold 代表二值化阈值,阈值设置为 80,处理之后我们看一下结果,如图 8-4 所示:

图 8-4 处理结果

经过处理之后我们发现原来的验证码中的线条已经被去除了,而且整个验证码变得黑白分明,这时重新识别验证码,代码如下:

import tesserocr
from PIL import Image

image = Image.open('code2.jpg')

image = image.convert('L')
threshold = 127
table = []
for i in range(256):
    if i < threshold:
        table.append(0)
    else:
        table.append(1)

image = image.point(table, '1')
result = tesserocr.image_to_text(image)
print(result)

即可发现运行结果变成了:

PFRT

识别正确。

可见对于一些有干扰的图片,我们做一些灰度和二值化处理,会提高其识别正确率。

6. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackImageCode

7. 结语

本节我们了解了利用 Tesserocr 识别验证码的过程,对于简单的图形验证码我们可以直接用它来得到结果,如果要提高识别的准确度还可以对验证码图片做一下预处理。

转载请注明:静觅 » [Python3网络爬虫开发实战] 8.1-图形验证码的识别

[Python3网络爬虫开发实战] 8.2-极验滑动验证码的识别

0
0

上节我们了解了图形验证码的识别,简单的图形验证码我们可以直接利用 Tesserocr 来识别,但是近几年又出现了一些新型验证码,如滑动验证码,比较有代表性的就是极验验证码,它需要拖动拼合滑块才可以完成验证,相对图形验证码来说识别难度上升了几个等级,本节来讲解下极验验证码的识别过程。

1. 本节目标

本节我们的目标是用程序来识别并通过极验验证码的验证,其步骤有分析识别思路、识别缺口位置、生成滑块拖动路径,最后模拟实现滑块拼合通过验证。

2. 准备工作

本次我们使用的 Python 库是 Selenium,使用的浏览器为 Chrome,在此之前请确保已经正确安装好了 Selenium 库、Chrome浏览器并配置好了 ChromeDriver,相关流程可以参考第一章的说明。

3. 了解极验验证码

极验验证码其官网为:http://www.geetest.com/,它是一个专注于提供验证安全的系统,主要验证方式是拖动滑块拼合图像,若图像完全拼合,则验证成功,即可以成功提交表单,否则需要重新验证,样例如图8-5 和 8-6 所示:

图 8-5 验证码示例

图 8-6 验证码示例

现在极验验证码已经更新到了 3.0 版本,截至 2017 年 7 月全球已有十六万家企业正在使用极验,每天服务响应超过四亿次,广泛应用于直播视频、金融服务、电子商务、游戏娱乐、政府企业等各大类型网站,下面是斗鱼、魅族的登录页面,可以看到其都对接了极验验证码,如图 8-7 和 8-8 所示:

图 8-7 斗鱼登录页面

图 8-8 魅族登录页面

4. 极验验证码的特点

这种验证码相较于图形验证码来说识别难度更大,极验验证码首先需要在前台验证通过,对于极验 3.0,我们首先需要点击按钮进行智能验证,如果验证不通过,则会弹出滑动验证的窗口,随后需要拖动滑块拼合图像进行验证,验证之后会生成三个加密参数,参数随后通过表单提交到后台,后台还会进行一次验证。

另外极验还增加了机器学习的方法来识别拖动轨迹,官方网站的安全防护说明如下:

  • 三角防护之防模拟

恶意程序模仿人类行为轨迹对验证码进行识别。针对模拟,极验拥有超过 4000 万人机行为样本的海量数据。利用机器学习和神经网络构建线上线下的多重静态、动态防御模型。识别模拟轨迹,界定人机边界。

  • 三角防护之防伪造

恶意程序通过伪造设备浏览器环境对验证码进行识别。针对伪造,极验利用设备基因技术。深度分析浏览器的实际性能来辨识伪造信息。同时根据伪造事件不断更新黑名单,大幅提高防伪造能力。

  • 三角防护之防暴力

恶意程序短时间内进行密集的攻击,对验证码进行暴力识别
针对暴力,极验拥有多种验证形态,每一种验证形态都有利用神经网络生成的海量图库储备,每一张图片都是独一无二的,且图库不断更新,极大程度提高了暴力识别的成本。

另外极验的验证相对于普通验证方式更加方便,体验更加友好,其官方网站说明如下:

  • 点击一下,验证只需要 0.4 秒

极验始终专注于去验证化实践,让验证环节不再打断产品本身的交互流程,最终达到优化用户体验和提高用户转化率的效果。

  • 全平台兼容,适用各种交互场景

极验兼容所有主流浏览器甚至古老的IE6,也可以轻松应用在iOS和Android移动端平台,满足各种业务需求,保护网站资源不被滥用和盗取。

  • 面向未来,懂科技,更懂人性

极验在保障安全同时不断致力于提升用户体验,精雕细琢的验证面板,流畅顺滑的验证动画效果,让验证过程不再枯燥乏味。

因此,相较于一般验证码,极验的验证安全性和易用性有了非常大的提高。

5. 识别思路

但是对于应用了极验验证码的网站,识别并不是没有办法的。如果我们直接模拟表单提交的话,加密参数的构造是个问题,参数构造有问题服务端就会校验失败,所以在这里我们采用直接模拟浏览器动作的方式来完成验证,在 Python 中我们就可以使用 Selenium 来通过完全模拟人的行为的方式来完成验证,此验证成本相对于直接去识别加密算法容易不少。

首先我们找到一个带有极验验证的网站,最合适的当然为极验官方后台了,链接为:https://account.geetest.com/login,首先可以看到在登录按钮上方有一个极验验证按钮,如图 8-9 所示:

图 8-9 验证按钮

此按钮为智能验证按钮,点击一下即可智能验证,一般来说如果是同一个 Session,一小段时间内第二次登录便会直接通过验证,如果智能识别不通过,则会弹出滑动验证窗口,我们便需要拖动滑块来拼合图像完成二步验证,如图 8-10 所示:

图 8-10 拖动示例

验证成功后验证按钮便会变成如下状态,如图 8-11 所示:

图 8-11 验证成功结果

接下来我们便可以进行表单提交了。

所以在这里我们要识别验证需要做的有三步:

  • 模拟点击验证按钮
  • 识别滑动缺口的位置
  • 模拟拖动滑块

第一步操作是最简单的,我们可以直接用 Selenium 模拟点击按钮即可。

第二步操作识别缺口的位置比较关键,需要用到图像的相关处理方法,那缺口怎么找呢?首先来观察一下缺口的样子,如图 8-12 和 8-13 所示:

图 8-12 缺口示例

图 8-13 缺口示例

可以看到缺口的四周边缘有明显的断裂边缘,而且边缘和边缘周围有明显的区别,我们可以实现一个边缘检测算法来找出缺口的位置。对于极验来说,我们可以利用和原图对比检测的方式来识别缺口的位置,因为在没有滑动滑块之前,缺口其实是没有呈现的,如图 8-14 所示:

图 8-14 初始状态

所以我们可以同时获取两张图片,设定一个对比阈值,然后遍历两张图片找出相同位置像素 RGB 差距超过此阈值的像素点位置,那么此位置就是缺口的位置。

第三步操作看似简单,但是其中的坑比较多,极验验证码增加了机器轨迹识别,匀速移动、随机速度移动等方法都是不行的,只有完全模拟人的移动轨迹才可以通过验证,而人的移动轨迹一般是先加速后减速的,这又涉及到物理学中加速度的相关问题,我们需要模拟这个过程才能成功。

有了基本的思路之后就让我们用程序来实现一下它的识别过程吧。

6. 初始化

首先这次我们选定的链接为:https://account.geetest.com/login,也就是极验的管理后台登录页面,在这里我们首先初始化一些配置,如 Selenium 对象的初始化及一些参数的配置:

EMAIL = 'test@test.com'
PASSWORD = '123456'

class CrackGeetest():
    def __init__(self):
        self.url = 'https://account.geetest.com/login'
        self.browser = webdriver.Chrome()
        self.wait = WebDriverWait(self.browser, 20)
        self.email = EMAIL
        self.password = PASSWORD

其中 EMAIL 和 PASSWORD 就是登录极验需要的用户名和密码,如果没有的话可以先注册一下。

7. 模拟点击

随后我们需要实现第一步的操作,也就是模拟点击初始的验证按钮,所以我们定义一个方法来获取这个按钮,利用显式等待的方法来实现:

def get_geetest_button(self):
    """
    获取初始验证按钮
    :return: 按钮对象
    """
    button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'geetest_radar_tip')))
    return button

获取之后就会获取一个 WebElement 对象,调用它的 click() 方法即可模拟点击,代码如下:

# 点击验证按钮
button = self.get_geetest_button()
button.click()

到这里我们第一步的工作就完成了。

8. 识别缺口

接下来我们需要识别缺口的位置,首先我们需要将前后的两张比对图片获取下来,然后比对二者的不一致的地方即为缺口。首先我们需要获取不带缺口的图片,利用 Selenium 选取图片元素,然后得到其所在位置和宽高,随后获取整个网页的截图,再从截图中裁切出来即可,代码实现如下:

def get_position(self):
    """
    获取验证码位置
    :return: 验证码位置元组
    """
    img = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'geetest_canvas_img')))
    time.sleep(2)
    location = img.location
    size = img.size
    top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
        'width']
    return (top, bottom, left, right)

def get_geetest_image(self, name='captcha.png'):
    """
    获取验证码图片
    :return: 图片对象
    """
    top, bottom, left, right = self.get_position()
    print('验证码位置', top, bottom, left, right)
    screenshot = self.get_screenshot()
    captcha = screenshot.crop((left, top, right, bottom))
    return captcha

在这里 get_position() 函数首先获取了图片对象,然后获取了它的位置和宽高,随后返回了其左上角和右下角的坐标。而 get_geetest_image() 方法则是获取了网页截图,然后调用了 crop() 方法将图片再裁切出来,返回的是 Image 对象。

随后我们需要获取第二张图片,也就是带缺口的图片,要使得图片出现缺口,我们只需要点击一下下方的滑块即可,触发这个动作之后,图片中的缺口就会显现,实现如下:

def get_slider(self):
    """
    获取滑块
    :return: 滑块对象
    """
    slider = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'geetest_slider_button')))
    return slider

利用 get_slider() 方法获取滑块对象,接下来调用其 click() 方法即可触发点击,缺口图片即可呈现:

# 点按呼出缺口
slider = self.get_slider()
slider.click()

随后还是调用 get_geetest_image() 方法将第二张图片获取下来即可。

到现在我们就已经得到了两张图片对象了,分别赋值给变量 image1 和 image2,接下来对比图片获取缺口即可。要对比图片的不同之处,我们在这里遍历图片的每个坐标点,获取两张图片对应像素点的 RGB 数据,然后判断二者的 RGB 数据差异,如果差距超过在一定范围内,那就代表两个像素相同,继续比对下一个像素点,如果差距超过一定范围,则判断像素点不同,当前位置即为缺口位置,代码实现如下:

def is_pixel_equal(self, image1, image2, x, y):
    """
    判断两个像素是否相同
    :param image1: 图片1
    :param image2: 图片2
    :param x: 位置x
    :param y: 位置y
    :return: 像素是否相同
    """
    # 取两个图片的像素点
    pixel1 = image1.load()[x, y]
    pixel2 = image2.load()[x, y]
    threshold = 60
    if abs(pixel1[0] - pixel2[0]) < threshold and abs(pixel1[1] - pixel2[1]) < threshold and abs(
            pixel1[2] - pixel2[2]) < threshold:
        return True
    else:
        return False

def get_gap(self, image1, image2):
    """
    获取缺口偏移量
    :param image1: 不带缺口图片
    :param image2: 带缺口图片
    :return:
    """
    left = 60
    for i in range(left, image1.size[0]):
        for j in range(image1.size[1]):
            if not self.is_pixel_equal(image1, image2, i, j):
                left = i
                return left
    return left

get_gap() 方法即为获取缺口位置的方法,此方法的参数为两张图片,一张为带缺口图片,另一张为不带缺口图片,在这里遍历两张图片的每个像素,然后利用 is_pixel_equal() 方法判断两张图片同一位置的像素是否相同,比对的时候比较了两张图 RGB 的绝对值是否均小于定义的阈值 threshold,如果均在阈值之内,则像素点相同,继续遍历,否则遇到不相同的像素点就是缺口的位置。

在这里比如两张对比图片如下,如图 8-15 和 8-16 所示:

图 8-15 初始状态

图 8-16 后续状态

两张图片其实有两处明显不同的地方,一个就是待拼合的滑块,一个就是缺口,但是滑块的位置会出现在左边位置,缺口会出现在与滑块同一水平线的位置,所以缺口一般会在滑块的右侧,所以要寻找缺口的话,我们直接从滑块右侧寻找即可,所以在遍历的时候我们直接设置了遍历的起始横坐标为 60,也就是在滑块的右侧开始识别,这样识别出的结果就是缺口的位置了。

到现在为止,我们就可以获取缺口的位置了,剩下最后一步模拟拖动就可以完成验证了。

9. 模拟拖动

模拟拖动的这个过程说复杂并不复杂,只是其中的坑比较多。现在我们已经获取到了缺口的位置,接下来只需要调用拖动的相关函数将滑块拖动到对应位置不就好了吗?然而事实很残酷,如果匀速拖动,极验必然会识别出来这是程序的操作,因为人是无法做到完全匀速拖动的,极验利用机器学习模型筛选出此类数据,归类为机器操作,验证码识别失败。

随后我又尝试了分段模拟,将拖动过程划分几段,每段设置一个平均速度,同时速度围绕该平均速度小幅度随机抖动,同样无法完成验证。

最后尝试了完全模拟加速减速的过程通过了验证,在前段滑块需要做匀加速运动,后面需要做匀减速运动,在这里利用物理学的加速度公式即可完成。

设滑块滑动的加速度用 a 来表示,当前速度用 v 表示,初速度用 v0 表示,位移用 x 表示,所需时间用 t 表示,则它们之间满足如下关系:

x = v0 * t + 0.5 * a * t * t 
v = v0 + a * t

接下来我们利用两个公式可以构造一个轨迹移动算法,计算出先加速后减速的运动轨迹,代码实现如下:

def get_track(self, distance):
    """
    根据偏移量获取移动轨迹
    :param distance: 偏移量
    :return: 移动轨迹
    """
    # 移动轨迹
    track = []
    # 当前位移
    current = 0
    # 减速阈值
    mid = distance * 4 / 5
    # 计算间隔
    t = 0.2
    # 初速度
    v = 0

    while current < distance:
        if current < mid:
            # 加速度为正2
            a = 2
        else:
            # 加速度为负3
            a = -3
        # 初速度v0
        v0 = v
        # 当前速度v = v0 + at
        v = v0 + a * t
        # 移动距离x = v0t + 1/2 * a * t^2
        move = v0 * t + 1 / 2 * a * t * t
        # 当前位移
        current += move
        # 加入轨迹
        track.append(round(move))
    return track

在这里我们定义了 get_track() 方法,传入的参数为移动的总距离,返回的是运动轨迹,用 track 表示,它是一个列表,列表的每个元素代表每次移动多少距离。

首先定义了一个变量 mid,即减速的阈值,也就是加速到什么位置就开始减速,在这里定义为 4/5,即模拟前 4/5 路程是加速过程,后 1/5 是减速过程。

随后定义了当前位移的距离变量 current,初始为 0,随后进入 while 循环,循环的条件是当前位移小于总距离。在循环里我们分段定义了加速度,其中加速过程加速度定义为2,减速过程加速度定义为 -3,随后再套用位移公式计算出某个时间段内的位移,同时将当前位移更新并记录到轨迹里即可。

这样直到运动轨迹达到总距离时即终止循环,最后得到的 track 即记录了每个时间间隔移动了多少位移,这样滑块的运动轨迹就得到了。

最后我们只需要按照该运动轨迹拖动滑块即可,方法实现如下:

def move_to_gap(self, slider, tracks):
    """
    拖动滑块到缺口处
    :param slider: 滑块
    :param tracks: 轨迹
    :return:
    """
    ActionChains(self.browser).click_and_hold(slider).perform()
    for x in tracks:
        ActionChains(self.browser).move_by_offset(xoffset=x, yoffset=0).perform()
    time.sleep(0.5)
    ActionChains(self.browser).release().perform()

在这里传入的参数为滑块对象和运动轨迹,首先调用ActionChains 的 click_and_hold() 方法按住拖动底部滑块,随后遍历运动轨迹获取每小段位移距离,调用 move_by_offset() 方法移动此位移,最后移动完成之后调用 release() 方法松开鼠标即可。

这样再经过测试,验证就通过了,识别完成,效果图 8-17 所示:

图 8-17 识别成功结果

最后,我们只需要将表单完善,模拟点击登录按钮即可完成登录,成功登录后即跳转到后台。

至此,极验验证码的识别工作即全部完成,此识别方法同样适用于其他使用极验3.0的网站,原理都是相同的。

10. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackGeetest

11. 结语

本节我们分析并实现了极验验证码的识别,其关键在于识别的思路,如怎样识别缺口位置,怎样生成运动轨迹等,学会了这些思路后以后我们再遇到类似原理的验证码同样可以完成识别过程。

转载请注明:静觅 » [Python3网络爬虫开发实战] 8.2-极验滑动验证码的识别

[Python3网络爬虫开发实战] 8.3-点触点选验证码的识别

0
0

上一节我们实现了极验验证码的识别,但是除了极验其实还有另一种常见的且应用广泛的验证码,比较有代表性的就是点触验证码。

可能你对这个名字比较陌生,但是肯定见过类似的验证码,比如 12306,这就是一种典型的点触验证码,如图 8-18 所示:

图 8-18 12306 验证码

我们需要直接点击图中符合要求的图,如果所有答案均正确才会验证成功,如果有一个答案错误,验证就会失败,这种验证码就可以称之为点触验证码。

另外还有一个专门提供点触验证码服务的站点,叫做 TouClick,其官方网站为:https://www.touclick.com/,本节就以它为例讲解一下此类验证码的识别过程。

1. 本节目标

本节我们的目标是用程序来识别并通过点触验证码的验证。

2. 准备工作

本次我们使用的 Python 库是 Selenium,使用的浏览器为 Chrome,在此之前请确保已经正确安装好了 Selenium 库、Chrome浏览器并配置好了 ChromeDriver,相关流程可以参考第一章的说明。

3. 了解点触验证码

TouClick 官方网站的验证码样式如图 8-19 所示:

图 8-19 验证码样式

和 12306 站点有相似之处,不过这次是点击图片中的文字,不是图片了,另外还有各种形形色色的点触验证码,其交互形式可能略有不同,但基本原理都是类似的。

接下来我们就来统一实现一下此类点触验证码的识别过程。

4. 识别思路

此种验证码的如果依靠图像识别的话识别难度非常之大。

例如就 12306 来说,其识别难点有两个点,第一点是文字识别,如图 8-20 所示:

图 8-20 12306 验证码

如点击图中所有的漏斗,“漏斗”二字其实都经过变形、放缩、模糊处理了,如果要借助于前面我们讲的 OCR 技术来识别,识别的精准度会大打折扣,甚至得不到任何结果。第二点是图像的识别,我们需要将图像重新转化文字,可以借助于各种识图接口,可经我测试识别正确结果的准确率非常低,经常会出现匹配不正确或匹配不出结果的情况,而且图片本身的的清晰度也不够,所以识别难度会更大,更何况需要同时识别出八张图片的结果,且其中几个答案需要完全匹配正确才能验证通过,综合来看,此种方法基本是不可行的。

再拿 TouClick 来说,如图 8-21 所示:

图 8-21 验证码示例

我们需要从这幅图片中识别出植株二字,但是图片的背景或多或少会有干扰,导致 OCR 几乎不会识别出结果,有人会说,直接识别白色的文字不就好了吗?但是如果换一张验证码呢?如图 8-22 所示:

图 8-22 验证码示例

这张验证码图片的文字又变成了蓝色,而且还又有白色阴影,识别的难度又会大大增加。

那么此类验证码就没法解了吗?答案当然是有,靠什么?靠人。

靠人解决?那还要程序做什么?不要急,这里说的人并不是我们自己去解,在互联网上存在非常多的验证码服务平台,平台 7×24 小时提供验证码识别服务,一张图片几秒就会获得识别结果,准确率可达 90% 以上,但是就需要花点钱来购买服务了,毕竟平台都是需要盈利的,不过不用担心,识别一个验证码只需要几分钱。

在这里我个人比较推荐的一个平台是超级鹰,其官网为:https://www.chaojiying.com,非广告。

其提供的服务种类非常广泛,可识别的验证码类型非常多,其中就包括此类点触验证码。

另外超级鹰平台同样支持简单的图形验证码识别,如果 OCR 识别有难度,同样可以用本节相同的方法借助此平台来识别,下面是此平台提供的一些服务:

  • 英文数字,提供最多20位英文数字的混合识别
  • 中文汉字,提供最多7个汉字的识别
  • 纯英文,提供最多12位的英文的识别
  • 纯数字,提供最多11位的数字的识别
  • 任意特殊字符,提供不定长汉字英文数字、拼音首字母、计算题、成语混合、 集装箱号等字符的识别
  • 坐标选择识别,如复杂计算题、选择题四选一、问答题、点击相同的字、物品、动物等返回多个坐标的识别

具体如有变动以官网为准:https://www.chaojiying.com/price.html

而本节我们需要解决的就是属于最后一类,坐标多选识别的情况,我们需要做的就是将验证码图片提交给平台,然后平台会返回识别结果在图片中的坐标位置,接下来我们再解析坐标模拟点击就好了。

原理非常简单,下面我们就来实际用程序来实验一下。

5. 注册账号

在开始之前,我们需要先注册一个超级鹰账号并申请一个软件ID,注册页面链接为:https://www.chaojiying.com/user/reg/,注册完成之后还需要在后台开发商中心添加一个软件ID,最后一件事就是充值一些题分,充值多少可以根据价格和识别量自行决定。

6. 获取API

做好上面的准备工作之后我们就可以开始用程序来对接验证码的识别了。

首先我们可以到官方网站下载对应的 Python API,链接为:https://www.chaojiying.com/api-14.html,但是此 API 是Python2 版本的,是用 Requests 库来实现的,我们可以简单更改几个地方即可将其修改为 Python3 版本。

修改之后的API如下:

import requests
from hashlib import md5

class Chaojiying(object):

    def __init__(self, username, password, soft_id):
        self.username = username
        self.password = md5(password.encode('utf-8')).hexdigest()
        self.soft_id = soft_id
        self.base_params = {
            'user': self.username,
            'pass2': self.password,
            'softid': self.soft_id,
        }
        self.headers = {
            'Connection': 'Keep-Alive',
            'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
        }

    def post_pic(self, im, codetype):
        """
        im: 图片字节
        codetype: 题目类型 参考 http://www.chaojiying.com/price.html
        """
        params = {
            'codetype': codetype,
        }
        params.update(self.base_params)
        files = {'userfile': ('ccc.jpg', im)}
        r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files, headers=self.headers)
        return r.json()

    def report_error(self, im_id):
        """
        im_id:报错题目的图片ID
        """
        params = {
            'id': im_id,
        }
        params.update(self.base_params)
        r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers)
        return r.json()

这里定义了一个 Chaojiying 类,其构造函数接收三个参数,分别是超级鹰的用户名、密码以及软件ID,保存好以备使用。

接下来是最重要的一个方法叫做 post_pic(),这里需要传入图片对象和验证码的代号,该方法会将图片对象和相关信息发给超级鹰的后台进行识别,然后将识别成功的 Json 返回回来。

另一个方法叫做 report_error(),这个是发生错误的时候的回调,如果验证码识别错误,调用此方法会返还相应的题分。

接下来我们以 TouClick 的官网为例来进行演示点触验证码的识别过程,链接为:http://admin.touclick.com/,如果没有注册账号可以先注册一个。

7. 初始化

首先我们需要初始化一些变量,如 WebDriver、Chaojiying对象等等,代码实现如下:

EMAIL = 'cqc@cuiqingcai.com'
PASSWORD = ''
# 超级鹰用户名、密码、软件ID、验证码类型
CHAOJIYING_USERNAME = 'Germey'
CHAOJIYING_PASSWORD = ''
CHAOJIYING_SOFT_ID = 893590
CHAOJIYING_KIND = 9102

class CrackTouClick():
    def __init__(self):
        self.url = 'http://admin.touclick.com/login.html'
        self.browser = webdriver.Chrome()
        self.wait = WebDriverWait(self.browser, 20)
        self.email = EMAIL
        self.password = PASSWORD
        self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)

这里的账号和密码请自行修改。

8. 获取验证码

接下来的第一步就是完善相关表单,然后模拟点击呼出验证码,此步非常简单,代码实现如下:

def open(self):
    """
    打开网页输入用户名密码
    :return: None
    """
    self.browser.get(self.url)
    email = self.wait.until(EC.presence_of_element_located((By.ID, 'email')))
    password = self.wait.until(EC.presence_of_element_located((By.ID, 'password')))
    email.send_keys(self.email)
    password.send_keys(self.password)

def get_touclick_button(self):
    """
    获取初始验证按钮
    :return:
    """
    button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'touclick-hod-wrap')))
    return button

在这里 open() 方法负责填写表单,get_touclick_button() 方法则是获取验证码按钮,随后触发点击即可。

接下来我们需要类似上一节极验验证码图像获取一样,首先获取验证码图片的位置和大小,随后从网页截图里面截取相应的验证码图片就好了。代码实现如下:

def get_touclick_element(self):
    """
    获取验证图片对象
    :return: 图片对象
    """
    element = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'touclick-pub-content')))
    return element

def get_position(self):
    """
    获取验证码位置
    :return: 验证码位置元组
    """
    element = self.get_touclick_element()
    time.sleep(2)
    location = element.location
    size = element.size
    top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
        'width']
    return (top, bottom, left, right)

def get_screenshot(self):
    """
    获取网页截图
    :return: 截图对象
    """
    screenshot = self.browser.get_screenshot_as_png()
    screenshot = Image.open(BytesIO(screenshot))
    return screenshot

def get_touclick_image(self, name='captcha.png'):
    """
    获取验证码图片
    :return: 图片对象
    """
    top, bottom, left, right = self.get_position()
    print('验证码位置', top, bottom, left, right)
    screenshot = self.get_screenshot()
    captcha = screenshot.crop((left, top, right, bottom))
    return captcha

在这里 get_touclick_image() 方法即为从网页截图中截取对应的验证码图片,其中验证码图片的相对位置坐标由 get_position() 方法返回得到,最后我们得到的是一个 Image 对象。

9. 识别验证码

随后我们调用 Chaojiying 对象的 post_pic() 方法即可把图片发送给超级鹰后台,在这里发送的图像是字节流格式,代码实现如下:

image = self.get_touclick_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_KIND)
print(result)

这样运行之后 result 变量就是超级鹰后台的识别结果,可能运行需要等待几秒,毕竟后台还有人工来完成识别。

返回的结果是一个 Json,如果识别成功后一个典型的返回结果类似如下:

{'err_no': 0, 'err_str': 'OK', 'pic_id': '6002001380949200001', 'pic_str': '132,127|56,77', 'md5': '1f8e1d4bef8b11484cb1f1f34299865b'}

其中 pic_str 就是识别的文字的坐标,是以字符串形式返回的,每个坐标都以 | 分隔,所以接下来我们只需要将其解析之后再模拟点击即可,代码实现如下:

def get_points(self, captcha_result):
    """
    解析识别结果
    :param captcha_result: 识别结果
    :return: 转化后的结果
    """
    groups = captcha_result.get('pic_str').split('|')
    locations = [[int(number) for number in group.split(',')] for group in groups]
    return locations

def touch_click_words(self, locations):
    """
    点击验证图片
    :param locations: 点击位置
    :return: None
    """
    for location in locations:
        print(location)
        ActionChains(self.browser).move_to_element_with_offset(self.get_touclick_element(), location[0], location[1]).click().perform()
        time.sleep(1)

在这里我们用 get_points() 方法将识别结果变成了列表的形式,最后 touch_click_words() 方法则通过调用 move_to_element_with_offset() 方法依次传入解析后的坐标,然后点击即可。

这样我们就可以模拟完成坐标的点选了,运行效果如图 8-23 所示:

图 8-23 点选效果

最后我们需要做的就是点击提交验证的按钮等待验证通过,再点击登录按钮即可成功登录,后续实现在此不再赘述。

这样我们就借助于在线验证码平台完成了点触验证码的识别,此种方法也是一种通用方法,用此方法来识别 12306 等验证码也是完全相同的原理。

10. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackTouClick

11. 结语

本节我们通过在线打码平台辅助完成了验证码的识别,这种识别方法非常强大,几乎任意的验证码都可以识别,如果遇到难题,借助于打码平台无疑是一个极佳的选择。

转载请注明:静觅 » [Python3网络爬虫开发实战] 8.3-点触点选验证码的识别

[Python3网络爬虫开发实战] 8.4-微博宫格验证码的识别

0
0

本节我们来介绍一下新浪微博宫格验证码的识别,此验证码是一种新型交互式验证码,每个宫格之间会有一条指示连线,指示了我们应该的滑动轨迹,我们需要按照滑动轨迹依次从起始宫格一直滑动到终止宫格才可以完成验证,如图 8-24 所示:

图 8-24 验证码示例

鼠标滑动后的轨迹会以黄色的连线来标识,如图 8-25 所示:

图 8-25 滑动过程

我们可以访问新浪微博移动版登录页面就可以看到如上验证码,链接为:https://passport.weibo.cn/signin/login,当然也不是每次都会出现验证码,一般当频繁登录或者账号存在安全风险的时候会出现。

接下来我们就来试着识别一下此类验证码。

1. 本节目标

本节我们的目标是用程序来识别并通过微博宫格验证码的验证。

2. 准备工作

本次我们使用的 Python 库是 Selenium,使用的浏览器为 Chrome,在此之前请确保已经正确安装好了 Selenium 库、Chrome浏览器并配置好了 ChromeDriver,相关流程可以参考第一章的说明。

3. 识别思路

要识别首先要从探寻规律入手,那么首先我们找到的规律就是此验证码的四个宫格一定是有连线经过的,而且每一条连线上都会相应的指示箭头,连线的形状多样,如C型、Z型、X型等等,如图 8-26、8-27、8-28 所示:

图 8-26 C 型

图 8-27 Z 型

图 8-28 X 型

而同时我们发现同一种类型它的连线轨迹是相同的,唯一不同的就是连线的方向,如图 8-29、8-30 所示:

图 8-29 反向连线

图 8-30 正向连线

这两种验证码的连线轨迹是相同的,但是由于连线上面的指示箭头不同导致滑动的宫格顺序就有所不同。

所以要完全识别滑动宫格顺序的话就需要具体识别出箭头的朝向,而观察一下整个验证码箭头朝向一共可能有 8 种,而且会出现在不同的位置,如果要写一个箭头方向识别算法的话需要都考虑到不同箭头所在的位置,我们需要找出各个位置的箭头的像素点坐标,同时识别算法还需要计算其像素点变化规律,这个工作量就变得比较大。

这时我们可以考虑用模板匹配的方法,模板匹配的意思就是将一些识别目标提前保存下来并做好标记,称作模板,在这里我们就可以获取验证码图片并做好拖动顺序的标记当做模板。在匹配的时候来对比要新识别的目标和每一个模板哪个是匹配的,如果找到匹配的模板,则被匹配到的模板就和新识别的目标是相同的,这样就成功识别出了要新识别的目标了。模板匹配在图像识别中也是非常常用的一种方法,实现简单而且易用性好。

模板匹配方法如果要效果好的话,我们必须要收集到足够多的模板才可以,而对于微博宫格验证码来说,宫格就 4 个,验证码的样式最多就是 4 3 2 * 1 = 24种,所以我们可以直接将所有模板都收集下来。

所以接下来我们需要考虑的就是用何种模板来进行匹配,是只匹配箭头还是匹配整个验证码全图呢?我们来权衡一下这两种方式的匹配精度和工作量:

  • 首先是精度问题。如果要匹配箭头的话,我们比对的目标只有几个像素点范围的箭头,而且我们需要精确知道各个箭头所在的像素点,一旦像素点有所偏差,那么匹配模板的时候会直接错位,导致匹配结果大打折扣。如果匹配全图,我们无需关心箭头所在位置,同时还有连线帮助辅助匹配,所以匹配精度上显然是全图匹配精度更高。
  • 其次是工作量的问题。如果要匹配箭头的话,我们需要将所有不同朝向的箭头模板都保存下来,而相同位置箭头的朝向可能不一,相同朝向的箭头位置可能不一,这时候我们需要都算出各个箭头的位置并将其逐个截出来保存成模板,同时在匹配的时候也需要依次去探寻验证码对应位置是否有匹配模板。如果匹配全图的话,我们不需要关心每个箭头的位置和朝向,只需要将验证码全图保存下来即可,在匹配的时候也不需要再去计算箭头的位置,所以工作量上明显是匹配全图更小。

所以综上考虑,我们选用全图匹配的方式来进行识别。

所以到此为止,我们就可以使用全图模板匹配的方法来识别这个宫格验证码了,找到匹配的模板之后,我们就可以得到事先为模板定义的拖动顺序,然后模拟拖动即可。

4. 获取模板

在开始之前,我们需要做一下准备工作,先将 24 张验证码全图保存下来,保存工作难道需要手工来做吗?当然不是的,因为验证码是随机的,一共有 24 种,所以我们可以写一段程序来批量保存一些验证码图片,然后从中筛选出需要的图片就好了,代码如下:

import time
from io import BytesIO
from PIL import Image
from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

USERNAME = ''
PASSWORD = ''

class CrackWeiboSlide():
    def __init__(self):
        self.url = 'https://passport.weibo.cn/signin/login'
        self.browser = webdriver.Chrome()
        self.wait = WebDriverWait(self.browser, 20)
        self.username = USERNAME
        self.password = PASSWORD

    def __del__(self):
        self.browser.close()

    def open(self):
        """
        打开网页输入用户名密码并点击
        :return: None
        """
        self.browser.get(self.url)
        username = self.wait.until(EC.presence_of_element_located((By.ID, 'loginName')))
        password = self.wait.until(EC.presence_of_element_located((By.ID, 'loginPassword')))
        submit = self.wait.until(EC.element_to_be_clickable((By.ID, 'loginAction')))
        username.send_keys(self.username)
        password.send_keys(self.password)
        submit.click()

    def get_position(self):
        """
        获取验证码位置
        :return: 验证码位置元组
        """
        try:
            img = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'patt-shadow')))
        except TimeoutException:
            print('未出现验证码')
            self.open()
        time.sleep(2)
        location = img.location
        size = img.size
        top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size['width']
        return (top, bottom, left, right)

    def get_screenshot(self):
        """
        获取网页截图
        :return: 截图对象
        """
        screenshot = self.browser.get_screenshot_as_png()
        screenshot = Image.open(BytesIO(screenshot))
        return screenshot

    def get_image(self, name='captcha.png'):
        """
        获取验证码图片
        :return: 图片对象
        """
        top, bottom, left, right = self.get_position()
        print('验证码位置', top, bottom, left, right)
        screenshot = self.get_screenshot()
        captcha = screenshot.crop((left, top, right, bottom))
        captcha.save(name)
        return captcha

    def main(self):
        """
        批量获取验证码
        :return: 图片对象
        """
        count = 0
        while True:
            self.open()
            self.get_image(str(count) + '.png')
            count += 1

if __name__ == '__main__':
    crack = CrackWeiboSlide()
    crack.main()

其中这里需要将 USERNAME 和 PASSWORD 修改为自己微博的用户名密码,运行一段时间后便可以发现在本地多了很多以数字命名的验证码,如图 8-31 所示:

图 8-31 获取结果

在这里我们只需要挑选出不同的24张验证码图片并命名保存就好了,名称可以直接取作宫格的滑动的顺序,如某张验证码图片如图 8-32 所示:

图 8-32 验证码示例

我们将其命名为 4132.png 即可,也就是代表滑动顺序为 4-1-3-2,按照这样的规则,我们将验证码整理为如下 24 张图,如图 8-33 所示:

图 8-33 整理结果

如上的 24 张图就是我们的模板,接下来我们在识别的时候只需要遍历模板进行匹配即可。

5. 模板匹配

上面的代码已经实现了将验证码保存下来的功能,通过调用 get_image() 方法我们便可以得到验证码图片对象,得到验证码对象之后我们就需要对其进行模板匹配了,定义如下的方法进行匹配:

from os import listdir

def detect_image(self, image):
    """
    匹配图片
    :param image: 图片
    :return: 拖动顺序
    """
    for template_name in listdir(TEMPLATES_FOLDER):
        print('正在匹配', template_name)
        template = Image.open(TEMPLATES_FOLDER + template_name)
        if self.same_image(image, template):
            # 返回顺序
            numbers = [int(number) for number in list(template_name.split('.')[0])]
            print('拖动顺序', numbers)
            return numbers

在这里 TEMPLATES_FOLDER 就是模板所在的文件夹,在这里我们用 listdir() 方法将所有模板的文件名称获取出来,然后对其进行遍历,通过 same_image() 方法对验证码和模板进行比对,如果成功匹配,那么就将匹配到的模板文件名转为列表,如匹配到了 3124.png,则返回结果 [3, 1, 2, 4]。

比对的方法实现如下:

def is_pixel_equal(self, image1, image2, x, y):
    """
    判断两个像素是否相同
    :param image1: 图片1
    :param image2: 图片2
    :param x: 位置x
    :param y: 位置y
    :return: 像素是否相同
    """
    # 取两个图片的像素点
    pixel1 = image1.load()[x, y]
    pixel2 = image2.load()[x, y]
    threshold = 20
    if abs(pixel1[0] - pixel2[0]) < threshold and abs(pixel1[1] - pixel2[1]) < threshold and abs(
            pixel1[2] - pixel2[2]) < threshold:
        return True
    else:
        return False

def same_image(self, image, template):
    """
    识别相似验证码
    :param image: 待识别验证码
    :param template: 模板
    :return:
    """
    # 相似度阈值
    threshold = 0.99
    count = 0
    for x in range(image.width):
        for y in range(image.height):
            # 判断像素是否相同
            if self.is_pixel_equal(image, template, x, y):
                count += 1
    result = float(count) / (image.width * image.height)
    if result > threshold:
        print('成功匹配')
        return True
    return False

在这里比对图片也是利用了遍历像素的方法,same_image() 方法接收两个参数,image 为待检测的验证码图片对象,template 是模板对象,由于二者大小是完全一致的,所以在这里我们遍历了图片的所有像素点,比对二者同一位置的像素点是否相同,如果相同就计数加 1,最后计算一下相同的像素点占总像素的比例,如果该比例超过一定阈值那就判定为图片完全相同,匹配成功。在这里设定阈值为 0.99,即如果二者有 0.99 以上的相似比则代表匹配成功。

这样通过上面的方法,依次匹配 24 个模板,如果验证码图片正常,总能找到一个匹配的模板,这样最后就可以得到宫格的滑动顺序了。

6. 模拟拖动

得到了滑动顺序之后,我们接下来就是根据滑动顺序来拖动鼠标连接各个宫格了,方法实现如下:

def move(self, numbers):
    """
    根据顺序拖动
    :param numbers:
    :return:
    """
    # 获得四个按点
    circles = self.browser.find_elements_by_css_selector('.patt-wrap .patt-circ')
    dx = dy = 0
    for index in range(4):
        circle = circles[numbers[index] - 1]
        # 如果是第一次循环
        if index == 0:
            # 点击第一个按点
            ActionChains(self.browser) 
                .move_to_element_with_offset(circle, circle.size['width'] / 2, circle.size['height'] / 2) 
                .click_and_hold().perform()
        else:
            # 小幅移动次数
            times = 30
            # 拖动
            for i in range(times):
                ActionChains(self.browser).move_by_offset(dx / times, dy / times).perform()
                time.sleep(1 / times)
        # 如果是最后一次循环
        if index == 3:
            # 松开鼠标
            ActionChains(self.browser).release().perform()
        else:
            # 计算下一次偏移
            dx = circles[numbers[index + 1] - 1].location['x'] - circle.location['x']
            dy = circles[numbers[index + 1] - 1].location['y'] - circle.location['y']

在这里方法接收的参数就是宫格的点按顺序,如 [3, 1, 2, 4]。首先我们利用 find_elements_by_css_selector() 方法获取到四个宫格元素,是一个列表形式,每个元素代表一个宫格,接下来我们遍历了宫格的点按顺序,再做一系列对应操作。

其中如果是第一个宫格,那就直接鼠标点击并保持动作,否则移动到下一个宫格。如果是最后一个宫格,那就松开鼠标,否则计算移动到下一个宫格的偏移量。

通过四次循环,我们便可以成功操作浏览器完成宫格验证码的拖拽填充,松开鼠标之后即可识别成功。

运行效果如图 8-34 所示:

图 8-34 运行效果

鼠标会慢慢的从起始位置移动到终止位置,最后一个宫格松开之后便完成了验证码的识别。

至此,微博宫格验证码的识别就全部完成了。

识别完成之后验证码窗口会自动关闭,接下来直接点击登录按钮即可完成微博登录。

7. 本节代码

本节代码地址为:https://github.com/Python3WebSpider/CrackWeiboSlide

8. 结语

本节我们介绍了一种常用的模板匹配识别图片的方式来识别验证码,并模拟了鼠标拖拽动作来实现验证码的识别。如果遇到类似的验证码,可以采用同样的思路进行识别。

转载请注明:静觅 » [Python3网络爬虫开发实战] 8.4-微博宫格验证码的识别

[Python3网络爬虫开发实战] 9-代理的使用

0
0

我们在做爬虫的过程中经常会遇到这样的情况,最初爬虫正常运行,正常抓取数据,一切看起来都是那么的美好,然而一杯茶的功夫可能就会出现错误,比如 403 Forbidden,这时候打开网页一看,可能会看到“您的 IP 访问频率太高”这样的提示,或者跳出一个验证码让我们输入,输入之后才可能解封,但是输入之后过一会儿就又这样了。

出现这样的现象的原因是网站采取了一些反爬虫的措施,比如服务器会检测某个 IP 在单位时间内的请求次数,如果超过了这个阈值,那么会直接拒绝服务,返回一些错误信息,这种情况可以称之为封 IP,于是乎就成功把我们的爬虫禁掉了。

既然服务器检测的是某个 IP 单位时间的请求次数,那么我们借助某种方式来伪装我们的 IP,让服务器识别不出是由我们本机发起的请求,不就可以成功防止封 IP 了吗?

所以这时候代理就派上用场了,本章我们会详细介绍一下代理的基本知识及各种代理的使用方式,帮助爬虫脱离封 IP 的苦海。

本章接下来会介绍代理的设置、代理池的维护、付费代理的使用、ADSL拨号代理的搭建方法。

转载请注明:静觅 » [Python3网络爬虫开发实战] 9-代理的使用

Viewing all 277 articles
Browse latest View live




Latest Images