前言

本文介绍Python中基本的数据类型：

  • 字符串、数字
  • 列表
  • 字典
  • 集合
  • 元组

以及一些常用的处理小技巧。

1. 字符串、数字

Python中字符串（str）的处理对于没有任何变成经验的同学可能有些苦恼，如下

1
2
3
4
s1 = '1222'
i = 1222

add_up = s1 + i # 这段函数就会报错，因为无法将 int类型 与 str类型相加

  • int ：整数类型，将小数抹除

    • float ：浮点数类型，因为二进制进位的关系数据并不准确的

  • 以上就是提醒各位，对数据处理的时候，一定要留心数据的类型

1.1 字符串中的序号

字符串的序号可以让你快速取得一串字符中任意位置的任意字符，有如下三种基本方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
s = 'Attention Is A Talent' # 首先创建一个字符串

# 第一种 取单个字符
s[0] 	# 将获得 'A'
s[20]	# 将获得 't'  

# 第二种 取多个字符
s[0:2]  # 将获得 'At' 
s[:20]	# 将获得 'Attention Is A Talen'
s[::2]  # 将获得 'AtninI  aet'
s[::1]  # 将获得 'Attention Is A Talent'

# 第三种 倒序
s[-1]   # 将获得 't' 
s[-21:]	# 将获得 'Attention Is A Talent'

有如下需要注意的几个地方：

  1. 在python中我们使用引号包裹需要的字符串内容

  2. 字符串的序号是从 0 开始定义的，所以上面的s有21个字符，而方括号内的取值范围是[0,20], 细心你的肯定发现了，空格数也算进去了。没错空格也算一种特殊的字符。

  3. 第二种取值方式我们称之为切片，python中的切片方式等价数学上的**左闭右开~[x, y)**，上面字符s[:20]，是取得s[20]号位左边的全部值，但是不会包含s[20]。

​ 当然是用s[0:20] 也是等价的。

​ 步长 即第二种方法的第三个式子，是用步长就是字面意思，每走n步取值。

​ s[::2]就是 s[0]第一步， s[1]第二步(存储)，s[2]第三步，s[3]第四步(存储)….

  1. 倒序是字符串的另一套序号，它有很多应用场景，比如定义一个很长的字符串你可能需要用s[1222222]才能取得这个值，但是是用s[-1]就很方便。

    当然，需要注意倒序是从[-1]开始的。

1.2 特殊字符

'\n'(换行) '\b'(回退) '\r'(光标回到本行行首) '\t'(相当于八个空格，两个table)

以上就是几个常见的特殊字符，其中特别需要注意的是路径中的斜杠如遇到 \nigger 计算机可能就无法明白你输入的是 ‘igger’，还是含有n的字符串。有以下两种处理方式：

  • '\\nigger'
  • r'\nigger'

1.3 字符串的运算以及常用函数

运算

1
2
3
s1 + s2               # 将两个字符串连接
s1*n                  # 将s1复制n次
s1 in s2              # 如果s1是s2的字串 则返回 True 否 False

函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
s = ' Attention,Is,A,Talent '

# split函数
s.split(',')					# 输出为 [' Attention', 'Is', 'A', 'Talent ']
                   				# split函数以逗号为标志，返回一个分隔后的列表
# count函数                   				
s.count('A')                    # 统计A在s中的次数，本例中将返回int类型的2

# upper，lower函数
s.upper() / s1.lower()          # 将字符串转化为对应的大小写

# replace函数
s.replace('tion', '')  			# 将字符串中的'tion'替换为''，即没有东西，相当于删除

# center函数
s.center(30, '=')               # 将s放在中间，左右两侧平均填充等于号至总字符数为30

# strip函数
s.strip(' ')                    # s两侧删除空格，以及其他不可读符号如'\n'

# join函数
','.join(s)                     # s中每个字符间填充逗号
								# 返回 'A,t,t,e,n,t,i,o,n,,,I,s,,,A,,,T,a,l,e,n,t'

# len函数
len(s)							# 返回s的长度
  1. 上面我们以逗号为分隔符使用split函数，但是注意中英文的逗号是有区别的，其他有些符号也一样，需要注意。
  2. 上述中的replace几乎可以代替center函数，但是注意strip只能处理字符串的两端
  3. 如join函数返回的结果，再次提醒空格也算是字符
  4. 最后，上述操作产生都是一个新的对象，即调用s后返回的是原本的字符串，并不是函数作用后的结果。
    需要s = s.replace('tion', '') 赋值才‘生效’。

1.4 数字函数

1
2
3
4
5
6
7
8
9
10
pow(x, n)   					 #为x的n次方
divmod(10, 3)   				 # 输出为（3， 1）
abs()      						 #返回值为绝对值

int(12.34)  					 #输出 12
float(12), float('12.23') 		 #输出为 12.0 和 12.23

round(1.2345， 2)  	 			#保留两位小数
max(1, 2, 3)  					 #返回值为3
min(1, 2, 3)  					 #返回值为1

1.5 格式化字符串

在我们得到一个数据之后，经常需要对其做保留多少位小数、居中打印、靠右输出、等操作，我们一般叫使其格式化。在python中有三种格式化填充字符串的方式：

1
2
3
4
5
# format方式
a, b, c = 'Is', 'Talent', 0.12222
'Attention {a} A {b} version {:.2f}'.format(a, b, c)

# 我们将得到如下输出 'Attention Is A Talent version0.12'

format格式化将按照顺序填入上面字符串{}的空位，{:.2f}表示此处保留两位小数

1
2
3
4
5
# f方式
a, b, c = 'Is', 'Talent', 0.12222
f'Attention {a} A {b} version {c:.2f}'

# 我们将得到如下输出 'Attention Is A Talent version0.12'

f格式化就是对format方式的简化版

1
2
3
4
5
# %方式
a, b, c = 'Is', 'Talent'
'Attention %s A %s '% ('Is', 'Talent')

# 我们将得到如下输出 'Attention Is A Talent '

这种方式很老了，推荐使用f方式，非常简洁。

以下不是必看内容：format填充方式

1
2
chr(Unicode)					#返回Unicode对应的字符
ord('字')					   #返回对应的编码，如chr(ord('a')+i ) 即可遍历26字母

填充物若为chr(12222)，等特殊字符

1
2
3
4
5
6
7
8
f'{chr(12222):^10}'
# 输出为 '    ⾾     '

f''{chr(12222):=^10}'
'====⾾====='

f''{chr(12222):=>10}'
'=========⾾'

如上{chr(12222):^10} 将chr(12222)对应的字符输出在中间，左右两侧填充空格。

也可用等号等其他符号填充，或者使用>大于号使结果置右。

2. 列表

列表跟上文中提到的字符串很像，或者说字符串是一种特殊的列表，其所有元素都是字符串。

python中的列表（list），在我的印象里几乎可以装任何的东西: 字符串、数字、甚至你定义的函数…

列表是一种非常好用的数据类型，也是我们最常使用数据类型，以下概要对其简要介绍并补充几个判断符。

2.1 概要

列表同字符串也有正反序号下标，切片操作，不同的是列表可以含有各种类型的数据

1
2
3
4
5
ls = ['Attention Is A Talent', 100, '% ']

ls[0] == ls[-3] 				# 返回True
'A' in ls						# 返回True
str(ls[1]) + ls[2] + ls[0]		# '100% Attention Is A Talent'

  • 上面我们使用双等号作为判断符，等价询问python 是否 ls[0] = ls[-3]

    • 还有 != 、>=、<=、等

  • 上面我们使用in作为判断词，等价询问python 是否 ‘A’ 在 ls

    • 还有 not in，or，and等

  • 第二点，我们使用了str()，它是一个函数，将对传给它的值做字符串化的处理

    • int类型的 100 ——> ‘100’ 即数字100变成字符串了

2.2 列表的运算以及常用函数

运算

1
2
3
4
5
ls = ['Attention Is A Talent', 100, '% ']

ls * 2 				# 将返回 ['Attention Is A Talent', 100, '%', 'Attention Is A Talent', 100, '%']

ls + ls[:1]			# 将返回 ['Attention Is A Talent', 100, '%', 'Attention Is A Talent']
  • 注意，列表的加法操作只能在列表跟列表之间。
    • 如上图使用 ls + ls[0] 将会报错

函数

1
2
3
4
5
6
7
8
# 下面x表示单个元素、ls表示列表0号、ls1表示列表1号

ls.append(x)					# 给ls尾添加x元素
ls.remove(x)					# 将ls中出现的第一个x删除，如要删除所有x可以用（while+flag）或者set集合类型除重
ls.extend(ls1)					# 将ls后面连接ls1
ls.reverse()					# 将列表的元素逆置
ls.insert(i,x)					# 在i位置 插入x
ls.pop(i)						# i位置元素出栈，删除

(这里加些列表复杂一点的方法，如果没有了解python中的字典、元组数据类型，可以在下文中了解后再看)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
ls = [('tom', 95), ('jerry', 80), ('mike', 99), ('john', 70)]
ls.sort()
ls.sort(reverse = ture)			# 逆排序
ls.sort(key= lambda x:x[1])		# 按值排序 
-------------------------------

sorted(ls)						# 会自动把序列从小到大排序
sorted(ls, reverse = true)
sorted(ls, lambda x:x[0])		# 以lambda函数作为值排序
-------------------------------

seasons = ['Spring', 'Summer', 'Fall', 'Winter']			# enumerate()的对象必须是可以迭代的类型(iterable)
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

  • 第一部分中为ls的sort方法配置参数

    • reverse 表示逆置，如果对象没有‘大小’，则按照原来的顺序直接逆置
    • key 参数表示排序根据此值的大小，这里我们就是以每个元组的第二个值作为value排序

  • 第二部分是使用python中的sorted和sort函数

    • 第一个参数表示传入的可迭代数据类型(就是列表这种含有很多元素，可以一个一个出来的数据类型)

    • 第二个参数 同上面的key

    • sort 与 sorted 区别：

      sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

      list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

  • 第三部分使用了enumerate函数，这个函数主要是为元素添加下标，方便一些特殊场景处理

    • enumerate函数返回一个含有位置下标的元组类型，为(index，element)形式

2.3 列表应用的例子

1
2
3
4
5
6
7
8
9
ls = ['Alice', 'Bob']
list(lt) = ls[0]							# [0]号为字符，导入list中会分割成['a', 'l', 'i', 'c', 'e']
------------------------------------
ls = ['Ali:ce', 'Bo:b']
lt = []
for i in ls:
    elem = i.split(':')[-1]					# ls[i]为字符串使用split分割->['Ali','ce']取[-1]
    lt.append(elem)							# 直接+=会变成['c','e'],所以使用list的append,则直接将str的ce加入
											# lt = [ce, b]  干净的字符串列表

3. 字典

Python字典（dict）是另一种可变容器模型,可存储任意类型对象。如字符串、数字、元组等其他容器模型
因为字典是无序的所以不支持索引和切片

注意：

  • key不可以重复,否则只会保留第一个;
  • value值可以重复;
  • key可以是任意的数据类型,但不能出现可变的数据类型,保证key唯一;
  • key一般形式为字符串。

3.1 基本属性

1
2
3
dic.keys()								# 返回字典中所有的key
dic.values()							# 返回包含value的列表
dic.items()								# 返回包含(键值,实值)元组的列表

3.2 基本函数

1
2
3
4
5
6
7
8
9
10
11
12
dic.setdefault(k,value)
#如果key值存在,那么返回对应字典的value,不会用到自己设置的value;
#如果key值不存在.返回None,并且把新设置的key和value保存在字典中;
#如果key值不存在,但设置了value,则返回设置的value;

dic.get(k,value)
#如果key值存在,那么返回对应字典的value,不会用到自己设置的value;
#如果key值不存在.返回None,但是不会把新设置的key和value保存在字典中;
#如果key值不存在,但设置了value,则返回设置的value;

dic.items()
#打印字典中的所有元组

以下不是必看内容：dic.get(key, init_value)

1
2
3
4
5
6
7
8
9
ls = [('tom', 95), ('tom', 95), ('tom', 95), ('jerry', 80), ('mike', 99), ('john', 70)]

ls1,dic = [], {}
for i, j in ls:
    ls1.append(i)

for i  in ls1:
	dic[i] = dic.get(i, 0) + 1         
dic

get第一个参数为对应的键，第二个参数为键对应的初始值。

get方法将键对应的值初始化为0，以后每见一次加一次，在文本统计时经常使用。

相对于dic[i]，dic.get(i)不会报错，而它每见一次加一次而不是覆盖，明显速度会比前者慢。(但是不是大量数据都差不多。)

4.集合

在Python中集合（set）元素之间无序，每个元素唯一，不存在相同元素集合元素不可更改，不能是可变数据类型

4.1 创建和运算

1
2
3
4
5
6
7
使用两种方式建立
A = {"python", 123, ("python",123)} 				# 使用{}建立集合
	输出为{123, 'python', ('python', 123)}
B = set("pypy123") 									# 使用set()建立集合
	输出为{'1', 'p', '2', '3', 'y'}
C = {"python", 123, "python",123}					# 去重
	输出为{'python', 123}
1
2
3
4
5
6
S | T 				并，返回一个新集合，包括在集合S和T中的所有元素 
S - T 				差，返回一个新集合，包括在集合S但不在T中的元素 
S & T 				交，返回一个新集合，包括同时在集合S和T中的元素 
S ^ T 				补，返回一个新集合，包括集合S和T中的非相同元素 
S <= T 或 S < T 	    返回True/False，判断S和T的子集关系 
S >= T 或 S > T 	    返回True/False，判断S和T的包含关系

4.2 函数

1
2
3
4
5
len(s) 											#返回序列s的长度，即元素个数
min(s) 											#返回序列s的最小元素，s中元素需要可比较
max(s) 											#返回序列s的最大元素，s中元素需要可比较
s.index(x) / s.index(x, i, j) 				    #返回序列s从i开始到j位置中第一次出现元素x的位置
s.count(x) 										#返回序列s中出现x的总次数

其中len()、min()、max()函数是内置的通用函数

5. 元组

python中的元组（tuple）是一种序列类型，一旦创建就不能被修改 ，使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔 。

5.1 创建和取值

1
2
3
creature = "cat","dog","tiger","human"
creature = ('cat', 'dog', 'tiger', 'human') 		# 可以使用括号和不带括号的两两种
color = (0x001100, "blue", creature)				# 输出会得到（，，（））

元组的取值操作跟列表一样

1
2
3
4
creature = "cat","dog","tiger","human"
creature[::-1]								# 输出为('human', 'tiger', 'dog', 'cat')
color = (0x001100, "blue", creature)
color[-1][2]								# 输出为'tiger'

5.2 函数

1
2
3
4
5
6
7
8
9
10
set(x) 									# 将其他类型变量x转变为集合类型
t.discard(x) 						    # 移除S中元素x，如果x不在集合S中，不报错
t.remove(x) 							# 移除S中元素x，如果x不在集合S中，产生KeyError异常
t.pop() 								# 随机返回S的一个元素，更新S，若S为空产生KeyError异常
t.add(x) 								# 如果x不在集合S中，将x增加到S
t.clear() 								# 移除S中所有元素
x in t									# 判断S中元素x，x在集合S中，返回True，否则返回False
x not in t 								# 判断S中元素x，x不在集合S中，返回True，否则返回False
t.copy() 								# 返回集合S的一个副本
len(t) 									# 返回集合S的元素个数

总结

  • 同上文我们定义的字符串、列表、字典，我们按照见名知意的原则，将其赋值给s、ls、dic。这样做是为了程序的可读性。今后我们在写程序的时候会定义很多变量，变量一多了就容易搞混了，顺藤摸瓜找着效率又很低，所以给你的变量取一个好名字，是一个很划算的决定。

    • 举个例子train_df = pandas.DataFrame('../train.csv')中的 train_df表示这个是个训练数据，其数据类型为pandas的DataFrame结构。

  • 此外在操作数据的时候一定要注意数据类型，根据数据的特性选择合适的数据类型。

  • 最后，python最好用的地方在于有各种各样的库供你选择，而掌握它基础的数据结构是第一步，下面我们将讲解函数以及类，最后介绍两个常用的库，介绍一些如何快速掌握一个库的通法。