面向对象编程 python,python面向对象编程指南

　　本文详细讲解Python的面向对象编程，通过示例代码详细介绍。对大家的学习或者工作都有一定的参考价值，有需要的朋友可以参考一下。

　　00-1010 1.在程序中定义类和对象，定义类2，定义对象2，自定义对象的独有特征1，引入它们2，自定义对象的独有特征3，对象属性的搜索顺序4，自定义类定义阶段的属性3，对象的绑定方法1，类使用对象的绑定方法2，对象使用对象的绑定方法4。Python面向对象的类和数据类型编程(1)

　　Python面向对象编程(2)

　　Python面向对象编程(3)

　　与其他编程语言相比，Python在尽可能不增加新的语法和语义的情况下，增加了类机制。

　　Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以重写基类中的任何方法，可以调用基类中同名的方法。

　　对象可以包含任意数量和类型的数据。

目录

一、程序中定义类和对象

　　定义函数时，函数只检测语法，而不执行代码。但是，当定义一个类时，类体代码将在类定义阶段立即执行，并生成一个类命名空间。也就是说，类本身其实就是一个容器/命名空间(__dict__)，用来存储名字。这是类的用途之一。

　　语法如下：

　　类类名：。

　　实例化一个类后，就可以使用它的属性了。事实上，在创建了一个类之后，可以通过类名来访问它的属性。

　　使用类名来访问其属性：

　　#注意，类中定义的变量使用驼峰体。

　　班级老男孩学生():

　　学校=老男孩

　　def choose_course(self):

　　打印(“正在选择课程”)

　　打印(OldboyStudent。__字典_ _)

　　# {__module__: __main__ ， school: oldboy ， choose_course: OldboyStudent 对象的__dict__:属性 __dict__ ， OldboyStudent 对象的__weakref__:属性 __weakref__ ， old boy student 对象的__doc__: None}

　　打印(OldboyStudent。__dict__[学校])

　　#老男孩

　　打印(OldboyStudent。__dict__[choose_course])

　　#

　　尝试：

　　老男孩学生。__dict__[choose_course]()

　　e:除外

　　打印(错误： ，e)

　　# error: choose_course()缺少1个必需的位置参数：“self”

　　打印(OldboyStudent.school)

　　#老男孩

　　print(old boy student . choose _ course(111))

　　#正在选择课程

　　打印(OldboyStudent.choose_course)

　　#

　　OldboyStudent.country=中国

　　打印(OldboyStudent。__dict__[country])

　　# 中国

　　德洛尔德博伊学生学校

　　打印(OldboyStudent。__字典_ _)

　　# {__module__: __main__ ， choose_course: OldboyStudent 对象的__dict__:属性 __dict__ ， old boy student 对象的__weakref__:属性 __weakref__

　　OldboyStudent objects>, __doc__: None, country: CHINA}

2、 定义对象

　　调用类即可产生对象，调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例。

stu1 = OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
　　print(stu1.school) # oldboy
　　stu2 = OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
　　print(stu2.school) # oldboy
　　stu3 = OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
　　stu3.choose_course() # is choosing course

二、定制对象独有特征

1、引入

　　对于上述的学生类，如果类的属性改了，则其他对象的属性也会随之改变

class OldboyStudent():
　　 school = oldboy
　　 def choose_course(self):
　　 print(is choosing course)
　　stu1 = OldboyStudent()
　　stu2 = OldboyStudent()
　　<strong>OldboyStudent.school</strong> = OLDBOY
　　print(stu1.school) # <strong>OLDBOY</strong>
　　print(stu2.school) # OLDBOY

2、定制对象独有特征

　　对象本质类似于类，也是一个名称空间，但是对象的名称空间存放对象独有的名字，而类中存放的是对象们共有的名字。

　　因此我们可以直接为对象单独定制名字。

print(stu1.__dict__) # {}
　　print(stu2.__dict__) # {}
　　stu1.name = tank
　　stu1.age = 18
　　stu1.gender = male
　　print(stu1.name, stu1.age, stu1.gender)
　　# tank 18 male
　　try:
　　 print(stu2.name, stu2.age, stu2.gender)
　　except Exception as e:
　　 print(e)
　　# OldboyStudent object has no attribute name
　　stu2.name = sean
　　stu2.age = 19
　　stu2.gender = female
　　print(stu2.name, stu2.age, stu2.gender)
　　# sean 19 female

3、对象属性查找顺序

　　首先从自身查找，没找到往类中找，类中没有则会报错。即对象的属性查找顺序为：自身—>类—>父类—>报错。

class OldboyStudent:
　　 school = oldboy
　　 count = 0
　　 aa = 10 #类的的公共变量aa
　　 def __init__(self, x, y, z): # 会在调用类时自动触发
　　 self.name = x # stu1.name=耗哥
　　 self.age = y # stu1.age=18
　　 self.sex = z # stu1.sex=male
　　 OldboyStudent.count += 1
　　 # self.count += 1
　　 self.aa = 1 #对象的私有变量aa
　　 def choose_course(self):
　　 print(is choosing course)
　　print(OldboyStudent.count) # 0
　　stu1 = OldboyStudent(nick, 18, male)
　　print(stu1.count) # 1
　　stu2 = OldboyStudent(sean, 17, male)
　　print(stu2.count) # 2
　　stu3 = OldboyStudent(tank, 19, female)
　　print(stu3.count) # 3
　　print(OldboyStudent.count) # 3
　　# 由于上述修改的是类属性，类属性的count已经被修改为3，所以其他实例的count都为3
　　print(stu1.count) # 3
　　print(stu2.count) # 3
　　print(stu3.count) # 3
　　# 由于aa是私有属性，因此stu们都会用自己私有的aa，不会用类的aa。count也不属于对象
　　print(stu1.__dict__) # {name: nick, age: 18, sex: male, aa: 1}
　　print(stu2.__dict__) # {name: sean, age: 17, sex: male, aa: 1}
　　print(stu3.__dict__) # {name: tank, age: 19, sex: female, aa: 1}

4、类定义阶段定制属性

　　类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

　　调用类时发生两件事：

• 创造一个空对象
• 自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入。

class OldboyStudent:
　　 school = oldboy
　　 def __init__(self, name, age, gender):
　　 """调用类的时候自动触发"""
　　 self.name = name
　　 self.age = age
　　 self.gender = gender
　　 print(* * 50)
　　 def choose_course(self):
　　 print(is choosing course)
　　try:
　　 stu1 = OldboyStudent()
　　except Exception as e:
　　 print(e)
　　# __init__() missing 3 required positional arguments: name, age, and gender
　　stu1 = OldboyStudent(nick, 18, male)
　　# **************************************************
　　print(stu1.__dict__) 
　　# {name: nick, age: 18, gender: male} #没有school

三、对象的绑定方法

• 类名称空间中定义的数据属性和函数属性都是共享给所有对象用的

  　　

• 对象名称空间中定义的只有数据属性，而且是对象所独有的数据属性。

  　　

1、类使用对象的绑定对象

　　类中定义的函数是类的函数属性，类可以使用它，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个

class OldboyStudent:
　　 school = oldboy
　　 def __init__(self, name, age, gender):
　　 self.name = name
　　 self.age = age
　　 self.sex = gender
　　 def choose_course(self):
　　 print(f{self.name} choosing course)
　　 def func(self):
　　 print(from func)
　　print(OldboyStudent.choose_course)
　　# <function OldboyStudent.choose_course at 0x00000000023AEF70>
　　try:
　　 OldboyStudent.choose_course(123)
　　except Exception as e:
　　 print(e)
　　# int object has no attribute name

2、对象使用对象的绑定方法

• 类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的，

  　　

• 绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入。

  　　

　　类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self。

　　self代表类的实例，而非类

　　类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self，self 代表的是类的实例。

　　self 不是 python 关键字，我们把他换成 aaabbb也是可以正常执行的:

class OldboyStudent:
　　 school = oldboy
　　 def __init__(self, name, age, gender):
　　 self.name = name
　　 self.age = age
　　 self.sex = gender
　　 def choose_course(self):
　　 print(f{self.name} choosing course)
　　 def func(self):
　　 print(from func)
　　stu1 = OldboyStudent(nick, 18, male)
　　stu2 = OldboyStudent(sean, 17, male)
　　stu3 = OldboyStudent(tank, 19, female)
　　stu1.choose_course() #相当于 OldboyStudent.choose_course(stul) 对象调对象绑定的方法,会自动传参
　　# nick choosing course
　　stu2.choose_course()
　　# sean choosing course
　　stu3.choose_course()
　　# tank choosing course
　　stu1.func()
　　# from func
　　stu2.func()
　　# from func

四、类与数据类型

　　python3中统一了类与类型的概念，类就是类型

class Foo:
　　def __init__(self,name):
　　 self.name = name
　　f = Foo(name)
　　obj = Foo()
　　print(type(obj))
　　# <class __main__.Foo>
　　lis = [1, 2, 3] # 相当于 lis = list([1,2,3])
　　print(type(lis))
　　# <class list>
　　lis.append(4) # 对象调对象绑定的方法,会自动传参
　　list.append(lis,4) # 类调用对象绑定的方法,必须得传参

　　对象其实就是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法）

import pymysql
　　class Foo:
　　 def __init__(self, host, port, db, chartset):
　　 self.host = host
　　 self.port = port
　　 self.db = db
　　 self.charset = chartset
　　 def exc1(self, sql):
　　 conn = pymysql.connect(self.host, self.port, self.db, self.charset)
　　 conn.execute(sql)
　　 return xxx
　　 def exc2(self, proc_name):
　　 conn = pymysql.connect(self.host, self.port, self.db, self.charsett)
　　 conn.call_proc(proc_name)
　　 return xxx
　　obj1 = Foo(1.1.1.1, 3306, db1, utf-8)
　　obj1.exc1(select * from t1)
　　obj1.exc1(select * from t2)
　　obj2 = Foo(1.1.1.2, 3306, db1, utf-8)
　　obj2.exc1(select * from t4)

　　到此这篇关于Python面向对象编程的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。