python面向对象基础

#!/usr/bin/env python
# coding:utf-8

def school(name,addr,type):
    def init(name, addr, type):
        sch = {
            ‘name‘: name,
            ‘addr‘: addr,
            ‘type‘: type,
            ‘kao_shi‘: kao_shi,
            ‘zhao_sheng‘: zhao_sheng,
        }
        return sch
    def kao_shi(school):
        print(‘%s 学校正在考试‘ %school[‘name‘])
    def zhao_sheng(school):
        print(‘%s %s 正在招生‘ %(school[‘type‘],school[‘name‘]))
    return  init(name,addr,type)

print("面向对象的设计")

s1=school(‘oldboy‘,‘沙河‘,‘私立学校‘)
print(s1)
print(s1[‘name‘])

s1[‘zhao_sheng‘](s1)

s2=school(‘清华‘,‘北京‘,‘公立学校‘)

print(s2)
print(s2[‘name‘],s2[‘addr‘],s2[‘type‘])
s2[‘zhao_sheng‘](s2)

#!/usr/bin/env python
# coding:utf-8

class Chinese:
    ‘‘‘这里写文档注释‘‘‘
    area = "Asia"

    # def init(name,age,gender):
    #     dic={
    #         ‘name‘:name,
    #         ‘age‘:age,
    #         ‘gender‘:gender
    #     }
    #     return dic

    def __init__(self, name, age, gender):
        print("start...")
        self.aname = name
        self.aage = age
        self.agender = gender
        print("end...")
        ## 自动return None 所以，不能加return

    def dun(self):
        print("%s 亚洲蹲在 %s " % (self.aname,self.area))

    def speak(self,lang):
        print("%s 讲%s " % (self.aname, lang))


p1 = Chinese("Tom",22,"male")  # 实例化
print(p1.__dict__) #查看实例的字典
print(p1.aname)
print(p1.agender)
print(p1.area)

p1.dun()
p1.speak(‘本地方言‘)
print(p1.area)

# 修改
Chinese.area = ‘东方大陆‘

# 修改函数
def xia_dun(self):
    print("%s 坐在了地上。" % self.aname)

Chinese.dun = xia_dun  # 修改了类的内部函数

# 增加
Chinese.skin = ‘yellow‘


p2 = Chinese("小明",11,"男")
print(p2.area)
print(p2.skin)
print(p1.skin) # 之前的实例也可以用，因为实例是对类的引用
p2.dun()

# 删除
# del Chinese.area
# print(p2.area)

#!/usr/bin/env python
# coding:utf-8

## 类：把一类事物的相同的特征和动作整合到一起就是类，类是一个抽象的概念
## 对象：就是基于类而创建的一个具体的事物（具体存在的）也是特征和动作整合到一起

# class Chinese: # 经典类 python2中的区分
#     ‘‘‘这是一个中国人的类‘‘‘
#     pass
#
# print(Chinese)
#
#
# class Chinese(object): # 新式类 python2中的区分
#     pass

# 实例化到底干了什么？
# p1 = Chinese()  # 实例化 并不像其它语言使用new
# print(p1)


## python3中不再区分，都是新式类
class Chinese:
    ‘‘‘这里写文档注释‘‘‘
    # 1 数据属性
    area = "Asia"

    # 2 函数属性
    def dun():
        print("亚洲蹲")

    def speak(self):
        print("讲汉语 %s" % self)


print(dir(Chinese))
print(Chinese.__dict__)  # 查看类的属性字典，字典里存放着类的数据属性和函数属性

print(Chinese.area)
Chinese.dun()  # 直接执行类中的函数
Chinese.__dict__[‘dun‘]()  # 通过字典方式调用类中函数
Chinese.__dict__[‘speak‘]("你好")

print(Chinese.__name__)  # 类名
print(Chinese.__doc__)  # 类的文档注释
print(Chinese.__base__)  # 基类 <class ‘object‘>
print(Chinese.__bases__)  # 基类 (<class ‘object‘>)
print(Chinese.__module__)  # 来自模块

#!/usr/bin/env python
# coding:utf-8

class Chinese:
    ‘‘‘这里写文档注释‘‘‘
    country = "China"

    def __init__(self, name):
        self.aname = name

    def speak(self,lang):
        print("%s 讲%s " % (self.aname, lang))

p1 = Chinese(‘alex‘)
print(p1.__dict__)

# 查看
print(p1.speak)  # 只得到实例中函数的内存地址
p1.speak(‘汉语‘)

# 增加实例中的属性
p1.age = 18
print(p1.__dict__)
print(p1.age)

## 不要修改实例的函数属性，虽然可以操作。因为不规范
## 可以通过__dict__的方式更改字典，但是也不建议这么做，因为不稳定。

# 删除
del p1.age
print(p1.__dict__)


## 分清类和实例
p1.country = "zh"
print(Chinese.country) # 这是类的
print(p1.country)  # 这是实例的

#!/usr/bin/env python
# coding:utf-8

country = "中国"

class Chinese:
    ‘‘‘这里写文档注释‘‘‘
    country = "China"

    li = [‘a‘,‘b‘]

    def __init__(self,name):
        self.name = name
        print(‘-----------------‘,country) # 这里的country只相当于普通的变量，跟类没有关系，因为没有通过点来调用

        # self.name = input("请输入用户名:") # 不建议在函数中使用输入输出。 混乱，可读性差

    def speak(self,lang):
        print("%s 讲%s " % (self.aname, lang))

p1 = Chinese(‘alex‘)
print("实例内调用", p1.country)  # 点的方式调用是从类的内部
print("类调用", Chinese.country)


print(p1.li)
# p1.li = [1,2,3]  # 实例的list被重新赋值
# print(p1.__dict__)  # 返回{‘name‘: ‘alex‘, ‘li‘: [1, 2, 3]}
# print(Chinese.li)  # 返回 [‘a‘, ‘b‘]

p1.li.append(‘c‘) # 附加了类中列表的元素
print(p1.__dict__)  # 实例的字典中没有 li 这个列表
print(Chinese.li)  # 类的列表被添加内容