python數據類型

時間  2019-11-16
標籤 python 數據 類型 欄目 Python 简体版
原文   原文鏈接

Date: 2019-05-27html

Author: Sunjava

1. 自省機制

什麼是自省？python

自省（introspection）是一種自我檢查行爲。程序員

自省是指這種能力：檢查某些事物以肯定它是什麼、它知道什麼以及它能作什麼。自省向程序員提供了極大的靈活性和控制力編程

Python自省機制安全

​ Python中比較常見的自省（introspection）機制(函數用法)有：help(), dir()，type(), hasattr(), isinstance()，經過這些函數，咱們可以在程序運行時得知對象的類型，判斷對象是否存在某個屬性，訪問對象的屬性。數據結構

dir()多線程

　dir() 函數多是 Python 自省機制中最著名的部分了。它返回傳遞給它的任何對象的屬性名稱通過排序的列表。若是不指定對象，則 dir() 返回當前做用域中的名稱。讓咱們將 dir() 函數應用於 keyword 模塊，並觀察它揭示了什麼：閉包

>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

type()　app

​ type() 函數有助於咱們肯定對象是字符串仍是整數，或是其它類型的對象。它經過返回類型對象來作到這一點，能夠將這個類型對象與 types 模塊中定義的類型相比較：

>>> type(100)
<class 'int'>
>>> type([])
<class 'list'>

hasattr()

​ 對象擁有屬性，而且 dir() 函數會返回這些屬性的列表。可是，有時咱們只想測試一個或多個屬性是否存在。若是對象具備咱們正在考慮的屬性，那麼一般但願只檢索該屬性。這個任務能夠由 hasattr() 和 getattr() 函數來完成.

>>> dir(int)
>>> hasattr(int, '__doc__')
True

isinstance()

​ 可使用 isinstance() 函數測試對象，以肯定它是不是某個特定類型或定製類的實例：

>>> isinstance("python", str)
True

2 變量

計算機本質上是一種能夠執行計算的機器，這裏的計算是一種廣義的「計算」，計算機上全部的處理均可以看作是計算。要計算必須的有數據，在程序中如何表示數據呢？

擴展知識：

​ 運行中的程序變量保存在內存中，當執行過程當中須要計算的部分放入CPU

​ 訪問速度：CPU > 內存 > 磁盤

在程序中，咱們通常以變量表示數據，所謂變量：

  • 變量是用來保存數據的
  • 在程序中，變量的值是能夠改變的，因此叫變量，不能改變的叫常量

2.1 變量定義

變量定義： 
    變量名 = 值（對象）

name = '楊冪'    #經過type就能夠判斷數據類型
age = 20
student = Student()   #類的實例化對象

2.2 變量命名規範

變量名也可稱之爲標識符（變量名、函數名、類名、報名等統稱爲標識符），其命名要符合python的語法要求：

  • 由數字、字母、下劃線組成，不能以數字開頭

  • 嚴格區分大小寫

  • 不能是python的關鍵字（保留字）

    獲取python的保留字
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2.3 變量命名風格

好的變量命名風格應該見名知意，有意義。

  • 見名知意，有自描述性
  • 不建議使用中文命名變量
  • 通常變量能夠用小駝峯規則：變量名由多個單詞組成，第一個單詞首字母小寫，其它單詞首字母大寫
  • 也能夠所有變量名都小寫，單詞之間用下劃線分隔
小駝峯命名：
    myBook   yourMoney
 下劃線分隔：
    my_book    your_money

模塊名：
小寫字母，單詞之間用_分割
eg： my_test.py

包名：
和模塊名同樣

​

類名：
單詞首字母大寫，採用駝峯式命名規範。
Student
PersonList

函數&方法

函數名應該爲小寫，能夠用下劃線風格單詞以增長可讀性。如：myfunction，my_example_function。

函數和方法的參數
總使用「self」做爲實例方法的第一個參數。總使用「cls」做爲類方法的第一個參數。

全局變量名（類變量，在java中至關於static變量）：
大寫字母，單詞之間用_分割
SNUMBER
COLOR_WRITE

普通變量：
小寫字母，單詞之間用_分割
this_is_a_var

實例變量：

​ 大多數狀況在類中， 以_開頭，其餘和普通變量同樣

_price    
 _instance_var

私有實例變量（外部訪問會報錯）：
以 _ _ 開頭（2個下劃線），其餘和普通變量同樣

__private_var

專有變量：
_ _ 開頭， _ _結尾，通常爲python的自有變量，不要以這種方式命名

__doc__
__class__

普通函數：
和普通變量同樣：

get_name() 
count_number() 
ad_stat()

私有函數（外部訪問會報錯）：

​ 以__開頭（2個下劃線），其餘和普通函數同樣

__get_name()

2.4 變量輸入和輸出

  • 變量輸出

    print函數 
    做用：將數據顯示到屏幕
用法：
    顯示字符串
    print('hello')

    顯示變量
    age = 20
    print(age)

    顯示多個字符串和變量
    age = 20
    sex = '男'
    print('俺是大傻',age,sex)

    格式化顯示
    name = '大傻'
    age = 20
    #%s和%d叫佔位符，替變量站了位置，顯示的時候會用變量的值替換佔位符
    #佔位符和和後面小括號裏的變量一一對應
    print('俺是%s,俺今年%d歲了'%(name,age))

    常見的佔位符
    %s  字符串佔位符
    %d  整數的佔位符
    %f  浮點數的佔位符

  • 變量輸入

    input用於輸入數據給變量
#input括號中字符串用於提示用戶，不用輸入
age = input('請輸入你的年齡')
print(age)

2.5 變量刪除

刪除後變量就不存在了，不可以在經過變量名進行存取了
del 變量名              #將變量名從內存中刪除掉

2.6 變量和內存

​ python中一切都是對象，python中變量保存了對象的引用，變量的比如是一個容器，容器中保存的變量所指對象的引用（地址）；變量自己是沒有類型的，變量的類型是指其所指對象的類型，好比說變量是一個瓶子，盛了醋就是醋瓶，盛了醬油就是醬油瓶

  • python中變量的所指對象的地址能夠用id函數獲取
  • 獲取變量的類型可使用type函數
num1 = 10
print(id(num1))    # 查看變量所指對象的地址
print(type(num1))  # 查看變量的類型

2.7 注意事項

  • 變量必須先定義後使用

  • =兩邊要留一個空格

3 常量

程序在運行的過程當中，值永遠不會發生改變的量稱之爲常量

python沒有專門的常量類型，通常約定俗成使用大寫表示常量

import math
math.pi

# 圓周率
PI = 3.1415926


# 個人生日
MY_BIRTHDAY = '2008/2/29'

4 註釋

python解釋器不解釋、不執行註釋

  • 註釋的優勢：

    • 註釋能夠提升代碼的可讀性、可維護性。
    • 保留代碼
    • 方便調試

  • 註釋的書寫格式

    • 單行註釋，以#開始，一直到本行結束都是註釋

      #這是單行註釋

age = 20  #這也是單行註釋

    • 多行註釋

      #1.使用三個單引號
'''
中間的任何內容都是註釋，
能夠有多行
但中間不能再有三個單引號

'''

#2.使用三個雙引號
"""
中間都是註釋內容
但不能出現三個雙引號
"""

  • 注意

    • 單行註釋通常出如今註釋代碼的上面和右面
    • 良好的註釋是一個優秀程序員的基本素質
    • 不要每行代碼都加註釋，只註釋比較難懂的代碼，或對變量說明

5. 變量做用域

按照做用域劃分，能夠分爲：

  • L：Local，局部做用域
  • E：Enclosing，閉包做用域【閉包外的函數中定義的變量】
  • G：Global，全局做用域 在全部函數外定義的變量
  • B：Built-in，內建做用域【內置做用域】
#1 局部做用域  
#局部變量只能在函數內部使用，外部沒法引用
#局部變量的做用域從定義開始到函數體結束
def demo():
    num = 20  #局部變量  
    print(num)
demo()
#print(num) 錯誤

#函數做用域
#
def outter():
   x = 10   #函數做用域,從定義開始到本函數結束
   def inner():
      y = x  #在閉包中能夠引用
      print(y)
   return inner
pf = outter()
pf()  #執行閉包
print(pf.__closure__)

#全局做用域
x = 100    #全局做用域  從定義開始到本文件結束
def demo():
   print(x)
print(x)

#內建做用域，是指系統內建的函數或常量，在系統載入時加載，在全部模塊中均可以直接引用
#好比說系統函數
print(max(1,2,3))  #max函數就是內建做用域  哪裏均可以引用
def  demo():
    x = 30
    y = 50
    print(max(x, y))

5.1 變量做用域查找規則

以 L --> E --> G -->B 的規則查找，即：在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全局找，最後到內建做用域中找。

5.2 全局變量和局部變量

定義在函數內部的變量擁有一個局部做用域，被稱爲局部變量

定義在函數外面的變量擁有一個全局做用域，被稱爲全局變量

total = 0   #全局變量

def sum(arg1,arg2):

    total = arg1 + arg2   #局部變量
    print("函數內部：",total)

    return total

sum(10,20)
#print(total1)
print("函數外部：",total)


num = 1
def fun1():
    print(num) #UnboundLocalError: local variable 'num' referenced before assignment
    num = 123
    print(num)

fun1()

6 數據類型

不一樣類型的變量能夠進行的運算是不一樣的，因此必須理解變量的類型，python中數據類型能夠分爲：

  • 內置類型

    內置類型分兩個部分：基礎類型（Number，String，Boolean，None）和 容器類型

    • Number：數值類型【整型，浮點型，複數 3+5j】
    • String:字符串
    • Boolean:布爾值【True，False】
    • None：空值，表示變量沒有肯定的值
    • list：列表
    • tuple：元組
    • dict：字典
    • set：集合

  • 自定義類型

    • class ：類

6.1 基礎類型

基礎類型

​ 包含Number，String，Boolean， None

  • 整型（int）： python3中只有int一種，能夠表示整數，例如：10，-5,10000

    python的int型也是4個字節，就是最大值也只是2^31；可是python 自帶大數整數運算，整數不會溢出，只要內存足夠

  • 浮點型（float）： 表示帶小數點的實數，有兩種表示法：

    • 小數表示： 1.9 .23

    • 科學計數法： 用e來表示10的指數，1e2就表明了100，注意e前面必須有數值，e後面必須爲整數

      print(float("%.3f" % 12.45623))   #保留小數點後三位浮點數

  • 複數（complex）：表示數學上的無理數，形如：a+bj

    aComplex = 1.56 + 1.2j
bComplex = 1 - 1j
print(aComplex.real, aComplex.imag）    #顯示aComplex的實部和虛部
aComplex - bComplex    #運算
abs(aComplex) #返回複數的模長

  • 布爾型(bool)：表示事務的兩種狀態，男女、陰晴、亮暗等，它只有兩個值：True，False

    1 print(True==1)                        # 返回True
2 print(False==0)                       # 返回True
3 print(1 is True)                    
4 print(0 is False)

  • None：表示空對象，通常用於判斷，不一樣於0和空字符

    Null表示對象或某種數據類型（數據類型也爲空，python中萬物皆爲對象）爲空，而None表示一種一種特殊的數據類型

    >>> s = ''     #爲s賦值一個空字符串
>>> print(s)   #該行打印了一個空字符串
>>> s == None  #可見,None不等於空
False

  • 字符串（str）：在python中，可使用字符串表示文本

    • 字符串的表示

      # 用單引號表示： 'hello'
# 用雙引號表示："我用python"
# 用3個單引號表示：能夠表示多行文本，例如：
    '''偉大
       的
       祖國
     '''
# 用3個雙引號表示：能夠表示多行文本，例如：
    """生死看淡，
    不服就幹"""

    • 轉義字符：有些特殊字符沒法從鍵盤輸入，可使用轉移字符表示，另外，不管是單引號、雙引號仍是雙引號字符串，在單引號字符串中如何表示一個單引號呢，這也可使用轉義字符表示。常見的轉義字符

      轉義字符 描述 轉義字符 描述
      ' 表示一個普通字符單引號 \r 回車
      " 表示一個普通字符雙引號 \r 回車
      ''' 一個普通的三單引號 \\ 一個普通的字符\
      """ 一個普通的三雙引號 \a 響鈴
      \t tab鍵 \b 回刪一個字符

      a = 'My name's sun'

      print(a)

    ​ 輸出：

    ​ My name‘s sun

    ​ c = "My name is Peter.\tYour name is Alice."

    ​ print(c)

    ​ 輸出：

    ​ My name is Peter. Your name is Alice.

    ​ 若是將上述的\t換成\n 呢？

    ​ 若是不但願字符串轉義呢？

    ​ 在字符串前加上r或者R

    ​ c = "My name is Peter.\tYour name is Alice."

    ​ print(c)

    ​ 輸出：

    ​ My name is Peter. \tYour name is Alice.

    • 字符串編碼：計算機只能識別二進制，那麼字符串如何存儲到計算機裏呢

      計算機不能直接存儲字符串，但咱們能夠將字符編碼，例如用65表示大寫字符A，66表示大寫字符B....等這種表示方式就是美國類的ASCII碼，只能表示127個字符，但對於美國人來講已經足夠了。一但能用整數表示字符，咱們能夠很方便的把整數用二進制表示，那麼字符串也就和容易存儲到計算機了。
但還有不少其餘國家的語言是不能用ASCII表示的，全部ISO組織就推出了unicode碼，用來表示任何一種語言的字符，unicode碼也稱之爲萬國碼，通用碼，能夠表示任何一種語言的任何一個字符。unicdoe碼有多中表示方式，例如：utf-八、utf-1六、utf-32等。通常使用較多的是utf-8，utf-8是一種變長的編碼，表示一個字符可能用一個字節，也多是三個字節
中文經常使用編碼通常用GBK編碼，用2個字節表示一個漢字

chr()函數

​ 是將編碼轉換成對應的字符

print(chr(65))
print(chr(97))

6.2 容器類型

容器類型有：

​ list：列表， tuple：元組， dict：字典， set：集合

List（列表）

列表是最經常使用的Python數據類型，它能夠做爲一個方括號內的逗號分隔值出現。

列表的數據項不必定須要具備相同的類型

建立一個列表，只要把逗號分隔的不一樣的數據項使用方括號括起來便可。以下所示：

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = list([1, 3, 4, 5])
list3 = ["a", "b", "c", "d"]

—— 雙向鏈表 有序，可變, 操做: 插入(append，insert， extend 任何位置)， 刪除（remove， pop，任何位置）， 查找（L[index], 任何位置）， 遍歷（列表，下標索引）

1 —》 2 —》 3 —》 4

《— 《— 《---

一、追加：names.append()

>> > names.append('e')
>> > names
['a', 'b', 'c', 'd', 'e']

二、刪除：pop，remove，del

​ 1）pop()

>> > names.pop()
'e'

​ 若是沒有指定下標，則默認會刪除最後一個元素，如上述例子

>>> names.pop(2)
'c'

​ 指定下標時，就會刪除下標所對應的元素

​ 2）remove()

>>> names.remove('e')
>>> names
['a', 'b', 'c', 'd']

​ 3）del

>>> del names[4]
>>> names
['a', 'b', 'c', 'd']

​

三、查找元素所在位置：index()

>>> names.index('c')
2

四、統計元素的次數：count()

>>> names.append('d')
>>> names.count('d')
2

五、反轉：reverse()

>>> names.reverse()
>>> names
['d', 'c', 'b', 'a']

六、清空：clear()

>>> names.clear()
>>> names
[]

七、插入：insert()

>>> names.insert(2,'devilf')
>>> names
['a', 'b', 'devilf', 'c', 'd']

#還有其餘的插入方法：
>>> names[3] = 'lebron'

八、排序：sort()按照ascii碼來進行排序

>>> names.insert(4,'&&')
>>> names
['a', 'b', 'd', 'devilf', '&&', 'lebron']
>>> names.sort()
>>> names
['&&', 'a', 'b', 'd', 'devilf', 'lebron']

九、拼接兩個列表：extend()

>>> names.extend(place)
>>> names
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

十、對列表進行切片處理

1）列出全部的元素

>>> names[::]
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

2）列出最後一個元素，從中間位置開始，列出後面全部的元素

>>> names[-1]
'usa'

案例：列表操做

#1.列表組合  將多個列表拼接爲一個列表
#直接使用加號
list1 = [43,65,76,6]
list2 = [45,77,90,11,2,4,66]
print(list1 + list2)  #產生一個新列表

#2.列表重複
#直接使用乘號 列表元素重複指定遍數，產生一個新列表
print(list1 * 4)

#3.成員操做
#成員運算符：in      not in
#運算的結果爲布爾值
list3 = ["hello",False,189,"good"]
print(189 in list3) #True
print(180 not in list3)  #True

#4.列表的截取【分片，切片】
#語法：列表名[開始下標:結束下標：步長]，表示按指定步長獲取從開始下標到結束下標之間的元素，
#     結果爲一個新的列表，步長默認是1
#注意：包頭不包尾【前閉後開區間】   [開始下標,結束下標)
#步長：默認是1，正數表示從左向右取，負數表示從右向左取
list1 = [10,20,30,40,50,60]
print(list1[0:3])   #[10,20,30]
print(list1[:3])    #[10,20,30]
print(list1[:])     #[10,20,30,40,50,60] 從頭取到尾
print(list1[::2])     # [10,30,50] 隔一個取一個
print(list1[3:0:-1])  #[40, 30, 20, 10]  從右向左取
print(list1[-1:-3:-1]) #[60, 50] 從右向左取
print(list1[2:]) #[30, 40, 50, 60] 從下標爲2的元素開始取到末尾
print(list1[-3::-1])#[40, 30, 20, 10] 從右向左取到第一個元素

Tuple（元組）

Python 的元組與列表相似，不一樣之處在於元組的元素不能修改。

元組使用小括號，列表使用方括號。

—— 有序，不可變， 查找（T.index(value, start, end)), 遍歷（列表，下標索引）

>>>tup1 = ('month', 'day', 1997, 2000);
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";   #  不須要括號也能夠
>>> type(tup3)
<class 'tuple'>

#建立空元組
tup1 = ();

注意：

​ 元組中只包含一個元素時，須要在元素後面添加逗號，不然括號會被看成運算符使用：

>> > tup1 = (50)
>> > type(tup1)  # 不加逗號，類型爲整型
<class 'int'>

>> > tup1 = (50,)
>> > type(tup1)  # 加上逗號，類型爲元組
<class 'tuple'>

​ 元組與字符串相似，下標索引從0開始，能夠進行截取，組合等。

  1. 訪問元組

​ 元組可使用下標索引來訪問元組中的值，以下實例:

tup1 = ('Google', 'baidu', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])

  1. 修改元組

    元組中的元素值是不容許修改的，但咱們能夠對元組進行鏈接組合，以下實例:

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')

# 如下修改元組元素操做是非法的。
# tup1[0] = 100

# 建立一個新的元組
tup3 = tup1 + tup2;
print(tup3)
  1. 刪除元組

​ 元組中的元素值是不容許刪除的，但咱們可使用del語句來刪除整個元組，以下實例:

tuple = ('Google', 'baidu', 1997, 2000)

print(tuple)
del tuple;
print("刪除後的元組 tuple : ")
print(tuple)

​ 以上實例元組被刪除後，輸出變量會有異常信息，輸出以下所示：

刪除後的元組 tuple : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tuple)
NameError: name 'tuple' is not defined

enumerate() 方法

seasons = ['Spring', 'Summer', 'Autumn', 'Winter']
list(enumerate(seasons))
list(enumerate(seasons, start=1))       # 下標從 1 開始
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print(i, element)

Dictionary（字典）

字典是一種可變容器模型，且可存儲任意類型對象。

​ 字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示：

d = {key1 : value1, key2 : value2 }

​ 鍵必須是惟一的，但值則沒必要。

​ 值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。

一個簡單的字典實例：

dict = {'A': '11111', 'B': '2222', 'C': '3333'}

— — key-value鍵值對。

​ 建立（1. mdict={'key':value}, 2.mdict=dict(key=value)）

​ 插入：mdict[key] = value 獲取：key獲取value數據（get， pop）

​ 查找：mdict[key], mdict.get(key), 遍歷（安裝mdict.keys（）遍歷key，由mdict[key]獲取value）

  1. 訪問字典裏的值

​ 把相應的鍵放入到方括號中，以下實例:

dict = {'Name': 'Andy', 'Age': 37, 'Class': 'Hongkong'}

print("dict['Name']: ", dict['Name'])
print("dict['Age']: ", dict['Age'])

​ 若是用字典裏沒有的鍵訪問數據，會輸出沒有key錯誤：KeyError

  1. 修改字典

    向字典添加新內容的方法是增長新的鍵/值對，修改或刪除已有鍵/值對

dict = {'Name': 'Andy', 'Age': 37, 'Class': 'Hongkong'}

dict['Age'] = 48;  # 更新 Age
dict['School'] = "清華大學"  # 添加信息

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

  1. 刪除字典元素

    能刪單一的元素也能清空字典，清空只需一項操做。

​ 顯示刪除一個字典用del命令

del dict['Name']  # 刪除鍵 'Name'
dict.clear()  # 清空字典
del dict  # 刪除字典

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

​ 這會引起一個異常，由於用執行 del 操做後字典再也不存在

字典鍵特性

​ 字典值能夠是任何的 python 對象，既能夠是標準的對象，也能夠是用戶定義的，但鍵不行

​ 1）不容許同一個鍵出現兩次。建立時若是同一個鍵被賦值兩次，後一個值會被記住

​ 2）鍵必須不可變，因此能夠用數字，字符串或元組充當，而用列表就不行

eg:

dict = {['Name']: 'Andy', 'Age': 37, 'Class': 'Hongkong'}

print("dict['Name']: ", dict['Name'])

此時，就會出異常，TypeError: unhashable type: 'list' 錯誤

其餘使用方法

len(dict) 計算字典元素個數，即鍵的總數

str(dict) 輸出字典，以可打印的字符串表示。

Set （集合）

集合（set）是一個無序的不重複元素序列

可使用大括號 { } 或者 set() 函數建立集合

集合對象還支持union(聯合), intersection(交), difference(差)等操做。

做用：（1）去重 （2）運算：交集（intersection），並集(union)

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 這裏演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判斷元素是否在集合內
True
>>> 'crabgrass' in basket
False
# 下面展現兩個集合間的運算.
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的全部元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不一樣時包含於a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

一樣集合支持集合推導式

>>>a = {x for x in 'abcbde' if x not in 'abc'}
>>> a
{'d', 'e'}

  1. 添加元素

    s.add( x )

​ 將元素 x 添加到集合 s 中，若是元素已存在，則不進行任何操做。

>>>thisset = set(("baidu", "Alibaba", "Tenxun"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Tenxun', 'Facebook', 'baidu', 'Alibaba'}

​ 還有一個方法，也能夠添加元素，且參數能夠是列表，元組，字典等

​ 語法格式以下：

s.update( x )       # x 能夠有多個，用逗號分開。
>>>thisset = set(("Google", "baidu", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'baidu'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'baidu'}

  1. 移除元素

    s.remove( x )

​ 將元素 x 從集合 s 中移除，若是元素不存在，則會發生錯誤。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>>thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>>thisset.remove("Facebook")   # 不存在會發生錯誤
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'

​ 此外還有一個方法也是移除集合中的元素，且若是元素不存在，不會發生錯誤，以下discard函數

s.discard( x )

  1. 清空集合

    s.clear()

  2. 判斷元素 x 是否在集合

    x in s

​ 判斷元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
  1. 集合內置方法完整列表
方法 描述
add() 爲集合添加元素
clear() 移除集合中的全部元素
copy() 拷貝一個集合
difference() 返回多個集合的差集
difference_update() 移除集合中的元素，該元素在指定的集合也存在。
discard() 刪除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 刪除集合中的元素，該元素在指定的集合中不存在。
isdisjoint() 判斷兩個集合是否包含相同的元素，若是沒有返回 True，不然返回 False。
issubset() 判斷指定集合是否爲該方法參數集合的子集。
issuperset() 判斷該方法的參數集合是否爲指定集合的子集
pop() 隨機移除元素
remove() 移除指定元素
symmetric_difference() 返回兩個集合中不重複的元素集合。
symmetric_difference_update() 移除當前集合中在另一個指定集合相同的元素，並將另一個指定集合中不一樣的元素插入到當前集合中。
union() 返回兩個集合的並集
update() 給集合添加元素

Queue (隊列)

​ Queue是python標準庫中的線程安全的隊列（FIFO）實現,提供了一個適用於多線程編程的先進先出的數據結構，即隊列，用來在生產者和消費者線程之間的信息傳遞

— 存儲先進先出的對象

​ 建立方式：mq = queue.Queue(maxsize=0)

​ 插入：put， put_nowait, 取數據：get, get_nowait

from queue import Queue #LILO隊列
q = Queue() #建立隊列對象
q.put(0)    #在隊列尾部插入元素
q.put(1)
q.put(2)
print('LILO隊列',q.queue)  #查看隊列中的全部元素
print(q.get())  #返回並刪除隊列頭部元素
print(q.queue)

from queue import LifoQueue #LIFO隊列
lifoQueue = LifoQueue()
lifoQueue.put(1)
lifoQueue.put(2)
lifoQueue.put(3)
print('LIFO隊列',lifoQueue.queue)
lifoQueue.get() #返回並刪除隊列尾部元素
lifoQueue.get()
print(lifoQueue.queue)

from queue import PriorityQueue #優先隊列
priorityQueue = PriorityQueue() #建立優先隊列對象
priorityQueue.put(3)    #插入元素
priorityQueue.put(78)   #插入元素
priorityQueue.put(100)  #插入元素
print(priorityQueue.queue)  #查看優先級隊列中的全部元素
priorityQueue.put(1)    #插入元素
priorityQueue.put(2)    #插入元素
print('優先級隊列:',priorityQueue.queue)  #查看優先級隊列中的全部元素
priorityQueue.get() #返回並刪除優先級最低的元素
print('刪除後剩餘元素',priorityQueue.queue)
priorityQueue.get() #返回並刪除優先級最低的元素
print('刪除後剩餘元素',priorityQueue.queue)  #刪除後剩餘元素
priorityQueue.get() #返回並刪除優先級最低的元素
print('刪除後剩餘元素',priorityQueue.queue)  #刪除後剩餘元素
priorityQueue.get() #返回並刪除優先級最低的元素
print('刪除後剩餘元素',priorityQueue.queue)  #刪除後剩餘元素
priorityQueue.get() #返回並刪除優先級最低的元素
print('所有被刪除後:',priorityQueue.queue)  #查看優先級隊列中的全部元素

from collections import deque   #雙端隊列
dequeQueue = deque(['Eric','John','Smith'])
print(dequeQueue)
dequeQueue.append('Tom')    #在右側插入新元素
dequeQueue.appendleft('Terry')  #在左側插入新元素
print(dequeQueue)
dequeQueue.rotate(2)    #循環右移2次
print('循環右移2次後的隊列',dequeQueue)
dequeQueue.popleft()    #返回並刪除隊列最左端元素
print('刪除最左端元素後的隊列：',dequeQueue)
dequeQueue.pop()    #返回並刪除隊列最右端元素
print('刪除最右端元素後的隊列：',dequeQueue)

Collections

​ Counter， defaultdict， deque， namedtuple， OrderedDict

​ 見下節《2-Collections庫使用》

6.3 自定義類型

自定義類型：類

類是一種高級抽象,就是一種高級的數據類型,是對象的藍圖,就是用來定義你要用的對象的屬性和行爲的

class MyClass:
    """一個簡單的類實例"""
    i = 12345

    def f(self):
        return 'hello world'

# 實例化類
x = MyClass()

# 訪問類的屬性和方法
print("MyClass 類的屬性 i 爲：", x.i)
print("MyClass 類的方法 f 輸出爲：", x.f())
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程