前言
Java后端技术点
StringUtils常用API
学习时笔记(Linux)
学习时笔记(Git)
学习时笔记(Docker)
学习时笔记(Vue2+3)
面试宝典
学习时笔记(JavaScript)
学习时笔记(JavaWeb)
学习时笔记(Java)
学习时笔记(Python)
1.Python入门
2.Python基础语法
3.Python判断语句
4.Python循环语句
5.Python函数
6.Python数据容器
7.Python函数进阶+文件操作
8.Python异常+模块与包
9.案例：折线图+地图+柱状图
10.面向对象
11.PySpark
12.高阶技巧
13.爬虫-urllib
14.爬虫-解析+selenium+requests
15.爬虫-scrapy
1.数据容器入门
- Python中的数据容器
- 一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素可以是任意类型的数据，如字符串、数组、布尔等
- 数据容器根据特点的不同，如：
- 是否支持重复元素
- 是否可以修改
- 是否有序等
- 五类数据容器
- 列表(list)、元组(tuple)，字符串(str)，集合(set)、字典(dict)
2.数据容器：list(列表)
- 列表的定义基本语法
#字面量
[元素1,元素2,元素3,...]
#定义变量
变量名称 = [元素1,元素2,元素3,...]
#定义空列表
变量名称 = []
变量名称 = list()
列表内的每一个数据，称之为元素。以[]作为表示，每个元素之间逗号分隔
# 定义一个列表 list
names = ["mahaonan","chengminghui","lize","wusai"]
print(names)
print(type(names))
print("----------------")
content = ["mahaonan",111,True]
print(content)
print(type(content))
print("----------------")
# 定义一个嵌套的列表
my_list = [[1,2,3],[7,8,9]]
print(my_list)
print(type(my_list))
print("----------------")
注意事项：列表可以一次存储多个数据，且可以不是同一类型的数据，支持嵌套
列表的下标索引：正向（与Java一致）
# 通过下标索引取出对应位置的数据 names = ["mahaonan","chengminghui","lize","wusai"] # 列表[下标索引] 从前向后从0开始， 从后向前从-1开始 -1 -2 -3... print(names[0]) print(names[1]) print(names[2]) print(names[3])列表的下标索引：反向
- 从-1开始，依次递减（-1 -2 -3 -4)
# 通过下标索引取出数据（倒叙取出） print(names[-1]) print(names[-2]) print(names[-3]) print(names[-4])嵌套列表的下标
# 取出嵌套列表的元素
my_list = [[1,2,3],[7,8,9]]
print(my_list[1][1])
列表的常用操作
- 查询功能(查询某元素的下标)：列表.index(元素)
names = ["mahaonan","chengminghui","lize","wusai"] # 1.1查找某元素在列表内的下表索引 print(f"lize在列表中的索引位置是：{names.index('lize')}") # 1.2如果被查找的元素不存在，则会报错 # print(names.index(111))- 修改功能(修改特定位置的元素值) 列表[下标] = 值
# 2.修改指定下表索引的值 names[0] = "马浩楠"- 插入元素(在指定的下标位置，插入值)：列表.insert(下标,元素)
# 3.在指定下表位置插入新元素 names.insert(4,"fox") print(f"列表添加后的内容是：{names}")- 追加元素(将元素追加到列表的尾部)：列表.append(元素)
# 4.在列表的尾部追加 单个 新元素 names.append("浩楠") print(f"列表追加新元素后的内容是：{names}") # 5.在列表的尾部追加 一批 新元素 nums = [1,2,3] names.extend(nums)- 删除元素：del 列表[下标]、列表.pop(下标)
# 6.1方式1：del 列表[下标] del names[0] print(f"列表删除元素后的内容是：{names}") #6.2方式2： 列表.pop(下表) delElement = names.pop(4)- 删除某元素在列表中的第一个匹配项
# 7.删除某个元素在列表中的第一个匹配项 names = ["mahaonan","chengminghui","lize","wusai","mahaonan"] names.remove("mahaonan") print(f"删除列表中的元素后，列表的内容是：{names}")- 清空列表内容：列表.clear()
# 8.清空列表 nums = [1,2,3,4] nums.clear() print(f"清空列表后，列表的内容是：{nums}")- 统计某元素在列表内的数量：列表.count(元素)
# 9.统计列表内某元素的数量 nums = [1,2,3,4,2,4,2,2] count = nums.count(2) print(f"查询数据2在该nums列表中的个数为：{count}")- 统计列表内有多少元素：len(列表)
# 10.统计列表中全部的元素数量 count = len(nums) print(f"统计nums列表中元素的个数是：{count}")列表方法总览
列表的特点
- 可以容纳多个元素
- 可以容纳不同类型的元素（混装）
- 数据是有序存储的（有下标）
- 允许重复数据存在
- 可以修改和删除
练习
# 1.定义列表，并用变量接收
ages = [21,25,21,23,22,20]
# 2.追加数字31,到列表尾部
ages.append(31)
# 3.追加一个新列表[29,33,30]，到列表的尾部
ages.extend([29,33,30])
# 4.取出第一个元素 (21)
print(ages[0])
# 5.取出最后一个元素(30)
print(ages[-1])
# 6.查找元素31，在列表中的下标位置
print(f"元素31在列表中的下标位置：{ages.index(31)}")
3.list(列表)的遍历
- while循环遍历
names = ["马浩楠","程明辉","李泽","吴赛"]
def list_while():
i = 0
while i<len(names):
print(names[i],end='\t')
i += 1
print()
list_while()
- for循环遍历
def list_for():
for i in names:
print(i,end='\t')
list_for()
- 两种方法对比
- 在循环控制上
- while循环可以自定义循环条件，并自行控制
- for循环不可以自定义循环条件，只可以一个个从容器内取出数据
- 在无限循环上
- while循环可以通过条件做到无限循环
- for循环理论上不可以，因为被遍历的容器容量不是无限的
- 在使用场景上
- while循环适用于任何想要循环的场景
- for循环适用于，遍历数据容器的场景或简单的固定次数循环的场景
- 在循环控制上
- 练习
nums = [1,2,3,4,5,6,7,8,9,10]
even = []
for i in nums:
if i%2==0:
even.append(i)
print(f"通过for循环，从列表：{nums}中取出偶数，组成新列表：{even}")
i = 0
even = []
while i<len(nums):
if nums[i]%2==0:
even.append(nums[i])
i += 1
print(f"通过while循环，从列表：{nums}中取出偶数，组成新列表：{even}")
4.数据容器：tuple(元组)
列表是可以修改的，如果想要传递的信息不被篡改，那么元组就较为合适
定义元组
- 定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
# 字面量 (元素1,元素2,元素3,....) # 定义元组变量 变量名称 = (元素1,元素2,元素3,....) # 定义空元组 变量名称 = () 变量名称 = tuple()
# 定义元组 tuple
t1 = ("马浩楠",22,True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t2的类型是：{type(t2)},内容是：{t2}")
print(f"t3的类型是：{type(t2)},内容是：{t2}")
# 元组的嵌套
t5 = ((1,2,3),(7,8,9))
print(f"t5的类型是：{type(t5)},内容是：{t5}")
注意点：元组只有一个数据的时候，定义的类型为str，数据后需要添加逗号，则改数据为元组
# 定义单个元组的元素
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},内容是：{t4}")
- 元组的相关操作
t5 = ((1,2,3),(7,8,9))
# 取出嵌套元组的单个元素
print(f"取出t5元组中的8：{t5[1][1]}")
# 元组的操作：index 查找方法
t6 = ("马浩楠","程明辉","李泽","吴赛","马浩楠","马浩楠")
print(f"马浩楠在该元组中的下标为：{t6.index('马浩楠')}")
# 元组的操作：count 统计某个元素个数的方法
print(f"统计马浩楠在该元组中的个数：{t6.count('马浩楠')}")
# 元组的操作： len 函数统计元组数量
print(f"统计该元组中的数量：{len(t6)}")
注意事项
- 不可以修改元组的内容，否则会直接报错
- 可以修改元组内的list的内容
# 元组的元素是不可以修改的，但如果内嵌的有list列表，则可以修改list列表中的值 t = (1,2,["马浩楠","张林烟"]) print(f"t的元组内容是：{t}") t[2][0] = "浩楠" t[2][1] = "林燕" print(f"t的元组内容是：{t}")- 不可以替换list为其它list或其它类型
元组的遍历
- while
t6 = ("马浩楠","程明辉","李泽","吴赛","马浩楠","马浩楠") i = 0 while i<len(t6): print(t6[i],end='\t') i += 1 print()- for
for i in t6: print(i,end='\t') print()元组的特点
- 和list列表一致
- 不同在于：不可以修改
练习
t = ("周杰伦",11,["football","music"])
# 2.1 查询其年龄所在的下标位置
print(f"年龄在该元组的下标为：{t.index(11)}")
# 2.2查询学生的姓名
print(f"学生的姓名为：{t[0]}")
# 2.3 删除学生爱好中的football
# 方式一：t[2].pop(t[2].index("football"))
del t[2][0]
print(f"删除学生爱好中的football，删除后的元组内容：{t}")
# 2.4 增加爱好：coding到爱好list内
t[2].append("coding")
print(f"增加爱好coding到list内，增加后的元组内容：{t}")
5.数据容器：str(字符串)
- 字符串的下标：与列表、元组一样，也可以通过下标进行访问单个字符
- 从前向后，下标从0开始
- 从后向前，下标从-1开始
同元组一样，字符串是一个无法修改的数据容器
字符串的常用操作
- 查找特定字符串的下标索引值
# 通过下标索引取值 print(f"下标为2的值：{my_name[2]}，取最后一个下标的值：{my_name[-1]}") # index方法 print(f"haonan在该字符串中的下标位置：{my_name.index('haonan')}")- 字符串的替换：字符串.replace(字符串1,字符串2)
不是修改了字符串本身，而是得到了一个新的字符串
# replace方法:会返回新的字符串（替换后的） print(f"将mahaonan替换为haonan，替换后的内容是：{my_name.replace('mahaonan','haonan')}")- 字符串的分割：字符串.split(分隔符)
字符串本身不变，而是得到了一个列表对象
# split 方法：会将字符串分割为列表返回 print(f"通过,来分割该字符串内容：{my_name.split(',')},类型为：{type(my_name.split(','))}")- 字符串的规整操作（去除前后空格）：字符串.strip()
# strip() 方法：取出前后的空格 str = " my name is mahaonan " print(f"去除空格后的内容为：{str.strip()}")- 字符串的规整操作（去除前后指定字符串）：字符串.strip(指定字符串)
传入指定字符串是12，按照单个字符进行去除，1 和 2 都会移出
# strip(指定字符) 方法：去除前后指定字符串 str = "123 my name is mahaonan 321" print(f"去除前后123后的内容为：{str.strip('123')}")- 统计字符串中某个字符串出现的次数：字符串.count(字符串)
# 统计字符串某字符的出现次数 print(f"统计n在该字符串中出现的次数：{my_name.count('n')}")- 统计字符串的长度：len(字符串)
# 统计字符串的长度 print(f"统计该字符串的长度：{len(my_name)}")字符串常用API总览
字符串特点：与元组相同
- 不同在于：只可以存储字符串
练习
str = "itheima itcast boxuegu"
# 统计字符串内有多少个 it 字符
print(f"字符串{str}中有：{str.count('it')}个it字符")
# 将字符串内的空格，全部替换为字符：|
str = str.replace(' ','|')
print(f"字符串{str}，被替换空过后，结果：{str}")
# 按照 | 进行字符串分割，得到列表
str_list = str.split("|")
print(f"字符串{str}，按照|分割后得到：{str_list}")
6.数据容器（序列）的切片
序列
- 指内容连续、有序，可使用下标索引的一类数据容器
- 列表、字符串、元组，均可以视为序列
序列的常用操作——切片
- 从一个序列中，取出一个子序列
- 语法：
序列[起始下标:结束下标:步长]- 起始下标表示从何开始，可以留空，留空视作从头开始
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示依次取元素的间隔
注意：此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
- 示例
# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6,7]
print(f"结果1：{my_list[1:4:1]}")
# 对cuple进行切片，从头开始，到最后结束，步长1
my_cuple = (0,1,2,3,4,5,6,7)
print(f"结果2：{my_cuple[:]}")
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
print(f"结果3：{my_str[::2]}")
# 对str进进行切片，从头开始，到最后结束，步长-1
print(f"结果4：{my_str[::-1]}")
# 对list进行切片，从3开始，到1结束，步长-1
print(f"结果5：{my_list[3:1:-1]}")
# 对cuple进行切片，从头开始，到尾结束，步长-2
print(f"结果6：{my_cuple[::-2]}")
- 练习
# 练习
str = "万过薪月，员序程马黑来，nohtyP学"
print(str[-10:-15:-1])
str = str[::-1]
print(str)
str_list = str.split("，")
print(str_list)
print(str_list[1][1::1])
7.数据容器：set(集合)
集合，最主要的特点结束：不支持元素的重复（自带去重功能）、并且内容无序
集合的定义
# 字面量 {元素1,元素2,元素3,...} # 定义集合变量 变量名称 = {元素1,元素2,元素3,...} # 定义空集合 变量名称 = set()和列表、元组、字符串等定义基本相同
- 列表使用：[]
- 元组使用：()
- 字符串使用：""
- 集合使用：{}
集合的常用操作
因为集合是无序的，所以集合不支持下标索引访问，但是集合和列表一样，是允许修改的
- 添加新元素：集合.add(元素)
# 定义集合 mySet = {"mahaonan","chengminghui","lize","wusai","mahaonan"} print(f"集合的内容：{mySet}") # 添加新元素 mySet.add("haonan")- 移出元素：集合.remove(元素)
# 移出元素 mySet.remove("mahaonan") print(f"集合删除mahaonan元素后的内容为：{mySet}")- 从集合中随机取出元素：集合.pop()
会得到一个元素的结果，同时集合本身被修改，元素被移出
# 随机取出一个元素 print(f"随机取出一个元素{mySet.pop()},取出元素后，原集合的内容是：{mySet}")- 清空集合：集合.clear()
# 清空集合 mySet.clear() print(f"清楚集合元素后的内容是：{mySet}")- 取出2个集合的差集：集合1.difference(集合2) 【集合1有而集合2没有的】
会得到一个新集合，集合1和集合2不变
# 取2个集合的差集 set1 = {1,2,3,5,6} set2 = {1,8,9,7} print(f"取出两个集合的差集是：{set1.difference(set2)}") #2 3 5 6 原集合都不变- 消除2个集合的差集：集合1.difference_update(集合2)【在集合1内
集合1被修改，集合2不变
# 消除2个集合的差集 set1.difference_update(set2) print(f"消除两个集合的差集后，集合1的内容：{set1}，集合2的内容：{set2}") # 集合1，消除了差集 2,3,5,6 集合2不变- 2个集合合并：集合1.union(集合2)
得到新集合，集合1和集合2不变
# 2个集合合并为1个 set1 = {1,2,3} set2 = {1,5,6} newSet = set1.union(set2) # set1和set2集合合并，原集合不变，返回新的集合 print(f"合并后的集合内容是：{newSet}")- 查看集合的元素数量：len(集合)
# 统计集合元素的数量 mySet = {"mahaonan","chengminghui","lize","wusai","mahaonan"} print(f"集合元素的数量是：{len(mySet)}")- for 循环遍历
# 遍历集合 for i in mySet: print(f"集合中的元素：{i}")集合常用功能总结
集合的特点
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改
案例
names = ["马浩楠","程明辉","李泽","吴赛","浩楠","程明辉","李泽","吴赛"]
mySet = set()
for i in names:
mySet.add(i)
print(f"元素去重后的集合对象：{mySet}")
8.数据容器：dict(字典)
- 字典的定义
- 同样使用{}，不过存储的元素是一个个的：键值对
# 定义字典
my_dict = {"马浩楠":99,"程明辉":88,"李泽":77,"吴赛":66}
print(f"字典内容是：{my_dict}，类型是：{type(my_dict)}")
# 定义空字典
my_dict1 = {}
my_dict2 = dict()
print(f"字典内容是：{my_dict1}，类型是：{type(my_dict1)}")
print(f"字典内容是：{my_dict2}，类型是：{type(my_dict2)}")
- 字典数据的获取
# 定义重复key的字段
my_dict = {"马浩楠":99,"马浩楠":88,"李泽":77,"吴赛":66}
print(f"重复字典内容是：{my_dict}") #{'马浩楠':88,'李泽':77,'吴赛':66}
# 从字典中基于key获取value
print(my_dict["李泽"])
- 字典的嵌套
# 定义嵌套字典
my_dict = {
"马浩楠":{
"数学":88,
"英语":59,
"语文":55
},"程明辉":{
"数学":78,
"英语":77,
"语文":92
}
}
# 从嵌套字典中获取数据
print(my_dict["马浩楠"]["语文"])
8.1、字典的常用操作
- 新增元素 and 修改元素： 字典[key] = value
字典key不可以重复，所以对已经存在的key执行操作则是修改，没有key则是新增
my_dict = {"马浩楠":99,"程明辉":88,"李泽":77,"吴赛":66}
# 新增元素
my_dict["浩楠"] = 100
print(f"新增元素后的字典内容：{my_dict}")
# 更新元素 新增和更新是一个方法，字典内存有数据则为修改，若没有该key 则增加
my_dict["马浩楠"] = 60
print(f"更新元素后的字典内容：{my_dict}")
- 删除元素：字典.pop(key)
# 删除元素
score = my_dict.pop("浩楠")
print(f"删除key 浩楠后的字典内容：{my_dict},删除的元素value值为：{score}")
- 清空字典：字典.clear()
# 清空元素
my_dict.clear()
print(f"清空元素后的字典内容：{my_dict}")
- 获取全部的key：字典.keys()
# 获取全部的key
my_dict = {"马浩楠":99,"程明辉":88,"李泽":77,"吴赛":66}
keys = my_dict.keys()
print(f"获取所有的key：{keys},返回的类型是：{type(keys)}")
- 遍历字典
# 遍历字典
for i in keys:
print(f"字典的key为：{i}")
print(f"字典的value为：{my_dict[i]}")
for i in my_dict:
print(f"2字典的key为：{i}")
print(f"2字典的value为：{my_dict[i]}")
- 计算字典内的全部元素数量：len(字典)
# 统计字典内的元素数量
print(f"字典的元素数量为：{len(my_dict)}")
- 字典的常用操作总结
字典的特点
- 每一份数据都是key value 键值对
通过key获取value，key值不可以重复（重复则覆盖前面的）
可以修改
练习
emps = {
"王力宏":{
"部门":"科技部",
"工资":3000,
"级别":1
},"周杰伦":{
"部门":"市场部",
"工资":5000,
"级别":2
},"林俊杰":{
"部门":"市场部",
"工资":7000,
"级别":3
},"张学友":{
"部门":"科技部",
"工资":4000,
"级别":1
},"刘德华":{
"部门":"市场部",
"工资":6000,
"级别":2
}
}
print("全体员工当前信息如下：")
print(emps)
for i in emps:
if emps[i]["级别"]==1:
emps[i]["级别"] += 1
emps[i]["工资"] += 1000
print(emps)
9.数据容器对比总结
- 下标索引
- 支持：列表、元组、字符串——序列类型
- 不支持：集合、字典——非序列类型
- 重复元素
- 支持：列表、元组、字符串——序列类型
- 不支持：集合、字典
- 修改
- 支持：列表、集合、字典
- 不支持：元组、字符串
10.数据容器的通用操作
遍历
- 5类数据容器都支持for循环遍历
- 列表、元组、字符串支持while循环，集合、字典不支持（无下标索引）
通用统计功能
- len(容器)
my_list = [1,2,3,4,5] my_tuple = (1,2,3,4,5) my_str = "abcdefg" my_set = {1,2,3,4,5} my_dict = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5} # len 元素个数 print(f"列表 元素个数有：{len(my_list)}") print(f"元组 元素个数有：{len(my_tuple)}") print(f"字符串 元素个数有：{len(my_str)}") print(f"集合 元素个数有：{len(my_set)}") print(f"字典 元素个数有：{len(my_dict)}")- max(容器)
# max 最大元素值 print(f"列表 元素最大值：{max(my_list)}") print(f"元组 元素最大值：{max(my_tuple)}") print(f"字符串 元素最大值：{max(my_str)}") print(f"集合 元素最大值：{max(my_set)}") print(f"字典 元素最大值：{max(my_dict)}")- min(容器)
# min 最小元素值 print(f"列表 元素最小值：{min(my_list)}") print(f"元组 元素最小值：{min(my_tuple)}") print(f"字符串 元素最小值：{min(my_str)}") print(f"集合 元素最小值：{min(my_set)}") print(f"字典 元素最小值：{min(my_dict)}")转换功能
- list(容器)
# 类型转换：容器转列表 print(f"列表转列表的结果是：{list(my_list)}") print(f"元组转列表的结果是：{list(my_tuple)}") print(f"字符串转列表的结果是：{list(my_str)}") print(f"集合转列表的结果是：{list(my_set)}") print(f"字典转列表的结果是：{list(my_dict)}")- tuple(容器)
# 类型转换：容器转元组 print(f"列表转元组的结果是：{tuple(my_list)}") print(f"元组转元组的结果是：{tuple(my_tuple)}") print(f"字符串转元组的结果是：{tuple(my_str)}") print(f"集合转元组的结果是：{tuple(my_set)}") print(f"字典转元组的结果是：{tuple(my_dict)}")- str(容器)
# 类型转换：容器转字符串 print(f"列表转字符串的结果是：{str(my_list)}") print(f"元组转字符串的结果是：{str(my_tuple)}") print(f"字符串转字符串的结果是：{str(my_str)}") print(f"集合转字符串的结果是：{str(my_set)}") print(f"字典转字符串的结果是：{str(my_dict)}")- set(容器)
# 类型转换：容器转集合 print(f"列表转集合的结果是：{set(my_list)}") print(f"元组转集合的结果是：{set(my_tuple)}") print(f"字符串转集合的结果是：{set(my_str)}") print(f"集合转集合的结果是：{set(my_set)}") print(f"字典转集合的结果是：{set(my_dict)}")排序功能 sorted
# sorted排序
my_list = [3,1,4,2,5]
my_tuple = (3,1,4,2,5)
my_str = "bdecagf"
my_set = {3,1,4,2,5}
my_dict = {"key3":1,"key1":2,"key4":3,"key2":4,"key5":5}
print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_set)}")
print(f"集合对象的排序结果：{sorted(my_list)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")
# 所有排序后返回的都是list列表，字典对象只会保留key
print("-------------------------------------")
# 反转
print(f"列表对象的排序结果：{sorted(my_list,reverse=True)}")
print(f"元组对象的排序结果：{sorted(my_tuple,reverse=True)}")
print(f"字符串对象的排序结果：{sorted(my_set,reverse=True)}")
print(f"集合对象的排序结果：{sorted(my_list,reverse=True)}")
print(f"字典对象的排序结果：{sorted(my_dict,reverse=True)}")
- 总览
11.字符串大小比较
- ASCII编码表
与Java一致
- 比较
- 字符串是按位比较，也就是一位位进行比对，只要有一位大，那么整体就大
# abc 比较 abd
print(f"abc > abd——{'abc' > 'abd'}")
# a 比较 ab
print(f"a > ab——{'a' > 'ab'}")
# a 比较 A
print(f"a > A——{'a' > 'A'}")
# key1 比较 key2
print(f"key1 > key2——{'key1' > 'key2'}")