目录
写在前面
本节主要介绍固定语法,包括:声明、注释、缩进、多行语句、保留字符和赋值等。
声明与注释
声明
要为源文件指定特定的字符编码格式,需要在文件的首行或第2行插入一行注释,称为编码声明。这一声明必须放在首行或第2行的原因是:注释行都是以#号开头的,不会被机器编译。编码声明虽然不属于注释行,但同样以#号开头,可能会被机器误识别为注释,只有放在首行或第2行的位置,才能被机器正常识别并编译。编码声明的格式如下。
通过这一声明,源文件中的所有字符都被当作coding指代的UTF-8编码对待。
# -*- coding: utf-8 -*-
编写Python脚本时,除声明编码格式外,常常也会加上一个路径声明。路径声明的格式如下。
# !/usr/bin/Pytho
路径声明指出了系统执行py文件时,调用的是/usr/bin下的Python解释器。路径声明一般放在脚本首行。
注释
单行注释以#号开头,#号后到换行前之间的所有字符都是注释部分;
多行注释同样可以使用#号,在每一行前都需要加上#号。使用#号进行多行注释;
通过3个单引号(′′′)或3个双引号(″″″)将注释对象括起来。使用引号进行多行注释时,需要保证前后使用的引号类型一致。
缩进与多行语句
缩进
代码行首的空白称为缩进,可用4个空格或制表符创建。Python的一大特色就是用缩进的方式标识代码结构,而Java和C++等语言则使用大括号{}。Python使用缩进标识代码结构的方式使得代码更加简洁优雅。
使用缩进方式标识代码结构时,同一代码块内的语句必须有相同的缩进空格数,否则就会出错。
缩进的长度没有硬性要求,保持同层次结构一致即可,推荐使用4个空格进行缩进。
正确的缩进方式:
In[1]: # 比较两个数字对于π的精度, 保持缩进一致
pie = 3.1415
pie 1 = 3.14
同一代码块内各行缩进空格数目相同, 观察输出结果
if pie > pie1:
print('π取pie更精确')
elif pie == pie1:
print('π取pie或pie1一样精确')
else:
print('π取pie1更精确')
Out[1]: π取pie更精确
缩进空格数不一致,会导致代码运行出错,
In[2]: # 比较两个数字对于π的精度, 使用不一致的缩进
pie = 3.1415
pie 1 = 3.14
# 内容与代码清单2-1相同, 缩进不对齐, 观察输出结果
if pie > pie1:
print('π取pie更精确')
elif Pie == pie:
print('π取pie或pie1一样精确')
else:
print('π取pie1更精确')
Out[2]: File "<ipython-input-33-1620b8ac3a51>", line 10
print('π取pie1更精确')
^
IndentationError: expected an indented block
多行语句
编写代码时,通常应在一行内完成一条语句,但太长的语句显得冗长,可读性差。用反斜杠(\)可以实现长语句的换行,且不会被机器识别成多个语句
长语句换行:
In[3]: # 给出3种水果的价格, 计算总价
apple_price, banana_price, pear_price = 1, 1.5, 0.5
用反斜杠实现长语句换行
total_price = apple_price + \
banana_price + \
pear_price
print('total_price =', total_price)
Out[3]: total_price = 3.0
需要注意,在[]、{}、()等不同括号内,多行语句换行时不需要使用反斜杠(\),直接换行即可,
逗号换行:
In[4]: # 方括号内, 在逗号后直接换行
total_price = sum([apple_price,
banana_price,
pear_price])
print('total_price =', total_price)
Out[4]: total_price = 3.0
除了将一个语句拆分为多行外,Python也支持在一行中实现多个语句,这通常只用于多个短语句。在一行中实现多个语句需要使用分号(;)将短语句隔离,
分号隔离:
In[5]: # 给出3种水果的价格, 计算总价
apple_price = 1; banana_price = 1.5; pear_price = 0.5
total_price = apple_price + banana_price + pear_price
print('total_price =', total_price)
Out[5]: total_price = 3.0
保留字符与赋值
保留字符
Python中的标识符是指变量、函数、类、模块及其他对象的名字,可以包含字母、数字和下划线(_),但必须以非数字字符开始。特殊符号,如$、%、@等,不能用在标识符中。标识符对大小写敏感,比如“UFO”和“ufo”就是两 个不同的对象。
保留字符清单:
'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'
In[6]: import keyword
print('Python中所有的保留字符为:\n', keyword.kwlist)
Out[6]: Python中所有的保留字符为:
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
In[7]: # class作为保留字符, 不能被当作普通标识符使用
class = 1
print(class)
Out[7]: File "<ipython-input-10-6950dab4b4c2>", line 1
class = 1
^
yntaxError: invalid syntax
赋值
Python中的赋值方式有4种,除最基本的赋值形式外,还有序列赋值、链接赋值和增量赋值等方式。
基本的赋值
赋值的最基本形式是以等号(=)为连接,将要赋值的变量放在等号左侧,将要赋给的值放在等号右侧
赋值的基本形式:
In[8]: # 使用等号直接给num_int赋一个整数值
num_int = 1
print('使用等号创建的整数为:', num_int)
Out[8]: 使用等号创建的整数为: 1
In[9]: # 使用等号直接给num_float赋一个浮点数值
num_float = 9.9
print('使用等号创建的浮点数为:', num_float)
Out[9]: 使用等号创建的浮点数为: 9.9
In[10]: # 使用等号直接给string赋一个字符串
string = 'python'
print('使用等号创建的字符串为:', string)
Out[10]: 使用等号创建的字符串为: python
序列赋值
序列赋值的基本形式是将多个变量排列成变量序列,变量之间使用逗号相连,使用等号作为赋值符号,后接值序列,值之间用逗号相连。序列赋值在变量序列与值序列之间建立了依次映射的关系。
序列赋值:
In[11]: # 序列赋值可给变量赋值多种数据类型
num_int, string, list1 = 123, 'str', [4,6]
print('赋值创建的多种数据类型为:', num_int, string, list1)
Out[11]: 赋值创建的多种数据类型为: 123 str [4,6]
In[12]: # 序列赋值可给变量赋值已赋值的变量
um1, num2, num3 = 7, 8, 9
num_int1, num_int2, num_int3 = num1, num2, num3
print('变量赋值为已赋值变量结果为:', num_int1, num_int2, num_int3)
Out[12]: 变量赋值为已赋值变量结果为: 7 8 9
链接赋值
链接赋值的基本形式是将多个变量用等号相连,在末个变量后用等号连接一个赋值。链接赋值只适用于给多个变量赋予同一值的情况,又称为多目标赋值
链接赋值:
In[13]: str1 = str2 = str3 = 'STR'
print('str1, str2, str3分别为:', str1, str2, str3)
Out[13]: str1, str2, str3分别为: STR STR STR
In[14]: print('str1, str2, str3的内存地址分别为:', id(str1), id(str2), id(str3))
Out[14]: str1, str2, str3的内存地址分别为: 151371368 151371368 151371368
In[15]: print('str1, str2, str3是否等价:', str1 is str2 is str3)
Out[15]: str1, str2, str3是否等价: True
增量赋值
又称为增强赋值,其基本形式是将原始赋值语句改写,去掉赋值符号右侧变量,将赋值符号右侧运算符挪至赋值符号左侧,形成新的运算式。增量赋值需要通过赋值运算符实现,Python的赋值运算符将在2.2.2节介绍。增量赋值是赋值运算式的“增量写法”,通过声明变量、增量方式和增量数值完成赋值(如运算式“x*=100”,其变量是x,增量方式是*,增量数值是100)。
增量赋值的优势在于可以减少输入代码的工作量,
增量赋值:
In[16]: x=100
x+=10
print('x+=10等价于x=x+10,其值为:',x)
Out[16]: x+=10等价于x=x+10,其值为:110
运算符
Python提供了算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、身份运算符和成员运算符7类运算符
算数运算符
算术运算结果的数字类型与运算数的类型有关。进行除法(/)运算时,不管商为整数还是浮点数,运算结果始终为浮点数。要得到整型的商,需要用双斜杠(//)做整除,且除数必须是整型的。对于其他的运算,只要任一运算数为浮点数,运算结果就是浮点数。
算术运算:
In[1]: num_int = 4
num_float = 4.0
print('整数与浮点数的和为:', num_int + num_float)
Out[1]: 整数与浮点数的和为: 8.0
In[2]: print('整数与浮点数的差为:', num_int - num_float)
Out[2]: 整数与浮点数的差为: 0.0
In[3]: print('整数与浮点数的积为:', num_int * num_float)
Out[3]: 整数与浮点数的积为: 16.0
In[4]: print('浮点数与整数的商为:', num_float / num_int)
Out[4]: 浮点数与整数的商为: 1.0
In[5]: print('浮点数对整数取模结果为:', num_float % num_int)
Out[5]: 浮点数对整数取模结果为: 0.0
In[6]: print('浮点数的整数次幂为:', num_float ** num_int)
Out[6]: 浮点数的整数次幂为: 256.0
赋值运算符
赋值运算符用于变量的赋值和更新。Python的赋值运算符除基础赋值运算符(=)外,还包括加法赋值运算符、减法赋值运算符等。严格地说,除基础赋值运算符外,其他都属于特殊的赋值运算符。
赋值运算
In[7]: num_int1 = 4
print('赋值后num_int1为:', num_int1)
Out[7]: 赋值后num_int1为: 4
In[8]: num_int1 = 4 + 6
print('赋值后num_int1为:', num_int1)
Out[8]: 赋值后num_int1为: 10
In[9]: num_int1 = 4 * 2
print('赋值后num_int1为:', num_int1)
Out[9]: 赋值后num_int1为: 8
In[10]: num_int1 = 4 / 2
print('赋值后num_int1为:', num_int1)
Out[10]: 赋值后num_int1为: 2.0
In[11]: num_int1 = 4 % 2
print('赋值后num_int1为:', num_int1)
Out[11]: 赋值后num_int1为: 0
In[12]: num_int1 = 4 ** 2
print('赋值后num_int1为:', num_int1)
Out[12]: 赋值后num_int1为: 16
比较运算符
比较运算符也可用于字符之间的比较。Python中的字符使用ASCII编码,每个字符都有属于自己的ASCII码,字符比较的本质是字符ASCII码的比较。
比较运算
In[13]: num_int = 4
num_float = 4.0
print('num_int与num_float是否相等:', num_int == num_float)
Out[13]: num_int与num_float是否相等: True
In[14]: print('num_int与num_float是否不相等:', num_int != num_float)
Out[14]: num_int与num_float是否不等: False
In[15]: print('num_int是否大于num_float:', num_int > num_float)
Out[15]: num_int是否大于num_float: False
In[16]: print('num_int是否小于num_float:', num_int < num_float)
Out[16]: num_int是否小于num_float: False
In[17]: print('num_int是否大于等于numfloat:', num_int >= num_float)
Out[17]: num_int是否大于等于numfloat: True
In[18]: print('num_int是否小于等于num_float:', num_int <= num_float)
Out[18]: num_int是否小于等于num_float: True
逻辑运算符
逻辑运算即判断事物之间的“与”“或”“非”关系,Python中的逻辑运算符包含and、or、not,
逻辑运算
In[19]: num_bool1 = False
num_bool2 = True
print('num_bool1 and num_bool2返回值为:', num_bool1 and num_bool2)
Out[19]: num_bool1 and num_bool2返回值为: False
In[20]: print('num_bool1 or num_bool2返回值为:', num_bool1 or num_bool2)
Out[20]: num_bool1 or num_bool2返回值为: True
In[21]: print('not num_bool2的返回值为:', not (num_bool2))
Out[21]: not num_bool2的返回值为: False
按位运算符
十进制数被人们广泛使用,但对于计算机而言,二进制数反而是更重要的,计算机的一切计算都建立在二进制数计算的基础上。按位运算是一种将十进制数转为二进制数再进行运算的过程。
按位运算
In[22]: num_int1 = 15 # 15 = 00001111
num_int2 = 23 # 23 = 00010111
按位与, num_int1 & num_int2 = 00000111
print('num_int1按位与num_int2结果为:', num_int1 & num_int2)
Out[22]: num_int1按位与num_int2结果为: 7
In[23]: # 按位或, num_int1 | num_int2 = 00011111
print('num_int1按位或num_int2结果为:', num_int1 | num_int2)
Out[23]: num_int1按位或num_int2结果为: 31
In[24]: # 按位异或, num_int1 ^ num_int2 = 00011000
print('num_int1按位异或num_int2结果为:', num_int1 ^ num_int2)
Out[24]: num_int1按位异或num_int2结果为: 24
In[25]: # 按位取反, ~ num_int1 = 11110000
print('num_int1按位取反结果为:', ~ num_int1)
Out[25]: num_int1按位取反结果为: -16
In[26]: # 左移动两位, num_int1 << 2 = 00111100
print('num_int1左移动两位结果为:', num_int1 << 2)
Out[26]: num_int1左移动两位结果为: 60
In[27]: # 右移动两位, num_int1 >> 2 = 00000011
print('num_int1右移动两位结果为:', num_int1 >> 2)
Out[27]: num_int1右移动两位结果为: 3
身份运算符
身份运算符用于比较两个对象的储存单位
身份运算符
In[28]: num_int1 = 15
num_int3 = 15
print('num_int1与num_int3储存单位是否相同:', num_int1 is num_int3)
Out[28]: num_int1与num_int3储存单位是否相同: True
In[29]: num_int2 = 15.0
print('num_int1与num_int2储存单位是否相同:', num_int1 is num_int2)
Out[29]: num_int1与num_int2储存单位是否相同: False
In[30]: # 如果储存单位相同就返回True, 否则返回False
print('num_int1与num_int3储存单位是否不同:', num_int1 is not num_int3)
Out[30]: num_int1与num_int3储存单位是否不同: False
In[31]: print('num_int1与num_int2储存单位是否不同:', num_int1 is not num_int2)
Out[31]: num_int1与num_int2储存单位是否不同: True
在身份运算中,内存地址相同的两个变量进行is运算时,返回True;内存地址不同的两个变量进行is not运算时,返回True。当a、b获取到一样的值时,两个变量就获取同样的内存地址
成员运算符
成员运算符的作用是判断某个指定值是否存在某一序列中,包括字符串、列表和元组,
成员运算符
In[32]: num_int1 = 15
ist2 = [1, 'apple', 15]
print('num_int1是否在list2中:', num_int1 in list2)
Out[32]: num_int1是否在list2中: True
In[33]: array = ('orange', 6, 15)
print('num_int1是否不在array中:', num_int1 not in array)
Out[33]: num_int1是否不在array中: False
运算符优先级![](https://i-blog.csdnimg.cn/blog_migrate/0c4e4dd8068c875b7a2c43b3c0ac6aae.png)
In[34]: # 先执行乘除法运算, 再执行加减法运算
print('num_float + num_int1 / num_int3 =', num_float + num_int1 / num_int3)
Out[34]: num_float + num_int1 / num_int3 = 5.0
In[35]: # 先执行加减法运算, 再执行比较运算
print('num_int1 - num_int2 > num_int1 - num_int3:',
num_int1 - num_int2 > num_int1 - num_int3)
Out[35]: num_int1 - num_int2 > num_int1 - num_int3: False
In[36]: # 先执行加减法运算, 再做身份判断
print('num_int1 - num_int3 + num_int1 is num_int1:',
num_int1 - num_int3 + num_int1 is num_int1)
Out[36]: num_int1 - num_int3 + num_int1 is num_int1: True
In[37]: # 先执行指数运算, 再执行减法运算, 最后做身份判断
print('num_float ** 2 - 1 is not num_int2:',
num_float ** 2 - 1 is not num_int2)
Out[37]: num_float ** 2 - 1 is not num_int2: True
数据类型
Python中的常用数据量类型有6种:number、str、list、tuple、dict和set。其中,number和str属于基础数据类型,而list、tuple、dict和sets属于复合数据类型。
基础数据类型
1.number
number又称数字,是专门用于储存数值的数据类型,具有不可改变性。数据的不可改变性意味着:每改变一个数据的类型,计算机就分配内存空间以创建新的对象,解释器则基于数据的类型分配指定的内存,决定什么样的数据可以被储存在内存中。要“改变”不可改变的数据类型,只能通过创造新变量的间接方式。number既是复合型数据中的基本元素,也是数学计算的基本元素,计算机的一切数学计算工作都离不开它。
int只有整数部分,即整型数。int仅表示广为使用的十进制整数,如果需要用到二进制数、八进制数和十六进制数,需要分别通过bin函数、oct函数和hex函数进行创建或转换。在Python 2中,用long表示长整型数,其特征是以L为后缀。长整型数和短整型数同属于整数,区别在于:短整型数的范围是[-2417483648,2417483647],长整型数的范围是[-2^{63},2^{63}-1]。Python 3不再保留长整型数,以int统一表示整数。
float是既有整数部分也有小数部分的数值类型,即浮点型数字。
complex是由实部(real)和虚部(imag)组成的数值类型,即复数。复数的实部和虚部都是浮点数。
bool表示布尔值,只有True(1)和False(0)两种取值。因为bool继承了int类型,所以True可以等价于数值1,False可以等价于数值0,bool值可以直接用于数学运算。
给变量指定一个数值时,number对象就被创建,并在内存中分配储存空间。通过type函数可以判断number对象的类型。
In[1]: num_int = 2
num_float = 4.5
num_bool = True
num_complex = 3j
print('数据类型分别为:\n', type(num_int),
dtype(num_float), type(num_bool), type(num_complex))
Out[1]: 数据类型分别为:
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
不同number类型通过函数可以互相转换,使用代表number类型的函数即可。也可以进行混合运算,运算时先自动转换成同一类型,然后再进行运算。转换遵守一定的方向:int向float转换,非complex向complex转换,
In[2]: # number类型转换
# 将float转换为int(直接去掉小数部分)
print('int(4.5)的结果为:', int(4.5))
Out[2]: int(4.5)的结果为: 4
In[3]: # 将int转换为float(直接增加小数部分)
print('float(4)的结果为:', float(4))
Out[3]: float(4)的结果为: 4.0
In[4]: # 将int和float转换为complex(直接增加虚部)
print('complex(4)和complex(4.5)的结果分别为:', complex(4), complex(4.5))
Out[4]: complex(4)和complex(4.5)的结果分别为: (4+0j) (4.5+0j)
In[5]: # 不同number类型混合运算
# int + float = float
print('整数和浮点数和的类型为:', type(124 + 4.0))
Out[5]: 整数和浮点数和的类型为: <class 'float'>
In[6]: # int + complex = complex
print('整数和复数和的类型为:', type(124 + 5.3j))
Out[6]: 整数和复数和的类型为: <class 'complex'>
In[7]: # float + complex = complex
print('浮点数和复数和的类型为:', type(4.0 + 5.3j))
Out[7]: 浮点数和复数和的类型为: <class 'complex'>
2.str
str又称为字符串,是存放着Unicode字符序列,用于表示文本的数据类型。str可以由任何字符构成,包括字母、数值、符号或标点符号以及它们的任意组合,如“Hello,word!”“1+1”等。与number相同的是,Python中的str也是不可变的,无法直接修改str中的某一位字符。
创建一个str,除字符外,还要在字符序列的首尾加上引号。使用单引号(')、双引号('')是等效的,但需要保证str两端的引号类型相同。如果要指定一个多行的str,则需要使用三引号(''')。
str支持索引,索引一般按照“变量[下标]”和“变量[头下标:尾下标]”两种格式处理,其中的“变量[下标]”格式能够索引单个数值,“变量[头下标:尾下标]”格式能够进行切片(索引连续一片元素)。索引的具体规则如下:
1)下标为正数时,最小为0,表示第1位。下标最大为总字符数减1,表示最后一位。
2)下标为负数时,下标最小为总字符数的相反数,表示第1位。尾下标最大为-1,表示最后一位。
3)当进行切片时,索引从头下标位置字符开始,到尾下标位置前一位字符终止。
4)在一个索引式中,头下标与尾下标可以异号,但必须保证头下标字符位置在尾下标字符之前。
5)头下标留空,表示索引从第1个字符开始;尾下标留空,表示索引到最后一个字符结束。
除一般的索引格式外,str还支持按步长索引,即指定步长后,每隔固定的步数索引一次字符,其格式为“变量[头下标:尾下标:步长]”。此外,通过“变量[::-1]”这一索引式可以将整个str反向排序。
In[8]: string = "ilovePython"
# 下标为正数, 从第2个字符开始索引, 到第6个字符
print('ilovePython[1:5] =', string[1:5])
Out[8]: ilovePython[1:5] = love
In[9]: # 下标为负数, 从倒数第10个字符开始索引, 到倒数第6个字符
print('ilovePython[-10:-6] =', string[-10:-6])
Out[9]: ilovePython[-10:-6] = love
In[10]: # 头下标留空, 从第1个字符开始索引, 到第6个字符
print('ilovePython[:5] =', string[:5])
Out[10]: ilovePython[:5] = ilove
In[11]: # 尾下标留空, 从第2个字符开始索引, 到最后一个字符截止
print('ilovePython[1:] =', string[1:])
Out[11]: ilovePython[1:] = lovePython
In[12]: # 按步索引, 从第2个元素开始索引, 到第11个元素, 步距为3
print('ilovePython[1:10:3] =', string[1:10:3])
Out[12]: ilovePython[1:10:3] = let
In[13]: # 反向索引
print('ilovePython[::-1] =', string[::-1])
Out[13]: ilovePython[::-1] = nohtyPevoli
str的索引方式对Python中其他支持索引的数据类型都具有参考价值。
尽管str不可变,但它其实有很好的可操作性。Python为str提供了极为丰富的内置方法,从而能实现多样化的操作。
str中的所有方法中部分是用于查询的,这些方法包括检查str中是否包含某个对象,是否只包含某个对象,某个对象是否在特定的位置,以及包含某个对象的个数。
str查询方法
In[14]: print('string中n的位置和总数分别为:', string.index('n'), string.count('n'))
Out[14]: string中n的位置和总数分别为: 10 1
In[15]: print('string中是否只包含字母:', string.isalpha())
Out[15]: string中是否只包含字母: True
In[16]: print('string中是否只包含数字:', string.isdigit())
Out[16]: string中是否只包含数字: False
In[17]: print('string是否以P开头:', string.startswith('P'))
Out[17]: string是否以P开头: False
In[18]: print('string是否是标题化的:', string.istitle())
Out[18]: string是否是标题化的: False
str方法除查询外,还有对str进行改写等操作的方法。
改写主要有两种形式:
对str中的制表符、空格等符号进行增删,且改变str的总长度;
针对str中的字母,进行大小写调整或替换。
改写方法
In[19]: print('string左对齐填充至20个字符结果为:', string.ljust(20))
Out[19]: string左对齐填充至20个字符结果为: ilovePython
In[20]: print('string右对齐填充至20个字符结果为:', string.rjust(20))
Out[20]: string右对齐填充至20个字符结果为:ilovePython
In[21]: print('string大写化结果为:', string.upper())
Out[21]: string大写化结果为: ILOVEPYTHON
In[22]: print('string大小写置换结果为:', string.swapcase())
Out[22]: string大小写置换结果为: ILOVEpYTHON
In[23]: print('string中h替换为H结果为:', string.replace('h','H'))
Out[23]: string中h替换为H结果为: ilovePytHon
一些其他功能:
转义字符
除转义输出外,还可以使用+号与*号分别实现str的连接和重复操作。
In[28]: print ('\note\mybook') # str中包含\n, 识别为换行符并转义
Out[28]:
te\mybook
In[29]: print ('\title\mybook') # str中包含\t, 识别为制表符并转义
Out[29]: itle\mybook
In[30]: print (r'\note\mybook ') # 使用r制止转义
Out[30]: \note\mybook
In[31]: print (string + "TEST") # 输出连接的str
Out[31]: ilovePythonTEST
In[32]: print (string * 2) # 输出str两次
Out[32]: ilovePythonilovePython
复合数据类型
Python中的容器包含序列、映射和集合
序列,是数据对象的有序排列,数据对象作为序列中的元素被分配了一个位置编号(索引),序列相当于数学中数列的概念。Python中的序列包括str、list、tuple、Unicode字符串、buffer对象等,其中的str、list、tuple最为常用。
映射,是包含一组键(key)和值(value)以及映射关系的容器,字典(dictionary)是Python中唯一的映射类型,字典中的每个元素都存在相应的名称(称为键)与之一一对应。字典相当于由带有各自名称的元素组成的集合,与序列不同的是,字典中的元素并没有排列顺序。
集合,在集合类型数据中,集合中的元素不能重复出现,当中的元素是唯一的,元素间不存在排列顺序,Python中的集合相当于数学中的集合概念。集合类型包括可变集合(set)与不可变集合(frozenset)。
1.list
list又称为列表,属于序列类数据,是包含0或多个对象引用的有序序列。由于list中所有的数据项都是对象引用,因此list可以存放任意数据类型的数据项,既可以是int、float、str等这种基础数据类型,也可以是list、tuple、dict等这一类的复合数据类型。list是Python中最通用的复合数据类型。
list可以用方括号“[]”创建:空的方括号创建空的list;包含多个项的list可以在方括号中使用逗号分隔的项序列创建。也可以通过list函数创建,list函数最多接收一个参数;不带参数调用函数时返回空list;带参数时返回参数的浅拷贝(在有指针的情况下,浅拷贝只是增加了一个指针,指向已经存在的内存);对复杂参数(非基本元素,如复合数据类型)则尝试将给出的对象转换为list。
In[33]: # 使用方括号创建一个非空list
sist1 = ['runoob', 786, 2.23, 'john']
print('方括号建立的列表为:', list1)
Out[33]: 方括号建立的列表为: ['runoob', 786, 2.23, 'john']
In[34]: #建立元组
tuple1 = (123, 'xyz', 'zara', 'abc')
list2 = list(tuple1)
print('元组转换成列表结果为:', list2)
Out[34]: 元组转换成列表结果为: [123, 'xyz', 'zara', 'abc']
In[35]: # list函数将str拆开, 作为新list中的元素
list3 = list('china')
print('字符串转换成列表结果为:', list3)
Out[35]: 字符串转换成列表结果为: ['c', 'h', 'i', 'n', 'a']
list基本操作
In[36]: print('列表按指定长度索引结果为:', list3[-4:-2])
Out[36]: 列表按指定长度索引结果为: ['h', 'i']
In[37]: print('列表按步长索引结果为:', list3[0::2])
Out[37]: 列表按步长索引结果为: ['c', 'i', 'a']
In[38]: list1[2] = 666
print('列表替换结果为:', list1)
Out[38]: 列表替换结果为: ['runoob', 786, 666, 'john']
In[39]: print('list1和list2用+连接结果为:', list1 + list2)
Out[39]: list1和list2用+连接结果为: ['runoob', 786, 666, 'john', 123, 'xyz', 'zara', 'abc']
In[40]: print('列表通过*重复结果为:', list1 * 2)
Out[40]: 列表通过*重复结果为: ['runoob', 786, 666, 'john', 'runoob', 786, 666, 'john']
Python为list提供了一些内置方法,可以实现list的查询、增删和排序等功能
In[41]: print('list3中a出现的次数:', list3.count('a'), '\n',
'list3中a首次出现的位置:', list3.index('a'))
Out[41]: list3中a出现的次数: 1
list3中a首次出现的位置: 4
In[42]: list3.insert(0,'g')
list1.append('新增')
list2.extend(list3)
print('在列表指定位置插入元素:', list3, '\n',
'在列表末尾新增元素:', list1, '\n',
'将list3扩展至list2:', list2)
Out[42]: 在列表指定位置插入元素: ['g', 'c', 'h', 'i', 'n', 'a']
列表末尾新增元素: ['runoob', 786, 666, 'john', '新增']
将list3扩展至list2: [123, 'xyz', 'zara', 'abc', 'g', 'c', 'h', 'i', 'n', 'a']
In[43]: list3.pop(0)
list1.remove('新增')
print('使用pop删除指定位置的元素:', list3, '\n',
'使用remove删除指定元素:', list1)
Out[43]: 使用pop删除指定位置的元素: ['c', 'h', 'i', 'n', 'a']
使用remove删除指定元素: ['runoob', 786, 666, 'john']
In[44]: list2.pop(0)
list2.sort()
list3.reverse()
print('列表排序:', list2, '\n',
'列表反向排序:', list3)
Out[44]: 列表排序: ['a', 'abc', 'c', 'g', 'h', 'i', 'n', 'xyz', 'zara']
列表反向排序: ['a', 'n', 'i', 'h', 'c']
2.tuple
tuple又称元组,与list同属于序列类数据,是包含0个或多个对象引用的有序序列。与list不同的是,tuple是不可更改的数据类型。
tuple可以用圆括号()创建:空的圆括号创建空的tuple;包含一个或多个项的tuple可以使用逗号分隔开元素;如果tuple内只包含一个元素,需要在元素后加上逗号予以区分。有时,tuple必须被包含在圆括号中以避免语义二义性。例如,要将tuple(1,2,3)传递给一个函数,应该写成function((1,2,3))的形式,以免被识别成“1,2,3”这3个数字变量。
创建tuple
In[45]: # 使用圆括号创建tuple
tup1 = ('Google', 'Runoob')
print('查看tup1类型:', type(tup1), '\n',
'查看tup1:', tup1)
Out[45]: 查看tup1类型: <class 'tuple'>
查看tup1: ('Google', 'Runoob')
In[46]: # 不加括号创建tuple
tup2 = "a", "b", "c", "d"
print('查看tup2:', tup2, '\n',
'查看tup2类型:', type(tup2))
Out[46]: 查看tup2: ('a', 'b', 'c', 'd')
查看tup2类型: <class 'tuple'>
In[47]: # 将['a','b','c']转换成tuple
tup3 = tuple(['x','y','z'])
print('查看tup3:', tup3, '\n',
'查看tup3类型:', type(tup3))
Out[47]: 查看tup3: ('x', 'y', 'z')
查看tup3类型: <class 'tuple'>
In[48]: # 单个数字元素加逗号, 变量是tuple
tup4 = (50,)
# 单个数字元素无逗号, 变量是int
tup5 = (50)
print('tup4和tup5的类型分别为:', type(tup4), type(tup5))
Out[48]: tup4和tup5的类型分别为: <class 'tuple'> <class 'int'>
tuple支持索引,其索引方式与str、list类似。与list相同的是,tuple也可以进行连接、重复操作;与list不同的是,tuple中的元素无法做增删操作,只能使用del函数删除整个tuple。
In[49]: print('tup2中第3元素为:', tup2[2])
print('tup2中第1个到倒数第2个元素为:', tup2[:-1])
Out[49]: tup2中第3元素为: c
tup2中第1个到倒数第2个元素为: ('a', 'b', 'c')
In[50]: print('连接两个元组结果为:', tup1 + tup2)
Out[50]: 连接两个元组结果为: ('Google', 'Runoob', 'a', 'b', 'c', 'd')
In[51]: print('元组重复输出结果为:', tup3 * 2)
Out[51]: 元组重复输出结果为: ('x', 'y', 'z', 'x', 'y', 'z')
Python为tuple提供的内置方法较少,主要用于查询
3.dict
dict又称字典,属于映射类数据。dict通过键而不是位置来索引。键是不可变对象(如number、str、tuple)的对象引用,值是可以指向任意类型对象的对象引用。dict是Python中唯一一种映射数据类型,具有可变性,dict的长度可以增大或减小,如同list一样。dict的值可以无限制地取任何Python对象,既可以是Python内置的标准数据,也可以是用户定义的。同一个键不允许出现两次,创建dict时如果同一个键被赋值两次,只有后一个值会被记住。键固定不变,所以只能用number、str或tuple充当。注意,可变的数据类型不能充当dict中的键。
dict可以用花括号{}创建:使用空的花括号创建空的dict;非空的花括号包含一个或多个逗号分隔的项,每个项包含一个键、一个冒号以及一个值。通过dict函数也可以创建dict:不带参数时返回一个空的dict;带一个映射类型参数时返回以该参数为基础的dict,当参数本身为dict时返回该参数的浅拷贝;也可以使用序列型参数,前提是序列中的每个项是包含两个对象的序列,第1个作为键,第2个作为值。创建dict
创建dict
In[54]: # 使用花括号创建空dict, 更新键值对
dict1 = {}
dict1['one'] = "This is 1"
dict1['two'] = "This is 2"
print('查看字典:', dict1)
Out[54]: 查看字典: {'one': 'This is 1', 'two': 'This is 2'}
In[55]: # 使用dict函数创建dict, 指定键值对
dict2 = dict(name='小明', height=187)
print('查看字典:', dict2)
Out[55]: 查看字典: {'name': '小明', 'height': 187}
dict的主要索引方式是通过键索引值,这与str等变量截然不同。通过dict的索引功能,可以实现dict的查改增删,且不需要用到Python提供的内置方法,
基本操作
In[56]: print('通过键索引字典元素:', dict1['one'])
Out[56]: 通过键索引字典元素: This is 1
In[57]: dict1['one'] = 'this is 1'
print('以键改字典元素值:', dict1)
Out[57]: 以键改字典元素值: {'one': 'this is 1', 'two': 'This is 2'}
In[58]: dict1[3] = 'This is 3'
print('更新后的字典为:', dict1)
Out[58]: 更新后的字典为: {'one': 'this is 1', 'two': 'This is 2', 3: 'This is 3'}
In[59]: del dict1[3]
print('删除键3后的字典为:', dict1)
Out[59]: 删除键3后的字典为: {'one': 'this is 1', 'two': 'This is 2'}
常用操作
In[60]: print('输出dict1中所有的键值对:', dict1.items(), '\n',
'输出dict1中所有的键:', dict1.keys(), '\n',
'输出dict1中所有的值:', dict1.values())
Out[60]: 输出dict1中所有的键值对: dict_items([('one', 'this is 1'), ('two', 'This is 2')])
输出dict1中所有的键: dict_keys(['one', 'two'])
输出dict1中所有的值: dict_values(['this is 1', 'This is 2'])
In[61]: print('与one对应的元素为:', dict1.get('one'), dict1.setdefault ('one'))
Out[61]: 与one对应的元素为: this is 1 this is 1
In[62]: dict1.update(dict2)
dict3 = dict2.copy()
print('将dict2中键值对更新到dict1中:', dict1, '\n',
'将dict2中内容复制到新的字典中:', dict3)
Out[62]: 将dict2中键值对更新到dict1中: {'one': 'this is 1', 'two': 'This is 2', 'name': '小明', 'height': 187}
将dict2中内容复制到新的字典中: {'name': '小明', 'height': 187}
In[63]: dict1.pop('name')
dict2.popitem()
dict3.clear()
print('删除dict1中name键对应的内容:', dict1, '\n',
'随机删除dict2中的一个键值对为:', dict2.popitem(), '\n',
'清空dict3中的内容:', dict3)
Out[63]: 删除dict1中name键对应的内容: {'one': 'this is 1', 'two': 'This is 2', 'height': 187}
随机删除dict2中的一个键值对为: ('name', '小明')
清空dict3中的内容: {}
4.set
Python中有两种内置集合类型:set(可变集合)和frozenset(不可变集合)。set是引用零个或多个对象的无序组合,所引用的对象都是不可变的,所有内置的固定数据类型(如float、frozenset、int、str、tuple)都是不可变的。以下所指的集合都是set。
set可以使用花括号{}或set函数创建。使用花括号{}创建集合时使用{}包裹一个或多个项,项与项间用“,”分割;空的set无法用{}创建。使用set函数创建set时,不带参数时返回空set;带一个参数时返回参数的浅拷贝;带多个参数时,则尝试将给定的对象转换为set,
创建set
In[64]: # 使用非空的{}创建set
set1 = {1, 2, 3}
print('set1的类型为:', type(set1))
Out[64]: set1的类型为: <class 'set'>
In[65]: # 创建一个空的set只能使用set函数
set2 = set()
print('查看set2:', set2, '\n',
'set2的类型为:', type(set2))
Out[65]: 查看set2: set()
set2的类型为: <class 'set'>
In[66]: # 将list、tuple转换为set
set3 = set([1,2,3])
set4 = set((1,2,3))
print('查看set3和set4:', set3, set4, '\n',
'set3和set4的类型分别为:', type(set3), type(set4))
Out[66]: 查看set3和set4: {1, 2, 3} {1, 2, 3}
set3和set4的类型分别为: <class 'set'> <class 'set'>
set是可变的,但由于其中的项是无序的,因此没有索引的概念。set可变而无法索引,这使得它无法进行查询和修改元素的操作,但仍支持元素的增删,并可以清空和拷贝。set的常用操作基本都需要通过内置方法,
常用方法
In[67]: set1.add('a')
print('add方法向set1中添加元素结果为:', set1)
Out[67]: add方法向set1中添加元素结果为: {1, 2, 3, 'a'}
In[68]: set1.pop()
print('pop方法删除set1中任意一个元素结果为:', set1)
Out[68]: pop方法删除set1中任意一个元素结果为: {2, 3, 'a'}
In[69]: set2.clear()
print('清除set2中内容结果为:', set2)
Out[69]: 清除set2中内容结果为: set()
集合运算:
In[70]: print('set4是否为set1的子集:', set4 < set1)
Out[70]: set4是否为set1的子集: False
In[71]: print('set4和set1的并集为:', set4 | set1)
Out[71]: set4和set1的并集为: {1, 2, 3, 'a'}
In[72]: print('set4和set1的交集为:', set4 & set1)
Out[72]: set4和set1的交集为: {2, 3}
In[73]: print('set4和set1的差集为:', set4 - set1)
Out[73]: set4和set1的差集为: {1}
Python I/O
I/O并不仅仅指信息键入和打印信息,还包括文件的输入输出。
input与print
1.input
input函数在用于交互式的信息键入时,相当于一个容器,用户从键盘输入的信息先存放在容器中,再被变量引用。
input函数可以接纳多种数据类型,包括number、str等基础类型,及list、tuple、dict、set等复合类型。使用input函数时,可以在括号内添加str以提示输入。需要注意的是,Python 3.x中的input函数将所有接收的数据都默认为str
输入不同数据类型
In[1]: # 输入一个数字, 由Python默认类型
number1 = input('请输入一个数字:')
Out[1]: 请输入一个数字:1
In[2]: # 输入一个str, 由Python默认类型
tr1 = input('请输入一个字符串:')
Out[2]: 请输入一个字符串:1
In[3]: # 输入一个数字, 并将其转换为int类型
number2 = int(input('请输入一个数字:'))
Out[3]: 请输入一个数字:123
In[4]: # 查看以上输入的输出结果类型
print('number1、str1和number2的类型分别为:\n',
type(number1), type(str1), type(number2))
Out[4]: number1、str1和number2的类型分别为:
<class 'str'> <class 'str'> <class 'int'>
在str1变量中,尽管输入的不是str,也被默认为str。要得到需要的数据类型,必须做类型转换。
2.print
In[5]: # print函数接收多个str
print('我', '爱', '中华')
Out5]: 我 爱 中华
In[6]: # print函数在打印前计算结果
print('100+200 =', 100 + 200)
Out[6]: 100+200 = 300
格式化输出是计算机输出中的一个重要概念,主要针对str。其运行机制为:使用占位符在str中进行占位,再用数值或字符替换占位符,重组str后输出。这种输出方法主要是为了方便修改语句,减少编写代码的工作量,并且包含自动取位、转换进制等功能。Python中的格式化输出方法有两种,即“%+格式符”的方法和format函数方法。
“%+格式符”的方法是一种较早的格式化输出方法,使用方式是在百分号(%)后加上相应的格式符以占位,再进行替换和输出。Python中的格式符
“%+格式符”格式化输出
In[7]: # 用%s、%d分别格式化字符串'Zara'和整数20
print("我的名字叫作%s, 已经%d岁了!"%('Zara',20))
Out[7]: 我的名字叫作Zara, 已经20岁了!
In[8]: # 用%d格式化16, 用%o将十进制整数16用八进制数表示
print("%d 的八进制是 %o"%(16,16))
Out[8]: 16 的八进制是 20
In[9]: # 用%.3f将整数转化为保留小数点后3位的float
print("23 转化为保留3位小数的浮点数%.3f"%(23))
Out[9]: 23转化为保留3位小数的浮点数23.000
文件I/O
1.open
内置函数open的作用是打开一个文件,创建一个file对象以进行调用。在打开文件的基础上,后续的文件读写操作才可以实现。open函数的基本语法格式如下:
open(filename, mode)
filename表示包含要访问的文件名称。mode决定打开文件的模式,这个参数是非强制的,默认的文件访问模式为只读(r),其可取值如表2-22所示。
2.read
在Python中,读取文件的内容需要以只读的模式先打开一个文件,可以用open函数传入文件名和模式标识符,再用read函数读取文件中的内容。
read函数可以从打开的文件中一次性读取全部内容,内容被读取到内存并用一个str对象表示。read函数的基本语法格式如下:
f = open(filename, mode)
f.read(size)
size表示要从文件中读取的字节数,该方法从文件的开头开始读入,每调用一次就读取size个字节的内容。如果没有传入size,程序会尝试尽可能多地读取内容,一直到文件的末尾。
使用read函数读取test.txt文件,并打印
read函数读取test.txt文件
In[14]: # 以只读模式打开test.txt文件
data = open('../data/test.txt', 'r')
# 读取文件中的内容, 存到content变量中
content = data.read()
# 打印出content变量中包含的文本内容
print('该文本中的内容是:', content)
Out[14]: 该文本中的内容是: Hello World!
3.write
在Python中,写入文件和读出文件的操作方式是相似的:先调用open函数并传入标识符‘w’或‘wb’,再使用write函数进行写入。write函数的基本语法格式如下:
f = open(filename, mode)
f.write(str)
write函数写入文件
In[15]: # 打开一个文件
web = open('../tmp/web.txt', 'w')
# 转换内容, 写入文件
value = ('http://www.tipdm.org', 14)
str_value = str(value)
web.write(str_value)
web.close()
# 打开文本, 读取出写入的内容
web = open('../tmp/web.txt', 'r')
content = web.read()
print('该文本中的内容是:', content)
Out[15]: 该文本中的内容是: ('http://www.tipdm.org', 14)
4.close
close函数可以刷新缓存里任何还没写入的信息并关闭文件,关闭之后的文件便不能再进行写入。使用完文件后应该关闭,关闭文件的本质是使文件指针与文件脱离,关闭后不再能通过该指针对原来与其联系的文件进行操作。如果文件使用完后不关闭,文件对象会一直占用操作系统的资源,并且,操作系统同一时间能打开的文件数量是有限的。写入文件时,数据会占用操作系统的内存,待计算机空闲时再慢慢写入,不调用close函数的后果是数据可能只写一部分到磁盘中,其他的信息则丢失了。
fileObject.close()
本节的各代码清单中,都需要在末尾使用close函数关闭文件,以保证信息的完整。
小结
Python可以实现快速开发,是最适合于机器学习的工具。本章介绍了利用Python进行编程的入门知识,主要内容如下:
1)固定语法主要介绍了Python的基本操作,包括声明、注释、缩进、多行语句、保留字符与赋值等。
2)运算符部分主要介绍了算术运算符、比较运算符、赋值运算符、按位运算符、逻辑运算符、成员运算符和身份运算符7类运算符的使用方法,并介绍了多个运算符时的优先级。
3)基础数据类型主要介绍了number和str两种数据类型,其中number包括int、float、bool、complex;str由引号标识,操作方式多样且灵活。
4)复合数据类型主要介绍了list、tuple、dict和set,需要注意各种数据类型之间的异同点,以及每种类型的基础操作。
5)交互式的输入操作主要介绍了基础I/O和文件读写。基础I/O部分说明了input函数的用法、输入数据类型和print函数的输出格式化。文件读写则说明了open、read、write、close四个函数分别实现打开、读取、写入、关闭操作。