一、装饰器
1、什么是装饰器
'' '
装饰器
'' '
def add( a,b) :
'' '求任意两个数的和'' '
print( '计算开始:' )
r = a + b
return r
print( '计算结束' )
def mul( a,b) :
'' '求任意两个数的积'' '
return a * b
r = add( 123,443 )
print( r)
def fn( ) :
print( '我是fn函数.....' )
def fn2( ) :
print( '函数开始计算...' )
fn( )
print( '函数执行结束.....' )
fn2( )
print( '---------下面就是-----------' )
def new_add( a,b) :
print( '函数开始计算...' )
r = add( a,b)
print( '函数执行结束.....' )
return r
r = new_add( 123,143 )
print( r)
def begin_end( old) :
'' '
用来对其他函数进行扩展,使其它函数可以执行前进行打印开始执行,执行后打印执行结束
参数:
old 要扩展的函数对象
'' '
def new_function( *args,**kwargs) :
print( '函数开始计算...' )
result = old( *args,**kwargs)
print( '函数执行结束.....' )
return result
return new_function
f = begin_end( add)
r = f( 12,3 )
print( r)
print( '-----------------' )
f2 = begin_end( mul)
r = f2( 123,22 )
print( r)
@begin_end
def say_hello( ) :
print( '大家好....' )
say_hello( )
def test_begin_end( old) :
'' '
用来对其他函数进行扩展,使其它函数可以执行前进行打印开始执行,执行后打印执行结束
参数:
old 要扩展的函数对象
'' '
def new_function( *args,**kwargs) :
print( 'test_begin_end函数开始计算...' )
result = old( *args,**kwargs)
print( 'test_begin_end函数开函数执行结束.....' )
return result
return new_function
print( '======================' )
@test_begin_end
@begin_end
def test( ) :
print( '开心快乐的一天' )
test( )
2、面向对象
'' '
对象( Object)
- 对象是内存中专门用来存储数据的一块区域
- 对象中可以存放各种数据( 比如:数字,布尔值,代码)
- 对象由三部分组成:
1 、对象标识(id)
2 、对象的类型(type)
3 、对象的值(value)
- Python是一门面向对象的编程语言
- 所谓的面向对象的语言,简单理解就是语言中的所有操作都是面向对象来进行的
= 面向过程的编程语言
- 面向过程将我们程序的逻辑分解为一个一个的步骤
通过对每个步骤的抽象,来完成程序
例子:
- 孩子上学程序(面向过程的步骤)
1 、妈妈起床
2 、妈妈上厕所
3 、妈妈洗漱
4 、妈妈做早饭
5 、妈妈叫孩子起床
6 、孩子上厕所
7 、孩子洗漱
8 、孩子吃饭
9 、孩子背着书包上学校
- 面向过程的编程思想将一个功能分解为一个一个小的步骤
我们通过完成一个一个的小的步骤来完成一个程序
- 这种编程方式,符合我们人类的思维,编写起来相对比较简单
- 但是这种方法编写代码的往往只适用于一个功能
如果呀实现别的功能,往往要重新编写代码,但是可复用性比较低
所以可复用性比较低,并且难于维护
- 面向对象的编程语言
- 面向对象的编程语言,关注的是对象,而不关注过程
- 例子:
1 、孩子他妈起来叫孩子上学
- 面向对象的编程思想,将所有的功能统一保存到对应的对象中
比如,妈妈功能保存到妈妈的对象中,孩子的功能保存在孩子的对象中
要使用某个功能,直接找到对应的对象即可
- 这种方式编写的代码,比较容易阅读,并且比较易于维护,容易复用
- 但是这种方式编写,不太符合常规的思维,编写起来稍微比较麻烦些
- 简单归纳一下,面向对象的思想
1 、找对象
2 、搞对象
'' '
二、类
1、类的定义
'' '
类(class)
- 我们目前所学习的对象都是Python内置的对象
- 但是内置对象不能满足所有的需求,所以我们在开发中经常需要自定义对象
- 类,简单理解它就相当于一个图纸,在程序中我们需要根据类来创建对象
- 类就是对象的一个图纸!
- 我们也称对象是类的实例(instance)
- 如果多个对象通过一个类创建的,我们称这些对象是一类对象
- 像int( ) float( ) bool( ) str( ) list( ) dict( ) .. .. 这些对象
- a = int( 10 )
- 我们自定义的类都需要使用大写字母开头,使用大驼峰命名法
'' '
a = int( 10 )
b = str( 'hello' )
print( a,type( a))
print( b,type( b))
class MyClass( ) :
pass
print( MyClass)
mc = MyClass( )
mc_2 = MyClass( )
mc_3 = MyClass( )
mc_4 = MyClass( )
result = isinstance( mc,MyClass)
print( mc,type( mc))
print( 'result =' ,result)
2、类的创建流程
'' '
实际上类 也是一个对象
类就是一个用来创建对象的对象
类是type类型的对象,定义类实际上就是定义一个type类型的对象
使用类创建对象的流程
1 、创建一个变量mc
2 、在内存中创建一个新的对象
3 、将对象的id赋值给变量
'' '
class MyClass( ) :
pass
mc = MyClass( )
mc_2 = MyClass( )
mc_3 = MyClass( )
mc_4 = MyClass( )
result = isinstance( mc,MyClass)
mc.name = '顺留'
print( mc.name)
mc_2.name = '四台'
print( mc_2.name)
3、类的定义
'' '
类的定义
- 类和对象都是对现实生活中或程序中的内容的抽象
- 怎么通过类或对象都一个人或事物进行说明呢
- 实际上所有的事物都有两部分构成:
1 、数据(属性)
2 、行为(方法)
- 在类的代码块中,我们可以定义变量和函数
变量会成为该类实例的公共属性,所有的该类的实例都可以通过,对象.属性名 的形式访问
函数会成为该类实例的公共方法,所有该类实例都可以通过 对象.方法名( ) 的形式调用方法
- 注意:
方法调用时,第一个参数由解析器自动传递,所以定义方法时,至少要定义一个形参!
'' '
class Person:
pass
name = 'swk'
def say_hello( a) :
print( '你好!!' )
p1 = Person( )
p2 = Person( )
print( p1.name)
p1.say_hello( )
p2.say_hello( )
4、属性和方法&& self介绍
'' '
类的定义
- 类和对象都是对现实生活中或程序中的内容的抽象
- 怎么通过类或对象都一个人或事物进行说明呢
- 实际上所有的事物都有两部分构成:
1 、数据(属性)
2 、行为(方法)
- 在类的代码块中,我们可以定义变量和函数
变量会成为该类实例的公共属性,所有的该类的实例都可以通过,对象.属性名 的形式访问
函数会成为该类实例的公共方法,所有该类实例都可以通过 对象.方法名( ) 的形式调用方法
- 注意:
方法调用时,第一个参数由解析器自动传递,所以定义方法时,至少要定义一个形参!
- 实例为什么能访问类中的属性和方法
类中定义属性和方法时公共的,任何该类实例都可以访问
- 属性和方法查找的流程
当我们调用一个对象的属性时,解析器会先在当前对象中寻找是否含有该属性
如果有,则直接返回当前的对象的属性值
如果没有,则去当前对象的类对象中去寻找,如果有则返回类对象的属性值
如果没有则报错!
- 类对象和实例对象中都可以保存属性(方法)
- 如果这个属性(方法)是所有的实例共享的,则应该将其保存在类对象中
- 如果这个属性(方法)是某个实例都有的,则应该保存到实例对象中
- 一般情况下,属性保存到实例对象中
实例保存到
'' '
class Person:
name = 'swk'
def say_hello( self) :
print( '你好!我是 %s' %self.name)
p1 = Person( )
p2 = Person( )
print( '-------------------' )
p1.name = '苏州'
p2.name = '汉中'
p1.say_hello( )
p2.say_hello( )
5、属性和方法(init )
class Person:
print( '执行类代码块值' )
def __init__( self,name) :
self.name = name
def say_hello( self) :
print( '大家好,我是%s' %self.name)
p1 = Person( '雨天后额' )
p2 = Person( '后人' )
p1.say_hello( )
p2.say_hello( )
'' '
创建对象的流程
p1 = Person( ) 的运行流程
1 、创建一个变量
2 、在内存中创建一个新对象
3 、__init__( self) 方法执行
4 、将对象的id赋值给变量
类的基本结构
class 类名( [ 父类] ) :
公共的属性.. .
def __init__( self,.. .) :
.. .
def method_1( self,.. .) :
.. .
def method_2( self,.. .) :
.. .
'' '
'' '
属性:
name
age
gender
height
.. .
方法:
jiao( )
yao( )
run( )
.. .
'' '
练习
class Dog:
'' '
表示狗类
'' '
def __init__( self,name,age,gender,height) :
self.name = name
self.age = age
self.gender = gender
self.height = height
def jiao( self) :
'' '
狗叫的方法
:return:
'' '
print( '汪汪汪...' )
def yao( self) :
'' '狗咬的方法'' '
print( '咬咬牙' )
def run( self) :
print( '%s 快乐的奔跑着~~' %self.name)
d = Dog( '阿达' ,8,'gs' ,80)
d.name = '哈化'
d.age = -3
d.run( )
d.yao( )
6、封装
'' '
封装
封装是面向对象的三大特性之一
封装指的是隐藏对象中一些不希望被外部所访问到的属性和方法
如何隐藏一个对象的属性?
- 将对象的属性名修改为一个外部不知道的名字
如何获取(修改)对象中的属性?
- 需要提供一个getter和setter方法使外部可以访问到属性
- getter 获取对象中的指定属性( get_属性名)
- setter 用来设置对象的指定属性( set_属性名)
使用封装,确实增加了类的定义的复杂程度,当时它也确保了数据的安全性
1 、隐藏了属性名,使调用者无法随意的修改对象中的属性
2 、增加了getter和setter方法,很好的控制属性是否是只读的
如果希望属性是只读的,则可以直接去掉setter方法
如果希望属性不能被外部访问,则可以直接去掉getter方法
3 、使用setter方法设置属性,可以增加数据的验证,确保数据的值是正确的
4 、使用getter方法获取属性,使用setter方法设置属性
可以在读取属性和修改属性的同时做一些其他的处理
'' '
class Dog:
'' '表示狗类'' '
def __init__( self,name,age) :
self.hidden_name = name
self.hidden_age = age
def say_hello( self) :
print( '大家好,我是%s' %self.hidden_name)
def get_name( self) :
'' '用来获取对象的name属性'' '
print( '用户读取了属性' )
return self.hidden_name
def set_name( self,name) :
'' '用来设置修改指定的属性名'' '
print( '用户修改了属性' )
self.hidden_name = name
def get_age( self) :
return self.hidden_age
def set_age( self,age) :
if age > 0 :
self.hidden_age = age
d = Dog( '王朝' ,19)
d.say_hello( )
d.set_name( '小花' )
d.say_hello( )
print( d.get_name( ))
print( d.get_age( ))
d.set_age( 3 )
print( d.get_age( ))
7、隐藏类中的属性
'' '
隐藏类中的属性
'' '
class Rectangle:
'' '
表示矩形的类
'' '
def __init__( self,width,heitht) :
self.hidden_width = width
self.hidden_height = heitht
def get_width( self) :
return self.hidden_width
def get_height( self) :
return self.hidden_height
def set_width( self,width) :
self.hidden_width = width
def set_height( self,height) :
self.hidden_height = height
def get_area( self) :
return self.hidden_height * self.hidden_width
r = Rectangle( 5,2 )
r.set_height( 10 )
r.set_width( 10 )
print( r.get_area( ))
'' '
'' '
class Person:
def __init__( self,name) :
self.hidden_name = name
def get_name( self) :
return self.hidden_name
def set_name( self,name) :
self.hidden_name = name
p = Person( 'swn' )
p.hidden_name = 'sss'
print( p.get_name( ))
'' '
'' '
print( '------------------------' )
class Person:
def __init__( self,name) :
self.__name = name
def get_name( self) :
return self.__name
def set_name( self,name) :
self.__name = name
p = Person( 'swn' )
print( p._Person__name)
p._Person__name = 'sssxss'
print( p.get_name( ))
print( '========================' )
class Person:
def __init__( self,name) :
self._name = name
def get_name( self) :
return self._name
def set_name( self,name) :
self._name = name
p = Person( '收和赌博' )
print( p._name)
8、property装饰器
'' '
装饰器,有set必须要有get
'' '
class Person:
def __init__( self,name) :
self._name = name
@property
def name( self) :
return self._name
@name.setter
def name( self,name) :
self._name = name
@property
def age( self) :
return self._age
@age.setter
def age( self,age) :
self._age = age
p = Person( '猪猪' )
print( p.name)
p.name = '扣扣'
print( p.name)
p.age = 29
print( p.name,p.age)
9、继承简介
'' '
继承
'' '
class Animal:
def run( self) :
print( '动物会跑。。。' )
def sleep( self) :
print( '动物睡觉。。' )
'' '
class Animal:
def run( self) :
print( '动物会跑。。。' )
def sleep( self) :
print( '动物睡觉。。' )
def bark( self) :
print( '汪汪汪。。。' )
'' '
class Dog( Animal) :
def bark( self) :
print( '汪汪汪' )
class Hashiqi( Dog) :
def fangshi( self) :
print( '它时傻哈' )
d = Dog( )
d.run( )
d.sleep( )
d.bark( )
r = isinstance( d,Dog)
r = isinstance( d,Animal)
print( r)
print( '------------------' )
h = Hashiqi( )
h.run( )
print( issubclass( Animal,Dog))
print( issubclass( Dog,Animal))
print( issubclass( Dog,object))
print( isinstance( print,object))
10、重写
'' '
重写
'' '
class Animal:
def run( self) :
print( '动物会跑。。。' )
def sleep( self) :
print( '动物睡觉。。' )
class Dog( Animal) :
def bark( self) :
print( '汪汪汪' )
def run( self) :
print( '狗跑。。。' )
d = Dog( )
d.run( )
class A( object) :
def test( self) :
print( 'AAA' )
class B( A) :
def test( self) :
print( 'BBB' )
class C( B) :
def test( self) :
print( 'CCC' )
c = C( )
c.test( )
11、super的使用
class Animal:
def __init__( self,name) :
self._name = name
def run( self) :
print( '动物会跑。。。' )
def sleep( self) :
print( '动物睡觉....' )
@property
def name( self) :
return self._name
@name.setter
def name( self,name) :
self._name = name
class Dog( Animal) :
def __init__( self,name,age) :
super( ) .__init__( name)
self._age = age
def bark( self) :
print( '汪汪。。。' )
def run( self) :
print( '狗跑。。。' )
@property
def age( self) :
return self._age
@age.setter
def age( self,age) :
self._age = age
d = Dog( '旺财' ,20)
d.name = '小黑'
d.run( )
print( d.name)
print( d.age)
12、多重继承
class A( object) :
def test( self) :
print( 'AAA' )
class B( object) :
def test( self) :
print( 'B中的test()方法' )
def test2( self) :
print( 'BBB' )
class C( B,A) :
pass
print( C.__bases__)
print( B.__bases__)
print( C.__bases__)
c = C( )
c.test( )
13、多态
'' '
多态
多态使面向对象的三大特征之一
多态从字面意思立即是多种形态
狗( 狼狗,哈士奇,古牧.. .. )
一个对象可以以不同的形态去呈现
'' '
class A:
def __init__( self,name) :
self._name = name
@property
def name( self) :
return self._name
@name.setter
def name( self,name) :
self._name = name
class B:
def __init__( self,name) :
self._name = name
def __len__( self) :
return 10
@property
def name( self) :
return self._name
@name.setter
def name( self,name) :
self._name = name
a = A( '空空' )
b = B( '住址' )
def say_hello( obj) :
print( '你好 %s' %obj.name)
say_hello( a)
say_hello( b)
def say_hello2( obj) :
if isinstance( obj,A) :
print( '你好 %s' %obj.name)
say_hello2( b)
l = [ 1,2 ,3]
s = 'hello'
print( len( l))
print( len( s))
print( len( b))
'' '
总结::
面向对象的三大特征:
封装
- 确保对象中的数据安全
继承
- 保证了对象的可扩展性
多态
- 保证了程序的灵活性
'' '
14、属性和方法
class A( object) :
count = 0
def __init__( self) :
self.name = '庶务课'
def test( self) :
print( '这是test方法..' ,self)
@classmethod
def test_2( cls) :
print( '这是test_2方法,他是一个类方法~~' ,cls)
@staticmethod
def test_3( ) :
print( 'test_3执行了~~~' )
a = A( )
A.count = 200
print( 'A,' ,A.count)
print( 'a,' ,a.count)
print( 'a,' ,a.name)
a.test( )
A.test( a)
A.test_2( )
A.test_3( )
15、垃圾回收
'' '
垃圾回收
程序运行过程中产生的垃圾会影响到程序的运行的运行性能,所以这些来及必须被及时清理
没有用的东西就是垃圾
在程序中没有被应用的对象就是垃圾,这种垃圾对象过多以后会影响程序的运行的性能
所以我们必须及时的垃圾回收,所谓的垃圾回收就是讲垃圾对象从内存中删除
在python中有自动的垃圾回收机制,它会自动将这些没有被引用的对象删除
所以我们不用手动处理垃圾回收
'' '
class A:
def __init__( self) :
self.name = 'A类'
def __del__( self) :
print( 'A对象被删除' ,self)
a = A( )
b = a
print( a.name)
a = None
b = None
del a
del b
input( '回车键退出....' )
16、特殊方法
在网上找 :: https://docs.python.org/3/ ----》 Language Reference --》Data model --》Special method names
class Person( object) :
'' '人类'' '
def __init__( self,name,age) :
self.name = name
self.age = age
def __str__( self) :
return 'Person [name = %s , age=%d]' %( self.name,self.age)
def __repr__( self) :
return 'Hello'
def __gt__( self, other) :
return self.age > other.age
def __bool__( self) :
return self.age > 181
p1 = Person( '扣扣' ,29)
p2 = Person( '宝宝' ,20)
print( p1)
print( p2)
print( repr( p1))
t = 1,2 ,3
print( t)
print( '-------------' )
print( p1 > p2)
print( p2 > p1)
print( bool( p1))
if p1 :
print( p1.name,'已经成年了' )
else:
print( p1.name,'还未成年' )