大小: 37093
备注:
|
大小: 8334
备注: converted to 1.6 markup
|
删除的内容标记成这样。 | 加入的内容标记成这样。 |
行号 1: | 行号 1: |
## page was renamed from Python游戏设计基础/第2讲:Python语言基本数据类型和表达式 [[TableOfContents]] |
<<TableOfContents>> |
行号 10: | 行号 9: |
== 数字Numbers == | == 数值Numbers == |
行号 18: | 行号 17: |
== 字符串Strings == 字符串是 字符的序列 。字符串基本上就是一组单词。我几乎可以保证你在每个Python程序中都要用到字符串。使用单引号(') 你可以用单引号指示字符串,就如同'Quote me on this'这样。所有的空白,即空格和制表符都照原样保留。使用双引号(") 在双引号中的字符串与单引号中的字符串的使用完全相同,例如"What's your name?"。 |
|
行号 19: | 行号 20: |
== 字符串Strings == 字符串是 字符的序列 。字符串基本上就是一组单词。我几乎可以保证你在每个Python程序中都要用到字符串,所以请特别留心下面这部分的内容。下面告诉你如何在Python中使用字符串。 * 使用单引号(') 你可以用单引号指示字符串,就如同'Quote me on this'这样。所有的空白,即空格和制表符都照原样保留。 * 使用双引号(") 在双引号中的字符串与单引号中的字符串的使用完全相同,例如"What's your name?"。 * 使用三引号({{{'''}}}或{{{"""}}}) 利用三引号,你可以指示一个多行的字符串。你可以在三引号中自由的使用单引号和双引号。例如:{{{'''This is a multi-line string. This is the first line. This is the second line. "What's your name?," I asked. He said "Bond, James Bond." '''}}} * 转义符 假设你想要在一个字符串中包含一个单引号('),那么你该怎么指示这个字符串?例如,这个字符串是What's your name?。你肯定不会用'What's your name?'来指示它,因为Python会弄不明白这个字符串从何处开始,何处结束。所以,你需要指明单引号而不是字符串的结尾。可以通过 转义符 来完成这个任务。你用\'来指示单引号——注意这个反斜杠。现在你可以把字符串表示为'What\'s your name?'。 另一个表示这个特别的字符串的方法是"What's your name?",即用双引号。类似地,要在双引号字符串中使用双引号本身的时候,也可以借助于转义符。另外,你可以用转义符\\来指示反斜杠本身。 值得注意的一件事是,在一个字符串中,行末的单独一个反斜杠表示字符串在下一行继续,而不是开始一个新的行。例如:{{{ "This is the first sentence.\ This is the second sentence." }}}等价于{{{"This is the first sentence. This is the second sentence."}}} * 自然字符串 如果你想要指示某些不需要如转义符那样的特别处理的字符串,那么你需要指定一个自然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicated by \n"。 * Unicode字符串 Unicode是书写国际文本的标准方法。如果你想要用你的母语如北印度语或阿拉伯语写文本,那么你需要有一个支持Unicode的编辑器。类似地,Python允许你处理Unicode文本——你只需要在字符串前加上前缀u或U。例如,u"This is a Unicode string."。记住,在你处理文本文件的时候使用Unicode字符串,特别是当你知道这个文件含有用非英语的语言写的文本。 * 字符串是不可变的 这意味着一旦你创造了一个字符串,你就不能再改变它了。虽然这看起来像是一件坏事,但实际上它不是。我们将会在后面的程序中看到为什么我们说它不是一个缺点。 * 按字面意义级连字符串 如果你把两个字符串按字面意义相邻放着,他们会被Python自动级连。例如,'What\'s' 'your name?'会被自动转为"What's your name?"。 {{{ 给C/C++程序员的注释 在Python中没有专门的char数据类型。确实没有需要有这个类型,我相信你不会为此而烦恼。 }}} == 变量 == |
== 变量Variants == |
行号 75: | 行号 38: |
使用内置函数type可以获取常量或者变量的类型,比如type(123.456)。 | |
行号 76: | 行号 40: |
== 对象 == | == 对象Objects == |
行号 88: | 行号 52: |
# Filename : var.py | |
行号 100: | 行号 63: |
$ python var.py | |
行号 118: | 行号 80: |
== 逻辑行与物理行 == 物理行是你在编写程序时所 看见 的。逻辑行是Python 看见 的单个语句。Python假定每个 物理行 对应一个 逻辑行 。 逻辑行的例子如print 'Hello World'这样的语句——如果它本身就是一行(就像你在编辑器中看到的那样),那么它也是一个物理行。 |
== 语句与行 == |
行号 126: | 行号 84: |
如果你想要在一个物理行中使用多于一个逻辑行,那么你需要使用分号(;)来特别地标明这种用法。分号表示一个逻辑行/语句的结束。例如: | 如果你想要在一行中使用多于一个语句,那么你需要使用分号(;)来特别地标明这种用法。分号表示一个语句的结束。例如: |
行号 144: | 行号 102: |
然而,我强烈建议你坚持在每个物理行只写一句逻辑行。仅仅当逻辑行太长的时候,在多于一个物理行写一个逻辑行。这些都是为了尽可能避免使用分号,从而让代码更加易读。事实上,我 从来没有 在Python程序中使用过或看到过分号。 | 然而,我强烈建议你坚持每行只写一个语句。仅仅当一个语句太长的时候,在多于一行中写一个语句。这些都是为了尽可能避免使用分号,从而让代码更加易读。事实上,我 从来没有 在Python程序中使用过或看到过分号。 |
行号 146: | 行号 104: |
下面是一个在多个物理行中写一个逻辑行的例子。它被称为明确的行连接。 | 下面是一个在多行中写一个语句的例子。它被称为明确的行连接。 |
行号 165: | 行号 123: |
有时候,有一种暗示的假设,可以使你不需要使用反斜杠。这种情况出现在逻辑行中使用了圆括号、方括号或波形括号的时候。这被称为暗示的行连接。你会在后面介绍如何使用列表的章节中看到这种用法。 | 有时候,有一种暗示的假设,可以使你不需要使用反斜杠。这种情况出现在语句中使用了圆括号、方括号或波形括号的时候。这被称为暗示的行连接。 |
行号 189: | 行号 147: |
如何缩进 | 如何缩进:不要混合使用制表符和空格来缩进,因为这在跨越不同的平台的时候,无法正常工作。我 强烈建议 你在每个缩进层次使用四个空格 。 |
行号 191: | 行号 149: |
不要混合使用制表符和空格来缩进,因为这在跨越不同的平台的时候,无法正常工作。我 强烈建议 你在每个缩进层次使用四个空格 。 == 运算符 == |
== 运算符Operators == |
行号 200: | 行号 156: |
||运算符|| 名称|| 说明|| 例子|| ||+|| 加|| 两个对象相加|| 3 + 5得到8。'a' + 'b'得到'ab'。|| ||-|| 减|| 得到负数或是一个数减去另一个数|| -5.2得到一个负数。50 - 24得到26。|| ||*|| 乘|| 两个数相乘或是返回一个被重复若干次的字符串|| 2 * 3得到6。'la' * 3得到'lalala'。|| ||**|| 幂|| 返回x的y次幂|| 3 ** 4得到81(即3 * 3 * 3 * 3)|| ||/|| 除|| x除以y|| 4/3得到1(整数的除法得到整数结果)。4.0/3或4/3.0得到1.3333333333333333|| ||//|| 取整除|| 返回商的整数部分|| 4 // 3.0得到1.0|| ||%|| 取模|| 返回除法的余数|| 8%3得到2。-25.5%2.25得到1.5|| ||<<|| 左移|| 把一个数的比特向左移一定数目(每个数在内存中都表示为比特或二进制数字,即0和1)|| 2 << 2得到8。——2按比特表示为10|| ||>>|| 右移|| 把一个数的比特向右移一定数目|| 11 >> 1得到5。——11按比特表示为1011,向右移动1比特后得到101,即十进制的5。|| ||&|| 按位与|| 数的按位与|| 5 & 3得到1。|| || | || 按位或|| 数的按位或|| 5 | 3得到7。|| || {{{^}}} || 按位异或|| 数的按位异或|| {{{5 ^ 3}}}得到6|| || ~ || 按位翻转|| x的按位翻转是-(x+1)|| ~5得到-6。|| || < || 小于|| 返回x是否小于y。所有比较运算符返回True表示真,返回False表示假。 || 5 < 3返回0(即False)而3 < 5返回1(即True)。比较可以被任意连接:3 < 5 < 7返回True。|| || > || 大于|| 返回x是否大于y|| 5 > 3返回True。如果两个操作数都是数字,它们首先被转换为一个共同的类型。否则,它总是返回False。|| ||<=|| 小于等于|| 返回x是否小于等于y|| x = 3; y = 6; x <= y返回True。|| ||>=|| 大于等于|| 返回x是否大于等于y|| x = 4; y = 3; x >= y返回True。|| ||==|| 等于|| 比较对象是否相等|| x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。|| ||!=|| 不等于|| 比较两个对象是否不相等|| {{{x = 2; y = 3; x != y}}}返回True。 || || not || 布尔“非” || 如果x为True,返回False。如果x为False,它返回True。|| x = True; not y返回False。|| || and || 布尔“与” || 如果x为False,x and y返回False,否则它返回y的计算值。|| x = False; y = True; x and y,由于x是False,返回False。在这里,Python不会计算y,因为它知道这个表达式的值肯定是False(因为x是False)。这个现象称为短路计算。|| || or || 布尔“或”|| 如果x是True,它返回True,否则它返回y的计算值。|| x = True; y = False; x or y返回True。短路计算在这里也适用。|| == 运算符优先级 == 如果你有一个如2 + 3 * 4那样的表达式,是先做加法呢,还是先做乘法?我们的中学数学告诉我们应当先做乘法——这意味着乘法运算符的优先级高于加法运算符。 下面这个表给出Python的运算符优先级,从最低的优先级(最松散地结合)到最高的优先级(最紧密地结合)。这意味着在一个表达式中,Python会首先计算表中较下面的运算符,然后在计算列在表上部的运算符。 下面这张表(与Python参考手册中的那个表一模一样)已经顾及了完整的需要。事实上,我建议你使用圆括号来分组运算符和操作数,以便能够明确地指出运算的先后顺序,使程序尽可能地易读。例如,2 + (3 * 4)显然比2 + 3 * 4清晰。与此同时,圆括号也应该正确使用,而不应该用得过滥(比如2 + (3 + 4))。 ||运算符|| 描述|| ||lambda|| Lambda表达式|| ||or|| 布尔“或”|| ||and|| 布尔“与”|| ||not x|| 布尔“非”|| ||in,not in|| 成员测试|| ||is,is not|| 同一性测试|| ||{{{<,<=,>,>=,!=,==}}} || 比较|| || | || 按位或|| || {{{^}}} || 按位异或|| || & || 按位与|| ||{{{<<,>>}}}|| 移位|| ||+,-|| 加法与减法|| ||*,/,% || 乘法、除法与取余|| ||+x,-x|| 正负号|| ||~x|| 按位翻转|| ||**|| 指数|| ||x.attribute|| 属性参考|| ||x[index]|| 下标|| ||x[index:index]|| 寻址段|| ||f(arguments...)|| 函数调用|| ||(experession,...)|| 绑定或元组显示|| ||[expression,...]|| 列表显示|| ||{key:datum,...}|| 字典显示|| ||'expression,...'|| 字符串转换|| 计算顺序 默认地,运算符优先级表决定了哪个运算符在别的运算符之前计算。然而,如果你想要改变它们的计算顺序,你得使用圆括号。例如,你想要在一个表达式中让加法在乘法之前计算,那么你就得写成类似(2 + 3) * 4的样子。 结合规律 运算符通常由左向右结合,即具有相同优先级的运算符按照从左向右的顺序计算。例如,2 + 3 + 4被计算成(2 + 3) + 4。一些如赋值运算符那样的运算符是由右向左结合的,即a = b = c被处理为a = (b = c)。 == 表达式 == |
== 表达式Expressions == |
行号 270: | 行号 159: |
# Filename: expression.py | |
行号 280: | 行号 168: |
$ python expression.py | |
行号 289: | 行号 176: |
= 更多数据结构 = 数据结构基本上就是——它们是可以处理一些 数据 的 结构 。或者说,它们是用来存储一组相关数据的。 在Python中有三种内建的高级数据结构——列表、元组和字典。我们将会学习如何使用它们,以及它们如何使编程变得简单。 == 列表Lists == list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目。假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了。只不过在你的购物表上,可能每样东西都独自占有一行,而在Python中,你在每个项目之间用逗号分割。 列表中的项目应该包括在方括号中,这样Python就知道你是在指明一个列表。一旦你创建了一个列表,你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是 可变的 数据类型,即这种类型是可以被改变的。 列表是使用对象和类的一个例子。当你使用变量i并给它赋值的时候,比如赋整数5,你可以认为你创建了一个类(类型)int的对象(实例)i。事实上,你可以看一下help(int)以更好地理解这一点。 类也有方法,即仅仅为类而定义地函数。仅仅在你有一个该类的对象的时候,你才可以使用这些功能。例如,Python为list类提供了append方法,这个方法让你在列表尾添加一个项目。例如mylist.append('an item')列表mylist中增加那个字符串。注意,使用点号来使用对象的方法。 一个类也有域,它是仅仅为类而定义的变量。仅仅在你有一个该类的对象的时候,你才可以使用这些变量/名称。类也通过点号使用,例如mylist.field。 {{{#!python #!/usr/bin/python # Filename: using_list.py # This is my shopping list shoplist = ['apple', 'mango', 'carrot', 'banana'] print 'I have', len(shoplist),'items to purchase.' print '\nI also have to buy rice.' shoplist.append('rice') print 'My shopping list is now', shoplist print 'I will sort my list now' shoplist.sort() print 'Sorted shopping list is', shoplist print 'The first item I will buy is', shoplist[0] olditem = shoplist[0] del shoplist[0] print 'I bought the', olditem print 'My shopping list is now', shoplist }}} 输出 {{{ $ python using_list.py I have 4 items to purchase. I also have to buy rice. My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice'] I will sort my list now Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice'] The first item I will buy is apple I bought the apple My shopping list is now ['banana', 'carrot', 'mango', 'rice'] }}} 变量shoplist是某人的购物列表。在shoplist中,我们只存储购买的东西的名字字符串,但是记住,你可以在列表中添加 任何种类的对象 包括数甚至其他列表。 接下来,我们使用append方法在列表中添加了一个项目,就如前面已经讨论过的一样。然后我们通过打印列表的内容来检验这个项目是否确实被添加进列表了。打印列表只需简单地把列表传递给print语句,我们可以得到一个整洁的输出。 再接下来,我们使用列表的sort方法来对列表排序。需要理解的是,这个方法影响列表本身,而不是返回一个修改后的列表——这与字符串工作的方法不同。这就是我们所说的列表是 可变的 而字符串是 不可变的 。 最后,但我们完成了在市场购买一样东西的时候,我们想要把它从列表中删除。我们使用del语句来完成这个工作。这里,我们指出我们想要删除列表中的哪个项目,而del语句为我们从列表中删除它。我们指明我们想要删除列表中的第一个元素,因此我们使用del shoplist[0](记住,Python从0开始计数)。 如果你想要知道列表对象定义的所有方法,可以通过help(list)获得完整的知识。 == 元组Tuples == 元组和列表十分类似,只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变。 {{{#!python #!/usr/bin/python # Filename: using_tuple.py zoo = ('wolf', 'elephant', 'penguin') print 'Number of animals in the zoo is', len(zoo) new_zoo = ('monkey', 'dolphin', zoo) print 'Number of animals in the new zoo is', len(new_zoo) print 'All animals in new zoo are', new_zoo print 'Animals brought from old zoo are', new_zoo[2] print 'Last animal brought from old zoo is', new_zoo[2][2] }}} 输出 {{{ $ python using_tuple.py Number of animals in the zoo is 3 Number of animals in the new zoo is 3 All animals in new zoo are ('monkey', 'dolphin', ('wolf', 'elephant', 'penguin')) Animals brought from old zoo are ('wolf', 'elephant', 'penguin') Last animal brought from old zoo is penguin }}} 变量zoo是一个元组,我们看到len函数可以用来获取元组的长度。这也表明元组也是一个序列。 由于老动物园关闭了,我们把动物转移到新动物园。因此,new_zoo元组包含了一些已经在那里的动物和从老动物园带过来的动物。回到话题,注意元组之内的元组不会失去它的身份。 我们可以通过一对方括号来指明某个项目的位置从而来访问元组中的项目,就像我们对列表的用法一样。这被称作 索引 运算符。我们使用new_zoo[2]来访问new_zoo中的第三个项目。我们使用new_zoo[2][2]来访问new_zoo元组的第三个项目的第三个项目。 含有0个或1个项目的元组。一个空的元组由一对空的圆括号组成,如myempty = ()。然而,含有单个元素的元组就不那么简单了。你必须在第一个(唯一一个)项目后跟一个逗号,这样Python才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目2的元组的时候,你应该指明singleton = (2 , )。 == 元组与字符串替换 == 元组最通常的用法是用在字符串替换中,下面是一个例子: {{{ #!/usr/bin/python # Filename: print_tuple.py age = 22 name = 'Swaroop' print '%s is %d years old' % (name, age) print 'Why is %s playing with that python?' % name }}} 输出 {{{ $ python print_tuple.py Swaroop is 22 years old Why is Swaroop playing with that python? }}} print语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种特定的格式。定制可以是%s表示字符串或%d表示整数。元组必须按照相同的顺序来对应这些定制。 观察我们使用的第一个元组,我们首先使用%s,这对应变量name,它是元组中的第一个项目。而第二个定制是%d,它对应元组的第二个项目age。 Python在这里所做的是把元组中的每个项目转换成字符串并且用字符串的值替换定制的位置。因此%s被替换为变量name的值,依此类推。 print的这个用法使得编写输出变得极其简单,它避免了许多字符串操作。它也避免了我们一直以来使用的逗号。 在大多数时候,你可以只使用%s定制,而让Python来提你处理剩余的事情。这种方法对数同样奏效。然而,你可能希望使用正确的定制,从而可以避免多一层的检验程序是否正确。 在第二个print语句中,我们使用了一个定制,后面跟着%符号后的单个项目——没有圆括号。这只在字符串中只有一个定制的时候有效。 == 字典Dictionaries == 字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿,即,我们把键(名字)和值(详细情况)联系在一起。注意,键必须是唯一的,就像如果有两个人恰巧同名的话,你无法找到正确的信息。 注意,你只能使用不可变的对象(比如字符串)来作为字典的键,但是你可以把不可变或可变的对象作为字典的值。基本说来就是,你应该只使用简单的对象作为键。 键值对在字典中以这样的方式标记:d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割,而各个对用逗号分割,所有这些都包括在花括号中。 记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序,那么你应该在使用前自己对它们排序。 字典是dict类的实例/对象。 {{{#!python #!/usr/bin/python # Filename: using_dict.py # 'ab' is short for 'a'ddress'b'ook ab = { 'Swaroop' : 'swaroopch@byteofpython.info', 'Larry' : 'larry@wall.org', 'Matsumoto' : 'matz@ruby-lang.org', 'Spammer' : 'spammer@hotmail.com' } print "Swaroop's address is %s" % ab['Swaroop'] # Adding a key/value pair ab['Guido'] = 'guido@python.org' # Deleting a key/value pair del ab['Spammer'] print '\nThere are %d contacts in the address-book\n' % len(ab) for name, address in ab.items(): print 'Contact %s at %s' % (name, address) if 'Guido' in ab: # OR ab.has_key('Guido') print "\nGuido's address is %s" % ab['Guido'] }}} 输出 {{{ $ python using_dict.py Swaroop's address is swaroopch@byteofpython.info There are 4 contacts in the address-book Contact Swaroop at swaroopch@byteofpython.info Contact Matsumoto at matz@ruby-lang.org Contact Larry at larry@wall.org Contact Guido at guido@python.org Guido's address is guido@python.org }}} 我们使用已经介绍过的标记创建了字典ab。然后我们使用在列表和元组章节中已经讨论过的索引操作符来指定键,从而使用键/值对。我们可以看到字典的语法同样十分简单。 我们可以使用索引操作符来寻址一个键并为它赋值,这样就增加了一个新的键/值对,就像在上面的例子中我们对Guido所做的一样。 我们可以使用我们的老朋友——del语句来删除键/值对。我们只需要指明字典和用索引操作符指明要删除的键,然后把它们传递给del语句就可以了。执行这个操作的时候,我们无需知道那个键所对应的值。 接下来,我们使用字典的items方法,来使用字典中的每个键/值对。这会返回一个元组的列表,其中每个元组都包含一对项目——键与对应的值。我们抓取这个对,然后分别赋给for..in循环中的变量name和address然后在for-块中打印这些值。 我们可以使用in操作符来检验一个键/值对是否存在,或者使用dict类的has_key方法。你可以使用help(dict)来查看dict类的完整方法列表。 关键字参数与字典。如果换一个角度看待你在函数中使用的关键字参数的话,你已经使用了字典了!只需想一下——你在函数定义的参数列表中使用的键/值对。当你在函数中使用变量的时候,它只不过是使用一个字典的键(这在编译器设计的术语中被称作 符号表 )。 == 序列 == 列表、元组和字符串都是序列,但是序列是什么,它们为什么如此特别呢?序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片,即一部分序列。 {{{ #!/usr/bin/python # Filename: seq.py shoplist = ['apple', 'mango', 'carrot', 'banana'] # Indexing or 'Subscription' operation print 'Item 0 is', shoplist[0] print 'Item 1 is', shoplist[1] print 'Item 2 is', shoplist[2] print 'Item 3 is', shoplist[3] print 'Item -1 is', shoplist[-1] print 'Item -2 is', shoplist[-2] # Slicing on a list print 'Item 1 to 3 is', shoplist[1:3] print 'Item 2 to end is', shoplist[2:] print 'Item 1 to -1 is', shoplist[1:-1] print 'Item start to end is', shoplist[:] # Slicing on a string name = 'swaroop' print 'characters 1 to 3 is', name[1:3] print 'characters 2 to end is', name[2:] print 'characters 1 to -1 is', name[1:-1] print 'characters start to end is', name[:] }}} 输出 {{{ $ python seq.py Item 0 is apple Item 1 is mango Item 2 is carrot Item 3 is banana Item -1 is banana Item -2 is carrot Item 1 to 3 is ['mango', 'carrot'] Item 2 to end is ['carrot', 'banana'] Item 1 to -1 is ['mango', 'carrot'] Item start to end is ['apple', 'mango', 'carrot', 'banana'] characters 1 to 3 is wa characters 2 to end is aroop characters 1 to -1 is waroo characters start to end is swaroop }}} 首先,我们来学习如何使用索引来取得序列中的单个项目。这也被称作是下标操作。每当你用方括号中的一个数来指定一个序列的时候,Python会为你抓取序列中对应位置的项目。记住,Python从0开始计数。因此,shoplist[0]抓取第一个项目,shoplist[3]抓取shoplist序列中的第四个元素。 索引同样可以是负数,在那样的情况下,位置是从序列尾开始计算的。因此,shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目。 切片操作符是序列名后跟一个方括号,方括号中有一对可选的数字,并用冒号分割。注意这与你使用的索引操作符十分相似。记住数是可选的,而冒号是必须的。 切片操作符中的第一个数(冒号之前)表示切片开始的位置,第二个数(冒号之后)表示切片到哪里结束。如果不指定第一个数,Python就从序列首开始。如果没有指定第二个数,则Python会停止在序列尾。注意,返回的序列从开始位置 开始 ,刚好在 结束 位置之前结束。即开始位置是包含在序列切片中的,而结束位置被排斥在切片外。 这样,shoplist[1:3]返回从位置1开始,包括位置2,但是停止在位置3的一个序列切片,因此返回一个含有两个项目的切片。类似地,shoplist[:]返回整个序列的拷贝。 你可以用负数做切片。负数用在从序列尾开始计算的位置。例如,shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。 使用Python解释器交互地尝试不同切片指定组合,即在提示符下你能够马上看到结果。序列的神奇之处在于你可以用相同的方法访问元组、列表和字符串。 == 引用 == 当你创建一个对象并给它赋一个变量的时候,这个变量仅仅 引用 那个对象,而不是表示这个对象本身!也就是说,变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。 一般说来,你不需要担心这个,只是在引用上有些细微的效果需要你注意。这会通过下面这个例子加以说明。 {{{ #!/usr/bin/python # Filename: reference.py print 'Simple Assignment' shoplist = ['apple', 'mango', 'carrot', 'banana'] mylist = shoplist # mylist is just another name pointing to the same object! del shoplist[0] print 'shoplist is', shoplist print 'mylist is', mylist # notice that both shoplist and mylist both print the same list without # the 'apple' confirming that they point to the same object print 'Copy by making a full slice' mylist = shoplist[:] # make a copy by doing a full slice del mylist[0] # remove first item print 'shoplist is', shoplist print 'mylist is', mylist # notice that now the two lists are different }}} 输出 {{{ $ python reference.py Simple Assignment shoplist is ['mango', 'carrot', 'banana'] mylist is ['mango', 'carrot', 'banana'] Copy by making a full slice shoplist is ['mango', 'carrot', 'banana'] mylist is ['carrot', 'banana'] }}} 大多数解释已经在程序的注释中了。你需要记住的只是如果你想要复制一个列表或者类似的序列或者其他复杂的对象(不是如整数那样的简单 对象 ),那么你必须使用切片操作符来取得拷贝。如果你只是想要使用另一个变量名,两个名称都 引用 同一个对象,那么如果你不小心的话,可能会引来各种麻烦。 == 字符串 == 我们已经在前面详细讨论了字符串。我们还需要知道什么呢?那么,你是否知道字符串也是对象,同样具有方法。这些方法可以完成包括检验一部分字符串和去除空格在内的各种工作。 你在程序中使用的字符串都是str类的对象。这个类的一些有用的方法会在下面这个例子中说明。如果要了解这些方法的完整列表,请参见help(str)。 {{{ #!/usr/bin/python # Filename: str_methods.py name = 'Swaroop' # This is a string object if name.startswith('Swa'): print 'Yes, the string starts with "Swa"' if 'a' in name: print 'Yes, it contains the string "a"' if name.find('war') != -1: print 'Yes, it contains the string "war"' delimiter = '_*_' mylist = ['Brazil', 'Russia', 'India', 'China'] print delimiter.join(mylist) }}} 输出 {{{ $ python str_methods.py Yes, the string starts with "Swa" Yes, it contains the string "a" Yes, it contains the string "war" Brazil_*_Russia_*_India_*_China }}} 这里,我们看到使用了许多字符串方法。startwith方法是用来测试字符串是否以给定字符串开始。in操作符用来检验一个给定字符串是否为另一个字符串的一部分。 find方法用来找出给定字符串在另一个字符串中的位置,或者返回-1以表示找不到子字符串。str类也有以一个作为分隔符的字符串join序列的项目的整洁的方法,它返回一个生成的大字符串。 == 文件Files == 你可以通过创建一个file类的对象来打开一个文件,分别使用file类的read、readline或write方法来恰当地读写文件。对文件的读写能力依赖于你在打开文件时指定的模式。最后,当你完成对文件的操作的时候,你调用close方法来告诉Python我们完成了对文件的使用。 {{{ #!/usr/bin/python # Filename: using_file.py poem = '''\ Programming is fun When the work is done if you wanna make your work also fun: use Python! ''' f = file('poem.txt', 'w') # open for 'w'riting f.write(poem) # write text to file f.close() # close the file f = file('poem.txt') # if no mode is specified, 'r'ead mode is assumed by default while True: line = f.readline() if len(line) == 0: # Zero length indicates EOF break print line, # Notice comma to avoid automatic newline added by Python f.close() # close the file }}} 输出 {{{ $ python using_file.py Programming is fun When the work is done if you wanna make your work also fun: use Python! }}} 首先,我们通过指明我们希望打开的文件和模式来创建一个file类的实例。模式可以为读模式('r')、写模式('w')或追加模式('a')。事实上还有多得多的模式可以使用,你可以使用help(file)来了解它们的详情。 我们首先用写模式打开文件,然后使用file类的write方法来写文件,最后我们用close关闭这个文件。 接下来,我们再一次打开同一个文件来读文件。如果我们没有指定模式,读模式会作为默认的模式。在一个循环中,我们使用readline方法读文件的每一行。这个方法返回包括行末换行符的一个完整行。所以,当一个 空的 字符串被返回的时候,即表示文件末已经到达了,于是我们停止循环。 注意,因为从文件读到的内容已经以换行符结尾,所以我们在print语句上使用逗号来消除自动换行。最后,我们用close关闭这个文件。 现在,来看一下poem.txt文件的内容来验证程序确实工作正常了。 |
= end = |
目录
基本概念
1. 字面常量Literal Constants
一个字面意义上的常量的例子是如同5、1.23、9.25e-3这样的数,或者如同'This is a string'、"It's a string!"这样的字符串。它们被称作字面意义上的,因为它们具备 字面 的意义——你按照它们的字面意义使用它们的值。数2总是代表它自己,而不会是别的什么东西——它是一个常量,因为不能改变它的值。因此,所有这些都被称为字面意义上的常量。
2. 数值Numbers
在Python中有4种类型的数——整数、长整数、浮点数和复数。
- 2是一个整数的例子。
- 长整数不过是大一些的整数。比如123456789987654321
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里,52.3E-4表示52.3 * 10-4。
- (-5+4j)和(2.3-4.6j)是复数的例子。
3. 字符串Strings
字符串是 字符的序列 。字符串基本上就是一组单词。我几乎可以保证你在每个Python程序中都要用到字符串。使用单引号(') 你可以用单引号指示字符串,就如同'Quote me on this'这样。所有的空白,即空格和制表符都照原样保留。使用双引号(") 在双引号中的字符串与单引号中的字符串的使用完全相同,例如"What's your name?"。
4. 变量Variants
仅仅使用字面意义上的常量很快就会引发烦恼——我们需要一种既可以储存信息 又可以对它们进行操作的方法。这是为什么要引入 变量 。变量就是我们想要的东西——它们的值可以变化,即你可以使用变量存储任何东西。变量只是你的计算机中存储信息的一部分内存。与字面意义上的常量不同,你需要一些能够访问这些变量的方法,因此你给变量名字。
5. 标识符的命名
变量是标识符的例子。 标识符 是用来标识 某样东西 的名字。在命名标识符的时候,你要遵循这些规则:
- 标识符的第一个字符必须是字母表中的字母(大写或小写)或者一个下划线(‘ _ ’)。
- 标识符名称的其他部分可以由字母(大写或小写)、下划线(‘ _ ’)或数字(0-9)组成。
- 标识符名称是对大小写敏感的。例如,myname和myName不是一个标识符。注意前者中的小写n和后者中的大写N。
有效 标识符名称的例子有i、__my_name、name_23和a1b2_c3。
- 无效 标识符名称的例子有2things、this is spaced out和my-name。
6. 数据类型
变量可以处理不同类型的值,称为数据类型。基本的类型是数和字符串,我们已经讨论过它们了。在后面的章节里面,我们会研究怎么用类创造我们自己的类型。
使用内置函数type可以获取常量或者变量的类型,比如type(123.456)。
7. 对象Objects
记住,Python把在程序中用到的任何东西都称为 对象 。这是从广义上说的。因此我们不会说“某某 东西 ”,我们说“某个 对象 ”。
给面向对象编程用户的注释 就每一个东西包括数、字符串甚至函数都是对象这一点来说,Python是极其完全地面向对象的。
我们将看一下如何使用变量和字面意义上的常量。
输出
5 6 This is a multi-line string. This is the second line.
下面来说明一下这个程序如何工作。首先我们使用赋值运算符(=)把一个字面意义上的常数5赋给变量i。这一行称为一个语句。语句声明需要做某件事情,在这个地方我们把变量名i与值5连接在一起。接下来,我们用print语句打印i的值,就是把变量的值打印在屏幕上。
然后我们对i中存储的值加1,再把它存回i。我们打印它时,得到期望的值6。
类似地,我们把一个字面意义上的字符串赋给变量s然后打印它。
给C/C++程序员的注释 使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。
8. 语句与行
默认地,Python希望每行都只使用一个语句,这样使得代码更加易读。
如果你想要在一行中使用多于一个语句,那么你需要使用分号(;)来特别地标明这种用法。分号表示一个语句的结束。例如:
i = 5 print i
与下面这个相同:
i = 5; print i;
同样也可以写成:
i = 5; print i;
甚至可以写成:
i = 5; print i
然而,我强烈建议你坚持每行只写一个语句。仅仅当一个语句太长的时候,在多于一行中写一个语句。这些都是为了尽可能避免使用分号,从而让代码更加易读。事实上,我 从来没有 在Python程序中使用过或看到过分号。
下面是一个在多行中写一个语句的例子。它被称为明确的行连接。
s = 'This is a string. \ This continues the string.' print s
它的输出:
This is a string. This continues the string.
类似地,
print \ i
与如下写法效果相同:
print i
有时候,有一种暗示的假设,可以使你不需要使用反斜杠。这种情况出现在语句中使用了圆括号、方括号或波形括号的时候。这被称为暗示的行连接。
9. 缩进
空白在Python中是重要的。事实上行首的空白是重要的。它称为缩进。在逻辑行首的空白(空格和制表符)用来决定逻辑行的缩进层次,从而用来决定语句的分组。
这意味着同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。我们将在后面的章节中看到有关块的用处的例子。
你需要记住的一样东西是错误的缩进会引发错误。例如:
i = 5 print 'Value is', i # Error! Notice a single space at the start of the line print 'I repeat, the value is', i
当你运行这个程序的时候,你会得到下面的错误:
File "whitespace.py", line 4 print 'Value is', i # Error! Notice a single space at the start of the line ^ SyntaxError: invalid syntax
注意,在第二行的行首有一个空格。Python指示的这个错误告诉我们程序的语法是无效的,即程序没有正确地编写。它告诉你, 你不能随意地开始新的语句块 (当然除了你一直在使用的主块)。何时你能够使用新块,将会在后面的章节,如控制流中详细介绍。
如何缩进:不要混合使用制表符和空格来缩进,因为这在跨越不同的平台的时候,无法正常工作。我 强烈建议 你在每个缩进层次使用四个空格 。
10. 运算符Operators
你编写的大多数语句(逻辑行)都包含表达式。一个简单的表达式例子如2 + 3。一个表达式可以分解为运算符和操作数。
运算符 的功能是完成某件事,它们由如+这样的符号或者其他特定的关键字表示。运算符需要数据来进行运算,这样的数据被称为 操作数 。在这个例子中,2和3是操作数。
11. 表达式Expressions
length = 5 breadth = 2 area = length * breadth print 'Area is', area print 'Perimeter is', 2 * (length + breadth)
输出
Area is 10 Perimeter is 14
矩形的长度与宽度存储在以它们命名的变量中。我们借助表达式使用它们计算矩形的面积和边长。我们表达式length * breadth的结果存储在变量area中,然后用print语句打印。在另一个打印语句中,我们直接使用表达式2 * (length + breadth)的值。
另外,注意Python如何打印“漂亮的”输出。尽管我们没有在'Area is'和变量area之间指定空格,Python自动在那里放了一个空格,这样我们就可以得到一个清晰漂亮的输出,而程序也变得更加易读(因为我们不需要担心输出之间的空格问题)。这是Python如何使程序员的生活变得更加轻松的一个例子。