'''
面向過程的程式設計思想
    核心過程二字,過程指的是解決問題的步驟,即先幹什麼\再幹什麼\後幹什麼
    基於該思想編寫程式就好比在設計一條流水線,是一種機械式的思維方式

    優點:複雜的問題流程化\進而簡單化
    缺點:可擴充套件性差

面向物件的程式設計思想
    核心是物件二字,物件是特徵與技能的結合體
    基於該思想編寫程式(腦子始終想的是物件二字)就好比在創造一個世界,世界是由
    一個個物件組成,在上帝眼裡任何存在的事物都是物件,任何不存在的事物也都可以造
    出來,是一種上帝式的思維方式

    優點: 可擴充套件性強
    缺點: 程式設計的複雜度要高與面向過程


類:
 

    物件是特徵與技能的結合體,而類則是一系列物件相同的特徵與技能的結合體
    強調:
        1.物件是具體存在的事物,而類則一個抽象的概念
        2.站在不同的角度總結出的類與物件是不同的


    在現實世界中:先有一個個具體存在的物件,然後隨著人類文明的發展才總結出類的概念

    在程式中: 先定義類,後呼叫類來產生物件


站在老男孩選課系統的角度
總結出現實世界中的老男孩學生物件:
    學生物件1
        特徵
            school='oldboy'
            name='李鐵蛋'
            age=18
            sex='male'
 


        技能
            選課

    學生物件2
        特徵
            school='oldboy'
            name='趙鋼彈'
            age=38
            sex='female'

        技能
            選課

    學生物件3
        特徵
            school='oldboy'
            name='劉銀彈'
            age=28
            sex='male'
        技能
            選課

    老師物件1
        特徵
 

            school='oldboy'
            name='Egon'
            age=18
            sex='male'
            level=10

        技能
            打分

總結現實世界中的老男孩學生類
    相同的特徵
        school='oldboy'
    相同的技能
        選課

在程式中....
'''


類的使用:

'''
站在老男孩選課系統的角度
總結出現實世界中的老男孩學生物件:
    學生物件1
        特徵
            school='oldboy'
            name='李鐵蛋'
            age=18
            sex='male'

        技能
            選課

    學生物件2
        特徵
            school='oldboy'
            name='趙鋼彈'
            age=38
            sex='female'

        技能
            選課

    學生物件3
        特徵
            school='oldboy'
            name='劉銀彈'
            age=28
            sex='male'
        技能
            選課

總結現實世界中的老男孩學生類
    相同的特徵
        school='oldboy'
    相同的技能
        選課
'''
#在程式中
#1. 先定義類
class OldboyStudent:
    #相同的特徵
    school = 'oldboy'

    #相同的技能
    def choose_course(self):
        print('choosing course')

    # print('===>>>')
#類是一系列物件相同的特徵(變數)與技能(函式)的結合體,即類體中最常見的就是變數與函式的定義
# 但其實類體中是可以存在任意python程式碼的
# 類體程式碼會在類定義階段立即執行,會產生一個類名稱空間,用來將類體程式碼執行過程中產生的名字都丟進去,檢視方式如下
# print(OldboyStudent.__dict__) # 檢視類的名稱空間
# print(OldboyStudent.school) #print(OldboyStudent.__dict__['school'])
# print(OldboyStudent.choose_course)
# OldboyStudent.school='OLDBOY' #OldboyStudent.__dict__['school']='OLDBOY'
# OldboyStudent.country='China' #OldboyStudent.__dict__['country']='China'
# del OldboyStudent.country # del OldboyStudent.__dict__['country']
# print(OldboyStudent.__dict__)

OldboyStudent.choose_course(123123)
# 總結:
#1. 類本質就是一個名稱空間,或者說是一個用來存放變數與函式的容器
#2. 類的用途之一就是當做名稱空間從其內部取出名字來使用
#3. 類的用途之二是呼叫類來產生物件



#2. 後呼叫類來產生物件


物件的使用:

'''
學生物件1
        特徵
            school='oldboy'
            name='李鐵蛋'
            age=18
            sex='male'
        技能
            選課

    學生物件2
        特徵
            school='oldboy'
            name='趙鋼彈'
            age=38
            sex='female'
        技能
            選課

    學生物件3
        特徵
            school='oldboy'
            name='劉銀彈'
            age=28
            sex='male'
        技能
            選課
'''

class OldboyStudent:
    #相同的特徵
    school = 'oldboy'

    #相同的技能
    def choose_course(self):
        print('choosing course')

#2. 後呼叫類來產生物件:
# 呼叫類的過程稱之為類的例項化,呼叫類的返回值稱之為類的一個物件/例項


# 呼叫類發生了?
# 1. 會產生一個物件,然後返回

stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()

# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)


# 為物件定製自己獨有的特徵
'''
# name='李鐵蛋'
# age=18
# sex='male'
stu1.name='李鐵蛋'
stu1.age=18
stu1.sex='male'

print(stu1.__dict__)

# name='趙鋼彈'
# age=38
# sex='female'
stu2.name='趙鋼彈'
stu2.age=38
stu2.sex='female'

print(stu2.__dict__)

# name='劉銀彈'
# age=28
# sex='male'
stu3.name='劉銀彈'
stu3.age=28
stu3.sex='male'

print(stu3.__dict__)
'''

# 為物件定製自己獨有的特徵,簡化方案一:
'''
def init(obj,name,age,sex):
    obj.name = name
    obj.age = age
    obj.sex = sex

# stu1.name='李鐵蛋'
# stu1.age=18
# stu1.sex='male'
init(stu1,'李鐵蛋',18,'male')

# stu2.name='趙鋼彈'
# stu2.age=38
# stu2.sex='female'
init(stu2,'趙鋼彈',38,'female')

# stu3.name='劉銀彈'
# stu3.age=28
# stu3.sex='male'
init(stu3,'劉銀彈',28,'male')

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
'''


# 為物件定製自己獨有的特徵,簡化方案二:
class OldboyStudent:
    #相同的特徵
    school = 'oldboy'

    #           stu1,'李鐵蛋',18,'male'
    def __init__(obj, name, age, sex):
        obj.name = name #stu1.name='李鐵蛋'
        obj.age = age   #stu1.age=18
        obj.sex = sex   #stu1.sex='male'

    #相同的技能
    def choose_course(self):
        print('choosing course')

# 呼叫類發生了
# 1. 先產生一個空物件stu1,然後返回
# 2. 觸發類中函式__init__的執行,將物件連同呼叫類括號內指定的引數一同傳入__init__(stu1,'李鐵蛋',18,'male')

stu1=OldboyStudent('李鐵蛋',18,'male') #__init__(stu1,'李鐵蛋',18,'male')
stu2=OldboyStudent('趙鋼彈',38,'female') #__init__(stu2,'趙鋼彈',38,'female')
stu3=OldboyStudent('劉銀彈',28,'male') #__init__(stu3,'劉銀彈',28,'male')


# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)
# 總結__init__的功能: 是在例項化時就為物件初始自己獨有的特徵
# 注意:不能有返回值

# stu1.xxx=111
# print(stu1.__dict__)


屬性查詢:

xxx=33333
class OldboyStudent:
    school = 'oldboy'
    # xxx=2222
    yyy=333
    count=0

    def __init__(obj, name, age, sex):
        # print(OldboyStudent.yyy)
        # print(obj.yyy)

        OldboyStudent.count+=1
        obj.name = name #stu1.name='李鐵蛋'
        obj.age = age   #stu1.age=18
        obj.sex = sex   #stu1.sex='male'

    def choose_course(self):
        print('choosing course')

# 1. 屬性查詢順序
# stu1=OldboyStudent('李鐵蛋',18,'male')
# print(stu1.__dict__)
# print(OldboyStudent.__dict__)
# stu1.xxx=111
# print(stu1.__dict__)
# 先從物件自己的名稱空間找,沒有則去所屬的類中找
# print(stu1.xxx)

# 2.
stu1=OldboyStudent('李鐵蛋',18,'male')
stu2=OldboyStudent('趙鋼彈',38,'female')
stu3=OldboyStudent('劉銀彈',28,'male')
# print(stu1.count)
# print(stu2.count)
# print(stu3.count)
# print(OldboyStudent.count)

# 類中定義的變數是所有物件共享的,物件可以來用,類也可以來使用,類一旦改變自己的資料屬性的值,所有的物件都能感知到
# print(id(stu1.school))
# print(id(stu2.school))
# print(id(stu3.school))
# print(id(OldboyStudent.school))

# stu1.school=123
# # OldboyStudent.school='OLDBOY'
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)
# print(OldboyStudent.__dict__)
#
# print(OldboyStudent.school)
# print(stu1.school)
# print(stu2.school)
# print(stu3.school)




# print(id(stu1.choose_course))
# print(id(stu2.choose_course))
# print(id(stu3.choose_course))

繫結方法:

#類中定義的變數是類的資料屬性,類可以用,物件也可以用,大家都指向同一個記憶體地址,類變數值一旦改變所有物件都跟著變

#類中定義的函式是類的函式屬性,類可以用,類來呼叫就是一個普通的函式,但其實類中定義的函式是給物件用的,而且是繫結給物件用的
# 繫結???
class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name #stu1.name='李鐵蛋'
        self.age = age   #stu1.age=18
        self.sex = sex   #stu1.sex='male'

    def choose_course(self,x): #self=stu1
        print('%s choosing course' %self.name)



stu1=OldboyStudent('李鐵蛋',18,'male')
stu2=OldboyStudent('趙鋼彈',38,'female')
stu3=OldboyStudent('劉銀彈',28,'male')

# 1. 類的函式: 該傳幾個引數就傳幾個
print(OldboyStudent.__init__)
print(OldboyStudent.choose_course)
# OldboyStudent.choose_course(stu1)

# 2. 繫結方法,指向類的函式: 特殊之處是繫結給誰就應該由誰來呼叫,誰來呼叫就會將誰當做第一個引數自動傳入
print(stu1.choose_course)
print(stu2.choose_course)
print(stu3.choose_course)

stu1.choose_course(123) #OldboyStudent.choose_course(stu1,123)
stu2.choose_course(123)
stu3.choose_course(123)


stu1.choose_course(2)





一切皆物件:

# 在python3中統一了類與型別的概念

class Foo:
    pass

# print(Foo)
# obj=Foo()
# print(type(obj))

# print(int)
# age=10 #age=int(10)
# print(type(age))

# print(dict)


l1=[1,2,3] #l1=list([1,2,3])
# print(type(l1))
# l1.append(4)
# print(l1)

l1.append(4) # list.append(l1,4)
print(l1)

l2=['a','b','c'] #l2=list(['a','b','c'])
l2.append('d')