一.Python中使用模块对微信进行控制
1.下载微信模块（itchat）：因为python3.6中没有itchat这个模块
<1>进入设置，选择setuptools进入搜索模块界面
<2>搜索itchat模块，选择Install Package，进行安装
<3>下面的安装完成的界面（Package 'itchat' installed successfully）。在右上角右键，点击close关闭此界面。
2.微信模块（itchat）的使用
<1>给手机助手发送消息
<2>统计微信中男生，女生，其他人的个数
<3>
需求：给文件助手发送消息，执行发送的内容
1.如果执行成功，显示执行结果
2.如果执行失败，显示执行失败
import itchat
import os
@itchat.msg_register(itchat.content.TEXT)
def text_reply(msg):
if msg['ToUserName']=='filehelper':
#获取要执行命令的内容
command=msg['Content']
print(command)
#让电脑执行命令代码
#如果执行成功，返回值为0
if os.system(command)==0:
res=os.popen(command).read()
result='[返回值]-命令执行成功,执行结果:\n'+res
itchat.send(result,'filehelper')
else:
result = '[返回值]-命令%s执行失败,请重试' %command
itchat.send(result,'filehelper')
itchat.auto_login()
itchat.run()
二.面向对象
1.面向对象的引入
<1>python是面向对象（简称oop）的语言
面向过程是一件事“该怎么做”，面向对象是一件事“该让谁来做”，然后那个“谁”就是对象，他要怎么做，是他自己的事，反正最后一群对象合力能把事做好就行了。
<2>即面向过程是针对动作，面向对象是针对一个对象（即一个事物）。
<3>类和对象：
面向对象的两个核心概念：
- 类是一群具有相同特征或行为的事物的统称，类是抽象的（大脑思考的一个概念），不能直接使用；
- 对象是由类创造出来的，对象是具体的（可以看得见，摸得着的）。
在开发中，应该先有类，再有对象。
类和对象的关系：
- 类是模板，对象是根据这个模板创建出来的。
- 类只需要一个，对象可以有多个（一张图纸可以造多个飞机）
<4>类的构成：
（1）类的名称：类名——这类事物的名字，满足大驼峰命名法。
（2）类的属性：一组数据（即类描述的特征）——这个类创建出来的对象有什么特征。
（3）类的方法：允许对进行操作的方法（行为），函数可以成为类的方法。——这个类创建出来的对象有什么行为。
其中，类名一定有，但是类的属性和类的方法不一定有。
<5>一个类可以构建多个对象。
<6>实例：
需求：
1.小明今年18岁，身高1.75，每天早上要跑步，然后去吃东西
小美今年17岁，身高1.65，小美不跑步，但是喜欢吃东西Person
name
age
height
run()
eat()2.一只黄颜色的狗叫大黄
看见生人汪汪叫
看见家人摇尾巴Dog
name
color
shout()
shake()
2.类的定义和对象的创建
<1>定义一个类：
格式：
class 类名:
方法列表
注意：类名和前面标示符的要求是一样的，但是，要是大驼峰的命名方法（首字母大写）
class Cat():
def eat(self):
print('%s爱吃鱼' %self.name)
def drink(self):
print('小猫要喝水')
tom = Cat()
tom.name = 'Tom'
print(tom)
tom.eat()
tom.drink()
#输出 <__main__.Cat object at 0x7f90decdf630>
# Tom爱吃鱼
# 小猫要喝水
hello_kitty = Cat()
hello_kitty.name = 'hello_kitty'
hello_kitty.eat()
hello_kitty.drink()
#输出 hello_kitty爱吃鱼
# 小猫要喝水
注意：里面的函数一定要加一个self的参数（且self这个参数必须放在第一个参数的位置），并且在调用函数时，self这个参数不用传实参。
先是定义了一个类（包括类名和方法列表），然后构建了对象（可以是多个），列出了对象的属性（可以是多个），定义了对象的方法，对象调用该方法同时也可以调用类的方法。
self：哪一个对象调用的方法，self就是哪一个对象的引用
可以使用 .属性名 利用赋值语句就可以在类的外部给对象增加属性（不推荐），将对象的属性封装在类中，所以引入3的__init__魔法方法。输出对象名字时，输出的是一个类。想要输出对象的相应信息，所以引入4的__str__魔法方法。
<2>创建对象：
语法：
对象名=类名()
只要创建了对象，一定会在内存中有一块空间存放对象的数据信息。
<3>总结：
（1）一个类可以有多个对象；一个对象可以有多个属性，多个方法（函数）
（2）在方法中，第一个参数一定是self，self表示调用这个方法本身的对象。
（3）对象可以调用类的方法（因为对象属于该类）
<4>一切皆对象
<5>面向对象的三个特征：继承，封装，多态。封装就是把数据封装到一个对象里面去。（通过对象的属性来封装数据）
3.魔法方法__init__讲解
<1>init方法——专门来封装数据的一个方法（init这个函数在定义一个对象之后，自动调用）
class Cat():
def __init__(self,name):
print('这是一个初始化方法')
self.name = name
def eat(self):
print('%s爱吃鱼' %self.name)
cat = Cat('tom')
print(cat.name)
#输出 这是一个初始化方法
# tom
hello_kitty = Cat('HK')
print(hello_kitty.name)
hello_kitty.eat()
# 这是一个初始化方法
# HK
# HK爱吃鱼<2>init方法总结：
- __init__()方法，在创建一个对象时默认被调用，不需要手动调用。
- __init__(self)中，默认有一个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中除了self作为第一个形参外还需要2个形参。例如__init(self,x,y)
- __init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去。
4.魔法方法__str__讲解
class Cat():
def __init__(self,name):
self.name = name
def __str__(self):
return '我是%s' %self.name
tom = Cat('粉条')
print(tom)
#输出 我是粉条
5.封装
封装
面向对象第一步 ： 将属性和方法封装到一个抽象的类中
外界使用类创建对象，然后让对象调用方法
对象方法的细节都封装在类的内部
需求
1.小明体重76.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西会增重1公斤需求
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重76.0公斤
4.每次跑步会减肥0.5公斤
5.每次吃东西会增重1公斤
class Person():
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我的名字叫%s 体重是%.2f' %(self.name,self.weight)
def run(self):
print('%s爱跑步' %self.name)
self.weight -= 0.5
def eat(self):
print('%s吃东西' %self.name)
self.weight += 1
xiaoming = Person('小明',76.0)
print(xiaoming)
xiaoming.run()
print(xiaoming)
xiaoming.eat()
print(xiaoming)
#输出 我的名字叫小明 体重是76.00
# 小明爱跑步
# 我的名字叫小明 体重是75.50
# 小明吃东西
# 我的名字叫小明 体重是76.50
xiaomei = Person('小美',45.0)
print(xiaomei)
xiaomei.run()
print(xiaomei)
xiaomei.eat()
print(xiaomei)
#输出 我的名字叫小美 体重是45.00
# 小美爱跑步
# 我的名字叫小美 体重是44.50
# 小美吃东西
# 我的名字叫小美 体重是45.50
6.继承——针对类（用得多）
继承：实现代码的重用，相同的代码不需要重复写
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
# def eat(self):
# print('吃~~~~~')
# def drink(self):
# print('喝')
# def run(self):
# print('跑')
# def sleep(self):
# print('睡')
def call(self):
print('喵～')
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
# def eat(self):
# print('吃~~~~~')
# def drink(self):
# print('喝')
# def run(self):
# print('跑')
# def sleep(self):
# print('睡')
def call(self):
print('喵～')
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
# def eat(self):
# print('吃~~~~~')
# def drink(self):
# print('喝')
# def run(self):
# print('跑')
# def sleep(self):
# print('睡')
def call(self):
print('喵～')
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
# def eat(self):
# print('吃~~~~~')
# def drink(self):
# print('喝')
# def run(self):
# print('跑')
# def sleep(self):
# print('睡')
def call(self):
print('喵～')
fentiao = Cat()
fentiao.eat()
fentiao.run()
fentiao.call()
#输出 吃~~~~~
# 跑
# 喵～
#子类继承自父类，可以直接享受父类中已经封装好的方法
#子类重应该根据职责，封装子类特有的属性和方法
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def call(self):
print('喵～')
class HelloKitty(Cat):
def speak(self):
print('我能说英语')
class Dog(Animal):
def bark(self):
print('汪～')
kt = HelloKitty()
kt.eat()
kt.speak()
#输出 吃~~~~~
# 我能说英语
#子类可以继承父类的所有属性和方法
#继承具有传递性，子类拥有父类的父类的属性和方法
7.多继承——针对类（没有单继承用得多）
class A():
def test(self):
print('A---->test方法')
def demo(self):
print('A---->demo方法')
class B():
def test(self):
print('B---->test方法')
def demo(self):
print('B---->demo方法')
class C(A,B):
pass
c = C()
c.test()
c.demo()
#输出 A---->test方法
# A---->demo方法由上面的案例可知：优先级跟写法有关系。
默认情况下：python中任何类都有一个父类——object类。
所以class A(object)与class A是一样的，但是，我们一般写class A(object)。即当没有直接的继承关系时，要写object。
8.方法的重写（有继承才会有方法的重写）
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def call(self):
print('喵～')
class HelloKitty(Cat):
def speak(self):
print('我能说英语')
def call(self):
print('@#@$@$@#@!#')
kt = HelloKitty()
kt.call()
#输出 @#@$@$@#@!#
#如果子类中，重写了父类的方法
#在运行中，只会调用在子类中重写的方法而不会调用父类方法想要调用父类的方法：如下代码（加上super）或者在字类的方法中调用父类的方法。
class Animal():
def eat(self):
print('吃~~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def call(self):
print('喵～')
class HelloKitty(Cat):
def speak(self):
print('我能说英语')
def call(self):
#1.针对子类特有的需求，编写代码
# print('@#@$@$@#@!#')
#2.调用原本在父类中封装的方法
# Cat.call(self)
super().call()
kt = HelloKitty()
kt.call()
#输出 喵～
9.多态的讲解
三.面向对象练习
1.练习一：栈原理的实现
class Stack():
def __init__(self):
self.stack=[]
def __str__(self):
return '这是一个栈'
def push(self,value):
self.stack.append(value)
return True
def pop(self):
#先判断栈是否为空
if self.stack:
item=self.stack.pop()
return item
else:
return False
def top(self):
if self.stack:
return self.stack[-1]
else:
return False
def null(self):
if self.stack:
return False
else:
return True
def len(self):
return len(self.stack)
def view(self):
return ','.join(self.stack)
stack=Stack()
print(stack)
#输出 这是一个栈
print(stack.push('2'))
#输出 True
print(stack.view())
#输出 2
print(stack.pop())
#输出 2
print(stack.top())
#输出 False
print(stack.null())
#输出 True
print(stack.len())
#输出 0
2.练习二：
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平面
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
class HouseItem():
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '[%s]占地 %.2f' %(self.name,self.area)
#1.创建家具
# bed = HouseItem('bed',4)
# print(bed)
# table = HouseItem('table',2)
# print(table)
class House():
def __init__(self,house_type,area):
self.house_type = house_type
self.area = area
#剩余面积
self.free_area = area
self.item_list = []
def __str__(self):
return ('户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s'
%(self.house_type,self.area,self.free_area,self.item_list))
def add_item(self,item):
#1.判断家具的面积
if item.area > self.free_area:
print('%s的面积太大，无法添加' %item.name)
#2.将家具的名称添加到列表中
self.item_list.append(item.name)
#3.计算剩余面积
self.free_area -= item.area
#1.创建家具对象
bed = HouseItem('bed',4)
# print(bed)
yg = HouseItem('yg',2)
# print(yg)
table = HouseItem('table',1.5)
# print(table)
#2.创建房子对象
my_house = House('两室一厅',100)
#3.添加家具
my_house.add_item(bed)
my_house.add_item(yg)
my_house.add_item(table)
print(my_house)
# 输出 户型:两室一厅
# 总面积:100.00[剩余:92.50]
# 家具:['bed', 'yg', 'table']
3.练习三
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
Soldier Gun
------------- -----------------
name model
gun bullet_count #子弹数量足够多才能完
成射击的动作
------------- -----------------
__init__(self): __init__(self):
fire(self): add_bullet(self,count):#装填子弹的
方法
shoot(self):
class Gun():
def __init__(self,model):
self.model = model
self.bullet_count = 0
def add_bullet(self,count):
self.bullet_count += count
def shoot(self):
if self.bullet_count <=0:
print('%s没有子弹了...' %self.model)
self.bullet_count -= 1
print('%s~~~~~%s' %(self.model,self.bullet_count))
class Soldier():
def __init__(self,name):
self.name = name
self.gun = None
def fire(self):
if self.gun == None:
print('%s还没有枪...' %self.name)
self.gun.add_bullet(10)
self.gun.shoot()
ak47 = Gun('ak47')
ak47.add_bullet(50)
ak47.shoot()
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
#输出 ak47~~~~~49
# ak47~~~~~58