Python：Pandas字符串处理相关函数与loc[]切片

最新推荐文章于 2024-06-02 23:19:04 发布

戳苏

最新推荐文章于 2024-06-02 23:19:04 发布

阅读量1.6k

点赞数 1

文章标签： pandas python 开发语言

本文链接：https://blog.csdn.net/weixin_66118670/article/details/129690371

版权

9. startswith() 和 endswith()

10. findall() 与 find()

二、切片之.loc[] 与 .iloc[]

.loc[]

.iloc[]

前言：

本文为学习记录，仅供个人复习使用。如有错误，望指正。文中字符串处理基于Series数据类型。

本文包含pandas三方库内处理字符串的相关函数，以及.loc[]和.icol[]切片。

新手注意：pandas库中包含了多种数据类型，在专门处理字符串类型的时候，添加一个.str

调用字符串相关函数时，写法为：数据名称.str.函数名称()

一、字符串处理

1. len()

该函数返回字符串的长度。

import numpy as np
import pandas as pd

s = pd.Series(['C', 'Python ', 'java', 'go', np.nan, '1125 ', ' javascript'])
print(s.str.len())
'''
0     1.0
1     6.0
2     4.0
3     2.0
4     NaN
5     4.0
6    10.0
dtype: float64
'''

注： np.nan 表示的就是numpy中的NaN

返回的时浮点数类型。

2. lower()

该函数类似于字符串函数中的lower()，将字符串中的字母全部转换为小写字母。

print(s.str.lower())
'''
0             c
1        python
2          java
3            go
4           NaN
5          1125
6    javascript
dtype: object
'''

注：有的教程中lower后面没有加：()，是错误写法，会报错。

3. strip()

删除字符串前后空格。

思考一下，如果我直接利用上面的Series数列进行操作，会发生什么？

会这样：

s.str.strip(s)
print(s.str.strip(s))
'''
0   NaN
1   NaN
2   NaN
3   NaN
4   NaN
5   NaN
6   NaN
dtype: float64
'''

原因： np.nan导致这一现象。但具体原因没有弄清楚。删除np.nan后恢复正常

sk = pd.Series(['C', 'Python ', 'java', 'go', '1125 ', ' javascript'])
print(sk.str.strip())
'''
0             C
1        Python
2          java
3            go
4          1125
5    javascript
dtype: object
'''

4. split()

很眼熟的函数，可以在括号内传入参数，按照参数对字符串进行分割，原来的字符串被返回的列表覆盖。

但注意，参数必须是字符串原本就包括的元素！！分割后并没有删除，依然存放在列表中

print(sk.str.split(' '))  # 用指定的分隔符分割字符串
'''
0               [C]
1        [Python, ]
2            [java]
3              [go]
4          [1125, ]
5    [, javascript]
dtype: object
'''

5. cat(sep=)

输入字符串参数，用参数将Series中的字符串连接在一起，形成一个字符串。

print(sk.str.cat(sep='_-'))  # 使用自定义字符链接字符串，注意此时输出的末尾已经没有dtype，表明该函数会改变原来数组的数据类型
print(type(sk.str.cat(sep='_-')))  # 注意此时数据类型，变成了字符串
'''C_-Python _-java_-go_-1125 _- javascript'''
'''<class 'str'>'''

6. contains()

查看字符串中是否包含传入的参数，返回布尔值。

print(sk.str.contains('a'))  # 输出包含某一字符元素的字符串，如果有返回True，如果没有，返回False
'''
0    False
1    False
2     True
3    False
4    False
5     True
dtype: bool
'''
print(sk.str.contains('t'))
'''
0    False
1     True
2    False
3    False
4    False
5     True
dtype: bool
'''
# 以上完成了两个实验，表明：并不仅仅是判断是否带有重复字符元素的字符串，而是判断是否包含。

7. replace()

替换字符串。不是替换字符串中的元素喔。

print(sk.str.replace('C', 'C++'))  # 替换字符串函数。
'''
0            C++
1        Python 
2           java
3             go
4          1125 
5     javascript
dtype: object
'''

8. count()

查数。查字符串里含有几个传入的参数。

print(sk.str.count('a'))
'''
0    0
1    0
2    2
3    0
4    0
5    2
dtype: int64   # 注意，这里输出的内容是整数型（整数型64和整数型32之间有什么区别呢？
                 相比之下，int64包含的整数范围更加广泛。）
'''

9. startswith() 和 endswith()

startswith()：检索字符串第一个元素是否为传入的参数

endswith()：检索字符串最后一个元素是否为传入的参数

print(sk.str.startswith('j'))  # 这里判断的是字符串开头字母（是否区分大小写？）
'''
0    False
1    False
2     True
3    False
4    False
5    False
dtype: bool
'''
print(sk.str.startswith('J'))  # 区分大小写
'''
0    False
1    False
2    False
3    False
4    False
5    False
dtype: bool
'''
# 同理，还有一个函数叫做endswith()   注意，这两个函数动词均为单三形式！！！

解释为什么能区分大小写：大写字母和小写字母的ASCII码不一样。

10. findall() 与 find()

findall():

如果字符串中包含该参数，则输出参数，有几个输出几个。

注意：输出的是传入的参数哈，不是输出包含该参数的字符串！

print(sk.str.findall('a'))  
'''
0        []
1        []
2    [a, a]
3        []
4        []
5    [a, a]
dtype: object
'''

find():

返回字符串中，第一个与传入参数相同的元素的索引值，如果没有，返回-1

print(sk.str.find('a'))  
'''
0   -1
1   -1
2    1
3   -1
4   -1
5    2
dtype: int64
'''

二、切片之.loc[] 与 .iloc[]

其实，pandas的切片和numpy的切片很有异曲同工之妙。

如有需要numpy切片方法，可点击：

python：Numpy学习（二）切片合集_豆包的戳苏的博客-CSDN博客

.loc[]

import pandas as pd
import numpy as np

doublenums = pd.DataFrame({
    'a': [1, 2, 3, 4, 7, 2, 8],
    'b': [3, 4, 5, 5, 3, 2, 4],
    'c': [2, 5, 3, 9, 0, 5, 8]
})

print(doublenums.loc[1:3, 'a'])  # 这里只能基于DataFrame，Series不行。
'''
1    2
2    3
3    4
Name: a, dtype: int64
'''

类比numpy的切片，发现区别了吗？
loc[]这里面的行索引，前后都包。

产生问题：单列的时候名称会在最末尾输出，如果是多列呢？

print(doublenums.loc[1:4, :])  # 直接按照DataFrame的形式输出，末尾也不再附带数据类型和列名称；
'''
   a  b  c
1  2  4  5
2  3  5  3
3  4  5  9
4  7  3  0
'''

产生问题：列表索引可以用吗？

可以。

print(doublenums.loc[[1, 4, 3], ['a', 'c']])  # 行的顺序打乱输出也可以
'''
   a  c
1  2  5
4  7  0
3  4  9
'''

产生问题：能不能判断索引内容的大小呢？

可以。

print(doublenums.loc[:, 'a'] > 0)
# print(doublenums.loc['a'] > 0) 这样写会报错
'''
0    True
1    True
2    True
3    True
4    True
5    True
6    True
Name: a, dtype: bool
'''
print(doublenums.loc[1]>0)
# 但是这样写行是没有问题的！
'''
a    True
b    True
c    True
Name: 1, dtype: bool
'''

注意：可以直接引用行索引index，但是在比较列的时候，需要加上行索引的切片。

.iloc[]

该索引只能使用数字，标准的“几行几列”输出法（0开始）

# .iloc[] 只能使用整数索引
print(doublenums.iloc[1:3, :])  # 看出来哪里和.loc[] 不一样了吗？
'''
   a  b  c
1  2  4  5
2  3  5  3
'''

print(doublenums.iloc[1:3, 1])
'''
1    4
2    5
Name: b, dtype: int64
'''

注意，iloc[]并不是头尾全包，而是包头不包尾！

日拱一卒，功不唐捐