面向对象编程，类与对象的使用，内置函数

今日内容概要:

一、面向对象编程介绍（重点）

二、类与对象的使用（重点）

三、内置函数（重点）

内容详解：

一、面向对象编程介绍

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：
    # 学生1的数据
    name = "egon"
    age = 18
    gender = "male"

对象2：
    # 学生2的数据
    name = "王三炮"
    age = 19
    gender = "female"


对象3：
    # 学生3的数据
    name = "李大炮"
    age = 20
    gender = "male"

    
    
学生类：
    # 学生对象相同的数据
    school = "上海校区"
    # 学生对象相同的功能
    选课功能
"""

2、实例化得到对象

在程序中必须先定义类：是申请内存空间，把对象之间相同的数据与功能存起来
类在定义时就会立即执行类体代码，会产生类的名称空间，然后类名指向该名称空间

class Student:
    # 学生对象相同的数据
    school = "上海校区"

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

    # print('====>')

# print(Student.__dict__)

然后调用类来产生对象，调用类的过程又称之为实例化
# 调用类的本质：就是产生一个与类相关联子空间

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)

3、__init__方法

改进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)

4、调用类

（1）会先创造一个与类相关联的子空间，也就对象=》空对象
（2）自动触发类内__init__(空对象,"egon",18,"male")
（3）返回一个初始化好的对象，我们可以赋值给一个变量名

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

5、类属性操作

类与对象都可以通过.来访问属性完成增删改查的操作

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)

6、对象属性操作

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

（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()

三、内置函数

1、eval

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))#<class 'str'>
    line=eval(line)
    print(line['k1'])#111

2、frozenset

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

3、pow

print(pow(10,3,3)) # 10 ** 3 % 3   #打印出1

4、reversed

l=[111,'aaa',333]
res=reversed(l)
print(res)#<list_reverseiterator object at 0x00000000021989D0>
for x in res:
    print(x)#333 aaa  111

l=list(reversed(l))
print(l) #[333, 'aaa', 111]

5、round小数部分5舍6入

print(round(4.6))#5
print(round(4.7))#5
print(round(4.4))#4
print(round(4.5))#4  超过5才进位

6、slice切片

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

s=slice(0,5,2)

print(l[0:5:2]) # 0 2 4  [111, 333, 555]
print(l[s]) # 0 2 4  [111, 333, 555]

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

7、sorted从小到大排序

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)#['axx', 'zegon', 'lxx']

8、sum求和

print(sum([1,2,3,4]))#10

9、zip压缩到一起

msg1="hello"
msg2={"name":"egon"}
l=[111,222,333]

res1=zip(msg1,l)
print(list(res1))#[('h', 111), ('e', 222), ('l', 333)]
res2=zip(msg2,l)
print(list(res2))#[('name', 111)]