python第四次笔记
python第四次笔记
- 字符串
- 常见的排序
-
- 1. 选择排序
- 2. 冒泡排序
- 2. 插入排序
- 4. 计数排序（桶排序）
- 切片
字符串
- 定义方法：
- 第一种：’ ’ 单引号（英文输入法）
- 第二种：" " 双引号（英文输入法）
- 第三种：’’’ ‘’’ 三引号（英文输入法）
- 第四种： 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])
#输出前三个单词 .