python类和构造方法_Python攻克之路-类和构造方法

1.面向对象介绍

描述：是函数的一个变种,在Python中,有函数式编程和面向对象编程,java和C#之类只能把函数写到类里,没有函数式编程,所以只有面向对象,所以在Python中有了选择,可能就变得有点麻烦,但是在Python里,函数式编程是可以完成所有的功能的,人都是想把事情变得越来越简单,机械化,而在函数式编程中可以使用的代码量和设计比较多,而可能几行代码面向对象就可以实现

分析:

a、Python: 支持函数式,支持面向对象

b、函数式可以做所有的事,但是是否合适？

c、示例

tom, 19, man, go to park

tom, 19, man, go to the hotel

tom, 19, man, go shopping

jerry, 20, man, go to park

jerry, 20, man, go to the hotel

jerry, 20, man, go shopping

函数实现

描述：一般情况下,使用以下函数来实现打印,但是存在一个小问题,前三个和后三个的名字、年龄、性别都是一样的,相当于各自传了三次,在文件操作的情况下,首先找到文件路径,打开文件进行操作,最后要关闭它,对于数据库,实际上也是一样的,要连接它首先知道它的服务器地址,账户密码之类的,如果以下的示例比作数据,前面的名字、年龄,性别类似于数据库的账户和密码之类的,后面的内容就是在数据的增删查改等操作,所以在这里的参数传送不太合适

[root@python3 day1]# cat ob.py

#!/usr/local/python3/bin/python3

def f(name,age,gender,content)

print(name,age,gender,content)

f(tom, 10, man, go to park)

f(tom, 19, man, go to the hotel)

f(tom, 19, man, go shopping)

f(jerry, 20, man, go to park)

f(jerry, 20, man, go to the hotel)

f(jerry, 20, man, go shopping)

类的实现：定义类和创建对象

第一个版本：函数修改成类的形式

class Bar:

def f(self,name,age,gender,content)

print(name,age,gender,content)

obj = Bar()

obj.f(tom, 10, man, go to park)

obj.f(tom, 19, man, go to the hotel)

obj.f(tom, 19, man, go shopping)

2.函数与类的对比

a. 定义

函数：

def + 函数名(参数)

面向对象：

class ==> 类,如bar类,bar是类名

def ==> 在类中有def是方法

类中的方法,第一个参数要写self

b. 执行

函数：

函数名(参数)

面向对象：

a.不对直接访问方法,要先创建名称 = 类名(),相当于创建一个中间人,通过它去访问里面的方法,如obj.f()调用

b.这个obj.f()中间人还有一个别名叫作对象,也可以叫作实例

c.实际是类和对象的应用

Summary: 使用class关键字定义一个类,类中有方法,可以没有方法,但是就没有意义,相当于写个模块里面没功能,然后创建一个对象,通过它来调用方法,而且类的方法就是函数,函数有返回值,类也有返回值

class 类名

def 方法名(self,arg): #self这个参数是特殊的,python内部会自行传值,所以就传一个arg参数就可以

print(arg)

return 1

中间人 = 类名()

ret = 中间人.方法名(1

print(ret) #返回值,函数没有返回值,默认是none

3.self是什么？

写函数时可以传参数,这个是形式参数,self单独说就是一个形式参数,创建类class后的操作,在内存中有一个空间,在类的空间中创建一个方法fuc,创建中间人mid1,也就是在类名后加上括号就可以,相当于在内存里再开辟一段内存空间,mid1是根据类来创建的,中间人只能去找类中的方法,所以它与类之间要有一个关联,在中间人内部有指向类,它叫做类对象指针

代码执行过程：从上到下执行,遇到类又遇到方法,把代码放到内存中,再执行中间人 = 类名(),也就是根据类名创建一个中间人,在内存中开辟新的内存空间,中间人是根据类名加了个括号,所以中间人与类之间是有关联的,再通过中间人去执行方法时,中间人就要找到对应的类,再去类中找到方法,再执行,而且可以再创建一个中间人mid2,也是在类后加一个括号,也是有关联,mid2也可以执行类中的方法

a. 字符串例子分析

s1 = "reid" #这步实际是s1 = str('reid'),s1是str的一个对象,str实际是一个类

s1.upper #s1有upper的方法

b.self在类中的使用

中间人1 = 类名()代表一块内存,中间人2 = 类名()代表的是另一块内存,中间人1要执行类中的方法时,它是自己找类中的方法,而

中间人2也是找到类中同一个方法,类中有一个函数叫f(自定义),这个函数名有一个self,self是python自身传入的参数,实际情况是,

中间人1去执行类中的方法时,self就是中间人1,中间人2执行类中的方法时,self就是中间人2

c. 测试self: self代指调用方法的对象(中间人)

In [1]: class bar: #创建一个类

...: def f(self,arg):

...: print(self,arg)

...:

In [2]: z1 = bar() #

In [3]: print(z1)

<__main__.bar object at> #z1的内存地址

In [4]: z1.f(222)

<__main__.bar object at> 222 #打印self和arg,self内存地址与z1的一样,所以z1执行类中的方法时,self就是z1

In [5]: z2 = bar()

In [6]: print(z2)

In [7]: z2.f(444)

<__main__.bar object at> 444

d.self进一步分析

描述：中间人执行类中的方法时,会把自身传过去,在类中的方法fuc中可以得到中间人,中间人中可以存放内容,中间人执行类中的方法时,可以得到中间人,所以它可以取得中间人里面的内容

In [8]: class bar:

...: def f(self,arg):

...: print(self,self.name,self.age,self.gender,arg)

...:

In [9]: z = bar()

In [10]: z.name='reid'

#相当于在中间人内部写入内容,再通过参数的形式把中间人整体传入类中的方法时,self代指的就是中间人,self.name就是取得reid

In [11]: z.age=19

In [12]: z.gender='male'

In [13]: z.f(33)

<__main__.bar object at> reid 19 male 33 #对应的内容self,self.name,self.age,self.gender,arg

z1与z封装的值不一样,都是一个中间人,共同引用类中的方法

In [19]: z1 = bar()

In [20]: z1.name='lily'

In [21]: z1.age=13

In [22]: z1.gender='female'

In [23]: z1.f(433)

<__main__.bar object at> lily 13 female 433

第二个版本

#!/usr/local/python3/bin/python3

class Bar:

def f(self,content) #self代指的obj.f(),所以name,age,gender可以不用

print(self.name,self.age,self.gender,content) #直接到self中取name,age,gender

obj = Bar()

obj.name= 'tom' #把名字、年龄、性别封装到对象,再去调用obj.f()时只要给它传入参数就可以

obj.age=10

obj.gender='male'

obj.f(go to park) #再次调用时,就传入content

obj.f(go to the hotel)

obj.f(go shopping

第二个版本延伸到数据库使用

描述：在数据库中的增删改查的操作,在它们的内部self都有三个值可以使用,也就没必要一次性再重新给它传入参数,方法中公用的要知道,在类中的方法里,公用的字段可以封装到中间值中,如果不是公用的要传什么就传什么,把值放入到对象的过程叫封装

[root@python3 day1]# cat class_test1.py

#!/usr/local/python3/bin/python3

class Bar:

def add(self,content)

print(self.name,self.age,self.gender,content)

def delete(self,content)

print(self.name,self.age,self.gender,content)

def update(self,content)

print(self.name,self.age,self.gender,content)

def get(self,content)

print(self.name,self.age,self.gender,content)

obj = Bar()

obj.name= 'tom'

obj.age=10

obj.gender='male'

obj.add(go to park)

obj.delete(go to the hotel)

obj.update(go shopping)

4.构造方法

特殊作用：

obj = 类名()

实现两个任务：一般情况执行方法时,是把自身内容传入,这里执行方法时,是内部定义好了,自动会执行一个方法,那个方法名固定了,在内部调用时,会把自身也传递过程

a.创建对象

b.通过对象执行类中的一个特殊方法

第三个版本修改

[root@python3 day1]# vim class_test2.py

#!/usr/local/python3/bin/python3

class Bar:

def __init__(self): #定义一个特殊方法,init方法的特殊别名叫做构建方法

print('123')

z = Bar() #这行代码有两个功能,先创建z对象,还会执行特殊Init方法,init方法中有self是z本身,所以会先输入123,再输出z

print(z)

[root@python3 day1]# python3 class_test2.py

123

<__main__.bar object at> #z

区别: 两者区别是认证调用的

def __init__(self): #内部方法是Python自动调用的,只要类后面加上括号就自动执行

print('123')

def f(self): #主动调用(程序号),通过类型于z.f()形式调用

print('567')

init的操作使用

描述：一般在创建对象时,会把一些公用的字段都放入init方法,init方法一般用于初始化,因为创建对象时,有些是需要先创建,当执行obj = 类(),python内部会自动调用init方法来执行,如果init中没写代码,相当于没有写,所以init就是类后面加上括号,python自动执行

class Bar:

def __init__(self,name,age):

print('123')

z = Bar('reid',99)

#通过调用执行方法,执行时要传入参数,默认只加括号,传入参数后name是reid,age是99,self就是z

class Bar:

def __init__(self,name,age):

print('123')

z.n = name #相当于在中间人中z加了个n等于name,name等于传入的reid,这个操作是把赋值放在类的init的方法中

z.a = age

z = Bar('reid',99) #self代指z,只要执行这行代码,默认就会执行__init__

init的实例

实例1：

class Bar:

def f(self):

print(self.name)

z = Bar()

z.name1='reid'

z.name2='tom'

z.name3='jerry'

z.name4='kate'

#在这里要写这么多,这时内部写的,如果有个地方处理这些,而且在调用时,只需要两句代码就可以实现,就变得方便,

把构造的工作放在init来做,直接调用

修改为：

class Bar:

def __init__(self,n1,n2,n3,n4):

self.name1=n1 #实际与外部操作z.name1=n1是一样的

self.name2=n2

self.name3=n3

self.name4=n3

def f(self):

print(self.name1,self.name2,self.name3,self.name4)

z = Bar(1,2,3,4) #这时工作就直接交给init,一堆的工作,在这行代码中就变得方便了

z.name1 #执行这行时是直接可以访问的,因为init已经执行过

z.f() #构造方法时,已经把值封装到对象中,所以也可以直接访问

[root@python3 day1]# python3 class_test2.py

1

1 2 3 3

实例2：

root@python3 day1]# cat class_test3.py

#!/usr/local/python3/bin/python3

class person:

def __init__(self,name,age):

self.n = name

self.a = age

def show(self):

print('%s-%s' %(self.n, self.a))

t = person('tom',19) #t是一个对象

t.show()

j = person('jerry',30)

j.show()

[root@python3 day1]# python3 class_test3.py

tom-19

jerry-30

实例3：

描述：如下人的例子,假设要每个人的血型都是0

[root@python3 day1]# cat class_test3.py

#!/usr/local/python3/bin/python3

class person:

def __init__(self,name,age):

self.n = name

self.a = age

self.x = 'o' #直接让每个人都是o型血

def show(self):

print('%s-%s' %(self.n, self.a,self.x))

t = person('tom',19) #t是一个对象

t.show()

j = person('jerry',30)

j.show()