1.面向对象及面向过程

1）面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么

基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式

优点：复杂的过程流程化

缺点：扩展性差

2）面向对象：核心是对象二字，对象指特征与技能的结合体

基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种‘上帝式’的思维方式

优点：可扩展性强

缺点：变成复杂度高，极容易出现过度设计的问题

3）类：对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体

在现实生活中：一定是先有一个个具体的对象，后总结出类

在程序中：一定是先定义类，后产生对象

2.驼峰式命名法

class Students:

school = '薪享宏福'

def __init__(self,name, age):#初始化函数（区分不同对象的函数）

self.name = name

self.age = age

#代表谁调用self，self就是谁

#stu1.name = name

#stu1.age = age

def run(self):

print('%s is running......' % self.name)

def __str__(self):

# 当打印实例化出来的对象的时候，会打印出__str__返回的值

return '实例化  %s' % self.name

stu1 = Students('li',88)

print(stu1.name)

print(stu1.age)

stu1.run()

print(stu1)

stu2 = Students('zhao',77)

print(stu2.name)

print(stu2.age)

stu1.run()

print(stu2)

输出结果：

li

88

li is running......

实例化  li

zhao

77

li is running......

实例化  zhao

3.封装实例

1）小明爱跑步

需求:

1.小明体重75公斤

2.小明每次跑步都会减肥0.5公斤

3.小明每次吃东西体重会增加1公斤

class Human(object):

def __init__(self,name,weight):

self.name = name

self.weight = weight

def run(self):

self.weight -= 0.5

def eat(self):

self.weight += 1

def __str__(self):

return '%s的体重为%skg' % (self.name,self.weight)

xiaoming = Human('小明',75)

xiaoming.eat()

xiaoming.eat()

xiaoming.run()

xiaoming.run()

xiaoming.run()

xiaoming.run()

xiaoming.run()

xiaoming.run()

xiaoming.run()

print(xiaoming)

输出结果：

小明的体重为73.5kg

2）封装案例2

需求：

1、房子有户型、总面积、家具名称列表

　　房子没有任何家具

2、家具有名字和占地面积，其中

　　席梦思(bed):4平米

　　衣柜(chest): 2平米

　　餐桌(table): 1.5平米

3、将以上3个家具添加到房子中

4、打印房子中，要求输出:户型、总面积、剩余面积、家具名称列表

class Item(object):

def __init__(self,name,area):

self.name = name

self.area = area

class House(object):

def __init__(self,name,total_area):

self.name = name

self.total_area = total_area

self.free_area = total_area

self.item = []

def add_item(self,item):

self.free_area -= item.area

self.item.append(item.name)

def __str__(self):

return '户型：%s  房子总大小：%s  剩余面积：%s  家具列表：%s  ' % (self.name,self.total_area,self.free_area,self.item)

bed = Item('床',4)

table = Item('桌子',1.5)

chest = Item('衣柜',2)

house = House('公寓',18)

house.add_item(bed)

house.add_item(table)

house.add_item(chest)

print(house)

输出结果：

户型：公寓  房子总大小：18  剩余面积：10.5  家具列表：['床', '桌子', '衣柜']

3）士兵突击

需求：

1.士兵许三多有一把AK47

2.士兵可以开火

3.枪能够发射子弹

4.枪装填子弹——增加子弹数量

class Gun(object):

def __init__(self,model,bullet):

self.model = model

self.bullet = bullet

def add_bullet(self,buller_num):

self.bullet += buller_num

print('装填完毕')

if self.bullet >= 30:

self.bullet = 30

def shoot(self):

self.bullet -= 1

if self.bullet <= 0:

print('枪内无子弹，请装弹')

self.bullet = 0

def __str__(self):

return '%s内还有%s发子弹' % (self.model,self.bullet)

class Human(object):

def __init__(self,name,gun):

self.name = name

self.gun = gun

def fire(self):

self.gun.shoot()

Ak47 = Gun('Ak47',5)

xusanduo = Human('许三多',Ak47)

xusanduo.fire()

xusanduo.fire()

xusanduo.fire()

xusanduo.fire()

Ak47.add_bullet(30)

print(Ak47)

4.继承

继承实现代码的重用，相同的代码不需要重复编写，子类可以继承父类的属性和方法

单继承，多继承

class Anamal:

def eat(self):

print('吃')

def drink(self):

print('喝')

def run(self):

print('跑')

def sleep(self):

print('睡')

class Dog(Anamal):

def bark(self):

print('汪汪叫')

class XiaoTianQuan(Dog):

def fly(self):

print('我会飞啦！！！！')

dog = XiaoTianQuan()

dog.eat()

dog.run()

dog.sleep()

dog.drink()

dog.bark()

dog.fly()

5.方法的重写与扩展

1）重写：

子类继承父类，可以享受父类中已经封装号的方法，不需要再次开发

当父类的方法不满足子类需求时，可以对方法进行重写

2）扩展：

在子类中重写父类的方法

在需要的位置使用super().父类方法来调用父类方法的执行

6.多态

不同的子类对象调用相同的父类方法时，产生不同的结果

多态可以增加代码的灵活度

class Animal(object):

def __init__(self,name):

self.name = name

def eat(self):

print('吃.....')

def drink(self):

print('喝.....')

def run(self):

print('跑.....')

def sleep(self):

print('睡.....')

def play(self):

pass

class Dog(Animal):

def play(self):

print('%s开开心心去玩耍......' % self.name)

class XiaoTianQuan(Animal):

def play(self):

print('%s飞到天上去玩耍.....' % self.name)

class Person(object):

def __init__(self,name):

self.name = name

def with_game(self, part):

print('%s 与 %s 一起去玩耍.....' % (self.name,part.name))

part.play()

dog = Dog('旺财')

xiaotianquan = XiaoTianQuan('飞天旺财')

xiaoming = Person('小明')

xiaoming.with_game(xiaotianquan)

7.异常处理

1）什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

2）异常处理：

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

try:

正常的操作

......................

except:

发生异常，执行这块代码

......................

else:

如果没有异常执行这块代码

try:

<语句>

finally:

<语句>    #退出try时总会执行

raise

try:

fh = open("testfile", "w")

fh.write("这是一个测试文件，用于测试异常!!")

finally:

print("Error: 没有找到文件或读取文件失败")

3）用户自定义异常

class O_ERROR(Exception):

def __init__(self, info):

self.info = info

def ad(age):

if age == 100:

raise O_ERROR('年纪不能等于100')

try:

ad(100)

except O_ERROR as e:

print(e)

输出结果：

年纪不能等于100

8.os模块

os.getcwd() 获取当前工作路径

os.chdir() 改变当前工作路径

os.makedirs() 创建递归目录

os.mkdir()创建单级目录

os.rmdir() 删除空目录

os.listdir() 列出指定目录下的文件和文件夹，包括隐藏文件，以列表方式打印出来

os.remove()删除文件或文件夹

os.rename()重命名

os.stat()查看一个文件的详细信息

os.path.exits()判断路径是否存在

os.path.isfile(）判断文件是否存在

os.path.isdir()判断文件夹是否存在

os.path.join()路径拼接

9.socket模块

检查主机、端口是否正常工作

import socket

hosts = ['192.168.254.10:22','192.168.100.100:3306','192.168.200.200:25']

server = socket.socket()#tcp协议

server.settimeout(1)

for host in hosts:

ip = host.split(':')[0]

port = host.split(':')[1]

status_code = server.connect_ex((ip,int(port)))

# print('%s:%s is %s' % (ip,port,status_code))

if status_code != 0:

pass