python 函数 类 模块

函数

封装好，进行某种功能

del 函数名(参数)：
	函数体
	return 返回值（可以没有return语句）

作用域

在函数内定义的变量，仅能在函数内部使用，这是局部变量
函数之外的定义与赋值的变量，可以再任何地方使用，这是全局变量
global语句，可以将局部变量变成全局变量global 函数名

函数参数

位置参数：参数的顺序和个数和函数定义中一致

sum=0
def math(a,b,c):
	sum=a+b+c
	return sum
a=1;b=2;c=3	
math(a,b,c)#a,b,c 依次传入math函数

默认参数：必须放在位置参数后面

def menu(hamburger,drinl,snacks='蛋挞'):
	print(('汉堡选择：' + hamburger)
	print('饮料选择：' + drink)
	print('小食选择：' + snacks + '\n')
menu('香辣鸡腿堡','可乐')
#打印结果：香辣鸡腿堡，可乐，蛋挞
menu('香辣鸡腿堡','可乐','薯条')
#打印结果：香辣鸡腿堡，可乐，薯条（给了3个参数。第3个参数被更新）	

不定长参数：*参数名，当传入参数数量不确定时使用，数据类型是元组（tuple），可以用for来循环遍历

def math(a,*b,c=1):
	print('a'=a)
	print('c'=c)
	for i in b:
		print(b)
math(123,11,22,33,c=2)

关键参数：使用伪参数（形参）的名字来指定其对应的实参（传入的变量）

def math(a,b):
	x=a-b
	return x
y=math(b=3,a=7)

字典传参
1.关键参数作为字典接收

def dic(**args):
	for s,t in args.items():
		print(s,':',t)
dic(a=20,b=30,c=50)
#a:20
#b:30
#c:50 args变成一个字典

2.将字典展开并接收

def dic(a,b,c):
	print(a,b,c)
d={'a':20,'b':30,'c':50}
dic(**d)
#20 30 50
#字典d被展开到伪参数a，b，c上

函数对象

在函数名末尾不加括号，只写名称的格式所表示的是函数本身，我们将其称之为函数对象，可以像值一样将其带入到变量中去

def printHello(name):
	print('hello',name)
func=printHello#func是函数对象
func('siri')
#打印结果是hello siri
#将函数printHello带入到func，func可以作为函数使用	

无名函数

进行简单处理的函数，可以使用关键字“lambda"来记述，这种写法称为无名函数（）

#函数
def lo(a):
	return a.lower()
#无名函数
lo=lambda s:s.lower()
print(lo('HELLO'))#输出 hello	

回调函数

函数可以将别的函数作为参数使用，被作为参数使用的函数被称为回调函数

def calcdisp(a,b,callback):
	print(callback(a,b))
def calllback(a,b):
	return (a+b)
calcdisp(3,5,callback)#输出值是8
#简化写法
calcdisp(3,5,lambda a,b : a + b)#callback被无名函数替代

函数嵌套

可以定义函数中的函数，内部函数称为本地函数

def func1():
	def func2():
		print(1)
	print(2)
	func2()#调用内部函数
func1()#调用外部函数
#在这里不能调用func2，func2是func1的内部函数，作用域在func1内

类

类的创建

类的创建：class 类名（类名首字母大写）：
类的属性创建：赋值语句
类的方法创建：def 方法名（self）：
其中，self代表着实例化对象，是所有实例的替身

class Math:
	type_1=int_true#创建属性
	def plus(self):#定义方法
		print(a+b)

类的调用

类的实例化：例如coke=water（），表明water这个类创建了一个叫做coke的实例，这个实例可以调用water类中的属性和方法

class Food:
	drink = '可口可乐'
	def hambage(self):
		print('香辣鳕鱼堡')
KFC=Food()#实例化类math，number为实例化对象，即self=number
print(Food.drink)#调用实例化对象的属性type_1
Food.hambage()#调用了实例化对象的方法plus

注意：用def创建方法时，第一个参数位置要留给self，不需要传参
在类的方法内部想要调用类属性和其他方法，用self.属性或self.方法

class Food:
	drink = '可口可乐'
	def hambage(self):
		print('香辣鳕鱼堡')
	def menu(self):
		self.hambage()
		print(self.drink,'\n''蛋挞')
KFC = Food()
KFC.menu()

初始化方法

当每个实例对象被创建时，该方法内的代码无须调用，自动运行
可以在初始化方法内部完成类属性的创建，并设定初始值，方便随时调用

class Musician:	
	def__int__(self):
		print('这是初始化方法')
lisi=Musician（）

那么调用属性的代码就发生了改变

class Pre:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def prin(self):
        print('%s的年龄是%d'%(self.name,self.age))
liu=Pre('刘刘',20)#作为name和age的值传到Pre中
liu.prin()

类的继承

子类有父类的属性和方法，子类属于父类，父类属于object类

class X():
    name=1
class Y(X):
    pass #占位

class Car:
	wheel=4
	def run(self):
		print('有%d个轮子'%self.wheel)
class BMW(Car):
	pass
BMW320=BMW() #子类BMW实例化，BMW320
print(BMW320.wheel)#有4个轮子

类的多层继承：
子类可以继承父类，父类的父类，父类的父类的父类，语法同单层继承
类的多重继承：
一个子类可以继承多个父类，和子类相关性更强的父类会放在更左侧，先在左侧父类找，找不到再去右侧父类（就近原则）

类的定制

子类可以再继承的基础上进行个性化定制，如创建新属性、新方法；修改继承的属性和方法
属性方法名不同时创建，相同名字时修改

#音乐人
class Musician():
	loveMusic = True3     
	def intr(self):
	         print("我喜欢音乐")
	         print("我来自音乐界")
	def sing(self):
		 print("我在唱歌")
# Rapper继承音乐人
class Rapper(Musician): #类的继承
        garrulous = True    #类的定制 ， 增加属性
        def composition(self):  #类的定制， 增加方法
                 print("我可以创作简单的歌词")
        def sing(self): #类的定制，更改方法
        	 print("我以说的方式进行唱歌")

csunYuk = Rapper()
print(csunYuk.loveMusic) 
print(csunYuk.garrulous)
csunYuk.composition()
csunYuk.sing()
#True
#True
#我可以创作简单的歌词
#我以说的方式进行唱歌

也可以对实例化属性进行修改

模块

模块，是一个将代码封装起来方便使用的py文件。里面可以有类、函数、变量。

a=10;b=1#变量


print(a)#函数


def math(a,b):#自定义函数    
    c=0
    c=a+b
    return c#math函数返回c


class Math:#类
    num='1'#属性
    def __init__(self,a):#初始化函数
        self.a=a
    def plus(self):#方法
        print(self.num)


import test.py#调用模块

使用模块

1、import 语句
⽤法：import 模块名
例⼦：import time;import csv

如何调⽤模块中的函数，变量
⽤法：模块名.函数；模块名.变量
2、from…import语句
⽤法： 从模块中导⼊⼀个指定的部分到当前模块（函数、变量、类名）
例⼦：from csv import *，默认将CSV模块中的所有函数、变量进⾏全部导⼊
3、if __name__=='__main__'
⽤法：当运⾏的⽂件是程序的⼊⼝时，则会执⾏if name=='main’下的语句，相反，当运⾏的⽂件作为模块是被其他程序导⼊时，代码if name=='main’下的代码则不会执⾏

#不使用if __name__=='__main__'
#A.py
name = '小刘'
def fun_A():
	print('调用方法A')
def print_name():
	print('__name__的值是',__name__)
print_name()
fun_A()#做脚本运行时：__name__的值是__main__,调用方法A
#B.py
import A#B运行，输出：__name__的值是A(值变成了模块名)，调用方法A

#使用if __name__=='__main__'
#A.py
name = '小刘'
def fun_A():
	print('调用方法A')
def print_name():
	print('__name__的值是',__name__)
if __name__=='__main__'
	print_name()
	fun_A()#做脚本运行时：__name__的值是__main__,调用方法A
#B.py
import A
print_name()#B运行，输出：__name__的值是A,不会调用fun_A函数了