Python学习笔记（2）数据类型

发表于 | 更新于 | 分类于 | 阅读次数： | 字数： 5,356 | 阅读时长： 21

类型的概念：

类型是编程语言对数据的一种划分。

Python语言的类型：

数字类型、字符串类型、元组类型、列表类型、文件类型、字典类型。

数字类型：

数字类型对Python语言中数字的表示和使用进行了定义和规范。

Python语言包括三种数字类型：

  • 整数类型：与数学中的整数概念一致，没有取值范围限制。
  • 浮点数类型：Python语言中浮点数的数值范围存在限制，小数精度也存在限制。这种限制与在不同计算机系统有关。一般计算机范围为，从10的-308次方 —到10的308次方，小数点后精度可达53位。
  • 复数类型：与数学中的复数概念一致，z = a + bj , a是实数部分，b是虚数部分，a和b都是浮点类型，虚数部分用j 或者J标识。例：12.3+4j。对于复数z，可以用z.real获得实数部分，z.imag获得虚数部分。

数字类型之间的关系：

三种类型存在一种逐渐“扩展”的关系：

整数 -> 浮点数 -> 复数 (整数是浮点数的特例，浮点数是复数的特例)

不同数字类型之间可以进行混合运算，运算后生成结果为最宽类型。

数字类型的转换：

三种类型可以相互转换，函数：int(), float(), complex().

示例：

  • int(4.5) = 4 (直接去掉小数部分)
  • float(4) = 4.0 (增加小数部分)
  • complex(4) = 4 + 0j

数字类型的判断：

函数：type(x)，返回x的类型，使用与所用类型的判断。

示例：

1
2
3
>>> type(5.2)
<class 'float'>
>>>

数字类型的运算：

运算符和运算函数 操作含义
x//y 不大于x与y之商的最大整数
x%y x与y之商的余数
x **y x的y次幂
abs(x) x的绝对值
divmod(x,y) (x//y,x%y)
pow(x,y) x的y次幂

字符串类型：

  • 字符串是用双引号””或者单引号’’括起来的一个或多个字符。
  • 字符串可以保存在变量中，也可以单独存在。
  • 可以用type()函数测试一个字符串的类型。
  • Python语言转义符： \。
  • 输出带有引号的字符串，可以使用转义符。
  • 使用\ 输出带有转移符的字符串。

字符串操作：

  1. 字符串是一个字符序列：字符串最左端位置标记为0，依次增加。字符串中的编号叫做“索引”
  2. 单个索引辅助访问字符串中的特定位置 。格式为： < string >[< 索引 >]。
  3. Python中字符串索引从0开始，一个长度为L的字符串最后一个字符的位置是L-1
  4. Python同时允许使用负数从字符串右边末尾向左边进行反向索引，最右侧索引值是-1。
  5. 可以通过两个索引值确定一个位置范围，返回这个范围的子串。格式： < string >[< start > : < end >]。
  6. start和end都是整数型数值，这个子序列从索引start开始直到索引end结束，但不包括end位置。
  7. 字符串之间可以通过+或*进行连接。
  8. 加法操作(+)将两个字符串连接成为一个新的字符串。
  9. 乘法操作(*)生成一个由其本身字符串重复连接而成的字符串。
  10. len()函数能否返回一个字符串的长度。
  11. 大多数数据类型都可以通过str()函数转换为字符串。

字符串操作示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> str1 = "hello"
>>> str2 = "Python"
>>> type(str1) #用type()测试字类型
<class 'str'>
>>> print("\"hello\"") #输入引号
"hello"
>>> print(str1[1])  #输出字符串str1的第2个字符
e
>>> str1[-4] #字符串倒数第四个字符
'e'
>>> str1[0:4] #字符串第一个到第四个字符
'hell'
>>> str1 + str2 #字符串加法操作
'helloPython'
>>> 3 * str1 #字符串乘法操作
'hellohellohello'
>>> len(str1) #字符串长度
5
>>> str(123) #把数组转换位字符串
'123'
>>>

字符串使用实例：

输入一个月份数字，返回对应月份名称缩写

这个问题的IPO模式是：

  • 输入：输入一个表示月份的数字(1-12)
  • 处理：利用字符串基本操作实现该功能
  • 输出：输入数字对应月份名称的缩写
1
2
3
4
5
6
7
8
9
10
11
12
#month.py
months = "JanFebMarAprMayJunJulAugSepOctNovDec"
n = input("请输入月份数（1-12）：")
pos = (int(n) - 1) * 3
monthAbbrev = months[pos:pos+3]
print("月份简写是：" + monthAbbrev + ".")

#程序运行结果：
#=============== RESTART: D:\我的文件\Python程序\输入数字月#份，转换位英语缩写月份.py ===============
请输入月份数（1-12）：11
月份简写是：Nov.
>>>

字符串的处理方法：

操作 含义
+ 连接
* 重复
< string >[ ] 索引
< string >[ : ] 剪切
len(< string >) 长度
< string >.upper() 字符串中字母大写
< string >.lower() 字符串中字母小写
< string >.strip() 去两边空格及去指定字符
< string >.split() 按指定字符分割字符串为数组
< string >.join() 连接两个字符串序列
< string >.find() 搜索指定字符串
< string >.replace() 字符串替换
for < var > in < string > 字符串迭代

可以通过for 和in 组成的循环来遍历字符串中每个字符。

1
格式：for < var > in < string >: 操作

字符串的格式化方法：

Python语言中提供两种字符串的格式化方法。一种类似C语言的格式化方法，使用%；另一种采用format()方法，Python推荐使用第二种。

字符串类型格式化采用format()方法，基本使用格式是：

<模板字符串>.format(<逗号分隔的参数>)

<模板字符串>由一系列的槽组成，用来控制修改字符串中嵌入值出现的位置，其基本思想是将format()方法的<逗号分隔的参数>中的参数按照序号关系替换到<模板字符串>的槽中。

槽用大括号({})表示，如果大括号中没有序号，则按照出现顺序替换。如下图：

format()方法槽顺序方法槽顺序.png)

如果大括号中指定了使用参数的序号，按照序号对应参数替换，如
下图所示。调用format()方法后会返回一个新的字符串，参数从0 开
始编号。

format

例如：

1
2
3
4
5
6
7
#默认排序
>> "{}:计算机{}的CPU占用率为{}%。".format("2016-12-31","Python",10)
'2016-12-31:计算机Python的CPU占用率为10%。'
#指定排序
>>> "{1}:计算机{2}的CPU占用率为{0}%。".format(10,"2016-12-31","Python")
'2016-12-31:计算机Python的CPU占用率为10%。'
>>>

format()方法可以非常方便地连接不同类型的变量或内容，如果需要输出大括号，采用{ {表示 { ， } } 表示 } ，例如：

1
2
3
4
5
6
7
8
9
10
>>> "{}{}{}".format("圆周率",3.1415926,"...")
'圆周率3.1415926...'
>>> "圆周率{{{1},{2}}}是{0}".format("无理数",3.1415926,"...")
'圆周率{3.1415926,...}是无理数'
>>> s = "圆周率{{{1},{2}}}是{0}"   #大括号本身是字符串的一部分
>>> s
'圆周率{{{1},{2}}}是{0}'
>>> s.format("无理数",3.1415926,"...")  #当调用format()是解析大括号
'圆周率{3.1415926,...}是无理数'
>>>

format()方法中<模板字符串>的槽除了包括参数序号，还可以包括格式控制信息。此时，槽的内部样式如下：

  • {<参数序号>: <格式控制标记>}

其中，<格式控制标记>用来控制参数显示时的格式，如下图：

控制字段

<格式控制标记>包括：<填充><对齐><宽度>,<.精度><类型>6 个字段，这些字段都是可选的，可以组合使用，逐一介绍如下。

<填充>、<对齐>和<宽度>是3 个相关字段。<宽度>指当前槽的设定输出字符宽度，如果该槽对应的format()参数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则位数将被默认以空格字符补充。<对齐>指参数在<宽度>内输出时的对齐方式，分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐。<填充>指<宽度>内除了参数外的字符采用什么方式表示，默认采用空格，可以通过<填充>更换。例如：

1
2
3
4
5
6
7
8
9
10
11
12
>>> s = "Python"
>>> "{0:30}".format(s) #指定宽度为30,
'Python                        '
>>> "{0:>30}".format(s)  #右对齐
'                        Python'
>>> "{0:*^30}".format(s)  #居中对齐,填充*
'************Python************'
>>> "{0:-^30}".format(s)  #居中对齐,填充-
'------------Python------------'
>>> "{0:3}".format(s)  #指定宽度为3,
'Python'
>>>

<格式控制标记>中逗号（，）用于显示数字的千位分隔符，例如：

1
2
3
4
5
6
7
8
9
>>> "{0:-^20,}".format(1234567890) #填充-，居中对齐，宽度为20，逗号分割千位分割符
'---1,234,567,890----'
>>> "{0:-^20}".format(1234567890)  #不分割输出
'-----1234567890-----'
>>> "{0:-^20}".format(123456.7890)
'-----123456.789-----'
>>> "{0:-^20,}".format(123456.7890)
'----123,456.789-----'
>>>

<.精度>表示两个含义，由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。

1
2
3
4
5
6
>>> "{0:.2f}".format(12345.67890)
'12345.68'
>>> "{0:H^20.3f}".format(12345.67890)  #填充H，居中对齐，宽度20，保留3位小数
'HHHHH12345.679HHHHHH'
>>> "{0:.4}".format("Python") #保留前四位字符
'Pyth'

<类型>表示输出整数和浮点数类型的格式规则。对于整数类型，输出格式包括6 种：

  1. b: 输出整数的二进制方式；
  2. c: 输出整数对应的 Unicode 字符；
  3. d: 输出整数的十进制方式；
  4. o: 输出整数的八进制方式；
  5. x: 输出整数的小写十六进制方式；
  6. X: 输出整数的大写十六进制方式；
1
2
>>> "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(255)
'11111111,ÿ,255,377,ff,FF'

对于浮点数类型，输出格式包括4 种：

  1. e: 输出浮点数对应的小写字母 e 的指数形式；
  2. E: 输出浮点数对应的大写字母 E 的指数形式；
  3. f: 输出浮点数的标准浮点形式；
  4. %: 输出浮点数的百分形式。

浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好
控制输出格式。

1
2
3
4
>>> "{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'
>>> "{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14) #都知道保留两位小数
'3.14e+00,3.14E+00,3.14,314.00%'

元组类型：

元组的概念

  • 元组是包含多个元素的类型，元素之间用逗号分割。例如：t1 = 123,456, “hello”
  • 元组可以是空的，t2=()
  • 元组包含一个元素时：t3=123,
  • 元组外侧可以使用括号，也可以不使用

元组的特点：

  1. 元组中元素可以是不同类型；一个元组也可以作为另一个元组的元素，此时，作为元素的元组需要增加括号，从而避免歧义。
  2. 元组中各元素存在先后关系，可以通过索引访问元组中元素。例如：t3[0].
  3. 元组定义后不能更改，也不能删除。例如：t3[0]=456
  4. 与字符串类型类似，可以通过索引区间来访问元组中部分元素。例如：t[1:]
    与字符串一样，元组之间可以使用+号和*号进行运算。
  5. 例如：
1
>>> t3 = 123,456,("hello", "中国")

元组总结

  1. Python语言中的元组类型定义后不能修改
  2. 因为tuple(元组)不可变，所以代码更安全。
  3. 如果仅考虑代码的灵活性，也可以用列表类型代替元组类型。

列表类型：

列表的概念

  • 列表(list)是有序的元素集合；
  • 列表元素可以通过索引访问单个元素；

列表与元组类似

  • 列表中每个元素类型可以不一样
  • 访问列表中元素时采用索引形式

列表与元组不同

  • 列表大小没有限制，可以随时修改

列表的操作：

针对列表有一些基本操作，这些操作与字符串操作类似。

列表操作符 含义
< list1 > + < list2> 连接两个列表
< list > * < 整数类型> 对列表进行整数次重复
< list > [< 整数类型>] 索引列表中的元素
len( < seq > ) 列表中元素个数
< list >[ < 整数类型> : < 整数类型>] 取列表的一个子序列
for < var > in < list > : 对列表进行循环列举
< expr > in < list > 成员检查，判断是否

列表操作示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>>> list1 = [1,2,3,4,5]
>>> lsit2 = [6,7,8,9,10]
>>> list1 + list2 #加法操作
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list1 * 3 #乘法操作
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> list1[1] #列表中第二个元素
2
>>> len(list1) #列表list1的长度
5
>>> list1[1:4] #取出列表第2到第四个元素
[2, 3, 4]
>>>for i in list1[:5]:  #遍历列表
      print(i)
1
2
3
4
5
>>> 2 in list1 #2是否在列表1中存在
True
>>> 2 in list2 #2是否在列表2中存在
False

列表相关方法：

方法 含义
< list > . append ( x ) 将元素x增加到列表的最后
< list > . sort ( ) 将列表元素排序
< list > . reverse ( ) 将序列元素反转
< list > . index ( ) 返回第一次出现元素x的索引值
< list > . insert ( i, x ) 在位置i处插入新元素x
< list > . count ( x ) 返回元素x在列表中的数量
< list > . remove ( x ) 删除列表中第一次出现的元素x
< list > . pop ( i ) 取出列表中位置i的元素，并删除它

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> list3
[1, 2, 3, 4, 5, 6]
>>> list3.reverse() #列表反转
>>> list3
[6, 5, 4, 3, 2, 1]
>>> list3.index(3) #f返回第一次3出现的索引值
3
>>> list3.insert(2,7) #在第3个位置插入7
>>> list3
[6, 5, 7, 4, 3, 2, 1]
>>> list3.sort() #排序
>>> list3
[1, 2, 3, 4, 5, 6, 7]
>>> list3.count(4) #返回4在列表中的数量
1
>>> list3.remove(7) #删除第一次出现的7
>>> list3
[1, 2, 3, 4, 5, 6]
>>> list3.pop(3) #取出列中位置3的元素，并删除它
4
>>>

对于字符串，可以通过split()函数，将字符串拆分成一个列表，默认以空格分割。

例如：

1
2
3
>>> "hello word hello python 1 123".split()
['hello', 'word', 'hello', 'python', '1', '123']
>>>

文件类型：

打开文件：

  1. 建立磁盘上的文件与程序中的对象相关联。
  2. 通过相关的文件对象获得。

文件操作：读取、写入、定位、追加、计算等。

关闭文件：

  • 切断文件与程序的联系
  • 写入磁盘，并释放文件缓冲区

打开文件：Open()

格式：

1
2
3
4
Open()
	<variavle> = open(<name>, <mode>)
	<name>磁盘文件名
	<mode>打开模式

打开模式：

符号 含义
r 只读。如果文件不存在，则输出错误
w 只写。如果文件不存在，则自动创建文件
a 附加文件到末尾
rb 只读二进制文件。如果文件不存在，则输出错误
wb 只写二进制文件。如果文件不存在，则自动创建文件
ab 附加文件到二进制文件末尾
r+ 读写

例如：

1
2
3
4
#打开一个名为“number.dat”的文本文件。
>>>infile = open("number.dat", "r")
#打开一个名为“music.mp3”的音频文件。
>>>infile = open("music.mp3", "rb")

文件读取：

  • read()返回值为包含整个文件内容的一个字符串。
  • readline()返回值为文件下一行内容的字符串。
  • readlines()返回值为整个文件内容的列表，每项是以换行符为结尾的一行字符串。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
#将文件内容输出到屏幕上
def main():
	fname = eval(input("Enter filename:"))
	infile = open(fname, "r")
	date = infile.read()
	print(date)
main()

#输出文件前五行内容
infile = open(someFile, "r")
for i in range(5)
	line = infile.readline()
  	print(line[:-1])

写入文件：

  • 从计算机内存向文件写入数据。
  • write()：把含有文本数据或二进制数据块的字符串写入文件中。
  • writelines():针对列表操作，接收一个字符串列表作为参数，将它们写入文件。

例如：

1
2
3
>>>outfile = open("outfile.txt", "w")
>>>outfile.writelines(["hello", " " , "word" ])
>>>outfile.close()

文件遍历

常用为：拷贝文件，根据数据文件定义行走路径，将文件由一种编码转换位另外一种编码。

通用代码框架：

1
2
3
4
file = open(someFlie, "r")
for line in file.readlines():
	#处理一行的文件内容
flie.close()

简化代码框架：

1
2
3
4
file = open(someFlie, "r")
for line in file:
	#处理一行文件内容
file.close()

例如：文件拷贝：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def main():

    #打开文件
    infile = open("原文件", "r") #默认原文件已存在
    outfile = open("新文件", "w")

    #拷贝数据
    for line in infile:
        outfile.write(line)

    #关闭文件
    infile.close()
    outfile.close()

    print("文件拷贝成功！")

main()

字典类型：

字典是针对非序列集合而提供的一种数据类型。

字典的概念：

  • 映射：通过任意键值查找集合中值信息的过程。
  • pthony中通过字典实现映射。
  • 字典是键值对的集合：该集合以键为索引。同一个键信息对应一个键。

字典类型与序列类型的区别：

  1. 存取和访问方式不同。
  2. 键的类型不同：序列类型只能用熟悉类型的键。 字典类型可以用其他对象类型的键。
  3. 排序方式不同：序列元素保持了元素的相对关系。 而字典中的数据都是无序排列的。
  4. 映射方式不同：序列类型通过地址映射到值。 而字典类型通过键直接映射到值。

字典的操作：

创建字典：

字典由键和对应的值成对组成。字典也被称为关联数组或哈希表。基本语法如如下：

1
2
3
dictionaryName[key] = value
#创建一个字典
students = {"001":"小明", "002":"大明"}

注意：

  • 每个键与值用冒号隔开（：）,每对用逗号分开，整体放在花括号中{}.
  • 键必须独一无二，但值不必。
  • 值可以取任何的数据类型，但必须是不可变的，如字符串，数或元组。

访问字典里的值：

dictionaryNmae[key] 返回键key对应的值value。

1
2
3
4
5
6
7
8
9
10
11
12
>>> students
{'001': '小明', '002': '大明'}
>>> students["001"]
'小明'

#如果用字典里没有的键访问数据，会报错
>>> students["003"]
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    students["003"]
KeyError: '003'
>>>

添加数据：

dictionaryNmae[key] = value 来向字典里添加数据。

1
2
3
4
>>> students["003"] = "小张"
>>> students
{'001': '小明', '002': '大明', '003': '小张'}
>>>

删除字典数据：

  1. del dictionaryNmae[key] 可以删除其中一组数据。
  2. del dictionaryNmae 可以删除整个字典。
  3. dictionaryNmae.clear() 可以清空字典内容。
1
2
3
4
5
6
7
8
9
10
11
>>> del students["002"] #删除编号为“002”的元素
>>> students
{'001': '小明', '003': '小张'}
>>> del students #删除整个字典
>>>studnets.clear()  #清空字典数据
>>> students  #报错，因为字典不存在
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    students
NameError: name 'students' is not defined
>>>

字典的遍历：

  • 遍历字典的键key: for key in dictionaryName.keys(): print(key)
  • 遍历字典的值value: for value in dictionaryName.values(): print(value)
  • 遍历字典的项 : for item in dicitonaryName.items(): print(item)
  • 遍历字典的key-value: for item，value in adict.items(): print(item, value)
1
2
3
4
5
6
7
8
9
10
>>>  students = {"001":"小明", "002":"大明" , "003":"小张"} #创建字典
>>> students  #显示字典
{'001': '小明', '002': '大明', '003': '小张'}
>>> for key in students:  #字典的遍历
	print(key + ":" + str(students[key]))
#程序运行结果：
001:小明
002:大明
003:小张
>>>

判断一个键是否在在字典中：

in 或者 not in。

1
2
3
4
5
6
7
>>>students
{'001': '小明', '002': '大明', '003': '小张'}
>>> "001" in students #判断001 是否在字典中
True 
>>> "004" in students
False
>>>

字典常用的方法：

方法名 含义
cmp(dict1，dict2) 比较两个字典元素
len(dict) 计算字典元素的个数，即键的总数
str(dict) 输出字典可打印的字符串提示
type(variable) 返回输入类型的变量
dict.clear() 清空字典元素
dict.copy() 返回一个字典的 浅复制。
dict.fromkeys() 创建一个新的字典， 以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key, default = None) 返回指定键的值，如果值不在字典中返回default值
in 或 not in 判断某键是否在字典中
dict.items() 以列表返回可遍历的(键, 值) 元组数组
dict.update(dict1) 把字典dict1的键/值对更新到dict里
dict.pop(key) 删除并返回字典中的key对应的值

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> students #原字典列表
{'001': '小明', '002': '大明', '003': '小张'}
>>> tuple(students.keys()) #遍历键
('001', '002', '003')
>>> tuple(students.values()) #遍历值
('小明', '大明', '小张')
>>> tuple(students.items()) #遍历键值对
(('001', '小明'), ('002', '大明'), ('003', '小张'))
>>> students.get("001") #获得某键对应的值
'小明'
>>> students.pop("001") #删除某个键对应的键值对，并返回删除的值
'小明'
>>> students #删除后的字典列表
{'002': '大明', '003': '小张'}
>>> type(students) #返回数据类型
<class 'dict'>
>>> students1 = students.copy() #字典的复制
>>> students1
{'002': '大明', '003': '小张'}
坚持原创技术分享，您的支持将鼓励我继续创作！