Python

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)

在这里插入图片描述
总结
如果需要在类外修改类属性,必须通过类对象去引用然后进行修改。如果通过实例对象去引用,会产生一个同名的实例属性,这种方式修改的是实例属性,不会影响到类属性,并且之后如果通过实例对象去引用该名称的属性,实例属性会强制屏蔽掉类属性,即引用的是实例属性,除非删除了该实例属性。

静态方法和类方法

  1. 类方法
    是类对象所拥有的方法,需要用修饰器@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())
结果显示在用类方法对类属性修改之后,通过类对象和实例对象访问都发生了改变

  1. 静态方法
    需要通过修饰器@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)
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值