Python3.x基础总结

虽然不是边学边记，但是什么时候开始都不算晚，不妨从现在开始，借着整理Python的机会，培养一下做笔记的习惯，更是磨练自己的韧性、毅力。

近来由于人工智能和深度学习越来越火爆，加之这门语言所提供的完全面向对象模式编程以及大量的第三方库，使得懂得如何使用Python几乎成为必备技能。

Python基础入门一共用了一个月的时间，其中包括Python基础以及面向对象基础，每天也就是学习2个小时，这样看来，学习时间应该能够进一步缩短到半月左右或更少（时间才是最珍贵的资源！！） 。

由于只是简单的整理备忘，不能具体到每个细节，只是整理一个大概罢了。

注意 python用来区分每条代码的是缩进，即空白符的个数，所以，合理的缩进是保证python程序可以正常运行的基础！！

首先是 数据类型， Python不同于其他语言，它自动为数据确定类型，比如

a=1
b=1.5
c=‘abc’
d=‘man’
print(type(a))
print(type(b))
print(type(c))
print(type(d))

代码中并没有明确为每个变量指定数据类型，但是python会自动为我们确定。

Python中可以使用input方法获取用户的输入，如：

#使用input函数获取用户输入
a=input(“请输入内容：”)
print(a)
print(type(a))
#input函数得到的数据都是字符串（str)

与C语言类似，Python也拥有强制转换数据类型的功能，如：

a=input(“请输入密码：”)
print(a)
print(type(a))
int(a)
print(type(a))

Python中提供了对字符串进行类数学运算的功能：

#加号拼接字符串
first_name=‘三’
last_name=‘张’
print(first_name+last_name)print(last_name+first_name)
#乘号重复字符串
print(first_name*10)
print(last_name*10)
#加号和乘号连用
print((first_name+last_name)*10)

同样的，可以对print方法使用格式化输出：

#与C语言类似
name=input(“请输入名字：”)
print(‘Welcome! %s’ %name)
score=1
print(‘%06d’ %score)  #控制输出宽度,不足补0
k=1.010021
print(‘%.3f’ %k)   #控制输出精度
print('%.2f%%' %k)  #输出百分号

Python中的逻辑运算符：

#与C语言不同，Python中的或用or来表示 而与用and来表示
#判断输入的整型数据是否在100-200之间或者300-400之间（包括两端）
#如果是 则输出YES 否则输出NO
a=int(input('请输入一个整数：'))
#if a>=100 and a<=200:    
#    print('YES')
#elif a>=300 and a<=400:    
#    print('YES')
#else:    
#    print('NO')
if (a>=100 and a<=200) or (a>=300 and a<=400): #组合写法   
    print('YES')
else:    
    print('NO') |

Python中的按位运算与C语言中相同，这里不再赘述。

之后是3大编程结构—顺序、分支、和循环。

顺序结构这里不谈

分支结构， 与C语言类似，可以使用if语句进行条件判断进而控制程序执行流程。

举例：

# 定义一个整型记录年龄
# 如果年龄大于等于18岁 输出'可以进入网吧嗨皮'
# 否则输出'未满十八周岁，不能进入网吧嗨皮'
age = int(input('请输入你的年龄：'))
if age >= 18:    
    print('可以进入网吧嗨皮')
else:    
    print('未满十八周岁，不能进入网吧嗨皮') |

If的嵌套：

#if语句的嵌套
#定义布尔类型变量has_ticket表示是否有车票
#定义int型变量knife_length表示刀的长度
#首先检查是否有车票，如果有才继续安检 否则输出'无票'
#安检检查是否有刀，如果没有，输出'通过'
#否则检查刀的长度，如果超过20cm，输出'刀太长，不能上车'
has_ticket = True
has_knife = True
knife_length = 50
if has_ticket == True:    
    if has_knife == False:        
        print("PASS")    
    elif has_knife == True:        
        if knife_length <=20:            
            print("PASS")        
        else:            
            print("knife too long!")
    elif has_ticket == False:    
        print("NO TICKET!") |

循环结构 ，python中明确定义的循环只有一种：while循环

# 用 while 打印5次 HELLO PYTHON
i = 0
while i < 5:    
    print("HELLO PYTHON")    
    i += 1 |

#利用循环计算 0-100 的累加和
i = 0
sum = 0
while i <= 100:    
    sum += i    
    i += 1
print("0~100的累加和为：%d" % sum)

下面是OJ常见题目— 打印图形

#利用循环嵌套打印菱形
n = int(input("请输入行数："))
a = n//2
i = -a
j = -a
while i <= a:    
    j = -a    
    while j <= a:        
        if abs(i)+abs(j) > n//2:            
            print(" ", end="")            
            j += 1        
        if abs(i)+abs(j) <= n//2:            
            print("\*", end="")            
            j += 1    
        print("")    
        i += 1

#利用循环嵌套打印阶梯
# Python提供了字符串的计算
n = int(input("请输入行数："))
i = 1
j = 1
ch = '*'
while i <= n:    
    while j <= i:        
        print("%s" % ch\*j, end="")        
        j += 1    
    print("")    
    i += 1

Python 打印九九乘法表：

i = 1
j = 1
while i <= 9:   
    j = 1    
    while j <= i:        
        print("%d * %d = %d" %(j, i, i*j), end="\t")        
        j += 1    
    print("")    
    i += 1

三大结构之后便是 函数 了：

Python中使用def关键字来定义函数，首先是无参数的函数，如：

# 封装2个函数 say_hello 和 say_bye
# 并调用这两个函数
def say_hello():    
    print("Hello World!")    
    print("Hello Python!")        
def say_bye():   
    print("Bye!")
say_hello()
say_bye()

接着是有参数的函数，如：

# 定义函数，对输入的整数判断是奇数还是偶数
# 若是奇数，则输出'奇数' 否则输出 '偶数'
def check(a):    
    if a % 2 == 0:        
        return '偶数'   
    else:        
        return '奇数'
k = int(input("请输入一个整数："))
print("%s" % check(k))

Python中函数可以一次接受多个参数 使用 *args 使函数接受一个元组

使用 *kwargs 使函数接受一个字典。

函数的递归 ，与C语言类似 。

# 函数的递归
# 递归求斐波那契数列
def f(i):    
    if i == 0 or i == 1:        
        return 1    
    else:        
        return f(i - 2) + f(i - 1)

k = int(input("请输入一个整数："))
for i in range(k):    
    print(f(i))

函数可以一次返回多个数据

def temwet():  # 此函数想要同时返回tem和wet    
    print("开始测量温度和湿度.....")    
    tem = 30    
    wet = 70    
    print("测量结束！")    
    return (tem, wet)  # 此处使用元组返回结果
gl_tem, gl_wet = temwet()
print("%d %d" % (gl_tem, gl_wet)) |

基本数据类型python与C语言类似，但是python拥有独特的数据结构：元组，列表，字典以及集合（集合并不常用，这里不去整理）。

元组， 使用一对小括号来定义：

# 元组使用小括号创建，且一旦创建就不能修改
# 元组多数用来存储不同类型的变量
t = (1, 2, 3, '123')
print(t)
t2 = (1)  # t2不是一个元组 而是int
print(type(t2))
t3 = (1,)  # 只包含一个元素的元组
print(type(t3))
li = list(t)      # 列表和元组之间的转换
print(li)
k = tuple(li)
print(k)

再次强调：元组一旦定义就无法修改！！

下面是 列表 ，列表可以说是python中最为常用的高级数据结构，它相当于C语言中的数组，但是它所提供的方法比C语言更为丰富。

列表使用一对中括号来定义，可以定义包含元组的列表。

# list:列表--Python中的高级数据类型之一 是使用最为频繁的数据类型
# 类似C语言中的数组
name = ['张三', '李四', '王五', '赵六']  
# 循环遍历列表
i = 0
while i < len(name):    
    print("%s" % name[i])    
    i += 1
#—————————————————————————————#
s = [10, 20, 75, 50, 556, 74, 66, 20, 33, 0]
print(s)              # 直接打印列表
print("%d" % len(s))  # 打印列表的长度
s.reverse()           # 列表逆序
print(s)s.sort()              # 升序排列
print(s)s.sort(reverse=True)  # 降序排序
print(s)
print(s.count(20))    # 求一个元素出现的次数print(s.index(20))    # 求一个元素的下标

向列表中增加数据：

# 向列表中增加元素的3种方法
# append—追加
# insert—插入
# extend—扩展（把另一个列表中的元素扩展到当前列表
s = [1, 2, 3, 4, 5, 7, 8, 9]  # 少了6和10
s.append(10)  # 追加一个10
print(s)
s.insert(5, 6)  # 在下标5处插入一个6
print(s)
new = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]  # 有一个新的列表 想要把它添加到s中
s.extend(new)  # 使用列表扩展函数
print(s)

从列表中删除数据：

# 从列表中删除元素
# remove—删除一个完全指定的元素（第一次出现的）
# pop—弹出，默认弹出最后一个元素并返回，可以按索引删除元素
# clear—清空，清空列表中所有的元素
# del关键字—从内存中删除一个变量
s = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(s)
s.remove(7)
print(s)
s.pop()
print(s)
s.pop(2)
print(s)
del s[0]  # 注意 del 是一个关键字，而不是列表的方法，它也可以用在如整型上面
print(s)
s.clear()
print(s)

下面是Python中一个非常重要且常用的功能 ：遍历

使用for关键字对列表进行遍历：

# 使用 for 关键字对列表进行迭代遍历
s = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in s:    
    print("%d" % i)

For的语法很固定，但是可以结合多种数据结构来达到强大的效果，如结合range来得到自然数队列等。

接着便是 字典 ，字典提供了独特的"键值对"的概念，相当于可以自定义下标的列表，但是注意，字典是无序的。

# 字典是除列表外 最灵活的数据类型
# 列表通常用来存储有序的数据集合 字典通常用来存储无序的数据集合
# 字典使用一对大括号定义
dic = {1: 'Hello', 2: 'Python', 3: '!'}
dic2 = {'hight': 1.75}
print(dic)
print("%s %s%s" % (dic[1], dic[2], dic[3]))  # 取值
dic[4] = 'YES'   # 添加元素
print(dic)
dic.pop(4)  # 删除元素
print(dic)
dic[3] = '!!!'  # 修改元素
print(dic)
print(len(dic))  # 统计键值对数量
dic.update(dic2) # 合并字典 如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
print(dic)
dic.clear()      # 清空字典
print(dic)

当然，字典也可以使用for关键字来迭代

# 使用 for 关键字 循环遍历字典
dic = {'name': '小明', 'age': '18', 'hight': '1.75'}
for k in dic:    
    print("%s : %s" % (k, dic[k]))

注意，这里的输出和定义的顺序并不一致，这也体现了字典的无序性。

案例：猜拳游戏

# 利用高级数据类型优化游戏
import random  # 导入随机数模块
player = int(input("请输入 1石头 2剪刀 3布"))
computer = random.randint(1, 3)
game = {1: '石头', 2: '剪刀', 3: '布'}
print("玩家出了%s,电脑出了%s" % (game[player], game[computer]))
if player == computer:    
    print("平局！")
elif (player == 1 and computer == 3) or (player == 2 and computer == 1) or (player == 3 and computer == 2):    
    print("玩家失败，电脑获胜")
else:    
    print("玩家胜利，电脑失败")

数据类型就整理到这里，接下来是 字符串的操作 。

注意：字符串是不可改变的对象，它一旦定义就无法改变。

Python针对字符串提供了大量的方法，使得对字符串的操作十分灵活。

字符串格式的控制：居中

# 使用字符串函数对字符串进行操作
poem = ["登鹳雀楼",        "王之涣",        "白日依山尽",        "黄河入海流",        "欲穷千里目",        "更上一层楼"]
for i in poem:    
    print("|%s|" % i.center(10, "　"))

1、去空格及特殊符号

代码如下:

s.strip().lstrip().rstrip(',')

2、复制字符 串

代码如下:

#strcpy(sStr1,sStr2)
sStr1 = 'strcpy'
sStr2 = sStr1
sStr1 = 'strcpy2'
print sStr2

3、连接字符 串

代码如下:

#strcat(sStr1,sStr2)
sStr1 = 'strcat'
sStr2 = 'append'
sStr1 += sStr2
print sStr1

4、查找字 符

代码如下:

#strchr(sStr1,sStr2).

#< 0 为未找到.
sStr1 = 'strchr'
sStr2 = 's'
nPos = sStr1.index(sStr2).
print nPos.

5、比较字符 串

代码如下:

#strcmp(sStr1,sStr2).
sStr1 = 'strchr'
sStr2 = 'strch'
print cmp(sStr1,sStr2).

6、扫描字符串是否包含指定的字 符

代码如下:

#strspn(sStr1,sStr2).
sStr1 = '12345678'
sStr2 = '456'

#sStr1 and chars both in sStr1 and sStr2.
print len(sStr1 and sStr2).

7、字符串长 度

代码如下:

#strlen(sStr1).
sStr1 = 'strlen'
print len(sStr1).

8、将字符串中的大小写转 换

代码如下:

S.lower() #小写.
S.upper() #大写.
S.swapcase() #大小写互换.
S.capitalize() #首字母大写.
String.capwords(S) #这是模块中的方法。它把S用split()函数分开，然后用capitalize()把首字母变成大写，最后用join()合并到一起.

#实例：

#strlwr(sStr1)
sStr1 = 'JCstrlwr'
sStr1 = sStr1.upper().

#sStr1 = sStr1.lower().
print sStr1.

9、追加指定长度的字符 串

代码如下:

#strncat(sStr1,sStr2,n).
sStr1 = '12345'
sStr2 = 'abcdef'
n = 3.
sStr1 += sStr2[0:n].
print sStr1.

10、字符串指定长度比 较

代码如下:

#strncmp(sStr1,sStr2,n).
sStr1 = '12345'
sStr2 = '123bc'
n = 3.
print cmp(sStr1[0:n],sStr2[0:n]).

11、复制指定长度的字 符

代码如下:

#strncpy(sStr1,sStr2,n).
sStr1 = ''
sStr2 = '12345'
n = 3.
sStr1 = sStr2[0:n].
print sStr1.

12、将字符串前n个字符替换为指定的字 符

代码如下:

#strnset(sStr1,ch,n).
sStr1 = '12345'
ch = 'r'
n = 3.
sStr1 = n * ch + sStr1[3:].
print sStr1.

13、扫描字符 串

代码如下:

#strpbrk(sStr1,sStr2).
sStr1 = 'cekjgdklab'
sStr2 = 'gka'
nPos = -1
for c in sStr1:
if c in sStr2:
nPos = sStr1.index(c).
break.
print nPos.

14、翻转字符 串

代码如下:

#strrev(sStr1).
sStr1 = 'abcdefg'
sStr1 = sStr1[::-1].
print sStr1.

15、查找字符 串

代码如下:

#strstr(sStr1,sStr2).
sStr1 = 'abcdefg'
sStr2 = 'cde'
print sStr1.find(sStr2).

16、分割字符 串

代码如下:

#strtok(sStr1,sStr2).
sStr1 = 'ab,cde,fgh,ijk'
sStr2 = ','
sStr1 = sStr1[sStr1.find(sStr2) + 1:].
print sStr1.

#或者.
s = 'ab,cde,fgh,ijk'
print(s.split(',')).

17、连接字符 串

代码如下:

delimiter = ','
mylist = ['Brazil', 'Russia', 'India', 'China'].
print delimiter.join(mylist).

18、PHP 中 addslashes 的实 现

代码如下:

def addslashes(s):
d = {'"':'\"', "'":"\'", "\0":"\\0", "\":"\\"}.
return ''.join(d.get(c, c) for c in s).

s = "John 'Johny' Doe (a.k.a. &quot;Super Joe&quot;)\\0"
print s.
print addslashes(s).

19、只显示字母与数 字

代码如下:

def OnlyCharNum(s,oth=''):
s2 = s.lower();
fomart = 'abcdefghijklmnopqrstuvwxyz0123456789'
for c in s2:
if not c in fomart:
s = s.replace(c,'');
return s;

print(OnlyStr("a000 aa-b")).

20、截取字符 串

代码如下:

str = '0123456789′.
print str[0:3] #截取第一位到第三位的字符.
print str[:] #截取字符串的全部字符.
print str[6:] #截取第七个字符到结尾.
print str[:-3] #截取从头开始到倒数第三个字符之前.
print str[2] #截取第三个字符.
print str[-1] #截取倒数第一个字符.
print str[::-1] #创造一个与原字符串顺序相反的字符串.
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符.
print str[-3:] #截取倒数第三位到结尾.
print str[:-5:-3] #逆序截取.

21、字符串在输出时的对 齐

代码如下:

S.ljust(width,[fillchar]).

#输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
S.rjust(width,[fillchar]) #右对齐.
S.center(width, [fillchar]) #中间对齐.
S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足.

22、字符串中的搜索和替换

代码如下:

S.find(substr, [start, [end]])

#返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索.
S.index(substr, [start, [end]])

#与find()相同，只是在S中没有substr时，会返回一个运行时错误
S.rfind(substr, [start, [end]]).

#返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号.
S.rindex(substr, [start, [end]])
S.count(substr, [start, [end]]) #计算substr在S中出现的次数.
S.replace(oldstr, newstr, [count])

#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换.
S.strip([chars])

#把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None.
S.lstrip([chars])
S.rstrip([chars]).
S.expandtabs([tabsize])

#把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个.

23、字符串的分割和组合

代码如下:

S.split([sep, [maxsplit]])

#以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符.
S.rsplit([sep, [maxsplit]]).
S.splitlines([keepends]).

#把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
S.join(seq) #把seq代表的序列──字符串序列，用S连接起来.

24、字符串的mapping，这一功能包含两个函 数

代码如下:

String.maketrans(from, to)

#返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。
S.translate(table[,deletechars])

#使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果S为unicode字符串，那么就不支持 deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。

25、字符串还有一对编码和解码的函 数

代码如下:

S.encode([encoding,[errors]])

#其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通过codecs.register_error注册的值。
S.decode([encoding,[errors]])

26、字符串的测试、判断函数，这一类函数在string模块中没有，这些函数返回的都是bool 值

代码如下:

S.startswith(prefix[,start[,end]]).

#是否以prefix开头.
S.endswith(suffix[,start[,end]]).

#以suffix结尾.
S.isalnum().

#是否全是字母和数字，并至少有一个字符.
S.isalpha() #是否全是字母，并至少有一个字符.
S.isdigit() #是否全是数字，并至少有一个字符.
S.isspace() #是否全是空白字符，并至少有一个字符
S.islower() #S中的字母是否全是小写.
S.isupper() #S中的字母是否便是大写.
S.istitle() #S是否是首字母大写的.

27、字符串类型转换函数，这几个函数只在string模块中 有

代码如下:

string.atoi(s[,base])

#base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，如果是16那么s就只能是0x23或0X12这种形式的字符串
string.atol(s[,base]) #转成long
string.atof(s[,base]) #转成float

这里再强调一次，字符串对象是不可改变的，也就是说在python创建一个字符串后，你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后，都会返回一个新的字符串，原字串并没有变。其实这也是有变通的办法的，可以用S=list(S)这个函数把S变为由单个字符为成员的list，这样的话就可以使用S[3]='a'的方式改变值，然后再使用S=" ".join(S)还原成字符串

切片 ：之前已经见过很多次了。

# 对字符串进行切片操作：[begin:end:step]
# 若步长为-1，则对字符串逆序
# s = "HELLO PYTHON"
# print(s[::-1])
s = "0123456789"
print(s[2:6:1])  # 截取从2-5位置的字符串
print(s[2::1])   # 截取从2-末尾的字符串
print(s[::])     # 截取完整的字符串
print(s[0::2])   # 从开始位置，每隔一个字符的字符串
print(s[2:-1:])   # 从2开始截取到末尾-1的字符串
print(s[-2::])    # 截取字符串末尾2个字符
print(s[::-1])   # 字符串的逆序

Python基础到这里就暂时结束了。

面向对象

面向对象指的是现代程序开发的一种思想，有别与面向过程，它能够更好的开发大型程序，使开发过程调理清晰，逻辑严密。

首先是 类 的概念，一切都是对象，但是一些对象是可以归为一类的，由这个类的实例化来形成不同的对象。

类中包括 属性和方法，又包括私有属性以及私有方法等。

先来看一个例子：

# 小猫爱吃鱼，小猫要喝水
# 分析要求的功能，定义猫对象 包含吃/喝两个方法
class Cat:    
    def eat(self):        
        print("小猫爱吃鱼")    
    def  drink(self):        
        print("小猫要喝水"). 


tom = Cat()  # 假设小猫叫做TOM
tom.eat()
tom.drink()
print(tom)# 此处打印tom这个对象的信息

代码中：先定义了 猫 这个类，其中包括 吃 和 喝 这两个方法，然后通过这个类创建出tom这个对象，接着调用 吃 喝 这两个方法，实现了要求的功能。

在类中初始化属性：

# 在类的内部调用 __init__ 方法初始化属性
class Cat:    
    def __init__(self, in_name):   # 从外部传入一个参数作为属性，使对象的定义更加灵活。
        
        self.name = in_name    
    def eat(self):        
        print("%s爱吃鱼" % self.name)    
    def drink(self):        
        print("%s要喝水" % self.name)

tom = Cat("Tom")tom.eat()tom.drink()

案例—小明爱跑步

# 小明爱跑步 小明跑完步吃东西
# 小明体重75KG
# 小明跑完步体重减少0.5KG
# 小明吃完东西体重增加1KG
class Person:          # 分析--小明是人类 所以创建一个 （人）类    
    def __init__(self, name, weight):   #根据需求推断—这个类具有体重和姓名两个属性，初始化这两个属性
        self.name = name      # 初始化一个名为 name 的属性        
        self.weight = weight   # 初始化一个名为 weight 的属性    

    def __str__(self):   # 给这个类增加字符串描述 注意 这个方法只能 "返回" 一个字符串        
        return "我叫 %s ，我的体重是 %.2f KG。" % (self.name, self.weight)    
    def eat(self):    # 吃东西的方法        
        self.weight += 1    
    def run(self):   # 跑步的方法        
        self.weight -= 0.5

xiaoming = Person("小明", 75)
print(xiaoming)
xiaoming.run()
xiaoming.run()
xiaoming.run()
xiaoming.eat()
print(xiaoming).  # 多个对象之间的属性 互不干扰 |

案例—摆放家具

# 房子有 户型 总面积 和 家具名称列表
# 新房子没有任何家具
# 家具有 名字 和 占地面积 其中
# 席梦思 占地 4 平米# 衣柜 占地 2 平米
# 餐桌 占地 1.5 平米
# 将以上 3 件家具添加到房子中
# 打印房子时 要求输出 户型 总面积 剩余面积 家具名称列表
class Items:  # 创建一个家具类    
    def __init__(self, name, size):        
        self.name = name        
        self.size = size    
    def __str__(self):        
        return "%s 占地 %.2f" % (self.name, self.size)

class House:  # 分析--有房子类    
    def __init__(self, house_type, area_size): # 初始化房子的属性 包括 户型 总面积   新房子没有任何家具        
        self.house_type = house_type        
        self.area_size = area_size        
        self.free_size = area_size        
        self.item_list = []    
def __str__(self):        
        return "户型： %s\n总面积: %.2f\n剩余面积: %.2f\n家具: %s"                % (self.house_type, self.area_size, self.free_size, self.item_list)    

def add_item(self, item):        
        if item.size > self.free_size:            
            print("%s 太大了，无法添加！" % item.name)            
            return        
        print("要添加 %s 占地 %.2f" % (item.name, item.size)) 
        self.item_list.append(item.name)        
        self.free_size -= item.size

ximengsi = Items("席梦思", 4)
yigui = Items("衣柜", 2)
canzhuo = Items("餐桌", 1.5)
house = House("两室一厅", 100)
house.add_item(ximengsi)
house.add_item(yigui)
house.add_item(canzhuo)
print(house)

类的继承 ，当已经编写完成一个类之后，例如，已经编写了一个"狗"类，包括吃饭、睡觉，两个方法，现在，希望再编写一个"哮天犬"类，其中包含"狗"类中的所有方法和属性，而且还包含一个特殊的方法：飞，那么需要完全重新编写"狗"类中的所有方法吗？ 似乎并不需要，这时，我们就可以使用python中一大特性：继承。

# 继承可以将已编写过的代码重复使用
# 父类和子类，子类拥有父类的所有属性和方法
# 语法：   class 类名(父类名)
#              pass
class Animal:    
    def __str__(self):        
        return "这是一个动物类！"    
    def eat(self):        
        print("吃")    
    def drink(self):        
        print("喝")    
    def run(self):        
        print("跑")    
    def sleep(self):        
        print("睡")

class Dog(Animal):    
    def __str__(self):        
        return "这是一个狗类！"    
    def bark(self):        
        print("汪汪叫")

class Cat(Animal):    
    def __str__(self):        
        return "这是一个猫类！"    
    def catch(self):        
        print("抓")

class XiaoTianQuan(Dog):    
    def __str__(self):        
        return "这是一个哮天犬类！"    
    def fly(self):        
        print("飞")
xiaobai = Dog()
xiaobai.eat()
xiaobai.run()
xiaobai.drink()
xiaobai.bark()
print("")
mimi = Cat()
mimi.drink()
mimi.catch()
print("")
xiaotianquan = XiaoTianQuan()
xiaotianquan.drink()
xiaotianquan.bark()
xiaotianquan.fly()

这里，被继承的类称为父类或基类，继承的类称为子类或派生类

方法的重写 ：在一些情况下，父类中预先编写好的代码与子类希望实现的功能完全不匹配，这时就要对方法进行 重写。

重写时在子类中声名一个与父类中同名的方法即可。

#当父类方法和子类的预期功能完全不匹配时，可以对方法进行重写
class Animal:    
    def __str__(self):        
        return "这是一个动物类！"    
    def eat(self):        
        print("吃")    
    def drink(self):        
        print("喝")    
    def run(self):        
        print("跑")    
    def sleep(self):        
        print("睡")

class Dog(Animal):    
    def __str__(self):        
        return "这是一个狗类！"    
    def bark(self):        
        print("汪汪叫")

class XiaoTianQuan(Dog):    
    def __str__(self):        
        return "这是一个哮天犬类！"    
    def fly(self):        
        print("飞")    
    def bark(self):         #在此处对它的父类中的bark方法进行重写        
        print("汲魂痛击！！")

xtq = XiaoTianQuan()
xtq.bark()

方法的拓展 ：在某些情况下，父类中的方法已经实现了子类期望的一部分功能，但是并不完整，这时就要对方法进行拓展。

使用python中一个特殊的对象 super() 来调用父类方法中的代码，在下面继续编写新的代码即可。

#当父类的方法满足子类预期功能的一部分时，可以对父类中的方法进行拓展
#利用 super()对象调用父类的方法，在之后添加其他代码
class Animal:    
    def __str__(self):        
        return "这是一个动物类！"    
    def eat(self):        
        print("吃")    
    def drink(self):        
        print("喝")    
    def run(self):        
        print("跑")    
    def sleep(self):        
        print("睡")

class Dog(Animal):    
    def __str__(self):        
        return "这是一个狗类！"    
    def bark(self):        
        print("汪汪叫")

class XiaoTianQuan(Dog):    
    def __str__(self):        
        return "这是一个哮天犬类！"    
    def fly(self):        
        print("飞")    
    def bark(self):         #在此处对它的父类中的bark方法进行拓展        
        super().bark()        
        print("汲魂痛击！！")

xtq = XiaoTianQuan()
xtq.bark()