name="hello word,abcdefgWX!!!"
str[::]读取操作

 print(name[0],name[1])

capitalize(self)方法，首字母大写
 print(name.capitalize())#打印Hello word，wx开头首字母大写,其余小写

casefold(self)大写转小写
 4 print(name.casefold())#把字符串大写转成小写

 # casefold() 方法是Python3.3版本之后引入的，其效果和 lower() 方法非常相似，

 # 都可以转换字符串中所有大写字符为小写。

 # 两者的区别是：lower() 方法只对ASCII编码，也就是‘A-Z’有效

 # 对于其他语言（非汉语或英文）中把大写转换为小写的情况只能用 casefold() 方法。

center(width,"")

 print(name.center(20,"*"))#把字符串居中，width=20字符串的总宽度  fillchar 填充字符

 # name.center(self,width,fillchar)

count(sub,start,end)

 print(name.count("l"))#统计字符串中字符出现的次数，也可以指定位置 默认从0到最后

 print(name.count("d",0,15))#1count(sub,start,end)

 print(name[0:15].count("d"))#2

encode("utf-8")字符串转成bytes

 print(name.encode().decode())  #字符转成字节byte类型

endswith(sub,start,end)、startswith(sub,start,end)

 print(name.endswith("!!!")) #判断是否以指定字符结尾 返回bool值，也可指定位置判断

 print(name.endswith("rd",0,10))#end=10 不包括10 到第9位

 print(name[:10],name[:10].endswith("rd"))
55 print(h.startswith("h")) #判断一指定字符开头
56 print(h.startswith("h",0,2))

expandtabs(tabzise)把字符串中的 tab 符号('\t')转为空格

 # Python expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，

 # tab 符号('\t')默认的空格数是 8。

 name2="abc\tqwer"

 print(name2.expandtabs())#默认tabsize=8,从字符串0开始数到\t位置补5个空格

 print(name2.expandtabs(16))

find(self,sub,start,end)查找元素位置，返回索引值，不存在返回-1

 print(name.find("l")) #查找字符串元素位置，返回索引值，查不到返回-1

 print(name.find("l",3,5))#指定查找范围

index(sub,start,end)、rindex()

 print(name.index("l"))  #输出索引值

 print(name.index("o",2,9))#指定范围
27 print(str1.rindex("D",2,11))#从最右边开始找某个字符,输出索引值

isalnum()、isnumeric()

 a="1223wew"

 print(a.isalnum()) #判断是否包含数字
41 print(name.isnumeric());#判断是否有纯数字组成

isalpha()

 b="sadsd"

 print(b.isalpha())#检查字符串是否为纯字母

isdecimal() 是否为十进制字符

 c=u"132323"

 print(c.isdecimal())#是否只是包含十进制字符

 c2=u"asdd3232"

 print(c2.isdecimal()) 

isidentifier()
 print(name.isidentifier())   #判断字符串是否已字母开头

 print(a.isdigit() #检查是否为纯数字

find()、rfind()查找元素，output索引值

 c="adsdsd8989"

 print(c.find("w"))
26 print(str1.rfind("D",2,11))#从最右边开始找某个字符,输出索引值

isprintable()

 print(name.isprintable()) #判断是否可打印字符串

istitle()

 print(name.istitle());#判断字符串是否为一个标题

isupper()、islower()

 print(name.isupper())#判断字符串是否都是大写
   print(name.islower())#判断字符串是否都为小写

isspace()

 print(name.isspace())#字符串是否只由空格组成

join(),将字符串用指定字符生成新的字符串
 1 a=("h","l","l")

 b="k"

 c="nihao"

 print(b.join(c)) #将字符串用指定的字符链接成新的字符串
   output"nkikhkako"

 print(b.join(a))
   output"hklkl"

just(width,"")对齐
 print(c.ljust(20,"_"))#字符串左对齐，指定20宽度，后边以_填充

 print(c.rjust(20,"-"))

maketrans(oldsub,newsub)、translate(sub)
 c1=c.maketrans("n","@") #将字符串某个字符用指定元素代替 与translate结合使用

 print(c.translate(c1))  #解密
   output:"@ihao"

upper()转大写、lower()转小写

 str1="ASADSASDsadsD1"

 print(str1.lower())  #转成小写

 print(str1.upper())  #转成大写

partition(sub)指定字符分割，返回一个元组类型

 # partition() 方法用来根据指定的分隔符将字符串进行分割。

 # 如果字符串包含指定的分隔符，则返回一个3元的元组，

 # 第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

 print(str1.partition("D"))
   output:("ASA","D","SASDsadsD1")

 print(str1.rpartition("D")) #从右往左找字符串开始分割
   output:('ASADSASDsads', 'D', '1')

replace()字符串替换

 # replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)

 # 如果指定第三个参数max，则替换不超过 max 次。

 # str.replace(old, new[, max])

 #可以用来改字符串内容

 print(str1.replace("A",2))  #指定替换成几个，默认全都替换，

tite()转换成标题

 e="sd dsd  23 dsd "

 print(e.title())#转换成标题
   output:"Sd Dsd  23 Dsd "

split(sub,num)、rsplit()返回一个列表

 # split(sub,num)通过指定分隔符对字符串进行切片，对指定分割符为空值代替

 # 如果参数num 有指定值，则仅分隔 num 个子字符串

 f="hellowordlll23"

 print(f.split("l",2))#分割2个l
   output:["he","","oword1ll23"]

 print(f.rsplit("l",2))#从右找指定字符开始分割
   output:["hellowordl","","l23"]

strip()移除字符串头尾指定的字符（默认为空格）。

 # Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）。

 # strip()方法语法：

 # str.strip([chars]);

 g=" sdsd32,dad sad $"

 h="helloh"

 print(g.strip())

 print(g.strip("$").strip())

 print(h.strip("h"))

 h1="ohelloo"

 print(h1.rstrip("o"))#去掉字符串最右边的字符

spliitlines(keepends)

 #Python splitlines() 按照行('\r', '\r\n', \n')分隔，

 # 返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，

 # 如果为 True，则保留换行符。最终返回一个列表

 h2="sas\nsad\rsads"

 print(h2.splitlines())

 print(h2.splitlines(True)) #以换行符分割成一个列表

swapcase()

 i="dsds212ASDSDS"

 print(i.swapcase()) #大小写互换

zfill()

 print(i.zfill(20))   #指定字符串长度，右对齐不够在字符串左边补0

 num = 10

 print ("%d to hex is %x" %(num, num))#a

 print ("%d to hex is %X" %(num, num))#A

 print ("%d to hex is %#X" %(num, num))#0XA    x/X十六进制的大小写

 print ("%d to hex is %#x" %(num, num))#0xa

 # 浮点数

 f = 3

 f2=3.23

 print("value of f is: %.4f" %f)  #保留4位小数

 print("value of f is: %e" %f2)

 # 指定宽度和对齐

 students = [{"name":"Wilber", "age":27},

             {"name":"Will", "age":28},

             {"name":"June", "age":27}]

 print("name:%10s, age:%10d"%(students[0]["name"], students[0]["age"]))

 #%10s代表指定name的value宽度为10,不够在左边补空格，右对齐

 print("name:%-10s, age:%-10d"%(students[1]["name"], students[1]["age"]))

 #与上边相反，左对齐，

 print("name:%*s, age:%*d"%(10,students[2]["name"], -10, students[2]["age"]))

 # dict参数

 for student in students:

     print("%(name)s is %(age)d years old" %student)

     print(student["name"],student["age"])

 '''

 print("---请输入你的姓名和密码---")

 username=input("username:")

 password=input("password:")

 print(username,password)

 '''

 #python2里的raw_input和python3里一样

 print("---请输入员工信息employee information---")

 name=input("name:")

 age=int(input("age:"))

 job=input("job:")

 salary=int(input("salary:"))

 #字符串的拼接'''+....+'''

 '''

 em_information='''

 em_name:'''+name+'''

 em_age:'''+age+'''

 em_job:'''+job+'''

 em_salary:'''+salary+'''

 '''

 print(em_information)

 '''

 #第2种方法采用%s格式化输出

 #eg:%s,表示格化式一个对象为字符 比如： "Hello, %s"%"world" => "Hello, world" 这个一般用在格式化输出上

 #%f 表示格式化一个对象为浮点型

 em_information1='''

 em_name1:%s

 em_age1:%d

 em_job1:%s

 em_salary:%d

 '''%(name,age,job,salary)

 print(type(name,),type(age)) #打印输出变量类型

 print("em_information1:",em_information1)

 #第3种方法，采用format()关键字参数

 em_information2='''

 em_name2={_name}

 em_age2={_age}

 em_job2={_job}

 em_salary2={_salary}

 '''.format(_name=name,

            _age=age,

            _job=job,

            _salary=salary)

 print(em_information2)

 #第4种方法，format()位置参数

 em_information3='''

 em_name3={0}

 em_age3={1}

 em_job3={2}

 em_salary3={3}

 '''.format(name,age,job,salary)

 print("em_information3:",em_information3)

补充:
infor=["Wilber",28,"it",9000] 
print("""name={0[0]} 
         age={0[1]} 
         it={0[2]} 
         salary={0[3]}""".format(li))

 a="hello"

 b="hello we"

 c=""

 for i in a:

     c+=i

 print(c)

 print(a in b)

 print(a[::-1])#翻转字符串

 print(list(a))#转成列表

 print(tuple(a))#转成元组

 str1 = ''

 str2 = 'abcdef'

 str1 += str2[0:3]

 str3=str2[0:3]

 print(str1,str3)

List读取操作
1 info=[1,"beijing",12,"xian",-2,-100,"changsha","@#$"]

 print(info[2])#读取指定索引的值

 print(info[:])#读取全部值

 print(info[::2])#跳位读取，间隔是2

 print(info[::-1]) #从右往左开始读取排列 相当于翻转一下

 print(info[-3:-5])#输出为空列表，默认开始位置必须小于结束位置

 print(info[-3:-1])

List增删改查
 1 info=[1,"beijing",12,"xian",-2,-100,"changsha","@#$"]

 info_1=[1,23,4,5,5,]

append(x)追加
 info.append(5)  #追加、默认放到最后

 info.append("qingdao")

 print(info)

insert(i,x),指定位置插入元素
 info.insert(2,90) #insert指定位置插入元素 insert(self,i,x)

 print(info)

clear(),清空列表
 info_1.clear() #清空一个列表

 print(info_1)

list[i]=x,修改其中的值
 info[0]="hunan" #指定索引值修改

 print(info)

remove(x),删除指定元素
 info.remove("@#$")  #删除指定元素

 print(info)

pop(i),移除下标为i的值,不写默认-1删除最后一个
 info_2=[1,23,4,5,5,]

 info_2.pop() #默认移出最后一个

 info_2.pop(2)#移出指定位置元素

 print(info_2)

Del方法、删除变量，也可以删除指定值
 info_3=[1,2,232,"sad","@#$"]

 del info_3[0:2]

 print(info_3)

 info=[1,"beijing",12,"xian",-2,-100,[1,2,3],"changsha","@#$",1]

count(x),统计列表某元素出现次数
 info.count(1) #统计元素出现的次数

 print(info.count(1))

copy()复制一份，也可以list1=list2[:],浅copy
 info_1=info.copy()

 info[6]=[2,3,4]

 print(info_1,info)

extend(list),向一个列表追加另一个列表序列
 a=["xuzhou","xian"]

 b=list(range(4))

 a.extend(b)  #用于列表扩展，向指定列表最后追加另外一个列表

 b.extend(a)

 print(a,b)

index(x.start,end),输出元素索引值，默认start、end为NONE,也可指定范围查找
 a.index("xian") #输出指定元素下标值，index(x,i,j)i,j参数默认为空 可以指定范围

 print(a.index("xian",1,5))

reverse()反转，等价于list[::-1]
 a.reverse()  #列表反转

 print(a)

sort([func])排序,可以接受一个函数
 c=[1,99,34,-100]

 c.sort()#排序

 print(c)#[-100,1,34,99]

 list1 = [(100,'huangxi',2),(99,'changsha',17),(-10,'aunan',90)]

 list1.sort()#sort方法会覆盖原来的列表，ID不变

 print(list1)# [(-10, 'hunan', 90), (99, 'changsha', 17), (100, 'huangxi', 23)]

 # 使用匿名表达式重写key所代表的函数

 list1.sort(key=lambda x:x[2] )

 print(list1)#[(100, 'huangxi', 2), (99, 'changsha', 17), (-10, 'aunan', 90)]

 # 使用匿名表达式重写key所代表的函数,按照元组的第三个元素进行排序

 list1.sort(key=lambda x:(x[2],x[0]))

 print(list1)

 #对于下标2处元素相同的，则按下标为0处的元素进行排序

 list2 = [(100,'huangxi',2),(99,'changsha',100),(-10,'aunan',90)]

 list2.sort(key=lambda x:(x[2],x[0]),reverse=True) #降序

 print(list2)#[(99, 'changsha', 100), (-10, 'aunan', 90), (100, 'huangxi', 2)]

 引用operation模块
 1 from operator import attrgetter,itemgetter

 list1 = [(100,'huangxi',2),(99,'changsha',17),(-10,'dunan',90)]

 # 使用operator模块中的itemgetter函数进行重写key所代表的函数，按照下标为1处的元素进行排序

 list1.sort(key=itemgetter(1))#按照列表中元组下标为1的进行排序

 print(list1)#[(-10, 'aunan', 90), (99, 'changsha', 17), (100, 'huangxi', 2)]

 #使用operator模块中的itemgetter函数进行重写key所代表的函数，

 list1.sort(key=itemgetter(2))# 按照下标为2处的元素进行排序

 print(list1)#[(100, 'huangxi', 2), (99, 'changsha', 17), (-10, 'dunan', 90)]

 list1.sort(key=itemgetter(2,0))#先按下标为2的排，相同的再按下标为0 的进行排序

 print(list1)

 d1={"name":"xx","job":"it","age":22,"salary":8000,"city":"beijing","sex":"m"}

dict的读取dict[key]和修改dict[key]=value
 2 print(d1["name"],d1["age"]) #字典读

 d1["name"]="ww"#修改key的value

 d1["爱好"]="study" 如果key不存在则创建一个房子末尾

 print(d1)

get(key),查看键值对应的元素，不存在则返回NONE
 6 print(d1.get("name"))#查看键值对应的元素，不存在则返回NONE

setdefault(key,default=NONE)查看key对应的元素，不存在则创建，Value为NONE

 print(a.setdefault("city"))

items(),把字典转成一个列表,[(key,value),(key,value)....]
 print(type(d1.items()),d1.items())#dict_items([('name', 'xx'), ('job', 'it'), ('age', 22), ('salary', 8000)])

copy()
10 d2=d1.copy() #字典的复制

 print(d2)

keys():输出键值 values()：输出Value值
 print(d1.keys())#dict_keys(['name', 'job', 'age', 'salary']) 输出key值

 print(d1.values())#dict_values(['xx', 'it', 22, 8000]) 输出value

pop(key)删除元素，popitem()删除最后一个（key,value）

 print(d1.pop("city"))#删除Key的Value 返回Value

 print(d1.popitem())#('sex', 'm') 删除最后一个key和value 返回一个tuple

update(dic)更新列表，参数必须是字典

 a={"age":22}

 b={"age":32,"sex":"M"}

 a.update(b)   #用于更新列表

 print(a,b)  #{'age': '32', 'sex': 'M'} {'age': '32', 'sex': 'M'}

描述

 Python 字典 fromkeys() 函数用于创建一个新字典

 以序列seq中元素做字典的键，value为字典所有键对应的初始值。

 语法

 fromkeys()方法语法：

 dict.fromkeys(seq[, value]))

 参数

 seq -- 字典键值列表。

 value -- 可选参数, 设置键序列（seq）的值。

 a=["name","city","job","age"]

 a1=dict.fromkeys(a)

 print(a1)#{'name': None, 'city': None, 'job': None, 'age': None}

 b=dict.fromkeys("c",3) #创建一个新字典

 print(b)#{'c': 3}

list去重

list_1=set([1,2,3,5,88,90,789,3])

list_2=set([22,33,5,123,90,"q","e"])

list_3=set([1,3,5])

print(list_1,list_2)

（交集、并集、差集）
print(list_1.intersection(list_2))  #两个集合的交集

print(list_1&list_2)   #交集 {90, 5}

print(list_1.union(list_2))#两个集合合并，并集

print(list_1|list_2)   #并集

print(list_1.difference(list_2))    #差集，去掉交集，我有的你没有

print(list_1-list_2)   #差集

print(list_2.difference(list_1))

print(list_1.symmetric_difference(list_2))#对称差集，去掉相同的元素，连接起来

print(list_1^list_2)   #对称差集

关系测试（子集、交集）

print(list_3.issubset(list_1))      #判断是否是子集

print(list_1.isdisjoint(list_2))    #判断两个集合有无交集没有返回Ture

集合的操作

a={"q","w",1,222,452}

print(list_1.pop(),list_1)  #随机删除

a.add("")     #添加一项

print(a)

a.update([1,2333,"df",2223])  #添加多项元素

print(a)

a.remove(1)                   #删除指定元素

print(a)

print(len(a))                 #长度

print(452 in a)

c={1,2}

d={1,2,5,7,900}

print(c<=d)             #测试是否为子集

print(d.discard(1),d)   #discard 删除指定元素 返回none,删完了不会做什么，并不存在也不会报错