1 Python 3.3.2 （v3.3.2:d047928ae3f6， May 16 2013， 00:03:43） [MSC v.1600 32 bit （Intel）] on win32

  2 Type copyright， credits or license（） for more information.

  3 >>> counter = 100

  4 >>> miles = 1000.0

  5 >>> name = hongten

  6 >>> numberA，numberB，nameC = 1，2，Hongten

  7 >>> list = [counter，miles，name，numberA，numberB，nameC]

  8 >>> print（list）

  9 [100， 1000.0， hongten， 1， 2， Hongten]

 10 >>> ＃这是注释项目组，注释用＃开端

 11 >>> for element in list:

 12     print（element）

 13 

 14 100

 15 1000.0

 16 hongten

 17 1

 18 2

 19 Hongten

 20 >>> ＃上方是遍历列表list

 21 >>> print（list[0]） ＃获取列表list里面的第一个元素值

 22 100

 23 >>> print（list[-1]） ＃获取列表list里面的最后一个元素值

 24 Hongten

 25 >>> print（len（list）） ＃用len（list）获取list列表的长度

 26 6

 27 >>> num_inc_list = range（10） ＃产生一个数值递增的列表

 28 >>> print（num_inc_list）

 29 range（0， 10）

 30 >>> for inc_list in num_inc_list:

 31     print（inc_list）

 32 

 33 0

 34 1

 35 2

 36 3

 37 4

 38 5

 39 6

 40 7

 41 8

 42 9

 43 >>> ＃从这里我们可以看到range（10）是产生了一个从0开端到9的一个数值递增列表

 44 >>> initial_value = 10

 45 >>> list_length = 5

 46 >>> myList = [initial_value for i in range（10）]

 47 >>> print（myList）

 48 [10， 10， 10， 10， 10， 10， 10， 10， 10， 10]

 49 >>> list_length = 2

 50 >>> myList = myList  list_length

 51 >>> print（myList）

 52 [10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10， 10]

 53 >>> print（len（myList））

 54 20

 55 >>> ＃上方是用一个固定值initial_value去初始化一个列表myList

 56 >>> ＃同时用myList = myList  list_length去复制myList

 57 >>> ＃下面再看看复制的结果

 58 >>> copyList = [1，2，3，hongten]

 59 >>> copyList = copyList  list_length

 60 >>> print（len（copyList））

 61 8

 62 >>> for cl in copyList:

 63     print（cl）

 64 

 65     

 66 1

 67 2

 68 3

 69 hongten

 70 1

 71 2

 72 3

 73 hongten

 74 >>> ＃下面我们来细心研究一下python里面的list

 75 >>> ＃在一个list中可以包含不合类型的元素，这个和ActionScript 3.0（AS3.0）中的数组类似

 76 >>> test_list = [hello，1，2，world，4，5，hongten]

 77 >>> print（len（test_list））

 78 7

 79 >>> print（test_list[0]） ＃ 打印test_list

 80 hello

 81 >>> ＃打印test_list中的第一元素

 82 >>> print（test_list[-1]） ＃打印test_list中最后一个元素

 83 hongten

 84 >>> print（test_list[-len]） ＃打印第一个元素

 85 Traceback （most recent call last）:

 86   File <pyshell＃44>， line 1， in <module>

 87     print（test_list[-len]） ＃打印第一个元素

 88 TypeError: bad operand type for unary -: builtin_function_or_method

 89 >>> print（test_list[-len（test_list）]） ＃打印第一个元素

 90 hello

 91 >>> print（test_list[len（test_list） - 1]） ＃打印最后一个元素

 92 hongten

 93 >>> test_list.append（6） ＃向列表中追加一个元素

 94 >>> print（test_list[-1]）

 95 6

 96 >>> test_list.（1，0）

 97 >>> print（test_list）

 98 [hello， 0， 1， 2， world， 4， 5， hongten， 6]

 99 >>> ＃上方的操纵是向列表test_list的小标为1的处所插入元素0

100 >>> test_list.（1，0）

101 >>> print（test_list）

102 [hello， 0， 0， 1， 2， world， 4， 5， hongten， 6]

103 >>> test_list.（2，1）

104 >>> print（test_list）

105 [hello， 0， 1， 0， 1， 2， world， 4， 5， hongten， 6]

106 >>> print（test_list.pop（0）） ＃返回最后一个元素，并从test_list中删除之

107 hello

108 >>> print（test_list）

109 [0， 1， 0， 1， 2， world， 4， 5， hongten， 6]

110 >>> print（test_list.pop（2）） ＃上方的注释有错误，pop（index）的操纵是返回数组下标为index的元素，并从列表中删除之

111 0

112 >>> print（test_list）

113 [0， 1， 1， 2， world， 4， 5， hongten， 6]

114 >>> test_list.remove（1）

115 >>> print（test_list）

116 [0， 1， 2， world， 4， 5， hongten， 6]

117 >>> ＃remove（1）默示的是删除第一次呈现的元素1

118 >>> test_list.（0，1）

119 >>> print（test_list）

120 [1， 0， 1， 2， world， 4， 5， hongten， 6]

121 >>> test_list.remove（1）

122 >>> print（test_list）

123 [0， 1， 2， world， 4， 5， hongten， 6]

124 >>> test_list.（2，hongten）

125 >>> print（test_list）

126 [0， 1， hongten， 2， world， 4， 5， hongten， 6]

127 >>> test_list.count（hongten）

128 2

129 >>> ＃count（var）是统计var元素在列表中呈现的个数

130 >>> test_list.count（foo）

131 0

132 >>> test_list_extend = [a，b，c]

133 >>> test_list.extend（test_list_extend）

134 >>> print（test_list）

135 [0， 1， hongten， 2， world， 4， 5， hongten， 6， a， b， c]

136 >>> ＃应用extend（list）感化是追加一个list到源list上方

137 >>> print（test_list.sort（））

138 Traceback （most recent call last）:

139   File <pyshell＃76>， line 1， in <module>

140     print（test_list.sort（））

141 TypeError: unorderable types: str（） < int（）

142 >>> test_list_extend.append（h）

143 >>> test_lsit_extend.append（e）

144 Traceback （most recent call last）:

145   File <pyshell＃78>， line 1， in <module>

146     test_lsit_extend.append（e）

147 NameError: name test_lsit_extend is not defined

148 >>> list_a = [e，z，o，r]

149 >>> list_a.extend（test_list_extend）

150 >>> print（list_a）

151 [e， z， o， r， a， b， c， h]

152 >>> print（list_a.sort（）） ＃对list_a列表进行排序

153 None

154 >>> ＃不知道为什么以上排序都有报错......

155 >>> list_b = [1，3，5，2，6，4]

156 >>> print（list_b.sort（））

157 None

158 >>> print（sort（list_b））

159 Traceback （most recent call last）:

160   File <pyshell＃86>， line 1， in <module>

161     print（sort（list_b））

162 NameError: name sort is not defined

163 >>> ＃不去管排序题目了，先看看删除操纵吧！！！！！

164 >>> print（list_b）

165 [1， 2， 3， 4， 5， 6]

166 >>> print（del list_b[1]）

167 SyntaxError: invalid syntax

168 >>> del list_b[1]

169 >>> print（list_b）

170 [1， 3， 4， 5， 6]

171 >>> del list_b[0，2]

172 Traceback （most recent call last）:

173   File <pyshell＃92>， line 1， in <module>

174     del list_b[0，2]

175 TypeError: list indices must be integers， not tuple

176 >>> del list_b[0:2]

177 >>> print（list_b）

178 [4， 5， 6]

179 

180 >>> ＃del list[index]删除下标为index的元素，del list[start:end]删除从start下标开端到end下标停止的元素

181 >>> del list_b[10]

182 Traceback （most recent call last）:

183   File <pyshell＃96>， line 1， in <module>

184     del list_b[10]

185 IndexError: list assignment index out of range

186 >>> ＃若是我们删除的下标超出了列表的长度局限，就会报错啦!!!!!

187 >>> ＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃

188 >>> list_c = range（5）;

189 >>> for c in list_c:

190     print（c）

191 

192     

193 0

194 1

195 2

196 3

197 4

198 >>> list_d = list_c

199 >>> for d in list_d:

200     print（d）

201 

202     

203 0

204 1

205 2

206 3

207 4

208 >>> ＃上方是列表的复制

209 >>> list_d[2] = 23

210 Traceback （most recent call last）:

211   File <pyshell＃108>， line 1， in <module>

212     list_d[2] = 23

213 TypeError: range object does not support item assignment

214 >>> list_e = [1，2，3，4，5]

215 >>> list_f = list_e

216 >>> list_f[2] = 234

217 >>> print（list_e）

218 [1， 2， 234， 4， 5]

219 >>> ＃从这里我们可以知道，list_f复制了list_e，list_f是对list_e的一个引用，

220 >>> ＃他们共同指向一个对象：[1，2，3，4，5]，视图批改list_f[2]的值的时辰，

221 >>> ＃list_f所指向的对象的行动产生了变更，即元素值产生了变更，然则他们的引用是没有

222 >>> ＃产生变更的。所以list_e[2] = 234也是在情理之中。

223 >>> ＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃

224 >>> list_i = list_e[:]

225 >>> print（list_i）

226 [1， 2， 234， 4， 5]

227 >>> print（list_e）

228 [1， 2， 234， 4， 5]

229 >>> list_i[2] = 3

230 >>> print（list_e）

231 [1， 2， 234， 4， 5]

232 >>> print（list_i）

233 [1， 2， 3， 4， 5]

234 >>> ＃上方是进行了列表的克隆操纵，即拷贝了另一个列表，如许的操纵，会发明出新的一个列表对象

235 >>> ＃使得list_i和list_e指向不合的对象，就有着不合的引用，所以当list_i[2] = 3的时辰，

236 >>> ＃list_e[2]还是便是234，即不变

237 >>>