字节

  • 在python3以后将字符串与字节（bytes）类型彻底分开
  • 字节是不可变的序列对象
  • 在python3中，字节用于数据传输、二进制图片和文件的保存等，其中bit为计算机的最小单位，byte是可操作性的最小单位

  • 单位换算：1byte=8bit 1024byte=1KB（千字节） 1024KB=1MB（兆字节） 1024MB=1GB（吉字节） 1024KGB=1TB（太字节） 1024TB=1PB

    字节的创建

    1. b1 = b 'hello'        #形式是b'xxx'
    2. print(b1, type(b1))    #b'hello' <class 'bytes'>
    3. b2 = bytes('hello', encoding='utf-8)
    4. print(b2, type(b2))        #b'hello'  <class 'bytes'>

    字节常用类型转换

    通常来说，字节与字符串做类型转换

  • 将字节转换成字符串——解码

  • 将字符串转换成字节——编码

image.png

列表

  • 列表是有序可重复的集合，它能够进行索引、切片、追加、删除、嵌套、迭代等
  • 列表的作用
    • 可以保存多个有序数据
    • 列表可以存储对象的对象

      列表的创建

  1. 只需要将逗号分隔的不同的数据元素使用方括号括起来即可。
  2. 直接通过list()来创建即可。
    1. lst = []
    2. lst1 = ['hello', 30, 5.2, True, None]
    3. print(li1,type(li1))    #['hello',30,5.2,True,None]  <class 'list'>
    4. lst2 = list()
    5. print(list('hello'))    #['h','e','l','l','o']
    6. print(list(1234567))    报错
    第六行会报错，因为整数它不是序列类型，它是整体存储的。 TypeError：’int’ object is not iterable
  • 这里面需要注意的是，变量名最好不要使用list
  • 列表中的元素可以是任意类型的且可重复

  • list()括号中的对象是可迭代的(iterable)，即可以将元素一个一个的取出

    访问列表内的数据

  • 列表从左以0开始，为每个元素进行顺序创建下标索引，最后一个是总长度减去一。

  • 列表从右以-1开始，往左每个元素相应减去一，指导为负的总长度。
  • 访问列表的某个元素，以方括号加下标值的方式即可。注意要确保索引不越界，一旦访问的索引超过范围，就会表现异常。所以，一定要记得最后一个元素的索引是 len(list)-1。

以上内容与字符串相同

  1. li = [1,'hello',5.2,True,None]
  2. print(li[2])    #5.2
  3. print(li[0])    #1
  4. print(li[-2])    #True
  5. print(li[6])    报错

第五行报错，下标值超出范围。IndexError: list index out of range

修改列表内元素

  • 直接取出元素并进行赋值即可

    1. list1 = ['孙悟空','白龙马','猪八戒','铁扇公主','白骨精'，'小猴']
    2. list1[3] = '嘚瑟'
    3. print(list1)    #['孙悟空','白龙马','猪八戒','嘚瑟','白骨精'，'小猴']
    4. list2 = list('abc')
    5. list2[0] = 'A'
    6. print(list2)    #['A','b','c']

    删除列表内元素

  • 直接取出，利用del语句或list.pop()或list.remove()来删除

  • del li[索引值]
  • list.remove() 根据元素来删除，没有返回值
  • list.pop() 根据索引来删除指定元素，如果未指定索引，则删除最后一个 ```python li_1 = [1,2,3,4,5,6] del li_1[0] print(li_1) #[2,3,4,5,6]

li_2 = list(‘guo vai’) print(li_2.remove(‘v’)) #None print(li_2) #[‘g’,’u’,’o’,’ ‘,’a’,’i’]

li_3 = list(‘gaier’) print(li_3.pop()) #r print(li_3.pop(2)) #i 这里要注意！！！ print(li_3) #[‘g’,’a’,’e’]

  1. <a name="Mt7G0"></a>
  2. ## 切片
  4. - 切片是指从现有列表中获得一个子列表，进而通过切片来获取指定的元素
  5. - 语法：slice(start, stop[, step])    分别是起始位置(默认为0)、结束位置 左闭右开区间、步长
  6. - 通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
  7. - 起始位置和结束位置的索引可以不写
  8. - 如果省略结束位置, 则会从当前的开始位置一直截取到最后
  9. - 如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素
  10. - 如果开始位置和结束位置都省略, 则则会从第一个元素开始截取到最后一个元素
  11. - 步长表示每次获取元素的间隔，默认是1(可以省略不写)，可以是是负数，但不能为0
  12. - 倒叙输入[::-1]
  13. ```python
  14. list1 = ['孙悟空','白龙马','猪八戒','铁扇公主','白骨精'，'小猴']
  15. print(list[3:5])    #['铁扇公主','白骨精']
  16. print(list[-2:-5:-1])    #['白骨精','铁扇公主','猪八戒']

列表的常见操作

  1. 加法：将列表进行拼接

  2. 乘法：对字符串进行复制

    li_1 = [1,2,3]
li_2 = [4,5,6]
print(li_1 + li_2)    #[1,2,3,4,5,6]
print(li_1 * li_2)    报错,列表与列表间不能相乘
print(li_1  *3)        #[1,2,3,1,2,3,1,2,3]

  3. 成员运算符：in 和 not in，返回的是布尔值

    li = ['孙悟空','白龙马','猪八戒','铁扇公主','白骨精']
print('白龙马' in li)           #True
print('小猴' in li)            #False
print('小猴' not in li)        #True
lst = [1,2,3,['小胖',6]]           嵌套列表
print(lst[3][0])             #'小胖'

  4. 迭代

    li = [1,2,3]
for i in li:
 print(i)    #1,2,3

    li = [1,2,3,4,5]
for i in range(li):
 li.remove(i)
 print(li)    #[2,4]

  5. len()返回长度、max()返回最大值、min()返回最小值

    li_1 = list('abc')
print(len(li_1))    #3
print(max(li_1))    #c
print(min(li_1))    #a
li_2=[1,2,'a']
print(max(li_2))    报错！

    注意：

    • 字符串与字符之间比较的是ASCII码
    • 字符串与整数比较会报错 TypeError:’>’ not supported between instances of ‘int’ and ‘str’
    • 以上方法都是 python 内置方法

      列表的排序和反转

  • 列表的反转list.reverse()来实现，此外可进行切片
  • list.sort() 列表的排序，默认升序
  • list.sort(reverse=True) 实现列表反转
    lst = [1,2,34,6,8,10,47,4,7,22]
print(lst[::-1])        #[22，7，4，47，10，8，6，34，2，1]
print(lst.reverse())    #None 说明无返回值
l = [54,38,2,290]
l.reverse()
print(l)                #[290,2,38,54]

    其他操作

    L.count(object) --> 统计某个元素在列表中出现的次数
L.extend(iterable) --> 用新列表扩展原来的列表
L.index(value） --> 从列表中找出某个值第一个匹配项的索引位置
L.insert(index, object)--> 将对象插入列表
L.pop([index]) --> 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
L.remove(value) --> 移除列表中某个值的第一个匹配项
L.reverse() --> 反向列表中元素
L.sort(reverse=False) --> 对原列表进行排序
L.copy() --> 复制列表
L.clear() --> 清空列表

  1. L.count()：统计列表中元素出现的次数，返回整数

    li_1 = [1,2,3,2,3]
print(li_1.count(3))    #2
li_2 = [1,2,3,[3,3]]
print(li_2.count(3))    #1

  2. 列表的添加

  • L.append()：向列表中的最后位置插入一个元素
  • L.insert()：向列表中指定位置插入一个元素，第一个参数是插入的位置，第二个参数是插入的内容
  • L.extend()：使用新的序列来扩展当前序列
    li1 = [1,2,3]
li1.append(4)
print(li1)        #[1,2,3,4]
li2 = [1,2,3]
li2.append([5,5])
print(li2)        #[1,2,3,[5,5]]
li3 = [1,2,3]
li3.extend([5,5])
print(li3)        #[1,2,3,5,5]
li3.extend(5)    报错
li4 = ['happy','year']
li4.insert(1,'new')
print(li4)        #['happy','new','year']
    第十行报错 TypeError: ‘int’ object is not iterable
  1. L.index()：返回元素所在索引的位置，且是最小的那个
    li = [1,2,3,2,3]
print(li.index(3))    #2

小练习

  1. 现在有a = [1,2,3,4,5,6]用多种方式实现列表的反转([6,5,4,3,2,1])并写出推导过程。

image.png

  1. 给用户9次机会猜猜1 -10个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不—致则表示错误。最终结果要求用户怎么也猜不对。

    lst = [1,2,3,4,5,6,7,8,9,10]
i = 1
while i < 10:
 num = int(input('请输入1-10内随机的一个数：'))
 lst.remove(num)
 print(lst)
 print('猜错了，请重新输入')
 i += 1
print(f'正确数字是{lst[0]}')

  2. 有两个列表lst1 = [11,22,33] lst2= [22,33,44]获取内容相同的元素。

    lst1 = [11,22,33]
lst2 = [22,33,44]
for i in range(3):
 if lst1[i] in lst2:
     print(lst[i])

  3. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中。

    import random
for i in range(1,9):
 room = random.randint(1,3)
 print(f'第{i}个老师在办公室{room}')