Python面向对象（类，字段和方法）

Python：函数式+面向对象
函数式可以做所有的事，是否合适

定义：
函数：def+函数名（参数）

面向对象：class
def (函数在class里面叫方法，类里面写方法，第一个参数必须是self)

执行
函数：函数名（参数）
面向对象：先创建中间人（对象，实例），然后通过中间人去访问方法

定义类并执行类中的方法：
class 类名：
def 方法名（self，arg）：
print（arg）

中间人=类名（）
中间人.方法名（）

class var:
def foo(self,arg):
print(arg)
return 4
boo=var()
ret=boo.foo(111)
print(ret)

self代指调用方法的对象，类和对象的关联为类对象指针

构造方法：
特殊作用：
在obj=类名（）
创建对象
通过对象执行类中的一个特殊方法
类名（）自动执行构造方法
=====================================================================

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

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

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

3、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 Province:
# 静态字段，属于类
country = '中国'

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

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

#hebei = Province('河北')

# Province.country

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

#__author__:"lili"
#date:2018/3/19  (面向对象)
class var:
    def foo(self,arg):
        print(arg)
        return 4
boo=var()
ret=boo.foo(111)
print(ret)


class bar:
    def foo(self,name,age,gender,content):
        print(self,name,age,gender,content)
obj=bar()
obj.foo('小明','23','男','开车去东北')
#============================================
class bar:
    def foo(self,arg):
        print(self,self.name,arg)
obj=bar()
obj.name='bh'
obj.foo(56)

class bar:
    def foo(self,name,age,gender,content):
        print(self,self.name,self.age,self.gender,content)
    def foo(self, name, age, gender, content):
        print(self, self.name, self.age, self.gender, content)
    def foo(self, name, age, gender, content):
        print(self, self.name, self.age, self.gender, content)
obj=bar()
# obj.foo('小明','23','男','开车去东北')
# obj.foo('小明','23','男','听音乐')
obj.name='小明'
obj.age=12
obj.gender='男'

# obj.add('上山去砍柴')
# obj.delete('开车去东北')
# obj.update('开车去东北')


# 构造方法：__init__
# 特殊作用：
#    在obj=类名（）
#       创建对象
#       通过对象执行类中的一个特殊方法

class bar:
    def __init__(self,name,age):
        # print('sb')
        self.n=name
        self.a=age
    def foo(self):
        print('jg')

obj=bar('alex',12)
print(obj.n,obj.a)

class person:
    def __init__(self,name,age):
        self.n=name
        self.a=age
    def show(self):
        print('%s--%s'%(self.n,self.a))

p1=person('alex',11)
p2=person('alice',22)
p1.show()
p2.show()

class bar:
    def __init__(self,name,age,gender):
        self.n=name
        self.a=age
        self.g=gender
    def add(self,content):
        print(self,self.n,self.a,self.g,content)
    def delete(self, content):
        print(self, self.n, self.a, self.g, content)
    def update(self,content):
        print(self, self.n, self.a, self.g, content)
    def get(self, content):
        print(self, self.n, self.a, self.g, content)
obj=bar('小明',11,'男')

obj.add('上山去砍柴')
obj.delete('开车去东北')
obj.update('最爱胡萝卜')

class person:
    def __init__(self,name,age):
        self.n=name
        self.a=age
        #默认值直接写在这里
        self.x='o'
    def show(self):
        print(self,self.n,self.a,self.x)
p1=person('xiao',11)
p1.show()
#==========================继承===================================
class grandFather():
    def heshui(self):
        pass
class Father(grandFather):  #父类（基类）
    def lanqiu(self):
        pass
    def zuqiu(self):
        pass
    def xiyan(self):
        pass
    def hejiu(self):
        pass
    def tangtou(self):
        pass

class Son(Father): #子类（派生类）
    def baojian(self):
        pass
s=Son()
s.baojian()
s.hejiu()
s.heshui()
# 在子类中定义和父类一样的方法名就执行子类的方法
class F:
    def f1(self):
        print('F.f1')
    def f2(self):
        print('F.f2')
class S(F):
    def s1(self):
        print('S.s1')
    def f1(self):
        # 执行父类的方法有两种方式
        super(S,self).f1()
        F.f1(self)
        print('S.f1')

obj=S()
obj.s1()  #s1中的self是形参，此时代指obj
obj.f1()  #self永远指调用方法的调用者
#python 中支持一个子类继承多个父类，按照从左到右的顺序依次寻找直到找到
#如果两个父类有共同的父类则先找左侧的父类，先不找共同的父类，而是找右边的父类，最后找共同的父类
#================================================================
#练习  ，用的最多的是继承
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('请输入名称：')

#面向对象中高级
class Foo:
    def __init__(self,namee):
        #普通字段
        self.name=name
    #普通方法
    def show(self):
        print(self.name)
obj=Foo('alex')
obj.name
obj.show()
#类成员：包括普通字段（保存在对象中），普通方法（保存在类中）,执行的时候字段不加括号，方法加括号
#静态字段保存在类中，执行时可以通过对象访问，也可以通过类访问

#中国的所有省份，用面向对象知识表示？
#创建一个省份的类
class Province:
    #静态字段
    country='中国'
    def __init__(self,name):
        self.name=name
        #有多少省就会有多少个中国，如果保存在类中，每个省用指针指向该值
        #类中的字段叫做静态字段，静态字段保存在类中，普通字段保存在对象中,只能通过对象访问
        #self.country='中国'
# henan=Province('河南')
# hebei=Province('河北')
print(Province.country)

#__author__:"lili"
#date:2018/3/24
class Province:
    #静态字段
    country='中国'

    def __init__(self,name):
        self.name=name
# henan=Province('河南')
# hebei=Province('河北')
print(Province.country)

#方法有三种，方法的调用要么通过创建对象执行方法，或直接通过类执行方法，首先需创建对象
#普通方法保存在类中，由对象调用
#静态方法，保存在类中，由类直接调用
#类方法，是静态方法的变种，通过类可以直接调用

class Foo:
    def bar(self): #self是对象
        print('bar')
    @staticmethod #加上装饰器，就是静态方法，静态方法self不是必须的
    def sta():
        print('123')
    @staticmethod
    def stat(a1,a2):
        print(a1,a2)
    @classmethod #类方法至少有一个参数
    def classmd(cls): #cls是类名，不依赖于对象
        print(cls)
        print('classmd')

Foo.sta()
Foo.stat(1,2)
Foo.classmd()
print('====================================================================')
class Foo:
    def bar(self):
        print('bar')
#通过类对象指针找到方法
obj=Foo()
obj.bar()
#通过类直接找到方法，但是里面需传参数
obj=Foo()
Foo.bar(obj)

class Foo:
    def __init__(self):
        self.name='a'
        #obj.name
    #obj.bar()
    def bar(self):
        #self是对象
        print('bar')
    @property  #属性（定义时像方法，访问时像字段）
    # 用于执行obj.per，用于获取值
    def per(self):
        # print('123')
        return 1
    @per.setter  #设置字段，给字段赋值，用于执行obj.per=123
    def per(self,val):
        print(val)
    @per.deleter  #删除某个字段时在前面加上关键字del
    def per(self):
        print(555)
obj=Foo()
r=obj.per  #@property
print(r)
obj.per=456  #@per.setter
del obj.per  #@per.deleter
#按照自己调用的方式不同，执行不同的对应的方法
print('========================================')

# li=[]
# for i in range(1000):
#     li.append(i)
# while True:
#     p=input("请输入要查看的页码：")
#     p=int(p)
#     start=(p-1)*10
#     end=p*10
#     print(li[start:end])
print('==========================================')
#封装成函数，用属性之后在调用时不用加括号。
# class pagenation:
#     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(1000):
#     li.append(i)
# while True:
#     p=input("请输入要查看的页码：")
#     obj=pagenation(p)
#     print(li[obj.start:obj.end])

class foo:
    def f1(self):
        return 123
    def f2(self,v):
        print(v)
    def f3(self):
        print('del')
    per=property(fget=f1,fset=f2,fdel=f3,doc='tuvctc7tcc')
    #和下面的功能一样
    # @property
    # def per(self):
    #     return 123
obj=foo()
ret=obj.per
print(ret)
obj.per=8989
del obj.per