python 3

字符串str操作方法

#capitalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
print（name.upper()) #全大写
print（name.lower()) #全小写
msg='egon say hi'   
print(msg.title()) #每个单词的首字母大写，中间有空格或特殊字符隔开都能识别不同单词。
#如不区分大小写：
s = 'acSR'
you_input = input('请输入验证码，不区分大小写:')
if s.upper() == you_input.upper():     #或同小写均可
    print('输入成功')
else:
    print('请重新输入')


# 内同居中，字符串总长度，空白处填充
s=' nujkdm '
s1= s.center(20,"*")  
print(s1)

#数字符串中的元素出现的个数。
# s2 = s.count("a",0,4) # 可切片
# print(s2)

s='alse你好'
I=lens(s)    #公共方法
print(I)      #6

s = "hqw	"
#	前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
s3 = s.expandtabs()
print(s3)

s = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
s4 = s.endswith('jdk',3,6)  #区间范围， 顾头不顾尾，左包右不包。 索引为0-10等等，0，1，2...
 print(s4)  # 返回的是布尔值
s5 = s.startswith("kfj",1,4)
 print(s5)

#寻找字符串中的元素是否存在，即找元素的索引
 s6 =s.find("fjdk",1,6)
print(s6)  # 返回的找到的元素的索引，如果找不到返回-1

 s61 = s.index("fjdk",4,6)    #index同find
print(s61) # 返回的找到的元素的索引，找不到报错。


#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。一分为二
s = 'title,Tilte,atre,'.split('t')
print(s)              #['', 'i', 'le,Til', 'e,a', 're,']
s1 = 'title,Tilte,atre,'.rsplit('t',1)
print(s1)            #['title,Tilte,a', 're,']


#format的三种玩法 格式化输出(对比%s,%d）
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age}{sex}'.format(sex='male',name='egon',age=18)

#strip字符串删除前后空格，可用于用户输入，lstrip从左删，右不动。
name='*egon**'
print(name.strip('*'))    #egon
print(name.lstrip('*'))     #egon**
print(name.rstrip('*'))     #*egon

#count数元素个数
s='gvhbjn bhj'
s1=s.count('h')
print(s1)          #2

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))     #（老，新，第几个）

#####is系列
name='jinlin123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成

字符串的索引和切片

索引即下标，就是字符串组成的元素从第一个开始，初始索引为 0 以此类推。

a = 'ABCDEFGHIJK'
print(a[0])   #A
print(a[3])   #D

切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。

a = 'ABCDEFGHIJK'
print(a[0:3])      #ABC(取不到3）
print(a[2:5])      #CDE
print(a[0:])同print(a[:]) #默认到最后 #ABCDEFGHIJK
print(a[0:-1]) #-1就是最后一个 #ABCDEFGHIJ
print(a[0:5:2]) #加步长      #ACE
print(a[5:0:-2]) #反向加步长  #FDB
print(a[3:0:-1])    #DCB
print(a[3::-1])    #DCBA
print(a[-1::-1])   #KJIHGFEDCBA

左闭右开，注意反向的也是。凡是到这取都是负的。

for循环

for循环为有限循环，while为无限循环

s='sdf‘' for i in s: #有引号为字符串，无引号为变量。固定用法for..in..
print(i)        #s d f(三行）

s='sdc苍井空fsdf'

if '苍井空' in s:

　　print('您的评论有敏感词')

ps:#数据类型转换

int——>str

i=123

s=str(i) #或者直接加引号str——>int

i='123'

s=int(s) #只可以数字，否则会报错

int——>bool

i=2

s=bool(i) #只要是0就是False,非零就是True

bool——>int        #True——>1,False——>0

#while 1: 比while True:效率高。

str——>bool

s='' ——>False

s='0' ——>True #非空字符都是True

列表list

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，而且列表是有序的，有索引值，可切片，方便取值。

增：三种方法——append增加到最后；insert按索引增加插入；extend迭代地增加

li=['bree',123,True,('haer','gogo')]
li.append('may')
print (li)           #['bree', 123, True, ('haer', 'gogo'), 'may']
li.insert(1,"cat")  #cat要加引号，不然会报错，也可以其他数据类型
print(li)            #['bree', 'cat', 123, True, ('haer', 'gogo'), 'may']
li.extend(["a,b,c"]) #可以是一个列表，列表则不会拆开
print(li)             #['bree', 'cat', 123, True, ('haer', 'gogo'), 'may', 'a,b,c']
li.extend(["a,b,c","122"])
print(li)      #['bree', 'cat', 123, True, ('haer', 'gogo'), 'may', 'a,b,c', 'a,b,c', '122']
li.extend("a,b")
print(li) #['bree', 'cat', 123, True, ('haer', 'gogo'), 'may', 'a,b,c', 'a,b,c', '122', 'a', ',', 'b']
li.extend("aa")
print(li)#['bree', 'cat', 123, True, ('haer', 'gogo'), 'may', 'a,b,c', 'a,b,c', '122', 'a', ',', 'b', 'a', 'a']

 删：

li=['bree',123,True,('haer','gogo')]
l1 = li.pop(1) #按照位置去删除，有返回值
print(l1)     #123

del li[1:3] #按照位置去删除，也可切片删除没有返回值。
    print(li)  #['bree', ('haer', 'gogo')]

li.remove(123) #按照元素去删除，比如123为int，不能加引号
    print(li)  #['bree', True, ('haer', 'gogo')]

li.clear() #清空列表

 改：

li = [1,'a','b',2,3,'a']
li[1] = 'go'
print(li)  #[1,'go','b',2,3,'a']
li[1:3] = ['go']
print(li)  #[1,'g','o',2,3,'a']
li[1:3] = ['gogo']  #嵌套改，先删了原对应位置的，然后又多少补多少
print(li)   #【1,'g','o','g','o',2,3,'a']

 查：

li=['bree',123,True,('haer','gogo')]
for i in  li:
    print(i)  #查了每一个元素  #bree，123，True，('haer', 'gogo')
print(li[0:2])  #切片查，查出的是一个列表  #['bree', 123]  切片顾头不顾尾

公共方法：

li=['bree',123,True,('haer','gogo')]
l=len(li)
print(l)    #4  ,计算列表长度
num=li.count("bree")
print(num)    #1  ，计算元素出现的个数
#索引，列表中只有index，字符串有index和find
print(li.index('bree'))  #0
#排序
li=[1,5,2,6,4]
li.sort()   #正向排序
print(li)  #[1, 2, 4, 5, 6]
li.sort(reverse=True)  #反向排序
print(li)   #[6, 5, 4, 2, 1]
li=[1,5,2,6,4]
li.reverse()  #列表反转（无序）
print(li)  #[4, 6, 2, 5, 1]

 列表的嵌套

#要对某个元素操作，先索引，在赋值
li=['sdf','你好','ab',[123,'qwe']]
print(li[1][1])   #好
li[0]=li[0].capitalize()
print(li[0])      #Sdf
#替换
li[2]='abc'
print(li)     #['Sdf', '你好', 'abc', [123, 'qwe']]
li[2].replace('b','bc')
print(li)     #['Sdf', '你好', 'abc', [123, 'qwe']]
li[0]=li[0].upper()
print(li)      #['SDF', '你好', 'abc', [123, 'qwe']]

元祖tuple：只读列表，可循环查询，可切片。#儿子不能改，孙子可能可以改

所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

 

#要对某个元素操作，先索引，在赋值
tu=['sdf','你好','ab',[123,'qwe']]
print(tu[2])  #ab
print(tu[0:3])  #['sdf', '你好', 'ab']
for i in tu:
    print(i)   
#sdf
你好
ab
[123, 'qwe']

join（列表转换成字符串的形式）list——>str

s='bree'
s1='_'.join(s)
print(s1)     #b_r_e_e
li=['sdf','你好','ab']
s=''.join(li)
print(s)    #sdf你好ab(无缝对接）

str——>list     split

range(数字按顺序排列）

for i in range(1:4) 

print(i)      #1,2,3(竖着写）

for i in range(10) (从0到9，顾头不顾腚）

for in range（0,10,2）（3为步长）

print（i）

for in range（10,0,-1）（到着写）#不可以（0,10，-1）

print（i）

li=[1,2,3,'bree',[1,2,3,'gogo'],'kris']#循环打印这个列表

不可变数据类型：元祖，bool， int，str    可哈希

可变数据类型：list，dict，set        不可哈希

字典dict

Python中唯一一个映射采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。不可变数据类型。

value:任意数据类型

dict优点：二分查找去查询

存储大量的关系型数据

特点：无序的，无索引（Python3.6及以上是有序的）

dic1={'age': 18, 'name': 'jin', 'sex': 'male',}
#增
dic1['high']=185  #没有键值对，添加
print(dic1)
dic1['age']=16  #如果有键，则值覆盖
print(dic1)
dic1.setdefault('weight')#没写则默认值，None，不是none。
pint(dic1)   #{'high': 185, 'weight': None, 'age': 16, 'sex': 'male', 'name': 'jin'}r
dic1.setdefault('weight',120) 
print(dic1)  #{'age': 16, 'sex': 'male', 'high': 185, 'weight': 120, 'name': 'jin'}

 #删
print(dic1.pop('age')) #有返回值，按键去删除  #18
print (dic1.pop('bree',None))  #可设置返回值。有的话直接删，没有的话返回值。  #None
print(dic1.popitem()) #py3.5随机删除，无意义,py3.6默认删最后一个。有返回值，以元祖的形式 #('sex', 'male')
dic.clear()  #清空字典
del.dic1  #删除整个字典


#改：（覆盖也是改）
dic={'age': 18, 'name': 'jin', 'sex': 'male',}
dic1={'age': 16, 'name': 'bree', 'weight': 120,}
dic1.update(dic)
print (dic)  #{'age': 18, 'sex': 'male', 'name': 'jin'}
print(dic1)  #{'age': 18, 'weight': 120, 'sex': 'male', 'name': 'jin'}  #将dic更新到dic1，有则覆盖改，无则添加

#查：
dic1={'age': 18, 'name': 'jin', 'sex': 'male',}
print(dic1.keys(),type(dic1.keys())) #dict_keys(['sex', 'name', 'age']) <class 'dict_keys'>  #键
print(dic1.values()) #dict_values(['male', 'jin', 18])  #值
print(dic1.items())  #dict_items([('sex', 'male'), ('name', 'jin'), ('age', 18)])元祖，对应的是键值对，元祖以逗号隔开

for i in dic1:
    print(i)  #name,age,sex(什么都不写，默认打印键，分三行出结果。
a,b=1,2
print(a,b)  #1 2
a,b=b,a
print(a,b)  #用一行代码交换a,b值

for k,v in dic1.items():
    print(k,v)
v1=dic1['name']
print(v1)  #jin
v2=dic1['name1']
print(v2)  #无name2，报错
print(dic1.get('name1'))  #None
print(dic1.get('name1','没有这个键')) #没有这个键