Python数据类型专题

1.整型

范围：python的整数类型没有长度限制，支持任意大的数字。

进制表示：
Untitled.png

2.浮点型

范围：浮点数存在范围的限制，范围在-e308到e308之间。

两种表示方法：十进制表示方法和科学计数法表示

  1. a = 2e4 #表示2x10^4,输出结果为20000.0

3. 复数型

二元有序实数对组成，可以对复数对象使用 .real 和 .imag 方法查看实部和虚部

a = 5 + 6j
b = complex(5,6)
print(a.real)
print(a.imag)
print(b.real)
print(a.imag)
'''
输出结果为
5.0
6.0
5.0
6.0
'''

4. 布尔型

只有两个值，True或者False

b1 = True
b2 = False
print(b1, b2)
n = None
print(n)

'''
运行结果为：
True False
None
'''

5.字符串

字符串是由字符组成的序列，单引号和双引号的作用相同

字符串的运算：连接、复制

a = 'I can learn PYTHON'
b = "You can do it as well"
c = "!"

print(a+c+b+c)#字符串进行连接
print(a+c*2)#连接+复制

'''
I can learn PYTHON!You can do it as well!
I can learn PYTHON!!
'''

当字符串中本身含有单引号或双引号或转义字符时，可以考虑转义字符或按原格式输出：

a = "I'm good at programming !\n"   #避免单引号与双引号的混用
b = 'I\'m good at programming !\n'    #利用转义字符
c = r"\r means enter !\n"              #字符串前加r或R表示不再转义，按照原格式输出

print(a,b,c)

'''
输出为
I'm good at programming !
 I'm good at programming !
 \r means enter !\n
'''

字符串的切片：利用索引截取字符串中的部分字符

索引分为正序和逆序；切片使用[ ]获取字符串中的对应字符，有三个参数.其中

[ ]第一个参数表示字符的起始位置（从0开始编号），第二个参数表示结束位置（不含）,第三个参数步长默认为1，可不写.当步长为负数时表示倒着数。

a = 'I can learn PYTHON'

print(a[:])
print(a[:5])
print(a[6:])
print(a[0:1])
print(a[0:10:3])
print(a[-6:])
print(a[-1:-7:-1])

'''
输出结果为
I can learn PYTHON
I can
learn PYTHON
I
Ial
PYTHON
NOHTYP
'''

专题二 Python的数据类型 - 图2

字符串相关函数与方法：

  • len(): 确定字符串长度
  • chr()： 将ASCII编码转化为对应的字符
  • title()：将单词的首字母大写
  • upper()、lower()：分别将单词的全部字母大写或者小写
  • lstrip()、rstrip()、strip()：分别删除字符串开头、末尾、两端的空白字符

以下为组合数据类型

6. 列表list

[ ] 、[1,2,3,4]、[‘1’,’2’,’3’,’4’],…

python的列表是有序的，列表中的值称为元素或者项，元素的序号又叫做索引（从0开始）

列表的长度没有限制，列表使用中括号表示，使用逗号分割其中的元素。

对于列表的操作可以分为创建列表、添加元素、获取元素，删除元素

1.创建列表

直接进行赋值即可创建一个列表

2.向列表中添加元素

使用append()在列表最后进行元素添加

使用insert( , ) 在指定位置插入元素，两个参数，第一个参数表示插入的位置，第二个参数表示插入的元素。（python的列表是有序的）

names = ['den','cen','gen']

names.append('hen')#在末尾加入'hen'元素
print(names)

names.insert(1,'ken')#在1号索引位置插入'ken'元素
print(names)

'''
['den', 'cen', 'gen', 'hen']
['den', 'ken', 'cen', 'gen', 'hen']
'''

3.从列表中获取元素

引用待获取元素的索引序号即可获取对应元素

names = ['den','cen','gen']
print(names[2])

for name in names:
    print(name,end=' ')

'''
gen
den cen gen den
'''

4.从列表中删除元素

三种删除方法，remove()、del、pop()

remove()：删除列表中首次出现的某个元素

del：永久删除列表中指定位置的元素

pop()：暂时删除列表末尾的元素。相当于取出末尾的元素？也可以在括号中指定索引号，取出对应的元素。

names = ['den','cen','gen','den']

names.remove('den')#移除首次出现的特定元素
print(names)

last_name = names.pop()#取出列表中的最后一个元素
print(last_name)
print(names)

del names[1]#删除列表中索引为1的元素
print(names)

'''
['cen', 'gen', 'den']
den
['cen', 'gen']
['cen']
'''

5.组织列表

count( )：返回某个元素在列表中出现的次数

extend( )：将另一列表的所有元素合并到现有列表的末尾

index( )：返回列表中首次出现的某元素的索引号

revere( )：永久反转列表元素的排列顺序，无参

sort( )、sorted( )：分别永久、暂时将列表升序排列

clear( )：清空列表，与del功能类似

num1 = [2,3,1,2,2,1]
num2 = [4,3,3,7,0,0]

count = num1.count(1)
print(count)

num1.extend(num2)
print(num1)

index1 = num1.index(7)
print(index1)

print(num2)
num2.reverse()
print(num2)

print(sorted(num1))   #暂时排序，不是永久改变
print(num1)

num1.sort()           #永久排序，后续不再变动
print(num1)

'''
2
[2, 3, 1, 2, 2, 1, 4, 3, 3, 7, 0, 0]
9
[4, 3, 3, 7, 0, 0]
[0, 0, 7, 3, 3, 4]
[0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 7]
[2, 3, 1, 2, 2, 1, 4, 3, 3, 7, 0, 0]
[0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 7]

'''

6.列表切片

列表切片的使用方法与字符串切片使用方法类似。

检查列表中是否含有某个元素，可以使用in检查

使用len( )查询列表的长度

num1 = [2,3,1,2,2,1]

num1.sort()
print(num1[2:5])  #输出第3-6位的元素
print(3 in num1)  #检查元素3是否在列表中

'''
[2, 2, 2]
True
'''

7. 元组tuple

（）、（1,2,3）、（’1’,’2’,’3’,’4’）

元组与列表非常相似，不同之处在于元组的元素不能修改（修改、删除、排列元素）

1.创建和访问元组

圆括号、逗号隔开

使用索引序号进行访问

2.更新、删除元组元素

可以对两个元组使用+连接，以及del语句删除整个元组

tuple1 = (45,26,78,33)
tuple2 = (78,42,16,61)

print(tuple1 + tuple2)  #将两个元组进行连接
del tuple1
print(tuple1)

'''
(45, 26, 78, 33, 78, 42, 16, 61)
Traceback (most recent call last):
  File "D:\eclipse-workspace\PythonLearning\Python&CNotion\bajinzhi.py", line 6, in <module>
    print(tuple1)
NameError: name 'tuple1' is not defined
'''

3.元组的内置函数

len( )：获取元组的长度

max( )、min( )：找出元组的最大值和最小值

tuple( )：将列表转换为元组

num1 = [2,3,1,2,2,1]
tuple1 = tuple(num1)
print(len(tuple1))
print(max(tuple1),min(tuple1))

'''
6
3 1
'''

8. 集合set

{‘1’,’2’,’3’,’4}、{[1,2,3,4}

集合不同于列表和元组类型，集合存储的元素是无序且不能重复的。元素间没有顺序，集合不能比较和排序。（无序表）

集合的元素类型只能是不可变数据

a = 45
b = 65
num = [a,b]#列表的元素类型可以为变量
print(num)
a = 12
print(num)
'''
[45, 65]
[45, 65]
'''

1.集合的创建

创建集合可以直接使用大括号进行创建或者使用set()命令

#coding:gbk
set1 = set(['den','cen','gen'])   #使用set()创建
set2 = {'den','cen','fen','den'}  #直接创建，重复元素只算一次
print(set1,set2,sep = '\n')

'''
{'den', 'cen', 'gen'}
{'den', 'cen', 'fen'}
'''

2. 访问元素

集合是无序的，因此不能直接通过索引获取某个元素，只能对集合所有元素进行遍历：

set1 = {'den','cen','fen','den'} 
for name in set1:
    print(name,end = ',')

'''
fen,cen,den,
'''

3.集合类型的操作符

集合有四种操作符：& 交集（共同元素）、 | 并集（所有元素） 、- 差集（差） 、^ 异或集（非共同元素）

#coding:gbk
# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建两个集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
print(s & s2) # {3, 4, 5}

# | 并集运算
print( s | s2 )# {1,2,3,4,5,6,7}

# - 差集
print(s - s2) # {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
print(s ^ s2) # {1, 2, 6, 7}

'''
{3, 4, 5}
{1, 2, 3, 4, 5, 6, 7}
{1, 2}
{1, 2, 6, 7}
'''

4.集合使用的方法

集合使用的方法

#coding:gbk
# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建两个集合
s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
print(s1.intersection(s2))
print(s1 & s2) # {3, 4, 5}

# | 并集运算
print(s1.union(s2))
print( s1 | s2 )

# - 差集
print(s1.difference(s2))
print(s1 - s2) # {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
print(s1 ^ s2) # {1, 2, 6, 7}

'''
{3, 4, 5}
{3, 4, 5}
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7}
{1, 2}
{1, 2}
{1, 2, 6, 7}
'''

9. 字典

{ ‘ShuXue’:59,’YuWen’:89,’Zhenzhi’:56}

字典是键值对的无序集合。字典中的每个元素都有两个属性，键和值，属于一种映射关系

字典中的键不可重复，值可以重复

1.字典的创建

直接使用{}进行创建，dict()

dict1 = dict(((1,'A'),(2,'B')))        #先值后键
dict2 = {1:'A',2:'B'}                  #先键后值

print(dict1,dict2,sep = '\n')

'''
{1: 'A', 2: 'B'}
{1: 'A', 2: 'B'}
'''

2.访问字典的键和值

字典名加对应的键

dict1 = dict(((1,'A'),(2,'B')))   
print(dict1[1])

'''
A
'''

3.更新字典

字典是一种动态结构，可随时在其中修改、添加、删除键值对

dict = {'A':'89-100','B':'70-89','C':'60-79'}
dict['A'] = '90-100'   #更改键值对
dict['D'] = '0-60'     #添加键值对
#del dict['B']          #删除键值对，后续调用会报错  
print(dict['A'],dict['B'],dict['D'])
'''
90-100 70-89 0-60
'''

4.遍历字典

先声明两个变量，分别存储字典对应的键和值

dict = {'A':'90-100','B':'70-89','C':'60-79'}
dict['D'] = '0-60'   
for k,v in dict.items():
    print('\nkey:'+k)
    print('value:'+v)

'''
key:A
value:90-100

key:B
value:70-89

key:C
value:60-79

key:D
value:0-60
'''

5. 字典的操作方法

clear()：清空字典所有的键值对

get()：返回指定键的值

items()、keys()、values()：分别对应字典的键值对、键、值（返回值为列表类型，若想按顺序排列可以使用sorted()进行排序）

update()、copy()：相加、拷贝

dict1 = {'A':'90-100','B':'70-89','C':'60-79'}
dict2 = {'D':'0-60'}  
dict3 = dict1.copy()   #拷贝字典
dict1.update(dict2)    #合并两个字典
print(dict2.get('D'))  #和直接取值好像没什么区别
print(dict1,dict3,sep = '\n')
print(dict1.keys(),dict1.values(),sep = '\n')
'''
0-60
{'A': '90-100', 'B': '70-89', 'C': '60-79', 'D': '0-60'}
{'A': '90-100', 'B': '70-89', 'C': '60-79'}
dict_keys(['A', 'B', 'C', 'D'])
dict_values(['90-100', '70-89', '60-79', '0-60'])
'''

10. range 数值列表

使用range()快速生成一系列的数字，结合list()快速生成数字列表

mons = list(range(1,13))
for mon in mons:
    print('M'+str(mon)+'\n')

'''
M1
M2
M3
M4
M5
M6
M7
M8
M9
M10
M11
M12
'''

mons = []
for num in range(1,13):
    mons.append(num)
print(mons)

'''
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
'''