可以重复使用，可以提高应用的模块性和代码重复利用率
定义函数规则：
以 def 开头，后接函数标识符和圆括号()
任何传入参数和自变量必须在圆括号中间，圆括号之间可以用于定义参数
函数内容以冒号起始，并且缩进
return[表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None
语法：
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
函数的调用
def printme(str):
"打印任何传入的字符串"
print(str)
return
printme("我要调用用户自定义函数");
printme("再次调用");
printme(str="my string")
按值传递参数和引用传递参数
# 可写函数说明
def changeme(mylist):
"修改传入的列表"
mylist.append([1,2,3,4])
print("函数内取值：", mylist )
return
# 调用changeme函数
mylist = [10,20,30]
changeme(mylist)
print("函数外取值：", mylist )
参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数
def printinfo(name,age):
"打印任何传入的字符串"
print("Name", name)
print("Age", age)
return
printinfo( age=18, name="zhangs" )
默认参数
不定长参数
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号(*)的变量名会存放所有未命名的变量参数
#可写函数说明
def printinfo( arg1, *vartuple):
"打印任何传入的参数"
print("输出：")
print(arg1)
for var in vartuple:
print(var)
return
printinfo(10)
printinfo(70,60,50)
匿名函数
python使用lambda来创建匿名函数
lambda只是一个表达式，函数体比def简单
lambda主体是一个表达式，不是代码块，仅仅能在lambda表达式中封装有限的逻辑
lambda拥有自己的命名空间
语法
lambda [arg1,arg2,.....argn]:expression
实例
#可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print("相加后的值为：", sum(10, 20))
return语句
退出函数，不带参数值的return语句返回None
变量作用域(全局变量 局部变量)
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
实例
total = 0 #这是一个全局变量
#可写函数说明
def sum(arg1, arg2):
"返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量
print("函数内是局部变量：", total)
return total
sum(10, 20)
print("函数外是全局变量：", total)
什么是面向对象编程？
面向对象术语
1、类（class）
用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
2、方法
类中定义的函数
3、类变量（属性）
类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性。
4、数据成员
类变量或者实例变量用于处理类及其实例对象的相关的数据
5、方法重写
从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override),也称为方法的重写
6、实例变量
定义在__int__方法中的变量，只用于当前实例的类
7、继承
一个派生类(derived class)继承基类(base class)的字段和方法。
继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象。
8、实例化
创建一个类的实例，类的具体对象。一个类可以实例化出无数个对象
9、对象
通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法
10、多态
不同类的对象使用同样的 *** 作
11、封装
对外部世界隐藏对象的工作细节
类的定义语法
class ClassName:
语句1
...
语句n
----------------
注：
1、类定义与函数定义(def语句)一样，只有在被执行才会起作用
在定义阶段只是语法检查
2、类是属性和方法的组合，所以语句1可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句
一个对象的特征称为”属性“
一个对象的行为称为”方法“
代码层面，属性就是变量，方法就是函数
3、进入类定义时，就会创建一个新的命名空间，并把它用作局部作用域
4、正常离开（从结尾出）类定义时，就会创建一个类对象
实例
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
return 'hello world'
注：
类包含属性和方法
类属性和实例属性
方法： 定义在类中的函数
func表示定义了一个名为func的"实例方法"，实际上就是一个稍微特殊点的函数(方法的第一个参数必须为self)
类对象
支持两种 *** 作（属性引用 实例化）
实例化：使用instance_name = class_name()的方式实例化，实例化 *** 作创建该类的实例(格式：实例对象名 = 类名()，实例对象名是我们自己定义的)
class MyClass:
'''定义一个MyClass类'''
i = 12345
def func(self):
return 'hello world'
#实例化一个类
my_class = MyClass()
print(my_class)
属性引用：使用class_name.attr_name的方式引用类属性(类名.属性名)
class MyClass:
'''定义一个MyClass类'''
i = 12345
def func(self):
return 'hello world'
print(MyClass.i) # 引用属性
print(MyClass.func) #引用实例方法：实例方法可以被这样引用，但是这样引用无意义
# 类属性也可以被赋值，因此可以通过赋值来更改类属性的值
MyClass.i = 123
print(MyClass.i)
实例对象
基于类创建的一个具体的事物
通过类产生实例对象的过程称为实例化
格式： 实例对象名 = 类名()
实例对象是类对象实例化的产物，实例对象仅支持一个 *** 作：属性引用
"实例对象名.属性名"
"实例对象名.方法名()"
=====================================================================
实例
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
return 'hello world'
# 第一个实例对象
my_class = MyClass()
print(id(my_class))
print(my_class.i) # 引用类属性
print(my_class.func()) # 引用实例方法
# 第二个实例对象
my_class1 = MyClass()
print(id(my_class1))
# 类属性重新赋值
my_class1.i = 123
print(my_class1.i) # 引用类属性
print(my_class1.func()) # 引用实例方法
# 第三个实例对象
my_class2 = MyClass()
print(id(my_class2))
print(my_class2.i)
print(my_class2.func()) # 引用实例方法
============================================================================
注：
类在使用前必须先实例化，并将实例赋值给一个变量(得到实例对象)
self参数
1、在定义实例变量、实例方法时的第一个参数必须是self
2、self在定义时需要定义，但是在调用时会自动传入
3、self代表的当前的实例对象本身
================================
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
print("self参数：", self)
return 'hello world'
a = MyClass()
print("实例对象：", a)
a.func()
b = MyClass()
print("实例对象：", b)
b.func()
================================================
class Ball:
def setname(self, name, age):
self.name = name
print(age)
def kick(self):
return "我叫%s" % self.name
a = Ball()
b = Ball()
c = Ball()
a.setname("A", 1)
b.setname("B", 2)
c.setname("C", 3)
print(a.kick())
print(b.kick())
print(c.kick())
=========================================
注：
在方法中定义的参数，一般来说只能在当前方法中使用(作用域)
如果想要一个方法中的参数能在其他方法中使用，那么就可以使用"self."来将这个参数变成一个实例变量(实例变量后面介绍，这里主要是遇到了这种写法)
类变量
该类所有实例对象共享的属性（也叫”类属性“）
⑴类属性是所有实例都共用的：所有实例都可以调用这个类属性
⑵在类中任意地方(所有方法中)都可以使用"类名.类属性名"来调用类属性
⑶在类外任意地方都可以使用"类名.类属性名"或"实例名.类属性名"来调用类属性
=================================================
class Car():
"""这是一个汽车类"""
brand = "宝马"
def run(self, s):
# 类中调用类属性：类名.属性名
print("当前车型为：%s,当前行驶速度：%s KM/S" % (Car.brand, s))
a = Car()
# 类外调用类属性：实例名.属性名
print(a.brand, id(a.brand))
a.run(110)
b = Car()
print(b.brand, id(b.brand))
b.run(200)
===============================================
实例变量
1、是每个实例都独有的数据（也可以叫"实例属性"）
2、实例变量是定义在__init__方法中的
①__init__()方法也是类中的一个方法，因此其第一个参数也必须是self
②实例变量是每个实例对象独有的，因此在定义实例变量时，必须是：self.实例变量名 = 外部形参名(通过self来绑定当前实例对象)
③在类中任意地方(所有方法中)都可以使用"self.实例属性名"来调用实例属性
④在类外任意地方都可以使用"实例名.实例属性名"来调用实例属性
=================================================================
class People():
country = "china" # 类属性country，是所有实例共有的
def __init__(self, name):
self.name = name # 实例属性name，是每个实例独有的
def speak(self, age):
# 类中调用类属性：类名.属性名
# 类中调用实例属性：self.属性名
print("我的名字是：%s,来自：%s,年龄是：%s" % (self.name, People.country, age))
# 实例化类时传入实例变量值
a = People("Tom")
a.speak(11)
b = People("Jack")
b.speak(12)
=============================================================
注：
一个类中存在实例变量(定义了init方法且init方法中存在形参)时，那么在实例化类时就需要传入对应的实参，否则会报错
类中是不可能出现实例对象名的
类中的self参数就相当于一个形参，当类实例化后，实例对象就相当于self参数的实参
哪个实例对象在调用，self参数就表示哪个实例对象
在类中调用实例属性时都必须使用"self.实例属性名"的方式来调用，这样才能通过self参数来确定当前是哪个实例对象在调用
类变量与实例变量
#在调用一个类中的属性时，Python会按照一定的顺序去查找这个属性：先在当前实例中找，有就用当前实例中的，如果没有就找类中的
==================================================================
class C:
count = 0
a = C()
b = C()
c = C()
print(a.count, b.count, c.count) # output:0,0,0
a.count += 10 # 实例对象调用类属性
print(a.count, b.count, c.count) # output:10,0,0
C.count += 100 # 类对象调用类属性
print(a.count, b.count, c.count) # output:10,100,100
================================================================
注：
通过"实例对象名.属性名"来覆盖类属性，只会影响到当前实例对象，不会影响到其他实例对象中的类属性
通过"类名.属性名"来覆盖类属性，会影响到所有实例的类属性
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）