一 . 字符串

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 ,rn , 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

指定区间，效率就会提高

1. index没找到会抛出异常ValueError

index(sub[，start[，end]]) ---->int

rindex(sub[，start[，end]]) ---->int

返回第一个字符找到的位置

2. find 不会报错—找到返回，找不到（负数）

find(sub[，start[，end]]) ---->int

反方向找---结果是正索引的值
rfind(sub[，start[，end]]) ---->int

3. count：统计子串sub出现的次数

count(sub[，start[，end]]) ---->int

4. len求字符串长度
   后面写容器—字符串

len(string)

9. 字符串判断endswith，startswith

1. endswith字符串是否是suffix(字符串)结尾

endswith(suffix[,start[,end]])--->bool

2. 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. 字符串格式化

1. 拼接字符串输出样式，更灵活
   join拼接只能使用分隔符，且要求被拼接的元素可迭代，且元素是字符串
   +拼接字符串，非字符串首先需要转换才能拼接

2. 在2.5版本之前只能用printf style风格的print输出
   printf-style formatting来自C语言的prinft函数
   格式要求
   占位符：使用% 和 格式字符组成，例如%s,%d等
   s强调str（），r会调用repr（），所有对象都可以被这两个转化
   占位符中还可以插入修饰字符，例如：%03d表示打印3个位置，不够前面补零，-4d%后面补
format % values，格式字符串和被格式的值之间使用%分隔
   valyes只能是一个对象，或者是一个与格式字符串占位符数目相等的元组，或一个字典

3. 在3.x版本有f格式化

%10.2f 小数点后几位

%x 转十六进制

三. format格式化字符串（建议）

前面只有'{}'里面的{}才有用—占位符

最多用的是改变位置（提取有效的字符串等信息）

关键：

按位置对应，按名称对应，排版对齐方式，浮点打印方式

1. 浮点数 %，f
2. 左边的{} 数量<= 右边元组的数
3. ： 表示强制转换（可以强制时间格式，或者进制）
4. 对齐方式
   向右对齐 > 默认
   向左对齐 <
   居中 ^
5. 十六进制x , X , #x, #X表示输出前面的格式符
6. 日期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=%dt' %(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)

最后

以上就是开朗小伙为你收集整理的（四）Python----字符串（连，分，排，替，删，查，判，格式化format）练习（算法-性能测试）一 . 字符串二. 返回值都为（新的字符串）三. format格式化字符串（建议）四. 练习如何测算性能datetime的全部内容，希望文章能够帮你解决（四）Python----字符串（连，分，排，替，删，查，判，格式化format）练习（算法-性能测试）一 . 字符串二. 返回值都为（新的字符串）三. format格式化字符串（建议）四. 练习如何测算性能datetime所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。