python类学习笔记

概述1、Python:函数式+面向对象2、函数式可以做所有的事，是否合适？3、示例小明，10岁，男，上山去砍柴小明，10岁，男，开车去东北小明，10岁，男，最爱大保健老李，90岁，男，上山去砍柴老李，90岁，男，开车去东北老李，90岁，男，最爱大保健deffoo(name,age,gender,content):print(name,age,gend

1、Python:函数式+面向对象
2、函数式可以做所有的事，是否合适？
3、示例
    小明，10岁，男，上山去砍柴
    小明，10岁，男，开车去东北
    小明，10岁，男，最爱大保健

    老李，90岁，男，上山去砍柴
    老李，90岁，男，开车去东北
    老李，90岁，男，最爱大保健

def foo(name,age,gender,content):
print(name,age,gender,content)
foo(小明，10岁，男，上山去砍柴)
foo(小明，10岁，男，开车去东北)
foo(小明，10岁，男，最爱大保健)
foo(老李，90岁，男，上山去砍柴)
foo(老李，90岁，男，开车去东北)
foo(老李，90岁，男，最爱大保健)

===>参数可能不太合适。

class bar:
    def foo(self,name,age,gender,content):
        print(name,age,gender,content)

obj= bar()
obj.foo(小明，10岁，男，上山去砍柴)
obj.foo(小明，10岁，男，开车去东北)
obj.foo(小明，10岁，男，最爱大保健)
obj.foo(老李，90岁，男，上山去砍柴)
obj.foo(老李，90岁，男，开车去东北)
obj.foo(老李，90岁，男，最爱大保健)

一、定义
函数：def+函数名(参数):
面向对象：
class => 名字bar类
def   =>名字叫foo的方法
    ####第一个参数self
二、执行
函数:
    函数名(参数)
面向对象:
    o=bar()#创建中间人
    o.foo()


定义类并执行类中的方法：
class类名：
    def 方法名(self,arg)
    print(arg)
中间人=类名()
中间人.方法名()

#self代指，调用方法的 对象(中间人)

--------->
class bar:
    def foo(self,arg):
        print(self,self.name,self.age,self.gender,arg)

z = bar()
z.name = 'alex'
z.age = 8
z.gender = 'aadfdfa'

z.foo(666)

z1 = bar()
z1.name = 'alex2'
z1.age = 81
z1.gender = '2222'

z1.foo(222)
------------->通过学习示例演变成如下：

class bar:
    def foo(self,arg):
        print(self,self.name,self.age,self.gender,arg)

obj= bar()
obj.name='小明'
obj.age='10岁'
obj.gender='男'
obj.foo('上山去砍柴')
obj.foo('最爱大保健')
obj.foo('上山去砍柴')

obj1= bar()
obj1.name='老李'
obj1.age='90岁'
obj1.gender='男'
obj1.foo('上山去砍柴')
obj1.foo('最爱大保健')
obj1.foo('上山去砍柴')



示例2:
class bar:
    def add(self,content):
        print(self.name,self.age,self.gender,content)
    def delete(self,content):
        print(self.name, self.age, self.gender, content)
    def update(self,content):
        print(self.name, self.age, self.gender, content)
    def get(self,content):
        print(self.name, self.age, self.gender, content)

obj = bar()
obj.name ='小明'
obj.age =10
obj.gender = '男'

obj.add('上山去砍柴')
obj.delete('开车去东北')
obj.update('上山去砍柴')

#####
构造方法：
特殊作用:
   b = 类名()
   #创建对象
   #通过对象执行类中的一个特殊方法
class bar:
    def __init__(self):
        '''
        构造方法
        '''
        print("123")
    def foo(self):
        print("456")
z=bar()
print(z)

示例3
class person:
    def __init__(self,n,a,s,f):
        self.name = n
        self.age = a
        self.sex = s
        self.fight = f
     def pp(self):
        print(self.name)

hei= person('吴汶泽',18,'女',1000)



-------上述内容小结------------>>>

1、如何创建类
class 类名
      pass

2、创建方法
构造方法，__init__(self,arg)
    obj = 类('a1')
普通方法:
    obj = 类('XXX')
    obj.普通方法名()
3、面向对象三大特性之一：封装
class bar:
   def __init__(self,n,a)
   self.name=n
   self.age=a
   self.xue='o'
b1 = bar('alex',123)
b2 = bar('eric',456)

4、


－－－－－－－－－－－－－－－〉


面向对象三大特性之二：继承
1、继承
class 父类:
     pass
class 子类(父亲)
     pass

2、重写
   防止执行父类中的方法
3、self永远是执行改方法的调用者
4、super(子类,self).父类中的方法(...)
   父类名.父类中的方法(self,...)
5、python中技持多继承
   a、左侧优先
   b、一条道走到黑
   c、同一个根时，根最后执行
6、面向对象三大特性之三：多态
------

#java
string v='alex'
def foo(string arg):
    print(arg)

foo('aaa')

#python
v='alex'
def fooa(arg):
    print(arg)

fooa('aaa')
fooa(123)
----------------
class foo:
    pass
class son(foo)
    pass

#声明func函数，函数只接受Foo类或Foo类的子类的对象
def func(foo arg):
   print(arg)
obj = foo()
func(obj)

*******************************
练习：
游戏人生程序
class person:
   def __init__(self,n,a,g,f)
   self.name=n
   self.age=a
   self.gender=g
   self.fight=f

role_List=[]#角色列表

y_n=input('是否创建角色?')
if y_n=='y':
   name=input('请输入名称:')
   age=inmput('')

   ....
   role_List.append(person(name,age,.....)
#role_List,1,2


************************面向对象中高级

class foo:
    def  __init__(self,name):
    #字段
    self.name=name

    #方法
    def show(self):
        print(self.name)

obj = foo('alex')
obj.name
obj.show()


类成员:
   #字段
class province:
        #---静态字段,属于类，保存在类中，执行时可以通过对象，也可以通过类访问
    country='中国'
    def __init__(self,name):
        #----普通字段，属于对象,保存在对象中，执行只能通过对象访问
        self.name=name
henan = province('河南')
hebei = province('河北')
print(province.country)
print(hebei.name)
print(hebei.country)


   #方法
   #－－普通方法，保存在类中，由对象调用，self=>对象
class foo:
     def fa(self):
         print()
ff = foo()
foo.fa()


   #－－静态方法，保存在类中，由类来调用
   加这个装饰器  @staticmethod
        self不是必须的
        不用创建对象直接调用
class foo:
     @staticmethod
     def fa(a,b):
         print(a,b)

foo.fa(1,2)
    #－－类方法，保存在类中，由类直接调用，cls=>当前类
class foo:
     @classmethod
    def faa(cls):
    print('classmethod')

foo.faa()
######应用场景：
如果对象中需要保存一些值，执行某功能时，需要使用对象中的值  －〉普法方法
不需要任何对象中的值，静态方法

属性、特性：加@property装饰器

class foo:
    @property
    def perr(self):
        return 1
    @perr.setter
    def perr(self,val):
        print(val)
    @perr.deleter
    def perr(self):
        print('456')

obj =foo()

r=obj.perr
print(r)
obj.perr=555
del obj.perr

总结

以上是内存溢出为你收集整理的python类学习笔记全部内容，希望文章能够帮你解决python类学习笔记所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。