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%yx与y之商的余数
x **yx的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.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 组成的循环来遍历字符串中每个字符。

格式: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)
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的元素,并删除它

示例:

>>> 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>
    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)
>>>  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 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对应的值

示例:

>>> 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': '小张'}
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页