Python基础知识
注释
注释的引入
注释:在程序代码中对程序代码进行解释说明的文字。
作用:注释不是程序,不能被执行,只是对程序代码进行解释说明,让别人可以看懂程序代码的作用,能够大大增强程序的可读性。
注释的分类
- 单行注释
以#开头,#右边的所有文字当作说明,而不是真正要执行的程序,起辅助说明作用
-
多行注释
‘’’
我是多行注释,可以写很多很多行的功能说明下面的代码完成 ,打印一首诗
名字叫做:春江花月夜
‘’’
变量以及类型
变量的定义
所谓变量,可以理解为菜篮子,如果需要存储多个数据,最简单的方式是有多个变量,当然了也可以使用一个
程序就是用来处理数据的,而变量就是用来存储数据的
变量的类型
怎样知道一个变量的类型呢?
在python中,只要定义了一个变量,而且它有数据,那么它的类型就已经确定了,不需要咱们开发者主动的去说明它的类型,系统会自动辨别
可以使用type(变量的名字),来查看变量的类型
标识符和关键字
标识符的规则
标识符由字母、下划线和数字组成,且数字不能开头
python中的标识符是区分大小写的
命名规则
- 见名知意
- 驼峰命名法
小驼峰式命名法(lower camel case): 第一个单词以小写字母开始;第二个单词的首字母大写,例如:myName、aDog
大驼峰式命名法(upper camel case): 每一个单字的首字母都采用大写字母,例如:FirstName、LastName
还有一种命名法是用下划线“_”来连接所有的单词,比如send_buf,
Python的命令规则遵循PEP8标准
关键字
python一些具有特殊功能的标识符,这就是所谓的关键字
关键字,是python已经使用的了,所以不允许开发者自己定义和关键字相同的名字的标识符
输出
格式化输出
age = 10
print("我今年%d岁" % age)
age += 1
print("我今年%d岁" % age)
age += 1
print("我今年%d岁" % age)
在程序中,看到了%这样的操作符,这就是Python中格式化输出。
age = 18
name = "xiaohua"
print("我的姓名是%s, 年龄是%d" % (name, age))
输入
input()
password = input("请输入密码:")
print('您刚刚输入的密码是:%d' % password)
input()的小括号中放入的是,提示信息,用来在获取数据之前给用户的一个简单提示
input()在从键盘获取了数据以后,会存放到等号右边的变量中
input()会把用户输入的任何值都作为字符串来对待!!!!!!!!!
运算符
算术运算符
注意:混合运算时,优先级顺序为: ** 高于 * / % // 高于 + - ,为了避免歧义,建议使用 () 来处理运算符优先级。
并且,不同类型的数字在进行混合运算时,整数将会转换成浮点数进行运算。
赋值运算符
常用的数据类型转换
比较(即关系,条件)运算符
逻辑运算符
判断语句和循环语句
if判断语句
if 要判断的条件:
条件成立时,要做的事情
if-else
if-else的使用格式
if 条件:
满足条件时要做的事情1
满足条件时要做的事情2
满足条件时要做的事情3
...(省略)...
else:
不满足条件时要做的事情1
不满足条件时要做的事情2
不满足条件时要做的事情3
...(省略)...
if…elif…else…语句格式
if xxx1:
事情1
elif xxx2:
事情2
elif xxx3:
事情3
elif必须和if一起使用,否则出错
else 一般用在最后,即所有条件都不满足时使用
if嵌套
if 条件1:
满足条件1 做的事情1
满足条件1 做的事情2
if 条件2:
满足条件2 做的事情1
满足条件2 做的事情2
循环语句介绍
while循环
while 条件:
条件满足时,做的事情1
条件满足时,做的事情2
条件满足时,做的事情3
...(省略)...
while循环嵌套
while 条件1:
条件1满足时,做的事情1
条件1满足时,做的事情2
条件1满足时,做的事情3
...(省略)...
while 条件2:
条件2满足时,做的事情1
条件2满足时,做的事情2
条件2满足时,做的事情3
...(省略)...
for循环
for 临时变量 in 列表或者字符串等可迭代对象:
循环满足条件时执行的代码
break和continue
break的作用:立刻结束break所在的循环
continue的作用:用来结束本次循环,紧接着执行下一次的循环
break/continue只能用在循环中,除此以外不能单独使用
break/continue在嵌套循环中,只对最近的一层循环起作用
容器:字符串、列表、元组、字典
字符串介绍
双引号或者单引号中的数据,就是字符串
字符串输出
格式化操作符
name = '峰哥'
position = '讲师'
address = '北京市'
print('--------------------------------------------------')
print("姓名:%s" % name)
print("职位:%s" % position)
print("公司地址:%s" % address)
print('--------------------------------------------------')
f-strings
f-strings 提供一种简洁易读的方式, 可以在字符串中包含 Python 表达式. f-strings 以字母 ‘f’ 或 ‘F’ 为前缀, 格式化字符串使用一对单引号、双引号、三单引号、三双引号. 格式化字符串中
name = 'Python'
age = 33
format_string1 = f'我的名字是 {name}, 我的年龄是 {age}'
format_string2 = f"我的名字是 {name}, 我的年龄是 {age}"
format_string3 = F'''我的名字是 {name}, 我的年龄是 {age}'''
format_string4 = F"""我的名字是 {name}, 我的年龄是 {age}"""
format_string5 = f'3 + 5 = {3 + 5}'
a = 10
b = 20
format_string6 = f'3 + 5 = {a + b}'
# 两个花括号会被替换为一个花括号, 注意{{}} 不表示表达式
format_string7 = F'我的名字是 {{name}}, 我的年龄是 {{age}}'
字符串输入
input函数,通过它能够完成从键盘获取数据,然后保存到指定的变量中;
注意:input获取的数据,都以字符串的方式进行保存,即使输入的是数字,那么也是以字符串方式保存
下标和切片
下标
切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法:[起始:结束:步长] 注意:选取的区间从"起始"位开始,到"结束"位的前一位结束(不包含结束位本身),步长表示选取间隔。
print(name[2:]) # 取 下标为2开始到最后的字符
print(name[1:-1]) # 取 下标为1开始 到 最后第2个 之间的字符
print(s[:]) # 取出所有元素(没有起始位和结束位之分),默认步长为1 “千里之行 始于足下”
print(s[1:]) # 从下标为1开始,取出 后面所有的元素(没有结束位)“里之行 始于足下”
print(s[:5]) # 从起始位置开始,取到 下标为5的前一个元素(不包括结束位本身)“千里之行 ”
print(s[:-1]) # 从起始位置开始,取到 倒数第一个元素(不包括结束位本身)“千里之行 始于足”
print(s[-4:-1]) # 从倒数第4个元素开始,取到 倒数第1个元素(不包括结束位本身)“始于足”
print(s[1:5:2]) # 从下标为1开始,取到下标为5的前一个元素,步长为2(不包括结束位本身)“千之 ”
# python 字符串快速逆置
print(s[::-1]) # 从后向前,按步长为1进行取值“下足于始 行之里千”
字符串常见操作
find
检测 str 是否包含在 mystr中,如果是返回开始的索引值,否则返回-1
mystr.find(str, start=0, end=len(mystr))
index
跟find()方法一样,只不过如果str不在 mystr中会报一个异常.
mystr.index(str, start=0, end=len(mystr))
count
返回 str在start和end之间 在 mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))
replace
把 mystr 中的 str1 替换成 str2,如果 count 指定,则替换不超过 count 次.
mystr.replace(str1, str2, count=mystr.count(str1))
split
以 str 为分隔符切片 mystr,如果 maxsplit有指定值,则仅分隔 maxsplit+1 个子字符串
参数:str -默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等
mystr.split(str=" ", 2)
join
strip
删除mystr字符串两端的空白字符
a = "\n\t itcast \t\n"
a.strip()
'itcast'
partition
把mystr以str分割成三部分,str前,str和str后
mystr.partition(str)
列表
列表的格式
变量A的类型为列表
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
比C语言的数组强大的地方在于列表中的元素可以是不同类型的
testList = [1, 'a']
列表的循环遍历
为了更有效率的输出列表的每个数据,可以使用循环来完成
demo:
names_list = ['xiaoWang','xiaoZhang','xiaoHua']
for name in names_list:
print(name)
结果:
xiaoWang
xiaoZhang
xiaoHua
列表的相关操作
添加元素("增"append, extend, insert)
append
通过append可以向列表添加元素
extend
通过extend可以将另一个集合中的元素逐一添加到列表中
insert(index, object) 在指定位置index前插入元素object
修改元素(“改”)
修改元素的时候,要通过下标来确定要修改的是哪个元素,然后才能进行修改
查找元素("查"in, not in, index, count)
- in, not in
python中查找的常用方法为:
in(存在),如果存在那么结果为true,否则为false
not in(不存在),如果不存在那么结果为true,否则false
- index, count
index和count与字符串中的用法相同
删除元素("删"del, pop, remove)
列表元素的常用删除方法有:
del:根据下标进行删除
pop:删除最后一个元素
remove:根据元素的值进行删除
排序(sort, reverse)
sort方法是将list按特定顺序重新排列,默认为由小到大,参数reverse=True可改为倒序,由大到小。
reverse方法是将list逆置。
>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]
列表的嵌套
一个列表中的元素又是一个列表,那么这就是列表的嵌套
school_names = [[‘北京大学’,‘清华大学’],
[‘南开大学’,‘天津大学’,‘天津师范大学’],
[‘山东大学’,‘中国海洋大学’]]
元组
Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。
my_tuple = (‘et’,77,99.9)
my_tuple
(‘et’,77,99.9)
字典介绍
变量info为字典类型:
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
说明:
字典和列表一样,也能够存储多个数据
列表中找某个元素时,是根据下标进行的
字典中找某个元素时,是根据’名字’(就是冒号:前面的那个值,例如上面代码中的’name’、‘id’、‘sex’)
字典的每个元素由2部分组成,键:值。例如 ‘name’:‘班长’ ,'name’为键,'班长’为值
根据键访问值
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info['name'])
print(info['address'])
结果:
班长
地球亚洲中国北京
字典的常见操作1
查看元素
除了使用key查找数据,还可以使用get来获取数据
info = {'name':'吴彦祖','age':18}
print(info['age']) # 获取年龄
# print(info['sex']) # 获取不存在的key,会发生异常
print(info.get('sex')) # 获取不存在的key,获取到空的内容,不会出现异常
修改元素
字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改
添加元素
如果在使用 变量名[‘键’] = 数据 时,这个“键”在字典中,不存在,那么就会新增这个元素
删除元素
对字典进行删除操作,有一下几种:
- del
del删除指定的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('删除前,%s'%info['name'])
del info['name']
print('删除后,%s'%info['name'])
del删除整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s'%info)
del info
print('删除后,%s'%info)
- clear()
clear清空整个字典
字典的常见操作2
len()
测量字典中,键值对的个数
keys
返回一个包含字典所有KEY的列表
values
返回一个包含字典所有value的列表
items
返回一个包含所有(键,值)元祖的列表
遍历
字符串遍历
a_str = “hello itcast”
for char in a_str:
… print(char,end=’ ')
…
h e l l o i t c a s t
列表遍历
a_list = [1, 2, 3, 4, 5]
for num in a_list:
… print(num,end=’ ')
…
1 2 3 4 5
元组遍历
a_turple = (1, 2, 3, 4, 5)
for num in a_turple:
… print(num,end=" ")
1 2 3 4 5
字典遍历
enumerate()
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
... print i, chr
...
0 a
1 b
2 c
3 d
公共方法
函数
定义函数
定义函数的格式如下:
def 函数名():
代码
调用函数
定义了函数之后,就相当于有了一个具有某些功能的代码,想要让这些代码能够执行,需要调用它
调用函数很简单的,通过 函数名() 即可完成调用
函数参数
def add2num(a, b):
c = a+b
print c
add2num(11, 22) # 调用带有参数的函数时,需要在小括号中,传递数据
定义时小括号中的参数,用来接收参数用的,称为 “形参”
调用时小括号中的参数,用来传递给函数用的,称为 “实参”
缺省参数
调用函数时,缺省参数的值如果没有传入,则取默认值。
下例会打印默认的age,如果age没有被传入:
def printinfo(name, age=35):
# 打印任何传入的字符串
print("name: %s" % name)
print("age %d" % age)
调用printinfo函数
printinfo(name="miki") # 在函数执行过程中 age去默认值35
printinfo(age=9 ,name="miki")
以上实例输出结果:
name: miki
age: 35
name: miki
age: 9
总结:
在形参中默认有值的参数,称之为缺省参数
注意:带有默认值的参数一定要位于参数列表的最后面
不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数,声明时不会命名。
加了星号(*)的变量args会存放所有未命名的变量参数,args为元组
而加**的变量kwargs会存放命名参数,即形如key=value的参数, kwargs为字典.
>>> def fun(a, b, *args, **kwargs):
... """可变参数演示示例"""
... print("a =%d" % a)
... print("b =%d" % b)
... print("args:")
... print(args)
... print("kwargs: ")
... for key, value in kwargs.items():
... print("key=%s" % value)
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应
a = 1
b = 2
args:
(3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d) # 注意元组与字典的传参方式
a = 1
b = 2
args:
(3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args:
((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>
缺省参数在*args后面
def sum_nums_3(a, *args, b=22, c=33, **kwargs):
print(a)
print(b)
print©
print(args)
print(kwargs)
sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)
说明:
如果很多个值都是不定长参数,那么这种情况下,可以将缺省参数放到 *args的后面, 但如果有**kwargs的话,**kwargs必须是最后的
函数返回值
一个函数中可以有多个return语句,但是只要有一个return语句被执行到,那么这个函数就会结束了,因此后面的return没有什么用处
return后面可以是元组,列表、字典等,只要是能够存储多个数据的类型,就可以一次性返回多个数据
def function():
# return [1, 2, 3]
# return (1, 2, 3)
return {"num1": 1, "num2": 2, "num3": 3}
如果return后面有多个数据,那么默认是元组
In [1]: a = 1, 2
In [2]: a
Out[2]: (1, 2)
In [3]:
In [3]: b = (1, 2)
In [4]: b
Out[4]: (1, 2)
In [5]:
函数的嵌套调用
def testB():
print('---- testB start----')
print('这里是testB函数执行的代码...(省略)...')
print('---- testB end----')
def testA():
print('---- testA start----')
testB()
print('---- testA end----')
testA()
结果:
---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----
局部变量
局部变量,就是在函数内部定义的变量
其作用范围是这个函数内部,即只能在这个函数中使用,在函数的外部是不能使用的
因为其作用范围只是在自己的函数内部,所以不同的函数可以定义相同名字的局部变量(打个比方,把你、我是当做成函数,把局部变量理解为每个人手里的手机,你可有个iPhone8,我当然也可以有个iPhone8了, 互不相关)
局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储
当函数调用时,局部变量被创建,当函数调用完成后这个变量就不能够使用了
全局变量
在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
全局变量和局部变量名字相同问题
当函数内出现局部变量和全局变量相同名字时,函数内部中的 变量名 = 数据 此时理解为定义了一个局部变量,而不是修改全局变量的值
修改全局变量
如果在函数中出现global 全局变量的名字 那么这个函数中即使出现和全局变量名相同的变量名 = 数据 也理解为对全局变量进行修改,而不是定义局部变量
如果在一个函数中需要对多个全局变量进行修改,那么可以使用
# 可以使用一次global对多个全局变量进行声明
global a, b
拆包、交换变量的值
对返回的数据直接拆包
def get_my_info():
high = 178
weight = 100
age = 18
return high, weight, age
my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)
拆包时要注意,需要拆的数据的个数要与变量的个数相同,否则程序会异常 除了对元组拆包之外,还可以对列表、字典等拆包
交换2个变量的值
a, b = 4, 5
a, b = b, a
print(a) #a = 5
print(b) # b = 4
引用
在python中,值是靠引用来传递来的。
我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。
>>> a = 1
>>> b = a
>>> id(a)
13033816
>>> id(b) # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a) # 注意a的id值已经变了
13033792
>>> id(b) # b的id值依旧
13033816
之前为了更好的理解变量,可以把a=100理解为变量a中存放了100,事实上变量a存储是100的引用(可理解为在内存中的一个编号)
Python中函数参数是引用传递(注意不是值传递)
对于不可变类型,因变量不能修改,所以运算不会影响到变量自身
而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量
可变、不可变类型
所谓可变类型与不可变类型是指:数据能够直接进行修改,如果能直接修改那么就是可变,否则是不可变
可变类型有: 列表、字典、集合
不可变类型有: 数字、字符串、元组
文件
文件的读写
写数据(write)
使用write()可以完成向文件写入数据
f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()
读数据(read)
使用read(num)可以从文件中读取数据,num表示要从文件中读取的数据的长度(单位是字节),如果没有传入num,那么就表示读取文件中所有的数据
读数据(readlines)
就像read没有参数时一样,readlines可以按照行的方式把整个文件中的内容进行一次性读取,并且返回的是一个列表,其中每一行的数据为一个元素
读数据(readline)
读取一行数据
f = open('test.txt', 'r')
content = f.read(5) # 最多读取5个数据
print(content)
print("-"*30) # 分割线,用来测试
content = f.read() # 从上次读取的位置继续读取剩下的所有的数据
print(content)
f.close() # 关闭文件,这个可以是个好习惯哦
运行现象:
hello
------------------------------
world, i am here!
文件的相关操作
文件重命名
os模块中的rename()可以完成对文件的重命名操作
rename(需要修改的文件名, 新的文件名)
import os
os.rename("毕业论文.txt", "毕业论文-最终版.txt")
删除文件
os模块中的remove()可以完成对文件的删除操作
remove(待删除的文件名)
import os
os.remove("毕业论文.txt")
创建文件夹
import os
os.mkdir("张三")
获取当前目录
import os
os.getcwd()
改变默认目录
import os
os.chdir("../")
获取目录列表
import os
os.listdir("./")
删除文件夹
import os
os.rmdir("张三")
面向对象编程
类和对象
类(Class) 由3个部分构成
类的名称:类名
类的属性:一组数据
类的方法:允许对进行操作的方法 (行为)
- 定义一个类,格式如下:
class 类名:
方法列表
# class Hero: # 经典类(旧式类)定义形式
# class Hero():
class Hero(object): # 新式类定义形式
def info(self):
print("英雄各有见,何必问出处。")
说明:
定义类时有2种形式:新式类和经典类,上面代码中的Hero为新式类,前两行注释部分则为经典类;
object 是Python 里所有类的最顶级父类;
类名 的命名规则按照"大驼峰命名法";
info 是一个实例方法,第一个参数一般是self,表示实例对象本身,当然了可以将self换为其它的名字,其作用是一个变量 这个变量指向了实例对象
python中,可以根据已经定义的类去创建出一个或多个对象。
创建对象
创建对象的格式为:
对象名1 = 类名()
对象名2 = 类名()
对象名3 = 类名()
对象既然有实例方法,是否也可以有自己的属性? 看下一点
添加和获取对象的属性
class Hero(object):
"""定义了一个英雄类,可以移动和攻击"""
def move(self):
"""实例方法"""
print("正在前往事发地点...")
def attack(self):
"""实例方法"""
print("发出了一招强力的普通攻击...")
# 实例化了一个英雄对象 泰达米尔
taidamier = Hero()
# 给对象添加属性,以及对应的属性值
taidamier.name = "泰达米尔" # 姓名
taidamier.hp = 2600 # 生命值
taidamier.atk = 450 # 攻击力
taidamier.armor = 200 # 护甲值
# 通过.成员选择运算符,获取对象的属性值
print("英雄 %s 的生命值 :%d" % (taidamier.name, taidamier.hp))
print("英雄 %s 的攻击力 :%d" % (taidamier.name, taidamier.atk))
print("英雄 %s 的护甲值 :%d" % (taidamier.name, taidamier.armor))
# 通过.成员选择运算符,获取对象的实例方法
taidamier.move()
taidamier.attack()
对象创建并添加属性后,能否在类的实例方法里获取这些属性呢?如果可以的话,应该通过什么方式?看下一点
在方法内通过self获取对象属性
class Hero(object):
"""定义了一个英雄类,可以移动和攻击"""
def move(self):
"""实例方法"""
print("正在前往事发地点...")
def attack(self):
"""实例方法"""
print("发出了一招强力的普通攻击...")
def info(self):
"""在类的实例方法中,通过self获取该对象的属性"""
print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))
print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))
# 实例化了一个英雄对象 泰达米尔
taidamier = Hero()
# 给对象添加属性,以及对应的属性值
taidamier.name = "泰达米尔" # 姓名
taidamier.hp = 2600 # 生命值
taidamier.atk = 450 # 攻击力
taidamier.armor = 200 # 护甲值
# 通过.成员选择运算符,获取对象的实例方法
taidamier.info() # 只需要调用实例方法info(),即可获取英雄的属性
taidamier.move()
taidamier.attack()
创建对象后再去添加属性有点不合适,有没有简单的办法,可以在创建对象的时候,就已经拥有这些属性?看下一点
魔法方法
_ init_()方法
class Hero(object):
"""定义了一个英雄类,可以移动和攻击"""
# Python 的类里提供的,两个下划线开始,两个下划线结束的方法,就是魔法方法,__init__()就是一个魔法方法,通常用来做属性初始化 或 赋值 操作。
# 如果类面没有写__init__方法,Python会自动创建,但是不执行任何操作,
# 如果为了能够在完成自己想要的功能,可以自己定义__init__方法,
# 所以一个类里无论自己是否编写__init__方法 一定有__init__方法。
def __init__(self):
""" 方法,用来做变量初始化 或 赋值 操作,在类实例化对象的时候,会被自动调用"""
self.name = "泰达米尔" # 姓名
self.hp = 2600 # 生命值
self.atk = 450 # 攻击力
self.armor = 200 # 护甲值
def move(self):
"""实例方法"""
print("正在前往事发地点...")
def attack(self):
"""实例方法"""
print("发出了一招强力的普通攻击...")
# 实例化了一个英雄对象,并自动调用__init__()方法
taidamier = Hero()
# 通过.成员选择运算符,获取对象的实例方法
taidamier.info() # 只需要调用实例方法info(),即可获取英雄的属性
taidamier.move()
taidamier.attack()
说明:
_ init_()方法,在创建一个对象时默认被调用,不需要手动调用
_ init_(self)中的self参数,不需要开发者传递,python解释器会自动把当前的对象引用传递过去。
在类的方法里定义属性的固定值,则每个对象实例变量的属性值都是相同的。
一个游戏里往往有很多不同的英雄,能否让实例化的每个对象,都有不同的属性值呢?看下一点
有参数的_ init_()方法
class Hero(object):
"""定义了一个英雄类,可以移动和攻击"""
def __init__(self, name, skill, hp, atk, armor):
""" __init__() 方法,用来做变量初始化 或 赋值 操作"""
# 英雄名
self.name = name
# 技能
self.skill = skill
# 生命值:
self.hp = hp
# 攻击力
self.atk = atk
# 护甲值
self.armor = armor
def move(self):
"""实例方法"""
print("%s 正在前往事发地点..." % self.name)
def attack(self):
"""实例方法"""
print("发出了一招强力的%s..." % self.skill)
def info(self):
print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))
print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))
# 实例化英雄对象时,参数会传递到对象的__init__()方法里
taidamier = Hero("泰达米尔", "旋风斩", 2600, 450, 200)
gailun = Hero("盖伦", "大宝剑", 4200, 260, 400)
# print(gailun)
# print(taidamier)
# 不同对象的属性值的单独保存
print(id(taidamier.name))
print(id(gailun.name))
# 同一个类的不同对象,实例方法共享
print(id(taidamier.move()))
print(id(gailun.move()))
说明:
通过一个类,可以创建多个对象,就好比 通过一个模具创建多个实体一样
_ init_(self)中,默认有1个参数名字为self,如果在创建对象时传递了2个实参,那么_ init_(self)中出了self作为第一个形参外还需要2个形参,例如_ init_(self,x,y)
注意:
在类内部获取 属性 和 实例方法,通过self获取;
在类外部获取 属性 和 实例方法,通过对象名获取。
如果一个类有多个对象,每个对象的属性是各自保存的,都有各自独立的地址;
但是实例方法是所有对象共享的,只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。
_ str_()方法
class Hero(object):
"""定义了一个英雄类,可以移动和攻击"""
def __init__(self, name, skill, hp, atk, armor):
""" __init__() 方法,用来做变量初始化 或 赋值 操作"""
# 英雄名
self.name = name # 实例变量
# 技能
self.skill = skill
# 生命值:
self.hp = hp # 实例变量
# 攻击力
self.atk = atk
# 护甲值
self.armor = armor
def move(self):
"""实例方法"""
print("%s 正在前往事发地点..." % self.name)
def attack(self):
"""实例方法"""
print("发出了一招强力的%s..." % self.skill)
# def info(self):
# print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
# print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))
# print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))
def __str__(self):
"""
这个方法是一个魔法方法 (Magic Method) ,用来显示信息
该方法需要 return 一个数据,并且只有self一个参数,当在类的外部 print(对象) 则打印这个数据
"""
return "英雄 <%s> 数据: 生命值 %d, 攻击力 %d, 护甲值 %d" % (self.name, self.hp, self.atk, self.armor)
taidamier = Hero("泰达米尔", "旋风斩", 2600, 450, 200)
gailun = Hero("盖伦", "大宝剑", 4200, 260, 400)
# 如果没有__str__ 则默认打印 对象在内存的地址。
# 当类的实例化对象 拥有 __str__ 方法后,那么打印对象则打印 __str__ 的返回值。
print(taidamier)
print(gailun)
# 查看类的文档说明,也就是类的注释
print(Hero.__doc__)
说明:
在python中方法名如果是__xxxx__()的,那么就有特殊的功能,因此叫做“魔法”方法
当使用print输出对象的时候,默认打印对象的内存地址。如果类定义了__str__(self)方法,那么就会打印从在这个方法中 return 的数据
__str__方法通常返回一个字符串,作为这个对象的描述信息
_ del_()方法
创建对象后,python解释器默认调用__init__()方法;
当删除对象时,python解释器也会默认调用一个方法,这个方法为__del__()方法
class Hero(object):
# 初始化方法
# 创建完对象后会自动被调用
def __init__(self, name):
print('__init__方法被调用')
self.name = name
# 当对象被删除时,会自动被调用
def __del__(self):
print("__del__方法被调用")
print("%s 被 GM 干掉了..." % self.name)
# 创建对象
taidamier = Hero("泰达米尔")
# 删除对象
print("%d 被删除1次" % id(taidamier))
del(taidamier)
print("--" * 10)
gailun = Hero("盖伦")
gailun1 = gailun
gailun2 = gailun
print("%d 被删除1次" % id(gailun))
del(gailun)
print("%d 被删除1次" % id(gailun1))
del(gailun1)
print("%d 被删除1次" % id(gailun2))
del(gailun2)
总结
当有变量保存了一个对象的引用时,此对象的引用计数就会加1;
当使用del() 删除变量指向的对象时,则会减少对象的引用计数。如果对象的引用计数不为1,那么会让这个对象的引用计数减1,当对象的引用计数为0的时候,则对象才会被真正删除(内存被回收)。
继承
在程序中,继承描述的是多个类之间的所属关系。
如果一个类A里面的属性和方法可以复用,则可以通过继承的方式,传递到类B里。
那么类A就是基类,也叫做父类;类B就是派生类,也叫做子类。
单继承:子类只继承一个父类
# 定义一个Master类
class Master(object):
def __init__(self):
# 属性
self.kongfu = "古法煎饼果子配方"
# 实例方法
def make_cake(self):
print("按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
# 定义Prentice类,继承了 Master,则Prentice是子类,Master是父类。
class Prentice(Master):
# 子类可以继承父类所有的属性和方法,哪怕子类没有自己的属性和方法,也可以使用父类的属性和方法。
pass
# laoli = Master()
# print(laoli.kongfu)
# laoli.make_cake()
damao = Prentice() # 创建子类实例对象
print(damao.kongfu) # 子类对象可以直接使用父类的属性
damao.make_cake() # 子类对象可以直接使用父类的方法
说明:
虽然子类没有定义__init__方法初始化属性,也没有定义实例方法,但是父类有。所以只要创建子类的对象,就默认执行了那个继承过来的__init__方法
总结:
子类在继承的时候,在定义类时,小括号()中为父类的名字
父类的属性、方法,会被继承给子类
多继承:子类继承多个父类
class Master(object):
def __init__(self):
self.kongfu = "古法煎饼果子配方" # 实例变量,属性
def make_cake(self): # 实例方法,方法
print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
def dayandai(self):
print("师傅的大烟袋..")
class School(object):
def __init__(self):
self.kongfu = "现代煎饼果子配方"
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
def xiaoyandai(self):
print("学校的小烟袋..")
# class Prentice(School, Master): # 多继承,继承了多个父类(School在前)
# pass
# damao = Prentice()
# print(damao.kongfu)
# damao.make_cake()
# damao.dayandai()
# damao.xiaoyandai()
class Prentice(Master, School): # 多继承,继承了多个父类(Master在前)
pass
damao = Prentice()
print(damao.kongfu) # 执行Master的属性
damao.make_cake() # 执行Master的实例方法
# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)
damao.dayandai() # 不重名不受影响
damao.xiaoyandai()
说明:
多继承可以继承多个父类,也继承了所有父类的属性和方法
注意:如果多个父类中有同名的 属性和方法,则默认使用第一个父类的属性和方法(根据类的魔法属性mro的顺序来查找)
多个父类中,不重名的属性和方法,不会有任何影响。
子类重写父类的同名属性和方法
class Master(object):
def __init__(self):
self.kongfu = "古法煎饼果子配方"
def make_cake(self):
print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class School(object):
def __init__(self):
self.kongfu = "现代煎饼果子配方"
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class Prentice(School, Master): # 多继承,继承了多个父类
def __init__(self):
self.kongfu = "猫氏煎饼果子配方"
def make_cake(self):
print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
# 如果子类和父类的方法名和属性名相同,则默认使用子类的
# 叫 子类重写父类的同名方法和属性
damao = Prentice()
print(damao.kongfu) # 子类和父类有同名属性,则默认使用子类的
damao.make_cake() # 子类和父类有同名方法,则默认使用子类的
# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)
子类调用父类同名属性和方法
class Master(object):
def __init__(self):
self.kongfu = "古法煎饼果子配方" # 实例变量,属性
def make_cake(self): # 实例方法,方法
print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class School(object):
def __init__(self):
self.kongfu = "现代煎饼果子配方"
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class Prentice(School, Master): # 多继承,继承了多个父类
def __init__(self):
self.kongfu = "猫氏煎饼果子配方"
def make_cake(self):
print("执行子类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
self.__init__() # 执行本类的__init__方法,做属性初始化 self.kongfu = "猫氏...."
print("执行子类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
# 调用父类方法格式:父类类名.父类方法(self)
def make_old_cake(self):
# 不推荐这样访问父类的实例属性,相当于创建了一个新的父类对象
# print("直接调用Master类的kongfu属性:%s" % Master().kongfu)
# 可以通过执行Master类的__init__方法,来修改self的属性值
print("执行Master类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
Master.__init__(self) # 调用了父类Master的__init__方法 self.kongfu = "古法...."
print("执行Master类的__init__方法后,self.kongfu属性:%s" % self.kongfu)
Master.make_cake(self) # 调用父类Master的实例方法
def make_new_cake(self):
# 不推荐这样访问类的实例属性,相当于创建了一个新的父类对象
# print("直接调用School类的kongfu属性:%s" % School().kongfu)
# 可以通过执行School类的__init__方法,来修改self的属性值
print("执行School类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
School.__init__(self) # 调用了父类School的__init__方法 self.kongfu = "现代...."
print("执行School类的__init__方法后,self.kongfu属性:%s" % self.kongfu)
School.make_cake(self) # 调用父类School的实例方法
# 实例化对象,自动执行子类的__init__方法
damao = Prentice()
damao.make_cake() # 调用子类的方法(默认重写了父类的同名方法)
print("--" * 10)
damao.make_old_cake() # 进入实例方法去调用父类Master的方法
print("--" * 10)
damao.make_new_cake() # 进入实例方法去调用父类School的方法
print("--" * 10)
damao.make_cake() # 调用本类的实例方法
核心点:
无论何时何地,self都表示是子类的对象。在调用父类方法时,通过传递self参数,来控制方法和属性的访问修改。
多层继承
class Master(object):
def __init__(self):
self.kongfu = "古法煎饼果子配方"
def make_cake(self):
print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class School(object):
def __init__(self):
self.kongfu = "现代煎饼果子配方"
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class Prentice(School, Master): # 多继承,继承了多个父类
def __init__(self):
self.kongfu = "猫氏煎饼果子配方"
self.money = 10000 # 亿美金
def make_cake(self):
self.__init__() # 执行本类的__init__方法,做属性初始化 self.kongfu = "猫氏...."
print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
# 调用父类方法格式:父类类名.父类方法(self)
def make_old_cake(self):
Master.__init__(self) # 调用了父类Master的__init__方法 self.kongfu = "古法...."
Master.make_cake(self) # 调用了父类Master的实例方法
def make_new_cake(self):
School.__init__(self) # 调用了父类School的__init__方法 self.kongfu = "现代...."
School.make_cake(self) # 调用父类School的实例方法,
class PrenticePrentice(Prentice): # 多层继承
pass
pp = PrenticePrentice()
pp.make_cake() # 调用父类的实例方法
pp.make_new_cake()
pp.make_old_cake()
print(pp.money)
super()的使用
class Master(object):
def __init__(self):
self.kongfu = "古法煎饼果子配方" # 实例变量,属性
def make_cake(self): # 实例方法,方法
print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
# 父类是 Master类
class School(Master):
def __init__(self):
self.kongfu = "现代煎饼果子配方"
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
super().__init__() # 执行父类的构造方法
super().make_cake() # 执行父类的实例方法
# 父类是 School 和 Master
class Prentice(School, Master): # 多继承,继承了多个父类
def __init__(self):
self.kongfu = "猫氏煎饼果子配方"
def make_cake(self):
self.__init__() # 执行本类的__init__方法,做属性初始化 self.kongfu = "猫氏...."
print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
def make_all_cake(self):
# 方式1. 指定执行父类的方法(代码臃肿)
# School.__init__(self)
# School.make_cake(self)
#
# Master.__init__(self)
# Master.make_cake(self)
#
# self.__init__()
# self.make_cake()
# 方法2. super() 带参数版本,只支持新式类
# super(Prentice, self).__init__() # 执行父类的 __init__方法
# super(Prentice, self).make_cake()
# self.make_cake()
# 方法3. super()的简化版,只支持新式类
super().__init__() # 执行父类的 __init__方法
super().make_cake() # 执行父类的 实例方法
self.make_cake() # 执行本类的实例方法
damao = Prentice()
damao.make_cake()
damao.make_all_cake()
# print(Prentice.__mro__)
子类继承了多个父类,如果父类类名修改了,那么子类也要涉及多次修改。而且需要重复写多次调用,显得代码臃肿。
使用super() 可以逐一调用所有的父类方法,并且只执行一次。调用顺序遵循 mro 类属性的顺序。
注意:如果继承了多个父类,且父类都有同名方法,则默认只执行第一个父类的(同名方法只执行一次,目前super()不支持执行多个父类的同名方法)
super() 在Python2.3之后才有的机制,用于通常单继承的多层继承。
私有权限
面向对象三大特性:封装、继承、多态
封装的意义:
将属性和方法放到一起做为一个整体,然后通过实例化对象来处理;
隐藏内部实现细节,只需要和对象及其属性和方法交互就可以了;
对类的属性和方法增加 访问权限控制。
私有权限:在属性名和方法名 前面 加上两个下划线 __
类的私有属性 和 私有方法,都不能通过对象直接访问,但是可以在本类内部访问;
类的私有属性 和 私有方法,都不会被子类继承,子类也无法访问;
私有属性 和 私有方法 往往用来处理类的内部事情,不通过对象处理,起到安全作用。
class Master(object):
def __init__(self):
self.kongfu = "古法煎饼果子配方"
def make_cake(self):
print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class Prentice(School, Master):
def __init__(self):
self.kongfu = "猫氏煎饼果子配方"
# 私有属性,可以在类内部通过self调用,但不能通过对象访问
self.__money = 10000
# 私有方法,可以在类内部通过self调用,但不能通过对象访问
def __print_info(self):
print(self.kongfu)
print(self.__money)
def make_cake(self):
self.__init__()
print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
def make_old_cake(self):
Master.__init__(self)
Master.make_cake(self)
def make_new_cake(self):
School.__init__(self)
School.make_cake(self)
class PrenticePrentice(Prentice):
pass
damao = Prentice()
# 对象不能访问私有权限的属性和方法
# print(damao.__money)
# damao.__print_info()
pp = PrenticePrentice()
# 子类不能继承父类私有权限的属性和方法
print(pp.__money)
pp.__print_info()
修改私有属性的值
class Master(object):
def __init__(self):
self.kongfu = "古法煎饼果子配方"
def make_cake(self):
print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class School(object):
def __init__(self):
self.kongfu = "现代煎饼果子配方"
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
class Prentice(School, Master):
def __init__(self):
self.kongfu = "猫氏煎饼果子配方"
# 私有属性,可以在类内部通过self调用,但不能通过对象访问
self.__money = 10000
# 现代软件开发中,通常会定义get_xxx()方法和set_xxx()方法来获取和修改私有属性值。
# 返回私有属性的值
def get_money(self):
return self.__money
# 接收参数,修改私有属性的值
def set_money(self, num):
self.__money = num
def make_cake(self):
self.__init__()
print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
def make_old_cake(self):
Master.__init__(self)
Master.make_cake(self)
def make_new_cake(self):
School.__init__(self)
School.make_cake(self)
class PrenticePrentice(Prentice):
pass
damao = Prentice()
# 对象不能访问私有权限的属性和方法
# print(damao.__money)
# damao.__print_info()
# 可以通过访问公有方法set_money()来修改私有属性的值
damao.set_money(100)
# 可以通过访问公有方法get_money()来获取私有属性的值
print(damao.get_money())
多态
在需要使用父类对象的地方,也可以使用子类对象, 这种情况就叫多态.
- 如何在程序中使用多态?
可以按照以下几个步骤来写代码:
1.子类继承父类
2.子类重写父类中的方法
3.通过对象调用这个方法
# 定义父类
class Father:
def cure(self):
print("父亲给病人治病...")
# 定义子类继承父类
class Son(Father):
# 重写父类中的方法
def cure(self):
print("儿子给病人治病...")
# 定义函数,在里面 调用 医生的cure函数
def call_cure(doctor):
# 调用医生治病的方法
doctor.cure()
# 创建父类对象
father = Father()
# 调用函数,把父类对象传递函数
call_cure(father)
# 创建子类对象
son = Son()
# 调用函数,把子类对象传递函数
call_cure(son)
多态的好处:
给call_cure(doctor)函数传递哪个对象,在它里面就会调用哪个对象的cure()方法,也就是说在它里面既可以调用son对象的cure()方法,也能调用father对象的cure()方法,当然了也可以在它里面调用Father类其它子类对象的cure()方法,这样可以让call_cure(doctor)函数变得更加灵活,额外增加了它的功能,提高了它的扩展性.
类属性和实例属性
类属性
class People(object):
name = 'Tom' # 公有的类属性
__age = 12 # 私有的类属性
p = People()
print(p.name) # 正确
print(People.name) # 正确
print(p.__age) # 错误,不能在类外通过实例对象访问私有的类属性
print(People.__age) # 错误,不能在类外通过类对象访问私有的类属性
实例属性(对象属性)
class People(object):
address = '山东' # 类属性
def __init__(self):
self.name = 'xiaowang' # 实例属性
self.age = 20 # 实例属性
p = People()
p.age = 12 # 实例属性
print(p.address) # 正确
print(p.name) # 正确
print(p.age) # 正确
print(People.address) # 正确
print(People.name) # 错误
print(People.age) # 错误
通过实例(对象)去修改类属性
class People(object):
country = 'china' #类属性
print(People.country)
p = People()
print(p.country)
p.country = 'japan'
print(p.country) # 实例属性会屏蔽掉同名的类属性
print(People.country)
del p.country # 删除实例属性
print(p.country)
总结
如果需要在类外修改类属性,必须通过类对象去引用然后进行修改。如果通过实例对象去引用,会产生一个同名的实例属性,这种方式修改的是实例属性,不会影响到类属性,并且之后如果通过实例对象去引用该名称的属性,实例属性会强制屏蔽掉类属性,即引用的是实例属性,除非删除了该实例属性。
静态方法和类方法
- 类方法
是类对象所拥有的方法,需要用修饰器@classmethod来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数(当然可以用其他名称的变量作为其第一个参数,但是大部分人都习惯以’cls’作为第一个参数的名字,就最好用’cls’了),能够通过实例对象和类对象去访问。
class People(object):
country = ‘china’
#类方法,用classmethod来进行修饰
@classmethod
def get_country(cls):
return cls.country
p = People()
print(p.get_country()) #可以用过实例对象引用
print(People.get_country()) #可以通过类对象引用
类方法还有一个用途就是可以对类属性进行修改:
class People(object):
country = ‘china’
#类方法,用classmethod来进行修饰
@classmethod
def get_country(cls):
return cls.country
@classmethod
def set_country(cls,country):
cls.country = country
p = People()
print(p.get_country()) #可以用过实例对象访问
print(People.get_country()) #可以通过类访问
p.set_country(‘japan’)
print(p.get_country())
print(People.get_country())
结果显示在用类方法对类属性修改之后,通过类对象和实例对象访问都发生了改变
- 静态方法
需要通过修饰器@staticmethod来进行修饰,静态方法不需要多定义参数,可以通过对象和类来访问。
class People(object):
country = ‘china’
@staticmethod
#静态方法
def get_country():
return People.country
p = People()
通过对象访问静态方法
p.get_contry()
通过类访问静态方法
print(People.get_country())
总结
从类方法和实例方法以及静态方法的定义形式就可以看出来,类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法;
实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。
静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类实例对象来引用
异常
捕获异常
else
咱们应该对else并不陌生,在if中,它的作用是当条件不满足时执行的实行;同样在try…except…中也是如此,即如果没有捕获到异常,那么就执行else中的事情
try…finally…
try…finally…语句用来表达这样的情况:
在程序中,如果一个段代码必须要执行,即无论异常是否产生都要执行,那么此时就需要使用finally。 比如文件关闭,释放锁,把数据库连接返还给连接池等
异常的传递
如果try嵌套,那么如果里面的try没有捕获到这个异常,那么外面的try会接收到这个异常,然后进行处理,如果外边的try依然没有捕获到,那么再进行传递。。。
如果一个异常是在一个函数中产生的,例如函数A---->函数B---->函数C,而异常是在函数C中产生的,那么如果函数C中没有对这个异常进行处理,那么这个异常会传递到函数B中,如果函数B有异常处理那么就会按照函数B的处理方式进行执行;如果函数B也没有异常处理,那么这个异常会继续传递,以此类推。。。如果所有的函数都没有处理,那么此时就会进行异常的默认处理,即通常见到的那样
注意观察上图中,当调用test3函数时,在test1函数内部产生了异常,此异常被传递到test3函数中完成了异常处理,而当异常处理完后,并没有返回到函数test1中进行执行,而是在函数test3中继续执行
抛出自定义的异常
可以用raise语句来引发一个异常。异常/错误对象必须有一个名字,且它们应是Error或Exception类的子类
class ShortInputException(Exception):
'''自定义的异常类'''
def __init__(self, length, atleast):
#super().__init__()
self.length = length
self.atleast = atleast
def main():
try:
s = input('请输入 --> ')
if len(s) < 3:
# raise引发一个你定义的异常
raise ShortInputException(len(s), 3)
except ShortInputException as result:#x这个变量被绑定到了错误的实例
print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'% (result.length, result.atleast))
else:
print('没有异常发生.')
main()
模块
Python中的模块
有过C语言编程经验的朋友都知道在C语言中如果要引用sqrt函数,必须用语句#include <math.h>引入math.h这个头文件,否则是无法正常进行调用的。
那么在Python中,如果要引用一些其他的函数,该怎么处理呢?
在Python中有一个概念叫做模块(module),这个和C语言中的头文件以及Java中的包很类似,比如在Python中要调用sqrt函数,必须用import关键字引入math这个模块,下面就来了解一下Python中的模块。
说的通俗点:模块就好比是工具包,要想使用这个工具包中的工具(就好比函数),就需要导入这个模块
import
在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。
形如:
import module1,mudule2...
当解释器遇到import语句,如果模块在当前的搜索路径就会被导入。
在调用math模块中的函数时,必须这样引用:
模块名.函数名
from…import
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中
语法如下:
from modname import name1[, name2[, ... nameN]]
例如,要导入模块fib的fibonacci函数,使用如下语句:
from fib import fibonacci
注意
不会把整个fib模块导入到当前的命名空间中,它只会将fib里的fibonacci单个引入
from … import *
把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:
from modname import *
as
重命名
import time as tt
定义自己的模块
在Python中,每个Python文件都可以作为一个模块,模块的名字就是文件的名字。
比如有这样一个文件test.py,在test.py中定义了函数add
test.py
def add(a,b):
return a+b
调用自己定义的模块
那么在其他文件中就可以先import test,然后通过test.add(a,b)来调用了,当然也可以通过from test import add来引入
main.py
import test
result = test.add(11,22)
print(result)