知识点:Python数据分析基础
-
Python基础
Python环境安装
下载、安装Anaconda3
wget https://repo.anaconda.com/archive/Anaconda3-2019.03-Linux-x86_64.sh
bash Anaconda3-2019.03-Linux-x86_64.sh
这里选择yes
配置路径
source ~/.bashrc
部署jupyter notebook过程
<1>配置环境,通过远程方式访问jupyter notebook,记录配置文件的路径/root/.jupyter/jupyter_notebook_config.py
jupyter notebook --generate-config
<2>生成登陆密码,进入Python
from notebook.auth import passwd
passwd()
保存密码,例如:'sha1:9196ad6d9d4a:a63068b5e26b0ea608bbd31675a517ef5c49de1a'
<3>修改<1>生成的配置文件
vi ~/.jupyter/jupyter_notebook_config.py #对应你的路径
c.NotebookApp.ip='*'
c.NotebookApp.password = '你保存的密码'
c.NotebookApp.open_browser = False
c.NotebookApp.port =8888 #随便指定一个端口,使用默认8888也可以
<4>启动Jupyter服务
jupyter notebook --ip=0.0.0.0 --no-browser --allow-root
nohup jupyter notebook --ip=0.0.0.0 --no-browser --allow-root & #后台启动
<5>浏览器访问,并输入密码
http://服务器地址:端口号
<6>结束进程
netstat -tunpl
kill -9 PID号、PID号、PID号等 或 killall 进程名
Python基本用法:控制语句、函数、文件读写等
控制语句由条件语句、循环语句构成,控制语句根据条件表达式控制程序的流转
条件判断语句
if else语句
a = input("a:")
a = int(a)
b = input("b:")
b = int(b)
if(a > b):
print (a, " > ", b)
else:
print (a, " < ", b)
if elif else语句
score = float( input("score:")) # 接受用户输入并转换为float类型,当输入的为小数时,使用int转换会报错
if 90 <= score <= 100:
print("A")
elif 80 <= score < 90:
print("B")
elif 60 <= score < 80:
print("C")
else:
print("D")
嵌套if语句,尽可能避免使用,不便于阅读,而且容易忽略一些可能性
x = -1
y = 99
if(x >= 0):
if(x > 0): #嵌套的if语句
y = 1
else:
y = 0
else:
y = -1
print ("y =", y)
switch替代方案1
class switch(object):
def __init__(self, value): # 初始化需要匹配的值value
self.value = value
self.fall = False # 如果匹配到的case语句中没有break,则fall为True。
def __iter__(self):
yield self.match # 调用match方法 返回一个生成器
raise StopIteration # StopIteration 异常来判断for循环是否结束
def match(self, *args): # 模拟case子句的方法
if self.fall or not args: # 如果fall为true,则继续执行下面的case子句
# 或case子句没有匹配项,则流转到默认分支。
return True
elif self.value in args: # 匹配成功
self.fall = True
return True
else: # 匹配失败
return False
operator = "+"
x = 1
y = 2
for case in switch(operator): # switch只能用于for in循环中
if case('+'):
print (x + y)
break
if case('-'):
print (x - y)
break
if case('*'):
print (x * y)
break
if case('/'):
print (x / y)
break
if case(): # 默认分支
print ""
switch替代方案2
# 使用字典实现switch语句
from __future__ import division
x = 1
y = 2
operator = "/"
result = {
"+" : x + y,
"-" : x - y,
"*" : x * y,
"/" : x / y
}
print result.get(operator)
循环语句,注意不要死循环
while循环
x = float(input("输入x的值:")) # 接收用户输入的数字并转换为float类型
i = 0
while(x != 0): # python3中不等于抛弃了<>,一律使用!=
if(x > 0):
x -= 1 # 如果x大于0则减1
else:
x += 1 # 如果x小于0则加1
i = i + 1
print( "第%d次循环:" %(i, x))
else:
print ("x等于0:", x)
for循环
# for in语句
for x in range(-1, 2):
if x > 0:
print ("正数:",x)
elif x == 0 :
print ("零:",x)
else:
print ("负数:",x)
else:
print ("循环结束")
break,continue
参考switch替代方案2例子
函数
switch替代方案2封装成函数
from __future__ import division
def arithmetic(x, y, operator):
result = {
"+" : x + y,
"-" : x - y,
"*" : x * y,
"/" : x / y
}
return result.get(operator) # 返回计算结果
return返回多个值,可以把这些值打包到元祖中,在调用时,对返回的元祖进行解包即可
def func(x, y, z):
l = [x, y, z]
l.reverse()
numbers = tuple(l)
return numbers
x, y, z = func(0, 1, 2)
print (x, y, z)
多个return语句
def func(x):
if x > 0:
return "x > 0"
elif x == 0:
return "x == 0"
else:
return "x < 0"
print (func(-2))
多个return语句重构,增加变量
def func(x):
if x > 0:
result = "x > 0"
elif x == 0:
result = "x == 0"
else:
result = "x < 0"
return result
print (func(-2))
嵌套函数
def sum(a, b):
return a + b
def sub(a, b):
return a - b
def func():
x = 1
y = 2
m= 3
n = 4
return sum(x, y) * sub(m, n)
print (func())
嵌套函数,内部函数
def func():
x = 1
y = 2
m= 3
n = 4
def sum(a, b): # 内部函数
return a + b
def sub(a, b): # 内部函数
return a - b
return sum(x, y) * sub(m, n)
print (func())
递归函数,经典例子,计算阶乘
def refunc(n):
i = 1
if n > 1: # 递归的结束判断
i = n
n = n * refunc(n-1) # 递推
print ("%d! =" %i, n)
return n # 回归
refunc(5)
lambda函数
lambda函数用于创建一个匿名函数,函数名未和标识符进行绑定,使用lambda函数可以返回一些简单的运算结果。lambda函数的格式如下
lambda 变量1,变量2,... :表达式
其中,变量列表用于表达式的计算,lambda属于函数,因此变量列表后需要一个冒号,通常把lambda赋值给一个变量,变量就可作为函数使用
def func():
x = 1
y = 2
m= 3
n = 4
sum = lambda x, y : x + y
print (sum)
sub = lambda m, n : m - n
print (sub)
return sum(x, y) * sub(m, n)
print (func())
lambda也可以直接作为函数使用
print ((lambda x:-x)(-2))
Generator函数
生成器(Generator)的作用是一次产生一个数据项,并把数据项输出,Generator函数可以用在for循环中遍历,Generator函数,每次返回一个数据项的特性,使得迭代器的性能更佳。Generator函数的定义和普通函数的定义没什么区别,只要在函数体内使用yield生成数据项即可。Generator函数可以被for循环遍历,而且可以通过next()方法获得yield生成的数据项。
def func(n):
for i in range(n):
yield i
# 在for循环中输出
for i in func(3):
print (i)
# 使用next()输出
r = func(3)
print (r.next())
print (r.next())
print (r.next())
print (r.next())
yield关键字与return关键字的返回值和执行原理都不相同,yield生成值并不会中止程序的执行,返回值后程序继续往后执行。return返回值后,程序将中止执行。
def func(n):
for i in range(n):
return i
def func2(n):
for i in range(n):
yield i
print (func(3))
f = func2(3)
print (f)
print (f.next())
print (f.next())
文件读写
使用readline()读文件,按行读取,需要使用永真表达式循环读取文件。但当文件指针移动到文件的末尾时,依然使用readline()读取文件将出现错误,因此程序需要添加1个判断语句,判断文件指针是否移动到文件的尾部,并且通过该语句中断循环。
f = open("hello.txt")
while True:
line = f.readline()
if line:
print (line)
else:
break
f.close()
使用readlines()读文件,需要通过循环访问readlines()返回列表中的元素。函数readlines()可以一次性读取文件多行数据。
f = file('hello.txt')
lines = f.readlines()
for line in lines: # 一次读取多行内容
print (line)
f.close()
使用read()最简单,将从文件中一次性读出所有内容,并赋值给1个字符串变量
f = open("hello.txt")
context = f.read()
print (context)
f.close()
可以通过控制read()参数的值,返回指定字节的内容
f = open("hello.txt")
context = f.read(5) # 读取文件前5个字节内容
print (context)
print (f.tell()) # 返回文件对象当前指针位置
context = f.read(5) # 继续读取5个字节内容
print (context)
print (f.tell()) # 输出文件当前指针位置
f.close()
使用writelines()写文件
f = file("hello.txt", "w+")
li = ["hello world\n", "hello China\n"]
f.writelines(li)
f.close()
追加新的内容到文件
f = file("hello.txt", "a+") # 写入方式为追加a+
new_context = "goodbye"
f.write(new_context)
f.close()
使用writelines()写文件的速度更快。如果需要写入文件的字符串非常多,可以使用writelines()提高效率。如果只需要写入少量的字符串,直接用write()即可。
Python基本数据结构:字典、集合等
元组
元组是Python中常用的一种数据结构,元组由不同的元素组成,每个元素可以存储不同类型的数据,如字符串,数字,甚至元组。元组是“写保护”的,即元组创建后不能再做任何修改操作,元组通常代表一行数据,而元组中的元素代表不同的数据项。
如果创建的元组只包含一个元素,通常会错误忽略单元素后的逗号,这样,python无法区分变量tuple是元组还是表达式,python误认为圆括号中的内容为表达式,因此tuple[0]输出的结果并非期望的值,并且其类型也不是tuple。正确的写法如下:
tuple = ["apple" , ] #定义元组,注意后面的逗号不可少
print (tuple[0]) #打印第一个元素
print (type(tuple)) #打印定义的tuple的类型
元组的访问
访问格式:tuple[n] ,n可以是0、正负整数。
输出:print (tuple[n])
可以把元组理解为C或者Java中的数组。
注意:元组创建后其内部元素的值不能被修改。元组中的元素不支持赋值操作。
提示:元组不能添加或删除任何元素。因此,元组不存在任何添加、删除元素的方法,元组也不存在任何其他方法。
元组的访问还有一些特殊的用法,例如负数索引和分片索引。这两个特性是python的特殊用法,C或者Java语言并不支持。负数索引从元组的尾部开始计数,最尾端的元素索引表示“-1”,次尾端的元素索引表示“-2”,以此类推。
分片是元组的一个子集,分片是从第1个索引到第2个索引(不包含第2个索引所指向的元素)所指定的所有元素。分片索引可以为正数或负数,两个索引之间用冒号分隔。分片的格式如下:
tuple[m:n] 其中m、n可以是0、正整数或负整数。
tuple=("apple","banana","grape","orange") #定义元组
print (tuple[-1])
print (tuple[-2])
tuple2 = tuple[1:3] #分片,第二个元素到第三个元素(不包括第四个)
tuple3 = tuple[0:-2] #分片,从第一个元素到倒数第二个元素(不包括倒数第二个)
tuple4 = tuple[2:-1] #分片,从第三个元素到倒数第一个元素(不包括倒数第一个)
print (tuple2)
print (tuple3)
print (tuple4)
元组还可以由其他元组组成。例如,二元元组可以表示为:
tuple = (('t1' , 't2'), ('t3' , 't4'))
该元组是一个二元元组,该元组由('t1' , 't2')和('t3' , 't4')组成。
fruit1 = ("apple", "banana")
fruit2 = ("grape", "orange")
tuple = (fruit1, fruit2)
print (tuple)
print ("tuple[0][1] =", tuple[0][1]) #打印输出第一个元组的第二个元素
print ("tuple[1][1] =", tuple[1][1]) #打印输出第二个元组的第二个元素
创建元组的过程,python称为“打包”。相反,元组也可以执行“解包”的操作。“解包”可以将打包元组中的各个元素分别赋值给多个变量,降低了代码的复杂性,使表达方式更自然。“打包”和“解包”例:
#打包
tuple = ("apple", "banana", "grape", "orange")
#解包
a, b, c, d = tuple #将元组中的元素分别赋值给a,b,c,d
print(a,b,c,d)
元组的遍历
元组的遍历是指通过循环语句依次访问元组中各元素的值。遍历元组需要用到两个函数range()和len()。range()和len()都是python的内建函数,这些函数可直接调用,不需要import语句导入模块。内建函数是Python自动导入的函数,相当与Java中的lang包。
len()计算出tuple元组中元素的个数,range()返回一个由数字组成的列表。
tuple = (("apple","banana"),("grape","orange"),("watermelon", ),("grapefruit", ))
for i in range(len(tuple)):
print("tuple[%d]:" %i)
for j in range(len(tuple[i])):
print(tuple[i][j])
print()
也可以用for实现遍历元组
tuple = (("apple","banana"),("grape","orange"),("watermelon", ),("grapefruit", )) #定义一个二元元组
for i in tuple:
for j in i:
print(j)
列表
列表是Python中非常重要的数据类型,通常作为函数的返回类型。列表和元组相似,也是由一组元组组成,列表可以实现添加、删除和查找操作,元素的值可以被修改。
列表的创建
List(列表)是Python内置的一种数据结构。它由一系列元素组成,所有元素被包含在一对方括号中。列表创建后,可以执行添加或删除操作。格式如下:
list = [元素1, 元素2, ...]
列表的添加可以调用append(),该方法的声明如下所示。
append(object)
其中,object可以是元组、列表、字典或任何对象。
列表的删除可以调用remove(),该方法的声明如下所示。
remove(value)
该方法也可删除元素value。如果value不在列表中,python将抛出异常
list = ["apple","banana","grape","orange"] #定义列表
print(list)
print(list[2])
list.append("watermelon") #在列表末尾添加元素
list.insert(1,"grapefruit") #向列表中插入元素
print(list)
list.remove("grape") #从列表中移除grape
print(list)
print(list.pop()) #打印从列表中弹出的元素,即最后一个元素。pop()表示取出最后一个元素
print(list)
注意:如果list列表中存在两个相同的元素,此时调用remove()移除同名元素,将只删除List列表中靠前的元素。
列表的使用,与元组十分相似,同样支持负数索引、分片以及多远列表等特性,但是列表中的元素可修改,而且存在一些处理列表的方法。
list = ["apple","banana","grape","orange"] #定义列表
print(list[-2])
print(list[1:3])
print(list[-3:-1])
list = [["apple","banana"],["grape","orange"],["watermelon"],["grapefruit"]]
for i in range(len(list)):
print("list[%d]:" %i)
for j in range(len(list[i])):
print(list[i][j])
print()
列表实现了连接操作的功能,列表的连接同样提供了两种方式,一种是调用extend()连接两个不同的列表,另一种是使用运算符“+”或“+=”。
list1=["apple","banana"]
list2=["grape","orange"]
list1.extend(list2) #list1连接list2
print(list1)
list3=["watermelon"]
list1=list1+list3 #将list1与list3连接后赋给list1
print(list1)
list1+=["grapefruit"] #使用+=给list1连接上["grapefruit"]
print(list1)
list1=["apple","banana"]*2 #连接两个相同的列表
print(list1)
列表的查找、排序、反转
list列表可以进行添加、删除操作,此外List列表还提供了查找元素的方法。list列表的查找提供了两种方式,一种是使用index方法返回元素在列表中的位置,另一种方法是使用关键字“in”来判断元素是否存在列表中。
list=["apple","banana","grape","orange"]
print(list.index("grape")) #打印grape的索引
print(list.index("orange")) #打印orange的索引
print("orange" in list) #判断orange是否在列表中
列表的排序和反转
list=["banana","apple","orange","grape"]
list.sort() #排序,按首字母升序排序
print("Sorted list:",list)
list.reverse() #反转,反转列表中元素的排列顺序
print("Reversed list:",list)
集合(Set)
set与dict大致相同,但set没有Value,只有key。因此,set只是一组key的集合。由于key不能重复,所以,在set中,没有重复的key。
创建空集合
在集合中,创建空集合(set)必须使用函数set()。不能使用{},{}用于创建空字典。
#创建空集合
>>>a = set()
>>>a
set()
>>>type(a)
<class 'set'>
创建非空集合
非空集合可以用大括号{}或 set()函数来创建。
#创建集合
>>>a={'a','b','c','d'}
>>>b=set('abcdefabcd')
>>>c=set({'a':1,'b':2,'c':3})
>>>d=set(['a','b','c','a'])
#运行结果
>>>print(a,type(a))
{'c', 'd', 'b', 'a'} <class 'set'>
>>>print(b,type(b))
{'f', 'e', 'b', 'c', 'd', 'a'} <class 'set'>
>>>print(c,type(c))
{'b', 'a','c'} <class 'set'>
>>>print(d,type(d))
{'c', 'b', 'a'} <class 'set'>
添加元素
在集合中添加元素,可以使用add()方法,并且不生成一个新的集合。add()方法可以向set中添加元素,可以重复添加,但不会有效果。
#添加元素:add()
>>>s = {1,2,3}
>>>s.add(4)
>>>s
{1,2,3,4}
>>>s.add('g')
>>>s
{1,2,3,4,'g'}
>>>s.add(4)
>>>s
{1,2,3,4,'g'}
删除元素
set中利用remove()方法可以删除集合中的元素。
#删除元素
>>>s
{1,2,3,4,'g'}
>>>s.remove('g')
>>>s
{1,2,3,4}
清空元素
clear()方法可以清空set中的元素。
#清空元素
>>>a = {1,2,3,4}
>>>b = a.clear()
>>>print(a,type(a))
set() <class 'set'>
>>>print(b,type(b))
None <class 'NoneType'>
复制元素
copy()方法只能浅拷贝set中的元素,并生成一个新的集合。
#浅拷贝:copy()
>>>a = {1,(9,2),3}
>>>b = a.copy()
>>>print(a,id(a))
{(9, 2), 1, 3} 2097937619880
>>>print(b,id(b))
{(9, 2), 1, 3} 2097937620776
#赋值
>>>s = {1,2,3,4}
>>>d = s
>>>print(s,id(s))
{1, 2, 3, 4} 2097937785128
>>>print(d,id(d))
{1, 2, 3, 4} 2097937785128
pop()
pop()方法用于从set中随机取一个元素。记住,是随机的~~~
#pop()方法
>>>s = {1,2,3,4,5,'g','s'}
>>>s.pop()
'g'
>>>s.pop()
3
set集合操作
#set集合操作
>>>s = {1,2,3,4}
>>>d = {2.3.5.6}
>>>s & d
{2.3}
>>>s | d
{1,2,3,4,5,6}
>>>s - d
{1,4}
>>>d - s
{5,6}
字典(Dict)
字典结构
字典是Python中重要的数据类型,字典的由“键-值”对组成的集合,字典中的“值”通过“键”来引用。
字典的创建
字典由一系列的“键-值”(key-value)对组成,“键-值”对之间用“逗号”隔开,并且被包含在一堆花括号中。字典与java语言中的HashMap类作用类似,都是采用“键-值”对映射的方式存储数据。
字典的创建格式如下:
dictionary={key1:value1, key2:value2,...}
其中,key1、key2等表示字典的key值,value1、value2等表示字典的value值。
如果需要创建一个空的字典,只需要一对花括号即可,代码如下:
dictionary = {}
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
print(dict)
print(dict["a"]) #打印建a对应的值
print(dict[2]) #打印建2对应的值,不用双引号
print()的使用非常灵活,也可以在print()中使用字典。下面示例字典在print()中的使用。
print("%s,%(a)s,%(b)s" %{"a":"apple", "b":"banana"})
解释:其中隐式的创建了字典{“a”:"apple","b":"banana"}。这个字典用来定制print()中的参数列表。“%s”输出这个字典的内容,"%(a)s"获取字典中对应的key值“a”的value值,“%(b)s”获取字典中对应key值"b"的value值。
字典的访问
字典的访问与元组、列表有所不同,元组和列表是通过数字索引来获取对应的值,而字典是通过key值获取相应的value值。访问字典格式如下:
value = dict[key]
字典的添加、删除和修改非常简单,添加或修改操作只需要编写一条赋值语句,例如:
dict["x"] = "value"
如果索引x不在字典dict的key列表中,字典dict将添加一条新的映射(x:value);如果索引x在字典dict的key列表中,字典dict将直接修改索引x对应的value值。
字典与列表不同,字典并没有remove()操作。字典元素的删除可以调用del()实现,del()属于内建函数,直接调用即可。列表可以调用pop()弹出列表中的一个元素,字典也有一个pop(),该方法的声明和作用与列表的pop()有些不同。pop()的声明如下所示。
D.pop(k[,d]) -> v
pop()必须指定参数才能删除对应的值。其中,参数k表示字典的索引,如果字典D中存在索引k,返回值v等于D[k];如果字典D中没有找到索引k,返回值为d。
如果需要清除字典中所有的内容,可以调用字典的clear()
#字典的添加、删除、修改操作
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
dict["w"]="watermelon" #添加字典元素
del(dict["a"]) #删除字典中键为a的元素
dict["g"]="grapefruit" #修改字典中键为g的值
print(dict.pop("b")) #弹出字典中键为b的元素
print(dict)
dict.clear() #清除字典中所有元素
print(dict)
由于字典是无序的,因此字典中没有append()、remove()等方法。如果需要向字典插入新的元素,可以调用setdefault()。
字典的遍历有多种方式,最直接的方式是通过"for...in..." 语句完成遍历的任务
dict={1:"apple",2:"banana",3:"grape",4:"orange"}
for k in dict:
print("dict[%s]" %k,dict[k])
语句循环访问字典dict,变量k获取的是字典dict的key值,并没有直接获取value值。因此打印输出时,通过dict[k]来获取value值。
此外,还可以使用字典的items()实现字典的遍历操作,items()返回一个由若干元组组成的列表
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
print(dict.items())
可见,items()把字典中每对key和value组成一个元组,并把这些元组存放在列表中返回。下面将使用字典item()实现字典的遍历。
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
for(k,v) in dict.items(): #变量k和v分别与字典dict中的key和cvalue值对应
print("dict[%s]" %k,v)
除了能采用字符串作为字典的value值,元组、列表甚至字典都可以作为字典的value值。使用元组、列表或字典作为value值创建字典,称为混合型字典。格式如下:
dict={"key1":(tuple), "key2":[list], "key3":[dictionary] ...}
dict={"a":("apple",),"g":["grape","grapefruit"],"bo":{"b":"banana","o":"orange"}}
print(dict["a"])
print(dict["a"][0])
print(dict["g"])
print(dict["g"][1])
print(dict["bo"])
print(dict["bo"]["b"])
字典的方法
get()方法
#get()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
if "key1" in D:
print (D["key1"])
else:
print ("None")
#字典中元素的获取方法
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print (dict)
print (dict.get("c", "apple")) # 使用get获取键为c的值,若不存在返回默认值apple
print (dict.get("e", "apple")) # 使用get获取键为e的值,若不存在返回默认值apple
update()方法
#udpate()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
E = {"key3" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print (D)
#字典E中含有字典D中的key
D = {"key1" : "value1", "key2" : "value2"}
E = {"key2" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print (D)
#字典的更新
dict = {"a" : "apple", "b" : "banana"}
print (dict)
dict2 = {"c" : "grape", "d" : "orange"}
dict.update(dict2) # 使用update方法更新dict
print (dict)
setdefault()方法
# 设置默认值
dict = {}
dict.setdefault("a")
print (dict)
dict["a"] = "apple"
dict.setdefault("a", "None")
print (dict)
sorted()方法
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
print (dict)
#按照key排序
print (sorted(dict.items(), key=lambda d: d[0]))
#按照value排序
print (sorted(dict.items(), key=lambda d: d[1]))
浅拷贝
#字典的浅拷贝
dict = {"a" : "apple", "b" : "grape"}
dict2 = {"c" : "orange", "d" : "banana"}
dict2 = dict.copy() # 拷贝dict并赋给dict2
print (dict2)
深拷贝
#字典的深拷贝
import copy
dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}
dict2 = copy.deepcopy(dict) # 深拷贝
dict3 = copy.copy(dict) # 浅拷贝
dict2["b"]["g"] = "orange"
print (dict)
dict3["b"]["g"] = "orange"
print (dict)
字典B浅拷贝字典A的数据,如果字典B的数据发生添加、删除或修改操作,字典A的数据也将发生变化;相反,如果字典B深拷贝字典A的数据,字典B的数据即使发生变化,也不会影响到字典A
-
Pandas基础
Pandas环境安装
安装Anaconda3,已经内置Pandas
Pandas数据结构:Series和Dataframe
将在云主机操作Anaconda3,链接:
-
实践
import numpy as np
import stats as sts
scores = [31, 24, 23, 25, 14, 25, 13, 12, 14, 23,
32, 34, 43, 41, 21, 23, 26, 26, 34, 42,
43, 25, 24, 23, 24, 44, 23, 14, 52,32,
42, 44, 35, 28, 17, 21, 32, 42, 12, 34]
#集中趋势的度量
print('求和:',np.sum(scores))
print('个数:',len(scores))
print('平均值:',np.mean(scores))
print('中位数:',np.median(scores))
print('众数:',sts.mode(scores))
print('上四分位数',sts.quantile(scores,p=0.25))
print('下四分位数',sts.quantile(scores,p=0.75))
#离散趋势的度量
print('最大值:',np.max(scores))
print('最小值:',np.min(scores))
print('极差:',np.max(scores)-np.min(scores))
print('四分位差',sts.quantile(scores,p=0.75)-sts.quantile(scores,p=0.25))
print('标准差:',np.std(scores))
print('方差:',np.var(scores))
print('离散系数:',np.std(scores)/np.mean(scores))
#偏度与峰度的度量
print('偏度:',sts.skewness(scores))
print('峰度:',sts.kurtosis(scores))
#中位数实现
def median(data):
data.sort()
half = len(data) // 2
return (data[half] + data[~half])/2
l = [1,2,3,7,5,6,4,9,8,10]
if __name__ == '__main__':
print(median(l))
网友评论