2017-7-28总结

s="hello {1} gg{0}"
print(s)
print(s.format("zz",333))
#在这里{0}相当于占位符，通过format函数从数字零开始替换而且若想要替换就必须
有{0}作为开始，而且下一个数必须是{1}（连续的），位置没什么要求，先从0依次
向1，2,3(按数字排列顺序替换)，如果占位符多余format后的参数就会报错，如果参数
多于占位符就不报错

a="jjfjjmldhzf"
print(a.index("f")) #找到a这个字符串中的第一个f的位置 在这里是2
print(a.find("j"))
print(a.find("a"))#如果没有找到就返回-1
print(a.index("a"))#index的用法和find基本相同但是index没有找到相应的关键字就
会报错

 

源码里如果显示仅显示self就是不用传入参数
如果除了self之外还有别的参数就是可以传参数
如果参数有默认值就可以不用传那个参数
没有默认值的就必须传参数

aa="8a8a8a"
print(aa.isalpha())#F
aa="aaa"
print(aa.isalpha())#T
aa="111"
print(aa.isalpha())#F
#判断字符串是否为字母

lj="666"
print(lj.isdigit())#T
lj="5s55s"
print(lj.isdigit())#F
lj="aaa"
print(lj.isdigit()#F
#判断是否为数字

 

lj="sdfasdfsd"
print(lj.islower())#T
lj="Ssss"
print(lj.islower())#F
lj="555555"
print(lj.islower())#F
#判断是否全为小写字母

 

lj="sdfasdfsd"
print(lj.isalnum())#T
lj="Ssss"
print(lj.isalnum())#T
lj="555555"
print(lj.isalnum())#T
lj="!aaa"
print(lj.isalnum())#F
#判断字符串是否只包含字母和数字

lj=" "
print(lj.isspace())#T
lj="Ssss"
print(lj.isspace())#F
lj="\t"
print(lj.isspace())#T
lj="\n"
print(lj.isspace())#T
#判断字符串是否为空格

 

 

lj="Sss Aaa "
print(lj.istitle())#T
lj="Ssss"
print(lj.istitle())#T
lj="Ass sssss"
print(lj.istitle())#F
lj="ssss"
print(lj.istitle())#F
#判断是否为标题（判断字符串里的单词的开头子母手否为大写）
aa=" the school"
print(aa.title())#将不是标题的变成标题（单词开头小写变大写）

 

lj="Sss Aaa "
print(lj.isupper())#F
lj="Ssss"
print(lj.isupper())#F
lj="SSSSS"
print(lj.isupper())#T
lj="ssss"
print(lj.isupper())#F
#检验字符串是否全部为大写

lj="SSSSS"
print(lj.lower())#将字符串全部变成大写
lj="ssss"
print(lj.upper())#将字符串全部变成小写

 

li=["haohao","xuexi","tiantianxiangshang"]
print("".join(li))
li=["haohao","xuexi","tiantianxiangshang"]
print("_".join(li))
li=["haohao","xuexi","tiantianxiangshang"]
print("****".join(li))
li=("haohao","xuexi","tiantianxiangshang")
print("****".join(li))
#迭代的链接连个字符串可定义字符串链接时中间的连接符（上述的是列表和元组的示例）

 

le="jjj"
print(le.ljust(10,"*"))
#内容左对齐，右侧填充*（）自定义宽度和填充符号

 

ls=" ssss "
print(ls.lstrip())#移除左侧空白
print(ls.rstrip())#移除右侧空白
print(ls.strip())#移除全部空白，除了字符串之间的空白

 

ls="sss ssss sssss"
print(ls.partition("sss"))
ls="sss ssss sss"
print(ls.partition("ssss"))
ls="sss ssss sss"
print(ls.partition("sss"))
ls="sssss ssss sss"
print(ls.partition("sss"))
结果
('', 'sss', ' ssss sssss')
('sss ', 'ssss', ' sss')
('', 'sss', ' ssss sss')
('', 'sss', 'ss ssss sss')
#用来分割字符串，将partition（）括号看里的作为中间的，在它前面的为前一部分
后面的为后一部分，最后输出时输出一个（元组？），括号里面的为从字符串最开始（左）检索到
的匹配的字符，详细就看上面的答案

 

aa="alex and alenten"
print(aa.replace("al","66"，1))
#检索字符串找到相同的字符串替换括号里前面的那个为被替换的字符，后面的那
个为替换字符，那个数字1为从左往右替换几个，不写就全部替换

aa="alex and alenten"
print(aa.rfind("al"))#同find只不过改为从右向左检索

rjust#内容右对齐，左侧填充*（）自定义宽度和填充符号
rindex#找到a这个字符串中的第一个f的位置 从右向左检索
rpatition#从右检索....

aa="alex and alenten"
print(aa.split("al"))
aa="alexandalenten"
print(aa.split("e"))
#检索到规定字符删除并在那个地方进行分割，在这是检索字符串里的每一个而
不是第一个，如果只需对第一个进行分割，只需在自己所规定的检索字符串后加上一个
1（最多分割1次）
#rsplit从右向左检索

 

aa="aa\nsdf\nasd"
print(aa.splitlines())#根据换行符进行分割

 

aa=" a sdf "
print(aa.strip())#移除两边空白

 

aa=" a sdf AAA"
print(aa.swapcase())#小写变大写大写变小写

upper变大写

字符串切片
s="asdfs"
print(s[0:2])
#留下序号为0，1的字符（0<=x<2)

s="alex"
start=0
while start<len(s):
print(s[start])
start+=1
while循环输出字符串

s="alex"
for i in s:
print(i)
for循环输出字符串

name_list=["alex","brain","rain"]
#索引
print(name_list[0])#输出第一个字符串
#切片
print(name_list[0:2])#输出序号为0，1的字符串
#len
print(name_list[2:len(name_list)])#在这里是输出序号为2的字符串
#for
for i in name_list: #循环输出字符串
print(i)
结果
alex
['alex', 'brain']
['rain']
alex
brain
rain

list类型功能
apend追加
name=["asdf","asdfsdf","sssdfs"]
name.append("lslslslsl")
print(name)
#在最后追加一个字符串

 

count
name=["asdf","asdfsdf","sssdfs"]
print(name.count("asdf"))
统计匹配的字符串有多少个，最小匹配单位为一个字符串不是字符

 

extend
name=["asdf","asdfsdf","sssdfs"]
name.append("lslslslsl")
print(name)
print(name.count("asdf"))
kali=[111,555,999]
name.extend(kali)#扩充，将kali里的元素（迭代的？）添加到name中
print(name)#结果['asdf', 'asdfsdf', 'sssdfs', 'lslslslsl', 111, 555, 999]

index
name=["asdf","asdfsdf","sssdfs"]
print(name.index("sssdfs"))
#获取字符串的索引（序号）

insert
name=["asdf","asdfsdf","sssdfs"]
print(name.index("sssdfs"))
name.insert(name.index("asdf"),"aaa")
print(name)
name.insert(2,"aaa")
print(name)
#在相应索引号（序号）插入字符串，序号在前，字符串在后name.index（1，“aaa”）

 

pop
name=["asdf","asdfsdf","sssdfs"]
ai=name.pop(0)
print(name)
print(ai)
ai=name.pop()
print(name)
print(ai)
#移除相应序号的字符串，如果不加序号就移除最后1个字符串，而且在执行移除命令时
还可以把移除的字符串赋值给别的变量

 

remove
name=["asdf","asdfsdf","sssdfs"]
name.remove("asdf")
print(name)
#移除左边开始第一个匹配的字符串（一个）

 

reverse
name=["asdf","asdfsdf","sssdfs"]
name.reverse()
print(name)
#对当前字符串进行倒置，反转

del
name=["asdf","asdfsdf","sssdfs"]
del name[1]
print(name)
#删除指定索引（序号）的字符串

name=["asdf","asdfsdf","sssdfs"]
del name[2:3]
print(name)
#删除指定索引（序号）范围内的字符串在这是删除的是序号为2的字符串

 

#元组
name_sss=("liudi","balabala","bulabula")
#索引输出
print(name_sss[0])
#len
print(name_sss[len(name_sss)-1])
#切片
print(name_sss[0:1])查看序号为0（0<=x<1）的内容
#for
for i in name_sss:
print(i)
#元组不可以删除、修改只可查看
#元组可以使用的命令有count和index

 

 

字典
#字典无切片
#字典的每一个元素就是一个键值对，在字典里值的索引为键
user={"name":"zz","age":99,"brain":0}
print(user["name"])
#这里的name就 相当于列表里的索引（序号），不过这个序号是自己定义的

for循环
user={"name":"zz","age":99,"brain":0}
for i in user
print(i)
#字典中通过for这种形式输出的是key（键）

user={"name":"zz","age":99,"brain":0}
print(user.keys())#获取user的key输出
print(user.values())#获取user的键的值输出
print(user) #输出user的内容
print(user.items())#获取user的键值对输出
for i in user.keys():#for循环输出键（key）和上面的那个for基本一样功能
print(i)
for i in user.values():#for循环输出值（values）
print(i)
for i in user.items():#for循环输出键值对带括号（格式和和上面的键、值的输出
不同）
for i,k in user.items():#输出键和值没有带括号
print(i,k)
for i,k in user.items():输出键和值没有带括号，分行输出键和值
print(i)
print(k)

user.clear()
print(user)清除内容

get
跟根据key获取值，如果key不存在，可以指定一个默认值（None？）
val=user.get("age")
print(val)
val=user.get("age11")
print(val)
使用索引取值是如果key不存在就报错
print(user["age"])

val=user.get("age")
print(val)
val=user.get("age11",99)#如果不存在在后面加上值就可以赋值给值
print(val)
val=user.get("age11","ooo")#如果不存在在后面加上值就可以赋值给值
print(val)
print(val)

has key 检查字典中指定key是否存在（py2中有3中无）
可以用这个代替
user={"name":"zz","age":99,"brain":0}
ret="name" in user.keys()
print(ret)
ret="names" in user.keys()
print(ret)

 

pop
user={"name":"zz","age":99,"brain":0}
print(user.pop("name"))#输出所删除的字符
print(user)#输出字典
结果如下
zz
{'age': 99, 'brain': 0}

popitem
user={"name":"zz","age":99,"brain":0}
print(user.popitem())#输出所删除的字符（无参数就从最后一个参数开始删除）
print(user)#输出字典的内容

update
user={"name":"zz","age":99,"brain":0}
print(user)
item={"a1":123,"a2":456}
user.update(item)#将item的字典更新（链接到user后面）
print(user)

 

items
user={"name":"zz","age":99,"brain":0}
print(user.items())#所有项列表形式输出

 

del
user={"name":"zz","age":99,"brain":0}
del user["name"]#删除指定索引键值对
print(user)