1.Python中函数
1. 函数的作用
提高代码的复用性
提高开发效率
减少维护代码维护量
# return 和 print的区别：
# 在执行函数的时候return无法打印出值，return返回的结果只能用于给变量赋值。而pirnt则可以直接打印。
# return还有一个重要特性：在函数中，凡是遇到return，这个函数就会结束，这里要特别注意。针对无限循环的函数，可以使用return
- 定义函数格式
Def 函数名():
代码
- 函数调用：
通过 函数名() 调用
- 函数的参数
定义：为了让一个函数更通用
例：
# 函数名里定义两个参数
def func(a,b): # 此参数为 形参
# 定义方法
c = a+b
print(c)
# 调用时添加具体值
func(3,6) # 调用的参数为 实参
- 缺省参数
定义：在形参中有默认值的参数，称为缺省参数
注意：缺省参数要放到形参最后面
例：
def func(a,b=3):
# 定义方法
c = a+b
print(c)
# 调用时添加具体值
func(3)
- 不定长参数
*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)
- 多个不定长参数的存放顺序
*args,缺省参数,**kwargs
- 函数的种类
(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)
- 函数嵌套
执行顺序：
例：
def func():
print('烫火锅')
def fun2():
print('第一次调用')
func()
print('第二次')
fun2()
2局部变量
就是在函数内部定义的变量
作用范围函数内部，函数外部不能调用
局部变量作用:为了临时保存数据需要在函数中定义变量来存储。
例：
def func1():
a = '高铁'
print('----修改前---a=%s'%a)
a = '飞机'
print('---修改后----a=%s'%a)
def func2():
a = 400
print('------a=%d'%a)
func1()
func2()
3全局变量
1. 什么是全局变量
一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
例：
# 在函数外定义变量称为 全局变量
# 定义全局变量
a = '烫火锅'
def func1():
print(a)
def func2():
print(a)
func1()
func2()
2. 修改全局变量
关键词：global
格式：global a 修改多个 , 隔开
使用global对全局变量进行修改
例：
a = '烫火锅'
def func1():
global a
# 将变量a声明为全局变量
a = 100
print(a)
def func2():
print(a)
func1()
func2()
4递归函数
- 递归函数
一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。
# 计算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))
5 Python中模块和包
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似
模块定义好后，我们可以使用 import 语句来引入模块
格式：
import 模块名
from ...import 语句：
从模块中导入一个指定的部分到当前文件
1.导入自定义模块
在test1中定义方法
例：
def name(a,b):
return a+b
在test2 调用
例：
from jiyun.test import test1
s = test1.name(10,30)
print(s)
6.面向对象
面向对象的三大特点：封装、继承、多态
面向过程：根据业务逻辑从上到下写代码
面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程
面向对象编程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私有属性和方法
- 在属性名和方法名前面加 "__",该属性和方法就是私有属性和私有方法
- 私有属性和私有方法,只有在方法内部可以访问,在类外部不能访问
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())
- 私有方法
在方法名前,加 __ ,该方法就是私有方法
例：
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方法重写及调用父类方法
子类与父类方法同名,子类会覆盖父类方法
子类想要保留继承父类的属性,还想有自己独有的属性:
1. 子类需要重写自己的__init__方法,
2. 在__init__方法中,通过super().init()的方式调用父类的初始化方法,可以继承父类的属性
3. 在__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())