substr 函数：截取字符串
	
语法：SUBSTR(string，start， [length])

string：表示源字符串，即要截取的字符串。

start：开始位置，从1开始查找。如果start是负数，则从string字符串末尾开始算起。

length：可选项，表示截取字符串长度。

示例：

SELECT SUBSTR('Hello SQL!', 1) FROM dual     --截取所有字符串，返回'Hello SQL!'
SELECT SUBSTR('Hello SQL!', 2) FROM dual     --从第2个字符开始，截取到末尾。返回'ello SQL!'
SELECT SUBSTR('Hello SQL!', -4) FROM dual    --从倒数第4个字符开始，截取到末尾。返回'SQL!'
SELECT SUBSTR('Hello SQL!', 3, 6) FROM dual  --从第3个字符开始，截取6个字符。返回'llo SQ'
SELECT SUBSTR('Hello SQL!', -4, 3) FROM dual --从倒数第4个字符开始，截取3个字符。返回'SQL'


	
instr 函数：返回子字符串在源字符串中的位置
	
语法：INSTR(string，child_string，[start]，[show_time])

string：表示源字符串。

child_string：子字符串，即要查找的字符串。

start：可选项，开始位置，默认从1开始。如果为负数，则从右向左检索。

show_time：可选项，表示子字符串第几次出现在源字符串当中，默认第1次，负数则报错。

示例：

--表示从源字符串'city_company_staff'中第1个字符开始查找子字符串'_'第1次出现的位置
SELECT INSTR('city_company_staff', '_') FROM dual    --返回5

--表示从源字符串'city_company_staff'中第5个字符开始查找子字符串'_'第1次出现的位置
SELECT INSTR('city_company_staff', '_', 5) FROM dual    --返回5

--表示从源字符串'city_company_staff'中第5个字符开始查找子字符串'_'第1次出现的位置
SELECT INSTR('city_company_staff', '_', 5, 1) FROM dual    --返回5

--表示从源字符串'city_company_staff'中第3个字符开始查找子字符串'_'第2次出现的位置
SELECT INSTR('city_company_staff', '_', 3, 2) FROM dual    --返回13

--start参数为-1，从右向左检索，查找'_'字符串在源字符串中第1次出现的位置
SELECT INSTR('city_company_staff', '_', -1, 1) FROM dual    --返回13

--start参数为-6，从右向左检索，查找'_'字符串在源字符串中第2次出现的位置
SELECT INSTR('city_company_staff', '_', -6, 2) FROM dual    --返回5



	
substr 函数结合 instr 函数截取字符串
	
现有需求：数据查询处理需要对code进行"拆分"

code命名规则类似：城市_所属公司_员工职位_员工姓名

其中，城市、公司、职位、姓民字符串长度不固定，由于字符串长度不固定，只使用substr函数无法实现需求，需配合instr函数定位到字符'_'的位置，然后使用substr函数进行截取。详细见下面例子。

表数据如下：

SOURCE_CODE
		
BJ_BAIDU_CEO_LY
		
SH_BOKE_MANAGER_LWX
		
HRB_WM_CASHIER_OYZY
		
获取城市：

SELECT
	SUBSTR (SOURCE_CODE, 1, INSTR (SOURCE_CODE, '_', 1, 1) - 1) AS CITY
FROM
	TABLE_CODE_TEST

结果：



解释：此处截取源字符串SOURCE_CODE，从第1个字符开始，由于代表城市的code长度不固定，我们无法确定截取几个字符，所以使用instr函数判断第一个'_'字符的位置，进而确定每个SOURCE_CODE截取几个字符串。

那为什么减1呢？

是因为INSTR (SOURCE_CODE, '_', 1, 1)获取的是源字符串中'_'字符第一次出现的位置，再减1就得出了CITY字符个数。

获取公司：

SELECT
	SUBSTR (
		SOURCE_CODE, 
		INSTR (SOURCE_CODE, '_', 1, 1) + 1, 
		INSTR (SOURCE_CODE, '_', 1, 2) - INSTR (SOURCE_CODE, '_', 1, 1)-1
	) AS COMPANY
FROM
	TABLE_CODE_TEST

结果：



解释：截取源字符串，从（第一个'_'出现位置+1）开始，截取个数为：第2个'_'出现位置减去第1个'_'出现位置，此时还多了一个下划线'_'，再减去1即可得到代表公司字符串。

获取姓名：

SELECT
	SUBSTR (SOURCE_CODE, INSTR (SOURCE_CODE, '_', 1, 3) + 1) AS STF_NAME
FROM
	TABLE_CODE_TEST

结果：



解释：截取源字符串，从（'_'第3次出现位置+1）开始截取，截取到末尾。

 

示例：

       在源字符串“You may be out of my sight, but never out of my mind.”中查找“my”的个数。输出：匹配个数为2
三种方法：

       1.通过String的indexOf方法

       2. 通过正则表达式

       3. 通过String的split方法

其中第一种方法只能用于精确匹配，第二三种则可以模糊匹配（方法3的参数为正则表达式）。例如：若将child改为“.my.”，第一种方法失效。
方法1：通过String的indexOf方法
public int indexOf(int ch, int fromIndex) ：返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。如果不存在则返回 -1。
//方法1、通过String的indexOf(String str, int fromIndex)方法
	private void matchStringByIndexOf( String parent,String child )
	{
		int count = 0;
		int index = 0;
		while( ( index = parent.indexOf(child, index) ) != -1 )
		{
			index = index+child.length();
			count++;
		}
		System.out.println( "匹配个数为"+count );							  //结果输出
	}

方法2：通过正则表达式
类 Pattern ：正则表达式的编译表示形式。

       指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

       因此，典型的调用顺序是

       Pattern p = Pattern.compile(“a*b”);

       Matcher m = p.matcher(“aaaaab”);

       boolean b = m.matches();

类 Matcher：通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：

       matches 方法尝试将整个输入序列与该模式匹配。

       lookingAt 尝试将输入序列从头开始与该模式匹配。

       find 方法扫描输入序列以查找与该模式匹配的下一个子序列

//方法2、通过正则表达式
	private void matchStringByRegularExpression( String parent,String child )
	{
		
		int count = 0;
		Pattern p = Pattern.compile( child );
		Matcher m = p.matcher(parent);
		while( m.find() )
		{
			count++;
			System.out.println( "匹配项" + count+"：" + m.group() ); //group方法返回由以前匹配操作所匹配的输入子序列。
		}
		System.out.println( "匹配个数为"+count );							  //结果输出
	}

方法3：通过String的split方法
public String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，所得数组中不包括结尾空字符串。
//方法3、通过split方法
	private void matchStringBySplit( String parent,String child )
	{
		String[] array = parent.split(child);
		System.out.println( "匹配个数为" + (array.length-1) );
	}

完整代码：
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 在字符串中查找匹配的子字符串
 * author：大能豆   QQ：1023507448
 * case ：
 * 源字符串：You may be out of my sight, but never out of my mind.
 * 要查找的子字符串：my
 * 输出：匹配个数为2
 */
public class MatchString {

    //方法1、通过String的indexOf(String str, int fromIndex)方法
    private void matchStringByIndexOf(String parent, String child) {
        int count = 0;
        int index = 0;
        while ((index = parent.indexOf(child, index)) != -1) {
            index = index + child.length();
            count++;
        }
        System.out.println("匹配个数为" + count);//结果输出
    }

    //方法2、通过正则表达式
    private void matchStringByRegularExpression(String parent, String child) {
        int count = 0;
        Pattern p = Pattern.compile(child);
        Matcher m = p.matcher(parent);
        while (m.find()) {
            count++;
            System.out.println("匹配项" + count + "：" + m.group()); //group方法返回由以前匹配操作所匹配的输入子序列。
        }
        System.out.println("匹配个数为" + count); //结果输出
    }

    //方法3、通过split方法，但此方法需考虑子字符串是否是在末尾，若在末尾则不需要-1
    private void matchStringBySplit(String parent, String child) {
        String[] array = parent.split(child);
        System.out.println("匹配个数为" + (array.length - 1));
    }

    public static void main(String[] args) {
        MatchString ms = new MatchString();
        String parent = "You may be out of my sight, but never out of my mind.";
        String child = "my";

        System.out.println("------通过indexOf-------");
        ms.matchStringByIndexOf(parent, child);  //调用方法1

        System.out.println("------通过正则表达式-------");
        ms.matchStringByRegularExpression(parent, child);  //调用方法2

        System.out.println("------通过split方法-------");
        ms.matchStringBySplit(parent, child);  //调用方法3

        String test = "abcdbdasda";
        String[] as = test.split("a");
        System.out.println(Arrays.toString(as));
    }

}

1、使用正则表达式，用法如下：
## 总结
## ^ 匹配字符串的开始。
## $ 匹配字符串的结尾。
## \b 匹配一个单词的边界。
## \d 匹配任意数字。
## \D 匹配任意非数字字符。
## x? 匹配一个可选的 x 字符 (换言之，它匹配 1 次或者 0 次 x 字符)。
## x* 匹配0次或者多次 x 字符。
## x+ 匹配1次或者多次 x 字符。
## x{n,m} 匹配 x 字符，至少 n 次，至多 m 次。
## (a|b|c) 要么匹配 a，要么匹配 b，要么匹配 c。
## (x) 一般情况下表示一个记忆组 (remembered group)。你可以利用 re.search 函数返回对象的 groups() 函数获取它的值。
## 正则表达式中的点号通常意味着 “匹配任意单字符”

2、解题思路：


既然是提取数字，那么数字的形式一般是：整数，小数，整数加小数；


所以一般是形如：----.-----；


根据上述正则表达式的含义，可写出如下的表达式："\d+.?\d*"；

\d+ 匹配1次或者多次数字，注意这里不要写成*，因为即便是小数，小数点之前也得有一个数字；
\.? 这个是匹配小数点的，可能有，也可能没有；
\d* 这个是匹配小数点之后的数字的，所以是0个或者多个；



3、代码如下：
# -*- coding: cp936 -*-
import re
 
string="A1.45，b5，6.45，8.82"
print re.findall(r"\d+\.?\d*",string)
 
# ['1.45', '5', '6.45', '8.82']

python中的strip()可以去除头尾指定字符

ss = '我的电话是18827038663，也是微信号，\n 请加入，谢谢\n\n\n'
print(ss.strip('\n'))

结果：

我的电话是18827038663，也是微信号，
 请加入，谢谢

可以看到只能删除头尾指定字符。

想要去除中间字符，可以使用replace()函数

ss = '我的电话是18827038663，也是微信号，\n 请加入，谢谢\n\n\n'
print(ss.replace('\n', ''))

结果：

我的电话是18827038663，也是微信号， 请加入，谢谢

note:

1. strip(str)

基本用法：ss.strip(rmStr)

ss.strip()参数为空时，默认去除ss字符串中头尾\r, \t, \n, 空格等字符；参数为某个字符时，可以去掉头尾指定字符噢，例如：

输入：

ss = '我的电话是18827038663，也是微信号，请加入，谢谢啦啦嗯'
print(ss.strip('嗯啦'))

运行结果：

我的电话是18827038663，也是微信号，请加入，谢谢

需要注意strip是按字符级别匹配的，只要头尾出现字符集中的字符，就会被strip掉，而不是整段字符匹配的。

ss.lstrip()删除ss字符串开头处的指定字符，ss.rstrip()删除ss结尾处的指定字符

2. replace(old, new[, max])

基本用法：ss.replace(old, new[, max])

old是原字符串中的字符，new是需要替换为的新字符串，max是最大匹配次数，匹配时从左到右最多max次。一般情况下不设置max的值，默认全部替换。

输入：

ss = 'old old string'
ret = ss.replace('old', 'new', 1)
print(ret)

输出：

new old string