def string_immutable_test():

    from io import StringIO

    """

    1.从下面测试来看，可以看出Python对字符串常量做了缓存

    2.表明python类似java一样存在一个字符串常量池,对于不可变对象可以重复利用

    3.使用str（num）创建字符串后id不同，说明python对于类型转换的变量不会缓存在常量池中

    """

    s1 = '123'

    s2 = '123'

    print(id(s1) == id(s2))  # True

    print(s1 is s2)  # True

    s3 = str('123444')

    s4 = str('123444')  # 这里并不会开辟新的地址，s4 和 s3 指向同一块内存区域

    print(id(s3) == id(s4))  # True

    print(s3 is s4)  # True

    s5 = str('1')

    s6 = str('1')

    print(id(s5) == id(s6))  # True

    print(s5 is s6)  # True

    s7 = str(5)  # 这里意思是将一个 number 类型数字转换为 string

    s8 = str(5)

    print(id(s7) == id(s8))  # False

    print(s7 is s8)  # False

    s9 = str(1)

    s10 = str(1)

    print(id(s9) == id(s10))  # False

    print(s9 is s10)  # False

    s11 = 'hello'

    s12 = str('hello')

    print(id(s11) == id(s12))  # True

    print(s11 is s12)  # True

    name_io = StringIO()

    name_io.seek(0)

    name_io.write('jones')

    print(name_io.getvalue())

    name_io.seek(0)

    name_io.write('jalen')

    print(name_io.getvalue())  # 原地修改字符串

    print('String object has changed.')

    name_io.close()  # 关闭 io 流，内存释放

if __name__ == '__main__':

    string_immutable_test()

def show_escape_sequences():

    # 续行符

    s1 = 'Today is yesterday, ' \

         'and yesterday is tomorrow, ' \

         'so what date is tomorrow?'

    print(s1)

    # 打印反斜杠符号

    s2_1 = 'Cat eat fish, \\fish eat shrimp.'

    print(s2_1)

    s2_2 = 'Cat eat fish, \fish eat shrimp.'

    print(s2_2)

    # 单引号

    s3 = 'I\'m a boy.'

    print(s3)

    # 双引号

    s4 = "I\"m a boy."

    print(s4)

    # 响铃

    s5 = '\a Get up!'

    print(s5)

if __name__ == '__main__':

    show_escape_sequences()

def show_string_append():

    # 1. 使用 '+' 号拼接

    string_1 = 'cat'

    string_2 = 'fish'

    introduce = string_1 + ' like ' + string_2

    print(introduce)  # cat like fish

    # 2. 如果不是变量形式，可以直接书写（中间可以带或者不带空格）

    string_3 = 'cat' ' like '  'fish'

    print(string_3)  # cat like fish

    string_4 = 'cat'' like ''fish'

    print(string_4)  # cat like fish

    # 3.list 列表转换为 str

    list_1 = ['cat', 'like', 'fish']

    string_5 = ' '.join(list_1)

    print(string_5)  # cat like fish

    # 4. 使用占位符拼接

    string_6 = '%s like %s' % ('cat', 'fish')

    print(string_6)  # cat like fish

if __name__ == '__main__':

    show_string_append()

def show_string_contains():

    string_foo = 'I always cheat my teammates when playing LOL!'

    string_bar = 'cheat'

    # 1. 使用 in 判断是否包含

    if string_bar in string_foo:

        print('foo contains bar')

    # 2.1 可以借助 find, find () 返回匹配到的第一个 mapping 上字符的下标（从 0 开始，第一位是 0），

    if string_foo.find(string_bar) >= 0:  # 此处返回下标为 9

        print('foo contains bar')

    # 2.2 相反，可以借助 rfind () 返回匹配到的最后一个 mapping 上的字符的下标

    if string_foo.rfind(string_bar) >= 0:  # 此处返回下标为 9

        print('foo contains bar')

    # 3. 借助 re 模块的 findall 方法，如果返回的列表不为空，说明有匹配上

    import re

    if re.findall(string_bar, string_foo, flags=re.I):  # re.I 中的 I 意思是 ignorecase，表示忽略大小写

        print('foo contains bar')

    # 4. 判断字符串从子串开始

    if string_foo.startswith('I always cheat'):

        print('foo start with bar')

    # 5. 判断字符串从子串结束

    if string_foo.endswith('LOL!'):

        print('foo end with LOL!')

    # 6.1 返回第一个匹配到的子字符串的索引号，注意如果不包含会抛出 ValueError 异常

    if string_foo.index(string_bar) >= 0:

        print('foo contains bar')

    # 6.2 返回最后一个匹配到的子字符串的索引号

    if string_foo.rindex(string_bar) >= 0:

        print('foo contains bar')

if __name__ == '__main__':

    show_string_contains()

def show_string_split():

    # 1. 使用内置的 split 函数拆分

    string_foo = 'Jalen,Jones,Jady'

    list_foo = string_foo.split(',')

    print(list_foo)

    # 2. 使用 re 模块的 split 函数拆分

    import re

    list_foo = re.split(',', string_foo)

    print(list_foo)

    # 3. 使用 re 模块的 split 函数通过正则表达式拆分

    text = "python is, an easy; language; to, learn. right? Yes. "

    list_text = re.split(r'; |, |\\? |. ', text)

    print(list_text)

    # 4. 根据换行符 ('\r', '\r\n', \n') 按行拆分，适用于文章拆分

    # 注：通常 Linux 的换行符是 \n，而 Windows 的换行符是 \r\n

    text = 'Hello Jones, \rI am new here!\n Thanks! \r\n My pleasure!'

    split_text = text.splitlines()

    print(split_text)

if __name__ == '__main__':

    show_string_split()

def show_lower_upper_transfer():

    text = "I am a boy!"

    # 1. 全部转大写

    upper_text = text.upper()

    print(upper_text)  # I AM A BOY!

    print(upper_text.isupper())

    # 2. 全部转小写

    lower_text = text.lower()

    print(lower_text)  # i am a boy!

    print(lower_text.islower())

    # 3. 让句子中的所有单词都是以大写字母开始

    upper_camel = text.title()

    print(upper_camel)  # I Am A Boy!

    print(upper_camel.istitle())

    # 4. 大小写字母反转 (大写变小写，小写变大写)

    swap_text = text.swapcase()

    print(swap_text)  # i AM A BOY!

    # 5. 把第一个字母转化为大写字母，其余小写

    text = 'i am a boy!'

    cap_text = text.capitalize()

    print(cap_text)

if __name__ == '__main__':

    show_lower_upper_transfer()

if __name__ == '__main__':

    string = 'abc'

    print(id(string))     # 1947333829272

    print(id(string[0]))  # 1947333727544

    print(id(string[1]))  # 1947333709416

    print(id(string[2]))  # 1947333592936

    string1 = 'abc'

    print(id(string1))    # 1947333829272 和 string 地址相同，即 string1 和 string 指向同一内存地址