phython学习笔记

1、 Python1.基础部分1.1 下载地址&学习地址官网下载即可。1.2 作为计算器使用>>> 2 + 2 4 >>> 50 - 5 * 6 20 >>> （50 - 5 * 6 ） / 4 5.0 >>> 8 / 5 除法总是返回浮点数1.6>>> 17 / 3 经典分区返回一个浮点数5.666666666666667 >>> >>> 17 / 3 分区丢弃小数部分5 >>> 17 3 运算符返回分区的剩余部分2 >> >

2、5 * 3 + 2 结果*除数+余数17>>> 5 * 2 5平方25 >>> 2 * 7 2 7 128 的幂>>> width = 20 #等号（=）用于为变量赋值>>> height = 5 * 9 >>> width * height 900>>> a=3+5j 支持虚数>>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> pr

3、ice + _ 在交互模式下最后打印的表达式被分配给变量_(只读)113.0625 >>> round （_ ， 2 ）113.061.3 字符串字符串的表示可以用单引号（'.'）或双引号（"."）括起来，结果相同。 可以用来逃避引号：（与其他语言不同，特殊字符（如n单引号'.'和双"."引号）具有相同的含义。两者之间的唯一区别在于，在单引号内，您不需要转义"（但您必须转义'），反之亦然。）>>> 'spam eggs' # single qu

4、otes'spam eggs'>>> 'doesn't' # use ' to escape the single quote."doesn't">>> "doesn't" # .or use double quotes instead"doesn't">>> '"Yes," he said.''"Yes," he said.'>&g

5、t;> ""Yes," he said."'"Yes," he said.'>>> '"Isn't," she said.''"Isn't," she said.'在交互式解释器中，输出字符串用引号括起来，特殊字符用反斜线转义。虽然这有时看起来不同于输入（封闭引号可能会改变），但这两个字符串是等价的。如果字符串包含单引号且不带双引号，则该字符串将用双引号括起来，否则将用单引号括起来。该print()函数通过省

6、略封闭引号并打印转义字符和特殊字符，产生更易读的输出：>>> '"Isn't," she said.''"Isn't," she said.'>>> print('"Isn't," she said.')"Isn't," she said.>>> s = 'First line.nSecond line.' # n means newline>>>

7、s # without print(), n is included in the output'First line.nSecond line.'>>> print(s) # with print(), n produces a new lineFirst line.Second line.如果您不希望以前缀的字符被解释为特殊字符，则可以通过在第一个引号之前添加一个字符串来使用原始字符串r：>>> print('C:somename') # here n means newline!C:someame>>>

8、 print(r'C:somename') # note the r before the quoteC:somename字符串文字可以跨越多行。一种方法是使用三引号： """."""或'''.'''。行尾自动包含在字符串中，但可以通过在行尾添加一个来防止这种情况。以下示例：print("""Usage: thingy OPTIONS -h Display this usage message -H hostname Hostnam

9、e to connect to""")产生以下输出（请注意，不包括初始换行符）：Usage: thingy OPTIONS -h Display this usage message -H hostname Hostname to connect to字符串可以与+操作员串接（粘合在一起），并重复以下操作*：>>> # 3 times 'un', followed by 'ium'>>> 3 * 'un' + 'ium''unununium'两个或多

10、个字符串文字（即引号之间的文字）彼此相邻，会自动连接在一起。>>> 'Py' 'thon''Python'当您想要分隔长字符串时，此功能特别有用：>>> text = ('Put several strings within parentheses '. 'to have them joined together.')>>> text'Put several strings within parentheses to have them joined t

11、ogether.'这只适用于两个文字，而不是变量或表达式：>>> prefix = 'Py'>>> prefix 'thon' # can't concatenate a variable and a string literal .SyntaxError: invalid syntax>>> ('un' * 3) 'ium' .SyntaxError: invalid syntax如果要连接变量或变量和文字，请使用+：>>> prefix +

12、 'thon''Python'字符串可以被索引（下标），第一个字符的索引为0.没有单独的字符类型; 一个字符只是一个大小为1的字符串：>>> word = 'Python'>>> word0 # character in position 0'P'>>> word5 # character in position 5'n'指数也可能是负数，从右边开始计算：>>> word-1 # last character'n'&g

13、t;>> word-2 # second-last character'o'>>> word-6'P'请注意，由于-0与0相同，负指数从-1开始。除了索引之外，还支持切片。虽然索引用于获取单个字符，但切片允许您获取子字符串：>>> word0:2 # characters from position 0 (included) to 2 (excluded)'Py'>>> word2:5 # characters from position 2 (included) to 5 (ex

14、cluded)'tho'请注意始终包含开始，并始终排除结尾。这可以确保始终等于：s:i + si:s>>> word:2 + word2:'Python'>>> word:4 + word4:'Python'切片索引具有有用的默认值; 省略的第一个索引默认为零，省略的第二个索引默认为正在切片的字符串的大小。>>> word:2 # character from the beginning to position 2 (excluded)'Py'&g

15、t;>> word4: # characters from position 4 (included) to the end'on'>>> word-2: # characters from the second-last (included) to the end'on'要记住片的工作是怎么想的指数作为指着一个方向 之间的字符，第一个字符的左边缘编号为0之后的字符串的最后一个字符的右边缘ñ字符具有指数ñ，例如：+ - + - + - + - + - + - + | P | y | t | h | o

16、| n | + - + - + - + - + - + - + 0 1 2 3 4 5 6 - 6 - 5 - 4 - 3 - 2 - 1第一行数字给出字符串中索引0 . 6的位置; 第二行给出相应的负指数。从i到 j的片段分别由标记为i和j的边缘之间的所有字符组成。对于非负数指数，如果两者都在边界内，那么切片的长度就是指数的差值。例如，长度word1:3是2。尝试使用太大的索引会导致错误：>>> word42 # the word only has 6 charactersTraceback (most recent call last): File &

17、quot;<stdin>", line 1, in <module>IndexError: string index out of range但是，超出范围的切片索引在用于切片时会优雅地处理：>>> word4:42'on'>>> word42:''Python字符串不能改变 - 它们是不可变的。因此，分配给字符串中的索引位置会导致错误：>>> word0 = 'J' .TypeError: 'str' object does not supp

18、ort item assignment>>> word2: = 'py' .TypeError: 'str' object does not support item assignment如果你需要一个不同的字符串，你应该创建一个新的字符串：>>> 'J' + word1:'Jython'>>> word:2 + 'py''Pypy'内置函数len()返回一个字符串的长度：>>> s = 'supercalifragil

19、isticexpialidocious'>>> len(s)341.4 列表Python知道许多复合数据类型，用于将其他值组合在一起。最通用的是该列表，其可以写成方括号之间的逗号分隔值（项目）列表。列表可能包含不同类型的项目，但通常这些项目都具有相同的类型。>>> squares = 1, 4, 9, 16, 25>>> squares1, 4, 9, 16, 25像字符串（以及所有其他内置序列类型），列表可以被索引和切片：>>> squares0 # indexing returns the item1>&

20、gt;> squares-125>>> squares-3: # slicing returns a new list9, 16, 25所有切片操作都会返回一个包含所请求元素的新列表。这意味着下面的切片将返回列表的新（浅）副本：>>> squares:1, 4, 9, 16, 25列表还支持拼接等操作：>>> squares + 36, 49, 64, 81, 1001, 4, 9, 16, 25, 36, 49, 64, 81, 100与不可变的字符串不同，列表是一种可变 类型，即可以更改它们的内容：>>>

21、; cubes = 1, 8, 27, 65, 125 # something's wrong here>>> 4 * 3 # the cube of 4 is 64, not 65!64>>> cubes3 = 64 # replace the wrong value>>> cubes1, 8, 27, 64, 125您也可以使用该append() 方法在列表末尾添加新项目（我们将在后面看到更多关于方法的信息）：>>> cubes.append(216) # add the cube of 6>&

22、gt;> cubes.append(7 * 3) # and the cube of 7>>> cubes1, 8, 27, 64, 125, 216, 343对切片的分配也是可能的，这甚至可以改变列表的大小或完全清除它：>>> letters = 'a', 'b', 'c', 'd', 'e', 'f', 'g'>>> letters'a', 'b', 'c', 'd

23、', 'e', 'f', 'g'>>> # replace some values>>> letters2:5 = 'C', 'D', 'E'>>> letters'a', 'b', 'C', 'D', 'E', 'f', 'g'>>> # now remove them>>> letters

24、2:5 = >>> letters'a', 'b', 'f', 'g'>>> # clear the list by replacing all the elements with an empty list>>> letters: = >>> letters内置函数len()也适用于列表：>>> letters = 'a', 'b', 'c', 'd'>>>

25、len(letters)4可以嵌套列表（创建包含其他列表的列表），例如：>>> a = 'a', 'b', 'c'>>> n = 1, 2, 3>>> x = a, n>>> x'a', 'b', 'c', 1, 2, 3>>> x0'a', 'b', 'c'>>> x01'b'1.5 简单的例子>>> # Fi

26、bonacci series:. # the sum of two elements defines the next. a, b = 0, 1>>> while b < 10:. print(b). a, b = b, a+b.1123582.控制流程语句2.1 if>>> x = int(input("Please enter an integer: ")Please enter an integer: 42>>> if x < 0:. x = 0. print('Negative changed

27、 to zero'). elif x = 0:. print('Zero'). elif x = 1:. print('Single'). else:. print('More').More2.2 forforPython中的语句与您在C或Pascal中习惯使用的语言有些不同。Python的for语句并不总是迭代数字的算术级数（比如在Pascal中），或者让用户能够定义迭代步骤和停止条件（如C），Python 语句迭代任何序列的项目（一个列表或一个字符串），按顺序出现在序列中。例如（没有双关意图）：>>> #

28、Measure some strings:. words = 'cat', 'window', 'defenestrate'>>> for w in words:. print(w, len(w).cat 3window 6defenestrate 12如果您需要修改在循环中迭代的序列（例如复制选定项目），建议您先制作一份副本。遍历一个序列并不会隐式地创建一个副本。切片符号使这特别方便：>>> for w in words: # Loop over a slice copy of the entire list

29、. if len(w) > 6:. words.insert(0, w).>>> words'defenestrate', 'cat', 'window', 'defenestrate'2.3 range()如果您确实需要迭代一系列数字，则内置函数 range()将派上用场。它生成算术级数：>>> for i in range(5):. print(i).01234给定的终点不是生成的序列的一部分; range(10)生成10个值，即长度为10的序列的项目的合

30、法索引。可以让范围从另一个数字开始，或者指定一个不同的增量（甚至是负数;有时这称为“步骤”）：range(5, 10) 5, 6, 7, 8, 9range(0, 10, 3) 0, 3, 6, 9range(-10, -100, -30) -10, -40, -70要遍历序列的指数，你可以结合range()和 len()如下：>>> a = 'Mary', 'had', 'a', 'little', 'lamb'>>> for i in range(len(a):.

31、print(i, ai).0 Mary1 had2 a3 little4 lamb如果您只打印一个范围，会发生一件奇怪的事情：>>> print(range(10)range(0, 10)在许多方面，返回的对象的range()行为就好像它是一个列表，但事实上并非如此。它是一个对象，它在您迭代时返回所需序列的连续项，但它并不真正生成列表，从而节省空间。我们说这样一个对象是可迭代的，也就是说，适合作为函数和构造的目标，期望它们可以从中获得连续的项目，直到耗尽。我们已经看到这个for陈述是这样一个迭代器。该功能list() 是另一个; 它会根据迭代创建列表：&g

32、t;>> list(range(5)0, 1, 2, 3, 42.4 break，continue&elsebreak和在c语言里面一样，用于跳出for和while循环。循环语句可能有一个else子句; 当循环通过用尽列表（with for）或当条件变为false（with while）时终止时执行，但当循环由break语句终止时不执行。这由以下循环来举例说明，该循环搜索素数：>>> for n in range(2, 10):. for x in range(2, n):. if n % x = 0:. print(n, &

33、#39;equals', x, '*', n/x). break. else:. # loop fell through without finding a factor. print(n, 'is a prime number').2 is a prime number3 is a prime number4 equals 2 * 25 is a prime number6 equals 2 * 37 is a prime number8 equals 2 * 49 equals 3 * 3上述的else属于for,而不是ifcontinue语句也从C

34、中借用，继续循环的下一次迭代：>>> for num in range(2, 10):. if num % 2 = 0:. print("Found an even number", num). continue. print("Found a number", num)Found an even number 2Found a number 3Found an even number 4Found a number 5Found an even number 6Found a number 7Found an even number

35、8Found a number 92.5 pass该pass语句什么也不做。当语句需要语法时可以使用它，但程序不需要任何操作。例如：>>> while True:. pass # Busy-wait for keyboard interrupt (Ctrl+C).这通常用于创建最小类：>>> class MyEmptyClass:. pass.另一个地方pass可以作为一个函数或条件体的占位符，当你在处理新的代码时，允许你继续思考一个更抽象的层次。这pass是默默的忽略：>>> def initlog(*args):. pass # Rem

36、ember to implement this!.2.6 定义函数我们可以创建一个将斐波那契数列写入任意边界的函数：>>> def fib(n): # write Fibonacci series up to n. """Print a Fibonacci series up to n.""". a, b = 0, 1. while a < n:. print(a, end=' '). a, b = b, a+b. print().>>> # Now call the func

37、tion we just defined:. fib(2000)0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597关键字def引入了一个函数定义。它必须跟随函数名称和形式参数的括号括起来的列表。构成函数主体的语句从下一行开始，并且必须缩进。函数体的第一个语句可以可选地是一个字符串文字; 此字符串文字是函数的文档字符串或docstring。（关于文档字符串的更多信息可以在文档字符串部分找到。）有一些工具可以使用文档自动生成在线或打印文档，或让用户交互式浏览代码; 在您编写的代码中包含文档字符串是一种很好的做法，请养成习惯

38、。函数的执行引入了一个用于函数局部变量的新符号表。更确切地说，函数中的所有变量赋值都将值存储在本地符号表中; 而变量引用首先在本地符号表中查找，然后在封闭函数的本地符号表中，然后在全局符号表中，最后在内置名称表中查找。因此，全局变量不能直接在函数内赋值（除非在global语句中命名），尽管它们可能被引用。函数调用的实际参数（参数）在被调用函数的本地符号表中引入时被调用; 因此，参数通过值调用传递（其中值始终是对象引用，而不是对象的值）。1当函数调用另一个函数时，为该调用创建一个新的本地符号表。函数定义在当前符号表中引入函数名称。函数名称的值具有由解释器识别为用户定义函数的类

39、型。这个值可以分配给另一个名字，然后也可以作为一个函数使用。这是一个通用的重命名机制：>>> fib <function fib at 10042ed0> >>> f = fib >>> f （100 ）0 1 1 2 3 5 8 13 21 34 55 89来自其他语言，你可能会反对，这fib不是一个函数，而是一个过程，因为它不返回一个值。事实上，即使没有return声明的函数也会 返回一个值，尽管这个值很无聊。这个值被调用None（这是一个内置的名字）。写入值None通常会被解释器抑制，如果它是唯一写入的值。你可以

40、看到它，如果你真的想使用print()：>>> fib(0)>>> print(fib(0)None编写一个返回斐波那契数列表的函数，而不是打印它的函数很简单：>>> def fib2(n): # return Fibonacci series up to n. """Return a list containing the Fibonacci series up to n.""". result = . a, b = 0, 1. while a < n:. result.a

41、ppend(a) # see below. a, b = b, a+b. return result.>>> f100 = fib2(100) # call it>>> f100 # write the result0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89像往常一样，这个例子演示了一些新的Python特性：· 该return语句返回一个函数的值。 return没有表达式参数返回None。掉落一个函数的结尾也会返回None。· 该语句result.append(a)调用列表对象 的方

42、法result。方法是一个“属于”对象并被命名的函数obj.methodname，其中obj某个对象（这可能是一个表达式），并且methodname是由该对象的类型定义的方法的名称。不同类型定义不同的方法。不同类型的方法可以具有相同的名称而不会造成歧义。（可以使用类定义自己的对象类型和方法，请参阅类）append()示例中显示的方法是为列表对象定义的; 它在列表的末尾添加了一个新元素。在这个例子中它相当于result = result + a ，但更有效。 2.7带参数的函数也可以使用可变数量的参数来定义函数。有三种形式，可以合并。

43、默认参数值最有用的形式是为一个或多个参数指定默认值。这创建了一个函数，它可以用比它定义允许的参数更少的参数来调用。例如：def ask_ok(prompt, retries=4, reminder='Please try again!'): while True: ok = input(prompt) if ok in ('y', 'ye', 'yes'): return True if ok in ('n', 'no', 'nop', 'nope'): return

44、 False retries = retries - 1 if retries < 0: raise ValueError('invalid user response') print(reminder)这个功能可以通过几种方式调用：· 只给出强制性的参数： ask_ok('Do you really want to quit?')· 给出一个可选参数： ask_ok('OK to overwrite the file?

45、', 2)· 给出所有参数： ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')这个例子还介绍了in关键字。这测试一个序列是否包含某个值。默认值是在定义范围中的函数定义点处计算的 ，因此打印为5。i = 5def f(arg=i): print(arg)i = 6f()重要警告： 默认值只计算一次。当默认值是可变对象

46、（如列表，字典或大多数类的实例）时，这会有所不同。例如，以下函数会累积在后续调用中传递给它的参数：def f(a, L=): L.append(a) return Lprint(f(1)print(f(2)print(f(3)这将打印 1 1 ， 2 1 ， 2 ， 3 如果你不想在后续调用之间共享默认值，你可以这样写：def f(a, L=None): if L is None: L = L.append(a) return L 关键字参数也可以使用 表单的关键字参数来调用函数kwarg=value。例如，以下功能：def parrot(voltage, state='a

47、stiff', action='voom', type='Norwegian Blue'): print("- This parrot wouldn't", action, end=' ') print("if you put", voltage, "volts through it.") print("- Lovely plumage, the", type) print("- It's", state, "!&

48、quot;)接受一个所需参数（voltage）和三个可选参数（state，action，和type）。该功能可以通过以下任何方式调用：parrot(1000) # 1 positional argumentparrot(voltage=1000) # 1 keyword argumentparrot(voltage=1000000, action='VOOOOOM') # 2 keyword argumentsparrot(action='VOOOOOM', voltage=1000000) # 2 keyword argumentsparrot('a

49、million', 'bereft of life', 'jump') # 3 positional argumentsparrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword但以下所有调用都是无效的：parrot() # required argument missingparrot(voltage=5.0, 'dead') # non-keyword argument after a keyword ar

50、gumentparrot(110, voltage=220) # duplicate value for the same argumentparrot(actor='John Cleese') # unknown keyword argument在函数调用中，关键字参数必须跟随位置参数。所有传递的关键字参数必须与函数接受的参数之一相匹配（例如actor，不是该parrot函数的有效参数 ），它们的顺序并不重要。这也包括非可选参数（例如parrot(voltage=1000)也是有效的）。没有参数可能会多次收到一个值。以下是由于此限制而失败的示例：>>&g

51、t; def function(a):. pass.>>> function(0, a=0)Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: function() got multiple values for keyword argument 'a'当表单的最终形式参数*name存在时，它会接收一个包含所有关键字参数的字典（参见映射类型 - 词典），除了那些对应于正式参数的关键字参数。这可以与形式的形式参

52、数*name（在下一小节中描述）结合，其接收包含形式参数列表之外的位置参数的元组。（*name必须在之前出现*name）。例如，如果我们定义一个像这样的函数：def cheeseshop(kind, *arguments, *keywords): print("- Do you have any", kind, "?") print("- I'm sorry, we're all out of", kind) for arg in arguments: print(arg) print("-" *

53、40) for kw in keywords: print(kw, ":", keywordskw)它可以这样调用：cheeseshop("Limburger", "It's very runny, sir.", "It's really very, VERY runny, sir.", shopkeeper="Michael Palin", client="John Cleese", sketch="Cheese Shop Sketch"

54、)当然它会打印：- Do you have any Limburger ?- I'm sorry, we're all out of LimburgerIt's very runny, sir.It's really very, VERY runny, sir.-shopkeeper : Michael Palinclient : John Cleesesketch : Cheese Shop Sketch请注意，打印关键字参数的顺序保证与它们在函数调用中提供的顺序相匹配。 任意参数列表最后，最不经常使用的选项是指定可以用任意数量的参数调用一个函数。这些参数将包

55、含在一个元组中（请参阅元组和序列）。在可变数量的参数之前，可能会出现零个或多个正常参数。def write_multiple_items(file, separator, *args): file.write(separator.join(args)通常，这些variadic参数将在形式参数列表中最后一个，因为它们会获取传递给该函数的所有剩余输入参数。在参数后面出现的任何形式参数*args 都是“仅关键字”参数，这意味着它们只能用作关键字而不是位置参数。>>> def concat(*args, sep="/"):. return sep.joi

56、n(args).>>> concat("earth", "mars", "venus")'earth/mars/venus'>>> concat("earth", "mars", "venus", sep=".")'earth.mars.venus' 解包参数列表当参数已经在列表或元组中时，会出现相反的情况，但需要对需要单独位置参数的函数调用进行解压缩。例如，内置range()函数需要单独

57、的 启动和停止参数。如果它们不能单独使用，请使用*-operator 编写函数调用以 将参数从列表或元组中解开：以同样的方式，字典可以用*-operator 提供关键字参数： Lambda表达式可以使用lambda关键字创建小型匿名函数。这个函数返回它的两个参数的总和：。Lambda函数可用于需要函数对象的任何地方。它们在语法上受限于单个表达式。在语义上，它们只是正常函数定义的语法糖。像嵌套函数定义一样，lambda函数可以引用来自包含范围的变量：lambda a, b: a+b上面的例子使用lambda表达式来返回一个函数

58、。另一个用途是传递一个小函数作为参数： 文档字符串以下是关于文档字符串内容和格式的一些约定。第一行应始终是对象目的的简短摘要。为简洁起见，它不应该明确声明对象的名称或类型，因为这些可以通过其他方式获得（除非名称恰好是描述函数操作的动词）。该行应以大写字母开头并以句号结尾。如果文档字符串中有更多行，则第二行应该是空白的，从总体上与描述的其余部分在视觉上是分开的。以下几行应该是一个或多个描述对象调用约定，副作用等的段落。Python解析器不会从Python中的多行字符串文字中去除缩进，所以如果需要，处理文档的工具必须去除缩进。这是使用以下惯例完成的。字符串的第一行之后的第一个非空行 确定

59、整个文档字符串的缩进量。（我们不能使用第一行，因为它通常与字符串的开始引号相邻，所以它的缩进在字符串文字中不明显）。然后从该字符串的所有行的开头剥离与该缩进等效的空格。缩进的行不应该出现，但如果它们发生，则应删除所有前导空白。在扩展选项卡后（通常为8个空格），应该测试空白的等效性。这是一个多行文档字符串的例子： 函数注释函数注释完全是有关用户定义函数使用的类型的可选元数据信息（请参阅PEP 484 了解更多信息）。注释_annotations_以字典的形式存储在函数的属性中，并且不影响函数的任何其他部分。参数注释由参数名称后面的冒号定义，后跟表达式评估注释的值。返回注释由一个文字定义

60、->，后跟一个表达式，在参数列表和冒号之间表示def语句的结尾。以下示例具有位置参数，关键字参数和注释的返回值： ntermezzo：编码风格现在您要编写更长，更复杂的Python，现在是讨论编码风格的好时机。大多数语言可以用不同的风格编写（或更简洁，格式化）; 有些比其他更可读。让别人轻松阅读你的代码总是一个好主意，采用一种很好的编码风格对此非常有帮助。对于Python， PEP 8已成为大多数项目遵循的风格指南; 它促进了非常可读和令人喜欢的编码风格。每个Python开发者都应该在某个时候阅读它; 这里是为你提取的最重要的点：· 使用

61、4空格缩进，并且没有选项卡。4个空格是小缩进（允许更大的嵌套深度）和大缩进（更容易读取）之间的良好折衷。选项卡引入了混淆，最好省略。· 自动换行不要超过79个字符。这有助于用户使用小型显示器，并可以在较大的显示器上并排显示多个代码文件。· 使用空行来分隔函数和类，以及函数内的更大块代码。· 如果可能，请将评论放在他们自己的一行上。· 使用docstrings。· 在运算符和逗号后面使用空格，但不要直接在包围结构中使用空格：。a = f(1, 2) + g(3, 4)· 一致地

62、命名你的类和函数; 该惯例是 CamelCase用于类和lower_case_with_underscores功能和方法。始终self用作第一个方法参数的名称（有关类和方法的更多信息，请参见首先查看类）。· 如果您的代码旨在用于国际环境，请不要使用奇特的编码。在任何情况下，Python的默认值，UTF-8或甚至纯ASCII都能最好地工作。· 同样，不要在标识符中使用非ASCII字符，如果只有轻微的机会，人们说不同的语言会读取或维护代码。3. 数据结构3.1 更多关于列表列表数据类型有更多的方法。以下是列表对象的所有方法：list.append（x

63、0;）将项目添加到列表的末尾。相当于。alen(a): = xlist.extend（iterable）通过附加iterable中的所有项来扩展列表。相当于 。alen(a): = iterablelist.insert（i，x ）在一个给定的位置插入一个项目。第一个参数是要插入的元素的索引，因此插入列表的前面，等同于。a.insert(0, x)a.insert(len(a), x)a.append(x)list.remove（x ）从列表中删除值为x的第一个项目。如果没有这样的项目，这是一个错误。list.pop（ i  ）删除列表中给定位置的项目，然后返回。如果没有指定索引，则a.pop()删除并返回列表中的最后一个项目。（方法签名中围绕i的方括号表示该参数是可选的，而不是您应该在该位置输入方括号，您会在Python库参