1.听写
1.声明一个列表
list0 = [23, 72, 91, 22, 65, 31]
对列表进行升序排序 [使用排序算法]
冒泡
每一次遍历 都是从左向右 两两元素进行比较
for out in range(1, len(list0)):
for i in range(0, len(list0) - out):
if list0[i] > list0[i + 1]:
选择
第一次遍历
取第一位置0的元素与之后每一个元素进行比较
for out in range(0, len(list0) - 1):
for i in range(out + 1, len(list0)):
if list0[out] > list0[i]:
插入
第一次取脚标为1的元素 向前 两两进行比较
第二次取脚标为2的元素 向前 两两进行比较
for out in range(1, len(list0)):
for i in range(out, 0, -1):
if list0[i] < list0[i-1]:
2.list1 = ["22", "hello", "good", "box", "little"]
在列表最后添加元素 "look at"
list1.append("look at")
移除脚标1位置的元素
list1.pop(1)
在脚标1的位置插入元素 "province"
list1.insert(1, "province")
移除元素good
list1.remove("good")
利用列表提供的排序方式: 按照字符串长度对列表进行降序排序
list1.sort(key=len, reverse=True)
2.课堂概述
二分法查找算法
列表排序实现流程
元组的使用
字典的使用
集合的使用
3.列表中元素的查找
顺序查找
# 遍历列表
从头到尾 与查找的元素进行对比 找到返回位置 找不到返回-1
list0 = [23, 45, 67, 87, 52, 23]
# find-index
index = list0.index(23)
print(index) # 找到返回位置 找不到报错
# 顺序查找
def search(src_list, key):
for i in range(0, len(src_list)):
if src_list[i] == key:
return i
index = search(list0, 25)
print(index)
'''
查找指定元素在列表中出现所有位置 位置可能有多个 所以需要一个容器来存放这多个数据
找到返回所有的脚标 找不到返回-1
'''
def search_all(src_list, key):
if key not in src_list:
return -1 # 遍历完成之后 函数没有结束 这种情况下没有找到 return -1
index_list = [] # 声明一个空的容器来进行存放
for i in range(len(src_list)):
if src_list[i] == key:
index_list.append(i)
return index_list
res = search_all(list0, 25)
print(res)
二分法来进行查找
前提:有序列表的情况下才可以进行二分法查找[以升序为例 小--->大]规则的:
先设定一个查找区间 [用索引来进行设定的]
初始区间 [0, len(list0)-1]
获得中间索引mid 判定中间索引对应的元素是否与 待查找的元素key相等
不相等的情况下 需要继续查找
key < list0[mid] 更新区间 缩小查找范围 [0, mid - 1]
重新设定中间索引mid 再去进行比较 判定
key > list0[mid] 更新区间 缩小查找范围 [mid + 1 ,len(list0)-1]
重新设定中间索引mid 再去进行比较 判定
list0 = [12, 34, 57, 81, 96, 108]
list0.sort()
#设定待查找元素
key_item = 109
#设置初始查找区间
min_index = 0
max_index = len(list0) - 1
#获得中间索引
mid_index = (min_index + max_index) // 2
#重复查找操作
while list0[mid_index] != key_item:
if key_item > list0[mid_index]:
min_index = mid_index + 1
elif key_item < list0[mid_index]:
max_index = mid_index - 1
if max_index >= min_index: # 区间发生变化 盘判断区间是否合理
mid_index = (min_index + max_index) // 2 # 更新中间索引 再去重新查找
else:
print("对不起, 没有该元素") #区间不合理
break # 不用再继续查找
else:
print("%d在列表的%d位置处" % (key_item, mid_index)) #找到了
# 定义为函数
def half_search_desc(src_list, key):
src_list.sort(reverse=True) # 大--->小
min_index = 0
max_index = len(src_list) - 1
mid_index = (min_index + max_index) // 2
while max_index >= min_index: #判定区间是否合理进行查找
if key > src_list[mid_index]:
max_index = mid_index - 1
elif key < src_list[mid_index]:
min_index = mid_index + 1
else:
return mid_index #代表找到了
mid_index = (min_index + max_index) // 2 #区间更改之后 更新中间索引
else:
return -1 #区间不合理
列表也提供了查找方式 index
查找某个元素第一次出现的位置
4.元组的使用
元组本身也是一个容器 与列表类似
区别: 元组的长度不能发生变化 —> [不能添加元素]
元组中元素对应的地址值不能发生变化
元组中如果只有一个元素 该元素后面必须添加逗号 否则会将小括号视为提高优先级的运算符 与元组无关
在元组添加的元素 也会为其添加编号 这个编号是从0开始
元组的常用方法
#1.声明方式
tuple1 = tuple() # 声明的是一个空元组()
# 可以放置序列 元组中的内容是序列中的每一个元素
tuple1 = tuple("abcdefg")
print(tuple1) #('a', 'b', 'c', 'd', 'e', 'f', 'g')
# 生成的元组中包含逗号
tuple1 = tuple([12])
print(tuple1) #(12,)
a = (10,)
print(a)
print(type(a)) #<class 'tuple'>
#2.运算符的操作 与列表中类似
+ 将两个元组的内容拼接在一起 生成一个新的元组
* 乘以数值 将元组的中复制n倍 生成一个新的元组
== 比较的是元组中的内容是否相等
!=
>=
<=
>
<
tuple2 = (12, 34, 56)
tuple3 = (22, 71, 19)
new_tuple = tuple2 + tuple3
new_tuple = tuple2 * 2
tuple4 = (12, 34, 56)
print(id(tuple2))
print(id(tuple4)) # 地址不同
tuple5 = (12, 34, ["a", "b"])
'''
操作元组中的元素 只能获取 不能直接修改元素的地址
[0,len(tuple5)- 1] 或 [-len(tuple5), -1]
元组元素地址不可修改
'''
tuple5[0] = 13
print(tuple5) #TypeError: 'tuple' object does not support item assignment
#这个可以 因为脚标2的位置地址没有发生变化
tuple5[2][0] = "m"
tuple0 = (12, 56, 78, 91, 12, 45, 72, 12)
# 获得元组指定元素出现的次数
num = tuple0.count(12)
print(num)
# 获得元组元素的个数
length = len(tuple0)
print(length)
# 获得最值
max_value = max(tuple0)
print(max_value)
min_value = min(tuple0)
print(min_value)
# 遍历
for item in tuple0:
print(item)
for i in range(length):
print(tuple0[i])
# 查找某个元素第一次出现的位置
index = tuple0.index(12)
print(index)
# 从指定位置开始查找
index = tuple0.index(12, 1)
print(index)
# 从指定区间进行查找[1, 3)
index = tuple0.index(12, 1, 5)
print(index) # 找到返回索引 找不到报错
5.字典的使用
字典也是一个容器 存放的是具有映射关系的键值对 在字典中存放的元素是成对出现的
注意:字典的键是唯一 不允许重复的 [需要通过键来获得对应的值]
字典中的value是可以重复的
字典中键值对是没有编号的 不可以通过索引来获取
字典也是无序的容器 [存放顺序和显示顺序]
使用字典的场景: 数据需要成对展示的时候
字典的常用方法
#1.字典的声明方式
dict0 = dict() #创建出来的是空字典 {}
dict0 = dict({"A":15, "B":17})
# 如果传递序列的话 传递的是嵌套的序列
dict0 = dict([[12, 34],[22, 34]])
# 变量=值
dict0 = dict(姓名="小沐", age=18)
dict0 = {"语文":87, "数学":22}
# 没有索引
item = dict0[0]
print(item) #KeyError: 0
# 获取value的方式 根据键来获取的 字典名[key]
value = dict0["数学"]
# 如果key不存在 这种获取方式会报错
value = dict0["英语"]
print(value) #KeyError: '英语'
# 另外一种获取方式 如果键不存在 会返回None
value = dict0.get("英语")
print(value)
# 设置值的方式
# 修改值 前提键存在的情况下修改[新值覆盖旧值] 如果不存在会添加为新的键值对
dict0["数学"] = 45
dict0["英语"] = 60
dict0.setdefault("政治", 55)
# 提供了set方法 注意: 如果键不存在于键值对中 才会将值赋予给对应键 如果存在就不会赋值了
# D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
dict0.setdefault("政治", 75)
# update的方法 合并字典 不会新生成一个字典 而是直接影响当前字典
dict1 = {"历史":55, "地理":78}
dict0.update(dict1)
print(dict0)
# 获得字典中键值对的个数
length = len(dict0)
print(length)
# 关于字典的遍历
# 直接遍历字典--->其实遍历的是键
for k in dict0:
print(k)
# 只遍历值 获得字典中所有的值
values = dict0.values()
print(values)
for v in dict0.values():
print(v)
# 遍历字典的键值对
# 获得所有的键值对 将键和值成对存放于元组中
items = dict0.items()
print(items)
for item in dict0.items():
print(item)
for k, v in dict0.items():
print(k, v)
# 删除元素:根据键删除键值对
dict0.pop("英语")
print(dict0) # KeyError: '英语' 如果不存在报错
# 直接删除键值对 删除的是确定位置后最后一个
dict0.popitem()
print(dict0)
# 清空字典
dict0.clear()
print(dict0)
练习
键盘录入一句英语 英语的每个单词之间使用空格隔开
统计每个单词出现的次数
hello hello good nice nice
hello 2
good 1
nice 2
键盘录入一个字符串 统计每个字符出现的次数
content = input("请输入一句英语 每个单词之间使用空格隔开:")
print(content)
#切割 切割符是空白
word_list = content.split()
print(word_list)
#声明一个空的字典 来存放单词和数量成对的数据
word_dict = {} #key是单词 value是单词数量
for word in word_list:
if word not in word_dict: #第一次进来
word_dict[word] = 1
else: #这种情况表示不是第一次来 需要在原有的次数上加1 获得原有次数
value = word_dict[word] + 1
word_dict[word] = value
print(word_dict)
for item in word_dict.items():
print(item)
6.集合的使用
集合无序的容器 也没有索引 存放的元素不能重复
常用的方式: 使用其进行排重
使用方法
# 声明集合的方式
set0 = set() #空集合 这个设置空集合的唯一方式
set0 = set("abcdefg")
# 集合有数据的时候是使用大括号包含的 但是没有数据的时候不能直接使用 {} 表示空集合 因为{}表示的是空字典
# 向集合中添加元素
set0.add(72)
# 移除任意一个
set0.pop()
# 删除指定元素
set0.discard(13)
set0.remove(13) #KeyError:存在就直接删除 如果不存在报错
# 运算符的使用
set1 = {12, 34, 77}
new_set = set0 - set1 #在前者中去除掉与后者的交集部分
# 合并两个集合
set2 = {12, 34, 56}
set3 = {12, 77, 65}
# 合并完成之后生成一个新的集合
new_set = set2.union(set3)
# 在原有集合的基础上 合并其他集合
set2.update(set3)
# 判断一个集合是否另外一个集合的子集
set4 = {13}
set5 = {12, 56, 71}
res = set4.issubset(set5)
# 判断一个集合是否包含另外一个集合
res = set5.issuperset(set4)
# 判断两个集合是否没有交集
res = set4.isdisjoint(set5)
# 在一个集合中移除另外一个集合与自己的交集
set0 = {43, 67, 81, 29}
set1 = {43, 22, 67}
set0.difference_update(set1)
# 清空集合
set0.clear()
print(set0)