python学习之路 - python的数据容器

于 2024-08-04 17:51:53 发布
阅读量553 收藏 9
点赞数 22
分类专栏： python 文章标签： python 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41444892/article/details/140909086
版权

目录

一、python数据容器

1、数据容器入门

  • 定义：一种可以容纳多份数据的数据类型，容纳的每一份数据称为1个元素，每个元素可以是任意类型的数据，如字符串、数字、布尔等
  • 分类：根据容器特点不同，可以分为列表（list），元组（tuple），字符串（str），集合（set），字典（dict）

2、数列容器：list（列表）

a、列表的定义
#字面量
[元素1,元素2,元素3...]

#定义变量
变量名称 = [元素1,元素2,元素3...]
如：name = ["python",123,True]

# 定义空列表
变量名称 = []
变量名称 = list()

# 列表的嵌套
变量名称 = [列表1,列表2,列表3...]
如：name = [["java","class"],["python",123],["C语言",True]]
b、列表的下标索引
  • 正向索引
    元素在列表中是有下标索引的，从前到后，从0开始，依次递增
# 取出对应索引中的值
name = ["java","python","C语言"]
print(name[0])		结果：java
print(name[1])		结果：python
print(name[2])		结果：C语言
  • 反向索引
    从后向前，从-1开始，依次递减
# 取出对应索引中的值
name = ["java","python","C语言"]
print(name[-3])		结果：java
print(name[-2])		结果：python
print(name[-1])		结果：C语言
  • 思考：如何获取嵌套列表中的值呢？
# 获取嵌套列表中的第二个小列表的第一个值
name = [["java","class"],["python",123],["C语言",True]]
print(name[1][0])		结果：python
c、列表的常用操作
  • 查询元素下标：列表.index(元素)
# 获取元素python的下标值
name = ["java","python","C语言"]
print(name.index("python"))
  • 修改元素：列表[下标] = 值
# 将列表的第三个元素修改为"C++"
name = ["java","python","C语言"]
name[2] = "C++"
print(name)

结果为：['java', 'python', 'C++']
  • 插入元素：列表.insert(下标，元素)
# 将列表第三个元素前插入新元素"C++"
name = ["java","python","C语言"]
name.insert(2,"C++")
print(name)

结果为：['java', 'python', 'C++', 'C语言']
  • 追加元素：列表.append(元素)
# 列表最后追加新元素"C++"
name = ["java","python","C语言"]
name.append("C++")
print(name)

结果为：['java', 'python', 'C语言', 'C++']
  • 追加一批元素：列表.extent(数据集)
# 将list1后追加list2
list1 = [1,2,3]
list2 = [4,5,6]
list1.extend(list2)
print(list1)

结果为：[1, 2, 3, 4, 5, 6]
  • 删除元素：del 列表[下标] 或者 列表.pop(下标)
# 删除列表第一个元素
list1 = [1,2,3,4,5,6]
del list1[0]		此语法只是删除元素，无法用变量接收内容
print(list1)		结果为：[2, 3, 4, 5, 6]
list1.pop(0)		此语法相当于剪切的效果，可以用变量接收内容
print(list1)		结果为：[3, 4, 5, 6]
  • 删除特定元素的第一个值：列表.remove(元素)
# 删除首次出现的1
list1 = [2,1,3,4,5,1]
list1.remove(1)
print(list1)

结果为：[2, 3, 4, 5, 1]
  • 清空列表：列表.clear()
# 清空列表
list1 = [2,1,3,4,5,1]
list1.clear()
print(list1)

结果为：[]
  • 统计元素个数：列表.count(元素)
# 统计列表中1的个数
list1 = [2,1,3,4,5,1]
print(list1.count(1))

结果为：2
  • 统计列表元素个数：len(列表)
list1 = [1,2,3,4,5,6]
num = len(list1)
print(num)

结果为：6

3、list（列表）的遍历

  • while循环遍历列表
i = 0
list1 = [1,2,3,4,5,6,7,8,9]
while i < len(list1):
    print(list1[i])
    i += 1
  • for循环遍历列表
list1 = [1,2,3,4,5,6,7,8,9]
for i in list1:
    print(i)
  • 案例
    循环列表，取出列表中的偶数并放入新的列表中
# while循环的方式
list1 = [1,2,3,4,5,6,7,8,9,10]
list2 = []
i = 0
while i < len(list1):
    if list1[i] % 2 == 0:
        list2.append(list1[i])
    i += 1

print(list2)

# for循环的方式
list1 = [1,2,3,4,5,6,7,8,9,10]
list2 = []
for i in list1:
    if i % 2 == 0:
        list2.append(i)
print(list2)

4、数据容器：tuple（元组）

a、定义格式
# 定义元组字面量
(元素1,元素2,元素3....)
# 定义元组变量
变量名称 = (元素1,元素2,元素3....)
# 定义空元组
变量名称 = ()
变量名称 = tuple()

注意：定义单个元素的元组时，后面需要打逗号
t1 = ("hello")		此时的类型为str
t1 = ("hello",)		此时的类型为tuple

#元组的嵌套
t1 = ((1),(2,3),(4,5)...)
b、特点
  • 元组和列表一样，可以封装多个不同类型的元素
  • 允许重复元素
  • 元组一旦定义完成，则不可修改
  • 特例：如果元组中的元素是一个列表，列表中的元素可以修改
c、常见操作
  • 查找某元素：元组.index(元组值)
#查看元组中2的索引
t1 = (1,2,3,4)
print(t1.index(2))

结果为：1
  • 统计某个数据出现次数：元组.count(元素值)
# 总计元组中1的个数
t1 = (1,2,3,4,1)
print(t1.count(1))

结果为：2
  • 统计元组内元素个数：len(元组)
# 统计元组内的元素个数
t1 = (1,2,3,4)
print(len(t1))

结果为：4
  • while循环遍历元组
t1 = (1,2,3,4)
i = 0
while i < len(t1):
    print(t1[i])
    i += 1
  • for循环编辑元组
t1 = (1,2,3,4)
for i in t1:
    print(i)

5、数据容器：str（字符串）

  • 和其他容易（列表，元组）一样，字符串也是可以通过下标进行访问的
  • 从前向后，下标从0开始增加。从后向前，下标从-1开始减少
  • 字符串本身不能修改，如要修改只能得到一个新的字符串
s1 = 'hello'
print(s1[0])
print(s1[-5])

结果都为：h
  • 字符串的替换：字符串.replace(被替换的字符串,替换为的字符串)
#将字符串中的1替换成2
s1 = '1234561'
s2 = s1.replace('1','2')
print(s2)

结果为：2234562
  • 字符串的分割：字符串.split(分割符字符串)
    得到的是一个列表
#按空格切割字符串
s1 = "hello i am a programmer"
l1 = s1.split(" ")
print(l1)

结果为：['hello', 'i', 'am', 'a', 'programmer']
  • 去掉字符串前后空格：字符串.strip()
#去掉hello前后空格
s1 = " hello "
s2 = s1.strip()
print(s1)
print(s2)

结果为：
 hello 
hello
  • 去掉前后指定字符串：字符串.strip(要去除的字符串)
    注意：只要字符串前后存在要去除的字符串内容，无论顺序如何都能被去除
#去掉hello前后的12
s1 = "12hello21"
s2 = s1.strip("12")
print(s2)

结果为：hello

这里无论s1是"12hello12"，还是"12hello21"，或者"21hello12"，前后的12的内容都能被去除掉
  • 统计字符串中某字符串的出现次数：字符串.count(字符串)
#统计hello字符串中l有几个
s1 = "hello"
print(s1.count("l"))

结果为：2
  • 统计字符串的长度：len(字符串)
#统计hello字符串的长度
s1 = "hello"
print(len(s1))

结果为：5

6、数据容器的切片

a、定义

序列支持切片，即列表、元组、字符串都支持切片操作
切片是从一个序列中取出一个子序列

b、语法
  • 语法：序列[起始下标：结束下标：步长]
  • 切片输入内容包含起始下标对应内容，不包含结束下标对应内容
  • 表示序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新的序列
  • 步长为1时，表示一个一个取元素。步长为2时，表示跳过1个元素取。步长为负数时，表示反向取，此时的起始下标和结束下标也要反向标记
#对list1进行切片，从1开始，4结束，步长为1
list1 = [0,1,2,3,4,5,6]
list2 = list1[1:4]		步长为1时可省略不写
print(list2)
结果为：[1, 2, 3]

#对tuple1进行切片，从头到尾，步长为1
tuple1 = (0,1,2,3,4,5,6)
tuple2 = tuple1[:]		起始和结束不写表示从头到尾，步长1时可省略
print(tuple2)
结果为：(0, 1, 2, 3, 4, 5, 6)

#对str进行切片，从头到尾，步长为2
str1 = "0123456"
str2 = str1[::2]		起始和结束不写表示从头到尾
print(str2)
结果为：0246

#对list反向切片，从头到尾，步长为-1
list1 = [0,1,2,3,4,5,6]
list2 = list1[::-1]
print(list2)
结果为：[6, 5, 4, 3, 2, 1, 0]

#对tuple反向切片，从6到1，步长为-2
tuple1 = (0,1,2,3,4,5,6)
tuple2 = tuple1[6:1:-2]
print(tuple2)
结果为：(6, 4, 2)

#对str反向切片，从6开始到尾结束，步长为-2
str1 = "0123456"
str2 = str1[5::-2]
print(str2)
结果为：531

7、数据容器：set（集合）

a、定义格式
# 定义集合字面量
{元素1,元素2,元素3....}
# 定义集合变量
变量名称 = {元素1,元素2,元素3....}
#定义空集合
变量名称 = set()
b、特点
  • 可以容纳多个不同类型的数据
  • 不支持重复元素，并且内容无序，不支持下标索引获取内容
  • 如果集合中内容有重复，集合会自动去重
c、常见操作
  • 添加新元素：集合.add(元素)
#集合中添加新元素4
set1 = {1,2,3,1,2,3}
set1.add(4)
print(set1)

结果为：{1, 2, 3, 4}		集合会自动去重
  • 移除元素：集合.remove(元素)
#集合移除元素3
set1 = {1,2,3,1,2,3}
set1.remove(3)
print(set1)

结果为：{1, 2}
  • 取出第一个元素：集合.pop()
set1 = {1,2,3}
set1.pop()
print(set1)

结果为：{2, 3}
  • 清空集合：集合.clear()
set1 = {1,2,3}
set1.clear()
print(set1)

结果为：set()
  • 取出集合1有而集合2没有的内容：集合1.difference(集合2)
    获取此内容后，集合1和集合2的原本内容不会改变
    此方法有数据返回，可用变量接收
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(set3)

结果为：{2, 3}
  • 在集合1中删除和集合2相同的元素：集合1.difference_update(集合2)
    获取此内容后，集合1被修改，集合2不变
    此方法无数据返回，不能用变量接收
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(set1)

结果为：{2, 3}
  • 两个集合合并为一个：集合1.union(集合2)
    此方法有数据返回，可用变量接收
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3)			结果为自动去重

结果为：{1, 2, 3, 5, 6}
  • 统计集合元素数量：len(集合)
set1 = {1,2,3,1}
print(len(set1))		集合会自动去重

结果为：3
  • 集合的遍历
    因为集合无序，没有下标，所以集合无法用while循环获取下标的方式遍历，只能for循环遍历
set1 = {1,2,3}
for i in set1:
    print(i)

8、数据容器：dict（字典，映射）

a、定义格式
#定义字典字面量
{key:value,key:value....}
#定义字典变量
变量名称 = {key:value,key:value....}
#定义空字典
变量名称 = {}
变量名称 = dict()
  • 定义嵌套字典
姓名语文数学英语
李556677
王667755
周775566
#将上述表格的成绩用字典定义
dict1 = {
	"李":{"语文":55,"数学":66,"英语":77},
	"王":{"语文":66,"数学":77,"英语":55},
	"周":{"语文":77,"数学":55,"英语":66}
	}
b、特点
  • 字典中的key不能重复，不能使用下标索引，而是通过key找对应的value
  • key和value可以是任何数据类型（key不可为字典）
  • 可以for循环遍历，不能用while循环遍历
b、常见操作
  • 获取嵌套字典数据：字典[key值]
# 获取李的语文成绩
dict1 = {
	"李":{"语文":55,"数学":66,"英语":77},
	"王":{"语文":66,"数学":77,"英语":55},
	"周":{"语文":77,"数学":55,"英语":66}
	}
print(dict1["李"]["语文"])
  • 新增 / 修改 元素：字典[key] = value
    如果存在key，则新增，如果不存在key，则修改
#修改李的语文成绩为88
dict1 = {"李":{"语文":55,"数学":66,"英语":77}}
dict1["李"]["语文"] = 88
print(dict1)
结果为：{'李': {'语文': 88, '数学': 66, '英语': 77}}

#为李新增物理成绩88
dict1 = {"李":{"语文":55,"数学":66,"英语":77}}
dict1["李"]["物理"] = 88
print(dict1)
结果为：{'李': {'语文': 55, '数学': 66, '英语': 77, '物理': 88}}
  • 删除元素：字典.pop(key)
#删除李的语文成绩
dict1 = {"李":{"语文":55,"数学":66,"英语":77}}
dict1["李"].pop("语文")
print(dict1)
结果为：{'李': {'数学': 66, '英语': 77}}
  • 清空元素：字典.clear()
dict1 = {"李":{"语文":55,"数学":66,"英语":77}}
dict1.clear()
print(dict1)

结果为：{}
  • 获取全部key：字典.keys()
#获取李中的全部key
dict1 = {"李":{"语文":55,"数学":66,"英语":77}}
keys = dict1["李"].keys()
print(keys)
  • 字典的遍历
# 遍历字典中李的value
#方法一：先获取所有key，在通过key获取value
dict1 = {"语文":55,"数学":66,"英语":77}
keys = dict1.keys()
for i in keys:
    print(dict1[i])

#方法二：直接对字典遍历
dict1 = {"语文":55,"数学":66,"英语":77}
for key in dict1:
    print(dict1[key])
  • 统计字典的元素数量：len(字典)
dict1 = {"语文":55,"数学":66,"英语":77}
print(len(dict1))

结果为：3

9、数据容器的简单对比

  • 是否支持下标索引
    • 支持：列表、元组、字符串
    • 不支持：集合、字典
  • 是否支持重复元素
    • 支持：列表、元组、字符串
    • 不支持：集合、字典
  • 是否支持可以修改
    • 支持：列表、集合、字典
    • 不支持：元组、字符串
  • 数据是否有序
    • 有序：列表、元组、字符串
    • 无序：集合、字典
  • 使用场景
    • 列表：记录可修改、可重复的一批数据
    • 元组：记录不可修改、可重复的一批数据
    • 字符串：记录一串字符
    • 集合：记录不可重复的数据
    • 字典：记录以key检索value的数据

10、数据容器的通用操作

  • 统计容器的元素个数：len(容器)
list1 = [1,2,3,4,5]
str1 = "12345"
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
dict1 = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(len(list1))
print(len(str1))
print(len(tuple1))
print(len(set1))
print(len(dict1))

结果都为：5
  • 统计容器的最大元素：max(容器)
list1 = [1,2,3,4,5]
str1 = "12345"
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
dict1 = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(max(list1))
print(max(str1))
print(max(tuple1))
print(max(set1))
print(max(dict1))

前4个结果为：5
第5个结果为：key5
  • 统计容器的最小元素：min(容器)
list1 = [1,2,3,4,5]
str1 = "12345"
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
dict1 = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(min(list1))
print(min(str1))
print(min(tuple1))
print(min(set1))
print(min(dict1))


前4个结果为：1
第5个结果为：key1
  • 容器转列表
list1 = [1,2,3,4,5]
str1 = "12345"
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
dict1 = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(f"列表转列表结果为：{list(list1)}")
print(f"字符串转列表结果为：{list(str1)}")
print(f"元组转列表结果为：{list(tuple1)}")
print(f"集合转列表结果为：{list(set1)}")
print(f"字典转列表结果为：{list(dict1)}")

结果为：
列表转列表结果为：[1, 2, 3, 4, 5]
字符串转列表结果为：['1', '2', '3', '4', '5']
元组转列表结果为：[1, 2, 3, 4, 5]
集合转列表结果为：[1, 2, 3, 4, 5]
字典转列表结果为：['key1', 'key2', 'key3', 'key4', 'key5']
  • 容器转元组
list1 = [1,2,3,4,5]
str1 = "12345"
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
dict1 = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(f"列表转元组结果为：{tuple(list1)}")
print(f"字符串转元组结果为：{tuple(str1)}")
print(f"元组转元组结果为：{tuple(tuple1)}")
print(f"集合转元组结果为：{tuple(set1)}")
print(f"字典转元组结果为：{tuple(dict1)}")

结果为：
列表转元组结果为：(1, 2, 3, 4, 5)
字符串转元组结果为：('1', '2', '3', '4', '5')
元组转元组结果为：(1, 2, 3, 4, 5)
集合转元组结果为：(1, 2, 3, 4, 5)
字典转元组结果为：('key1', 'key2', 'key3', 'key4', 'key5')
  • 容器转字符串
list1 = [1,2,3,4,5]
str1 = "12345"
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
dict1 = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(f"列表转字符串结果为：{str(list1)}")
print(f"字符串转字符串结果为：{str(str1)}")
print(f"元组转字符串结果为：{str(tuple1)}")
print(f"集合转字符串结果为：{str(set1)}")
print(f"字典转字符串结果为：{str(dict1)}")

结果为：
列表转字符串结果为：[1, 2, 3, 4, 5]
字符串转字符串结果为：12345
元组转字符串结果为：(1, 2, 3, 4, 5)
集合转字符串结果为：{1, 2, 3, 4, 5}
字典转字符串结果为：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

注意：转化为字符串后，内容自动会有双引号，只是打印时会自动将双引号去掉
  • 容器转集合
list1 = [1,2,3,4,5]
str1 = "12345"
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
dict1 = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(f"列表转集合结果为：{set(list1)}")
print(f"字符串转集合结果为：{set(str1)}")
print(f"元组转集合结果为：{set(tuple1)}")
print(f"集合转集合结果为：{set(set1)}")
print(f"字典转集合结果为：{set(dict1)}")

结果为：
列表转集合结果为：{1, 2, 3, 4, 5}
字符串转集合结果为：{'5', '3', '4', '2', '1'}
元组转集合结果为：{1, 2, 3, 4, 5}
集合转集合结果为：{1, 2, 3, 4, 5}
字典转集合结果为：{'key5', 'key1', 'key3', 'key2', 'key4'}
  • 通用排序：sorted(容器, reverse=True)
    默认为正序排序，添加 reverse=True 则为倒序排序
list1 = [2,4,3,1,5]
str1 = "53214"
tuple1 = (3,2,5,1,4)
set1 = {5,2,1,3,4}
dict1 = {"key2":2,"key5":5,"key3":3,"key1":1,"key4":4}
print(f"列表排序结果为：{sorted(list1, reverse=True)}")
print(f"字符串排序结果为：{sorted(str1, reverse=True)}")
print(f"元组排序结果为：{sorted(tuple1, reverse=True)}")
print(f"集合排序结果为：{sorted(set1, reverse=True)}")
print(f"字典排序结果为：{sorted(dict1, reverse=True)}")

结果为：
列表排序结果为：[5, 4, 3, 2, 1]
字符串排序结果为：['5', '4', '3', '2', '1']
元组排序结果为：[5, 4, 3, 2, 1]
集合排序结果为：[5, 4, 3, 2, 1]
字典排序结果为：['key5', 'key4', 'key3', 'key2', 'key1']
骨力
关注
  • 22
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从零开始学习 Python 3 - Python 数据容器大揭秘 4：集合 - 高效处理去重数据
05-26
还在为数据去重而烦恼吗？ Python 集合，一键去重，高效处理，让你的代码更简洁、运行更快！
Python-100-Days-master.zip
03-17
2. **列表、元组、字典与集合**：这四类数据结构是Python中常用的容器，它们各自有不同的特点和用途。列表是最常用的数据结构，支持动态添加和删除元素；元组是不可变的列表；字典则是一种键值对的映射关系；集合...
python学习--数据容器（列表）
跨界小白
04-21 492
数据容器--列表: 列表的定义、 列表的下表索引（正向索引、反向索引）、 列表的方法、 列表常用操作(index\append\extend\insert\del\pop\remove\clear\count\index\len)、 列表的遍历（while\for））
python学习--数据容器（集合）
跨界小白
04-22 338
数据容器--集合 集合特点（数据无序存储，无重复项） 集合方法（remove\add\pop\clear\difference\difference update\union\len）
python学习--数据容器（字典）
跨界小白
04-22 111
字典的特点 字典的常用操作
python学习--数据容器（元组）
跨界小白
04-21 100
数据容器--元组（元组与列表主要区别在于：元组不可修改）
python学习--数据容器（序列）
跨界小白
04-22 164
序列、切片
python数据容器---字符串(str)
zcffight的博客
10-09 664
字符串是字符的容器，一个字符串可以存放任意数量的字符。如：字符串：“itheima”。
python学习--数据容器（字符串）
跨界小白
04-21 287
数据容器--字符串 字符串下标索引 字符串常用方法（index\replace\split\strip\len\count） 字符串遍历（while\for） 字符串特点（只可以存储字符串、不可以修改）
python学习--数据容器对比
跨界小白
06-27 96
python：collections --- 容器数据类型
点点关注不迷路
03-04 31
python：collections --- 容器数据类型
Python之数据容器
m0_60121089的博客
10-23 2979
列表的定义语法：[元素，元素，元素，...]元素：数据容器内的每一份数据，都称之为元素。元素的数据类型无限制，甚至元素可以是列表，这样就定义了嵌套列表。字典可以提供基于Key检索Value的场景实现，就像查字典一样。字典的定义语法：# 定义字典my_dict = {"张三":99,"李四":88,"王五":77}# 内容：{'张三': 99, '李四': 88, '王五': 77},类型：
从零开始学习 Python 3 - Python 数据容器大揭秘 3：字典 - 数据存储的万能工具
05-26
还在为复杂数据的存储和查找而烦恼吗？ Python 字典，Key-Value 键值对，数据存储的万能工具，让你的代码更简洁、更高效！
python输出数据类型 - 大学课件PPT
11-25
本课件主要涵盖了Python数据类型的介绍，以及Python执行模型、解释器和版本差异等概念。 首先，Python因其可读性和维护性而受到青睐。它的语法简洁明了，易于理解，这有助于保持代码库的整洁并降低维护成本。Python...
Python复合数据类型（容器篇）
12-22
在python中使用容器来存储这样的数据。 1 list(列表) 列表是一种线性表，由大量的节点组成，每个节点都可以存储数据。 1.1列表的定义 a=list([n1,n2,n3,...,nn]) b=[1,2,3,4,5,64] 列表可以通过以上两种方式来定义...
【Python】pandas：排序、重复值、缺省值处理、合并、分组
yannan20190313的博客
07-30 1268
【Python】pandas：排序（sort_index,sort_values,nsmallest,nlargest）、重复值（duplicated,drop_duplicates,value_counts,nunique）、缺省值处理（isna,isnull,notna,notnull,fillna,dropna,replace）、合并（join,merge,append,concat）、分组（groupby）
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 509
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
十个好用到爆炸的Python技巧
qq_36807888的博客
07-30 733
生成器表达式与列表推导式类似，但它创建的是一个迭代器，而不是一个完整的列表。zip(names, ages) 创建一个迭代器，该迭代器生成由 names 和 ages 列表中对应位置的元素组成的元组。defaultdict(int) 创建一个字典，如果访问的键不存在，则默认值为 0 (int 类型的默认值)。惰性求值: 元素是在需要时才计算的，而不是预先计算好存储在内存中，这在处理包含复杂计算的序列时非常有用。wrapper 函数是装饰器函数内部定义的函数，它调用被装饰的函数，并将结果转换为大写。
python字符串数据容器练习（replace,split,count）
最新发布
2301_79600015的博客
07-31 599
Python字符串是由一系列字符组成的数据类型。在Python中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能修改它的内容。以下是关于Python字符串的一些重要知识点：1. 字符串的基本操作：拼接字符串：使用`+`运算符。重复字符串：使用`*`运算符。索引和切片：使用`[]`和`:`操作符访问字符串中的子串。长度：使用`len()`函数获取字符串长度。转换大小写：使用`upper()`和`lower()`方法。分割和连接：使用`split()`和`join()`方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值