Python——数据类型（数字，字符串，dict ，set，map函数）

python核心数据类型

Number（数字）

• python支持 int（整数） , float（浮点型） , complex（复数） 三种不同的数据类型。

a = 3
b = 3.14
c = 3 + 4j
print (type(a),type(b),type(c))
#结果：
<class 'int'> <class 'float'> <class 'complex'>
#判断变量是否是该类型
print(isinstance(a,int))
#结果：
True

• Number实例代码

import math
print(math.factorial(32))  #计算32的阶乘
263130836933693530167218012160000000

print(0.4-0.3 == 0.1)    #实数之间尽量避免直接比较大小
False

print(0.4-0.3)
0.10000000000000003

print(math.isclose(0.4-0.3,0.1))  #测试两个实数是否足够接近
True

#python中复数的运算
c = 3 + 4j
print (c+c)     #复数相加   
print (c.real)      #复数的实部
print(c.imag)     #复数的虚部
print (3+4j.imag)   #相当于3+(4j).imag
#结果：
(6+8j)
3.0
4.0
7.0

数字类型的各类函数

数学函数

随机函数

三角函数

数学常量

String(字符串)

• python中的字符串可以使用单引号，双引号，三引号（三个单引号或者是三个双引号）括起来，使用\（反斜杠）转义特殊字符。
• python3源码文件默认以UTF-8编码，所有字符串都是Unicode字符串。
• 支持字符串拼接，截取等多种运算。

text = '''beautiful is better than ugly.
explicit is better than implicit
simple is better than complex
flat is better than nested
'''
print(len(text))  #字符串长度，即所有字符的数量
print(text.count('is'))  #字符串中单词is出现的次数
print ('beautiful' in text)  #测试字符串中是否包含单词beautiful
121
4
True

字符串操作方法：（以下“str”表示为一个字符串）

str[ ]：索引

str[ : ]：剪切

len（str）：长度

str.upper()：字符串中字母大写

str.lower()：字符串中字母小写

str.capitalize()

str.title()

str.swapcase()

text = 'beautiful is better than ugly is.'
print(text.upper())   #字符串中字母大写
print(text.lower())  #字符串中字母小写
print(text.capitalize())    #句首字母大写
print(text.title())     #每个字符首字母大写
print(text.swapcase())  #原来的大写变小写，小写变大写


BEAUTIFUL IS BETTER THAN UGLY IS.
beautiful is better than ugly is.
Beautiful is better than ugly is.
Beautiful Is Better Than Ugly Is.
BEAUTIFUL IS BETTER THAN UGLY IS.

split(str = ’ ',num = string.count(str))

• 其中num = string.count(str))以str为分隔符截取字符串，如果num有指定值，则仅截取num+1个子字符串。
• rsplit()类似，从右侧开始截取。

str.join(seq)：已制定字符串作为分隔符，将seq中所有元素（的字符串表示）合并为一个新的字符串。

text = 'Beautiful is better than ugly.'
print(text.split())     #使用空白字符进行分割
print(text.split(maxsplit = 1))
print(text.rsplit(maxsplit = 2))
print('1,2,3,4'.split(','))
print(','.join(['1','2','3','4']))

['Beautiful', 'is', 'better', 'than', 'ugly.']
['Beautiful', 'is better than ugly.']
['Beautiful is better', 'than', 'ugly.']
['1', '2', '3', '4']
1,2,3,4

str.find(sub,start,end)：搜索字符串中是否有sub字符串，从start开始，end结束。

str.replace(str1,str2,max)：将字符串中的str1替换为str2，替换不超过max次。

text = 'python是一门非常棒的编程语言。'
#replace() 方法返回替换后的新字符串，可以直接再次调用replace()方法
print(text.replace('棒','优雅').replace('编程','程序设计'))
print(text)		#text没有发生变化，是因为字符串是不可变的，replace()是产生一个新的字符串

python是一门非常优雅的程序设计语言。
python是一门非常棒的编程语言。

for v in str：字符串迭代

index(x)：从左到右依次检测x第一次出现的索引值，如果不存在，返回异常

rindex(x)：从右到左依次检测x第一次出现的索引值，索引值为从左数的，如果不存在，返回异常

text = '处处飞花飞处处；声声笑语笑声声。'
print(text.rindex('处'))
print(text.index('声'))
print(text.count('处'))

6
8
4

count(x)：返回x在字符串中出现的次数

maketrans()：创建字符串映射的转换表。

translate(str)：根据str给出的映射转换表转换string字符。

table = ''.maketrans('0123456789','零一二三四五六七八九')
print('Tel:6761865'.translate(table))

Tel:六七六一八六五	

ljust(width,fillchar)：返回一个原字符串左对齐，并使用fillchar填充至长度width的新字符串，fillchar默认为空格。rjust()、center()类似。

print('居左'.ljust(20)+'结束')
print('居右'.rjust(20,'#'))   #左侧使用#填充
print('居中'.center(20,'-'))  #两侧使用-填充

居左                  结束
##################居右
---------居中---------

startswith()、endswith()：检查字符串是否以指定字符开头或者是结尾，返回值为布尔值。

text = 'beautiful is better than ugly is.'
print(text.startswith('beautiful'))
print(text.startswith('Beautiful'))
print(text.endswith(('.',',',':')))

True
False
True

strip() 、rstrip()、lstrip()：从两侧、右侧、左侧截取字符串的指定字符

text = '******=======text========###$$$$*****'
print(text.strip('*'))  #从两端删除*号

#从两端删除=#*，参数中无需规定顺序，类似于一个字符串列表。
# 右端只删除了*是因为参数中没有$，所以遇到$时候停止
print(text.strip('=#*'))

print(text.lstrip('*='))    #从左端删除*=

#从右端删除*$=，只删除了*$，到#停止是因为参数里没有#
print(text.rstrip('*$='))

结果：
=======text========###$$$$
text========###$$$$
text========###$$$$*****
******=======text========###

Process finished with exit code 0

list列表

• 详见python3-内置数据结构

tuple元组

• 详见python3-内置数据结构

dict字典

• 字典是有序（python 3.6 版本之后更新）的对象集合，使用键-值（key-value）存储，具有极快的查找速度。
• 键（key）必须使用不可变类型。
• 同一个字典中，键（key）必须是唯一的，如果重复，最后的一个键值会替换前面的，值不需要唯一。
• 字典中值可以时任意数据类型，但键必须是不可变的，如字符串，数字或元组。

d = {'Michael':95,'Bob':75,'Tracy':85}
print(d['Michael'])
95

d = {'a':1,'b':2,'b':3}
print(d)
{'a':1,'b':3}

• 创建字典的另一种方法：dict函数

items = [('name','Ruby'),('age',25)]
d = dict(items)
print(d)

d = dict(name = 'Ruby',age = 25)
print(d)
#结果：
{'name': 'Ruby', 'age': 25}
{'name': 'Ruby', 'age': 25}

字典的常用方法：

copy（）：返回字典高层结构的一个拷贝，但是不复制嵌入结构，只复制对那些结构的引用。

items = [('name','Ruby'),('age',25),('sex','female')]
d = dict(items)
print(d['name'])
print(d.get('age','sex'))   #如果字典中有age，则返回该键相对应的值，如果没有则返回get函数的第二个参数。
#结果：
Ruby
25

print(list(d))  #返回字典的键
print(list(d.values())) #返回字典的值
print(list(d.items()))  #返回字典的所有元素
#结果：
['name', 'age', 'sex']
['Ruby', 25, 'female']
[('name', 'Ruby'), ('age', 25), ('sex', 'female')]

#用for循环，返回字典的所有元素：
for k,v in d.items():
    print(k,v,sep = ' ')
#结果:
name Ruby
age 25
sex female

'''
字典元素的修改，添加与删除
'''

#当以指定“键”为下标给字典元素赋值时，1）若是“键”存在，则修改；2）若是不存在，则添加。
items = [('name','Ruby'),('age',25),('sex','female')]
d = dict(items)
d['name'] = 'zhaojiaxuan'
d['address'] = 'Nei Meng gu '
print(d)
{'name': 'zhaojiaxuan', 'age': 25, 'sex': 'female', 'address': 'Nei Meng gu '}



#用update（）方法可以将另一个字典的元素一次性全部添加到当前字典，如果键相同就替换，如没有像关键就添加
items = [('name','Ruby'),('age',25),('sex','female')]
d = dict(items)
b = {'name':'zhaojiaxuan','address':'liulin'}
d.update(b)
print(d)
{'name': 'zhaojiaxuan', 'age': 25, 'sex': 'female', 'address': 'liulin'}


#删除
items = [('name','Ruby'),('age',25),('sex','female')]
d = dict(items)
print(d.pop('name'))	#用pop（）删除指定“键”对应的元素，同时返回对应的“值”
print(d)
Ruby	
{'age': 25, 'sex': 'female'}

# 使用popitem()删除
items = [('name','Ruby'),('age',25),('sex','female')]
d = dict(items)
print(d.popitem())	#删除最后一个元素，并以元组的形式返回最后一个元素的键值对
print(d)
('sex', 'female')
{'name': 'Ruby', 'age': 25}


#使用del函数删除
items = [('name','Ruby'),('age',25),('sex','female')]
d = dict(items)
del d['name']  
print(d)
{'age': 25, 'sex': 'female'}

set集合

• set和dict类似，也是一组key的集合，但是不存储value。由于key不可以重复，所以在set中，没有重复的key。
• set是无序的，重复元素在set中自动被过滤。

s = set([1,2,3])
print(s)
s = set([1,1,2,2,3,4,4,5])
print(s)
#结果：
{1, 2, 3}
{1, 2, 3, 4, 5}

• set中只可以包含数字、字符串、元组等不可变类型的数据，而不可以包含列表、字典、集合等可变类型数据，包含列表等可变类型的元组也不能作为集合的元素。
• set是无序的，所以不支持用下标直接访问特定位置的元素，但是可以使用random模块中的sample（）函数随机选取部分元素。
• set可以看作是数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集（&）、并集（|）、差集（-）等操作。

set常用方法：

s.add（x）：将元素x添加到集合s中，如果已存在，则不进行任何操作

s.update（x）：将x的元素添加到集合s中，x可以是元组，列表，字典等。

s.pop(x)：随机删除集合中的一个元素。

s.remove（x）：将元素x从集合s中删除，如果x不存在，则会发生错误。

s.discard(x)：将元素x从集合s中删除，如果x不存在，不会发生错误。

s = {3,5,9,7,6}
s.add(2)    #给集合增加一个元素2
print(s)

s = {3,5,9,7,6}
d = {8,2,9}
s.update(d)     #将集合d更新到集合s中
print(s)
s.pop()     #随机删除一个元素
print(s)
s.remove(5)     #删除5
print(s)
s.discard(2)       #删除一个不存在的元素，不会报错
print(s)

#结果：
{2, 3, 5, 6, 7, 9}
{2, 3, 5, 6, 7, 8, 9}
{3, 5, 6, 7, 8, 9}
{3, 6, 7, 8, 9}
{3, 6, 7, 8, 9}

综合示例

list = [1,2,3]
tuple = (1,2,3)
dict = {'a':97,'b':98,'c':88}
set = {1,2,3}
print(dict['a'])    #字典的下标是“键”，输出为对应“键”的“值”
print(tuple.index(2))   #查看元组中元素2首次出现的位置
#结果：
97
1

#查看字典中那些“键”对应的“值”为98
for key,value in dict.items():  #items为元素
    if value == 98:
        print(key)
#结果：
b

map函数

s = []
for i in range(5):
    s.append(i)
print(s)
a = map(str,s)  #map函数就是把转换函数，将s中元素从int转换为str
print('1' in a)
#结果：
[0, 1, 2, 3, 4]
True

数据类型间的转换

• base表示转换为base进制的整数
• real表示复数的实数，imag表示复数的虚数