python面向对象入门_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 = "cai"

a = A('yong')

a.func(19)

print(A.__dict__)

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

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

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

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

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