python學習—基礎

時間 2019-11-20

標籤 python 學習基礎欄目 Python 简体版

原文原文鏈接

python目錄中有兩個關鍵性的目錄：lib和Script java

lib:包含了python的內置模塊；當下載的第三方模塊則在lib\site-packages內； python

Script:包含了腳本exe文件；etc : pip.exe;easy_install.exe等； linux

python安裝第三方模塊的方式彙總：算法

1、方法1：單文件模塊
直接把文件拷貝到 $python_dir/Lib/site-packages/ api

2、方法2：多文件模塊，帶setup.py
下載模塊包，進行解壓，進入模塊文件夾，執行：
python setup.py install 數組

3、方法3：easy_install 方式
先下載ez_setup.py,運行python ez_setup 進行easy_install工具的安裝，以後就可使用easy_install進行安裝package了。
easy_install packageName
easy_install package.egg
數據結構

4、方法4：pip 方式
先進行pip工具的安裝：easy_install pip（pip 能夠經過easy_install 安裝，並且也會裝到 Scripts 文件夾下。）
        安裝：pip install PackageName
        更新：pip install -U PackageName
        移除：pip uninstall PackageName
        搜索：pip search PackageName
        幫助：pip help
app

注:當前建議使用pip進行安裝第三方模塊 函數

python的基本數據類型：工具

空（None）
表示該值是一個空對象，相似於java中的Null
布爾類型（Boolean）
在Python中，None、任何數值類型中的0、空字符串「」、空元組()、空列表[]、空字典{}都被看成False，還有自定義類型，若是實現了__nonzero__()或__len__()方法且方法返回0或False，則其實例也被看成False，其餘對象均爲True
整形（Int）
在Python內部對整數的處理分爲普通整數和長整數，普通整數長度爲機器位長，一般都是32位，超過這個範圍的整數就自動當長整數處理，而長整數的範圍幾乎徹底沒限制
整形作取餘和除算法的時候，按floor取值：
```
17/10 # 1
17/-10 # -2
-17/10 # -2

17%10 # 7
17%-10 # -3
-17% 10 # 3
```
浮點數（float）
Python的浮點數就是數學中的小數，相似C語言中的double。之因此稱之爲浮點數，便是由於用科學計數法表示時，浮點數中的小數點是能夠變更的；如：
```
1.2e8  <==> 0.12e9
```
注：在運算中，整數與浮點數運算的結果是浮點數

字符串（String）
Python字符串便可以用單引號也能夠用雙引號括起來，甚至還能夠用三引號括起來

'ab c' # 有四個字符：a、b、空格、c
'i\'m ok' # \用來作轉義字符
r'\\\t\\\' # r表示''內部的字符串默認不轉義

針對字符串的操做：

# 去空格及特殊符號
# strip：在首尾部分去除指定的字符串；當沒有指定字符時，去除首尾空格
# lstrip: 去除左邊的指定字符串
# rstrip：去除右邊的指定字符串
theString = 'saaaay yes no yaaaass'
print theString.strip('say') 
print theString.strip('say ') #say後面有空格 
print theString.lstrip('say') 
print theString.rstrip('say') 

結果：
yes no 
es no 
yes no yaaaass 
saaaay yes no

# 字符串包含 判斷操做符：in，not in

# string模塊，還提供了不少方法，如
S.find(substring, [start [,end]]) #可指範圍查找子串，返回索引值，不然返回-1
S.rfind(substring,[start [,end]]) #反向查找
S.index(substring,[start [,end]]) #同find，只是找不到產生ValueError異常
S.rindex(substring,[start [,end]])#同上反向查找
S.count(substring,[start [,end]]) #返回找到子串的個數

S.lowercase()
S.capitalize()      #首字母大寫
S.lower()           #轉小寫
S.upper()           #轉大寫
S.swapcase()        #大小寫互換
S.split(str, ' ')   #將string轉list，以空格切分
S.join(list, ' ')   #將list轉string，以空格鏈接

處理字符串的內置函數
len(str)                #串長度
cmp("my friend", str)   #字符串比較。第一個大，返回1
max('abcxyz')           #尋找字符串中最大的字符
min('abcxyz')           #尋找字符串中最小的字符

string的轉換
            
oat(str) #變成浮點數，float("1e-1")  結果爲0.1
int(str)        #變成整型，  int("12")  結果爲12
int(str,base)   #變成base進制整型數，int("11",2) 結果爲2
long(str)       #變成長整型，
long(str,base)  #變成base進制長整型，

列表(List)
用符號[]表示列表，中間的元素能夠是任何類型，用逗號分隔。list相似C語言中的數組，用於順序存儲結構；list取元素能夠順序也能夠倒序取；如：

list = ['a', 'b', 'c']
print list[2] # 取list中的最後一個元素，len(list)-1便是list最後一個元素的位置
print list[-1] # 倒數第一個元素
print len(list) # 得到list中元素的個數

#--------list是可變的有序表，因此能夠動態的增刪改查list中的元素
list.append('d') # 默認追加到尾元素 a,b,c,d
list.insert(0, 'd') # 指定索引添加元素 d,a,b,c
在列表中插入一個值
sample_list[0:0] = ['sample value']
list.pop(...) # pop不帶參數默認刪除尾元素，參數指定list元素索引，#返回最後一個元素，並從list中刪除
list.remove(var)   #刪除第一次出現的該元素
L.count(var)    #該元素在列表中出現的個數
L.index(var)    #該元素的位置,無則拋異常 
L.extend(list)  #追加list，即合併list到L上
L.sort()        #排序
L.reverse()     #倒序
[1,2]+[3,4] #爲[1,2,3,4]。同extend()
[2]*4       #爲[2,2,2,2]
del L[1]    #刪除指定下標的元素
L1 = L[:]   #L1爲L的克隆，即另外一個拷貝。
用in語法判斷list是否包含該元素
print 1 in list
list[0] = 'e' # 直接替代元素 e,b,c  # list中的數據類型能夠不一致，相似java中的數組，list中能夠包含list

元祖(tuple)
元組是和列表類似的數據結構，但它一旦初始化就不能更改，速度比list快，同時tuple不提供動態內存管理的功能，需理解一下規則：
tuple能夠用下標返回一個元素或子tuple
表示只含有一個元素的tuple的方法是：(d,)後面有個逗號，用來和單獨的變量相區分
```
tuple = (1, 'a', ['x', 'b'])
print tuple # 1, 'a', ['x', 'b']
tuple[2][0] = 'y'
tuple[2][1] = 'c'
print tuple # (1, 'a', ['y', 'c']) # 發現tuple中元素有變，其實tuple指定的list內存地址是沒有變化的，變化的是list中的元素
```
集合（Set）
集合是無序的，不重複的元素集，相似數學中的集合，可進行邏輯運算和算術運算

set和dict相似，也是一組key的集合，但不存儲value。因爲key不能重複，因此，在set中，沒有重複的key。

要建立一個set，須要提供一個list做爲輸入集合：
```
>>> s = set([1, 2, 3]) >>> s set([1, 2, 3])
```
注意，傳入的參數[1, 2, 3]是一個list，而顯示的set([1, 2, 3])只是告訴你這個set內部有1，2，3這3個元素，顯示的[]不表示這是一個list。
能夠經過add,remove添加和刪除元素
set和dict的惟一區別僅在於沒有存儲對應的value，可是，set的原理和dict同樣，因此，一樣不能夠放入可變對象，由於沒法判斷兩個可變對象是否相等，也就沒法保證set內部「不會有重複元素」。試試把list放入set，看看是否會報錯

字典（dict）
字典是一種無序存儲結構，包括關鍵字（key）和關鍵字對應的值（value）。字典的格式爲：dictionary = {key:value}。關鍵字爲不可變類型，如字符串、整數、只包含不可變對象的元組，列表等不可做爲關鍵字。若是列表中存在關鍵字對，能夠用dict()直接構造字典
dict中的元素能夠動態經過key增長，因爲一個key只能對應一個value；當後key相同時，後面的value會將前面的值進行重置；

dict = {'java': 'diffcult', 'python':'middle'}
print dict['java'] # diffcult
print dict.get('java') # diffcult
dict.pop('java')
print dict # {'python': 'middle'}

dict定義的方式和特性：

info = dict(name = 'old') # {'name':'cold'} # 更優雅
info = {'name': 'old'} # {'name':'cold'} 

key = 'name'
info = {key: 'old'} # {'name':'cold'}
info = dict(key='old') # {'key':'cold'}

#Python字典還有一種初始化方式,就是使用字典的fromkeys方法能夠從列表中獲取元素做爲#鍵並用None或fromkeys方法的第二個參數初始化
info = {}.fromkeys(['name', 'blog']) # {'blog': None, 'name': None}
info = dict().fromkeys(['name', 'blog']) # {'blog': None, 'name': None}
info = dict().fromkeys(['name', 'blog'], 'linuxzen.com') # {'blog': 'linuxzen.com', 'name': 'linuxzen.com'}

# 可是若是獲取不存在的鍵的值就會觸發的一個KeyError異常,字典有一個get方法,可使用字典get方法更加優雅的獲取字典
info.get(key) # None

#咱們看到使用get方法獲取不存在的鍵值的時候不會觸發異常,同時get方法接收兩個參數,#當不存在該鍵的時候就會返回第二個參數的值 咱們能夠看到使用get更加的優雅
info.get(key, default) # default

# 同時Python字典的update方法也能夠更新和添加字典
info = dict(name='cold', blog='linuxzen.com')
info.update({'name':'cold night', 'blogname':'linuxzen'})
info.update(name='cold', blog='www.linuxzen.com') # 更優雅

結果：
{'blog': 'www.linuxzen.com', 'name': 'cold', 'blogname': 'linuxzen'}

# 字典刪除
del info['name']
info.pop('name')
# 字典查找
info.has_key(key)      #有該鍵返回TRUE，不然FALSE
info..clear()           #清空字典，同del dict 
info.copy()      #拷貝字典
info.cmp(dict1,dict2)  #比較字典，(優先級爲元素個數、鍵大小、鍵值大小)  #第一個大返回1，小返回-1，同樣返回0

和list比較，dict有如下幾個特色：

查找和速度極快，不會隨着key的增長而增長
須要佔用大量的內存，內存浪費多
而list相反：
查找和插入的時間隨着元素的增長而增長

佔用空間小，浪費內存不多

python有內置模塊types:

NoneType = type(None)
TypeType = type
ObjectType = object
IntType = int
LongType = long
FloatType = float
BooleanType = bool
StringType = str
BufferType = buffer
TupleType = tuple
ListType = list
DictType = DictionaryType = dict
ClassType = type(_C)
InstanceType = type(_x)
FileType = file