6. 数据类型相关方法

数据类型装换和方法

整型

在python中，age=10,相当于age=Int（10），int（）函数就是将一个对象转换成整型的数据，需要注意的是，转换字符串的时候，只能将纯数字的字符串转换成整型（浮点数也一样），否则会报错

十进制转换成二进制——bin（）函数

十进制转换成八进制——oct（）函数

十进制转换成十六进制——hex（）函数

二进制转换成十进制 ——int（'10010',2）第二个数字2是说明前面的数字是二进制的意思，八进制就写8，十六进制就写16

内置方法：基本上没啥方法，多在算数运算和比较运算中使用

浮点型

float（）将一个对象转换成浮点数类型，

虚数

complex（实部，虚部）

可以了解一下位运算相关知识

字符串类型

str（）将任意类型的数据转换成字符串

s1='hello world'

# 按照索引取值和切片
s1[3]  # 得到l
s1[1:7:2]  # 从索引1开始到索引8结束，每隔两个字符(步长)取一个值得到el o
s1[-1:-3]  # 得到lr
s1[::-1]  # 倒着取全部的字符串
###  需要注意的是 字符串不能通过索引进行改值，因为是不可变的数据类型

# 统计长度
len(s1)

# in和not in
# 判断字符是否存在在字符串中，返回true或false
'l'in s1  # true

# strip() 移除字符串两侧的符号，只去除两边，不去除中间的
s2='***nihao/\.\//\***'
s3=s2.strip('*')  # 括号里面是想要去掉的符号，剩下nihao/\.\//\
s4=s2.strip('*/\.')  # 去掉两边的多种符号,只剩下nihao
lstrip()  # 只去除左边的（left）
rstrip()  # 只去除右边的（right）
### 应用在输入的时候对字符串进行处理（去掉两边的空格）

# split和rsplit切分方法，按照某种分隔符进行拆分，得到的是一个列表(默认分隔符是空格)
s1.split(' ')  # 按照空格进行拆分，得到['hello','world']
s1.split(' ',1)  # 设置分隔次数(就是从第一个空格开始分隔，分成两个元素的列表)
s1.rsplit(' ',1) # 从右向左开始切分

# s1.upper() 英文字母全部大写 HELLO WORLD
# s1.isupper()  # 判断是否全是大写
# s1.lower() 英文字母全部小写 hello world
# s1.islower()  # 判断是否全是小写
# s1.isdigit()  # 判断是否全是数字
# s1.title() 对单词的首字母的大写 Hello World
# s1.startswith('h') 判断是不是以h开头的字符串
# s1.endswith('d') 判断是不是以d结尾的字符串
# s1.isdigit()  # 判断是否全是数字

# join()将列表拼接成字符串
l1=['ni','hao','ya']
'!'.join(l1)  # 用！l1的三个元素连起来——》'ni!hao!ya'

# replace()替换方法
s1.replace("l",'L',1)  # 将第一个l替换成大写的L，如果不写数字默认替换掉所有

# 了解内容
# find()和index()
s1.find('ll')
s1.index('ll')
# 两者都是返回查找的子字符串的第一个字符的索引，不同之处在于find如果找不到返回的是-1，index如果找不到直接报错，所以使用find要好一点

# s1.count('l')   # 返回l在字符串中出现了多少次

# center()rjust()ljust()zfill()
'nihao'.center(20,'*')  # 创造一个20字符长度的字符串，nihao居中显示，其他的位置用*填充
'nihao'.rjust(20,'*')  # 创造一个20字符长度的字符串，nihao右对齐显示，其他的位置用*填充
'nihao'.ljust(20,'*')  # 创造一个20字符长度的字符串，nihao左对齐显示，其他的位置用*填充
'nihao'.zfill(20)  # 创造一个20字符长度的字符串，nihao右对齐显示，其他的位置用0填充，z是zero的意思

# s1.expandtabs(10)  # 当s1中有制表符时，指定制表符的长度，这里指定的是10个字符长度

# s1.capitalize()  # Hello world整个字符串的第一个首字母大写
# s1.swapcase()  # 将字符串中的大写字符变成小写，小写字符变成大写

# is系列，判断字符串中的字符的种类，返回true和false
.islower()  # 全是小写
.isupper()  # 全是大写
.istitle()  # 单词的首字母是大写
.isalnum()  # 全是字母或者数字
.isalpha()  # 全是字母
.isdecimal()  # 全是数字 
.isspace()  # 全是空格
.isidentifier()  # 判断标识符是不是合法的，如果是关键字的话返回true

# .numberic()和.digit()和.isdecimal()的区别
.isnumberic()  # 能够判断是不是阿拉伯数字、罗马数字、中文数字
.isdigit()  # 只能判断是不是阿拉伯数字（Unicode和bytes类型的数字）
.isdecimal()  # 智能判断是不是unicode显示的数字（python3中默认是unicode）

列表

list()方法，将一个可迭代对象变成列表，元素就是可迭代对象的每一个元素，列表是有序的

列表可以通过切片和索引进行取值

l1=[111,'nihao',3.3]
# 查
l1[0]  # 结果是111
l1[0:3:2]  # 结果是切片相当于一种copy，是一种浅copy，不改变本身的值，只是复制一份
# 改
l1[0] =222  # 索引存在的话可以直接改值，不存在的话直接报错[222,'nihao',3.3]
# 增
l1.append('qidian')  # 在列表后面追加值[222,'nihao',3.3,'qidian']
l1.insert(0,'ni')  # 在索引为0的位置直接添加值['ni',222,'nihao',3.3,'qidian']
l1.extend('abc')  # 迭代着追加在列表的后面['ni',222,'nihao',3.3,'qidian','a','b','c']
# 删
del l1[0]  # 通用的删除方法，单纯的删除，但是没有返回值，无法赋值
l1.pop(2)  # 根据索引删，不指定索引（括号里面不填值），默认删除最后一个，有返回值，返回删除的那个值
l1.romove('nihao')  # 按照对象删，制定删除的对应元素,返回值是none

# in和 not in 也适用于列表

# 一些需要掌握的内置方法
l1.count()  # 查找元素出现的次数
l1.index()  # 查找元素的索引
l1.clear()  # 清空元素，将列表变为空列表
l1.reverse()  # 将元素的顺序颠倒
l1.sort()  # 默认是从小到大排序（升序），传入参数reverse=true（默认是false），变成元素从大到小排序（降序）
### 在使用sort方法时，列表内元素必须是同种类型才可以，字符串的排序是按照ASCII码表的顺序来比较的，在进行字符串的比较的时候，是按照相对应的位置的字符来比较的，同理列表的比较也一样

不建议在循环中修改列表等可变数据类型，因为这样会改变列表的索引

队列和堆栈

队列：一种数据结构，特点是FIFO（first in first out）像是管道

堆栈：特点是LIFO（last in first out）像是水桶

元组

元组是一种不可变的数据类型，相当于一个不可变的列表，但是元组内的元素不能重复，元组的作用就是按照索引存放多个值，只用于读不能修改

对于元组中存放的可变的数据类型（比如说列表），是可以进行修改的，但是列表的内存地址是没有改变的

元祖的函数是tuple()

元祖的表示是（1,2,3,4,5,6），需要注意的是，只存放一个数据的时候，表示为（1，）（1）表示的是整数1

# 无法进行修改，所以增删改都不可以使用，只能使用索引查看，可以切片查看，可以使用in和 not in判断，方法只能使用index和count，与上面的原理一样，这里就不说了

字典

字典是键值对组成的，键（key）和值（value）是一一对应的

key必须是不可变的数据类型，并且不可重复，value可以是任何类型

表示{'name':'david','age':18}

创建字典的函数方式：dict（）

# 空字典{}
# 字典的创建
d=dict(x=1,y=2,c=3)

l=[[1,'a'],[2,'b'],[3,'c']]
d1=dict(l)  # 直接得到字典{1:'a',2:'b',3:'c'}

key1=[1,2,3]
none
{}.fromkeys(key1,none)  # 得到字典{1：none,2:none,3:none}，原理将前面的可迭代对象的每一个元素都当做key，值是同一个，都是none，这种方式常常用于快速初始化一个字典，值的部分通常不使用可变的数据类型，一般是none，或者是可变的数据类型

# 改/增
d1={1:'a',2:'b',3:'c'}
d1[1]  # 查看值，如果键值对不存在会直接报错
d1.get(1，'当key不存在的时候get方法的返回值')  # 是为了弥补使用索引进行查询的时候，如果字典中没有对应的键会直接报错，但是get方法会返回none
d1[1]='asd'  # 键存在的话就是直接修改值
d1[4]='d'  # 如果key不存在的话就直接增加键值对

len(d1)  # 计算长度

# 成员运算in 和 not in判断的是key

# 删除
del d1[1]  # 直接删除键值对
d1.pop(1)  # 默认删除最后一个，或者按照键删除，返回删除的key对应的值
d1.popitem()  # 随机删除，返回删除键值对组成的元组

# 其他的一些方法，下面是在python2中得到的结果，在python3中进行了优化，将每个得到的结果换成了迭代器，为了节省内存空间
d1.keys()  # 得到key组成的列表
d1.values()  # 得到value组成的列表
d1.items()  # 得到键值对组成的元组形成的列表

d1.clear()  # 全删除，清空
d1.update(d2)  # 在d1中有的键值对，还继续保留，d1中没有d2中有的键值对，将其增加到d1中
d1.setdefault(1，'abc')  # 如果键值在原字典中存在，就不会对原字典进行修改
d1.setdefault(5,'e')  # 如果键不存在，就将键和默认值形成键值对添加到字典中

集合

在{}内用逗号分隔开多个元素，元素满足以下条件：

​ 集合内元素必须是不可变类型

​ 集合内元素无序

​ 集合内元素没有重复

{}是空集合，集合的函数是set（）

集合有两个用处，一个是关系运算，一个是去重

# 类型转换
s=set('abcde')  # {'a','b','c','d','e'}要注意的是，集合里面放的是不可变的数据类型
# 集合的关系运算与相关的内置方法
s1={1,2,3,4,5}
s2={2,3,4,5,6}
# 取交集，两个集合共有的元素
s1&s2  # {2,3,4,5}
s1.intersection(s2)
# 取并集，两个集合相加去重
s1|s2  # {1，2,3,4,5，6}
s1.union(s2)
# 取s1独有的元素（差集）
s1-s2  # {1}
s1.difference(s2)
# 对称差集，就是两个元组所独有的元素组成的集合
s1^s2  # {1，6}
s1.symmetric_difference(s2)
# 父子集，包含的关系若s1的元素包含s2里面的元素，就称s1是父集合，s2是子集合（两个集合相等就互为父子）
s1>s2  # 用大于小于表示，返回true或者false，这里的s1和s2不存在父子关系，返回false
s1.issuperset(s2)
s1.subset(s2)

# 集合的去重（有局限性）
# 局限1.只能针对不可变得数据类型进行去重
# 局限2.无法保证原来的顺序

# 集合可以计算长度len()方法
# 集合可以进行成员运算in和not in
# 集合可以用for方法进行循环
# s1.remove(1)  # 可以删除元素，但是删除不存在的元素会报错所以有了discard方法
# s1.discard(9) # 同样可以删除，但是删除不存在的元素的时候什么都不会做，相当于没进行操作
# s1.update(s3)  # 将新集合加到原来的集合中在将重复的去掉（相当于取并集）
# update方法可以和交集并集等方法运算的函数结合使用，下面举个例子就明白了
s1.deiierence_update(s2)  # 就是先去差集然后在进行update
s1.clear()  # 将集合进行清空
s1.pop()  # 随机删除
s1.add(8)  # 增加元素
s1.isdisjoint()  # 如果两个集合完全独立，没有共同部分，返回true

数据类型总结

按照存值个数区分
只能存一个值，称为标量/原子类型	数字、字符串
可以存多个量，称为容器类型	列表、元组、字典

按访问方式区分
直接访问，只能通过变量值访问某个值	数字
顺序访问：可以通过索引访问，也叫序列类型	字符串、列表、元组
key访问：又被称为映射类型	字典

​

按照可变不可变区分
可变类型	列表、字典
不可变类型	数字、字符串、元组