Txidol 's Blog

重构摘要4_构筑测试体系

确保所有测试都完全自动化，让它们检查自己的测试结果。
通常使用Junit测试框架
准备好测试夹具，setUp() 创建 tearDown() 删除
Tip 现在使用注解@Before @After @BeforeClass @AfterClass
频繁地运行测试。每次编译请把测试也考虑进去--每天至少执行每个测试一次。
编写测试代码时，往往一开始让它们失败，为了确保测试机制的确可行。
每当你收到bug报告，请先写一个单元测试来暴露bug.
测试你担心出错的部分。
考虑可能出错的边界条件，把测试火力集中在那儿。
当事情被认为应该会出错时，别忘了检查是否抛出了预期的异常。
不要因为测试无法捕捉所有BUG就不写测试，因为测试的确可以捕捉绝大多数BUG。
构建良好的BUG检测器并经常运行它，这对任何开发工作都将大有裨益，并且是重构的前提。

说明

《重构-改善既有代码的设计》Martin Fowler 摘要：第四章构筑测试体系
欢迎修改，地址：https://github.com/txidol/txidol.github.io
你也可以访问：http://txidol.github.io 获取更多的信息

创建于：2014-04-17 | 分类： java重构 | 标签：重构

Java.lang.string

字符串广泛应用在Java编程中，在Java中字符串属于对象，Java提供了String类来创建和操作字符串。

创建字符串

创建字符串最简单的方式如下:

String greeting = "Hello world!";

在代码中遇到字符串常量时，这里的值是"Hello world!"，编译器会使用该值创建一个String对象。

和其它对象一样，可以使用关键字和构造方法来创建String对象。

String类有11种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:

public class StringDemo{

    public static void main(String args[]){
        char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.'};
        String helloString = new String(helloArray);  
        System.out.println( helloString );
    }
}

以上实例编译运行结果如下：

hello.

注意:String类是不可改变的final类，所以你一旦创建了String对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用StringBuffer & StringBuilder 类。

常用方法

char charAt(int index) 返回指定索引处的 char 值。
static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
boolean equals(Object anObject) 将此字符串与指定的对象比较。
boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
int length() 返回此字符串的长度。
boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replaceAll(String regex, String replacement使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String trim() 返回字符串的副本，忽略前导空白和尾部空白。
static String format(String format,Object... args) 使用指定的格式字符串和参数返回一个格式化字符串。

常见题目（使用JUnit演示）

@Test
public void testEquels(){
    String test = "12345";
    String test1 = "12345";
    String test2 = new String("12345");
    String test3 = new String("12345");

    String t1 = test;
    String t2 = "12"+"345";

    assertTrue(test==test1);
    assertTrue(test==t1);
    assertTrue(test==t2);

    assertTrue(test!=test2);
    assertTrue(test2!=test3);       
}

@Test
public void testNotChange(){
    String inString = "123";        
    String outString =  stubChangeString(inString);

    assertEquals("123", inString);
    assertEquals("123test", outString);
}

private String stubChangeString(String inString){
    inString += "test";
    return inString;
}

@Test
public void testSubString() {
    String test = "12345";
    assertEquals("2345", test.substring(1));
}

@Test
public void testToArrays() {
    List<String> ids = new ArrayList<>();
    ids.add("1");
    ids.add("2");
    ids.add("3");
    String[] id = ids.toArray(new String[0]);
    assertEquals(3, id.length);
    assertEquals("1", id[0]);
}

创建于：2014-04-17 | 分类： java初级码农 | 标签： Java 基础

LEFT JOIN 操作符

LEFT JOIN 关键字从左表（table1）返回所有的行，即使右表（table2）中没有匹配。如果右表中没有匹配，则结果为 NULL。

SQL LEFT JOIN 语法

SELECT column_name(s)
FROM table1
LEFT JOIN table2
ON table1.column_name=table2.column_name;

或：

SELECT column_name(s)
FROM table1
LEFT OUTER JOIN table2
ON table1.column_name=table2.column_name;

注释：在某些数据库中，LEFT JOIN 称为 LEFT OUTER JOIN。

Demo

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
LEFT JOIN Orders
ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName;

注释：LEFT JOIN 关键字从左表（Customers）返回所有的行，即使右表（Orders）中没有匹配。

RIGHT JOIN 操作符

RIGHT JOIN 关键字从右表（table2）返回所有的行，即使左表（table1）中没有匹配。如果左表中没有匹配，则结果为 NULL。

SQL RIGHT JOIN 语法

SELECT column_name(s)
FROM table1
RIGHT JOIN table2
ON table1.column_name=table2.column_name;

或：

SELECT column_name(s)
FROM table1
RIGHT OUTER JOIN table2
ON table1.column_name=table2.column_name;

注释：在某些数据库中，RIGHT JOIN 称为 RIGHT OUTER JOIN。

Demo

SELECT Orders.OrderID, Employees.FirstName
FROM Orders
RIGHT JOIN Employees
ON Orders.EmployeeID=Employees.EmployeeID
ORDER BY Orders.OrderID;

注释：RIGHT JOIN 关键字从右表（Employees）返回所有的行，即使左表（Orders）中没有匹配。

FULL OUTER JOIN 操作符

FULL OUTER JOIN 关键字只要左表（table1）和右表（table2）其中一个表中存在匹配，则返回行.

FULL OUTER JOIN 关键字结合了 LEFT JOIN 和 RIGHT JOIN 的结果。

SQL FULL OUTER JOIN 语法

SELECT column_name(s)
FROM table1
FULL OUTER JOIN table2
ON table1.column_name=table2.column_name;

创建于：2014-04-17 | 分类：数据库小虫 | 标签：数据库 SQL

1.Duplicated Code 重复代码

Extract Method
Pull Up Method
Form Template Method --》 Template Method 模式
Substitute Algorithm --》函数算法替代

2.Long Method 过长的函数

“间接层”所带来的全部利益--解释能力、共享能力、选择能力--都是有小函数支持的。

真正关键在于一个好名字。

每当感觉需要以注释来说明点什么的时候，我们就把需要说明的东西写进一个独立函数中，并以其用途（而非实现手法）命名。

对于参数、临时变量

Replace Temp with Query
Introduce Parameter Object
Preserver Whole Object
Replace Method with Method Object

如何确定该提炼哪段代码：寻找注释

条件表达式和循环常常也是提炼的信号

3.Large Class 过大的类

根据客户端的使用，先提炼一个接口

4.Long Parameter List 过长的参数列

函数需要的东西多半可以在函数的宿主类中找到

5.Divergent Change 发散式变化

一个类受多种变化的影响

6.Shotgun Surgery 散弹式变化

一种变化引发多个类相应修改

7.Feature Envy 依恋情结

函数对某个类的兴趣高过对自己所处类的兴趣 --焦点数据

8.Data Clumps 数据泥团

两个类中相同的字段、许多函数签名中相同的参数

9.Primitive Obsession 基本类型偏执

如果有一组总是被放在一起的字段，可以抽到一个类中。

如果在参数列表中看到基本类型数据，试试Introduce Parameter Object

如果自己正从数组中挑选数据可以运行 Replace Array with Object

10.Switch Statements switch语句

11.Parallel Inheritance Hierarchies 平行继承体系

引用另一个类

12.Lazy Class 冗赘类

13.Speculation Generality 夸夸其谈未来性

14.Temporary Field 令人迷惑的暂时字段

Null对象

15.Message Chains 过度耦合的消息链

Hide Delegate 可以在消息链的不同位置进行这种重构手法

16.Middle Man 中间人

过度运用委托，那么干脆把委托干掉

17.Inappropriate Intimate 狎昵关系

继承有时造成过度亲密，可以独立子类

18.Alternative Classes with Different Interface 异曲同工的类

函数做同一件事，却有不同的签名

19.Incomplete Library Class 不完美的类库

Introduce Foreign Method
Introduce Local Extension

20.Data Class 纯稚的数据类

调用行为搬移到Data Class类，必须承担一定责任

21.Refuse Bequest 被拒绝的馈赠

子类不想继承超类的函数和数据

22.Comments 过多的注释

注释之所以存在是因为代码很糟糕，试着重构，让注释变得多余

注释记录将来的打算，没把握的区域，为什么做某某事

说明

《重构-改善既有代码的设计》Martin Fowler 摘要：第三章代码的坏味道
欢迎修改，地址：https://github.com/txidol/txidol.github.io
你也可以访问：http://txidol.github.io 获取更多的信息

创建于：2014-04-03 | 分类： java重构 | 标签：重构

INNER JOIN 操作符

INNER JOIN 关键字在表中存在至少一个匹配时返回行。

SQL INNER JOIN 语法

SELECT column_name(s)
FROM table1
INNER JOIN table2
ON table1.column_name=table2.column_name;

或：

SELECT column_name(s)
FROM table1
JOIN table2
ON table1.column_name=table2.column_name;

注释：INNER JOIN 与 JOIN 是相同的 (交集)。

Demo

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
INNER JOIN Orders
ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName;

Mysql

也可以用上面的写法，等同下面

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers , Orders
WHERE  Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName;

创建于：2014-04-03 | 分类：数据库小虫 | 标签：数据库 SQL

3 Python简介

在下面的例子中，输入和输出是通过提示(的存在或不存在区别>>>和...)：重复的例子中，您必须在提示符后输入所有的一切，出现提示时; 没有以提示符开始的行，是解释器输出。请注意，在上一个例子的线本身的从属提示符意味着你必须输入一个空行; 这是用来结束一个多行命令。

许多本手册中的例子，甚至有一些在交互提示符中，包括注释。Python中的注释以井字符，＃，并延伸到物理行的结尾。注释可能出现在一行或下面的空格或程序代码的开始，而不是一个字符串中。在一个字符串哈希字符只是一个哈希字符。由于评论是澄清代码并没有被Python解释，他们可能会在实例打字时可以省略。

一些例子：

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1。使用Python作为一个计算器

让我们尝试一些简单的Python命令。启动解释器然后等(它不应该需要很长时间)待主提示符>>>ssss

3.1.1。数字

解释器的行为就像是一个计算器：你可以向它输入一个表达式，它会返回结果。表达式的语法很简单：运营商+，- ，*和/就像在大多数其他语言的工作(例如，C或Pascal); 括号(()) 可用于分组。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating point number
1.6

的整数(如2，4，20)具有类型整型，那些带有小数部分(例如5.0，1.6)的类型为浮动。我们将看到更多关于数字类型后面的教程。

司(/)总是返回一个浮点数。做地板事业部，并得到一个整数的结果(不考虑任何小数结果)，你可以使用/ / 操作符; 计算剩余可使用％：

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # result * divisor + remainder
17

与Python，可以使用**运算符来计算权[1] ：

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128
>>> 5 * 3 + 2  # result * divisor + remainder
17

等号(=)，用于分配一个值给一个变量。事后，没有结果的下一个交互式的提示之前显示：

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

如果一个变量没有被"定义"(赋值)，试图用它会给你一个错误：

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

NameError: name 'n' is not defined

有浮点全力支持; 混合型的操作数运算符将整数操作数为浮点数：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.55

在交互模式下，最近一次表达式赋值给变量 _。这意味着，当你在使用Python当做桌面计算器，它是比较容易的进行连续计算，例如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)    
113.06

这个变量应该由用户被视为只读。不要一个明确的值赋给它 - 你将创建一个独立的局部变量同名屏蔽内置有它的魔力的行为变量。

除了INT和浮动，Python支持其它类型的数字，如小数和分数。Python还内置了支持复数，并使用Ĵ或Ĵ后缀来表示虚部(如3 +5Ĵ)。

3.1.2。字符串

除了数值，Python也可以操作字符串，它可以表现在几个方面。它们可以包含在单引号('...' )或双引号("..." )具有相同的结果[2] 。 \可以用来逃生的报价：

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

在交互式解释器，输出字符串括在引号和特殊字符进行转义用的反斜杠。虽然这可能看起来有时从输入(封闭引号可能会改变)不同，这两个字符串是等效的。该字符串括在双引号如果字符串包含一个单引号，没有双引号，否则是单引号括起来。在打印()函数产生一个更可读的输出，通过省略引号括和印刷转义和特殊字符：

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print('"Isn\'t," she said.')
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a new line
First line.
Second line.

如果您不希望通过开头的字符\被解释为特殊字符，则可以使用原始字符串通过添加ř第一次报价之前：

>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

字符串可以跨多行。一种方法是使用三引号： """......"""或'''...''' 。线的端部被自动包含在字符串中的，但它能够防止这种通过添加\在该行的末尾。下面的例子：

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

产生下面的输出(注意，最初的换行符是不包括在内)：

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

字符串可以连接(粘合)与+运算符，重复*：

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

两个或多个字符串常量(也就是那些引号括起来)彼此相邻的是自动连接在一起。

>>> 'Py' 'thon'
'Python'

这只有两个文字作品虽然不能与变量或表达式：

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

如果你要连接的变量或者变量和文字，可以使用+：

>>> prefix + 'thon'
'Python'

当你想打破长字符串，此功能特别有用：

>>> text = ('Put several strings within parentheses '
            'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

字符串可以被索引(下标)，具有索引0的第一个字符。没有单独的字符类型; 一个字符仅仅是大小为一的字符串：

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

指数也可能是负数，开始从右边计数：

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

请注意，由于-0是相同的为0，负指数从-1开始。

除了索引，切片也支持。虽然索引用于获取单个字符，切片可以让你获得子字符串：

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

请注意如何开始总是包括在内，最后总是排除。这可以确保获得s [：I] + S [I：]总是等于s：

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

切片索引可以使用默认值; 前一个索引默认为零，省略的第二个索引默认值为被切片的字符串的大小。

>>> word[:2]  # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]  # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'

记住如何切片工作是考虑指数作为指着一个方向之间的字符，第一个字符的左边缘编号为0。那么字符串的最后一个字符的右边缘Ñ个字符的索引Ñ，例如：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

数字的第一行给出了指数0 ... 6字符串中的位置; 第二行是对应的负索引。切片从我到 Ĵ由标记的边缘之间的所有字符我和Ĵ分别。

对于非负索引，切片的长度是指数的差异，如果两者都在一定范围内。例如，长度字[1:3]是2。

尝试使用一个索引过大，将导致一个错误：

>>> word[42]  # the word only has 7 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

然而，超出范围的切片索引被正常处理用于切片时：

>>> word[4:42]
'on'
>>> word[42:]
''

Python字符串不能被改变-它们是不可变的。因此，分配给在一个错误的结果字符串索引位置：

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

如果你需要一个不同的字符串，你应该创建一个新的：

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

内置函数LEN()返回一个字符串的长度：

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

另请参阅文本序列类型 - str 字符串是实例序列类型，并支持这些类型所支持的常用操作。字符串方法弦乐支持大量的方法基本变换和搜索。字符串格式化关于使用字符串格式化信息str.format()是描述在这里。 printf风格的格式化字符串旧的格式化操作时调用字符串和Unicode字符串是左操作数％运营商更详细描述。

3.1.3。清单

Python知道了一些复合数据类型，用于组织其它的值。最通用的是列表，可以写成方括号之间用逗号分隔值(项目)列表。列表可能包含不同类型的物品，但通常的项目都具有相同的类型。

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

如字符串(和所有其他内置序列类型)，列表可以被索引和切片：

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

所有切片操作返回一个包含要求的元素的新列表。这意味着下面的切片返回列表的新(浅)副本：

>>> squares[:]
[1, 4, 9, 16, 25]

列表还支持像拼接操作：

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

不像字符串，这是不可改变的，列表是一个可变的类型，也就是说，它是可以改变它们的内容：

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

您也可以在列表的末尾添加新项目，使用的append() 方法(稍后我们将看到更多的方法)：

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

分配到片也是可以的，这甚至可以改变列表的大小或者完全清除它：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

内置函数 len() 也适用于列表：

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

它也可以嵌套列表(创建其它链表)，例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2。首先开始编程步骤

当然，我们可以用Python做更复杂的任务不是增加两者结合。例如，我们可以写的一个初始子序列斐波那契数列如下：

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5

8

这个例子引入了一些新的功能。

第一行包含一个多重赋值：变量一和b 同时被赋值为0和1。在最后一行此再次使用，这表明在右手侧的表达式都计算一次前的任何指配的发生。右手侧的表达式求值从左边到右边。

的，而循环只要条件执行(这里：b < 10)，仍是如此。在Python和C一样，任何非零整数值为true; 零是假的。这种状况也可以是字符串或链表，事实上任何序列; 具有非零长度事情是真实的，空序列为假。在这个例子中使用的测试是一个简单的比较。标准的比较运算符写法相同，The standard comparison operators are written the same as in C: < less than, > greater than, == equal to, <= less than or equal to, >= greater than or equal to , != not equal to.

在身体循环被缩进：缩进是Python对语句分组的方法。在交互提示符中，你必须在每一个缩线制表符或空格(S)。在实践中你将准备为Python更复杂的输入用文本编辑器; 所有像样的文本编辑器有自动缩进功能。当一个复合语句交互式的输入，它必须跟一个空行表示完成(因为当你输入最后一行解析器无法猜测)。请注意，一个基本块内的每一行必须以相同的量缩进。

在打印()函数将参数(S)的它被赋予的价值。它不同于只写你想写(正如我们在前面的计算器示例一样)，在它处理多个参数，浮点运算量的方式表达，和字符串。字符串输出时没有引号，并插入一个空格的项目之间，所以你可以格式化的东西很好，像这样：

>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

关键字参数端可以用来避免换行后输出，或结束与一个不同的字符串的输出：

>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=',')
...     a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

脚注

[1] 由于**的优先级高于- ，-3**2将被解释为-(3**2) ，从而导致-9。为了避免这种情况，并得到9中，可以使用(-3)**2。

[2] 不像其他的语言，特殊字符，如\n具有相同的含义既包含单('...' )和双("..." )引号。两者之间的唯一区别是，单引号内你不需要逃避"(但你必须逃离\' )，反之亦然。

创建于：2014-04-03 | 分类： python | 标签： python 翻译

1
2
3
4
5 (current)
6
7
8
9
10

重构摘要4_构筑测试体系

说明

Java.lang.string

创建字符串

常用方法

常见题目（使用JUnit演示）

Sql_outer_join

LEFT JOIN 操作符

Demo

RIGHT JOIN 操作符

Demo

FULL OUTER JOIN 操作符

重构摘要3_代码的坏味道

1.Duplicated Code 重复代码

2.Long Method 过长的函数

3.Large Class 过大的类

4.Long Parameter List 过长的参数列

5.Divergent Change 发散式变化

6.Shotgun Surgery 散弹式变化

7.Feature Envy 依恋情结

8.Data Clumps 数据泥团

9.Primitive Obsession 基本类型偏执

10.Switch Statements switch语句

11.Parallel Inheritance Hierarchies 平行继承体系

12.Lazy Class 冗赘类

13.Speculation Generality 夸夸其谈未来性

14.Temporary Field 令人迷惑的暂时字段

15.Message Chains 过度耦合的消息链

16.Middle Man 中间人

17.Inappropriate Intimate 狎昵关系

18.Alternative Classes with Different Interface 异曲同工的类

19.Incomplete Library Class 不完美的类库

20.Data Class 纯稚的数据类

21.Refuse Bequest 被拒绝的馈赠

22.Comments 过多的注释

说明

Sql_inner_join

INNER JOIN 操作符

Demo

Mysql

Python入门指南3_简介

3 Python简介

3.1。使用Python作为一个计算器

3.1.1。数字

3.1.2。字符串

3.1.3。清单

3.2。首先开始编程步骤

脚注

文档分类