标准数据类型
本文为CSDN博主「Javier_Ji」的原创文章原文链接：https://blog.csdn.net/Viking_JoneJi/article/details/105453812
一、不可变数据类型
1.1 数字(Number)
- 1.1.1 int(整型)
- 1.1.2 float(浮点型) ， 即小数
- 1.1.3 bool(布尔类型)
- 1.1.4 complex(复数)
1.2字符串(String)
- 1.2.1 特征
- 1.2.2 字符串常用操作指令
1.3元组(Tuple)
- 1.3.1 特征
- 1.3.2 元组的创建
- 1.3.3 常用操作
二、 可变数据类型
2.1 列表(List)
- 2.1.1 特征
- 2.1.2 增
- 2.1.3 删
- 2.1.4 改：修改指定位置元素
- 2.1.5 查
- 2.2.1 特征
- 2.2.2 创建字典
- 2.2.3增
- 2.2.4 删
- 2.2.5 改
- 2.2.6 查
- 2.3.1 特征
- 2.3.2 创建集合
- 2.3.3 增：相同元素不能再被增加
- 2.3.4 删
- 2.3.5 查
一、不可变数据类型
- 数字(Number)
- 字符串(String)
- 元组(Tuple)
1.1 数字(Number)
1.1.1 int(整型)
在64位系统上，整数的位数为64位，取值范围为-263~263-1, 即-9223372036854775808 至 9223372036854775807注意：在Python 3中不再有long类型了，全都是int
1.1.2 float(浮点型) ， 即小数
注意：在混合运算中，Python会把整型转换成浮点型。
1.1.3 bool(布尔类型)
注意：在 Python 2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python 3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
1.1.4 complex(复数)
复数由实部和虚部构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。内置函数type()可以用来查看数据类型
>>> a = 64
>>> type(a)
<class 'int'>
>>> a = 2**80
>>> type(a)
<class 'int'> #整型
>>> b = 3.1415926535
>>> type(b)
<class 'float'> #浮点型
>>> c = True
>>> type(c)
<class 'bool'> #布尔型
>>> b + c
4.1415926535 #布尔型可以和数字相加
>>> d = complex(a,b)
>>> d
(1.2089258196146292e+24+3.1415926535j)
>>> type(d)
<class 'complex'> #复数
1.2 字符串(String)
加了引号的字符都被认为是字符串，同时使用反斜杠 \ 转义特殊字符。
- 转义字符
| 转义字符 | 描述 |
|---|---|
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| \’ | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格 |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
单引号、双引号无区别
可以在单引号内使用双引号，也可以在双引号内使用单引号。
如：hello_word = “Hi, I’m a boy.”
多引号
作用一：多行注释
作用二：格式化打印
msg = """
-------------------用户登录------------------
User_name = %s
Password = %s
-------------------%s------------------------
""" % (User_name, Password , Result)
字符串能跟字符串之间相加，即字符串的连接，跟数字相乘，即复制。
>>> given_name = 'Javier'
>>> family_name = ' Ji'
>>> given_name + family_name
'Javier Ji'
>>> family_name * 3
' Ji Ji Ji'
1.2.1 特征
(1)、字符串按照从左到右的顺序定义字符集合，下标从0开始(与列表等类似)，有序
(2)、可以进行切片
>>> a = 'Javier Ji'
>>> a[::-1]
'iJ reivaJ'
>>> a[1:5]
'avie'
(3)、不可以对字符串中的某个字母进行修改，只能对该字符串整体进行重新赋值！
>>> a = 'Javier Ji'
>>> a
'Javier Ji'
>>> a[0]
'J'
>>> a[4]
'e'
>>> a[4] = 'b'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> a = 'Chica'
>>> a
'Chica'
(4)、取消转义字符
方法一：在字符串引号前加r
>>> b = 'apple\tbanana'
>>> b
'apple\tbanana'
>>> print(b)
apple banana
>>> c = r'apple\tbanana'
>>> c
'apple\\tbanana'
>>> print(c)
apple\tbanana
方法二：在转义字符前加\
>>> d = 'apple\\tbanana'
>>> d
'apple\\tbanana'
>>> print(d)
apple\tbanana
1.2.1字符串常用操作指令
names.capitalize(self)—>首字母大写，其他字母小写
>>> names = 'apple'
>>> print(names.capitalize())
Apple
names.casefold(self) —>字符串全变小写，所有语言都适用
>>> names = 'APPLE'
>>> names.casefold()
'apple'
names.center(self,width,fillchar=None) —>字符串居中显示，两边填充单一字符
>>> names.center(50,'*')
'**********************APPLE***********************'
names.count(self,sub,start=None,end=None) —>返回个数（顾头不顾尾）
>>> names.count('p')
0
>>> names.count('P',1,-1)
2
>>> names.count('P',1,-3)
1
>>> names.count('P',1,2)
names.endswith(self, suffix, start=None, end=None) —> 判断以什么结尾
>>> names.endswith('P',-1)
False
>>> names.endswith('E',-1)
True
>>> names.endswith('P',2,4)
False
>>> names.endswith('P',2,3)
True
names.find(self, sub, start=None, end=None) —>查询是否有该字符，有返回0，无返回-1
>>> names.find('A')
0
>>> names.find('a')
-1
>>> names.find('AP')
0
>>> names.find('AE')
-1
names.format() —>格式化输出
>>> s = 'Hello {0}, I like {1}.'
>>> s.format('Jone','Chica')
'Hello Jone, I like Chica.'
>>> s1 = 'Hello {q}, I like {p}.'
>>> print(s1)
Hello {q}, I like {p}.
>>> s1.format(q='Jone',p='Chica')
'Hello Jone, I like Chica.'
names.index(self, sub, start=None, end=None)—>返回第一个sub的索引值
>>> names = "hello everyone, I'm Javier.001"
>>> names.index('e')
names.isdigit(self) —>若字符串中全是数字则返回True，否则返回False
>>> a = '1234657'
>>> a.isdigit()
True
>>> b = '1234567ji'
>>> b.isdigit()
False
names.islower(self) —>判断字符串中的字母是否都为小写，若无字母或含有大写字母，则返回False
>>> a = '1234657'
>>> a.islower()
False
>>> b = '1234567ji'
>>> b.islower()
True
>>> c = ' '
>>> c.islower()
False
>>> d = 'javier'
>>> d.islower()
True
>>> e = 'Javier'
>>> e.islower()
False
>>> f = 'javie r'
>>> f.islower()
True
>>> f = 'javie r1'
>>> f.islower()
True
names.isspace(self) —>若字符串中全是空格则返回True，否则返回False
>>> b = '1 2'
>>> b.isspace()
False
>>> c = ' '
>>> c.isspace()
True
names.isupper(self) —>判断字符串中的字母是否都为大写
>>> e = 'Javier'
>>> e.isupper()
False
>>> g = 'JAVIER'
>>> g.isupper()
True
names.lower(self) —>将字符串中的大写字母都转换为小写，并返回。只对ASCII有效！！！
>>> g.lower()
'javier'
>>> e.lower()
'javier'
names.upper(self) —>将字符串中的小写字母都转换为大写，并返回。只对ASCII有效！！！
names.split(self,sep=None,maxsplit=-1) —>返回将字符串分隔后的列表
>>> names = 'Javier_Ji,Chica_Chen,Jone_Ji'
>>> names.split() #sep默认分割','
['Javier_Ji,Chica_Chen,Jone_Ji']
>>> names
'Javier_Ji,Chica_Chen,Jone_Ji'
>>> names.split('_') #sep增加参数后，以设定的参数分割
['Javier', 'Ji,Chica', 'Chen,Jone', 'Ji']
names.zfill(self,width) —>填充字符串至width长度，字符串左边补0
>>> b
'1234567ji'
>>> b.zfill(15)
'0000001234567ji'
1.3 元组(Tuple)
元组又被称为只读列表，不能修改元组内的元素
1.3.1 特征
可存放多个值
元组内元素不可变
按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序
1.3.2 元组的创建
>>> a = ('Javier','Chica',1,2,3)
>>> a
('Javier', 'Chica', 1, 2, 3)
>>> b = tuple(('Chica','Jone',5,8,6,9,7))
>>> b
('Chica', 'Jone', 5, 8, 6, 9, 7)
1.3.3 常用操作
索引、切片、循环输出元组元素、计算元组长度、查询是否包含某元素
注意：元组本身不可变，如果元组中包含其他可变元素，则这个可变元素可以被改变
二、可变数据类型(Number)
列表(List)
字典(Dict)
集合(Set)
2.1 列表(List)
2.1.1 特征
1、可存放多个值
按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
可修改指定索引位置对应的值，可变
2、增、删、查、改
2.1.2 增
append() —>追加(在列表中最后一个元素的后面加上需要追加的元素)
>>> names = ['Javier', 'Chica']
>>> names
['Javier', 'Chica']
>>> names.append('Jone')
>>> names
['Javier', 'Chica', 'Jone']
insert () —>插入(可在列表中任意位置插入)
>>> names
['Javier', 'Chica', 'Jone']
>>> names.insert(1,'Jack')
>>> names
['Javier', 'Jack', 'Chica', 'Jone']
>>> names.insert(3,1)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone']
>>> names.insert(5,2)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone', 2]
>>> names.insert(7,3)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone', 2, 3]
>>> names.insert(0,0)
>>> names
[0, 'Javier', 'Jack', 'Chica', 1, 'Jone', 2, 3]
extend() —>合并(可以把两个列表中的元素合并，有前后之分)
>>> names = ['Javier', 'Chica']
>>> names
['Javier', 'Chica']
>>> names1 = ['Jone','Jack']
>>> names1
['Jone', 'Jack']
>>> names.extend(names1)
>>> names
['Javier', 'Chica', 'Jone', 'Jack']
>>> names1.extend(names)
>>> names1
['Jone', 'Jack', 'Javier', 'Chica', 'Jone', 'Jack']
列表嵌套
>>> names.insert(1,[1,2,3])
>>> names
['Javier', [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> names[1][2]
2.1.2 删
直接删 del xxx[ ]
>>> names
['Javier', (0, 4, 5), [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> del names[1]
>>> names
['Javier', [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> del names[1][1]
>>> names
['Javier', [1, 3], 'Chica', 'Jone', 'Jack']
pop ()删(删除后返回被删除的值，默认删除最后一个元素)
>>> names.pop()
'Jack'
>>> names
['Javier', [1, 3], 'Chica', 'Jone']
>>> names.pop(1)
[1, 3]
>>> names
['Javier', 'Chica', 'Jone']
clear()清空(清除所有元素)
>>> names.clear()
>>> names
[]
remove()
2.1.3 改：修改指定位置元素
>>> names = ['Javier', 'Jack', 'Chica', 'Jone']
>>> names
['Javier', 'Jack', 'Chica', 'Jone']
>>> names[0] = 'Ji'
>>> names[-1] = 'Chen'
>>> names
['Ji', 'Jack', 'Chica', 'Chen']
reverse()
sort()
reversed / sorted()
2.1.4 查
index () —>返回索引值
>>> names
['Ji', 'Jack', 'Chica', 'Chen']
>>> names.index('Chica')
2
count() —>返回该元素个数
>>> names.count('Ji')
1
>>> names.append('Ji')
>>> names
['Ji', 'Jack', 'Chica', 'Chen', 'Ji']
>>> names.count('Ji')
2
切片：特性.顾头不顾尾
names[start:end]
步长：names[start:end:step] #step 默认是1，(-1时列表反转，start、end无效)
sort() —>排序(只能排单一数据类型的列表)
>>> names1
['Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone']
>>> names1.append('1')
>>> names1.append('2')
>>> names1
['Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone', '1', '2']
>>> names1.sort()
>>> names1
['1', '2', 'Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone']
reverse() —>反转
>>> names1.reverse()
>>> names1
['Jone', 'Jone', 'Javier', 'Jack', 'Jack', 'Candy', '2', '1']
3、循环列表
>>> for i in names1:
... print(i)
...
Jone
Jone
Javier
Jack
Jack
Candy
2
1
2.2 字典(Dict)
{key1:value1,key2:value2}
1、键与值用冒号分开；
2、项与项用逗号分开。
2.2.1 特征
1、key必须为不可变数据类型、必须唯一
2、可存放多个value值、可以修改、可以不唯一
3、无序
4、查询速度快，并且不受字典大小影响
2.2.2 创建字典
1、names = {'name':'Javier','sex':'male'}
2、names = dict(name = 'Javier', sex = 'male')
3、names = dict({'name':'Javier','sex':'male'})
4、names = {}.fromkeys([1,2,3,4,5],99)
>>> names = {}.fromkeys([1,2,3,4,5],99)
>>> names
{1: 99, 2: 99, 3: 99, 4: 99, 5: 99}
2.2.3 增
1.直接增加：
>>> names = {'name':'Javier','sex':'male'}
>>> names['age'] = 23
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23
2.增加方法：
names.setdefault(self,key,default)
>>> names.setdefault('gf','Chica')
'Chica'
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
2.2.4 删
1.pop()删：删除指定key，并返回该key下的value
names.pop('age')
>>> names.pop('age')
23
>>> names
{'name': 'Javier', 'sex': 'male', 'gf': 'Chica'}
2.popitem()删：随机删除1个key，并返回
>>> names.popitem()
('gf', 'Chica')
>>> names
{'name': 'Javier', 'sex': 'male'}
3.del()删：删除指定key()，不返回
>>> del names['sex']
>>> names
{'name': 'Javier'}
4.clear()清空：
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names.clear()
>>> names
{}
2.2.5 改
1.直接改：
>>> names = {'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names['age'] = 18
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 18, 'gf': 'Chica'}
2.更新改：即可对原key进行修改，也可增加新key
>>> names = {'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names1 = {'name':'Jone','gpa':5.0}
>>> names.update(names1)
>>> names
{'name': 'Jone', 'sex': 'male', 'age': 23, 'gf': 'Chica', 'gpa': 5.0}
2.2.6 查
(1) 直接查，返回key对应的value，若key不在字典中，则报错
>>> names['gf']
'Chica'
>>> names['bf']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'bf'
(2) get()查，
names.get(key,default = None) 若 key在字典中，则返回 key 对应的value，若key不在字典中，则返回 default (默认为不返回)
>>> names.get('gf')
'Chica'
>>> names.get('gf','none')
'Chica'
>>> names.get('bf','none')
'none'
>>> names.get('bf')
(3) 判断key在不在字典中，在返回True,不在返回False
>>> 'gf' in names
True
>>> 'bf' in names
False
4.names.keys() —>返回字典中所有key的列表
>>> names.keys()
dict_keys(['name', 'sex', 'age', 'gf', 'gpa'])
5.names.values() —>返回字典中所有value的列表
>>> names.values()
dict_values(['Jone', 'male', 23, 'Chica', 5.0])
6.names.items() —>返回每组key和key对应的value形成的元组并组成的列表
>>> names.items()
dict_items([('name', 'Jone'), ('sex', 'male'), ('age', 23), ('gf', 'Chica'), ('gpa', 5.0)])
求长度：
>>> len(names)
5
2.3 集合(Set)
2.3.1 特征
元素不可变，不能嵌套可变数据类型如list、dict，str、数字、tuple等，不可变类型可以嵌套
天生去重，集合中无重复元素
无序
集合的常用之处：去重、关系运算
2.3.2 创建集合
>>> a = {1,2,2,3,9,5,5,6,7,8,8,'Javier','Chica','Jone'}
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 'Javier', 'Chica'}
2.3.3 增：相同元素不能再被增加
>>> a.add(2)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 'Javier', 'Chica'}
>>> a.add(10)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 10, 'Javier', 'Chica'}
2.3.4 删
a.discard(self,element) —>删除指定元素，若元素不存在，则什么都不做
>>> a.discard('Jone')
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}
>>> a.discard(0)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}
a.pop() —>随机删，并返回删除的元素
>>> a.pop()
1
>>> a
{2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}
a.remove(self,element) —>删除指定元素，若元素不存在，则报错
>>> a.remove(10)
>>> a
{2, 3, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
>>> a.remove(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 10
2.3.5 查
>>> 2 in a
True
>>> 10 in a
False
2.3.6 集合中的关系运算
差集：返回集合a中包含而集合b中不包含的元素
(1) .a - b
>>> a
{2, 3, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
>>> b = {0,1,2,4,6,8}
>>> a - b
{3, 5, 7, 'Javier', 9, 'Chica'}
>>> b - a
{0, 1, 4}
(2).a.difference(self,s)
>>> a.difference(b)
{3, 5, 7, 'Javier', 9, 'Chica'}
>>> b.difference(a)
{0, 1, 4}
交集：返回集合a和集合b共同包含的元素
(1).a & b
>>> a & b
{8, 2, 6}
(2).a.intersection(self,s)
>>> a.intersection(b)
{8, 2, 6}
并集：返回一个新集合包含集合a和集合b的所有元素
(1).a | b
>>> a | b
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
(2).a.union(self,s)
>>> a.union(b)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
对称差集：把脚踩两只船的人丢掉，也就是“并集-交集”
(1).a ^ b
>>> a ^ b
{0, 1, 3, 4, 5, 7, 'Javier', 9, 'Chica'}
(2).a.symmetric_difference(self,s)
>>> a.symmetric_difference(b)
{0, 1, 3, 4, 5, 7, 'Javier', 9, 'Chica'}
判断两集合之间的关系：
(1).判断两集合是否不相交：不相交返回True，相交则返回False
>>> a.isdisjoint(b)
False
>>> c = {10,11,12,'Jone'}
>>> a.isdisjoint(c)
True
(2).a.issubset(self,s)—>判断a是不是s的子集
>>> a.issubset(b)
False
>>> b
{0, 1, 2, 4, 6, 8}
>>> d = {0,1,2,4,5,6,7,8,9}
>>> b.issubset(d)
True
(3).a.issuperset(self,s) —>判断a是不是s的父集
>>> a.issuperset(b)
False
>>> d.issuperset(b)
True
————————————————
版权声明：本文为CSDN博主「Javier_Ji」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Viking_JoneJi/article/details/105453812
列表和元组的操作
加法运算 + ：连接两个列表 / 元组
乘法运算 * ：复制N次，生成新列表 / 元组
列表 / 元组大小
len(): 列表 / 元组中元素的个数
扫一扫
2052
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
