一、Python基础

1.1 注释

定义和作用

对代码解释说明，增强可读性

单行注释

#

多行注释

"""

这是一个多行注释

""" 

1.2 变量及变量类型 

定义和作用

计算机目的是计算，编程是为了更方便计算，计算对象就是变量，可以在程序运行过程中，临时存储数据 

变量基本使用

变量初始化

变量名  =  变量值 

a = 200

a = 100        变量值可以变化

b = 100

c = 300

d = b + c        变量可以运算

print(变量名)        直接调用即可输出 

遇到不同类型的数据怎么办,怎么用变量来存储？
例如

• 小伙的名字叫鲁班
• 今年18岁
• 身高一米半半
• 是个纯爷们儿

name = "鲁班"
age =18
height = 1.55
is_man = True

变量是什么类型的,取决于它储存的数据的类型,常用的数据类型有:

• 数字 number: 其中整数 int, 浮点数 float
• 字符串 str (也叫 string)
• 布尔类型 bool (也叫 boolean)
• 列表 list
• 元组 tuple
• 字典 dict

# 可以使用type()函数，来获得数据的类型

print(type(1))
print(type(name)) 

 1.3 标识符和关键字

什么是标识符
标识符就是程序中用来标识变量,函数,类或其他对象的名字
标识符的命名规则

• 只能包含字母,数字,下划线,中文(不推荐)
• 不能以数字开头区分大小写 (如 Andy 和 andy 是不同的标识符)
• 不能是python的关键字 （关键字是Python已经使用的有特殊功能的标识符）。

 变量命名规范
变量名应简短而有意义,如: name="张三",尽量别用 a="张三'单词使用小写字母,多个单词用下划线分割,如 total sum,user name

文件的命名和函数的命名都可以参照这种规范,后续类的命名会有一点区别

1.4 输入和输出 

对输入和输出的理解

• 生活中,例如去ATM取款你的卡,输入的密码和金额, 都是输入,ATM机吐的卡和钱都是输出
• 软件里也一样,你操作软件的过程都是输入,软件反馈的结果都是输出 

print("我爱中国")

# 换行打印，\n 后的内容会在下一行打印
print(“我爱\n中国")

# 为了输出信息更完整，经常在print()语句中使用,来拼接多个值
slogan="我是纯爱战神
print(slogan)
print("我的s1ogan是:"，slogan)print("我的s1ogan是:"，1)

常见的获取键盘输入
可以使用 input()函数等待并获取用户键盘上的输入,用户以回车结束输入,输入内容被认为是字符串

print(1)
input()
print(2)
password =input()
print(password)
# 推荐格式 变量名 = input"提示信息:")
password =input("请输入密码:")
print(password)

关于函数：
函数可以是别人或自己写的,可以直接使用,不用关心内部实现,目前学过的函数有:print()type()input()

 类型转换函数

first_number = input("请输入第一个数字:")
second_number = input("请输入第二个数字:")
result =first_number +second_number
print("计算结果是:"，result)
# 计算结果出错，因为数据类型是字符串，相加的效果是拼接的计算，不是数值上的相加
# 改为
result=int(first_number)+int(second_number)

常用的几个类型转换函数

• int(x)表示将 x转换为一个整数
• float(x) 表示将 x转换为一个浮点数
• str(x)表示将x转换为一个字符串
• bool(x)表示将 x转换为一个布尔类型 

1.5 运算符

按优先级从最高到最低：

 1.6 判断语句

if-elif-else判断语句结构 

if 条件1:

        事情1

elif 条件2:

        事情2

elif 条件3:

        事情3
else:
        事情4

说明：

• 如果满足条件1，执行事情1,代码块执行结束
• 否则，如果满足条件2,执行事情2,代码块执行结束
• 否则,如果满足条件3,执行事情3,代码块执行结束
• 否则，执行事情4,代码块执行结束

代码示例：

score =77
if 90 <= score <= 100:
    print("本次考试成绩为A")
elif 80 <= score < 90:
    print("本次考试成绩为B")
elif 70 <= score < 80:
    print("本次考试成绩为C")
elif 60 <= score < 70:
    print("本次考试成绩为D")
else:
    print("本此考试成绩不及格"
#也可以写成 if score >= 90 and score <= 100:

if嵌套判断：

a=“帅”
b="善"
c="没有腹肌"
if a =="帅":
    if b ==“善”:
        if c =="有腹肌":
            print("处对象")

match-case判断

match x:
case 1:
    print('x is 1")
case 2:
    print(“x is 2")
case 3:
    print("x is 3")

1.7 循环

Python三大控制结构：顺序、分支、循环，用于控制代码执行顺序

•  顺序: 从上而下,顺序执行代码
• 分支: 根据条件判断,确定执行哪个分支的代码
• 循环: 让特定代码块中的代码重复执行

1.7.1 while循环 

基本语法

当 条件(满足时):

        要做的事
while True:
        print("He1lo world")
# 上面缺少了条件限制，导致了死循环

i=0
while i < 5:
        print("He11o world")
        i=i+1 

计算1-100的和

i= 1
sum=0
while i <= 100:
    sum=sum +i
    i=i+1
print(sum)

计算1-100的偶数和 

i = 1
sum=0
while i <= 100:
    if i%2 == 0:
        sum= sum + i
    i = i+1
print(sum)

while嵌套

whi1e(天)条件:
    事
    while(题)条件:
        事
day = 1
while day <= 7:
    print("今天是第"， day，"天")
    problem=1
    while problem <= 3:
        print("做了"，problem，“道题”)
        problem += 1
    day += 1

1.7.2 for循环 

python 中的 for 循环, 可以遍历任何可迭代对象, 如: 字符串,列表,元组,字典

遍历可迭代对象:指按顺序,逐一得到全部数据,且无遗漏

for x in "abcdefg":
    print(x)
# 如果固定需要循环100次怎么办
for i in range(100):
    print(i)
# 效果等同于
i=0
while i < 100:
    print(i)
    i+= 1

a=range(5)        

# range()函数返回的是一个可迭代对象(类型是对象)，打印时不能直观看到数据
b=list(a)        

# list函数可以把可迭代对象转为一个列表
print(b)

1.7.3 break和continue

break
作用: 立即终止当前循环,并跳出循环体外,并继续执行循环之后的代码

i = 1
while i<=5:
    print(i)
    if i == 3:
        break
i += 1
print(i)

for x in "abcdefg":
    if x == "e"
        break
    print(x)
print(x)

continue
作用: 跳过本次循环中的剩余代码，直接进入下一次循环

会导致死循环#
i = 1
while i <= 5:
    print(i)
        if i == 3:
            continue
    i += 1
# 死循环的修改思路i= 1
while i <= 5:
    i += 1
        if i == 3:
            continue
    print(i)

for x in "abcdefg":
    if x == "e"
        continue
    print(x)

注意点
break 和 continue 只能用在循环中,除此以外不能单独使用

break 和 continue 在嵌套循环中,只对最近的一层循环起作用 

二、Python高级数据类型 

2.1 字符串 

什么是字符串：双引号或者单引号中的数据就是字符串 

"123456""3.14""{[()]}'"!@#$%^'
震惊
print(type(a))

字符串格式化

字符串格式化就是把变量嵌入到字符串中,推荐使用字符串.format()

#电子生日贺卡中的祝福语，"He110 xx，祝你 xx岁生日快乐!"
name ="张三
age =18
print("He11o"，name，",祝你"，age，"岁生日快乐!")
print(“He11o {}，祝你{}岁生日快乐!".format(name，age))

# 自定义名片
name = input("请输入你的名字:")#张三
position =input("请输入你的职位:")#软件测试工程师
company_name -input("请输入你的公司名:")#法外狂徒股份有限公司
print(“_”* 30)
print("姓名:{}".format(name))
print("职位:{}".format(position))
print("公司名称:{}".format(company_name))
print(“_” * 30)

字符串的下标
含义:下标其实就是编号,比如高铁上的座位号,超市储物柜的编号,用 字符串[下标]表示,如“abc"[1]

s="abcdef"
#下标从左往右，从0开始
print(s[0])
print(s[3])
print(s[6])#
# 超出下标范围会标错
#还有一套下标是从右往左，从-1开始
print(s[-1])
print(s[-2])
print(s[-6])

 切片

• 含义：切片指截取其中一部分，字符串/元组/列表都支持切片
• 语法: [起始下标:结束下标:步长],从起始位开始,到结束位为止(不包含结束位本身),步长表示切片间隔 

a="abcdefgh"
print(a[:])        #取所有，默认步长为1
print(a[::2])      #取所有，步长为2
print(a[:3])       #取前3位
print(a[5:])       #取第5位以后的内容
print(a[1:5])      #取第2,3,4，5位
print(a[1:5:2])    #取第2位和第4位
print(a[1:-1])     #取第2位到倒数第2位
print(a[5:1:-2])   #反向(从右向左),取第6位和第4位
print(a[::-1])     #:反转字符串

字符串常见操作 

 len(),获取字符串长度

s="听君一席话,如听一席话"
print(len(s))

find() 和 index(),检测字符串中是否包含某个子串,如果包含,则返回第一个找到的子串的初始下标

s="听君一席话,如听一席话!"
print(s.find(","))
print(s.index(","))
# 区别在于，如果找不到，find 返回-1，index则抛出异常
print(s.find("二"))
print(s.index("二"))
#[了解]s.find(sub，start,end)中
#start 表示搜索的起始位置，默认为0[可选]
#end 表示搜索的结束位置，默认为字符串的长度[可选]
# index()也支持这种写法
print(s.find("一席话”，0，11))
print(s.find("一席话”，6，11))

replace(),替换字符串中的某些子串,可以控制替换次数 

s="听君一席话,如听一席话"
print(s.replace("一","二"))
print(s.replace("一","二"，1))

count()，返回字符串中某个子串出现的次数

s="听君一席话,如听一席话"
print(s.count("一席话"))
print(s.count("一席话"，6，11))

split(), 以某字符为分隔符进行切片,如果 maxsplit 有指定值,则仅分割 maxsplit 次

s="听君一席话,如听一席话"
print(s.split("一"))
print(s.split("一",1))

startwith()和 endwith(),检査字符串是否以某子串为开始或结束,是则返回 True,否则返回 False

s="听君一席话,如听一席话"
print(s.startswith("听君"))
print(s.endswith("话"))

lower()和 upper(),把字符串中的所有字符转换为 小写 或 大写 字符

s="Hello world"
print(s.lower())
print(s.upper())

join() 格式为 分隔符.join(数据),数据可以是字符串,列表, 元组,字典,返回值是字符串

s="听君一席话,如听一席话!"
print("~".join(s))
l =[“广东省"，“广州市"，"天河区..."]
print("".join(l)) 

[了解]除了上述常见操作外,字符串单词首字母大写,字符串的对齐,判断字符串是否只包含空格等各种操作 

2.2 列表

什么是列表
列表(List)是 python 中使用非常频繁的数据类型,在其他语言中通常叫做 数组.语法上用[]来定义一个列表,数据之间用，分割,例如:

name_list =["张三”,"李四",“王五”]

列表的索引从0开始(索引就是下标),引用超出索引就会抛出异常 

name_list =〔"张三","李四","王五"]
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(name_list[3])

列表可以储存不同类型的数据

name_list=["张三",100,[1,2]]
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(name_list[3]) 

 

列表的遍历

name_1ist =["张三","李四","王五"]
for name in name_list:
    print(name)

i=0
while i < len(name_1ist):
    print(name_list[i])
    i += 1 

列表增删改查操作 

• append：list.append()        把数据加到列表末尾
• extend：list.extend()          把一个可迭代对象逐一添加到列表中
• insert：list.insert(列表元素,"要添加的元素")        在指定位置前插入数据
• pop：list.pop(索引)        根据索引删数据
• remove：list.remove(值)        根据列表中元素值删数据
• list[索引]=值        改列表数据
• in 和 not in 用于判断列表中是否存在某数据,成功为True,失败为False
• index和count,与字符串中的用法相同

排序：sort方法是将列表按顺序正序排列，默认从小到大，参数reverse=True可改为倒序

注意: 需要排序的列表中的数据需要是同一类型的，同时存在整数和字符串就不能排序

列表生成式 

# 列表生成式顾名思义，可以帮我们生成列表
# 生成0~9的10个数
a=[x for x in range(10)]
print(a)
# 生成1~10
b=[x for x in range(l, 11)]
print(b)
# 生成10以内的奇数/偶数
c=[x for x in range(1，11) if x%2==0]
d=[x for x in range(1,11) if x%2==1]
print(c)
print(d)
# 生成10以内的各数的平方
e=[x**2 for x in range(l，11)]
print(e)

2.3 元组

什么是元组
元组 (Tuple)是与列表类似,语法上用()来定义一个元组

l=[1，2，3]
t=(1，2，3)
print(type(l))
print(type(t))

元组常见操作 

• 元组中的数据不能修改
• 对元组内的数据的操作只支持查询类操作，如:index,count 

2.4 集合

 什么是集合

• 集合(Set),和列表,元组都很像,区别就是集合用于保存不重复的数据
• 语法上,使用 {} 或者 set()进行创建
• 集合也是可变的数据类型,可以有增删改查等各种操作

# 使用{}创建集合
collection={1,2,3,4}
print(type(collection))
# [推荐]使用set()函数创建集合，集合最主要的作用就是去重
l=[1,2,3,3]
t=(1,2,3,3)
c1=set(l)
c2=set(t)
print(c1,type(c1))
print(c1,type(c2))

2.5 字典 

 什么是字典
字典 (Dict),语法上用 {}来定义一个字典,数据之间用,分割,每个数据都是键值对的形式,包含键名(key)和键值(value)两个部分，例如:

d = {}
print(type(d))
t_info ={"name":"杰哥","sex":"男","age":18，"address":"广州"，"hobby":["吹牛","看电影"]}

字典中找某个数据不是根据下标来找的,是根据key, 如:
 

t_info ={"name":"杰哥”,"sex":"男"，"age":18，"address":"广州"，"hobby":["吹牛"，"看电影”]}
print(t_info["name"])
print(t_info["hobby"])

字典的常见操作
增,使用 变量名[“键“〕 = 值 时,如果”键"在字典中不存在,就会新增这个数据

t_info = {"name":"杰哥"，"sex":"男"，"age":18,"address":"广州"，"hobby":["吹牛"，"看电影"]}
t_info["score"]= 10
print(t_info)

删,pop和 clear 方法

t_info ={"name":"杰哥","sex":"男","age":18，"address":"广州"，"hobby":["吹牛","看电影"]}
t_info.pop("age")
print(t_info)
t_info.clear()
print(t_info) 

 

改, 和新增一样, 使用 变量名[“键"〕= 值 时, 如果"键"在字典中存在,就好更新这个值

查：

t_info ={"name":"杰哥","sex":"男","age":18，"address":"广州"，"hobby":["吹牛","看电影"]}
# 查询某个键对应的值
# print(t_info["a"])
# 键不存在时会报错
print(t_info.get("a"))
# 键不存在时会返回 None

# 查询字典的长度
print(len(t_info))

# 查询字典中的键列表,值列表，键值对元组的列表(以前返回列表，新版本python不再返回列表类型，但可以当做列表来使用)
print(t_info.keys())
print(t_info,values())
print(t_info.items())

# 遍历
for key in t_info.keys():
    print(key)
for value in t_info.values():
    print(value)
for item in t_info.items:
    print(item)
for key,value in t_info.items():
    print(key，value)

python中有哪些数据类型,其中可变和不可变得数据类型都有什么?
常见的数据类型有整型int,浮点型float,布尔bool, 字符串string,列表list,元组tuple,集合set,字典dictionary

• 其中可变数据类型有: 列表,集合,字典
• 不可变数据类型有: 数字,布尔,字符串,元组 

三、Python的函数 

3.1 函数介绍

函数定义：可以被重复使用的代码块

使用步骤：定义函数，封装独立功能，调用函数

查看函数使用文档：print(help(函数)) 

3.2 函数的参数 

def add_2num():
    x=1
    y= 2
    print(x+y)
add_2num()
# 这个函数只能把固定的两个数相加，怎么样让这个函数适用于可变的两个数相加，答案就是参数
def add(x，y):
    print(x+y)
add(2，3)

参数的基本含义：

• 形参: 在定义时使用的,用于在调用时接收变量值的形式参数 (如上述代码中的x和 y)
• 实参: 在调用时传入的实际参数值(如上述代码中的 2和 3)

注意

# 注意，调用参数时,参数的位置和数量是一致的
# add(1，2，3)    # 参数数量不一致会报错
add(y=1，x=2)     # 如果位置需要变动，则需要以 变量名=参数值 的形式传参
# 参数的默认值 (缺省值)，需保证带有默认值的参数在未尾，def add(x=1，y): 是错误的
def add(x，y=1):
    print(x+y)
    add(1)
add(2，2)

参数拓展

# def len(*args，**kwargs):在这个定义中 *args 和 ** kwargs 是什么?
# 这些用于传参数量不确定的情况
# *args 用于接收不确定个数的参数，"它会将传入的参数打包成一个元组
def demo(*args):
    print(args)
demo(1，2，3)
demo((4，5，6))
demo()
# **kwargs 用于接收不确定个数的关键字参数(键=值)，并打包成一个字典
def demo(**kwargs):
    print(kwargs)
demo(a=1，b=2，c=3)

 

说明
args 和 kwargs 是可以改变名字的,但不推荐, args 是arguments (参数的缩写), kw 是keyword (关键字)的缩写
参数定义是有顺序的: 必选参数,默认参数,可变参数,如：

def demo(a,b,c=1,*args,**kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)
demo(1,2,3,4,5,6,aa=7,bb=8,cc=9)

3.3 函数的返回值 

什么是返回值
在程序开发中,有时候会希望一个函数执行结束后,告诉调用者一个结果,这个结果就是返回值

• 语法上,使用 return 这个关键字来返回结果 

def add(x,y):
    print(x+ y)
    a= add(1，2)
print(a)    # 结果是 None，说明add函数只关注打印和的过程，没有返回值
def add(x，y):
    return x+y
a= add(1，2)
print(a)print(add(a，3))

#函数执行到了 return 就会结束
demo():
    print(1)
    print(2)
    return 0
    print(3)
    print(4)
demo()

3.4 函数的执行过程

# 函数中三大结构和嵌套调用时的执行过程
def demo1():
    print(1)
    print(2)
    print(3)
def demo2():
    print(1)
    if True:
        print(2)
    print(3)
def demo3():
    print(1)
    for i in range(3)
    print(2)
    print(3)
def demo4_a():
    print("a_start")
    print("a_stop")
def demo4_b():
    print("b_start")
    demo4_a()
    print("b_stop")

demo1()
demo2()
demo3()
demo4_b()
demo4_a()

3.5 局部变量和全局变量

局部变量和全局变量

• 从含义上说,局部变量定义在函数内部,全局变量定义在函数外部

从作用域的角度说

• 局部变量只能在函数内部使用,函数执行结束后,变量会被回收,不同函数可以有同名的局部变量。
• 全局变量可以在全局使用 (不论函数内外),但如果全局变量太多可能导致不好维护

局部变量是在函数内部定义的变量,只能在函数内部使用

注意：

• 局部变量和全局变量是个相对的概念,示例中的局部是函数内部,全局是文件全局
• 未来大家可能会接触到作用域更大的变量,比如整个项目都可以使用的,这种也是全局变量

如何在函数内部修改全局变量 

# 在函数内部定义与全局变量同名的变量时，两个变量是不同的，并不能直接修改全局变量
a =1
    def demo():
    a =2
demo()
print(a)

# 可以使用 globa] 关键字引用全局变量
b=1
def demo():
    global b
    b=2
demo()
print(b)

 3.6 匿名函数lambda

# 匿名函数的定义语法是 Tambda 参数:表达式
# 匿名函数中不能使用 print，表达式就是返回值(无需写return)
# lambda x,y:x+y    #这样就定义了一个两个数相加的匿名函数

# 应用1
sum=lambda x,y:x+y
print(sum(1,2))

#应用2，在高阶函数中，作为参数传递
def sq(x):
    return x**2
print(list(map(sq,[xfor xin range(10)])))
print(list(map(lambda x:x**2,[xfor xin range(10)])))

四、面向对象编程（OOP） 

4.1 基本理解

面向对象和面向过程编程思想

两种思想的区别

• 面向过程: 强调的是步骤,过程,每一步都是自己亲自去实现 用怎么做的思想来解决问题
• 面向对象:找个对象,让对象来实现(专业的人干专业的事儿),用谁来做的思想来解决问题
• 面向对象是基于面向过程的

面向对象编程的优点

• 面向过程: 根据业务逻辑从上到下写代码(之前的函数式编程, 都是面向过程的)
• 面向对象: 减少了重复代码,高度封装,易扩展

4.2 类和对象

类是抽象的，对象是一个具体的事物

# 定义一个Dog类
class Dog:
    pass
# 定义一个对象dahuang
dahuang = Dog()
xiaobai = Dog()
# isclass函数 用于判断是不是一个类，True表示是类 False表示不是类
# print(inspect.isclass(Dog))
# print(inspect.isclass(dahuang))
#ctr1 + D 快速辅助并粘贴到下一行

# type函数，表示查看一个数据的类型# print(type(1))
# print(type(dahuang))

# isinstance函数来判断参数1是否是参数2的一个实例(对象)
# print(isinstance(l,int)
# print(isinstance(dahuang, Dog))

# id函数，可以查看变量的内存地址
print(id(dahuang))
print(id(xiaobai))

 4.2.1 类的构成

类 是对一群具有相同的特征或者行为的事物的统称

• 特征 被称为 属性
• 行为 被称为 方法

如何体现对象和对象之间的区别?
通过属性和方法来体现同一个类的不同对象的区别

类由3个部分构成

• 类的名称: 类名
• 类的属性: 拥有的特征 (名词)
• 类的方法: 拥有的能力(动词)

示例
"人"类 

• 类名:Person
• 属性: 国籍, 性别,年龄,身高, 体重...
• 方法: 学习,跑,打游戏... 

注意
在程序开发过程中,只关注需求中涉及的属性和方法
        如一个人的身份证上不会记录身高,体重等属性,也不需要知道这个人游戏打得好不好 

4.2.2 类的设计

开发人员如何分析需求,确认程序中需要包含哪些类?

用名词提炼法分析业务，出现的名词,通常就是找到的类 

4.3 基础语法 

4.3.1 定义类和对象

# 创建类
class Hero():
# 定义属性
    hp =1000
# 定义函数
    def info(se1f):
        print("我是一个英雄")
# 或者
class Hero:
    hp =1000
        def info(self):
            print("我是一个英雄")

# 创建对象
anqila = Hero()

说明

• 类名的命名规则按照"大驼峰命名法",每个单词的首字母大写,单词和单词之间没有下划线
• info 是一个实例方法,第一个参数一般是self, 表示实例对象本身,当然了可以将self换为其他名字,其作用是一个变量,这个变量指向了实例对象

4.3.2 类中的方法

4.3.2.1 魔术方法

有些特殊方法,在python代码执行时可以自动调用,这些方法被称为魔术方法

• 魔术方法名的两侧各有2个下划线
• 常用的魔术方法有__init__，__str__,__del__等
• 软件测试人员最常用的是__init__方法,用来完成属性的初始化,它在创建对象时默认执行 

class Hero:
    def _init_(self):
        self.name = None
        self.sex= None
        self.hp=0
        self.attack=0
    def info(self):
        print("我是一个英雄")


anqila=Hero()
chengyaojin=Hero()
print(anqila.name)
print(anqila.sex)
print(anqila.hp)
print(angila.attack)
print(chengyaojin.name)
print(chengyaojin.sex)
print(chengyaojin.hp)
print(chengyaojin.attack)

每个对象好像有自己的属性，又没有 

class Hero:
    position ="泉水"
    def __init__(self,name,sex,hp, attack):
        self.name =name
        self.sex=sex
        self.hp =hp
        self.attack =attack
    def info(self):
        print("我叫{}，性别{，血量为{}，攻击力为{}".format(self.name,self.sex,self.hp,self.attack))

anqila=Hero("安琪拉","女",1000，200)
chengyaojin = Hero("程咬金”,"男”,8000,666)
print(angila.position)
angila.info()
chengyaojin.info()

 类属性和实例属性

Class 类名:
    # 类属性，表示的是类的共性，如汽车类，共性的内容有，有轮子，有座椅，有方向盘，有挡风玻璃
    类属性名1 = 值1
    类属性名2 = 值2

    # 实例属性，表示的是对象(实例)的个性，轮子数量，轮毂样式，座椅数量，是不是敞篷
def __init__(se1f，参数1，参数2):
    self.实例属性名1= 参数1
    se1f.实例属性名2 = 参数2

4.3.2.2 实例属性 

特点：

• 实例方法是每个对象独有的
• 实例方法需要带 se1f 参数
• 主要用于处理实例属性，也可以访问其他实例方法 

def 实例方法(self,参数):
    pass

调用：类.实例方法（参数） 

4.3.2.3 类方法 

特点

• 类方法是针对类定义对的方法
• 类方法需带 c1s 参数
• 主要用于处理类属性,也可以访问其他类方法

语法：

@classmethod
def 类方法名(c1s):
    pass

类方法需要用装饰器 @classmethod 来标识, 告诉python解释器这是一个类方法

调用
类名.类方法名()
 

class Hero:
    born_position ="泉水"
    def __init__(self,name,sex, hp, attack):
        self.name = name
        self.sex=sex
        self.hp= hp
        self.attack =attack
    def info(self):
        print("我叫{}，性别{}，血量为{}，攻击力为{}".format(self.name，self.sex，    self.hp,self.attack))

    @classmethod
    def where_was_i born(cls):
        print("我在{}出生".format(cls.born_position))
# angila = Hero("安琪拉","女",1000,200)
# chengyaojin = Hero("程咬金","男",8000,666)
    
    @staticmethod
    def haha():
        print("哈哈哈")

Hero.where_was_i born()
Hero.haha()

 4.3.2.4 静态方法

特点
如果想在类中封装一个方法,既不需要访问实例属性和类属性,也不需要访问实例方法和类方法这个时候,就可以把这个方法封装成一个静态方法
语法

@staticmethod
def 静态方法名():
    pass

静态方法需要用装饰器 @staticmethod 来标识,告诉python解释器这是一个静态方法
调用
类名.静态方法名()

小结

• 实例方法,方法内部需访问 se1f.属性名 的实例属性, 也可以访问 类名.属性 的类属性
• 类方法,方法内部只需要访问类属性
• 静态方法,方法内部不需要访问任何属性