知识点：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))