# ------------ Python 八大基本数据类型的定义 -------------------

a = 1  #            --->        a = int(1)

b = 1.1  #          --->        b = float(1.1)

c = "hello"  #      --->        c = str("hello")

d = [1,2,3]  #      --->        d = list([1,2,3])

e = (1,2,3)  #      --->        e = tuple((1,2,3))

f = {"k1":"v1"}  #  --->        f = dict({"k1":"v1"}) or f = dict(k1="v1") 字典有2中定义方法。

g = {"a","b","c"}  # -->        g = set({1,2,3})

h = True  #         --->        h = bool(True)

#------------ 支持len()方法的基本数据类型 -------------------

str1 = "1,2,3,4,5,6"  # 11

li = [1, 2, 3, 4]  # 4

tup = (1, 2, 3, 4)  # 4

dic = {"k1": "v1", "k2": "v2"}  # 4 . 注意,虽然len()看起来是4,但是for循环只会拿出key

set1 = {1, 2, 3, 4}  # 4

print(len(str1))
print(len(li))
print(len(tup))
print(len(dic))
print(len(set1))

# ------------ 支持 in 与 not in 的基本数据类型 -------------------

str1 = "1,2,3,4,5,6"  # True

li = [1, 2, 3, 4]  # True

tup = (1, 2, 3, 4)  # True

dic = {"k1": "v1", "k2": "v2"}  # False .. 注意：对于dict的in来说默认只会检查key  

set1 = {1, 2, 3, 4}  # True

print("1" in str1)
print(1 in li)
print(1 in tup)
print("v1" in dic)
print(1 in set1)

#------------ index的高级使用 (取操作) 用str做演示 -------------------# === str 和 tuple 只支持 index 的取操作.而list支持 删改查(也称为取) ,list不支持使用index来增加新元素

# === str 除开 [:] 其他的取值都是生成新对象，list和tuple的取值不管怎样都是生成新对象

s1 = "hello,world"

s2 = s1[:]  #  hello,world 如果对str类型使用这种操作.等同于 s2 = s1 ,内存地址引用都是相同的.而对于list和tuple来说则是浅copy.生成新对象。

s3 = s1[3:7] # lo,w 取头不取尾,生成新的一段字符串(list,tuple同理)

s4 = s1[::2] # hlowrd 隔一个取一个,步长为2。

s5 = s1[::-1] # dlrow,olleh 反取,步长为负数

s6 = s1[::-2] # drwolh 倒过来,隔一个取一个.

s7 = s1[:-6:-2] # drw  倒过来.截至 -6 结束,隔着位置取。

s8 = s1[0::-1] # h  倒着取，正着数到第零个开始取，也就是h，唯一 一个就是这个h了，取到头了，就拿出h。没啥好说的。

s9 = s1[5::-2] # ,le 倒着取，开始位置是正着数到第五个 也就是,开始。再看结束位置，没有代表取到头。跳着来

#=== 注意，如果结束值，也就是第二个参数超过了len()的数值，则默认还是为len() === 如果三个参数都有，先看第三个参数。是倒着取还是正着取，再看第一个参数从哪儿开始取，最后看第三个参数取到哪儿

#------------ 进制转换，参数只能为int或bool。不支持float -------------------

print(bin(True))  # 二进制  0b1

print(oct(10))  # 八进制  0o12


print(hex(10))  # 十六进制  0xa

# ------------ str的必备操作 14个 -------------------

# === 以下方法均不会改变原本str中的值，而是生成一个新的对象返回 ===

s1 = "_*hello,world+*"
print(s1.strip("_*+"))  # hello,world 移除两边指定字符 , 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)

print(s1.split(",",maxsplit=1))    # [‘_*hello‘, ‘world+*‘] 切分,元组形式返回。maxsplit 代表最大 切割次数。

print(s1.rsplit("o",maxsplit=1))   # [‘_*hello,w‘, ‘rld+*‘] 从右切分，切分1次代表分成2段。以字符 o 进行切分

print(",".join(["hello!!","yunya~"]))  # hello!!,yunya~ 。与split()正好相反，指定一个字符做拼接操作，返回一个str对象。

print(s1.replace("*","$$$",))  # _$$$hello,world+$$$ ，替换，将指定字符子串替换为另一个字符子串

print(s1.count("lo"))  # 1 统计字符子串在父串中出现的次数

print(s1.title())  # _*Hello,World+* 每个首字母大写

print(s1.capitalize())  # _*hello,world+* 第一个首字母大写。由于是特殊字符故没有效果

print(s1.find("hel"))  # 2 返回字符子串在父串中第一次出现的位置索引。如父串中不包含该子串则返回 -1

print(s1.upper())  # _*HELLO,WORLD+* 将字符串中所有的小写字母替换为大写字母

print(s1.lower())  # _*hello,world+* 将字符串中所有的大写字母替换为小写字母，实例中字符串没有大写字母故没有改变

print(s1.startswith("hello"))  # False 字符串是否以指定子串开头

print(s1.endswith("hello"))  # False 字符串是否以指定子串结尾

print(s1.isdigit())  # False 字符串是否全部是数字（不包含特殊数字，只针对阿拉伯数字等等常见的数字）

# ------------ str的了解操作 -------------------

# === 以下方法均不会改变原本str中的值，而是生成一个新的对象返回 ===

s2 = "hello,world"

print(s2.index("hel"))  # 0 同find()，唯一区别找不到抛出异常，find()是返回-1

print(s2.center(20, "+"))  # ++++hello,world+++++ center代表居中，算上原本的hello,world一共要凑齐20的长度，如果不够则在两边添加符号 + 。原本的字符占中间

print(s2.ljust(20, ‘+‘))  # hello,world+++++++++ ljust,l代表left，同上。left规定原本字符占左边

print(s2.rjust(20, ‘+‘))  # +++++++++hello,world rjust,r代表right，同上。right规定原本字符占右边

print(s2.zfill(20))  # 000000000hello,world 同rjust，但是自动填充0而不是指定的字符。

print(s2.swapcase())  # HELLO,WORLD 字符串中的大小写翻转


s3 = "hello,\tyunya!" # \t 代表 tab  制表符。

print(s3)  # hello,    yunya! 默认tab宽度为1个空格

print(s3.expandtabs(6))  # hello,      yunya!  修改字符串中的tab宽度为6个空格。

# ======= Python3.x 中 is系列之 判断纯数字组成的str三种方法 推荐：isdigt()=======

num1 = b‘4‘ #bytes 代表字节。

num2 = u‘4‘ #unicode,python3中无需加u就是unicode。（字符编码类型。后面会讲）

num3 = ‘四‘ #中文数字

num4 = ‘Ⅳ‘ #罗马数字

#isdigt()查看字符串是否是由数字组成。只支持bytes和unicode
print(num1.isdigit()) # True

print(num2.isdigit()) # True

print(num3.isdigit()) # False

print(num4.isdigit()) # False

#isdecimal()查看字符串是否由数字组成。只支持unicode并且没有bytes的使用。
print(num2.isdecimal()) # True

print(num3.isdecimal()) # False

print(num4.isdecimal()) # False

#isnumeric()。只支持unicode,中文数字,罗马数字并且没有bytes的使用。
print(num2.isnumeric()) # True

print(num3.isnumeric()) # True

print(num4.isnumeric()) # True

# ======= 以上3种方法均不支持浮点型str的判断，全部为False =======

# ======= is 系列其他的一些方法 =======
name = ‘yunya696969‘

print(name.isalnum()) # True 字符串中既可以包含数字也可以包含字母

print(name.isalpha()) # False 字符串中只包含字母

print(name.isidentifier()) # True 判断字符串是否是符合Python变量命名标准。（数字字母下划线）

print(name.islower()) # True 判断字符串是否纯小写

print(name.isupper()) # False 判断字符串是否纯大写

print(name.istitle()) # False 判断字符串中的单词是否首字母大写

print(name.isspace()) # False 判断字符串是否全是空格

# ------------ list的必备操作 -------------------
li1 = [1,2,3,4]

li1.append(5)

print(li1)  # [1, 2, 3, 4, 5] append()代表添加一个元素至列表中。如果添加的是一个列表那么就直接是一个列表

li1.extend([5,6,7])

print(li1)  # [1, 2, 3, 4, 5, 5, 6, 7] extend()代表添加一个可迭代对象。将其中的每一个元素都拿出来给到原本的列表中

li1.insert(0,"start")

print(li1)  # [‘start‘, 1, 2, 3, 4, 5, 5, 6, 7] insert()代表向指定索引位置插入一个元素值。（任意类型）

li2 = li1.copy()  # 浅拷贝li1并赋值给了li2.这个没什么好说的

print(li1.pop()) # 7

print(li1)  # [‘start‘, 1, 2, 3, 4, 5, 5, 6] pop()填入元素索引，弹出并删除。如不填入索引默认删除最后一个元素并弹出。

li1.remove("start")

print(li1)  # [1, 2, 3, 4, 5, 5, 6] remove()根据元素名删除第一次出现在该列表中的元素。

li1.clear() # 代表清空li1列表。什么都没有了

#======由于li1清空，用li2做操作======。

print(li2)  # [‘start‘, 1, 2, 3, 4, 5, 5, 6, 7]

print(li2.count(4))  # 1 返回元素在列表中出现的次数

print(li2.index("start")) # 0 返回元素在列表中首次出现的索引位置。如查找不到则抛出异常

li2.remove("start") # 为了给下面的操作腾出位置，删除start元素

li2.sort(reverse=True)

print(li2) # [7, 6, 5, 5, 4, 3, 2, 1]  sort()代表从小到大排列元素，reverse参数代表反转。2个都设置代表从大到小开始排列

print(list(reversed(li2))) # [1, 2, 3, 4, 5, 5, 6, 7] 反转整个列表,给出一个生成器对象。

# ------------ tuple的寥寥数个方法 -------------------

t1 = (1,2,3,1,1,1)
print(t1.count(1))  # 4 统计元素出现在元组中的次数
print(t1.index(3))  # 2 返回元素在元组中首次出现的索引位置。如查找不到则抛出异常

# ------------ dict的必备操作 -------------------

# === 一定注意，字典的key不可变，且唯一（不允许重复） ===

dic = dict(k1="v1",k2="v2",k3="v3",k4="v4")  # 定义字典

print(dic)  # {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘, ‘k4‘: ‘v4‘}

print(dic["k1"]) # v1 通过[键名]取值，如果键名不存在则抛出异常（不推荐）

print(dic.get("k7"))  # None get()填入键名，如果键名不存在则返回None(推荐)

print(dic.setdefault("k7","v7")) # v7 setdefault()填入键名与设定值，如果键名存在则返回其对应值，如果不存在则设置其设定值。

dic.update({"name":"yunya","age":18})  #为dic更新字典。没有返回值

print(dic) # {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘, ‘k4‘: ‘v4‘, ‘k7‘: ‘v7‘, ‘name‘: ‘yunya‘, ‘age‘: 18}

print(dic.pop("k1"))  # pop()填入键名，弹出值并删除。如不填入键名则抛出异常，必填键名。

# =======非常重要=======

print(dic.keys())  # dict_keys([‘k2‘, ‘k3‘, ‘k4‘, ‘k7‘, ‘name‘, ‘age‘]) Python3.x中返回由字典key组成的生成器对象。Python2.x返回列表*（前面的那个样子）

print(dic.values())  # dict_values([‘v2‘, ‘v3‘, ‘v4‘, ‘v7‘, ‘yunya‘, 18]) Python3.x中返回由字典value组成的生成器对象。Python2.x返回列表*（前面的那个样子）

print(dic.items())  #  dict_items([(‘k2‘, ‘v2‘), (‘k3‘, ‘v3‘), (‘k4‘, ‘v4‘), (‘k7‘, ‘v7‘), (‘name‘, ‘yunya‘), (‘age‘, 18)])  Python3.x中返回由字典key与value组成的生成器对象。Python2.x返回列表*（前面的那个样子）

# ===== keys()，values()，items() 的应用场景 =====

for k in dic: # 等同于 for k in dic.keys():
    print(k)

for v in dic.values():
    print(v)

for k,v in dic.items():
    print(k,v)

# ------------ dict的了解操作 -------------------

dic = dict(k1="v1",k2="v2",k3="v3",k4="v4")
print(dic.popitem())  # (‘k4‘, ‘v4‘) 随机删除一组键值对,并将删除的键值放到元组内返回

dic2 = dict.fromkeys([1,2,3,4],None) # 第一个参数是可迭代对象，其中每一个元素都为新生成字典的key，第二个参数为同一的value值。
print(dic2) # {1: None, 2: None, 3: None, 4: None}

dic2.clear()  # 清空字典

# ------------ set方法之关系运算（符号篇） -------------------

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# -- 交集 --
print(set1 & set2)  # {4, 5}

# -- 差集 --
print(set1 - set2)  # {1, 2, 3}
print(set2 - set1)  # {8, 6, 7} 集合无序

# -- 合集/并集 --
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}

# -- 对称差集 --
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}

# -- 父级 --
set3 = {1, 2, 3, 4}
set4 = {1, 2}

print(set3 > set4)  # True
print(set3 >= set4)  # True

# -- 子级 --
print(set4 # True
print(set4 # True

# ====== 两个集合相等 ======= 互为父子关系

# ------------ set方法之关系运算（方法篇） -------------------

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# -- 交集 --
print(set1.intersection(set2))  # {4, 5}

# -- 差集 --
print(set1.difference(set2))  # {1, 2, 3}
print(set2.difference(set1))  # {8, 6, 7} 集合无序

# -- 合集/并集 --
print(set1.union(set2))  # {1, 2, 3, 4, 5, 6, 7, 8}

# -- 对称差集 --
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

# -- 父级 --
set3 = {1, 2, 3, 4}
set4 = {1, 2}

print(set3.issuperset(set3))  # True

# -- 子级 --
print(set4.issubset(set3))  # True

# ====== 两个集合相等 ======= 互为父子关系

# ------------ set方法的其他操作 ------------------

# --- 去重 --- 不举例，这个是集合的特性。上两章举过例子了。

set5 = {1,2}

set5.add(3)
print(set5)  # {1, 2, 3} add() 为集合中添加一个元素

set6 = set5.copy()  # copy() 浅拷贝
print(set5.pop())  # 从集合中随机弹出并删除元素（集合无序所以随机）。不可指定index（set不支持index）

set5.remove(2)  # 将指定元素从集合中删除。如果元素不存在集合中则抛出异常
print(set5)  # {3}

set5.discard(5)  # 同 remove()，但是如果元素不存在于集合中也不会抛出异常。

set5.clear()  #清空集合
print(set5)  #set()

set5.update({1,2,3,4,5,6,7})  # 更新集合
print(set5)  # {1, 2, 3, 4, 5, 6, 7}

set5.difference_update({1,2,3,4}) # 求出差集后赋值给set5 。（注意：单纯的difference只是生成新对象，并不会覆盖原值）
print(set5) # {5, 6, 7}

print(set5.isdisjoint({"a,b,c"}))  # True 两个集合完全独立没有共同部分返回 True

set6 = frozenset({1,2,3,}) # 创建一个不可变的set。（生成器对象）