1.函数回顾
1)函数的定义:以功能为导向,一个函数就是一个功能,用于简化代码
2)函数返回值:
①return作用
#结束函数的执行
#将函数的返回值返回给调用者,即函数名()
②如果函数中没有return,默认返回None
③如果只有return,也返回None
④如果返回多个值(return 1,2,'str'),返回一个元组(1,2,'str')
3)函数的参数
①实参角度
#位置参数
#关键字参数
#混合参数:关键字参数一定在位置参数后面
②形参角度
#位置参数
#默认值参数:传值就会覆盖,不传值就会使用默认的;默认参数一定在位置参数后面
#动态参数:*args **args 当传入的参数不缺定时可使用
*args可接受所有的位置参数,放置在元组中;即把实参中的所有位置参数聚合到一个元组当作,这个元组赋值给了args
**kwargs可接受所有的默认值参数,放置在字典中;即把实参中所有的位置参数聚合到一个字典中,然后把这个字典赋值给kwargs
注:形参顺序:位置参数、*args、默认参数、**kwargs
def func(*args,**kwargs): print(args) print(kwargs) func(1,2,3,name="阿狸",age=18) 输出: (1, 2, 3) {'name': '阿狸', 'age': 18}
补充:
当定义一个函数的时候,*代表聚合
当执行一个函数的时候,*代表打散
print()函数不能接受关键字参数
def func(*args): print(args) lst1 = [1,3,5] lst2 = [2,4,6] func(lst1,lst2) func(*lst1,*lst2) #打散,相当于传入了6个参数 输出: ([1, 3, 5], [2, 4, 6]) (1, 3, 5, 2, 4, 6)
4)名称空间,作用域
①名称空间:当程序执行时,将变量与值对应关系存放在一个空间中
②临时名称空间:当函数执行时,将函数中的变量以及值得对应关系放到一个空间中,这个空间会随着函数得结束而消失
③内置名称空间:python自带的,如内置函数等
⑤作用域
#全局作用域:内置名称空间+全局名称空间
#局部作用域:临时名称空间
⑥global
#在函数中声明一个全局变量
#在函数中修改一个全局变量
⑦nonloal
#在函数中对父级(或者)更高等级的变量进行修改,但是不能修改全局变量
⑧函数名的运用:
#可以作为变量
#可以作为容器类的元素
#可以作为函数的参数
#可以作为函数的返回值
⑨函数的嵌套
⑩闭包:内层函数对外层函数的变量的引用
5)迭代器
#内部含有__ier__并且含有__next__方法
#节省内存
#惰性机制
#一条路走到黑
6)生成器
①字节用python代码写的迭代器
②生成器表达式
#循环模式
#筛选模式
2.面向对象
1)概念
①类:具有相同属性和功能的一类事物
②对象:具体的类的表现,具体的、真实存在的实例
2)定义类
①语法:
class 类名:
类体(变量部分+函数部分)
3)以类名的角度,操作类中的静态变量:
#法一:
类名.__dict__ 查询类中所有的内容
注:只能通过__dict__对类中的静态变量进行查询,不能对类中变量进行增删改
class Student: id = "学号" #静态变量 name = "名字" age = "年龄" def sleep(self): #动态变量 print("睡觉") def sleep(self): print("学习") print(Student.__dict__) print(Student.__dict__['name']) 输出: {'__weakref__': <attribute '__weakref__' of 'Student' objects>, '__module__': '__main__', 'age': '年龄', 'sleep': <function Student.sleep at 0x000002B327E3C0D0>, 'id': '学号', '__doc__': None, '__dict__': <attribute '__dict__' of 'Student' objects>, 'name': '名字'} 名字
#法二:通过 【类名.静态变量】的方式对类中的单个变量进行增删改查
class Student: id = "学号" #静态变量 name = "名字" age = "年龄" def sleep(self): #动态变量 print("睡觉") def sleep(self): print("学习") print(Student.name) 输出: 名字
#可通过类名.静态变量的方式对类中的静态变量进行增删改查
class Student: id = "学号" #静态变量 name = "名字" age = "年龄" def sleep(self): #动态变量 print("睡觉") def sleep(self): print("学习") Student.email = "邮箱" print(Student.__dict__) 输出: {'__weakref__': <attribute '__weakref__' of 'Student' objects>, 'age': '年龄', '__doc__': None, '__module__': '__main__', 'name': '名字', 'id': '学号', '__dict__': <attribute '__dict__' of 'Student' objects>, 'sleep': <function Student.sleep at 0x000002708900B0D0>, 'email': '邮箱'}
4)以类名的角度,操作类中的动态变量(即函数):
#以【类名.函数名()】的方式执行函数,但是需要传参数,因为函数默认有一个位置参数---基本不用类名去操作函数,而是通过对象的方式
class Student: id = "学号" #静态变量 name = "名字" age = "年龄" def sleep(self): #动态变量 print("睡觉") def sleep(self): print("学习") Student.sleep(111) 输出: 学习
5)以对象的角度
①实例化一个对象(即创建一个对象,也叫产生一个类名空间)
类名() ----------实例化对象(即类名+()的过程,就是实例化的过程、就是创建对象的过程)
如:Student()
class Student: def __init__(self,id,name,age): id = id name = name age = age def study(self): print("学习。。。。") Student(101,"阿狸","16") #实例化过程,即常见对象的过程;整体叫做实例,即对象
注:只要类名+()产生一个对象,自动执行类中的__int__方法
②只要通过【类名()】产生一个对象,自动执行类中的__init__方法
class Student: def __init__(self): print("初始化方法") Student() 输出: 初始化方法
③【类名()】产生一个内存地址(就相当于开辟了一个内存空间),然后【类名()】自动执行__init__()方法,然后把对象的内存地址传入了__init__()方法的形参self,所以打印self的值和对象地址是一样的
class Student: def __init__(self): print(self) print("初始化方法") ret = Student() 输出: <__main__.Student object at 0x00000168A0745EB8> 初始化方法 <__main__.Student object at 0x00000168A0745EB8>
④以对象的角度,对类中变量进行增删改
class Student: def __init__(self, id, name, age): self.id = id self.name = name self.age = age print(id, name, age) ret = Student(101, "阿狸", "16") # 实例化过程,即常见对象的过程 ret.higt = "165" #增加 del ret.age #删除 ret.name = "九尾妖狐" #修改 print(ret.__dict__) 输出: 101 阿狸 16 {'higt': '165', 'name': '九尾妖狐', 'id': 101}
注:对象只能对类中的静态变量进行查询,不能增删改
⑤通过对象名调用类中的方法,方法第一个参数self是不用传实参的
3.类、对象
1)__init__()方法-------给对象封装相应的属性
①实例化一个对象后,会把对象的内存地址传给__init()方法的第一个位置参数(约定俗成为self)
class Student: def __init__(a): print(a) ret = Student() print(ret) 输出: <__main__.Student object at 0x00000240C8785EB8> <__main__.Student object at 0x00000240C8785EB8>
②__init__()其他的位置参数,在创建对象时在【类名()】的括号中写入
class Student: def __init__(self, id, name, age): id = id name = name age = age print(id, name, age) Student(101, "阿狸", "16") # 实例化过程,即常见对象的过程 输出: 101 阿狸 16
总结:实例化一个对象,产生一个对象空间,然后自动执行类中的__init__()方法,然后将对象空间传给__init__()方法的第一个参数,并且将其他实参传递给__init__()函数的其他形参;然后再在__init__()方法中为对象的地址增加变量
class Student: def __init__(self, id, name, age): self.id = id self.name = name self.age = age print(id, name, age) Student(101, "阿狸", "16") # 实例化过程,即常见对象的过程 输出: 101 阿狸 16
#可通过__dict__()查看类中的所有变量
class Student: def __init__(self, id, name, age): self.id = id self.name = name self.age = age print(id, name, age) ret = Student(101, "阿狸", "16") # 实例化过程,即常见对象的过程 print(ret.__dict__) 输出: 101 阿狸 16 {'id': 101, 'name': '阿狸', 'age': '16'}
补充:
①__init__()方法就是构造方法
②操作类中的方法:除了类方法、静态方法需要类名调用之外,剩下的方法都要对象调用
③除了类方法和静态方法,所有的方法的第一个参数都是self;所以都可以通过对象名调用类中的方法(即将对象空间传递给了方法的第一个参数self)
4.练习
1.完成如下功能
1)创建一个Person类,在类中创建三个静态变量(静态字段)
mind= "能思考"
age = "有肤色"
language = "能说话"
2)在类中定义三个方法,吃饭,睡觉,工作.
3)在此类中的__init__方法中,给对象封装5个属性:国家,姓名,性别,年龄,
①实例化四个人类对象:
第一个人类对象p1属性为:德玛西亚,拉克丝,女,18,165
第二个人类对象p2属性为:诺克萨斯,卡特,女,20,170
第三个人类对象p3属性为:均衡教派,劫,男,26, 178
第四个人类对象p4属性为:p1的国籍,p2的名字,p3的性别,p2的年龄,p3 的身高.
②通过对象执行方法
通过p1对象执行吃饭方法,方法里面打印:拉克丝在吃饭.
通过p2对象执行吃饭方法,方法里面打印:卡特在吃饭.
通过p3对象执行吃饭方法,方法里面打印:(p3对象自己的名字)在吃饭.
通过p1对象找到Person的静态变量
mind
通过p2对象找到Person的静态变量
skin
通过p3对象找到Person的静态变量 language
class Person: mind = "能思考" skin = "有肤色" language = "能说话" def __init__(self,country,name,sex,age,hight): self.country = country self.name = name self.sex = sex self.age = age self.hight = hight def eat(self): print("%s在吃饭" % self.name) def sleep(self): print("睡觉") def work(self): print("工作") p1 = Person("德玛西亚","拉克丝","女",18,165) p2 = Person("诺克萨斯","卡特","女",20,170) p3 = Person("均衡教派","劫","男",26,178) p4 = Person(p1.country,p2.name,p3.sex,p2.age,p3.hight) p1.eat() p2.eat() p3.eat() print(p1.mind) print(p2.skin) print(p3.language) 输出: 拉克丝在吃饭 卡特在吃饭 劫在吃饭 能思考 有肤色 能说话
2.写一个类,输入名字,年龄,性别,爱好
如小明 10岁 男 最爱打篮球
小明 10岁 男 喜欢吃苹果
小花 12 女 喜欢吃苹果
class Hobby: def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def sports(self): print("%s %s %s最爱打篮球"% (self.name,self.age,self.sex)) def fruits(self): print("%s %s %s喜欢吃苹果" % (self.name,self.age,self.sex)) h1 = Hobby("小明",18,"男") h2 = Hobby("小花",15,"女") h1.sports() h1.fruits() h2.fruits() 输出: 小明 18 男最爱打篮球 小明 18 男喜欢吃苹果 小花 15 女喜欢吃苹果