当前位置:   article > 正文

【Python基础篇】Python中的七种数据类型_python数据类型

python数据类型

前导

Python中的数据类型主要有:Number(数字)Boolean(布尔)String(字符串)List(列表)Tuple(元组)Dictionary(字典)Set(集合)

其中又分为可变数据类型和不可变数据类型,可变数据类型是指可以随着函数的执行发生变化,而不可变数据类型不可以改变
不可变数据类型(3个):Number(数字)Boolean(布尔)String(字符串)Tuple(元组)
可变数据类型(4个):List(列表)Dictionary(字典)Set(集合)

问:如何判断一个变量的类型?
答:1.可以使用type(变量名称)方法,返回变量的数据类型;2.isinstance(变量名称,数据类型),只能返回True或False

一、数字类型(Number)

Python3中有3种数据类型:int(整型)、float(浮点型)、complex(复数)。
Python3的整型没有限制大小,可以当作Long类型来使用,且bool是整型的子类型。

# 整型int,浮点型float
a=2
b=2.6
print(a,b,type(a),type(b),isinstance(a,int))
# 输出结果为
# 2 2.6 <class 'int'> <class 'float'> True
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

二、布尔类型(Boolean)

布尔类型是与逻辑相关的一种数据类型,且只有True和False两个值。(注意:布尔值可以相加,相加之后类型就会转换为int类型)

# 2.布尔型Boolean
c=True
d=False
d=c+d
print(type(c),type(d),d)
# 输出结果
# <class 'bool'> <class 'int'> 1
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

三、字符串类型(String)

Python变量定义中,通过单引号和双引号引起来的值就是字符串str类型。

3.1 字符串索引

在这里插入图片描述
字符串正索引a[i]从0开始表示首个字符,负索引a[-1]从-1开始表示字符串末尾的字符。

3.2 字符串截取、拼接和复用

a = b[begin, end, step],begin表示开始位置,默认为0,end表示结束位置,默认为变量长度,step表示步长,默认为1。例如:a【i,j】,表示从位置i开始到位置j结束,其中截取的字符串不包括位置j。
注意:切片中负索引的使用并不是表示从尾到头的获取,索引只是限制了数据获取的范围。
步长才是确定读取顺序,如果步长为负数,则是从尾到头读取,如果是正数,则是从头到尾读取。

str1 = "hello,world!"
print(str1[::])
print(str1[2:5])
print(str1[2,6,2])
print(str1[-1:-4])
print(str1[-5:-2])
print(str1[-1:-5:-1])

# 输出结果
hello,world!
llo
lo
空
orl
!dlr
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
a = "我是王菜鸟"
b = ",你呢"
print(a[0],a[-1],a[:3],a[1,-1],a+b,a*2)

# 输出结果
我 鸟 我是王 是王菜 我是王菜鸟,你呢 我是王菜鸟我是王菜鸟
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

四、列表类型(List)

列表是经常用到的数据类型,其元素可以是字符串、数字、列表、元组等自定义的对象。列表是以[]定义,用英文逗号分隔开的集合,元素是可以重复的。

列表中的操作通常包含索引切片in和not inlen操作符+和*添加/删除/查询元素排序和反转将元组、字符串等序列转换成列表(不会修改原有的序列)
列表的索引和切片与字符串一致,此处不做赘述。

接下来将介绍在列表中的部分操作:

4.1 in和not in

判断某个值是否存在于列表中,若存在则返回True,否则返回False(注意:存在是指和列表的某个元素相同)。

store = [[65, 33], '女', 'wang', 24, 2.3]
print("wang" in store)
print("33" in store)
print("女" not in store)

# 输出结果
True
False
False
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
4.2 len()

len()方法返回列表元素数量

store = [[65, 33], '女', 'wang', 24, 2.3]
print(len(store))

# 输出结果
5
  • 1
  • 2
  • 3
  • 4
  • 5
4.3 添加/删除/查询元素
添加/删除/查询元素
操作方法描述
添加元素append(obj)追加元素到列表中,即在列表末尾增加一个指定元素
extend(iterable) 追加多个元素到列表中,即在列表末尾增加多个元素,iterable是序列,表示要添加的元素序列
insert(index, obj)在列表指定位置插入元素(指定位置及之后的元素都向后移动一个下标)
删除元素pop(index)删除并返回列表中指定索引的元素,index默认为-1,即最后一个元素
remove(element)删除第一个与指定值匹配一致的元素(不会返回相关值)
del删除列表元素或整个列表
clear()删除列表中所有元素,即成功后,列表是个空列表
查询元素index(value, start=None, stop=None)从列表中的指定范围找出与指定值第一个匹配项的索引位置(start和stop不能根据关键字传参)
count(obj)统计某个元素在列表中出现的次数

添加元素

# append
store = [[65, 33], '女', 'wang', 24, 2.3]
store.append("王菜鸟")
print(store)
store.append([66, 68])
print(store)

# extend
store.extend(["Kevin",168])
print(store)

# insert
store.insert(2,999)
print(store)


# 输出结果
[[65, 33], '女', 'wang', 24, 2.3, '王菜鸟']
[[65, 33], '女', 'wang', 24, 2.3, '王菜鸟', [66, 68]]
[[65, 33], '女', 'wang', 24, 2.3, '王菜鸟', [66, 68], 'Kevin', 168]
[[65, 33], '女', 999, 'wang', 24, 2.3, '王菜鸟', [66, 68], 'Kevin', 168]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

删除元素

print(store.pop(2))
store.remove('Kevin')
print(store)
store.clear()
print(store)

# 输出结果
999
[]
[]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

查询元素

store = [[65, 33], '女', 'wang', 24, 2.324]
print(store.index('女'))
print(store.count(24))

# 输出结果
1
2
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
4.4 排序(sort)和反转(reverse)

排序(sort)

格式:list.sort(key=None, reverse=False)
key – 指定带有一个参数并返回一个对象的函数,用于从列表中的元素提取需要比较的内容
sort()默认升序排序,即reverse=False,降序reverse=True

list1 = [22, 11, 25, 98, 72, 68, 49]
list1.sort()
print(list1)
list1.sort(reverse=True)
print(list1)

# 输出结果
[11, 22, 25, 49, 68, 72, 98]
[98, 72, 68, 49, 25, 22, 11]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

注意:sort中key参数的用法

# 按照总分成绩降序排名
list1 = [[97, 54, 93], [59, 78, 83], [44, 64, 97], [83, 79, 73]]
def sum_scores(scores):
    return scores[0] + scores[1] + scores[2]
    
list1.sort(key=sum_scores, reverse=True)
print(list1)

# 输出结果
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

反转(reverse)
reverse:排序规则,reverse = True 降序, reverse = False 升序(默认)。

list1 = [22, 11, 25, 98, 72, 68, 49]
list1.reverse()
print(list1)

# 输出结果
[49, 68, 72, 98, 25, 11, 22]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
4.5 list()

将元组、字符串等序列转成列表(不会修改原有的序列)。

# 元组
tup = (22, 86, 26, 35)
print(list(tup))
print(tup)

# 字符串
str1 = "Happy New Year"
print(list(str1))
print(str1)

# 输出结果
[22, 86, 26, 35]
(22, 86, 26, 35)

['H', 'a', 'p', 'p', 'y', ' ', 'N', 'e', 'w', ' ', 'Y', 'e', 'a', 'r']
Happy New Year
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

五、集合(Set)

集合Set是一个无序且不可重复的序列,使用{}set()函数进行创建,如果想创建一个空集合必须用 set() ,{ } 是用来创建一个空字典的
注意:集合(Set)只存储不可变的数据类型,如Number(数字)、字符串、元组等,而无法存储列表、字典、集合这些可变的数据类型。

set1 = set({"Kevin", "Lucy", "Toke", 24})
print(set1)

set2 = set("wang")
print(set2)

set3 = set({22, 33})
print(set3)

# 输出结果
{'Toke', 24, 'Lucy', 'Kevin'}
{'w', 'g', 'n', 'a'}
{33, 22}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

六、字典类型(Dictionary)

字典以键值对(key: value)的方式存储对象。
1、键(key)在字典中必须是唯一的,且键是不可变的数据类型,如字符串、数字、元组。如果创建时键被赋值多次,最后一个值才被存储。
2、值(value)可以是任意对象,比如None、数值、字符串、字典等。

dict1 = dict()
print(len(dict1), type(dict1))

dict2 = {}
print(len(dict2), type(dict2))

# 如果创建时键被赋值多次,最后一个值才被存储
dict3 = {"a": "Kevin", "b": "Lucy", "a": "Toke"}
print(dict3)

# 输出结果
0 <class 'dict'>
0 <class 'dict'>
{'a': 'Toke', 'b': 'Lucy'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

七、其他

7.1 深拷贝与浅拷贝

Python提供了针对列表、集合、字典等数据类型的深拷贝和浅拷贝方法。
浅拷贝:对数据进行地址拷贝,copy()方法只是增加了指向对象的指针,并没有分配新的空间去存储数据;
深拷贝:分配新的空间存储数据,原数据与深拷贝后的数据互不影响

函数描述
iterable.copy()返回可迭代对象iterable的浅拷贝数据
copy.deepcopy(iterable)返回可迭代对象iterable的深拷贝数据

如果从相对简单的角度来理解的话,浅拷贝和深拷贝是针对嵌套对象的区别,对原数据的嵌套对象的修改,浅拷贝对应的嵌套对象会同步影响,深拷贝就不会受影响。
从存储的角度来理解,浅拷贝就是增加了指针指向值的存储地址,并没有对值开辟新的内存空间进行存储,深拷贝则是开辟新的内存空间去存储并指针指向新的内存地址。

7.2 类型比较

列表[ ](list):有序可改变集合,允许重复数据。
元组( )(tuple):有序不可改变集合,允许重复数据。
集合{ }(set):无序无索引(索引为键值)集合,无重复数据。
字典{ }(dictionary):无序,可变,有索引集合,无重复数据。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小蓝xlanll/article/detail/170825
推荐阅读
相关标签
  

闽ICP备14008679号