Python 数据分析——Python 基础（二）

上回说到，Python 中有四种内建的数据结构 —— 列表、元组、字典和集合，是数据分析的重要基础，这回就来学习一下这几种数据结构。此篇内容较多，亦显枯燥，贵在坚持。

序列

首先来讲讲序列，序列分为可变序列list，不可变序列tuple（元祖）、str。序列有一些通用的操作

注： 以下讲的是序列的通用操作，使用于list、tulpe、str，代码以列表举例。

1、判断一个值是否属于序列

lst = [1,2,3,4,5,6]
a,b = 4,12
# a 在 lst 序列中 , x in y--如果 x 在 y 序列中返回 True。
print(a in lst)
# b 不在 lst 序列中 , x not in y--如果 x 不在 y 序列中返回 True。
print(b not in lst)
# 这也是上节说到的成员运算符 in、 not in   

| 输出：True True

2、序列拼接与重复操作

lst1 = [7,8,9]
lst2 = ['a','b','c']
print(lst1+lst2)      # "+"：序列的拼接
print(lst1*2,lst2*3)  # "*"：序列重复

| 输出：[7, 8, 9, ‘a’, ‘b’, ‘c’]
    [7, 8, 9, 7, 8, 9] [‘a’, ‘b’, ‘c’, ‘a’, ‘b’, ‘c’, ‘a’, ‘b’, ‘c’]

3、通过下标索引序列中的值

lst = [9,8,7,6,5,4,3,2,1,0]
print(lst[0],lst[5],lst[9])  # 索引从0开始，索引最大值是：序列长度-1。如：lst[2]中，下标索引是2，指向lst的第3个值；序列有10个值，最大索引是9
print(lst[-1])               # 索引-1代表最后一个值

| 输出：9 4 0     0

4、切片，序列的切片也是后续数据分析的重点

lst = [0,1,2,3,4,5,6,7,8,9]
print(lst[4:8])  # 切片可以理解成序列的值区间，且是一个左闭右开区间，这里lst[4:8]代表的区间是：索引4的值 - 索引7的值
print(lst[:3])   # 左边无索引，代表从索引0开始
print(lst[3:])   # 右边无索引，代表以最后一个值结束
print(lst[4:-1]) # 索引4的值 -- 倒数第二个值 （注意：切片是右开区间，所以是索引-2的值）

| 输出：[4, 5, 6, 7]
    [0, 1, 2]
    [3, 4, 5, 6, 7, 8, 9]
    [4, 5, 6, 7, 8]

5、步长

lst = [0,1,2,3,4,5,6,7,8,9]
print(lst[0:7:2])  # List[i:j:n]代表：索引i -- 索引j，以n为步长
print(lst[::3])    # 按照3为步长，从第一个值开始截取lst数据
print(lst[1::5])   # 按照5为步长，从第二个值开始截取lst数据

| 输出：[0, 2, 4, 6]
    [0, 3, 6, 9]
    [1, 6]

6、序列的基本内置全局函数及方法

全局函数：len，max，min，sum；方法：lst.index(obj)，lst.count(obj)

lst1 = [0,1,2,3,4,5,6,7,8,9]
print(len(lst))                    # 列表元素个数
print(max(lst),min(lst),sum(lst))  # 返回列表的最大值、最小值、求和，这三个函数都只针对数字的list
lst = [1,1,2,8,8,8,8,5,6,3,3]
print(lst.index(3))                # .index(obj)方法：从列表中找出某个值第一个匹配项的索引位置
print(lst.count(8))                # .count(obj)方法：计算值的出现次数

| 输出：10
    9 0 45
    9
    4

列表

列表（list） 是处理一组有序项目的数据结构,它支持字符，数字，字符串甚至可以包含列表（即嵌套）。序列的通用操作适用于列表。

列表生成器 range()

# range()是生成器，指向了一个范围
# range(5)代表指向了0,1,2,3,4这几个值
print(range(5),type(range(5)))
lst = list(range(5))
print(lst)
# range(2,5)代表指向了2,3,4这几个值，注意这里不是使用:
print(list(range(2,5)))
# range(0,10,2)代表指向了0,2,4,6,8这几个值，最后的2代表步长
print(list(range(0,10,2)))  

| 输出：range(0, 5)
    [0, 1, 2, 3, 4]
    [2, 3, 4]
    [0, 2, 4, 6, 8]

列表的常用操作：添加，插入，删除，排序

（1）添加元素

#生成列表
lst = list(range(8))
# list.append() 添加元素
lst.append('python')
print(lst)
lst.append(['h','e','l'])
print(lst)
lst.extend(['h','e','l']) # 添加多个元素 .extend()
print(lst)
# 注意extend()方法和append()方法的区别，append方法是嵌套

| 输出：[0, 1, 2, 3, 4, 5, 6, 7, ‘python’]
    [0, 1, 2, 3, 4, 5, 6, 7, ‘python’, [‘h’, ‘e’, ‘l’]]
    [0, 1, 2, 3, 4, 5, 6, 7, ‘python’, [‘h’, ‘e’, ‘l’], ‘h’, ‘e’, ‘l’]

（2）删除元素

lst = ['lily','Jack','kyle','lily','lucy','lilei','wangwu']
lst.remove('lily') # remove方法：移除列表中某个值的第一个匹配项
print(lst)
del lst[1:3]       # del语句：删除list的相应索引值(左闭右开)，如索引1-2的值删除
print(lst)
lst.clear()
print(lst)         # 移除所有值

| 输出：[‘Jack’, ‘kyle’, ‘lily’, ‘lucy’, ‘lilei’, ‘wangwu’]
    [‘Jack’, ‘lucy’, ‘lilei’, ‘wangwu’]
    []

（3）插入元素

lst = list(range(8))
lst.insert(5,'a')     # x.insert(i,m)方法：在索引i处插入m，这里索引5代表第6个值
print(lst)
lst.insert(6,[1,2,3]) # 插入一个列表元素
print(lst)

| 输出：[0, 1, 2, 3, 4, ‘a’, 5, 6, 7]
    [0, 1, 2, 3, 4, ‘a’, [1, 2, 3], 5, 6, 7]

（4）复制

# lst，lst1指向同一个列表
lst = list(range(10))
lst1 = lst
lst1[2] = 'hello'
print(lst,lst1)

# list.copy()方法：复制一个新的列表，lst，lst2指向两个列表
lst = list(range(10))
lst2 = lst.copy()
lst2[2] = 'hello'
print(lst,lst2)

| 输出：[0, 1, ‘hello’, 3, 4, 5, 6, 7, 8, 9] [0, 1, ‘hello’, 3, 4, 5, 6, 7, 8, 9]
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, ‘hello’, 3, 4, 5, 6, 7, 8, 9]

（5）排序：方法sort()，函数sorted

# 默认升序排序/字母顺序
lst1 = [1,34,20,45,67,12,90,46]
lst2 = ["der", "sds", "acx"]
lst1.sort()
lst2.sort()
print(lst1,lst2)
# 参数reverse：反向排序
lst1.sort(reverse=True)
lst2.sort(reverse=True)
print(lst1,lst2)
# 函数sorted():排序并复制
lst3 = sorted(lst1)
lst3.append('python')
print(lst1,lst3)

| 输出：[1, 12, 20, 34, 45, 46, 67, 90] [‘acx’, ‘der’, ‘sds’]
    [90, 67, 46, 45, 34, 20, 12, 1] [‘sds’, ‘der’, ‘acx’]
    [90, 67, 46, 45, 34, 20, 12, 1] [1, 12, 20, 34, 45, 46, 67, 90, ‘python’]

元祖（tuple）

元祖 通过圆括号中用逗号分割的项目，定义实际上是不可变的“列表”

tupl1 = ('kyle', 'lily', 1997, 2000);
tupl2 = (6,3,4,5,6 );
tupl3 = "x", "y", "z", "s"  # 可以不加括号
tupl4 = (62,)               # 元组中只包含一个元素时，需要在元素后面添加逗号
print(tupl1[3],tupl3[:4])     # 索引、切片和list一样
del tupl3                    # 元祖不能单独删除内部元素（不可变性），但可以del语句来删除整个元祖
# tuple()函数：将列表转换为元组
lst = list(range(8))
tupl5 = tuple(lst)
print(tupl5)

| 输出：2000 (‘x’, ‘y’, ‘z’, ‘s’)
    (0, 1, 2, 3, 4, 5, 6, 7)

文本序列str

字符串是 Python 中最常用的数据类型，前一回已经介绍过一些，这里在介绍些常用的功能
（1）修改字符串–替换

# str.replace(old_str,new_str,count)：修改字符串，count：更换几个
st1 = "I'm kyle!"
st2 = st1.replace('kyle','lilei')
print(st1)
print(st2)
st1 = 'hahaha'
st2 = st1.replace('ha','he',2)
print(st2)

| 输出：I’m kyle!
    I’m lilei!
    heheha

（2）拆分字符串和连接字符串

# str.split(obj)：拆分字符串，生成列表
st = "dog,20,cat,23.56"
lst = st.split(',')
print(lst)

# str.join()：连接字符串，对象为序列
lst = ['dog', '20', 'cat','23.56']
tupl = ('dog', '20', 'cat','23.56')
m = '_'
st = m.join(lst)
st2 = m.join(tupl)
print(st,st2)

| 输出：[‘dog’, ‘20’, ‘cat’, ‘23.56’]
    dog_20_cat_23.56   dog_20_cat_23.56

（3）startswith 和 endswith

# str.startswith(“str”)  判断是否以“str”开头；str.endswith (“str”)  判断是否以“str”结尾
st1 = 'azxhtyfg'
print(st1.startswith('a'), st1.endswith('f'))

|输出：True False

（4）字母大小写转换

st = 'i am Kyle'
print(st.upper())       # 全部大写
print(st.lower())       # 全部小写
print(st.swapcase())    # 大小写互换
print(st.capitalize())  # 首字母大写

| 输出：I AM KYLE
    i am kyle
    I AM kYLE
    I am kyle

（5）判断字符串是否全数字或字母

st = '8965324'
print(st.isnumeric())  # 如果 str 只包含数字则返回 True,否则返回 False.

st = 'dEdfgr'
print(st.isalpha())   # 如果 str 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

st = 'avd   '
print(st.rstrip())   # 删除字符末尾的空格
print(st.lstrip())   # 删除字符左边的空格
print(st.strip())    # 删除字符首位的空格

| 输出：True
    True
    avd

（6）字符串的格式化

# 输出2位小数:%.2f，此处是四舍五入！
m = 3.1415926 
print("pi is %f"  %m)
print("pi is %.2f" %m)

# 区别：%i 不四舍五入，直接切掉小数部分
m = 10.6
print("pi is %i"  %m)
print("pi is %.0f" %m)

| 输出：pi is 3.141593
    pi is 3.14
    pi is 10
    pi is 11

m = 100 
print("need money %+i"  % m)
print("have money %.2f"  % -m)
# 显示正号，负号根据数字直接显示

| 输出：need money +100
    have money -100.00

# 加空格，空格和符号只能显示一个
m = 100 
print("have money % i"  %m)
print("have money % +i"  %m)
print("have money % .2f"  %-1000)

| 输出：have money 100
    have money +100
    have money -1000.00

# 科学计数法 %e  %E
m = 123.456789654 
print("have money %.2e"  %m)
print("have money %.4E"  %m)

| 输出：have money 1.23e+02
    have money 1.2346E+02

# 小数位数少的时候自动识别用浮点数，数据复杂的时候自动识别用科学计数法
m1 = 12123123.1231231231231
m2 = 1.6
print("have money %g"  %m1)
print("have money %g"  %m2)

| 输出：have money 1.21231e+07
    have money 1.6

这节主要讲了序列（列表、元祖、字符串）的一些特性和常用的操作。内容比较多，能坚持看完也实属不易。技术本身是枯燥的，特别的基础知识更甚，但是还是的反复的敲，反复的练。基础扎实了，后面的数据分析方能运用自如，信手捏来。此篇代码较多，难免有疏忽遗漏之处，若影响了阅读体验，还望海涵。

上一篇：Python 数据分析——Python基础（一）
下一篇：Python 数据分析——Python基础（三）

                更多内容，扫码关注
​​