Python---数据类型
Posted 珠峰上吹泡泡
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python---数据类型相关的知识，希望对你有一定的参考价值。
一 数据类型简介
计算机不仅仅能处理数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有整型，字符串，布尔型，列表，字典，元组等几种。
二 整型
2.1 数字类型的创建
Python3 支持 int、float、bool、complex（复数）。在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。像大多数语言一样，数值类型的赋值和计算都是很直观的。内置的 type() 函数可以用来查询变量所指的对象类型。
a=10 b=a b=666 print(a)#10 print(b)#666
2.2 数字类型的转换
var1=3.14 var2=5 var3=int(var1) var4=float(var2) print(var3,var4)
2.3 py内置数字函数
# abs(x) 返回数字的绝对值，如abs(-10) 返回 10 # ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5 # cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 # exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 # fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0 # floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4 # log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 # log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0 # max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。 # min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。 # modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 # pow(x, y) x**y 运算后的值。 # round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 # sqrt(x) 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
三 字符串类型（string）
Python中的字符串用单引号(\')或双引号(")括起来，同时使用反斜杠(\\)转义特殊字符。
3.1 创建字符串
var1 = \'Hello World!\' var2 = "Python Terry"
3.2 常用操作
重复输出字符串
print(\'hello\'*2)
通过索引获取字符串中字符
print(\'helloworld\'[2:]) 注：仅举一例，其余与列表切片相同
成员运算符（如果字符串中包含给定的字符返回 True）
print(\'el\' in \'hello\')
格式化字符串输出
print(\'Terry is a good teacher\') print(\'%s is a good teacher\'%\'Terry\')
字符串拼接
a=\'123\' b=\'abc\' c=\'789\' d1=a+b+c print(d1) # +效率低,该用join d2=\'\'.join([a,b,c]) print(d2)
3.3 python内置方法
# string.capitalize() 把字符串的第一个字符大写 # string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 # string.decode(encoding=\'UTF-8\', errors=\'strict\') 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 \'ignore\' 或 者\'replace\' # string.encode(encoding=\'UTF-8\', errors=\'strict\') 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是\'ignore\'或者\'replace\' # string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 # string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常. # string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False # string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False # string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False. # string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False. # string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False # string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False # string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False. # string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False # string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False # string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 # string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 # string.lower() 转换 string 中所有大写字符为小写. # string.lstrip() 截掉 string 左边的空格 # string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 # max(str) 返回字符串 str 中最大的字母。 # min(str) 返回字符串 str 中最小的字母。 # string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. # string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找. # string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始. # string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 # string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找. # string.rstrip() 删除 string 字符串末尾的空格. # string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 # string.splitlines(num=string.count(\'\\n\')) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. # string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. # string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() # string.swapcase() 翻转 string 中的大小写 # string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) # string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 # string.upper() 转换 string 中的小写字母为大写
四 布尔型
一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写)。
4.1 基本操作
print(True) print(4>2) print(bool([3,4])) print(True+1) 布尔值经常用在条件判断中: age=18 if age>18:#bool(age>18) print(\'old\') else: print(\'young\')
4.2 与或非操作：
bool(1 and 0) bool(1 and 1) bool(1 or 0) bool(not 0)
五 列表（list）
List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。列表是写在方括号([])之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
5.1 基本操作
查（［］）
names_class2=[\'张三\',\'李四\',\'王五\',\'赵六\'] # print(names_class2[2]) # print(names_class2[0:3]) # print(names_class2[0:7]) # print(names_class2[-1]) # print(names_class2[2:3]) # print(names_class2[0:3:1]) # print(names_class2[3:0:-1]) # print(names_class2[:]) 注;左闭右开
增（append，insert）
#insert 方法用于将对象插入到列表任意一个位置，而append方法则用于在列表末尾追加新的对象 names_class2.append(\'alex\') names_class2.insert(2,\'alvin\') print(names_class2)
改（重新赋值）
names_class2=[\'张三\',\'李四\',\'王五\',\'赵六\'] names_class2[3]=\'赵七\' names_class2[0:2]=[\'wusir\',\'alvin\'] print(names_class2)
删（remove，del，pop）
names_class2.remove(\'alex\') del names_class2[0] del names_class2 names_class2.pop()#注意,pop是有一个返回值的，即可以用一个变量接受
5.2 其他操作
count：count 方法统计某个元素在列表中出现的次数。
>>> [\'to\', \'be\', \'or\', \'not\', \'to\', \'be\'].count(\'to\') 2 >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] >>> x.count(1) 2 >>> x.count([1,2]) 1
extend：可以在列表的末尾一次性追加另一个序列中的多个值。
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6]
注：extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。>>> a=[1,2,3]
>>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6] >>> a + b [1, 2, 3, 4, 5, 6, 4, 5, 6] >>> a [1, 2, 3, 4, 5, 6] index：用于从列表中找出某个值第一个匹配项的索引位置。
names_class2=[\'张三\',\'李四\',\'王五\',\'赵六\']
names_class2.index(\'李四\')
reverse：将列表中的元素反向存放。
names_class2=[\'张三\',\'李四\',\'王五\',\'赵六\'] names_class2.reverse() print(names_class2)
sort：用于在原位置对列表进行排序。
x = [4, 6, 2, 1, 7, 9] x.sort() # 顺序排序 x.sort(reverse=True)#逆序排序
深浅拷贝：浅拷贝（只拷贝第一层），深拷贝（克隆一份）。
注：再讲深浅拷贝之前，先说明：（不可变数据类型:数字,字符串,元组 可变类型:列表,字典）
（1）浅拷贝：
a=[[1,2],3,4] b=a[:]#b=a.copy() print(a,b) print(id(a),id(b)) print(\'*************\') print(\'a[0]:\',id(a[0]),\'b[0]:\',id(b[0])) print(\'a[0][0]:\',id(a[0][0]),\'b[0][0]:\',id(b[0][0])) print(\'a[0][1]:\',id(a[0][1]),\'b[0][1]:\',id(b[0][1])) print(\'a[1]:\',id(a[1]),\'b[1]:\',id(b[1])) print(\'a[2]:\',id(a[2]),\'b[2]:\',id(b[2])) print(\'___________________________________________\') b[0][0]=8 print(a,b) print(id(a),id(b)) print(\'*************\') print(\'a[0]:\',id(a[0]),\'b[0]:\',id(b[0])) print(\'a[0][0]:\',id(a[0][0]),\'b[0][0]:\',id(b[0][0])) print(\'a[0][1]:\',id(a[0][1]),\'b[0][1]:\',id(b[0][1])) print(\'a[1]:\',id(a[1]),\'b[1]:\',id(b[1])) print(\'a[2]:\',id(a[2]),\'b[2]:\',id(b[2]))<br><br><br>#outcome 运行结果： # [[1, 2], 3, 4] [[1, 2], 3, 4] # 4331943624 4331943752 # ************* # a[0]: 4331611144 b[0]: 4331611144 # a[0][0]: 4297375104 b[0][0]: 4297375104 # a[0][1]: 4297375136 b[0][1]: 4297375136 # a[1]: 4297375168 b[1]: 4297375168 # a[2]: 4297375200 b[2]: 4297375200 # ___________________________________________ # [[8, 2], 3, 4] [[8, 2], 3, 4] # 4331943624 4331943752 # ************* # a[0]: 4331611144 b[0]: 4331611144 # a[0][0]: 4297375328 b[0][0]: 4297375328 # a[0][1]: 4297375136 b[0][1]: 4297375136 # a[1]: 4297375168 b[1]: 4297375168 # a[2]: 4297375200 b[2]: 4297375200
解释如下图所示：
（2）深拷贝
import copy b=copy.deepcopy(a)
六 元组（tuple）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同。
6.1 创建元组
tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号
6.2 元组的作用
1 对于一些数据我们不想被修改，可以使用元组；
2 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。
七 字典
字典（dictionary）是Python中另一个非常有用的内置数据类型。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
7.1 创建字典
dic1={\'name\':\'alex\',\'age\':36,\'sex\':\'male\'}
dic2=dict(((\'name\',\'alex\'),))
print(dic1)
print(dic2)
7.2 基本操作
增
dic3={} dic3[\'name\']=\'alex\' dic3[\'age\']=18 print(dic3)#{\'name\': \'alex\', \'age\': 18} a=dic3.setdefault(\'name\',\'yuan\') b=dic3.setdefault(\'ages\',22) print(a,b) print(dic3)
删
dic4={\'name\': \'alex\', \'age\': 18,\'class\':1}
# dic4.clear()
# print(dic4)
del dic4[\'name\']
print(dic4)
a=dic4.popitem()
print(a,dic4)
# print(dic4.pop(\'age\'))
# print(dic4)
# del dic4
# print(dic4)
改
dic3={\'name\': \'alex\', \'age\': 18}
dic3[\'name\']=\'alvin\'
dic4={\'sex\':\'male\',\'hobby\':\'girl\',\'age\':36}
dic3.update(dic4)
print(dic3)
查
dic3={\'name\': \'alex\', \'age\': 18}
# print(dic3[\'name\'])
# print(dic3[\'names\'])
#
# print(dic3.get(\'age\',False))
# print(dic3.get(\'ages\',False))
print(dic3.items())
print(dic3.keys())
print(dic3.values())
print(\'name\' in dic3)# py2: dic3.has_key(\'name\')
print(list(dic3.values()))
7.3 其他操作
dict.fromkeys
d1=dict.fromkeys([\'host1\',\'host2\',\'host3\'],\'Mac\') print(d1) d1[\'host1\']=\'xiaomi\' print(d1)
运行结果为：
{\'host2\': \'Mac\', \'host1\': \'Mac\', \'host3\': \'Mac\'}
{\'host2\': \'Mac\', \'host1\': \'xiaomi\', \'host3\': \'Mac\'}
#######
d2=dict.fromkeys([\'host1\',\'host2\',\'host3\'],[\'Mac\',\'huawei\']) print(d2) d2[\'host1\'][0]=\'xiaomi\' print(d2)
运行结果为
{\'host2\': [\'Mac\', \'huawei\'], \'host1\': [\'Mac\', \'huawei\'], \'host3\': [\'Mac\', \'huawei\']}
{\'host2\': [\'xiaomi\', \'huawei\'], \'host1\': [\'xiaomi\', \'huawei\'], \'host3\': [\'xiaomi\', \'huawei\']}
d.copy() ：对字典 d 进行浅复制，返回一个和d有相同键值对的新字典。
字典的嵌套：三级菜单
sorted(dict) : 返回一个有序的包含字典所有key的列表。
dic={5:\'555\',2:\'222\',4:\'444\'}
print(sorted(dic))
字典的遍历
ic5={\'name\': \'alex\', \'age\': 18}
for i in dic5:
print(i,dic5[i])
for items in dic5.items():
print(items)
for keys,values in dic5.items():
print(keys,values)
八 集合（set）
集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键。
注：可哈希是指集合的对象必须是不可变类型的（数字，字符串，元组）
8.1 集合的简单介绍
集合的创建：
由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建
s1 = set(\'alvin\') s2= frozenset(\'yuan\') print(s1,type(s1)) #{\'l\', \'v\', \'i\', \'a\', \'n\'} <class \'set\'> print(s2,type(s2)) #frozenset({\'n\', \'y\', \'a\', \'u\'}) <class \'frozenset\'>
集合分类：可变集合、不可变集合
可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素
不可变集合(frozenset)：与上面恰恰相反
li=[1,\'a\',\'b\'] s =set(li) dic={s:\'123\'} #TypeError: unhashable type: \'set\'
集合的作用：
- 去重，把一个列表变成集合，就自动去重了
li=[1,2,\'a\',\'b\'] s =set(li) print(s) # {1, 2, \'a\', \'b\'} li2=[1,2,1,\'a\',\'a\'] s=set(li2) print(s) #{1, 2, \'a\'}
- 关系测试，测试两组数据之前的交集、差集、并集等关系
1 in ,not in 2 集合等价与不等价(==, !=) 3 子集、超集 >>>s=set(\'alvinyuan\') >>>s1=set(\'alvin\') >>>print(\'v\' in s) >>>print(s1<s)#返回True,还有另一种表达：s1.issubset(s) 判断s1是不是s的子集
>>>print(s>s1)#返回True，还有一种表达：s.issuperset(s1) 判断s是不是s1的超集 4 并集(|) 并集(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。 >>>s1=set(\'alvin\') >>>s2=set(\'yuan\') >>>s3=s1|s2 >>>print(s3) #{\'a\', \'l\', \'i\', \'n\', \'y\', \'v\', \'u\'} >>>print(s1.union(s2)) #{\'a\', \'l\', \'i\', \'n\', \'y\', \'v\', \'u\'} 5、交集(&) 与集合and等价，交集符号的等价方法是intersection() >>>s1=set(\'alvin\') >>>s2=set(\'yuan\') >>>s3=s1&s2 >>>print(s3) 以上是关于Python---数据类型的主要内容，如果未能解决你的问题，请参考以下文章