（四）Python----字符串（连，分，排，替，删，查，判，格式化format）练习（算法-性能测试）
文章目录
- 一 . 字符串
- 二. 返回值都为（新的字符串）
-
- 1. 索引
- 2. 字符串连接join，map方法
-
- 字符串+连接
- 3. 分割
-
- split()
- rsplit
- splitlines按行切分
- partition（前缀）切一刀
- rpartition（后缀）切一刀
- 4. 字符串大小
- 5. 字符串排版（了解）
- 6. 替换replace
- 7. 移除strip
- 8. 字符串查找 find，index，count，len
- 9. 字符串判断endswith，startswith
- 10. 字符串判断 is
- 11. 字符串格式化
- 三. format格式化字符串（建议）
-
- 关键：
- in 方式查找
- 四. 练习
-
- 9x9乘法表
- 打印菱形
- 对顶三角形
- 打印闪电
- 打印斐波那契数列
- 求质数（素数）
- 如何测算性能datetime
-
- 孪生素数
一 . 字符串
print（value,...,sep='',end='\n'）
sep字符之间分隔符
end默认换行符
一个个字符组成的有序的序列，是字符的集合
使用单引号，双引号，三引号
字符串是不可变的对象,所以以下下的分割，替换等都是生成新的字符串
Python3开始，字符串就是Unicode类型
大写小写都行
r前缀不做任何处理
f前缀，格式化字符Python3.6增加（支持特殊字符,\n等）
二. 返回值都为（新的字符串）
1. 索引
不可变
有序的字符集合
for c in sql:
print(c)
print(type(c)) #字符类型
可迭代：也就是可以赋值给数组 / 元组
lst=list(sql)
lst =tuple(sql)
2. 字符串连接join，map方法
string为连接符
"string".join(iterable)->str
要求元素必须是字符串
将可迭代对象连接起来，使用string作为分隔符
可迭代对象本身元素都是字符串，返回一个新的字符串
如下：类型不对（不是字符串）
但如果用map（）函数，强制转换为字符串
s=list(range(9))
"string".join(s)
注意对于列表：用 [ ] 表示，如果为（）则每一个字符都是一个元素
换行效果
字符串+连接
将字符串拼接到一起
3. 分割
split()
split(sep=None,maxsplit=-1)
从左向右
sep值当分割字符串，如果不指定（就以最可能长的方式切分）
maxsplit指定分割次数，-1表示遍历整个字符串
常见的空白字符，空格，\r , \n , \t
rsplit
rsplit(sep=None,maxsplit=-1)
rsplit() 从右向左切
不会改变字符串顺序
sep指定分割字符，
maxsplit指定分割次数，-1表示遍历整个字符串
splitlines按行切分
splitlinex([keepends])
按照行切分字符串
keepends指的是是否保留行分隔符，True，False 默认False
行分隔符包括 \n ,\r\n , \r 等
partition（前缀）切一刀
partition（sep）
从左向右，遇到分隔符就把字符串分割为两部分，
返回头，分隔符，尾部三部分的三元组
如果没有找到分隔符，就返回头，2个空元素的三元组
sep分割字符串，必须指定
rpartition（后缀）切一刀
rpartition(sep)
从右向左，遇到分隔符就把字符串分割为两部分，
返回头，分隔符，尾部的三元组
如果没有找到分隔符，就返回头，2个空元素的三元组
4. 字符串大小
upper() 变大写
lower() 变小写
swapcase() 交换大小写
用法：
'字符串'.upper()
5. 字符串排版（了解）
title() 单词首字母大写
capitalize() 首字母大写
center(width，[,fillchar]) 居中效果（宽度，字符）
zfill(width) 0填充 （多少个）
ljust(width,fillchar) 右对齐
rjust(width,fillchar) 左对齐
6. 替换replace
replace(old,new [,count])
字符串中匹配替换为新的字符串，返回新的字符串
count表示替换几次，默认全部替换
7. 移除strip
strip(]chars])---->str
在字符串两端 删除指定的字符集chrs中的所有字符
如果chars没有指定，去除两端的空白字符
lstrip([chars])--->str 从左开始
rstrip([chars])--->str 从右开始
8. 字符串查找 find，index，count，len
指定区间，效率就会提高
- index没找到会抛出异常
ValueError
index(sub[，start[，end]]) ---->int
rindex(sub[，start[，end]]) ---->int
返回第一个字符找到的位置
- find
不会报错—找到返回，找不到（负数）
find(sub[，start[，end]]) ---->int
反方向找---结果是正索引的值
rfind(sub[，start[，end]]) ---->int
- count：统计
子串sub出现的次数
count(sub[，start[，end]]) ---->int
- len求字符串
长度
后面写容器—字符串
len(string)
9. 字符串判断endswith，startswith
- endswith字符串是否是
suffix(字符串)结尾
endswith(suffix[,start[,end]])--->bool
- startswith 字符串是否
prefix开头
startswith(prefix[,start[,end]])--->bool
负数结尾—前包后不包（-3，不包括最后3个字符）
10. 字符串判断 is
isalnum()-->bool 是都是字符和数字组成
isalpha（） 是否是字母
isdecimal（）是否自暴寒十进制数字
isdigit（）是否全部数字（0~9）
isidentifier（）是不是字母和下划线开头，其他都是字母，数字，下划线
islower（）是否全都是小写
isupper（）是否全是大写
isspace（）是否只包含空白字符（空格，\t \r \n \f等）
iskeyword() 是否是关键字
11. 字符串格式化
-
拼接字符串输出样式，更灵活
join拼接只能使用分隔符，且要求被拼接的元素可迭代，且元素是字符串
+拼接字符串，非字符串首先需要转换才能拼接 -
在2.5版本之前只能用printf style风格的print输出
printf-style formatting来自C语言的prinft函数
格式要求
占位符：使用% 和 格式字符组成，例如%s,%d等
s强调str（），r会调用repr（），所有对象都可以被这两个转化
占位符中还可以插入修饰字符，例如：%03d表示打印3个位置，不够前面补零，-4d%后面补
format % values，格式字符串和被格式的值之间使用%分隔
valyes只能是一个对象，或者是一个与格式字符串占位符数目相等的元组，或一个字典 -
在3.x版本有
f格式化
%10.2f 小数点后几位
%x 转十六进制
三. format格式化字符串（建议）
前面只有'{}'里面的{}才有用—占位符
最多用的是改变位置（提取有效的字符串等信息）
关键：
按位置对应，按名称对应，排版对齐方式，浮点打印方式
- 浮点数 %，f
- 左边的{} 数量
<=右边元组的数 ：表示强制转换（可以强制时间格式，或者进制）- 对齐方式
向右对齐>默认
向左对齐<
居中^ - 十六进制
x , X , #x, #X表示输出前面的格式符 - 日期datetime
补零
正确的转换后（十六进制）
用：格式化
向右对齐 > 默认
向左对齐 <
居中 ^
注意宽度可以被撑破
in 方式查找
四. 练习
9x9乘法表
for i in range(1,10):
line=''
for j in range(1,i+1):
line += str(j) + '*' + str(i) + '=' + str(i*j) + '\t'
print(line)
for i in range(1,10):
line=''
for j in range(1,i+1):
line += "{}*{}={} ".format(j,i,i*j)
print(line)
for i in range(1,10):
for j in range(1,i+1):
print('%dx%d=%d\t' %(j,i,i*j),end=' ')
if i==j:
print(' ')
三元表达式
对齐
如何打印上三角
打印菱形
分析：首先我们分析一下菱形的构成，你输入2，则打印一个3行的菱形；你输入一个3，则打印5行的菱形。也就是根据输入的数字a，打印2a-1行的菱形。菱形从图像来说，是一个三角形加上一个倒三角组成的，所以可以用双循环打印两个三角形，打印倒三角形的条件是第一次循环计数器i的值等于a。
a=int(input("please input a number a="))
b=a #空格数
c=a # ✳数
for i in range(1,a+1):
print(' '*(b-1)+'*'*(2*i-1))
b=b-1 #空格数减一
if i==a:
for y in range(1,a): #y为空格
print(' '*y+'*'*(2*c-3))
c=c-1 #*减少
优化
a=int(input("请输入一个数"))
for i in range(-a,a+1): #[-a,a]
if i<0:
i=-i
print(' '*i + '*'*(2*(a-i)+1))
abs(i)取绝对值
居中对齐
a=7
e=7//2
for i in range(-e,a-e):
print("{:^{}}".format('*' * (a - 2*abs(i)),a))
对顶三角形
a=5
for i in range(-a,a+1): #[-a,a]
if i<0:
i=-i
print(' '*(a-i) + '*'*(2*i+1))
a=5
for i in range(-a,a+1): #[-a,a]
print(' '*(a-abs(i))+'{}'.format('*'*(2*abs(i)+1)))
a=5
for i in range(-a,a+1): #[-a,a]
print('{}{}'.format(' '*(a-abs(i)),'*'*(2*abs(i)+1)))
居中
a=5
for i in range(-a,a+1): #[-a,a]
print('{:^11}'.format('*'*(2*abs(i)+1)))
打印闪电
分析
a=5
for i in range(-a,a+1):
if i < 0:
print(' '* -i + (a+1+i) * '*')
elif i > 0:
print(' '*a+'*'*(a+1-i))
else:
print('*'*(2*a+1))
打印斐波那契数列
0、1、1、2、3、5、8、13、21、34
a=0
b=1
index=0
print('fib({})={}'.format(index,a))
index+=1
print('fib({})={}'.format(index,b))
while True:
c = a +b
#打印100之内的
if c > 100:
break
index+=1
print('fib({})={}'.format(index,c))
a=b
b=c
那如何打印100个斐波那契数
a=0
b=1
index=0
print('fib({})={}'.format(index,a))
index+=1
print('fib({})={}'.format(index,b))
while True:
c = a +b
index += 1
print('fib({})={}'.format(index, c))
if index == 100:
break
a=b
b=c
求质数（素数）
给一个数，判断是不是素数（质数）自能被1和它本身整除
输入一个数判断是不是素数
a=int(input("please input a number a="))
for i in range(2,a):
if a%i == 0:
break
else:
print("是素数")
for i in range(1,100):
for j in range(2,i):
if i%j == 0:
break
else:
print(i)
求100以内的质数
count =0
for x in range(2,100):
for i in range(2,x):
if x % i == 0: #合数
break
else:
print(x,sep="\n")
count += 1
print("count=",count)
优化:只需要除 到 开方的那个值就可以（这样做—cpu快）
count =0
for x in range(2,100):
for i in range(2,int(x**0.5)+1):
if x % i == 0: #合数
break
else:
count += 1
print(x)
print("count=",count)
再次优化：直接跳过2的倍数
import datetime
start = datetime.datetime.now()
count =1
print(2)
for x in range(3,100000,2):
#这里排除更多个内容
if x > 10 and x % 5 == 0:
continue
if x > 6 and x % 3 == 0:
continue
for i in range(3,int(x**0.5)+1,2):
if x % i == 0: #合数
break
else:
count += 1
print("count=",count)
# total_seconds秒数-----时间差才会有
date = (datetime.datetime.now() - start).total_seconds()
print(date)
再次优化
如何测算性能datetime
(排除更多的无用功)
再次优化：还是用列表方式
是将更多数排除掉（在已知道的质数表中将合数排除）
排除掉多次开方的消耗
import datetime
count =1
#primenumbers=[None]*10000
primenumbers[0]=2
start = datetime.datetime.now()
for x in range(3,100000,2):
flag=False #不是素数
# 质数表
# 逻辑，整除之前的质数，如果可以被整除就说明不是素数
edge=int(x**0.5)
for i in primenumbers:
if i > edge: #是质数
flag=True #是素数
break
if x % i == 0: #合数
break
if flag: #是质数
count += 1
primenumbers.append(x)
print("count=",count)
date = (datetime.datetime.now() - start).total_seconds()
print(date)
更进一步
import datetime
count =2
#primenumbers=[None]*10000
primenumbers =[3]
start = datetime.datetime.now()
for x in range(5,100000+1,2):
flag=False #不是素数
# 质数表
# 逻辑，整除之前的质数，如果可以被整除就说明不是素数
edge=int(x**0.5)
for i in primenumbers:
if i > edge: #是质数
flag=True #是素数
break
if x % i == 0: #合数
break
if flag: #是质数
count += 1
primenumbers.append(x)
print("count=",count)
date = (datetime.datetime.now() - start).total_seconds()
print(date)
孪生素数
大于3的素数只有6N-1和6N+1两种形式，如果6N-1和6N+1都是素数成为孪生素数
注意其实测试的都是6的倍数前后的数字，这些数字一定是奇数。
import datetime
n=100000
count =3 #2,3,5
start = datetime.datetime.now()
x=7 #11,13,17,19
step=4 #步长
while x<n:
if x%5 !=0: #至少是质数的候选
for i in range(3,int(x**0.5)+1,2):
if x % i ==0:
break
else:
count+=1
x+=step
#变长
step=4 if step == 2 else 2
print("count=",count)
date = (datetime.datetime.now() - start).total_seconds()
print(date)
再次提升（用质数列表）
import datetime
n=100000
count =3 #2,3,5
primenumbers=[3,5]
x=7 #11,13,17,19
step=4 #步长
start = datetime.datetime.now()
while x<n:
if x%5 !=0: #至少是质数的候选
flag=False #不是质数
edge=int(x**0.5)
for i in primenumbers:
#大于 开方，就是质数
if i > edge:
flag = True
break
if x % i == 0: #是合数
break
if flag:
count +=1
primenumbers.append(x)
x+=step
step=4 if step == 2 else 2
print("count=",count)
date = (datetime.datetime.now() - start).total_seconds()
print(date)