（四）Python中的“四大才子”（字符串、列表、字典、集合）

前戏：在python中把数据序列分为可变（mutable）和不可变(immutable)两种

          不可变：string、int、float、tuple  

          特点：相同对象只是占用一个内存地址，不管有多少个变量引用它，例如a=1,b=1

                    由于是不可变的，每次必须创建新的对象，之前不用的对象如果没有引用指向它，Python垃圾回收机制会自动清理掉

        

          可变：list、dict

          特点：相同对象，每次引用它都会在内存中开辟一块新地址来保存它，但是当我们对他的值进行操作时，内存地址是不会发生变化的

         

总结：python中不可变数据类型一旦对变量的值进行改变，相当于重新建立一个对象，所以内存地址也会发生改变；

          可变数据类型变量的值是可以改变的不会引起内存地址的变化，但是如果值被多个变量引用的话，每个变量都会开辟一块地址

一、字符串（string）

1、str的切片

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 符号('	')转为空格
# Python expandtabs() 方法把字符串中的 tab 符号('	')转为空格，
# tab 符号('	')默认的空格数是 8。
name2="abc	qwer"
print(name2.expandtabs())#默认tabsize=8,从字符串0开始数到	位置补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() 按照行('
', '
', 
')分隔，
# 返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，
# 如果为 True，则保留换行符。最终返回一个列表
h2="sas
sad
sads"
print(h2.splitlines())
print(h2.splitlines(True)) #以换行符分割成一个列表

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

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

 

2、格式化字符串

     2.1%是格式化的操作符，有以下操作符

 

格式化符号	说明
%c	转换成字符（ASCII 码值，或者长度为一的字符串）
%r	优先用repr()函数进行字符串转换
%s	优先用str()函数进行字符串转换
%d / %i	转成有符号十进制数
%u	转成无符号十进制数
%o	转成无符号八进制数
%x / %X	转成无符号十六进制数（x / X 代表转换后的十六进制字符的大小写）
%e / %E	转成科学计数法（e / E控制输出e / E）
%f / %F	转成浮点数（小数部分自然截断）
%g / %G	%e和%f / %E和%F 的简写
%%	输出% （格式化字符串里面包括百分号，那么必须使用%%）

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

注意： 

1、% s   str()得到的字符串是面向用户的，具有较好的可读性

2、%r    repr()得到的字符串是面向机器的  eval(repr(str))

     2.2、格式化辅助操作符

通过"%"可以进行字符串格式化，但是"%"经常会结合下面的辅助符一起使用。

辅助符号	说明
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号(+)
#	在八进制数前面显示零(0)，在十六进制前面显示"0x"或者"0X"（取决于用的是"x"还是"X"）
0	显示的数字前面填充"0"而不是默认的空格
(var)	映射变量（通常用来处理字段类型的参数）
m.n	m 是显示的最小总宽度，n 是小数点后的位数（如果可用的话）

 

 

 

 

 

 

 

 

 

 

 

 

 

 

示例：

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"])

       2.3、字符串的拼接

'''
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))

       2.4字符串的迭代和一些风骚的操作

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 = '12345'
str2 = 'abcdef'
str1 += str2[0:3]
str3=str2[0:3]
print(str1,str3)

二、列表List

        1、切片、增删改查

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]

 2、关于列表的排序问题sort、sorted()

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)

 sorted()方法

总结： 

sort是容器的函数：sort(cmp=None, key=None, reverse=False)

sort()是可变对象(字典、列表)的方法，无参数，无返回值，sort()会改变可变对象，因此无需返回值。sort()方法是可变对象独有的方法或者属性，而作为不可变对象如元组、字符串是不具有这些方法的，如果调用将会返回一个异常。

sorted是python的内建函数：sorted(iterable, key=None, reverse=False)

sorted()是python的内置函数，并不是可变对象(列表、字典)的特有方法，sorted()函数需要一个参数(参数可以是列表、字典、元组、字符串)，无论传递什么参数，都将返回一个以列表为容器的返回值，如果是字典将返回键的列表。

 三、字典dict

         1、字典的基本操作

 

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}

四、元组tuple

tuple相当于不可变列表，例如  a=(1,2,3,"xx",(23,1,2),"df"),不能对里边进行修改，只有count(),index()两种方法

在相同数值情况下，元组占用更小的内存

 五、集合set

 注意:想要创建空集合,你必须使用set() 而不是 {} 。{}用于创建空字典

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("3333")     #添加一项
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,删完了不会做什么，并不存在也不会报错