今日内容概要:
一、面向对象编程介绍（重点）
二、类与对象的使用（重点）
三、内置函数（重点）
内容详解：
一、面向对象编程介绍
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)]