Skip to content

J
jbt-zh

OpenDocCN / jbt-zh
8 个月 前同步成功

通知 0
Star 8
Fork 1
J
jbt-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 cd3252f7 编写于 作者: W wizardforcel
浏览文件
操作

2020-06-25 12:57:05

上级 8528d91a
隐藏空白更改
内联 并排
Showing with 459 addition and 269 deletion
docs/101.md
浏览文件 @ cd3252f7
......@@ -14,11 +14,11 @@
您一定在想我是怎么想到这个好主意的。 正如小兵曾经说过的，我当然会自言自语！ 有时我需要专家的建议。 （好吧，明白了，别那样看着我！）继续…
## PPT的简要说明：
## PPT 的简要说明：
该视频首先向您展示演示的整体情况。 我们的大脑更喜欢视觉而不是文字。 因此，始终要畅所欲言，并在幻灯片上显示相关图像，而不是数百个单词，这始终是一个好习惯。
* *幻灯片 1*： 'WOW'。 用**爆炸**打开PPT！ 首先要引起您对样式的“迷恋”。 可能是*现实生活中的事件，假想的场景，发人深省的报价或问题*
* *幻灯片 1*： 'WOW'。 用**爆炸**打开 PPT！ 首先要引起您对样式的“迷恋”。 可能是*现实生活中的事件，假想的场景，发人深省的报价或问题*
* *幻灯片 2*： 面临的挑战。 简单介绍一下我们在没有自动化的情况下面临的挑战/问题。 允许客户**考虑**。 这也应该作为介绍的介绍。 例如，显示简单场景的图形。 对于每个发行版，测试用例数量都会增加（回归套件+发行用例），从而增加了总体开发成本。 这最终减少了产品的上市时间，这可能会对总收入/销售额造成重大打击。
......@@ -47,7 +47,7 @@
所有这些看起来都不酷吗？ 如果是，那您还等什么呢？ 成为哈利·波特！ 添加您的魔力和创造力，进行自定义，使其更具表现力和令人印象深刻！
像我创建的PPT一样，想要复制它并根据您的要求进行编辑吗？ 这是我的 [**prezi 链接**](https://prezi.com/t23nditffrdy/?utm_campaign=share&utm_medium=copy&rc=ex0share)。 我将其设置为“*公开且可重复使用*”。 复制副本之前，请先点击“赞”按钮，希望您喜欢这个免费赠品。🙂
像我创建的 PPT 一样，想要复制它并根据您的要求进行编辑吗？ 这是我的 [**prezi 链接**](https://prezi.com/t23nditffrdy/?utm_campaign=share&utm_medium=copy&rc=ex0share)。 我将其设置为“*公开且可重复使用*”。 复制副本之前，请先点击“赞”按钮，希望您喜欢这个免费赠品。🙂
在评论部分让我知道您的想法和经验。 即将在我们即将推出的，期待已久的 WebDriver 系列中与您见面！
docs/103.md
浏览文件 @ cd3252f7
......@@ -56,7 +56,7 @@
单击“添加外部 JAR ...”按钮。 “JAR 选择”窗口将打开。 浏览至 seleniumhq.org 站点（Selenium 客户端和 WebDriver 语言绑定）中的文件的下载和提取位置。
确保选择所有类型为“可执行 Jar 文件”的文件。 目前，我在“`selenium-java-3.0.0-beta2`”文件夹中有一个文件，在`selenium-java-3.0.0-beta2\lib`文件夹中有16个文件。
确保选择所有类型为“可执行 Jar 文件”的文件。 目前，我在“`selenium-java-3.0.0-beta2`”文件夹中有一个文件，在`selenium-java-3.0.0-beta2\lib`文件夹中有 16 个文件。
点击“打开”，将它们添加到“用户库”窗口下创建的文件夹中。 点击“确定”，现在您将在“添加库”窗口中看到带有复选框的用户库。 确保选中此复选框，然后单击“完成”。 创建的用户库将在项目属性窗口的“库”选项卡中提供所有添加的外部 JAR。
......
docs/130.md
浏览文件 @ cd3252f7
......@@ -12,7 +12,7 @@
所有这些使自动化测试人员的工作更具挑战性！ 绝对 XPath 可能会有所帮助，但是如果 DOM 中包含新元素或现有元素稍微移动了一点，那么脚本可能会失败，因为找不到该元素。 相对的 XPath 可能可以解决，但是即使那样，由于脚本变得复杂，整个过程也变得很困难。
处理此类情况的最简单便捷的方法是在HTML元素上引入`data-*`属性（自定义数据属性）。 这里唯一的问题是，您将需要成为开发人员的好书！ 他/她是根据您的要求将这些属性添加到代码中的人。😉
处理此类情况的最简单便捷的方法是在 HTML 元素上引入`data-*`属性（自定义数据属性）。 这里唯一的问题是，您将需要成为开发人员的好书！ 他/她是根据您的要求将这些属性添加到代码中的人。😉
现在让我对这些自定义数据属性进行学习，
......
docs/145.md
浏览文件 @ cd3252f7
# 1.使用 Vue.js 的 Hello World
# 1 使用 Vue.js 的 Hello World
> 原文： [https://javabeginnerstutorial.com/js/vue-js/1-hello-world-with-vue-js/](https://javabeginnerstutorial.com/js/vue-js/1-hello-world-with-vue-js/)
......@@ -14,7 +14,7 @@
### 选项 1：
```java
```js
<!-- development version -->
<script src="https://cdn.jsdelivr.net/npm/[[email protected]](/cdn-cgi/l/email-protection)/dist/vue.js"></script>
<!-- production version -->
......@@ -25,7 +25,7 @@
Vue 也可用于 unpkg，
```java
```js
<script src="https://unpkg.com/[[email protected]](/cdn-cgi/l/email-protection)/dist/vue.js"></script>
```
......@@ -33,7 +33,7 @@ Vue 也可用于 unpkg，
但是，如果您不想提及该版本并使用最新版本，请继续，
```java
```js
<script src="https://cdn.jsdelivr.net/npm/[[email protected]](/cdn-cgi/l/email-protection)/dist/vue.js"></script>
<script src="https://cdn.jsdelivr.net/npm/vue"></script>
<!-- or -->
......@@ -52,7 +52,7 @@ Vue 也可用于 unpkg，
使用以下代码创建一个 HTML 文件“`index.html`”，
```java
```js
<!DOCTYPE html>
<html>
<head>
......@@ -82,7 +82,7 @@ Chrome 浏览器中的当前输出如下，
我们已经使用`<script>`标签将 Vue.js 导入了我们的项目，但这并不能解决问题。 这相当于在我们的工作台上有一台笔记本电脑。 要打开它并完成一些工作，我们必须按下电源按钮。 同样，要在我们的项目中使用 Vue，我们必须使用`new`关键字创建 Vue 对象的实例。 这个实例是 Vue 的电源按钮！
```javascript
```jsscript
new Vue();
```
......@@ -92,7 +92,7 @@ new Vue();
**例如**：“`el`”，“`data`”，“`method`”等。
```javascript
```jsscript
new Vue({ options/config object });
```
......@@ -102,7 +102,7 @@ new Vue({ options/config object });
为了在 Vue 实例和 DOM 的一部分之间建立这种连接，以便可以根据我们的需要对其进行控制，我们有一个名为“`el`”的保留属性，该属性转换为*元素*。 此属性将字符串作为值指定为 CSS 选择器，即`id`的“`#`”和“`.`”对于`class`。
```javascript
```jsscript
new Vue({ el: "#app" });
```
......@@ -112,7 +112,7 @@ new Vue({ el: "#app" });
为了存储我们要在此 Vue 实例及其链接的 DOM 中使用的所有数据/信息，我们还有一个保留的属性，称为“`data`”。 与“`el`”不同，“`data`”将对象作为其值。 由于我们要向 DOM 显示消息“`Hello World`”，因此让我们在“数据”对象中将其指定为键值对。
```javascript
```jsscript
new Vue({ el: "#app", data: { message: "Hello World" } });
```
......
docs/146.md
浏览文件 @ cd3252f7
# 2.模板语法和反应式的初探
# 2 模板语法和反应式的初探
> 原文： [https://javabeginnerstutorial.com/js/vue-js/2-template-syntax-reactivity/](https://javabeginnerstutorial.com/js/vue-js/2-template-syntax-reactivity/)
......@@ -8,7 +8,7 @@
来自“`index.html`”的摘录，
```java
```js
<div id="app">
<h1>{{ message }}</h1>
</div>
......@@ -18,7 +18,7 @@
以下是“`index.js`”文件中的代码，
```java
```js
var app = new Vue({
el: "#app",
data: {
......@@ -71,7 +71,7 @@ var app = new Vue({
另外，让我们将`index.js`文件中`message`属性的值更改为“`Vue`”，而不是“`Hello World !!!`”。 只是为了使这些句子更有意义。
```javascript
```jsscript
var app = new Vue({
el: "#app",
data: {
......
docs/147.md
浏览文件 @ cd3252f7
# 3\. Vue 指令简介
# 3 Vue 指令简介
> 原文： [https://javabeginnerstutorial.com/vue-js/3-vue-directives/](https://javabeginnerstutorial.com/vue-js/3-vue-directives/)
......@@ -30,7 +30,7 @@ Vue 带有一些内置指令。 请注意，我们可以编写自己的自定义
### `Index.html`
```java
```js
<html>
<head>
<title>Hello Vue!</title>
......@@ -50,7 +50,7 @@ Vue 带有一些内置指令。 请注意，我们可以编写自己的自定义
### `Index.js`
```java
```js
var app = new Vue({
el: "#app",
data: {
......
docs/148.md
浏览文件 @ cd3252f7
# 4\. Vue Devtools 设置
# 4 Vue Devtools 设置
> 原文： [https://javabeginnerstutorial.com/vue-js/4-vue-devtools-setup/](https://javabeginnerstutorial.com/vue-js/4-vue-devtools-setup/)
......
docs/149.md
浏览文件 @ cd3252f7
# 5.数据绑定第 1 部分（文本，原始 HTML，JavaScript 表达式）
# 5 数据绑定第 1 部分（文本，原始 HTML，JavaScript 表达式）
> 原文： [https://javabeginnerstutorial.com/vue-js/5-data-binding-p1/](https://javabeginnerstutorial.com/vue-js/5-data-binding-p1/)
......@@ -28,19 +28,19 @@
1. 可以始终在模板语法中访问“`message`”属性的值。 现在，我们可以对其应用任何可用的 JavaScript `String`方法。
```javascript
```jsscript
{{ message.length }}
```
2. js 允许访问模板表达式中的几个全局对象，即`Math`和`Date`。 小心，不允许访问用户定义的全局变量。
```javascript
```jsscript
{{ Math.PI }} {{ new Date() }}
```
3. 流控制语句（如`if-else`，`for`，`while`，`do-while`等）将不起作用，因此剩下的唯一选择是使用三元表达式。 始终建议将复杂的逻辑放入我们将在以后的文章中详细讨论的方法中。
```javascript
```jsscript
{{ message === "Hi everyone!" ? "Welcome to the World of Vue" : "Hola" }}
```
......@@ -84,7 +84,7 @@
### `Index.js`
```javascript
```jsscript
var app = new Vue({
el: "#app",
data: {
......
docs/150.md
浏览文件 @ cd3252f7
# 6.数据绑定第 2 部分（属性）
# 6 数据绑定第 2 部分（属性）
> 原文： [https://javabeginnerstutorial.com/vue-js/6-data-binding-p2/](https://javabeginnerstutorial.com/vue-js/6-data-binding-p2/)
......@@ -53,7 +53,7 @@
在 Vue 实例的数据对象中，让我们拥有`isInputDisabled`属性，并将其值设置为`true`
```javascript
```jsscript
isInputDisabled: true
```
......@@ -69,7 +69,7 @@ isInputDisabled: true
现在让我们将`isInputDisabled`的值更改为`false`。
```javascript
```jsscript
isInputDisabled: false
```
......@@ -110,7 +110,7 @@ isInputDisabled: false
### `Index.js`
```javascript
```jsscript
var app = new Vue({
el: "#app",
data: {
......
docs/151.md
浏览文件 @ cd3252f7
# 7.条件渲染第 1 部分（`v-if`，`v-else`，`v-else-if`）
# 7 条件渲染第 1 部分（`v-if`，`v-else`，`v-else-if`）
> 原文： [https://javabeginnerstutorial.com/vue-js/7-conditional-rendering-part-1/](https://javabeginnerstutorial.com/vue-js/7-conditional-rendering-part-1/)
......@@ -22,7 +22,7 @@ Vue **指令**再来一次！ 在这方面，我们有`v-if`，`v-else`和`v-els
让我们向 Vue 实例的数据对象添加`display`属性，并为其赋予`false`值。
```javascript
```jsscript
data: { message: "Hi", display: false }
```
......@@ -67,7 +67,7 @@ data: { message: "Hi", display: false }
让我们向数据对象添加`val`属性，并为其提供数值。
```javascript
```jsscript
data: { message: "Hi", val: 5 }
```
......
docs/152.md
浏览文件 @ cd3252f7
# 8.条件渲染第 2 部分（`v-if`和`v-show`）
# 8 条件渲染第 2 部分（`v-if`和`v-show`）
> 原文： [https://javabeginnerstutorial.com/vue-js/8-conditional-rendering-part-2/](https://javabeginnerstutorial.com/vue-js/8-conditional-rendering-part-2/)
......@@ -14,7 +14,7 @@
首先，将`display`属性添加到 Vue 实例的数据对象，并为其赋予`true`值。
```java
```js
data: {
display: true
}
......@@ -22,7 +22,7 @@ data: {
其次，对`index.html`文件进行以下更改，
```java
```js
<template v-if="display">
<h1>Welcome</h1>
<p>Hi there!</p>
......@@ -62,7 +62,7 @@ data: {
#### `Index.js`
```javascript
```jsscript
var app = new Vue({
el: "#app",
data: {
......
docs/153.md
浏览文件 @ cd3252f7
# 9.渲染列表第 1 部分（遍历数组）
# 9 渲染列表第 1 部分（遍历数组）
> 原文： [https://javabeginnerstutorial.com/vue-js/9-rendering-lists-part-1/](https://javabeginnerstutorial.com/vue-js/9-rendering-lists-part-1/)
......@@ -8,7 +8,7 @@
我们面临的最常见和最简单的方案是遍历数组的各项并将它们呈现为列表。 以下是四种不同语言的问候语，我们希望将其显示为网页的无序列表。
```java
```js
data: {
greetings: ["hi", "bonjour", "hola", "ciao"]
}
......@@ -16,7 +16,7 @@ data: {
在我们的`index.html`文件中，让我们将`v-for`指令添加到`<li>`元素中，以动态地呈现`greetings`数组的内容，如下所示：
```java
```js
<li v-for="greeting in greetings">{{ greeting }}</li>
......@@ -29,7 +29,7 @@ data: {
* 首先， `greeting` – 建议在我们的情况下使用单数名词，`greeting`，作为数组元素的**别名**反复进行。 这可以是您选择的任何名称，然后可以在我们的代码中使用该名称来寻址每个数组项。
* 其次，作为语法一部分的 – **定界符**`in`。 如果您具有 JavaScript 背景，那么所有这些看起来都应该很熟悉，因为在这里我们将`for in`和`for of`用于迭代目的。 即使使用 Vue，我们也可以使用`of`作为分隔符而不是`in`
```java
```js
<li v-for="greeting of greetings">{{ greeting }}</li>
```
......@@ -63,7 +63,7 @@ data: {
让我们转到控制台，使用`push`方法向`greetings`数组添加一个问候，然后查看视图是否进行了动态更新（*神奇地*！）。
```javascript
```jsscript
$vm0.greetings.push("namaste")
```
......@@ -118,7 +118,7 @@ $vm0.greetings.push("namaste")
### `Index.js`
```javascript
```jsscript
var app = new Vue({
el: "#app",
data: {
......
docs/154.md
浏览文件 @ cd3252f7
# 10.渲染列表第 2 部分（遍历对象）
# 10 渲染列表第 2 部分（遍历对象）
> 原文： [https://javabeginnerstutorial.com/vue-js/10-rendering-lists-part-2/](https://javabeginnerstutorial.com/vue-js/10-rendering-lists-part-2/)
......@@ -8,7 +8,7 @@
是时候向我们的 Vue 实例的`data`对象添加一个简单的对象了。
```java
```js
var app = new Vue({
el: "#app",
data: {
......@@ -28,7 +28,7 @@ var app = new Vue({
访问对象的值非常简单。
```java
```js
<div v-for="value in letters"> {{ value }} </div>
```
......@@ -76,7 +76,7 @@ var app = new Vue({
假设我们的数据对象中有两个简单对象的数组。
```javascript
```jsscript
movies: [
{ character: "Iron man", name: "Avengers" },
{ character: "groot", name: "Guardians of the Galaxy" }
......@@ -217,7 +217,7 @@ movies: [
**`index.js`**
```java
```js
var app = new Vue({
el: "#app",
data: {
......
docs/155.md
浏览文件 @ cd3252f7
# 11.监听 DOM 事件和事件修饰符
# 11 监听 DOM 事件和事件修饰符
> 原文： [https://javabeginnerstutorial.com/vue-js/11-listening-to-dom-events-and-event-modifiers/](https://javabeginnerstutorial.com/vue-js/11-listening-to-dom-events-and-event-modifiers/)
......@@ -6,7 +6,7 @@
#### `Index.html`
```java
```js
<!DOCTYPE html>
<html>
<head>
......@@ -28,7 +28,7 @@
#### `Index.js`
```java
```js
var app = new Vue({
el: "#app",
data: {
......@@ -50,7 +50,7 @@ var app = new Vue({
因此，我们现在的任务是监听按钮“Say Hello”上发生点击事件时，将消息文本从“`Hi`”更改为“`Hello`”。 一件事很清楚。 我们必须将`v-on`指令添加到将要监听`click`事件的`button`元素中。
```java
```js
<button v-on:click="message='Hello'">Say Hello</button>
```
......@@ -82,7 +82,7 @@ var app = new Vue({
#### `Index.js`
```javascript
```jsscript
var app = new Vue({
el: "#app",
data: {
......@@ -118,7 +118,7 @@ var app = new Vue({
#### `Index.js`（代码段）
```javascript
```jsscript
methods: {
addOne: function() {
this.counter += 1;
......@@ -223,7 +223,7 @@ v-on:click.self.prevent
index.js
```javascript
```jsscript
var app = new Vue({
el: "#app",
data: {
......
docs/156.md
浏览文件 @ cd3252f7
# 12.监听键盘和鼠标事件
# 12 监听键盘和鼠标事件
> 原文： [https://javabeginnerstutorial.com/vue-js/12-listening-to-keyboard-and-mouse-events/](https://javabeginnerstutorial.com/vue-js/12-listening-to-keyboard-and-mouse-events/)
......@@ -8,7 +8,7 @@
**`Index.html`**
```java
```js
<!DOCTYPE html>
<html>
<head>
......@@ -29,7 +29,7 @@
**`Index.js`**
```java
```js
new Vue({
el: "#app",
data: {
......@@ -49,7 +49,7 @@ new Vue({
**`Index.html`（代码段）**
```java
```js
<!-- Using key modifiers along with keyboard events -->
<button v-on:keyup.13="greet">greet</button>
```
......@@ -78,13 +78,13 @@ new Vue({
将以下行添加到“`index.js`”文件中以启用“`v-on:keyup.a`”，
```java
```js
Vue.config.keyCodes.a = 65;
```
**`Index.html`（代码段）**
```java
```js
<button v-on:keyup.a="greet">greet</button>
```
......@@ -100,7 +100,7 @@ Vue.config.keyCodes.a = 65;
**`Index.js`**
```java
```js
new Vue({
el: "#app",
data: {
......@@ -118,7 +118,7 @@ new Vue({
**`Index.html`（代码段）**
```java
```js
<button v-on:mouseover="showRole">Hover over me!</button>
{{ role }}
```
......@@ -146,7 +146,7 @@ new Vue({
**`Index.js`**
```javascript
```jsscript
new Vue({
el: "#app",
data: {
......@@ -193,7 +193,7 @@ new Vue({
**`Index.js`（代码段）**
```javascript
```jsscript
showRole(customRole, event) {
// 'this' keyword refers to the current Vue instance
this.role = customRole;
......@@ -234,7 +234,7 @@ showRole(customRole, event) {
**`Index.js`**
```javascript
```jsscript
new Vue({
el: "#app",
data: {
......
docs/157.md
浏览文件 @ cd3252f7
# 13.让我们使用简写
# 13 让我们使用简写
> 原文： [https://javabeginnerstutorial.com/vue-js/13-shorthands-for-v-bind-and-v-on/](https://javabeginnerstutorial.com/vue-js/13-shorthands-for-v-bind-and-v-on/)
......@@ -10,7 +10,7 @@
`Index.html`
```java
```js
<!DOCTYPE html>
<html>
<head>
......@@ -30,7 +30,7 @@
`Index.js`
```java
```js
new Vue({
el: "#app",
data: {
......@@ -47,7 +47,7 @@ new Vue({
*`Index.html`（代码段）*
```java
```js
<a v-bind:href="url" target="_blank">Google</a>
```
......@@ -55,7 +55,7 @@ new Vue({
*`Index.js`（代码段）*
```java
```js
data: {
url: "https://www.google.com"
}
......@@ -63,7 +63,7 @@ data: {
这段代码工作得很好。 单击链接“`Google`”，将打开一个新标签，并导航到 Google 页面。 但是我们想看起来很酷。 不是吗？因此，编写`v-bind`指令的简短方法是一次性删除`v-bind`一词，而仅使用**冒号**。
```java
```js
<!— Cool way of writing v-bind -->
<a :href="url" target="_blank">Google</a>
```
......@@ -88,7 +88,7 @@ data: {
*`Index.js`（代码段）*
```javascript
```jsscript
data: {
message: "Hi",
url: "https://www.google.com"
......@@ -137,7 +137,7 @@ methods: {
`Index.js`
```javascript
```jsscript
new Vue({
el: "#app",
data: {
......
docs/158.md
浏览文件 @ cd3252f7
# 14.使用`v-model`进行双向数据绑定
# 14 使用`v-model`进行双向数据绑定
> 原文： [https://javabeginnerstutorial.com/vue-js/14-two-way-binding-v-model/](https://javabeginnerstutorial.com/vue-js/14-two-way-binding-v-model/)
......@@ -32,13 +32,13 @@
通过将`v-model`指令添加到`<input>`标记并将“`message`”属性绑定到它，可以完成所有这三个步骤，
```java
```js
<input type="text" v-model="data_property_to_bind"></input>
```
**`Index.html`**
```java
```js
<!DOCTYPE html>
<html>
<head>
......@@ -64,7 +64,7 @@
**`Index.js`**
```java
```js
new Vue({
el: "#app",
data: {
......
docs/159.md
浏览文件 @ cd3252f7
# 15.表单输入绑定
# 15 表单输入绑定
> 原文： [https://javabeginnerstutorial.com/vue-js/15-form-input-bindings/](https://javabeginnerstutorial.com/vue-js/15-form-input-bindings/)
......@@ -19,7 +19,7 @@
index.html
```java
```js
<!DOCTYPE html>
<html>
<head>
......@@ -39,7 +39,7 @@ index.html
index.js
```java
```js
new Vue({
el: "#app",
data: {
......@@ -53,7 +53,7 @@ new Vue({
`index.html`（代码段）
```java
```js
<div>
<h4>Single checkbox with a boolean value</h4>
<!-- form input bindings: single checkbox -->
......@@ -64,7 +64,7 @@ new Vue({
`index.js`
```java
```js
new Vue({
el: "#app",
data: {
......@@ -101,7 +101,7 @@ new Vue({
`index.js`（代码段）
```javascript
```jsscript
data: {
checkedFilms: []
}
......@@ -135,7 +135,7 @@ data: {
`index.js`（代码段）
```javascript
```jsscript
data: {
selected: ''
}
......@@ -169,7 +169,7 @@ data: {
`index.js`（代码段）
```javascript
```jsscript
data: {
singleSelect: ''
}
......@@ -200,7 +200,7 @@ data: {
`index.js`（代码段）
```javascript
```jsscript
data: {
multiselect: []
}
......@@ -230,7 +230,7 @@ data: {
`Index.js`（代码段）
```javascript
```jsscript
data: {
dynamicSelection: 'Apple',
alphabet: [
......@@ -338,7 +338,7 @@ data: {
`index.js`
```javascript
```jsscript
new Vue({
el: "#app",
data: {
......
docs/160.md
浏览文件 @ cd3252f7
# 18.类绑定
# 18 类绑定
> 原文： [https://javabeginnerstutorial.com/vue-js/18-class-bindings/](https://javabeginnerstutorial.com/vue-js/18-class-bindings/)
......@@ -10,7 +10,7 @@
index.html
```java
```js
<!DOCTYPE html>
<html>
<head>
......@@ -34,7 +34,7 @@ index.html
index.js
```java
```js
new Vue({
el: "#app",
data: {}
......@@ -43,7 +43,7 @@ new Vue({
style.css
```java
```js
<!-- LET US WRITE SOME CODE AS WE GO -->
```
......@@ -51,7 +51,7 @@ style.css
假设我们有一个名为“`success`”的类，其样式在`style.css`样式表中定义如下，
```java
```js
.success {
color: green;
font-weight: bold;
......@@ -63,7 +63,7 @@ style.css
`index.html`（代码段）
```java
```js
<div id="app">
<h2>Welcome</h2>
<div>
......@@ -80,7 +80,7 @@ style.css
`index.js`
```java
```js
new Vue({
el: "#app",
data: {
......@@ -99,7 +99,7 @@ new Vue({
`index.js`（代码段）
```javascript
```jsscript
data: {
successFlag : false
}
......@@ -131,7 +131,7 @@ YESSSS！ 使用 Vue，几乎所有内容都是肯定的！
`index.js`（代码段）
```javascript
```jsscript
data: {
successFlag: false,
bcgFlag: true
......@@ -166,7 +166,7 @@ data: {
`index.js`（代码段）
```javascript
```jsscript
data: {
classObject: {
success : false,
......@@ -194,7 +194,7 @@ data: {
`index.js`（代码段）
```javascript
```jsscript
data: {
successFlag: false,
bcgFlag: true,
......
docs/162.md
浏览文件 @ cd3252f7
......@@ -38,7 +38,7 @@ Python 是*高级*，*交互式*，*面向对象*和*解释*脚本语言。 它
一种解决方案是在运行时确定 Python 版本并在用户使用错误版本执行脚本时退出应用。 为此，让我向您展示一个简单的代码。 现在，请看一下，您就会知道：您可以稍后回到本节中，根据所收集的知识进行修改。
```java
```py
import sys
if sys.version_info[0] != 3:
print("Wrong Python version used")
......@@ -53,13 +53,13 @@ Python 3.5 当前仅是候选版本。 这意味着不鼓励 Python 开发人员
也许您已经注意到您已经在计算机上安装了 Python。 要验证这一点，您必须输入
```java
```py
python
```
在命令提示符下，然后按回车键。 如果已安装，则应显示以下消息：
```java
```py
Python 2.7.10 (default, Jun 10 2015, 19:42:47)
[GCC 4.2.1 Compatible Apple LLVM 6.1.0 (clang-602.0.53)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
......@@ -70,7 +70,7 @@ Type "help", "copyright", "credits" or "license" for more information.
要查看是否已安装 Python 3，请输入
```java
```py
python3
```
......@@ -82,7 +82,7 @@ python3
就是这样。 现在是时候启动 Python 解释器外壳了，可以确定安装正常：
```java
```py
python3
Python 3.4.2 (v3.4.2:ab2c023a9432, Oct 5 2014, 20:42:22)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
......@@ -106,7 +106,7 @@ Type "help", "copyright", "credits" or "license" for more information.
让我们继续并安装`lxml`模块，稍后当我告诉您有关使用 Python 处理 XML 时将需要用到。
```java
```py
$ pip3 install lxml
Collecting lxml
Downloading lxml-3.4.4.tar.gz (3.5MB)
......@@ -120,7 +120,7 @@ Successfully installed lxml-3.4.4
要查看`pip`命令是否适合您，您可以查找其版本并查看其修改的 Python 版本：
```java
```py
$ pip -V
pip 7.0.3 from /usr/local/lib/python2.7/site-packages/pip-7.0.3-py2.7.egg (python 2.7)
$ pip3 -V
......@@ -143,7 +143,7 @@ pip 1.5.6 from /Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/s
幸运的是，有一个解决方案：您可以为导入的模块甚至导入的部件（功能，类）指定自定义名称。
```java
```py
>>> import multiprocessing as mp # from now on you can use 'mp' instead of 'multiprocessing'
>>> from calendar import isleap
>>> from calendar import isleap as leap1 # 'leap1' has the same functionality than isleap
......
docs/163.md
浏览文件 @ cd3252f7
......@@ -8,7 +8,7 @@
以下代码段显示了您应该看到的内容：
```java
```py
Python 3.4.2 (v3.4.2:ab2c023a9432, Oct 5 2014, 20:42:22)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
......@@ -34,13 +34,13 @@ Python 的基本语法与其他编程语言非常相似。 但是，有些差异
**Java 代码**
```java
```py
if(a == 42){a = 25; System.out.println(a);}else{a = 42;}
```
**Python 代码**
```java
```py
if a == 42:
a = 25
print(a)
......@@ -50,7 +50,7 @@ else:
如您所见，Python 代码更具可读性（尽管我也是一个有良好基础的 Java 开发人员，但我认为这是我的看法，因此我可以覆盖前面的示例以使其可读）。 如果您有**缩进行（请仔细查看 python 代码中的缩进）**，则表示它属于同一执行组。 例如，在 Java 中，它将不会：
```java
```py
if(a == 42)
a = 25;
System.out.println(a); // Indention will not work here. And it will give compilation error
......@@ -64,7 +64,7 @@ else
为什么会导致不眠之夜？ 因为您有两种缩进方式：**空格**或 **TAB**。 **而且您不能将两者混为一谈！** 如果这样做，则会出现`TabError`：
```java
```py
>>> a = 33
>>> if a == 42:
... a = 25
......@@ -79,7 +79,7 @@ TabError: inconsistent use of tabs and spaces in indentation
如果我切换线路，则会收到另一个错误：
```java
```py
File "<stdin>", line 3
a = 25
^
......@@ -95,7 +95,7 @@ File "<stdin>", line 3
您可以使用井号（# ）。 这告诉解释器，井号后面的同一行上的文字仅是注释，它们无意执行：
```java
```py
>>> print(1+2) # results in 3 : this is comment
3
```
......@@ -130,7 +130,7 @@ False class finally is return None continue for lambda try True def from nonloca
它带有输入功能，并且使用非常简单：
```java
```py
>>> entered = input("Enter some text: ")
Enter some text: 42
>>> entered
......@@ -151,7 +151,7 @@ Enter some text: 42
让我们快速列举一些示例。 我希望这些示例能说明自己。 如果不是这种情况，请随时给我写一封信息，我还将在示例中添加说明性文字。
```java
```py
>>> 6 + 5 # the + sign adds numbers up
11
>>> 6 - 5 # the - sign subtracts the second number from the firs
......@@ -172,7 +172,7 @@ Enter some text: 42
这些运算符比较值（变量或值本身不再重要）。 结果来自布尔类型，可以为`True`或`False`。
```java
```py
>>> 5 == 4 # == is the equality operator, returns True when both sides are equal
False
>>> 4 == 4
......@@ -197,7 +197,7 @@ True
仅输入变量名（在本例中为`a`）并按回车键，便可以在交互式解释器中看到变量的值。
```java
```py
>>> a = 5
>>> a += 3 # a has the value of 8
>>> a -= 2 # a has the value of 6
......@@ -218,7 +218,7 @@ True
现在，让我们看一些示例：
```java
```py
>>> a = True
>>> b = False
>>> a and b
......@@ -245,7 +245,7 @@ True
结果是布尔值`True`或`False`。
```java
```py
>>> primes = [2,3,5,7,11]
>>> 4 in primes
False
......
docs/165.md
浏览文件 @ cd3252f7
......@@ -62,7 +62,7 @@ python 的安装程序也可以从官方网站安装以获得最新版本。 链
安装后，我们将在 Windows 中设置路径。 要在 Windows 的命令提示符下添加 python 目录：
```java
```py
type path %path%;
C: \Python and then press Enter. // It is the path of the python directory
......@@ -74,31 +74,31 @@ C: \Python and then press Enter. // It is the path of the python directory
现在要安装 Homebrew，请打开终端或 OS X 终端仿真器并运行
```java
```py
$ ruby –e “$(curl –fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)”
```
安装 Homebrew 之后，将 Homebrew 目录添加到路径环境变量的顶部，或者可以通过以下方法完成
```java
```py
~/ .profile file
```
路径声明为
```java
```py
Export PATH = /usr/local/bin: /usr/local/sbin: $PATH
```
现在可以安装 Python 2.7。
```java
```py
$ brew install python
```
现在我们来看看简单的 python 程序。
```java
```py
num1 = input('Enter first number: ')
num2 = input('Enter second number: ')
......@@ -114,7 +114,7 @@ print('The sum of {0} and {1} is {2}'.format(num1, num2, sum))
输出：
```java
```py
Enter first number: 4
Enter second number: 4
......
docs/166.md
浏览文件 @ cd3252f7
# Python 3 数字和字符串
# Python 数字和字符串
> 原文： [https://javabeginnerstutorial.com/python-tutorial/python-numbers-and-strings-2/](https://javabeginnerstutorial.com/python-tutorial/python-numbers-and-strings-2/)
......@@ -16,7 +16,7 @@
您也可以在 Python 中使用两个常用的数字（至少在数学上是如此）。 这些数字是`pi`和`e`。 要使用它们，您必须导入数学模块：
```java
```py
>>> import math
>>> math.pi
3.141592653589793
......@@ -30,7 +30,7 @@
为此，我们必须导入一个模块：`random`。
```java
```py
>>> import random
>>> random.choice((1,2,3,4,'a')) # chooses one item of the provided list, tuple or string (it has to be an idexable object)
2
......@@ -54,7 +54,7 @@
让我们举个简单的示例：
```java
```py
>>> "this is a
File "<stdin>", line 1
"this is a
......@@ -80,7 +80,7 @@ Python 没有*字符*的显式类型，它们被视为长度为 1 的字符串
不能就地更新字符串，因为字符串在 Python 中是不可变的类型。 如果您“更新”字符串的值，则仅使用新字符串重新分配该值。
```java
```py
>>> s1 = "Hello World!"
>>> id(s1)
4318883504
......@@ -105,7 +105,7 @@ Python 没有*字符*的显式类型，它们被视为长度为 1 的字符串
* `in`判断字符串中是否存在子字符串
* `not in`判断字符串中是否不存在子字符串
```java
```py
>>> 'Hello' + ' ' + "Python" # the + sign concatenates the strings
'Hello Python'
>>> 'Hello'+'!' * 5 # the * sign creates multiple copies of the string
......@@ -128,7 +128,7 @@ True
多行字符串表示它们与单行（或普通）字符串的打印方式相同，但保留其显式的新行并将特殊的转义字符转换为其打印版本。
```java
```py
>>> spam = """Spam, Spam, Spam, lovely Spam
... Wonderful Spam, Lovely Spam.
... Spam, Spam, Spam, magnificent Spam,
......@@ -155,7 +155,7 @@ Spam, Spam, Spam, Spaaam!
让我们直接进入细节。
```java
```py
>>> name = 'Bob'
>>> age = 31
>>> 'My name is %s and I am %d years young!'%(name, age)
......@@ -172,7 +172,7 @@ Spam, Spam, Spam, Spaaam!
格式函数与参数索引一起使用，并根据类型确定格式。 因此，您不必明确提及参数的类型。 如果您提供的参数数量与占位符相同，则可以保留参数索引。
```java
```py
>>> 'My name is %s and I am %d years young and I have read %d books!'%(name, age, age)
'My name is Bob and I am 31 years young and I have read 31 books!'
>>> 'My name is {} and I am {} years young and I have read {} books!'.format(name, age)
......
docs/167.md
浏览文件 @ cd3252f7
......@@ -4,7 +4,7 @@
我们已经知道 python 列表可以用方括号之间的逗号分隔值编写，并且元素不必来自同一类型。 如果您倾向于忘记此功能，那么后者自然会引起一些混乱和错误。
```java
```py
>>> [1, 'Python', 3.14]
[1, 'Python', 3.14]
```
......@@ -13,7 +13,7 @@
访问列表中的值需要使用它们的索引。 索引是分配给元素的数字，也称为元素的位置。 索引以 0 开头。您可以访问列表或一系列条目中的一个条目。
```java
```py
>>> a = [1,2,3,4,5]
>>> a[2]
3
......@@ -23,7 +23,7 @@
如果尝试访问未填充的索引（该索引不包含任何值），则会收到`IndexError`。
```java
```py
>>> a = []
>>> a[0]
Traceback (most recent call last):
......@@ -33,7 +33,7 @@ IndexError: list index out of range
但是，如果您对不包含索引的列表进行切片，就不会出现错误，而只是一个值比您期望的少的列表（或者当然是一个空列表）：
```java
```py
>>> a = [1,2,3,4,5]
>>> a[:7]
[1, 2, 3, 4, 5]
......@@ -57,7 +57,7 @@ IndexError: list index out of range
如果必须在给定索引处将元素插入列表中的某处，请使用具有两个参数的列表插入功能：插入位置的索引和要插入的对象。 如果索引被某个值占用，则新对象将在给定索引处插入此值之前。 如果未占用索引，则将对象附加到列表。
```java
```py
>>> a = []
>>> a[0] = 2
Traceback (most recent call last):
......@@ -117,7 +117,7 @@ IndexError: list assignment index out of range
如您所知，您可以通过列表中的元素的索引来更新它。 再次：如果您尝试访问当前未填充的索引，则会收到`IndexError`。
```java
```py
>>> a = ["Java", "is", "cool!"]
>>> a
['Java', 'is', 'cool!']
......@@ -134,7 +134,7 @@ IndexError: list assignment index out of range
另一种方法是从列表中弹出一个元素。 `pop`函数采用一个可选参数，该参数是要删除的索引。 如果不提供此参数，则最后一个元素将被删除。 `del`和`pop`之间用法的核心区别在于`pop`返回已删除的元素，因此您可以实际使用它。
```java
```py
>>> a = [1, 2, 3, 4, 5, [6, 7, 8]]
>>> a
[1, 2, 3, 4, 5, [6, 7, 8]]
......@@ -153,7 +153,7 @@ IndexError: list assignment index out of range
这两种方法的区别在于，第一种方法确实在内存中留下了一些占用空间，并且列表的 ID 发生了变化，而清除列表则保留了 ID（内存位置）。
```java
```py
>>> a = [1, 2, 3, 4, 5, [6, 7, 8]]
>>> id(a)
4335030344
......@@ -174,7 +174,7 @@ IndexError: list assignment index out of range
第一个问题是众所周知的，第二个问题在进行动态编程或要从一种使用初始化的编程语言中迁移算法时最常见。
```java
```py
>>> a = [1, 2, 3, 4, 5]
>>> len(a) # returns the length of the given list
5
......
docs/168.md
浏览文件 @ cd3252f7
# Python 3 集
# Python 集
> 原文： [https://javabeginnerstutorial.com/python-tutorial/python-3-set-2/](https://javabeginnerstutorial.com/python-tutorial/python-3-set-2/)
......@@ -14,7 +14,7 @@
有一些方法可以创建集合。 基本版本是列出花括号（`{}`）之间的所有元素。 但是，最常见的用法是当您要从列表中删除重复项时。 在这种情况下，您可以将列表转换为集合，然后再次返回列表。 这将从集合的中间用法中将重复项从列表中删除，您将再次拥有列表。 为此，使用`set`函数，该函数需要一个可迭代的参数。
```java
```py
>>> A = {1,2,3,4,5}
>>> A
{1, 2, 3, 4, 5}
......@@ -38,7 +38,7 @@ TypeError: 'int' object is not iterable
**但是！** 您可以传递字符串作为 set 函数的参数，因为（您可能还记得），字符串是 Python 中的字符列表。 在这种情况下，字符串将拆分为字符，并且每个字符在集合中仅存储一次。
```java
```py
>>> D = set("Spam! Spam! Spam!")
>>> D
{'p', 'm', ' ', 'a', 'S', '!'}
......@@ -46,7 +46,7 @@ TypeError: 'int' object is not iterable
而且因为我已经提到过，您可以使用集合来过滤列表的重复项，因此这里是示例：
```java
```py
>>> l = [1,2,3,2,1,2,3,4,5,6,5,6,4,7,8,3,2,1,3,4,5,6]
>>> l
[1, 2, 3, 2, 1, 2, 3, 4, 5, 6, 5, 6, 4, 7, 8, 3, 2, 1, 3, 4, 5, 6]
......@@ -63,7 +63,7 @@ TypeError: 'int' object is not iterable
这意味着我们仅需添加和删除元素。 与列表不同，您不能使用加法运算符（加号`+`）来扩展集合。 您必须使用`add()`或`update()`。 这两种方法的区别在于参数的数量和类型。
```java
```py
>>> A = {1}
>>> A
{1}
......@@ -106,7 +106,7 @@ TypeError: 'int' object is not iterable
有时您需要根据各种条件删除元素。 在这种情况下，您有一些方法在每种情况下的行为都会略有不同。
```java
```py
>>> A = {1, 2, 3, 4, 5, 6, 7, 8, 9, (3, 4)}
>>> A
{1, 2, 3, 4, 5, 6, 7, 8, 9, (3, 4)}
......@@ -151,7 +151,7 @@ KeyError: 'pop from an empty set'
我们来看一些示例。
```java
```py
>>> A = frozenset([1,2,3,4,5])
>>> B = {2,4,6,8,10}
>>> A | B
......
docs/169.md
浏览文件 @ cd3252f7
......@@ -10,7 +10,7 @@
将创建一个空的字典，其中包含大括号和右括号：
```java
```py
>>> d = {}
>>> type(d)
<class 'dict'>
......@@ -18,7 +18,7 @@
要拥有带有值的字典，我们必须在这些花括号之间添加键-值对。 键具有与`set`元素相同的限制：它们必须是可哈希的，因此不允许使用列表，字典，集合，而只能使用不可变的值，例如数字，字符串，布尔值，元组和`Frozensets`。
```java
```py
>>> d = {'name':'Gabor', 'age':31}
>>> d
{'name': 'Gabor', 'age': 31}
......@@ -26,7 +26,7 @@
自然，您可以像真正的字典一样使用字典变量。 例如，您可以创建英语-德语词典来“翻译”一些单词。
```java
```py
>>> en_de = {'eggs':'Eier', 'sausage':'Würstchen','bacon':'Schinken', 'spam':'Spam'}
>>> en_de
{'bacon': 'Schinken', 'sausage': 'Würstchen', 'eggs': 'Eier', 'spam': 'Spam'}
......@@ -44,7 +44,7 @@ KeyError: 'baked beans'
自然，可以通过使用`get`方法来避免`KeyError`，该方法接受可选的默认值。 如果未提供可选的默认值，则如果字典中不存在该键，则返回`None`：
```java
```py
>>> bb = en_de.get('baked beans')
>>> print(bb)
None
......@@ -52,7 +52,7 @@ None
如果您有两个列表，则可能需要将它们合并为对列表（最终是键值对）。 您可以使用 zip 功能执行此操作。 之后，您可以将此压缩列表转换为字典，其中每对的第一个元素将是键，而对的第二个元素将是值。
```java
```py
>>> food = ['eggs', 'sausage','bacon','spam']
>>> preferences = ['yes','no','yes','no']
>>> food_preferences = dict(zip(food, preferences))
......@@ -66,7 +66,7 @@ None
当然，您可以在字典中添加元素或从中删除元素。 方法与我们从列表中学到的方法完全相同，但让我们通过示例进行查看。
```java
```py
>>> d = {'eggs':2}
>>>
>>> d
......@@ -90,7 +90,7 @@ None
`popitem`函数从字典中删除一个元素，然后将已删除的（键，值）对作为元组返回。 在这里，您不知道返回哪个元素。 如果字典为空，则您将收到`KeyError`。
```java
```py
>>> food_preferences = {'bacon': 'yes', 'sausage': 'no', 'eggs': 'yes', 'spam': 'no'}
>>> del food_preferences['spam']
>>> food_preferences
......@@ -126,7 +126,7 @@ KeyError: 'popitem(): dictionary is empty'
有时，您只是想避免使用`get`函数，因为如果请求的键不在字典中，则不需要任何默认值。 在这种情况下，可以在带有字典键的语句中使用它们。
```java
```py
>>> d = {'eggs': 1, 'sausage': 2, 'bacon': 1}
>>> d
{'bacon': 1, 'sausage': 2, 'eggs': 1}
......@@ -146,7 +146,7 @@ False
在这种情况下，可以使用字典的键或值方法。 您可能会认为它们会给您带回字典中类似键或值的集合的对象。 让我们来看一个示例。
```java
```py
>>> d = {'first_name': 'Gabor', 'age':31, 'twitter':'@GHajba'}
>>> d
{'first_name': 'Gabor', 'age': 31, 'twitter': '@GHajba'}
......@@ -158,7 +158,7 @@ dict_values(['Gabor', 31, '@GHajba'])
这些类似集合的对象不可索引，但是您可以稍后在循环中使用它们。 当您想查看字典中是否有值时，`dict_values`对象很有用。
```java
```py
>>> d = {'first_name': 'Gabor', 'age':31, 'twitter':'@GHajba'}
>>> "Gabor" in d.values()
True
......@@ -168,7 +168,7 @@ False
自然地，您可以使用`list`函数并将这些类似于字典`set`的对象转换为`list`（或者使用`set`关键字来设置`set`或使用`tuple`函数，您可以创建一个包含所有项目的元组-希望您能理解其中的内容） 。
```java
```py
>>> list(d.keys())
['first_name', 'age', 'twitter']
>>> tuple(d.values())
......
docs/170.md
浏览文件 @ cd3252f7
# Python 3 条件语句
# Python 条件语句
> 原文： [https://javabeginnerstutorial.com/python-tutorial/python3-conditional-statements-2/](https://javabeginnerstutorial.com/python-tutorial/python3-conditional-statements-2/)
......@@ -14,7 +14,7 @@
让我们将以下代码保存到名为`fizzbuzz.py`的文件中：
```java
```py
n = int(input("Enter a number: "))
if n%15 == 0:
print("FizzBuzz")
......@@ -30,7 +30,7 @@ else:
如果我运行该应用，一些示例输出将如下所示：
```java
```py
MB:examples GHajba$ python3 fizzbuzz.py
Enter a number: 5
Buzz
......@@ -67,7 +67,7 @@ FizzBuzz
这意味着`if`块必须始终存在。 但是，此`if`块不必后面带有任何`elif`或`else`语句。 但是，如果没有`if`块，则不能单独拥有`elif`或`else`块。
```java
```py
if conditional_expression_1:
statement_block_1
elif conditional_expression_2:
......@@ -78,7 +78,7 @@ else:
而且，如果您有多个`if`语句，则将同时求值它们。 这意味着对于“FizzBu​​zz”示例，您不能使用简单的`if`块。 这是因为在这种情况下，每个`if`语句都会被求值，并且会导致您无法预期的结果。
```java
```py
n = int(input("Enter a number: "))
if n%15 == 0:
print("FizzBuzz")
......@@ -116,7 +116,7 @@ Fizz
但是，在这种情况下，隐式有时甚至更好。 这意味着您可以避免类似以下的构造：
```java
```py
if len(l) == 0:
# do something
......@@ -126,7 +126,7 @@ if a == 0 or a is None:
并用这些替换它们：
```java
```py
if not l:
# do something
......
docs/171.md
浏览文件 @ cd3252f7
......@@ -10,7 +10,7 @@ Python 有两种循环类型：`for`循环和`while`循环。
如果循环中没有终止条件，则可能会遇到无限循环或永无止境的循环，永不终止，您必须手动终止应用。 这些循环大多数是通过`while`构造实现的。 让我向您展示示例：
```java
```py
while True:
print('I love Python!')
......@@ -37,7 +37,7 @@ while i < 1:
此语句立即结束循环，因此不再执行任何语句-在`break`语句和循环的`else`部分之后不在循环体内，也未执行。
```java
```py
while / for some_condition:
execute_this
do_this
......@@ -55,7 +55,7 @@ else:
与`break`语句平行，您可以告诉循环再次从头继续执行。 这意味着`continue`语句后面的任何其他语句都不会执行，但是，循环将继续，直到循环头部的条件计算为`False`为止。 在这种情况下，循环的`else`块在循环结束时执行。
```java
```py
while / for some_condition:
execute_this
do_this
......@@ -73,7 +73,7 @@ else:
`for`循环旨在遍历集合或在有限的时间内执行循环主体。 循环的一般语法如下所示：
```java
```py
for variable in sequence:
statement_1
statement_2
......@@ -90,7 +90,7 @@ else:
让我们举一个真实的示例：
```java
```py
>>> for m in menu:
... print(m)
... else:
......@@ -113,7 +113,7 @@ What do you want?
如果提供了唯一停靠点，则范围功能会生成一个从数字 0 到停靠点数字（不包括停靠点数字）的范围，步长为 1。
```java
```py
>>> for i in range(10):
... print(i)
...
......@@ -135,7 +135,7 @@ What do you want?
如果起始编号大于或等于终止编号，则不执行循环。
```java
```py
>>> for i in range(15,20):
... print(i)
...
......@@ -151,7 +151,7 @@ What do you want?
该步骤定义了要忽略的元素数，或者即使起始编号大于终止编号也要跳过起始和终止之间的编号。 在这种情况下，您必须提供步骤 -1。
```java
```py
>>> for i in range(1,10,2):
... print(i)
...
......@@ -182,7 +182,7 @@ What do you want?
正如我之前告诉您的，如果您使用`break`，则整个循环将终止。 您还记得从本节开始的`for`循环示例吗？ 现在，我们向其添加一个条件，以便在我们迭代通过的元素为“垃圾邮件”时打破该条件：
```java
```py
>>> menu = ['eggs', 'sausage', 'bacon', 'spam']
>>> for m in menu:
... if m == 'spam':
......@@ -207,7 +207,7 @@ eggs
如果是`for`循环，`Continue`跳回到循环的开头，它跳到集合的下一个元素。 如果集合为空，则循环结束，然后执行`else`循环。 我们再来看两个示例：一个带有条件继续，另一个带有自己的继续。
```java
```py
>>> menu = ['eggs', 'sausage', 'bacon', 'spam']
>>> for m in menu:
... if m == 'spam':
......@@ -237,7 +237,7 @@ What do you want?
当然，将`for`循环与列表一起使用时，您会产生副作用。 这是因为您要遍历的集合不是一成不变的，因此您可以在循环期间更改其值，这可能导致意外行为。 让我们来看一个示例：
```java
```py
>>> l = ['eggs']
>>> for e in l:
... if e == 'eggs':
......@@ -260,7 +260,7 @@ m
为了避免这种情况，我们可以使用列表的副本在循环中进行迭代：
```java
```py
>>> l = ['eggs']
>>> for e in l[:]:
... if e == 'eggs':
......@@ -280,7 +280,7 @@ eggs
让我们看看`while`循环是如何建立的：
```java
```py
while condition_evaluates_to_True:
statement_1
statement_2
......@@ -295,7 +295,7 @@ else:
如您所见，该结构与`for`循环几乎相同，但是在这里，您需要一个布尔条件，即计算结果为`True`。 `else`块是相同的，并在循环正常终止时执行。 如果在循环主体中遇到中断，则不会执行`else`块。
```java
```py
>>> i = 0
>>> while i < 10:
... i += 1
......@@ -307,7 +307,7 @@ Finished loop, i has the value of 10
`while`循环的主要用法是在具有用户交互作用的游戏或应用中，例如，您需要获取特定类型的输入（例如数字）或要执行逻辑直到游戏结束。 让我们看一个简单的示例，在该示例中，我们要求用户输入数字。
```java
```py
while True:
try:
a = int(input('Enter a number: '))
......@@ -323,7 +323,7 @@ print("You entered: ", a)
如果您运行该应用，则可能会得到以下信息：
```java
```py
Enter a number: enter
This was not a number!
Enter a number: a
......@@ -338,7 +338,7 @@ You entered: 42
### while 循环中断和继续
```java
```py
>>> i = 0
>>> while i < 10:
... continue
......@@ -350,7 +350,7 @@ You entered: 42
这段代码不会停止，因为我永远不会递增，因此在继续调用表达式`i < 10`之后，它会被一次又一次地赋值为`False`，因此循环将无限执行。 如果启动了上面的示例，则可以通过按键盘上的`CTRL-C`来停止它。
```java
```py
>>> i = 0
>>> while i < 10:
... break
......
docs/172.md
浏览文件 @ cd3252f7
......@@ -25,13 +25,13 @@ def function_name(param_list)：
如您所知：函数必须在其主体中至少包含一个语句。 没有它，您会得到一个错误：
```java
```py
>>> def no_body_function():
...
File "<stdin>", line 2
```
```java
```py
^
IndentationError: expected an indented block
```
......@@ -40,14 +40,14 @@ def function_name(param_list)：
因此，我们编写一个简单的函数，它是交换计算器。 它获得两个参数：值和汇率，并返回更改后的值（值乘以汇率）。
```java
```py
def exchange(value, rate):
return value*rate
```
因此，每次定义函数时，请确保您具有缩进的主体。 如果您在 Python 的交互式解释器中遵循本文，则定义将如下所示：
```java
```py
>>> def exchange(value, rate):
...     return value*rate
...
......@@ -55,7 +55,7 @@ def exchange(value, rate):
正如我之前提到的，您也可以使用没有`return`语句的函数。 但是，大多数情况下，您不会使用这些函数，但是为了简洁起见，我们在这里也看一个示例：
```java
```py
>>> def no_return():
...     print("This function has no return statement")
...
......@@ -69,7 +69,7 @@ def exchange(value, rate):
现在，我们调用上一节中定义的两个函数。
```java
```py
>>> no_return()
This function has no return statement
>>> exchange(123, 1.12)
......@@ -84,7 +84,7 @@ def exchange(value, rate):
要查看函数的`return`语句，我们只需将函数调用包装到`print()`函数调用中即可。
```java
```py
>>> print(no_return())
This function has no return statement
None
......@@ -94,7 +94,7 @@ def exchange(value, rate):
在这里您可以看到，即使没有`return`语句的函数也返回`None`。 这意味着在这种情况下，您必须小心使用返回值，因为使用`None`时，仅在布尔表达式中使用它就几乎无能为力-当然要小心。
```java
```py
>>> result_value = no_return()
This function has no return statement
>>> result_value + 5
......@@ -103,7 +103,7 @@ def exchange(value, rate):
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
```
```java
```py
>>> if result_value == False:
...     print("Nothing useful...")
... else:
......@@ -116,7 +116,7 @@ def exchange(value, rate):
要修复示例的第二部分，我们可以像这样更改代码：
```java
```py
>>> if not result_value:
...     print("Nothing useful...")
... else:
......@@ -135,14 +135,14 @@ def exchange(value, rate):
以前面介绍的交换函数为例。 快速提醒一下，这里是定义：
```java
```py
def exchange(value, rate):
return value * rate
```
如果我们尝试仅使用 1 个参数（带有值）来调用此交换函数，则会从解释器中收到错误消息：
```java
```py
>>> exchange(42)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
......@@ -155,7 +155,7 @@ def exchange(value, rate):
要查看其工作原理，我还对代码进行了一些更改以显示当前汇率：
```java
```py
>>> def exchange(value, rate=1):
...     print('Current exchange rate is', rate)
...     return value * rate
......@@ -163,7 +163,7 @@ def exchange(value, rate):
现在`rate`参数是可选的，我们可以调用带有或不带有`rate`的函数：
```java
```py
>>> exchange(124,0.78)
Current exchange rate is 0.78
96.72
......@@ -177,7 +177,7 @@ def exchange(value, rate):
可选参数和必需参数的顺序很重要。 例如，如果我们更改顺序并将`rate = 1`作为`value`之前的第一个参数添加，我们将得到一个错误：
```java
```py
>>> def exchange(rate=1, value):
...     return value * rate
...
......@@ -193,7 +193,7 @@ def exchange(value, rate):
让我们再次看一下前面的示例：`rate`是函数的关键字参数。 由于`exchange`只有一个可选参数，因此您可以同时使用两种参数来调用它：
```java
```py
>>> exchange(42, 1.25)
52.5
>>> exchange(42, rate=1.25)
......@@ -206,7 +206,7 @@ def exchange(value, rate):
该示例将非常基础：我们定义一个函数，该函数采用四个参数`a`，`b`，`c`，`d`并执行以下计算：`a + b – c + d`。 要使其工作，它仅需要 2 个参数，两个是可选的。
```java
```py
>>> def sub_sum(a, b, c=0, d=0):
...   return a + b - c + d
...
......@@ -216,7 +216,7 @@ def exchange(value, rate):
现在，我们可以选择传递变量`c`和`d`的值。 如果我们已经知道为`c`提供值有两种选择。
```java
```py
>>> sub_sum(12,33,0,10)
55
>>> sub_sum(12,33,d=10)
......@@ -227,7 +227,7 @@ def exchange(value, rate):
进一步讲这个概念，我们可以用一种关键字语法调用函数，其方式是您在其他语言中无法想象的：您可以随意对值进行排序，直到为所有必需的参数提供它们的名称。
```java
```py
>>> sub_sum(b=12,a=33,d=10)
55
>>> sub_sum(d=10, 8, 11)
......@@ -243,7 +243,7 @@ def exchange(value, rate):
但是，当我们使用可变变量（例如列表）时，可能会出现问题：
```java
```py
>>> def append_if_short(s, lst=[]):
...     if len(s) < 4:
...         lst.append(s)
......@@ -253,7 +253,7 @@ def exchange(value, rate):
在上面的示例中，如果`s`的长度最大为 3，则将参数`s`附加到参数`lst`上。如果将两个参数都传递给函数，这似乎很好。 但是让我们有时调用此函数...
```java
```py
>>> append_if_short("one")
['one']
>>> append_if_short("two")
......@@ -272,7 +272,7 @@ def exchange(value, rate):
但是，这还不是全部。 我们会让事情变得更糟：
```java
```py
>>> def append_if_short(s, lst=[]):
...     if len(s) < 4:
...         lst.append(s)
......@@ -290,7 +290,7 @@ def exchange(value, rate):
要解决此问题，请更改函数定义：
```java
```py
>>> def append_if_short(s, lst=None):
...     if lst is None:
...         lst = []
......@@ -316,14 +316,14 @@ def exchange(value, rate):
因此，让我们使用此指南并将文档添加到我们的`append_if_short`函数中。
```java
```py
def append_if_short(s, lst=None):
""" Returns a list containing s if the length of s is smaller than 4.
```
`s`是任何字符串，`lst`是可选的列表类型参数。 如果未提供`lst`，则新的`l​​st`将分配一个新的空列表。 如果`len < 4`，则将`s`附加到`lst`并返回`lst`。
```java
```py
>>> append_if_short('one')
['one']
>>> append_if_short('two', ['one'])
......
docs/173.md
浏览文件 @ cd3252f7
......@@ -59,7 +59,7 @@
在 OOP 中，多态是为多个类型提供单个接口。 在 Python 中，这意味着您希望将超类作为参数（例如，执行`isinstance()`检查）并在对象上调用该超类的通用方法。 现在，通过多态，将在所使用的子类中执行该方法的实际实现。
```java
```py
>>> class Animal:
... def sound(self):
... raise NotImplementedError
......@@ -102,13 +102,13 @@ meow
一个简单的示例就是几何图形之外的东西。 在那里，您使用一个 2 元组（一对）来存储点。 点列表代表一个形状（多边形）。 因此，您首先要定义一个列表，其中包含一些表示点的对：
```java
```py
triangle = [(2,3), (5,7), (0,0)]
```
现在，如果您要计算该三角形的周长，可以编写一个如下所示的函数：
```java
```py
import math
def perimeter(points):
......
docs/174.md
浏览文件 @ cd3252f7
......@@ -16,7 +16,7 @@
类定义语法：
```java
```py
class ClassName:
<statement 1>
......@@ -36,7 +36,7 @@ class ClassName:
下面给出的是一个简单的 Python 类的示例：
```java
```py
class Student: //common base class for all students
stuCount=0
......@@ -64,7 +64,7 @@ print “Name : ” , self.name , “, Roll No : ” , self.rollno
对象是 Python 面向对象程序的基本构建块。
```java
```py
stu1 = Student(“Raj” , 34) // first object of student class
stu2 = Student(“Reema” , 12) //second object of student class
......@@ -74,7 +74,7 @@ stu2 = Student(“Reema” , 12) //second object of student class
属性是对象的特征。 `__init__()`方法用于初始化对象的属性。 要访问对象的属性，我们对对象使用点运算符。 喜欢
```java
```py
stu1.displayStudent( )
stu2.displayStudent( )
......@@ -84,7 +84,7 @@ print “The number of students are: %d ” % Student.stuCount
因此，完整的程序是：
```java
```py
class Student: //common base class for all students
stuCount=0
......@@ -122,7 +122,7 @@ print “The number of students are: %d ” % Student.stuCount
**示例：**
```java
```py
class Vehicle: // base class
def _init_( self ):
......@@ -152,7 +152,7 @@ c.vehicle1( ) //calling base class method
**输出**：
```java
```py
Calling car class
Mercedes,BMW
......@@ -168,7 +168,7 @@ Calling vehicle1 method
**示例：**
```java
```py
class Books:
def _init_(self, name=‘ ’):
......@@ -206,7 +206,7 @@ j.programming( )
**输出：**
```java
```py
Programming books:
In python world
......@@ -220,7 +220,7 @@ In java world
**示例：**
```java
```py
class Addition:
def _init_(self,a,b):
......
docs/175.md
浏览文件 @ cd3252f7
# Python 3.5 中的异常处理
# Python 3 中的异常处理
> 原文： [https://javabeginnerstutorial.com/python-tutorial/exception-handling-python-3-5/](https://javabeginnerstutorial.com/python-tutorial/exception-handling-python-3-5/)
......@@ -18,7 +18,7 @@
您可能还记得，在*猜数字*游戏中，我们已经使用了异常处理。 处理异常的一般规则是您需要一个`try-except`块：
```java
```py
try:
block of code which might raise an error
except:
......@@ -31,14 +31,14 @@ except:
让我们创建一个简单的示例，在该示例中，我们调用一个总是引发异常的函数：
```java
```py
def error_function():
return int('nine')
```
如果我们在交互式解释器中定义此函数并调用它，则会出现异常：
```java
```py
>>> error_function()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
......@@ -48,7 +48,7 @@ ValueError: invalid literal for int() with base 10: 'nine'
现在，我们将此函数调用包装到`try-except`块中：
```java
```py
>>> try:
... error_function()
... except:
......@@ -60,7 +60,7 @@ ValueError: invalid literal for int() with base 10: 'nine'
在上面的示例中，我们捕获了`try`块中可能引发的所有异常。 但是，正如我提到的那样，这是一个不好的做法。 最好捕获那些我们知道它们可能会来的异常，并让真正意外的异常上升，直到它们被处理为止。 为此，我们一开始只会捕获语法错误：
```java
```py
>>> try:
... error_function()
... except SyntaxError:
......@@ -74,7 +74,7 @@ ValueError: invalid literal for int() with base 10: 'nine'
如您所见，在这种情况下，异常由解释器处理。 因此，更改异常处理以处理`ValueErrors`：
```java
```py
>>> try:
... error_function()
... except ValueError:
......@@ -90,7 +90,7 @@ an exception occurred
为此，您可以按如下所示编写先前的异常处理块：
```java
```py
>>> try:
... error_function()
... except ValueError as e:
......@@ -110,7 +110,7 @@ an exception occurred
这就引发了一个普遍的异常，对此没有太多了解。 您可以在交互式解释器中尝试一下：
```java
```py
>>> raise Exception
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
......
docs/176.md
浏览文件 @ cd3252f7
......@@ -17,7 +17,7 @@
好吧，这并不像听起来那样困难。 让我们看一下我的解决方案的一些示例输出：
```java
```py
Should the secret number between 1 and 100 or 1 and 1000? 100
You have chosen 100, you will have 7 guesses to find the secret number.
I have chosen the secret number...
......@@ -61,7 +61,7 @@ Do you want to play another round? (yes / no) no
让我们看一下代码。
```java
```py
__author__ = 'GHajba'
import random
......@@ -120,7 +120,7 @@ while True:
但是，此脚本也有一些替代解决方案。 例如，您可以将中间的`while`循环更改为`for`循环：
```java
```py
for guesses in range(guess_count):
```
......
docs/177.md
浏览文件 @ cd3252f7
......@@ -8,7 +8,7 @@
因此，让我们将其提取为一个函数。 唯一的区别是我们打印出的询问用户输入数字的消息。 可以将其作为函数的参数来处理，因为这是唯一的可变部分。 因此，让我们看一下函数的定义：
```java
```py
def ask_user_for_number(message_text):
while True:
try:
......@@ -24,7 +24,7 @@ def ask_user_for_number(message_text):
在此简单修改的​​最后，我们为应用提供了以下代码（并且具有相同的功能）：
```java
```py
__author__ = 'GHajba'
import random
......@@ -84,7 +84,7 @@ while True:
例如，求值用户是赢还是输。 为此，我们可以编写一个函数，该函数将秘密数字，猜测，猜测计数和猜测数字作为输入，并对消息进行求值以告知用户。 但是一个函数的四个参数很多，因此现在让我们对其进行划分。 基于这些输入，我将创建一个函数来告诉用户秘密数字是猜中的数字是更高还是更低。
```java
```py
def user_won(guessed, secret):
if guessed == secret_number:
print('Congrats, you have Won!')
......@@ -99,7 +99,7 @@ def user_won(guessed, secret):
我们可以测试的另一件事是询问用户是否要再玩一轮。
```java
```py
def want_continue():
answer = ''
while answer.lower() not in ['yes', 'no', 'y', 'n']:
......@@ -110,7 +110,7 @@ def want_continue():
完成所有这些更改后，让我再次向您显示完整代码：
```java
```py
__author__ = 'GHajba'
import random
......
docs/178.md
浏览文件 @ cd3252f7
......@@ -25,7 +25,7 @@
可迭代的对象通常是序列类型，例如列表，范围，元组或集合，在 Python 中，可迭代的对象意味着可以用`for`之类的东西来迭代对象。
```java
```py
# These are all iterable objects that 'for' is operating on
my_list = [1,2,3,"Python",4]
......@@ -61,7 +61,7 @@ for x in range(5):
实际上，这意味着“`for`”可以循环可提供迭代器的任何对象，但不能在其他任何事情上循环。像`int`或`float`之类的对象不能与其一起使用，因为它们没有实现正确的方法。
```java
```py
# Example: for statement works over a list, but not over a float
my_list = [3,5,7,9]
......@@ -79,7 +79,7 @@ for item in my_float:
### 输出
```java
```py
3
5
......@@ -148,7 +148,7 @@ TypeError: 'float' object is not iterable
以下是一些通常用于创建生成器函数的语法示例：
```java
```py
# Form 1 - Loop through a collection (an iterable) and apply some processing to each item
def generator_function(collection):
......@@ -220,7 +220,7 @@ def generator_function(collection):
这是调用生成器函数的一些示例语法：
```java
```py
#Form 1 - more readable
my_generator = generator_function(arguments)
......@@ -244,7 +244,7 @@ for result in generator_function(arguments):
这是说明创建和使用简单生成器函数的示例。 它将文本文件过滤为仅包含特定字符串的行。 它还显示了三种稍微不同的调用生成器的方式，有关详细信息，请参见注释：
```java
```py
#Example: Generator Functions
def filtered_text(text_lines,wanted_text):
......@@ -314,7 +314,7 @@ with open("Programming_Books_List.txt",'r') as file_obj:
一些示例语法可能会有所帮助：
```java
```py
#Form 1: basic form - iterate over all items, run some processing on each
new_generator = (apply_processing to(item) for item in iterable)
......@@ -332,7 +332,7 @@ new_generator = (apply_processing to(item) for item in iterable if condition)
创建生成器后，即可使用与使用生成器功能几乎相同的方式来使用（或使用）生成器。 这里有一些示例：
```java
```py
#Form 1 - more readable
my_generator = (apply_processing to(item) for item in iterable)
......@@ -352,7 +352,7 @@ for result in (apply_processing to(item) for item in iterable):
这是上一本书的清单示例，使用表格 2 进行了覆盖：
```java
```py
#Example: Generator Expressions
with open("Programming_Books_List.txt",'r') as file_obj:
......@@ -399,7 +399,7 @@ with open("Programming_Books_List.txt",'r') as file_obj:
这是代码：
```java
```py
#Example: Fibonacci sequence using generators
def fibonacci(limit):
......@@ -439,7 +439,7 @@ for term in fibonacci(144):
其输出如下：
```java
```py
0
1
......@@ -485,7 +485,7 @@ for term in fibonacci(144):
这个示例有点费解，可以通过使用正则表达式（很有可能还有其他库或 OS 函数）进行改进，但是作为一个纯 Python 演示，它应该说明使用生成器可以实现的一些功能：
```java
```py
# pipeline_demo.py
#Example: Search for "# TODO:" at start of lines in Python
......@@ -567,7 +567,7 @@ for item in filtered:
输出：
```java
```py
test-TODOs.py
# TODO: Test finding a TODO in another file
......
docs/18.md 已删除 100644 → 0
浏览文件 @ 8528d91a
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-equals-method-vs-operator/](https://javabeginnerstutorial.com/core-java-tutorial/java-equals-method-vs-operator/)
\ No newline at end of file
docs/181.md
浏览文件 @ cd3252f7
# Hibernate 4.3 入门教程
# Hibernate 4 入门教程
> 原文： [https://javabeginnerstutorial.com/hibernate/hibernate-4-introduction/](https://javabeginnerstutorial.com/hibernate/hibernate-4-introduction/)
......
docs/71.md
浏览文件 @ cd3252f7
# Java 10 独特功能
# Java 10 独特功能
> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-10-features/](https://javabeginnerstutorial.com/core-java-tutorial/java-10-features/)
......
docs/77.md
浏览文件 @ cd3252f7
# 1.什么是 Selenium？
# 1 什么是 Selenium？
> 原文： [https://javabeginnerstutorial.com/selenium/1-what-selenium/](https://javabeginnerstutorial.com/selenium/1-what-selenium/)
......
docs/78.md
浏览文件 @ cd3252f7
# 2.为什么要进行自动化测试？
# 2 为什么要进行自动化测试？
> 原文： [https://javabeginnerstutorial.com/selenium/2-automated-testing/](https://javabeginnerstutorial.com/selenium/2-automated-testing/)
......
docs/79.md
浏览文件 @ cd3252f7
# 3.Selenium 的历史
# 3 Selenium 的历史
> 原文： [https://javabeginnerstutorial.com/selenium/3-history-selenium/](https://javabeginnerstutorial.com/selenium/3-history-selenium/)
......
docs/80.md
浏览文件 @ cd3252f7
# 4.Selenium 工具套件
# 4 Selenium 工具套件
> 原文： [https://javabeginnerstutorial.com/selenium/4-selenium-tool-suite/](https://javabeginnerstutorial.com/selenium/4-selenium-tool-suite/)
......
docs/81.md
浏览文件 @ cd3252f7
# 5\. Selenium 工具支持的浏览器和平台
# 5 Selenium 工具支持的浏览器和平台
> 原文： [https://javabeginnerstutorial.com/selenium/5-browsers-platforms-support/](https://javabeginnerstutorial.com/selenium/5-browsers-platforms-support/)
......
docs/82.md
浏览文件 @ cd3252f7
# 6.Selenium 工具：争霸
# 6 Selenium 工具：争霸
> 原文： [https://javabeginnerstutorial.com/selenium/6-selenium-tools-fight-supremacy/](https://javabeginnerstutorial.com/selenium/6-selenium-tools-fight-supremacy/)
......
docs/84.md
浏览文件 @ cd3252f7
......@@ -81,7 +81,7 @@ Firefox 重新启动后，我们可以通过以下其中一种方式启动 **Sel
关于 **Firebug** 的几句话：它是 Mozilla Firefox 的免费开放源代码 Web 浏览器扩展。 我们将利用其优势，在使用 Selenium 进行自动化的情况下，识别和检查应用的 Web 元素。 如果您不了解我在说什么，那完全没问题。 只需立即安装 Firebug。 随着我们更深入地探索，一切都会落在原地。
*该采取行动了*：启动 Firefox 并导航至 [https://getfirebug.com/downloads/](https://getfirebug.com/downloads/) 用于下载Firebug。
*该采取行动了*：启动 Firefox 并导航至 [https://getfirebug.com/downloads/](https://getfirebug.com/downloads/) 用于下载 Firebug。
根据与当前 Firefox 版本的兼容性，单击“**下载**”链接。
......
docs/90.md
浏览文件 @ cd3252f7
# 7 小时 Selenium IDE – Selenium 命令一览
# 7H Selenium IDE – Selenium 命令一览
> 原文： [https://javabeginnerstutorial.com/selenium/7h-ide-selenium-commands/](https://javabeginnerstutorial.com/selenium/7h-ide-selenium-commands/)
......
docs/SUMMARY.md 0 → 100644
浏览文件 @ cd3252f7
+ [Java 教程](2.md)
+ [Java 教程 – 入门](3.md)
+ [Java 的历史](4.md)
+ [Java 基础知识：Java 入门](5.md)
+ [jdk vs jre vs jvm](6.md)
+ [`public static void main(string args[])`说明](7.md)
+ [面向初学者的 Java 类和对象教程](8.md)
+ [Java 构造器](9.md)
+ [使用 Eclipse 编写 Hello World 程序](10.md)
+ [执行顺序](11.md)
+ [Java 中的访问修饰符](12.md)
+ [Java 中的非访问修饰符](13.md)
+ [Java 中的数据类型](14.md)
+ [Java 中的算术运算符](15.md)
+ [Java 语句初学者教程](16.md)
+ [用 Java 创建对象的不同方法](17.md)
+ [内部类](19.md)
+ [字符串构建器](20.md)
+ [Java 字符串教程](21.md)
+ [Java 教程 – 变量](22.md)
+ [Java 中的变量](23.md)
+ [Java 中的局部变量](24.md)
+ [Java 中的实例变量](25.md)
+ [Java 引用变量](26.md)
+ [变量遮盖](27.md)
+ [Java 教程 – 循环](28.md)
+ [Java `for`循环](29.md)
+ [Java 教程 – 异常](30.md)
+ [Java 异常教程](31.md)
+ [异常处理 – `try-with-resources`语句](32.md)
+ [Java 异常处理 – `try catch`块](33.md)
+ [Java 教程 – OOPS 概念](34.md)
+ [Java 重载](35.md)
+ [Java 方法覆盖](36.md)
+ [Java 接口](37.md)
+ [继承](38.md)
+ [Java 教程 – 关键字](39.md)
+ [Java 中的`this`关键字](40.md)
+ [Java `static`关键字](41.md)
+ [Java 教程 – 集合](42.md)
+ [Java 数组教程](43.md)
+ [Java 集合](44.md)
+ [Java 集合迭代器](45.md)
+ [Java `Hashmap`教程](46.md)
+ [链表](47.md)
+ [Java 初学者`List`集合教程](48.md)
+ [Java 初学者的`Map`集合教程](49.md)
+ [Java 初学者的`Set`教程](50.md)
+ [Java 初学者的`SortedSet`集合教程](51.md)
+ [Java 初学者`SortedMap`集合教程](52.md)
+ [Java 教程 – 序列化](53.md)
+ [Java 序列化概念和示例](54.md)
+ [Java 序列化概念和示例第二部分](55.md)
+ [Java 瞬态与静态变量](56.md)
+ [`serialVersionUID`的用途是什么](57.md)
+ [Java 教程 – 枚举](58.md)
+ [Java 枚举（`enum`）](59.md)
+ [Java 枚举示例](60.md)
+ [核心 Java 教程 – 线程](61.md)
+ [Java 线程教程](62.md)
+ [Java 8 功能](63.md)
+ [Java Lambda：初学者指南](64.md)
+ [Lambda 表达式简介](65.md)
+ [Java 8 Lambda 列表`foreach`](66.md)
+ [Java 8 Lambda 映射`foreach`](67.md)
+ [Java 9](68.md)
+ [Java 9 功能](69.md)
+ [Java 10](70.md)
+ [Java 10 独特功能](71.md)
+ [核心 Java 教程 – 高级主题](72.md)
+ [Java 虚拟机基础](73.md)
+ [Java 类加载器](74.md)
+ [Java 开发人员必须知道..](75.md)
+ [Selenium 教程](76.md)
+ [1 什么是 Selenium？](77.md)
+ [2 为什么要进行自动化测试？](78.md)
+ [3 Selenium 的历史](79.md)
+ [4 Selenium 工具套件](80.md)
+ [5 Selenium 工具支持的浏览器和平台](81.md)
+ [6 Selenium 工具：争霸](82.md)
+ [7A Selenium IDE – 简介，优点和局限性](83.md)
+ [7B Selenium IDE – Selenium IDE 和 Firebug 安装](84.md)
+ [7C Selenium IDE – 突破表面：初探](85.md)
+ [7D Selenium IDE – 了解您的 IDE 功能](86.md)
+ [7E Selenium IDE – 了解您的 IDE 功能（续）。](87.md)
+ [7F Selenium IDE – 命令，目标和值](88.md)
+ [7G Selenium IDE – 记录和运行测试用例](89.md)
+ [7H Selenium IDE – Selenium 命令一览](90.md)
+ [7I Selenium IDE – 设置超时，断点，起点](91.md)
+ [7J Selenium IDE – 调试](92.md)
+ [7K Selenium IDE – 定位元素（按 ID，名称，链接文本）](93.md)
+ [7L Selenium IDE – 定位元素（续）](94.md)
+ [7M Selenium IDE – 断言和验证](95.md)
+ [7N Selenium IDE – 利用 Firebug 的优势](96.md)
+ [7O Selenium IDE – 以所需的语言导出测试用例](97.md)
+ [7P Selenium IDE – 其他功能](98.md)
+ [7Q Selenium IDE – 快速浏览插件](99.md)
+ [7Q Selenium IDE – 暂停和反射](100.md)
+ [8 给新手的惊喜](101.md)
+ [9A WebDriver – 架构及其工作方式](102.md)
+ [9B WebDriver – 在 Eclipse 中设置](103.md)
+ [9C WebDriver – 启动 Firefox 的第一个测试脚本](104.md)
+ [9D WebDriver – 执行测试](105.md)
+ [9E WebDriver – 用于启动其他浏览器的代码示例](106.md)
+ [9F WebDriver – JUnit 环境设置](107.md)
+ [9G WebDriver – 在 JUnit4 中运行 WebDriver 测试](108.md)
+ [9H WebDriver – 隐式等待](109.md)
+ [9I WebDriver – 显式等待](110.md)
+ [9J WebDriver – 定位元素：第 1 部分（按 ID，名称，标签名称）](111.md)
+ [9K WebDriver – 定位元素：第 2 部分（按`className`，`linkText`，`partialLinkText`）](112.md)
+ [9L WebDriver – 定位元素：第 3a 部分（按`cssSelector`定位）](113.md)
+ [9M WebDriver – 定位元素：第 3b 部分（`cssSelector`续）](114.md)
+ [9N WebDriver – 定位元素：第 4a 部分（通过 xpath）](115.md)
+ [9O WebDriver – 定位元素：第 4b 部分（XPath 续）](116.md)
+ [9P WebDriver – 节省时间的捷径：定位器验证](117.md)
+ [9Q WebDriver – 处理验证码](118.md)
+ [9R WebDriver – 断言和验证](119.md)
+ [9S WebDriver – 处理文本框和图像](120.md)
+ [9T WebDriver – 处理单选按钮和复选框](121.md)
+ [9U WebDriver – 通过两种方式选择项目（下拉菜单和多项选择）](122.md)
+ [9V WebDriver – 以两种方式处理表](123.md)
+ [9W WebDriver – 遍历表元素](124.md)
+ [9X WebDriver – 处理警报/弹出框](125.md)
+ [9Y WebDriver – 处理多个窗口](126.md)
+ [9Z WebDriver – 最大化窗口](127.md)
+ [9AA WebDriver – 执行 JavaScript 代码](128.md)
+ [9AB WebDriver – 使用动作类](129.md)
+ [9AC WebDriver – 无法轻松定位元素？ 继续阅读...](130.md)
+ [10A 高级 WebDriver – 使用 Apache ANT](131.md)
+ [10B 高级 WebDriver – 生成 JUnit 报告](132.md)
+ [10C 高级 WebDriver – JUnit 报表自定义](133.md)
+ [10D 高级 WebDriver – JUnit 报告自定义续](134.md)
+ [10E 高级 WebDriver – 生成 PDF 报告](135.md)
+ [10F 高级 WebDriver – 截屏](136.md)
+ [10G 高级 WebDriver – 将屏幕截图保存到 Word 文档](137.md)
+ [10H 高级 WebDriver – 发送带有附件的电子邮件](138.md)
+ [10I 高级 WebDriver – 使用属性文件](139.md)
+ [10J 高级 WebDriver – 使用 POI 从 excel 读取数据](140.md)
+ [10K 高级 WebDriver – 使用 Log4j 第 1 部分](141.md)
+ [10L 高级 WebDriver – 使用 Log4j 第 2 部分](142.md)
+ [10M Advanced WebDriver – 以无头模式运行测试](143.md)
+ [Vue 教程](144.md)
+ [1 使用 Vue.js 的 Hello World](145.md)
+ [2 模板语法和反应式的初探](146.md)
+ [3 Vue 指令简介](147.md)
+ [4 Vue Devtools 设置](148.md)
+ [5 数据绑定第 1 部分（文本，原始 HTML，JavaScript 表达式）](149.md)
+ [6 数据绑定第 2 部分（属性）](150.md)
+ [7 条件渲染第 1 部分（`v-if`，`v-else`，`v-else-if`）](151.md)
+ [8 条件渲染第 2 部分（`v-if`和`v-show`）](152.md)
+ [9 渲染列表第 1 部分（遍历数组）](153.md)
+ [10 渲染列表第 2 部分（遍历对象）](154.md)
+ [11 监听 DOM 事件和事件修饰符](155.md)
+ [12 监听键盘和鼠标事件](156.md)
+ [13 让我们使用简写](157.md)
+ [14 使用`v-model`进行双向数据绑定](158.md)
+ [15 表单输入绑定](159.md)
+ [18 类绑定](160.md)
+ [Python 教程](161.md)
+ [Python 3 简介](162.md)
+ [Python 基础知识 - 又称 Hello World 以及如何实现](163.md)
+ [如何在 Windows 中安装 python](164.md)
+ [适用于 Windows，Mac，Linux 的 Python 设置](165.md)
+ [Python 数字和字符串](166.md)
+ [Python 列表](167.md)
+ [Python 集](168.md)
+ [Python 字典](169.md)
+ [Python 条件语句](170.md)
+ [Python 循环](171.md)
+ [Python 函数](172.md)
+ [面向对象编程（OOP）](173.md)
+ [Python 中的面向对象编程](174.md)
+ [Python 3 中的异常处理](175.md)
+ [Python 3：猜数字](176.md)
+ [Python 3：猜数字 – 回顾](177.md)
+ [Python 生成器](178.md)
+ [Hibernate 教程](179.md)
+ [Hibernate 框架基础](180.md)
+ [Hibernate 4 入门教程](181.md)
+ [Hibernate 4 注解配置](182.md)
+ [Hibernate 4 的实体关系](183.md)
+ [Hibernate 4 中的实体继承模型](184.md)
+ [Hibernate 4 查询语言](185.md)
+ [Hibernate 4 数据库配置](186.md)
+ [Hibernate 4 批处理](187.md)
+ [Hibernate 4 缓存](188.md)
+ [Hibernate 4 审计](189.md)
+ [Hibernate 4 的并发控制](190.md)
+ [Hibernate 4 的多租户](191.md)
+ [Hibernate 4 连接池](192.md)
+ [Hibernate 自举](193.md)
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或