python開發【基礎二】

基本數據類型：

一、數字

　　在Python2中，分爲整形(int)和長整形(long)。

　　在Python3中，都是int。

#一、將字符串轉換爲數字
a = "123"
v = int(a)
print(v)
print(type(v))

#二、當前數字的二進制，至少用幾位表示

'''
1位等於8個字節.
佔2個字節的：帶有附加符號的拉丁文、希臘文、西裏爾字母、亞美尼亞語、希伯來文、阿拉伯文、敘利亞文及它拿字母則須要二個字節編碼

佔3個字節的：基本等同於GBK，含21000多個漢字

佔4個字節的：中日韓超大字符集裏面的漢字，有5萬多個

一個utf8數字佔1個字節

一個utf8英文字母佔1個字節

少數是漢字每一個佔用3個字節，多數佔用4個字節。
'''
b = 5
v = b.bit_length()
print(v)

int

二、字符串

字符串的索引、切片、步長
格式[索引:索引:步長]，原則，顧頭不顧尾
a = 'ABCDEFGHIJKLMN'
print(a[2])         # 字符串的索引，0爲起始，-1爲最後。
print(a[0:3])       # 字符串的切片。顧頭不顧尾，取值爲0,1,2三個索引對應的值。
print(a[0:])        # 默認到最後。
print(a[0:-1])      # -1默認爲最後，可是顧頭不顧尾，取不到最後一個值N。
print(a[:10:2])     # 加步長。
print(a[-1:-10:-2]) # 反向步長。步長鬚爲-2，若是爲2的話，會往右取值。

#!/usr/bin/env python
# -*- conding:utf-8 -*-
# 一、capitalize(self):
# 做用：首字母大寫
'''
name = "a_catinsky"
v = name.capitalize()
print(v)
'''

# 二、casefold(self):
# 做用：將全部大寫字母變爲小寫
'''
a = "catInSky"
v = a.casefold()
print(v)
'''

# 三、center(self, width, fillchar=None):
# 做用：設置字符佔用的總長度
# width:設置總寬度，fillchar:設置填充字符，只能爲一個字符。
# 例子：設置變量username的寬度爲20字符，並居中顯示，不足位置使用*號代替。
'''
username = "cat"
v = username.center(20,'*')
print(v)
'''

# 四、count(self, sub, start=None, end=None):
# 做用：統計子序列數量
# start=None, end=None，設置開始的和結束的字符位置
# 例子：統計字符串"c"，在變量username中，從6--10出現的次數。
'''
username = "catinsky_catinsky"
v = username.count("c",6,10)
print(v)
'''

# 五、encode與decode(self, encoding='utf-8', errors='strict'):
# 描述：以指定的編碼格式編碼字符串。errors參數能夠指定不一樣的錯誤處理方案。
'''
username = "那隻貓飛走了"
v1_gbk = username.encode("gbk")
print("GBK編碼：",v1_gbk)
v2_utf8 = username.encode("utf-8")
print("UTF-8編碼：",v2_utf8)
#反編譯，將utf-8編碼轉換爲utf-8
v3 = v1_gbk.decode("gbk")
print("反編譯GBK：",v3)
v4 = v2_utf8.decode("utf-8")
print("反編譯UTF-8：",v4)
'''
# 六、decode
# 以指定的編碼格式解碼字符串，示例如上。

# 七、endswith(self, suffix, start=None, end=None)：
# 判斷字符串是否以指定後綴結尾，若是以指定後綴結尾返回True，不然返回False。
# 可選參數"start"與"end"爲檢索字符串的開始與結束位置。
'''
username = "catinsky"
v = username.endswith("in",2,5)
print(v)
a = username.startswith("cat",0,10)
print(a)
'''
# 八、startswith
# 判斷字符串是否以指定字符開始，結果返回bool值。示例如上。

# 九、expandtabs(self, tabsize=8):
# 描述：把字符串的Tab符號(/t)，轉換爲空格。默認空格數量是8。
# 參數：tabsize -- 指定轉換字符串中的 tab 符號('\t')轉爲空格的字符數。
# 參數：tabsize -- 跟center函數相似。設置字符佔用的總長度，不足的用空格補上，且左對齊。而center是居中。
# 例1：
'''
text = "username\tpassword\temail\ncatinsky\t******\tcatinsky@qq.com\ncat\t******\tcat@qq.com"
v = text.expandtabs(15)
print(v)
'''
# 例2：
'''
test = "My name is\tcat\tinsky,What is your name?"
v = test.expandtabs()
print(v)
'''

# 十、find(self, sub, start=None, end=None):
# 描述：檢查字符串中，是否包含指定字符。若是包含則返回開始的索引值，不然返回數字-1.
'''
username = "catinskyc"
user = "in"
v = username.find(user)
print(v)                        # 從下標0開始，查找在字符串裏第一個出現的子串，返回結果：3
print(username.find("c"))       # 從下標0開始，查找在字符串裏第一個出現的子串，返回結果：0
print(username.find("c",1))     # 從下標0開始，查找在字符串裏第一個出現的子串，返回結果：8
print(username.find("p",0))     # 從下標0開始，查找在字符串裏第一個出現的子串，返回結果：-1
'''

# 十一、format(self, *args, **kwargs):
# 描述：格式化函數
'''
print("個人名字：{name},個人郵箱：{url}".format(name = "李白",url = "libai@qq.com"))
# 經過字典設置參數
site = {"name": "個人名字", "url": "www.abc.com"}
print("網站名：{name}, 地址 {url}".format(**site))

# 經過列表索引設置參數
my_list = ['個人名字', 'www.abc.com']
print("網站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必須的
'''

# 十二、index(self, sub, start=None, end=None):
# index() 方法檢測字符串中是否包含子字符串 str ，若是指定 start（開始） 和 end（結束） 範圍，
# 則檢查是否包含在指定範圍內，該方法與 python find()方法同樣，只不過若是str不在 string中會報一個異常。
# 不建議使用此函數，不如使用find函數。由於若是不包含時，報錯，而find是返回數值-1。

# 1三、isalnum(self):
# 描述：檢測字符串是否由字母和數字組成。
'''
name = "catinsky01"     #字符中沒有空格
v = name.isalnum()
print(v)    #結果爲：True

name1 = "catinsky 01"     #字符中有空格
v = name1.isalnum()
print(v)    #結果爲False
'''

# 1四、isalpha(self):
# 描述：檢測字符串是否所有由字母組成，所有爲字母返回True，不然返回false。
'''
name = "catinsky "
v = name.isalpha()
print(v)    #有空格則爲False
'''

# 1五、isdecimal(self):
# 判斷字符串是否只有數字組成，不能判斷 ①② 這種數字。返回值爲True或False:
'''
text = "123①"
v = text.isdecimal()
print(v)    #返回結果爲False;
'''

# 1六、isdigit(self):
# 判斷字符串是否只有數字組成，能判斷 ①② 這種數字。返回值爲True或False:
'''
text = "123①"
v = text.isdigit()
print(v)    #返回結果爲True;
'''
# 1七、isnumeric(self):
# 檢測字符串中只包含數字字符，則返回 True，不然返回 False
# 若是是utf-8漢字，則爲True，好比1、2、三等
'''
text = "abc123"
v1 = text.isdecimal()
v2 = text.isdigit()
v3 = text.isnumeric()
print(v1)
print(v2)
print(v3)

text = "二"
v1 = text.isdecimal()
v2 = text.isdigit()
v3 = text.isnumeric()
print(v1)
print(v2)
print(v3)
'''
# isdecimal、isdigit、isnumeric的區別
'''
isdigit()
True: Unicode數字，byte數字（單字節），全角數字（雙字節），羅馬數字
False: 漢字數字
Error: 無

isdecimal()
True: Unicode數字，，全角數字（雙字節）
False: 羅馬數字，漢字數字
Error: byte數字（單字節）

isnumeric()
True: Unicode數字，全角數字（雙字節），羅馬數字，漢字數字
False: 無
Error: byte數字（單字節）
'''

# 1八、isidentifier(self):
# 判斷字符串是否以字母、數字、下劃線開頭。返回值爲True或False。
'''
text = "_123"
v = text.isidentifier()
print(v)    #返回值True
text = "abc"
v = text.isidentifier()
print(v)    #返回值True
text = "123"
v = text.isidentifier()
print(v)    #返回值False
'''

# 1九、islower(self):
# 判斷字符串字母是否都是小寫或數字，則返回 True，不然返回 False。
'''
test = "Acb"
v1 = test.islower()
print(v1)   #結果爲False
test = "abc123"
v2 = test.islower()
print(v2)   #結果爲True
'''

# 20、isprintable(self):
# 判斷是否存在不可見字符，例如換行符\n,\t等。
'''
test = "catin\tsky"
v = test.isprintable()
print(v)    #結果爲False
'''

# 2一、isspace(self):
# 判斷是否所有是空格
'''
test = "   "
v1 = test.isspace()
print(v1)   #結果爲True
test = "cat  in  sky"
v2 = test.isspace()
print(v2)   #結果爲False
'''

# 2二、title(self):
# 2三、istitle(self):
# title，將字符串轉換爲標題，每一個單詞首字是大寫的就是標題。
# istitle，判斷字符串是否爲標題，返回值爲True或False。
'''
test = "My name is catinsky"
v1 = test.istitle()
print(v1)   #結果爲False
v2 = test.title()
print(v2)   #結果爲"My Name Is Catinsky"
v3 = v2.istitle()
print(v3)   #結果爲True
'''

# 2四、isupper(self):
# 判斷字符串是否所有是大寫
# upper，將字符串轉換爲所有是大寫
'''
test = "MY NAME IS CATINSKY"
v1 = test.isupper()
print(v1)   #結果爲True
test = "My Name is catinsky"
v2 = test.isupper()
print(v2)   #結果爲False
'''

# 2五、join(self, iterable):
# 將序列中的元素以指定的字符鏈接生成一個新的字符串。
'''
text = "春風又綠江南岸"
t = "_"
v = t.join(text)
print(v)
'''

# 2六、ljust(self, width, fillchar=None):
# 2七、rjust(self, width, fillchar=None):
# 2八、zfill(self, width):
# 原字符串左對齊,並使用 fillchar 填充至長度 width 的新字符串，fillchar 默認爲空格。
# 原字符串右對齊,並使用 fillchar 填充至長度 width 的新字符串，fillchar 默認爲空格。
# 返回長度爲 width 的字符串，原字符串右對齊，前面填充0
'''
test = "catsky"
v1 = test.ljust(20,"*")
print(v1)   #輸出結果爲：catsky**************
v2 = test.rjust(20,"#")
print(v2)   #輸出結果爲：##############catsky
'''

# 2九、lower(self):
# 將字符串所有轉換爲小寫
# islower判斷字符串是否所有爲小寫
'''
test = "CatInsky"
v = test.lower()
print(v)
'''

# 30、upper:
# 將字符串所有轉換爲大寫
# isupper判斷字符串是否所有爲大寫
'''
name = "catinsky"
v = name.upper()
print(v)
'''

# 3一、lstrip(self, chars=None):
# 3二、rstrip(self, chars=None):
# 3三、strip(self, chars=None):
# 用於去除字符串左邊的空格（包含\n和\t）或指定字符。
# 用於去除字符串右邊的空格（包含\n和\t）或指定字符。
# 用於去除字符串左邊和右邊的空格（包含\n和\t）或指定字符。只能去除兩邊，不能去除中間字符。
# 筆記：一、strip() 處理的時候，若是不帶參數，默認是清除兩邊的空白符，例如：/n, /r, /t, ' ')。
# 二、strip() 帶有參數的時候，這個參數能夠理解一個要刪除的字符的列表，是否會刪除的前提是從字符串
# 最開頭和最結尾是否是包含要刪除的字符，若是有就會繼續處理，沒有的話是不會刪除中間的字符的。
'''
name = "***my* *name* ***is*** ***catinsky***"
v1 = name.strip("*")
print(v1)
#輸出結果爲： my* *name* ***is*** ***catinsky，去除左右兩邊的*字符，不能去除中間的。
name = " cat in sky "
v2 = name.strip()
print(v2)   #返回結果爲：cat in sky，默認去除左右兩邊的空格，但不能去除中間的。
name = "catinsky\t   "
v3 = name.strip()
print(v3)   #輸出結果爲catinsky，去除了\t和右邊的空白。
name = "catinsky"
v4 = name.strip("in")
print(v4)   #輸出結果爲catinsky，不能去除中間的in字符。
'''

# 3四、maketrans(self, *args, **kwargs):
# 3五、translate(self, table):
# maketrans,建立字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，
# 第一個參數是字符串，表示須要轉換的字符，第二個參數也是字符串表示轉換的目標。
# translate,根據 maketrans 給出的表，替換爲新的字符串。
'''
a = "ctns"
trans_name = "1235"
name = "catinsky"
v1 = name.maketrans(a,trans_name)   #製做翻譯表
print(name.translate(v1))
'''

# 3六、partition(self, sep):
# 3七、rpartition(self, sep):
# 將字符串以指定字符分隔，只能分紅3部分，且去除分隔字符。

# 3八、split(self, sep=None, maxsplit=-1):
# 3九、rsplit(self, sep=None, maxsplit=-1):
# 經過指定分隔符對字符串進行切片，可分多個部分，且去除分隔字符。
# split()方法語法：
# str.split(str="", num=string.count(str))
# str -- 分隔符，默認爲全部的空字符，包括空格、換行(\n)、製表符(\t)等。
# num -- 分割次數。

# 40、splitlines(self, keepends=None):
# 按照行('\r', '\r\n', \n')分隔，返回一個包含各行做爲元素的列表，
# 若是參數 keepends 爲 False，不包含換行符，若是爲 True，則保留換行符。
# partition例子：
'''
name = "catinskycatinsky"
v1 = name.partition("s")
print(v1)   #返回結果爲：('catin', 's', 'kycatinsky')
'''
# split例子1：
'''
name = "catinskycatinskycatinsky"
v2 = name.split("s")
print(v2)   # 返回結果爲：['catin', 'kycatin', 'kycatin', 'ky']
'''
# split例子2：
'''
str = "this is string example....wow!!!"
print (str.split( ))      # 輸出結果：['this', 'is', 'string', 'example....wow!!!']
print (str.split('i',1))  # 輸出結果：['th', 's is string example....wow!!!']
print (str.split('w'))    # 輸出結果：['this is string example....', 'o', '!!!']
'''

# 4一、replace(self, old, new, count=None):
# 把字符串中的 old（舊字符串）替換成 new(新字符串)，若是指定第三個參數max，則替換不超過 max 次。
# 語法：str.replace(old, new[, max])
# 參數：
# old -- 將被替換的子字符串。
# new -- 新字符串，用於替換old子字符串。
# max -- 可選字符串, 替換不超過 max 次
'''
str = "www.w3cschool.cc"
print ("菜鳥教程舊地址：", str)
print ("菜鳥教程新地址：", str.replace("w3cschool.cc", "runoob.com"))

str = "this is string example....wow!!!"
print (str.replace("is", "was", 3))
以上實例輸出結果以下：

菜鳥教程舊地址： www.w3cschool.cc
菜鳥教程新地址： www.runoob.com
thwas was string example....wow!!!
'''

# 4二、swapcase(self):
# 將字符串中大寫轉換爲小寫，小寫轉換爲大寫
'''
name = "Cat in Sky !"
v = name.swapcase()
print(v)    #返回結果爲：cAT IN sKY !
'''

# #################字符串的灰魔法##################
# 4三、獲取字符串中的某一個字符
# 獲取指定字符
'''
name = "catinsky"
v = name[1]
print(v)    # 返回結果爲:a
'''
# 切片
'''
name = "catinsky"
v1 = name[0:4] # 獲取大於等0，小於4之間的字符
print(v1)   # 返回結果爲：cati
'''
# 例子2：
'''
name = "catinsky"
v2 = name[0:-2] # 獲取第1個至倒數第2個之間的字符，包含第1個，但不包含倒數第2個。
print(v2)   # 返回結果爲：catins
'''

# 4四、len獲取字符串中有幾個字符組成
'''
name = "春風又綠江南岸"
v = len(name)
print(v)    # 返回結果爲7，在python2中則是其餘數字。
'''

# 4五、for循環
'''
name = "春風又綠江南岸"
for i in name:
    print(i)
'''

# 4六、用戶輸入驗證碼
"""
def check_code():
    import random
    checkcode = ''
    for i in range(4):
        current = random.randrange(0,4)
        if current != i:
            temp = chr(random.randint(65,90))
        else:
            temp = random.randint(0,9)
        checkcode += str(temp)
    return checkcode

while True:
    code = check_code()
    print(code)
    user_code = input(">>>請輸入驗證碼：")
    v = user_code.upper()
    if code == v:
        print("驗證經過")
        break
    else:
        print("驗證碼錯誤")
"""

# 屏蔽關鍵字
'''
user_input = input("請輸入內容：")
maket = ("蒼井空,東京熱")
trans = ("***,***")
v1 = user_input.maketrans(maket,trans)
print(user_input.translate(v1))
'''

string

三、列表

#!/usr/bin/env python
# -*- conding:utf-8 -*-
# ###############列表的8個特徵###############
# 一、列表(list)的格式、特色
"""
li = [11,"字符串",["列表",23],True]
列表能夠包含數字、字符串、列表、布爾值，例如：
"""
# 二、列表能夠索引取值
"""
li = [11,"李白",["劉備",["曹操",23]],True]
v = li[2][1][0]
print(v)    # 返回結果爲：曹操
"""
# 三、列表能夠切片取值
"""
li = [11,"李白",["劉備",["曹操",23]],True]
v = li[1:-1]    # 取第一個至倒數第一個之間的值
print(v)
"""
# 四、列表能夠for和while循環
"""
li = [11,"李白",["劉備",["曹操",23]],True]
while True:
   if "李白在" in li:
       print("存在")
       break
   else:
       print("不存在")
       break
"""
# 五、列表能夠被修改（索引和切片均可以修改）
# a、索引修改
"""
li = [11,"李白",["劉備",["曹操",23]],True]
li[1] = "孫權"
print(li) 
"""
# b、切片修改
"""
li2 = [11,"李白",["劉備",["曹操",23]],True]
li2[1:3] = ["關羽", "張飛", "劉備"]
print(li2)
"""
# 六、列表能夠被刪除
# a、索引刪除
"""
li = [11, "李白", ["劉備", ["曹操", 23]], True]
del li[2][1][1]  # 刪除數字23
print(li)
"""
# b、切片刪除
"""
li = [11, "李白", ["劉備", ["曹操", 23]], True]
del li[1:3] # 刪除索引0-3之間的元素，不會刪除索引位置爲3的元素
print(li)   # 返回結果爲：[11, True]
"""
# 七、in 操做，結果爲布爾值
"""
li = [11, "李白", ["劉備", ["曹操", 23]], True]
v1 = "劉備" in li
print(v1)   # 返回結果爲：False
v2 = "李白" in li
print(v2)   # 返回結果爲：True
"""
# 八、數據類型轉換
# a、字符串轉換爲列表
"""
a = "coincidance"
a1 = "新三國"
v = list(a)
print(v)    # 返回值爲：['c', 'o', 'i', 'n', 'c', 'i', 'd', 'a', 'n', 'c', 'e']
# 將字符串的每一個字符for循環後，當爲列表的元素。
"""
# b、將列表轉換爲字符串
# 方法1：
"""
a = [123,"abc",[5,"劉備"]]
v = str(a)
print(a)    # 返回結果爲：[123, 'abc', [5, '劉備']]
# 將整個列表看成字符串處理。
"""
# 方法2：
"""
b = [123,"abc",[5,"劉備"]]
s = ""
for i in b:
    s = s + str(i)
print(s)    # 返回結果爲：123abc[5, '劉備']
# 定義變量s接收for循環的值，for循環的i值轉換爲字符串，而後字符能夠相加拼接。
"""
# 九、字符串一旦被建立，便不能修改
"""
a = "abc"
a = a.replace("a","99")
print(a)
"""
# ###############列表list的函數###############
# 一、len(list)
# 列表的元素個數
"""
list1 = ['Google', 'Runoob', 'Taobao']
print(len(list1))
list2 = list(range(5))  # 建立一個 0-4 的列表
print(len(list2))
"""
# 二、max(list)
# 列表元素最大值
"""
list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]
print ("list1 最大元素值 : ", max(list1))
print ("list2 最大元素值 : ", max(list2))
"""
# ###############列表list的功能###############
# 一、append(self, p_object):
# 在列表末尾添加新的對象object
"""
li = [123,"abc",[5,"劉備"]]
v = li.append([23,"關羽"])
print(v)
print(li)
"""
# 二、clear(self):
# 清空列表
"""
li = [123,"abc",[5,"劉備"]]
li.clear()
print(li)
"""
# 三、copy(self):
# 使用=直接賦值，是引用賦值，更改一個，另外一個一樣會變。複製一個副本，原值和新複製的變量互不影響。
"""
li = [0,1,2,3,4,5]
a = li
b = li.copy()
del a[1]
b.append(9)
print(li)   # 返回值：[0, 2, 3, 4, 5]
print(a)    # 返回值：[0, 2, 3, 4, 5]
print(b)    # 返回值：[0, 1, 2, 3, 4, 5, 9]
"""
# 四、count(self, value):
# 統計某個元素在列表中出現的次數
"""
li = [0,1,2,3,4,5,2,2]
v = li.count(2)
print(v)
"""
# 五、extend(self, iterable):
# 在列表末尾一次性追加另外一個序列中的多個值（用新列表擴展原來的列表）
"""
list1 = ["關羽","張飛","劉備"]
list2 = list(range(5))
print(list2)    # 返回結果爲：[0, 1, 2, 3, 4]
list1.extend(list2)
print(list1)    # 返回結果爲：['關羽', '張飛', '劉備', 0, 1, 2, 3, 4]
"""
# 六、index(self, value, start=None, stop=None):
# 從列表中找出某個值第一個匹配項的索引位置
"""
li = [11, 22, 33, 22, 44]
v = li.index(22)
print(v)
"""
# 七、insert(self, index, p_object):
# 將對象插入列表
"""
list1 = ["關羽","張飛","劉備"]
list1.insert(1,"趙雲")    # 在索引爲1的位置插入字符串「趙雲」。
print(list1)    # 返回結果爲：['關羽', '趙雲', '張飛', '劉備']
"""
# 八、pop(self, index=None):
# 刪除某個值(1.指定索引；2. 默認最後一個)，並獲取刪除的值。
"""
list1 = ["關羽", "張飛", "劉備"]
v1 = list1.pop()
print("默認刪除最後一個元素：", v1.center(6))
print ("刪除後的列表：", str(list1).center(30))

list2 = ["關羽", "張飛", "劉備"]
list2.pop(1)    # 指定刪除的索引位置
print(list2)    # 返回值爲：['關羽', '劉備']
"""
# 九、remove(self, value):
# 移除列表中某個值的第一個匹配項
"""
list1 = ["關羽", "張飛", "劉備"]
list1.remove("關羽")
print(list1)    # 返回值爲：['張飛', '劉備']
"""
# 十、reverse(self):
# 將列表中的元素進行反轉
"""
list1 = ["關羽", "張飛", "劉備"]
list1.reverse()
print(list1)    #返回值爲：['劉備', '張飛', '關羽']
"""
# 十一、sort(self, key=None, reverse=False):
# cmp -- 可選參數, 若是指定了該參數會使用該參數的方法進行排序。
# key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。
# reverse -- 排序規則，reverse = True 降序， reverse = False 升序（默認）。
"""
li = [11,44, 22, 33, 22]
li.sort()
print(li)
"""

list

四、元組

#!/usr/bin/env python
# -*- conding:utf-8 -*-
# ########元組Tuple的特色########
# 一、元組裏的一級元素，不可被修改，刪除或者增長。
# tu = (11,"劉備",[22,"列表"],(33,"元組"),True)
# 二、元組的索引
"""
tu = (11,"劉備",[22,"列表"],(33,"元組"),True,)
v = tu[1]
print(v)    # 返回結果爲：劉備
"""
# 三、元組的切片
"""
tu = (11,"劉備",[22,"列表"],(33,"元組"),True,)
v = tu[0:2]
print(v)    #返回結果爲：(11, '劉備')
"""
# 四、元組的轉換
"""
tu1 = "字符串"
tu2 = [11, "列表"]
tu3 = (22, "元組",)
v1 = tuple(tu1)  # 將字符串轉換爲元組
print(v1)  # 返回結果爲：('字', '符', '串')
v2 = tuple(tu2)  # 將列表轉換爲元組
print(v2)  # 返回結果爲：(11, '列表')
v3 = list(tu3)  # 將元組轉換爲列表
print(v3)   # 返回結果爲：[22, '元組']
"""
# 五、元組的一級元素不可被修改、刪除、增長
"""
tu = (11, "劉備", [22, "列表"], (33, "元組"), True,)
tu[2][1] = "關羽"  # 元組二級元素的修改
print(tu)  # 返回結果爲：(11, '劉備', [22, '關羽'], (33, '元組'), True)
tu[2].append("趙雲")
print(tu)   # 返回結果爲：(11, '劉備', [22, '關羽', '趙雲'], (33, '元組'), True)
tu[2].insert(0, "孫權")
print(tu)   # 返回結果爲：(11, '劉備', ['孫權', 22, '關羽', '趙雲'], (33, '元組'), True)
"""

tuple

五、字典

六、布爾值