码迷,mamicode.com
首页 > 编程语言 > 详细

Python 入门 之 初识面向对象

时间:2019-09-23 15:27:47      阅读:83      评论:0      收藏:0      [点我收藏+]

标签:地址   ==   def   编程   特征   可读性   面向过程编程   驼峰   people   

Python 入门 之 初识面向对象

1、初识面向对象编程 (核心--对象)

(1)观察以下代码:

# 面向过程编程
s = "alexdsb"
count = 0
for i in s:
    count += 1
print(count)

s = [1,2,7,3,4,5,]
count = 0
for i in s:
    count += 1
print(count)

# 面向对象编程
def my_len(s):
    count = 0
    for i in s:
        count += 1
    print(count)
my_len([1,2,3,4,5])

可得出结论:

面向过程 vs 函数式编程

<1> 函数式编程 减少了重复代码
<1> 函数式编程 提高了代码的可读性高

(2)观察以下代码;

# 面向函数编程
def login():
    pass

def check_buy_goods():
    pass

def change_pwd():
    pass

def shopping():
    pass

def register():
    pass

def check_unbuy_goods():
    pass

# 面向对象编程
class Auth:

    def login(self):
        pass

    def register(self):
        pass

    def change_pwd(self):
        pass

class Shopping:

    def shopping(self):
        pass

    def check_buy_goods(self):
        pass

    def check_unbuy_goods(self):
        pass

可以得出结论:

函数式编程 vs 面向对象

<1> 面向对象 代码结构清晰,可读性高
<2> 面向对象使用 上帝思维

2、面向对象初识:

类:对一些事物的统称和概括 (就是具有相同属性和功能的一类事物)

对象:实实在在存在的东西,具有特征和功能 (就是类的具体表现形式)

3、面向对象结构:

class --- 关键字

class 类名: # 类名建议使用驼峰体 函数名建议使用下划线

静态属性(类变量,静态字段)
方法(类方法,动态属性,动态字段)
class People:

    mind = "有思想"  # 静态属性

    def eat(self):   # 方法
        print("在吃饭")

    def work(self):
        print("在工作")


class Dog:

    hair = "毛"   # 静态属性

    def eat(self):
        print("吃食")

    def lick(self):
        print("添水")

4、类角度操作类:

class People:
    mind = "有思想"  # 静态属性

    def eat(self):   # 方法
        print("在吃饭")

    def work(self):
        print("在工作")

(1)_ dict _查看类下所有内容

print(People.__dict__)   # __dict__ 只能查看当前空间下的内容

(2). 万能的点 查看单个属性或方法

print(People.mind)      # 类名.属性名

? 一般情况我们不使用类名去操作方法(类方法)

(3)增:

People.emotion = "有情感"

(4)删:

del People.mind

(5)改:

People.mind = "无脑"

(6)查:

print(People.mind)  #类名.属性名   单独查一个
print(People.__dict__)    # 查看类下所有的

5、对象角度操作类:

class People:
    mind = "有思想"  # 静态属性

    def eat(self):   # 方法
        print("self --->",self)
        print("在吃饭")

    def work(self):
        print("在工作")

# 创建对象 -- 类名()
p = People()  # 实例化对象
print(p.__dict__)  # 对象的空间
print("p---->",p)
print(p.mind)
p.eat()
p.work()
class People:

    mind = "有思想"        # 静态属性

    def __init__(self,name,age,sex):     # 初始化
        # self == p
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):         # 方法
        print(self.name)
        print("在吃饭")

    def work(self):
        print("在工作")

p = People("marry",19,"男")       # 实例化一个对象
p.eat()

? 可以在类的外部给对象创建属性,但不建议这样使用

p.mind = "无脑"  # 给对象创了一个属性
print(People.__dict__)
print(p.__dict__)        # 对象查询对象中所有属性

(1)对象只能使用类中的属性和方法,不能进行修改

(2)实例化一个对象总共发生了三件事:

<1> 实例化一个对象,给对象开辟空间

<2> 自动执行_ _init__ 方法

<3> 自动将对象的地址隐性传递给了self

6、self 是什么?

(1)就是函数的位置参数

(2)实例化对象的本身(对象和self指向同一内存地址)

class People:

    mind = "有思想"  # 静态属性

    def __init__(self,name,age,sex,high=None):   # 初始化(给创建的对象封装独有属性)
        # self == p  地址相同
        self.name = name
        self.age = age
        self.sex = sex
        if high:
            self.high = high

    def eat(self):   # 方法
        print(f"{self.name}在吃饭")

    def work(self):
        print("在工作")

p1 = People("jim",19,"未知",170) # 实例化一个对象
p2 = People("kuqir",19,"未知",170) # 实例化一个对象
p3 = People("diva",19,"未知",170) # 实例化一个对象
p4 = People("李玲",19,"未知",170) # 实例化一个对象
p5 = People("好哥",19,"未知",170) # 实例化一个对象

p1.eat()
p2.eat()

7.类空间

(1)给对象空间添加属性:

对象的属性不仅可以在_ _init__里面添加,还可以在类的其他方法或者类的外面添加

class A:

    def __init__(self,name):
        # 类里边给对象添加属性
        self.name = name

    def func(self,sex):
        self.sex = sex

a = A("jim")
a.func("男")
# 类外边给对象添加属性
a.age = 18
print(a.__dict__)

# 总结:给对象空间添加属性可以在类的内部,类的外部,类中的方法

(2)给类空间添加属性:

类的静态属性不仅可以在内部添加,还可以在类的外部添加

class A:

    def __init__(self,name):
        # 类内部给类空间添加属性
        A.name = name

    def func(self,age):
        # 类中的方法给类空间添加属性
        A.age = age

类外部给类空间添加属性
A.name = "alex"
a = A('meet')
a.func(19)
print(A.__dict__)

# 总结:给类空间添加属性可以在类的内部,类的外部,类中的方法

8、面向对象中的查找顺序

对象查找属性的顺序:先从对象空间找 ——> 类空间找——>父类空间找——>·········

类名查找属性的顺序:先从本类空间找 ——> 父类空间找——>······

上面的顺序都是单向不可逆的,类名不可能找到对象的属性。(对象之所以可以找到类,是因为对象空间中有类对象指针这么个东西)

Python 入门 之 初识面向对象

标签:地址   ==   def   编程   特征   可读性   面向过程编程   驼峰   people   

原文地址:https://www.cnblogs.com/caiyongliang/p/11572034.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!