Python数据类型(史上最全~不谈)

Python中的6种标准数据类型

标准数据类型

Python 3中有六种标准的数据类型。

一、不可变数据类型

  1. 数字(Number)
  2. 字符串(String)
  3. 元组(Tuple)

1.数字(Number)


1. int(整型)

在64位系统上,整数的位数为64位,取值范围为-263~263-1, 即-9223372036854775808 至 9223372036854775807

注意:在Python 3中不再有long类型了,全都是int


2. float(浮点型) , 即小数

注意:在混合运算中,Python会把整型转换成浮点型。


3. bool(布尔类型)

注意:在 Python 2 中是没有布尔型的,它用数字 0 表示 False,用 1 表示 True。到 Python 3 中,把 True 和 False 定义成关键字了,但它们的值还是 1 和 0,它们可以和数字相加。


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'>			#复数

2.字符串(String)


  1. 加了引号的字符都被认为是字符串,同时使用反斜杠 \ 转义特殊字符。
  • 转义字符
转义字符 描述
\(在行尾时) 续行符
\\ 反斜杠符号
\’ 单引号
\" 双引号
\a 响铃
\b 退格
\e 转义
\000
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页

  1. 单引号、双引号无区别

    可以在单引号内使用双引号,也可以在双引号内使用单引号。

    如:hello_word = "Hi, I'm a boy."


  1. 多引号:
  • 作用一:

    多行注释

  • 作用二:格式化打印

msg = """
-------------------用户登录------------------
User_name = %s
Password = %s
-------------------%s------------------------
""" % (User_name, Password , Result)

  1. 字符串能跟字符串之间相加,即字符串的连接,跟数字相乘,即复制。
>>> given_name = 'Javier'
>>> family_name = ' Ji'
>>> given_name  + family_name
'Javier Ji'

>>> family_name * 3
' Ji Ji Ji'

特征

  1. 字符串按照从左到右的顺序定义字符集合,下标从0开始(与列表等类似),有序

  2. 可以进行切片

>>> a = 'Javier Ji'
>>> a[::-1]
'iJ reivaJ'
>>> a[1:5]
'avie'
  1. 不可以对字符串中的某个字母进行修改,只能对该字符串整体进行重新赋值!
>>> 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'
  1. 取消转义字符
    方法一:在字符串引号前加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

字符串常用操作指令

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)
1

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')
1

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'

3.元组(Tuple)

元组又被称为只读列表,不能修改元组内的元素

特征

  1. 可存放多个值
  2. 元组内元素不可变
  3. 按照从左到右的顺序定义元组元素,下标从0开始顺序访问,有序

元组的创建

>>> 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. 列表(List)
  2. 字典(Dict)
  3. 集合(Set)

1.列表(List)

特征

  1. 可存放多个值
    按照从左到右的顺序定义列表元素,下标从0开始顺序访问,有序
    可修改指定索引位置对应的值,可变

  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]
3

直接删(del)

>>> 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
[]

改:修改指定位置元素

>>> names = ['Javier', 'Jack', 'Chica', 'Jone']
>>> names
['Javier', 'Jack', 'Chica', 'Jone']
>>> names[0] = 'Ji'
>>> names[-1] = 'Chen'
>>> names
['Ji', 'Jack', 'Chica', 'Chen']

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']
  1. 循环列表
>>> for i in names1:
	...   print(i)
	...
	Jone
	Jone
	Javier
	Jack
	Jack
	Candy
	2
	1

2.字典(Dict)

{key1:value1,key2:value2}

  1. 键与值用冒号分开;
  2. 项与项用逗号分开。

特征

  1. key必须为不可变数据类型、必须唯一
  2. 可存放多个value值、可以修改、可以不唯一
  3. 无序
  4. 查询速度快,并且不受字典大小影响

创建字典

  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}

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'}

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
{}

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}

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()—>返回每组keykey对应的value形成的元组并组成的列表

>>> names.items()
dict_items([('name', 'Jone'), ('sex', 'male'), ('age', 23), ('gf', 'Chica'), ('gpa', 5.0)])

求长度:

>>> len(names)
5

3.集合(Set)

特征

  1. 元素不可变,不能嵌套可变数据类型如list、dict,str、数字、tuple等,不可变类型可以嵌套

  2. 天生去重,集合中无重复元素

  3. 无序

集合的常用之处:去重、关系运算

创建集合

>>> 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'}

增:相同元素不能再被增加

>>> 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'}

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 in a
True
>>> 10 in a
False

4.集合中的关系运算

  • 差集:返回集合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}
  1. 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}
  1. 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'}
  1. 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'}
  1. 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
  1. 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
  1. a.issuperset(self,s)—>判断a是不是s的父集
>>> a.issuperset(b)
False
>>> d.issuperset(b)
True
上一篇:fedora下体验gentoo安装


下一篇:Linux_用户和权限