本文目錄

1. 基礎知識
2. 基本數(shù)據(jù)類型
3. 基本數(shù)據(jù)結構
4. 基礎語句
5. 函數(shù)
6. 類與對象
7. 編程風格
8. 總結

這是我Python數(shù)據(jù)分析系列文章的第一篇，主要介紹Python基礎部分，Python知識面比較廣，本文主要是介紹平時使用比較多的知識點，更多的問題，大家可以后臺私信我。

基礎知識

1、第一個Python代碼

2、Python不區(qū)分大小寫，嚴格縮進。

3、單行注釋以#開頭，多行注釋以''' '''(三引號，可以是單引或者雙引)開始結尾。

基本數(shù)據(jù)類型

數(shù)據(jù)類型是每一種編程語言的必有的知識，Python也有其對應的基本數(shù)據(jù)類型，本節(jié)主要介紹其四種基本類型：整形、浮點型、布爾型。

#賦值操作=，==表示等于
int_value = 520
type(int_value) #<class 'int'> 
float_value = 19.9
type(float_value) #<class 'float'> 
boolean_value = True
type(boolean_value) #<class 'bool'>

可以通過dir()或者help()查看其對應的屬性和方法，比如查看整形：

其中帶雙劃線的就是整形的可用方法，其他就是整形的屬性。

基本數(shù)據(jù)結構

Python基本的數(shù)據(jù)結構主要包括字符串、列表、元組、字典、集合等

字符串

1、基本方法

string_value = 'python' 
type(string_value) #<class 'str'>

字符串的內(nèi)置方法可以通過dir()查詢。

str1 = 'hello world'
str1.split() #['hello','world']
str1.find('hello') #0
str1.replace('hello','Hello') #'Hello world'
str1.capitalize() #'Hello world'
'_'.join(str1) #'h_e_l_l_0_ _w_o_r_l_d'

2、切片

tips:

• python里面的索引一般是從0開始的
• 索引值可正可負，從左以0開始，從右以-1開始
• 左閉右開,比如[2,4)，但是是有例外的(有知道在哪里會出現(xiàn)例外嗎？)

列表

1、創(chuàng)建列表

l1 = []
l2 = [1,2,3] #中括號，以逗號間隔
type(l1) #<class 'list'>

2、方法

列表是一種Python基本數(shù)據(jù)結構，是可變類型，支持刪減查等操作,相對來說遍歷查找效率較低，不過使用方面。

3、切片

與字符串類似，具體操作如下

l = [1,2,3,4,5,6,7,8]
l[0] #[1],索引從0開始
l[-1] [8]支持正負縮影，-1表示列表最后一個元素
l[2:4] #[3,4] 注意左閉右開
l[:] #[1,2,3,4,5,6,7,8],相當于淺拷貝，在深淺拷貝知識點會講到
l[::2] #[1,3,5,7]，step為2
l[::-1] #相當于列表翻轉(zhuǎn)
l l[:3] #[1,2,3,4,5,6,7,8,1,2,3]
[0]*5 #列表生成[0,0,0,0,0]

4、遍歷

元組

Python基本數(shù)據(jù)結構，不可變類型，不支持刪查等操作

t = tuple() #空元組，小括號
t1 = (1,2,[3,4]) #注意嵌套
t1[0] = 0 #TypeError
t1[2].remove(3) #(1,2,[4]) 注意列表可以刪減操作

1、方法

2、賦值

a,b = (1,2) #a=1,b=2
a,*b1 = (1,2,3,4) #a=1,b=(2,3,4),注意*操作，函數(shù)參數(shù)有應用

元組創(chuàng)建和遍歷優(yōu)于列表。

字典

用{}包含，以鍵值對的形式存在，劍指不可重復，可變類型，支持基本操作。

1、方法

#基本方法
cmp(d1, d2) #比較兩個字典元素。
len(d1) #計算字典元素個數(shù)，即鍵的總數(shù)。
str(d1) #輸出字典可打印的字符串表示。
type(d1) #返回輸入的變量類型，如果變量是字典就返回字典類型。
# 訪問字典中的值
d1['name'] # 查找不到會出錯
d1.get('name') # 查找不到，返回None，查找效率更高
#1.get('name','not find') # 查找不到，返回not find
d1.keys() #獲取字典所有的鍵的列表
d1.values() #獲取字典所有的值的列表
d1.items() #獲取字典的鍵值對
#字典的修改
d1['key'] = value #key存在即修改，key不存在即新增
d1.setdefault('key',value) #新增鍵值對,存在會出錯
d1.pop('key') #必須要傳值，因為字典是無序的
d1.popitem() #隨機刪除一個
del d1['key'] #刪除元素
d1.clear() #清空字典
d1.update(d2) #將d2更新到d1,如果key存在則修改，不存在則添加
#字典的fromkeys方法創(chuàng)建字典，所有元素有一個默認值
{}.fromkeys(['key1', 'key2', 'key3'], 'value')
d1.has_key('key')#判斷d1中是否有ke

集合

用大括號表示，或者用set()，集合里面的元素唯一、無序。

1、方法

#基本方法
s1.add(5) #向集合中添加元素
s1.remove(5) #從集合中刪除元素，當刪除的元素不存在時，返回TypeError
s1.discard(6) #從集合中刪除元素,當刪除的元素不存在時不出錯
s1.pop() #任意刪除一個值，如果集合為空，返回KeyError
s1.clear() #清除集合中的值
#對集合進行排序
sorted(s1,reverse=True)
list(set(l1)) #刪除l1列表中的重復項
#并交補
s1.union(s2) #兩個集合取并集
s1|s2 #等價上式
s1.intersection(s2) #兩個集合取交集
s1&s2 #等價上式
s1.difference(s2) #兩個集合取差集，在s1中，不在s2中
s1-s2 #等價上式
s2.issubset(s1) #判斷s2是不是s1的子集

集合不能存儲可變對象，也能去判斷重復的對象。

基礎語句

語句可以稱之為代碼結構，在任何編程語言中都是基礎和重點，不同代碼編寫，我們需要使用不同的語句。本節(jié)主要介紹Python語言的條件語句和循環(huán)語句。

條件語句

條件語句主要包括三種：

• if 語句
• if-else 語句
• if-elif-else 語句

循環(huán)語句

循環(huán)語句主要包括for循環(huán)和white循環(huán)

#for循環(huán)
for i in range(10):
 print(i)
#在for循環(huán)中，有一個常用的內(nèi)置函數(shù)enumerate(),使用它比range()高效
for index，value in enumerate([1,2,3,4,5]):
 print(index,value) 
#white循環(huán)
n = 0
while n<5:
 n  = 1
 print(n)

函數(shù)

Python內(nèi)置函數(shù)和匿名函數(shù)

1、內(nèi)置函數(shù)

函數(shù)是是任何一門語言中最主要的部分之一，在介紹Python之前先了解一下，Python內(nèi)置的一些函數(shù)(所謂Python內(nèi)置函數(shù)是指Python里面已經(jīng)封裝好的，不需要人為去編寫，可以直接拿來使用的)，下面是一些常用的Python內(nèi)置函數(shù)。

大部分內(nèi)置函數(shù)在Python前面部分已經(jīng)有所介紹，本節(jié)主要介紹三個內(nèi)置函數(shù)map(),filter(),reduce()(注:Python3中reduce不在是一個內(nèi)置函數(shù))以及和Python匿名函數(shù)的使用。

2、匿名函數(shù)

用 lambda 關鍵字來創(chuàng)建一個小的匿名函數(shù)。這個函數(shù)返回兩個參數(shù)的和：lambda a, b: a b 。lambda函數(shù)可以在需要函數(shù)對象的任何地方使用。它們在語法上限于單個表達式。從語義上來說，它們只是正常函數(shù)定義的語法糖。與嵌套函數(shù)定義一樣，lambda函數(shù)可以引用包含范圍的變量:

def make_incrementor(n): #和一個普通函數(shù)一樣
 return lambda x: x   n
f = make_incrementor(42)
f(0) #42
f(1) #43
#在一些如字典的排序中常用到
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs.sort(key=lambda pair: pair[1])
pairs #[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

Python函數(shù)

1、Python函數(shù)定義

關鍵字 def 引入一個函數(shù)定義。它必須后跟函數(shù)名稱和帶括號的形式參數(shù)列表。構成函數(shù)體的語句從下一行開始，并且必須縮進。

2、函數(shù)參數(shù)形式

函數(shù)定義主要包括四種形式。

• 必需參數(shù)
• 關鍵字參數(shù)
• 默認參數(shù)
• 不定長參數(shù)

（1）必需參數(shù)

必需參數(shù)須以正確的順序傳入函數(shù)。調(diào)用時的數(shù)量必須和聲明時的一樣，不然函數(shù)運行會出錯。

def get_age(age):
 return 'he is {}'.format(age)
get_age(28) #'he is 28'

（2）關鍵字參數(shù)

關鍵字參數(shù)和函數(shù)調(diào)用關系緊密，函數(shù)調(diào)用使用關鍵字參數(shù)來確定傳入的參數(shù)值。使用關鍵字參數(shù)允許函數(shù)調(diào)用時參數(shù)的順序與聲明時不一致，因為 Python 解釋器能夠用參數(shù)名匹配參數(shù)值。

注意：在函數(shù)調(diào)用中，關鍵字參數(shù)必須跟隨在位置參數(shù)的后面。傳遞的所有關鍵字參數(shù)必須與函數(shù)接受的其中一個參數(shù)匹配（比如 actor 不是函數(shù) parrot 的有效參數(shù)），它們的順序并不重要。這也包括非可選參數(shù)，

（3）默認參數(shù)

調(diào)用函數(shù)時，如果沒有傳遞參數(shù)，則會使用默認參數(shù)。以下實例中如果沒有傳入 age 參數(shù)，則使用默認值。

def printinfo( name, age=35 ):
 print ('名字: ', name)
 print ('年齡: ', age)
 return
 
#注意默認參數(shù)的使用
def add_end(L=[]):
 L.append('END')
 return L
#連續(xù)運行兩次，結果不一致
add_end() #['END']
add_end() #['END', 'END']
#注：Python函數(shù)在定義的時候，默認參數(shù)L的值就被計算出來了，即[]，因為默認參數(shù)L也是一個變量，它指向?qū)ο骩]，每次調(diào)用該函數(shù)，如果改變了L的內(nèi)容，則下次調(diào)用時，默認參數(shù)的內(nèi)容就變了，不再是函數(shù)定義時的[]了。
#正確寫法
def add_end(L=None):
 if L is None:
 L = []
 L.append('END')
 return L
#兩次調(diào)用結果一致
add_end() #['END']
add_end() #['END']

（4）不定長參數(shù)

不定長參數(shù)以*或者**的形式存在。

• *args是可變參數(shù)，args接收的是一個tuple；
• **kw是關鍵字參數(shù)，kw接收的是一個dict。

迭代器和生成器

1、迭代器

迭代器的使用并使得 Python 成為一個統(tǒng)一的整體。 比如使用for 語句時會調(diào)用容器對象中的 iter()。 該函數(shù)返回一個定義了 __next__() 方法的迭代器對象，該方法將逐一訪問容器中的元素。 當元素用盡時，__next__() 將引發(fā) StopIteration 異常來通知終止 for 循環(huán)。 你可以使用 next() 內(nèi)置函數(shù)來調(diào)用 __next__() 方法:

s = 'abc'
it = iter(s)
it #<iterator object at 0x00A1DB50>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
 File '<stdin>', line 1, in <module>
 next(it)
StopIteration

看過迭代器協(xié)議的幕后機制，給你的類添加迭代器行為就很容易了。 定義一個 __iter__() 方法來返回一個帶有 __next__() 方法的對象。 如果類已定義了 __next__()，則 __iter__() 可以簡單地返回 self:

2、生成器

Generator 是一個用于創(chuàng)建迭代器的簡單而強大的工具。 它們的寫法類似標準的函數(shù)，但當它們要返回數(shù)據(jù)時會使用 yield 語句。 每次對生成器調(diào)用 next() 時，它會從上次離開位置恢復執(zhí)行（它會記住上次執(zhí)行語句時的所有數(shù)據(jù)值）。 顯示如何非常容易地創(chuàng)建生成器的示例如下:

def reverse(data):
 for index in range(len(data)-1, -1, -1):
 yield data[index]
 
for char in reverse('golf'):
 print(char)
f
l
o
g

可以用生成器來完成的操作同樣可以用迭代器來完成。 但生成器的寫法更為緊湊，因為它會自動創(chuàng)建 __iter__() 和 __next__() 方法。另一個關鍵特性在于局部變量和執(zhí)行狀態(tài)會在每次調(diào)用之間自動保存。 這使得該函數(shù)相比使用 self.index 和 self.data 這種實例變量的方式更易編寫且更為清晰。除了會自動創(chuàng)建方法和保存程序狀態(tài)，當生成器終結時，它們還會自動引發(fā) StopIteration。 這些特性結合在一起，使得創(chuàng)建迭代器能與編寫常規(guī)函數(shù)一樣容易。

類與對象

類提供了一種組合數(shù)據(jù)和功能的方法。創(chuàng)建一個新類意味著創(chuàng)建一個新 類型 的對象，從而允許創(chuàng)建一個該類型的新 實例 。每個類的實例可以擁有保存自己狀態(tài)的屬性。一個類的實例也可以有改變自己狀態(tài)的（定義在類中的）方法。

類的定義

類定義內(nèi)的語句通常都是函數(shù)定義，但也允許有其他語句。

類對象

類對象支持兩種操作：屬性引用和實例化。

屬性引用 使用 Python 中所有屬性引用所使用的標準語法: obj.name。 有效的屬性名稱是類對象被創(chuàng)建時存在于類命名空間中的所有名稱。 因此，如果類定義是這樣的:

class MyClass:
 '''A simple example class'''
 i = 12345
 def f(self):
 return 'hello world'

那么 MyClass.i 和 MyClass.f 就是有效的屬性引用，將分別返回一個整數(shù)和一個函數(shù)對象。 類屬性也可以被賦值，因此可以通過賦值來更改 MyClass.i 的值。 __doc__ 也是一個有效的屬性，將返回所屬類的文檔字符串: 'Asimple example class'。

類的 實例化 是使用函數(shù)表示法。 可以相像類對象就是會返回一個新的類實例的不帶參數(shù)的函數(shù)。 舉例來說（假設使用上述的類）:

創(chuàng)建類的新實例 并將此對象分配給局部變量 x。

實例化操作會創(chuàng)建一個空對象。 許多類喜歡創(chuàng)建帶有特定初始狀態(tài)的自定義實例。 因此類定義可能包含一個名為 __init__() 的特殊方法，比如：

def __init__(self):
 self.data = []

當一個類定義了 __init__() 方法時，類的實例化操作會自動為新創(chuàng)建的類實例發(fā)起調(diào)用 __init__()。而且__init__() 方法還可以有額外參數(shù)以實現(xiàn)更高靈活性。 在這種情況下，提供給類實例化運算符的參數(shù)將被傳遞給 __init__()。 例如:

類和實例變量

實例變量用于每個實例的唯一數(shù)據(jù)，而類變量用于類的所有實例共享的屬性和方法:

class Dog:
 def __init__(self, name):
 self.name = name
 self.tricks = [] 
 def add_trick(self, trick):
 self.tricks.append(trick)
d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
d.tricks
#['roll over']
e.tricks
#['play dead'

類的繼承

一般情況下子類會繼承一些父類的方法，并切可能會對父類的一些方法進行重寫。

Python有兩個內(nèi)置函數(shù)可被用于繼承機制：

• 使用 isinstance() 來檢查一個實例的類型: isinstance(obj, int) 僅會在 obj.__class__ 為 int 或某個派生自 int 的類時為 True。
• 使用 issubclass() 來檢查類的繼承關系: issubclass(bool, int) 為 True，因為 bool 是 int 的子類。 但是，issubclass(float, int) 為 False，因為 float 不是 int 的子類。

編程風格

從學習python的那一刻起，你就已經(jīng)準備好了寫更長，更復雜的Python代碼了，這時候有必要討論一下代碼風格。對于Python，PEP 8 已經(jīng)成為大多數(shù)項目所遵循的風格指南；它促進了一種非常易讀且令人賞心悅目的編碼風格。每個Python開發(fā)人員都應該在某個時候閱讀它。以下是為你提取的最重要的幾個要點：

• 使用4個空格縮進，不要使用制表符。
• 換行，使一行不超過79個字符。
• 使用空行分隔函數(shù)和類，以及函數(shù)內(nèi)的較大的代碼塊。
• 盡可能把注釋放到單獨的一行。
• 使用文檔字符串。
• 在運算符前后和逗號后使用空格。
• 類和函數(shù)命名的一致性。

總結

本文是Python數(shù)據(jù)分析系列文章的第一篇，簡單的介紹一些Python語言特性，下一篇將帶來numpy庫的使用介紹。