基本数据类型的相关操作

字符串

常规的字符串操作

字符串的拼接

x = "hello python!"
y = 'hello pandas!'
print(x+y)
# hello python!hello pandas!

字符串的大小写转换

y_upper = y.upper()
print(y_upper)
# 'HELLO PANDAS!'

y_lower = y_upper.lower()
print(y_lower)
# hello pandas!

字符串的替换

y.replace('p', 'P')
#  'hello Pandas!'

字符串的切割

• 返回的是一个列表

y.split(" ")
# ['hello', 'pandas!']

字符串去除空白

• 相当于把列表转为字符串

"".join(y.split())
# 'hellopandas!'

'-'.join(y.split())
# 'hello-pandas!'

包含与否

"m" in y # False
"p" in y # True

Pandas中的字符串操作

• Pandas中存在两种字符串类型：ObjectDtype类型和StringDtype类型。关于StringDtype类型，官方有说明：

StringDtype is considered experimental. The implementation and parts of the API may change without warning.

StringDtype类型是实验性的。它的实现和部分API功能可能在未告知的情况下删除。

• Object类型是我们在pandas中常用的字符串类型。

astype指定类型

s = pd.Series(['a','b','c',None])
s
# 结果：
0       a
1       b
2       c
3    None
dtype: object

# 上面表示的是Pandas中字符或者字符与其他类型(案例是None)的混合类型。

s.dtype
# dtype('O')

• 通过astype强制转化成string

s1 = s.astype("string") 
s1
# 结果：
0       a
1       b
2       c
3    <NA>
dtype: string

s1.dtype
#  string[python]

# 以上是pandas的“纯”字符串类型

convert_dtypes转化数据类型

df = pd.DataFrame(['1','2','3',None],
                 columns=['A'])
df
# 结果：
      A
0     1
1     2
2     3
3  None

df.dtypes
# 结果：
A    object
dtype: object

• 通过convert_dtypes转化数据类型

df = df.convert_dtypes()
df.dtypes
# 结果：
A    string
dtype: object

汇总

1. str.len：计算字符串长度
2. str.strip：去除字符串开头和结尾处的空格（默认）
3. str.lstrip：去除字符串左边的空格（默认）或者指定字符
4. str.rtrip：去除字符串结尾处的空格（默认）或者指定字符
5. str.lower：所有字符串的字母转成小写
6. str.uppper：所有字符串的字母转成大写
7. str.find：查找字符串中指定的子字符串第一次出现的位置
8. str.rfind：查找字符串中指定的子字符串最后一次出现的位置
9. str.index：查找指定字符在字符串中第一次出现的位置（索引号）
10. str.rindex：查找指定字符在字符串中最后一次出现的位置（索引号）
11. str.capitalize：将字符串中的单词的第一个字母变成大写，其余字母为小写
12. str.isalpha：检查字符串是否只由字母组成
13. str.isdigit;检查字符串是否只由数字组成
14. str.islower：检查字符串是否只由小写字母组成
15. str.isupper：检查字符串是否只由大写字母组成
16. str.istitle：检查所有单词首字母是否大写，其他字母是否是小写组成
17. str.startswith：检查字符串是否以指定字符开始
18. str.endswith：检查字符串是否以指定字符结束
19. str.ljust：左对齐，默认使用空格填充
20. str.zfill：右对齐，前面使用0填充到指定字符串长度

字典

• 字典是另一种可变容器模型，且可存储任意类型对象。
• 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 键必须是唯一的，但值则不必。

字典的特点

dic = {'a':1,'b':2,'c':3}
# 键值对，一定共同出现，不能只有一个

dic = {'a':1,'a':2}
print(dic)
# {'a': 2}
# 不允许同一个键出现两次：创建时如果同一个键被赋值两次，后一个值会被记住

dic = {'var1':1, 'var2':'hello', 'var3':[1,2,3], 'var4':{'a':1,'b':2}}
# key必须是不可变的对象，value则可以是任意对象：数值，字符串，序列，字典

print(dic)
# {'var4': {'b': 2, 'a': 1}, 'var2': 'hello', 'var3': [1, 2, 3], 'var1': 1}
# 字典是一个无序集合,序列由于没有key来做对应，所以以顺序来对应值
# 序列有顺序，字典没有！

dic['var5'] = '添加一个值'  # 任意添加元素
dic['var4'] = '任意修改其中一个值'  # 任意修改元素
del dic['var1']  # 任意删除元素
print(dic)
# {'var4': '任意修改其中一个值', 'var2': 'hello', 'var5': '添加一个值', 'var3': [1, 2, 3]}

dic.clear()  # 清空词典所有条目
print(dic)
# {}

del dic  # 删除词典
#print(dic)  

申明一个字典

dic = {'a':1,'b':2}
# 最简单直接的方式，手动书写申明一个字典变量，注意是：不是=

dic = dict(m = 10 ,n = 'aa', h = [1,2,3])
print(dic)
# {'n': 'aa', 'm': 10, 'h': [1, 2, 3]}

lst1=[("a","fff"),("b","ggg")]
lst2=[["c",1],["d",2]]
lst3=(("e",[1,2]),("f",[3,4]))
dic1 = dict(lst1)
dic2 = dict(lst2)
dic3 = dict(lst3)
print(dic1,dic2,dic3)
# {'b': 'ggg', 'a': 'fff'} {'d': 2, 'c': 1} {'f': [3, 4], 'e': [1, 2]}
# dict()由序列生成一个字典，嵌套序列，可以是list或者tuple

keys = ["a", "b", "c"]
dic1 = dict.fromkeys(keys)
dic2 = dict.fromkeys(keys, 'hello')
print(dic1,dic2)
# {'b': None, 'a': None, 'c': None} {'b': 'hello', 'a': 'hello', 'c': 'hello'}
# 只有key，直接生成一个字典

字典常用操作

dic1 = {"a":1, "b":2}
dic2 = {"c":3, "d":4}
dic1.update(dic2)
print(dic1,dic2)
# dict.update()方法：更新/合并一个字典，把第二个字典合并到第一个字典，改变了第一个字典

a = {'m':1 , 'n':2 , 'p':3}
b = a
a.update({'q':4})
print(a,b)
# 和序列的原理一样，a和b指向同一个字典，所以会一起更新

a = {'m':1 , 'n':2 , 'p':3}
b = a.copy()
a.update({'q':4})
print(a,b)
# 通过.copy()方法，复制一个新的字典

print(len(a))
# 查看字典元素个数

print('m' in a)
print(1 in a)
# in / not in ：判断是否包含，这里的判断对象是key

字典的元素访问

dic = {'a':1, "b":2, "c":3}
print(dic['a'])
# 1
#print(dic[1])  # 不能用序列的索引方式
# 字典里面也就同样的意思，但字典没有顺序，以key来作为指向，所以指向的key必须存在

poi = {'name':'shop', 'city':'shanghai', 'information':{'address':'somewhere', 'num':66663333}}
print(poi['information']['address'])
# somewhere
# 对于嵌套字典，输出嵌套内容，通过重复指向来输出

print(poi.get('name'))
# shop
print(poi.get('type',print('nothing')))
# 结果：
nothing
None
# .get(key)方法：直接查看key的value，如果没有相应key则返回None，添加print参数可以多返回一个值

print(poi.keys(),type(poi.keys()))
# dict_keys(['information', 'name', 'city']) <class 'dict_keys'>
print(list(poi.keys()))
# ['information', 'name', 'city']
# .keys()方法：输出字典所有key，注意这里的输出内容格式是视图，可以用list()得到key的列表，类似range()

print(poi.values(),type(poi.values()))
# dict_values([{'num': 66663333, 'address': 'somewhere'}, 'shop', 'shanghai']) <class 'dict_values'>
print(list(poi.values()))
# [{'num': 66663333, 'address': 'somewhere'}, 'shop', 'shanghai']
# .values()方法：输出字典所有values，原理同.keys()方法

print(poi.items(),type(poi.items()))
# dict_items([('information', {'num': 66663333, 'address': 'somewhere'}), ('name', 'shop'), ('city', 'shanghai')]) <class 'dict_items'>
print(list(poi.items()))	
# [('information', {'num': 66663333, 'address': 'somewhere'}), ('name', 'shop'), ('city', 'shanghai')]
# .items()方法：输出字典所有items（元素），原理同.keys()方法

字典的元素遍历

poi = {'name':'shop', 'city':'shanghai', 'information':{'address':'somewhere', 'num':66663333}}
for key in poi.keys():
    print(key)
print('-------')

for value in poi.values():
    print(value)
print('-------')

for (k,v) in poi.items():
    print('key为 %s, value为 %s' %(k,v))
print('-------')  

# 结果：
information
name
city
-------
{'num': 66663333, 'address': 'somewhere'}
shop
shanghai
-------
key为 information, value为 {'num': 66663333, 'address': 'somewhere'}
key为 name, value为 shop
key为 city, value为 shanghai
-------