字符串
- 定义方法:
- 第一种:’ ’ 单引号(英文输入法)
- 第二种:" " 双引号(英文输入法)
- 第三种:’’’ ‘’’ 三引号(英文输入法)
- 第四种: s = str()
- 常用方法:
-
capitalize ----- 格式化字符串,将字符串的首字母进行大写
-
center(width,fillchar) ------ 按照字符串的长度(必须大于字符串本身的长度,单位是符号位)
进行居中fillchar默认的是空格,是可选参数,例如*,+等符号 -
rjust ------ 右对齐,fillchar默认的是空格,是可选参数
-
ljust --------左对齐,fillchar默认的是空格,是可选参数
-
count --------- 统计字符或者字符串出现的次数
-
endswith ------- 判断字符串是否以XXXX位结尾
-
startswith ------- 判断字符串是否以XXXX位开始
-
index ------- 查找字符或者字符串第一次出现的位置,如果不存在会抛出异常
-
rindex -------从右往左找,查找的是字符或者字符串出现的最后一个位置(角标)
-
find ----- 查找字符或者字符串第一次出现的位置,如果不存在返回-1
-
rfind------ 从右往左找,查找的是字符或者字符串出现的最后一个位置(角标)
-
encode ----- 将字符串转换为字节(byte)数据的方法(python3)
-
decode() -------将字节转换成字
符串(是字节里面的方法 dir(t),不是字符串里面的方法) -
format ------ 格式化字符串
-
islower ------------ 判断字符串是否全部为小写字母
-
isupper ---------判断字符串是否全部为大写字母
-
istitle ------------ 判断字符串是否为标题
-
isspace ------- 判断是否是空格位(了解)
-
isdigit ------ 判断是否全为数字(用途:将字符串转换为整型)
-
isalnum ------判断的不是全为数字,判断的是是否是有效字符(#*&%)
-
isalpha ------ 判断是否全为字母
-
title ------ 将字符串转换为标题
-
lower ----- 将字符串转换为小写字母
-
upper----将字符串转换为大写字母
-
split(" ") ------- 分割字符串,返回的是列表
-
a = "qw eq eq" a.split(" ")(引号内的内容代表以什么为分割的条件,此代码中是以空格为条件) ['qw', 'eq', 'eq'] a = "qw,e,qeq" a.split(",")(此代码中是以','为条件) ['qw', 'e', 'qeq']
-
join ---------- 以特定的格式将一个可迭代的对象转换成字符串(一般和split()连用,可以通过split()把字符串转化为列表,通过列表进行一些字符串无法进行的操作,再通过"".join()把列表转化为字符串)
-
列表 a = ["a","b"] print( "".join(a)) 'ab'(结果) 字典 d = {"name":"zhangsan","age":18} print( "".join(d)) 'nameage' 只会把键转化为字符串,不会把值算进去 集合 s = {"a","b"} print( "".join(s)) 'ba'
-
strip ------- 清除字符串两侧的空格(java里面trim(),用途:注册页面的验证,例如:用户名:
张三) -
lstrip -------- 清除字符串左边的空格
-
rstrip -------- 清除字符串右边的空格
-
replace(新字符,旧字符) -------- 新字符或者字符串替换旧字符或字符串(常用)
常见的排序
1. 选择排序
arr = [8,3,2,6,1,4,9,7]
for i in range(0,len(arr)):
for j in range(i+1,len(arr)):
if arr[i] >= arr[j]:
arr[i],arr[j] = arr[j],arr[i]
print(arr)
解析
i = 0时代表第一个位置的值去和剩余位置的值进行比较,比i = 0小就交换,把最小值放到第一个位置。
i = 1时就是第二个位置开始重复同样的操作
2. 冒泡排序
arr = [8,3,2,6,1,4,9,7]
for i in range(0,len(arr)-1):
for j in range(0,len(arr)-1-i):
if arr[j] >= arr[j+1]:
arr[j],arr[j+1] = arr[j+1],arr[j]
print(arr)
解析
len(arr)-1 = 7
i = 0
len(arr)-1-i = 6(考虑j+1的取值范围)
就是arr[0]和arr[1]比较,若是arr[0]》arr[1]则交换两者 的取值,同样的操作知道arr[6]和arr[7]比较,(长度为8,下标最大为7)把最大值放到最后一个位置去。
i = 1
len(arr)-1-i = 5(考虑j+1的取值范围)
此时最后一个位置已经放的是最大的值,就不用考虑,就比较的范围是arr[0]到arr[6],重复同样的操作
2. 插入排序
a = [8,3,2,6,1,4,9,7]
for i in range(1,len(arr)):
for j in range(i,0,-1):
if arr[j] <= arr[j-1]:
arr[j],arr[j-1] = arr[j-1],arr[j]
print(arr)
解析
i = 1
j in range(1,0,-1) j取值为1,取不到0,逆序输出
比较a[0]和a[1]大小,if arr[1] <= arr[0],值交换
i = 2
j in range(2,0,-1), j取值为2,然后是1
先比较a[2]和a[1]if arr[2] <= arr[1],值交换
再比较a[0]和a[1]大小,if arr[1] <= arr[0],值交换
4. 计数排序(桶排序)
arr = [7,3,2,0,1,2,3,6]
max_num = arr[0]
min_num = arr[0]
for num in arr:
if num > max_num:
max_num = num
elif num < min_num:
min_num = num
# print(max_num)
# print(min_num)
#中间数组长度
len_arr1 = max_num - min_num + 1 #7
#偏移量
offset = min_num #(0)
#初始化计数列表 元素全为0
#arr1 = [0] * 7
# arr1
#[0, 0, 0, 0, 0, 0, 0]
arr1 = [0] * len_arr1
#排序后的列表
arr2 = [0] * len(arr)
#计数
for num in arr: # 7,3,2,0,1,2,3,6
print(num)
arr1[num-offset] += 1 # 0 0 0 0 0 0 0 num-offset = 7-0= 7 arr1[7]+=1,代表7出现了一次
print(arr1)
index = 0
for i in range(0,len_arr1): #len_arr1=7
for j in range(0,arr1[i]):
print(i+offset,end=" ")
arr2[index] = i + offset
index += 1
print()
print(arr2)
解析
9 3 2 4 2 1 7 6 4 7
第一步:找最大值和最小值
中间数组的作用是用来统计arr中每个元素的出现次数,中间数组的下标就是arr中元素的值,中间数组的值就是arr中该下标值出现的次数
之所以要获取arr的最大值和最小值,是因为需要排序的一定范围的整数不一定是从0开始,此时为避免空间位置浪费,中间数组的长度是是数列最大值和最小值的差+1,此时最小值作为一个偏移量存在
0 1 2 3 4 5 6 7 8 9
第一次遍历:用来遍历arr的每个元素,统计每个元素的出现次数,存入中间数组(下标是arr中的元素值,值是该元素在arr中的出现次数)
第二次遍历:遍历中间数组,每个位置的值=当前值+前一个位置的值,用来统计出小于等于当前下标的元素个数
第三次遍历:反向遍历arr的每个元素,找到该元素值在中间数组的对应下标,以这个中间数组的值作为结果数组的下标,将该元素存入结果数组
切片
python分割可迭代的对象
一个完整的切片包含两个":"
语法格式:
object[start_index : end_index : step]
start_index: 切片切割开始的位置
end_index:切片切割结束的位置,不包含end_index处的元素
step:步长,默认值是1,也可以取负值(从右往左的切割)
前闭后开
**切割列表
以列表 a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例
以负数 a = [-10,-9,-8,-7,-6,-5,-4,-3,-2,-1]下标
**
-
切割单个值:
以列表 a = [0,1,2,3,4,5,6,7,8,9]为例a[0]
print(a[0])
0a[-1]
print(a[-1])
9
超越可迭代对象的下标会报错,仅仅在切割单个值的时候 -
切割完整的对象:
a[:] #从左往右
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]a[::] #从左往右
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]a[::-1] #从右往左
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] -
start_index和end_index全为正
输出为空,即[ ]的情况,是因为左右输出的顺序不一
只有左右输出的顺序一致就不会返回[ ]a[1:6]
从1切割到6(不包含6)step=1
[1, 2, 3, 4, 5]a[1:6:-1]
step=-1
表示的从右往左 start_index=1和end_index=6 表示从左往右,矛盾了,所以返回的是空
[]a[6:1]
step = 1 表示从左往右,start_index=6 end_index=1 表示从右往左
[]a[:6]
start_index = 0 end_index=6 (不包含6)
[0, 1, 2, 3, 4, 5]a[:6:-1]
step = -1 表示从右往左
[9, 8, 7]a[6:]
从下标6开始然后输出全部,从左到右
[6, 7, 8, 9]a[6::-1]
step=-1,从下标为6开始逆序输出全部值
[6, 5, 4, 3, 2, 1, 0] -
start_index和end_index全为负
以列表 a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例
以负数下 = [-10,-9,-8,-7,-6,-5,-4,-3,-2,-1]
a[-1:-6]
step=1 从左往右 start_index=-1 和end_index=-6 从右往左
[]a[-1:-6:-1]
start_index=-1 和end_index=-6(不包含-6) 从右往左 step = -1
[9, 8, 7, 6, 5]a[-6:-1]
step=1 从左往右 start_index=-6 和end_index=-1
[4, 5, 6, 7, 8]a[:-6]
[0, 1, 2, 3]a[:-6:-1]
[9, 8, 7, 6, 5]a[-6:]
[4, 5, 6, 7, 8, 9]a[-6::-1]
[4, 3, 2, 1, 0] -
start_index和end_index 正负混合
a[1:-6]
#step = 1 从左往右 start_index=1 和end_index=-6 从左往右
[1, 2, 3]a[1:-6:-1]
[]a[-1:6]
[]a[-1:6:-1]
[9, 8, 7]
可以通过想象x轴来看正负输出的方向是否相同。
三个参数可以是表达式,但是结果必须是int型的数据 -
其他对象的切片
t=(1, 2, 3, 4)
t[1:3]
(2, 3)s = “ABCDSDE”
s[::2]
‘ACSE’“ABCDS”[1:3]
‘BC’for i in range(0,100)[4:20][5:7]:
print(i)
9 10
例子:list1 = [1,2,3,4,5,6,7]
list1[3]= [4]
list1[2:4] = [3,4]
list1[:5]=[1,2,3,4,5]
list1[3:]=[4,5,6,7]
list1[-1:4]=[]
list1[::2]=[1,3,5,7]
list1[::-1] =[7,6,5,4,3,2,1]
list1[2:6][-1:-4][::-1]=[]
面试题:
1、如果使用切片切割数据的时候,超越可迭代对象的下标会不会报错?
超越可迭代对象的下标会报错,仅仅在切割单个值的时候,其他时候不会报错
2、在python 中如何将列表反向输出?
切片
reverse()------------ 将列表进行翻转
l=['asd','bnm','123','qwd']
print(l[0][0:3:1])
print(l[1][0:3:1])
print(l[2][0:3:1])
#输出前三个单词 .