Python从入门到高手（内部资源-配学习资料）_哔哩哔哩_bilibili

# 类中方法：动作
# 类首字母大写
# 种类：普通方法 类方法 静态方法 魔术方法

'''
普通方法格式：
def 方法名（self,[,参数，参数]）
    pass
'''


class Phone:
    brand = 'xiaomi'
    price = 4999
    type = 'mate 80'

    # Phone类里面方法：call
    def call(self): #创建对象后所分配的内存地址
        print('self------>', self)
        print('正在访问通讯录:')
        for person in self.address_book:
            print(person.items())
        print('正在打电话......')
        print('留言：',self.note)


phone1 = Phone()  # 产生自身的空间
phone1.note = '我是phone1的note'
phone1.address_book=[{'159008867454':'于鹏'},{'159008860000':'晓伟'}] # 手机号在前面避免重名
print(phone1, '------1------')
# print(phone.brand)
phone1.call() # call(phone1)--->self.note

print('*' * 30)
phone2 = Phone()  # 产生自身的空间
phone2.note = '我是phone2的note'
print(phone2, '------2------')
phone2.call() #call(phone2)--->self.note

------------------------------------------------------------------------------------------

# 函数 和 类里面定义的：方法
def func(names):
    for name in names:
        print(name)


name_list = ['aa', 'bb', 'cc']
func(name_list)


class Phone:
    # 魔术方法之一：__名字__() 称作魔术方法
    def __init__(self):  # init初始的，初始化,系统默认执行，模版的统一化
        # print('------init------')
        self.brand = 'xiaomi'  # 动态的给self空间里添加两个属性：brand，price
        self.price = '4999'

    def call(self):  # self是不断发生改变的
        print('------>call')
        print('价格', self.price)  # 不能保证每个self中都存在price


# p = Phone()
# p.price = 1000
# p.call()  # p.call()  p对象
#
# p1 = Phone()
# p1.call()

p = Phone()


'''
1.找有没有一块空间是Phone
2.利用Phone类，向内存申请一块Phone一样的空间
3.去Phone中找有没有__init__. 如果没有则执行将开辟内存给对象名：p
4.如果有__init__，则会进入__init__方法执行里面的动作
将内存地址赋值给对象p
'''

--------------------------------------------------------------------------------

# class Person:
#     name = '张三'
#
#     def __init__(self):
#         self.name = 'zhangsan'
#         self.age = 18
#
#     def eat(self):
#         print('{}正在吃红烧肉！'.format(self.name))
#
#     def run(self):
#         print('{},今年｛｝岁，正在跑步'.format(self.name, self.age))
#
#
# p = Person()
# p.name = '李四'
# p.eat()
# p.run()
#
# p1 = Person()
# p1.name = '王五'
# p1.eat()
# p1.run()

''''''''''''''''''


class Person:
    name = '张三'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print('{}正在吃红烧肉！'.format(self.name))

    def run(self):
        print('{},今年{}岁，正在跑步'.format(self.name, self.age))


p = Person('李四', 20)
p.eat()
p.run()

p1 = Person('王五', 22)
p1.eat()
p1.run()

-------------------------------------------------------------------------------------------------------

# 类方法
'''
特点：
1.定义需要依赖装饰器@classmethod
2.类方法中参数不是一个对象，而是类
3.类方法中值可以使用类属性
类方法还没创建的时候就可以调用
4.类方法中不能调用普通方法

类方法作用：
因为只能访问类属性和类方法，所以可以在对象创建之前，如果需要完成一些动作（功能）
'''


class Dog:

    def __init__(self, nickname):
        self.nickname = nickname

    def run(self):
        print('{}在院子里跑来跑去!'.format(self.nickname))

    def eat(self):
        print('吃饭。。。')
        self.run()  # 类方法中的调用，需要通过self.方法名()

    @classmethod
    def test(cls):  # cls class   cls--->Dog类
        print(cls)
        # print(cls.nickname) #问题


d = Dog('大黄')
d.run()
d.test()

--------------------------------------------------------------------------------

# 补充类方法
'''
不依赖于类对象
静态方法：很类似类方法
1.需要装饰器@staticmethod
2.静态方法是无需传递参数（cls,self）
3.只能访问类的属性和方法，对象的是无法访问的
4.加载时机同类方法


总结：
类方法 静态方法
不同：
1.装饰器不同
2.类方法有参数的，静态方法没有参数

相同：
1.只能访问类的属性和方法，对象的是无法访问的
2.都可以通过类名调用访问
3.都可以在创建对象之前使用，因为是不依赖于对象

普通方法与两者区别：
不同：
1.没有装饰器
2.普通方法永远是要依赖对象，每个普通方法都有一个self
3.只有创建了对象才可以调用普通方法，否则无法调用
'''


class Person:
    __age = 18

    def __init__(self, name):
        self.name = name

    def show(self):
        print('------>', Person.age)

    @classmethod
    def update_age(cls):
        cls.__age = 20
        print('------>类方法')

    @classmethod
    def show_age(cls):
        print('修改后的年龄是:', cls.__age)

    @staticmethod
    def test():
        print('------>静态方法')
        print(Person.__age)


Person.update_age()
Person.show_age()

--------------------------------------------------------------------------------

# 魔术方法
# __init__:
# 触发时机：初始化对象时触发（不是实例触发，但是和实例化在一个操作中）
参数至少有一个self

'''
__new__:实例化的魔术方法
触发时机：在实例化时触发
把底层自带的魔术方法覆盖，比如使得__init__无法正常使用

class Person: 
        def __init__(self, name): 
                self.name = name 
        def __new__(cls, *args, **kwargs):
                 # __new__向内存要空间---地址 print('------>new')
p = Person('jack') 
print(p)
运行错误

__call__:对象调用方法
触发时机：将对象当成函数使用的时候，会默认调用此函数中的内容


__del__:
'''


class Person:
    def __init__(self, name):
        self.name = name

    def __new__(cls, *args, **kwargs):  # __new__向内存要空间---地址
        print('------>new')
        position = object.__new__(cls)  # 申请内存分配空间
        return position  # 地址

    def __call__(self, *args, **kwargs):
        print('------->call')


p = Person('jack')
print(p)

--------------------------------------------------------------------------------

import sys

'''
__del__:
1.对象赋值
    p=Person()
    p1=p
    说明：p和p1共同指向同一个地址
    
2.删除地址的引用
    del p1 删除p1对地址的引用

3.查看对地址的引用次数
import sys
sys.getrefcount(p)
4.当一块空间没有任何引用，默认执行__del__
python底层自带
垃圾回收机制
sys.getrefcount(p)为0
'''


class Person:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print('------del------')


p = Person('jack')
p1 = p
p2 = p
print(p1.name)
print(p2.name)
p1.name = 'tom'
print(p.name * 5)
print(p2.name)

del p2
print('删除p2后打印', p.name)

del p1
print('删除p1后打印', p.name)

del p
print('删除p后打印', p.name)  #
print(sys.getrefcount(p))  # 查找引用个数
# 对象复制
n = 5
n1 = n

---------------------------------------------------------------------------------------

# __str__：
# 魔术方法与普通方法的区别：魔术方法在特定时刻自动触发
# 注意：一定要在__str__方法中添加return，return后面内容就是打印对象看到的内容
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return '姓名是' + self.name + ',年龄' + str(self.age)


p = Person('tom', 18)
print(p)

# 单纯打印对象名称，出来的是一个地址。地址对于开发者来说没有太大意义
# 如果想在答应对象名的时候能够给开发者更多的一些信息量

p1 = Person('jack', 20)
print(p)


'''
总结：魔术方法
重点：
__init__（构造方法，创建完空间后调用的第一个方法）  __str__

了解:
__new__ 作用 开辟空间
__del__ 作用 没有指针引用的时候会调用。99%都不需要重写

__call__作用 想不想将对象当成函数用


大总结：
方法：
普通方法（重点）
    def 方法名(self,[参数]):
     方法体
    
    对象.方法()
    方法之间的调用:
    class A:
        def a(self):
            pass
        def b(self):
            #调用a方法
            self.a()
    
    
类方法
    @classmethod
    def 方法名cls(cls,[参数]):
        pass
        
    类名.方法名
    对象.方法名
静态方法
    @staticmethod
    def 方法名([参数]):
        pass
    
    类名.方法名()
    对象.方法名()
    
魔术方法
    自动执行方法
    print(p)--->str
'''