# 1、casefold
# 用法：S.casefold()
# 意义：lower() 方法只对ASCII编码，也就是‘A-Z’有效，对于其他语言（非汉语或英文）中把大写转换为小写的情况只能用 casefold() 方法
# 用法:
s = 'aBBex '
print(s.casefold())  #abbex
# 2、expandtabs
# 用法：S.expandtabs(tabsoze=8)
# 意义：把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。
# 从头开始数，数到第一个\t正好为8个空格，不足则补空格，如果还有\t，接着从第一个\t数到第二个\t仍然为8个空格，以此类推直到最后一个\t结束。
# 用法
S = "this is\tstring example....wow!!!"
print("原始字符串: " + S)    #原始字符串: this is    string example....wow!!!
print("替换 \\t 符号: " + S.expandtabs())   #替换 \t 符号: this is string example....wow!!!
print("使用16个空格替换 \\t 符号: " + S.expandtabs(16))  #使用16个空格替换 \t 符号: this is         string example....wow!!!

tu = (1)
tu1 = (1,)
print(tu,type(tu))  #1 <class 'int'>
print(tu1,type(tu1))    #(1,) <class 'tuple'>

tu = ('老男孩')    
tu1 = ('老男孩',)
print(tu,type(tu))  #老男孩 <class 'str'>
print(tu1,type(tu1))    #('老男孩',) <class 'tuple'>

tu = ([1,2,3])
tu1 = ([1,2,3],)
print(tu,type(tu))  #[1, 2, 3] <class 'list'>
print(tu1,type(tu1))    #([1, 2, 3],) <class 'tuple'>

# li = [11,22,33,44,55]
# 将索引为奇数的元素删除。
li = [11,22,33,44,55]
# del li[1::2]
# print(li)    #[11, 33, 55]
ll = []
for i in range(len(li)):
    if i%2 == 0:
        ll.append(li[i])
li = ll
print(li)    #[11, 33, 55]

li = [11,22,33,44,55]
# for i in range(len(li)):
#     print(li)  # [11, 22, 33, 44, 55]    [11, 22, 33, 44, 55]  [11, 33, 44, 55] [11, 33, 44, 55]  [11, 33, 44]
#     print(i)  # 0  1 2 3 4
#     if i % 2 == 1:
#         del li[i]
#     print(li)  # [11, 22, 33, 44, 55]  [11, 33, 44, 55]  [11, 33, 44, 55]  [11, 33, 44]  [11, 33, 44]
#     print(i)  # 0  1  2  3 4
# print(li)  # list assignment index out of range
# del li[100]  # list assignment index out of range
# for i in li:
#     print(li)
#     li.remove(i)
#     print(li)
# print(li)
# for i in range(len(li)-1,-1,-1):
#     if i % 2 == 1:
#         del li[i]
# print(li)

#Python 字典(Dictionary) fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
#dict.fromkeys(seq[, value]))
dic = dict.fromkeys('abc','alex')
print(dic)  #{'c': 'alex', 'a': 'alex', 'b': 'alex'}
dic = dict.fromkeys([1,2,3],[])
print(dic)  #{1: [], 2: [], 3: []}
dic[1].append('laonanhai')
print(dic)  #{1: ['laonanhai'], 2: ['laonanhai'], 3: ['laonanhai']}

dic = {'k1':'value1','k2':'value2','name':'wusir'}
# 将字典中含有k元素的键，对应的键值对删除。

# 在循环字典中，不能增加或者删除此字典的键值对。
# dictionary changed size during iteration

# for i in dic:
#     if 'k' in i:
#         del dic[i]
# count = 0
# for i in dic:
#     dic[i+str(count)] = dic[i]
#     count += 1
# l1 = []
# for i in dic:
#     if 'k' in i:
#         l1.append(i)
#
# for i in l1:
#     del dic[i]
# print(dic)

# 去重
li = [11,11,22,22,33,33,33,44]
li = list(set(li))
print(li)   #[33, 11, 44, 22]
set = {11,22,33,11,22,33,44}
print(set)  #{33, 11, 44, 22}

# 增
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('sb')
print(set1) #{'sb', 'barry', 'egon', 'ritian', 'wusir', 'alex'}
set1.update('abc')
set1.update([1,2,3])    #迭代的增加
print(set1) #{'sb', 1, 2, 3, 'barry', 'egon', 'ritian', 'a', 'b', 'wusir', 'alex', 'c'}

# 删
set1.remove('sb')
print(set1) #{'c', 1, 2, 'ritian', 'wusir', 3, 'barry', 'b', 'a', 'alex', 'egon'}

set1.clear()
print(set1) #set()

del set1
# print(set1) #删除了

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
# 交集 & intersection
print(set1 & set2)  #{4, 5}
print(set1.intersection(set2))  #{4, 5}
# 反交集 ^ symmetric_difference
print(set1^set2)    #{1, 2, 3, 6, 7, 8}
print(set.symmetric_difference(set2)) #{1, 2, 3, 6, 7, 8}
#差集 | union
print(set1 | set2)  #{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2)) #{1, 2, 3, 4, 5, 6, 7, 8}

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1.issubset(set2))  #True 子集
print(set2.issuperset(set1))  #True set2 是set1的超集

set1 = {'barry',"wusir"}
set2 = frozenset(set1)  #把集合变成可哈希的，有序集合
print(set2,type(set2))  #frozenset({'barry', 'wusir'}) <class 'frozenset'>

l1 = [1,2,3]
l2 = l1
l2.append(111)
# print(l1,l2)
print(id(l1))   #2682785139272
print(id(l2))   #2682785139272
# 对于赋值运算，指向的是同一个内存地址。字典，列表，集合都一样。
s = 1000
s1 = s
print(id(s))    #2682776128688
print(id(s1))   #2682776128688

l1 = [1,2,3]
l2 = l1
l2.append(111)
# print(l1,l2)
print(id(l1))   #2682785139272
print(id(l2))   #2682785139272
# 对于赋值运算，指向的是同一个内存地址。字典，列表，集合都一样。
s = 1000
s1 = s
print(id(s))    #2682776128688
print(id(s1))   #2682776128688

#copy 不是指向一个，在内存中开辟了一个内存空间
#对于浅copy来说，第一层创建的是新的内存地址，
# 而从第二层开始，指向的都是同一个内存地址，
# 所以，对于第二层以及更深的层数来说，保持一致性。
# l1 = [1,2,3]
# l2 = l1.copy()
# l1.append(111)
# print(id(l1),id(l2))
l1 = [1,2,[1,2,3,[22,33,44]],4]
l2 = l1.copy()
# l1[2].append(666)
print(l1)   #[1, 2, [1, 2, 3, [22, 33, 44]], 4]
print(l2)   #[1, 2, [1, 2, 3, [22, 33, 44]], 4]
print(id(l1))   #1603100643016
print(id(l2))   #1603100738056

#deep.copy
# 对于深copy来说，两个是完全独立的，
# 改变任意一个的任何元素（无论多少层），另一个绝对不改变.
import copy
l1 = [1, 2, [1, 2, 3], 4]
l2 = copy.deepcopy(l1)
l1[2].append(666)
print(l1,l2)    #[1, 2, [1, 2, 3, 666], 4] [1, 2, [1, 2, 3], 4]
print(id(l1[2]),id(l2[2]))  #print(id(l1[2]),id(l2[2]))  #

l1 = [1,2,3]
l2 = l1
l2.append(111)
print(l1,l2)    #[1, 2, 3, 111] [1, 2, 3, 111]

l1 = [1,2,3,[22,33]]
l2 = l1[:]
l1[3].append(666)
print(l2)  # [1, 2, 3, [22, 33, 666]]

l1 = [1,2,3,]
l2 = l1[:]
l1.append(666)
print(l2)   #[1, 2, 3]

s = 'alex'
s1 = s.encode('utf-8')  # unicode ---> utf-8 编码
s3 = s1.decode('utf-8')  # utf-8 ---> unicode 解码
print(s3)

# s = 'alex'
# s1 = s.encode('gbk')  # unicode ---> gbk 编码
# s3 = s1.decode('gbk')  # gbk ---> unicode 解码
# print(s3)

#gbk ---> utf-8
# s = 'alex'
# s1 = s.encode('gbk')
# print(s1)
#
# s2 = s1.decode('gbk').encode('utf-8')
# print(s2)

s = '老男孩'
s1 = s.encode('gbk')
print(s1)　　#b'\xc0\xcf\xc4\xd0\xba\xa2'

s2 = s1.decode('gbk').encode('utf-8')　　#b'\xe8\x80\x81\xe7\x94\xb7\xe5\xad\xa9'
print(s2)