第六章 python 列表（List）

第六章 python 列表（List）

相信阅读至此章节，读者已经对 python 有一些基础了解了，这章笔者也将讲解简单的面向对象（Object Oriented）观念，同时指导读者学习利用 python 所提供的内置资源，未来将一步一步带领读者迈向高手之路。

6-1 认识列表（list）

• 其实在其他程序语言，相类似的功能是称数组（array），不过，python 的列表功能除了可以存储相同数据类型，例如，整数、浮点数、字符串，也可以存储不同数据类型，例如，列表内同时含有整数、浮点数和字符串。甚至一个列表也可以内含其它列表（将在 6-7 节解说）或是字典（dict）（将在 9-3 节解说），因此，python 可以工作的能力，将此其他程序语言强大。

6-1-1 列表的基本定义

• 定义列表的语法格式如下：

• name_list = [ 元素1 , … , 元素n ] # name_list 是假设的列表名称

• 基本上列表的每一个数据称元素，这此元素放在中括号 [ ] 内，彼此用逗号 " , " 隔开，如果要打印列表内容，可以使用 print() 函数，将列表名称当作变量名称即可。、

  • 实例1：NBA 环员 James 前 5 场比赛得分，分别是 23、19、22、31、18，可以用下列方式定义列表

    james = [23,19,22,31,18]
    print("打印 james 列表",james)
    
    #输出结果
    打印 james 列表 [23, 19, 22, 31, 18]
    
    James = ["Lebron James",23,19,22,31,18]
    print("打印 James 列表",James)
    
    #输出结果
    打印 James 列表 ['Lebron James', 23, 19, 22, 31, 18]
    

6-1-2 python 简单的面向对象观念

• 我们可以用列表名称与索引读取列表元素的内容，在 python 中元素是从索引值 0 开始配置，所以如果是列表的第一个元素，索引值是 0，第二个元素索引值是 1，其他依此类推，如果所示

  james = [23,19,22,31,18]
  print("打印 james 的第 1 场得分",james[0])
  print("打印 james 的第 2 场得分",james[1])
  print("打印 james 的第 3 场得分",james[2])
  print("打印 james 的第 4 场得分",james[3])
  print("打印 james 的第 5 场得分",james[4])
  
  #输出结果
  打印 james 的第 1 场得分 23
  打印 james 的第 2 场得分 19
  打印 james 的第 3 场得分 22
  打印 james 的第 4 场得分 31
  打印 james 的第 5 场得分 18
  

• 上述程序经过第 2 行的定义后，列表索引值的解释如下：

• 例：一个传统处理列表元素内容方式，与 python 多重指定观念的应用。

james = [23,19,22,31,18]
game1 = james[0]
game2 = james[1]
game3 = james[2]
game4 = james[3]
game5 = james[4]
print("打印 james 条场次得分",game1,game2,game3,game4,game5)

# python 高手好的设计方式
game1,game2,game3,game4,game5 = james
print("打印 james 各场次得分",game1,game2,game3,game4,game4)

#输出结果
打印 james 条场次得分 23 19 22 31 18
打印 james 各场次得分 23 19 22 31 31

上述 python 第 10 行让整个 python 设计简洁许多，这是 python 高手常用的程序设计方式，在上述设计中第 10 行的多重指定变数的数量需与列表元素的个数相同，否则会产生错误

6-1-3 列表切片（list slices）

• 在设计程序时，常会需要取得列表前几个元素，后几个元素，某区间元素或是依照一定规则排序的元素，所取得的系列元素也可以称子列表，这个观念称列表切片（list slices），此时可以用下列方法。

  • name_list[ start:end ] ：读取从索引 atart 到 （end - 1）索引的列表元素
  • name_list[ :n ]：取得列表前 n 名
  • name_list[ n: ]：取得列表索引 n 到最后
  • name_list[ -n ]：取得列表后 n 名
  • name[ : ]：取得所有元素

• 下列是读取区间，但是用 step 作为每隔多少区间再读取

  • name_list [ start : \end : step ]

• 例：列出特定区间球员的得分子列表

  james = [23,19,22,31,18]
  print("打印 james 第 1-3 场得分",james[0:3])
  print("打印 james 第 2-4 场得分",james[1:4])
  print("打印 james 第 1,3,5 场得分",james[0:6:2])
  
  #输出结果
  打印 james 第 1-3 场得分 [23, 19, 22]
  打印 james 第 2-4 场得分 [19, 22, 31]
  打印 james 第 1,3,5 场得分 [23, 22, 18]
  

• 例：列出球队前 3 名队员，从索引 1 到最后队员与后 3 名队员子列表

  warriors = ['Curry','Iquodala','Bell','Thompson']
  first3 = warriors[:3]
  print("前 3 名球员",first3)
  n_to_last = warriors[1:]
  print("球员索引 1 到最后",n_to_last)
  last3 = warriors[-3:]
  print("后3名球员",last3)
  
  #输出结果
  前 3 名球员 ['Curry', 'Iquodala', 'Bell']
  球员索引 1 到最后 ['Iquodala', 'Bell', 'Thompson']
  后3名球员 ['Iquodala', 'Bell', 'Thompson']
  

6-1-4 列表索引值 是 -1

• 在列表使用中，如果索引值是 -1，代表是最后一个列表元素。
• 例：列表索引值是 -1 的应用，由下列执行结果可以得到各列表的最后一个元素了。

warriors = ['Curry','Iquodala','Bell','Thompson']
print("最后一名球员",warriors[-1])
james = [23,19,22,31,18]
print("最后一场得分",james[1])
mixs = [9,20,5,"DeepStone"]
print("最后一个元素",mixs[-1])

#输出结果
最后一名球员 Thompson
最后一场得分 19
最后一个元素 DeepStone

• 其实在 python 中索引 -1 代表最后一个元素，-2 代表最后第 2 个元素，其他负索引观念可以依次类推，可参考下列实例：

  warriors = ['Curry','Durant','Iquodala','Bell','Thompson']
  print(warriors[-1],warriors[-2],warriors[-3],warriors[-4],warriors[-5])
  
  #输出结果
  Thompson Bell Iquodala Durant Curry
  

6-2-5 列表统计资料、最大值 max()、最小值 min()、总和 sum()

• python 有内置一些执行统计运算的函数，如果列表内容全部是数值则可以使用 max() 函数获得列表的最大值，min() 函数可以获得列表的最小值，sum() 函数可以获得列表的总和。如果列表内容全部是字符或字符串则可以使用 max() 函数获得列表的 unicode 码值的最大值，min() 函数可以获得列表的 unicode 码值最小值。sum() 则不可使用在列表元素为非数值情况。

• 例：计算 james 球员 5 场的最高得分，最低得分和 5 场的得分总计

  james = [23,19,22,31,18]
  print("最高得分：",max(james))
  print("最低得分：",min(james))
  print("总分：",sum(james))
  
  #输出结果
  最高得分： 31
  最低得分： 18
  总分： 113
  

• 上述我们很快获得了统计信息，各位可能会想，当列表内含有字符串，上面的例子会发生错误

  james = ["Lebron James",23,19,22,31,18]
  print("最高得分：",max(james))
  
  #输出强果
  ---------------------------------------------------------------------------
  TypeError                                 Traceback (most recent call last)
  <ipython-input-9-3c64822a4ab2> in <module>
        1 james = ["Lebron James",23,19,22,31,18]
  ----> 2 print("最高得分：",max(james))
  
  TypeError: '>' not supported between instances of 'int' and 'str'
  #译：'int'和'str'实例之间不支持
  

• 碰上这类的字符串我们可以使用切片方式处理

  james = ["Lebron James",23,19,22,31,18]
  print("最高得分：",max(james[1:5]))
  print("最低得分：",min(james[1:5]))
  print("总分：",sum(james[1:10]))
  
  #输出结果
  最高得分： 31
  最低得分： 19
  总分： 113
  

6-1-6 列表个数 len()

• 程序设计时，可能会增加元素，也有可能会删元素，时间久了即使是程序设计师也无法得知列表内剩余多少元素，此时可以借用本小节的 len() 函数，这个函数可以获得列表的元素个数。

  james = [23,19,22,31,18]
  games = len(james)
  print("经过 %d 轮比赛最高分数" % games,max(james))
  print("经过 %d 轮比赛最高分数" % games,min(james))
  print("经过 %d 轮比赛最高分数" % games,sum(james))
  
  #输出结果
  经过 5 轮比赛最高分数 31
  经过 5 轮比赛最高分数 18
  经过 5 轮比赛最高分数 113
  

6-1-7 更改列表元素的内容

• 可以使用列表名称和索引值更改列表元素的内容

• 例：修改 james 第 5 场比赛分数

  james = [23,19,22,31,18]
  print("旧的 james 比赛分数",james)
  james[4] = 28
  print("新的 james 比赛分数",james)
  
  #输出结果
  旧的 james 比赛分数 [23, 19, 22, 31, 18]
  新的 james 比赛分数 [23, 19, 22, 31, 28]
  

• 这个观念可以用在更改整数数据也可以修改字符串数据

• 例：一家汽车经销商原本可以销售 Toyota、Nissan、Honda，现在 Nissan 销售权被回收，改成销售 Ford，可用下列方式设计销售品牌

  cars = ['Toyota','Nissan','Honda']
  print("旧汽车销售品牌",cars)
  cars[1]='Ford'
  print("新汽车销售品牌",cars)
  
  #输出结果
  旧汽车销售品牌 ['Toyota', 'Nissan', 'Honda']
  新汽车销售品牌 ['Toyota', 'Ford', 'Honda']
  

6-1-8 列表相加

• python 是允许列表相加的，相当于将列表结合。

• 例：一家汽车经销商原本可以销售 Toyota、Nissan、Honda，现在开购一家销售 Audi、BMW 的经销商，可用下列方式设计销售品牌。

  cars1 = ['Toyota','Nissan','Honda']
  print("旧的汽车销售品牌",cars1)
  cars2 = ['Audi','BMW']
  cars1 += cars2
  print("新的汽车销售品牌",cars1)
  
  #输出结果
  旧的汽车销售品牌 ['Toyota', 'Nissan', 'Honda']
  新的汽车销售品牌 ['Toyota', 'Nissan', 'Honda', 'Audi', 'BMW']
  

• 例：整数列表相加实例

  num1 = [1,3,5]
  num2 = [2,4,6]
  num3 = num1 + num2
  print(num3)
  
  #输出结果
  [1, 3, 5, 2, 4, 6]
  

6-1-9 列表乘以一个数字

• 如果将列表乘以一个数字，这个数字相当于是列表元素重复次数

• 例：将列表乘以数字的应用

  cars = ['toyota','nissan','honda']
  nums = [1,3,5]
  carslist = cars * 3
  print(carslist)
  numslist = nums * 5
  print(numslist)
  
  #输出结果
  ['toyota', 'nissan', 'honda', 'toyota', 'nissan', 'honda', 'toyota', 'nissan', 'honda']
  [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]
  
  

6-1-10 列表元素的加法运作

• 既然我们可以读取列表内容，其实就可以使用相同的观念操作列表内的元素数据。

• 例：建立 Lebron James 和 Kevin Love 在比赛的得分列表，然后利用列表元素加法运作，列出 2 个人在第四场比赛的得分总和

  James = ['Lebron James',23,19,22,31,18]
  Love = ['Kevin Love',20,18,30,22,15]
  game3 = James[4] + Love[4]
  LKgame = James[0] + " 和 " + Love[0] + " 第四场总得分 = "
  print(LKgame,game3)
  
  #输出结果
  Lebron James 和 Kevin Love 第四场总得分 =  53
  

  需要注意，由第 2 行列表定义可知，James[0] 是指 ” Lebron James “，James[1] 是第 1 场得分 23，所以 James[4] 是第 2 场得分 31，第 3 行 Love 列表观念相同

6-1-11 删除列表元素

• 可以使用下列方式删除指定索引的列表元素：

  • del name_list [ i ] ：删除索引 i 的列表元素

• 下列是删列表区间元素

  • del name_list [ start : end ]：删除从索引 start 到 ( end -1 ) 索引的列表元素

• 下列是删除区间，便是用 step 作为每隔多少区间再删除

  • del name_list [ start : end : step ]：第隔 step，删除从索引 start 到 ( end - 1 ) 索引的列表元素

• 例：如果 NBA 勇士队主将阵容有 5 名，其中一名队员 Bell 离队了，可用下列方式设计

  warrlors = ['curry','Durant','Iquodala','Bell','Thompson']
  print("2018 年初 NBA 勇士队主将阵容 ",warrlors)
  del warrlors[3]
  print("2018 年末 NBA 勇士队主将阵容 ",warrlors)
  
  #输出结果
  2018 年初 NBA 勇士队主将阵容  ['curry', 'Durant', 'Iquodala', 'Bell', 'Thompson']
  2018 年末 NBA 勇士队主将阵容  ['curry', 'Durant', 'Iquodala', 'Thompson']
  

• 例：删除列表元素的应用

  nums1 = [1,3,5]
  print('nums1 列表删除前',nums1)
  del nums1[1]
  print('nums1 列表删除后',nums1)
  nums2 = [1,2,3,4,5,6]
  print("删除 nums2 列表索引 [ 0:2 ] 前",nums2)
  del nums2[0:2]
  print("删除 nums2 列表索引 [ 0:2 ] 后",nums2)
  nums3 = [1,2,3,4,5,6]
  print("删除 nums3 列表索引 [0:6:2] 前",nums3)
  del nums3[0:6:2]
  print("删除 nums3 列表索引 [0:6:2] 后",nums3)
  
  #输出结果
  nums1 列表删除前 [1, 3, 5]
  nums1 列表删除后 [1, 5]
  删除 nums2 列表索引 [ 0:2 ] 前 [1, 2, 3, 4, 5, 6]
  删除 nums2 列表索引 [ 0:2 ] 后 [3, 4, 5, 6]
  删除 nums3 列表索引 [0:6:2] 前 [1, 2, 3, 4, 5, 6]
  删除 nums3 列表索引 [0:6:2] 后 [2, 4, 6]
  

• 以这种方式删除列表元素最大的缺点是，元素删除后我们无法得知删除的是什么内容，有时我们设计网站时，可能想将某个人从 VIP 客户降为一般客户，采用上述方式删除元素时，我们就无法再度取得所删除的元素数据，未来笔者会介绍另一种方式删除数据，删除后我们还可利用所删除的数据。又或者你设计一个游戏，敌人是放在列表内，采用上述方式删除所杀死的敌人时，我们就无法再度取得所删除的敌人元素数据，如果我们可以取得的话，可以在杀死敌人坐标位置放置庆祝动画等。

6-1-12 如果想建立一个列表，可是暂时不放置元素，可使用下列方式定义

• name_list = [] ：这是空列表

• 例：删除列表元素的应用，这个程序基本上会用 len() 函数判断列表内是否有元素数据，如果有则删除索引为 0 的元素，如果没有则列出列表内没有元素了。

  cars = ['toyota','nissan','honda']
  print("cars 列表长度是 %d"% len(cars))
  if len(cars) != 0:
      del cars[0]
      print("成功删除 cars 元素")
      print("cars 列表长度是 %d"% len(cars))
  else:
      print("cars 内没有元素")
      
  nums = []
  print("nuns 列表长度是 %d"% len(nums))
  if  len(nums) != 0:
      del nums[0]
      print("成功删除 nums 元素")
  else:
      print("nums 内没有元素")
      
  #输出结果
  cars 列表长度是 3
  成功删除 cars 元素
  cars 列表长度是 2
  nuns 列表长度是 0
  nums 内没有元素
  

6-1-13 删除列表

• python 也允许我们删除整个列表，列表一经删除后就无法复原，同时也无法做任何操作了，下列是删除列表的方式

• del name_list：删除列表 name_list

• 例：建立列表、打印列表、删除列表，然后尝试再度打印列表结果出现错误信息，因为列表经删除后已经不存在了。

  x = [1,2,3]
  print(x)
  del x
  print(x)
  
  #输出结果
  [1, 2, 3]
  ---------------------------------------------------------------------------
  NameError                                 Traceback (most recent call last)
  <ipython-input-5-b8a8997c422e> in <module>
        2 print(x)
        3 del x
  ----> 4 print(x)
  
  NameError: name 'x' is not defined
  
  

6-2 python 简单的面向对象观念

• 在面向对象的程序设计（Object Oriented Programming）观念里，所有数据皆是一个对象（Object），例如，整数、浮点数、字符串或是本章所提的列表皆是一个对象。我们可以为所建阅兵对象设计一些方法（method），供这些对象使用，在这里所提的方法就是函数，其实方法与函数还是有一些差异，后面还会解说。目前 python 有为一些基本对象提供默认的方法，要使用这些方法可以在对象后先放小数点，再放方法名称，基本语法格式如下：
  • 对象 . 方法 ( )
  • 下列将分成几个小节一步一步以实例说明。

6-2-1 字符串的方法

• 几个字符串操作常用的方法如下：

  • lower()：将字符串转成小写字。
  • upper()：将字符串转成大写字。
  • title()：将字符串转成第一个字母大写，其他小写。
  • rstrip()：删除字符串尾端多余的空白。
  • lstrip()：删除字符串开始端多余的空白。
  • strip()：删除字符串头尾两边多余的空白。

• 例：将字符串改成小写，与将字符串改成大写，以及将字符串改成第一个字母大写，其他小写。

  strN = "DeepStone"
  strU = strN.upper()
  strL = strN.lower()
  strT = strN.title()
  print("大写输出：",strU,"\n小写输出：",strL,"\n第一个字母大写：",strT)
  
  #输出结果
  大写输出： DEEPSTONE 
  小写输出： deepstone 
  第一个字母大写： Deepstone
  

• 删除字符串开始或结尾多余空白是一个很好用的方法，特别是系统要求读者输入数据时，一定会有人不小心多输入了一些空格符，些时可以用这个方法删除多余的空白。

• 例：删除开始端与结尾端多余空白的应用

  strN = " DeepStone "
  strL = strN.lstrip()  #删除字符串左边多余空白
  strR = strN.rstrip()  #删除字符串右边多余空白
  strB = strN.lstrip()  #先删除字符串左边多余空白
  strB = strB.rstrip()  #再删除字符串右边多余空白
  strO = strN.strip()  #一次删除头尾端多余空白
  print("/%s/"%strN)
  print("/%s/"%strL)
  print("/%s/"%strR)
  print("/%s/"%strB)
  print("/%s/"%strO)
  
  #输出结果
  / DeepStone /
  /DeepStone /
  / DeepStone/
  /DeepStone/
  /DeepStone/
  

6-2-2 更改字符串大小写

• 如果列表内的元素数据是小写，例如，输出的车辆名称是 ” benz “，其实我们可以使用前一小节的 title() 让开头车辆名称的第一个字母大写，可能会更好。

• 例：将 upper() 和 title() 应用在字符串。

  cars = ["bmw","benz","audi"]
  carF = "我开的第一部车是" + cars[1].title()
  carN = "我现在开的车是" + cars[0].upper()
  print(carF)
  print(carN)
  
  #输出结果
  我开的第一部车是Benz
  我现在开的车是BMW
  

3-2-3 dir() 获得系统内部对象的方法

• dir() 函数可以列出对象有哪些内置的方法可以使用。

• 例：列出字符串对象的方法，处理方式是可以先设定一个字符变量，再列出此字符变量的方法。

  string = "abc"
  dir(string)
  
  #输出结果
  ['__add__',
   '__class__',
   '__contains__',
   '__delattr__',
   '__dir__',
   '__doc__',
   '__eq__',
  #...略...
  

• 看到上述密密麻麻的方法，不用紧张，也不用想要一次学会，需要时再学即可，如果想要了解上述特定方法可以使用前面所介绍的 help() 函数，可以用下列方式：

  • 例：延续前一个实例，列出对象 string，内置的 islower 的使用说明，同时以 string 对象为例，测试使用结果。

  help(string.islower)
  
  #输出结果
  Help on built-in function islower:
  
  islower() method of builtins.str instance
      Return True if the string is a lowercase string, False otherwise.
      
      A string is lowercase if all cased characters in the string are lowercase and
      there is at least one cased character in the string.
      
  #翻译结果
  内置功能帮助islower:
  内建函数的islower()方法。str实例
  如果字符串是小写字符串，返回True，否则返回False。
      
  如果字符串中的所有大小写字符都是小写和，则该字符串为小写
  字符串中至少有一个大小写字符。
  

• 由上述说明可知，islower() 可以传回对象是否是小写，如果对象全部是小写或至少有一个字符是小写将传回 True，否则传回 False。在上述实列，由于 string 对象的内容是 " abc "，全部是小写，所以传回 True

• 上述观念同样可以应用在查询整 数对象的方法

  • 例：例出整 数对象的方法，同样可以先设定一个整数变量，再列出此整数变量的方法。

  num = 5
  dir(num)
  

• 上述 dir(num) 输出结果里面的 bit_length 是可以计算出要多少位以 2 进位方式存储此变量。

  • 例：列出需要多少位，存储实例 3 的整 变量 num

  num = 5
  y = num.bit_length()
  print(y)
  
  #输出结果
  3
  

6-3 获得列表的方法

• 这节重点是列表，我们可以使用下列方式获得列表的方法。

  • 例1：例出内置列表 ( list ) 内字符串 ( string ) 元素的方法。

  string = ["bmw","benz","audi"]
  dir(string)
  

• 上述实例的重点是我们先建立一个列表 string，然后由此列表利用 dir() 函数可以了解有哪此列表的方法可以使用。

  • 例2：列出内置列表 ( list ) 内整数 ( int ) 的元素方法。

  numlist = [1,3,5]
  dir(numlist)
  

• 可以看到例 1 与例 2 内容完全相同，这表示下一节起讲解操作列表的方法，可以用在字符串元素，也可以用在整数元素

6-4 增加与删除列表元素

6-4-1 在列表末端增加元素 append()

• 程序设计时常常会发生需要增加列表元素的情况，如果目前元素个数是 3 个，想要增加第 4 个元素，读者可能会想可否使用下列传统方式，直接设定新增的值。

• name_list[ 3 ] = value

• 例：使用索引方式，为列表增加元素，但是发生索引值超过列表长度的错误

  car = ["Honda","Toyata","Ford"]
  print(car)
  car[3] = "Nissan"
  
  #输出结果
  ['Honda', 'Toyata', 'Ford']
  ---------------------------------------------------------------------------
  IndexError                                Traceback (most recent call last)
  <ipython-input-9-b4027e37285d> in <module>
        1 car = ["Honda","Toyata","Ford"]
        2 print(car)
  ----> 3 car[3] = "Nissan"
  
  IndexError: list assignment index out of range
  

• 读者可能会想可以增加一个新列表，将欲新增的元素放在新列表，然后再将原先列表与新列表相加，就达到增加列表元素的目的了，这个方法理论是可以，可是太麻烦了。python 为列表内置了新增元素的方法 append()，这个方法可以在列表末端直接增加元素

• name_list.append( ‘ 新增元素 ’ )

• 例：先建立一个空列表，然后分别使用 append() 增加 3 个元素内容

  cars = []
  print("目前列表的内容",cars)
  cars.append("Honda")
  print("目前列表的内容",cars)
  cars.append("Toyota")
  print("目前列表的内容",cars)
  cars.append("Ford")
  print("目前列表的内容",cars)
  
  #输出结果
  目前列表的内容 []
  目前列表的内容 ['Honda']
  目前列表的内容 ['Honda', 'Toyota']
  目前列表的内容 ['Honda', 'Toyota', 'Ford']
  

6-5 列表的排序

6-5-1 颠倒排序 reverse()

• reverse() 可以颠倒排序列表元素，它的使用方式如下：

• name_list.reverse()

• 其实用切片应用 [ : : -1] 方式取得列表颠倒排序。

• 例：使用 2 种方式执行颠倒排序列表元素

  cars = ["Honda","bmw","Toyota","Ford","bmw"]
  print("目前列表内容：",cars)
  print("使用 [::-1]颠例排序：",cars[::-1])
  print("使用 reverse() 颠倒排序")
  cars.reverse()
  print("新的列表内容：",cars)
  
  #输出结果
  目前列表内容： ['Honda', 'bmw', 'Toyota', 'Ford', 'bmw']
  使用 [::-1]颠例排序： ['bmw', 'Ford', 'Toyota', 'bmw', 'Honda']
  使用 reverse() 颠倒排序
  新的列表内容： ['bmw', 'Ford', 'Toyota', 'bmw', 'Honda']
  

6-5-2 sort() 排序

• sort() 方法可以对列表元素由小到大排序，这个方法同时对纯数值元素与纯英文字符串元素有非常好的效果，需要注意的是，经排序后原列表的元素顺序会被永久更改。它的使用格式如下：

• name_list.sort()

• 如果是排序英文字符串，建议先将字符串英文字符全部改成小写或大写。

• 例：数字与英文字符串元素排序的应用

  cars = ["honda","bmw","toyota","ford"]
  print("目前列表内容：",cars)
  print("使用 sort() 由小排到大")
  cars.sort()
  print("排序列表结果：",cars)
  nums = [5,3,9,2]
  print("目前列表内容：",nums)
  print("使用 sort() 由小排到大")
  nums.sort()
  print("排序列表结果：",nums)
  
  #输出结果
  目前列表内容： ['honda', 'bmw', 'toyota', 'ford']
  使用 sort() 由小排到大
  排序列表结果： ['bmw', 'ford', 'honda', 'toyota']
  目前列表内容： [5, 3, 9, 2]
  使用 sort() 由小排到大
  排序列表结果： [2, 3, 5, 9]
  

• 上述内容是由小排到大，sort() 方法是允许由大排到小，只要在 sort() 内增加参数 " reverse=True "即可

  cars = ["honda","bmw","toyota","ford"]
  print("目前列表内容：",cars)
  print("使用 sort(reverse=True) 由大排到小")
  cars.sort(reverse=True)
  print("排序列表结果：",cars)
  nums = [5,3,9,2]
  print("目前列表内容：",nums)
  print("使用 sort(reverse=True) 由大排到小")
  nums.sort(reverse=True)
  print("排序列表结果：",nums)
  
  #输出结果
  目前列表内容： ['honda', 'bmw', 'toyota', 'ford']
  使用 sort(reverse=True) 由大排到小
  排序列表结果： ['toyota', 'honda', 'ford', 'bmw']
  目前列表内容： [5, 3, 9, 2]
  使用 sort(reverse=True) 由大排到小
  排序列表结果： [9, 5, 3, 2]
  

6-5-3 sorted() 排序

• 前一小节的 sort() 排序将造成列表元素顺序永久更改，如果你不希望更改列表元素的顺序，可以使用另一种排序 sorted()，使用这个排序可以获得想要的排序结果，我们可以用新列表存储新的排序列表，同时原先列表的顺序不更改。它的使用如下：

• new_list.sorted( name_list )

• 例：这个程序使用 car_sorted() 新列表存储 car 列表的排序结果，同时使用 num_sorted 新列表存储 num 列表的排序结果

  cars = ["honda","bmw","toyota","ford"]
  print("目前 cars 列表的内容：",cars)
  print("使用 sorted() 由小排到大")
  cars_sorted = sorted(cars)
  print("排序串列结果",cars_sorted)
  print("原先串列 cars 内容：",cars)
  num = [5,3,9,2]
  print("目前 num 列表的内容：",num)
  print("使用 sorted() 由小排到大")
  num_sorted = sorted(num)
  print("排序串列结果",num_sorted)
  print("原先串列 num 内容：",num)
  
  #输出结果
  目前 cars 列表的内容： ['honda', 'bmw', 'toyota', 'ford']
  使用 sorted() 由小排到大
  排序串列结果 ['bmw', 'ford', 'honda', 'toyota']
  原先串列 cars 内容： ['honda', 'bmw', 'toyota', 'ford']
  目前 num 列表的内容： [5, 3, 9, 2]
  使用 sorted() 由小排到大
  排序串列结果 [2, 3, 5, 9]
  原先串列 num 内容： [5, 3, 9, 2]
  

• 如果我们想要从大排到小，可以在 sorted() 内增加参数 " reverse=True "，可参考下列实例

• 例：重新设计上面例子，将列表由大到小。

  cars = ["honda","bmw","toyota","ford"]
  print("目前 cars 列表的内容：",cars)
  print("使用 sorted(reverse=True) 由大排到小")
  cars_sorted = sorted(cars,reverse=True)
  print("排序串列结果",cars_sorted)
  print("原先串列 cars 内容：",cars)
  num = [5,3,9,2]
  print("目前 num 列表的内容：",num)
  print("使用 sorted(reverse()) 由大排到小")
  num_sorted = sorted(num,reverse=True)
  print("排序串列结果",num_sorted)
  print("原先串列 num 内容：",num)
  
  #输出结果
  目前 cars 列表的内容： ['honda', 'bmw', 'toyota', 'ford']
  使用 sorted(reverse=True) 由大排到小
  排序串列结果 ['toyota', 'honda', 'ford', 'bmw']
  原先串列 cars 内容： ['honda', 'bmw', 'toyota', 'ford']
  目前 num 列表的内容： [5, 3, 9, 2]
  使用 sorted(reverse()) 由大排到小
  排序串列结果 [9, 5, 3, 2]
  原先串列 num 内容： [5, 3, 9, 2]
  

6-6 进阶列表操作

6-6-1 index()

• 这个方法可以返回特定元素内容第一次出现的索引值，它的使用格式如下：

• 索引值 = 列表名称.index( 搜寻值 )

• 如果搜寻值不在列表会出现错误。

• 例：返回搜寻值的应用:

  cars = ["toyota","nissan","honda"]
  search_str="nissan"
  i = cars.index(search_str)
  print("所搜寻元素 %s 第一次出现位置索引是 %d" % (search_str,i))
  nums = [7,12,30,12,30,9,8]
  search_val = 30
  j = nums.index(search_val)
  print("所搜寻元素 %s 第一次出现位置索引是 %d" % (search_val,j))
  
  #输出结果
  所搜寻元素 nissan 第一次出现位置索引是 1
  所搜寻元素 30 第一次出现位置索引是 2
  

• 例用列表 James，这个列表有 Lebron James 一系列比赛得分，由此列表计算他在第几场得最高分，同时列出所得分数

  James = ["Lebron James",23,19,22,31,18]    #定义 James 列表
  games = len(James)                         #求元素数量
  score_Max = max(James[1:games])            #最高得分
  i = James.index(score_Max)                 #场次
  print(James[0],"在第 %d 场得最高分 %d" % (i,score_Max))
  
  #输出结果
  Lebron James 在第 4 场得最高分 31
  

• 这个实例有一点不完美，因为如果有2场或更多场次得到相同分数的最高分，本程序无法处理，下一章笔者将以实例讲解如何修订此缺点。

6-6-2 count()

• 这个方法可以返回特定元素的次数，它的使用格式如下：

• 次数 = 列表名称 . count ( 搜寻值 )

• 如果搜寻值不在列表会出现错误

• 例：返回搜寻值出现的次数。

  cars = ["toyota","nissan","honda"]
  search_str = 'nissan'
  num1 = cars.count(search_str)
  print("所搜寻元素 %s 出现 %d 次" % (search_str,num1))
  nums = [17,12,30,12,30,9,8]
  search_val = 30
  num2 = nums.count(search_val)
  print("所奸录元素 %d 出现 %d 次"%(search_val,num2))
  
  #输出结果
  所搜寻元素 nissan 出现 1 次
  所奸录元素 30 出现 2 次
  

6-6-3 列表元素的组合 join()

• 这个方法可以将列表的元素组成一个字符串，它的使用格式如下：

• char.join ( seq )： seq 表示参数必须是列表，元组等序列数据

• 至于 char 则是组合后各元素间的分隔字符，可以是单一字符，也可以是字符串。

• 例：列表元素组合的应用

  char = '-'
  lst = ['Silicon','Stone','Education']
  print(char.join(lst))
  car = "***"
  lst = ['Silicon','Stone','Education']
  print(car.join(lst))
  car = '\n'
  lst = ['Silicon','Stone','Education']
  print(car.join(lst))
  
  #输出结果
  Silicon-Stone-Education
  Silicon***Stone***Education
  Silicon
  Stone
  Education
  

6-7 列表内含列表

• 列表内含列表的基格式如下：

• num = [ 1 , 2 , 3 , 4 , 5 , [ 6 , 7 , 8 ] ]

• 对上述而言，num 是一个列表，在这个列表内有另一个列表 [ 6 , 7 , 8 ]，因为内为列表的索引值是 5，所以可以用 num [ 5 ]，获得这个元素列表的内容。

  num = [1,2,3,4,5,[6,7,8]]
  num[5]
  
  输出结果
  [6, 7, 8]
  

• 如果想要存取列表内的列表元素，可以使用下列格式

• num [ 索引 1 ] [ 索引 2 ]

• 索引 1 是元素列表原先索引位置，索引 2 是元素列表内部的索引。

• 例：列出列表内的列表元素值

  num = [1,2,3,4,5,[6,7,8]]
  print(num[5][0])
  print(num[5][1])
  print(num[5][2])
  
  #输出结果
  6
  7
  8
  

• 列表内含列表主要应用是，例如，可以用这个资料格式存储 NBA 球员 Lebron James 的数据如下所示：

• James = [ [ ‘Lebron James’ , ‘SF’ , ‘12/30/1984’ ] , 23 , 19 , 22 , 31 , 18 ]

• 其中第一个元素是列表，用于存储 Lebron James 个人资料，其他则是存储每场得分数据。

• 例：先列出 lebron Jame 个人资料，再计算哪一个场次得到最高分。

  James = [['Lebron James','SF','12/30/1984'],23,19,22,31,18]
  games = len(James)
  score_Max = max(James[1:games])
  i = James.index(score_Max)
  name = James[0][0]
  position = James[0][1]
  born = James[0][2]
  print("姓名    ：",name)
  print("位置    ：",position)
  print("出生日期：",born)
  print("在第 %d 场得最高分 %d" %(score_Max,i))
  
  #输出结果
  姓名    ： Lebron James
  位置    ： SF
  出生日期： 12/30/1984
  在第 31 场得最高分 4
  

6-7-1 再谈 append()

• 我们有提过可以使用 append() 方法，将元素插入列表的末端。其实也可以使用 append() 函数将某一列表插入另一列表的末端，方法与插入元素方式相同，这时就会产生列表中有列表的效果。它的使用格式如下：

• 列表 A . append ( 列表B )：列表 B 将接在列表 A 的末端

• 例：例用 append() 将列表插入另一列表的末端

  cars1 = ["toyota","nissan","honda"]
  cars2 = ['ford','audi']
  print("原先 cars1 列表内容：",cars1)
  print("原先 cars2 列表内容：",cars2)
  cars1.append(cars2)
  print("执行 append() 后列表 cars1 内容",cars1)
  print("执行 append() 后列表 cars2 内容",cars2)
  
  #输出结果
  原先 cars1 列表内容： ['toyota', 'nissan', 'honda']
  原先 cars2 列表内容： ['ford', 'audi']
  执行 append() 后列表 cars1 内容 ['toyota', 'nissan', 'honda', ['ford', 'audi']]
  执行 append() 后列表 cars2 内容 ['ford', 'audi']
  

6-7-2 extend()

• 这也是2个列表连接的方法，与 append() 类似，不过这个方法只是适用 2 个列表连接，不能用在一般元素。同时在连接后， extend() 会将列表分解成元素，一一插入列表。它的使用格式如下：

• 列表 A . extend( 列表 B )

• 例：使用 extend() 方法取代上面例子，并观察执行结果

  cars1 = ["toyota","nissan","honda"]
  cars2 = ['ford','audi']
  print("原先 cars1 列表内容：",cars1)
  print("原先 cars2 列表内容：",cars2)
  cars1.extend(cars2)
  print("执行 append() 后列表 cars1 内容",cars1)
  print("执行 append() 后列表 cars2 内容",cars2)
  
  #输出结果
  原先 cars1 列表内容： ['toyota', 'nissan', 'honda']
  原先 cars2 列表内容： ['ford', 'audi']
  执行 append() 后列表 cars1 内容 ['toyota', 'nissan', 'honda', 'ford', 'audi']
  执行 append() 后列表 cars2 内容 ['ford', 'audi']
  
  

6-8 列表的复制

6-8-1 列表的深复制 deep copy

• 假设我喜欢的运动是，篮球与棒球，可以用下列方式设定列表：

• mysports = [ ’ basketball ’ , ’ baseball ’ ]

• 如果我的朋友也喜欢这 2 种运动，读者可能会想用下列方式设定列表。

• friendsports = mysports

• 例：列出我和朋友所喜欢的运动。

  mysports = ['basketball','baseball']
  friendsports = mysports
  print("我喜欢的运动    ：",mysports)
  print("我朋友喜欢的运动：",friendsports)
  
  #输出结果
  我喜欢的运动    ： ['basketball', 'baseball']
  我朋友喜欢的运动： ['basketball', 'baseball']
  

• 初看上述执行结果好像没有任何问题，可是如果我想加入 football ( 美式足球 ) 当作喜欢的运动，我的朋友想加入 soccer ( 传统足球 ) 当作喜欢的运动，这时我喜欢的运动如下：

• basketball、baseball、football

• 我朋友喜欢的运动如下：

• basketball、baseball、soccer

• 例：继续使用上面例子，加入 football（美式足球）当作喜欠的运动，我的朋友想加入 soccer（传统足球）当作喜欢的运动，同时列出执行结果

  mysports = ['basketball','baseball']
  friendspots = mysports
  print("我喜欢的运动    ：",mysports)
  print("我朋友喜欢的运动：",friendsports)
  mysports.append('football')
  friendspots.append('soccer')
  print("我喜欢的运动    ：",mysports)
  print("我朋友喜欢的运动：",friendspots)
  
  #输出结果
  我喜欢的运动    ： ['basketball', 'baseball']
  我朋友喜欢的运动： ['basketball', 'baseball', 'soccer']
  我喜欢的运动    ： ['basketball', 'baseball', 'football', 'soccer']
  我朋友喜欢的运动： ['basketball', 'baseball', 'football', 'soccer']
  
  

• 这时获得的结果，不论是我还是我的朋友，喜欢的运动皆相同， football 和 soccer 皆是变成 2 人共同喜欢的运动。类似这种只要有一个列表更改元素会影响到另一个列表同步更改的复制称深复（deep copy）

6-8-2 地址的观念

• 使用 python 可以使用 id() 函数，获得变量的地址，可参考下列语法。

• id( x )

• 上述可以获得变量 x 的地址，对于列表而言，如果例用下列方式设定 2 个列表以后量相等，相当于只是将变量地址复制给另一个变量。

• friendsports = mysports

• 上述相当于是针 mysports 变量地址复制给 friendsports 。所以上面程序实例，在执行时，2个列表变量所指的地址相同，所以新增运动项目时，皆是将运动项目加在同一变量地址，可参考下列实例。

• 例：重新设计上面例子，增加列出列表变量的地址。

  mysports = ['basketball','baseball']
  friendspots = mysports
  print("我喜欢的运动    ：",mysports)
  print("我朋友喜欢的运动：",friendsports)
  mysports.append('football')
  friendspots.append('soccer')
  print("--新增运动项目后--")
  print("列出 mysports 地址    :",id(mysports))
  print("列出 friendspots 地址：",id(friendspots))
  print("我喜欢的最新运动    ：",mysports)
  print("我朋友喜欢的最新运动：",friendspots)
  
  #输出结果
  我喜欢的运动    ： ['basketball', 'baseball']
  我朋友喜欢的运动： ['basketball', 'baseball', 'soccer']
  --新增运动项目后--
  列出 mysports 地址    : 122943240
  列出 friendspots 地址： 122943240
  我喜欢的最新运动    ： ['basketball', 'baseball', 'football', 'soccer']
  我朋友喜欢的最新运动： ['basketball', 'baseball', 'football', 'soccer']
  

• 由上述执行的结果可以看到，使用程序第 3 行设定列表变量相等时，实际只是将列表地址复制给另一个列表变量。

6-8-3 列表的浅复制 shallow copy

• 浅复制观念是，执行复制后当一个列表改变后，不会影响另一个列表的内容，这是本小节的重点。方法应该如下：

• friendsports = mysports [ : ]

• 例：例用浅复制方式，重新设计上面例子，下列是与上面例子之间，唯一不同的程序代表

• friendsports = myports [ : ]

  mysports = ['basketball','baseball']
  friendspots = mysports[:]     #只有这里和上面例子不同
  print("我喜欢的运动    ：",mysports)
  print("我朋友喜欢的运动：",friendsports)
  mysports.append('football')
  friendspots.append('soccer')
  print("--新增运动项目后--")
  print("列出 mysports 地址    :",id(mysports))
  print("列出 friendspots 地址：",id(friendspots))
  print("我喜欢的最新运动    ：",mysports)
  print("我朋友喜欢的最新运动：",friendspots)
  
  #输出结果
  我喜欢的运动    ： ['basketball', 'baseball']
  我朋友喜欢的运动： ['basketball', 'baseball', 'soccer']
  --新增运动项目后--
  列出 mysports 地址    : 126085064
  列出 friendspots 地址： 122881096
  我喜欢的最新运动    ： ['basketball', 'baseball', 'football']
  我朋友喜欢的最新运动： ['basketball', 'baseball', 'soccer']
  

• 由上述执行结果可知，我们已经获得了 2 个列表彼此是不同的列表地址，同时也得到了想要的结果

6-9 再谈字符串

• 3-4 节笔者介绍了字符串（string）的观念，在 python 的应用中可以将单一字符串当作是一个序列，这个序列是由字符所组成，可想成字符序列，不过字符串与列表不同的是，字符串内的单一元素内容是不可更改的。

6-9-1 字符串的索引

• 可以使用索引的方式取得字符串内容，索引方式则与列表相同。

• 例：使用正值与负值的索引列出字符串元素内容。

  string = 'python'
  #正值索引
  print("string[0]=",string[0])
  print("string[1]=",string[1])
  print("string[2]=",string[2])
  print("string[3]=",string[3])
  print("string[4]=",string[4])
  print("string[5]=",string[5])
  #负值索引
  print("string[-6]=",string[-6])
  print("string[-5]=",string[-5])
  print("string[-4]=",string[-4])
  print("string[-3]=",string[-3])
  print("string[-2]=",string[-2])
  print("string[-1]=",string[-1])
  #多重指定观念
  s1,s2,s3,s4,s5,s6 = string
  print("多重指定观念的输出测试 = ",s1,s2,s3,s4,s5,s6)
  
  输出结果
  string[0]= p
  string[1]= y
  string[2]= t
  string[3]= h
  string[4]= o
  string[5]= n
  string[-6]= p
  string[-5]= y
  string[-4]= t
  string[-3]= h
  string[-2]= o
  string[-1]= n
  多重指定观念的输出测试 =  p y t h o n
  

6-2-9 字符串切片

• 6-1-3节列表切片的观念可以应用在字符串，下列将直接以实例说明

• 例：字符串切片的应用

  string = "Deep Learning"
  print("打印 string 第 1-3 元素:",string[0:3])
  print("打印 string 第 2-4 元素:",string[2:4])
  print("打印 string 第 2，4，6 元素:",string[1:6:2])
  print("打印 string 第 1 到最后元素:",string[1:])
  print("打印 string 前 3 元素:",string[0:3])
  print("打印 string 后 3 元素:",string[-3:])
  
  #输出结果
  打印 string 第 1-3 元素: Dee
  打印 string 第 2-4 元素: ep
  打印 string 第 2，4，6 元素: epL
  打印 string 第 1 到最后元素: eep Learning
  打印 string 前 3 元素: Dee
  打印 string 后 3 元素: ing
  

6-9-4 将字符串转成列表

• list() 函数可以将参数内的对象转成列表，下列是字符串转为列表的实例

  x = list("Deep Stone")
  print(x)
  
  #输出结果
  ['D', 'e', 'e', 'p', ' ', 'S', 't', 'o', 'n', 'e']
  

6-9-5 切片赋值的应用

• 字符串本身无法用切片方式更改内容，但是将字符串改为列表后，就可以使用切片更改列表内容了，下列是延续 6-9-4 节实例

  x = list("Deep Stone")
  x[5:] = 'Mind'
  print(x)
  
  #输出结果
  ['D', 'e', 'e', 'p', ' ', 'M', 'i', 'n', 'd']
  

6-9-6 使用 split() 处理字符串

• 这个方法可以将字符串以空格为分隔符，将字符串拆开，变成一个列表。变成列表后我们可以使用 len() 获得此列表的元素个数，这相当于可以计算字符串是由多少个英文字母组成，由于中文字之间没有空格，可以使用这个方法获得这一篇文章或这一本书的字数。

• 例：获得字符串内的字数

  str1 = "Silicon Stone Education"
  str2 = "DeepStone"
  str3 = "深石数位"
  sList1 = str1.split()
  sList2 = str2.split()
  sList3 = str3.split()
  print(str1," 列表内容是：",sList1)
  print(str1," 列表字数是：",len(sList1))
  print(str2," 列表内容是：",sList2)
  print(str2," 列表字数是：",len(sList2))
  print(str3," 列表内容是：",sList3)
  print(str3," 列表字数是：",len(sList3))
  
  #输出结果
  Silicon Stone Education  列表内容是： ['Silicon', 'Stone', 'Education']
  Silicon Stone Education  列表字数是： 3
  DeepStone  列表内容是： ['DeepStone']
  DeepStone  列表字数是： 1
  深石数位  列表内容是： ['深石数位']
  深石数位  列表字数是： 1
  

6-10 in 和 not in 表达式

• 主要是用于判断一个对象是否属于另一个对象，对象可以是字符串，列表，元组，字典。它的语法格式如下：

• boolean_value = obj1 in obj2：对象 obj1 在对象 obj2 内会传回 True

• boolean_value = obj1 not in obj2：对象 obj1 不在对象 obj2 内会传回 True

  password = "deepstone"
  ch = input("请输入字符：")
  print("in 表达式")
  if ch in password:
      print("输入字符在密码中")
  else:
      print("输入字符不在密码中")
      
  print("not in 表达式")
  if ch not in password:
      print("输入字符不在密码中")
  else:
      print("输入字符在密码中")
      
  #输出结果
  请输入字符：d
  in 表达式
  输入字符在密码中
  not in 表达式
  输入字符在密码中
  

• 其实这个功能一般更常见是用在侦测某个元素是否存在列表中，如果不存在，则将它加入列表内，可参考下列实例

• 例：这个程序基本上会要求输入一个水果，如果列表内目前没有这个水果，就将输入的水果加入列表内

  fruits = ['苹果','香蕉','梨子']
  fruit = input("请输入水果")
  if fruit in fruits:
      print("这个水果已经有了")
  else:
      fruits.append(fruit)
      print("已经加入水果清单：",fruits)
      
  #输出结果1
  请输入水果梨子
  这个水果已经有了
  
  #输出结果2
  请输入水果西瓜
  已经加入水果清单： ['苹果', '香蕉', '梨子', '西瓜']
  
  

6-11 is 或 is not 表达式

• 可以用于比较两个对象是否相同，在此所谓相同并不只是内容相同，而是指对象变量指向相同的内存，对象可以是变量、字符串、列表、元组、字典。它的语法格式如下：
• boolean_value = obj1 is obj2：对象 obj1 等于对象 obj2 会传回 True
• boolean_value = obj1 is not obj2：对象 obj1 不等于对象 obj2 会传回 True

6-11-1 整数变量在内存地址的观察

• 在 6-8-2 节已经讲解可以使 id() 函数获得列表变量地址，其实这个函数也可以获得整数（或浮点数）变量在内存中的地址，当我们在 python 程序中设立变量时，如果两个整数（或浮点数）变量内容相同，它们会使用相同的内存地址存储此变量。

• 例：整 数变量在内存地址的观察，这个程序比较特别的是，程序执行行初，变量 x 和 y 值是 10，所以可以看到经过 id() 函数后，彼此有相同的内存位置。变量 z 和 r 由于值与 x 和 y 不相同，所以有不同的内存地址，经过和 9 行运算后 r 的值变为 10，最后得到 x、y 和 r 不仅值相同，同时也指向相同的内存地址：

  x = 10
  y = 10
  z = 15
  r = 20
  print("x = %d，y = %d，z = %d，r = %d"%(x,y,z,r))
  print("x 地址 = %d，y 地址 = %d，z 地址 = %d，r 地址 = %d"%(id(x),id(y),id(z),id(r)))
  r = 10
  print("x = %d，y = %d，z = %d，r = %d"%(x,y,z,r))
  print("x 地址 = %d，y 地址 = %d，z 地址 = %d，r 地址 = %d"%(id(x),id(y),id(z),id(r)))
  
  #输出结果
  x = 10，y = 10，z = 15，r = 20
  x 地址 = 8791489880752，y 地址 = 8791489880752，z 地址 = 8791489880912，r 地址 = 8791489881072
  x = 10，y = 10，z = 15，r = 10
  x 地址 = 8791489880752，y 地址 = 8791489880752，z 地址 = 8791489880912，r 地址 = 8791489880752
  

• 当 r 变量值变为 10 时，它所指的内存地址与 x 和 y 变量相同了。

6-11-2 将 is 和 is not 表达式应用在列表变量

x = 10
y = 10
z = 15
r = z - 5

boolena_value = x is y
print("x 地址 = %d，y 地址 = %d" % (id(x),id(y)))
print("x = %d，y = %d" % (x,y),boolena_value )

boolena_value = x is z
print("x 地址 = %d，z 地址 = %d" % (id(x),id(z)))
print("x = %d，z = %d" % (x,z),boolena_value )

boolena_value = x is r
print("x 地址 = %d，y 地址 = %d" % (id(x),id(r)))
print("x = %d，r = %d" % (x,r),boolena_value )

boolena_value = x is not y
print("x 地址 = %d，y 地址 = %d" % (id(x),id(y)))
print("x = %d，y = %d" % (x,y),boolena_value )

boolena_value = x is not z
print("x 地址 = %d，z 地址 = %d" % (id(x),id(z)))
print("x = %d，z = %d" % (x,z),boolena_value )

boolena_value = x is not r
print("x 地址 = %d，y 地址 = %d" % (id(x),id(r)))
print("x = %d，r = %d" % (x,r),boolena_value )

#输出结果
x 地址 = 8791489880752，y 地址 = 8791489880752
x = 10，y = 10 True
x 地址 = 8791489880752，z 地址 = 8791489880912
x = 10，z = 15 False
x 地址 = 8791489880752，y 地址 = 8791489880752
x = 10，r = 10 True
x 地址 = 8791489880752，y 地址 = 8791489880752
x = 10，y = 10 False
x 地址 = 8791489880752，z 地址 = 8791489880912
x = 10，z = 15 True
x 地址 = 8791489880752，y 地址 = 8791489880752
x = 10，r = 10 False

6-11-3 将 is 和 is not 表达式应用在列表变量

• 这个范例所使用的 3 个列表内容均是相同，但是 mysports 和 sports1 所指地址相同所以会被视为相同对象，sports2 则指向不同地址所以会被视为不同对象，在使用 is 指令测试时，不同地址的列表会被视为不同的列表

  mysports = ['basketball','baseball']
  sports1 = mysports
  sports2 =mysports[:]
  print("我喜欢的运动：",mysports,"地址是：",id(mysports))
  print("运动1       ：",sports1,"地址是：",id(sports1))
  print("运动2       ：",sports2,"地址是：",id(sports2))
  
  boolean_value = mysports is sports1
  print("我喜欢的运动 is 运动 1 ：",boolean_value)
  
  boolean_value = mysports is sports2
  print("我喜欢的运动 is 运动 2 ：",boolean_value)
  
  boolean_value = mysports is not sports1
  print("我喜欢的运动 is 运动 1 ：",boolean_value)
  
  boolean_value = mysports is not sports2
  print("我喜欢的运动 is 运动 2 ：",boolean_value)
  
  #输出结果
  我喜欢的运动： ['basketball', 'baseball'] 地址是： 134128840
  运动1       ： ['basketball', 'baseball'] 地址是： 134128840
  运动2       ： ['basketball', 'baseball'] 地址是： 129103368
  我喜欢的运动 is 运动 1 ： True
  我喜欢的运动 is 运动 2 ： False
  我喜欢的运动 is 运动 1 ： False
  我喜欢的运动 is 运动 2 ： True
  

6-12 enumerate 对象

• enumerate() 方法可以将 iterable 类数值的元素用计数值与元素配对方式传回，返回的数据称 enumerate 对象。其中 iterable 类数值可以是列表、元组、集合、等。它的语法格式如下：

• obj = enumerate( iterable [ , start = 0 ] )：如果省略 start = 设定，默认值是 0

• 未来我们可以使用 list() 将 enumerate 对象转成列表，使用 tuple() 将 enumerate 对象转成元组

• 例：将列表数据转成 enumerate 对象应用

  drinks = {'coffee','tea','wine'}
  enumerate_drinks = enumerate(drinks)
  print(enumerate_drinks)
  print("下列是输出 enumerate 对象类型")
  print(type(enumerate_drinks))
  
  #输出结果
  <enumerate object at 0x0000000007C20A48>
  下列是输出 enumerate 对象类型
  <class 'enumerate'>
  

• 例：将列表数据转成 enumerate 对象，再将 enumerate 对象转成列表的实例，start 起始值分别为 0 和 10：

  drinks = {'coffee','tea','wine'}
  enumerate_drinks = enumerate(drinks)
  print("转成列表输出，初始值是 0 ：",list(enumerate_drinks))
  
  enumerate_drinks = enumerate(drinks,start = 10)
  print("转成列表输出，初始值是 10：",list(enumerate_drinks))
  
  #输出结果
  转成列表输出，初始值是 0 ： [(0, 'tea'), (1, 'coffee'), (2, 'wine')]
  转成列表输出，初始值是 10： [(10, 'tea'), (11, 'coffee'), (12, 'wine')]
  

• 上述程序第 4 行的 list() 函数可以将 enumerate 对象转成列表，在 7-5 节当笔者介绍完循环后，还将继续使用循环解析 enumerate 对象

ysports is not sports2
print(“我喜欢的运动 is 运动 2 ：”,boolean_value)

#输出结果
我喜欢的运动： [‘basketball’, ‘baseball’] 地址是： 134128840
运动1 ： [‘basketball’, ‘baseball’] 地址是： 134128840
运动2 ： [‘basketball’, ‘baseball’] 地址是： 129103368
我喜欢的运动 is 运动 1 ： True
我喜欢的运动 is 运动 2 ： False
我喜欢的运动 is 运动 1 ： False
我喜欢的运动 is 运动 2 ： True

### 6-12 enumerate 对象

- enumerate() 方法可以将 iterable 类数值的元素用计数值与元素配对方式传回，返回的数据称 enumerate 对象。其中 iterable 类数值可以是列表、元组、集合、等。它的语法格式如下：

- obj = enumerate( iterable [ , start = 0 ] )：如果省略 start = 设定，默认值是 0

- 未来我们可以使用 list() 将 enumerate 对象转成列表，使用 tuple() 将 enumerate 对象转成元组

- 例：将列表数据转成 enumerate 对象应用

```python
drinks = {'coffee','tea','wine'}
enumerate_drinks = enumerate(drinks)
print(enumerate_drinks)
print("下列是输出 enumerate 对象类型")
print(type(enumerate_drinks))

#输出结果
<enumerate object at 0x0000000007C20A48>
下列是输出 enumerate 对象类型
<class 'enumerate'>

• 例：将列表数据转成 enumerate 对象，再将 enumerate 对象转成列表的实例，start 起始值分别为 0 和 10：

  drinks = {'coffee','tea','wine'}
  enumerate_drinks = enumerate(drinks)
  print("转成列表输出，初始值是 0 ：",list(enumerate_drinks))
  
  enumerate_drinks = enumerate(drinks,start = 10)
  print("转成列表输出，初始值是 10：",list(enumerate_drinks))
  
  #输出结果
  转成列表输出，初始值是 0 ： [(0, 'tea'), (1, 'coffee'), (2, 'wine')]
  转成列表输出，初始值是 10： [(10, 'tea'), (11, 'coffee'), (12, 'wine')]
  

• 上述程序第 4 行的 list() 函数可以将 enumerate 对象转成列表，在 7-5 节当笔者介绍完循环后，还将继续使用循环解析 enumerate 对象