數據結構 | 可變 | 可迭代 | 有序 | 特性 |
---|---|---|---|---|
str | ✖ | ✔ | ✔ | |
list | ✔ | ✔ | ✔ | |
tuple | ✖ | ✔ | ✔ | |
set | ✔ | ✔ | ✖ | key不重複,且必須可hash |
dict | ✔ | ✔ | ✖ | 同上 |
字符串
- 一個個字符組成的有序的序列,是字符的集合
- 使用單引號、雙引號、三引號引住的字符序列
- 字符串是不可變對象
- Python3,字符串就是Unicode類型
字符串定義 初始化
舉例
s1 = 'string' s2 = "string2" s3 = '''this`s a "string" ''' s4 = 'hello \n magedu.com' s5 = r"hello \n magedu.com" s6 = 'c:\windows\nt' s7 = R"c:\windows\\nt" s8 = 'c:\windows\\nt' sql = """select * from user where name='tom'"""
字符串元素訪問
- 字符串支持使用索引訪問
- 有序的字符集合,字符序列
- 可迭代
字符串join連接
"string".join(iterable) -> str
- 將可迭代對象連接起來,使用string作爲分隔符
- 可迭代對象本身元素都是字符串
- 返回一個新字符串
- 舉例
lst = ['1','2','3'] print("\"".join(lst)) print("\n".join(lst)) #返回 1"2"3 1 2 3 lst = ['1',['a','b'],'3'] print(" ".join(lst)) #報錯,注意可迭代對象元素都是字符串
字符串 + 連接
- + > str
- 將2個字符串連接在一起
- 返回一個新字符串
字符串分割
- 分割字符串的方法分爲2類
- split
- 將字符串按照分隔符分割成若干字符串,並返回列表
- partition
- 將字符串按照分隔符分割成2段,返回這2段和分隔符的元組
- split
split(sep=None,maxsplit=-1) - > list of strings
- 從左至右
- sep指定分割字符串,缺省的情況下空白字符串作爲分隔符
- maxsplit指定分割次數,-1表示遍歷整個字符串
- 舉例
s1 = "i`m \ta super student." s1.split() s1.split('s') s1.split('super') s1.split('super ') s1.split('') s1.split('',maxsplit=2) s1.split('\t',maxsplit=2)
rsplit(sep=None,maxsplit=-1)-> list of string
- 從右至左
- sep指定分割字符串,缺省的情況下空白字符串作爲分隔符
- maxsplit指定分割次數,-1表示遍歷整個字符串
splitlines([keepends]) -> list of strings
- 按照行來切分字符串
- keepends指的是是否保留分隔符
- 行分隔符包括\n、\r\n、\r等
partition(sep) -> (head,sep,tail)
- 從左至右,遇到分隔符酒吧字符串分割成兩部分,返回頭,分隔符,尾三部分;如果沒有找到分隔符,就返回頭,2個空元素的三元組
- sep分割字符串,必須指定
rpartiton(sep) -> (dead, sep, tail)
- 從右至左,遇到分隔符酒吧字符串分割成兩部分,返回頭,分隔符,尾三部分;如果沒有找到分隔符,就返回頭,2個空元素的三元組
字符串大小寫
- upper() 全大寫
- lower() 全小寫
- swapcase() 交互大小寫
字符串排版
- title() -> str
- 標題的每個單詞都大寫
- capitalize() -> str
- 首個單詞大寫
- center(width[, fillchar]) -> str
- width 打印寬度
- fillchar 填充的字符
- zfill(width) -> str
- width 打印寬度,居右,左邊用0填充
- ljust(width[,fillchar]) -> str 左對齊
- rjust(width[,fillchar]) -> str 右對齊
字符串修改
- replace(old, new[,count]) -> st
- 字符串中找到匹配替換爲新子串,返回新字符串
- count表示替換幾次,不指定就是全部替換
- strip([chars]) -> str
- 從字符串兩端去除指定的字符集chars中的所有字符
- 如果chars沒有指定,去掉兩端的空白字符
- lstrip([chars]) -> str
- 從左開始
- rstrip([chars]) -> str
- 從右開始
字符串查找
- find(sub[, strat[, end]]) -> int
- 在指定的區間[start, end],從左至右,查找子串sub。找到返回索引,沒找到返回-1
- rfind(sub[, strat[, end]]) -> int
- index(sub[, start[, end]]) -> int
- 在指定的區間[start,end),從左至右,查找子串sub。找到返回索引,沒找到拋出異常ValueError
- rindex(sub[, start[, end]]) -> int
- 在指定的區間[start,end),從右至左,查找子串sub。找到返回索引,沒找到拋出異常ValueError
- 時間複雜度
- index和count方法都是O(n)
- 隨着列表數據規模的增大,而效率下降
- len(string)
- 返回字符串的長度,即字符的個數
- count(sub[,start[, end]]) -> int
- 在指定區間[start, end),從左至右,統計子串sub出現的次數
字符串判斷
- endswith(suffix[, start[, end]]) -> bool
- 在指定的區間[start, end),字符串是否是suffix結尾
- startswith(prefix[,start[, end]])-> bool
- 在指定的區間[start, end),字符串是否是suffix開頭
字符串判斷is系列
- isalnum() -> bool 是否是字母和數字組成
- isalpha() 是否是字母
- isdecimal() 是否只包含十進制數字
- isdigit()是否包含全部數字(0-9)
- isidentifer()是不是字母和下劃線開頭,其他嗾使字母、數字、下劃線
- islower()是否都是小寫
- isupper()是否全部大寫
- isspace() 是否只包含空白字符
字符串格式化
- 字符串的格式化是一種拼接字符串輸出樣式的手段,更靈活方便
- join拼接只能使用分隔符,且要求被拼接的是可迭代的對象
- + 拼接字符串還算方便,但是非字符串需要先轉化爲字符串才能呢個拼接
- format函數格式字符串語法
- ”{} {xxx}”.format(*args,**kwargs) -> str
- args是位置參數,是一個元組
- kwargs是關鍵字參數,是一個字典
- 花括號表示佔位符
- {}表示按照順序匹配位置參數,{n}表示取位置參數索引爲n的值
- {xxx}表示在關鍵字參數中搜索名稱一致的
- {{}}表示打印花括號
位置參數
"{}:{}".format('192.168.1.100',8888) 這就是按照位置順序用位置參數替換前面的格式字符串的佔位符中
關鍵字參數或命名參數
"{server} {1}:{0}".format(8888,'192.168.1.100', server='Web Server Info:') 位置參數按照序號匹配,關鍵字參數按照名詞匹配
訪問參數
"{0[0]}.{0[1]}".format(('magedu','com'))
對象屬性訪問
from collections import namedttuple Point = namedtuple('Point','x y') p = Point(4,5) "{{{0,x},{0,y}}}".format(p)
對齊
'{0}*{1}={2:<2}'.format(3,2,2*3) '{0}*{1}={2:<02}'.format(3,2,2*3) '{0}*{1}={2:>02}'.format(3,2,2*3) '{:^30}'.format('centered') '{:*^30}'.format('centered')
進制
"int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42) "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42) octets = [192, 168, 0, 1] '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
列表list
- 一個排列整齊的隊列
- 列表內的個體稱爲元素,由若干個元素組成列表
- 元素可以是任意對象(數字、字符串、對象、列表等)
- 列表內元素有順序,可以使用索引
- 線性數據結構
- 使用[]表示
- 列表是可變的
列表list定義 初始化
- list() 生成一個新列表
- list(iterable) 可將可循環結構轉化爲列表
- 列表不能一開始就定義大小
- 舉例
- lst=list()
- lst=[]
- lst=[2,3,’adfa’]
- lst=list(range(5))
列表索引訪問
- 索引,也叫下標
- 正索引:從左至右,從0開始,爲列表中的每一個元素編號
- 負索引:從右至左,從-1開始
- 正負索引不可以越界,否則引發異常indexError
- 列表通過索引訪問
list[index]
,index就是索引,使用中括號訪問
列表查詢
- index(value,[start,[stop]])
- 通過值valaue,從指定區間查找列表內的元素是否匹配
- 匹配第一個就立即返回索引
- 匹配不到,拋出異常ValueError
- count(value)
- 返回列表中匹配value的次數
- 時間複雜度
- index和count方法都是O(n)
- 隨着列表數據規模的增大,效率下降
- len()
列表元素修改
- 索引訪問修改
- list[index] = value
- 索引不要越界
列表增加、插入元素
- append(object) -> None
- 列表尾部追加元素,返回None
- 不產生新列表,就地修改
- 時間複雜度O(1)
- insert(index,object) -> None
- 在指定的索引index處插入object
- 不產生新的列表,就地修改
- 時間複雜度是O(n)
- 索引超出上下界
- 超越上屆,尾部追加
- 超越下屆,頭部追加
- extend(iteratable) -> None
- 將可迭代對象的元素追加進來,返回None
- 就地修改
- + > list
- 連接操作,將兩個列表連接起來
- 產生新的列表,原來列表不變
- 本質上是調用add()方法
列表*重複的問題
pass
列表刪除元素
- remove(value) -> None
- 從左至右查找第一個匹配value的值,移除該元素,返回None
- 就地修改
- 時間複雜度是O(n)
pop([index]) -> item
- 不指定索引index,就從尾部彈出一個元素
- 指定索引index,就從索引處彈出一個元素,索引超界拋出IndexError錯誤
- 時間複雜度
- 指定索引是O(n)
- 不指定是O(1)
clear() -> None
- 清除列表內所有的元素
列表其他操作
- reverse() -> None
- 將列表元素反轉,返回None,就地修改
- sort(key=None,reverse=False) -> None
- 對列表元素進行排序,就地修改,默認升序
- reverse爲True,反轉,降序
- key一個函數,指定key如何排序
- in
- [3,4] in [1,2,[3,4]]
- for x in [1,2,3,4]
列表複製
- copy() -> List
- shadow copy 影子拷貝,也叫淺拷貝,遇到引用類型,只是複製了一個引用而已。
- 深拷貝
- copy 模塊提供了deepcopy
隨機數
- random模塊
- randint(a,b) 返回a,b之間的整數
- choice(seq)從非空序列的元素中隨機挑選一個元素
- randrange([start,] stop [,step])從指定範圍內,按指定基數遞增的集合中獲取一個隨機數
- random.shuffle(list) ->None 就地打亂列表元素
- sample(population, k)從樣本空間或總體中隨機取出k個不同的元素,返回一個新的列表
元組 tuple
- 一個有序的元素組成的集合
- 使用小括號() 表示
- 元組是不可變對象
元組的定義 初始化
定義
- tuple() -> empty tuple
- tuple(iterable) -> tuple initialized from iterable’s items
- 舉例
t = tuple() t = () t = tuple(range(1,7,2) t = (2,3,4,6,7) t = (1,) t = (1,2,3) * 6
元組元素的訪問
- 支持索引
- 正索引:從左至右,從0開始,爲列表中每一個元素編號
- 負索引:從右至左,從-1開始
- 正負索引不可以超界,否則引發異常IndexError
- 元組通過索引訪問
- tuple[insex],index就是索引,使用中括號訪問
元組查詢
- index(value,[start,[stop]])
- 通過值value,從指定區域查找列表內的元素是否匹配
- 匹配第一個就立即返回索引
- 匹配不到,拋出異常ValueErroe
- count(value)
- 返回列表中匹配value的次數
- 時間複雜度
- index和count方法都是O(n)
- 隨着列表數據規模的增大,而效率下降
- len(tuple)
- 返回元素的個數
元組其他操作
- 元組是隻讀的,所以增、改、刪的方法都沒有
字典dict
- key-value鍵值對的數據集合
- 可變的、無序的、key不重複
字典dict定義 初始化
d = dict() 或者 d = {}
dict(**kwargs) 使用name=value對初始化一個字典
dict(iterable, **kwarg) 使用可迭代對象和name=value 對結構字典,不過可迭代對象的元素必須是一個二元結構
d = dict(((1, 'a'), (2, 'b'))) 或者 d = dict(([1, 'a'], [2, 'b'])))
dict(mapping, **kwarg) 使用一個字典構建另一個字典
d = {'a':10, 'b':20, 'c':None, 'd':[1,2,3]}
類方法dict.fromkeys(iterable, value)
d = dict.fromkeys(range(5))
d = dict.fromkeys(range(5), 0)
字典元素的訪問
d[key]
返回key對應的值value
key不存在拋出KeyError異常get(key[, default])
返回key對應的值value
key不存在返回缺省值,如果沒有設置缺省值就返回Nonesetdefault(key[, default])
返回key對應的值value
key不存在,添加kv對,value爲default,並返回default,如果default沒有設置,缺省爲None
字典增加和修改
d[key] = value
將key對應的值修改爲value
key不存在添加新的kv對update([other]) -> None
使用另一個字典的kv對更新本字典
key不存在,就添加
key存在,覆蓋已經存在的key對應的值
就地修改
d.update(red=1)
d.update((('red', 2),))
d.update({'red':3})
字典刪除
pop(key[, default])
key存在,移除它,並返回它的value
key不存在,返回給定的default
default未設置,key不存在則拋出KeyError異常popitem()
移除並返回一個任意的鍵值對
字典爲empty,拋出KeyError異常clear()
清空字典del語句
del a[‘key’]
本質是刪除對象引用
字典遍歷
for … in dict
遍歷key
for k in d:
print(k)
for k in d.keys():
print(k)
遍歷value
for k in d:
print(d[k])
for k in d.keys():
print(d.get(k))
for v in d.values():
print(v)
遍歷item
for item in d.items():
print(item)
for item in d.items():
print(item[0], item[1])
for k,v in d.items():
print(k, v)
for k,_ in d.items():
print(k)
for _,v in d.items():
print(v)
總結
python3中,keys、values、items方法返回一個類似一個生成器的可迭代對象,不會吧函數的返回值複製到內存中
字典的遍歷移除
錯誤做法
d = dict(a=1,b=2,c='abc')
for k,v in d.items():
d.pop(k) #拋出異常,不能在遍歷中改變字典長度
正確做法
d = dict(a=1,b=2,c='abc')
key = []
for k,v in d.items():
if isinstance(v,str):
keys.append(k)
for k in keys:
d.pop(k)
print(d)
字典的key
- key的要求和set的元素要求一致
- set的元素可以看作key,set可以看作是dict的簡化版
- hashable可哈希纔可以作爲key,可以使用hash()測試
deaultdict
collections.defaultdict([default_factory[, ...]])
第一個參數是default_factory,缺省是None,它提供一個初始化函數,當key不存在的時候,會調用這個共產函數來生成key對應的value
import random
d1 = {}
for k in 'abcdef':
for i in range(random.randint(1,5)):
if k not in d1.keys():
d1[k] = []
d1[k].append(i)
print(d1)
form collections import defaultdict
import random
d1 = defaultdict(list)
for k in 'abcdef':
for i in range(random.randint(1, 5)):
d1[k].append(i)
print(d1)
OrderedDict
collections.OrderedDict([items])
key並不是按照加入的順序排列,可以使用OrderedDict記錄順序
from collections import OrderedDict
import random
d = {'banana':3, 'apple':4, 'pear':1, 'orangr':2}
print(d)
keys = list(d.keys())
random.shuffle(keys)
print(keys) 89
od = OrderedDict()
for key in keys:
od[key] = d[key]
print(od)
print(od.keys())