【学习随笔】python编程从入门到实践笔记整理汇总

rstrip（）确保字符串末尾没有空白符

lstrip（）确保字符串开头没有空白符

strip（）确保字符串两端没有空白符
language=' python '
language.lstrip()
language.rstrip()
language.strip()
#注意调用该函数返回值是修改后的串类型，language本身还是' python ',前后均有空白符

2.3.5 python2和python3的print

注意python3的print是函数，因此括号不可缺少如：print（message）

2.4数字

2.4.1整数

（1）支持 + - * / 运算

（2）**代表乘方运算

>>> 3**3

27

2.4.2浮点数

>>> 0.1+0.2

0.3
//结果包含的小数位数可能是不确定的，所有语言均有这个问题
>>>0.1+0.2  

0.30000000000000004

2.4.3 字符串转换函数（str）

将非字符串值转换为字符串如 (int )num=23 str(num) 转成"23"

2.4.4 python整数取整，保留小数用浮点数

整数计算中，取整，小数删除

想保留小数，用浮点数计算
>>>3/2
1
>>>3.0/2
1.5
>>>3/2.0
1.5
>>>3.0/2.0
1.5

2.5 python注释用#

3列表简介

3.1列表是什么

个人感觉就是一个vector+栈两个功能的集合体

bicycles=['trek','cannondale','specialized']
print(bicycles)
#/结果显示
['trek','cannondale','specialized']
列表定义：列表由一系列按特定顺序排列的元素组成。python中用 [ ] 表示

3.1.1 列表访问元素（依靠下标）

print(bicycles[0])
结果显示：trek，不带 [ ] 与 ' '

3.1.2 列表索引从0开始而不是1

3.1.2 列表索引特殊语法（负数下标）

bicycles=['trek','cannondale','specialized']
print(bicycles[-1])
特殊语法：-1，python返回最后一个列表元素，-2返回倒数第二个列表元素，依次类推

3.1.3 通过索引使用列表各个值

bicycles[0]
bicycles[1]
可以像使用其他变量一样使用列表的各个值

3.2 列表修改、添加和删除元素

创建的大多数列表都是动态的

3.2.1 修改列表元素（利用索引）

bicycles[0]='ducati'
修改列表元素的语法与访问列表元素的语法类似

3.2.2 在列表中添加元素(append、insert)

bicycles=['trek','cannondale','specialized']
bicycles.append('ducati')
append函数将元素添加到了列表末尾
bicycles.insert(1,'cucati')
insert可在列表的任何位置添加新元素，指明索引和值。且插入处后面的每个元素都要右移一个位置！

3.2.3 从列表中删除元素(del、pop、remove)

bicycles=['trek','cannondale','specialized']
del bicycles[1] # cannondale被移除
1.使用del需要知道删除的元素在列表中的位置
>>>bicycles=['trek','cannondale','specialized']
>>>pop_bicycle=bicycles.pop() 
>>>pop_bicycle       #此时pop_bicycle值为specialized
specialized
2.使用pop，列表就像栈，列表的最后一个元素就是栈顶元素
bicycles=['trek','cannondale','specialized']
pop_bicycle=bicycles.pop(2) #此时 pop_bicycle值为cannondale
3.其实pop可以pop任何位置的元素，只需要指定索引位置。这和栈又有点区别
bicycles.remove('ducati')
4.remove 是不知道删除值在列表中的位置使用，且此函数只删除第一个值，也就是说若要删除所有值为‘ducati’应配合循环

总结：

del和pop的区别：看是否需要继续用删除值，不需要就del，需要就pop

remove和del、pop的区别：看是否知道删除值的位置，知道del、pop，不知道remove

书中的一个解释

书中说：remove删除后也可以继续使用？？？WTF？？？
bicycles=['trek','ducati','cannondale','specialized']
expensive='ducati'
bicycles.remove('ducati')
print(bicycles)  #里面没了ducati
print('可以使用变量'+ expensive +'看到了吗？') #ducati变量可以继续使用
搞不懂好吧，你不对劲！我是傻子还是作者是傻子，expensive和bicycle有关系吗？鸟的关系啊

3.3组织列表

创建列表，元素的排列顺序常常无法预测

3.3.1 列表排序(sort、sorted)

bicycles=['audi','ducati','cannondale','specialized']
bicycles.sort()
# bicycles结果：['audi','cannondale','ducati','specialized']
bicycles.sort(reverse=True)
# bicycles结果：['specialized','ducati','cannondale','audi']
sort是字母性质的永久性排序，即按照字母顺序排序，且对列表会产生修改。

字母逆序，参数传入reverse=True

备注：仅针对小写字母，大写字母需要指定排列顺序
bicycles=['audi','ducati','cannondale','specialized']
print(sorted(bicycles))
# bicycles结果：['audi','ducati','cannondale','specialized']
# 输出结果：['audi','cannondale','ducati','specialized']
sorted临时排序，列表还是保留原来的顺序

总结：sort对列表永久排序，sorted对列表临时排序

3.3.3 逆序列表(reverse)

bicycles=['audi','ducati','cannondale','specialized']
bicycles.reverse()
reverse永久性修改列表的排列顺序

3.3.4 列表长度(len)

bicycles=['audi','ducati','cannondale','specialized']
len(bicycles) #  4

python 计算长度从1开始

3.4 列表索引错误总结

1.索引越界 IndexError ：list index out of range

2.访问最后列表元素使用索引-1，任何情况下都有效，即便其长度发生变化

当且仅当列表为空，此访问方式出错

4.操作列表

4.1遍历列表

bicycles=['audi','ducati','cannondale','specialized']
for  bicycle  in bicycles:
    print(bicycle)
解释：for循环，从bicycles中取出一个值，存入bicycle，然后打印

4.1.1 深入研究循环（缩进内为一个块）

for  bicycle  in bicycles:
1.首先对列表的每个元素都执行循环指定步骤，若列表有一百万元素，则执行一百万次
bicycles=['audi','ducati','cannondale','specialized']
for  bicycle  in bicycles:
    print("hello")
    print(bicycle.title()) # Audi
    print(bicycle.upper()) # AUDI
print("This is End"+bicycle.upper())  #SPECIALIZED
2.缩进内为同一块，执行循环N次，未缩进为另一块区，只执行一次

4.2避免缩进错误

4.2.1 忘记缩进 / 不必要的缩进 / 循环后不必要的缩进

1.IndentationError：expected an indented block

2.产生逻辑错误 //忘记缩进

1.IndentationError：unexpected indent //不必要的缩进

1.逻辑错误 //循环后不必要的缩进

4.2.2 遗忘了冒号(：)

导致语法错误，且难以发现

4.3创建数值列表

4.31 生成一系列的数字（range）

for value in range(1,5):
    print(value)
#其中range可以指定步长
for value in range(1,10,2):  #步长2
#结果1 3 5 7 9

#打印结果
1
2
3
4

#结果不会打印5

4.3.2用range创建列表(list、range)

numbers=list(range(1,6))
print(numbers)
#结果如下
[1,2,3,4,5]
用list()将range()的结果直接转换成列表

4.3.3对数字执行简单统计（max、min、sum）

>>>digits=[1,2,3,4,5,6,7,8,9,0]
>>min(digits)
0
>>>max(digits)
9
>>>sum(digits)
45

简单的函数调用演示

4.3.4列表解析（一行代码生成列表）

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

#结果如下
[1,4,9,16,25,36,49,64,81,100]

value**2 代表平方

4.4使用部分列表

处理列表的部分元素——python称为切片

4.4.1切片

bicycles=['trek','cannondale','specialized','michael','eli']
print(bicycles[0:3])

#结果如下
['trek','cannondale','specialized','michael']

eli没有被输出，重要一点在于切片是原bicycles的一个副本copy

切片的4种表达方式

1.bicycles[0:3]    提取下标0-3元素

2.bicycles[:3]     提取下标从起始点0-3的元素

3.bicycles[2:]     提取下标从2-末尾的元素

4bicycles[-3:]     提取下标最后3个元素

最后一种需要重点了解

4.4.2遍历切片

4.4.3复制列表

复制列表可以创建一个整个列表的切片
bicycles=['trek','cannondale','specialized','michael','eli']
bicycles_too=bicycles[:]    #起始点到终止点
备注：对bicycles_too的修改不会影响bicycles，同样对bicycles修改也不会影响bicycles_too，故这是一个副本拷贝，而不是一个关联
bicycles_too=bicycles
#这是关联，可以看成引用，修改任意一个，另一个收到影响

4.5元组

不能修改的值称为不可变的，而列表可以修改，为了满足列表中值不能修改需要，创造出了元组。

简单来说元组就是一个列表，但是其中的值不可以修改

4.5.1定义元组

元组跟列表的不同之处在于，使用圆括号而不是方括号来标识
#列表
dimensions_too=[1,4,3,5,6]
#元组
dimensions=(1,4,3,5,6)
#使用依旧同列表，利用下标
print(dimensions[0])
当尝试修改元组的元素时
>>>dimensions[0]=2
TypeError: 'tuple' object not support item assignment
显示出错，不允许修改

4.5.3修改元组变量

虽然不能修改元组的元素，但竟然可以给存储元组的变量赋值
dimensions=(1,4,3,5,6)
#修改元素，错误
dimensions[0]=10
#给变量赋值,正确
dimensions=(3,4,5)
变量赋值合法，修改元素非法，好家伙，房子不给人装修，竟然可以拆了重盖

5 if 语句

if 语句的核心就是True 或者 False的表达式，这种表达式称为条件测试

5.1 条件测试

5.1.1 检查字母考虑大小写，数字比较

python中 if 语句检查区分字母大小写

布尔表达式要么 True 要么 False
>>> age = 10
>>> age < 21
True
>>> age <= 21
True
>>> age > 21
False
>>> age >=21
False
#支持数学符号 =、!=、>、<、<=、>=

5.1.2 检查多个条件(and、or)

>>>A and B  # AB均为true才true，否则false
False
>>>A or B   # AB有一个为true则为true
True

逻辑运算

5.1.3检查特定值是否包含在列表中(in、not in)

>>>bicycles=['trek','cannondale','specialized','michael','eli']
>>>'trek' in bicycles
True
>>>'eell' in bicycles
False

bicycles=['trek','cannondale','specialized','michael','eli']
bicycle='TREKL'
if bicycle in bicycles
    print("IN")
if bicycle not in bicycles
    print("NOT IN")

# in 和 not in 两种写法

5.2 if 语句

5.2.1 简单的 if 语句 / if-else 语句 / if-else if-else 语句

切记冒号：
age=19
if age>18 :
    print("Older")
#简单的 if 语句
age=19
if age>18 :
    print("Older")
else  :
    print("Younger")
# if-else 语句
age=19
if age<18 :
    print("Children")
else if age<30 :
    print("Younger")
else :
    print("Older")
# if - else if -else

# 多个else if

# 省略else

5.2.2 确定列表不是空的 ( if )

numbers=[]
if numbers :
    print("empty")
# 直接名称判断

6字典

字典是一系列的键-值对，每个键都和一个值相关联。——其实也就相当于C++ map<key,value>，但由又有点区别

6.1 字典使用 / 访问字典中的值

区别：C++ map<string,string>m 确实可以存color:green 但是points：5（map<string,int>）二者混合了
alien_0={'color':'grenn','points':5}     #使用字典
print(alien_0['color'])    #访问字典
print(alien_0['points'])
#输出结果
green
5
# 要获取与键相关联的值，可依次指定字典名和放在方括号内的键，如print(alien_0['color'])

6.1.1 创建空字典 / 字典中添加键值对 / 修改字典中的值

字典是一种动态结构，可随时添加键值对，也可随意修改
alien_1={} #初始化空字典
alien_0={'color':'grenn','points':5}     #初始化
alien_0['x_point']=0     #动态添加
alien_0['x_point']=25    #修改键值对中的值

6.1.2删除键值对( del )

alien_0={'color':'grenn','points':5}  
print(alien_0)
del alien_0['points']
print(alien_0)
#结果如下
{'color':'grenn','points':5}  
{'color':'grenn'}
对于字典中不在需要的信息，使用 del 语句将相应键值对彻底删除

6.2遍历字典

6.2.1 遍历所有的键值对（items）

alien_0={'color':'grenn','points':5} 
for  key,value  in  alien_0.items()
    print('Key'+key)
    print('value'+value)
注意：即便遍历字典时，键值对的返回顺序也与存储顺序不同，python不关心键值对的存储顺序，而只追踪键值之间的关联关系

6.2.2遍历字典中的所有键（keys）/ 判断某键是否在字典中 (in / not in)

alien_0={'color':'grenn','points':5} 
for  key in  alien_0.keys()
    print(key.title())
for  key in  alien_0    #二者等价
     print(key.title())
在不需要使用字典中的值时，方法keys（）很有用

遍历字典时，会默认遍历所有的键，因此上述代码中的二者等价，输出不变
if 'erin' in  alien_0.key()    #在
    print('Y')
if 'erin' not in alien_0.key()    #不在
    print('N')
事实上，key返回的是一个列表，其中包含了字典中的所有键

6.2.3按顺序遍历字典中的所有键（sorted）

字典记录键和值之间的关联关系，但获取字典元素时，获取顺序是不可预测的。

以特定的顺序返回元素，在for循环中对返回的键进行排序
for name in sorted(alien_0.key())
    print(name)
思想：在遍历前对key列表进行排序

6.2.4遍历字典中的所有值（values）/ 并剔除重复项 (set)

for value in alien_0.values()
    print(value)
values返回一个值列表，而不包含任何键

缺点：值可以重复，因此提取的值未剔除重复项
for value  in set(elien_0.values())
    print(value)
解决方案：set中每个元素必须独一无二，因此对包含所有值元素的列表调用set

6.3嵌套

将一系列字典存储在列表中，或将列表作为值存储在字典中，称为嵌套

6.3.1字典列表（类似vector<map<string,string>>）

alien_0={'color':'grenn','points':5}  
alien_1={'color':'red','points':4}  
alien_2={'color':'yellow','points':3}  
aliens=[alien_0,alien_1,alien_2]

将字典都放到一个名为aliens的列表中

6.3.2 在字典中嵌套列表(类似map<string,vector<string>>)

pizza-{
    'crust':'thick',
    'toppings':['mushrooms','extra cheesse']
}
每当需要字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表

6.3.3在字典中嵌套字典（类似map<string,map<string,string>>）

users={
    '张三':{    
         '原来住':'江苏省某市'   
         '现在住':'山东省某市'
    },
    '李四':{
         '原来住':'陕西省某市'   
         '现在住':'山西省某市'
    }
}
张三类似第一个string，（原来住，现在住）对应map<string,string>里面的元素

6.4关于列表，元组，字典总结（[]、（）、{}）

[ ] 列表

( ) 元组

{ } 字典

7用户输入和while循环

7.1用户输入

函数input（）让程序暂停运行，等待用户输入一些文本。获取用户输入后，python将其存储在一个变量中，以供使用

7.1.1 输入函数(input）

>>>age=input("How old are you ?")
How old are you ? 21
>>>age
21
使用input输入，python解读为字符串，参数为提示符

7.1.2 数字字符串转换数字函数(int)

>>>age=input("How old are you ?")
How old are you ? 21
>>>age=int(age)
>>>age>18
True

若不int转换，直接比较会出错

TypeError:unorderable types:str()>=int()

7.1.3 求模运算符（%）

7.2while循环简介

7.2.1while使用 / break / continue

i=1
while i<5 :
    print(i)
    i+=1
break终止循环，continue终止本次循环，进入下一次循环

循环必须有停止的途径，防止无限循环

7.3使用while循环处理列表和字典

for循环中不能修改列表，否则导致python难以跟踪其中元素，若在遍历的同时对其修改，可使用while

7.3.1在列表间移动元素

confirmed_users=[]
unconfirmed_users=['a','b','c']
while unconfirmed_users :
    current_user=unconfirmed_users.pop()
    print(current_user)
    confirmed_users.append(current_user)
#结果遍历检查元素，unconfirmed_users变成空表

缺点：做个检查修改了原来的unconfirmed_users 列表，因此可以通过副本来做 unconfirmed_users_too=unconfirmed_users[ : ]

7.3.2删除包含特定值的所有列表元素 (remove)

users=['b','a','b','c','b']
while 'b' in users:
    users.remove('b')
通过while检查，remove移除实现

8函数

8.1定义函数

def user():
    """ 文档字符串，描述函数功能 """
    print('hello')

user()
user 函数名，冒号后面为函数体，三个双引号"""部分为文档字符串，user()为函数调用

8.1.1向函数传递参数(形参、实参)

def user(username='Admin'): 
    """ 显示问候 """
    print('hello '+username)
user()           # hello Admin
user('jake')     # hello jake
username 形参，函数调用时候输入的'jake'实参 ,其中形参给了默认值

8.2传递实参

函数传递实参方式很多

位置实参：要求实参顺序与形参顺序相同

关键字实参：每个实参都有变量名和值组成

使用列表和字典等

8.2.1位置实参

def login(username,userpassword):
    """登录密码检查"""
    if username=='Admin' and userpassword=='123'
        print('True')
    else
        print('False')
login('admin','123') # 实参顺序和形参顺序一致
python函数调用每个实参都关联到函数定义中的一个形参，此关联方式基于实参的顺序，故被称为位置实参

8.2.2关键字实参

def login(username,userpassword):
    """登录密码检查"""
    if username=='Admin' and userpassword=='123'
        print('True')
    else
        print('False')
login(username='admin',userpassword='123') # 准确指定函数定义中的形参名

关键字实参是传递给函数的名称-值对，直接在实参中将名称和值关联起来了

8.3返回值

函数返回的值被称为返回值

8.3.1返回简单值

def Hi(first_name,last_name) :
    """返回整洁的名字"""
    full_name=first_name+' '+last_name
    return full_name     #返回值

8.3.2返回字典

def build_person(first_name,last_name):
    """存储名字"""
    person={'first':first_name,'last':last_name}
    return person    #返回字典
#函数可返回任何类型的值，包括列表和字典等较复杂的数据结构

8.4传递列表

8.4.1向函数中传递列表

def greet_users(names):
    """输出列表中的名字"""
    for name in names:
        print(name)

#向函数中传递列表很有用

8.4.2在函数中修改列表

check_names={}
uncheck_names={'aa','bb','cc'}
def print_model(check_names,uncheck_names):
    """检查名字输出"""
    current_name=uncheck_names.pop()
    print(current_name)
    check_names.append(current_name)
print_model(check_names,uncheck_names)

缺点：检查名字的模块竟然修改了传递的数据集check_names和uncheck_names

8.4.3避免在函数中修改列表 ( 利用切片 )

check_names={}
uncheck_names={'aa','bb','cc'}
def print_model(check_names,uncheck_names):
    """检查名字输出"""
    current_name=uncheck_names.pop()
    print(current_name)
    check_names.append(current_name)
print_model(check_names,uncheck_names[:]) #切片
解决方案：向函数传递列表的副本而不是原件，这样函数的任何修改都只影响副本，不影响原件。（切片表示法 [ : ] 创建列表的副本）

8.5传递任意数量的实参

形参*argv，不管调用语句提供多少个实参，这个形参都接受。

其实*argv中的*是创建了一个名为argv的空元组，并将所接收到的参数都放入元组内

def make_pizza(*toppings):
    """打印顾客配料"""
    print(toppings)
make_pizza('pepperoni')
make_pizza('pepperoni','green peppers','extra cheese')

# 一个参数和多个参数均可以传

8.5.1结合使用位置实参和任意数量实参

def make_pizza(size,*toppings):
    """打印顾客配料"""
    print(size+'配料:'+toppings)
make_pizza(12,'pepperoni')
make_pizza(16,'pepperoni','green peppers','extra cheese')
注意：如果想让函数接收不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后

8.5.2使用任意数量的关键字实参

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
use_profile=build_profile('alber','einstein',location='princeton',field='physics')
print(use_profile)

形参**user_info的**是让python创建一个名为user_info的字典，并将收到的所有名称-值对都封装到字典中

8.6将函数存储在模块中

将函数存储在被称为模块的独立文件中，再利用import将模块导入主程序中

8.6.1 导入整个模块（ import ）

import make_pizza
创建模块，只让.py的文件中含有make_pizza

8.6.2 导入特定的函数（ from XX import XX）

from model_name import function_name
从模块中导入函数

8.6.3 使用as给函数指定别名/ 使用as给模块指定别名

from pizza import make_pizza as mp

import pizza as p
取别名，避免导入的函数名称与程序中现有的名称冲突。或者名称太长，指定简短而独一无二的别名

8.6.4 导入模块中的所有函数

from pizza import *
注意：（1）* 号运算符可让python导入模块中的所有函数

（2）并非自己编写的大型模块，最好不要采用这种导入方法

原因：a. 模块中的函数名称可能与自己项目中使用名称相同冲突

b.python遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入

建议：要么只导入需要使用的函数，要么导入整个模块并使用句点表示法

9类

9.1创建使用类

9.1.1创建dog类（init，self）

class dog():
    """模拟小狗"""
    def _init_(self,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 !')
1. 方法_init_( ):类中的函数称为方法，此方法每当dog类创建新实例时，python会自动运行 ( 类似构造函数 )

2. self : self必不可少，还必须位于其他形参前面，它是一个指向实例本身的引用

9.1.2 根据类创建实例（句点表示法——访问属性/调用方法）

my_dog=dog('willie',6)
print('dog age is'+ str( my_dog.age )+'years old')
1.访问属性：句点表示法 my_dog.age

2.调用方法：句点表示法 my_dog.sit ( )

9.1.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):
        --snip--
类中每个属性都必须要有初始值，哪怕这个值是0或者空字符串，设置默认值在_init_内指定是可行的

9.1.4 修改属性的值 ( 直接/方法/通过方法对属性值递增)

1.直接修改属性的值

my_car.odometer_reading=23

2.通过方法修改属性的值

def update_odometer(self,mileage):
    """将里程表读数设置为指定的值"""
    self.odometer_raading=mileage

3.通过方法对属性的值递增

def update_odometer(self,mileage):
    """将里程表读数设置为指定的值"""
    self.odometer_raading += mileage    #递增

9.2继承

编写的类是另一个现成类的特殊版本，可使用继承.

一个类继承另一个类时，原有的类称为父类，而新类称为子类。子类继承其父类的所有属性和方法，同时还可以定义自己的属性和方法

9.3.1子类的方法_init_()

创建子类的实例时，python需要给父类的所有属性赋值，因此子类的方法_init_()需要父类——super实现

class Car():
    """模拟汽车的简单尝试"""
    def _init_(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.odometer_raading=0
    def get_descriptive_name(self):
        --snip--
    def update_odometer(self,mileage):
        --snip--

class ElectricCar(Car):
    """电动车独特之处"""
    def _init_(self,make,model,year):
        """初始化父类的属性"""
        super._init_(make,model,year)    #super方法实现

my_tesla=ElectricCar('tesla','model s','2016')

#子类的方法_init_()需要给父类的所有属性赋值父类——super实现

9.3.2给子类定义属性和方法

import Car

class ElectricCar(Car):
    """电动车独特之处"""
    def _init_(self,make,model,year):
        """初始化父类的属性"""
        super._init_(make,model,year)    #super方法实现
        self.battery_size=70

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print(str(self.battery_size))

#属性定义在_init_中，方法直接写在类中

9.3.3重写父类的方法

对于父类的方法，只要它不符合子类模拟实物的行为，都可以对其进行重写，在子类中定义一个方法，与父类的方法同名。python将不会考虑这个父类方法，而只关注你在子类定义的相应方法

注意：使用继承时，可让子类保留从父类哪里继承而来的精华，剔除糟粕

9.4导入类

python允许你将类存储在模块中，然后在主程序中导入所需的模块

9.4.1导入单个类

from car import Car    #导入单类

from car import Car,ElectricCar     #导入多类
# 解释从car.py模块中导入Car类

解释：（1）导入类是一种有效的编程方式。

（2）主程序文件变得简洁，程序员可以专注与主程序的高级逻辑部分
"""一个可用于表示汽车的类"""    

class Car():
    """模拟汽车的简单尝试"""
    def _init_(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.odometer_raading=0
    def get_descriptive_name(self):
        --snip--
    def update_odometer(self,mileage):
        --snip--

class ElectricCar(Car):
    """电动车独特之处"""
    def _init_(self,make,model,year):
        """初始化父类的属性"""
        super._init_(make,model,year)    #super方法实现
注意：（1）应该为每一个创建的模块都编写文档字符串。如本类中的"""一个可用于表示汽车的类"""

（2）同一个模块中的类应存在某种关系，但是可根据需要在一个模块中存储任意数量的类