python 基礎之數據類型
1、python中的數據類型之列表
一、列表
列表是咱們最之後最經常使用的數據類型之一，經過列表能夠對數據實現最方便的存儲、修改等操做
2、列表經常使用操做html
>切片
>追加
>插入
>修改
>刪除
>擴展
>拷貝
>統計python
>排序git
>翻轉api
>>> names = ["admin","abc","jack","lily"] #定義列表 >>> names #查表中的元素 ['admin', 'abc', 'jack', 'lily'] 經過下標訪問列表中的元素，下標從0開始計數 >>> names[0] 'admin' >>> names[1] 'abc' >>> names[2] 'jack' 取最後一個元素： >>> names[-1] 'lily' 取倒數第二個元素： >>> names[-2] 'jack'
2.1.一、切片：取多個元素數據結構
>>> names ['admin', 'abc', 'jack', 'lily'] >>> names[0:3] #取下標0到下標3之間的數字，包括0，不包括3 ['admin', 'abc', 'jack'] >>> names[:3] #從頭開始取，0能夠忽略，跟上問效果同樣 ['admin', 'abc', 'jack'] >>> names[0:-1] #取下標0到-1以前的數字，包括0，不包括-1.也就是最後一個 ['admin', 'abc', 'jack'] >>> names[1:] #若是想取到最後一個，只能這麼寫，不能寫-1 ['abc', 'jack', 'lily'] >>> names[1:-1] #若是寫成-1,此時不包括-1 ['abc', 'jack'] >>> names[0::2] #後面的2表明每隔一個元素取一個 ['admin', 'jack'] >>> names[::2] #跟上句效果同樣 ['admin', 'jack']
2.1.二、追加app
>>> names ['admin', 'abc', 'jack', 'lily'] >>> names.append("追加第一個") #追加函數 append，默認追加到最後一個 >>> names ['admin', 'abc', 'jack', 'lily', '追加第一個'] >>> names.append("追加第二個") >>> names ['admin', 'abc', 'jack', 'lily', '追加第一個', '追加第二個']
2.1.三、插入ide
>>> names ['admin', 'abc', 'jack', 'lily', '追加第一個', '追加第二個'] >>> names.insert(1,"我是新來的") #在下標1的前面插入一個元素 >>> names ['admin', '我是新來的', 'abc', 'jack', 'lily', '追加第一個', '追加第二個'] >>> names.insert(-1,"我也是新來的") #在倒數第一個前面插入一個元素 >>> names ['admin', '我是新來的', 'abc', 'jack', 'lily', '追加第一個', '我也是新來的', '追加第二個']
2.1.四、修改函數
>>> names ['admin', '我是新來的', 'abc', 'jack', 'lily', '追加第一個', '我也是新來的', '追加第二個'] >>> names[6] = "boy" #將下標6的元素改成boy >>> names ['admin', '我是新來的', 'abc', 'jack', 'lily', '追加第一個', 'boy', '追加第二個']
2.1.五、刪除測試
刪除能夠有三種方法實現 >>> names ['admin', '我是新來的', 'abc', 'jack', 'lily', '追加第一個', 'boy', '追加第二個'] >>> del names[3] #刪除下標爲第3個的元素 ‘蠟jack' >>> names ['admin', '我是新來的', 'abc', 'lily', '追加第一個', 'boy', '追加第二個'] >>> names ['admin', '我是新來的', 'abc', 'lily', '追加第一個', 'boy', '追加第二個'] >>> names.remove("abc") #刪除指定元素 >>> names ['admin', '我是新來的', 'lily', '追加第一個', 'boy', '追加第二個'] >>> names.pop() #刪除最後一個元素並將刪除元素顯示出來 '追加第二個' >>> names ['admin', '我是新來的', 'lily', '追加第一個', 'boy']
2.1.六、擴展編碼
>>> names ['admin', '我是新來的', 'lily', '追加第一個', 'boy'] >>> a = ["123","abc","321"] >>> names.extend(a) #將兩個列表擴展成一個列表 >>> names ['admin', '我是新來的', 'lily', '追加第一個', 'boy', '123', 'abc', '321'] >>> a #列表不會改變 ['123', 'abc', '321']
2.1.七、拷貝
>>> names ['admin', '我是新來的', 'lily', '追加第一個', 'boy'] >>> names_copy = names.copy() >>> names_copy ['admin', '我是新來的', 'lily', '追加第一個', 'boy']
2.1.八、統計
>>> names ['admin', '我是新來的', 'lily', '追加第一個', 'boy', 'admin', 'admin'] >>> names.count("admin") #統計列表中相同元素的個數 3
2.1.九、排序
>>> names ['admin', '我是新來的', 'lily', '追加第一個', 'boy', 'admin', 'admin', '123', 'abc', '321'] >>> names.sort() #排序 >>> names ['123', '321', 'abc', 'admin', 'admin', 'admin', 'boy', 'lily', '我是新來的', '追加第一個']
2.2.一、翻轉
>>> names ['123', '321', 'abc', 'admin', 'admin', 'admin', 'boy', 'lily', '我是新來的', '追加第一個'] >>> names.reverse() >>> names ['追加第一個', '我是新來的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123']
2.2.二、獲取下標
>>> names ['追加第一個', '我是新來的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123'] >>> names.index("admin") #只返回找到的第一個下標 4
2.2.三、長度獲取
>>> names ['追加第一個', '我是新來的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123'] >>> len(names) #列表中元素的個婁 10
3、python 字符串函數
Python內置的字符串處理函數整理,收集經常使用的Python 內置的各類字符串處理 函數的使用方法
>>> abc = "Python String Function" #生成字符串變量 >>> abc 'Python String Function' >>> len(abc) #字符串長度獲取，從0開始，包括空格在內 22 >>> abc[0] 'P' >>> abc[21] 'n'
3.一、字母處理
>>> abc 'Python String Function' >>> abc.upper() #所有大寫 'PYTHON STRING FUNCTION' >>> abc.lower() #所有小寫 'python string function' >>> abc.swapcase() #大小寫互換 'pYTHON sTRING fUNCTION' >>> abc.capitalize() #首字母大寫，其餘小寫 'Python string function' >>> abc.title() #首字母大寫 'Python String Function'
3.二、格式化相關
>>> abc 'Python String Function' >>> abc.ljust(30，"*") #獲取固定長度，左對齊，右邊不夠*補齊,不加*會以空格補齊 'Python String Function********' >>> abc.rjust(30) #獲取固定長度，右對齊，左邊不夠*補齊 '********Python String Function' >>> abc.center(30,"*") #獲取固定長度，中間對齊，兩邊不夠用*補齊 '****Python String Function****'
3.三、搜索相關
>>> abc 'Python String Function' >>> abc.find("b") #搜索指定字符串，沒有返回-1 -1 >>> abc.find("t",3) #指定起始位置搜索，返回的是第二個t的下標 8 >>> abc.find("t",1,13) #指定開始及結束位置搜索，若是找到多個，只返回第一個的下標 2 >>> abc.rfind("t") #從右邊開始找 18 >>> abc.count("t") #指定字符串的個數 3 上面全部方法均可用index代替，不一樣的是使用index查找不到會拋異常，而find返回-1
3.四、替換相關
>>> abc 'Python String Function' >>> abc.replace("tion","TION") #將指定字符串替換爲大寫 'Python String FuncTION' >>> abc.replace("t","*",1) #替換字符串中的第一個t爲* 'Py*hon String Function'
3.五、去空格及去指定字符
>>> abc.strip() #去兩邊空格 'Python String Function' >>> abc.lstrip() #去左邊空格 'Python String Function' >>> abc.rstrip() #去右邊空格 'Python String Function' >>> abc.strip("n") #去兩邊字符串，也有lstrip和rsrtip 'Python String Functio'
3.六、判斷相關
>>> abc 'Python String Function' >>> abc.startswith("P") #是否以P開頭，是則爲True，不是則爲False True >>> abc.endswith("n") #是否以n結尾，是則爲True,不是則爲False True >>> abc.isalnum() #是否全爲字母或數字，是則爲True False >>> abc.isalpha() #是否全爲字母，不是則爲False,由於還有空格 False >>> abc.isdigit() #是否全爲數字，不是則False False >>> abc.islower() #是否全小寫 False >>> abc.isupper() #是否全大寫 False
4、元組
定義：與列表相似，只不過［］改爲（）
特性：
1.可存放多個值
2.不可變
3.按照從左到右的順序定義元組元素，下標從0開始順序訪問，有序
>>> ages = ("10","20","30","40") >>> ages ('10', '20', '30', '40')
注：只有2個方法，一個是count,一個是index
5、字典
定義：｛key1:value1,key2:value2｝,key-value結構，key必須可hash
字典一種key - value 的數據類型
語法：
>>> info = { ... "stu1":{"lily":{"age":18,"job":"IT"}}, ... "stu2":{"jack":{"age":20,"job":"IT"}}, ... "stu3":{"admin":{"age":30,"job":"Driver"}} ... } >>> info {'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}
字典的特性：
- dict是無序的
- key必須是惟一的,天生去重
5.一、增長
>>> info["abc"] = {"age":22,"job":"IT"} >>> info {'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'abc': {'age': 22, 'job': 'IT'}, 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}
5.二、修改
>>> info["abc"] = "xiaoming" >>> info {'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'abc': 'xiaoming', 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}
5.三、刪除
>>> info {'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'abc': 'xiaoming', 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}} >>> del info["abc"] >>> info {'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}} >>> #另外一種方法 >>> info.pop("stu3") {'admin': {'age': 30, 'job': 'Driver'}} >>> info {'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}}
5.四、查找
>>> info {'stu2': {'admin': {'age': 30, 'job': 'Driver'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'stu3': {'jack': {'age': 20, 'job': 'IT'}}} >>> "stu3" in info #顯示返回值 True >>> info["stu3"] #第二種方法 {'jack': {'age': 20, 'job': 'IT'}} >>> info["stu4"] #若是沒找到會報錯 Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'stu4' >>> info.get("stu3") #第三種方法 {'jack': {'age': 20, 'job': 'IT'}} >>> info.get("stu4") #沒找到不會報錯 >>>
其餘方法：
>>> info.values() dict_values([{'admin': {'age': 30, 'job': 'Driver'}}, {'lily': {'age': 18, 'job': 'IT'}}, {'jack': {'age': 20, 'job': 'IT'}}]) >>> info.keys() dict_keys(['stu2', 'stu1', 'stu3']) >>> a = {1:2,2:3,"a":"b"} >>> info.update(a) >>> info {'stu1': {'lily': {'job': 'IT', 'age': 18}}, 1: 2, 2: 3, 'stu2': {'jack': {'job': 'IT', 'age': 20}}, 'stu3': {'admin': {'job': 'Driver', 'age': 30}}, 'a': 'b'} >>> info.items() dict_items([('stu1', {'lily': {'job': 'IT', 'age': 18}}), (1, 2), (2, 3), ('stu2', {'jack': {'job': 'IT', 'age': 20}}), ('stu3', {'admin': {'job': 'Driver', 'age': 30}}), ('a', 'b')])
循環、、、
info = { "name1":"lily", "name2":"admin", "name3":"jack", "name4":"abc" } for key in info: print(key,info[key]) name3 jack name1 lily name2 admin name4 abc
6、集合
集合是一個無序的，不重複的數據組合，它的主要做用以下：
- 去重，把一個列表變成集合，就自動去重了
- 關係測試，測試兩組數據以前的交集、差集、並集等關係
集合經常使用操做：關係運算
in
not in
＝＝
！＝ 不等於
<,<=
>,>=
|,|=:合集
&.&=:交集
－,－=:差集
^,^=:對稱差分
set 的建立：
>>> L = [1,1,2,4,3] >>> t = (2,3,4,6,6,6,7) >>> s = {1} >>> type(s) <class 'set'> >>> s= set(L) >>> s {1, 2, 3, 4} #從列表到集合 >>> s = set(t) >>> s {2, 3, 4, 6, 7} #從元組到集合
set 基本函數與操做：
s.add( x ) 將元素 x 添加到集合s中，若重複則不進行任何操做
>>> s = {1,2,"a"}
>>> s.add("b")
>>> s
{1, 2, 'b', 'a'}
>>> s.add(1)
>>> s
{1, 2, 'b', 'a'}
s.update( x ) 將集合 x 併入原集合s中，x 還能夠是列表，元組，字典等，x 能夠有多個，用逗號分開
>>> s {1, 2, 'b', 'a'} >>> s.update({1,3}) >>> s {1, 2, 'b', 3, 'a'} >>> s.update([1,4]) >>> s {1, 2, 'b', 3, 4, 'a'}
s.discard( x ）將 x 從集合s中移除，若x不存在，不會引起錯誤
>>> s {1, 2, 'b', 3, 4, 'a'} >>> s.discard(1) >>> s {2, 'b', 3, 4, 'a'} >>> s.discard(1) >>> s {2, 'b', 3, 4, 'a'}
s.remove( x ) 將 x 從集合s中移除，若x不存在，會引起錯誤
>>> s {2, 'b', 3, 4, 'a'} >>> s.remove("a") >>> s {2, 'b', 3, 4} >>> s.remove("a") Traceback (most recent call last): File "<input>", line 1, in <module> KeyError: 'a'
s.pop() 隨機刪除並返回集合s中某個值，注意，由於set是無序的，不支持下標操做，沒有所謂的最後一個，pop()移除隨機一個元素，這和其餘數據結構不一樣
>>> s {2, 'b', 3, 4} >>> s.pop() 2 >>> s {'b', 3, 4}
s.clear() 清空
len(s) set支持len操做
>>> s {'b', 3, 4} >>> len(s) 3
x in s set一樣支持in操做
>>> s {'b', 3, 4} >>> 1 in s False >>> 3 in s True
s.union( x ) 返回s與集合x的交集，不改變原集合s，x 也能夠是列表，元組，字典。
>>> s1 = {1,2,3}
>>> s2 = {"a","b"}
>>> s1.union(s2)
{1, 2, 3, 'b', 'a'}
>>> s1
{1, 2, 3}
>>> s2
{'b', 'a'}
s.intersection( x ) 返回s與集合x的並集，不改變s， x 也能夠是列表，元組，字典。
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1.intersection(s2)
{2, 3}
>>> s1
{1, 2, 3}
s.symmetric_difference( x ) 返回s和集合x的對稱差集，即只在其中一個集合中出現的元素，不改變集合s， x 也能夠是列表，元組，字典。
>>> s1 {1, 2, 3} >>> s2 {2, 3, 4} >>> s1.symmetric_difference(s2) {1, 4} >>> s1 {1, 2, 3}
s.issubset( x ) 判斷 集合s 是不是 集合x 子集
s.issuperset( x ） 判斷 集合x 是不是集合s的子集
>>> s1 = {1,2,3}
>>> s2 = {1,3}
>>> s2.issubset(s1)
True
>>> s1.issubset(s2)
False
>>> s1.issuperset(s2)
True
求交集，並集，差集，對稱差集的另外一種方法：
>>> s1 = {1,2,3,"a"}
>>> s2 = {3,4,"b"}
>>> s1 & s2 #交集
{3}
>>> s1 | s2 #並集
{1, 2, 3, 'b', 4, 'a'}
>>> s1 - s2 #差集
{1, 2, 'a'}
>>> s1 ^ s2 #對稱差集
{1, 'b', 2, 4, 'a'}
{ } 在布爾運算中表示 False，其餘均爲 True
7、文件操做
對文件操做流程
- 打開文件，獲得文件句柄並賦值給一個變量
- 經過句柄對文件進行操做
- 關閉文件
| 模式 | 描述 |
|---|---|
| r | 打開一個文件爲只讀。文件指針被放置在文件的開頭。這是默認模式。 |
| rb | 打開一個文件只能以二進制格式讀取。文件指針被放置在文件的開頭。這是默認模式。 |
| r+ | 打開用於讀和寫文件。文件指針置於該文件的開頭。 |
| rb+ | 打開用於讀取和寫入二進制格式的文件。文件指針置於該文件的開頭。 |
| w | 打開一個文件只寫。若是文件存在覆蓋該文件。若是該文件不存在，則建立寫入新文件。 |
| wb | 打開一個文件只能以二進制格式寫入。若是文件存在覆蓋該文件。若是該文件不存在，則建立寫入新文件。 |
| w+ | 打開文件爲寫入和讀取模式。若是文件存在覆蓋現有文件。若是該文件不存在，建立用於讀寫操做的新文件。 |
| wb+ | 打開用於以二進制格式寫入和讀出文件。若是文件存在覆蓋現有文件。若是該文件不存在，建立用於讀寫操做的新文件。 |
| a | 打開用於追加的文件。文件指針是在文件是否存在該文件的末尾。也就是說，該文件是在追加模式。若是該文件不存在，它會建立一個用於寫入的新文件。 |
| ab | 打開文件用於二進制格式追加。文件指針是在文件是否存在該文件的末尾。也就是說，文件是在追加模式。 若是該文件不存在，它會建立一個用於寫入的新文件。 |
| a+ | 打開文件爲追加和讀取方式。文件指針是在文件是否存在該文件的末尾。該文件以追加模式打開。若是該文件不存在，它將建立用於讀寫操做的新文件。 |
| ab+ | 打開一個文件以附加和二進制格式讀取模式。若是該文件存在文件指針在該文件的末尾。該文件以追加模式打開。若是該文件不存在，它將建立讀寫操做的新文件。 |
file 對象屬性
一旦文件被打開，則就會有一個文件對象，你就能夠獲得有關該文件的各類信息。
這裏是一個文件對象相關的全部屬性的列表：
屬性:
| 描述 | |
|---|---|
| file.closed |
若是文件被關閉返回true，不然爲false
|
| file.mode |
返回文件打開訪問模式
|
| file.name |
返回文件名
|
示例：
1 fo = open("foo.txt","wb") 2 print("Name of the file:",fo.name) 3 print("Closed or not :",fo.closed) 4 print("Opening mode:",fo.mode) 5 fo.close()
結果：
Name of the file: foo.txt Closed or not : False Opening mode: wb
close()方法
文件對象的close()方法用於刷新任何未寫入的信息，並關閉文件對象， 以後就沒有更多的寫入東西了。
Python自動關閉文件當參考文件對象分配給另外一個文件。使用 close()方法關閉文件一個很好的作法。
fileObject.close();
示例：
fo = open("foo.txt","wb") print("Name of the file:",fo.name) fo.close()
結果：
Name of the file: foo.txt
讀寫文件
文件對象提供了一組訪問方法。 咱們將看到如何使用 read()和write()方法來讀取和寫入文件。
write() 方法
write()方法將字符串寫入一個打開的文件。要注意，Python的字符串能夠是二進制數據，而不只僅只是文字。
write()方法不添加換行符('\n')到字符串的結尾-
語法：
fileObject.write(string);
這裏，傳遞的參數是要寫入到打開的文件的內容。
示例：
fo = open("foo.txt","w") fo.write("Python is a great language.\n Yeah its great!\n") fo.close()
上面的方法將建立 foo.txt 文件，並給出的內容寫入文件，最後將關閉該文件。若是打開這個文件，會看到它有如下內容。
Python is a great language. Yeah its great!
read() 方法
read()方法從一個打開的文件讀取字符串。要注意，Python字符串能夠是二進制數據。而並不是只是文本數據。
語法
fileObject.read([count]);
這裏，傳遞的參數是從打開的文件讀取的字節數。該方法開始從文件的開始讀取，而且若是 count 丟失，那麼它會嘗試儘量讀，也許直到文件的末尾。
示例
讓咱們使用一個文件 foo.txt，這是咱們在上面所建立的。
# Open a file fo = open("foo.txt", "r+") str = fo.read(10) print ("Read String is : ", str) # Close opened file fo.close()
這將產生如下結果 -
Read String is : Python is
文件位置
tell() 方法告訴你該文件中的當前位置；換句話說，下一個讀或寫將發生在從該文件的開頭以後多個字節。
seek(offset[, from]) 方法改變當前文件的位置。 offset 參數指示要移動字節數。from 參數指定字節從哪移動的參考位置。
若是 from 被設置爲0，這意味着使用該文件的開頭做爲基準位置，以及若是設置爲1，則使用當前位置做爲基準位置，若是它被設置爲2，則該文件的結束將被做爲基準位置。
示例
讓咱們使用一個文件foo.txt，這是咱們在上面建立的。
# Open a file fo = open("foo.txt", "r+") str = fo.read(10) print ("Read String is : ", str) # Check current position position = fo.tell() print ("Current file position : ", position) # Reposition pointer at the beginning once again position = fo.seek(0, 0) str = fo.read(10) print ("Again read String is : ", str) # Close opened file fo.close()
這將產生如下結果 -
Read String is : Python is Current file position : 10 Again read String is : Python is
重命名和刪除文件
Python的os模塊提供了執行文件處理操做，如重命名和刪除文件的方法。
要使用這個模塊，須要先導入它，而後就能夠調用任何相關的功能了。
八. 字符編碼與轉碼
詳細文章:
http://www.cnblogs.com/yuanchenqi/articles/5956943.html
http://www.diveintopython3.net/strings.html
需知:
1.在python2默認編碼是ASCII, python3裏默認是utf-8
2.unicode 分爲 utf-32(佔4個字節),utf-16(佔兩個字節)，utf-8(佔1-4個字節)， so utf-8就是unicode
3.在py3中encode,在轉碼的同時還會把string 變成bytes類型，decode在解碼的同時還會把bytes變回string
相關文章
- 1. Python基礎數據類型
- 2. Python基礎-數據類型
- 3. python基礎之 數據類型的補充，小數據類型
- 4. Python基礎之數據類型詳解
- 5. python基礎之-數據類型
- 6. python語法之基礎數據類型
- 7. Python基礎之數據類型
- 8. Python基礎語法之「數據類型」
- 9. Python 基礎數據類型之dict
- 10. python基礎篇之數據類型
- 更多相關文章...
- • Kotlin 基本數據類型 - Kotlin 教程
- • C# 數據類型 - C#教程
- • Kotlin學習（二）基本類型
- • Flink 數據傳輸及反壓詳解
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Python基礎數據類型
- 2. Python基礎-數據類型
- 3. python基礎之 數據類型的補充，小數據類型
- 4. Python基礎之數據類型詳解
- 5. python基礎之-數據類型
- 6. python語法之基礎數據類型
- 7. Python基礎之數據類型
- 8. Python基礎語法之「數據類型」
- 9. Python 基礎數據類型之dict
- 10. python基礎篇之數據類型