Python 序列类型(2)

【10月更文挑战第8天】

元组的定义

空元组：（）

有数据的元组：（元素1，元素2，元素3）

有数据的列表：[元素1，元素2，元素3]

元组和列表唯一的区别是外面的括号

元组被称为不可以改变的列表

我们存储多个数据的时候，这些数据是不能修改的数据，那么我们就能将这些数据存储在元组中

t=(1,2,3,4,5)
print(type(t))
#<class 'tuple'>

如果只在元组只存在一个元素的时候，如果我们括号内只有一个元素的话

那么我们打印这个元组的类型就是这个唯一一个元素的类型

为了表示出这个是元组，我们需要在这个数据的后面加上逗号,

加上了逗号就表示出这个类型是元组

t=(1,2,3,4,5)
print(type(t))
t1=(12)
#<class 'tuple'>
print(type(t1))
#<class 'int'>
t2=(12,)
print(type(t2))
#<class 'tuple'>

如果元组里面仅有一个元素的话，我们一定要额外加一个逗号表示这个是元组

不然编译器会认为我们只是将这个元素当度框出来

因为元组和列表一样都是序列

那么都存在索引以及切片操作

元组的索引以及切片操作：

#切片
#序列[开始索引:结束索引:步长]
print(t[::2])
#(1, 3, 5)

元组的数据是不能进行修改的

如果强行修改的话会报错的

如果一定要改怎么办呢？

将元组转换为列表，进行修改，再转换回元组

li[0]='12'
t=tuple(li)
print(t)
#('12', 2, 3, 4, 5)

元组的拆包

元组可以同时赋值给多个变量，只要变量个数不超过元组长度，变量前面加上* 号则可以将多于元素都接受，并组成一个列表

元素和变量个数要一致，不然会出现报错的

#拆包的过程：将元组拆开，将里面的元素分配给左边的变量
a,b,c=(1,2,3)
print(a,b,c,sep="\n")

#而且我们在拆包的过程中我们需要保证元祖中元素的个数和左边变量的个数要达到一致
#不然是会匹配不上从而出现报错

#元素个数和变量个数要一致，拆包的顺序也是从左到右

我们在变量的前面加上*，那么这个变量就能接受元组中的多个数据

并且是以列表类型进行存放的

a,b,*c=(1,2,3,4,5)
print(a,b,c,sep="\n")
'''
1
2
[3, 4, 5]

'''

元祖没有增删改

只有查找的方法

反正涉及到改变元组的话的方法我们就不能使用

小题目

定义一个列表，存储分数

分数分别有5位评委进行输入，去掉最高分，去掉最低分，求这位选手的平均值

'''
定义一个列表，存储分数
分数分别有5位评委进行输入，去掉最高分，去掉最低分，求这位选手的平均值
'''
scores=[]#定义一个空列表
for i in range(1,6):#循环将评委的分数写入
    score=eval(input(f'请输入第{i}位评委的分数：'))
    #将获取的分数append到列表中
    scores.append(score)
#每次循环就对score进行赋值，然后我们将这个值追加到之前创建的空列表里面

print("所有评委的分数为",scores)

#去掉最高分
scores.remove(max(scores))

#去掉最低分
scores.remove(min(scores))


avg=sum(scores)/len(scores)

print(f"选手的平均分是：{avg:.2f}")

#添加的方法有3种
'''
append--追加
insert---在指定位置插入元素
extend--添加序列
'''
'''
去掉最高分，去掉最低分
方法一：先排序，删除第一元素和最后一个元素
方法二：max()获取最高分，min()获取最低分

我们上面使用的就是方法二

那我们下面使用方法一进行操作下
'''

scores.sort()#排序
print(li)
li.pop(0)#删除第一个
li.pop(-1)#删除最后一个
print(li)
#我们现在已经去掉最低分和最高分了

#pop是删除索引对应的位置
#而remove是删除列表中值为这个数的数字


#平均值=总和/数量
'''
1.求总和
    1.通过循环遍历列表中的数据
    2.通过sum这个函数进行求和的操作
'''
sum_b=0
for i in scores:
    sum_b+=i

print(sum_b)
#那么我们现在就拿到了总和了

#后面就能进行平均值的求了
#我们通过len函数获取序列元素的个数

字符串基础操作

字符串也是属于列表的

那么字符串也是有索引切片的操作的

字符串索引切片的操作:

s="pyhton"
#索引---序列[索引]
print(s[-1])
#n

#切片---序列[开始索引：结束索引：步长]   不包含步长的
print(s[::2])
#pho

字符串是不能进行修改的：

#能否将字符串中的数据进行修改呢？
s[0]='P'
print(s)
'''
Traceback (most recent call last):
  File "C:\Users\27890\Desktop\7.序列类（字符串）、散列类型（字典）.py", line 84, in <module>
    s[0]='P'
TypeError: 'str' object does not support item assignment
'''
#很明显是会报错的
#那么就说明字符串是不能进行修改的，和元组一样的

字符串的一些小操作

替换字符串内的数据--replace

如果真的需要对字符串进行修改的话

方法是有的，但是所有的字符串的修改方式都是不会在原来的字符串上进行修改，都是返回一个新的字符串

如果需要修改字符串，我们需要调用字符串内置的方法并且重新赋值

replace 方法是字符串修改常用的方法，可替换原字符串中的字符，但是并不会修改原字符，只是会返回一个新的对象，字符串所有的修改方法都是如此，不会改变原字符串，会返回一个新的字符串

replace的基础用法：

replace(旧字符，新字符，替换次数)

#replace(旧字符，新字符，替换次数)
s.replace("p","P")
print(s)
#我们打印这个字符串发现并没有任何的修改

#因为这个修改的话是不对原字符串进行任何操作的
#仅仅是返回一个新的字符串，这个字符串就是被修改了的
b=s.replace("p","P")

print(b)
#Pyhton
#那么现在就是修改成功了
#对s进行重新赋值的操作
s=b
print(s)
#那么现在s里面的内容就被修改了

如果我们没有设置替换次数的话，编译器会默认修改所有要替换的字符

没有指定替换次数，那么编译器就会将这个字符串中我们提出要替换的字符的所有相同的字符都进行替换了

默认是替换全部

如果指定次数，那么就替换指定的次数

对指定的次数进行替换：

s1="hahaha".replace("a","i")
print(s1)
#hihihi
#我们这里发现所有的a都被改成i了

#如果我们没有设置替换次数的话，编译器会默认修改所有要替换的字符

s2="hahaha".replace("a","i",1)
print(s2)
#hihaha
#我么还能规定了替换次数之后，那么编译器就仅仅只替换了第一个

字母的操作

1.title()---字符串中每个单词的首字母大写---标题形式

使用方法：字符串.title()

title的使用方法，将字符串中每个单词的首字母进行大写的操作：

print("hi, my name is xiaoming".title())
#Hi, My Name Is Xiaoming
#title的使用方法：  字符串.title()
#将字符串中每个单词的首字母进行大写的操作

2.upper()---字符串中字母全部进行大写的操作

使用方法：字符串.upper()

print("Hi,name,123".upper())
#HI,NAME,123

3.lower()---字符串中字母全部进行小写的操作

使用方法：字符串.lower()

print("HI,NAME,123".lower())
#hi,name,123

4.capitalize()--将字符串中首元素的首字母进行大写的操作

print("hi,name,123".capitalize())
#Hi,name,123

字符串中的对字母的判断操作

上面的操作都是对单词开头或者所有字母进行大小写的操作

那么我们这里就是判断字符串中字母的操作实现了没

下面的操作中一般都会有逗号，如果是判断字符串中是否全是字母的话，那么就会返回False

因为逗号不是字母，逗号也是这个字符串的一员，也是这个字符串内的一个元素

那么我们在判断的时候就会算上这个逗号

1.isupper---判断字符串中字母是否进行大写的操作

print("Hi,name,123".isupper())
#False
#因为这个字符串里面存在小写的字母，那么就说明这个字符串并没有进行大写的操作

如果都是大写的话，那么就会返回True,如果存在小写的字母的话，那么就会返回False

2.islower()---判断字符串中字母是否全部进行了小写的操作

print("HI,NAME,123".islower())
#False

3.isdigit()---判断字符串中的字符是否都是数字

print("HI,NAME,123".isdigit())
#False

4.isalpha()---判断字符串中的字符是否都是字母

print("HI,NAME".isalpha())
#False

print("HINAME".isalpha())
#True

字符串的切割

1.strip--删除字符串左右两边指定的元素

strip(字符)---在字符串的左右两边删除指定字符，默认是空白字符

s=" hahaha"#这个字符串的开头有一个空格
print(s)
s1=s.strip()
print(s1)
#默认将左右两边的空格进行删除
'''
 hahaha
hahaha

'''
s1=s.strip("a")
print(s1)
'''
 hahah
我们这里没有删除空格，我们将左右两边的a进行删除了

我们的操作都是左右两边，不会对字符中间进行处理的
'''

2.split---以字符串中的元素为基点来进行拆分

split可以对字符串进行切割，默认是以空格来作为分割符，切割之后的元素会放在一个列表当中

默认是以空格为切割点的进行拆分

#split(字符，拆分次数)---按照指定字符对字符串进行拆分，默认是空白字符

print("my name is xiaoming".split())
'''
['my', 'name', 'is', 'xiaoming']
'''
#我们的这个函数是什么参数都没进行添加的
#那么默认就是按照空格进行拆分

#我们这里的句子是有三个空格的，那么通过这个拆分函数进行拆分之后
#那么就拆分成了四个元素组成的列表

规定拆分的次数的情况：

print("my name is xiaoming".split(" ",2))
'''
['my', 'name', 'is xiaoming']
我们在这里设置了分隔符为空格，拆分的次数为2
然后最后面的那个空格就没有进行拆分了
我们拆了两次拿到了3个元素
'''

s="www.baidu.com"
#以点进行拆分，并且加以拆分次数
print(s.split(".",2))
'''
['www', 'baidu', 'com']
'''
s1="www.baidu.cn.com"
print(s1.split("."))#不加拆分次数，默认全部拆
'''
['www', 'baidu', 'cn', 'com']
'''

不加拆分次数，默认全部拆

3.join--拆分后的列表内的字符串的拼接以及列表中元素拼接成字符串的操作

通常拆分完之后我们可以使用join函数来指定特殊符号进行列表中字符串元素的拼接

#使用join进行拼接，使用我们指定的符号进行拆分后元素的拼接
print('*'.join(s1.split(".")))

'''
www*baidu*cn*com
'''
#使用方法就是："指定的符号".join(拆分好的列表)

使用方法就是："指定的符号".join(拆分好的列表)

对于列表中元素拼接成字符串的操作

#字符串转列表，修改元素之后再变回字符串的操作
s="hahahaha"
li=list(s)
print(li)
'''
['h', 'a', 'h', 'a', 'h', 'a', 'h', 'a']
字符串转列表的话会将每个字符转换为一个元素
'''

li[3]="p"
print(li)
'''
['h', 'a', 'h', 'p', 'h', 'a', 'h', 'a']
我们直接利用索引就能进行对应数据的修改了
'''
##s=str(li)
##print(s)
'''
交互模式下
s
"['h', 'a', 'h', 'p', 'h', 'a', 'h', 'a']"
说明我们已经转换成功了
'''

'''
我们利用类型的转换，将字符串先转换为列表，
然后之前字符串的每个字符就变成了列表的元素了
然后我们利用列表的索引值对元素进行修改的操作
修改完之后我们将这个列表转换为字符串
发现仅仅只是在这个列表外面加了一层引号，并没有做出什么实质性的改变
那么我们应该怎么做才能将修改后的列表变为原先那样的字符串呢？
'''
'''
这里我们提到了join函数这个概念
"连接符".join(序列)
作用就是将序列的元素用连接符连接成一个字符串
'''
s="".join(li)#因为原先的字符串内的字符之间是没有符号的，我们这里使用空字符
print(s)
'''
hahphaha
'''
#通过这种方法我们在改变数据之后我们就不需要再进行类型的转换的操作了

#我们直接将列表中的单个元素拼接在一起形成一个字符串

#我们也是可以用其他的符号进行连接的

我们先将字符串转类型为列表，然后利用索引对元素进行修改

因为字符串是不能对数据进行修改的

我们在修改完数据之后

我们利用join函数对列表中的单个字符元素进行拼接

我们可以选择指定的符号进行拼接，拼接完成之后这个类型就变成了字符串了

对于这里我们选择的是空字符，，就是字符和字符之间是没有符号的，所以选择空字符

字符串的查找

find

#find(字符，开始索引，结束索引)---在指定的范围中查找字符，
#默认的话是在整个字符串中进行查找
#个人感觉像列表的切片操作

#我们这里打印的是返回值
print("python".find("p"))
#0
print("python".find("P"))
#-1

#如果找到了的话就返回0，没有找到的话就返回-1
#我们这里没找到的话是不会进行报错的


#index没有找到对应的数据的时候是会进行报错的
print("python".index("p"))
#0
print("python".index("P"))
#报错

find没有在字符串中寻找数据的话是不会进行报错的

但是index没有找到的话是会进行报错的

find如果找到的话是会返回0

没有找到的话返回-1

index找到就返回0

没有找到就报错

#交互模式
"python".find("o",1)
4
"python".find("o",2)
4
"python".find("o",5)
-1

第二个参数就是我们寻找我们指定数据的开始位置的索引

我们从这个索引对应的位置开始寻找我们要找的元素

找到了就返回这个元素索引值

没有找到就返回-1

字符串的转义

格式：以反斜杠（\）开头，后面跟一个或者几个字符

意义：具有一些特殊含义，不同与字符原有的意义

我们之前使用到了\n \t

\n是换行

\t是制表符

print("abcd\tefg")
'''
abcd    efg
中间的空格就是一个Tab的大小
'''
print("w\t*")
print("ww\t*")
print("www\t*")
print("wwww\t*")
print("wwwww\t*")


'''
w    *
ww    *
www    *
wwww    *
wwwww    *
\t会自动帮我们进行对齐，进行排版
'''

自动对齐

\---转义之后就是\

\'以及\"的用法

'''
\' ----  '
\"----  "
在下面这种单引号包裹着双引号，双引号包裹着单引号的情况下，我们可以使用这种方式
进行隔离，保证不会因为引号匹配错误导致报错
'''

print('my name is \'xiaoming\'')
#my name is 'xiaoming'

print('my \'name\' is \'xiaoming\'')
my 'name' is 'xiaoming'

\-----\

print("C:\\Temp\\BT_DFU_FW\\10\\DFU_SOP.pdf")

#我们这里的\本来表示的就是一个单纯的\
#但是可能会和后面的字母组合成为转义字符
#为了避免这种可能，我们在字符串引号前面加上一个字符r
#那么就会将这个字符串的转义给去掉

#还有一种方法就是上面的在原本的\前面再加上一个\
#\\   两个右斜杠转义过来就是一个\   那么就不会存在\与后面的字母进行配对成转义字符的情况了

或者在字符串的引号前面加上r，那么这个字符串就会取消字符串的转义效果了