python学习第14天----函数复习、面向对象初始

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 女喜欢吃苹果

学习来源：https://www.bilibili.com/video/BV1sE411D7qf