0%

发表于

在String类中提供了indexOf和lastIndexOf方法用于查找字符或字符串，返回值是查找的字符串所在的位置，-1表示没有找到。

1
String的Char At(int index)方法可以返回索引index所在位置的字符

实例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
String sourceString = "There is a string accessing exemple";

//获得字符串长度
int len = sourceString.length();
//获得索引位置16的字符串
char ch = sourceString.charAt(16);

//查找字符和子字符串
int firstChar1 = sourceString.indexOf('r');//从前往后搜索字符
int lastChar1 = sourceString.lastIndexOf('r');//从后往前搜索字符
int firststr1 = sourceString.indexOf("ing");//从前往后搜索字符串
int laststr1 = sourceString.lastIndexOf("ing");//从后往前搜索字符串

int firstchar2 = sourceString.indexOf('e', 15);//从索引为15的位置开始
/*
 * 也就是说：indexOf和lastIndexOf都还可以接收一个开始的索引
 * 需要注意的是：如果没有找到，是不能够从头直接跳到尾巴去接着找，
 * 也不能从尾巴跳到头部去继续找，这种情况下，就只能算作找不到，
 * 返回-1
 */

发表于 更新于

字符串拼接

由于String字符串是不可变字符串，所以String字符串进行拼接以后会产生一个新的对象。

1 使用 + 号（可以连接任何类型数据拼接成为字符串）

2 使用 concat(String str)方法(只能拼接String字符串)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class Test {
	public static  void main (String[]args) {
//字符串拼接
//使用+运算符连接
String s1 = "Hello";
String s2 = s1 + " World";
System.out.println(s2);

String s4 = "Hello";
//使用+运算符连接，支持+=赋值运算符
s4 += " ";
s4 += "World";
System.out.println(s4);

String s5 ="Hello";
//使用concat连接
s5 = s5.concat(" ").concat("World!");//concat的参数和返回值都是String,所以可以连续调用该方法进行多个字符串的拼接
int age = 18;
String s6 = "她的年龄是" + age + "岁";
System.out.println(s6);

char score = 'A';
String s7 = "她的英语成绩是" + score;
System.out.println(s7);

java.util.Date nowDate = new java.util.Date();
//对象拼接自动调用toString()方法
/*这里解释一下：
 * Java中所有对象都有一个toString()方法，该方法可以将对象转换为字符串，而且拼接过程中会自动调用这个方法。
 * 
 * java.util.Date类是java的日期类
 */
String s8 = "今天是： " + nowDate;
System.out.println(s8);
	}
	
}
/* 输出结果：
 *Hello World
*Hello World
*她的年龄是18岁
*她的英语成绩是A
*今天是： Wed Feb 19 00:54:22 CST 2020
*/

发表于 更新于

系统环境

如果命令很长，可以分两行来输入。（需要利用续行符…）

设置当前文件夹

步骤：先建立文件夹，然后在Matlab命令行中用cd命令+路径设置

工作区也称为工作区，用于变量的显示(以表格形式)和操作(可以编辑，删除)

Matlab的搜索路径

在命令行中输入一条命令后，Matlab

变量 –>内部函数–>程序文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
%{Matlab的搜索路径有一定的顺序：变量>内部函数>程序文件,下面是一个实例:}%
x=sin(1) %这里的sin是内部函数，正弦，所以结果应该是:0.8415
sin=[1,2,3,4,5]; %这里定义sin为一个变量，包含5个向量元素，不是内部函数了
x=sin(1) %因为变量的级别高于内部函数，所以这个命令的结果是1而不是0.8415

%{Matlab的搜索路径有一定的顺序：变量>内部函数>程序文件,下面是一个实例:}%
x=sin(1) %这里的sin是内部函数，正弦，所以结果应该是:0.8415
sin=[1,2,3,4,5]; %这里定义sin为一个变量，包含5个向量元素，不是内部函数了
x=sin(1) %因为变量的级别高于内部函数，所以这个命令的结果是1而不是0.8415
%{此时如果要计算sin的本来值，可以在工作区将已经定义的sin变量删除}%

% Matlab的文件搜索
% 如何设置文件搜索路径
% 1 使用path命令。例如>>path(path,'需要搜索的路径')
% 2 在窗口上设置
% 搜索的顺序：1 当前文件；2 已经设置的搜索路径中；3 如果两个位置都没有搜索结果则会报错

数据类型

分类

整型：

分为：

1:有符号整数

2: 无符号整数

然后又分别分为8，16，32，64位整数

需要记住：

int是带符号，uint是不带符号

带符号8位整数的最大值是127

提供了数据类型转换函数

浮点数

同样提供了类型转换函数：

1 single函数：将其他类型的数据转换为单精度型

2 double函数：将其他类型的数据转换为双精度型

复型

复型数据包括实部和虚部两个部分，都默认为双精度单位，用i或者j来表示

常用函数有两个：

real：获取复数的实部

imag：获取复数的虚部

数值数据的输出格式

使用format命令，格式是：

format 格式符

注意：format命令只影响数据输出的格式，而不影响数据的计算和存储

常用数学函数

调用方法：

函数名(函数自变量的值)

函数在运算时是将函数逐项作用于矩阵的每个元素上，所以最后运算的结果就是一个与自变量同类型的矩阵

即作用于矩阵，结果是矩阵

1 函数的调用格式：(实例)

2 常用函数的应用

三角函数

三角函数也分为两种类型：

以弧度为单位的函数和以角度为单位的函数，如果是以角度为单位的函数，则在调用时应该在函数名后面加上d，以示区别。

abs函数

可以用来求实数的绝对值、复数的模、字符串的ASCII码值，具体操作见后面代码

取整函数

有round、fix、floor、ceil四种类型，具体实例见文章尾部

3 函数应用举例

1 分别求一个三位正整数的个、十、百位

2 求[1,100]区间的所有素数

代码见后面。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
% 转换函数实例
class(4)
(class(single(4)))
%{结果分别是ans ='double'，ans ='single'}%



%format来设置数值数据的输出形式
% 格式：format 格式符
% 实例：
format long 
50/3
% 此时的输出结果是：16.666666666666668
format
50/3
% 重置以后结果变回了：16.6667

%常用函数实例
%exp函数实例
% 在matlab中exp意思是以自然常数e为底的指数函数。返回 e（自然对数的底）的幂次方。
A = [4,2;3,6]
B = exp(A)
%{输出结果：B =54.5982    7.3891 20.0855  403.4288}%
% 上行结果格式和真实情况不同

%三角函数的两种调用方法：
% 1
cos(pi)
% 2 
cosd(180)
% 两种方法结果肯定是一样的
% 结果：-1

%abs函数使用实例：
% 1 求绝对值
abs(-100)
% ans = 100

%2 求复数的模
abs(5+12i)
% ans = 13

%3 求字符串的ASCII码
abs('abd')
% ans 87 98 100

% 取整函数
% 1 round:按照四舍五入取整
% 2 ceil：向上取整，即取大于等于这个数的第一个整数
% 3 floor：向下取整，取小于等于这个数的第一个整数
% 4 fix： 取靠近0的那个整数，也就是舍去小数取整
% 实例：
round(4.7)
fix(-3.2)
floor(3.6)
ceil(-3.8)
%ans=5;ans=-3;ans=3;ans=-3

% 函数应用举例1：分别求出一个三位整数的个位、十位、百位
% rem是取余函数
m=345;
m1=rem(m,10)%个位数
m2=rem(fix(m/10),10)
m3=fix(m/100)
% m1=5;m2=4;m3=3

%函数应用举例2：求[1,00]区间的所有素数
x=1:100;
k=isprime(x);%isprime用来判断一个数是否能被2整除，能为真，不能则为假
k1=find(k);%find用来找出为真的x序列
p=x(k1)%输出1到100之间的素数

对句柄的理解

句柄是matlab语言独有的参数，相当于C语言的指针。

发表于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# yield
# 带有yield的函数在Python中被称为generator(生成器)
##   如何生成斐波那契数列
# 第一版
'''
def fab(max):
	n, a , b  = 0, 0, 1
	while n < max:
		print(b)
		a , b  = b, a + b
		n = n + 1

fab(6)
'''
## 输出斐波那契数列前N个第二版
'''
def fab(max):
	n, a, b = 0, 0, 1
	L = []
	while n < max:
		L.append(b)
		a, b = b, a + b
		n = n + 1
	return L
for n in fab(5):
	print(n)
'''
'''改写后的fab函数通过满足返回List能够满足复用性的要求，但是，随着max越来越大，会导致程序所占内存越来越大
所以更好的做法是通过iterable对象来迭代'''
### 第三版 -----有错
'''
class Fab(object):
	def __int__(self, max):
		self.max = max
		self.n, self.a, self.b = 0, 0, 1
	def __iter__(self):
		return self
	def next(self):
		if self.n < self.max:
			r = self.b
			self.a, self.b =self.b, self.a + self.b
			self.n = n + 1
			return r
		raise StopIteration()

for n in Fab(5):
	print(n)
'''
#### 第四版
def fab(max):
	n , a, b = 0, 0, 1
	while n  < max:
		yield b
		a, b = b, a + b
		n = n+ 1

for n in fab(5):
	print(n)
"""简单的讲：yield就是把一个函数变成一个generator，带有yield的函数不再是一个普通函数，Python解释器会将其视为一个
generator，调用fab(5)不会执行fab函数，而是返回一个iterable对象！
结论：一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起
来像函数调用，但不会执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）
才开始执行。虽然执行流程仍按函数的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭
代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被
 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。yield 的好处是显而易见的，把
 一个函数改写为一个 generator 就获得了迭代能力，比起用类的实例保存状态来计算下一个 next() 
 的值，不仅代码简洁，而且执行流程异常清晰
"""
# 可以使用 isgeneratorfunction来判断是不是一个特殊的generator函数
from inspect import isgeneratorfunction
print(isgeneratorfunction(fab))

"""输出结果：
1
1
2
3
5
True
"""

发表于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# python的and返回值
"""
在布尔上下文中从左到右演算表达式的值，如果布尔上下文中的所有值都为真，那么 and 返回最后一个值。

如果布尔上下文中的某个值为假，则 and 返回第一个假值。
"""
# 实例1
def re(n):
    return n + 1 and n ** 2

print(re(0))#因为非零即假，所以返回第一个表达式的值
print(re(100))# 因为100为真，所以返回后一个表达式的值
# 实例2
"""对于字符串而言，其中有空格的字符串为假，否则为真"""
def st(s):
    return s and s.strip()


print(st('happy '))#这里有空格为假的，则返回后一个表达式的值。经过strip方法之后，末尾的空格被剔除了
print(st('names'))# 这里为空格，则直接返回这个字符串
print(st('fa fdaf'))# strip只对首尾的对象管用
"""
输出结果：
0
10000
happy
names
fa fdaf
"""

发表于 
1
2
3
4
5
6
7
8
9
10
# strip方法用于移除字符串头尾的字符（默认为空格或者换行符）或字符序列
strs = "happp "
print(strs.strip())

print(strs.strip().strip('p'))

"""输出结果：
happp
ha
"""

发表于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# filter ： Python内建的filter函数用于过滤序列
"""
和map()类似。filter也接收一个序列。区别是：filter把传入额函数依次作用于每个元素，然后根据
返回值是True 还是Flase决定保留还是丢弃该元素
"""
            #在一个list中删掉偶数，只保留奇数
def is_odd(n):
    return n % 2 == 1
print(list(filter(is_odd, [1,2,3,4,5,6,7,8,9,10,11])))

# 把一个序列中的空字符串删掉
def not_empty(s):
    return s and s.strip()

print(list(filter(not_empty,['a', '', None, 'B', 'C', 'D'])))
"""返回值：
['a', 'B', 'C', 'D']
注意到：filter函数返回的是一个lterator，也就是一个惰性序列，所以要强迫fliter完成计算结果，需要用到方法list
"""

发表于

什么叫计算

1 算术运算

2 较复杂的运算：即根据已知量求出未知量

什么叫科学计算

对于复杂的数值计算问题，可以利用计算机进行问题求解

利用计算机进行数值计算的方法叫做数值计算

科学计算与Matlab语言的关系

数值问题 ——> 求解算法 ——> 程序实现——> 结果分析

Matlab是矩阵实验室的缩写

Matlab语言的主要功能

例如：可以求解一元二次方程

1
2
p = [1,-3,1];
x = roots(p)

发表于 更新于 分类于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# names.py
def normalize(name):
    return name.capitalize()

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)
# 求积
from functools import reduce
def prod(L):
    def prod1(x, y):
        return x * y
    return reduce(prod1, L)


print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
# 转换字符串
'''
先记住这个结果，等会实现需要用到
a = '123.456'
n = a.index('.')
b = [x for x in a[:n]]
print(b)
结果：
['1', '2', '3']
'''
def str2float(s):
    def fn(x, y):
        return x * 10 + y
    n = s.index('.')
    s1 = list(map(int, [x for x in s[:n]]))
    s2 = list(map(int, [y for y in s[n+1: ]]))
    return reduce(fn,s1) + (reduce(fn, s2) / 10 ** len(s2))

print(str2float('123.456'))
"""
输出结果：

['Adam', 'Lisa', 'Bart']
3 * 5 * 7 * 9 = 945
123.456

"""

发表于 更新于 分类于 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 一个最简单的高阶函数
def add(x,y,f):
    return (f(x)+f(y))


print(add(500,20,abs))

"""
输出结果：
520

"""
# map函数
"""map函数接受两个参数，一个是函数，一个是lterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的lterable返回"""
# 代码实现：
def sq(x):
    return x * x
print(list(map(sq,[1,3,5,7,9])))
#reduce函数
# reduce函数：reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
## 用reduce函数实现序列的求和
# 使用时需要先导入一个模块
from functools import reduce
numbers = [1,3,5,7,9,11,13,15,17,19]
def add(x,y):
    return x + y
print(reduce(add,numbers))
# 其实用sum函数求和更简单
print(sum(numbers))
## reduce的妙用：将[1，3，5，7，9，]变为整数13579
def f(x,y):
    return x * 10 + y
print(reduce(f,[1,3,5,7,9]))
## map + reduce 实现str转int
def char2num(s):
    return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
# 上一行函数是简单的给出key调用字典的value。s必须在字典key里。关键在于字符串在python里是可以
# 被当做list用的。map(char2num, '13579')把字符串'13579'当list用，于是就变成了
# map(char2num, ['1','3','5','7','9'])得到的是[1, 3, 5, 7, 9]
reduce(f,map(char2num, '13579'))
"""
输出结果：
520
[1, 9, 25, 49, 81]
100
100
13579
"""