函数封装及面向对象

Posted 2020-12-11 fairytalk

1.函数的作用
提高代码的复用性
提高开发效率
减少维护代码维护量
2.定义函数格式

Def 函数名():
代码

3.函数调用：

通过 函数名() 调用

4.函数的参数
定义：为了让一个函数更通用

例：

函数名里定义两个参数
def func(a,b): # 此参数为 形参

定义方法

c = a+b
print(c)

调用时添加具体值
func(3,6) # 调用的参数为 实参

5.缺省参数
定义：在形参中有默认值的参数，称为缺省参数
注意：缺省参数要放到形参最后面
例：
def func(a,b=3):

定义方法

c = a+b
print(c)

调用时添加具体值
func(3)

6.不定长参数
*args: 存放的参数为元祖类型

例：

def s(*args):
print(type(args))

s(1,2,3,4)

kwargs: 存放数据为字典类型
例：
def s(kwargs):
print(type(kwargs))

    s(a=1,b=2,c=3,d=4)

7.多个不定长参数的存放顺序
*args,缺省参数,**kwargs

8.函数的种类
(1)无参数，无返回值
例:
def func():
print(‘烫火锅‘)
func()

(2)无参数，有返回值
例：
def func():
s = ‘烫火锅‘
return s
print(func())

(3)有参数，有返回值
例：
def func(a,b):
s = a+b
return a,b
print(func(4,5))

(4)有参数，无返回值
例：
def func(a,b):
s = a+b
print(s)
func(4,5)

9.函数嵌套
执行顺序：
例：
def func():
print(‘烫火锅‘)

def fun2():
print(‘第一次调用‘)
func()
print(‘第二次‘)

fun2()局部变量
就是在函数内部定义的变量
作用范围函数内部，函数外部不能调用
局部变量作用:为了临时保存数据需要在函数中定义变量来存储。
例：
def func1():
a = ‘高铁‘
print(‘----修改前---a=%s‘%a)
a = ‘飞机‘
print(‘---修改后----a=%s‘%a)

def func2():
a = 400
print(‘------a=%d‘%a)

func1()
func2()全局变量

什么是全局变量
一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
例：

在函数外定义变量称为 全局变量
定义全局变量
a = ‘烫火锅‘
def func1():
print(a)
def func2():
print(a)

func1()
func2()

修改全局变量
关键词：global
格式：global a 修改多个 , 隔开
使用global对全局变量进行修改
例：
a = ‘烫火锅‘
def func1():
global a

将变量a声明为全局变量
a = 100
print(a)
def func2():
print(a)

func1()
func2()递归函数
一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

计算n的阶乘：
例1循环操作：
def func(n):
i = 1
s = 1
while i<=n:
s = s * i
i += 1

return s
print(func(10))
例2递归操作：
def func(n):
if n>1:
res = n * func(n-1)
return res
else:
res = 1
return res

print(func(0))Python中模块和包
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似
模块定义好后，我们可以使用 import 语句来引入模块
格式：
import 模块名
from ...import 语句：Python中函数

函数的作用
提高代码的复用性
提高开发效率
减少维护代码维护量
2.定义函数格式

Def 函数名():
代码

3.函数调用：

通过 函数名() 调用

4.函数的参数
定义：为了让一个函数更通用

例：

函数名里定义两个参数
def func(a,b): # 此参数为 形参

定义方法

c = a+b
print(c)

调用时添加具体值
func(3,6) # 调用的参数为 实参

5.缺省参数
定义：在形参中有默认值的参数，称为缺省参数
注意：缺省参数要放到形参最后面
例：
def func(a,b=3):

定义方法

c = a+b
print(c)

调用时添加具体值
func(3)

6.不定长参数
*args: 存放的参数为元祖类型

例：

def s(*args):
print(type(args))

s(1,2,3,4)

kwargs: 存放数据为字典类型
例：
def s(kwargs):
print(type(kwargs))

    s(a=1,b=2,c=3,d=4)

7.多个不定长参数的存放顺序
*args,缺省参数,**kwargs

8.函数的种类
(1)无参数，无返回值
例:
def func():
print(‘烫火锅‘)
func()

(2)无参数，有返回值
例：
def func():
s = ‘烫火锅‘
return s
print(func())

(3)有参数，有返回值
例：
def func(a,b):
s = a+b
return a,b
print(func(4,5))

(4)有参数，无返回值
例：
def func(a,b):
s = a+b
print(s)
func(4,5)

9.函数嵌套
执行顺序：
例：
def func():
print(‘烫火锅‘)

def fun2():
print(‘第一次调用‘)
func()
print(‘第二次‘)

fun2()局部变量
就是在函数内部定义的变量
作用范围函数内部，函数外部不能调用
局部变量作用:为了临时保存数据需要在函数中定义变量来存储。
例：
def func1():
a = ‘高铁‘
print(‘----修改前---a=%s‘%a)
a = ‘飞机‘
print(‘---修改后----a=%s‘%a)

def func2():
a = 400
print(‘------a=%d‘%a)

func1()
func2()全局变量

什么是全局变量
一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
例：

在函数外定义变量称为 全局变量
定义全局变量
a = ‘烫火锅‘
def func1():
print(a)
def func2():
print(a)

func1()
func2()

修改全局变量
关键词：global
格式：global a 修改多个 , 隔开
使用global对全局变量进行修改
例：
a = ‘烫火锅‘
def func1():
global a

将变量a声明为全局变量
a = 100
print(a)
def func2():
print(a)

func1()
func2()递归函数
一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

计算n的阶乘：
例1循环操作：
def func(n):
i = 1
s = 1
while i<=n:
s = s * i
i += 1

return s
print(func(10))
例2递归操作：
def func(n):
if n>1:
res = n * func(n-1)
return res
else:
res = 1
return res

print(func(0))PythoPython中函数

函数的作用
提高代码的复用性
提高开发效率
减少维护代码维护量
2.定义函数格式

Def 函数名():
代码

3.函数调用：

通过 函数名() 调用

4.函数的参数
定义：为了让一个函数更通用

例：

函数名里定义两个参数
def func(a,b): # 此参数为 形参

定义方法

c = a+b
print(c)

调用时添加具体值
func(3,6) # 调用的参数为 实参

5.缺省参数
定义：在形参中有默认值的参数，称为缺省参数
注意：缺省参数要放到形参最后面
例：
def func(a,b=3):

定义方法

c = a+b
print(c)

调用时添加具体值
func(3)

6.不定长参数
*args: 存放的参数为元祖类型

例：

def s(*args):
print(type(args))

s(1,2,3,4)

kwargs: 存放数据为字典类型
例：
def s(kwargs):
print(type(kwargs))

    s(a=1,b=2,c=3,d=4)

7.多个不定长参数的存放顺序
*args,缺省参数,**kwargs

8.函数的种类
(1)无参数，无返回值
例:
def func():
print(‘烫火锅‘)
func()

(2)无参数，有返回值
例：
def func():
s = ‘烫火锅‘
return s
print(func())

(3)有参数，有返回值
例：
def func(a,b):
s = a+b
return a,b
print(func(4,5))

(4)有参数，无返回值
例：
def func(a,b):
s = a+b
print(s)
func(4,5)

9.函数嵌套
执行顺序：
例：
def func():
print(‘烫火锅‘)

def fun2():
print(‘第一次调用‘)
func()
print(‘第二次‘)

fun2()局部变量
就是在函数内部定义的变量
作用范围函数内部，函数外部不能调用
局部变量作用:为了临时保存数据需要在函数中定义变量来存储。
例：
def func1():
a = ‘高铁‘
print(‘----修改前---a=%s‘%a)
a = ‘飞机‘
print(‘---修改后----a=%s‘%a)

def func2():
a = 400
print(‘------a=%d‘%a)

func1()
func2()全局变量

什么是全局变量
一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
例：

在函数外定义变量称为 全局变量
定义全局变量
a = ‘烫火锅‘
def func1():
print(a)
def func2():
print(a)

func1()
func2()

修改全局变量
关键词：global
格式：global a 修改多个 , 隔开
使用global对全局变量进行修改
例：
a = ‘烫火锅‘
def func1():
global a

将变量a声明为全局变量
a = 100
print(a)
def func2():
print(a)

func1()
func2()递归函数
一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

计算n的阶乘：
例1循环操作：
def func(n):
i = 1
s = 1
while i<=n:
s = s * i
i += 1

return s
print(func(10))
例2递归操作：
def func(n):
if n>1:
res = n * func(n-1)
return res
else:
res = 1
return res

print(func(0))Python中模块和包
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似
模块定义好后，我们可以使用 import 语句来引入模块
格式：
import 模块名
from ...import 语句：n中模块和包
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似
模块定义好后，我们可以使用 import 语句来引入模块
格式：
import 模块名
from ...import 语句：
从模块中导入一个指定的部分到当前文件

导入自定义模块
在test1中定义方法
例：
def name(a,b):
return a+b

在test2 调用

例：
from jiyun.test import test1

s = test1.name(10,30)
print(s)
面向对象
面向对象的三大特点：封装、继承、多态
面向过程：根据业务逻辑从上到下写代码
面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程
面向对象编程2个非常重要概念：类和对象

类(抽象): 具备相同特征和行为的一类事物的统称
对象(具体): 一个具体的事物

对象是面向对象的核心；

6.1.类的组成
类由三部分组成：

类的名称：类名
类的属性：一组数据
类的方法：他的行为

对象 = 属性 + 方法
静态 + 方法
6.2.定义类
格式：
class 类名(object)：
方法
object是顶级父类；
类名的命名规则：大驼峰命名法

6.3.创建实例化对象
格式：
对象名=类名()

例：
# 定义类
class Car():

定义实例方法:

def move(self):

当对象调用实例方法时，Python会自对象本身的引用做为参数，传到实例方法的参数self里

print(‘车在奔跑...‘)

创建一个实例化对象，并用变量BMW来保存它的引用
创建一个实例化对象，他可以调用类的方法和属性
bmn = Car()
bmn.move()
6.4.创建实例属性

例：
class Person(object):

def info(self):
print(‘名字%s‘ % (self.name))

xiaoming=Person()

添加属性，以及对应的值
xiaoming.name="小明"
xiaoming.age=12
xiaoming.grade=3

print(xiaoming.name)

调用方法输出
xiaoming.info()
6.5.魔法方法：init()
init()：初始化属性,在创建对象时,会自动调用该方法初始化属性,还可以通过传参设置不同的属性值
init(self) 中的self参数，不需要传递，python解释器会自动把当前的对象引用传递过去。

例：
class Person():
def init(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age

person1=Person("小明","男",19)
person2=Person("小红","女",20)

print(person1.name,person1.sex,person1.age)
print(person2.name,person2.sex,person2.age)

6.6魔法方法：str()
例：
class Person():
def init(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age

def str(self):
# 可以通过该方法来自定义对象的输出信息
student= "我的名字叫%s的%s" % (self.name, self.age)
return student
person1=Person("小明","男",19)

print(person1)

6.7魔法方法：del()
例：
class Person():
def init(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age

def del(self):
# 在对象被销毁时，自动调用该方法
print( "%s死了" % self.name)
person1=Person("小明","男",19)

del person1

6.8私有属性和方法

1.在属性名和方法名前面加 "__",该属性和方法就是私有属性和私有方法
2.私有属性和私有方法,只有在方法内部可以访问,在类外部不能访问
3. 不管是修改还是访问私有权限的属性,必须通过公有的方法来实现
4. 子类不能继承父类的私有属性和方法

1. 私有属性

   例：
   class Person():
   def init(self,name,sex,age):
   self.name=name
   self.sex=sex
   self.__age=age

def get_age(self):

return self.__age

def set_age(self,a):

self.__age = a

person1=Person("小明","男",19)

调用方法
person1.set_age(30)
print(person1.get_age())

2.私有方法
在方法名前,加 __ ,该方法就是私有方法
例：
class Person():
def init(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age

def __set_age(self,a):
# 在私有方法内修改
self.age = a

def login(self):
# 在公共方法内部，调用私有方法
self.__set_age(30)
person1=Person("小明","男",19)

调用公共方法
person1.login()

展示
print(person1.age)
6.9类属性
在类名和方法中间定义的属性,称为类属性
例：
class Person:

address="china"
def init(self,name,age):
self.name=name
self.age=age
person1=Person(‘zhangsan‘,19)

实例对象调用
print(person1.address)#earth

类名调用
print(Person.address)#earth

6.10.类方法和静态方法
一类事物的共同行为,定义为类方法
类方法可以访问类变量，但不能访问实例变量
类方法的参数为cls,代表类本身,通过cls可以访问类属性或类方法

静态方法不需要多定义参数，可以通过对象和类来访问
静态方法不能访问类变量和实例变量，也不能使用self
例：
class Person:
count = 10
address = ‘china‘
def init(self,name,age):
self.name=name
self.age=age

静态方法修饰符
@staticmethod
def get_address():
return Person.address

类方法修饰符
@classmethod
def money(cls):
return cls.count

person1=Person(‘zhangsan‘,19)

实例对象调用
print(person1.money())#earth

类名调用
print(Person.money())#earth
继承
7.继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

7.1.继承的优点

1. 提高代码重用性
2. 可以继承父类的方法和属性
3. 可以减少代码量，提高开发速度

7.2 单继承
子类继承自多个基类

例：
class Dog(object):
def init(self,name,color="黄色"):
self.name=name
self.color=color
def run(self):
print("%s在跑着"%self.name)

class JinMao(Dog):
def setNewName(self,name):
self.name=name

dog1=JinMao("大黄")
dog1.run()
dog1.setNewName(‘小黄‘)
print(dog1.name)

7.3多继承
子类继承自多个基类
例：
class Ma(object):
def printMa(self):
print("ma的特性")
def run(self):
print("万马奔腾")
class Lv(object):
def printLv(self):
print("lv的特性")
def run(self):
print("万驴奔腾")
class LuoZi(Ma,Lv):
def printLuo(self):
print("骡子的特性")

luo=LuoZi()
luo.printLuo()
luo.printLv()
luo.printMa()
luo.run()

7.4多级继承
例：
class Ma(object):
def printMa(self):
print("ma的特性")
def run(self):
print("万马奔腾")
class Lv(object):
def printLv(self):
print("lv的特性")
def run(self):
print("万驴奔腾")
class LuoZi(Ma,Lv):
def printLuo(self):
print("骡子的特性")

luo=LuoZi()
luo.run()
print(LuoZi.mro)

7.5多重继承
允许从多个父类继承，称为多重继承

例：
class Ma(object):
def printMa(self):
print("ma的特性")
class Lv(Ma):
def printLv(self):
print("lv的特性")
class LuoZi(Lv):
def printLuo(self):
print("骡子的特性")

luo=LuoZi()
luo.printMa()

7.6方法重写及调用父类方法
子类与父类方法同名,子类会覆盖父类方法

子类想要保留继承父类的属性,还想有自己独有的属性:

子类需要重写自己的__init__方法,
在__init__方法中,通过super().init()的方式调用父类的初始化方法,可以继承父类的属性
在__init__方法中,通过self方式可以添加自己独有的属性
例：
class Person():
def init(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
def money(self):
print(‘我有1000‘)

class Student(Person):
def init(self,name,sex,age,hight):
super().init(name,sex,age)
self.hight = hight
def money(self):
print(‘我有100‘)

person1=Student("小明","男",19,178)
print(person1.name,person1.sex,person1.age,person1.hight)
person1.money()

7.7多态
1．多态是面向对象的重要特性,简单点说:“一个接口，多种实现”
2. 指一个基类中派生出了不同的子类，且每个子类在继承同样的方法名的同时又对父类的方法做了不同的实现

例：
class Person(object):
def init(self, name, gender):
self.name = name
self.gender = gender
def address(self):
return ‘中国 ‘ + self.name

class Student(Person):
def init(self, name, gender, score):
super().init(name, gender)
self.score = score
def address(self):
return ‘北京 ‘ + self.name

class Teacher(Person):
def init(self, name, gender, course):
super(Teacher, self).init(name, gender)
self.course = course
def address(self):
return ‘广东 ‘+ self.name

p = Person(‘张三‘,‘男‘)
s = Student(‘小明‘,‘男‘,88)
t = Teacher(‘老王‘,‘男‘,‘语文‘)

print(p.address())
print(s.address())
print(t.address())

练习

1.请手写一个函数，用来取出1—100（均包含）中5的倍数或者带有数字5的所有整数
def fun1():
for i in range(1,101):
if i%5==0 or ‘5‘ in str(i):
print(i)
fun1()
2. lis = [2,3,‘k‘,[‘qwe‘,20,[‘k‘,[‘tt‘,3,‘1‘]],89],‘ab‘,‘adv‘] 写一个函数将该列表中的tt变成大写
def fun2():
lis = [2, 3, ‘k‘, [‘qwe‘, 20, [‘k‘, [‘tt‘, 3, ‘1‘]], 89], ‘ab‘, ‘adv‘]
a = str(lis).replace(‘tt‘,‘TT‘)
print(a)
fun2()
3. 打印该年所有月份，并显示所属季节，如：“1月 冬季 2月 冬季 3月 春季”等
def fun3():
for i in range(1, 13):
if i in (12, 1, 2):
print(i, "冬季")
elif i in (3, 4, 5):
print(i, "春季")
elif i in (6, 7, 8):
print(i, "夏季")
else:
print(i, "秋季")
fun3()
4. 用户由键盘随机输入一个年份，如：2018，打印该年是否是闰年（能被4整除但不能被100整除，或者能被400整除的年 份）
def fun4(b):
if b % 4 == 0 and b % 100 != 0 or b % 400 == 0:
print(b,"是闰年")
else:
print(b,‘不是闰年‘)
year = int(input(‘请输入年份：‘))
fun4(year)
5. 判断数字是否是回文数（数字顺读和逆读都是一样）
def fun5(a):
if a == a[::-1]:
print(a,‘是回文数，回文数是‘,a[::-1])
else:
print(a,"不是回文数")
a = input("请输入数字：")
fun5(a)
面向对象

1. 功能描述
   定义一个类：MyYear ，它包含：
   1个实例属性：year
   用户由键盘随机输入一个年份，如：2018，将该值作为MyYear类__init__方法的一个参数传入，并赋给类的实例属性year
   class MyYear(object):
   def init(self):
   self.year = int(input("请输入年份："))

7个实例方法：

1. show_season()
   打印该年所有月份，并显示所属季节，如：“1月 冬季 2月 冬季 3月 春季”等
   def show_season(self):
   for i in range(1, 13):
   if i in (12, 1, 2):
   print(i, "冬季")

    elif i in (3, 4, 5):
        print(i, "春季")
   
    elif i in (6, 7, 8):
        print(i, "夏季")
   
    else:
        print(i, "秋季")
   

2. isleap()
   打印该年是否是闰年（能被4整除但不能被100整除，或者能被400整除的年 份），如：如果属性year的值为2018，则输出：“2018年不是闰年”
   def isleap(self):
   if self.year % 4 == 0 and self.year % 100 != 0 or self.year % 400 == 0:
   print(self.year, "是闰年")
   else:
   print(self.year, ‘不是闰年‘)

3. year_sum()
   打印从1到该年所在数字之间所有整数的和，如：如果属性year的值为2018， 则计算1+2+3+4+5+...+2018的值并输出结果。
   def year_sum(self):
   a = 1
   sum = 0
   while a <= self.year:
   sum += a
   a += 1
   print(sum)

4. check_num()
   判断该年所在数字是否是回文数（即是给定一个数，这个数顺读和逆读都是一样 的）并输出判断结果，如：如果属性year的值为2002，则输出“2002是回文 数”， 如果属性year的值为2018，则输出“2018不是回文数”
   def check_num(self):
   if self.year == self.year[::-1]:
   print(self.year,‘是回文数，回文数是‘,self.year[::-1])
   else:
   print(self.year,"不是回文数")

5. show_leap_year()
   判断从公元1年到该年所在的区间内的所有年份,输出所有闰年年份
   如:如果属性year的值为20，则输出 4 8 12 16 20
   def show_leap_year(self):
   for i in range(1,self.year+1):
   if i % 4 == 0 and i % 100 != 0 or i % 400 == 0:
   print(i, "是闰年")
   else:
   pass

6. show_num_div()
   打印出从1-该年所在数字之间所有能被9整除或者包含数字9的年份,
   如:如果属性year的值为20，则输出 9 18 19
   def show_num_div(self):
   for i in range(1,self.year+1):
   if i % 9 == 0 or ‘9‘ in str(i) :
   print(i)
   else:
   pass
   if name == ‘main‘:

b =MyYear()

b.year_sum()

b.show_leap_year()

b.show_num_div()

2. 功能描述
   定义一个类：MyNum，它包含：
   1个实例属性：num
   用户由键盘随机输入一个正整数数字，如：100，将该值作为MyNum类__init__方法的一个参数传入，并赋给类的实例属性num
   class MyNum(object):
   def init(self):
   self.num = int(input("请输入一个整数数字："))

6个实例方法：

1. show_num()
   打印从1到属性num之间所有的数字，如：如果属性num为100，则打印“1 2 3 4 ...99 100”
   def show_num(self):
   for i in range(1,self.num+1):
   print(i)
2. calc_sum()
   计算从1-num之间所有数字的和并输出，如：如果属性num的值为100，则计算 1+2+3+...+99+100的值
   def calc_sum(self):
   a = 1
   sum = 0
   while a<= self.num:
   sum += a
   a +=1
   print(sum)
3. calc_odd_sum()
   计算从1-num之间所有奇数的和并输出，如：如果属性num的值为100，则计算 1+3+5+7+...+99的值
   def calc_odd_sum(self):
   a = 1
   sum = 0
   while a <= self.num:
   if a%2==1:
   sum += a
   a +=2
   else:
   pass
   print(sum)
4. calc_even_sum()
   计算从1-num之间所有偶数的和并输出，如：如果属性num的值为100，则计算 2+4+6+8+...+100的值
   def calc_even_sum(self):
   sum = 0
   for i in range(1,self.num+1):
   if i%2==0:
   sum += i
   i += 1
   print(sum)
5. show_num_div()
   打印出从1-num之间所有能被7整除的数
   def show_num_div(self):
   for i in range(1,self.num+1):
   if i%7==0:
   print(i)
6. check_num()
   判断num是否是回文数（即是给定一个数，这个数顺读和逆读都是一样的）并输 出判断结果，如：如果属性num的值为101，则输出“101是回文数”；如果属性 num的值为123，则输出“123不是回文数”
   def check_num(self):
   if self.num == self.num[::-1]:
   print(self.num,‘是回文数，回文数是‘,self.num[::-1])
   else:
   print(self.num,"不是回文数")
   if name == ‘main‘:
   c=MyNum()
   c.calc_sum()
   c.calc_odd_sum()
   c.calc_even_sum()
   c.show_num_div()
   c.check_num()