博客

目录

• 1、面向过程编程
• 2、面向对象编程
• 1、在程序必须先定义类：
• 2、然后调用类来产生对象，调用类的过程又称之为实例化
• 调用类的本质：就是产生一个与类相关联子空间
  • 改进1：
  • 改进2：
• 一.调用类：
• 二：类属性操作：
• 三：对象属性操作：
  • 1、类中的定义的数据属性为了给对象用的，而且所有对象共享的，大家访问的都是同一个地址
  • 2、类中的定义的函数属性，类可以调用但就是一个普通函数，而类中函数通常都是为对象
  • 准备的，也就是说是给对象用的，如何给对象用？绑定给对象

1、面向过程编程

​ 核心是过程二字，过程指的是做事的步骤，即先干啥、再干啥、后干啥
​ 基于该思想编写程序就好比在涉及一条条的流水线

​ 优点：复杂的问题流程化、进而变得简单化
​ 缺点：扩展性差

2、面向对象编程

​ 核心是对象二字，对象就是一个用来盛放相关数据与相关功能的容器

​ 优点：程序解耦合强，扩展性高
​ 缺点：比面向过程更复杂

衣柜：
    x="asdf"
    y=18
    z=[1,2,3]
    a=1
    def f1():
        print("登录功能1")
        print("登录功能2")
        print("登录功能3")


化妆包：
    e=5
    def f2():
        print("注册功能1")
        print("注册功能2")
        print("注册功能3")

厨房：
    b=2
    c=3
    d=4
    def f3():
        print("转账功能1")
        print("转账功能2")
        print("转账功能3")

对象是数据与功能的集合体，而类则对象之间相同数据与功能的集合体
对象1：

学生1的数据

​    name = "egon"
​    age = 18
​    gender = "male"

对象2：

学生2的数据

​    name = "王三炮"
​    age = 19
​    gender = "female"


对象3：

学生3的数据

​    name = "李大炮"
​    age = 20
​    gender = "male"



学生类：

学生对象相同的数据

​    school = "上海校区"

学生对象相同的功能

​    选课功能

1、在程序必须先定义类：

是申请内存空间，把对象之间相同的数据与功能存起来
类在定义时就会立即执行类体代码，会产生类的名称空间，然后类名指向该名称空间
class Student:
学生对象相同的数据
school = "上海校区"

​ 学生对象相同的功能
​ def choose_course(self):
​ print('正在选课')

​ print('====>')

print(Student.dict)

2、然后调用类来产生对象，调用类的过程又称之为实例化

调用类的本质：就是产生一个与类相关联子空间

stu1 = Student()
stu2 = Student()
stu3 = Student()

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

stu1.__dict__["name"] = "egon"
stu1.__dict__["age"] = 18
stu1.__dict__["gender"] = "male"
stu1.name = "egon"
stu1.age = 18
stu1.gender = "male"

stu2.name = "王三炮"
stu2.age = 19
stu2.gender = "female"

stu3.name = "李大炮"
stu3.age = 20
stu3.gender = "male"


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


print(stu1.name)
print(stu1.age)
print(stu1.gender)
print(stu1.school)
print(stu1.choose_course)

def func(stu1):
    print(stu1.name)
    print(stu1.age)
    print(stu1.gender)
    print(stu1.school)
    print(stu1.choose_course)

改进1：

class Student:
    school = "上海校区"

​    def choose_course(self):
​        print('正在选课')

stu1 = Student()
stu2 = Student()
stu3 = Student()

def init(obj,x,y,z):
    obj.name = x
    obj.age = y
    obj.gender = z

init(stu1,"egon",18,"male")
init(stu2,"王三炮",19,"female")
init(stu3,"李大炮",20,"male")

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

改进2：

class Student:
    school = "上海校区"

​              空对象,"egon",18,"male"
​    def __init__(self, x, y, z):
​        self.name = x  # 空对象.name="egon"
​        self.age = y  # 空对象.age=18
​        self.gender = z  # 空对象.gender="male"
​        print("===>")
​        该函数内可以有任意代码，但是该函数不能返回非None值
​        return 123

​                    stu1
​    def choose_course(self):
​        print('%s 正在选课' %self.name)

​    def func(self,x,y):
​        print(self.name,x,y)

一.调用类：

1、会先创造一个与类相关联的子空间，也就对象=》空对象
2、自动触发类内__init__(空对象,"egon",18,"male")
3、返回一个初始化好的对象，我们可以赋值给一个变量名
stu1 = Student("egon",18,"male")
stu2 = Student("王三炮",19,"female")
stu3 = Student("李大炮",20,"male")

二：类属性操作：

类与对象都可以通过.来访问属性完成增删改查的操作
print(Student.dict)
1、访问类的数据属性

Student.school="xxx"
print(Student.school)

Student.xxx=111
print(Student.__dict__)
del Student.xxx
print(Student.__dict__)

2、访问类的函数属性：它就是一个普通函数，该传几个参数就传几个参数

print(Student.choose_course)
Student.choose_course(stu1)
Student.choose_course(stu2)
Student.choose_course(stu3)

三：对象属性操作：

对象.属性，会先从对象自己的空间里找，没有话去类中找

1、类中的定义的数据属性为了给对象用的，而且所有对象共享的，大家访问的都是同一个地址

print(id(Student.school))
print(id(stu1.school))
print(id(stu2.school))
print(id(stu3.school))

Student.school = "XXX" # 修改类的数据属性，所有对象都会跟着改
print(stu1.school)
print(stu2.school)
print(stu3.school)

stu1.school="YYY"
print(stu1.__dict__)
print(stu1.school)

print(Student.school)
print(stu2.school)
print(stu3.school)

2、类中的定义的函数属性，类可以调用但就是一个普通函数，而类中函数通常都是为对象

准备的，也就是说是给对象用的，如何给对象用？绑定给对象

print(Student.choose_course)
print(stu1.choose_course)

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

stu1.func()

dic={"k1":111}
with open('a.txt',mode='wt',encoding='utf-8') as f:
f.write(str(dic))

with open('a.txt',mode='rt',encoding='utf-8') as f:
line=f.read() # line="{'k1': 111}"

print(type(line))

​ line=eval(line)
​ print(line['k1'])

s=frozenset({1,2,3})
print(s)

print(pow(10,3,3)) # 10 ** 3 % 3

l=[111,'aaa',333]
res=reversed(l)
for x in res:
print(x)

l=list(reversed(l))
print(l)

print(round(4.6))
print(round(4.7))
print(round(4.4))
print(round(4.5))

l=[111,222,333,44,555,666,777,888]

s=slice(0,5,2)

print(l[0:5:2]) # 0 2 4
print(l[s]) # 0 2 4

msg="hello world"
print(msg[s])

l=[444,111,222,555,666,333,777,888]
new_l=sorted(l)
print(new_l)

dic={
'zegon':3000,
"lxx":2000,
'axx':4000
}
res=sorted(dic,key=lambda x:dic[x],reverse=True)
print(res)

print(sum([1,2,3,4]))
msg="hello"
msg={"name":"egon"}
l=[111,222,333]

res=zip(msg,l)
print(list(res))