# ### day1
print("hello world")
print("ptthon5期唯一女生罗婷")
rujia_305="王文"
rujia_306="李四"
print(rujia_305)
import keyword
print(keyword.kwlist)
#a,b的交换
a=1
b=2
print(a,b)
a,b=b,a
print(a,b)
#通用写法
a=1
b=2
temp=a
a=b
b=temp
print(a,b)
#变量的命名
'''字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
变量命名有意义,且不能使用中文哦'''
# ###
# 二进制转换为10进制
# 从右到左,依次数位∑a*2^b 其中a为位数上的值,b为位数
# 从右到左,依次数位∑a*8^b 其中a为位数上的值,b为位数
# 从右到左,依次数位∑a*16^b 其中a为位数上的值,b为位数
#10进制转二进制，8进制，16进制
# 10%2 然后从下到上依次排列即可
# 10%16 然后从下岛上依次排列即可
# 206》》》》0xCE
#补码原码的转换
# 计算机底层用的是补码，正数的补码原码反码都一样
# 负数：补码=原码的反码+1
# 原码=补码的反码+1
# 复数的原码再原来的基础上 高位0变成1
'''
9-5
9的补码（原码）：0 0000 1001
-5的原码： 1 0000 0101
-5的原码的反码：1 1111 1010
-5的补码：1 1111 1011
9-5的补码：0 0000 0100
9-5的原码：0 0000 0100
4
1 001
2 010
3 011
4 100
5 101
6 110
7 111
8 1000
9 1001
a 1010
b 1011
c 1100
d 1101
e 1110
f 1111
'''
#python的6大类型数据
#Num(int,float,complex,bool)
intvar=152
print(intvar,type(intvar))
intvar=0b0100110
print(intvar,type(intvar))
intvar=0o1260
print(intvar,type(intvar))
intvar=0xFF
print(intvar,type(intvar))
floatvar=10e2
print(floatvar,type(floatvar))
floatvar=1.3606
print(floatvar,type(floatvar))
boolvar=True
print(boolvar,type(boolvar))
complexvar=4+5j
complevar=complex(4,5)
print(complevar)
#容器类型str
strvar="人生苦短,我用python"
print(strvar)
strvar='''古道西风瘦马
断肠人在天涯'''
print(strvar)
strvar="天苍苍,\n野茫茫,\n遍地黄花香,\n\r哈哈哈\t哈哈哈"
print(strvar)
strvar="天苍苍,也茫茫\r遍地黄花香"
print(strvar)
strvar="明月几时有'把酒问青天'"
print(strvar)
strvar="明月几时有,\"把酒问青天\""
print(strvar)
#转移字符,将有意义的字符变的无意义,将无意义的字符变的有意义
# \+某个字符
#\n表示换行
# \n\r表示换行
#\r表示将右边的字符提到行首,左边的字符被覆盖
# \t表示一个缩进(水平制表符)
#\加"" 可以打印出""
# 元字符串r+字符串(字符串内的转义字符失效)
strvar=r"天苍苍,\n野茫茫,\n遍地黄花香,\n\r哈哈哈\t哈哈哈"
print(strvar)
#字符串的格式化,其中%d表示整形,%f表示浮点型,%s表示字符串
# 其中f默认是小数点后6位
# %3d表示字符个数,默认靠右
# %-3d,默认靠左
# 如果%d给予一个浮点型,将直接取整
strvar="小黄转了%f的钱,准备买入%d斤的苹果,她%s"%(1.53,2,"高兴")
print(strvar)
strvar="小黄转了%f的钱,准备买入%d斤的苹果,她%s"%(2,1.53,"高兴")
print(strvar)
strvar="小黄转了%.1f的钱,准备买入%d斤的苹果,她%s"%(1.58,2,"高兴")
print(strvar)
strvar="小黄转了%f的钱,准备买入%3d斤的苹果,她%s"%(1.53,2,"高兴")
print(strvar)
strvar="小黄转了%f的钱,准备买入%-3d斤的苹果,她%s"%(1.53,2,"高兴")
print(strvar)
#list列表
#定义一个空列表[]
listvar=[1,2,3,4]
print(listvar[0])
listvar[1]="开心"
print(listvar)
length=len(listvar)
print(length)
#特征:可获取,可修改,有序
#tuple元组
#定义一个空元组:()
# 特征:可获取,不可修改,有序
tuplevar=(1,2,3,4)
# 元组的标致符号是,
print(tuplevar[2])
tuplevar=(1,2,3,4,[5,6,7])
tuplevar[-1][0]="开心"
print(tuplevar)
#字符串
#特征:可获取,不可修改,有序
strvar="很高兴见到你"
print(strvar)
#定义一个字符串''
#集合set
#定义一个空集合set()
setvar=set()
setvar={"开心",123,556}
print(setvar)
#特征:自动去重,无序
#字典
#键值对存储数据,看似有序,实际无序
#定义一个空字典{}
dictvar={"a":123,"b":456,"c":789}
print(dictvar)
print(dictvar["a"])
#哈希算法
#将任意长度的不可改变的数据通过算法变成固定长度的唯一值,这种算法叫做哈希算法,这个值叫做哈希值
#集合的元素,字典的键一定是可哈希
#特点:哈希存储数据的时候是一个随机存放的散列,存储速度快
#自动类型转换
#Number 精度从低到高 bool int float complex
res=True + 1
print(res)
res=True+4j+10
print(res)
#可哈希的数据:Number(int,float,complex,bool),string,tuple
#不可哈希的数据:dict,set,list
####强制类型转换
#number
var1=4
var2=1.9
var3=4e5
var4=4+5j
var5=True
var6="12315"
var7="asssacx61581"
'''int类型转化,其中int float bool 还有字符全为数字的字符串'''
res1=int(var2)
res2=int(var3)
# res3=int(var4) error
res4=int(var5)
res5=int(var6)
# res6=int(var7) error
print(res1,res2,res4,res5)
#float强行转换
'''float类型转换,其中int,float,bool,还有字符全为数字的字符串'''
res1=float(var1)
res2=float(var3)
res3=float(var5)
res4=float(var6)
print(res1,res2,res3,res4)
#complex转换
"""complex转换,能将所有数字类型及字符全为数字的字符串转换"""
res1=complex(var1)
res2=complex(var2)
res3=complex(var3)
res4=complex(var4)
res5=complex(var5)
res6=complex(var6)
print(res1,res2,res3,res4,res5,res6)
#bool类型转换
'''任何类型都可以转为bool,除以下十种外转换值都为True
0 '' 0.0 0j False [] () set() {} None'''
var1="今天天气好晴朗"
var2=["高兴","开心","悲伤"]
var3=("2","3","4")
var4={"天天","快乐","哈"}
var5={"上路":"牛头","上路":"sven","中路":"小y"}
#str
'''可以转换所有的数据
在原数据基础上外加上双引号'''
strvar1=str(var1)
strvar2=str(var2)
strvar3=str(var3)
strvar4=str(var4)
strvar5=str(var5)
print(repr(strvar1))
print(repr(strvar2))
print(repr(strvar3))
print(repr(strvar4))
print(repr(strvar5))
#listvar
'''只能容器类型数据强转
其中字符串类型,将每个字符都作为列表中的元素录入,并套上[]标识符转换'''
listvar1=list(var1)
listvar2=list(var2)
listvar3=list(var3)
listvar4=list(var4)
listvar5=list(var5)
print(listvar1,listvar2,listvar3,listvar4,listvar5)
'''字典类型强转列表,只保留键,并套上[]标识符转换
其余类型,在原有数据基础上,套上[]标识符转换'''
#tuple
tuplevar1=tuple(var1)
tuplevar2=tuple(var2)
tuplevar3=tuple(var3)
tuplevar4=tuple(var4)
tuplevar5=tuple(var5)
print(tuplevar1,tuplevar2,tuplevar3,tuplevar4,tuplevar5)
'''如果强转字符串类型,将字符串中的每个字符作为元组中的元素录入,并套上()标识符进行转换
字典类型转化,只保留键,并套上()标识符
其余类型,在元数据的基础上,套上()标识符'''
#set集合
set1=set(var1)
set2=set(var2)
set3=set(var3)
set4=set(var4)
set5=set(var5)
print(set1,set2,set3,set4,set5)
'''如果强转字符串类型,将字符串中的每个字符作为集合中的元素录入,并套上{}标识符进行转换
字典类型转化,只保留键,并套上{}标识符
其余类型,在元数据的基础上,套上{}标识符'''
#如果数据中含有不可哈希的数据,则不可以转换为集合
var=[1,2,3,4]
print(set(var))
# var=[1121,2,[3,4]]
# print(set(var)) error
#多级容器
#在原有容器类型数据的内部,其内部的元素还是容器类型数据(list,tuple,set,dict)
#二级列表
listvar=[1,2,3,4,[1,2,3]]
print([-1][0])
#二级元组
tuplevar=(1,2,3,4,(5,6,7,8))
print(tuplevar[-1][-1])
#二级集合
#里面只能存储元组
setvar={"开心",123,(1,2,3,4)}
print(setvar)
#二级字典
dictvar={"a":{1:"开心",2:"高兴"},"c":0}
print(dictvar["a"][2])
#等长的二级容器
#首先容器是两个,代表二级容器,容器元素的个数是一样的
res=[[1,2],[3,4],[5,6]]
print(dict(res))
#强转字典
'''(1)外面是列表,里面是列表,元组或字符串的二级容器
(2)外面是元组,里面是列表,元组或字符串的二级容器
(3)外面是集合,里面是元组,字符串而二级容器'''
#字符串的元素个数只能是两层,有局限,不推荐使用
#合集作为容器的元素,容易出现非预期的效果,不推荐使用
#变量的缓存机制
#-5~正无穷,值相同,地址相同
#float,非负数的浮点型,值相同,地址相同
#bool ,值相同,地址相同
#complex,除了纯虚数的情况,值相同,地址相同,其余情况地址都不同
#容器类型数据,字符串,值相同,地址相同
#空元组()地址相同
#其余容器类型数据,都不相同
# ####python运算符
#算数运算符:+ - * / // % **
print(4+3)
print(30-8)
print(30*6)
print(30//9)
print(30/9)
print(30%9)
print(2**3)
#7 22 180 3 3.333333 3 8
#比较运算符 > < = <= >= == !=
#返回值是True 或 False
#身份运算符
#is ,is not
var1=[1,2]
var2=[1,2]
print(var1 is var2)
print(var1==var2)
#is是判断地址是否相同,==判断值是否相同
#逻辑运算符
#and or not
#优先级 not> or >and
#逻辑短路
#True or 布尔值
#False and 布尔值
res=True and print(8)
print(res)
None
res=True or print(8)
print(res)
res=False and print(8)
print(res)
#porint默认返回一个None
# ###数据类型的判断isinstance
print(isinstance("hello world",str))
res=123456
print(isinstance(res,(str,list,set)))
#赋值运算符 = += -= /= //= %= **=
var1=15
var2=16
var1+=var2
var1=var1+var2
var1-=var2
var1=var1-var2
var1/=var2
var1=var1/var2
var1//=var2
var1=var1//var2
var1%=var2
var1=var1%var2
var1**=var2
var1=var1**var2
#成员运算符
#in not in
#如果是字符串,必须是连续的片段
strvar="窈窕淑女,君子好逑"
print("淑女"in strvar)
print("女君" in strvar)
strvar="1111天才"
print("111" in strvar)
setvar={"开心","高兴",1}
print(1 in setvar)
#如果是字典,只能识别键
dictvar={1:"asd",2:"dcsvart"}
print(1 in dictvar)
#位运算符 << >> & | ^ ~
#按位与&,在数字二进制中进行运算,全真为真,一假则假
var1=15
var2=10
res=var1&var2
print(res)
'''
15 0000 0000 1111
10 0000 0000 1010
0000 0000 1010
10
'''
#按位或| 在数字二进制中进行运算,全假则假,一真为真
va1=15
var2=10
res= var1|var2
print(res)
'''
15 0000 0000 1111
10 0000 0000 1010
0000 0000 1111
15
'''
#按位异或^ 在数字二进制中进行运算,相同为假,不同为真
var1=15
var2=10
res=var1^var2
print(res)
'''
15 0000 0000 1111
10 0000 0000 1010
0000 0000 0101
5
'''
#左移<< 在数字二进制中进行原酸,将二进制向左移动数字位
#在实际运算中a<<b 直接用a乘上2的b次幂
var1=10
res=var1<<2
print(res)
'''
10 0000 0000 1010
0000 0010 1000
40
'''
#右移>>在二进制中进行运算,将二进制向右移动数字位
#实际运算过程中a>>b 直接用a地板除2的b次幂
var1=10
res=var1>>2
print(res)
'''
10 0000 0000 1010
0000 0000 0010
2
'''
#按位非~ 在数字二进制的补码中操作,将二进制中的所有位数都取反
var1=-12
print(~(var1))
#可直接计算为-(n+1)
'''
-12的原码 1 0000 0000 1100
-12的反码 1 1111 1111 0011
-12的补码 1 1111 1111 0100
-12的按位非补码
0 0000 0000 1011
原码即为 0 0000 0000 1011
11
'''
#运算符的优先级
'''
()优先级最高\
**优先级其次
一般情况下一元运算符的要优先于二元运算符(not除外)
not>and>or
=的优先级最低
赋值运算符将右边的值算出后赋值于等号左边的值
算数运算符>比较运算符>位运算符>身份运算符>成员运算符>逻辑运算符'''
#小数据池
#-5~256的数字
#字符为1或0的字符串
#字符串只包含数字字幕下划线的字符串
#bool
#由乘积得到的字符串,如乘积为1都保留在小数据池,若大于1,为字母数字下划线,保留,但数位不能超过20
#指定驻留函数
from sys import intern
a=intern("天下为我独尊")
b=intern("天下为我独尊")
print(a is b)
#代码块;以冒号作为开始,用缩进来划分作用域,这个整体就叫做代码块
#其他语言用{}来表示
#注意空格和tab 的区别
####流程控制
# 流程:代码运行的过程
#流程控制:对代码运行的过程进行管控
'''
1,顺序结构
2,分支结构
3,循环结构'''
#单项分支
xujingxiong="爽"
if xujingxiong=="爽":
print("开心")
#多项分支
xujingxiong="爽"
if xujingxiong=="悲":
print("伤心")
else:
print("开心")
#input 等待用户输入字符串
'''
username=input("请输入用户名:")
pasword=input("请输入密码:")
if username=='admin' and pasword=='0000':
print("欢迎你")
else:
print("用户名或密码错误")
'''
#多项分支(elif只要一个条件满足,剩下的就不执行了)
youqian=False
youche=False
youfang=False
youyanzhi=False
if youqian == True:
print("xxxx1")
elif youche==True:
print('xxxx2')
elif youfang==True:
print("xxxx3")
elif youyanzhi==True:
print("XXXX4")
else:
print("滚")
#巢状分支(单项,多项,嵌套执行)
youqian=True
youche=False
youfang=False
youyanzhi=False
if youqian==True:
if youche==True:
if youyanzhi==True:
if youfang==True:
print("来来来")
else:
print("滚4")
else:
print("滚3")
else:
print("滚2")
else:
"滚"
#循环结构while for
'''基本语法
while 条件:
code1
code2
'''
#打印1~100
i=1
while i<=100:
print(i)
i+=1
#1~100的累加和
i=1
total=0
while i<=100:
total+=i
i+=1
print(total)
#死循环写法
i=1
total=0
flag=True
while flag:
total+=i
i+=1
if i ==101:
flag =False
print(total)
#打印一行10个小星星
i=0
while i<10:
print("*",end="")
i+=1
#字符串的相关操作:
#字符串的拼接
str1="我是"
str2='天才'
res=str1+str2
print(res)
#字符串的重复
str1="天才"
res=str1*10
print(res)
#字符串的跨行拼接
strvar="xxxxxxxxxxxx"\
"151051815115"\
"hello world"
print(strvar)
#字符串的索引
strvar="我是天天和你在一起"
res=strvar[4]
print(res)
#字符串的切片:切片就是截取
#语法[:: ]截取的开始,截取的结束,截取的间隔值
#其中结束值是取不到的
strvar="我想你在365的夜,希望能和你在一起,开开心心"
res=strvar[::]
print(res)
res=strvar[:]
print(res)
res=strvar[1:]
print(res)
res=strvar[:9]
print(res)
res=strvar[:9:3]
print(res)
res=strvar[-7:-1]
print(res)
print("<=================================================>")
res=strvar[-1:1:-1]
print(res)
res=strvar[::-1]
print(res)
#如果是倒叙,即步长为负,则前面开头的顺序一定是数数的顺序,先数的在前,后数的在end
'''
3出题 height
#女生找对象
# 男生在1米~1.5米之间 小强 你在哪里?
# 男生在1.5~1.7米之间 没有安全感~
# 男生 1.7~ 1.8米之间 帅哥 留个电话
# 男生 1.8~2米之间 帅哥 你建议多一个女朋友吗
#python特有的写法
high=float(input("请输入你的身高:"))
if 1<=high<1.5:
print("小强,你在哪里")
elif 1.5<=high<1.7:
print("没有安全感")
else:
print("滚")
#通用写法
high = float(input("请输入你的身高:"))
if 1 <= high and high< 1.5:
print("小强,你在哪里")
elif 1.5 <= high and high< 1.7:
print("没有安全感")
else:
print("滚")
'''
#用一行变量打印出一行十个小星星
i=0
while i<10:
print("*",end="")
i+=1
i=0
total=""
while i<10:
total+="*"
i+=1
print(total)
# 3.打印一行十个小星星 奇数个打印★ 偶数个打印☆
'''任意数m%n,余数范围0~(n-1)'''
i=0
while i <10:
if i%2==0:
print("☆",end="")
else:
print("★",end="")
i+=1
# 4.一个循环 打印十行十列小星星\
#单循环
i=0
while i <100:
print("*",end="")
if i%10==9:
print()
i+=1
#双循环
i=0
while i<10:
j=0
while j<10:
print("*",end='')
j+=1
print()
i+=1
# 5.一个循环 打印十行十列隔列变色小星星
#单循环
i=0
while i <100:
if i % 2 == 0:
print("☆", end="")
else:
print("★", end="")
if i%10==9:
print()
i+=1
#双循环:
i=0
while i<10:
j=0
while j<10:
if j%2==0:
print("☆", end="")
else:
print("★", end="")
j+=1
print()
i+=1
# 6.一个循环 打印十行十列隔行变色小星星
#单循环
i=0
while i <100:
if i//10%2 == 0:
print("☆", end="")
else:
print("★", end="")
if i%10==9:
print()
i+=1
#双循环:
i=0
while i<10:
j=0
while j<10:
if i%2==0:
print("☆", end="")
else:
print("★", end="")
j+=1
print()
i+=1
# 7.用户登陆（三次输错机会）且每次输错误时显示剩余错误次数
# （提示：字符串格式化）
'''
times=3
while times:
pasw=input("请输入密码:")
if pasw=="0000":
print("欢迎你")
break
else:
if times==1:
print("账户已被冻结")
break
print("你输入的密码有误,还可输入%d次"%(times-1))
times-=1
'''
#关键字的使用
#pass
if 5 ==5:
pass
i=0
while i<10:
pass
i+=1
#break终止当前循环(只能用在循环中)
'''打印1~10,如果遇到5中止'''
i=1
while i<=10:
print(i)
if i ==5:
break
i+=1
#break终止的是当前循环
i=1
while i<3:
j=1
while j<=3:
if j==3:
break
print(i,j)
j+=1
i+=1
#(1,1),(1,2),(2,1),(2,2)
#continue 跳过当前循环,从下一次循环开始
# 打印1~10 不打印5
i=0
while i <10:
if i ==5:
i+=1
continue
print(i)
i += 1
# 打印1~100 所有不含有4的数字
#方法一
i=1
while i<=100:
strvar=str(i)
if "4" not in strvar:
print(i)
i+=1
#方法二
i=1
while i <=100:
shiwei=i//10
gewei=i%10
if shiwei!=4 and gewei!=4:
print(i)
i+=1
# ###for循环
#循环,遍历,迭代
#把列表里面的元素一一拿出来就是遍历
listvar=["开心","高兴","伤心"]
#用len来遍历
lenth=len(listvar)
i=0
while i<lenth:
print(listvar[i])
i+=1
#while循环局限性在于,不能遍历集合这样的数据类型
#for循环特指用来遍历
#for 的语法 for...in...
#代码解析;将容器类型数据的每一个元素,依次的拿出来赋值给变量,直到所有数据依次遍历后终止,跳出循环
#遍历字典的时候,遍历的是键
container="我爱你亲爱的的姑娘,见到你我就心慌"
for i in container:
print(i)
#字符串是将每一个字符进行单独遍历
#编列等长的二级容器
listvar=[[1,2],[3,4],[5,6]]
for x,y in listvar:
print(x)
print(y)
#变量的解包
#range对象
'''
语法
range(start,end,step)
使用方式像是,高位的end取不到'''
#一个参数情况
for i in range(5):
print(i)
#默认从0开始
#两个参数
for i in range(3,10):
print(i)
#三个参数:
for i in range(3,10,2):
print(i)
#打印9~1
for i in range(9,0,-1):
print(i)
# ###字符串相关函数(函数就是方法的意思,完成某个功能)
'''语法:字符串.函数'''
#capitalize
strvar="one world one dream"
res=strvar.capitalize()
print(res)
#title将每个字母的字母大写(非字母就可以 让后面的字母字符串大写)
strvar="oneworld one---dream"
print(strvar.title())
#upper将所有字母大写
strvar="one world one dream"
res=strvar.title()
print(res)
#lower将所有字母小写
print(res)
print(res.lower())
#swapcase大小写互换
strvar="sacmiamreASACMIR"
print(strvar.swapcase())
#len计算字符串的长度
#count计算某个元素在字符串中出现的数量
strvar="案件哈时间啊曹鹏模拟题你不觉得是你觉得烦哈哈回复"
print(strvar.count("哈"))
#find 查找某个元素第一次出现的索引,找不到返回-1
'''find("元素",start,end),高位取不到end'''
strvar="are u happy"
res=strvar.find('h')
print(res)
res2=strvar.find("h",0,5)
print(res2)
res3=strvar.find("h",-6,-1)
print(res3)
#find只接受从左到右的顺序
#index用法和find相同,但index如果没有查找到就是报错
#startswith 返回True or False
'''表村是否以某个字符或字符串的为开头'''
strvar="天天开心日日快乐"
res=strvar.startswith("天")
print(res)
'''startswith("字符",starts,end)高位取不到'''
#endswith以某个字符串或者字符皆为
strvar="天天开心日日快乐"
res=strvar.endswith("乐")
print(res)
#isalpha判断字符串是否由字母或者文字组成
strvar="哈哈哈哈123505xxx"
print(strvar.isalpha())
strvar="哈哈哈哈xxx"
print(strvar.isalpha())
#isalnum判断字符串是否由数字字母汉字组成
strvar="哈哈哈哈123505xxx"
print(strvar.isalnum())
#isdigit判断字符串是否完全由数字组成,可以接受二进制字节流
strvar="15050600"
print(strvar.isdigit())
strvar=b"1223150"
print(strvar.isdigit())
strvar=b"asdfa"
print(strvar.isdigit())
#isdecimal判断字符串是否由数字组成,不能接受二进制字节流
strvar="15050600"
print(strvar.isdecimal())
# strvar=b"1223150"
# print(strvar.isdecimal()) error
#split将字符串分割为列表(默认是空格)
strvar="开心高兴快乐"
res=strvar.split()
print(res)
strvar="开心 高兴 快乐"
res=strvar.split()
print(res)
strvar="开心.高兴.快乐"
res=strvar.split(".")
print(res)
strvar="开心.高兴.快乐"
res=strvar.split(".",1)
print(res)
#split从左往右数 rsplit是从右往左数
strvar="开心.高兴.快乐"
res=strvar.rsplit(".",1)
print(res)
#join 将容器类型数据拼接为字符串
listvar=["开心","高兴","完美",'',""]
res="".join(listvar)
print(res)
listvar=["开心","高兴","完美",'',""]
res="+".join(listvar)
print(res)
dictvar={"a":"天才","b":"儿童"}
res="+".join(dictvar)
print(res)
#字典使用join时,只提取键
#center填充字符,原字符默认居中(默认填充空格)
'''原字符个数+要填充的字符一共多少个'''
strvar="哈哈哈"
print(strvar.center(10,"*"))
#数在前,填充的字符在后
#strip 默认去掉首位两边的空白符
strvar=" 周杰伦 "
res=strvar.strip()
print(res)
#rstrip 去掉右边的字符
#lstrip 去掉左边的字符
strvar="aaxxxaaaaaaaaaaa15505bbbbbbsssbbbb"
print(strvar.lstrip("aa"))
print(strvar.rstrip("bb"))
#replace() 将某个元素替换为另一个元素(可选择替换几次)
strvar="可爱的小狼狗,喜欢吃肉肉,有么有,有没有,还有没有"
res=strvar.replace("有没有","别啊",1)
print(res)
# ###字符串的格式化 format
# (1)顺序占位
strvar="{}给{}踹了一脚".format("xjxj","yx")
print(strvar)
#索引占位
strvar="{1}向{0}开了一枪".format("xjxjxx","yx")
print(strvar)
#关键字占位
strvar="{凶手}向{受害人}开了一枪".format(凶手="天才",受害人="智障")
print(strvar)
#容器类型传参
strvar="{1[1]}向{0[2]}开了一枪".format(["天才","智障","王牌","间谍"],[12315,150505])
print(strvar)
#如果是字典,场景发生在format字符串格式化中,通过键取值,不要加上引号
strvar="{0[凶手]}向{0[受害者]}开了一枪".format({"凶手":"天才","受害者":"智障"})
print(strvar)
# ###format填充符号与格式化
# (5)format填充符号的使用
strvar="{who:*^10}今天买了香蕉".format(who="王朝")
print(strvar)
'''格式{who:*>10}'''
strvar="{who:*^10}在这个城市的{where:*>20}能够开心的{what:*<10}"
res=strvar.format(who="王朝",where="上层",what="生活")
print(res)
#进制转换等特殊符号的使用(:d :f :s :,)
#:d整形占位符
strvar="徐小姐买了{:d}双鞋"
res=strvar.format(16)
print(res)
strvar="徐小姐买了{:7d}双鞋"
res=strvar.format(16)
print(res)
strvar="徐小姐买了{:<7d}双鞋"
res=strvar.format(16)
print(res)
strvar="徐小姐买了{:^7d}双鞋"
res=strvar.format(16)
print(res)
#f浮点型占位符
strvar="xjx的体重是{:.2f}"
res=strvar.format(120.529502)
print(res)
#s字符串占位符
strvar="{:s}"
res=strvar.format("1235")
print(res)
#金钱占位符
strvar="{:,}"
print(strvar.format(1505602))
