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

类型的概念：

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

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的类型，使用与所用类型的判断。

示例：

>>> 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()函数转换为字符串。

字符串操作示例：

>>> 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)
• 处理：利用字符串基本操作实现该功能
• 输出：输入数字对应月份名称的缩写

#month.pymonths = "JanFebMarAprMayJunJulAugSepOctNovDec"n = input("请输入月份数（1-12）：")pos = (int(n) - 1) * 3monthAbbrev = 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 组成的循环来遍历字符串中每个字符。

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

字符串的格式化方法：

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

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

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

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

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

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

例如：

#默认排序>> "{}:计算机{}的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()方法可以非常方便地连接不同类型的变量或内容，如果需要输出大括号，采用{ {表示 { ， } } 表示 } ，例如：

>>> "{}{}{}".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()参数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则位数将被默认以空格字符补充。<对齐>指参数在<宽度>内输出时的对齐方式，分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐。<填充>指<宽度>内除了参数外的字符采用什么方式表示，默认采用空格，可以通过<填充>更换。例如：

>>> 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'>>> 

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

>>> "{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-----'>>> 

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

>>> "{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: 输出整数的大写十六进制方式；

>>> "{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. %: 输出浮点数的百分形式。

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

>>> "{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. 例如：

>>> t3 = 123,456,("hello", "中国")

元组总结

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

列表类型：

列表的概念

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

列表与元组类似

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

列表与元组不同

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

列表的操作：

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

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

列表操作示例：

>>> 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)12345>>> 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的元素，并删除它

示例：

>>> 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()函数，将字符串拆分成一个列表，默认以空格分割。

例如：

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

文件类型：

打开文件：

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

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

关闭文件：

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

打开文件：Open()

格式：

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

打开模式：

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

例如：

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

文件读取：

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

例如：

#将文件内容输出到屏幕上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():针对列表操作，接收一个字符串列表作为参数，将它们写入文件。

例如：

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

文件遍历

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

通用代码框架：

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

简化代码框架：

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

例如：文件拷贝：

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. 映射方式不同：序列类型通过地址映射到值。 而字典类型通过键直接映射到值。

字典的操作：

创建字典：

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

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

注意：

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

访问字典里的值：

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

>>> 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 来向字典里添加数据。

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

删除字典数据：

1. del dictionaryNmae[key] 可以删除其中一组数据。
2. del dictionaryNmae 可以删除整个字典。
3. dictionaryNmae.clear() 可以清空字典内容。

>>> del students["002"] #删除编号为“002”的元素>>> students{'001': '小明', '003': '小张'}>>> del students #删除整个字典>>>studnets.clear()  #清空字典数据>>> students  #报错，因为字典不存在Traceback (most recent call last):  File "<pyshell#22>", line 1, in <module>    studentsNameError: 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)

>>>  students = {"001":"小明", "002":"大明" , "003":"小张"} #创建字典>>> students  #显示字典{'001': '小明', '002': '大明', '003': '小张'}>>> for key in students:  #字典的遍历    print(key + ":" + str(students[key]))#程序运行结果：001:小明002:大明003:小张>>> 

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

in 或者 not in。

>>>students{'001': '小明', '002': '大明', '003': '小张'}>>> "001" in students #判断001 是否在字典中True >>> "004" in studentsFalse>>> 

字典常用的方法：

方法名 含义 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对应的值

示例：

>>> 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': '小张'}