CataLpa

仿生人会梦见电子羊吗?

  • 主页
所有文章 友链 关于我

CataLpa

仿生人会梦见电子羊吗?

  • 主页

Python3.x基础总结

2018-03-16

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

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

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

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

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

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

1
2
3
4
5
6
7
8
a=1
b=1.5
c=‘abc’
d=‘man’
print(type(a))
print(type(b))
print(type(c))
print(type(d))

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

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

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

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

1
2
3
4
5
a=input(“请输入密码:”)
print(a)
print(type(a))
int(a)
print(type(a))

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

1
2
3
4
5
6
7
8
9
#加号拼接字符串
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方法使用格式化输出:

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

Python中的逻辑运算符:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#与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语句进行条件判断进而控制程序执行流程。

举例:

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

If的嵌套:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#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循环

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#利用循环嵌套打印菱形
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

1
2
3
4
5
6
7
8
9
10
11
12
#利用循环嵌套打印阶梯
# 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 打印九九乘法表:

1
2
3
4
5
6
7
8
9
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关键字来定义函数,首先是无参数的函数,如:

1
2
3
4
5
6
7
8
9
# 封装2个函数 say_hello 和 say_bye
# 并调用这两个函数
def say_hello():
print("Hello World!")
print("Hello Python!")
def say_bye():
print("Bye!")
say_hello()
say_bye()

接着是有参数的函数,如:

1
2
3
4
5
6
7
8
9
# 定义函数,对输入的整数判断是奇数还是偶数
# 若是奇数,则输出'奇数' 否则输出 '偶数'
def check(a):
if a % 2 == 0:
return '偶数'
else:
return '奇数'
k = int(input("请输入一个整数:"))
print("%s" % check(k))

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

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

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

1
2
3
4
5
6
7
8
9
10
11
# 函数的递归
# 递归求斐波那契数列
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))

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

1
2
3
4
5
6
7
8
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拥有独特的数据结构:元组,列表,字典以及集合(集合并不常用,这里不去整理)。

元组, 使用一对小括号来定义:

1
2
3
4
5
6
7
8
9
10
11
12
# 元组使用小括号创建,且一旦创建就不能修改
# 元组多数用来存储不同类型的变量
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语言更为丰富。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 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)) # 求一个元素的下标

向列表中增加数据:

1
2
3
4
5
6
7
8
9
10
11
12
# 向列表中增加元素的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)

从列表中删除数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 从列表中删除元素
# 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关键字对列表进行遍历:

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 字典是除列表外 最灵活的数据类型
# 列表通常用来存储有序的数据集合 字典通常用来存储无序的数据集合
# 字典使用一对大括号定义
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关键字来迭代

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

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

案例:猜拳游戏

1
2
3
4
5
6
7
8
9
10
11
12
# 利用高级数据类型优化游戏
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针对字符串提供了大量的方法,使得对字符串的操作十分灵活。

字符串格式的控制:居中

1
2
3
4
# 使用字符串函数对字符串进行操作
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)还原成字符串

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

1
2
3
4
5
6
7
8
9
10
11
12
# 对字符串进行切片操作:[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基础到这里就暂时结束了。

面向对象

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

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

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

先来看一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
# 小猫爱吃鱼,小猫要喝水
# 分析要求的功能,定义猫对象 包含吃/喝两个方法
class Cat:
def eat(self):
print(&quot;小猫爱吃鱼&quot;)
def drink(self):
print(&quot;小猫要喝水&quot;).


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

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

在类中初始化属性:

1
2
3
4
5
6
7
8
9
10
11
# 在类的内部调用 __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()

案例—小明爱跑步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 小明爱跑步 小明跑完步吃东西
# 小明体重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). # 多个对象之间的属性 互不干扰 |

案例—摆放家具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 房子有 户型 总面积 和 家具名称列表
# 新房子没有任何家具
# 家具有 名字 和 占地面积 其中
# 席梦思 占地 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中一大特性:继承。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# 继承可以将已编写过的代码重复使用
# 父类和子类,子类拥有父类的所有属性和方法
# 语法: 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()

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#当父类方法和子类的预期功能完全不匹配时,可以对方法进行重写
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() 来调用父类方法中的代码,在下面继续编写新的代码即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#当父类的方法满足子类预期功能的一部分时,可以对父类中的方法进行拓展
#利用 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()