基本数据类型与操作方法

引入

　　在前面的学习中我们学习了基本的数据类型。以及区分出了可变不可变等等操作，还掌握了index的基本用法。那么在本章节中将介绍Python中的八大基本数据类型的操作方法，这些方法都是Python为我们提供好的。他们被称为内建函数，也被称之为工厂函数。常用称呼为：BIF(built-in functions)，旨在你只管拿去用，不用管内部如何实现的。并且在今后的学习中还将学习更多的BIF函数。

通用方法篇

八大基本数据类型的定义与类型互转

　　在介绍类型互转之前。我们还是先了解一下如果声明定义一个变量，并且确认好他变量的基本数据类型。在明面上和底层中都做了那些事。

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

　　在右边的所有操作均与左边做出的操作一模一样，左边是最简洁的写法。可以认为每一个英文单词加括号代表一种功能的执行，括号中给定的任何东西都被称之为参数。按照严格意义上来讲定义出某种数据类型的变量应该称之为某某类的实例化，如定义了一个int类型的变量并赋值给了a就应该称为实例化出了一个int类型的对象a。

　　明白了这一层，我们再来看类型之间的互转操作：

# ==== Python 八大基本数据类型的互转 ====

# ------------ int类型 -------------------

# === int 不支持 list tuple dict set 以及不是纯数字的str ===

print(int(1.1))  # float 转 int --> 1
print(int(True))  # bool 转 int --> 1
print(int("123"))  # str 转 int --> 123

# ------------ float类型 -------------------

# === float 不支持 list tuple dict set 以及不是纯数字的str ===

print(float(1))  # int 转 float --> 1.0
print(float(False))  # int 转 bool  --> 1.0
print(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转换出的结果都是无序的

print(dict(k1="v1",k2="v2")) # 想了想还是举例了出来。这种也是属于键值对的一种形式 --> {'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'}

# ------------ 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类型支持任意类型并且返回一个布尔值 ===
# 不举例

　　八大类型互转中最常用的还是str与int类型的互转。别的其实都还好，所以自己敲一遍吧。

len()

　　len()支持除开int，float，bool以外的其它五大基本数据类型的使用。在这里你应该发现凡是能被len()操作的数据类型，都能被for循环使用。

# ==== 支持 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

　　in与not in支持除开int，float，bool以外的其它五大基本数据类型的使用。他是有一个包含关系在里面的，所以必须是针对容器类型。

# ==== 支持 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,list,tuple）

　　index只支持除开str,list,tuple这三种基本数据类型。可以他们的共同点都是内部为顺序存储。关于index的简单使用我们说过了，下面看一点骚操作。

index取值的高级用法（称之为切片）:

　　[start:stop:step]

　　　　start　

　　　　　　- 从哪个位置开始取，默认为0

　　　　stop　

　　　　　　- 取到那个位置结束，默认为len()

　　　　step

　　　　　　- 同range()的步长一样，如果步长为2开始为0则代表：第一次取值，0。第二次取值，0加上步长2，2。第三次取值2加上步长2，4...类推。

# ==== 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类型的进制转换

　　计算机基础中我们讲过了二进制，八进制，十六进制等等。来看一下Python提供的转换方法：

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

print(bin(True))  # 二进制  0b1
print(oct(10))  # 八进制  0o12
print(hex(10))  # 十六进制  0xa

str方法篇

str的必备操作

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

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

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

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的了解操作 ====

# === 以下方法均不会改变原本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,	yunya!" # 	 代表 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和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方法篇

list的必备操作

# ==== 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方法篇

tuple的寥寥数个方法

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

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

dict方法篇

dict的必备操作

# ==== 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的了解操作

# ==== 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方法篇

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

　　首先集合是来操作数据的，并不是用来存数据的。集合最重要的操作手法就是去重以及关系运算（求交差并集）。我们要先了解什么是交差并集才行。

# ==== 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 < set3)  # True
print(set4 <= set3)  # True

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

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

　　集合的交差并集除开可以用符号求，也可以用方法求。

# ==== 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方法的其他操作

# ==== 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。（可迭代对象）