【Python】 Python数据类型
重点讲解一下python中常见数据类型:
- Number--数字类型
- String--字符串类型
- List--列表类型
- Tuple--元组类型
- set--集合类型
- Dict--字典类型
- Bool--布尔类型
一、数字类型
python中的Number数字类型,主要分为整形、浮点型和复数三种
1、整形数据--int
在python中是精确的,想存储多大就是多大,是和内存大小相关,如:age=124556666666666666
2、浮点型数据--float--decimal.Decimal
默认的存放精度是17位,在范围内保证数据准确性,超过了就不精确了。
- salary = 1234.123456789012
- salary = 1234.12345678901234
如果想提升精度,需要使用decimal模块(提升到30位精度)
import decimal
decimal.getcontext().prec=30 #提升精度到30位
aa = decimal.Decimal(10)/decimal.Decimal(3)
输出:Decimal('3.33333333333333333333333333333')
bb = 10/3
输出:3.3333333333333335
3、复数--complex
复数是有实部和虚部组成的,aa = x + yj
- aa.real:获取复数的实部
- aa.imag:获取复数的虚部
二、布尔类型
布尔类型只有两个值False和True
flag = False
flag = True
在python中下面的数据都会被认为是False:
- None
if None:print("aa")
else:print("bb")
#输出结果为bbprint(bool())
- False
if False:print("aa")
else:print("bb")
#输出结果为bbprint(bool(False))
- zero of any numeric type, for example, 0, 0.0, 0j
if 0:print("aa")
else:print("bb")
#输出结果为bbprint(bool(0),bool(0.0),bool(0j))
- any empty sequence, for example, '', (), []
if []:print("aa")
else:print("bb")
#输出结果为bbprint(bool(""),bool(()),bool([]),bool({}))
- any empty mapping, for example, {}
if {}:print("aa")
else:print("bb")
#输出结果为bbprint(bool(""),bool(()),bool([]),bool({}))
三、序列类型
1、序列类型简介
序列类型其实也是一种容器类型,可以放多个数据,里面放的不同类型的数据就叫成员或者元素。
序列类型包括:
- 字符串类型String
- 列表list
- 元组tuple
系列类型的特点:
- 序列类型的成员是有序的(怎么放进去的怎么拿出来)
- 可以通过下标(索引index,就是每个元素在序列中的位置的编号,一般是从0开始)访问到序列一个或者多个元素或者成员
- 通过下标可以访问一个或者多个元素
- 访问多个元素,我们称为切片
2、序列类型通用运算符
序列中通用的运算符:str1 = "abcdefg",str2 ='123456'
- x in str1:元素(成员)x是在字符串中,x是字符串str1的一个成员?如果是返回True,否则返回False。
'a' in str1
- x not in str1 :元素x不在str1中,x不是字符串的一个成员?如果不在返回True,否则返回False。
'a' not in str1
- str1 + str2:str1和str2都是序列,+就是拼接作用
print(str1+str2)
- str1 * n:n是一个整形的数据,将str1进行复制2份
print(str1*2)
- str1[m]:m就是索引,范围从0到str1元素个数-1;str1[0]-->a;str1[7]-->string index out of range;str1[-2]
序列中的元素:1 2 3 4 5 6
序列元素索引:0 1 2 3 4 5
支持逆向索引:-6 -5 -4 -3 -2 -1
- str1[start:end:step]:切片的使用,start开始的位置索引,end表示结束位置,step为步进。
str1[0:3]->abc,左闭右开(可以取到0,但是取不到3),步进step默认是1
str1[0:3:2]->ac,步进改为了2,各一个取一个值,start和end还是左闭右开的
str1[:]->切片所有的值
str1[0:6]->'abcdef'
str1[0:7]->切片所有的值
str1[::-1]->逆向切片所有
str1[-4:-2]->de
str1[2:4:-1]->空
str1[4:2:-1]->ed
2、序列类型通用方法
- len(str1):返回序列的元素的个数(长度)
str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'len(str1)
- min(str1):获取指定的序列中的最小元素(按照大小进行比较),元素必须可以比较
- 对于字符来说,比较多是ascii码的大小(A-65,a-97)
- 对于数字来说,比较的就是数字的大小
str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'min(str1)
max(str1)
- max(str1):获取指定的序列中的最大值(按照大小进行比较),元素必须可以比较
- str1.index(value):查找value值在str1序列中的索引(位置序号-1)
- value值可以是字符串、也可以是数字、还可以是序列,返回对应的字符串、数字所在的索引
- value值是多个元素的序列的话,返回的是value的首字符在大串中的第一次出现的索引
str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'str1.index("a")
str2.index('2')
str3.index("ca")
- str1.index(value,start,end):在指定的范围内(start到end),查找value的值,返回索引
str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'str3.index("ca",4,8)
- str1.count(value):查str1序列中指定的value值出现的次数,返回的就是一个整形数据
str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'str1.count('a')
四、字符串
1、字符串定义
字符串是由 ""及 ''圈起来的一串数字或者字符,并且字符串是支持转义的,转义符号(\t:tab键,会有4个空格;\n:回车换行;\:表示是一个反斜杠)
- 字符串的截取(索引和切片):str1[start:end:step]
- 正向索引范围是从0到字符串长度-1
- 反向索引范围是(-字符串长度)到-1
- +表示字符串的连接
- *表示字符串的复制
2、自然字符串
将具备转义功能字符全部当作普通字符串来用,使用r或者R来修饰字符串
str1 = r"asfasdfasd\t \nafasdfasdfasdfas"
3、多行显示(续行)
一行中字符太多了,写不开了
str1= 'asdfasdfasdf \
asdfasdfasdfasdfasf \
asdfasdfasfasdfasfasdf'str2='asdfasdfasdfasd' \
'asdfasdfasdfasdfasdf' \
'asdfasdfasdfas'str3 = """
asdfasdfasdfasdfasdfasdf
asfasdfas
asdfasdf
"""
4、注意事项:
- python没有字符类型,一个字符可以理解为长度为1的字符串
- \可以进行转义,使用r或者R可以让\不发生转义,这就是自然字符串的用法
- 字符串是不允许被改变的
- 字符串可以用+运算符连接在一起,用*运算符重复
- Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始
- Python中的字符串不能改变
- 如果想字符串反转显示:则str[::-1]
- %格式化 - 执行字符串格式
>>> a=12
>>> b=23.5
>>> print(a)
12
>>> print("%d,%f"%(a,b))
12,23.500000
>>> print("输出的数据是:%d,%f"%(a,b))
输出的数据是:12,23.500000
>>> print("输出的数据是:%d,%3f"%(a,b))
输出的数据是:12,23.500000
>>> print("输出的数据是:%d,%9f"%(a,b))
输出的数据是:12,23.500000
>>> print("输出的数据是:%d,%12f"%(a,b))
输出的数据是:12, 23.500000
>>> print("输出的数据是:%d,%3f"%(a,b))
输出的数据是:12,23.500000
>>> print("输出的数据是:%d,%5.3f"%(a,b))
输出的数据是:12,23.500
>>> print("输出的数据是:%5d,%5.3f"%(a,b))
输出的数据是: 12,23.500
>>> print("输出的数据是:%1d,%5.3f"%(a,b))
输出的数据是:12,23.500
>>> print("输出的数据是:%d,%5.3f"%(a,b))
输出的数据是:12,23.500
>>> print("输出的a是:%3d"%a)
输出的a是: 12
>>> print("输出的a是:%8d"%a)
输出的a是: 12
五、列表
1、列表的简介
列表是序列类型,有序、可索引、可切片,可变、可重复,也可以理解为一个容器类型,所有基础数据类型都可以存入(数字、字符串、列表、元组、字典等) 。
列表是以[]进行定义的,以,进行元素的分隔。
list1 = [1,2,3,4,5,6]
list2 = ["a","b","c","d"]
list3 = [1,"a",2,"b"]
list4 = [list1,list2]
- 列表是可以被索引或者切片的,被切片之后返回一个包含切片元素的新的列表(留个疑问,列表不是可变的吗?)
list1 = [1,2,3,4,5,6]
print(list1[1:3])
print(list1)
- 列表也可以进行正向的索引,可以进行逆向索引
list1 = [1,2,3,4,5,6]
print(list1[1:3])
print(list1[::-1])
print(list1[:-1])
print(list1[-4:])
- 列表的+拼接和列表的*复制
list1 = [1,2,3,4,5,6]
list2 = ["a","b","c","d"]
list3 = [1,"a",2,"b"]
list4 = [list1,list2]
# [1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd']
print(list1+list2)
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
print(list1 * 3)
- 列表元素是可以变化的:可以通过索引改变某一个元素,直接给基础数据类型(数字、字符串);可以通过切片该表一个或者多个元素,通过列表给值
list1 = [1,2,3,4,5,6]
print(id(list1))
#可以通过索引改变某一个元素,直接给基础数据类型(数字、字符串)
list1[0]=12
print(id(list1))
print(list1)
可以通过切片该表一个或者多个元素,通过列表给值
list1[:]=[222]
print(list1)
list1[:]=[2,3,4,56,7]
print(list1)
#可以实现删除某些元素
list[2:3]=[]
2、列表中常用的方法
- list.index(value):查找list列表中value元素所在的位置(索引)
list1 = [1,2,3,4,5,6]
print(list1.index(4))
- list.append(value):往列表中追加元素,只能追加到列表的末尾处
list1 = [1,2,3,4,5,6]
#append()的返回值是空
print(list1.append())
#list1是可变的,其值已经被改变了
print(list1)
- list.insert(index,value):在列表的指定的位置处,插入一个新的值,原来该位置处的值往后移动
list1 = [1,2,3,4,5,6]
list1.insert(2,12)
#[1, 2, 12, 3, 4, 5, 6]
print(list1)
#返回的事insert方法的返回值,None
#print(list1.insert(2,12))
#如果是超出了list的索引号,插入在最后的位置
#print(list1.insert(8,12))
- list.extend(list2):将list2中的元素依次添加到list列表的末尾位置(前面的append、insert方法是将列表整个加到新列表中)
list1 = [1,2,3,4,5,6]
list2 = ["a","b","c","d"]
# [1, 2, ['a', 'b', 'c', 'd'], 3, 4, 5, 6]
# list1.insert(2,list2)
#[1, 2, 3, 4, 5, 6, ['a', 'b', 'c', 'd']]
# list1.append(list2)
# print(list1)
#extend方法将一个列表中的元素分别加载到另外一个列表中
list1.extend(list2)
print(list1)
- list.count(value):统计list列表中的出现value元素的次数
list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
print(list1.count(1))
- list.reverse():列表元素逆序(反过来)
list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
print(list1.reverse())
print(list1)
- list.remove(value):将指定的value元素从list列表中移除,只移除在列表中出现的第一个元素
list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
# list1[2:4]=[]
# print(list1)#可以通过remove方法实现删除一个元素,是对列表本身做的操作
list1.remove(1)
print(list1)
#ValueError: list.remove(x): x not in list
list1.remove(7)
print(list1)
- del list[index]:直接删除指定索引号的元素,每次只能删除一个
list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
del list1[0]
print(list1)
- list.pop(index):弹出指定索引的元素,并返回该元素;如果不指定index索引的话,弹出最后一个元素
list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
# 删除指定的元素并返回
# print(list1.pop(0))
# print(list1.pop())
# print(list1)#结合append和pop方法实现栈内存特点的模拟(先进后出)
#压栈的过程
list4=[]
list4.append(1)
list4.append(2)
list4.append(3)
list4.append(4)
list4.append(5)
print(list4)
#弹栈的过程
print(list4.pop())
print(list4.pop())
print(list4.pop())
print(list4.pop())
print(list4.pop())
六、元组
元组是序列类型,有序、可索引、可切片、可重复、不可以修改,一旦元素被存储,以后就不能修改、删除了
1、元组的定义
- 元组是用()来定义的,多个元素之间是用,分隔的,至少要有一个逗号
tuple1 = (10,)
#可以定义空的元组
tuple2=()
#也可以通过set创建元组或者空元组
tuple3 = tuple()
tuple = tuple("avasdfa")
#<class 'int'>
print(type(tuple1))
print(tuple1)
2、元组的特点
- 元组是容器类型,其中可以放数字、字符串、列表、元组
tuple1 = (10,"aaa",[12,23],(12,3))
print(type(tuple1))
print(tuple1)
- 元组的元素是可以重复的
tuple1 = (10,10,10,"aaa","aaa",[12,23],(12,3))
print(type(tuple1))
print(tuple1)
- 元组是不可修改的,数字、字符串元素不允许更改;如果是列表则列表(地址)不允许修改,但是可以该列表中数据
tuple1 = (10,10,10,"aaa","aaa",[12,23],(12,3))print(tuple1[0])
print(tuple1[:])
print(tuple1[:-1])
print(tuple1[-7:])
# 'tuple' object does not support item assignment
# tuple1[0] = 12
tuple1[5][0] =22
print(tuple1[5][0])
- 元组也支持连接+及复制*的使用
tuple1 = (10,10,10,"aaa","aaa",[12,23],(12,3))
tuple2 = tuple1 + tuple1
print(tuple2 * 2)
3、元组和其他序列的区别
为什么区分列表和元组?
- 最好使用不可变类型变量的一个情况是,如果在维护一些敏感的数据,并且不想数据被调用的函数篡改。
- 需要可变类型参数的一个例子,如果在管理动态数据集合时,你需要先把它们创建出来,逐渐地或者不定期的添加它们,或者有时还要移除一些单个的元素。
序列类型为数据的顺序存储提供了几种机制?
- 字符串是最常用的数据载体,无论是用于给用户显示,存贮到硬盘,通过网络传输,还是作为一个多源信息的容器
- 列表和元组提供了容器存储能力,允许简单的操作和访问多个对象,无论它们是Python 的对象还是用户自定义的对象
- 单一元素或一组元素可以通过持续有序地索引偏移进行切片操作来访问
七、set集合
集合(set)是一个无序、不重复元素的数据类型
1、set集合的创建
#定义一个空的set集合
setKong = set()
#元素不能重复,会将重复的除去掉
studentName = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
studentSex = set("男女")
#输出和输入是不一致的
print(studentName)
print(studentSex)
2、set集合的基本用法
- 增加集合元素:add
studentSex = {"男","女"}
studentSex.add("男女")
#{'男', '男女', '女'}
print(studentSex)
- 清除集合元素:clear
studentSex = {"男","女"}
studentSex.clear()
#set()
print(studentSex)
- 浅拷贝集合元素:copy
studentSex = {"男","女"}
ss = studentSex.copy()
#{'男', '女'}
print(ss)
- 差集运算:difference
studentSex = {"男","女"}
ss = studentSex.copy()
#两个集合的差集是set()
print(studentSex.difference(ss))
#相当于
print(studentSex-ss)
- 弹出集合元素:pop,无参,只能弹出集合的最后一个元素并返回该元素
studentSex = {"男","女"}
print(studentSex.pop())
print(studentSex)
- 移除指定的元素:remove,有参数,无返回值
studentSex = {"男","女"}
#无返回值,显示None
print(studentSex.remove("男"))
#移除后剩下{"女"}
print(studentSex)
- 更新集合元素:update
studentSex = {"男","女"}
print(studentSex.update("好"))
#{'好', '男', '女'}
print(studentSex)
- 成员关系测试
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}print(student) # 输出集合,重复的元素被自动去掉# 成员测试
if('Rose' in student) :print('Rose 在集合中')
else :print('Rose 不在集合中’)# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
八、字典
字典是一个无序的数据集合、是一种映射类型,并且字典是以键、值对组成,通过键来取值的(不能通过索引或者切片来取)
1、字典的定义
- 字典是通过{}来定义的
- 字典是以键、值对组成
- 字典的键是无序的、不允许重复的(set)
- 字典的值没有这种限制
set1 = {} #空的大括号其实定义的是字典
set2 = {1,2,3,4}#空的大括号其实定义的是set集合
#就是想定义一个空的set集合,怎么做?
set3 = set()
print(type(set3))
print(set3)#字典的定义
dict11 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}print(type(dict11))
print(dict11)
print(dict11["黄晓明"])
#通过这种方式是可以修改键的值的
dict11["黄晓明"]="angle baby"#其他的字典定义方式
dict1 = {"a":1,"b":2,"c":3}
print(dict1)
print(dict1.items())
# dict()是一个工厂类方法
dict2 = dict([('a', 1), ('b', 2), ('c', 3)])
print(dict2)dict3 = dict(a=1,b=2,c=3)
print(dict3)dict4 = dict(zip(('a','b','c'),(1,2,3)))
print(dict4)dict5 = {}.fromkeys(('a','b','c'))
dict5['a']=1
print(dict5)
2、字典的常用方法
- dict1.keys():获取字典的所有的键
dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.keys())
print(type(dict1.keys())
- dict1.values():获取字典的所有值
dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.values())
print(type(dict1.values()))
- dict1.items():获取的是字典的所有键和值组成的元组的集合
dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.items())
print(type(dict1.items()))
- dict1.clear():清空字典内容,返回None,字典dict1为{}
dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.clear())
print(dict1)
- dict1.copy():浅拷贝功能,其实就是复制一个副本
dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
dict2 = dict1.copy()
print(dict2)
print(dict1)
- {}.fromkeys(seq,value=None):将seq序列种的数据作为字典的键,value作为其默认值返回
dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4)
- dict1.get(key,default=None):获取字典中指定key所对应的value,如果key不在字典中,则返回None,比直接通过dict[""]更安全
dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4.get('Rose11'))
print(dict4.get('Rose11','字典中没有这个键'))
#KeyError: 'Rose11'
# print(dict4["Rose11"])
- dict1.pop(key[,default]) :如果字典中存在key,删除并返回key对应的vuale;如果key不存在,且没有default值,则keyerror异常
dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4.pop("RR","dd"))
print(dict4)
- dict1.update(bdict) :将字典bdict的键值对添加到字典dict1中。
dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4.update(dict1))
print(dict4)
【Python】 Python数据类型相关推荐
- Python组合数据类型之集合类型
单元概述 主要解决问题:让程序更好地处理一组数据 三类重要组合数据类型:集合类型.序列类型和字典类型 学完本章,我们能够在头脑中建立集合.序列和字典的模式来表达对一组数据的表达和处理 1. 定义 集合 ...
- Python的零基础超详细讲解(第四天)-Python的数据类型
Python 基本数据类型 Python 中的变量不需要声明.每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建. 在 Python 中,变量就是变量,它没有类型,我们所说的"类型&q ...
- python的数据类型和变量
python的数据类型和变量 数据类型 计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当然地可以处理各种数值.但是,计算机能处理的远不止数值,还可以处理文本.图形.音频.视频.网页等各种 ...
- python核心数据类型_Python核心数据类型-列表
Python核心数据类型-列表 关于列表的重要属性 列表是任意对象的有序集合,列表中可以包含任何种类的对象,数字 字符串 或者是其他列表 列表可以通过偏移来读取其中的元素,也可以通过分片读取列表中的某 ...
- python判断数据类型type_Python 判断数据类型有type和isinstance
Python 判断数据类型有type和isinstance 基本区别在于: type():不会认为子类是父类 isinstance():会认为子类是父类类型 执行结果如下: 用isinstance判断 ...
- Python基础数据类型之set集合
Python基础数据类型之set集合 一.set数据类型介绍 二.set集合演示 三.set集合中hash介绍 1.哈希定义 2.数据类型的hash和不可hash 3.set中hash示例 四.set ...
- Python基础数据类型之字符串(二)
Python基础数据类型之字符串(二) 一.字符串的常规操作 二.字符串的大小写转换 1.首字母大写 2. 每个单词首字母大写 3.大写转化为小写 4.所有字母变成大写字母 二.验证码忽略大小写 三. ...
- Python基础数据类型之字符串(一)
Python基础数据类型之字符串(一) 一.字符串格式化 1.字符串占位符 2.字符串格式化操作 二.f-string格式化 三.字符串的索引 四.字符串的切片 1.常规切片使用方法 3.步长的介绍 ...
- 好好学python·基本数据类型
好好学Python的第一天 基本用法 注释 输出 变量 命名规范 变量的定义方式 python的数据类型 数据类型分类 字符串类型 数字类型 List列表类型 tuple 元组类型的定义 Dict字典 ...
- python元组类型_什么是python元组数据类型
什么是python元组数据类型 发布时间:2020-08-25 11:46:29 来源:亿速云 阅读:68 这篇文章运用简单易懂的例子给大家介绍什么是python元组数据类型,代码非常详细,感兴趣的小 ...
最新文章
- 微信小程序开发——超链接或按钮点击跳转到其他页面失效
- 工作流性能优化(敢问activiti有扩展性?)(3)
- Linux基本常用命令
- OpenShift 4 - 部署一个基于 Serverless 的 Banking 应用
- 华为专利全球第一:哪里跌倒,哪里爬起!
- java程序设计基础篇_java程序设计基础篇 复习笔记 第一单元
- SpringBoot→请求参数、返回参数、文件上传、拦截器、异常处理、定时任务、异步任务
- 开课吧:现阶段人工智能应用涉及到哪些行业?
- mysql 随机函数 效率_MySQL 随机函数获取数据速度和效率分析
- 一位硕士毕业生三个月求职经历与经验的结晶
- [html] 你有使用过blockquote标签吗?说说它的用途有哪些?
- win10显示无法连接到Internet但是能上网
- Focal损失函数学习笔记
- 2021湖南省计算机类考研
- kali中如何更新python_怎么在线更新kali linux
- VMware 安装Ubuntu系统后,启动一直黑屏
- 思科设备VLAN配置命令
- 三次B样条曲线拟合算法
- Little Red Riding Hood(动态规划)
- 【转载】Java语言中的参数传递