python基礎(二)—-資料型別

Python基礎第二章

• 二進位制
• 字元編碼
• 基本資料型別-數字
• 基本資料型別-字串
• 基本資料型別-列表
• 基本資料型別-元組
• 可變、不可變資料型別和hash
• 基本資料型別-字典
• 基本資料型別-集合

二進位制

二進位制是計算技術中採用的一種進位制。二進位制數由0和1兩個數碼組成，它的基數為2，進位制規則是“逢二進一”，由18世紀德國數理哲學大師萊布尼茲發現。當前的計算機系統使用的基本上是二進位制系統，資料在計算機中主要是以補碼的形式儲存的。計算機中的二進位制則是一個非常微小的開關，用“開”代表1，“關”代表0。

二進位制與十進位制的轉換

二進位制的第n位代表的十進位制值都剛好遵循著2的n次方這個規律

裝水桶法

先把他們代表的值一次寫出來，然後再根據10進位制的值把數填到相應位置，就好了~~~
十進位制轉二進位制的方法相同，只要對照二進位制為1的那一位對應的十進位制值相加就可以了。

        128     64      32      16      8       4       2        1

20       0       0       0       1      0       1       0        0   
200      1       1       0       0      1       0       0        0

字元編碼

十進位制與二進位制之間的轉換隻能解決計算機理解數字的問題，那麼為文字的話需要怎麼讓計算機去理解呢？
於是就有了一種曲線救國的方法，既然數字可以轉換成十進位制，那麼我們只需要想辦法解決文字轉換成數字的問題，那麼文字不就是可以表示成二進位制了嗎？
可是文字應該怎麼轉換成二進位制呢？ 就是強制轉換
我們自己強行約定了一個表，把文字和數字對應上，這張表就等於是進行了翻譯，我們可以拿一個數字來對比對應表中的文字，反之亦然。

ASCII碼

ASCII表

ASCII（American Standard Code for Information Interchange，美國資訊交換標準程式碼）是基於拉丁字母的一套電腦編碼系統，主要用於顯示現代英語和其他西歐語言。它是現今最通用的單位元組編碼系統，並等同於國際標準ISO/IEC 646。

由於計算機是美國人發明的，因此，最早只有127個字母被編碼到計算機裡，也就是大小寫英字母、數字和一些符號，這個編碼表被稱為ASCII編碼，比如大寫字母 A的編碼是65，小寫字母 z的編碼是122。後128個稱為擴充套件ASCII碼。

那現在我們就知道了上面的字母符號和數字對應的表是早就存在的。那麼根據現在有的一些十進位制，我們就可以轉換成二進位制的編碼串。
比如：

一個空格對應的數字是0     翻譯成二進位制就是0(注意字元0和整數0是不同的)
一個對勾√對應的數字是251  翻譯成二進位制就是11111011

提問：如果我們要列印兩個空格和一個對勾，寫成二進位制就應該是[`0011111011]，但是問題來了，我們怎麼知道從哪到哪是一個字元呢？聰明的人類就想出了一個解決辦法，既然一共就這255個字元，那最長的也不過11111111八位，不如就把所有的二進位制都轉換成8位的，不足的用0來替換。

這樣一來，剛剛的兩個空格一個對勾就寫作[`000000000000000011111011]，讀取的時候只要每次讀8個字元就能知道每個字元的二進位制值啦。

在這裡，[`每一位0或者1所佔的空間單位為bit(位元)]，這是計算機中最小的表示單位。每8個bit組成一個位元組，這是計算機最小的儲存單位。

    bit                 位，計算機中最小的表示單位
    8bit = 1bytes       位元組，最小的儲存單位，1bytes縮寫為1B
    1KB = 1024KB
    1MB = 1024KB
    1GB = 1024MB
    1TB = 1024GB
    1PB = 1024TB
    ......

那麼，到了現在學完了ASCII碼，作為一名英文程式設計師來說，基本是圓滿了，但是作為一名中國程式設計師，是不是覺得還少了點什麼？

GBK和GB2312

很顯然，對於我們來說，能在計算機中顯示中文才是最重要的，可是在剛才ASCII表裡連一個偏旁部首都沒有。所以我們需要一張關於中文和數字對應的關係表。之前我們看到，1個位元組最多表示256個字元，要處理中文顯然一個位元組是不夠的，所以我們需要採用2個位元組來表示，而且還不能和ASCII編碼衝突，所以中國製訂了GB2312編碼，用來把中文編進去。

那麼此時，又出現了問題：全世界由一百多種語言，當國外某個遊戲或者電影引到中國來時，那麼編碼需要怎麼處理？

Unicode

因此，Unicode應運而生，Unicode把所有語言都統一到一套編碼裡，這樣就不會再有亂碼問題了。

Unicode標準也在不斷髮展，但最常用的是用兩個位元組表示一個字元（如果要用到非常偏僻的字元，就需要4個位元組）。現代作業系統和大多數程式語言都直接支援Unicode。
現在，捋一捋ASCII編碼和Unicode編碼的區別：

ASCII編碼是1個位元組，而Unicode編碼通常是2個位元組。

字母A用ASCII編碼是十進位制的65，二進位制的01000001；

字元0用ASCII編碼是十進位制的48，二進位制的00110000；

漢字“中”已經超出了ASCII編碼的範圍，用Unicode編碼是十進位制的20013，二進位制的01001110 00101101。

你可以猜測，如果把ASCII編碼的A用Unicode編碼，只需要在前面補0就可以，因此，A的Unicode編碼是00000000 01000001。

新的問題又出現了，如果都改成Unicode編碼的話，亂碼問題就會消失，那麼隨之而來的就是：如果你寫的文字基本上都是英文的話，用Unicode編碼要比ASCII編碼需要多一倍的空間，在儲存和傳輸上就十分不划算了。

UTF-8

所以，本著節約的精神，又出現了把Unicode編碼轉化為“可變長編碼”的UTF-8編碼。UTF-8編碼把一個Unicode字元根據不同的數字大小編碼成1-6個位元組，常用的英文字母被編碼成1個位元組，漢字通常是3個位元組，只有很生僻的字元才會被編碼成4-6個位元組。如果你要傳輸的文字包含大量英文字元，用UTF-8編碼就能節省空間：

    字元  ASCII           Unicode                 UTF-8
    A          01000001     00000000 01000001              01000001
    中              x        01001110 00101101       11100100 10111000 10101101

從上圖來看，UTF-8編碼有一個額外的好處，就是ASCII編碼實際上可以看作為UTF-8的一部分，所以，大量只支援ASCII編碼的歷史遺留軟體可以在UTF-8編碼下繼續工作。

搞清楚了ASCII和、Unicode和UTF-8的區關係，可以總結一下計算機系統通用的字元編碼工作方式：
在計算機記憶體中，統一使用Unicode編碼，當需要儲存到硬碟或者是需要傳輸的時候，就轉換為UTF-8編碼；

用記事本編輯的時候，從檔案讀取的UTF-8字元被轉換成Unicode字元到記憶體裡，編輯完成後，儲存的時候再把Unicode轉換成UTF-8儲存到檔案；

• windows預設是GBK
• MacOSLinux預設為UTF-8

• Python2編碼為ASCII
• Python3編碼為UTF-8

基本資料型別-數字

布林型

bool型只有兩個值：True和False

之所以將bool值歸類為數字，是因為我們也習慣用1表示True，0表示False

整型

Python中的整數屬於int型別，預設用十進位制表示，此外也支援二進位制，八進位制,十六進位制表示方式。

進位制轉換

雖然計算機只認識二進位制，但是為了迎合我們的習慣，python的數字預設還是十進位制。還提供了一些方法來幫助我們做轉換，比如是進位制轉換為二進位制使用[`bin] 方法，在轉換結果面前還會加上0b表示是一個二進位制的數。

>>> num = 132
>>> bin(num)
`0b10000100`

既然十進位制可以轉換為二進位制，那麼其實使用同樣的原理也可以轉換為其他進位制，python也為我們提供了十進位制轉換成八進位制和十六進位制的方法，分別是oct和hex。八進位制前面以0o表示 ，十六進位制以0表示

>>> num = 129
>>> oct(num)
`0o201`
>>> hex(num)
`0x81`

取餘運算

>>> 16%5
1

divmod

>>> divmod(16,3)
(5, 1)          #5為商，1為餘數

浮點型

浮點數是屬於有理數中某特定子集的數的數字表示，在計算機中用以近似表示任意某個實數。具體的說，這個實數由一個整數或定點數（即尾數）乘以某個基數（計算機中通常是2）的整數次冪得到，這表示方法類似於基數為10的科學計數法。

python的浮點數就是數學中的小數(有限小數和無限迴圈小數)

在運算中，整數與浮點數運算的結果也是一個浮點數

為什麼要用浮點數

浮點數也就是小數，之所以稱為浮點數，是因為按照科學記數法表示時，
一個浮點數的小數點位置是可變的，比如，
1.23×109和12.3×108是相等的。
浮點數可以用數學寫法，如1.23，3.14，-9.01，等等。但是對於很大或很小的浮點數，就必須用科學計數法表示，把10用e替代：
1.23*109就是1.23e9，或者12.3e8，0.000012可以寫成1.2e-5，等等。
整數和浮點數在計算機內部儲存的方式是不同的，整數運算永遠是精確的而浮點數運算則可能會有四捨五入的誤差。

關於小數不精準問題

python預設是17位精準度，也就是小數點的後16位，儘管有16位，但這個精確度還是越往後越不準的。

首先，這個問題不是隻存在在python中，其他語言也有同樣的問題

其次，小數不精準是因為在轉換成二進位制的過程中會出現無限迴圈的情況，在約省的時候就會出現偏差。

比如：11.2的小數部分0.2轉換為2進位制則是無限迴圈的00110011001100110011…

單精度在儲存的時候用23bit來存放這個尾數部分（前面9位元儲存指數和符號）；同樣0.6也是無限迴圈的；

這裡有一個問題，就是當我們的計算需要更高的精度(超過16位數)的情況下怎麼做呢？

#這裡需要藉助decimal模組的getcontext()和Decimal()方法
>> a = 3.141592653513651054608317828332
>>> a
3.141592653513651
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec = 50      #將小數點後的尾數修改到50
>>> a = Decimal(1)/Decimal(3)   #在分數計算中結果正確，如果直接定義超長精度小數不會準確
>>> a
Decimal(`0.33333333333333333333333333333333333333333333333333`)
>>> a = 3.141592653513651054608317828332
>>> a
3.141592653513651
>>> Decimal(a)
Decimal(`3.141592653513650912344701282563619315624237060546875`)

複數

複數complex是由實數和虛陣列成的。

要了解複數，其實關於複數還需要先了解虛數。虛數(就是虛假不實的數):平方為複數的數叫做虛數。

複數是指能寫成如下形式的數a+bi，這裡a和b是實數，i是虛數單位(即-1開根)。在複數a+bi中，a稱為複數的實部，b稱為複數的虛部(虛數是指平方為負數的數)，i稱為虛數單位。

當虛部等於零時，這個複數就是實數；當虛部不等於零時，這個複數稱為虛數。

注，虛數部分的字母j大小寫都可以。

基本資料型別-字串

字串的定義和建立

字串是一個有序的字元的集合，用於儲存和表示基本的文字資訊，“或“”或“”“中間包含的記憶體稱之字串

建立：

s = `Hello XiaoYafei！Hello Python!`

字串的特性與常用操作

特性

1.按照從左往右的順序定義字符集合，下表從0開始順序訪問，有序

    str      =           hello
    索引                 01234

補充：
1.字串的單引號和雙引號都無法取消特殊字元的含義，如果想讓引號內所有字元均取消特殊意義，在引導前面新增r，如：
python name = r`pytho n`

• 使用ctrl加上滑鼠左鍵可以檢視原始碼

class str(object):
    """
    str(object=``) -> str
    str(bytes_or_buffer[, encoding[, errors]]) -> str
    
    Create a new string object from the given object. If encoding or
    errors is specified, then the object must expose a data buffer
    that will be decoded using the given encoding and error handler.
    Otherwise, returns the result of object.__str__() (if defined)
    or repr(object).
    encoding defaults to sys.getdefaultencoding().
    errors defaults to `strict`.
    """
    def capitalize(self): # real signature unknown; restored from __doc__
        """
        S.capitalize() -> str
        
        Return a capitalized version of S, i.e. make the first character
        have upper case and the rest lower case.
        """
        return ""

    def casefold(self): # real signature unknown; restored from __doc__
        """
        S.casefold() -> str
        
        Return a version of S suitable for caseless comparisons.
        """
        return ""

    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.center(width[, fillchar]) -> str
        
        Return S centered in a string of length width. Padding is
        done using the specified fill character (default is a space)
        """
        return ""

    def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.count(sub[, start[, end]]) -> int
        
        Return the number of non-overlapping occurrences of substring sub in
        string S[start:end].  Optional arguments start and end are
        interpreted as in slice notation.
        """
        return 0

    def encode(self, encoding=`utf-8`, errors=`strict`): # real signature unknown; restored from __doc__
        """
        S.encode(encoding=`utf-8`, errors=`strict`) -> bytes
        
        Encode S using the codec registered for encoding. Default encoding
        is `utf-8`. errors may be given to set a different error
        handling scheme. Default is `strict` meaning that encoding errors raise
        a UnicodeEncodeError. Other possible values are `ignore`, `replace` and
        `xmlcharrefreplace` as well as any other name registered with
        codecs.register_error that can handle UnicodeEncodeErrors.
        """
        return b""

    def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.endswith(suffix[, start[, end]]) -> bool
        
        Return True if S ends with the specified suffix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        suffix can also be a tuple of strings to try.
        """
        return False

    def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
        """
        S.expandtabs(tabsize=8) -> str
        
        Return a copy of S where all tab characters are expanded using spaces.
        If tabsize is not given, a tab size of 8 characters is assumed.
        """
        return ""

    def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.find(sub[, start[, end]]) -> int
        
        Return the lowest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Return -1 on failure.
        """
        return 0

    def format(self, *args, **kwargs): # known special case of str.format
        """
        S.format(*args, **kwargs) -> str
        
        Return a formatted version of S, using substitutions from args and kwargs.
        The substitutions are identified by braces (`{` and `}`).
        """
        pass

    def format_map(self, mapping): # real signature unknown; restored from __doc__
        """
        S.format_map(mapping) -> str
        
        Return a formatted version of S, using substitutions from mapping.
        The substitutions are identified by braces (`{` and `}`).
        """
        return ""

    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.index(sub[, start[, end]]) -> int
        
        Return the lowest index in S where substring sub is found, 
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Raises ValueError when the substring is not found.
        """
        return 0

    def isalnum(self): # real signature unknown; restored from __doc__
        """
        S.isalnum() -> bool
        
        Return True if all characters in S are alphanumeric
        and there is at least one character in S, False otherwise.
        """
        return False

    def isalpha(self): # real signature unknown; restored from __doc__
        """
        S.isalpha() -> bool
        
        Return True if all characters in S are alphabetic
        and there is at least one character in S, False otherwise.
        """
        return False

    def isdecimal(self): # real signature unknown; restored from __doc__
        """
        S.isdecimal() -> bool
        
        Return True if there are only decimal characters in S,
        False otherwise.
        """
        return False

    def isdigit(self): # real signature unknown; restored from __doc__
        """
        S.isdigit() -> bool
        
        Return True if all characters in S are digits
        and there is at least one character in S, False otherwise.
        """
        return False

    def isidentifier(self): # real signature unknown; restored from __doc__
        """
        S.isidentifier() -> bool
        
        Return True if S is a valid identifier according
        to the language definition.
        
        Use keyword.iskeyword() to test for reserved identifiers
        such as "def" and "class".
        """
        return False

    def islower(self): # real signature unknown; restored from __doc__
        """
        S.islower() -> bool
        
        Return True if all cased characters in S are lowercase and there is
        at least one cased character in S, False otherwise.
        """
        return False

    def isnumeric(self): # real signature unknown; restored from __doc__
        """
        S.isnumeric() -> bool
        
        Return True if there are only numeric characters in S,
        False otherwise.
        """
        return False

    def isprintable(self): # real signature unknown; restored from __doc__
        """
        S.isprintable() -> bool
        
        Return True if all characters in S are considered
        printable in repr() or S is empty, False otherwise.
        """
        return False

    def isspace(self): # real signature unknown; restored from __doc__
        """
        S.isspace() -> bool
        
        Return True if all characters in S are whitespace
        and there is at least one character in S, False otherwise.
        """
        return False

    def istitle(self): # real signature unknown; restored from __doc__
        """
        S.istitle() -> bool
        
        Return True if S is a titlecased string and there is at least one
        character in S, i.e. upper- and titlecase characters may only
        follow uncased characters and lowercase characters only cased ones.
        Return False otherwise.
        """
        return False

    def isupper(self): # real signature unknown; restored from __doc__
        """
        S.isupper() -> bool
        
        Return True if all cased characters in S are uppercase and there is
        at least one cased character in S, False otherwise.
        """
        return False

    def join(self, iterable): # real signature unknown; restored from __doc__
        """
        S.join(iterable) -> str
        
        Return a string which is the concatenation of the strings in the
        iterable.  The separator between elements is S.
        """
        return ""

    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.ljust(width[, fillchar]) -> str
        
        Return S left-justified in a Unicode string of length width. Padding is
        done using the specified fill character (default is a space).
        """
        return ""

    def lower(self): # real signature unknown; restored from __doc__
        """
        S.lower() -> str
        
        Return a copy of the string S converted to lowercase.
        """
        return ""

    def lstrip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.lstrip([chars]) -> str
        
        Return a copy of the string S with leading whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

    def maketrans(self, *args, **kwargs): # real signature unknown
        """
        Return a translation table usable for str.translate().
        
        If there is only one argument, it must be a dictionary mapping Unicode
        ordinals (integers) or characters to Unicode ordinals, strings or None.
        Character keys will be then converted to ordinals.
        If there are two arguments, they must be strings of equal length, and
        in the resulting dictionary, each character in x will be mapped to the
        character at the same position in y. If there is a third argument, it
        must be a string, whose characters will be mapped to None in the result.
        """
        pass

    def partition(self, sep): # real signature unknown; restored from __doc__
        """
        S.partition(sep) -> (head, sep, tail)
        
        Search for the separator sep in S, and return the part before it,
        the separator itself, and the part after it.  If the separator is not
        found, return S and two empty strings.
        """
        pass

    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
        """
        S.replace(old, new[, count]) -> str
        
        Return a copy of S with all occurrences of substring
        old replaced by new.  If the optional argument count is
        given, only the first count occurrences are replaced.
        """
        return ""

    def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.rfind(sub[, start[, end]]) -> int
        
        Return the highest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Return -1 on failure.
        """
        return 0

    def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.rindex(sub[, start[, end]]) -> int
        
        Return the highest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Raises ValueError when the substring is not found.
        """
        return 0

    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.rjust(width[, fillchar]) -> str
        
        Return S right-justified in a string of length width. Padding is
        done using the specified fill character (default is a space).
        """
        return ""

    def rpartition(self, sep): # real signature unknown; restored from __doc__
        """
        S.rpartition(sep) -> (head, sep, tail)
        
        Search for the separator sep in S, starting at the end of S, and return
        the part before it, the separator itself, and the part after it.  If the
        separator is not found, return two empty strings and S.
        """
        pass

    def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.rsplit(sep=None, maxsplit=-1) -> list of strings
        
        Return a list of the words in S, using sep as the
        delimiter string, starting at the end of the string and
        working to the front.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified, any whitespace string
        is a separator.
        """
        return []

    def rstrip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.rstrip([chars]) -> str
        
        Return a copy of the string S with trailing whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

    def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.split(sep=None, maxsplit=-1) -> list of strings
        
        Return a list of the words in S, using sep as the
        delimiter string.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified or is None, any
        whitespace string is a separator and empty strings are
        removed from the result.
        """
        return []

    def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
        """
        S.splitlines([keepends]) -> list of strings
        
        Return a list of the lines in S, breaking at line boundaries.
        Line breaks are not included in the resulting list unless keepends
        is given and true.
        """
        return []

    def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.startswith(prefix[, start[, end]]) -> bool
        
        Return True if S starts with the specified prefix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        prefix can also be a tuple of strings to try.
        """
        return False

    def strip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.strip([chars]) -> str
        
        Return a copy of the string S with leading and trailing
        whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

    def swapcase(self): # real signature unknown; restored from __doc__
        """
        S.swapcase() -> str
        
        Return a copy of S with uppercase characters converted to lowercase
        and vice versa.
        """
        return ""

    def title(self): # real signature unknown; restored from __doc__
        """
        S.title() -> str
        
        Return a titlecased version of S, i.e. words start with title case
        characters, all remaining cased characters have lower case.
        """
        return ""

    def translate(self, table): # real signature unknown; restored from __doc__
        """
        S.translate(table) -> str
        
        Return a copy of the string S in which each character has been mapped
        through the given translation table. The table must implement
        lookup/indexing via __getitem__, for instance a dictionary or list,
        mapping Unicode ordinals to Unicode ordinals, strings, or None. If
        this operation raises LookupError, the character is left untouched.
        Characters mapped to None are deleted.
        """
        return ""

    def upper(self): # real signature unknown; restored from __doc__
        """
        S.upper() -> str
        
        Return a copy of S converted to uppercase.
        """
        return ""

    def zfill(self, width): # real signature unknown; restored from __doc__
        """
        S.zfill(width) -> str
        
        Pad a numeric string S with zeros on the left, to fill a field
        of the specified width. The string S is never truncated.
        """
        return ""

常見操作

字串是不可變的？

>>> a = `xiaoyafei`     #變數的複製，即是將這個變數指向記憶體空間中的地址
>>> id(a)               #檢視到此時變數a的空間地址
139742341438256     
>>> a = `xiaobaba`         #對a進行修改
>>> id(a)                   #再次檢視變數a的空間地址
139742341436848

為什麼說字串是不可變的呢？我們可以很清晰的看到變數a兩次的空間地址並不一樣，是因為在我們修改時，把a指向了另一個記憶體空間地址，而xiaoyafei這個值將會被垃圾回收

swapcase() 小寫變大寫，大寫變小寫

>>> str = `Hello World`
>>> str.swapcase()
`hELLO wORLD`

capitalize() 首字母大寫，其餘全變成小寫

>>> str = `helLo WORLD`
>>> str.capitalize()
`Hello world`

casefold() 把大寫都全部換成小寫

>>> str = `HELLO WORLD!`
>>> str.casefold()
`hello world!`

center() 返回字串在中間，兩邊以字元填充

>>> str = `hello world`
>>> str.center(50,`*`)
`*******************hello world********************`

count() 統計字元出現的次數

>>> str = `abcdfdawadsqasacsasasaa`
>>> str.count(`a`)
9
#也可以指定從哪開始到哪結束
>>> str.count(`a`,0,10)
3

endswith() 判斷是否以某字串結尾，返回True或False

>>> str = `hello world!python`
>>> str.endswith(`python`)
True
>>> str.endswith(`hello`)
False

expandtabs() 擴充套件tab鍵

>>> a = `a	b`
>>> a
`a	b`
>>> print(a)
a       b
>>> a.expandtabs(20)
`a                   b`

find() 查詢，找到則返回索引，找不到則返回-1

>>> name = `xiaoyafei`
>>> name.find(`o`)
3
>>> name.find(`g`)
-1
#也可以規定搜尋範圍
>>> name.find(`a`,4,9)
5

format() 格式化字串

>>> info = `my name is {0},i am {1} years old.`
>>> info.format(`xiaoyafei`,22)
`my name is xiaoyafei,i am 22 years old.`
#也可以使用變數
>>> info = `my name is {name},my age is {age}.`
>>> info.format(name = `xiaoyafei`,age=22)
`my name is xiaoyafei,my age is 22.`

index() 返回索引值，找不到則報錯

>>> s = `hello tairan and welcome!`
>>> s.index(`t`)
6
>>> s.index(`g`)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
#也可以根據開始和終止位置查詢
>>> s
`hello tairan and welcome!`
>>> s.index(
... `a`)
7

isalnum() 判斷是不是阿拉伯字元（數字和字母）

>>> a = `123abc`
>>> a.isalnum()
True
>>> b = `123!abc`
>>> b.isalnum()
False

isalpha() 判斷是否只包含字木，不包含數字

>>> a = `abc123`
>>> a.isal
a.isalnum(  a.isalpha(  
>>> a.isalpha()
False
>>> b = `abcdefg`
>>> b.isalpha()
True

decimal() 判斷是否是整數

>>> a = `111`
>>> a.isdecimal()
True
#第二種方法
>>> a.isdigit()
True

isidentifier() 判斷字串的值是不是可以使用的變數名

>>> a = `111`
>>> a.isidentifier()
False           #數字不能作為變數名
>>> b = `Menu`
>>> b.isidentifier()
True

islower() 判斷字串是不是都是小寫

>>> str = `HelloWorld`
>>> str.islower()
False
>>> str2 = `helloworld`
>>> str2.islower()
True

isnumeric() 判斷是不是隻有數字在裡面

>>> a = `1233`
>>> a.isnumeric()
True
>>> b = `abc123`
>>> b.isnumeric()
False

isspace() 判斷是不是空格

>>> a = ` `
>>> a.isspace()
True

title() 變成title，即每一個單詞的首字母都是大寫

>>> str = `hello world python tairan `
>>> str.title()
`Hello World Python Tairan `

upper() 將字串全部轉換成大寫
python >> namew = `xiaoyafei` >> namew.upper() `XIAOYAFEI`
join() 把列表變成字串後，以指定的字串來區分列表裡的元素

>>> names = [`lipeng`,`likun`,`lipeng`]
>>> str = `---`
>>> str.join(names)
`lipeng---likun---lipeng`

ljust() 從左邊開始，總長度不夠的話用指定的字元去代替

>>> name = `xiaoyafei`
>>> name.ljust(50,`_`)
`xiaoyafei_________________________________________`

lower() 把字串都變成小寫

>>> name = `XIAOYAFEI`
>>> name.lower()
`xiaoyafei`

strip() 去除兩邊的空格和換行

>>> str = `
 hello world              `
>>> str.strip()
`hello world`
# lstrp只去左邊不去右邊
# rstrip只去右邊不去左邊

maketrans() 密碼錶

>>> str_in = `1234567890`       #這個為原本的
>>> str_out = `!@#$%^&*()`        #這個是輸出後的
>>> table = str.maketrans(str_in,str_out)       #將兩張表進行對應關係
>>> s = `572428582`         #重新輸入的
>>> s.translate(table)      #輸出後的密碼錶
`%&@$@*%*@`

partition() 把整個字串以自己想要的進行切割

>>> str
`hello world`
>>> str.partition(`o`)
(`hell`, `o`, ` world`)

replace() 替換，預設全部更換掉

>>> s = `hello world,hello tairan`
>>> s.replace(`llo`,`LLO`)
`heLLO world,heLLO tairan`
#只更換一次
>>> s
`hello world,hello tairan`
>>> s.replace(`llo`,`LLO`,1)
`heLLO world,hello tairan`

rsplit() 從右邊開始將字串以指定的字元切割

> s
`hello world,hello tairan`
>>> s.rsplit(`o`)
[`hell`, ` w`, `rld,hell`, ` tairan`]

splitlines() 按行來分，格式為列表

>>> str = `a
b
c
d
`
>>> str.splitlines()
[`a`, `b`, `c`, `d`]

startswith() 判斷以指定字元開始

>>> str
`hello,xiaoyafei`
>>> str.startswith(`hel`)
True

zfill() 從左開始，以指定字元代替，（右邊為原字串）

>>> str = `hello tairan`
>>> str.zfill(50)
`00000000000000000000000000000000000000hello tairan`

基本資料型別-列表

列表的定義和建立

定義：[ ]內以逗號分隔，按照索引，存放各種資料型別，每一個位置代表一個元素

列表的建立

list_test = [`張三`,`李四`,`xiaoyafei`,22]
或
list_test = list([`zhangsan`,`lisi`,`wanger`])

列表的特點

特徵：

• 可存放多個值
• 按照從左到右的順序定義列表元素，下標從0開始順序訪問，有序

    list    =       [`張三`,`李四`,`校長`]
    索引                0      1      2

• 可以修改指定索引的值，可變

列表的常見操作

這裡用了不同的列表，請注意檢視！

append() 追加一個元素在列表的最後

>>> list = [`xiaoyafei`]
>>> list.append(`lipeng`)
>>> list
[`xiaoyafei`, `lipeng`]

切片

#切下表為2到下標為4的元素，顧頭不顧尾
>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list[2:5]
[`zhangsan`, `lisi`, `wanger`]

#切下表為2到最後的元素，顧頭也顧尾
>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list[2:]
[`zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]

#切從第一個到最後一個
>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list[:]
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]

#切最後兩個，顧頭也顧尾
>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list[-2:]
[`zhaoliu`, `likun`]

# 步長語句，只切下表為奇數
>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list[::2]
[`xiaoyafei`, `zhangsan`, `wanger`, `zhaoliu`]

count() 檢視存在多少相同的元素

>>> list1
[2, 2, 3, 4, 1, 2]
>>> list1.count(2)
3
>>> list2 = [`lipeng`,`likun`,`lipeng`,`weiwenwu`,`lihang`,`lisiru`,`lipeng`]
>>> list2.count(`lipeng`)
3

index() 獲取元素的下標

>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list.       #tab鍵
list.__add__(           list.__dir__(           list.__getattribute__(  list.__imul__(          list.__lt__(            list.__reduce_ex__(     list.__setitem__(       list.clear(             list.insert(            
list.__class__(         list.__doc__            list.__getitem__(       list.__init__(          list.__mul__(           list.__repr__(          list.__sizeof__(        list.copy(              list.pop(               
list.__contains__(      list.__eq__(            list.__gt__(            list.__iter__(          list.__ne__(            list.__reversed__(      list.__str__(           list.count(             list.remove(            
list.__delattr__(       list.__format__(        list.__hash__           list.__le__(            list.__new__(           list.__rmul__(          list.__subclasshook__(  list.extend(            list.reverse(           
list.__delitem__(       list.__ge__(            list.__iadd__(          list.__len__(           list.__reduce__(        list.__setattr__(       list.append(            list.index(             list.sort(              
>>> list.index(`lipeng`)
1

獲取指定下標的值

>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list[2]
`zhangsan`

insert() 插入一個元素

>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
# 在下表為3的元素前插入一個元素
>>> list.insert(3,`xixihaha`)
>>> list
[`xiaoyafei`, `lipeng`, `zhangsan`, `xixihaha`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]

列表的修改

>>> list2
[`lipeng`, `likun`, `lipeng`, `weiwenwu`, `lihang`, `lisiru`, `lipeng`]
>>> list2[2] = `xixihaha`
>>> list2
[`lipeng`, `likun`, `xixihaha`, `weiwenwu`, `lihang`, `lisiru`, `lipeng`]

# 想要連續修改或者批量修改，可以使用切片，因為會把字串拆掉，不夠的話會自動建立
>>> list
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`, `wanger`, `mazi`, `zhaoliu`, `likun`]
>>> list[5:] = `xixihaha`
>>> list
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`, `x`, `i`, `x`, `i`, `h`, `a`, `h`, `a`]

pop() 刪除列表的最後一個元素

>>> list2
[`lipeng`, `likun`, `xixihaha`, `weiwenwu`, `lihang`, `lisiru`]
>>> list2.pop()
`lisiru`        #會把刪除的東西列印出來
>>> list2
[`lipeng`, `likun`, `xixihaha`, `weiwenwu`, `lihang`]

remove() 刪除指定元素

>>> list2
[`lipeng`, `likun`, `xixihaha`, `weiwenwu`, `lihang`]
>>> list2.remove(`likun`)       #刪除元素不會列印
>>> list2
[`lipeng`, `xixihaha`, `weiwenwu`, `lihang`]

# 也可以使用del
>>> list2
[`lipeng`, `xixihaha`, `weiwenwu`, `lihang`]
>>> del list2[1]
>>> list2
[`lipeng`, `weiwenwu`, `lihang`]

# 批量刪除
>>> list
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`, `x`, `i`, `x`, `i`, `h`, `a`, `h`, `a`]
>>> del list[5:]
>>> list
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`]

    pop()和remove()和del的區別：
        在於pop()函式刪完元素之後，會將刪除的元素列印出來，而remove()函式以及del不會列印
     

列表的迴圈

>>> list
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`]
>>> for i in list:
...   print(i)
... 
xiaoyafei
lipeng
xixihaha
xixihaha
lisi

    for和while的區別：
        while是可以支援死迴圈的，例如while True，而for迴圈是有邊界的

sort() 根據ASCII碼標表順序排序

# 有重複的元素，但是在排序時就去重了
>>> list3 = [`a`,`b`,`c`,`d`,`e`,`A`,`D`,`c`,`f`,`g`]
>>> list3.sort()        不會立馬就列印出來
>>> list3
[`A`, `D`, `a`, `b`, `c`, `c`, `d`, `e`, `f`, `g`]

reverse() 把整個列表倒過來

>>> list3
[`A`, `D`, `a`, `b`, `c`, `c`, `d`, `e`, `f`, `g`]
>>> list3.reverse()
>>> list3
[`g`, `f`, `e`, `d`, `c`, `c`, `b`, `a`, `D`, `A`]

把兩個列表進行相加

>>> list 
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`]
>>> list3
[`g`, `f`, `e`, `d`, `c`, `c`, `b`, `a`, `D`, `A`]
>>> list+list3
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`, `g`, `f`, `e`, `d`, `c`, `c`, `b`, `a`, `D`, `A`]

# 或者也可以使用extend()函式
>>> list
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`]
>>> list3
[`g`, `f`, `e`, `d`, `c`, `c`, `b`, `a`, `D`, `A`]
>>> list.extend(list3)      #同樣不會立馬列印出來
>>> list
[`xiaoyafei`, `lipeng`, `xixihaha`, `xixihaha`, `lisi`, `g`, `f`, `e`, `d`, `c`, `c`, `b`, `a`, `D`, `A`]

clear() 清空列表

>>> list3
[`g`, `f`, `e`, `d`, `c`, `c`, `b`, `a`, `D`, `A`]
>>> list3.clear()
>>> list3
[]

深拷貝和淺拷貝

這裡重新定義了列表！

# 把list複製給list3
>>> list
[`zhangsan`, `xiaoyafei`]
>>> list3 = list
>>> id(list)            #檢視到列表的ID號是一樣的
2661905413128
>>> id(list3)
2661905413128
>>> list[1] = `lidapeng`    #所以可以理解為這個列表是公用的
>>> list3
[`zhangsan`, `lidapeng`]
>>> list
[`zhangsan`, `lidapeng`]

讓我們首先來回顧下變數:

    name = `xiaoyafei`      #代表在記憶體中開闢一個新的空間用來存放這個值xiaoyafei,變數名為name
    name2 = name        #代表著name2指向了這個空間地址,這個空間地址的值是xiaoyafei
    >>> id(name)        #記憶體空間地址相同，即可證明這一點
    2292157129392
    >>> id(name2)
    2292157129392

那麼我們希望list能和list4分開，那麼我們就需要使用copy()函式：

# 此時的list和list2列表是完全獨立的
>>> list = [`zhangsan`,`lisi`]
>>> list
[`zhangsan`, `lisi`]
>>> list2 = list.copy()     #list呼叫copy()函式，copy給list2
>>> list2
[`zhangsan`, `lisi`]
>>> list[1] = `xiaoyafei`
>>> list2
[`zhangsan`, `lisi`]

# 檢視兩個列表的ID號
>>> id(list)
2661905413128
>>> id(list2)
2661906326600 

知識點2–淺copy

# 重新定義list和list2函式，然後使用append將list2新增到list中
>>> list = [`zhangsan`,`lisi`,`wangwu`]
>>> list2 = [`beijing`,`shanghai`,`guangzhou`]
>>> list.append(list2)
>>> list
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`, `guangzhou`]]

# 這個時候我們使用copy()函式
>>> list3 = list.copy()
>>> list3
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`, `guangzhou`]]
>>> id(list)        #檢視記憶體地址後發現是不一樣的，那麼我們對list進行修改的話，list3也會修改嗎？
1708042040328
>>> id(list3)
1708042953736

# 我們來修改測試一下
>>> list[1] = `xixihaha`        #對list列表下標為1的元素進行修改，發現 list3沒有繼續修改
>>> list
[`zhangsan`, `xixihaha`, `wangwu`, [`beijing`, `shanghai`, `guangzhou`]]
>>> list3
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`, `guangzhou`]]

# 讓我們再來修改一下看看
>>> list[3][0] = `珠海`
>>> list
[`zhangsan`, `xixihaha`, `wangwu`, [`珠海`, `shanghai`, `guangzhou`]]
>>> list3
[`zhangsan`, `lisi`, `wangwu`, [`珠海`, `shanghai`, `guangzhou`]]
# 奇怪的事情發生了，為什麼list3也會跟著修改呢？可剛剛我們測試的時候是沒有修改的啊

# 原因就是
>>> id(list[3])     #我們發現在列表中的子列表在記憶體中的空間地址是一模一樣的，難不成會跟著修改呢
1708042061768
>>> id(list3[3])
1708042061768

知識點3–深copy

# 在這裡，我們又重新定義了列表
>>> list = [`zhangsan`,`lisi`,`wangwu`]
>>> list2 = [`beijing`,`shanghai`]
>>> list.append(list2)
>>> list
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`]]

# 如果想使用深copy的話，需要匯入python的工具包copy
>>> list
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`]]
>>> import copy     #匯入python工具包
>>> list3 = copy.deepcopy(list)
>>> list3
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`]]
>>> id(list)
1255945745416
>>> id(list3)
1255948140680

# 讓我們來試一下
>>> list[1] = `xixihaha`        #對list列表下標為1的元素進行修改，發現list3並無修改
>>> list
[`zhangsan`, `xixihaha`, `wangwu`, [`beijing`, `shanghai`]]
>>> list3
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`]]

# 再來試一下
>>> list[3][0] = `珠海`
>>> list
[`zhangsan`, `xixihaha`, `wangwu`, [`珠海`, `shanghai`]]
>>> list3
[`zhangsan`, `lisi`, `wangwu`, [`beijing`, `shanghai`]]
那麼為什麼list3沒有隨著list的改變再修改呢？
原因看下面

深copy和淺copy的區別

• 淺copy不會重新建立記憶體地址，內容指向之前的空間地址，如果淺copy物件中有其他子物件，那麼在修改這個子物件的時侯子物件的內容就會改變
• 深copy就是新建一個物件重複分配空間地址，複製物件的內容

那麼我們可以理解成，在list這個列表中，存在著子列表，那麼我們對子列表之外的元素進行修改時，另一個物件不會去修改，但是在我們修改子列表的元素的時候，另一個列表就會跟著修改

基本資料型別-元組

元組的定義

與列表相似，只不過[]換成了()，我們一般稱元組為制度列表

元組的特徵

• 可存放多個值
• 不可變,元組本身不可變，但是如果元組還存放其餘可變型別的資料，則是可變的
• 按照從左到右的順序定義元組元素，下表從0開始順序訪問，有序

元組的用途

• 顯示的告知別人，此處資料不能修改
• 資料庫連線配置資訊等

元組的建立

    ages = (11,22,33,44,55)
    或
    ages = tuple(11,22,33,44,55)

元組的常見操作

索引

>>> ages = (11,22,33,44,55)
>>> ages[0]
11
>>> ages[3]
44

切片

>>> ages
(11, 22, 33, 44, 55)
>>> ages[1:2]
(22,)
>>> ages[1:]
(22, 33, 44, 55)
>>> ages[::2]
(11, 33, 55)

迴圈

>>> ages
(11, 22, 33, 44, 55)
>>> for i in ages:
...  print(i)
...
11
22
33
44
55

len() 長度

>>> ages
(11, 22, 33, 44, 55)
>>> len(ages)
5

in 包含

>>> ages
(11, 22, 33, 44, 55)
>>> 11 in ages
True

最後講解元組的修改

>>> ages
(11, 22, 33, 44, 55)
>>> ages[1] = `libaba`
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: `tuple` object does not support item assignment      #立馬報錯提示不能修改

可變、不可變資料型別和hash

    可變型別                不可變型別
    列表                      數字
                             字串
                             元組

我們看下什麼是可變什麼是不可變：

列表

>>> list =  [1,2,3,4]
>>> id(list)
1602240328712
>>> list.append(5)
>>> list
[1, 2, 3, 4, 5]
>>> id(list)
1602240328712

數字

>>> a = 1
>>> id(a)
1664904208
>>> a += 1
>>> a
2
>>> id(a)
1664904240

字串

# 示範 1
>>> str = `hello`
>>> str[1] = `a`
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: `str` object does not support item assignment
# 示範2
>>> str = `hello`
>>> id(str)
1602241176272
>>> str += ` world`
>>> str
`hello world`
>>> id(str)
1602241242992

元組

>>> tup = (1,2,3,4)
>>> tup[1] = 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: `tuple` object does not support item assignment

所以:可變不可變重要的區分在於記憶體空間地址是否發生改變

hash

• 就是將任意長度的字串，通過雜湊演算法，變成固定長度的輸出，該輸出就是雜湊值
• 這種轉換被稱為壓縮對映，雜湊值的空間通常遠小於輸入的空間，不同的輸入可能會雜湊成相同的輸出，所以不可能從雜湊值來卻東唯一輸入值
• 簡單的來說，就是將一種任意長度的訊息壓縮到固定長度的訊息摘要的函式

特徵

• hash值的計算過程是依據這個值的一些特徵進行計算的，要求被hash值是固定的，因此被hash是不可變的

用途

• 檔案簽名
• md5加密（無法反解）
• 密碼驗證

語法

>>> hash(`xiaoyafei`)
-1204730465301308513

基本資料型別-字典

字典的定義

字典是Python語言中唯一的對映型別。

>>> info = {
...     `stu1`:`zhangsan`,
...     `stu2`:`lisi`,
...     `stu3`:`wangwu`
... }

# 也可以使用另一種方法
>>> person = dict({`name`:`zhangsan`})

字典的特徵

• key-value結構
• key必須可hash,且必須為不可變型別必須唯一
• 可存放任意多個值可修改可以不唯一
• 無序

字典的常見操作

增加

>>> info
{`stu1`: `zhangsan`, `stu2`: `lisi`, `stu3`: `wangwu`}
>>> info[`stu4`] = `xixihaha`
>>> info
{`stu1`: `zhangsan`, `stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`}

修改

>>> info
{`stu1`: `zhangsan`, `stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`}
>>> info[`stu1`] = `student1`           #修改的是value
>>> info
{`stu1`: `student1`, `stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`}

集合去重

# 集合會自動去重
>>> s = {1,1,2,2,3,3,4,4}
>>> s
{1, 2, 3, 4}

將列表轉換成集合

>>> list = [1,2,3,4,5,6,7]
>>> s = set(list)
>>> s
{1, 2, 3, 4, 5, 6, 7}

in 查詢表示準語法

>>> info
{`stu1`: `student1`, `stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`}
>>> `stu1` in info
True

獲取value值,存在則返回,不存在不返回任何資訊

>>> info
{`stu1`: `student1`, `stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`}
>>> info.get(`stu1`)
`student1`

# 存在則返回,不存在則報錯
>>> info[`stu1`]
`student1`

pop() 刪除

>>> info
{`stu1`: `student1`, `stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`}
>>> info.pop(`stu1`)             #會返回刪除的資訊
`student1`
>>> info
{`stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`}

popitem() 隨機刪除,如果資料量足夠大那麼就是無序的

>>> info
{`stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`, `stu1`: `zhangsan`, `stu5`: `lihaha`}
>>> info.popitem()      
(`stu5`, `lihaha`)
>>> info.popitem()
(`stu1`, `zhangsan`)

丟棄discard

>>> s
{1, 2, 3, 4, 5, 6, 7}
>>> s.discard(6)
>>> s.discard(10)           #即使沒有也不會報錯

del 刪除

>>> person
{`name`: `zhangsan`}
>>> del person
>>> person
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name `person` is not defined

清空clear()

>>> s
{1, 2, 3, 4, 5, 7}
>>> s.clear()
>>> s
set()

列印所有key

>>> info
{`stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`, `stu5`: `lihaha`, `stu6`: `zhangsan`}
>>> info.keys()
dict_keys([`stu2`, `stu3`, `stu4`, `stu5`, `stu6`])

列印所有value

>>> info.values()
dict_values([`lisi`, `wangwu`, `xixihaha`, `lihaha`, `zhangsan`])

列印key和value變成元組,把字典轉成列表

>>> info
{`stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`, `stu5`: `lihaha`, `stu6`: `zhangsan`}
>>> info.items()
dict_items([(`stu2`, `lisi`), (`stu3`, `wangwu`), (`stu4`, `xixihaha`), (`stu5`, `lihaha`), (`stu6`, `zhangsan`)])

update 把兩個字典合併成一個字典,key有重複則覆蓋,沒有則新建

>>> info
{`stu2`: `lisi`, `stu3`: `wangwu`, `stu4`: `xixihaha`, `stu5`: `lihaha`, `stu6`: `zhangsan`}
>>> info2
{`stu2`: `北京`, `stu8`: `上海`, `stu9`: `廣州`}
>>> info.update(info2)
>>> info
{`stu2`: `北京`, `stu3`: `wangwu`, `stu4`: `xixihaha`, `stu5`: `lihaha`, `stu6`: `zhangsan`, `stu8`: `上海`, `stu9`: `廣州`}

setdefault建立,存在則不操作,不存在則建立

>>> info2
{`stu2`: `北京`, `stu8`: `上海`, `stu9`: `廣州`}
>>> info2.setdefault(2,`new2`)
`new2`
>>> info2
{`stu2`: `北京`, `stu8`: `上海`, `stu9`: `廣州`, 2: `new2`}

fromkeys 不會新增到原來字典當中,而是直接彈出

>>> info.fromkeys([`a`,`b`,`c`,`d`],[`xiaoyafei`])
{`a`: [`xiaoyafei`], `b`: [`xiaoyafei`], `c`: [`xiaoyafei`], `d`: [`xiaoyafei`]}

字典的迴圈

>>> info
{`stu2`: `北京`, `stu3`: `wangwu`, `stu4`: `xixihaha`, `stu5`: `lihaha`, `stu6`: `zhangsan`, `stu8`: `上海`, `stu9`: `廣州`}
>>> for i in info:
...     print(i,info[i])
...
stu2 北京
stu3 wangwu
stu4 xixihaha
stu5 lihaha
stu6 zhangsan
stu8 上海
stu9 廣州

# 還有一種方法,但是很低效,因為要把字典轉換成列表
>>> for k,v in info.items():
...     print(k,v)
...
stu2 北京
stu3 wangwu
stu4 xixihaha
stu5 lihaha
stu6 zhangsan
stu8 上海
stu9 廣州

集合

集合的建立

set = {`xiaozhang`,`laowang`,`dage`}
有人可能會說了著明明是一個字典,那我們用type()函式試一下
>>> set = {`xiaozhang`,`laowang`,`dage`}
>>> type(set)
結果為:class `set`>
原來當{}裡為空就是一個字典,如果有東西就是集合

由一個或者多個確定的元素所構成的整體叫做集合

集合中的元素由三個特徵

• 確定性(元素必須可hash)
• 互異性(去重)
• 無序性(集合中的元素沒有先後之分)

注意:集合存在的意義就是在於去重和關係運算

用過例子來說明關係運算

  自定義購買iphone7和iphone8的人
    i7 = {`xiaozhang`,`xiangwang`,`xiaoli`}
    i8 = {`xiaoli`,`laozhao`,`laowang`}

交集 intersection()

# 兩個都購買的人
>>> l_p  = i7&i8
>>> l_p
{`xiaoli`}

# 也可以使用
>>> i7
{`xiaoli`, `xiangwang`, `xiaozhang`}
>>> i8
{`xiaoli`, `laozhao`, `laowang`}
>>> i7.intersection(i8)
{`xiaoli`}

差集 difference()

# 只購買iphone7的人
>>> i7.difference(i8)
{`xiangwang`, `xiaozhang`}

# 只購買iphone8的人
>>> i8.difference(i7)
{`laowang`, `laozhao`}

並集 union()

# 購買iphone7和iphone8的人
>>> i7.union(i8)
{`laozhao`, `laowang`, `xiaozhang`, `xiaoli`, `xiangwang`}
>>> i8.union(i7)
{`laozhao`, `laowang`, `xiaozhang`, `xiaoli`, `xiangwang`}

# 也可以使用
>>> i7|i8
{`laozhao`, `laowang`, `xiaozhang`, `xiaoli`, `xiangwang`}

對稱差集,把不交集的地方取出來 symmetric_difference

# 可以理解為: 只買了i7和只買了i8的人
>>> i7 = {`xiaozhang`,`xiangwang`,`xiaoli`}
>>> i8 = {`xiaoli`,`laozhao`,`laowang`}
>>> i7.symmetric_difference(i8)
{`laowang`, `xiaozhang`, `xiangwang`, `laozhao`}

子集

# 可以理解成北京市是中國的子集,而中國是北京市的超集
>>> s = {1,2,3}
>>> s2 = {1,2,3,4,5,6}
>>> s.issubset(s2)
True

# 也可以使用
>>> s2>s
True

超集

>>> print(s,s2)
{1, 2, 3} {1, 2, 3, 4, 5, 6}
>>> s2.issuperset(s)
True

# 也可以使用
>>> s<s2
True

判斷兩個集合是不是不相交 isdisjoint()

>>> set1 = {1,2,3}
>>> set2 = {7,8,9}
>>> set1.isdisjoint(set2)
True

獲取差集並重新賦值給set1

>>> set1
{1, 2, 3, -1, -2}
>>> set2
{1, 2, 3, 7, 8, 9}
>>> set1.difference(set2)
{-1, -2}
>>> set1.difference_update(set2)
>>> set1
{-1, -2}
>>> set2
{1, 2, 3, 7, 8, 9}