面向对象一

 面向对象：并不是字面意思，就是类和对象的应用。  python里面一切事物皆对象。

def foo(name,age,gender,content):
    print(name,age,gender,content)
foo("小明","10岁","男","上山去看柴")
foo("小明","10岁","男","开车去东北")
foo("小明","10岁","男","喜欢打篮球")

class bar():                                      #创建类，名字叫bar的类
    def foo(self,name, age, gender, content):      #函数写到类里面就不叫函数了，我们叫它方法，方法名就叫foo
        print(name, age, gender, content)
obj=bar()                                         #创建对象（扮演着中间人的角色）   其中self就是中间人obj，对象就是中间人。

obj.foo("小明","10岁","男","上山去看柴")
obj.foo("小明","10岁","男","开车去东北")
obj.foo("小明","10岁","男","喜欢打篮球")

 

中间人里面也是可以传参数的，这就是引入封装的条件。

class bar():
    def foo(self):
        print(self.name,self.age,self.gender)
z=bar()
z.name="mengheng"       #这样的在中间人里传参数就是封装
z.age="25"
z.gender="nan"
z.foo()

 

这就是封装，就是在有重复有不重复的时候，把重复的装在一起。

class bar():                                      #创建类，名字叫bar的类
    def foo(self, content):      #函数写到类里面就不叫函数了，我们叫它方法，方法名就叫foo
        print(self.name, self.age, self.gender, content)
obj=bar()                         #创建对象（扮演着中间人的角色）   其中self就是中间人obj，对象就是中间人。
obj.name="小明"
obj.age="10岁"
obj.gender="男"

obj.foo("上山去看柴")
obj.foo("开车去东北")
obj.foo("喜欢打篮球")

 

1、如何创建类
class 类名：
pass

class bar():                    #bar()就是类名
    def foo(self,arg):           #类下面的都是方法
        print("1234",arg)
obj=bar()
obj.foo(56)

 

2、创建方法
构造方法，__init__(self,arg)
obj = 类('a1')                                              #这句是创建对象，创建对象时自动运行该方法
普通方法
obj = 类(‘xxx’)
obj.普通方法名()

3、面向对象三大特性之一：封装

class Bar:
def __init__(self, n,a):
self.name = n
self.age = a
self.xue = 'o'

b1 = Bar('alex', 123)

b2 = Bar('eric', 456)


4、适用场景：
如果多个函数中有一些相同参数时，转换成面向对象

class DataBaseHelper:

def __init__(self, ip, port, username, pwd):
self.ip = ip
self.port = port
self.username = username
self.pwd = pwd

def add(self,content):
# 利用self中封装的用户名、密码等 链接数据
print('content')
# 关闭数据链接

def delete(self,content):
# 利用self中封装的用户名、密码等 链接数据
print('content')
# 关闭数据链接

def update(self,content):
# 利用self中封装的用户名、密码等 链接数据
print('content')
# 关闭数据链接

def get(self,content):
# 利用self中封装的用户名、密码等 链接数据
print('content')
# 关闭数据链接

s1 = DataBaseHelper('1.1.1.1',3306, 'alex', 'sb')

5、面向对象三大特性之二：继承

1、继承

class 父类：
pass

class 子类(父类):
pass

class bar():
    def F(self):
        print("1,f")
class bar1(bar):
    def S(self):
        print("2,s")
z=bar1()
z.S()
z.F()
>>>>>>2,s
>>>>>>1,f

 

2、重写
防止执行父类中的方法

3、self永远是执行该方法的调用者(不管是找到父类还是什么，self永远指的是执行该方法的调用者)

4、
super(子类, self).父类中的方法(...)
父类名.父类中的方法(self,...)



5、Python中支持多继承

a. 左侧优先
b. 一条道走到黑
c. 同一个根时，根最后执行

6、面向对象三大特性之三：多态
====> 原生多态

# Java
string v = 'alex'

def func(string arg):
print(arg)

func('alex')
func(123)

# Python
v = 'alex'

def func(arg):
print(arg)


func(1)
func('alex')

==================================================================

练习：

class Person:

def __init__(self,n,a,g,f):

self.name = n
self.age =a
self.gender =g
self.fight = f

role_list = []

y_n = input('是否创建角色？')
if y_n == 'y':
name = input('请输入名称:')
age = input('请输入名称:')
...
role_list.append(Person(....))

# role_list,1,2


======================================================= 面向对象中高级 ========================================================

class Foo:

def __init__(self, name):
# 普通字段
self.name = name

# 普通方法
def show(self):
print(self.name)

obj = Foo('alex')
obj.name
obj.show()       #调用的时候，方法加（），字段不加（）。

类成员：
# 字段
- 普通字段，保存在对象中，执行只能通过对象访问
- 静态字段，保存在类中， 执行 可以通过对象访问 也可以通过类访问

静态字段属于类，普通字段属于对象

# 方法
- 普通方法，保存在类中，由对象来调用，self=》对象
- 静态方法，保存在类中，由类直接调用
- 类方法，保存在类中，由类直接调用，cls=》当前类

########　应用场景：
如果对象中需要保存一些值，执行某功能时，需要使用对象中的值　－＞　普通方法
不需要任何对象中的值，静态方法


# 属性，特性
- 不伦不类

创建的时候像方法，调用的时候像字段

class Foo():
    def __init__(self):
        self.name="a"
        #obj.name         字段的调用
    def bar(self):
        #self是对象
        print("bar")
    @property
    def per(self):
        print("123")
        return 1
obj=Foo()
r=obj.per
print(r)
>>>>>>123
>>>>>>1

 

 

class pageation:
    def __init__(self,current_page):
        try:
            p=int(current_page)
        except Exception as e:
            p=1
        self.page=p
    @property
    def start(self):
        val=(self.page-1)*10
        return val
    @property
    def end(self):
        val=(self.page)*10
        return val
li=[]
for i in range(20):
    li.append(i)
while True:
    p=input("请输入要查看的页码：")#1、每页显示10条
    obj=pageation(p)
    print(li[obj.start:obj.end])  #属性的作用就是为了不加（）

 

中国的所有省份，用面向对象知识表示？

class province:
    country="中国"    #静态字段属于类
    def __init__(self,name):
        self.name=name
hehan=province("河南")
hebei=province("河北")    #创建对象
print(province.country)    #静态字段可直接调用
print(hebei.name)         #对象只有在创建之后，才能调用
>>>>>>中国
>>>>>>河北

 

class Province:
# 静态字段，属于类
country = '中国'


def __init__(self, name):
# 普通字段，属于对象
self.name = name

henan = Province('河南')
henan.name
henan.name = "河南南"

#hebei = Province('河北')

# Province.country

加上静态方法，self就不是必须的了

class Foo:
    def bar(self):
        print("bar")
    @staticmethod
    def sta():
        print("123")
Foo.sta()                #因为是静态的，所以不需要创建对象，也就是不需要中间人就可以直接调用方法