测试的一些Python中的关于字典、列表、字符串的使用方法，放在这里备查。
整个测试代码和说明如下：

# -*- coding: utf-8 -*-
"""Python:函数中全是指针传递，而任何变量都是给予一个指针指向一个内存空间"""

import types
import copy
import string

###define _Debug  to enable assert

__Debug__=1

def my_format(x,y):
        """par one: what des your print
           par two: value
        """
        x="-->"+x+" {}"
        print(x.format(y))
        return

def get_format(s,len):
    """头部分割"""
    len1 = int(len/2)
    print("%s %s %s" %("="*len1,s,"="*len1))
    return

def get_pointer(y,obj):
    """获得obj中每个元素的内存地址并且打印"""
    list_index=[]
    list_values=[]
    if __Debug__:
        assert isinstance(obj,list) or isinstance(obj,dict) or isinstance(obj,str)
    if isinstance(obj,list) or isinstance(obj,str):
        for i in range(len(obj)):
            list_index.append(i)
            list_values.append("0X{:x}".format(id(obj[i])))
    else: ##对于字典来讲这样取应该是不对的，但是可以用作测试
        key_list = list(obj.keys())
        for i in range(len(key_list)):
            list_index.append(key_list[i])
            list_values.append("0X{:x}".format(id(obj[key_list[i]])))

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

def convert_to_int(obj):
    """将list中的字符也转换为ASCII返回一个新list"""
    list_test_m=[]
    if __Debug__:
        assert isinstance(obj,list)
    for m in obj:
        if isinstance(m, str):
            list_test_m.append(ord(m))
        else:
            list_test_m.append(m)

    return list_test_m

def init_smaple(x):
    """初始化测试数据"""
    if __Debug__:
        assert str(type(x))=="<class 'list'>"
    for i in  range(10):
        x.append(i)
    return tuple(x)

sample_list=[]  #外部全局变量
sample_tupe= init_smaple(sample_list) #外部全局变量

def main_dict(dict_test):
    """测试的dict一些常用的方法:
1、字典的键不可能相同
2、字典是hash算法KEY-VALUES的数据结构
3、字典没有顺序，这是hash算法注定的
4、查找时间复杂度O(1)
5、不能进行切片操作

"""
    #part1:最简单的更改和增加字典的方式
    dict_test['gaopeng_4'] = '44'
    dict_test['gaopeng_5'] = '44'
    dict_test['gaopeng_5'] = '55'
    dict_test['gaopeng_5'] = '0' #修改

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

    #part2:setdefault:会返回原有的值 并且更新 如果没有则设置一个,返回老值 注意和get的区别 part10 get不会更新只能设置返回的值
    dict_test.setdefault("gaopeng_1",'N/A')
    dict_test.setdefault("gaopeng_2",'N/A')

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

    #part3:update:根据一个字典更改或者增加到另外一个字典，键相同则更新，不相同则增加

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

    #part4:values:通过字典的values返回一个字典视图dict_view
    my_format ("part4:values:",dict_test.values())
    dict_test_v_list= list(dict_test.values())
    my_format ("part4:values::dict_view:",dict_test_v_list)
    #part5:keys:通过字典的keys返回一个字典视图
    my_format ("part5:keys:",dict_test.keys())
    dict_test_k_list= list(dict_test.keys())
    my_format ("part5:keys:dict_view:",dict_test_k_list)
    # part6:items:通过字典的返回一个字典视图，其值为key-values p61 需要转换为list
    dict_test_k_v_list = list(dict_test.items())
    my_format ("part6:items:", dict_test.items())
    my_format ("part6:items:dict_view:", dict_test_k_v_list)

    #part7:pop:根据键值删除values 返回删除的values
    my_format("part7:pop:删除前", dict_test)
    my_format ("part7:pop:删除",dict_test.pop('gaopeng_1'))
    my_format("part7:pop:删除后", dict_test)
    #part8:popitem:随机弹出一个元素 返回删除的key-values
    dict_test_copy = dict_test.copy() #一层浅拷贝即可
    for i in range(len(dict_test)):
        my_format ("part8:popitem:", dict_test_copy.popitem())


    #part9:fromkeys;根据一个字典的keys创建另外一个字典，值为None可以认为指定
    my_format ("part9:fromkeys;",  {}.fromkeys(dict_test))
    my_format ("part9:fromkeys;",  dict.fromkeys(dict_test,'NULL'))

    #part10:get 通过key访问字典数据，但是如果没有不会报错，也不会像setdefault一样设置一个，没有则
    #返回None，也可以自己指定返回值
    my_format ("part10:当前字典为:", dict_test)
    my_format ("part10:get:", dict_test.get("gaopeng_10"))
    my_format ("part10:get:", dict_test.get("gaopeng_10",'NULL'))
    my_format ("part10:get:", dict_test.get("gaopeng_5"))

    #part11:clear python引用(指针)传递,clear用于同时清理变量但是 是一个指针指向的内存空间的值
    #dict_test__c = dict_test.copy()
    dict_test__c = dict_test
    if dict_test__c is dict_test:
        my_format ("part11:他们是同样地址指向的字典如果要清理使用clear方法:", str(id(dict_test__c))+"=="+str(id(dict_test)))
        dict_test.clear()
        my_format ("part11:clear:", dict_test__c)
        my_format ("part11:clear:", dict_test)
    else:
        my_format ("part11:Diff addr not use clear:", str(id(dict_test__c)) + "==" + str(id(dict_test)))

    #part12:format_map 这种方法是字符串的方法用于通过字典的key 进行映射到 values 替换到字符串
    str_m = """name is  {name} 
    age is {age}""".format_map({"name":"gaopeng","age":22})
    my_format("part12:format_map:", str_m)
    return

def main_list(list_test):
    """测试的list一些常用的方法:
1、list类似于链表数据结构
2、感觉查找的时间复杂度为O(n)
3、list可以进行头插尾插，按照索引插入，这是链表数据结构决定的
4、list可以进行头删尾删，按照索引删除，这是链表数据结构决定的

"""
    #part0:init list:
    for i in range(97,110):
        if i%2 == 0:
            list_test.append(chr(i))
        else:
            list_test.append(i)
    else:
        my_format("part0:init list:",list_test)


    #part1:list:常用于将字符串按字符分割为一个list 当然也有其他作用
    my_format("part1:list:", list("test"))
    if list({"test1":1,"test2":2,"test3":3}) == list({"test1": 1, "test2": 2, "test3": 3}.keys()): #其他作用举例
        my_format("part1:list:", "The same!!")

    #part2:修改列表的方式也非常简单找到下标修改即可,但是不能修改没有的值，这点和字典不一样，字典试图修改没有的值则新加入一个元素
    list_test[0]=110
    my_format("part2:", list_test)
    #part3:list切片
    #1、左边包含右边不包含
    #2、并且切片可以赋值,也就是说改变元素内存的位置
    #3、切片左边不能大于等于右边否则返回为空
    #4、左边不填值表示最开头，最开头可以用0代替，右边不填值表示最末尾，无法代替
    #5、切片可以指定步长 如果为正数则左到右开始计数步长 如果是负数则改变默认的取值方式
    # EXP:[-3::-2]  [110, 'b', 99, 'd', 101, 'f', 103, 'h', 105, 'j', 107, 'l', 109]
    #          结尾<------------------------[2]----------------------*开头
    my_format("part3:init list:", list_test)
    my_format("part3:list切片", list_test[0:2])
    my_format("part3:list负数切片", list_test[-3:-2]) #只包含倒数第三个元素
    my_format("part3:list空切片", list_test[-3:-3])  # 为空测试
    my_format("part3:list最后3个元素", list_test[-3:])  # 最后3个元素
    my_format("part3:list最后3个元素步[正]长为2", list_test[-3::2])  # 最后3个元素
    my_format("part3:list最后3个元素步[负]长为2", list_test[-3::-2])  #改变顺序
    my_format("part3:list切片赋值内存位置改变:改变前的位置", [ id(x) for x in list_test ])
    list_test[:2] = [112,'z'] #此处会改变list_test[0] list_test[1] 的引入指向(指针指向)
    my_format("part3:list切片赋值内存位置改变:改变后的位置", [id(x) for x in list_test])

    m_test = list_test[:2]
    my_format("part3:list切片后给予新对象地址是同一地址", [id(x) for x in m_test])
    m_test[1] =900
    my_format("part3:修改切片是否修改源数据[不修改基础对象赋值重新给予内存空间]", list_test)
    #part4:None列表:None 类似 C 语言中*p=NULL及空指针但是它是指向了一个固定的全局区？ list中可以用于建立一个N个元素但是元素没有指向的空列表
    test = [None] * 10
    test[1] = 'I' #注意这里我修改了这个值明显这里内存指向会重新指向
    my_format("part4:None列表:None初始化后", test)
    my_format("part4:None列表:本机指向:", "0X{:x}".format(id(None)))
    for i in test:
        my_format("part4:None列表:每个元素的地址打印:", "0X{:x}".format(id(i)))
    #part5:删除元素:使用del可以删除list中的一个元素,引用(指针)删除
    list_test_m=[]
    for m in list_test:
        if isinstance(m,int):
            list_test_m.append(str(m))
        else:
            list_test_m.append(m)
    print(list_test_m)
    x=list_test
    my_format("part5:删除元素:删除前", "+".join(list_test_m)+" "+"addr: "+str(id(list_test)))
    del list_test[2]
    list_test_m.clear()
    for m in list_test:
        if isinstance(m,int):
            list_test_m.append(str(m))
        else:
            list_test_m.append(m)
    my_format("part5:删除元素:删除后","+".join(list_test_m)+" "+"addr: "+str(id(list_test)))
    my_format("part5:删除元素:",x)

    #part6:删除元素:pop也用于删除列表中的一个元素 默认删除尾部最后一个可以指定INDEX 并且返回删除的列表值
    my_format("part6:删除元素:删除前",list_test)
    my_format("part6:删除元素尾部:", list_test.pop())
    my_format("part6:删除元素指定INDEX:", list_test.pop(0))
    my_format("part6:删除元素:删除后", list_test)

    #part7:删除元素:remove用于删除列表中的一个元素 通过指定值来删除[第一个]是指定值的元素
    my_format("part7:删除元素:删除前", list_test)
    list_test.remove(101)
    my_format("part7:删除元素:删除后", list_test)

    #part8:反转元素:有两种方法一种使用reverse方法另外一种使用切换步长 reverse方法是用反转的后的元素内容覆盖原来地址
    #但是方法二则是一个匿名的内存空间切片方式
    my_format("part8:反转元素:初始列表", list_test)
    my_format("part8:反转元素:内存地址", id(list_test))
    list_test.reverse()
    my_format("part8:反转元素:反转后", list_test)
    my_format("part8:反转元素:内存地址", id(list_test))
    list_test.reverse()
    my_format("part8:反转元素:反转后", list_test[::-1])

    #part9:增加一个元素:使用append可以为列表在末尾增加一个元素
    my_format("part9:增加一个元素:初始列表", list_test)
    list_test.append(100)
    my_format("part9:增加一个元素:使用append可以为列表在末尾增加一个元素", list_test)

    #part10:clear:使用clear会清空整个列表和字典一样即便有多个指向同一个列表的变量指针全部清空
    list_test_c1 = list_test.copy()
    list_test_c2 = list_test_c1
    my_format("part10:clear:清空前", list_test_c1)
    my_format("part10:clear:清空前", list_test_c2)
    my_format("part10:clear:清空前", list_test)
    list_test_c2.clear()
    my_format("part10:clear:清空后", list_test_c1)
    my_format("part10:clear:清空后", list_test_c2)
    my_format("part10:clear:清空后原始列表", list_test)

    #part11:copy:使用copy用于将列表复制第一层引用(指针)，如果需要完全深复制到最后一层指针使用deepcopy
    my_format("part11:copy:原始列表内存地址", id(list_test))
    get_pointer("part11:copy:原始列表各元素内存地址",list_test)
    list_test_copy=list_test.copy()
    my_format("part11:copy:copy列表内存地址", id(list_test_copy))
    get_pointer("part11:copy:copy列表各元素内存地址", list_test_copy)

    list_test_deepcopy=copy.deepcopy(list_test)
    my_format("part11:copy:deepcopy列表内存地址", id(list_test_deepcopy))
    get_pointer("part11:copy:deepcopy列表各元素内存地址", list_test_deepcopy)

    #part12:count:count用于计算元素在列表中出现的次数 返回次数
    list_test.append(100) #再增加一个100
    my_format("part12:count:count用于计算元素在列表中出现的次数 返回次数",list_test.count(100))

    #part13:扩展一个list有三种方法:
    #方法1:使用extend，原list地址不变
    #方法2:使用切片赋值，原list地址不变
    #方法3:使用list加法，生成一个新的list
    list_test.extend([990,991,992])
    my_format("part13:扩展:方法1:使用extend，原list地址不变", list_test)
    list_test[len(list_test):] = [993,994,995]
    my_format("part13:扩展:方法2:使用切片赋值，原list地址不变", list_test)
    tmp_list_test_ =  list_test+[996,997,998]
    my_format("part13:扩展:方法3:使用list加法，生成一个新的list", tmp_list_test_)

    #part14:index:index用于查找指定值第一次出现的索引 返回位置
    my_format("part14:index:index用于查找指定值第一次出现的索引 返回位置", list_test.index(103))
    my_format("part14:index:index用于查找指定值第一次出现的索引 返回位置", list_test.index(100))

    #part15:insert:insert用于在指定index后增加一个值 无返回
    #part15:insert:同时也可以用切片赋值的方式代替
    get_pointer("part15:insert:原有内存地址", list_test)
    list_test.insert(list_test.index(103), 99998)
    my_format("part15:insert:insert用于在指定index后增加一个值 无返回", list_test)
    list_test[list_test.index(103):list_test.index(103)] = [99999]
    my_format("part15:insert:同时也可以用切片赋值的方式代替", list_test)
    get_pointer("part15:insert:原有内存地址未变化", list_test)

    #part16:sort:对列表进行排序，在原有列表上修改 并不是返回新的副本 但是如果列表有不同类型元素 排序将不能进行
    #从内存地址的变化，就像是链表排序后NEXT指针重新指向，也就是改变的只是NEXT指针而已
    #也可以使用sorted函数返回一个副本
    tmp_list_test_2 = convert_to_int(list_test)[:3]
    tmp_list_test_2.append(1)
    my_format("part16:sort:原始列表", tmp_list_test_2)
    my_format("part16:sort:原始列表内存", id(tmp_list_test_2))
    get_pointer("part16:sort:原有内存地址变化", tmp_list_test_2)
    tmp_list_test_2.sort()
    my_format("part16:sort:对列表进行排序,在原有列表上修改", tmp_list_test_2)
    get_pointer("part16:sort:原有内存地址未变化", tmp_list_test_2)
    my_format("part16:sort:排除后列表内存", id(tmp_list_test_2))

    #part17:sorted:本方法可用用于排序很多类型，返回一个副本，但是元素的内存指针未变(python中都是这种方法节约内存)

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

    my_format("part17:sorted:原始列表", tmp_list_test_3)
    my_format("part17:sorted:原始列表内存", id(tmp_list_test_3))
    get_pointer("part17:sorted:原有内存地址变化", tmp_list_test_3)
    tmp_list_test_4 = sorted(tmp_list_test_3)
    my_format("part17:sorted:对列表进行排序,新返回副本", tmp_list_test_4)
    get_pointer("part17:sorted:副本元素内存地址未变化", tmp_list_test_4)
    my_format("part17:sorted:排除后副本列表内存改变", id(tmp_list_test_4))
    #part18:高级排序;sort和sorted接受两个关键字参数key和reverse
    #key:根据自定义的函数返回一个值作为排序的基础，类似一个函数指针
    #reverse:是否反向
    def sort_key(obj):
        if isinstance(obj,str):
            obj = ord(obj) % 10
        else:
            obj = obj%10
        return obj

    my_format("part18:sort高级排序;原始列表", list_test)
    list_test.sort(key=sort_key,reverse=1)
    my_format("part18:sort高级排序;排序后列表", list_test)

    list_test_1 = sorted(list_test,key=sort_key,reverse=1)
    my_format("part18:sorted高级排序;排序后列表", list_test_1)


def main_str():
    """测试的str一些常用的方法
1、字符串本身是不能修改的，实际上PYTHON简单对象(非list dict)都不能更改，只能重新赋予指向内存空间
2、在C中使用char a[10]或者 char* a=(char*)malloc(10*sizeof(char))来做,类似一个数组区别只是在栈还是堆空间，
python的str却是不可修改的
3、分片方法同样适用于字符串
"""
    #初始化测试字符串
    str_test = string.digits[::3]+string.ascii_lowercase[0:10:2]

    #part1:一些有用的string方法,返回新的字符串:
    my_format("part1:一些有用的string方法:string.digits 返回0-9的字符串:", string.digits)
    my_format("part1:一些有用的string方法:ascii_lowercase 返回a-z小写的字符串:", string.ascii_lowercase)
    my_format("part1:一些有用的string方法:ascii_uppercase 返回A-Z小写的字符串:", string.ascii_uppercase)
    my_format("part1:一些有用的string方法:printable 返回ASCII中可以打印的字符:", string.printable)
    my_format("part1:一些有用的string方法:punctuation 返回ASCII中可以标点字符:", string.punctuation)

    #part2:center:在让指定字符串居中两边填充字符(默认为空格),返回新的字符串
    #类似的还有
    #ljust:左边顶格右边填充
    #rjust:右边顶格左边填充

    str_test_center_20 = str_test.center(len(str_test) + 20, '=')
    my_format("part2:center:在让指定字符串居中两边填充字符(默认为空格),返回新的字符串:",str_test.center(len(str_test)+20,'='))
    my_format("part2:ljust:在让指定字符串居中两边填充字符(默认为空格),返回新的字符串:", str_test.ljust(len(str_test) + 20,'='))
    my_format("part2:rjust:在让指定字符串居中两边填充字符(默认为空格),返回新的字符串:", str_test.rjust(len(str_test) + 20,'='))
    #part3:find:查找字符串中的字符，找到第一个符合的其所在的index,没找到返回-1 可以指定起点终点 包含起点不包含终点
    #类似的还有
    # index:和find类似但是没有找到出现异常
    # rfind:和find类似但是最后一个符合的
    # rindex:和rfind类似但是没有知道出现异常
    # count:指定字符串出现的次数，返回次数
    # startswith:是否已某个字符串开头返回bool类型
    # endswith:是否已某个字符串结尾返回bool类型
    my_format("part3:find:初始化字符串:", str_test)
    my_format("part3:find:查找字符串中的字符:", str_test.find('a'))
    my_format("part3:find:查找字符串中的字符:", str_test.find('go'))
    my_format("part3:find:查找字符串中的字符:", str_test.find('a',2,6))
    my_format("part3:index:查找字符串中的字符:", str_test.index('a', 2, 6))

    # part4:split:其作用和join相反,用于将字符串按照指定分隔符分割为一个list,返回一个序列
    tmp_list=list(str_test)
    tmp_str='+'.join(tmp_list) ##初始化测试tmp_str
    str_test=tmp_str

    my_format("part4:split:字符初始化", str_test)
    tmp_list=str_test.split('+')
    my_format("part4:split:按照'+'号进行分割为一个list", tmp_list)

    #part5:join:其作用和split相反,用于按照指定的分割符合并字符元素的list为一个字符串，返回一个新的字符串

    my_format("part5:join:列表初始化", tmp_list)
    str_test = "".join(tmp_list)
    my_format("part5:join:没有指定分隔符的合并", str_test)
    my_format("part5:join:指定'='分隔符的合并", "=".join(tmp_list))

    #part6:strip:删除开头和结尾的某些字符，默认不指定为空格，返回一个新的字符串，注意只是匹配末尾
    #类似的还有
    #lstrip:删除左边
    #rstrip:删除右边

    str_test_center_26=str_test_center_20.center(len(str_test_center_20)+6,' ')
    str_test_center_32 = str_test_center_26.center(len(str_test_center_26) + 6, '*')
    my_format("part6:strip:初始化字符串为:", str_test_center_32)
    my_format("part6:strip:去掉符号和空格字符后:", str_test_center_32.strip(' =*')) #匹配多种字符
    my_format("part6:strip:去掉星号和空格字符后:", str_test_center_32.strip('*').strip())
    my_format("part6:lstrip:去掉符号和空格字符后:", str_test_center_32.lstrip(' =*'))
    my_format("part6:rstrip:去掉符号和空格字符后:", str_test_center_32.rstrip(' =*'))

    #part7:replace:将字符串的某些子字符串进行替换为另外的字符串，返回一个新的字符串
    my_format("part7:replace:初始化字符串为:", str_test_center_32)
    my_format("part7:replace:替换空格为+号", str_test_center_32.replace(' ','+'))

    #part8:translate:需要建立映射字典表，单个字符匹配进行替换,效率高于replace？
    #映射还是非常有用的
    my_format("part8:translate:初始化字符串为:", str_test_center_32)
    table=str_test_center_32.maketrans('a ','A+')
    my_format("part8:translate:映射字典为:", table) ##只做映射？
    my_format("part8:translate:替换后:",str_test_center_32.translate(table))
    str_test_center_32=str_test_center_32.translate(table)

    #part9:upper lower:字母全部大写或者小写返回一个新字符串
    my_format("part9:upper lower:初始化字符串为:", str_test_center_32)
    my_format("part9:upper lower:lower:", str_test_center_32.lower())
    my_format("part9:upper lower:upper:", str_test_center_32.upper())

    #part10:swapcase:将字符串中字母大小写反转 返回一个新的字符串
    my_format("part10:swapcase:初始化字符串为:", str_test_center_32)
    my_format("part10:swapcase:反转后:", str_test_center_32.swapcase())

    #part11:字符串反转 使用切片步长返回一个新的字符串
    my_format("part11:swapcase:初始化字符串为:", str_test_center_32)
    my_format("part11:swapcase:初始化字符串为:", str_test_center_32[::-1])

    #part12:swapcase将字符串第一个字母大写 返回一个新字符串
    #title:字符串每个单词的首字符大写 返回一个新的字符串
    my_format("part12:swapcase:初始化字符串为:", 'abcdef oooo')
    my_format("part12:swapcase:首字母大写后:", 'abcdef oooo'.capitalize())
    my_format("part12:title:首字母大写后:", 'abcdef oooo'.title())


    #part12:各种字符串检查
    # startswith:是否已某个字符串开头
    # endswith:是否已某个字符串结尾
    # isalnum:是否字符串的所有的字符都是数字或者字母
    # isalpha:是否字符串的所有的字符都是字母
    # isdecimal:是否所有字符都是十进制数字
    # isdigit:是否所有字符都是数字
    # isnumeric:是否字符串中字符都是数字字符
    """
    来自网上的区别
    isdigit()
    True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
    False: 汉字数字
    Error: 无  
    isnumeric()
    True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
    False: 无
    Error: byte数字（单字节）
    """
    # islower:是否所有字母都是小写
    # isupper:是否所有字母都是大写
    # isspace:是否字符串中的字符都是空白字符？(制表符 空格等？)
    my_format("part12:各种字符串检查:初始化字符串为:", str_test)
    my_format("part12:各种字符串检查:startswith:是否已某个字符串开头:", str_test.startswith('**'))
    my_format("part12:各种字符串检查:endswith:是否已某个字符串结尾:", str_test.endswith('-*'))
    my_format("part12:各种字符串检查:isalnum:是否字符串的所有的字符都是数字或者字母:", str_test.isalnum())
    my_format("part12:各种字符串检查:isalpha:是否字符串的所有的字符都是字母:", str_test.isalpha())
    my_format("part12:各种字符串检查:isdecimal:是否所有字符都是十进制数字:", str_test.isdecimal())
    my_format("part12:各种字符串检查:isdigit:是否所有字符都是十进制数字:", str_test.isdigit())
    my_format("part12:各种字符串检查:isnumeric:是否字符串中字符都是数字字符:", str_test.isnumeric())
    my_format("part12:各种字符串检查:islower:是否所有字母都是小写:", str_test.islower())
    my_format("part12:各种字符串检查:isupper:是否所有字母都是小写:", str_test.isupper())
    my_format("part12:各种字符串检查:isspace:是否字符串中的字符都是空白字符？:", '     '.isspace())

    #part13:字符串格式汇总
    #常用字符串格式
    #b 二进制数字
    #d 将整数作为十进制数字进行处理 默认设置
    #e 科学计数法表示小数(e表示指数)
    #E 同e 但用E表示指数
    #f 将小数表示为定点小数
    #F 同f 但是对于nan inf使用大写表示
    #o 整数使用八进制
    #s 保持字符串的格式不变 默认设置
    #x 将整数表示为16进制使用小写字母
    #X 同x 但是使用大写字母
    #% 显示百分比 及乘以100 用f表示然后加上%符号

    #测试字符初始化
    temp_inter = -100
    temp_inter_1 = 100
    temp_float = 93.33633
    temp_str   = 'abcdef'

    #字符串格式化方法1
    my_format("part13:字符串格式汇总:字符串格式化方法1", "this is test %s %x %o"
              %(temp_str,temp_inter,temp_inter))
    # 字符串格式化方法2 这里使用位置作为映射,默认就是0 1 2 3的方式所以可以不要 #号是一个自适应的前缀转换符 非常有用
    my_format("part13:字符串格式汇总:字符串格式化方法2 #号是一个自适应的前缀转换符",
              "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))

    #字符串格式化方法3 这里使用关键字作为映射
    my_format("part13:字符串格式汇总:字符串格式化方法3",
              "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))

    #对于格式2和格式3可以使用更加详细的格式化
    #左对齐/居中/右对齐: <  , ^  , >
    my_format("part13:字符串格式汇总:左对齐/居中/右对齐",
              "this is test \n{:<50s}\n{:^50s}\n{:>50s}".format(temp_str,temp_str,temp_str))
    #使用填充符号进行填充
    my_format("part13:字符串格式汇总:使用填充符号进行填充",
              "this is test \n{:*<50s}\n{:*^50s}\n{:*>50s}".format(temp_str, temp_str, temp_str))

    #对于一个整数的大部分格式
    # +(用+填充) ^(居中) +(显示符号) #(自适应转换) 50(精度) x(16进制显示)
    my_format("part13:字符串格式汇总:对于一个整数的大部分格式:","this is test {:+^+#50x}".format(temp_inter_1))
    # =(将符号左边顶格) +(显示符号) #(自适应转换) 50(精度) x(16进制显示)
    my_format("part13:字符串格式汇总:对于一个整数的大部分格式:", "this is test {:=+#50x}".format(temp_inter_1))
    #对于一个小数的大部分格式
    # *(用*填充) ^(居中) +(显示符号) #(自适应转换) 50(精度) .2(刻度) f(float显示)
    my_format("part13:字符串格式汇总:对于一个小数的大部分格式:", "this is test {:*^+#50.2f}".format(temp_float))

def main_normal():
    # part0:序列(list和tuple都支持乘法加法)，字符串也支持 返回一个新的对象
    my_format("part0:序列:元组初始化",sample_tupe)
    my_format("part0:序列:列表初始化",sample_list)
    my_format("part0:序列:元组相加", sample_tupe+sample_tupe)
    my_format("part0:序列:元组相乘", sample_tupe*2)
    my_format("part0:序列:列表相加", sample_list+sample_list)
    my_format("part0:序列:列表相乘", sample_list*2)

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

    #part1:内存地址测试
    temp_chr = 'abcde'
    temp_list = list(temp_chr)
    temp_dict = {}
    for i in range(len(temp_list)):
        temp_dict.setdefault( temp_list[i],i)

    my_format("part1:内存地址测试:初始化的字符串:", temp_chr)
    temp_chr_1 = temp_chr
    my_format("part1:内存地址测试:字符串自身内存地址:", "0X{:x}".format(id(temp_chr)))
    my_format("part1:内存地址测试:temp_chr_1 = temp_chr内存地址:", "0X{:x}".format(id(temp_chr_1)))
    get_pointer("part1:内存地址测试:字符串各个字符内存地址？:", temp_chr)
    my_format("part1:内存地址测试:一个字符内存地址？:","0X{:x}".format(id(temp_chr[0])))


    my_format("part1:内存地址测试:初始化的列表:", temp_list)
    temp_list_1 = temp_list
    my_format("part1:内存地址测试:list自身内存地址:", "0X{:x}".format(id(temp_list)))
    my_format("part1:内存地址测试:temp_list_1 = temp_list内存地址:", "0X{:x}".format(id(temp_list_1)))
    get_pointer("part1:内存地址测试:list各个元素内存地址:", temp_list)
    my_format("part1:内存地址测试:一个list元素内存地址:", "0X{:x}".format(id(temp_list[0])))

    my_format("part1:内存地址测试:初始化的字典:", temp_dict)
    temp_dict_1 = temp_dict
    my_format("part1:内存地址测试:dict自身内存地址:", "0X{:x}".format(id(temp_dict)))
    my_format("part1:内存地址测试:temp_dict_1 = temp_dict内存地址:", "0X{:x}".format(id(temp_dict_1)))
    get_pointer("part1:内存地址测试:dict各个values内存地址:", temp_dict)
    my_format("part1:内存地址测试:一个dict values内存地址:", "0X{:x}".format(id(temp_dict['a'])))

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

    get_pointer("part1:内存地址测试:dict.copy各个values内存地址:", temp_dict2)
    get_pointer("part1:内存地址测试:copy.deepcopy各个values内存地址:", temp_dict_3)
    return

def main():
    get_format("dict test",100)
    print(main_dict.__doc__)
    dict_test={}
    main_dict(dict_test)

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

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

    get_format("normal test", 100)
    main_normal()
    return

##begin
if __name__ == '__main__':
    main()

作者微信：