python 列表 换行_python基础语法学习——参考Python Crash Course

第一章：python在各个系统之间的安装和使用（略）

第二章：

变量

2.1.每个变量都存储了一个值 ——与变量相关联的信息.在程序中可随时修改变量的值，而 Python将始终记录变量的最新值。

2.2变量名只能包含字母、数字和下划线，不能有空格。变量名可以字母或下划线打头，但不能以数字打头。

小练习：将一条消息存储到变量中，再将其打印出来。#print只能打印变量和字符串，不能打数字和字母！

Liuyuanji="He is so handsome!"
print(Liuyuanji)

字符串

2.3字符串就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号.没什么区别. 单独的字符串需要有引号来引用，数字就不用了。

"He said'i don't like you.'"

2.3.1将字符串进行大小写的改变——X.title（）title() 以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。

AK="taylor swift"
print(AK.title())

2.3.2 将字母全部变成大写——x.upper（）；将字母全部变成小写x.lower（）

2.3.3合并（拼接）字符串，在python中使用“+”号来连接字符串.

A="John"
B="NYU"
C=A+" "+B
print(C)

可以再来一句话给出一个例子来试验。这里需要注意的地方（我自己写出错的地方）：在print语句中，如果是单纯的字符（字母和符号），是需要用引号隔开的，如果是字符串就不用啦）

A="John,I love you baby!"
print("Hello,I wanna tell you:"+A)

2.3.4使用制表符或换行符来添加空白:

可使用字符组合 t来添加制表符（多一个tap）；可以使用n来添加换行符。害，我刚才又出现了一个错误：制表符是要放在字符前面的！然后最后一行不要换行了.......

print（"tHello,John!"）
print("name:nage:ngender:")

ps：还可在同一个字符串中同时包含制表符和换行符。字符串 "nt" 让 Python 换到下一行，并在下一行开头添加一个制表符。

2.3.5删除空白：

1. Python 能够找出字符串开头和末尾多余的空白。要确保字符串末尾没有空白，可使用方法 .rstrip() 这里的删除只是暂时的，也可以理解为把删除空白格的变量成了一个新的变量。要永久删除这个字符串中的空白，必须将删除操作的结果存回到变量中。

2.同理：还可以剔除字符串开头的空白，或同时剔除字符串两端的空白。为此，可分别使用方法 lstrip() 和 strip() ：（具体不写example了）

A="NYU     "
B=A.rstrip()
print(B)
A=B
print（A）

2.4 数字

2.4.1 整数运算（略）:加（ + ）减（ - ）乘（ * ）除（ / ）；Python 使用两个乘号表示乘方运算

2.4.2浮点数（小数）（略）

2.4.3关于将非字符数变成字符数：str（x） 我的错误我以为是x.str（）

age=20
print("John is "+str(age)+" old")

2.5注释（一个很有用的技能）

在 Python 中，注释用井号（ # ）标识。井号后面的内容都会被 Python 解释器忽略。

print("I LOVE TAYLOR SWIFT!")#DBDFHOIHDOICIOSAFOIIFCEO

在本章中，学习了：如何使用变量；如何创建描述性变量名以及如何消除名称错误和语法错误；字符串是什么，以及如何使用小写、大写和首字母大写方式显示字符串；使用

空白来显示整洁的输出，以及如何剔除字符串中多余的空白；如何使用整数和浮点数；使用数值数据时需要注意的意外行为。你还学习了如何编写说明性注释，让代码对你和其

他人来说更容易理解。最后，你了解了让代码尽可能简单的理念。

第三章：列表简介

在 Python 中，用方括号（ [] ）来表示列表：

My Favorite singer=([Taylor Swift],[justin bieber])#这是我第一次的错误
MY Favorite singer=["Taylor Swift","Justin Bieber"]#这个就是第二次正确的一个列表

3.1.1访问列表元素，只需将该元素的位置或索引告诉 Python 即可。（索引位置是从0开始而不是1,算是常识）

MY Favorite singer=["Taylor Swift","Justin Bieber"]
print（MY Favorite singer[1])#这样给出的就是Justin Bieber了

3.1.2使用列表中的各个值。这个其实和一开始用非字符串当做字符串是一样的。我觉得如果列表中的元素不是字符串的话，可能还需要用一个str（）吧。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
 message = "My first bicycle was a " + bicycles[0].title() + "."

3.2 　修改、添加和删除元素

3.2.1 　修改列表元素： 修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
bocycles[2]="red"
print(bicycles)

3.2.2 增加列表元素：X.append（）将一个新的元素加入到列表的末尾。（注意，不是加新的列表，而是列表元素哦，我一开始学的时候列表个数和列表元素老是分不清）

ps:小技巧：可首先创建一个空列表，用于存储用户将要输入的值，然后将

用户提供的每个新值附加到列表中。

3.2.3在列表中插入元素，如果要插入的话，确定两个变量就好咯——索引，和元素内容。

用X.insert（a,b）——a为列表中的索引，b为元素内容：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
bicycles.insert(3,'good')
print(bicycles)

3.2.4从列表中删除元素

如果知道要删除的元素在列表中的位置，可使用 del 语句。注意，是语句。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
del bicycles[1]#语句不需要加括号吧
print(bicycles)

使用方法 pop() 删除元素。pop（）可以删除列表中的最后一个元素.如果需要使用删去的那个元素，创建一个新的变量保存吧。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
Ok=bicycles.pop()#Ok就是代表了最后一个元素了
print(bicycles)#这个时候就会给出失去最后一个元素的原本列表bicycles了

3.2.5从列表中弹出任何位置的元素。用pop（x），其中x就是代表元素在列表中的索引位置。如果想使用：先用pop（）删去，然后用新的变量表示删去的，再引用新的变量，就开业弹出了。 ps:如果用del语句删除就无法再引用了，如果用pop（）就还可以。（例子也可以用上面的）

3.2.6根据值删除元素 remove(x)具体的比pop（x）差不多吧我感觉。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
apple=bicycles.remove（"redline"）
print(bicycles)

3.3组织列表

3.3.1　使用方法 sort() 对列表进行永久性排序（按字母顺序排序);你还可以按与字母顺序相反的顺序排列列表元素，为此，只需向 sort() 方法传递参数 reverse=True 。这里的永久性我的理解就是电脑删去了原本的样子没有copy了。彻底改变回不去。

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)
cars.sort(reverse=True)#为什么是这样的形式呢？
print（cars）

3.3.2使用函数 sorted() 对列表进行临时（按字母顺序）排序。这样的话就相当于出现了新的排序，但是原本的也有备份吧。

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sorted()
print(cars)

3.3.3倒着打印列表 reverse().将列表的元素顺序颠倒显示。reverse的修改也是永久性的，无备份。

3.3.4确定列表长度——len（）ps：列表长度从1开始

关于索引的顺序：从左往右从0开始，从右往左从-1开始。

在本章中，学习了：列表是什么以及如何使用其中的元素；如何定义列表以及如何增删元素；如何对列表进行永久性排序，以及如何为展示列表而进行临时排序；如何确定列表的长度，以及在使用列表时如何避免索引错误。

第 4 章　操作列表

4.1 　遍历整个列表——用for循环就可 （for X in Y：）

4.1.2 　在 for 循环中执行更多的操作，其实也就多了之前的结合。

magicians = ['alice', 'david', 'carolina']
for x in magicians：
    print（x.title（）+“is a good person！”）

在 for 循环后面，没有缩进的代码都只执行一次，而不会重复执行。缩进不缩进，关乎着逻辑的问题。只有要在 for 循环中对每个元素执行的代码需要缩进（目前）。还有一个！！！千万别忘记了冒号。

4.2 　创建数值列表

4.2.1　使用函数 range()

for X in range(a,b）:
    print(x)#给出来的结果应该是a到b-1
for X in range（a，b，3）
    print(x)#这里range多了一个步长，算是数列中的差吧 不写默认为1

4.2.2 　使用 range() 创建数字列表：用list（），将range（）变成list（）中的参数。

4.2.3 max(); min();sum()

4.2.4.列表解析 用一行代码来实现循环

squares = [value**2 for value in range(1,11)]
print(squares)

就个人感觉，如有小misson：一般先创建一个空列表，然后for循环填进去，然后在用for print或者sum 都行。

4.3关于切片。与函数 range() 很相似吧， Python 在到达你指定的第二个索引前面的元素后停止。关于那种负数索引和正数索引用法和range（）一样。

players = ['charles', 'martina', 'michael', 'florence', 'eli']
   print(players[0:3])#零对应第一个，一直切到3之前的元素，也就是2
   print(players[:3])#没有首个元素的索引，默认从第一个开始
   print(players[2:])#没有尾部元素的索引，默认一直开始到最后一个

4.3.2 　遍历切片——用for循环进行列表切片索引就好

4.4.3 　复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（ [:] ）

4.4. 4　元组—— Python 将不能修改的值称为 不可变的 ，而不可变的列表被称为元组 。元组是圆括号，列表是方括号。虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组。（类似于重新写一个吧）

在本章中，学习了：如何高效地处理列表中的元素；如何使用for 循环遍历列表，Python如何根据缩进来确定程序的结构以及如何避免一些常见的缩进错误；如何创建简单的数字列表，以及可对数字列表执行的一些操作；如何通过切片来使用列表的一部分和复制列表。你还学习了元组（它对不应变化的值提供了一定程度的保护）。

第五章 if语句

5.2 条件测试

每条if 语句的核心都是一个值为True 或False 的表达式，这种表达式被称为条件测试 。

=：赋值；==等于；！=不等于

5.2.1多个条件测试（同时满足），可以用 and （类似与门）；多个条件测试（满足一个就可），可以用or（类似或门）

5.2.2判断特定的值是否已包含在列表中，可使用关键字in;确定特定的值未包含在列表中很重要；在这种情况下，可使用关键字not in

Caffe=["ad","va"]
 "ad" in Caffe:

banned_users = ['andrew', 'carolina', 'david'] 
user = 'marie' 
if user not in banned_users: 
    print(user.title() + ", you can post a response if you wish.")

5.3 if 语句学习

在if 语句中，缩进的作用与for 循环中相同。如果测试通过了，将执行if 语句后面所有缩进的代码行，否则将忽略它们。

John= "handsome"
if John="handsome':
   print("He is so good! i wanna him")

5.3.2 if-else 语句，常常用于二选一的状态：通常else之后直接就是一个冒号就好了，因为只要不满足if，就是else。

if xxxxx：
 xxxxxxxxxx
else：
xxxxxxx

5.3.3 if-elif-else 结构：也就多了一个选择吧，多个elif

ifxxxxx：
  xxxxxxx
elif xxxxx：
  xxxxxxxx
else：
  xxxxx

5.3.4 多个elif结构。有时候可以不用else了，可以用一个具体的elif来代替else，会使得代码更加清晰。else 是一条包罗万象的语句，只要不满足任何if 或elif 中的条件测试，其中的代码就会执行，这可能会引入无效甚至恶意的数据。

上面的几个条件结构都是针对只需要满足其中一种的情况，如果需要多个条件独立检验（和有and or 的不一样的），则我们需要多个if语句来分开来独立检验。

5.3.5 用if语句使用多个列表：

available_toppings = ['mushrooms', 'olives', 'green peppers', 'pepperoni', 'pineapple', 'extra cheese'] 
requested_toppings = ['mushrooms', 'french fries', 'extra cheese'] 
for requested_topping in requested_toppings:
      if requested_topping in available_toppings: 
           print("Adding " + requested_topping + ".") 
      else:
           print("Sorry, we don't have " + requested_topping + ".") 
print("nFinished making your pizza!")

在本章中，学习了如何编写结果要么为Ture 要么为False 的条件测试。你学习了如何编写简单的if 语句、if-else 语句和if-elif-else 结构。在程序中，你使用了这些结构来测试特定的条件，以确定这些条件是否满足。学习了如何在利用高效的for 循环的同时，以不同于其他元素的方式对特定的列表元素进行处理。

第六章 字典

在 Python 中， 字典 是一系列 键 — 值对 。每个 键 都与一个值相关联，你可以使用键来访问与之相关联的值（print（键），然后输出值）。字典用放在花括号 {} 中的一系列键 — 值对表示

cool={"John":"handsome","jack":"ugly"}#字典中间需要用逗号隔开

6.2.2 添加键值对，很简单就是一行代码：X[添加的键]=添加的值。（x为已知的字典）；一般也可以先添加一个空的字典，然后一点点的往里面填键值对。

6.2.3修改键值对——要修改字典中的值，可依次指定字典名、用方括号括起的键以及与该键相关联的新值。其实和添加差不多。只是键名不是新的，而是已经存在的。

6.2.4对于字典中不再需要的信息，可使用 del 语句将相应的键 — 值对彻底删除。

del X[键名]

6.2.5 X.items() 可以返回一个对应的键和值：

message={"Name":"John","Age":20,"Gender":"male"}
for key,value in message.items():#一定要有2个变量，分别对应键，值
    print(n"Key is:"+key)
    print("Value is:"+value)#跑数字的时候还需要用str单独搞一下。可以考虑使用if elif结构
     

6.2.6遍历字典中的所有键 for循环+keys()方法 keys() 并非只能用于遍历；实际上，它返回一个列表，其中包含字典中的所有键。

6.3 按顺序遍历字典的所有键：还是for循环+sorted()顺序功能。

ps：是要获取所有字典的值的话：for循环+values（）即可。如果值出现了重复，使用set（）即可。

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
    print(language.title())

6.4嵌套

系列字典存储在列表中，或将列表作为值存储在字典中，这称为 嵌套。（类似于换元吧）

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]#这个就嵌套
for alien in aliens:
print(alien）




pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese'],
}#这个也是嵌套
 print("You ordered a " + pizza['crust'] + "-crust pizza " +
"with the following toppings:")
 for topping in pizza['toppings']:
print("t" + topping)

学习了：如何定义字典，以及如何使用存储在字典中的信息；如何访问和修改字典中的元素，以及如何遍历字典中的所有信息；如何遍历字典中所有的键 - 值对、所有的键和所有的值；如何在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典。

第 7 章　用户输入和 while 循环

7.1 　函数 input()----函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后， Python 将其存储在一个变量中。

7.1.2 　使用 int() 来获取数值输入。int（x）x原本代表的是数字字符串，用了之后就转变成了数字类型了（不是字符串）。

7.1.3求模运算符 %(用来判断奇数偶数）

7.2while 循环。

就是给了一个条件（范围），让东西停止吧。主要因为那个范围不是给定的（就像那种完整的列表之类，可以用for来搞定）。一直运行到while后面的条件不满足为止。

prompt = "nTell me something, and I will repeat it back to you:"
prompt += "nEnter 'quit' to end the program. "
message = ""
while message != 'quit':
    message = input(prompt)
    print(message)

7.2.3使用标志 while X： x只需要等于true 作为是否进行的一个标志即可。

john="Tell me love me ,baby!"
john+="nif you do,let us make love."
active=True
while active:
      if message==" No!":
          active=False
      else:
           print(message)## False &True 要大写！

7.2.4 　使用 break 退出循环，有时候不方面确定明确的停止条件，就需要用break了。

prompt = "nPlease enter the name of a city you have visited:"
prompt += "n(Enter 'quit' when you are finished.) "
while True:
    city = input(prompt)
if city == 'quit':
    break
else:
    print("I'd love to go to " + city.title() + "!")

7.2.5 　在循环中使用 continue

要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用 continue 语句，它不像 break 语句那样不再执行余下的代码并退出整个循环。

.3.1 　在列表之间移动元素:创建一个空的列表，原本的用pop调出，append调入，加上while循环即可。

学习了：如何在程序中使用 input() 来让用户提供信息；如何处理文本和数字输入，以及如何使用 while 循环让程序按用户的要求不断地运行；多种控制 while循环流程的方式：设置活动标志、使用 break 语句以及使用 continue 语句；如何使用 while 循环在列表之间移动元素，以及如何从列表中删除所有包含特定值的元素；如何结合使用 while 循环和字典。

第八章 函数

函数是带名字的代码块，用于完成具体的工作。

8.1定义函数 —— def X（）：x为函数名（函数名不需要加引号哦，不是字符串！） 后面可以直接地调用函数名

8.1.2将函数信息传递进去——在8.1的基础上，在括号里面填入变量，后期使用的时候变量为什么都可以直接带入函数式。可以说 填入的那个变量是形参，而后面真正调用进去的是实参。

def greet_user(username):
""" 显示简单的问候语 """
print("Hello, " + username.title() + "!")
greet_user('jesse')#这里变量就是username

8.2传递实参

8.2.1位置实参——多个形参和实参位置顺序一一对应。

def greet_user(username,gender):
     print("Hello, " + username.title() +",you are a"+gender)
greet_user('jesse','girl')#实参还是需要考虑是不是要加引号的

8.2.2关键字实参——用关键字实参来调用 describe_pet() 顺序不重要了，因为在形参里面已经将其一一对应。

8.2.3默认值实参，在def的时候就给参数赋值，如果不声明，那就是默认参数为已经提前赋过值的。使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。这让 Python 依然能够正确地解读位置实参。(有explaination，但是记住比较好）有默认值的放在没有参数默认值的后面。

8.3 返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值。 用return函数 return+X

可以返回字典，字符串，列表........

8.4传递列表：列表包含的可能是名字、数字或更复杂的对象（如字典）。结合for对列表进行循环。

如果要修改列表：老生常谈，先建立新列表，然后旧的pop，新的append。当然，如果不想原列表修改，可以创建copy版本：切片表示法 [:] 创建列表的副本

print_models(unprinted_designs[:], completed_models)

8.5　传递任意数量的实参——将多个实参，用一个元组封装。（如果需要用位置实参，则把代表元组的那个形参放在最后位置)

8.6使用任意数量的关键字实参 :我们无法确认input会出现什么并且和什么一一对应时，我们可以将一个形参形式为字典。通过我们自己在那个字典中的键值对一一对应（for遍历），便可得到很好地信息。

def build_profile(first, last, **user_info):
""" 创建一个字典，其中包含我们知道的有关用户的一切 """
profile = {}
 profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items():
    profile[key] = value
return profile
user_profile = build_profile('albert', 'einstein',
location='princeton',
field='physics')
print(user_profile)      #这里的**user_info就是字典，加上我们用的for 在字典中的遍历，就可以得到完整消息。

8.6 　将函数存储在模块中 用import+函数名

8.6.2使用 as 给函数指定别名 from xxx import xx as xxx. import xxx as xxxx.

8.6.3使用星号（ * ）运算符可让 Python 导入模块中的所有函数(用的不多，如果是大模块函数，不得歇菜）

学习了：如何编写函数，以及如何传递实参，让函数能够访问完成其工作所需的信息；如何使用位置实参和关键字实参，以及如何接受任意数量的实参；显示输出的函数和返回值的函数；如何将函数同列表、字典、 if 语句和 while 循环结合起来使用。还知道了如何将函数存储在被称为 模块 的独立文件中。

第九章 类

编写类时，你定义一大类对象都有的通用行为。基于类创建 对象 时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。

类，就是对象。类里面构造成员变量和成员函数；函数想成是方法，变量想成属性。

9.1.1 　创建 Dog 类，给与这个特别的dog类特别的function——class x（）

class Dog():
 """ 一次模拟小狗的简单尝试 """
 def __init__(self, name, age):
""" 初始化属性 name 和 age"""
 self.name = name
self.age = age#这几步是必不可少的初始化过程！
 def sit(self):
""" 模拟小狗被命令时蹲下 """
print(self.name.title() + " is now sitting.")
def roll_over(self):
""" 模拟小狗被命令时打滚 """
print(self.name.title() + " rolled over!")

9.1.2 类中的函数都叫方法，普遍适用。（我目前的感觉好像如果没有必要创造类的话，可以直接创建函数，省去了很多麻烦）

方法 __init__() 定义成了包含三个形参： self 、 name 和 age 。在这个方法的定义中，形参 self 必不可少，还必须位于其他形参的前面。以 self 为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。

换句话说：self就是你一开始先创建了一个class，但是没有给具体的名字之前的统一名字，就像你在中国出生，你不知道叫什么名字，但是我可以喊你中国人。self是在为class编写instance method的时候，放在变量名的第一个位置的站位词。在具体的method中（class中的方法）可以不用self这个变量（def method（self）即可，在method里面都写self，方便后面出现了真的实例X后，可以直接调用）。

方法 __init__() 并未显式地包含 return 语句，但 Python 自动返回一个表示这条小狗的实例。我们将这个实例存储在变量 my_dog 中。给出实例后，后面需要调用方法，用实例.函数名（）即可。

class Dog():
--snip--
 my_dog = Dog('willie', 6)# my_dog就是实参
 print("My dog's name is " + my_dog.name.title() + ".")
 print("My dog is " + str(my_dog.age) + " years old.")

给属性和方法需要名字正常一点，方便能直接看出来方法是什么意思。

9.2给属性设定默认值（self.X=一个值）在self的时候这样给出，就相当于设定了默认值了。

9.3修改属性的值

方法一：直接访问实例，给他赋值：X=Y；

方法二：通过方法来修改：给出一个def方法，然后给这个方法中一个实参。

class Car():
--snip--
def update_odometer(self, mileage):
""" 将里程表读数设置为指定的值 """
self.odometer_reading = mileage
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
 my_new_car.update_odometer(23)
my_new_car.read_odometer()

方法三：通过方法对属性的值进行递增（一种新的代码方法，不是直接赋值，而是用x+=Y）不停的给方法输入不同的y来达到递增的效果。

9.3 继承

编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用 继承 。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类而新类称为子类 。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

class Car():
""" 一次模拟汽车的简单尝试 """
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name = str(self.year) + ' ' + self.make + ' ' + self.model
 return long_name.title()
def read_odometer(self):
print("This car has " + str(self.odometer_reading) + " miles on it.")
def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
def increment_odometer(self, miles):
self.odometer_reading += miles
 class ElectricCar(Car):
""" 电动汽车的独特之处 """
 def __init__(self, make, model, year):
""" 初始化父类的属性 """
 super().__init__(make, model, year)##这个函数很特殊，用init来调用父类的方法，注意，后面的参数不需要有self.
 my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

1.创建子类时，父类必须在子类的前面先创建好。

2.定义子类时，必须在括号内指定父类的名称。方法 __init__() 接受创建。

9.3.3 　给子类定义属性和方法——创建完子类后，在里面定义新的就好。但是不用写在init里面，init里面是之前父类的。

class Car():
--snip--
class ElectricCar(Car):
"""Represent aspects of a car, specific to electric vehicles."""
def __init__(self, make, model, year):
"""
电动汽车的独特之处
初始化父类的属性，再初始化电动汽车特有的属性
"""
super().__init__(make, model, year)
❶ self.battery_size = 70
❷ def describe_battery(self):#这里的self应该就是指新的electriccar的self吧
""" 打印一条描述电瓶容量的消息 """
print("This car has a " + str(self.battery_size) + "-kWh battery.")
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery(

9.3.4重写父类的方法：在子类中定义一个新的方法：方法名和父类要一样。

9.3.5将实例用作属性：

class Car():
--snip--
❶ class Battery():
""" 一次模拟电动汽车电瓶的简单尝试 """
❷ def __init__(self, battery_size=70):
""" 初始化电瓶的属性 """
self.battery_size = battery_size
❸ def describe_battery(self):
""" 打印一条描述电瓶容量的消息 """
print("This car has a " + str(self.battery_size) + "-kWh battery.")
class ElectricCar(Car):
""" 电动汽车的独特之处 """
def __init__(self, make, model, year):
"""
初始化父类的属性，再初始化电动汽车特有的属性
"""
super().__init__(make, model, year)
❹ self.battery = Battery()#NB！！这个特别关键，先创建一个electriccar属性self.battery，再将另一个类battery（）等于这个实例，从而electricacar类属性中就有了battery类了
my_tesla = ElectricCar('tesla', 'model s', 2016
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()#实参.类中类.类种类的方法

9.4 导入类 多了一句 from X（文件名）import（文件中的类）。很简单，不赘述。

本章学习：如何编写类；如何使用属性在类中存储信息，以及如何编写方法，以让类具备所需的行为；如何编写方法 __init__() ，以便根据类创建包含所需属性的实例。如何修改实例的属性 —— 包括直接修改以及通过方法进行修改。使用继承可简化相关类的创建工作；将一个类的实例用作另一个类的属性可让类更简洁。通过将类存储在模块中，并在需要使用这些类的文件中导入它们，可让项目组织有序。

至此，你掌握了编写组织有序而易于使用的程序所需的基本技能，该考虑让程序目标更明确、用途更大了。本文到此结束。