Python基础知识——数据类型详解
数据类型详解
数字：
int（整型）：
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型）：
Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大
自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果
float（浮点型）：
浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）：
复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
布尔值：
0：False，假
1：True，真
字符串：
特性：无法修改，字符串一旦定义即无法对其进行修改，仅可以重新定义字符串
格式化输出：参阅Python基础知识一
字符串方法：（中括号内表示可选参数）
第一类：判断类
isalnum():如果字符串至少有一个字符并且所有字符都是字母或者数字则返回True，否则False
isalpha():如果字符串至少有一个字符且所有字符都是字母则返回True，否则False
isdecimal():如果字符串只包含十进制数字则返回True，否则False
isdigit():如果字符串只包含数字则返回True，否则False
islower():如果字符串至少包含一个区分大小写的字符，且都是小写，则返回True，否则False
isnumeric():如果字符串只包含数字，则返回True，否则False
isspace():如果字符串只包含空格，返回True，否则False
istitle():如果字符串是标题化（所有单词都是以大写开始，其余字母均小写），则返回True，否则False
isupper():如果字符串至少包含一个区分大小写的字符，且都是大写，则返回True，否则False
endswith(sub[, start[, end]]):检查字符串是否以sub子串结尾，是则返回True，否则返回False，start和end表示字符串可选范围
startswith(prefix[, start[, end]]):检查字符串是否以prefix开头，是则返回True，否则False
第二类：检索类
find(sub[, start[, end]]):检测sub是否在字符串中，如果有则返回索引值，没有则返回-1
index(sub[, start[, end]]):方法同find，但若子串不存在会返回异常
rfind(sub[, start[, end]]):同find（），从右侧开始查找
rindex(sub[, start[, end]]):同index（），从右侧开始
partition(sub):找到子字符串sub，把字符串分成一个三元组（pre_sub, sub, fol_sub），如果不包含sub则返回（‘原字符串’，‘’，‘’）
rpartition(sub):同partition（），从右侧开始
count(sub[, start[, end]]):返回sub在字符串里出现的次数，start和end表示统计的范围
replace(old, new[, count]):把字符串中的old子字符串替换成new，如果count指定，则替换不超过count次
第三类：格式化类
title():返回标题化的字符
swapcase():反转字符串中的大小写
capitalize():把字符串第一个字符改为大写
casefold():把整个字符串的所有字符改为小写
upper():转换所有小写字符为大写
lower():将字符串中的大写字符变成小写
center(width):用空格将字符串扩展至width长，且将字符串居中
ljust(width):用空格将字符串扩展至width长，且将字符串左对齐
rjust(width):用空格将字符串扩展至width长，且将字符串右对齐
zfile(width):返回长度为width的字符串，原字符串右对齐，前面用0填充
encode(encoding='utf-8',errors='strict'):以encoding指定的编码格式对字符串进行编码
expandtabs([tabsize=8]):将字符串的tab转换为空格，默认为八个空格
join(sub):以字符串作为分隔符，插入到sub中的所有字符之间
lstrip():去掉字符串左边所有空格
rstrip():删除字符串末尾的空格
strip([chars]):删除字符串前后所有空格，chars可以定制删除的字符
第四类：切片类
split(sep=None, maxsplit=-1):不带参数默认以空格为分隔符切片字符串，如果maxsplit参数有设置，则仅分割maxsplit个子字符串，返回切片后的子字符串拼接成的列表
splitlines([keepends]):以‘\n’分割， 返回一个包含各行作为元素的列表，如果keepends参数指定，则返回前keepends行
列表：
`
>>> a=[]#新建空列表
>>> a
[]
>>> a.append('one')#为列表追加元素
>>> a
['one']
>>> b = ['1', '2', '3','4', '5']
>>> a.extend(b)#列表扩展及合并
>>> a
['one', '1', '2', '3', '4', '5']
>>> c = a[:]#切片拷贝
>>> c
['one', '1', '2', '3', '4', '5']
>>> d = a.copy()#列表直接拷贝
>>> d
['one', '1', '2', '3', '4', '5']
>>> a[1:4]#切片截取列表元素
['1', '2', '3']
>>> a.insert(2,'one')#插入元素，插在指定位置的前面
>>> a
['one', '1', 'one', '2', '3', '4', '5']
>>> a[4]='one'#直接修改列表里的元素
>>> a
['one', '1', 'one', '2', 'one', '4', '5']
>>> a.count('one')#统计列表内的某个元素的个数
3
>>> a.index('one', 1, 6)#返回列表内元素的索引值，后两个可选参数划定查找范围
2
>>> a.pop()#删除列表最后一个元素并返回该元素
'5'
>>> a
['one', '1', 'one', '2', 'one', '4']
>>> a.remove('one')#删除元素，只能删除从前数第一个
>>> a
['1', 'one', '2', 'one', '4']
>>> del a[1]#删除指定位置元素
>>> a
['1', '2', 'one', '4']
>>> a.reverse()#列表元素逆排序
>>> a
['4', 'one', '2', '1']
>>> a.sort()#列表元素正排序
>>> a
['1', '2', '4', 'one']
>>> a.sort(reverse=True)#逆排序
>>> a
['one', '4', '2', '1']
>>> a.clear()#清空列表，使列表变成空列表
>>> a
[]
`
列表方法：
list.append(object):追加元素
list.extend(iterable)：追加合并列表
list.copy()：复制列表
list.insert(index, object)：在index位置前插入object
list.count(value)：统计value在列表中出现的次数
list.index(value, [start, [stop]])：在start和stop中返回第一个value的索引值
list.pop([index])：删除索引位置为index的元素，默认删除最后一个
list.remove(value)：删除元素value
list.sort(key=None, reverse=False)：排序，若reverse为True则逆排
list.reverse()：逆排序
list.clear()：清空列表，列表清空后还是列表
列表推导式：
>>> list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]
等价于：
list1 = []
for x in range(10):
for y in range(10):
if x%2 == 0:
if y%2 != 0:
list1.append((x, y))
元组：
`
>>> a = ()#创建空元组
>>> type(a)
<class 'tuple'>
>>> a = (1)
>>> type(a)
<class 'int'>
>>> a = (1,)#创建有一个元素的元组，一定要加上逗号
>>> type(a)
<class 'tuple'>
`
元组只有index（）和count（）两种方法，意味着元组里的内容不可以随便改变，又被称为被束缚的列表。
字典：
字典特性：
- 有大括号标志且元素都有映射关系的数据类型，叫做字典
- 字典不是序列类型，字典是映射类型，列表和元组都是序列类型
- 字典元素无序，没有排序和索引功能
- 字典的Key值唯一，如果出现重复的会自动去重
字典基本操作：
定义|拷贝：
`
方法一：
#通过定义根据大括号以及映射关系创建，如没有映射关系则会被定义成集合
>>> a = {}
>>> type(a)
<class 'dict'>
>>> a = {2:'b', 1:'a', 3:'c'}
>>> a
{2: 'b', 1: 'a', 3: 'c'}
>>> type(a)
<class 'dict'>
方法二：
#fromkeys方法可以形成一个新的字典，注意两个参数不会智能的一一赋值，而是将第二个参数全部作为值来对应所有的键
>>> a = {}
>>> a = a.fromkeys((1, 2, 3))
>>> a
{1: None, 2: None, 3: None}
>>> a
{}
>>> a.fromkeys(('1', '2', '3'), (1, 2, 3))
{'1': (1, 2, 3), '2': (1, 2, 3), '3': (1, 2, 3)}
方法三：
#字典浅拷贝
>>> a
{'1': 'b', '2': None, '3': 'c'}
>>> b = a.copy()
>>> b
{'1': 'b', '2': None, '3': 'c'}
`
添加|修改：
`
方法一：
#直接对字典中键的值进行修改，如果没有该键则会创建
>>> a = {}
>>> a['1'] = 'a'
>>> a
{'1': 'a'}
>>> a['1'] = 'b'
>>> a
{'1': 'b'}
方法二：
#setdefault方法为字典添加新的键和值，不会对已经存在的键的值进行修改
>>> a.setdefault('2')
>>> a
{'1': 'b', '2': None}
>>> a.setdefault('2','b')
>>> a
{'1': 'b', '2': None}
>>> a.setdefault('3', 'c')
'c'
>>> a
{'1': 'b', '2': None, '3': 'c'}
>>> a.setdefault('1')
'b'
方法三：
#用一个字典更新另一个字典，键值相同的不修改，键相同值不同的修改值，键不同的直接创建新的键值
>>> a
{'1': 'b', '2': None, '3': 'c'}
>>> b = {'2':'a', '4':'d'}
>>> a.update(b)
>>> a
{'1': 'b', '2': 'a', '3': 'c', '4': 'd'}
`
删除：
`
方法一：
#pop方法弹出指定键对应的元素并返回，如果该键不存在，则返回第二个参数
>>> a
{'1': 'b', '2': 'a', '3': 'c', '4': 'd'}
>>> a.pop('1')
'b'
>>> a
{'2': 'a', '3': 'c', '4': 'd'}
>>> a.pop('1', 'a')
'a'
方法二：
#popitem方法随机删除字典中的元素
>>> a
{'3': 'c', '4': 'd', '1': 'a'}
>>> a.popitem()
('1', 'a')
>>> a
{'3': 'c', '4': 'd'}
方法三：
#清空字典
>>> a
{'3': 'c', '4': 'd'}
>>> a.clear()
>>> a
{}
`
查询：
`
#根据键查询并返回值，如果键不存在方法一会报错，而方法二不会，且不修改字典中的值
方法一：
>>> a
{'2': 'a', '4': 'd', '5': 'e', '1': 'c'}
>>> a['1']
'c'
>>> a['3']
Traceback (most recent call last):
File "<pyshell#401>", line 1, in <module>
a['3']
KeyError: '3'
方法二：
>>> a
{'2': 'a', '4': 'd', '5': 'e', '1': 'c'}
>>> a.get('1')
'c'
>>> a.get('3')
>>> a
{'2': 'a', '4': 'd', '5': 'e', '1': 'c'}
`
其他操作：
`
>>> a
{'2': 'a', '4': 'd', '5': 'e', '1': 'c'}
>>> a.keys()
dict_keys(['2', '4', '5', '1'])
>>> a.values()
dict_values(['a', 'd', 'e', 'c'])
>>> a.items()
dict_items([('2', 'a'), ('4', 'd'), ('5', 'e'), ('1', 'c')])
循环输出：
>>> for i in a.keys():
print(i)
2
4
5
1
`
集合：
- 以大括号标志且其中元素没有映射关系则为集合
- 同字典相同，无排序和索引功能，且可自动去重
- 与数学中的集合同义，能进行集合运算
集合的操作：
>>> a = {1, 2, 3, 4}#定义
>>> b = set([2, 3, 4, 5, 6, 7])#通过工厂函数定义
>>> a
{1, 2, 3, 4}
>>> b
{2, 3, 4, 5, 6, 7}
>>> a | b #a 和 b的并集
{1, 2, 3, 4, 5, 6, 7}
>>> a & b #a 和 b的交集
{2, 3, 4}
>>> a - b #求差集（项在a中，但不在b中）
{1}
>>> a ^ b #对称差集（项在a或b中，但不会同时出现在二者中）
{1, 5, 6, 7}
>>> a.add(5)#添加一个元素
>>> a
{1, 2, 3, 4, 5}
>>> b.update([1,2,3])#添加多个元素
>>> b
{1, 2, 3, 4, 5, 6, 7}
>>> a.remove(5)#删除某个元素
>>> a
{1, 2, 3, 4}
>>> c = a.copy()#集合浅复制
>>> c
{1, 2, 3, 4}
>>> a
{1, 2, 3, 4}
>>> b
{1, 2, 3, 4, 5, 6, 7}
>>> a.issubset(b)#判断a是否为b的子集
True
>>> a.issuperset(b)#判断b是否为a的子集
False
a.union(b) 等价于 a | b
a.intersection(b) 等价于 a & b
a.difference(b) 等价于 a - b
a.symmetric_difference(b) 等价于 a ^ b
注：
- 工厂函数：int(), long(), str(), list(), cuple()等这些以变量类型为名的函数统称为工厂函数，这些函数可以对变量进行强制转换，以及定义各个类型的变量等
- 复制操作：copy函数为另外创建一个变量，而直接对变量名进行赋值仅仅是增加了指向该变量所处内存的指针，内存内容发生变化，则指针对应的值都会变化
浙公网安备 33010602011771号