Python:字典列表字串方法測試

gaopengtttt發表於2018-03-13
Python字串
測試的一些Python中的關於字典、列表、字串的使用方法，放在這裡備查。
整個測試程式碼和說明如下：

點選(此處)摺疊或開啟

  1. # -*- coding: utf-8 -*-
  2. """Python:函式中全是指標傳遞，而任何變數都是給予一個指標指向一個記憶體空間"""

  4. import types
  5. import copy
  6. import string

  8. ###define _Debug to enable assert

  10. __Debug__=1

  12. def my_format(x,y):
  13.         """par one: what des your print
  14.            par two: value
  15.         """
  16.         x="-->"+x+" {}"
  17.         print(x.format(y))
  18.         return

  20. def get_format(s,len):
  21.     """頭部分割"""
  22.     len1 = int(len/2)
  23.     print("%s %s %s" %("="*len1,s,"="*len1))
  24.     return

  26. def get_pointer(y,obj):
  27.     """獲得obj中每個元素的記憶體地址並且列印"""
  28.     list_index=[]
  29.     list_values=[]
  30.     if __Debug__:
  31.         assert isinstance(obj,list) or isinstance(obj,dict) or isinstance(obj,str)
  32.     if isinstance(obj,list) or isinstance(obj,str):
  33.         for i in range(len(obj)):
  34.             list_index.append(i)
  35.             list_values.append("0X{:x}".format(id(obj[i])))
  36.     else: ##對於字典來講這樣取應該是不對的，但是可以用作測試
  37.         key_list = list(obj.keys())
  38.         for i in range(len(key_list)):
  39.             list_index.append(key_list[i])
  40.             list_values.append("0X{:x}".format(id(obj[key_list[i]])))

  42.     y = "-->" + y + " {}"
  43.     print(y.format(list(zip(list_index,list_values))))
  44.     return

  46. def convert_to_int(obj):
  47.     """將list中的字元也轉換為ASCII返回一個新list"""
  48.     list_test_m=[]
  49.     if __Debug__:
  50.         assert isinstance(obj,list)
  51.     for m in obj:
  52.         if isinstance(m, str):
  53.             list_test_m.append(ord(m))
  54.         else:
  55.             list_test_m.append(m)

  57.     return list_test_m

  59. def init_smaple(x):
  60.     """初始化測試資料"""
  61.     if __Debug__:
  62.         assert str(type(x))=="<class 'list'>"
  63.     for i in range(10):
  64.         x.append(i)
  65.     return tuple(x)

  67. sample_list=[] #外部全域性變數
  68. sample_tupe= init_smaple(sample_list) #外部全域性變數

  70. def main_dict(dict_test):
  71.     """測試的dict一些常用的方法:
  72. 1、字典的鍵不可能相同
  73. 2、字典是hash演算法KEY-VALUES的資料結構
  74. 3、字典沒有順序，這是hash演算法註定的
  75. 4、查詢時間複雜度O(1)
  76. 5、不能進行切片操作

  78. """
  79.     #part1:最簡單的更改和增加字典的方式
  80.     dict_test['gaopeng_4'] = '44'
  81.     dict_test['gaopeng_5'] = '44'
  82.     dict_test['gaopeng_5'] = '55'
  83.     dict_test['gaopeng_5'] = '0' #修改

  85.     my_format ("part1:simple add modify value",dict_test)

  87.     #part2:setdefault:會返回原有的值 並且更新 如果沒有則設定一個,返回老值 注意和get的區別 part10 get不會更新只能設定返回的值
  88.     dict_test.setdefault("gaopeng_1",'N/A')
  89.     dict_test.setdefault("gaopeng_2",'N/A')

  91.     my_format ("part2:setdefault:",dict_test.setdefault("gaopeng_2",'33')) ##更改
  92.     my_format ("part2:setdefault:",dict_test)

  94.     #part3:update:根據一個字典更改或者增加到另外一個字典，鍵相同則更新，不相同則增加

  96.     dict_test_1 = {'gaopeng_1':'18','gaopeng_3':'N/A'}
  97.     dict_test.update(dict_test_1)
  98.     my_format ("part3:update:",dict_test)

  100.     #part4:values:通過字典的values返回一個字典檢視dict_view
  101.     my_format ("part4:values:",dict_test.values())
  102.     dict_test_v_list= list(dict_test.values())
  103.     my_format ("part4:values::dict_view:",dict_test_v_list)
  104.     #part5:keys:通過字典的keys返回一個字典檢視
  105.     my_format ("part5:keys:",dict_test.keys())
  106.     dict_test_k_list= list(dict_test.keys())
  107.     my_format ("part5:keys:dict_view:",dict_test_k_list)
  108.     # part6:items:通過字典的返回一個字典檢視，其值為key-values p61 需要轉換為list
  109.     dict_test_k_v_list = list(dict_test.items())
  110.     my_format ("part6:items:", dict_test.items())
  111.     my_format ("part6:items:dict_view:", dict_test_k_v_list)

  113.     #part7:pop:根據鍵值刪除values 返回刪除的values
  114.     my_format("part7:pop:刪除前", dict_test)
  115.     my_format ("part7:pop:刪除",dict_test.pop('gaopeng_1'))
  116.     my_format("part7:pop:刪除後", dict_test)
  117.     #part8:popitem:隨機彈出一個元素 返回刪除的key-values
  118.     dict_test_copy = dict_test.copy() #一層淺拷貝即可
  119.     for i in range(len(dict_test)):
  120.         my_format ("part8:popitem:", dict_test_copy.popitem())


  123.     #part9:fromkeys;根據一個字典的keys建立另外一個字典，值為None可以認為指定
  124.     my_format ("part9:fromkeys;", {}.fromkeys(dict_test))
  125.     my_format ("part9:fromkeys;", dict.fromkeys(dict_test,'NULL'))

  127.     #part10:get 通過key訪問字典資料，但是如果沒有不會報錯，也不會像setdefault一樣設定一個，沒有則
  128.     #返回None，也可以自己指定返回值
  129.     my_format ("part10:當前字典為:", dict_test)
  130.     my_format ("part10:get:", dict_test.get("gaopeng_10"))
  131.     my_format ("part10:get:", dict_test.get("gaopeng_10",'NULL'))
  132.     my_format ("part10:get:", dict_test.get("gaopeng_5"))

  134.     #part11:clear python引用(指標)傳遞,clear用於同時清理變數但是 是一個指標指向的記憶體空間的值
  135.     #dict_test__c = dict_test.copy()
  136.     dict_test__c = dict_test
  137.     if dict_test__c is dict_test:
  138.         my_format ("part11:他們是同樣地址指向的字典如果要清理使用clear方法:", str(id(dict_test__c))+"=="+str(id(dict_test)))
  139.         dict_test.clear()
  140.         my_format ("part11:clear:", dict_test__c)
  141.         my_format ("part11:clear:", dict_test)
  142.     else:
  143.         my_format ("part11:Diff addr not use clear:", str(id(dict_test__c)) + "==" + str(id(dict_test)))

  145.     #part12:format_map 這種方法是字串的方法用於通過字典的key 進行對映到 values 替換到字串
  146.     str_m = """name is {name}
  147.     age is {age}""".format_map({"name":"gaopeng","age":22})
  148.     my_format("part12:format_map:", str_m)
  149.     return

  151. def main_list(list_test):
  152.     """測試的list一些常用的方法:
  153. 1、list類似於連結串列資料結構
  154. 2、感覺查詢的時間複雜度為O(n)
  155. 3、list可以進行頭插尾插，按照索引插入，這是連結串列資料結構決定的
  156. 4、list可以進行頭刪尾刪，按照索引刪除，這是連結串列資料結構決定的

  158. """
  159.     #part0:init list:
  160.     for i in range(97,110):
  161.         if i%2 == 0:
  162.             list_test.append(chr(i))
  163.         else:
  164.             list_test.append(i)
  165.     else:
  166.         my_format("part0:init list:",list_test)


  169.     #part1:list:常用於將字串按字元分割為一個list 當然也有其他作用
  170.     my_format("part1:list:", list("test"))
  171.     if list({"test1":1,"test2":2,"test3":3}) == list({"test1": 1, "test2": 2, "test3": 3}.keys()): #其他作用舉例
  172.         my_format("part1:list:", "The same!!")

  174.     #part2:修改列表的方式也非常簡單找到下標修改即可,但是不能修改沒有的值，這點和字典不一樣，字典試圖修改沒有的值則新加入一個元素
  175.     list_test[0]=110
  176.     my_format("part2:", list_test)
  177.     #part3:list切片
  178.     #1、左邊包含右邊不包含
  179.     #2、並且切片可以賦值,也就是說改變元素記憶體的位置
  180.     #3、切片左邊不能大於等於右邊否則返回為空
  181.     #4、左邊不填值表示最開頭，最開頭可以用0代替，右邊不填值表示最末尾，無法代替
  182.     #5、切片可以指定步長 如果為正數則左到右開始計數步長 如果是負數則改變預設的取值方式
  183.     # EXP:[-3::-2] [110, 'b', 99, 'd', 101, 'f', 103, 'h', 105, 'j', 107, 'l', 109]
  184.     # 結尾<------------------------[2]----------------------*開頭
  185.     my_format("part3:init list:", list_test)
  186.     my_format("part3:list切片", list_test[0:2])
  187.     my_format("part3:list負數切片", list_test[-3:-2]) #只包含倒數第三個元素
  188.     my_format("part3:list空切片", list_test[-3:-3]) # 為空測試
  189.     my_format("part3:list最後3個元素", list_test[-3:]) # 最後3個元素
  190.     my_format("part3:list最後3個元素步[正]長為2", list_test[-3::2]) # 最後3個元素
  191.     my_format("part3:list最後3個元素步[負]長為2", list_test[-3::-2]) #改變順序
  192.     my_format("part3:list切片賦值記憶體位置改變:改變前的位置", [ id(x) for x in list_test ])
  193.     list_test[:2] = [112,'z'] #此處會改變list_test[0] list_test[1] 的引入指向(指標指向)
  194.     my_format("part3:list切片賦值記憶體位置改變:改變後的位置", [id(x) for x in list_test])

  196.     m_test = list_test[:2]
  197.     my_format("part3:list切片後給予新物件地址是同一地址", [id(x) for x in m_test])
  198.     m_test[1] =900
  199.     my_format("part3:修改切片是否修改源資料[不修改基礎物件賦值重新給予記憶體空間]", list_test)
  200.     #part4:None列表:None 類似 C 語言中*p=NULL及空指標但是它是指向了一個固定的全域性區？ list中可以用於建立一個N個元素但是元素沒有指向的空列表
  201.     test = [None] * 10
  202.     test[1] = 'I' #注意這裡我修改了這個值明顯這裡記憶體指向會重新指向
  203.     my_format("part4:None列表:None初始化後", test)
  204.     my_format("part4:None列表:本機指向:", "0X{:x}".format(id(None)))
  205.     for i in test:
  206.         my_format("part4:None列表:每個元素的地址列印:", "0X{:x}".format(id(i)))
  207.     #part5:刪除元素:使用del可以刪除list中的一個元素,引用(指標)刪除
  208.     list_test_m=[]
  209.     for m in list_test:
  210.         if isinstance(m,int):
  211.             list_test_m.append(str(m))
  212.         else:
  213.             list_test_m.append(m)
  214.     print(list_test_m)
  215.     x=list_test
  216.     my_format("part5:刪除元素:刪除前", "+".join(list_test_m)+" "+"addr: "+str(id(list_test)))
  217.     del list_test[2]
  218.     list_test_m.clear()
  219.     for m in list_test:
  220.         if isinstance(m,int):
  221.             list_test_m.append(str(m))
  222.         else:
  223.             list_test_m.append(m)
  224.     my_format("part5:刪除元素:刪除後","+".join(list_test_m)+" "+"addr: "+str(id(list_test)))
  225.     my_format("part5:刪除元素:",x)

  227.     #part6:刪除元素:pop也用於刪除列表中的一個元素 預設刪除尾部最後一個可以指定INDEX 並且返回刪除的列表值
  228.     my_format("part6:刪除元素:刪除前",list_test)
  229.     my_format("part6:刪除元素尾部:", list_test.pop())
  230.     my_format("part6:刪除元素指定INDEX:", list_test.pop(0))
  231.     my_format("part6:刪除元素:刪除後", list_test)

  233.     #part7:刪除元素:remove用於刪除列表中的一個元素 通過指定值來刪除[第一個]是指定值的元素
  234.     my_format("part7:刪除元素:刪除前", list_test)
  235.     list_test.remove(101)
  236.     my_format("part7:刪除元素:刪除後", list_test)

  238.     #part8:反轉元素:有兩種方法一種使用reverse方法另外一種使用切換步長 reverse方法是用反轉的後的元素內容覆蓋原來地址
  239.     #但是方法二則是一個匿名的記憶體空間切片方式
  240.     my_format("part8:反轉元素:初始列表", list_test)
  241.     my_format("part8:反轉元素:記憶體地址", id(list_test))
  242.     list_test.reverse()
  243.     my_format("part8:反轉元素:反轉後", list_test)
  244.     my_format("part8:反轉元素:記憶體地址", id(list_test))
  245.     list_test.reverse()
  246.     my_format("part8:反轉元素:反轉後", list_test[::-1])

  248.     #part9:增加一個元素:使用append可以為列表在末尾增加一個元素
  249.     my_format("part9:增加一個元素:初始列表", list_test)
  250.     list_test.append(100)
  251.     my_format("part9:增加一個元素:使用append可以為列表在末尾增加一個元素", list_test)

  253.     #part10:clear:使用clear會清空整個列表和字典一樣即便有多個指向同一個列表的變數指標全部清空
  254.     list_test_c1 = list_test.copy()
  255.     list_test_c2 = list_test_c1
  256.     my_format("part10:clear:清空前", list_test_c1)
  257.     my_format("part10:clear:清空前", list_test_c2)
  258.     my_format("part10:clear:清空前", list_test)
  259.     list_test_c2.clear()
  260.     my_format("part10:clear:清空後", list_test_c1)
  261.     my_format("part10:clear:清空後", list_test_c2)
  262.     my_format("part10:clear:清空後原始列表", list_test)

  264.     #part11:copy:使用copy用於將列表複製第一層引用(指標)，如果需要完全深複製到最後一層指標使用deepcopy
  265.     my_format("part11:copy:原始列表記憶體地址", id(list_test))
  266.     get_pointer("part11:copy:原始列表各元素記憶體地址",list_test)
  267.     list_test_copy=list_test.copy()
  268.     my_format("part11:copy:copy列表記憶體地址", id(list_test_copy))
  269.     get_pointer("part11:copy:copy列表各元素記憶體地址", list_test_copy)

  271.     list_test_deepcopy=copy.deepcopy(list_test)
  272.     my_format("part11:copy:deepcopy列表記憶體地址", id(list_test_deepcopy))
  273.     get_pointer("part11:copy:deepcopy列表各元素記憶體地址", list_test_deepcopy)

  275.     #part12:count:count用於計算元素在列表中出現的次數 返回次數
  276.     list_test.append(100) #再增加一個100
  277.     my_format("part12:count:count用於計算元素在列表中出現的次數 返回次數",list_test.count(100))

  279.     #part13:擴充套件一個list有三種方法:
  280.     #方法1:使用extend，原list地址不變
  281.     #方法2:使用切片賦值，原list地址不變
  282.     #方法3:使用list加法，生成一個新的list
  283.     list_test.extend([990,991,992])
  284.     my_format("part13:擴充套件:方法1:使用extend，原list地址不變", list_test)
  285.     list_test[len(list_test):] = [993,994,995]
  286.     my_format("part13:擴充套件:方法2:使用切片賦值，原list地址不變", list_test)
  287.     tmp_list_test_ = list_test+[996,997,998]
  288.     my_format("part13:擴充套件:方法3:使用list加法，生成一個新的list", tmp_list_test_)

  290.     #part14:index:index用於查詢指定值第一次出現的索引 返回位置
  291.     my_format("part14:index:index用於查詢指定值第一次出現的索引 返回位置", list_test.index(103))
  292.     my_format("part14:index:index用於查詢指定值第一次出現的索引 返回位置", list_test.index(100))

  294.     #part15:insert:insert用於在指定index後增加一個值 無返回
  295.     #part15:insert:同時也可以用切片賦值的方式代替
  296.     get_pointer("part15:insert:原有記憶體地址", list_test)
  297.     list_test.insert(list_test.index(103), 99998)
  298.     my_format("part15:insert:insert用於在指定index後增加一個值 無返回", list_test)
  299.     list_test[list_test.index(103):list_test.index(103)] = [99999]
  300.     my_format("part15:insert:同時也可以用切片賦值的方式代替", list_test)
  301.     get_pointer("part15:insert:原有記憶體地址未變化", list_test)

  303.     #part16:sort:對列表進行排序，在原有列表上修改 並不是返回新的副本 但是如果列表有不同型別元素 排序將不能進行
  304.     #從記憶體地址的變化，就像是連結串列排序後NEXT指標重新指向，也就是改變的只是NEXT指標而已
  305.     #也可以使用sorted函式返回一個副本
  306.     tmp_list_test_2 = convert_to_int(list_test)[:3]
  307.     tmp_list_test_2.append(1)
  308.     my_format("part16:sort:原始列表", tmp_list_test_2)
  309.     my_format("part16:sort:原始列表記憶體", id(tmp_list_test_2))
  310.     get_pointer("part16:sort:原有記憶體地址變化", tmp_list_test_2)
  311.     tmp_list_test_2.sort()
  312.     my_format("part16:sort:對列表進行排序,在原有列表上修改", tmp_list_test_2)
  313.     get_pointer("part16:sort:原有記憶體地址未變化", tmp_list_test_2)
  314.     my_format("part16:sort:排除後列表記憶體", id(tmp_list_test_2))

  316.     #part17:sorted:本方法可用用於排序很多型別，返回一個副本，但是元素的記憶體指標未變(python中都是這種方法節約記憶體)

  318.     tmp_list_test_3 = convert_to_int(list_test)[:3]
  319.     tmp_list_test_3.append(1)

  321.     my_format("part17:sorted:原始列表", tmp_list_test_3)
  322.     my_format("part17:sorted:原始列表記憶體", id(tmp_list_test_3))
  323.     get_pointer("part17:sorted:原有記憶體地址變化", tmp_list_test_3)
  324.     tmp_list_test_4 = sorted(tmp_list_test_3)
  325.     my_format("part17:sorted:對列表進行排序,新返回副本", tmp_list_test_4)
  326.     get_pointer("part17:sorted:副本元素記憶體地址未變化", tmp_list_test_4)
  327.     my_format("part17:sorted:排除後副本列表記憶體改變", id(tmp_list_test_4))
  328.     #part18:高階排序;sort和sorted接受兩個關鍵字引數key和reverse
  329.     #key:根據自定義的函式返回一個值作為排序的基礎，類似一個函式指標
  330.     #reverse:是否反向
  331.     def sort_key(obj):
  332.         if isinstance(obj,str):
  333.             obj = ord(obj) % 10
  334.         else:
  335.             obj = obj%10
  336.         return obj

  338.     my_format("part18:sort高階排序;原始列表", list_test)
  339.     list_test.sort(key=sort_key,reverse=1)
  340.     my_format("part18:sort高階排序;排序後列表", list_test)

  342.     list_test_1 = sorted(list_test,key=sort_key,reverse=1)
  343.     my_format("part18:sorted高階排序;排序後列表", list_test_1)


  346. def main_str():
  347.     """測試的str一些常用的方法
  348. 1、字串本身是不能修改的，實際上PYTHON簡單物件(非list dict)都不能更改，只能重新賦予指向記憶體空間
  349. 2、在C中使用char a[10]或者 char* a=(char*)malloc(10*sizeof(char))來做,類似一個陣列區別只是在棧還是堆空間，
  350. python的str卻是不可修改的
  351. 3、分片方法同樣適用於字串
  352. """
  353.     #初始化測試字串
  354.     str_test = string.digits[::3]+string.ascii_lowercase[0:10:2]

  356.     #part1:一些有用的string方法,返回新的字串:
  357.     my_format("part1:一些有用的string方法:string.digits 返回0-9的字串:", string.digits)
  358.     my_format("part1:一些有用的string方法:ascii_lowercase 返回a-z小寫的字串:", string.ascii_lowercase)
  359.     my_format("part1:一些有用的string方法:ascii_uppercase 返回A-Z小寫的字串:", string.ascii_uppercase)
  360.     my_format("part1:一些有用的string方法:printable 返回ASCII中可以列印的字元:", string.printable)
  361.     my_format("part1:一些有用的string方法:punctuation 返回ASCII中可以標點字元:", string.punctuation)

  363.     #part2:center:在讓指定字串居中兩邊填充字元(預設為空格),返回新的字串
  364.     #類似的還有
  365.     #ljust:左邊頂格右邊填充
  366.     #rjust:右邊頂格左邊填充

  368.     str_test_center_20 = str_test.center(len(str_test) + 20, '=')
  369.     my_format("part2:center:在讓指定字串居中兩邊填充字元(預設為空格),返回新的字串:",str_test.center(len(str_test)+20,'='))
  370.     my_format("part2:ljust:在讓指定字串居中兩邊填充字元(預設為空格),返回新的字串:", str_test.ljust(len(str_test) + 20,'='))
  371.     my_format("part2:rjust:在讓指定字串居中兩邊填充字元(預設為空格),返回新的字串:", str_test.rjust(len(str_test) + 20,'='))
  372.     #part3:find:查詢字串中的字元，找到第一個符合的其所在的index,沒找到返回-1 可以指定起點終點 包含起點不包含終點
  373.     #類似的還有
  374.     # index:和find類似但是沒有找到出現異常
  375.     # rfind:和find類似但是最後一個符合的
  376.     # rindex:和rfind類似但是沒有知道出現異常
  377.     # count:指定字串出現的次數，返回次數
  378.     # startswith:是否已某個字串開頭返回bool型別
  379.     # endswith:是否已某個字串結尾返回bool型別
  380.     my_format("part3:find:初始化字串:", str_test)
  381.     my_format("part3:find:查詢字串中的字元:", str_test.find('a'))
  382.     my_format("part3:find:查詢字串中的字元:", str_test.find('go'))
  383.     my_format("part3:find:查詢字串中的字元:", str_test.find('a',2,6))
  384.     my_format("part3:index:查詢字串中的字元:", str_test.index('a', 2, 6))

  386.     # part4:split:其作用和join相反,用於將字串按照指定分隔符分割為一個list,返回一個序列
  387.     tmp_list=list(str_test)
  388.     tmp_str='+'.join(tmp_list) ##初始化測試tmp_str
  389.     str_test=tmp_str

  391.     my_format("part4:split:字元初始化", str_test)
  392.     tmp_list=str_test.split('+')
  393.     my_format("part4:split:按照'+'號進行分割為一個list", tmp_list)

  395.     #part5:join:其作用和split相反,用於按照指定的分割符合並字元元素的list為一個字串，返回一個新的字串

  397.     my_format("part5:join:列表初始化", tmp_list)
  398.     str_test = "".join(tmp_list)
  399.     my_format("part5:join:沒有指定分隔符的合併", str_test)
  400.     my_format("part5:join:指定'='分隔符的合併", "=".join(tmp_list))

  402.     #part6:strip:刪除開頭和結尾的某些字元，預設不指定為空格，返回一個新的字串，注意只是匹配末尾
  403.     #類似的還有
  404.     #lstrip:刪除左邊
  405.     #rstrip:刪除右邊

  407.     str_test_center_26=str_test_center_20.center(len(str_test_center_20)+6,' ')
  408.     str_test_center_32 = str_test_center_26.center(len(str_test_center_26) + 6, '*')
  409.     my_format("part6:strip:初始化字串為:", str_test_center_32)
  410.     my_format("part6:strip:去掉符號和空格字元後:", str_test_center_32.strip(' =*')) #匹配多種字元
  411.     my_format("part6:strip:去掉星號和空格字元後:", str_test_center_32.strip('*').strip())
  412.     my_format("part6:lstrip:去掉符號和空格字元後:", str_test_center_32.lstrip(' =*'))
  413.     my_format("part6:rstrip:去掉符號和空格字元後:", str_test_center_32.rstrip(' =*'))

  415.     #part7:replace:將字串的某些子字串進行替換為另外的字串，返回一個新的字串
  416.     my_format("part7:replace:初始化字串為:", str_test_center_32)
  417.     my_format("part7:replace:替換空格為+號", str_test_center_32.replace(' ','+'))

  419.     #part8:translate:需要建立對映字典表，單個字元匹配進行替換,效率高於replace？
  420.     #對映還是非常有用的
  421.     my_format("part8:translate:初始化字串為:", str_test_center_32)
  422.     table=str_test_center_32.maketrans('a ','A+')
  423.     my_format("part8:translate:對映字典為:", table) ##只做對映？
  424.     my_format("part8:translate:替換後:",str_test_center_32.translate(table))
  425.     str_test_center_32=str_test_center_32.translate(table)

  427.     #part9:upper lower:字母全部大寫或者小寫返回一個新字串
  428.     my_format("part9:upper lower:初始化字串為:", str_test_center_32)
  429.     my_format("part9:upper lower:lower:", str_test_center_32.lower())
  430.     my_format("part9:upper lower:upper:", str_test_center_32.upper())

  432.     #part10:swapcase:將字串中字母大小寫反轉 返回一個新的字串
  433.     my_format("part10:swapcase:初始化字串為:", str_test_center_32)
  434.     my_format("part10:swapcase:反轉後:", str_test_center_32.swapcase())

  436.     #part11:字串反轉 使用切片步長返回一個新的字串
  437.     my_format("part11:swapcase:初始化字串為:", str_test_center_32)
  438.     my_format("part11:swapcase:初始化字串為:", str_test_center_32[::-1])

  440.     #part12:swapcase將字串第一個字母大寫 返回一個新字串
  441.     #title:字串每個單詞的首字元大寫 返回一個新的字串
  442.     my_format("part12:swapcase:初始化字串為:", 'abcdef oooo')
  443.     my_format("part12:swapcase:首字母大寫後:", 'abcdef oooo'.capitalize())
  444.     my_format("part12:title:首字母大寫後:", 'abcdef oooo'.title())


  447.     #part12:各種字串檢查
  448.     # startswith:是否已某個字串開頭
  449.     # endswith:是否已某個字串結尾
  450.     # isalnum:是否字串的所有的字元都是數字或者字母
  451.     # isalpha:是否字串的所有的字元都是字母
  452.     # isdecimal:是否所有字元都是十進位制數字
  453.     # isdigit:是否所有字元都是數字
  454.     # isnumeric:是否字串中字元都是數字字元
  455.     """
  456.     來自網上的區別
  457.     isdigit()
  458.     True: Unicode數字，byte數字（單位元組），全形數字（雙位元組），羅馬數字
  459.     False: 漢字數字
  460.     Error: 無
  461.     isnumeric()
  462.     True: Unicode數字，全形數字（雙位元組），羅馬數字，漢字數字
  463.     False: 無
  464.     Error: byte數字（單位元組）
  465.     """
  466.     # islower:是否所有字母都是小寫
  467.     # isupper:是否所有字母都是大寫
  468.     # isspace:是否字串中的字元都是空白字元？(製表符 空格等？)
  469.     my_format("part12:各種字串檢查:初始化字串為:", str_test)
  470.     my_format("part12:各種字串檢查:startswith:是否已某個字串開頭:", str_test.startswith('**'))
  471.     my_format("part12:各種字串檢查:endswith:是否已某個字串結尾:", str_test.endswith('-*'))
  472.     my_format("part12:各種字串檢查:isalnum:是否字串的所有的字元都是數字或者字母:", str_test.isalnum())
  473.     my_format("part12:各種字串檢查:isalpha:是否字串的所有的字元都是字母:", str_test.isalpha())
  474.     my_format("part12:各種字串檢查:isdecimal:是否所有字元都是十進位制數字:", str_test.isdecimal())
  475.     my_format("part12:各種字串檢查:isdigit:是否所有字元都是十進位制數字:", str_test.isdigit())
  476.     my_format("part12:各種字串檢查:isnumeric:是否字串中字元都是數字字元:", str_test.isnumeric())
  477.     my_format("part12:各種字串檢查:islower:是否所有字母都是小寫:", str_test.islower())
  478.     my_format("part12:各種字串檢查:isupper:是否所有字母都是小寫:", str_test.isupper())
  479.     my_format("part12:各種字串檢查:isspace:是否字串中的字元都是空白字元？:", ' '.isspace())

  481.     #part13:字串格式彙總
  482.     #常用字串格式
  483.     #b 二進位制數字
  484.     #d 將整數作為十進位制數字進行處理 預設設定
  485.     #e 科學計數法表示小數(e表示指數)
  486.     #E 同e 但用E表示指數
  487.     #f 將小數表示為定點小數
  488.     #F 同f 但是對於nan inf使用大寫表示
  489.     #o 整數使用八進位制
  490.     #s 保持字串的格式不變 預設設定
  491.     #x 將整數表示為16進位制使用小寫字母
  492.     #X 同x 但是使用大寫字母
  493.     #% 顯示百分比 及乘以100 用f表示然後加上%符號

  495.     #測試字元初始化
  496.     temp_inter = -100
  497.     temp_inter_1 = 100
  498.     temp_float = 93.33633
  499.     temp_str = 'abcdef'

  501.     #字串格式化方法1
  502.     my_format("part13:字串格式彙總:字串格式化方法1", "this is test %s %x %o"
  503.               %(temp_str,temp_inter,temp_inter))
  504.     # 字串格式化方法2 這裡使用位置作為對映,預設就是0 1 2 3的方式所以可以不要 #號是一個自適應的字首轉換符 非常有用
  505.     my_format("part13:字串格式彙總:字串格式化方法2 #號是一個自適應的字首轉換符",
  506.               "this is test {0:s} {1:#x} {2:#o} {3:#b} {4:%} {5:f}".format(temp_str,temp_inter,temp_inter,temp_inter,temp_float,temp_float))

  508.     #字串格式化方法3 這裡使用關鍵字作為對映
  509.     my_format("part13:字串格式彙總:字串格式化方法3",
  510.               "this is test {temp_str_ad:s} {temp_inter_ad1:x} {temp_inter_ad2:o} {temp_inter_ad3:b} {temp_float_ad1:%} {temp_float_ad2:f}".format(temp_str_ad=temp_str,temp_inter_ad1=temp_inter,temp_inter_ad2=temp_inter,temp_inter_ad3=temp_inter,temp_float_ad1=temp_float,temp_float_ad2=temp_float))

  512.     #對於格式2和格式3可以使用更加詳細的格式化
  513.     #左對齊/居中/右對齊: < , ^ , >
  514.     my_format("part13:字串格式彙總:左對齊/居中/右對齊",
  515.               "this is test \n{:<50s}\n{:^50s}\n{:>50s}".format(temp_str,temp_str,temp_str))
  516.     #使用填充符號進行填充
  517.     my_format("part13:字串格式彙總:使用填充符號進行填充",
  518.               "this is test \n{:*<50s}\n{:*^50s}\n{:*>50s}".format(temp_str, temp_str, temp_str))

  520.     #對於一個整數的大部分格式
  521.     # +(用+填充) ^(居中) +(顯示符號) #(自適應轉換) 50(精度) x(16進位制顯示)
  522.     my_format("part13:字串格式彙總:對於一個整數的大部分格式:","this is test {:+^+#50x}".format(temp_inter_1))
  523.     # =(將符號左邊頂格) +(顯示符號) #(自適應轉換) 50(精度) x(16進位制顯示)
  524.     my_format("part13:字串格式彙總:對於一個整數的大部分格式:", "this is test {:=+#50x}".format(temp_inter_1))
  525.     #對於一個小數的大部分格式
  526.     # *(用*填充) ^(居中) +(顯示符號) #(自適應轉換) 50(精度) .2(刻度) f(float顯示)
  527.     my_format("part13:字串格式彙總:對於一個小數的大部分格式:", "this is test {:*^+#50.2f}".format(temp_float))

  529. def main_normal():
  530.     # part0:序列(list和tuple都支援乘法加法)，字串也支援 返回一個新的物件
  531.     my_format("part0:序列:元組初始化",sample_tupe)
  532.     my_format("part0:序列:列表初始化",sample_list)
  533.     my_format("part0:序列:元組相加", sample_tupe+sample_tupe)
  534.     my_format("part0:序列:元組相乘", sample_tupe*2)
  535.     my_format("part0:序列:列表相加", sample_list+sample_list)
  536.     my_format("part0:序列:列表相乘", sample_list*2)

  538.     my_format("part0:序列:字串相加", 'AAAA'+'aaaa')
  539.     my_format("part0:序列:字串相乘", 'AAAA'*2)

  541.     #part1:記憶體地址測試
  542.     temp_chr = 'abcde'
  543.     temp_list = list(temp_chr)
  544.     temp_dict = {}
  545.     for i in range(len(temp_list)):
  546.         temp_dict.setdefault( temp_list[i],i)

  548.     my_format("part1:記憶體地址測試:初始化的字串:", temp_chr)
  549.     temp_chr_1 = temp_chr
  550.     my_format("part1:記憶體地址測試:字串自身記憶體地址:", "0X{:x}".format(id(temp_chr)))
  551.     my_format("part1:記憶體地址測試:temp_chr_1 = temp_chr記憶體地址:", "0X{:x}".format(id(temp_chr_1)))
  552.     get_pointer("part1:記憶體地址測試:字串各個字元記憶體地址？:", temp_chr)
  553.     my_format("part1:記憶體地址測試:一個字元記憶體地址？:","0X{:x}".format(id(temp_chr[0])))


  556.     my_format("part1:記憶體地址測試:初始化的列表:", temp_list)
  557.     temp_list_1 = temp_list
  558.     my_format("part1:記憶體地址測試:list自身記憶體地址:", "0X{:x}".format(id(temp_list)))
  559.     my_format("part1:記憶體地址測試:temp_list_1 = temp_list記憶體地址:", "0X{:x}".format(id(temp_list_1)))
  560.     get_pointer("part1:記憶體地址測試:list各個元素記憶體地址:", temp_list)
  561.     my_format("part1:記憶體地址測試:一個list元素記憶體地址:", "0X{:x}".format(id(temp_list[0])))

  563.     my_format("part1:記憶體地址測試:初始化的字典:", temp_dict)
  564.     temp_dict_1 = temp_dict
  565.     my_format("part1:記憶體地址測試:dict自身記憶體地址:", "0X{:x}".format(id(temp_dict)))
  566.     my_format("part1:記憶體地址測試:temp_dict_1 = temp_dict記憶體地址:", "0X{:x}".format(id(temp_dict_1)))
  567.     get_pointer("part1:記憶體地址測試:dict各個values記憶體地址:", temp_dict)
  568.     my_format("part1:記憶體地址測試:一個dict values記憶體地址:", "0X{:x}".format(id(temp_dict['a'])))

  570.     temp_dict2 = temp_dict.copy()
  571.     temp_dict_3 = copy.deepcopy(temp_dict)

  573.     get_pointer("part1:記憶體地址測試:dict.copy各個values記憶體地址:", temp_dict2)
  574.     get_pointer("part1:記憶體地址測試:copy.deepcopy各個values記憶體地址:", temp_dict_3)
  575.     return

  577. def main():
  578.     get_format("dict test",100)
  579.     print(main_dict.__doc__)
  580.     dict_test={}
  581.     main_dict(dict_test)

  583.     get_format("list test",100)
  584.     print(main_list.__doc__)
  585.     list_test=[]
  586.     main_list(list_test)

  588.     get_format("charset test", 100)
  589.     print(main_str.__doc__)
  590.     main_str()

  592.     get_format("normal test", 100)
  593.     main_normal()
  594.     return

  596. ##begin
  597. if __name__ == '__main__':
  598.     main()

作者微信：


Python:字典列表字串方法測試

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/7728585/viewspace-2151794/，如需轉載，請註明出處，否則將追究法律責任。

相關文章