函数，作用域，递归，类

函数内部可以访问全局变量，但是不能直接修改全局变量
全局变量使用场景
1.计数器
2.共享变量
def fun01():
#内部函数要去修改全局变量需要使用关键字global  定义
     global a
     a+=1
     print(a)
fun01(3)
print(a)
嵌套函数内部函数可以直接访问外部变量，但不能直接修改
def outer():
     x=10
     def inner():
          y=20
          #内部函数要去修改外部变量需要使用关键字nonlocal  定义
          nonlocal x
          x+=y
     inner()
     print(x)
outer()

def conunt_outer():
     count=0
     count2=1
     count2+=1

     def counter():
          nonlocal count
          count+=1
          return count,count2
     return counter
counter=conunt_outer()
print(counter())
print(counter())
print(counter())
print(counter())
print(counter())

实现阶乘

1.迭代实现
num=int(input("输入数字"))
def fun(n):
    result=1
    for i in range(1,n+1):
        result=result*i
    return result
print(fun(num))

2.递归
def fun1(n):
    if n==1:
        return 1
    else:
        return n*fun1(n-1)
print(fun1(6))
类：描述对象的工具
self 作用可以理解为c/c++中的this指针
self在__init__函数之前还有__new__方法（创建实例的)~
~创建实例后，给到__init__，在__init__用self表示实例
实例创建后不知道自己有哪些属性，在__init__方法中给实例什么属性，那么该实例就有哪些属性
如果不构建该实例，则会默认构造一个无参函数
class Dog():
    pass
class Person():
    def __init__(self,name,age):
        self.name =name
        self.age = age
    定义类的行为（函数）
    def say_hello(self):
        print(f"{self.name}要吃饭！！！！！！！！！！！")
person=Person("老子",18)
person.say_hello()
dog=Dog()
print(id(dog))

动态添加类实例的实例属性
运行对象实例化后，在运行阶段动态添加和修改实例属性
实例属性是实例化对象后的属性，属于实例的，而非属于对象
person2=Person("张三",30)
print(person2.name)
person2.name='zhangsan'
person2.address='chengdu'
print(person2.name)
print(person2.address)

class Dog():
    def __init__(self,name,age,sex):
        self.name =name
        self.age = age
        self.sex = sex
    def say(self):
        print("调用犬吠")
dog1=Dog("旺财",2,1)
print(dog1.name)
print(dog1.age)
print(dog1.sex)
dog1.say()

类属性：定义在__init__方法外，属于类的属性
调用
1.通过类名.属性名
2.通过实例名.属性名
作用：可以定义一些公共属性
class Person:
    count = 0
    def __init__(self,name):
        self.name = name
p1=Person('zhangsan')
print("通过实例打印",p1.count)
print("通过类打印",Person.count)

类方法：类方法是用于描述类的行为的方法，类方法属于类，不属于该类创建的对象
1. 类方法需要使用@classmethod装饰器定义
2. 类方法至少有一个形参，第一个形参用于绑定类，约定写为'cls'
3. 类和该类的实例都可以调用类方法
4. 类方法不能访问此类创建的实例属性
class Animal:
    clor ='black'
    @classmethod
    def set_clor(cls,clor):
        cls.clor=clor
    @classmethod
    def get_clor(cls):
        return cls.clor
1.通过类调用类方法
print(Animal.get_clor())
Animal.set_clor('yellow')
print(Animal.get_clor())
2.通过实例调用类方法
a1=Animal()
print(a1.get_clor())
a1.set_clor('red')
print(a1.get_clor())

class MyClass:
    #定义类属性
    class_attr=0
    #定义实例方法，初始化实例属性
    def __init__(self,value):
        self.instance_attr = value
    定义类方法，初始化类属性
    @classmethod
    def set_instance(cls,value):
        try:
            尝试使用类方法使用实例属性，会报错
            cls.instance_attr = value
        except Exception as e:
            print(e)

    定义实例方法
    def show(self):
        print(self.instance_attr)
        print(self.class_attr)
myclass=MyClass(10)
myclass.show()
myclass.set_instance_attr(30)
myclass.show()
MyClass.set_instance(20)
print(MyClass.class_attr)

静态方法：是定义在类的内部函数，此函数的作用域是类的内部
1.静态方法需要使用@staticmethod装饰器定义
2.静态方法与普通函数定义相同，不需要传入self实例参数和cls类参数
3.静态方法只能凭借该类或类创建的实例调用
4.静态方法可以访问类属性但是不能访问实例属性
作用：实现一些公共方法，跟类和实例没有关系
class Myclass:
    class_value=0
    def __init__(self,value):
        self.instance=value
    @staticmethod
    def my_add(a,b):
        return a+b
    #实例方法不能直接调用静态方法，只能通过类或则实例对象调用
    # def instance_add(self,a,b):
    #     return my_add(a,b)

    def instance_add(self):
        m1=Myclass(1)
        print(m1.my_add(1,2))



#通过类调用静态方法
result=Myclass.my_add(1,2)
print(result)
#通过实例对象调用静态方法
myclass=Myclass(10)
result=myclass.my_add(1,2)
print(result)
myclass.instance_add()

魔术方法
class MyClass:
    def __init__(self,value):
        self.instance_value = value
    #定义字符串显示形式
    def __str__(self):
        return f'实例属性值{self.instance_value}'
myclass = MyClass(10)
print(myclass)