# ==== 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)

# ==== Python 八大基本数据类型的互转 ====# ------------ int类型 -------------------# === int 不支持 list tuple dict set 以及不是纯数字的str ===print(int(1.1))  # float 转 int --> 1print(int(True))  # bool 转 int --> 1print(int("123"))  # str 转 int --> 123# ------------ float类型 -------------------# === float 不支持 list tuple dict set 以及不是纯数字的str ===print(float(1))  # int 转 float --> 1.0print(float(False))  # int 转 bool  --> 1.0print(float("123"))  # int 转 str --> 123.0# ------------ str类型 -------------------# === str 支持任意类型 ===  注意。print 不会打印 "" ，为了区分特地加上的""print(str(1))  # int 转 str --> "1"print(str(1.1))  # float 转 str --> "1.1"print(str(True))  # bool 转 str --> "True"print(str([1, 2, 3]))  # list 转 str --> "[1,2,3]"print(str((1, 2, 3)))  # tuple 转 str --> "(1,2,3)"print(str({"k1", "v1"}))  # dict 转 str --> "{"k1","v1"}"print(str({1, 2, 3}))  # dict 转 str --> "{1,2,3}"# ------------ list类型 -------------------# === list 不支持 int float bool ===print(list("hello"))  # str 转 list --> ['h', 'e', 'l', 'l', 'o']print(list((1, 2, 3)))  # tuple 转 list --> [1, 2, 3]print(list({"k1", "v1"}))  # dict 转 list --> ['k1', 'v1']print(list({1, 2, 3}))  # set 转 list --> [1, 2, 3]# ------------ tuple类型 -------------------# === tuple 不支持 int float bool ===print(tuple("hello"))  # str 转 tuple --> ('h', 'e', 'l', 'l', 'o')print(tuple([1, 2, 3]))  # list 转 tuple --> (1, 2, 3)print(tuple({"k1", "v1"}))  # dict 转 tuple --> ('k1', 'v1')print(tuple({1, 2, 3}))  # set 转 tuple --> (1, 2, 3)# ------------ dict类型 -------------------# === dict 只支持以下形式的list和tuple === 注意:dict转换出的结果都是无序的# 想了想还是举例了出来。这种也是属于键值对的一种形式 --> {'k1': 'v1', 'k2': 'v2'}print(dict(k1="v1", k2="v2"))  # 特定格式的list 转 dict --> {'k1': 'v1', 'k2': 'v2'}print(dict([("k1", "v1"), ("k2", "v2")]))  # 特定格式的tuple 转 dict --> {'k1': 'v1', 'k2': 'v2'}print(dict((("k1", "v1"), ("k2", "v2"))))# ------------ set类型 -------------------# === set 不支持 int float bool === 注意:set转换出的结果都是无序的print(set("hello"))  # str 转 set --> {'h', 'l', 'o', 'e'}print(set([1, 2, 3]))  # list 转 set  --> {1, 2, 3}print(set((1, 2, 3)))  # tuple 转 set --> {1, 2, 3}print(set({"k1", "v1"}))  # dict 转 set --> {'v1', 'k1'}# ------------ bool类型 -------------------# === bool类型支持任意类型并且返回一个布尔值 ===# 不举例

# ==== 支持 len() 方法的基本数据类型 ====str1 = "1,2,3,4,5,6"  # 11li = [1, 2, 3, 4]  # 4tup = (1, 2, 3, 4)  # 4dic = {"k1": "v1", "k2": "v2"}  # 4 . 注意,虽然len()看起来是4,但是for循环只会拿出keyset1 = {1, 2, 3, 4}  # 4print(len(str1))print(len(li))print(len(tup))print(len(dic))print(len(set1))

# ==== 支持 in 与 not in 的基本数据类型 ====str1 = "1,2,3,4,5,6"  # Trueli = [1, 2, 3, 4]  # Truetup = (1, 2, 3, 4)  # Truedic = {"k1": "v1", "k2": "v2"}  # False .. 注意：对于dict的in来说默认只会检查keyset1 = {1, 2, 3, 4}  # Trueprint("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"# hello,world 如果对str类型使用这种操作.等同于 s2 = s1 ,内存地址引用都是相同的.而对于list和tuple来说则是浅copy.生成新对象。s2 = s1[:]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))  # 二进制  0b1print(oct(10))  # 八进制  0o12print(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 返回字符子串在父串中第一次出现的位置索引。如父串中不包含该子串则返回 -1print(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()是返回-1print(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 中 is系列之 判断纯数字组成的str三种方法 推荐：isdigt()=======num1 = b'4' #bytes 代表字节。num2 = u'4' #unicode,python3中无需加u就是unicode。（字符编码类型。后面会讲）num3 = '四' #中文数字num4 = 'Ⅳ' #罗马数字#isdigt()查看字符串是否是由数字组成。只支持bytes和unicodeprint(num1.isdigit()) # Trueprint(num2.isdigit()) # Trueprint(num3.isdigit()) # Falseprint(num4.isdigit()) # False#isdecimal()查看字符串是否由数字组成。只支持unicode并且没有bytes的使用。print(num2.isdecimal()) # Trueprint(num3.isdecimal()) # Falseprint(num4.isdecimal()) # False#isnumeric()。只支持unicode,中文数字,罗马数字并且没有bytes的使用。print(num2.isnumeric()) # Trueprint(num3.isnumeric()) # Trueprint(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()) # 7print(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中返回由字典key组成的经过优化的可迭代对象。Python2返回列表*（前面的那个样子）print(dic.values())  # dict_values(['v2', 'v3', 'v4', 'v7', 'yunya', 18]) Python3中返回由字典value组成经过优化的可迭代对象。Python2返回列表*（前面的那个样子）print(dic.items())  #  dict_items([('k2', 'v2'), ('k3', 'v3'), ('k4', 'v4'), ('k7', 'v7'), ('name', 'yunya'), ('age', 18)])  Python3中返回由字典key与value组成的经过优化的可迭代对象。Python2返回列表*（前面的那个样子）# ===== 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') 随机删除一组键值对,并将删除的键值放到元组内返回# 第一个参数是可迭代对象，其中每一个元素都为新生成字典的key，第二个参数为同一的value值。dic2 = dict.fromkeys([1, 2, 3, 4], None)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)  # Trueprint(set3 >= set4)  # True# -- 子级 --print(set4 < set3)  # Trueprint(set4 <= set3)  # 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只是生成新对象，并不会覆盖原值）set5.difference_update({1, 2, 3, 4})print(set5)  # {5, 6, 7}print(set5.isdisjoint({"a,b,c"}))  # True 两个集合完全独立没有共同部分返回 Trueset6 = frozenset({1, 2, 3, })  # 创建一个不可变的set。（可迭代对象）