day8-python-成员修饰符

python的面相对象中,拥有3个成员,字段、方法、属性

 1 class Foo:
 2     def __init__(self,name):
 3         #公有字段name在类中与类外均能调用
 4         self.name = name
 5
 6     def f1(self):
 7         print(self.name)
 8
 9 obj = Foo(‘alex‘)
10 #内部调用
11 print(obj.name)
12 #>>>alex
13 #外部调用
14 obj.f1()
15 #>>>alex
 1 class Foo:
 2     def __init__(self,name):
 3         #私有字段name只能在类中调用类外不能调用
 4         self.__name = name
 5
 6     def f1(self):
 7         print(self.__name)
 8
 9
10 obj = Foo(‘alex‘)
11 #内部调用
12 print(obj.name)
13 #>>>alex
14 #外部调用
15 obj.f1()
16 #>>>报错
 1 #特殊成员
 2 class Foo:
 3     #构造方法
 4     def __init__(self,name,age):
 5         self.name =name
 6         self.age = age
 7         print(‘实例化对象时执行‘)
 8
 9     #析构方法
10     def __def__(self):
11         print(‘内存被释放时,自动触发执行‘)
12     def __call__(self):
13         print(‘call‘)
14
15     def __str__(self):
16         return ‘%s-%d‘%(self.name,self.age)
17         return ‘返回什么就显示什么‘
18 p=Foo()
19 >>>实例化对象时执行
20 #>>>显示对象属于哪个类
21 print(p.__class__)
22 >>><class ‘__main__.Foo‘>
23 #执行call方法
24 p()
25 >>>call
26 #先执行构造方法在执行call方法
27 Foo()()
28 >>>实例化对象时执行
29 >>>call
30
31 obj1 = Foo(‘alex‘,71)
32 obj2 = Foo(‘eric‘,72)
33 #打印对象自动调用__str__方法
34 print(obj1)
35 >>>alex-71
36 print(obj2)
37 >>>eric-72
38 #执行str()方法的时候自动调用__str__方法
39 ret = str(obj1)
40 print(ret)
41 >>>alex-71
时间: 2024-08-11 03:35:35

day8-python-成员修饰符的相关文章

Python学习:17.Python面向对象(四、属性(特性),成员修饰符,类的特殊成员)

一.属性(特性) 普通方法去执行的时候,后面需要加括号,特性方法执行的时候和静态字段一样不需要不需要加括号. 特性方法不和字段同名. 特性方法不能传参数. 在我们定义数据库字段类的时候,往往需要对其中的类属性做一些限制,一般用get和set方法来写,那在python中,我们该怎么做能够少写代码,又能优雅的实现想要的限制,减少错误的发生呢,这时候就需要我们的@property. 获取特性 class Foo: def __init__(self,name): self.name = name #

python学习笔记-Day8 上(pickle补充、字段、面向对象成员、成员修饰符、特殊方法)

pickle 序列化补充 # pickle load # 现在有两个python程序,调用关系如下 # s1.py class foo: …. Obj = foo(x,y) Pickle.dump(obj, open(‘db’,’wb’)) S2.py # s2.py from s1 import foo pickle.load(db) # s2.py 反序列化加载包含对象,一定要先导入对象对应的类,否则Pickle load将会报错 类多继承关系 有共同父类的继承关系如下 如图,如果我们有两个

Python面向对象成员修饰符

成员修饰符就是设置类的成员有些是公开的有些是私有的,公开的是在外部通过对象或者类可以调用,但是私有的只能通过类的内部才可以调用. 静态字段修饰 #!/usr/bin/env python # _*_coding:utf-8 _*_ class Foo:    # 公有的静态字段    ClassMembers = "公开的"    # 私有的静态字段    __ClassMembers = "私有的" # 执行公有的静态字段 print(Foo.ClassMembe

python入门第二十四天----成员修饰符 类的特殊成员

1 #成员修饰符 修饰符可以规定内部的字段.属性.方法等 是共有的成员,私有的成员 2 class Foo: 3 def __init__(self,name,age): 4 self.name=name 5 self.age=age #可以在外部直接访问 6 7 obj=Foo('Jack',22) 8 print(obj.name) 9 print(obj.age) 共有字段 1 #成员修饰符 修饰符可以规定内部的字段.属性.方法等 是共有的成员,私有的成员 2 class Foo: 3 d

Python学习 :面向对象 -- 成员修饰符

成员修饰符 两种成员 - 公有成员 - 私有成员, __字段名 - 无法直接访问,只能通过内部方法来间接访问私有成员 简例:公有成员与私有成员  class Info: country = '中国' # 静态字段 __gender = '男' # 静态字段私有化 def __init__(self,name,age): self.name = name self.__age = age # age字段为私有的,外部无法直接访问 def show(self): return self.__age,

Python类成员及类成员修饰符

13.面向对象:多态.继承.封装成员:字段:普通字段.静态字段方法:普通方法.静态方法.类方法特性:property,将方法伪造为字段,可以直接使用类.方法名调用,不用加() 成员修饰符:公有和私有,私有的字段和方法可以通过对象中的其他普通方法间接进行调用私有字段:__field, 以__双下划线开头的字段,私有字段只能在自己的对象中才能使用,继承后也无法使用私有方法:__function, 以__双下划线开头的方法,私有字段只能在自己的对象中才能使用,继

文成小盆友python-num8 面向对象中的成员,成员修饰符,特殊成员,异常处理,设计模式之单例模式

本节主要内容: 1.面向对象中的成员 2.成员修饰符 3.特殊成员 4.异常处理 5.设计模式之单例模式 一.面向对象中的成员(类的成员) 类的成员总共可以分为3大类,每类中有不同的分支. 1.总述,基本分类 如下图所示: 类成员包括字段,方法,和属性 2.字段 如上图字段分为普通字段和静态字段,两者的使用有区别,但是最大的区别在于两者在内存中的保存位置有区别. 普通字段属于对象而静态字段属于类,在使用过程中谁的字段就由谁来调用. 静态字段和普通字段的定义如下: 在调用时分各自调用 #####类

Python_day8_面向对象(多态、成员修饰符、类中特殊方法、对象边缘知识)、异常处理之篇

一.面向对象之多态 1.多态:简而言子就是多种形态或多种类型 python中不支持多态也用不到多态,多态的概念是应用与java/C#中指定传参的数据类型, java多态传参:必须是传参数的数据类型或传参的子类类型 面向对象总结: 面向对象是一种编程方式,此编程方式的实现是基于类和对象的使用 类:是一个模板,模板中包含了多个函数共使用,即类中可包含多个函数(类中的函数即叫做方法) 一般疑问: 1)什么样的代码才是面向对象? 简单来说,如果程序中的所有功能否是由 “类”和“对象”实现,那么就是面向对

面向对象中的特殊的成员修饰符和几个特殊的方法

面向对象的成员修饰符 #Auther Bob #--*--conding:utf-8 --*-- # 成员修饰符 # 共有成员 # 私有成员 # 1.私有字段 # 私有的普通字段 # 私有的静态字段 # 2.私有方法 # 私有的方法 # 默认情况下,类的字段和方法都是共有的,通过对象和类就直接可以访问,但是如果我们在字段或者方法名字的前面加2个下划线,那么我们就不能在外部访问这些字段和方法,这些 # 方法和字段只能内部方法 class person(object): name = "diandi

学习C#修饰符:类修饰符和成员修饰符

C#修饰符之类修饰符:public.internal. partial.abstract.sealed.static C#修饰符之成员修饰符:public.protected.private.internal.sealed.abstract.virtual.override.readonly.const Public:最开放,所有的本程序集以及其他的程序集里面的对象都能够访问 Protected:比较开放,自身成员以及子类成员可访问 Private:只有自身成员才能够访问 Internal:本程