s = "abC"
upper,lower
print(s.upper())      实现字符串全部大写
print(s.lower())      实现字符串全部小写
replace      替换
     a = "abacad"
     print(a.replace("a""中国"))
     print(a.replace("a""中国",2))    2 表示个数
capitalize,
      首字母大写,其余字母小写
swapcase, #大小写翻转
  
strip
     去掉开头和结尾的空格,特定的字符
     print(a.strip())
          a = "&&a&bc&&"
          print(a.strip("&"))
startswith,endswith
结果是bool 值  ,支持切片
     print(s.startswith("a"))     判断以。。。开头
     print(s.endswith("a"))      判断以。。。结尾
     print(s.startswith("a",1,4))   切片部分判断
 公共方法:
     count()
          s = "abac"
          print(s.count("a")   )       # a 元素出现的次数
     len()      print(len(s))           对象的长度
split        str --->list
 str分割为列表,默认以空格分割
     s.split()    默认空格
     s.split("符号")
join       list ---->str

     列表里面元素用指定符号进行连接

     形式:”分隔符“.join(list)

find
     返回找到的元素的索引,如果找不到返回-1

index
      返回找到的元素的索引,如果找不到报错

列表的方法:

创建列表的方法

a = ["a",123,"abc",[123]]   #直接创建   常用
 
   b = list("abc")     #list
 
str,list   序列   ,有顺序,支持索引,切片
 增:


append  
    加到列表的最后面
insert    
    插入    第一个参数是插入的索引位置,第二个参数要添加的值
extend  
    迭代着追加元素    ,添加的对象要是可迭代对象,把组成迭代对
象的最小元素迭代追加到后面
 删:

pop         
按索引删,有返回值
remove 
按元素删
clear      
清空整个列表
del    
按索引,按切片,可加步长
del    li[2] , del    li[2:4]    , del li[2:4:2]
   改:

按索引    改单个值
按切片 改多个值
   查:


按索引
按切片
for 循环
 列表的常用方法:

len()          测序列的长度
count()     测序列中值的数量
index()      通过元素找索引
sort()          实现序列排序,默认升序
sort(reverse=True)   加参数reverse,可以实现降序
reverse()      序列反转
  字典的方法:



keys()           所有键
values()       所有值
items()         所有键值对  ,元组形式
for I in dic.keys():
       Print(i)   #得到的是所有的键      str
for I in dic.values():
       Print(i)   #得到的是所有的值      str
for I in dic.items():
       Print(i)   #得到的是所有的键值    tuple
(‘name’,‘小白’)<class 'tuple’>   # 元组的形式('age',18)    
     <class 'tuple’>
  
fromkeys
dic = dict.fromkeys('abcd','小白')
print(dic)
结果:{'a':'小白', 'b': '小白', 'c': '小白', 'd': '小白'}
分别赋值,--拆包
a, b = 1,2
a, b = [1,2]
a, b = (1,2)
a , b = {“name”:”a”,”age”:2}      结果 name  age
for k,v in dic.items():
print(k,v)
enumerate:枚举,
对于一个可迭代的/可遍历的对象,将其组成一个索引序列,
利用它可以同时获得索引和值。
for k ,v  in enumerate():
print(k,v)
 增:


键操作值    dic["age"] = 18 
有则覆盖,无则添加
setdefault     
dic.setdefault("name","王伟汀")
有则不变,无则添加
有返回值,返回的值是增加的value
 删:


pop   通过键去删除键值对
有返回值,返回的是删除的值
可以设置返回值,当没有此键的时候,返回你设置的值
a = dic.pop("hobby","删除成功")
print(a)
popitem
3.6 之后删除最后一个,有返回值
 改:


dic["name"] ="冯铭昌"  
有则改之,无则添加
update 
有则改之,无则添加
dic.update(age=18,hobby="学习")
dic.update([(1,"田佳俊"),(2,"王征")])
两个字典的合并
dic = {"name":"冯铭昌"}
dic1 = {"name1":"孙悟空"}
dic1.update(dic)
print(dic1)           # {'name1': '孙悟空', 'name': '冯铭昌'}
 查:

通过键查询值
1,dic["name"]    没有键时报错
 
2,get 方法
  1,dic.get("name")  
           有键返回对应的值,查找不到返回none
  2,dic.get("na","没有此键")   
           可以设置返回的值,查找不到返回你设置的值
 元组:


1,俗称:不可变的列表
只能查看,不能增删改
2,方法:
len()   index()    count()
3,儿子不能改,孙子能改
tu = (1,2,[3,4,5])    # 里面的列表能改
4,当元组只有一个元素时:
tu=(2,)    元素后面一定要记得加,否则和元素类型相同,多个元素不用加,
5,元组整体可以被删除
del   tu
 集合:


     空集合   set()
 
     只能增删查     不能改
     本身是可变的数据类型(不可哈希)
     里面的元素是不可变的(可哈希的),
     无序的, 不重复
     列表,字典是可变的,不可以作为集合的元素
作用:  去重      关系测试
    li = [1,2,3,4,5,5,4,3,2,1]
    a = list(set(li))
    print(a)
Add        增加
update       迭代着追加
Remove      按元素删除
Pop              随机删除一个元素
Clear           清空集合
Del  set       删除整个集合
Frozenset     集合变成不可变类型。
  
关系测试:
交集。 (&或者intersection)
并集。 (  |  或者union)
差集。 (  -  或者difference)
反交集。(^ 或者 symmetric_difference)
子集      <      返回bool
超集      >      返回bool