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. 计数排序(桶排序)

python第四次笔记_第1张图片

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

你可能感兴趣的:(python,开发语言,后端)