Python數據類型

數據類型介紹

• 什么是數據

• 為何要數據分不同的類型

• 數據有哪些類型

• 五大數據類型基本划分

一、什么是數據

　　在計算機科學中，數據是指所有能輸入到計算機並被計算機程序處理的符號的介質的總稱，是用於輸入電子計算機進行處理，具有一定意義的數字字母、符號和模擬量等的統稱。現在計算機存儲和處理對象十分廣泛，表示這些對象的數據也隨之變得越來越復雜。

二、為何要數據分不同的類型

　　數據是用來表示狀態的，不同的狀態就應該用不同的類型的數據去表示

　　舉個例子：

　　在游戲當中你會有你的自己的人物、裝備、等級、金錢等等、這些都是數據，在Python中這些數據都有自己各自的類型。

　　例如用cs來說
　　名字：帝皇俠傳說------------------------>字符串
　　金錢：88888888 --------------------------------->數字
　　裝備：毀滅，閃光彈，防彈衣 --------->列表
　　擊殺數：999999 --------------------------------->數字
　　等等，還有很多其他類型的數據，處理不同類型的數據就需要定義不同的數據類型

　　數據結構的意義：

　　數據結構的意義：將上述五大數據類型整合到一起。但是摻到一起不是目的。目的是能夠組合成一個好的結構，方便自己或者他人進行數據存儲或者讀取。

三、數據有哪些類型

數字（整型，長整型，浮點，布爾，復數）

　　1.整數：根據字面的意思倆理解就沒有小數點的數

　　2.長整數：就是很長的整數

　　3.浮點型：就是帶小數點的數字

　　4.布爾型：True與False(1和0)

　　5.復數： 復數有實數部分和虛數部分組成，一般形式為x+yj，其中x是復數的實數部分，y是復數的虛數部分，這里的x和y都是實數

　　注意，虛數的大小寫字部分的字母j不分大小寫

字符串

　　在python如何定義一串字符為字符串呢？

　　用 " " 、' ' 、''' '''或者""" """。中間包含的部分稱之為字符串

　　注意：即使里面寫入的是數字，那么他的數據類型也是字符串；字符串是不可改變的

　　常見的字符串操作有：

　　移除空白、分隔、長度、索引、切片等等；

列表

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

　　常見的操作有：

　　增加、插入、刪除、查詢、切片、索引、長度等

元組

　　以'()'圓括號進行定義，與列表極其相似。也是序列類型 可以進行索引，切片，查詢，也可以進行遍歷

　　元組與列表的唯一區別則是不可改變

　　常見的操作有：

　　索引、切片、循環、長度、包含

字典

　　字典占用的內存空間將會大於列表，在系統中要保存一個hash列表(用系統內存換取時間)

　　字典屬於key:value 結合（key值是不可變的，value值可以變）並且是無序的

集合

　　定義：由不同的元素組成的集合，集合中是一組無序排列的可hash值，可作為字典的key，而且集合中的值不可重復。

　　特性：集合的目的就是將不同的值存放在一起，不同的集合間來做關系運算，無序糾結集合中單個值

　　集合包括可變集合和不可變集合

　　hash是什么？

　　打個比方，比如說有一個文件（不管多大），對這個文件要進行一個hash校驗，會得到一個校驗值（固定長度）。

hash是一種統稱，具體要進行校驗的話，是需要調用它下面的算法。(校驗就是通過一個算法算出這個文件的一個值)。

　　特點：

　　1.只要用的算法是一定，那么得到的值的長度永遠是一定的

　　2.原值（被校驗的值）只要改一點，那么在此校驗的值將會改變

　　3.不可逆。不可能通過一串hash值來推導出這個文件內容

　　算法：MD5 SH512等等

　　用途：最多的用途就是進文件校驗（看文件是否被篡改）。再一個就是tcp/ip協議。只能對不可變的值進行hash校驗。如果集合中有可變類型那么回保錯。

　　注意：

　　列表是不可hash類型；在python中，看到不可hash類型就是可變類型，反之，可hash類型就是不可變類型

數字類型

• 種類

• 數字類型的關系

• 數字類型轉換

• 數字運算

• 數學函數

• 隨機數函數

• 三角函數

• 數學常量

一、種類

整數型（int）

　　整數型定義上也可成短整型，理論上有范圍的限制，取值范圍為：在32位機器上int的范圍是:  -2**31～2**31-1，即-2147483648～2147483647

在64位機器上int的范圍是: -2**63～2**63-1，即-9223372036854775808～9223372036854775807，如果超過這個范圍就可以使用長整型，不過必須在結尾寫上大寫的“L”，小寫也可以，為了避免與1混淆，建議用L

　　需要注意的是：

　　上述中的int理論范圍取值是參考的C語言整數范圍。在實際的環境中，int范圍並沒有固定，我們用上述所說64位最大值乘1000測試一下；

　　實例如下：

>>> print(9223372036854775807 * 1000)
9223372036854775807000

　　我們發現並沒有出錯，實際上是因為發生溢出，Python3會自動將整數數據轉換為長整數！這點還是需注意的。

　　Python中的整數不僅可以用十進制表示，也可以用八進制和十六進制表示。

　　當用二進制表示整數時，數值前面要加上一個前綴【0b或0B】用來表示是二進制數據

　　當用八進制表示整數時，數值前面要加上一個前綴【0o或0O】用來表示是八進制數據

　　當用十六進制表示整數時，數字前面要加上一個前綴【0x或0X】用來表示是十六進制數據

　　例如：我們這里將整數15分別以八進制和十六進制和二進制的形式賦給整型變量a、b、c，然后再以十進制的形式輸出它們

字符串類型（str）

• 字符串說明

• 索引和切片

• 轉義字符

• 字符串運算符

• 字符串格式化

• 字符串內置的函數

一.字符串說明

　　字符串是 Python 中最常用的數據類型。我們可以使用引號('或")來創建字符串。

　　字符串是不可變的數據類型，不論執行任何操作，源字符串是不會改變的，每次操作都會返回新字符串；

　　創建字符串，只需要為變量賦值即可，如：Str = "hello world"

　　字符串在轉換成int時，如果字符串中的數字有空格，則在轉換時自動去除空格；

　　訪問字符串中的值：

　　Python 不支持單字符類型，單字符在 Python 中也是作為一個字符串使用。

>>> print("hello world")
hello world

　　字符串更新：

　　可以截取字符串的一部分並與其他字段拼接，如下實例：

>>> print("hello world" + " 你好，中國")
hello world 你好，中國

二、索引和切片

1.索引

　　說明：通過索引取出字符串對應的值

　　格式：str[下標]

　　參數：下標 ------ > 是一個int型數據，

　　索引從0開始，使用[下標]可以獲取到每一個字符，還可以倒着數，最后一個字符用-1表示，一次往前數是-1、-2...

　　返回值：返回字符串對應索引所對應的值；如果索引超出邊界則報錯

　　實例：

>>> s = "abcdefg"
>>> print(s[0])
a
>>> print(s[1])
b
>>> print(s[2])
c
>>> print(s[3])
d
>>> print(s[4])
e
>>> print(s[5])
f
>>> print(s[6])
g

----------------索引超出邊界，報錯---------------------------------

　>>> print(s[7])
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　IndexError: string index out of range

 

2.切片

　　說明：通過切片取出字符串的一段字符；

　　格式：str[起始位置:結束位置:步長]

　　參數：起始位置 --------> 表示從哪個下標開始

　　　　　結束位置 --------> 表示到哪個下標結束

　　　　　 步長 --------------> 默認從左到右，步長為1，也可以取反，表示倒敘，步長取負數

　　特點：顧頭不顧尾，從start開始截取. 截取到end位置. 但不包括end

　　返回值：返回一個由切片選擇好的子串；

　　實例：

>>> s = "abcdefg"
>>> print(s[:])
abcdefg
>>> print(s[0:4])
abcd
>>> print(s[2:6])
cdef
>>> print(s[:6:2])
ace
>>> print(s[1::2])
bdf
>>> print(s[::-1])
gfedcba
>>> print(s[-1:-3])

>>> print(s[-1:-3:-1])
gf
>>> print(s[-1::-2])
geca

三.轉義字符

　　在需要在字符中使用特殊字符時，python用反斜杠(\)轉義字符。如下表：

四.字符串運算符

下表實例變量a值為字符串 "Hello"，b變量值為 "Python"：

五.字符串格式化

　　Python 支持格式化字符串的輸出 。盡管這樣可能會用到非常復雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。

　　在 Python 中，字符串格式化使用與 C 中 sprintf 函數一樣的語法。

>>> print("中國的首都是%s" % ("北京"))
中國的首都是北京

　　python字符串格式化符號:

　　格式化操作符輔助指令:

六.字符串內置的函數

　　

 

　　1.capitalize(self)

　　說明：將字符串的第一個字符轉換為大寫，其他字母變成小寫；注意的是並不會改變原字符串內容；

　　語法：str.capitalize()

　　返回值：該方法返回一個首字母大寫的字符串；

　　實例：

>>> S = "hello WoRld"
>>> print(S.capitalize())
Hello world

 

　　2.casefold(self)

　　說明：將字符串中的所有大寫字符轉換為小寫字符；並支持識別東歐的一些字母；lower不支持東歐的字母；

　　語法：str.casefold()

　　返回值：返回將字符串中所有大寫字符轉換為小寫后生成的字符串；

　　實例：

>>> S = "hello WoRld"
>>> print(S.casefold())
hello world

 

　　3.center(self, width, fillchar=None)

　　說明：返回一個指定的寬度width且居中的字符串，字符串長度為width，fillchar為填充的字符，默認為空格；

　　語法：str.center(width,fillchar)

　　返回值：返回一個指定的寬度 width 居中的字符串，如果 width 小於字符串寬度直接返回字符串，否則使用 fillchar 去填充。

　　實例：

>>> print("今日頭條".center(40,"*"))
******************今日頭條******************

 

　　4.count(self, sub, start=None, end=None)

　　說明：用於統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置。

　　語法：str.count(sub,start=None, end=None)

　　參數：sub  -----> 要搜索的子字符串；

　　　　　start -----> 字符串開始搜索的位置。默認為第一個字符,第一個字符索引值為0;

　　　　　end ------> 字符串中結束搜索的位置。字符中第一個字符的索引為 0。默認為字符串的最后一個位置;

 　  返回值：返回子字符串在字符串中出現的次數；

　　實例：

>>> print(ss.count("a"))
2
>>> print(ss.count("a",0,8))
1

 

　　5.encode(self, encoding='utf-8', errors='strict')

　　說明：以指定的編碼格式來編碼字符串。errors參數可以指定不同的錯誤處理方案。

　　語法：str.encode(encoding='utf-8', errors='strict')

　　參數：encoding -----> 要使用的編碼，如：UTF-8

　　　　　errors -----> 設置不同錯誤的處理方案。默認為 'strict',意為編碼錯誤引起一個UnicodeError。 其他可能得值有 'ignore', 'replace', 　　　　　　　　　　   'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 注冊的任何值。

　　返回值：返回編碼后的字符串，是一個 bytes 對象

　　實例：

>>> abc = "燈火闌珊"
>>> abc_utf8 = abc.encode("UTF-8")
>>> abc_gbk = abc.encode("GBK")
>>> print(abc)
燈火闌珊
>>> print(abc_utf8)
b'\xe7\x81\xaf\xe7\x81\xab\xe9\x98\x91\xe7\x8f\x8a'
>>> print(abc_gbk)
b'\xb5\xc6\xbb\xf0\xc0\xbb\xc9\xba'

 

　　6.decode(self, decoding='utf-8', errors='strict')

　　說明：以指定的編碼格式來解碼字符串。errors參數可以指定不同的錯誤處理方案。

　　語法：bytes.decode(encoding="utf-8", errors="strict")

　　參數：encoding -----> 要使用的編碼，如：UTF-8

　　　　　errors -----> 設置不同錯誤的處理方案。默認為 'strict',意為編碼錯誤引起一個UnicodeError。 其他可能得值有 'ignore', 'replace', 　　　                                        'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 注冊的任何值。

　　返回值：返回解碼后的字符串；

　　實例：

>>> print(abc_gbk.decode("GBK"))
燈火闌珊
>>> print(abc_utf8.decode("UTF-8"))
燈火闌珊

 

　　7.endswith(self, suffix, start=None, end=None)

　　說明：用於判斷字符串是否以指定后綴結尾，如果以指定后綴結尾返回True，否則返回False；

　　語法：str.endswith(suffix,start=None, end=None)

　　參數：suffix -----> 該參數可以是一個字符串或者是一個元素；

　　　　    start ------> 字符串中的開始位置;

　　　　    end  ------> 字符中結束位置

　　返回值：如果字符串含有指定的后綴返回True，否則返回False；

　　實例：

>>> end = "hello world"
>>> print(end.endswith("ld"))
True
>>> print(end.endswith("ld",0,10))
False

 

　　8.expandtabs(self, tabsize=8)

　　說明：把字符串中的 tab 符號('\t')轉為空格，tab 符號('\t')默認的空格數是 8；

　　注意：規則是這樣的，如果設置空格數是8，則會從開頭查詢，每8個字符為一組，到有\t那組時，缺幾個就補幾個空格；

　　語法：str.expandtabs(tabsize=8)

　　參數：tabszie -----> 指定轉換字符串中的 tab 符號('\t')轉為空格的字符數；

　　返回值：返回字符串中的 tab 符號('\t')轉為空格后生成的新字符串；

　　實例：

>>> ss = "this is \tstring example"
>>> print(ss)
this is     string example
#this is 剛好8個，所以到\t這里自動在補8個空格；

>>> print(ss.expandtabs(0)) 

this is string example 
#0自動沒有

>>> print(ss.expandtabs(20)) 
this is             string example
#this is \t是8個，設置的是20空格，所以還需在補12個空格

 

　　9.find(self, sub, start=None, end=None)

　　說明：檢測字符串中是否包含子字符串 sub ，如果指定 start（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，如果指定范圍內如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。

　　語法：str.find(sub, start=None, end=None)

　　參數：sub ------> 指定檢索的字符串；

　　　　　start -----> 指定開始索引位置，默認為0

　　　　　end  -----> 指定結束索引位置，默認為字符串長度，len(str)

　　返回值：如果包含子字符串返回開始的索引值，否則返回-1；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.find("short"))
12
>>> print(str1.find("short",5,19))
12
>>> print(str1.find("short",17,19))
-1

 

　　10.format(self, *args, **kwargs)

　　說明：format函數用於字符串的格式化，通過{}和:來代替%；傳入的參數兩種形式，一種是位置參數，一種是關鍵字參數；位置參數不受順序約束，且可以為{},只要format里有相對應的參數值即可,參數索引從0開，傳入位置參數列表可用*列表，關鍵字參數值要對得上，可用字典當關鍵字參數傳入值，字典前加**即可，注意的是當位置參數和關鍵字參數混合使用時，位置參數一定要在關鍵字參數左邊。

　　語法：str.format( *args, **kwargs)

　　參數：*args ------> 當傳入的參數為列表時，可用*列表；

　　　　　**kwargs -------> 可用字典當關鍵字參數傳入值，字典前加**即可；

　　返回值：返回一個已經填充好的字符串。

　　例子：

------------------不設置指定位置，按默認順序--------------------------

>>> str2 = "中國的城市有,{},{},{},{}"
>>> print(str2.format("北京","上海","深圳","武安"))
中國的城市有,北京,上海,深圳,武安


----------------設置指定位置-------------------------------------------

>>> str2 = "中國的城市有,{3},{0},{2},{1}"
>>> print(str2.format("北京","上海","深圳","武安"))
中國的城市有,武安,北京,深圳,上海


------------------使用位置-列表形式---------------------------
>>> li = ["北京","上海","深圳","武安"]
>>> print(str2.format(*li))
中國的城市有,北京,上海,深圳,武安

-------------------使用關鍵字位置形式-------------------------
>>> print(str2.format(k2="北京",k3="上海",k1="深圳",k4="武安"}))
中國的城市有,深圳,北京,上海,武安

-------------------使用關鍵字位置字典形式-------------------------
>>> print(str2.format(**{"k2":"北京","k3":"上海","k1":"深圳","k4":"武安"}))
中國的城市有,深圳,北京,上海,武安


-------------------使用混合模式--------------------------------
>>> str2 = "中國的城市有,{3},{0},{2},{1},{h}"
>>> print(str2.format("北京","上海","深圳","武安",**{"h":"石家庄"}))
中國的城市有,武安,北京,深圳,上海,石家庄

　　也可以向.format()傳入對象：

class test():
    def __init__(self,asd):
        self.num = asd
ming = test(6)
print("ming的數字是：{0.num}".format(ming))
#{0.num}中的0是可選的表示指定位置

-------------------輸出結果為------------------------------

ming的數字是：6

　　.format()的數字格式化：

>>> print("{:.2f}".format(3.1415926))
3.14

　　下表展示了 str.format() 格式化數字的多種方法：

>>> print("{}對應的位置是{{0}}".format("zjk"))
zjk對應的位置是{0}

 

　　11.format_map(self, mapping)

　　說明：類似於format，不同的是format_map只能使用關鍵字位置形式傳入字典來進行；

　　語法：str.format_map(mapping)

　　參數：mapping -----> 必須是一個字典；

　　返回值：一個已經填充好的字符串；

　　實例：

>>> print("{name}對應的位置是{{0}}".format_map({"name":"zjk"}))
zjk對應的位置是{0}

 

　　12.index(self, sub, start=None, end=None)

　　說明：檢測字符串中是否包含子字符串 sub ，如果指定 start（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，該方法與 python find()方法一樣，只不過如果sub不在 str中則會報一個異常，而find則是返回-1；

　　語法：str.index(sub,start=None, end=None)

　　參數：sub ------> 指定檢索的子字符串；

　　　　　start -----> 指定開始索引位置，默認為0；

　　　　　end ------> 指定結束索引位置，默認為字符串的長度；

　　返回值：如果包含子字符串返回開始的索引值，否則拋出異常；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.index("short"))
12
>>> print(str1.index("short",14))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

 

　　13.isalnum(self)

　　說明：檢測字符串是否由字母和數字組成；

　　語法：str.isalnum()

　　返回值：如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True,否則返回 False

　　實例：

>>> str1 = "helloworld"
>>> print(str1.isalnum())
True
>>> str2 = "hello world"
>>> print(str2.isalnum())
False

 

　　14.isalpha(self)

　　說明：檢測字符串是否只由字母組成；

　　語法：str.isalpha()

　　返回值：如果字符串至少有一個字符並且所有字符都是字母則返回 True,否則返回 False；

　　實例：

>>> str1 = "python"
>>> print(str1.isalpha())
True
>>> str2 = "python3"
>>> print(str2.isalpha())
False

 

　　15.isdecimal(self)

　　說明：檢查字符串是否只包含十進制字符。這種方法只存在於unicode對象；注意:定義一個十進制字符串，只需要在字符串前添加 'u' 前綴即可。

　　語法：str.isdecimal()

　　返回值：如果字符串只包含十進制字符返回True，否則返回False

　　實例：

>>> str1 = u"zjk2018"
>>> print(str1.isdecimal())
False
>>> str2 = u"201807"
>>> print(str2.isdecimal())
True

 

　　16.isdigit(self)

　　說明：檢測字符串是否只由數字組成；

　　語法：str.isdigit()

　　返回值：如果字符串只包含數字則返回 True 否則返回 False；

　　實例：

>>> str1 = "zjk2018"
>>> print(str1.isdigit())
False
>>> str2 = "201807"
>>> print(str2.isdigit())
True

 

　　17.isidentifier(self)

　　說明：判斷是否為python中的標識符，也就是說是否符合python變量名語法；

　　語法：str.isidentifier()

　　返回值：如果字符串的內容符合python變量命名語法，則返回True，否則返回False；

　　實例：

>>> str1 = "zjk1"
True
>>> str2 = "666zjk"
>>> str2.isidentifier()
False
>>> str3 = "變量名"
>>> str3.isidentifier()
True
>>> str4 = "def"
>>> str4.isidentifier()
True
#python的關鍵字一樣是合法的
>>> str5 = "88888"
>>> str5.isidentifier()
False

 

　　18.islower(self)

　　說明：檢測字符串是否由小寫字母組成；

　　語法：str.islower()

　　返回值：如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False；

　　實例：

>>> str1 = "Life is too short for python -zjk23"
>>> print(str1.islower())
False
>>> str2 = "life is too short for python -zjk23"
>>> print(str2.islower())
True

 

　　19.isnumeric(self)

　　說明：檢測字符串是否只由數字組成。這種方法是只針對unicode對象；注：定義一個字符串為Unicode，只需要在字符串前添加 'u' 前綴即可；

　　語法：str.isnumeric()

　　返回值：如果字符串中只包含數字字符，則返回 True，否則返回 False

　　實例：

>>> str1 = "zjk1995"
>>> print(str1.isnumeric())
False
>>> str2 = "1995"
>>> print(str2.isnumeric())
True

 

　　20.isprintable(self)

　　說明：判斷是否由可打印字符組成，回車符等一些特殊字符是不會打印顯示在屏幕上的；

　　語法：str.isprintable()

　　返回值：如果字符串中所有內容都可打印則返回True，否則返回False；

　　實例：

>>> print("123\t4\t56".isprintable())
False
>>> print("123\\t456".isprintable())
True

 

　　21.isspace(self)

　　說明：檢測字符串是否只由空白字符組成；

　　語法：str.isspace()

　　返回值：如果字符串中只包含空格，則返回 True，否則返回 False；

　　實例：

>>> str1 = "    "
>>> print(str1.isspace())
True
>>> str2 = " sdf sdf"
>>> print(str2.isspace())
False

 

　　22.istitle(self)

　　說明：檢測字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫；

　　語法：str.istitle()

　　返回值：如果字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫則返回 True，否則返回 False；

　　實例：

>>> str1 = "Life Is Too Short For Python"
>>> print(str1.istitle())
True
>>> str2 = "Life is Too short For PyThon"
>>> print(str2.istitle())
False

 

　　23.isupper(self)

　　說明：檢測字符串中所有的字母是否都為大寫；

　　語法：str.isupper()

　　返回值：如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False；

　　實例：

>>> str1 = "LIFE IS TOO SHORT FOR PYTHON"
>>> print(str1.isupper())
True
>>> str2 = "LIFE Is TOO ShOrT FOR PYTHON"
>>> print(str2.isupper())
False

 

　　24.join(self, iterable)

　　說明：用於將序列中的元素以指定的字符連接生成一個新的字符串；

　　語法：n.join(iterable)

　　參數：iterable ------> 要連接的元素序列；

　　　　　n --------------> 指定用來連接的字符；

　　返回值：返回通過指定字符連接序列中元素后生成的新字符串；

　　實例：

>>> str1 = "zjk"
>>> print("-".join(str1))
z-j-k

 

　　25.ljust(self, width, fillchar=None)

　　說明：返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串；

　　語法：str.ljust(width, fillchar=None)

　　參數：width ------> 指定字符串長度；

　　　　　fillchar -----> 填充字符，默認為空格；

　　返回值：返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.ljust(20,"*"))
I Love You**********

------------當指定的填充長度小於原字符串長度時返回原字符串-------

>>> str2 = "I Love You"
>>> print(str1.ljust(10,"*"))
I Love You

 

　　26.lower(self)

　　說明：轉換字符串中所有大寫字符為小寫；

　　語法：str.lower()

　　返回值：返回將字符串中所有大寫字符轉換為小寫后生成的字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.lower())
i love you

 

　　27.lstrip(self, chars=None)

　　說明：用於截掉字符串左邊的空格或指定字符，貪婪模式；

　　語法：str.lstrip( chars=None)

　　參數：chars ------> 指定截取的字符；

　　返回值：返回截掉字符串左邊的空格或指定字符后生成的新字符串；

　　實例：

>>> str1 = "666666I66Love You"
>>> print(str1.lstrip("6"))
I66Love You

 

　　28.maketrans(self, *args, **kwargs)

　　說明：用於創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。兩個字符串的長度必須相同，為一一對應的關系；

　　語法：str.maketrans(intab,outtab)

　　參數：intab -------> 需要轉換的字符串；

　　　　　outtab -----> 被轉換的字符串；

　　返回值：返回的是一個字典，字典內容是字符串的ASCII碼的序號，一一對應

　　實例：

>>> dat = str.maketrans("123","abc")
>>> print(dat)
{49: 97, 50: 98, 51: 99}

-----------------解釋--------------------------
1 的ASCII碼為 49
a 的ASCII碼為 97

 

　　29.partition(self, sep)

　　說明：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　語法：str.partition(sep)

　　參數：sep ------> 指定分隔符

　　返回值：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　實例：

>>> str1 = "http://www.dhlanshan.cn"
>>> print(str1.partition("//"))
('http:', '//', 'www.dhlanshan.cn')

-----------如果指定的分隔符在字符串中有兩個，則以最左側為分隔符----------

>>> print(str1.partition("."))
('http://www', '.', 'dhlanshan.cn')

 

　　30.replace(self, old, new, count=None)

　　說明：將字符串中的某子串進行替換，默認替換指定的所有子串；

　　語法：str.replace(old, new, count=None)

　　參數：old ------> 舊的子串；

　　　　　new -----> 新的子串；

　　　　　count ----> 替換的次數；

　　返回值：返回一個子串替換好之后的新的字符串；

　　實例：

------------------替換所有子串----------------------------

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.replace("a","A"))
http://video.dhlAnshAn.cn

-----------------從左到右只替換1次子串------------------

>>> print(str1.replace("a","A",1))
http://video.dhlAnshan.cn

 

　　31.rfind(self, sub, start=None, end=None)

　　說明：返回指定的子串在字符串中最后一次出現的位置，如果沒有匹配項則返回-1；也可以說是從右邊開始找這個指定的子串；

　　語法：str.rfind(sub, start=None, end=None)

　　參數：sub ------> 指定的子串；

　　　　　start ------> 開始查找的位置，默認為0;

　　　　　end  ------> 結束查找位置，默認為字符串的長度;

　　返回值：返回字符串最后一次出現的位置，如果沒有匹配項則返回-1

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rfind("an"))
20
>>> print(str1.rfind("an",21))
-1

 

　　32.rindex(self, sub, start=None, end=None)

　　說明：返回子字符串 str 在字符串中最后出現的位置，如果沒有匹配的字符串會報異常，和rfind類似，只不過rfind找不到會返回-1；也可以說是從右邊開始找這個指定的子串；

　　語法：str.rindex(sub, start=None, end=None)

　　參數：sub ------> 指定的子串；

　　　　　start ------> 開始查找的位置，默認為0;

　　　　　end  ------> 結束查找位置，默認為字符串的長度;

　　返回值：返回子字符串 str 在字符串中最后出現的位置，如果沒有匹配的字符串會報異常；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rindex("an"))
20

---------------找不到則報錯--------------------------
>>> print(str1.rindex("an",21))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

　　

　　33.rjust(self, width, fillchar=None)

　　說明：返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串。

　　語法：str.rjust(width, fillchar=None)

　　參數：width ------> 指定填充指定字符后中字符串的總長度；

　　　　　fillchar -----> 填充的字符，默認為空格；

　　返回值：返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rjust(30,"-"))
-----http://video.dhlanshan.cn

 

　　34.rpartition(self, sep)

　　說明：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串，分隔符從字符串的右邊開始查找。

　　語法：str.rpartition(sep)

　　參數：sep ----->指定分隔符；

　　返回值：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rpartition("."))
('http://video.dhlanshan', '.', 'cn')

 

　　35.rsplit(self, sep=None, maxsplit=-1)

　　說明：分隔字符串，從右側開始分隔，返回一個將字符串以指定分隔符分隔的列表，從右邊開始查找分隔符,默認空格為分隔符；注意，最后列表里是不存在指定的那個分隔符的；

　　語法：str.rsplit(sep=None, maxsplit=-1)

　　參數：sep ------> 指定分隔符；

　　　　　maxsplit ------> 最多分隔的次數，-1表示全部分隔；

　　返回值：返回一個將字符串以指定分隔符分隔的列表；

　　實例：

--------------------分隔所有--------------------------------------
>>> str1 = "1 2 3 4 5"
>>> print(str1.rsplit(" ",maxsplit=-1))
['1', '2', '3', '4', '5']

-------------------分隔2次---------------------------------------
>>> print(str1.rsplit(" ",maxsplit=2))
['1 2 3', '4', '5']

--------------------列表中會刪除指定的分隔符-----------------
>>> print(str1.rsplit("3",maxsplit=1))
['1 2 ', ' 4 5']

 

　　36.rstrip(self, chars=None)

　　說明：刪除 string 字符串最右邊的指定字符（默認為空格）；貪婪模式；

　　語法：str.rstrip(chars=None)

　　參數：chars ------> 指定的子符；

　　返回值：返回刪除 string 字符串最右邊的指定字符后生成的新字符串；

　　實例：

>>> str1 = "**********今日說法**************"
>>> print(str1.rstrip("*"))
**********今日說法

 

　　37.split(self, sep=None, maxsplit=-1)

　　說明：分隔字符串，從左側開始分隔，返回一個將字符串以指定分隔符分隔的列表，從左邊開始查找分隔符,默認空格為分隔符；注意，最后列表里是不存在指定的那個分隔符的；

　　語法：str.rsplit(sep=None, maxsplit=-1)

　　參數：sep ------> 指定分隔符；

　　　　　maxsplit ------> 最多分隔的次數，-1表示全部分隔；

　　返回值：返回一個將字符串以指定分隔符分隔的列表；

　　實例：

--------------------分隔所有--------------------------------------
>>> str1 = "1 2 3 4 5"
>>> print(str1.split(" ",maxsplit=-1))
['1', '2', '3', '4', '5']

-------------------當分隔符為整個字符串時則返回一個有兩個空字符串的元素的列表----------------------

>>> str1 = "1 2 3 4 5"
>>> print(str1.split("1 2 3 4 5",maxsplit=-1))
['', '']

-------------------分隔2次---------------------------------------
>>> print(str1.split(" ",maxsplit=2)) ['1','2','3 4 5'] --------------------列表中會刪除指定的分隔符-----------------
>>> print(str1.split("3",maxsplit=1)) ['1 2 ', ' 4 5']

 

　　38.splitlines(self, keepends=None)

　　說明：按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。

　　語法：str.splitlines(keepends=None)

　　參數：keepends -- 在輸出結果里是否去掉換行符('\r', '\r\n', \n')，默認為 False，不包含換行符，如果為 True，則保留換行符

　　返回值：返回一個包含各行作為元素的列表。

　　實例：

>>> print("abc\n\ndefg\rkl\r\n".splitlines())
['abc', '', 'defg', 'kl']
>>> print("abc\n\ndefg\rkl\r\n".splitlines(True))
['abc\n', '\n', 'defg\r', 'kl\r\n']

 

　　39.startswith(self, prefix, start=None, end=None)

　　說明：用於檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 start 和 end 指定值，則在指定范圍內檢查。

　　語法：str.startswith(prefix, start=None, end=None)

　　參數：prefix ------> 指定的子串；

　　　　　start  -------> 索引開始處；

　　　　　end  --------> 索引結尾處；

　　返回值：如果檢測到字符串則返回True，否則返回False；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.startswith("http"))
True
>>> print(str1.startswith("video",7))
True
>>> print(str1.startswith(":",6,9))
False

 

　　40.strip(self, chars=None)

　　說明：用於移除字符串頭尾指定的字符（默認為空格）或字符序列。注意：該方法只能刪除開頭或是結尾的字符，不能刪除中間部分的字符。

　　語法：str.strip(chars)

　　參數：chars -------> 移除字符串頭尾指定的字符序列；

　　返回值：返回移除字符串頭尾指定的字符序列生成的新字符串；

　　實例：

>>> str1 = "**********今*日*說*法**************"
>>> print(str1.strip("*"))
今*日*說*法

　　無敵匹配法：

　　先看效果：

>>> str1 = "12345654321"
>>> print(str1.strip("12"))
3456543
>>> str1 = "12345654312"
>>> print(str1.strip("12"))
3456543
>>> str1 = "12345654321"
>>> print(str1.strip("125"))
3456543
>>> str1 = "1234565431221"
>>> print(str1.strip("12"))
3456543
>>> str1 = "1234565432121"
>>> print(str1.strip("12"))
3456543
 ----------------------------------------說明--------------------------------
#其實“12”是分為了3個匹配符，分別是"1" "2" "12",這三個匹配符會循環去匹配字符串，直到這三個匹配符一個也匹配不上為止。

 

　　41.swapcase(self)

　　說明：用於對字符串的大小寫字母進行轉換，小寫變大寫，大寫變小寫；

　　語法：str.swaocase()

　　返回值：返回大小寫字母轉換后生成的新字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.swapcase())
i lOVE yOU

 

　　42.title(self)

　　說明：返回"標題化"的字符串,就是說所有單詞的首個字母轉化為大寫，其余字母均為小寫；注意，默認是按空格來分單詞，也可以是其他特殊字符或數字。

　　語法：str.title()

　　返回值：返回"標題化"的字符串,就是說所有單詞的首字母都轉化為大寫。

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.title())
Life Is Too Short For Python

 　　使用特殊字符或數字來區分：

>>> str1 = "zjk zjk*zjk&zjk^zjk@,zjk.zjk9zjk8zjk/zjk"
>>> print(str1.title())
Zjk Zjk*Zjk&Zjk^Zjk@,Zjk.Zjk9Zjk8Zjk/Zjk

 

　　43.translate(self, table)

　　說明：根據由maketrans函數生成的對照表table完成字符替換；

　　語法：str.tarnslate(table)

　　參數：table ---- 對照表，是由maketrans函數生成；

　　返回值：返回翻譯后的字符串；

　　實例：

>>> table = str.maketrans("zjk","666")
>>> str = "zjkqwert"
>>> print(str.translate(table))
666qwert

 

　　44.upper(self)

　　說明：將字符串中的小寫字母轉為大寫字母；

　　語法：str.upper()

　　返回值：返回小寫字母轉為大寫字母的字符串；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.upper())
LIFE IS TOO SHORT FOR PYTHON

 

　　45.zfill(self, width)

　　說明：返回指定長度的字符串，原字符串右對齊，前面填充0，若指定長度小於原字符串長度，則返回原字符串；

　　語法：str.zfill(width)

　　參數：width -------> 指定字符串的長度。原字符串右對齊，前面填充0;

　　返回值：返回指定長度的字符串；

　

布爾類型

• 布爾說明

• 判定

一、布爾說明

　　python 中布爾值使用常量True 和 False來表示；注意大小寫；

　　比較運算符< > == 等返回的類型就是bool類型；布爾類型通常在 if 和 while 語句中應用；

　　注意的是，python中，bool是int的子類（繼承int），故 True==1  False==0 是會返回Ture的；

　　Python2中True/False不是關鍵字，因此我們可以對其進行任意的賦值；同理，Python 中 if(True) 的效率遠比不上 if(1)；Python2 版本中True False不是關鍵字，可被賦值，Python3中會報錯；

　　由於bool是int，可進行數字計算 ，例如：print(True+True)

二、判定

　　以下值會被判斷是True或False：

　　數字0  ---------- False；

　　None ---------- False;   None是真空；

　　null （包括空字符串、空列表、空元祖....） --------- False；

　　除了以上的，其他的表達式均會被判定為 True，這個需要注意，與其他的語言有比較大的不同。

數據結構之列表類型（list）

• 列表說明

• 索引和切片

• 增加元素到列表

• 刪除列表元素

• 更改列表元素

• 查看列表元素

• 列表腳本操作符

• 列表截取與拼接

• 嵌套列表

• 列表內置函數

一、列表說明

　　序列是Python中最基本的數據結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。

　　列表是一個可變的數據類型

　　Python有6個序列的內置類型，但最常見的是列表和元組。

　　序列都可以進行的操作包括索引，切片，加，乘，檢查成員。

　　Python已經內置確定序列的長度以及確定最大和最小的元素的方法

　　列表的數據項不需要具有相同的類型

　　列表由 [ ] 來表示, 每一項元素使用逗號隔開. 列表什么都能裝. 能裝對象的對象；

　　創建一個列表，只要把逗號分隔的不同的數據項使用方括號括起來即可。如下所示：

>>> li = ["zjk",123,"python"]
>>> li2 = [1,2,3,4,5]
>>> li3 = ["a","b","c"]

二、索引和切片

　　列表和字符串一樣. 也有索引和切片. 只不過切出來的內容是列表；

　　索引的下標從0開始；

　　切片的表達形式：[起始位置:結束位置:步長]

二、增加元素到列表

　　向列表中添加元素有三種基本方法：

　　append()、insert()、extend()

　　1.append(obj)，表示向列表的末尾追加一個元素obj,這個obj被當做一個整體添加到列表的末尾處；

　　例如：

>>> li = [1,2,3,4]
>>> li.append("abc")
>>> print(li)
[1, 2, 3, 4, 'abc']

　　2.insert(index，obj)，表示在索引index位置添加一個obj元素，obj元素是一個整體；

　　例如：

>>> li.insert(1,["a","b","c"])
>>> print(li)
[1, ['a', 'b', 'c'], 2, 3, 4]

　　3.extend( iterable),表示向列表的末尾處添加一個可迭代對象，iterable被疊加到列表的末尾處；

　　例如：

>>> li = [1,2,3,4]
>>> li.extend(["a","b","c"])
>>> print(li)
[1, 2, 3, 4, 'a', 'b', 'c']

 

三、刪除列表元素

　　刪除列表中的元素有四種基本方法：

　　pop()、remove()、del 切片、clear()

　　1.pop(index)，表示通過索引位置剪切走一個元素，

　　例子：

>>> li = [1,2,3,4]
>>> a = li.pop(1)
>>> print(li,a)
[1, 3, 4] 2

 

　　2.remove()，搜索元素然后直接在列表中刪除；

　　例子：

>>> li = [1,2,3,4]
>>> li.remove(3)
>>> print(li)
[1, 2, 4]

　　

　　3.del 切片,通過索引或切片的方式進行刪除；

　　例子：

>>> li = [1,2,3,4]
>>> del li[0]
>>> print(li)
[2, 3, 4]
>>> del li[0:2]
>>> print(li)
[4]

 

　　4.clear()，清空整個列表；

　　例子：

>>> li = [1,2,3,4]
>>> li.clear()
>>> print(li)
[]

 

四、更改列表元素

　　1.索引修改；

　　例子：

>>> li = [1,2,3,4]
>>> li[0] = "a"
>>> print(li)
['a', 2, 3, 4]

　　2.切片修改：

　　這邊需要注意的是，如果切片的步長為1，則不用關心賦值的參數問題，如果步長值不為1則是幾就要添加幾個參數；

　　例子：

----------------步長值為1，元素可以隨意添加---------------------------
>>> li = [1,2,3,4]
>>> li[1:3] = "abcdefg"
>>> print(li)
[1, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 4]

--------------步長值為2，元素必須是兩個元素----------------------------
>>> li = [1,2,3,4]
>>> li[0::2] = "abc","kkk"
>>> print(li)
['abc', 2, 'kkk', 4]

 

五、查看列表元素

　　查詢列表中的元素可以使用索引方式，也可以使用for循環的方式；

　　索引方式或切片方式查詢：

　　例子：

-----------------索引方式--------------------------
>>> li[0::2] = "abc","kkk"
>>> print(li)
['abc', 2, 'kkk', 4]


----------------切片方式---------------------------
>>> print(li[0:3])
[1, 2, 3]

　　for循環方式查詢：

>>> li = [1,2,3,4]
>>> for n in li:
...     print(n)
... 
1
2
3
4

 

六、列表腳本操作符

　　列表對 + 和 * 的操作符與字符串相似。+ 號用於組合列表，* 號用於重復列表。

 

七、列表截取與拼接

 

八、嵌套列表

　　使用嵌套列表即在列表里創建其它列表，通過降維. 一層一層看；

>>> li = ["a","b","c",[1,2,3],7,8,"d"]
>>> print(li[1])
b
>>> print(li[3])
[1, 2, 3]
>>> print(li[3][2])
3

 

九、列表內置函數

　　1.append(self, p_object)

　　說明：用於在列表末尾添加新的對象；

　　語法：list.append(obj)

　　參數：obj ----------> 添加到列表末尾的對象；

　　返回值：該方法無返回值，但是會修改原來的列表。

　　實例：

>>> li = [1,2,3]
>>> li.append("abc")
>>> print(li)
[1, 2, 3, 'abc']

　　

　　2.clear(self)

　　說明：用於清空列表，類似於 del a[:]

　　語法：list.clear()

　　實例：

>>> print(li)
[1, 2, 3, 'abc']
>>> li.clear()
>>> print(li)
[]

 

　　3.copy(self)

　　說明：用於淺復制列表，類似於 a[:]；

　　語法：list.copy()

　　返回值：返回復制后的新列表；

　　實例：

>>> li1 = ["a","b",[1,2,3],"c"]
>>> li2 = li1.copy()
>>> print(li2)
['a', 'b', [1, 2, 3], 'c']
>>> print(id(li1),id(li2))
139844385179656 139844384906184
#可以看出兩個列表的內存地址是不一樣的
>>> print(id(li1[2][0]),id(li2[2][0]))
139844383671616 139844383671616
#可以看出里面的內容地址是一樣的

 

　　4.count(self, value)

　　說明：用於統計某個元素在列表中出現的次數

　　語法：list.count(obj)

　　參數：obj -------> 列表中統計的對象；

　　返回值：返回元素在列表中出現的次數；

　　實例：

>>> li = ["a","b","c","a",1,8,"a"]
>>> print(li.count("a"))
3

 

　　5.extend(self, iterable)

　　說明：用於在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）；

　　語法：list.extend(seq)

　　參數：seq --------> 元素列表，必須是一個可迭代對象；

　　返回值：該方法沒有返回值，但會在已存在的列表中添加新的列表內容。

　　實例：

>>> li = [1,2,3,4]
>>> li2 = [5,6,7,8]
>>> li.extend(li2)
>>> print(li)
[1, 2, 3, 4, 5, 6, 7, 8]

 

　　6.index(self, value, start=None, stop=None)

　　說明：用於從列表中找出某個值第一個匹配項的索引位置。

　　語法：list.index(value)

　　參數：value --------> 查找的對象；

　　返回值：返回查找對象的索引位置，如果沒有找到對象則拋出異常；

　　實例：

>>> li = ["a","b","c","a"]
>>> print(li.index("a"))
0

　>>> print(li.index("a",1))
　3

 

　　7.insert(self, index, p_object)

　　說明：用於將指定對象插入列表的指定位置；

　　語法：list.insert(index,p_object)

　　參數：index ------> 對象p_object需要插入的索引位置；

　　　　　p_object ----> 要插入列表中的對象；

　　返回值：該方法沒有返回值，但會在列表指定位置插入對象；

　　實例：

>>> li = ["a","b","c","a"]
>>> li.insert(1,"尼瑪的")
>>> print(li)
['a', '尼瑪的', 'b', 'c', 'a']

 

　　8.pop(self, index=None)

　　說明：用於根據索引移除列表中的一個元素（默認最后一個元素），並且返回該元素的值，相當於剪切；

　　語法：list.pop(index)

　　參數：index -------> 可選參數，要移除列表元素的索引值，不能超過列表總長度，默認為 index=-1，刪除最后一個列表值；

　　返回值：該方法返回從列表中移除的元素對象；

　　實例：

>>> li = ["a","b","c","a"]
>>> a = li.pop(2)
>>> print(li)
['a', 'b', 'a']
>>> print(a)
c

 

　　9.remove(self, value)

　　說明：用於根據元素值移除列表中某個值的第一個匹配項；

　　語法：list.remove(value)

　　參數：value --------> 列表中要移除的元素

　　返回值：該方法沒有返回值但是會移除兩種中的某個值的第一個匹配項。

　　實例：

>>> li = ["a","b","c","a"]
>>> a = li.remove("a")
>>> print(li)
['b', 'c', 'a']

 

　　10.reverse(self)

　　說明：用於反向列表中元素；

　　語法：list.reverse()

　　返回值：該方法沒有返回值，但是會對列表的元素進行反向排序；

　　實例：

>>> li = ["a","b","c","a"]
>>> li.reverse()
>>> print(li)
['a', 'c', 'b', 'a']

 

　　11.sort(self, key=None, reverse=False)

　　說明：用於對原列表進行排序，如果指定參數，則使用比較函數指定的比較函數

　　語法：list.sort(key=None, reverse=False)

　　參數：key ------> 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。

　　　　　 reverse -----> 指定排序規則，默認為升序，reverse = True 降序， reverse = False 升序（默認）；

　　返回值：該方法沒有返回值，但是會對列表的對象進行排序；

　　實例：

>>> li = ["Ack","Ync","seq"]
>>> li.sort(reverse = True)
>>> print(li)
['seq', 'Ync', 'Ack']

 

元祖類型（tuple）

• 元祖定義

• 索引和切片

• 查詢元組元素

• 元組的連接組合

• 刪除整個元組

• 元組的運算符

• 元組內置函數

• range()-Python內置函數簡單說明

一、元組定義

　　Python 的元組與列表類似，不同之處在於元組的元素不能修改，不能刪除，不能新增，只能讀取；也被稱為只讀列表

　　元組的表達形式：使用 ( ) 表示元組；

　　如果元組中只有一個元素，則表現形式為：(元素,)因為元組中只包含一個元素時，如果不加逗號，會被當作運算符使用；

　　空元組的表達形式：tuple()

　　元組是一個可迭代對象，有__iter__方法；

　　例子：

>>> tu1 = (50)
>>> print(type(tu1))
<class 'int'>
>>> tu2 = (50,)
>>> print(type(tu2))
<class 'tuple'>
>>> tu3 = tuple()
>>> print(type(tu3))
<class 'tuple'>

 

二、索引和切片

　　元組的索引和切片的使用方式和字符串以及列表的索引切片使用方式是一樣的；

 

三、查詢元組元素

　　可以通過索引或切片來訪問元組中的值；

　　例子：

>>> tu1 = (1,2,3,4,"a","b","c")
>>> print(tu1[4])
a
>>> print(tu1[2:6])
(3, 4, 'a', 'b')
>>> print(tu1[0:6:2])
(1, 3, 'a')
>>> print(tu1[6:0:-2])
('c', 'a', 3)

 

四、元組的連接組合

　　元組中的元素值是不允許修改的，但我們可以對元組進行連接組合，如下實例:

>>> tu1 = (1,2,3,4,5)
>>> tu2 = ("a","b","c","d","e",)
>>> tu3 = tu1 + tu2
>>> print(tu3)
(1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'e')

 

五、刪除整個元組

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

>>> tu1 = (1,2,3,4,5)
>>> print(tu1)
(1, 2, 3, 4, 5)
>>> del tu1
>>> print(tu1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tu1' is not defined

 

六、元組的運算符

　　與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味着他們可以組合和復制，運算后會生成一個新的元組。

 

七、元組的內置函數

　　1.count(self, value)

　　說明：記錄所要搜索的value在元組中出現的次數；

　　語法：tuple.count(value)

　　參數：value -------------> 搜索的元素

　　返回值：返回被搜索元素出現在元組中的次數，沒有則返回0；

　　實例：

>>> tu1 = （"a","b","d","a","d","a"）>>> print(tu1.count("a"))
3
>>> print(tu1.count("p"))
0

 

　　2.index(self, value, start=None, stop=None)

　　說明：用於從元組中找出某個值第一個匹配項的索引位置。

　　語法：tuple.index(value, start=None, stop=None)

　　參數：value -----------> 搜素的元素；

　　　　　start ------------> 起始位置；

　　　　　end ------------> 結束位置；

　　返回值：若存在此元素，則返回次元素所在的索引位置，否則報錯，提示找不到該元素；

　　實例：

>>> tu1 = ("a","b","d","a","d","a")
>>> print(tu1.index("a"))
0
>>> print(tu1.index("b"))
1
>>> print(tu1.index("p"))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple

 

八、range()-Python內置函數簡單說明

　　range()的使用方式相當於切片；

　　range(n) 從0到n-1

　　range(m,n) 從m到n-1
　　range(m,n,q) 從m到n-1 每q個取1個

　　使用for循環和range來獲取列表或元組中的索引：

　　for n in range(len(tuple))：

　　　　print(tuple[n)

　　注意：

　　Python2中的range(1,10)，可以被print()直接打印出列表[1,2,3,4,5,6,7,8,9]

　　Python3中的range(1,10)，被print（）打印后輸出為，range(1,10)

 

字典類型（dict）

• 字典數據類型介紹

• 字典鍵值對的增加

• 字典鍵值對的刪除

• 字典鍵值對的修改

• 字典鍵值對的查看

• 字典鍵的特性

• 字典的嵌套

• 字典的內置方法

• 解構（解包）和封裝

一、字典數據類型介紹

　　字典是Python中唯一的一個映射類型，它是以 { } 擴起來的鍵值對組成的{key:value}；在字典中key是唯一的，在保存的時候，根據key來計算出一個內存地址，然后將key-value保存在這個地址中，這種算法被稱為hash算法，所以，切記，在dict中存儲的key-value中的key必須是可hash的；

　　字典是一個可變的無序的可以存儲任何類型的類型；

　　字典中的key都必須是可哈希的，不可變的數據類型；

　　字典中的值沒有限制，可以是任何數據類型；

　　一個簡單的字典實例：

>>> dic = {"name":"zjk","age":18}

 

二、字典鍵值對的增加

　　字典中的鍵值對增加有兩個基本方式：dict[key] = value       dict.setdefault(key,value)

　　1.dict[key] = value

　　實例：

>>> dic = {"name":"zjk","age":18}
>>> dic["like"] = [1,2,3]
>>> print(dic)
{'name': 'zjk', 'age': 18, 'like': [1, 2, 3]}

　　2.dict.setfefault(key,value)

　　說明：如果鍵在字典中存在不進行任何操作,否則就添加；

　　實例：

>>> dic = {"name":"zjk","age":18}
>>> dic.setdefault("home","wuan")
'wuan'
>>> print(dic)
{'name': 'zjk', 'age': 18, 'home': 'wuan'}

 

三、字典鍵值對的刪除

　　刪除鍵值對的四種方法：pop(key)，del dic[key]、popitem()、clear()

　　1.dict.pop(key)

　　說明：刪除鍵值對，有返回值，返回的是被刪除的key的value；

>>> dic = {"name":"zjk","age":18}
>>> a = dic.pop("age")
>>> print(a,dic)
18 {'name': 'zjk'}

　　2.del dict[key]

　　說明：通過key刪除

　　實例：

>>> dic = {"name":"zjk","age":18}
>>> del dic["name"]
>>> print(dic)
{'age': 18}

　　3.dict.popitem()

　　說明：隨機刪除，默認刪除最后一個，（還在測試中）

　　實例：

>>> dic = {"name":"zjk","age":18}
>>> dic.popitem()
('age', 18)
>>> print(dic)
{'name': 'zjk'}

　>>> dic = {"name":"zjk","age":18}
　>>> a = dic.popitem()
　>>> print(dic,a)
　{'name': 'zjk'} ('age', 18)

　　4.dic.clear()

　　說明：清空字典；

　　實例：

>>> dic = {"name":"zjk","age":18}
>>> dic.clear()
>>> print(dic)
{}

 

四、字典鍵值對的修改

　　修改字典兩種方法：dic[key] = value     dic.update(字典)

　　1.dic[key] = value

　　實例：

>>> dic = {"name":"zjk","age":18}
>>> dic["name"] = "lalala"
>>> print(dic)
{'name': 'lalala', 'age': 18}

　　2.dic.update(字典)

　　說明：將一個字典導入到另一個字典中，新的數據會覆蓋舊的數據；

　　實例：

>>> dic = {"name":"zjk","age":18}
>>> dic1 = {"home":"wuan","age":23,"high":"66666"}
>>> dic.update(dic1)
>>> print(dic)
{'name': 'zjk', 'age': 23, 'home': 'wuan', 'high': '66666'}

 

五、字典鍵值對的查看

　　查看字典的幾種方法：for循環、dic[key]、get(key)、setfault(key)

　　1.for循環

　　實例：

>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> for n in dic:
...     print(n)
... 
a
b
c
d
e
>>> for n in dic.values():
...     print(n)
... 
1
2
3
4
5
>>> for n in dic.items():
...     print(n)
... 
('a', 1)
('b', 2)
('c', 3)
('d', 4)
('e', 5)

　　2.dict[key]

　　說明：如果key在字典中存在，則返回對應key的value值，如果key不存在，則報錯；

　　實例：

>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> print(dic["a"])
1
>>> print(dic["b"])
2
>>> print(dic["aaa"])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'aaa'

　　3.dict.get(key，default=None)

　　說明：返回指定鍵的值，如果值不在字典中則返回default值；

　　實例：

>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> print(dic.get("a"))
1
>>> print(dic.get("aaa"))
None
>>> print(dic.get("aaa","66666"))
66666

　　4.dict.setfault(key，dafault)

　　說明：和get類似，如果鍵存在的話返回鍵對應的值，但如果鍵不存在的話，將會在字典中添加鍵並將值設為default；

　　實例：

>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> print(dic.setdefault("a","888"))
1
>>> print(dic.setdefault("aaaa","888"))
888
>>> print(dic)
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'aaaa': '888'}

 

六、字典鍵的特性

　　字典值可以是任何的 python 對象，既可以是標准的對象，也可以是用戶定義的，但鍵不行；

　　不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，后一個值會被記住，如下實例：

>>> dic = {"a":1,"b":2,"c":3,"a":4}
>>> print(dic["a"])
4

 

七、字典鍵的嵌套

　　字典里可以無限嵌套，字典也可以嵌套字典：

dic = {
    'name':'汪峰',
    'age':43,
    'wife':{
        'name':'國際章',
        'age':39,
        'salary':100000
    },
    'baby':[
        {'name':'熊大','age':18},
        {'name':'熊二','age':15},
    ]

}

 

八、字典鍵的內置方法

　　1.clear(self)

　　說明：用於刪除字典內所有元素，清空字典；

　　語法：dict.clear()

　　實例：

>>> dic = {"a":1,"b":2,"c":3}
>>> dic.clear()
>>> print(dic)
{}

 

　　2.copy(self)

　　說明：返回一個字典的淺復制，將字典進行復制；

　　語法：dcit.copy()

　　返回值：返回一個字典的淺復制；

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> dic1 = dic.copy()
>>> print(dic1)
{'name': 'zjk', 'age': 23}

　

　　3.fromkeys(*args, **kwargs)

　　說明：用於創建一個新字典，以序列seq中元素做字典的鍵，value為字典所有鍵對應的初始值；

　　語法：dict.fromkeys(*args, **kwargs)

　　返回值：該方法返回字典；

　　實例：

>>> li = ["name","age","like"]
>>> a = dict.fromkeys(li,"666")
>>> print(a)
{'name': '666', 'age': '666', 'like': '666'}
>>> print(type(a))
<class 'dict'>

 　　需要注意的是，由fromkeys生成的新字典中，所有的key都是共享的一個value，如果所這個被共享的value是一個可變類型，

1.----------------- 當共享的value是一個可哈希的數據類型時，該字典中的某個key的值被修改，不會影響其他key的value--------------------
>>> li = ["name","age","like"]
>>> a = dict.fromkeys(li,"666")
>>> a
{'name': '666', 'age': '666', 'like': '666'}
>>> a["age"] = "777"
>>> a
{'name': '666', 'age': '777', 'like': '666'}



2.----------------當共享的value是一個可變的數據類型時，該字典中的某個key的值被修改后，其他key的值都會被修改 ----------------------------
>>> li1 = ["name","age","like"]
>>> a = dict.fromkeys(li,[111,222])
>>> a
{'name': [111, 222], 'age': [111, 222], 'like': [111, 222]}
>>> a["like"].append(333)
>>> a
{'name': [111, 222, 333], 'age': [111, 222, 333], 'like': [111, 222, 333]}

 

那么，如果其中有個key的值進行了改變，那么該字典中所有的value都會被改變；

　　例如：

 

　　4.get(self, k, d=None)

　　說明：返回指定鍵的值，如果值不在字典中返回默認值。默認值為None；

　　語法：dict.get(key,default=None)

　　參數：key ------> 字典中要查找的鍵；

　　　　　default ------> 如果指定的值不存在，返回該默認值；

　　返回值：返回指定鍵的值，如果值不在字典中返回默認值 None；

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> print(dic.get("name"))
zjk
>>> print(dic.get("name11"))
None
>>> print(dic.get("name11","888"))
888

 

　　5.items(self)

　　說明：以列表形式返回可遍歷的(鍵, 值) 元組數組；

　　語法：dict.items()

　　返回值：返回可遍歷的(鍵, 值) 元組數組；

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> print(dic.items())
dict_items([('name', 'zjk'), ('age', 23)])

 

　　6.in操作符

　　說明： in 操作符用於判斷鍵是否存在於字典中，如果鍵在字典dict里返回true，否則返回false。

　　語法：key in dict

　　參數：key -------> 要在字典中查找的鍵；

　　返回值：如果鍵在字典里返回true，否則返回false；

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> if "name" in dic:
...     print(666)
... else :
...     print(111)
... 
666
>>> if "hahaha" in dic:
...     print(666)
... else :
...     print(111)
... 
111

 

　　7.keys(self)

　　說明：以列表返回一個字典所有的鍵；

　　語法：dict.keys()

　　返回值：返回一個字典所有的鍵。

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> print(dic.keys())
dict_keys(['name', 'age'])

 

　　8.pop(self, k, d=None)

　　說明：刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。

　　語法：dict.pop(k, d=None)

　　參數：key ----------> 要刪除的鍵值；

　　　　　default -------> 如果沒有key，返回default值

　　返回值：返回被刪除的value值

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> a = dic.pop("age")
>>> print(dic,a)
{'name': 'zjk'} 23
>>> 
>>> dic = {"name":"zjk","age":23}
>>> print(dic.pop("aaaaa","666"))
666

 

　　9.popitem(self)

　　說明：隨機返回並刪除字典中的一對鍵和值(一般刪除末尾對)；如果字典已經為空，卻調用了此方法，就報出KeyError異常；

　　語法：dcit.popitem()

　　返回值：返回一個鍵值對(key,value)形式。是一個元組類型；

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> b = dic.popitem()
>>> print(dic,b)
{'name': 'zjk'} ('age', 23)

>>> dic = {}
>>> b = dic.popitem()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'

 

　　10.setdefault(self, k, d=None)

　　說明：setdefault() 方法和get()方法類似, 如果鍵不已經存在於字典中，將會在字典中添加鍵並將值設為默認值。

　　語法：dict.setdefault(key, default=None)

　　參數：key -----------> 查找的鍵值；

　　　　　default -------> 鍵不存在時，設置的默認鍵值；

　　返回值：如果 key 在 字典中，返回對應的值。如果不在字典中，則插入 key 及設置的默認值 default，並返回 default ，default 默認值為 None。

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> print(dic.setdefault("name"))
zjk
>>> print(dic.setdefault("aaaaa"))
None
>>> print(dic.setdefault("bbbbb","6666"))
6666
>>> print(dic)
{'name': 'zjk', 'age': 23, 'aaaaa': None, 'bbbbb': '6666'}

 

　　11.update(self, E=None, **F)

　　說明：把字典參數 dict2 的 key/value(鍵/值) 對更新到字典 dict 里，如果有相同的鍵值進行替換；

　　語法：dict.update(dict2)

　　參數：dict2 -----> 添加到指定字典dict里的字典。

　　實例：

>>> dic = {"name":"zjk","age":23}
>>> dic1 = {"a":1,"b":2,"age":18}
>>> dic.update(dic1)
>>> print(dic)
{'name': 'zjk', 'age': 18, 'a': 1, 'b': 2}

 

　　12.values(self)

　　說明：以列表返回字典中的所有值；

　　語法：dict.values()

　　返回值：返回字典中的所有值；

　　實例：

>>> print(dic)
{'name': 'zjk', 'age': 18, 'a': 1, 'b': 2}
>>> print(dic.values())
dict_values(['zjk', 18, 1, 2])

 

九、解構（解包）和封裝

　　元素在左邊是解構，元素在右邊是封裝；

　　封裝的定義：將多個值使用逗號分隔，組合在一起；本質上返回一個元組，只是省略了小括號；Python特有語法，被很多語言學習和借鑒；

　　解構的定義：按照元素順序，把線性解構的元素，賦值給變量；

　　Python3中的解構變化：

　　　　通過使用星號 * 加上變量，可以接受所有元素；

　　　　不能單一的使用星號作為變量接收，如果可以，相當於lst[0:0]

　　　　同一個解構中，只能使用一個星號；

　　　　當左邊變量超過右邊元素個數的時候，是不允許的；

　　兩大用法：

　　對稱性賦值：

　　　　對稱性賦值在很多情況下被稱為解構，其實只是解構的一小部分；

　　　　把線性結果（包括字典和list等）的元素解開，並按順序賦值給其他變量；

　　　　左邊接收的變量數要和右邊解開的元素個數一致；

　　　　通常用在x,y = y,x 相當於將y,x先封裝為一個元組(y,x),等價於x,y = (y,x)，然后依據位置參數進行依次賦值。

　　簡化添加類型：

　　　　極大的簡化了“添加”的類型，比如結合字典，並且以明確的方式進行：

　　　　例如：

　　　　

　　實例：

>>> a,b = 1,2
>>> print(a,b)
1 2
>>> a,b = (1,2)
>>> print(a,b)
1 2
>>> a,b = [1,2]
>>> print(a,b)
1 2
>>> a,b = {1,2}
>>> print(a,b)
1 2
>>> a,b = {"a":1,"b":2}
>>> print(a,b)
a b
>>> 
>>> 
>>> 
>>> a,*b = {1,2,3}
>>> print(a,b)
1 [2, 3]
>>> a,*b,c = {1,2,3,4,5,6,7,8}
>>> print(a,b,c)
1 [2, 3, 4, 5, 6, 7] 8

 

集合類型（set）

• 集合定義

• 集合-增加元素

• 集合-刪除元素

• 集合-查看元素

• 交集

• 並集

• 差集

• 反交集

• 子集與超集

• set內置函數

• frozenset不可變集合，讓集合變成不可變類型；

一、集合定義

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

　　集合的元素都是不可變類型的

　　使用大括號 { } 或者set()函數創建，注意：創建一個空集合必須使用set()而不是 { }，因為 { } 是用來創建一個空字典；

　　創建集合：

se = {"a","b","c",(1,2,3)}
se1 = set("123")
se2 = set((1,2,3,4,5,))
print(se)
print(se1)
print(se2)
---------------------輸出結果----------------------------------
{'c', 'b', 'a', (1, 2, 3)}
{'3', '1', '2'}
{1, 2, 3, 4, 5}

 

二、集合-增加元素

　　1.s.add(x)

　　說明：將元素x添加到集合s中，如果元素已存在，則不進行任何操作；

　　實例：

se = set(("zjk","china","beijing"))
se.add("hello world")
print(se)

--------------------輸出結果---------------------
{'beijing', 'china', 'zjk', 'hello world'}

　　2.s.update(x)

　　說明：添加元素，參數可以是列表，元組、字典等；

　　實例：

se = {"a","b","c","d","e"}
se.update([1,2,3,4,5])
print(se)

-------------輸出結果-------------------
{'a', 1, 2, 3, 'e', 'b', 4, 5, 'c', 'd'}

 

三、集合-刪除元素

　　1.s.remove(x)

　　說明：將元素x從集合s中刪除，如果該元素不存在，則報錯；

　　實例：

se = {"a","b","c","d","e"}
se.remove("d")
print(se)

----------------輸出結果---------------------
{'e', 'b', 'a', 'c'}

se = {"a","b","c","d","e"}
se.remove("dddd")
print(se)
-----------------輸出結果------------------

Traceback (most recent call last):
File "C:/Users/Administrator/Desktop/123.py", line 2, in <module>
se.remove("dddd")
KeyError: 'dddd'

　　

　　2.s.discard(x)

　　說明：將元素x從集合中刪除，如果該元素不存在，不會發生錯誤並返回當前集合

　　實例：

se = {"a","b","c","d","e"}
se.discard("e")
print(se)
------------------輸出結果-----------------------
{'d', 'a', 'b', 'c'}



se = {"a","b","c","d","e"}
se.discard("eeee")
print(se)
-----------------------輸出結果-------------------
{'b', 'c', 'd', 'a', 'e'}

 

　　3.pop()

　　說明：隨機刪除集合的一個元素，並返回這個被刪除的元素；

　　實例：

se = {"a","b","c","d","e"}
a = se.pop()
print(se,a)

-----------------輸出結果-------------------
{'c', 'b', 'e', 'a'} d

 

　　4.s.clear()

　　說明：清空集合s

　　實例：

se = {"a","b","c","d","e"}
se.clear()
print(se)
------------輸出結果---------------
set()

 

四、集合-查看元素

　　通過for循環遍歷集合的元素；

　　實例：

>>> se = {"a","b","c",(1,2,3,4)}
>>> for n in se:
...     print(n)
... 
a
(1, 2, 3, 4)
c
b

 

五、交集（& 或者 intersection）

>>> se1 = {1,2,3,4,5}
>>> se2 = {4,5,6,7,8}
>>> print(se1 & se2)
{4, 5}
>>> print(se1.intersection(se2))
{4, 5}

 

六、並集（| 或者 union）

>>> se1 = {1,2,3,4,5}
>>> se2 = {4,5,6,7,8}
>>> print(se1 | se2)
{1, 2, 3, 4, 5, 6, 7, 8}
>>> print(se2.union(se1)
... )
{1, 2, 3, 4, 5, 6, 7, 8}

 

七、差集（- 或者 difference）

>>> se1 = {1,2,3,4,5}
>>> se2 = {4,5,6,7,8}
>>> print(se1 - se2)
{1, 2, 3}
>>> print(se1.difference(se2))
{1, 2, 3}

 

八、反交集（^ 或者 symmetric_difference）

>>> se1 = {1,2,3,4,5}
>>> se2 = {4,5,6,7,8}
>>> print(se1 ^ se2)
{1, 2, 3, 6, 7, 8}
>>> print(se1.symmetric_difference(se2))
{1, 2, 3, 6, 7, 8}

 

九、子集與超集

>>> se1 = {1,2,3}
>>> se2 = {1,2,3,4,5,6}

>>> print(se1 < se2)
True
>>> print(se1.issubset(se2))
True
#這兩個用法相同，都是說明se1是se2的子集


>>> print(se2 > se1)
True
>>> print(se2.issuperset(se1))
True
#這兩個都相同，都是說明se2是se1超集。

 

 

十、set內置函數

　　1.add(self, *args, **kwargs)

　　說明：向集合中添加元素；

　　語法：set.add(*args, **kwargs)

　　實例：

>>> se1.add(4)
>>> se1 = {1,2,3}
>>> se1.add(4)
>>> print(se1)
{1, 2, 3, 4}

　　2.clear(self, *args, **kwargs)

　　說明：清空集合；

　　語法：set.clear()

　　實例：

>>> se1 = {1,2,3}
>>> se1.clear()
>>> print(se1)
set()

　　3.copy(self, *args, **kwargs)

　　說明：返回集合的淺拷貝；

　　語法：set.copy()

　　實例：

>>> se1 = {1,2,3,(4,5,6)}
>>> se2 = se1.copy()
>>> print(se2)
{1, 2, 3, (4, 5, 6)}

　　4.difference(self, *args, **kwargs)

　　說明：將兩個或多個集合的差集作為一個新集合返回；

　　語法：se1.difference(se2)

　　實例：

>>> se1 = {1,2,3,4,5}
>>> se2 = {4,5,6,7,8}
>>> print(se1 - se2)
{1, 2, 3}
>>> print(se1.difference(se2))
{1, 2, 3}

 　　5.difference_update(self, *args, **kwargs)

　　說明：從這個集合中刪除另一個集合的所有元素

　　語法：set.difference_update(set1)

　　實例：

>>> s = {1,2,3}
>>> s1 = {1,2,3,4}
>>> s2 = {2,3}
>>> s.difference_update(s2)
>>> s
{1}
>>> s1.difference_update(s2)
>>> s1
{1, 4}

　　6.discard(self, *args, **kwargs)

　　說明：刪除集合中的一個元素，如果該元素不存在，則不執行任何操作；

　　語法：set.discard(x)

　　實例：

>>> s1 = {1,2,3,4}
>>> s1.discard(3)
>>> s1
{1, 2, 4}
>>> s1.discard("a")
>>> s1
{1, 2, 4}

　　7.intersection(self, *args, **kwargs)

　　說明：將兩個集合的交集作為一個新集合返回

　　語法：set.intersection(set1)

　　實例：

>>> s1 = {1,2,3,4}
>>> s2 = {3,4,5,6}
>>> s3 = s1.intersection(s2)
>>> s3
{3, 4}

　　8.intersection_update(self, *args, **kwargs)

　　說明：用自己和另一個的交集來更新這個集合；

　　語法：s.intersection_upfate(s2)

　　實例：

>>> s = {"a","b","c","d","e"}
>>> s1 = {"c","d","e","e","f","g"}
>>> s.intersection_update(s1)
>>> s
{'d', 'c', 'e'}

　　9.isdisjoint(self, *args, **kwargs)

　　說明：如果兩個集合有一個空交集，返回True

　　語法：set.isdisjoint(set1)

　　實例：

>>> s = {1,2}
>>> s1 = {3,4}
>>> s2 = {2,3}
>>> s.isdisjoint(s1)
True
>>> s.isdisjoint(s2)
False

　　10.issubset(self, *args, **kwargs)

　　說明：如果另一個集合包含這個集合，返回True

　　語法：s.issubset(set1)

　　實例：

>>> s = {1,2,3}
>>> s1 = {1,2,3,4}
>>> s2 = {2,3}
>>> s.issubset(s1)
True
>>> s.issubset(s2)
False
>>> s2.issubset(s)
True

　　11.issuperset(self, *args, **kwargs)

　　說明：如果這個集合包含另一個集合，返回True；

　　語法：s.issuperset(s1)

　　實例：

>>> s = {1,2,3}
>>> s1 = {1,2,3,4}
>>> s2 = {2,3}
>>> s1.issuperset(s)
True
>>> s.issuperset(s2)
True
>>> s2.issuperset(s1)
False

　　12.pop(self, *args, **kwargs)

　　說明：刪除並返回任意的集合元素（如果集合為空，會引發KeyError）

　　語法：s.pop()

　　實例：

>>> s = {1,2,3,4,5,6}
>>> s.pop()
1
>>> s
{2, 3, 4, 5, 6}

　　13.remove(self, *args, **kwargs)

　　說明：刪除集合中的一個元素（如果元素不存在，會引發KeyError）

　　語法：set.remove(x)

　　實例：

>>> s = {1,2,3,4,5,6}
>>> s.remove(4)
>>> s
{1, 2, 3, 5, 6}
>>> s.remove(99)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 99
>>> s
{1, 2, 3, 5, 6}

　　14.symmetric_difference(self, *args, **kwargs)

　　說明：將兩個集合的對稱差作為一個新集合返回(兩個集合合並刪除相同部分，其余保留)

　　語法：s.symmetric_difference(s1)

　　實例：

>>> s1 = {1,2,3,4,5,6,7,8}
>>> s2 = {3,4,5,6,7,8,9,10}
>>> s1.symmetric_difference(s2)
{1, 2, 9, 10}
>>> s2.symmetric_difference(s1)
{1, 2, 9, 10}

　　15.symmetric_difference_update(self, *args, **kwargs)

　　說明：用自己和另一個的對稱差來更新這個集合

　　語法：s.symmetric_difference_update(s1)

　　實例：

>>> s = {1,2,3}
>>> s1 = {1,2,3,4}
>>> s2 = {2,3}
>>> s1.symmetric_difference_update(s)
>>> s1
{4}
>>> s1.symmetric_difference_update(s2)
>>> s1
{2, 3, 4}
>>> s.symmetric_difference_update(s2)
>>> s
{1}

　　15.union(self, *args, **kwargs)

　　說明：將集合的並集作為一個新集合返回；

　　語法：s.union(s1)

　　實例：

>>> s = {1,2,3,4,5,6}
>>> s1 = {3,4,5,6,7,8}
>>> print(s.union(s1))
{1, 2, 3, 4, 5, 6, 7, 8}
>>> print(s|s1)
{1, 2, 3, 4, 5, 6, 7, 8}

　　16.update(self, *args, **kwargs)

　　說明：用自己和另一個的並集來更新這個集合；

　　語法：s.update(*args, **kwargs)

　　實例：

>>> s = {"p","y"}
>>> s.update("t","h","o","n")
>>> s
{'p', 'h', 't', 'n', 'y', 'o'}
>>> s.update(["q","e"],{"l","l","o"})
>>> s
{'q', 'p', 'h', 't', 'n', 'y', 'o', 'e', 'l'}

字符串類型（str）

• 字符串說明

• 索引和切片

• 轉義字符

• 字符串運算符

• 字符串格式化

• 字符串內置的函數

一.字符串說明

　　字符串是 Python 中最常用的數據類型。我們可以使用引號('或")來創建字符串。

　　字符串是不可變的數據類型，不論執行任何操作，源字符串是不會改變的，每次操作都會返回新字符串；

　　創建字符串，只需要為變量賦值即可，如：Str = "hello world"

　　字符串在轉換成int時，如果字符串中的數字有空格，則在轉換時自動去除空格；

　　訪問字符串中的值：

　　Python 不支持單字符類型，單字符在 Python 中也是作為一個字符串使用。

>>> print("hello world")
hello world

　　字符串更新：

　　可以截取字符串的一部分並與其他字段拼接，如下實例：

>>> print("hello world" + " 你好，中國")
hello world 你好，中國

二、索引和切片

1.索引

　　說明：通過索引取出字符串對應的值

　　格式：str[下標]

　　參數：下標 ------ > 是一個int型數據，

　　索引從0開始，使用[下標]可以獲取到每一個字符，還可以倒着數，最后一個字符用-1表示，一次往前數是-1、-2...

　　返回值：返回字符串對應索引所對應的值；如果索引超出邊界則報錯

　　實例：

>>> s = "abcdefg"
>>> print(s[0])
a
>>> print(s[1])
b
>>> print(s[2])
c
>>> print(s[3])
d
>>> print(s[4])
e
>>> print(s[5])
f
>>> print(s[6])
g

----------------索引超出邊界，報錯---------------------------------

　>>> print(s[7])
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　IndexError: string index out of range

 

2.切片

　　說明：通過切片取出字符串的一段字符；

　　格式：str[起始位置:結束位置:步長]

　　參數：起始位置 --------> 表示從哪個下標開始

　　　　　結束位置 --------> 表示到哪個下標結束

　　　　　 步長 --------------> 默認從左到右，步長為1，也可以取反，表示倒敘，步長取負數

　　特點：顧頭不顧尾，從start開始截取. 截取到end位置. 但不包括end

　　返回值：返回一個由切片選擇好的子串；

　　實例：

>>> s = "abcdefg"
>>> print(s[:])
abcdefg
>>> print(s[0:4])
abcd
>>> print(s[2:6])
cdef
>>> print(s[:6:2])
ace
>>> print(s[1::2])
bdf
>>> print(s[::-1])
gfedcba
>>> print(s[-1:-3])

>>> print(s[-1:-3:-1])
gf
>>> print(s[-1::-2])
geca

 

 

 

 

 

 

 

三.轉義字符

　　在需要在字符中使用特殊字符時，python用反斜杠(\)轉義字符。如下表：

四.字符串運算符

下表實例變量a值為字符串 "Hello"，b變量值為 "Python"：

五.字符串格式化

　　Python 支持格式化字符串的輸出 。盡管這樣可能會用到非常復雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。

　　在 Python 中，字符串格式化使用與 C 中 sprintf 函數一樣的語法。

>>> print("中國的首都是%s" % ("北京"))
中國的首都是北京

　　python字符串格式化符號:

　　格式化操作符輔助指令:

六.字符串內置的函數

　　

 

　　1.capitalize(self)

　　說明：將字符串的第一個字符轉換為大寫，其他字母變成小寫；注意的是並不會改變原字符串內容；

　　語法：str.capitalize()

　　返回值：該方法返回一個首字母大寫的字符串；

　　實例：

>>> S = "hello WoRld"
>>> print(S.capitalize())
Hello world

 

　　2.casefold(self)

　　說明：將字符串中的所有大寫字符轉換為小寫字符；並支持識別東歐的一些字母；lower不支持東歐的字母；

　　語法：str.casefold()

　　返回值：返回將字符串中所有大寫字符轉換為小寫后生成的字符串；

　　實例：

>>> S = "hello WoRld"
>>> print(S.casefold())
hello world

 

　　3.center(self, width, fillchar=None)

　　說明：返回一個指定的寬度width且居中的字符串，字符串長度為width，fillchar為填充的字符，默認為空格；

　　語法：str.center(width,fillchar)

　　返回值：返回一個指定的寬度 width 居中的字符串，如果 width 小於字符串寬度直接返回字符串，否則使用 fillchar 去填充。

　　實例：

>>> print("今日頭條".center(40,"*"))
******************今日頭條******************

 

　　4.count(self, sub, start=None, end=None)

　　說明：用於統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置。

　　語法：str.count(sub,start=None, end=None)

　　參數：sub  -----> 要搜索的子字符串；

　　　　　start -----> 字符串開始搜索的位置。默認為第一個字符,第一個字符索引值為0;

　　　　　end ------> 字符串中結束搜索的位置。字符中第一個字符的索引為 0。默認為字符串的最后一個位置;

 　  返回值：返回子字符串在字符串中出現的次數；

　　實例：

>>> print(ss.count("a"))
2
>>> print(ss.count("a",0,8))
1

 

　　5.encode(self, encoding='utf-8', errors='strict')

　　說明：以指定的編碼格式來編碼字符串。errors參數可以指定不同的錯誤處理方案。

　　語法：str.encode(encoding='utf-8', errors='strict')

　　參數：encoding -----> 要使用的編碼，如：UTF-8

　　　　　errors -----> 設置不同錯誤的處理方案。默認為 'strict',意為編碼錯誤引起一個UnicodeError。 其他可能得值有 'ignore', 'replace', 　　　　　　　　　　   'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 注冊的任何值。

　　返回值：返回編碼后的字符串，是一個 bytes 對象

　　實例：

>>> abc = "燈火闌珊"
>>> abc_utf8 = abc.encode("UTF-8")
>>> abc_gbk = abc.encode("GBK")
>>> print(abc)
燈火闌珊
>>> print(abc_utf8)
b'\xe7\x81\xaf\xe7\x81\xab\xe9\x98\x91\xe7\x8f\x8a'
>>> print(abc_gbk)
b'\xb5\xc6\xbb\xf0\xc0\xbb\xc9\xba'

 

　　6.decode(self, decoding='utf-8', errors='strict')

　　說明：以指定的編碼格式來解碼字符串。errors參數可以指定不同的錯誤處理方案。

　　語法：bytes.decode(encoding="utf-8", errors="strict")

　　參數：encoding -----> 要使用的編碼，如：UTF-8

　　　　　errors -----> 設置不同錯誤的處理方案。默認為 'strict',意為編碼錯誤引起一個UnicodeError。 其他可能得值有 'ignore', 'replace', 　　　                                        'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 注冊的任何值。

　　返回值：返回解碼后的字符串；

　　實例：

>>> print(abc_gbk.decode("GBK"))
燈火闌珊
>>> print(abc_utf8.decode("UTF-8"))
燈火闌珊

 

　　7.endswith(self, suffix, start=None, end=None)

　　說明：用於判斷字符串是否以指定后綴結尾，如果以指定后綴結尾返回True，否則返回False；

　　語法：str.endswith(suffix,start=None, end=None)

　　參數：suffix -----> 該參數可以是一個字符串或者是一個元素；

　　　　    start ------> 字符串中的開始位置;

　　　　    end  ------> 字符中結束位置

　　返回值：如果字符串含有指定的后綴返回True，否則返回False；

　　實例：

>>> end = "hello world"
>>> print(end.endswith("ld"))
True
>>> print(end.endswith("ld",0,10))
False

 

　　8.expandtabs(self, tabsize=8)

　　說明：把字符串中的 tab 符號('\t')轉為空格，tab 符號('\t')默認的空格數是 8；

　　注意：規則是這樣的，如果設置空格數是8，則會從開頭查詢，每8個字符為一組，到有\t那組時，缺幾個就補幾個空格；

　　語法：str.expandtabs(tabsize=8)

　　參數：tabszie -----> 指定轉換字符串中的 tab 符號('\t')轉為空格的字符數；

　　返回值：返回字符串中的 tab 符號('\t')轉為空格后生成的新字符串；

　　實例：

>>> ss = "this is \tstring example"
>>> print(ss)
this is     string example
#this is 剛好8個，所以到\t這里自動在補8個空格；

>>> print(ss.expandtabs(0)) 

this is string example 
#0自動沒有

>>> print(ss.expandtabs(20)) 
this is             string example
#this is \t是8個，設置的是20空格，所以還需在補12個空格

 

　　9.find(self, sub, start=None, end=None)

　　說明：檢測字符串中是否包含子字符串 sub ，如果指定 start（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，如果指定范圍內如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。

　　語法：str.find(sub, start=None, end=None)

　　參數：sub ------> 指定檢索的字符串；

　　　　　start -----> 指定開始索引位置，默認為0

　　　　　end  -----> 指定結束索引位置，默認為字符串長度，len(str)

　　返回值：如果包含子字符串返回開始的索引值，否則返回-1；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.find("short"))
12
>>> print(str1.find("short",5,19))
12
>>> print(str1.find("short",17,19))
-1

 

　　10.format(self, *args, **kwargs)

　　說明：format函數用於字符串的格式化，通過{}和:來代替%；傳入的參數兩種形式，一種是位置參數，一種是關鍵字參數；位置參數不受順序約束，且可以為{},只要format里有相對應的參數值即可,參數索引從0開，傳入位置參數列表可用*列表，關鍵字參數值要對得上，可用字典當關鍵字參數傳入值，字典前加**即可，注意的是當位置參數和關鍵字參數混合使用時，位置參數一定要在關鍵字參數左邊。

　　語法：str.format( *args, **kwargs)

　　參數：*args ------> 當傳入的參數為列表時，可用*列表；

　　　　　**kwargs -------> 可用字典當關鍵字參數傳入值，字典前加**即可；

　　返回值：返回一個已經填充好的字符串。

　　例子：

------------------不設置指定位置，按默認順序--------------------------

>>> str2 = "中國的城市有,{},{},{},{}"
>>> print(str2.format("北京","上海","深圳","武安"))
中國的城市有,北京,上海,深圳,武安


----------------設置指定位置-------------------------------------------

>>> str2 = "中國的城市有,{3},{0},{2},{1}"
>>> print(str2.format("北京","上海","深圳","武安"))
中國的城市有,武安,北京,深圳,上海


------------------使用位置-列表形式---------------------------
>>> li = ["北京","上海","深圳","武安"]
>>> print(str2.format(*li))
中國的城市有,北京,上海,深圳,武安

-------------------使用關鍵字位置形式-------------------------
>>> print(str2.format(k2="北京",k3="上海",k1="深圳",k4="武安"}))
中國的城市有,深圳,北京,上海,武安

-------------------使用關鍵字位置字典形式-------------------------
>>> print(str2.format(**{"k2":"北京","k3":"上海","k1":"深圳","k4":"武安"}))
中國的城市有,深圳,北京,上海,武安


-------------------使用混合模式--------------------------------
>>> str2 = "中國的城市有,{3},{0},{2},{1},{h}"
>>> print(str2.format("北京","上海","深圳","武安",**{"h":"石家庄"}))
中國的城市有,武安,北京,深圳,上海,石家庄

　　也可以向.format()傳入對象：

class test():
    def __init__(self,asd):
        self.num = asd
ming = test(6)
print("ming的數字是：{0.num}".format(ming))
#{0.num}中的0是可選的表示指定位置

-------------------輸出結果為------------------------------

ming的數字是：6

　　.format()的數字格式化：

>>> print("{:.2f}".format(3.1415926))
3.14

　　下表展示了 str.format() 格式化數字的多種方法：

>>> print("{}對應的位置是{{0}}".format("zjk"))
zjk對應的位置是{0}

 

　　11.format_map(self, mapping)

　　說明：類似於format，不同的是format_map只能使用關鍵字位置形式傳入字典來進行；

　　語法：str.format_map(mapping)

　　參數：mapping -----> 必須是一個字典；

　　返回值：一個已經填充好的字符串；

　　實例：

>>> print("{name}對應的位置是{{0}}".format_map({"name":"zjk"}))
zjk對應的位置是{0}

 

　　12.index(self, sub, start=None, end=None)

　　說明：檢測字符串中是否包含子字符串 sub ，如果指定 start（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，該方法與 python find()方法一樣，只不過如果sub不在 str中則會報一個異常，而find則是返回-1；

　　語法：str.index(sub,start=None, end=None)

　　參數：sub ------> 指定檢索的子字符串；

　　　　　start -----> 指定開始索引位置，默認為0；

　　　　　end ------> 指定結束索引位置，默認為字符串的長度；

　　返回值：如果包含子字符串返回開始的索引值，否則拋出異常；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.index("short"))
12
>>> print(str1.index("short",14))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

 

　　13.isalnum(self)

　　說明：檢測字符串是否由字母和數字組成；

　　語法：str.isalnum()

　　返回值：如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True,否則返回 False

　　實例：

>>> str1 = "helloworld"
>>> print(str1.isalnum())
True
>>> str2 = "hello world"
>>> print(str2.isalnum())
False

 

　　14.isalpha(self)

　　說明：檢測字符串是否只由字母組成；

　　語法：str.isalpha()

　　返回值：如果字符串至少有一個字符並且所有字符都是字母則返回 True,否則返回 False；

　　實例：

>>> str1 = "python"
>>> print(str1.isalpha())
True
>>> str2 = "python3"
>>> print(str2.isalpha())
False

 

　　15.isdecimal(self)

　　說明：檢查字符串是否只包含十進制字符。這種方法只存在於unicode對象；注意:定義一個十進制字符串，只需要在字符串前添加 'u' 前綴即可。

　　語法：str.isdecimal()

　　返回值：如果字符串只包含十進制字符返回True，否則返回False

　　實例：

>>> str1 = u"zjk2018"
>>> print(str1.isdecimal())
False
>>> str2 = u"201807"
>>> print(str2.isdecimal())
True

 

　　16.isdigit(self)

　　說明：檢測字符串是否只由數字組成；

　　語法：str.isdigit()

　　返回值：如果字符串只包含數字則返回 True 否則返回 False；

　　實例：

>>> str1 = "zjk2018"
>>> print(str1.isdigit())
False
>>> str2 = "201807"
>>> print(str2.isdigit())
True

 

　　17.isidentifier(self)

　　說明：判斷是否為python中的標識符，也就是說是否符合python變量名語法；

　　語法：str.isidentifier()

　　返回值：如果字符串的內容符合python變量命名語法，則返回True，否則返回False；

　　實例：

>>> str1 = "zjk1"
True
>>> str2 = "666zjk"
>>> str2.isidentifier()
False
>>> str3 = "變量名"
>>> str3.isidentifier()
True
>>> str4 = "def"
>>> str4.isidentifier()
True
#python的關鍵字一樣是合法的
>>> str5 = "88888"
>>> str5.isidentifier()
False

 

　　18.islower(self)

　　說明：檢測字符串是否由小寫字母組成；

　　語法：str.islower()

　　返回值：如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False；

　　實例：

>>> str1 = "Life is too short for python -zjk23"
>>> print(str1.islower())
False
>>> str2 = "life is too short for python -zjk23"
>>> print(str2.islower())
True

 

　　19.isnumeric(self)

　　說明：檢測字符串是否只由數字組成。這種方法是只針對unicode對象；注：定義一個字符串為Unicode，只需要在字符串前添加 'u' 前綴即可；

　　語法：str.isnumeric()

　　返回值：如果字符串中只包含數字字符，則返回 True，否則返回 False

　　實例：

>>> str1 = "zjk1995"
>>> print(str1.isnumeric())
False
>>> str2 = "1995"
>>> print(str2.isnumeric())
True

 

　　20.isprintable(self)

　　說明：判斷是否由可打印字符組成，回車符等一些特殊字符是不會打印顯示在屏幕上的；

　　語法：str.isprintable()

　　返回值：如果字符串中所有內容都可打印則返回True，否則返回False；

　　實例：

>>> print("123\t4\t56".isprintable())
False
>>> print("123\\t456".isprintable())
True

 

　　21.isspace(self)

　　說明：檢測字符串是否只由空白字符組成；

　　語法：str.isspace()

　　返回值：如果字符串中只包含空格，則返回 True，否則返回 False；

　　實例：

>>> str1 = "    "
>>> print(str1.isspace())
True
>>> str2 = " sdf sdf"
>>> print(str2.isspace())
False

 

　　22.istitle(self)

　　說明：檢測字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫；

　　語法：str.istitle()

　　返回值：如果字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫則返回 True，否則返回 False；

　　實例：

>>> str1 = "Life Is Too Short For Python"
>>> print(str1.istitle())
True
>>> str2 = "Life is Too short For PyThon"
>>> print(str2.istitle())
False

 

　　23.isupper(self)

　　說明：檢測字符串中所有的字母是否都為大寫；

　　語法：str.isupper()

　　返回值：如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False；

　　實例：

>>> str1 = "LIFE IS TOO SHORT FOR PYTHON"
>>> print(str1.isupper())
True
>>> str2 = "LIFE Is TOO ShOrT FOR PYTHON"
>>> print(str2.isupper())
False

 

　　24.join(self, iterable)

　　說明：用於將序列中的元素以指定的字符連接生成一個新的字符串；

　　語法：n.join(iterable)

　　參數：iterable ------> 要連接的元素序列；

　　　　　n --------------> 指定用來連接的字符；

　　返回值：返回通過指定字符連接序列中元素后生成的新字符串；

　　實例：

>>> str1 = "zjk"
>>> print("-".join(str1))
z-j-k

 

　　25.ljust(self, width, fillchar=None)

　　說明：返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串；

　　語法：str.ljust(width, fillchar=None)

　　參數：width ------> 指定字符串長度；

　　　　　fillchar -----> 填充字符，默認為空格；

　　返回值：返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.ljust(20,"*"))
I Love You**********

------------當指定的填充長度小於原字符串長度時返回原字符串-------

>>> str2 = "I Love You"
>>> print(str1.ljust(10,"*"))
I Love You

 

　　26.lower(self)

　　說明：轉換字符串中所有大寫字符為小寫；

　　語法：str.lower()

　　返回值：返回將字符串中所有大寫字符轉換為小寫后生成的字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.lower())
i love you

 

　　27.lstrip(self, chars=None)

　　說明：用於截掉字符串左邊的空格或指定字符，貪婪模式；

　　語法：str.lstrip( chars=None)

　　參數：chars ------> 指定截取的字符；

　　返回值：返回截掉字符串左邊的空格或指定字符后生成的新字符串；

　　實例：

>>> str1 = "666666I66Love You"
>>> print(str1.lstrip("6"))
I66Love You

 

　　28.maketrans(self, *args, **kwargs)

　　說明：用於創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。兩個字符串的長度必須相同，為一一對應的關系；

　　語法：str.maketrans(intab,outtab)

　　參數：intab -------> 需要轉換的字符串；

　　　　　outtab -----> 被轉換的字符串；

　　返回值：返回的是一個字典，字典內容是字符串的ASCII碼的序號，一一對應

　　實例：

>>> dat = str.maketrans("123","abc")
>>> print(dat)
{49: 97, 50: 98, 51: 99}

-----------------解釋--------------------------
1 的ASCII碼為 49
a 的ASCII碼為 97

 

　　29.partition(self, sep)

　　說明：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　語法：str.partition(sep)

　　參數：sep ------> 指定分隔符

　　返回值：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　實例：

>>> str1 = "http://www.dhlanshan.cn"
>>> print(str1.partition("//"))
('http:', '//', 'www.dhlanshan.cn')

-----------如果指定的分隔符在字符串中有兩個，則以最左側為分隔符----------

>>> print(str1.partition("."))
('http://www', '.', 'dhlanshan.cn')

 

　　30.replace(self, old, new, count=None)

　　說明：將字符串中的某子串進行替換，默認替換指定的所有子串；

　　語法：str.replace(old, new, count=None)

　　參數：old ------> 舊的子串；

　　　　　new -----> 新的子串；

　　　　　count ----> 替換的次數；

　　返回值：返回一個子串替換好之后的新的字符串；

　　實例：

------------------替換所有子串----------------------------

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.replace("a","A"))
http://video.dhlAnshAn.cn

-----------------從左到右只替換1次子串------------------

>>> print(str1.replace("a","A",1))
http://video.dhlAnshan.cn

 

　　31.rfind(self, sub, start=None, end=None)

　　說明：返回指定的子串在字符串中最后一次出現的位置，如果沒有匹配項則返回-1；也可以說是從右邊開始找這個指定的子串；

　　語法：str.rfind(sub, start=None, end=None)

　　參數：sub ------> 指定的子串；

　　　　　start ------> 開始查找的位置，默認為0;

　　　　　end  ------> 結束查找位置，默認為字符串的長度;

　　返回值：返回字符串最后一次出現的位置，如果沒有匹配項則返回-1

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rfind("an"))
20
>>> print(str1.rfind("an",21))
-1

 

　　32.rindex(self, sub, start=None, end=None)

　　說明：返回子字符串 str 在字符串中最后出現的位置，如果沒有匹配的字符串會報異常，和rfind類似，只不過rfind找不到會返回-1；也可以說是從右邊開始找這個指定的子串；

　　語法：str.rindex(sub, start=None, end=None)

　　參數：sub ------> 指定的子串；

　　　　　start ------> 開始查找的位置，默認為0;

　　　　　end  ------> 結束查找位置，默認為字符串的長度;

　　返回值：返回子字符串 str 在字符串中最后出現的位置，如果沒有匹配的字符串會報異常；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rindex("an"))
20

---------------找不到則報錯--------------------------
>>> print(str1.rindex("an",21))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

　　

　　33.rjust(self, width, fillchar=None)

　　說明：返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串。

　　語法：str.rjust(width, fillchar=None)

　　參數：width ------> 指定填充指定字符后中字符串的總長度；

　　　　　fillchar -----> 填充的字符，默認為空格；

　　返回值：返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rjust(30,"-"))
-----http://video.dhlanshan.cn

 

　　34.rpartition(self, sep)

　　說明：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串，分隔符從字符串的右邊開始查找。

　　語法：str.rpartition(sep)

　　參數：sep ----->指定分隔符；

　　返回值：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rpartition("."))
('http://video.dhlanshan', '.', 'cn')

 

　　35.rsplit(self, sep=None, maxsplit=-1)

　　說明：分隔字符串，從右側開始分隔，返回一個將字符串以指定分隔符分隔的列表，從右邊開始查找分隔符,默認空格為分隔符；注意，最后列表里是不存在指定的那個分隔符的；

　　語法：str.rsplit(sep=None, maxsplit=-1)

　　參數：sep ------> 指定分隔符；

　　　　　maxsplit ------> 最多分隔的次數，-1表示全部分隔；

　　返回值：返回一個將字符串以指定分隔符分隔的列表；

　　實例：

--------------------分隔所有--------------------------------------
>>> str1 = "1 2 3 4 5"
>>> print(str1.rsplit(" ",maxsplit=-1))
['1', '2', '3', '4', '5']

-------------------分隔2次---------------------------------------
>>> print(str1.rsplit(" ",maxsplit=2))
['1 2 3', '4', '5']

--------------------列表中會刪除指定的分隔符-----------------
>>> print(str1.rsplit("3",maxsplit=1))
['1 2 ', ' 4 5']

 

　　36.rstrip(self, chars=None)

　　說明：刪除 string 字符串最右邊的指定字符（默認為空格）；貪婪模式；

　　語法：str.rstrip(chars=None)

　　參數：chars ------> 指定的子符；

　　返回值：返回刪除 string 字符串最右邊的指定字符后生成的新字符串；

　　實例：

>>> str1 = "**********今日說法**************"
>>> print(str1.rstrip("*"))
**********今日說法

 

　　37.split(self, sep=None, maxsplit=-1)

　　說明：分隔字符串，從左側開始分隔，返回一個將字符串以指定分隔符分隔的列表，從左邊開始查找分隔符,默認空格為分隔符；注意，最后列表里是不存在指定的那個分隔符的；

　　語法：str.rsplit(sep=None, maxsplit=-1)

　　參數：sep ------> 指定分隔符；

　　　　　maxsplit ------> 最多分隔的次數，-1表示全部分隔；

　　返回值：返回一個將字符串以指定分隔符分隔的列表；

　　實例：

--------------------分隔所有--------------------------------------
>>> str1 = "1 2 3 4 5"
>>> print(str1.split(" ",maxsplit=-1))
['1', '2', '3', '4', '5']

-------------------當分隔符為整個字符串時則返回一個有兩個空字符串的元素的列表----------------------

>>> str1 = "1 2 3 4 5"
>>> print(str1.split("1 2 3 4 5",maxsplit=-1))
['', '']

-------------------分隔2次---------------------------------------
>>> print(str1.split(" ",maxsplit=2)) ['1','2','3 4 5'] --------------------列表中會刪除指定的分隔符-----------------
>>> print(str1.split("3",maxsplit=1)) ['1 2 ', ' 4 5']

 

　　38.splitlines(self, keepends=None)

　　說明：按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。

　　語法：str.splitlines(keepends=None)

　　參數：keepends -- 在輸出結果里是否去掉換行符('\r', '\r\n', \n')，默認為 False，不包含換行符，如果為 True，則保留換行符

　　返回值：返回一個包含各行作為元素的列表。

　　實例：

>>> print("abc\n\ndefg\rkl\r\n".splitlines())
['abc', '', 'defg', 'kl']
>>> print("abc\n\ndefg\rkl\r\n".splitlines(True))
['abc\n', '\n', 'defg\r', 'kl\r\n']

 

　　39.startswith(self, prefix, start=None, end=None)

　　說明：用於檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 start 和 end 指定值，則在指定范圍內檢查。

　　語法：str.startswith(prefix, start=None, end=None)

　　參數：prefix ------> 指定的子串；

　　　　　start  -------> 索引開始處；

　　　　　end  --------> 索引結尾處；

　　返回值：如果檢測到字符串則返回True，否則返回False；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.startswith("http"))
True
>>> print(str1.startswith("video",7))
True
>>> print(str1.startswith(":",6,9))
False

 

　　40.strip(self, chars=None)

　　說明：用於移除字符串頭尾指定的字符（默認為空格）或字符序列。注意：該方法只能刪除開頭或是結尾的字符，不能刪除中間部分的字符。

　　語法：str.strip(chars)

　　參數：chars -------> 移除字符串頭尾指定的字符序列；

　　返回值：返回移除字符串頭尾指定的字符序列生成的新字符串；

　　實例：

>>> str1 = "**********今*日*說*法**************"
>>> print(str1.strip("*"))
今*日*說*法

　　無敵匹配法：

　　先看效果：

>>> str1 = "12345654321"
>>> print(str1.strip("12"))
3456543
>>> str1 = "12345654312"
>>> print(str1.strip("12"))
3456543
>>> str1 = "12345654321"
>>> print(str1.strip("125"))
3456543
>>> str1 = "1234565431221"
>>> print(str1.strip("12"))
3456543
>>> str1 = "1234565432121"
>>> print(str1.strip("12"))
3456543
 ----------------------------------------說明--------------------------------
#其實“12”是分為了3個匹配符，分別是"1" "2" "12",這三個匹配符會循環去匹配字符串，直到這三個匹配符一個也匹配不上為止。

 

　　41.swapcase(self)

　　說明：用於對字符串的大小寫字母進行轉換，小寫變大寫，大寫變小寫；

　　語法：str.swaocase()

　　返回值：返回大小寫字母轉換后生成的新字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.swapcase())
i lOVE yOU

 

　　42.title(self)

　　說明：返回"標題化"的字符串,就是說所有單詞的首個字母轉化為大寫，其余字母均為小寫；注意，默認是按空格來分單詞，也可以是其他特殊字符或數字。

　　語法：str.title()

　　返回值：返回"標題化"的字符串,就是說所有單詞的首字母都轉化為大寫。

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.title())
Life Is Too Short For Python

 　　使用特殊字符或數字來區分：

>>> str1 = "zjk zjk*zjk&zjk^zjk@,zjk.zjk9zjk8zjk/zjk"
>>> print(str1.title())
Zjk Zjk*Zjk&Zjk^Zjk@,Zjk.Zjk9Zjk8Zjk/Zjk

 

　　43.translate(self, table)

　　說明：根據由maketrans函數生成的對照表table完成字符替換；

　　語法：str.tarnslate(table)

　　參數：table ---- 對照表，是由maketrans函數生成；

　　返回值：返回翻譯后的字符串；

　　實例：

>>> table = str.maketrans("zjk","666")
>>> str = "zjkqwert"
>>> print(str.translate(table))
666qwert

 

　　44.upper(self)

　　說明：將字符串中的小寫字母轉為大寫字母；

　　語法：str.upper()

　　返回值：返回小寫字母轉為大寫字母的字符串；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.upper())
LIFE IS TOO SHORT FOR PYTHON

 

　　45.zfill(self, width)

　　說明：返回指定長度的字符串，原字符串右對齊，前面填充0，若指定長度小於原字符串長度，則返回原字符串；

　　語法：str.zfill(width)

　　參數：width -------> 指定字符串的長度。原字符串右對齊，前面填充0;

　　返回值：返回指定長度的字符串；

　　實例：

>>> str = "zjkqwert"
>>> print(str.zfill(10))
00zjkqwert
>>> print(str.zfill(6))
zjkqwert