下载掌阅APP，畅读海量书库
立即打开
Python语言与Perl、C和Java等语言有许多相似之处，但是也存在一些差异。在本章中我们将学习Python的基础语法，让我们快速学会Python编程吧！
在Python中，标识符的格式满足以下条件：
·第一个字符必须是字母表中字母或下画线“_”。
·标识符的其他的部分由字母、数字或下画线组成。
·标识符对大小写敏感。
在Python中，可以用中文作为变量名，非ASCII标识符也是允许的。此外，Python的标准库提供了一个keyword模块，可以输出当前版本的所有关键字。
import keyword
keyword.kwlist
['False',
'None',
'True',
'and',
'as',
'assert',
…
'while',
'with',
'yield']
Python中单行注释以“#”开头，如图2-10所示。
多行注释可以用多个“#”号，还可以用“'''”和“"""”，如图2-11所示。
图2-10 单行注释
图2-11 多行注释
Python通常是一行写完一条语句，但如果语句很长，可以使用反斜杠“\”来实现多行语句。例如：
total=item_one+\
item_two+\
item_three
在[]、{}或()中的多行语句，不需要使用反斜杠“\”。例如：
total=['item_one','item_two','item_three',
'item_four','item_five']
Python中的变量不需要声明，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。变量没有类型，我们所说的“类型”是变量所指的内存中对象的类型。
等号运算符“=”左边是一个变量名，右边是存储在变量中的值。例如：
counter=100 #整型变量
miles =1000.0 #浮点型变量
name ="Python" #字符串
print(counter)
print(miles)
print(name)
运行程序，输出如下：
100
1000.0
Python
在Python中，允许同时为多个变量赋值。例如：
a=b=c=2
以上实例，创建一个整型对象，值为2，从后向前赋值，三个变量被赋予相同的数值。也可以为多个对象指定多个变量。例如：
a,b,c=1,2,"Python"
以上实例，两个整型对象1和2的分配给变量a和b，字符串对象"Python"分配给变量c。
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，一般情况下只需要将数据类型作为函数名即可。Python数据类型转换可以分为两种：
·隐式类型转换：自动完成。
·显式类型转换：需要使用类型函数来转换。
1）隐式类型转换
在隐式类型转换中，Python会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。
以下实例中，对两种不同类型的数据进行运算时，较低数据类型（整数）会自动转换为较高数据类型（浮点数），以避免数据丢失。
num_int=163
num_flo=1.63
num_new=num_int+num_flo
print(":",type(num_int))
print("num_flo的数据类型：",type(num_flo))
print("num_new的值：",num_new)
print("num_new的数据类型：",type(num_new))
运行程序，输出如下：
:＜class 'int'＞
num_flo的数据类型：＜class 'float'＞
num_new的值：164.63
num_new的数据类型：＜class 'float'＞
在该实例中，我们对两个不同数据类型的变量num_int和num_flo进行相加运算，并存储在变量num_new中。然后查看三个变量的数据类型，在输出结果中，看到num_int是整型（integer），num_flo是浮点型（float）。同样，新的变量num_new是浮点型（float），这是因为Python会将较小的数据类型转换为较大的数据类型，以避免数据丢失。
下面再看一个实例，即整型数据与字符串类型的数据进行相加。
num_int=321
num_str="654"
print("num_int的数据类型：",type(num_int))
print("num_str的数据类型：",type(num_str))
print(num_int+num_str)
运行程序，输出如下：
um_int的数据类型：＜class 'int'＞
num_str的数据类型：＜class 'str'＞
---------------------------------------------------------------------
TypeError Traceback(most recent call last)
＜ipython-input-7-b00b3ddd493f＞ in＜module＞()
----＞5 print(num_int+num_str)
TypeError:unsupported operand type(s)for+:'int'and 'str'
从输出中可以看出，整型和字符串类型运算结果会报错，输出TypeError。Python在这种情况下无法使用隐式转换。但是，Python为这些类型的情况提供了一种解决方案，称为显式转换。
2）显式类型转换
在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。使用int()、float()、str()等预定义函数来执行显式类型转换。
如果要对整型和字符串类型进行运算，则可以用强制类型转换来完成。例如：
num_int=321
num_str="654"
print("num_int数据类型为：",type(num_int))
print("类型转换前，num_str数据类型为：",type(num_str))
num_str=int(num_str) #强制转换为整型
print("类型转换后，num_str数据类型为：",type(num_str))
num_sum=num_int+num_str
print("num_int与num_str相加结果为：",num_sum)
print("sum数据类型为：",type(num_sum))
运行程序，输出如下：
num_int数据类型为：＜class 'int'＞
类型转换前，num_str数据类型为：＜class 'str'＞
类型转换后，num_str数据类型为：＜class 'int'＞
num_int与num_str相加结果为：975
sum数据类型为：＜class 'int'＞
字符串是Python中最常用的数据类型。我们可以使用单引号“'”或双引号“"”创建字符串。创建字符串很简单，只要为变量分配一个值即可。例如：
var1='Hello Python!'
var2="Python"
Python不支持单字符类型，单字符在Python中也是作为一个字符串使用。Python访问子字符串，可以使用方括号“[]”来截取字符串，字符串的截取的语法格式如下：
变量[头下标：尾下标]
索引值以0为开始值，-1为从末尾的开始位置。
例如：
var1='Hello Python!'
var2="Python"
print("var1[0]:",var1[0])
print("var2[1:5]:",var2[1:5])
运行程序，输出如下：
var1[0]:H
var2[1:5]:ytho
跟其他编程语言一样，在字符串也提供相关操作符实现字符串运算。
·+：字符串连接。
·*：重复输出字符串。
·[]：通过索引获取字符串中的字符。
·[：]：截取字符串中的一部分，遵循左闭右开原则，str[0：2]是不包含第3个字符的。
·in：成员运算符。如果字符串中包含给定的字符，则返回True。
·not in：成员运算符。如果字符串中不包含给定的字符，则返回True。
·r/R：原始字符串。所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母r（可以大写或小写）以外，与普通字符串有着几乎完全相同的语法。
·%：格式字符串。
【例2-1】 字符串的运算实例演示。
a="Hello"
b="Python"
print("a+b输出结果：",a+b)
print("a * 2输出结果：",a * 2)
print("a[1]输出结果：",a[1])
print("a[1:4]输出结果：",a[1:4])
if("H"in a):
print("H在变量a中")
else:
print("H不在变量a中")
if("M"not in a):
print("M不在变量a中")
else:
print("M在变量a中")
print(r'\n')
print(R'\n')
运行程序，输出如下：
a+b输出结果：HelloPython
a * 2输出结果：HelloHello
a[1]输出结果：e
a[1:4]输出结果：ell
H在变量a中
M不在变量a中
\n
\n
序列是Python中最基本的数据结构。序列中的每个值都有对应的位置值，称之为索引，第一个索引是0，第二个索引是1，以此类推。Python有6个序列的内置类型，但最常见的是列表和元组。列表都可以进行的操作包括索引、切片、加、乘、检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。它的数据项不需要具有相同的类型。创建一个列表，只要把逗号分隔的不同的数据项用方括号括起来即可。例如：
list1=['Google','Python',2000,2022]
list2=[1,2,3,4,5]
list3=["a","b","c","d"]
list4=['red','green','blue','yellow','white','black']
与字符串的索引一样，列表索引从0开始，第二个索引是1，以此类推。通过索引列表可以进行截取、组合等操作，如图2-12所示。
图2-12 列表索引
索引也可以从尾部开始，最后一个元素的索引为-1，往前一位为-2，以此类推，如图2-13所示。
图2-13 列表反向索引
使用下标索引来访问列表中的值，同样也可以使用方括号“[]”的形式截取字符，如图2-14所示。
图2-14“[]”的形式截取字符
【例2-2】 访问列表中的值的实例。
nums=[10,20,30,40,50,60,70,80,90]
print(nums[0:3])
'''使用负数索引值截取'''
list=['Hello','Python',"xuexi","biancheng","Wiki"]
#读取第二位
print("list[1]:",list[1])
#从第二位开始（包含）截取到倒数第二位（不包含）
print("list[1:-2]:",list[1:-2])
运行程序，输出如下：
[10,20,30]
list[1]: Python
list[1:-2]: ['Python','xuexi']
在Python中，可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项，使用del语句来删除列表的元素。此外，列表比较需要引入operator模块的eq()方法。
提示： 列表对“+”和“*”的操作符与字符串相似。“+”号用于组合列表，“*”号用于重复列表。
【例2-3】 列表的操作实例。
list=['Google','Runoob',2000,2022]
print("第三个元素为：",list[2])
list[2]=2023
print("更新后的第三个元素为：",list[2])
list1=['Hello','Python','xuexi']
list1.append('baidu')
print("更新后的列表：",list1)
del list[2]
print("删除第三个元素：",list)
#导入operator模块
import operator
a=[1,2]
b=[2,3]
c=[2,3]
print("operator.eq(a,b):",operator.eq(a,b))
print("operator.eq(c,b):",operator.eq(c,b))
运行程序，输出如下：
第三个元素为：2000
更新后的第三个元素为：2023
更新后的列表：['Hello','Python','xuexi','baidu']
删除第三个元素：['Google','Runoob',2022]
operator.eq(a,b):False
operator.eq(c,b):True
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用圆括号“()”，列表使用方括号“[]”。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
提示： 元组中只包含一个元素时，需要在元素后面添加逗号“，”，否则括号会被当作运算符使用，如图2-15所示。
图2-15 创建元组
在元组中，可以使用下标索引来访问元组中的值；虽然元组中的元素值是不允许修改的，但可以对元组进行连接组合。同样，也可以使用del语句来删除整个元组。
【例2-4】 元组中元素的相关操作。
tup1=('Baidu','Python',2000,2022)
tup2=(1,2,3,4,5,6,7)
'''访问元组'''
print("tup1[0]:",tup1[0])
print("tup2[1:5]:",tup2[1:5])
tup1[0]: Baidu
tup2[1:5]: (2,3,4,5)
'''删除元组'''
print(tup1)
del tup1
print("删除后的元组tup:")
print(tup1)
('Baidu','Python',2000,2022)
删除后的元组tup:
----------------------------------------------------------------------
NameError Traceback(most recent call last)
＜ipython-input-3-0c09d40b78e6＞ in＜module＞()
---＞10 print(tup1)
NameError:name 'tup1'is not defined
'''修改元组'''
tup3=(12,34.56)
tup4=('abc','xyz')
#以下修改元组元素操作是非法的
#tup3[0]=100
#创建一个新的元组
tup5=tup3+tup4
print(tup5)
(12,34.56,'abc','xyz')
与字符串一样，元组之间可以使用“+”、“+=”和“*”号进行运算。这就意味着它们可以组合和复制，运算后会生成一个新的元组。
元组的元素是不可变的，所谓的不可变指的是元组所指向的内存中的内容不可变，例如：
tup=('r','u','n','o','o','b')
tup[0]='g' #不支持修改元素
Traceback(most recent call last):
File"＜stdin＞",line 1,in＜module＞
TypeError:'tuple'object does not support item assignment
id(tup) #查看内存地址
4440687904
tup=(1,2,3)
id(tup)
4441088800 #内存地址不一样了
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值（key-value）对用冒号“：”分割，每个对之间用逗号“，”分割，整个字典包括在花括号“{}”中，格式为
d={key1:value1,key2:value2,key3:value3}
注意： dict作为Python的关键字和内置函数，变量名不建议命名为dict。字典中的键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串、数字。
在Python中，创建字典有两种方法：一种是使用花括号“{}”创建空字典；另一种是使用内建函数dict()创建字典。
【例2-5】 创建字典。
#使用花括号{}创建空字典
emptyDict={}
#打印字典
print(emptyDict)
#查看字典的数量
print("Length:",len(emptyDict))
#查看类型
print(type(emptyDict))
{}
Length:0
＜class 'dict'＞
emptyDict=dict()
#打印字典
print(emptyDict)
#查看字典的数量
print("Length:",len(emptyDict))
#查看类型
print(type(emptyDict))
{}
Length:0
＜class 'dict'＞
在元组中，可以把相应的键放入方括号中以访问字典里的值；还可以向字典中添加新内容，方法是增加新的键值对、修改或删除已有键值对。在元组中，能删除单一的元素也能清空字典。清空只需一项操作，显式删除一个字典用del命令。
【例2-6】 元组的其他操作实例。
tinydict={'Name':'Python','Age':8,'Class':'two'}
print("tinydict['Name']:",tinydict['Name'])
print("tinydict['Age']:",tinydict['Age'])
tinydict['Name']: Python
tinydict['Age']: 8
#如果用字典里没有的键访问数据，则会输出如下错误
print("tinydict['Alice']:",tinydict['Alice'])
----------------------------------------------------------------------
KeyError Traceback(most recent call last)
＜ipython-input-8-797f63209bc3＞ in＜module＞()
----＞5 print("tinydict['Alice']:",tinydict['Alice'])
KeyError:'Alice'
'''修改字典'''
tinydict['Age']=8 #更新Age
tinydict['School']="Python教程" #添加信息
print("tinydict['Age']:",tinydict['Age'])
print("tinydict['School']:",tinydict['School'])
tinydict['Age']: 8
tinydict['School']: Python教程
'''删除字典元素'''
del tinydict['Name'] #删除键'Name'
tinydict.clear() #清空字典
del tinydict #删除字典
print("tinydict['Age']:",tinydict['Age'])
print("tinydict['School']:",tinydict['School'])
#这会引发一个异常，因为在执行del操作后字典不再存在
NameError Traceback(most recent call last)
＜ipython-input-10-22485daa8f46＞ in＜module＞()
----＞5 print("tinydict['Age']:",tinydict['Age'])
NameError:name 'tinydict'is not defined
字典值可以是任何的Python对象，既可以是标准的对象，也可以是用户定义的，但键不行。两个重要的点需要记住：
（1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，那么后一个值会被记住。
（2）键必须不可变，所以可以用数字、字符串或元组充当，而用列表就不行。
集合（set）是一个无序的不重复元素序列。可以使用花括号“{}”或set()函数创建集合。
注意： 创建一个空集合必须用set()而不是{}，因为{}用来创建一个空字典。
创建格式：
parame={value01,value02,...}
或者
set(value)
【例2-7】 展示集合间的运算。
basket={'apple','orange','apple','pear','orange','banana'}
print(basket) #演示的是去重功能
{'orange','banana','pear','apple'}
'orange'in basket #快速判断元素是否在集合内
{'apple','banana','pear','orange'}
True
'crabgrass'in basket
False
#展示两个集合间的运算
a=set('abracadabra')
b=set('alacazam')
a
{'a','b','c','d','r'}
a-b #集合a中包含而集合b中不包含的元素
{'b','d','r'}
a|b #集合a或b中包含的所有元素
{'a','b','c','d','l','m','r','z'}
a&b #集合a和b中都包含了的元素
{'a','c'}
a^b #不同时包含a和b的元素
{'b','d','l','m','r','z'}
下面来介绍集合的基本操作。
1）添加元素
在集合中，使用add()来添加元素，格式为
s.add(x) #将元素x添加到集合s中，如果元素已存在，则不进行任何操作
也可以添加元素，且参数可以是列表、元组、字典等，格式为
s.update(x) #x可以有多个，用逗号分开
2）移除元素
在集合中，利用remove()可实现移除元素，格式为
s.remove(x) #将元素x从集合s中移除，如果元素不存在，则会发生错误
此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式为
s.discard(x)
3）计算集合元素个数
在集合中，利用len()函数可计算集合元素个数，格式为
len(s) #计算集合s元素个数
4）清空集合
在集合中，利用clear()函数可清空集合，格式为
s.clear() #清空集合s
5）判断元素是否在集合中存在
在集合中，利用in()函数可判断元素是否在集合中存在，语法格式为
x in s #判断元素x是否在集合s中，存在返回True，不存在返回False
【例2-8】 集合的基本操作实例。
set1=set(("Baidu","Python","Taobao"))
#添加元素
set1.add("Facebook")
print(set1)
{'Taobao','Baidu','Python','Facebook'}
#移除元素
set1.remove("Taobao")
print(set1)
{'Baidu','Python','Facebook'}
#计算集合元素个数
len(set1)
3
#清空元素
set1.clear()
print(set1)
set()
#判断元素是否在集合中存在
set1=set(("Baidu","Python","Taobao"))
#判断元素是否在集合中存在
"Python"in set1
True
"Facebook" in set1
False
