Python数据分析与数据挖掘 第3章 Python数据组织结构

第3章Python数据组织结构Python数据分析与数据挖掘3.1字符串创建和使用字符串字符串变量的创建方法是直接将字符串常量赋值给一个变量。>>>

str

=

"Hello

world">>>

str[0],

str[1],

str[-2],

str[3:7]("H",

"e",

"l",

"lo

w")>>>

str

=

"Hello

world">>>

strstr

=

"Hello

world"for

c

in

str:print(c,

end="")Hello

world"Hello

world"字符串格式化格式化操作符>>>tup=("Hello","world!")#元组>>>

"%s,

%s"

%tup>>>dict={"h":"Hello","w":"World!"}#字典>>>

"%(h)s,

%(w)s"

%

dict"Hello,

World!">>>

str

=

"Hello,

%s"

%"world!">>>

str>>>

"%s,

%s"

%

("Hello","world!")"Hello,

world!">>>

"%s,

%s"

%

"Hello","world!"TypeError:

not

enough

arguments

forformat

string"Hello,

world!"字符串格式化控制输出宽度、精度from

math

import

piprint("1234567890")print("%.2f"

%

pi)print("%10f"

%

pi)print("%10.2f"

%

pi)#标尺#精度2#字段宽10#字段宽10，精度212345678903.143.1415933.14字符串格式化模板字符串from

string

importTemplatestrTemp

=

Template("$x,

$y!")str

=strTemp.substitute(x="Hello",y="world")

print(str)s1

=

"Good

morning"s2

=

"Beijing"str

=

strTemp.substitute(x=s1,

y=s2)print(str)Hello,

world!Good

morning,

Beijing!字符串格式化模板字符串from

string

importTemplatestr1=Template("Hello,

w${x}d!")str1=str1.substitute(x="orl")print(str1)Hello,

world!from

string

importTemplated={"h":"Hello","w":"world"}str1=Template("$h,$w!")str1=str1.substitute(d)print(str1)Hello,world!字符串输出格式化函数具体说明str.ljust(width,[fillchar])左对齐输出字符串str，总宽度为参数width，不足部分以参数fillchar指定的字符填充，默认使用空格填充。str.rjust(width,[fillchar])右对齐输出字符串str，用法同上。str.center(width,[fillchar])居中对齐输出字符串str，用法同上。str.zfill(width)将字符串str长度变成width，右对齐，多余部分用0补足。字符串输出格式化print("123456789012345678901234567890")#标尺str

=

"Hello,world!"print(str.ljust(30))

#左对齐print(str.rjust(30,"_"))print(str.center(30,

"."))#右对齐

#居中对齐print(str.zfill(30))

#右对齐，补0123456789012345678901234567890Hello,

world!

Hello,

world!........Hello,

world!.........00000000000000000Hello,

world!字符串判断函数具体说明str.startswith(substr)判断str是否以substr开头str.endswith(substr)判断str是否以substr为结尾str.isalnum()判断str是否全为字母或数字str.isalpha()判断str是否全为字母str.isdigit()判断str是否全为数字str.islower()判断str是否全为小写字母str.isupper()判断str是否全为大写字母转换大小写函数具体说明str.capitalize()将字符串str的首字母转为大写（注意是指整个字符串的首字母转大写，而非每个单词的首字母转大写）。str.title()将字符串str中的每个单词首字母转为大写，其余为小写。str.upper()将字符串中的所有字母转为大写。str.lower()将字符串中的所有字母转为小写。str.swapcase()将字符串中的字母大小写互换转换大小写>>>

str

=

"stuDENTSsTUDY">>>str.capitalize()#字符串首字母转大写，其余小写"Students

study">>>str.title()#将字符串中的每个单词首字母大写，其余为小写"Students

Study"其他处理对一个字符串以某分隔符进行分割，分割后的结果生成一个列表str.split(sep=None,

maxsplit=-1)参数sep为分割符，默认值为None，即按空格进行分割；参数maxsplit定义最多进行几项分割。>>>

str

=

"

out

ofdateinformation

is

of

no

value

to

me.

">>>

str.split()["out",

"of",

"date",

"information",

"is",

"of",

"no",

"value",

"to",

"me."]>>>

str.split("

")["",

"out",

"of",

"date",

"information",

"is",

"of",

"no",

"value",

"to",

"me.",

"",

""]其他处理>>>slist=str.split(maxsplit=2)#分割str，得到字符串列表slist>>>

slist["out",

"of",

"date

information

is

of

no

value

to

me."]对一个字符串以某分隔符进行分割，分割后的结果生成一个列表str.split(sep=None,

maxsplit=-1)其他处理>>>"-".join(slist)#将字符串列表slist中的各字符串拼接"out-of-date

information

is

of

no

value

to

me.

"将一个字符串序列拼接为一整个字符串str.join(iterable,

/)参数iterable为可迭代序列。>>>

slist["out",

"of",

"date

information

is

of

no

value

to

me."]其他处理生成一个将字符表示为字节编码的字符串。bytes()bStr=bytes("我爱学Python!",encoding="utf-8")print(bStr)for

b

in

bStr:print(hex(b),

end="

")b"\xe6\x88\x91\xe7\x88\xb1\xe5\xad\xa6Python!"0xe6

0x88

0x91

0xe7

0x88

0xb1

0xe5

0xad

0xa6

0x50

0x79

0x74

0x68

0x6f

0x6e

0x21输出特殊字符输出(%)这个特殊字符>>>

str

=

"%s%%"

%

100>>>

str"100%"输出($)符号，可以使用$$符输出$from

string

importTemplatestr1=Template("$$$x")str1=str1.substitute(x="100")print(str1)$1003.2列表创建列表可以通过列举列表元素的方法创建列表，列表中的元素的类型可以是Python所支持的各种数据类型，并可以混合列举组成列表。>>>

list4

=

[3,

"abc",

True]>>>

list4[3,

"abc",

True]>>>

list1=["hello","world"]>>>

list1>>>

list5

=

[123,

"hello",

[3,

"abc",

True]]>>>

list5[123,

"hello",

[3,

"abc",

True]]["hello",

"world"]创建列表利用list类的构造函数list()，创建一个空列表，或将多种其他类型的数据对象转换为列表。#或lst=[]>>>

lst

=

list()>>>

lst#查看变量lst的数据类型>>>

type(lst)<class

"list">[]创建列表利用list类的构造函数list()，创建一个空列表，或将多种其他类型的数据对象转换为列表。>>>

list(range(10,

15))[10,

11,

12,

13,

14]>>>list(("P","y","t","h","o","n"))#将元组转换为列表["P",

"y",

"t",

"h",

"o",

"n"]>>>

list("Python")["P",

"y",

"t",

"h",

"o",

"n"]访问列表list[index]list[start:end]list[index1][index2]#获取一维列表中的索引值为index的元素

#获取列表中从第start到end-1个元素#获取二维列表中索引值为index1行index2列的元素>>>

lst

=

["coke",

"sugar",

"beer",

"apple"]>>>lst[0];lst[3]#访问列表索引为0、3的元素"coke"["apple",

"orange"]>>>lst[0:3]#访问列表索引为0到2的元素["coke",

"sugar",

"beer"]1.访问列表元素访问列表list[index]list[start:end]list[index1][index2]#获取一维列表中的索引值为index的元素

#获取列表中从第start到end-1个元素#获取二维列表中索引值为index1行index2列的元素>>>lst_=[lst[:3],lst[1:]]#以获取的子列表为元素构成一个新的列表>>>

lst_;

len(lst_)[["coke",

"sugar",

"beer"],

["sugar",

"beer",

["apple",

"orange"]]]2>>>

lst_[1];

lst_[1][2]["sugar",

"beer",

["apple",

"orange"]]["apple",

"orange"]1.访问列表元素访问列表len(["coke","sugar","beer",["apple","orange"]])#共有4个元素42.获取列表长度访问列表>>>

lst

=

["coke",

"sugar",

"beer",

"apple"]>>>max(lst);min(lst)

#字符串，按元素字母序依次比较大小"sugar""apple"3.返回列表元素最大值、最小值访问列表4.定位列表元素list.index(value,

start=0,

stop=9223372036854775807,/)>>>

lst

=

["coke",

"sugar",

"beer",

"apple"]>>>

if

"beer"

in

lst:lst.index("beer")2>>>

lst.index("nay")Traceback

(most

recent

call

last):File

"<pyshell#21>",

line

1,

in

<module>lst.index("nay")ValueError:

"nay"

is

not

in

list访问列表>>>

lst

=

["coke",

"beer",

"sugar",

"beer",

"apple",

"beer"]>>>

lst.count("beer")35.统计某个元素在列表中出现的次数访问列表#列表lst原长度为

4#添加的新元素是一个列表>>>

lst

=

["coke",

"sugar",

"beer",

"apple"]>>>

lst.append(["pork",

"beef"])>>>

lst;

len(lst)["coke",

"sugar",

"beer",

"apple",

["pork",

"beef"]]56.添加列表元素list.append(obj)访问列表7.插入列表元素list.insert(pos,

new_value)>>>

lst

=

["coke","sugar","beer","apple"]>>>

lst.insert(2,

"pork")>>>

lst["coke",

"sugar",

"pork",

"beer",

"apple"]访问列表>>>lst

#移除后["coke",

"beer",

"apple",

"pork"]8.移除列表元素list.pop([index])>>>

lst

=

["coke",

"sugar",

"beer",

"apple",

"pork"]>>>lst.pop(1)

#移除列表中索引为1的元素"sugar"访问列表8.移除列表元素del

List

[index]>>>

lst

=

["coke",

"sugar",

"beer",

"apple",

"pork"]>>>

del

lst[1]>>>

lst;

len(lst)["coke",

"beer",

"apple",

"pork"]4访问列表>>>

lst

=

["apple",

"banana",

"pear",

"grape",

"pork"]>>>lst.sort()

#升序排序>>>lst.sort(reverse=True)

#降序排序9.列表排序list.sort([key=None],

[reverse=False])参数key指定排序的回调函数；参数reverse指定是否反序排序。访问列表9.列表排序list.sort([key=None],

[reverse=False])>>>def

get2nd(n):

#定义排序方法函数return-n[1],n[0]>>>

lst

=

[[1,3],[4,3],[2,3],[1,5],[2,1]]>>>lst.sort(key=get2nd)

#使用get2nd()所定义的排序方法>>>

lst[[1,

5],

[1,

3],

[2,

3],

[4,

3],

[2,

1]]其中，get2nd()函数先后返回列表元素的第1个值的负数和第0个值，即令.sort()方法先按照第一个值进行逆序排序，在此基础上再按第二个值顺序排序。访问列表注意，reverse()仅仅是将列表元素按原顺序的逆序进行排列，并非按照内容的大小进行排序。10.反序列表list.reverse()>>>

lst

=

["apple",

"banana",

"pear",

"grape",

"pork"]>>>lst.reverse()

#反转排列列表中的元素>>>

lst["pork",

"grape",

"pear",

"banana",

"apple"]访问列表#添加到list1列表中>>>

list1.extend(list2)>>>

list1["coke",

"sugar",

"beer",

"apple",

"pork"]11.合并列表（扩展列表元素）list.extend(list_)>>>

list1

=

["coke","sugar"]>>>

list2

=

["beer","apple","pork"]>>>list1+list2

#产生新的列表["coke",

"sugar",

"beer",

"apple",

"pork"]访问列表>>>

s1.append(4)>>>

s1;

s2#s1添加一个元素，s1的内容变为[1,2,3,4]#s2也随s1相应改变了[1,

2,

3,

4][1,

2,

3,

4]12.复制列表list.copy()>>>

s1

=

[1,

2,

3]>>>

s2

=

s1.copy()>>>

s2[1,

2,

3]访问列表12.复制列表list.copy()要获得一个列表的拷贝，必须使用.copy()的方法，如果使用赋值的方法，得到的仅仅是类似指向原列表的一个指针。>>>

s1

=

[1,

2,

3]>>>s2=s1

#这时s2中内容为[1,2,3]>>>s1.append(4)

#s1添加一个元素，s1的内容变为[1,2,3,4]>>>s1;s2

#s2也随s1相应改变了[1,

2,

3,

4][1,

2,

3,

4]对于一个可变的可迭代对象（如下面要介绍的集合set、映射dict），均必须使用.copy()的方法获得该对象的拷贝。遍历列表1.遍历列表for…in…>>>

list1

=

["coke",

"sugar",

"beer",

"apple",

"pork"]>>>for

i

in

list1:

#遍历列表元素print(i,end="")#不换行输出列表元素coke

sugar

beer

apple

pork遍历列表2.遍历列表enumerate()for

index,

>>>

list1

=

["coke",

"sugar",

"beer",

"apple",

"pork"]>>>

for

idx,

val

in

enumerate(list1):

#遍历列表元素print(idx,

val)

#输出列表元素索引号和值value

in

enumerate(list):cokesugarbeerapplepork3.3元组创建元组#或tup=(1,2,3)>>>

tup

=

1,

2,

3>>>

tup#定义元素个数为1的元组，必须加逗号","，以区别加了括号的数字>>>

tup

=

(1,)>>>

tup(1,)(1,

2,

3)1.列举元素创建元组2.

tuple()>>>tuple([3,2,1])#将列表转换为元组(3,

2,

1)>>>tuple("work")#将字符串转换为单个字母构成的元组("w",

"o",

"r",

"k")>>>tuple((1,2,3))#列举元素创建元组。注意不能使用tuple(1,2,3)创建元组(1,

2,

3)访问元组>>>

tup

=

("apple",

"coke",

"orange",

"turkey",

"bean",

"carrot")>>>

lst

=

list(tup)>>>

lst.sort()>>>

tup

=

tuple(lst)>>>

tup("apple",

"bean",

"carrot",

"coke",

"orange",

"turkey")3.4集合创建集合>>>

set(["jeff",

"wong",

"cnblogs"])#字符串集合，排列顺序是随机的{"cnblogs",

"jeff",

"wong"}>>>set([5,4,3,3,2,2,1,1,0])#转换为集合时会消除重复元素{0,

1,

2,

3,

4,

5}>>>

set(range(10)){0,

1,

2,

3,

4,

5,

6,

7,

8,

9}创建集合>>>

frozenset(range(10))frozenset({0,

1,

2,

3,

4,

5,

6,

7,

8,

9})使用frozenset(object)可以创建不可变空集合，或由其他可迭代序列对象（如列表、元组等）转换创建不可变集合。>>>frozenset("python")

#由字符串所创建的集合，排列顺序是随机的frozenset({"t",

"n",

"y",

"p",

"h",

"o"})访问集合获取集合的长度（使用len()函数）访问集合元素（不支持按索引访问元素，只能通过遍历集合元素进行访问）判断集合是否存在元素>>>s=

set([1,

2,

3])>>>

2

in

s,

5

in

s(True,

False)访问集合#[4,5,6]首先被转化为集合{4,5,6}，再添加>>>s

=

set([1,2,3])>>>

s.update([4,5,6])>>>

s{1,

2,

3,

4,

5,

6}4.添加集合元素>>s=

set("python")>>>

s.add(0)>>>

s{0,

"t",

"n",

"y",

"p",

"h",

"o"}访问集合5.删除集合元素set.remove()set.clear()>>>

s

=

set([1,

2,

3])>>>

s.remove(1)>>>

s{2,

3}>>>s

=

set(["a",

"b",

"c",

"d",

"e"])>>>s.remove("z")

#删除不存在的元素Traceback

(most

recent

call

last):File

"<pyshell#191>",line

1,in

<module>s.remove("z")

#删除不存在的元素KeyError:

"z"访问集合6.子集、超集及集合关系操作符/判定函数示例说明==S1==S2判定S1是否等于S2，返回True/False。!=S1!=S2判定S1是否不等于S2，返回True/False。<S1<S2判定S1是否为S2的真子集，返回True/False。<=S1<=S2判定S1是否为S2的子集，返回True/False。>S1>S2判定S1是否为S2的真超集，返回True/False。>=S1>=S2判定S1是否为S2的超集，返回True/False。.issubset()S1.issubset(S2)判定S1是否为S2的子集或真子集，返回True/False。.issuperset()S1.issuperset(S2)判定S1是否为S2的超集或真超集，返回True/False。.isdisjoint()S1.isdisjoint(S2)判定S1是否与S2不相交，返回True/False。集合的运算1.集合的交集集合的交集由所有既属于集合A又属于集合B的元素组成。使用intersection()方法计算两个集合的交集。ersection()或“&”s

=

s1

&

s2s

=

ersection(s2)>>>

s1

=

set([1,

2,

3])>>>

s2

=

set([3,

4])>>>s1

&

s2#或s=ersection(s2){3}集合的运算2.集合的并集set.union()

或

“|”>>>

s1=set([1,

2,

3])>>>

s2=set([2,

3,

4])>>>

s1.union(s2){1,

2,

3,

4}集合的运算3.集合的差集集合的差集由所有属于集合A但不属于集合B的元素组成。使用difference()方法计算两个集合的差集。set.difference()

或“-”s

=

s1

-

s2s

=

s1.difference(s2)>>>

s1

=

set([1,

2,

3])>>>

s2

=

set([3,

4])>>>s1-s2#或s=s1.difference(s2){1,

2}集合的运算3.5映射（字典）定义字典>>>d={"name":"小明","sex":"男","age":18,"score":80}#构成键值对儿>>>

d{"name":"小明","sex":"男","age":18,"score":80}1.赋值定义键key值valuename小明sex男age18score80定义字典>>>d=dict(name="小明",sex="男",age=18,score=80)#用"="构成键值对儿，或者：>>>d=dict([("name","小明"),("sex","男"),("age",18),("score",80)])>>>

d{"name":"小明","sex":"男","age":18,"score":80}2.

dict(object)键key值valuename小明sex男age18score80定义字典>>>

d

=

{}>>>d["name"]="小明">>>

d[("model",

"cylinder",

"hpower")]

=

["Toyota",

4,

500]>>>

d{"name":"小明",("model","cylinder","hpower"):["Toyota",4,500]}>>>

d[set([123])]

=

"abc"Traceback

(most

recent

call

last):File

"<pyshell#14>",

line

1,

in

<module>d[set([123])]

=

"abc"TypeError:

unhashable

type:

"set"3.键的类型键key值valuename小明sex男age18score80定义字典4.字典嵌套字典项的值可以为Python定义的多种类型对象，甚至也可以是一个字典。d={"name":{"first":"Johney","last":"Lee"},"age":40}访问字典>>>

d["age"]#取得age值40获取字典长度（len()函数）访问字典元素>>>

d

=

{"name":{"first":"Johney",

"last":"Lee"},

"age":40}>>>d["name"]["last"]#d["name"]取得{"first":"Johney","last":"Lee"}，进而取得其中键"last"的值"Lee""Lee"访问字典3.添加字典元素>>>d={"name":"小明","sex":"男","age":18}>>>

d["score"]

=

80>>>

d["age"]

=

d["age"]

+

1>>>

d{"name":"小明","sex":"男","age":19,"score":80}访问字典合并2个字典（update()函数）判断字典是否存在元素（关键字in，查找的是字典的键(key)）删除字典元素dict.pop(key[,default])>>>d={"age":18,"name":"小明","score":80,"sex":"男"}>>>d.pop("score")

#弹出以"score"为键的键值对儿，并返回对应的值80>>>

d{"age":18,"name":"小明","sex":"男"}>>>d.pop("score","not

exists")#尝试弹出键为"score"的元素，不存在，返回默认值"not

exists"访问字典7.遍历字典元素for

key

in

Dict.keys():

#遍历字典的键，即可使用Dict[key]获得对应的valuefor

value

in

Dict.values():

#遍历字典的值，随后可使用各value值for

key,value

in

Dict.items():#遍历字典的键与值，随后可使用key-value对d

=

{"age":

18,

"name":

"小明",

"score":

80,"sex":

"男"}for

key

in

d.keys():

#通过遍历key，访问所有的键值对儿print(key,

d[key])for

value

in

d.values():

#仅遍历valueprint(value)for

key,value

in

d.items():

#遍历key和valueprint(key,value)访问字典8.清空字典dict.clear()3.6数组ndarray创建数组numpy.array(object,

dtype=None,

copy=True,

order="K",

subok=False,ndmin=0)>>>

t1

=

(1,

2,

3);

t2

=

(2,

3,

4)>>>

arr

=

np.array((t1,

t2))>>>

arrarray([[1,

2,

3],[2,

3,

4]])>>>

arr1

=

np.array((5,

4,

3,

2,

1),dtype=

"float64")>>>

arr1>>>arr3=np.array((5,4,3,2,1),ndmin=3)

#创建3维数组>>>

arr3array([[[5,

4,

3,

2,

1]]])>>>

arr

=

np.array([[1,

2,

3],

[4,

5,

6],[7,

8,

9]])>>>

arrarray([[1,

2,

3],[4,

5,

6],[7,

8,

9]])array([5.,

4.,

3.,

2.,

1.])访问数组#一维数组>>>

arr1

=

np.array([3,

6])>>>

arr1.ndim;

arr1.shape1(2,)>>>arr2=np.array([[[1],[2]],[[3],[4]],[[5],[6]]])#三维数组>>>arr2.ndim;arr2.shape

#可得维数为3，各维阶数为(3,2,1)3(3,

2,

1)1.维数和各维阶数ndarray.ndimndarray.shape访问数组#生成一个由随机数数组>>>

arr

=

np.array(np.random.rand(2,

2))>>>

arr>>>arr.dtype#查看数组元素的数据类型dtype("float64")array([[0.9215393

,

0.43412927],[0.94762942,

0.21441442]])2.元素类型和个数ndarray.ndimndarray.shape>>>

arr.size4访问数组>>>

arr.reshape((2,

3))#将数组变换为2行3列array([[1,

2,

3],[4,

5,

6]])3.改变数组维数和阶数ndarray.reshape(shape,order="C")>>>

arr

=

np.array([[[1,

2]],

[[3,

4]],

[[5,

6]]])>>>

arr.shape(3,

1,

2)访问数组>>>

arr.reshape(-1,)#变换为一维数组。参数-1表示结果由数据个数确定>>>

arr.reshape(-1,

1)#变换为n行1列，这里用-1表示结果由数据个数确定array([[1],[2],[3],[4],[5],[6]])array([1,

2,

3,

4,

5,

6])(3,

1,

2)3.改变数组维数和阶数ndarray.reshape(shape,order="C")访问数组#数据类型变为了"float64">>>

arr1;arr1.dtypearray([[[1.,

2.]],[[3.,

4.]],[[5.,

6.]]])dtype("float64")4.更改数据类型ndarray.astype()>>>

arr

=

np.array([[[1,

2]],

[[3,

4]],

[[5,

6]]],

dtype="str")>>>

arrarray([[["1",

"2"]],[["3",

"4"]],[["5",

"6"]]],

dtype="<U1")>>>arr1=arr.astype(float)

#或arr1=arr.astype("float32")等访问数组>>>

arr1

=

np.array([[2,

4],

[5,

7],

[8,

1]])>>>

arr1[0]#二维数组#得到一维数组，为原二维数组的第0行>>>

arr1[0:2,

:]#仍得到二维数组，保留了原有的维度结构array([[2,

4],[5,

7]])array([2,

4])5.访问数组数据>>>

arr1[0,

:]#得到一维数组，为原二维数组第0行的各列array([2,

4])数组的运算array([[1,

2],[3,

4],[5,

6]])1.数值统计ndarray.sum(axis=None,

dtype=None,

out=None,

keepdims=False,

initial=0,

where=True)ndarray.mean(axis=None,

dtype=None,

out=None,

keepdims=False)ndarray.max(axis=None,

out=None,

keepdims=False,

initial=<no

value>,

where=True)ndarray.min(axis=None,

out=None,

keepdims=False,

initial=<no

value>,

where=True)>>>arr

>>>arr.sum()#或np.sum(arr)21>>>arr.sum(axis=0)#或

np.sum(arr,axis=0),按列求和array([

9,

12])#或np.sum(arr,>>>arr.sum(axis=1)axis=1),按行求和array([

3,

7,

11])数组的运算1.数值统计ndarray.sum(axis=None,

dtype=None,

out=None,

keepdims=False,

initial=0,

where=True)ndarray.mean(axis=None,

dtype=None,

out=None,

keepdims=False)ndarray.max(axis=None,

out=None,

keepdims=False,

initial=<no

value>,

where=True)ndarray.min(axis=None,

out=None,

keepdims=False,

initial=<no

value>,

where=True)>>>

arrarray([[1,

1,

4],[2,

3,

7],[4,

2,

9]])>>>np.argmax(arr,0)#计算所有列的最大值对应在该列中的索引array([2,

1,

2],

dtype=int64)>>>np.argmin(arr[1,:])#计算第2行中最小值所在列的索引0数组的运算>>>

arr1**2array([16,

4,

25],

dtype=int32)>>>

1/arr1array([0.25,

0.5

,

0.2

])2.加、减、乘、除、平方、倒数、负数、异或>>>

arr1

=

np.array([4,

2,

5])>>>

arr2

=

np.array([2,

4,

5])>>>

arr1

+arr2array([

6,

6,

10])>>>

-arr1array([-4,

-2,

-5])>>>

arr1

*

arr2array([

8,

8,

25])数组的运算>>>a+1

#运算时1进行了扩充np.array([[1,1],[1,1],[1,1]])array([[2.,

3.],[4.,

5.],[6.,

7.]])>>>a/b#运算时数组b进行了扩充np.array([[1.,2.],[1.,2.],[1.,2.]])array([[1.,

1.],[3.,

2.],[5.,

3.]])如果两个数据维度不一致时，低维数据会自动进行维度的复制扩充，进而完成相应的运算。>>>x=np.array([1,2,3])

#一维数组，shape=(3,)>>>w=np.array([[1,2,3],[4,5,6]])

#二维数组，shape=(2,3)>>>

w

*

xarray([[

1,

4,

9],[

4,

10,

18]])>>>a=np.array([[1.,2.],[3.,4.],[5.,6.]])

#二维数组，各维阶数为(3,2)>>>b=np.array([1.,2.])#一维数组，各维阶数(2,)数组的运算如果两个数据维度不一致时，低维数据会自动进行维度的复制扩充，进而完成相应的运算。>>>a=np.array([[1.,2.],[3.,4.],[5.,6.]])

#二维数组，各维阶数为(3,2)>>>b=np.array([[1.],[2.],[3.]])

#二维数组，各维阶数为(3,1)>>>

a

/

b#运算时数组b进行了扩充：np.array([[1.,1.],[2.,2.],[3.,3.]])array([[1. ,

2.

],[1.5 ,

2.

],[1.66666667,

2.

]])数组的运算>>>

arr1.shape;

arr1.T.shape#一维数组转置后阶数不变>>>

arr2.shape;

arr2.T.shape#二维数组转置后，各维阶数互换(1,

2)(2,

1)(2,)(2,)3.转置ndarray.T数组的运算4.指数运算，以e为底numpy.exp(x)>>>

a

=

np.array([

2,

5,

7])>>>

np.exp(a)array([

7.3890561

,

148.4131591

,

1096.63315843])访问数组>>>np.concatenate((a,b.T),axis=1)#沿行合并后，shape为(2,3)array([[1,

2,

5],[3,

4,

6]])点积、内积、外积合并numpy.concatenate((a1,

a2,

...),

axis=0,

out=None)>>>a=np.array([[1,2],[3,4]])

#shape为(2,2)>>>b=np.array([[5,6]])

#shape为(1,2)>>>np.concatenate((a,b),axis=0)

#沿列合并后，shape为(3,2)array([[1,

2],[3,

4],[5,

6]])>>>np.concatenate((a,b),axis=None)#axis=None,合并为一维(6,)数组array([1,

2,

3,

4,

5,

6])访问数组>>>

a

=

np.array([[1,2],

[3,4]])>>>

b

=

np.array([[5,6],

[7,8]])>>>np.vstack((a,b))#按列合并，增加行数>>>np.hstack((a,b))#按行合并，即行数不变，扩展列数array([[1,

2,

5,

6],[3,

4,

7,

8]])array([[1,

2],[3,

4],[5,

6],[7,

8]])点积、内积、外积合并numpy.vstack()或numpy.hstack()生成特定值ndarray对象numpy.zeros(shape,

dtype=float,

order="C")numpy.ones(shape,

dtype=None,

order="C")numpy.eye()numpy.diag()>>>np.diag([1,2,3])#对角数组array([[1,

0,

0],[0,

2,

0],[0,

0,

3]])>>>

np.zeros(3)>>>

np.ones((3,

3))array([[1.,

1.,

1.],[1.,

1.,

1.],[1.,

1.,

1.]])>>>np.eye(3)

#单位数组array([[1.,

0.,

0.],[0.,

1.,

0.],[0.,

0.,

1.]])array([0.,

0.,

0.])3.7矩阵matrix创建matrix对象numpy.matrix(data,

dtype=None,

copy=True)>>>

np.matrix([[1,2,3],[4,5,6],[7,8,9]],dtype=float)#由列表数据创建matrix([[1.,

2.,

3.],[4.,

5.,

6.],[7.,

8.,

9.]])>>>np.matrix(((1,2,3),(4,5,6)))#由元组数据创建矩阵>>>

np.matrix(np.array([[1,2,3],[4,5,6],[7,8,9]]))#由数组数据创建matrix([[1,

2,

3],[4,

5,

6],[7,

8,

9]])>>>

np.matrix([np.array([1,2,3]),np.array([4,5,6])])#由数组数据创建matrix([[1,

2,

3],[4,

5,

6]])matrix([[1,

2,

3],[4,

5,

6]])访问matrix>>>

mtx[1,2]#访问第1行第2列元素7>>>

mtx>>>mtx[1]#访问子矩阵，或mtx[1,:]matrix([[5,

6,

7,

8]])#访问第0、1行、第1、2>>>

mtx[0:2,

1:3]列构成的2x2矩阵matrix([[2,

3],[6,

7]])matrix([[

1,

2,

3,

4],[

5,

6,

7,

8],[

9,

10,

11,

12],[13,

14,

15,

16]])matrix运算>>>

mtx.getT()#求转置矩阵matrix([[1,

3],[2,

4]])>>>

mtx

=

np.matrix(([1,2],[3,4]))>>>mtx.I

#求逆矩阵matrix([[-2.

,

1.

],[

1.5,

-0.5]])数值统计与检索加、减、除、倒数、负数、异或求逆和转置numpy.matrix.I

或

numpy.matrix.getI()numpy.matrix.T

或

numpy.matrix.getT()matrix运算>>>

np.multiply(a,

b)matrix([[2,

2]])4.矩阵相乘和点积numpy.multiply()numpy.dot()>>>

mtx1

=

np.matrix((1,2,3))#1x3矩阵>>>

mtx2

=

np.matrix([[1],[2],[3]])#3x1矩阵>>>mtx1

*

mtx2

#得到1x1矩阵matrix([[14]])>>>

a

=

np.matrix([1,1])>>>

b

=

np.matrix([2,2])>>>

b

=

np.matrix([2,2])>>>

b

*

2matrix([[4,

4]])matrix运算5.合并（与array相似）矩阵、列表、数组间的互相转换matrix.getA()matrix.tolist()#创建一个矩阵#将矩阵转换成列表>>>

matrix1.tolist()[[1,

2],

[3,

2],

[5,

2]]>>>

matrix1

=

np.matrix([[1,2],[3,2],[5,2]])>>>matrix1.getA()

#将矩阵转换成数组array([[1,

2],[3,

2],[5,

2]])>>>arr1=np.array(matrix1)#将矩阵转换成数组3.8系列Series创建Series对象pandas.Series(data=None,

index=None,

dtype=None,

name=None,

copy=False,fastpath=False)>>>pd.Series(data=[1,2,3,4,5],index=["a","b","c","d","e"],name="s",dtype=float)#指定index、name和dtype>>>

d={"a":1,"b":2,"c":3,"d":4,"e":5}>>>

s

=

pd.Series(d,

name="sDict",dtype=float)Name:

sDict,

dtype:

float64a

1.0a1.0b

2.0b2.0c

3.0c3.0d

4.0d4.0e

5.0e5.0Name:

s,

dtype:

float64访问Series对象1.访问对象结构>>>#对于上例中的Series对象>>>="series"

#访问和修改Series对象的name>>>s.index=["q","w","e","r","t"]

#访问和修改index>>>

sq1.0w2.0e3.0r4.0t5.0Name:

series,

dtype:

float64访问Series对象>>>s.values[2]=333#修改特定数据>>>

sName:

series,

dtype:

float642.访问数据>>>s.values

#对于上例中的Series对象，访问其数据array([1.,

2.,

3.,

4.,

5.])>>>

s.values[:]

=

[11,22,33,44,55]>>>

sq1.0a11.0w2.0b22.0e333.0c33.0r4.0d44.0t5.0e55.0Name:

series,

dtype:

float64Series对象的运算>>>

s**3#或s.pow(3)a

1.0b

8.0c

27.0d

64.0e

125.0Name:

sDict,

dtype:

float64a

1.0b

4.0c

9.0d

16.0e

25.0Name:

sDict,

dtype:

float641.数学及统计运算>>>#对于上例中的原始Series对象>>>s

*

11#与数值相乘，即为与每个Series的数据元素相乘a

11.0b

22.0c

33.0d

44.0e

55.0Name:

sDict,

dtype:

float64>>>s*(1,2,3,4,5)#与“数组”相乘，即为与每个Series的数据元素对应相乘Series对象的运算1.数学及统计运算>>>s.count();s.sum()#计算计数、总和515.0>>>s.max();s.min()#计算最大、最小值>>>

s.mean()#计算均值3.0>>>s.std()

#计算标准差1.58113883008418985.01.0Series对象的运算2.更改数据类型>>>

ser

=

pd.Series(["20210826",

"20210827",

"20210828",

"20210829"])>>>

ser0

202108261

202108272

202108283

20210829dtype:

objectSeries对象的运算2.更改数据类型#转换为datetime数据类型>>>

ser_dt

=

ser.apply(pd.to_datetime)>>>

ser_dt0

2021-08-261

2021-08-272

2021-08-283

2021-08-29dtype:

datetime64[ns]Series对象的运算2.更改数据类型>>>ser_dt.map(lambda

x:str(x))#使用.map()将datetime型转为str型0

2021-08-26

00:00:001

2021-08-27

00:00:002

2021-08-28

00:00:003

2021-08-29

00:00:00dtype:

object3.9数据框架DataFrame创建DataFrame对象pandas.DataFrame(data=None,

index=None,

columns=None,

dtype=None,copy=False)>>>df=

pd.DataFrame()>>>

dfEmpty

DataFrameColumns:

[]Index:

[]创建DataFrame对象函

数说

明DataFrame(由数组、列表或元组组成的字典)每个序列会变成DataFrame的一列。所有序列的长度必须相同。DataFrame(由Series组成的字典)每个Series会成为一列。如果没有显式制定索引，则各

Series的索引会被合并成结果的行索引。DataFrame(由字典组成的字典)各内层字典会成为一列。键会被合并成结果的行索引。DataFrame(二维ndarray)数据矩阵，还可以传入行标和列标。DataFrame(字典或Series的列表)各项将会成为DataFrame的一行。索引的并集会成为

DataFrame的列标。DataFrame(由列表或元组组成的列表)类似于二维ndarrayDataFrame(DataFrame)沿用DataFrame创建DataFrame对象>>>

d

=

{"height"

:

np.array([1,

2,

3,

4,

5]),"weight"

:

[5,

4,

3,

2,

1],"age":(15,14,16,17,13)}#定义多种类型数据构成的字典>>>idx=("KEVIN","SAM","PETER","HELEN","SMITH")#类型为元组>>>df=pd.DataFrame(data=d,index=idx)#创建DataFrame>>>

dfheightweight

ageKEVIN

15

15SAM

24

14PETER

33

16HELEN

42

17SMITH

51

13创建DataFrame对象如果在创建DataFrame对象时不指定columns和index，则使用默认序号值。>>>df=pd.DataFrame(np.random.randint(0,10,(4,5)))#产生随机数>>>df

#未指定columns和index0

1

2

340

035361

790132

733493

43332访问DataFrame>>>df.index=("KEVIN","SAM","PETER","HELEN","SMITH")#修改index内容>>>df.index.rename("IDX",inplace=True)

#修改index的名字>>>df.columns=["code","number","value","level","score"]#修改columns内容>>>df.columns.rename("COL",inplace=True)#修改columns名字>>>

dfe="object",

name="COL")COL code

number

value

level

scoreIDXKEVIN50337SAM93524PETER76881HELEN67781SMITH598941.访问index和columns>>>

df0

1

2

3

40

5

0

3

3

71

9

3

5

2

42

7

6

8

8

13

6

7

7

8

14

5

9

8

9

4访问Dat