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