python內置數據結構

分類

  • 數值型
    • int、float、complex、bool
  • 數列對象
    • 字符串 str
    • 列表 list
    • tuple
  • 鍵值對
    • 集合set
    • 字典dict

數值型

  • 數值型
    • int、float、complex、bool都是class,1、5.0、2+3j都是對象即實例
    • int:Python3的int就是長類型,且沒有大小限制,受限於內存區域的大小
    • float:有整數部分和小數部分組成。支持十進制和科學計數法表示。只有雙精度型。
    • complex:有實數和虛數部分組成,實數和虛數部分都是浮點數,3+4.2j
    • bool:int的子類,僅有2個實例True、False對應1和0,可以和整數直接運算
  • 類型轉換(built-in)
    • int(x)返回一個整數
    • float(x)返回一個浮點數
    • complex(x)、complex(x,y)返回一個複數
    • bool(x)返回布爾值,前面講過False等價的對象

數字的處理函數

  • round(),四舍五取偶六入
  • math模塊、
    • floor():向下取整
    • ceil():向上取整
  • int():取整數部分
  • //:整除且向下取整
  • min():取最小值
  • max():取最大值
  • pow(x,y)等價於x**y
  • math.sqrt():開平方
  • 進制函數,返回值是字符串
    • bin():二進制轉換
    • oct():八進制轉換
    • hex():十六進制轉換
  • math.pi π
  • math.e 自如常數

類型判斷

  • type(obj),返回類型,而不是字符串
  • isinstance(obj,class_or_tuple),返回布爾值
  • 舉例:
    • type(a)
    • type(‘abd’)
    • type(123)
    • isinstance(6,str)
    • isinstance(6,(str,bool,int))

列表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 [,sttep])從指定範圍內,按指定基數遞增的集合中獲取一個隨機數
  • 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)
    • 返回元素的個數

元組其他操作

  • 元組是隻讀的,所以增、改、刪的方法都沒有

字符串

  • 一個個字符組成的有序的序列,是字符的集合
  • 使用單引號、雙引號、三引號引住的字符序列
  • 字符串是不可變對象
  • 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'"""

字符串元素訪問

  • 字符串支持使用索引訪問
  • 有序的字符集合,字符序列
  • 可迭代

字符串joinlianjie

  • “string”.join(iterable) -> str
    • 將可迭代對象連接起來,使用string作爲分隔符
    • 可迭代對象本身元素都是字符串
    • 返回一個新字符串
    • 舉例

      lst = ['1','2','3']
      print("\"".join(lst))
      print("\n".join(lst))
      lst = ['1',['a','b'],'3']
      print(" ".join(lst)

字符串 + 連接

  • +-> str
    • 將2個字符串連接在一起
    • 返回一個新字符串

字符串分割

  • 分割字符串的方法分爲2類
    • split
      • 將字符串按照分隔符分割成若干字符串,並返回列表
    • partition
      • 將字符串按照分隔符分割成2段,返回這2段和分隔符的元組
  • 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結尾
  • startwith(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)
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章