python第四次笔记

字符串

• 定义方法：
  • 第一种：’ ’ 单引号（英文输入法）
  • 第二种：" " 双引号（英文输入法）
  • 第三种：’’’ ‘’’ 三引号（英文输入法）
  • 第四种： 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]）
  0

  a[-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]) 
 #输出前三个单词 .