知識(shí)點(diǎn)：Python數(shù)據(jù)分析基礎(chǔ)

• Python基礎(chǔ)

Python環(huán)境安裝

下載奇唤、安裝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過(guò)程

<1>配置環(huán)境，通過(guò)遠(yuǎn)程方式訪(fǎng)問(wèn)jupyter notebook，記錄配置文件的路徑/root/.jupyter/jupyter_notebook_config.py

    jupyter notebook --generate-config

<2>生成登陸密碼布近，進(jìn)入Python

    from notebook.auth import passwd
    passwd()

保存密碼，例如：'sha1:9196ad6d9d4a:a63068b5e26b0ea608bbd31675a517ef5c49de1a'

<3>修改<1>生成的配置文件

    vi ~/.jupyter/jupyter_notebook_config.py #對(duì)應(yīng)你的路徑
    c.NotebookApp.ip='*'
    c.NotebookApp.password = '你保存的密碼'
    c.NotebookApp.open_browser = False
    c.NotebookApp.port =8888    #隨便指定一個(gè)端口扫茅，使用默認(rèn)8888也可以

<4>啟動(dòng)Jupyter服務(wù)

   jupyter notebook --ip=0.0.0.0 --no-browser --allow-root
   nohup jupyter notebook --ip=0.0.0.0 --no-browser --allow-root & #后臺(tái)啟動(dòng)

<5>瀏覽器訪(fǎng)問(wèn)暂衡，并輸入密碼

http://服務(wù)器地址:端口號(hào)

<6>結(jié)束進(jìn)程

   netstat -tunpl 
   kill -9 PID號(hào)、PID號(hào)浊服、PID號(hào)等 或 killall 進(jìn)程名

Python基本用法：控制語(yǔ)句统屈、函數(shù)、文件讀寫(xiě)等

控制語(yǔ)句由條件語(yǔ)句牙躺、循環(huán)語(yǔ)句構(gòu)成愁憔，控制語(yǔ)句根據(jù)條件表達(dá)式控制程序的流轉(zhuǎn)

條件判斷語(yǔ)句

if else語(yǔ)句

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語(yǔ)句

score = float( input("score:"))  # 接受用戶(hù)輸入并轉(zhuǎn)換為float類(lèi)型,當(dāng)輸入的為小數(shù)時(shí)孽拷，使用int轉(zhuǎn)換會(huì)報(bào)錯(cuò)
if 90 <= score <= 100:
    print("A")
elif 80 <= score < 90:
    print("B")
elif 60 <= score < 80:
    print("C")
else:
    print("D")

嵌套if語(yǔ)句吨掌，盡可能避免使用，不便于閱讀脓恕，而且容易忽略一些可能性

x = -1
y = 99
if(x >= 0):
    if(x > 0):          #嵌套的if語(yǔ)句
        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語(yǔ)句中沒(méi)有break膜宋，則fall為T(mén)rue。

    def __iter__(self):
        yield self.match           # 調(diào)用match方法 返回一個(gè)生成器
        raise StopIteration     # StopIteration 異常來(lái)判斷for循環(huán)是否結(jié)束

    def match(self, *args):         # 模擬case子句的方法
        if self.fall or not args:       # 如果fall為true炼幔，則繼續(xù)執(zhí)行下面的case子句
                                 # 或case子句沒(méi)有匹配項(xiàng)秋茫，則流轉(zhuǎn)到默認(rèn)分支。
            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循環(huán)中
    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():                      # 默認(rèn)分支
        print ""

switch替代方案2

# 使用字典實(shí)現(xiàn)switch語(yǔ)句  
from __future__ import division  
x = 1 
y = 2 
operator = "/" 
result = {  
 
 
"+" : x + y,  
"-" : x - y,  
"*" : x * y,  
"/" : x / y   
}  
print result.get(operator) 

循環(huán)語(yǔ)句江掩，注意不要死循環(huán)

while循環(huán)

x = float(input("輸入x的值："))        # 接收用戶(hù)輸入的數(shù)字并轉(zhuǎn)換為float類(lèi)型
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次循環(huán)：" %(i, x))
else:
    print ("x等于0：", x)

for循環(huán)

# for in語(yǔ)句
for x in range(-1, 2):
    if x > 0: 
        print ("正數(shù)：",x)
    elif x == 0 : 
        print ("零：",x)
    else:
        print ("負(fù)數(shù)：",x)
else:
    print ("循環(huán)結(jié)束")

break,continue

參考switch替代方案2例子

函數(shù)

switch替代方案2封裝成函數(shù)

from __future__ import division
def arithmetic(x, y, operator):
    result = {
        "+" : x + y,
        "-" : x - y,
        "*" : x * y,
        "/" : x / y 
    }
    return result.get(operator)     # 返回計(jì)算結(jié)果

return返回多個(gè)值，可以把這些值打包到元祖中环形，在調(diào)用時(shí)，對(duì)返回的元祖進(jìn)行解包即可

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)

多個(gè)return語(yǔ)句

def func(x):
    if x > 0:
        return "x > 0"
    elif x == 0:
        return "x == 0"
    else:
        return "x < 0"
print (func(-2))

多個(gè)return語(yǔ)句重構(gòu)衙傀，增加變量

def func(x):
    if x > 0:
        result = "x > 0"
    elif x == 0:
        result = "x == 0"
    else:
        result = "x < 0"
    return result    
print (func(-2))  

嵌套函數(shù)

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())

嵌套函數(shù)抬吟，內(nèi)部函數(shù)

def func():
    x = 1
    y = 2
    m= 3
    n = 4
    def sum(a, b):              # 內(nèi)部函數(shù)
        return a + b
    def sub(a, b):              # 內(nèi)部函數(shù)
        return a - b
    return sum(x, y) * sub(m, n)

print (func())

遞歸函數(shù)，經(jīng)典例子统抬，計(jì)算階乘

def refunc(n):
    i = 1
    if n > 1:                           # 遞歸的結(jié)束判斷
        i = n
        n = n * refunc(n-1)             # 遞推
    print ("%d! =" %i, n)
    return n                            # 回歸

refunc(5)

lambda函數(shù)

lambda函數(shù)用于創(chuàng)建一個(gè)匿名函數(shù)，函數(shù)名未和標(biāo)識(shí)符進(jìn)行綁定聪建，使用lambda函數(shù)可以返回一些簡(jiǎn)單的運(yùn)算結(jié)果。lambda函數(shù)的格式如下

lambda 變量1,變量2,... :表達(dá)式

其中擎析，變量列表用于表達(dá)式的計(jì)算挥下，lambda屬于函數(shù)桨醋，因此變量列表后需要一個(gè)冒號(hào)喜最，通常把lambda賦值給一個(gè)變量，變量就可作為函數(shù)使用

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也可以直接作為函數(shù)使用

print ((lambda x:-x)(-2))

Generator函數(shù)

生成器(Generator)的作用是一次產(chǎn)生一個(gè)數(shù)據(jù)項(xiàng)瞬内，并把數(shù)據(jù)項(xiàng)輸出，Generator函數(shù)可以用在for循環(huán)中遍歷限书，Generator函數(shù)虫蝶，每次返回一個(gè)數(shù)據(jù)項(xiàng)的特性，使得迭代器的性能更佳蔗包。Generator函數(shù)的定義和普通函數(shù)的定義沒(méi)什么區(qū)別秉扑，只要在函數(shù)體內(nèi)使用yield生成數(shù)據(jù)項(xiàng)即可。Generator函數(shù)可以被for循環(huán)遍歷调限，而且可以通過(guò)next()方法獲得yield生成的數(shù)據(jù)項(xiàng)舟陆。

def func(n):
    for i in range(n):
        yield i
# 在for循環(huán)中輸出
for i in func(3):
    print (i)
# 使用next()輸出
r =  func(3)
print (r.next())
print (r.next())
print (r.next())
print (r.next())

yield關(guān)鍵字與return關(guān)鍵字的返回值和執(zhí)行原理都不相同，yield生成值并不會(huì)中止程序的執(zhí)行耻矮，返回值后程序繼續(xù)往后執(zhí)行秦躯。return返回值后，程序?qū)⒅兄箞?zhí)行裆装。

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())

文件讀寫(xiě)

使用readline()讀文件踱承，按行讀取，需要使用永真表達(dá)式循環(huán)讀取文件哨免。但當(dāng)文件指針移動(dòng)到文件的末尾時(shí)茎活，依然使用readline()讀取文件將出現(xiàn)錯(cuò)誤，因此程序需要添加1個(gè)判斷語(yǔ)句琢唾，判斷文件指針是否移動(dòng)到文件的尾部载荔，并且通過(guò)該語(yǔ)句中斷循環(huán)。

f = open("hello.txt")
while True:
    line = f.readline()
    if line: 
        print (line)
    else:
        break
f.close()

使用readlines()讀文件采桃，需要通過(guò)循環(huán)訪(fǎng)問(wèn)readlines()返回列表中的元素懒熙。函數(shù)readlines()可以一次性讀取文件多行數(shù)據(jù)。

f = file('hello.txt')
lines = f.readlines()
for line in lines:              # 一次讀取多行內(nèi)容
    print (line)
f.close()    

使用read()最簡(jiǎn)單普办，將從文件中一次性讀出所有內(nèi)容工扎，并賦值給1個(gè)字符串變量

f = open("hello.txt")
context = f.read() 
print (context)
f.close()

可以通過(guò)控制read()參數(shù)的值肢娘，返回指定字節(jié)的內(nèi)容

f = open("hello.txt")
context = f.read(5)           # 讀取文件前5個(gè)字節(jié)內(nèi)容
print (context)
print (f.tell())                # 返回文件對(duì)象當(dāng)前指針位置
context = f.read(5)          # 繼續(xù)讀取5個(gè)字節(jié)內(nèi)容
print (context)
print (f.tell())               # 輸出文件當(dāng)前指針位置
f.close()

使用writelines()寫(xiě)文件

f = file("hello.txt", "w+")
li = ["hello world\n", "hello China\n"]
f.writelines(li)
f.close()  

追加新的內(nèi)容到文件

f = file("hello.txt", "a+")         # 寫(xiě)入方式為追加a+
new_context = "goodbye"
f.write(new_context)
f.close()

使用writelines()寫(xiě)文件的速度更快。如果需要寫(xiě)入文件的字符串非常多笨忌，可以使用writelines()提高效率官疲。如果只需要寫(xiě)入少量的字符串途凫，直接用write()即可。

Python基本數(shù)據(jù)結(jié)構(gòu)：字典犀盟、集合等

元組

元組是Python中常用的一種數(shù)據(jù)結(jié)構(gòu)阅畴，元組由不同的元素組成，每個(gè)元素可以存儲(chǔ)不同類(lèi)型的數(shù)據(jù)纽哥，如字符串昵仅，數(shù)字，甚至元組垦写。元組是“寫(xiě)保護(hù)”的，即元組創(chuàng)建后不能再做任何修改操作分蓖，元組通常代表一行數(shù)據(jù)终娃，而元組中的元素代表不同的數(shù)據(jù)項(xiàng)棠耕。

如果創(chuàng)建的元組只包含一個(gè)元素，通常會(huì)錯(cuò)誤忽略單元素后的逗號(hào)蕊退，這樣瓤荔，python無(wú)法區(qū)分變量tuple是元組還是表達(dá)式茉贡，python誤認(rèn)為圓括號(hào)中的內(nèi)容為表達(dá)式，因此tuple[0]輸出的結(jié)果并非期望的值愉粤，并且其類(lèi)型也不是tuple衣厘。正確的寫(xiě)法如下：

tuple = ["apple" , ]   #定義元組影暴，注意后面的逗號(hào)不可少
print (tuple[0])  #打印第一個(gè)元素
print (type(tuple))   #打印定義的tuple的類(lèi)型

元組的訪(fǎng)問(wèn)

訪(fǎng)問(wèn)格式：tuple[n] ，n可以是0妆兑、正負(fù)整數(shù)。

輸出：print (tuple[n])

可以把元組理解為C或者Java中的數(shù)組芯勘。

注意：元組創(chuàng)建后其內(nèi)部元素的值不能被修改。元組中的元素不支持賦值操作屉来。

提示：元組不能添加或刪除任何元素茂契。因此掉冶，元組不存在任何添加厌小、刪除元素的方法，元組也不存在任何其他方法癣蟋。

元組的訪(fǎng)問(wèn)還有一些特殊的用法疯搅，例如負(fù)數(shù)索引和分片索引。這兩個(gè)特性是python的特殊用法礁蔗，C或者Java語(yǔ)言并不支持瘦麸。負(fù)數(shù)索引從元組的尾部開(kāi)始計(jì)數(shù)滋饲，最尾端的元素索引表示“-1”，次尾端的元素索引表示“-2”呵曹，以此類(lèi)推奄喂。

分片是元組的一個(gè)子集跨新，分片是從第1個(gè)索引到第2個(gè)索引（不包含第2個(gè)索引所指向的元素）所指定的所有元素。分片索引可以為正數(shù)或負(fù)數(shù)肖揣，兩個(gè)索引之間用冒號(hào)分隔龙优。分片的格式如下：

tuple[m:n] 其中m彤断、n可以是0瓦糟、正整數(shù)或負(fù)整數(shù)菩浙。

tuple=("apple","banana","grape","orange") #定義元組
print (tuple[-1])
print (tuple[-2])
tuple2 = tuple[1:3]  #分片，第二個(gè)元素到第三個(gè)元素（不包括第四個(gè)）
tuple3 = tuple[0:-2]  #分片，從第一個(gè)元素到倒數(shù)第二個(gè)元素（不包括倒數(shù)第二個(gè)）
tuple4 = tuple[2:-1]    #分片楚堤，從第三個(gè)元素到倒數(shù)第一個(gè)元素（不包括倒數(shù)第一個(gè)）
print (tuple2)
print (tuple3)
print (tuple4)

元組還可以由其他元組組成衅胀。例如滚躯，二元元組可以表示為：

tuple = (('t1' , 't2'), ('t3' , 't4'))

該元組是一個(gè)二元元組茁影，該元組由('t1' , 't2')和('t3' , 't4')組成。

fruit1 = ("apple", "banana")
fruit2 = ("grape", "orange")
tuple = (fruit1, fruit2)
print (tuple)
print ("tuple[0][1] =", tuple[0][1])  #打印輸出第一個(gè)元組的第二個(gè)元素
print ("tuple[1][1] =", tuple[1][1])　 #打印輸出第二個(gè)元組的第二個(gè)元素

創(chuàng)建元組的過(guò)程蝇更，python稱(chēng)為“打包”。相反厨幻，元組也可以執(zhí)行“解包”的操作况脆。“解包”可以將打包元組中的各個(gè)元素分別賦值給多個(gè)變量盛末，降低了代碼的復(fù)雜性悄但，使表達(dá)方式更自然檐嚣∥撕兀“打包”和“解包”例：

#打包
tuple = ("apple", "banana", "grape", "orange")
#解包
a, b, c, d = tuple  #將元組中的元素分別賦值給a暑刃，b溜嗜，c，d
print(a,b,c,d)

元組的遍歷

元組的遍歷是指通過(guò)循環(huán)語(yǔ)句依次訪(fǎng)問(wèn)元組中各元素的值炸宵。遍歷元組需要用到兩個(gè)函數(shù)range()和len()辟躏。range()和len()都是python的內(nèi)建函數(shù)，這些函數(shù)可直接調(diào)用土全，不需要import語(yǔ)句導(dǎo)入模塊捎琐。內(nèi)建函數(shù)是Python自動(dòng)導(dǎo)入的函數(shù)，相當(dāng)與Java中的lang包裹匙。

len()計(jì)算出tuple元組中元素的個(gè)數(shù)瑞凑，range()返回一個(gè)由數(shù)字組成的列表籽御。

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實(shí)現(xiàn)遍歷元組

tuple = (("apple","banana"),("grape","orange"),("watermelon", ),("grapefruit", ))  #定義一個(gè)二元元組
for i in tuple:
        for j in i:
                print(j)

列表

列表是Python中非常重要的數(shù)據(jù)類(lèi)型绘盟，通常作為函數(shù)的返回類(lèi)型撤嫩。列表和元組相似丈牢，也是由一組元組組成，列表可以實(shí)現(xiàn)添加霹粥、刪除和查找操作，元素的值可以被修改舶斧。

列表的創(chuàng)建

List(列表)是Python內(nèi)置的一種數(shù)據(jù)結(jié)構(gòu)怀酷。它由一系列元素組成友瘤，所有元素被包含在一對(duì)方括號(hào)中甥桂。列表創(chuàng)建后懂诗，可以執(zhí)行添加或刪除操作问窃。格式如下：

list = [元素1熟呛， 元素2昔逗， ...]

列表的添加可以調(diào)用append(),該方法的聲明如下所示。

append(object)

其中，object可以是元組姥饰、列表瘩蚪、字典或任何對(duì)象棚贾。

列表的刪除可以調(diào)用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())    #打印從列表中彈出的元素，即最后一個(gè)元素规揪。pop()表示取出最后一個(gè)元素
print(list)

注意：如果list列表中存在兩個(gè)相同的元素桥氏，此時(shí)調(diào)用remove()移除同名元素，將只刪除List列表中靠前的元素猛铅。

列表的使用字支，與元組十分相似，同樣支持負(fù)數(shù)索引奸忽、分片以及多遠(yuǎn)列表等特性堕伪，但是列表中的元素可修改，而且存在一些處理列表的方法栗菜。

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()

列表實(shí)現(xiàn)了連接操作的功能刃跛，列表的連接同樣提供了兩種方式，一種是調(diào)用extend()連接兩個(gè)不同的列表苛萎，另一種是使用運(yùn)算符“+”或“+=”桨昙。

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  #連接兩個(gè)相同的列表
print(list1)

列表的查找检号、排序、反轉(zhuǎn)

list列表可以進(jìn)行添加蛙酪、刪除操作齐苛，此外List列表還提供了查找元素的方法。list列表的查找提供了兩種方式桂塞，一種是使用index方法返回元素在列表中的位置凹蜂，另一種方法是使用關(guān)鍵字“in”來(lái)判斷元素是否存在列表中。

list=["apple","banana","grape","orange"]
print(list.index("grape")) #打印grape的索引
print(list.index("orange"))  #打印orange的索引
print("orange" in list)   #判斷orange是否在列表中

列表的排序和反轉(zhuǎn)

list=["banana","apple","orange","grape"]
list.sort()  #排序阁危，按首字母升序排序
print("Sorted list:",list)
list.reverse()  #反轉(zhuǎn)玛痊，反轉(zhuǎn)列表中元素的排列順序
print("Reversed list:",list)

集合(Set)

set與dict大致相同，但set沒(méi)有Value狂打，只有key擂煞。因此，set只是一組key的集合趴乡。由于key不能重復(fù)对省，所以，在set中晾捏，沒(méi)有重復(fù)的key蒿涎。

創(chuàng)建空集合

在集合中，創(chuàng)建空集合（set）必須使用函數(shù)set()惦辛。不能使用{}劳秋，{}用于創(chuàng)建空字典。

#創(chuàng)建空集合
>>>a = set()
>>>a
set()
>>>type(a)
<class 'set'>

創(chuàng)建非空集合

非空集合可以用大括號(hào){}或 set()函數(shù)來(lái)創(chuàng)建胖齐。

#創(chuàng)建集合
>>>a={'a','b','c','d'}
>>>b=set('abcdefabcd')
>>>c=set({'a':1,'b':2,'c':3})
>>>d=set(['a','b','c','a'])
#運(yùn)行結(jié)果
>>>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()方法，并且不生成一個(gè)新的集合市怎。add()方法可以向set中添加元素，可以重復(fù)添加辛慰，但不會(huì)有效果区匠。

#添加元素：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'>

復(fù)制元素

copy()方法只能淺拷貝set中的元素驰弄，并生成一個(gè)新的集合。

#淺拷貝：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中隨機(jī)取一個(gè)元素速客。記住，是隨機(jī)的~~~

#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)

字典結(jié)構(gòu)

字典是Python中重要的數(shù)據(jù)類(lèi)型，字典的由“鍵-值”對(duì)組成的集合沟优，字典中的“值”通過(guò)“鍵”來(lái)引用赛不。

字典的創(chuàng)建

字典由一系列的“鍵-值”（key-value）對(duì)組成位喂，“鍵-值”對(duì)之間用“逗號(hào)”隔開(kāi)，并且被包含在一堆花括號(hào)中乱灵。字典與java語(yǔ)言中的HashMap類(lèi)作用類(lèi)似塑崖，都是采用“鍵-值”對(duì)映射的方式存儲(chǔ)數(shù)據(jù)。

字典的創(chuàng)建格式如下：

dictionary={key1：value1, key2：value2,...}

其中,key1痛倚、key2等表示字典的key值规婆，value1、value2等表示字典的value值蝉稳。

如果需要?jiǎng)?chuàng)建一個(gè)空的字典抒蚜，只需要一對(duì)花括號(hào)即可，代碼如下：

dictionary = {}

dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
print(dict)
print(dict["a"]) #打印建a對(duì)應(yīng)的值
print(dict[2]) #打印建2對(duì)應(yīng)的值耘戚，不用雙引號(hào)

print()的使用非常靈活嗡髓，也可以在print()中使用字典。下面示例字典在print()中的使用毕莱。

print("%s,%(a)s,%(b)s" %{"a":"apple", "b":"banana"})

解釋?zhuān)浩渲须[式的創(chuàng)建了字典{“a”:"apple","b":"banana"}器贩。這個(gè)字典用來(lái)定制print()中的參數(shù)列表∨蠼兀“%s”輸出這個(gè)字典的內(nèi)容蛹稍，"%(a)s"獲取字典中對(duì)應(yīng)的key值“a”的value值，“%(b)s”獲取字典中對(duì)應(yīng)key值"b"的value值部服。

字典的訪(fǎng)問(wèn)

字典的訪(fǎng)問(wèn)與元組唆姐、列表有所不同，元組和列表是通過(guò)數(shù)字索引來(lái)獲取對(duì)應(yīng)的值廓八，而字典是通過(guò)key值獲取相應(yīng)的value值奉芦。訪(fǎng)問(wèn)字典格式如下:

value = dict[key]

字典的添加、刪除和修改非常簡(jiǎn)單剧蹂，添加或修改操作只需要編寫(xiě)一條賦值語(yǔ)句声功，例如：

dict["x"] = "value"

如果索引x不在字典dict的key列表中，字典dict將添加一條新的映射(x:value);如果索引x在字典dict的key列表中宠叼，字典dict將直接修改索引x對(duì)應(yīng)的value值先巴。

字典與列表不同，字典并沒(méi)有remove()操作冒冬。字典元素的刪除可以調(diào)用del()實(shí)現(xiàn)伸蚯，del()屬于內(nèi)建函數(shù)，直接調(diào)用即可简烤。列表可以調(diào)用pop()彈出列表中的一個(gè)元素剂邮，字典也有一個(gè)pop()，該方法的聲明和作用與列表的pop()有些不同横侦。pop()的聲明如下所示挥萌。

D.pop(k[,d]) -> v

pop()必須指定參數(shù)才能刪除對(duì)應(yīng)的值绰姻。其中，參數(shù)k表示字典的索引瑞眼，如果字典D中存在索引k龙宏，返回值v等于D[k];如果字典D中沒(méi)有找到索引k，返回值為d伤疙。

如果需要清除字典中所有的內(nèi)容银酗，可以調(diào)用字典的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)

由于字典是無(wú)序的黍特，因此字典中沒(méi)有append()、remove()等方法锯蛀。如果需要向字典插入新的元素灭衷，可以調(diào)用setdefault()。

字典的遍歷有多種方式旁涤，最直接的方式是通過(guò)"for...in..." 語(yǔ)句完成遍歷的任務(wù)

dict={1:"apple",2:"banana",3:"grape",4:"orange"}
for k in dict:
        print("dict[%s]" %k,dict[k])

語(yǔ)句循環(huán)訪(fǎng)問(wèn)字典dict翔曲，變量k獲取的是字典dict的key值，并沒(méi)有直接獲取value值劈愚。因此打印輸出時(shí)瞳遍，通過(guò)dict[k]來(lái)獲取value值。

此外菌羽，還可以使用字典的items()實(shí)現(xiàn)字典的遍歷操作掠械，items()返回一個(gè)由若干元組組成的列表

dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
print(dict.items())

可見(jiàn)，items()把字典中每對(duì)key和value組成一個(gè)元組注祖，并把這些元組存放在列表中返回猾蒂。下面將使用字典item()實(shí)現(xiàn)字典的遍歷。

dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
for(k,v) in dict.items():　　#變量k和v分別與字典dict中的key和cvalue值對(duì)應(yīng)
        print("dict[%s]" %k,v)

除了能采用字符串作為字典的value值是晨，元組肚菠、列表甚至字典都可以作為字典的value值。使用元組罩缴、列表或字典作為value值創(chuàng)建字典蚊逢，稱(chēng)為混合型字典。格式如下：

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()的等價(jià)語(yǔ)句
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的值靴庆，若不存在返回默認(rèn)值apple
print (dict.get("e", "apple"))          # 使用get獲取鍵為e的值，若不存在返回默認(rèn)值apple

update()方法

#udpate()的等價(jià)語(yǔ)句
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()方法

# 設(shè)置默認(rèn)值
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的數(shù)據(jù)怒医，如果字典B的數(shù)據(jù)發(fā)生添加炉抒、刪除或修改操作，字典A的數(shù)據(jù)也將發(fā)生變化稚叹；相反焰薄，如果字典B深拷貝字典A的數(shù)據(jù)拿诸，字典B的數(shù)據(jù)即使發(fā)生變化，也不會(huì)影響到字典A

• Pandas基礎(chǔ)

Pandas環(huán)境安裝

安裝Anaconda3塞茅，已經(jīng)內(nèi)置Pandas

Pandas數(shù)據(jù)結(jié)構(gòu)：Series和Dataframe

將在云主機(jī)操作Anaconda3亩码，鏈接：

• 實(shí)踐

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]
#集中趨勢(shì)的度量
print('求和：',np.sum(scores))
print('個(gè)數(shù)：',len(scores))
print('平均值:',np.mean(scores))
print('中位數(shù):',np.median(scores))
print('眾數(shù):',sts.mode(scores))
print('上四分位數(shù)',sts.quantile(scores,p=0.25))
print('下四分位數(shù)',sts.quantile(scores,p=0.75))
#離散趨勢(shì)的度量
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('標(biāo)準(zhǔn)差:',np.std(scores))
print('方差:',np.var(scores))
print('離散系數(shù):',np.std(scores)/np.mean(scores))
#偏度與峰度的度量
print('偏度:',sts.skewness(scores))
print('峰度:',sts.kurtosis(scores))

#中位數(shù)實(shí)現(xiàn)
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))