GVKun编程网logo

Python复数属性和方法操作实例（python复数类型）

14

本文的目的是介绍Python复数属性和方法操作实例的详细情况，特别关注python复数类型的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解Python复数属性和方法操

本文的目的是介绍Python复数属性和方法操作实例的详细情况，特别关注python复数类型的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解Python复数属性和方法操作实例的机会，同时也不会遗漏关于13_Python 类的属性和方法、Python - 类属性和实例属性、python 为 class 添加新的属性和方法、Python 之路 - 面向对象 & 继承和多态 & 类属性和实例属性 & 类方法和静态方法的知识。

本文目录一览：

Python复数属性和方法操作实例（python复数类型）

Python复数属性和方法操作实例（python复数类型）

#coding=utf8
''''''
复数是由一个实数和一个虚数组合构成，表示为：x+yj
一个负数时一对有序浮点数(x,y)，其中x是实数部分，y是虚数部分。
Python语言中有关负数的概念：
1、虚数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数
2、复数由实数部分和虚数部分构成
3、表示虚数的语法：real+imagej
4、实数部分和虚数部分都是浮点数
5、虚数部分必须有后缀j或J

复数的内建属性：
复数对象拥有数据属性，分别为该复数的实部和虚部。
复数还拥有conjugate方法，调用它可以返回该复数的共轭复数对象。
复数属性：real(复数的实部)、imag(复数的虚部)、conjugate()（返回复数的共轭复数）
''''''
class Complex(object):
    ''''''创建一个静态属性用来记录类版本号''''''
    version=1.0
    ''''''创建个复数类，用于操作和初始化复数''''''
    def __init__(self,rel=15,img=15j):
        self.realPart=rel
        self.imagPart=img
       
    #创建复数
    def creatComplex(self):
        return self.realPart+self.imagPart
    #获取输入数字部分的虚部
    def getImg(self):
        #把虚部转换成字符串
        img=str(self.imagPart)
        #对字符串进行切片操作获取数字部分
        img=img[:-1] 
        return float(img)  
                       
def test():
    print "run test..........."
    com=Complex()
    Cplex= com.creatComplex()
    if Cplex.imag==com.getImg():
        print com.getImg()
    else:
        pass
    if Cplex.real==com.realPart:
        print com.realPart
    else:
        pass
    #原复数
    print "the religion complex is :",Cplex
    #求取共轭复数
    print "the conjugate complex is :",Cplex.conjugate()
    
if __name__=="__main__":
    test()

13_Python 类的属性和方法

13_Python 类的属性和方法

Python 类

  • 类的定义
    • 类的方法至少有一个参数self
class MyClass(object):
    def fun(self):
	    print ''类的方法''
  • 类的实例化 --> 创建对象
obj = MyClass

  • 类的属性

    • 公有属性： 类内外都能调用的属性
    • 私有属性：不能在类外以及被类以外的函数调用，私有属性定义方法：以双下划线开始的成员变量就是私有属性
    • 内置属性：系统在定义类的时候默认添加的，由前后双下划线构成，
      • dict:类的属性（包含一个字典，由类的数据属性组成）
      • doc:类的文档字符串
      • name:类名
      • module:类定义所在的模块

  • 类的方法：类的方法定义跟函数的定义一样，但是需要self作为第一个参数

    • 公有方法：在类中类外都能调用的方法
    • 私有方法：不能被类的外部调用，私有方法定义：方法前面加上双下划线，

  • 类方法：被classmethod()函数处理过，才能被类所调用

    	In [8]: class Testing(object):
	...:     def test(self):
	...:         print(''hello test'')
	...:     def test2(self):
	...:         print(''hello test2'')
	...:     pt = classmethod(test)
	...:     

	In [9]: Testing.pt()
	hello test

	In [10]: Testing.test()         ##是不能直接通过类调用类方法的，
	-------------------------------------------------------------------
	TypeError                         Traceback (most recent call last)
	<ipython-input-10-372b771144d0> in <module>()
	----> 1 Testing.test()

	TypeError: unbound method test() must be called with Testing 
	instance as first argument (got nothing instead)

	In [11]: Testing.test2()
	-------------------------------------------------------------------
	TypeError                        Traceback (most recent call last)
	<ipython-input-11-f17045d44574> in <module>()
	----> 1 Testing.test2()

	TypeError: unbound method test2() must be called with Testing 
	instance as first argument (got nothing instead)

  • 静态方法：相当于“全局函数”，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义，静态方法没有“self”参数。

Python - 类属性和实例属性

Python - 类属性和实例属性

一、实例属性

首先说说差异化最小的实例属性。从代码中直视它们的异同。

JAVA实例属性：

class Book{
	private String name;
    public Book(String name){
        this.name=name;
    }
	public String getName(){
		return this.name;
	}
}

Python实例属性：

class Book:
	def getName(self):
		return self.name

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

除了语法层面的区别，语义层面是没有任何差异的。这里所描述的“差异”一词，表达的是这样的语境“我明白JAVA中的实例属性，所以Python中的实例属性，我只需要了解语法的区别，就能明白Python的实例属性”

显然，就实例属性来说，二者的区别只在于语法层面。

二、类属性

JAVA代码如下：

class Book{
	public static String paper="宣纸";
}
//为了书写方便，省略main。
Book book=new Book();
System.out.println(book.paper);
Book.paper="竹简";
System.out.println(book.paper);
book.paper="宣纸";
System.out.println(book.paper+"|"+Book.paper);

类属性可以通过类名以及实例名来访问，上述代码通过类名方式修改类属性，查看实例名访问时类属性的变化情况。代码执行结果如下：

>java Book
宣纸
竹简
宣纸|宣纸

通过结果看，JAVA在处理类名和实例名使用类属性时完全一致，尽管类名和实例名不是一个逻辑层次的概念，所以才会有尴尬的提示——建议使用类名来访问类属性。

这种处理方式会让人觉得“很随意”，但是的确降低了程序员的理解成本。

Python代码如下：

class Book:
	paper=u''宣纸''

book=Book()
print book.paper
Book.paper=u''竹简''
print book.paper
book.paper=u''宣纸''
print book.paper,Book.paper

运行结果如下：

>python book.py
宣纸
竹简
宣纸 竹简

对比JAVA的输出，最大的区别在于——实例名操作了类属性之后，结果出现天壤之别。

为什么会是这样？

  1. python的属性查找规则造成了，实例名也可以访问类属性的假象。当调用book.paper时，python会向上查找属性，也就是说最终显示出来的是Book.paper
  2. 通过实例名设置一个不存在的属性时，python会动态创建这个属性。这个属性既然是真实存在的，那么就和Book.paper没有任何关系，各自存储各自的数据，所以不一样的变化就出现了。

这么“诡异”的现象把理由讲出来后，你会发现这是一种很“自然”的处理方式。代价当然是增加了理解的难度。

通过这个“好玩”的东东，衍生了一个设计模式——Borg，根据上述的说明，它非常容易理解。

三、Borg设计模式

代码如下（摘自github）：

class Borg(object):
    __state_pool = {}
    def __init__(self):
        self.__dict__ = self.__state_pool #这是秘密的关键，所有实例的所有属性将全部共享。
        self.state = ''Init''
    def __str__(self):
        return self.state
class YourBorg(Borg):
    pass

if __name__ == ''__main__'':
    rm1 = Borg()
    rm2 = Borg()
    rm1.state = ''Idle''
    rm2.state = ''Running''
    print(''rm1: {0}''.format(rm1))
    print(''rm2: {0}''.format(rm2))
    rm2.state = ''Zombie''
    print(''rm1: {0}''.format(rm1))
    print(''rm2: {0}''.format(rm2))
    print(''rm1 id: {0}''.format(id(rm1)))
    print(''rm2 id: {0}''.format(id(rm2)))
    rm3 = YourBorg()
    print(''rm1: {0}''.format(rm1))
    print(''rm2: {0}''.format(rm2))
    print(''rm3: {0}''.format(rm3))

执行效果如你所想：

>python 01.py
rm1: Running
rm2: Running
rm1: Zombie
rm2: Zombie
rm1 id: 31013576
rm2 id: 40287424
rm1: Init
rm2: Init
rm3: Init

Borg实现了所有实例的所有属性的共享——单态池！我想这应该是非常贴切的一个名字。

为任意一个实例添加一个属性，其他所有实例都可以共享访问。

复制代码，修改后试试效果。

python 为 class 添加新的属性和方法

python 为 class 添加新的属性和方法

通过继承：

>>> class Point(namedtuple(''Point'', [''x'', ''y''])):
...     __slots__ = ()
...     @property
...     def hypot(self):
...         return (self.x ** 2 + self.y ** 2) ** 0.5
...     def __str__(self):
...         return ''Point: x=%6.3f  y=%6.3f  hypot=%6.3f'' % (self.x, self.y, self.hypot)

>>> for p in Point(3, 4), Point(14, 5/7):
...     print(p)
Point: x= 3.000  y= 4.000  hypot= 5.000
Point: x=14.000  y= 0.714  hypot=14.018

__slots__: 元组、列表、可迭代对象

当一个类需要创建大量实例时，通过_slots_可以声明实例所需要的属性。

slots主要用于优化内存和属性的访问速度，也可以用于限制子类中的属性，但这不是主要用途。

使用__slots__要注意，__slots__定义的属性仅对当前类起作用，对继承的子类是不起作用的

 

通过MethodType:

class Student:
    pass


s = Student()

单独给某个实例动态添加方法：

def func(self, x):
        print(x)


from types import MethodType
s.func = MethodType(func, s, Student)

给类动态绑定方法：

def set_score(self, score):
    self.score = score


Student.set_score = MethodType(set_score, None, Student)

 

Python 之路 - 面向对象 & 继承和多态 & 类属性和实例属性 & 类方法和静态方法

Python 之路 - 面向对象 & 继承和多态 & 类属性和实例属性 & 类方法和静态方法

一、面向对象

　　编程方式

　　面向过程：根据业务逻辑从上到下写垒代码

　　函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

　　面向对象：对函数进行分类和封装，让开发 “更快更好更强…”

　　什么是面向对象

　　面向对象就不像面向过程那样按照功能划分模块了，它所关注的是软件系统有哪些参与者，把这些参与者称为对象，找出这些软件系统的参与者也就是对象之后，分析这些对象有哪些特征、哪些行为，以及对象之间的关系，所以说面向对象的开发核心是对象

　　什么是类

　　面向对象编程的两个重要的概念：类和对象

　　类是对象的类型，具有相同属性和行为事物的统称。类是抽象的，在使用的时候通常会找到这个类的一个具体存在。

　　什么是对象

　　万物皆对象，对象拥有自己的特征和行为。

　　类和对象的关系

　　类是对象的类型，对象是类的实例。类是抽象的概念，而对象是一个你能够摸得着，看得到的实体。二者相辅相成，谁也离不开谁。

二、类的定义

　　类由三部分组成

　　类的名称：类型

　　属性：对象的属性

　　方法：对象的方法

　　类定义：

　　class 类名：

　　　　属性列表

　　　　方法列表

　　__init__() 构造方法和 self

　　__init__（）是一个特殊的方法属于类的专有方法，被称为类的构造函数或初始化方法，方法的前面和后面都有两个下划线。 　　这是为了避免 Python 默认方法和普通方法发生名称的冲突。每当创建类的实例化对象的时候，__init__() 方法都会默认被运行。作用就是初始化已实例化后的对象。

　　在方法定义中，第一个参数 self 是必不可少的。类的方法和普通的函数的区别就是 self，self 并不是 Python 的关键字，你完全可以用其他单词取代他，只是按照惯例和标准的规定，推荐使用 self。

''''''
    类定义
    class 类名():
        #类的文档说明
        属性
        方法
''''''
class person():
    ''''''
    这是一个人类
    ''''''

    country = ''中国'' #类属性
    #实例属性通过构造方法来声明
    #self不是关键字，代表的是当前对象（类似于this）
    def __init__(self,name,age,sex): #构造方法
        #构造方法不需要调用 在实例化的时候自动调用
        print(''我是构造方法，在实例化的时候调用'')
        self.name = name #通过self 创建实例属性 并且赋值
        self.age = age
        self.sex = sex

    #创建普通方法
    def getName(self):
         print(''我的名字叫:%s,我来自%s'' %(self.name,person.country))#在方法里面使用实例属性

#实例化对象
people01 = person(''joe'',12,''男'')
#这个people01 就要具有三个属性，并且可以使用getName方法

　　类的属性分类

　　类属性

　　类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。如果需要用在函数中使用类名。类属性.

　　实例属性

　　实例变量：定义在方法中的变量，只作用于当前实例的类。

　　类的属性的一些方法

　　可以使用点实例化对象名 +. 来访问对象的属性

　　也可以使用以下函数的方式来访问属性

　　　　getattr (obj, name [, default]) : 访问对象的属性

　　　　hasattr (obj,name) : 检查是否存在一个属性

　　　　setattr (obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性

　　　　delattr (obj, name) : 删除属性

　　注意:name 需要加单引号，obj 为实例化对象名称

#访问属性
# print(people01.name)#通过对象名.属性名 访问实例属性(对象属性)
# print(people01.age)
# print(people01.sex)

#通过内置方法访问对象属性
# print(getattr(people01,''name''))

# print(hasattr(people01,''name''))
#
# print(setattr(people01,''name'',''susan''))
# print(people01.name)
#
# delattr(people01,''name'')
# print(people01.name)

#通过对象调用实例方法
# people01.getName()

　　内置类属性

　　Python 内置类属性

　　__dict__ : 类的属性（包含一个字典，由类的属性名：值组成） 实例化类名.__dict__

　　__doc__ : 类的文档字符串 (类名.) 实例化类名.__doc__

　　__name__: 类名，实现方式 类名.__name__

　　__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）  

''''''
    内置类属性
''''''
# print(people01.__dict__) #会将实例对象的属性和值通过字典的形式返回
#{''age'': 12, ''name'': ''joe'', ''sex'': ''男''}

# print(people01.__doc__) #查看类的文档说明
#    这是一个人类

# print(people01.__name__) #返回类名

# print(person.__bases__) #类的组成 (<class ''object''>,)

people02 = person(''susan'',32,''女'')
people02.getName()

　　小结：

　　类 (Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

　　类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

　　数据成员：类变量或者实例变量 (方法中的变量) 用于处理类及其实例对象的相关的数据。

　　方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

　　实例变量：定义在方法中的变量，只作用于当前实例的类。

　　实例化：创建一个类的实例，类的具体对象。

　　方法：类中定义的函数。

　　对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

　　__name__

　　__name__: 如果是放在 Modules 模块中，就表示是模块的名字； 如果是放在 Classs 类中，就表示类的名字；

　　__main__：模块，xxx.py 文件本身。被直接执行时，对应的模块名就是__main__了 可以在 if __name__ == “__main__”: 中添加你自己想要的，用于测试模块，演示模块用法等代码。 作为模块，被别的 Python 程序导入（import）时，模块名就是本身文件名 xxx 了。

　　一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

定义 name.py 文件

def a():
    print(''我是a方法'')

if __name__ == ''__main__'':
    a()

print(__name__) #__main__

输出：

　　我是 a 方法
　　__main__

定义 name2.py 文件

''''''
引入name.py文件
输出 name
''''''
import name

输出：name

练习：

''''''
1.餐馆：创建一个名为Restaurant的类，其方法__init__()设置两个属性：
restaurant_name 和 cuisine_type(烹饪)。
创建一个名为 describe_restaurant()方法和一个名为open_restaurant ()
方法,其中前者打印前述两项信息，而后者打印一条消息,指出餐馆正在营业。
根据这个类创建一个名为restaurant的实例，分别打印其两个属性，
再调用前述两个方法。

2.三家餐馆：根据你为完成练习1而编写的类创建三个实例，
并对每个实例调用方法 describe_restaurant()。

3.就餐人数：在为完成练习1而编写的程序中,添加一个名为number_served的属性,
并将其默认值设置为0。打印有多少人在这家餐馆就餐过,然后修改这个值并再次打印
它。
添加一个名为set_number_served()的方法,它让你能够设置就餐人数。
调用这个方法并向它传递一个值，然后再次打印这个值。
添加一个名为increment_number_served()的方法,它让你能够将就餐人数递增.
调用这个方法并向它传递一个这样的值：你认为这家餐馆每天可能接待的就餐人数。


''''''
class Restaurant():
    ''''''
        餐馆类
    ''''''
    def __init__(self,restaurant_name,cuisine_type,number_served = 0):
        #声明两个实例属性
        self.restaurant_name = restaurant_name #餐馆名字
        self.cuisine_type = cuisine_type       #菜系
        self.number_served = number_served

    def describe_restaurant(self):
        print(''名称：%s,菜系：%s''%(self.restaurant_name,self.cuisine_type))


    def open_restaurant(self):
        print(''欢迎光临%s,正在营业''%self.restaurant_name)


    #设置就餐人数
    def set_number_served(self,n):
        self.number_served = n  #通过传递的参数给实例属性赋值
        print(''当前就餐人数:%d''%self.number_served)

    #递增增加就餐人数
    def increment_number_served(self,n):
        for i in range(1,n+1):
            self.number_served += 1
            print(''当前就餐人数:%d''%self.number_served)

if __name__ == ''__main__'':
    #练习1.
    # restaurant = Restaurant(''金拱门'',''西餐'')
    #打印两个属性
    # print(restaurant.restaurant_name)
    # print(restaurant.cuisine_type)

    #调用两个方法
    # restaurant.describe_restaurant()
    # restaurant.open_restaurant()

    # 练习2. 创建三个实例
    # chuancai = Restaurant(''我家酸菜鱼'', ''川菜'')
    # chuancai.describe_restaurant()
    #
    # xiangcai = Restaurant(''沪上湘城'', ''湘菜'')
    # xiangcai.describe_restaurant()
    #
    # loulan = Restaurant(''楼兰'', ''新疆菜'')
    # loulan.describe_restaurant()

    #4.
    loulan = Restaurant(''楼兰'', ''新疆菜'')
    # print(''就餐人数:%d''%loulan.number_served)
    # loulan.number_served = 10  #通过对象名.属性名设置 属性值
    # print(''就餐人数:%d'' % loulan.number_served)
    loulan.set_number_served(40)
    loulan.increment_number_served(10)

　　

''''''
    创建一个名为User的类，其中包含属性first_name和last_name ,
    还有用户简介通常会存储的其他属性。在User中定义一个名为describe_user()的方法
    他打印用户信息摘要；
    再定义一个名为greet_user()方法，他向用户发出个性化的问候。
    创建多个表示不同用户的实例，并对每个实例都调用上述两个方法
''''''
''''''
　　2.尝试登录次数：在为完成练习3而编写的User类中，添加一个名为login_attempts的属性。
　　编写一个名为increment_login_attempts()的方法,它将属性 login_attempts的值加 1。
　　再编写一个名为reset_login_attempts()方法,它将属性login_attempts的值重置为0。 
　　根据User类创建一个实例,再调用方法increment_login_attempts()多次。
　　打印属性login_attempts的值,确认它被正确地递增；然后，调用方法reset_login_attempts(),
　　并再次打印属性login_attempts的值，确认它被重置为0。
''''''

class User():
    ''''''
    用户类
    ''''''
    def __init__(self,first_name,last_name,age,sex,phone,login_attempts = 0):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age
        self.sex = sex
        self.phone = phone
        self.login_attempts = login_attempts

    #查看用户信息
    def describe_user(self):
        print(''大家好我叫%s %s,我今年%d岁,我的电话是%s'' %(self.first_name,self.last_name,self.age,self.phone))

    #个性化问候
    def greet_user(self):
        print(''尊敬的%s,恭喜你中了五百万''%self.first_name)

    #增加登录次数
    def increment_login_attempts(self):
        self.login_attempts += 1
        print(''当前登录次数为%d''%self.login_attempts)

    #重置登录次数
    def reset_login_attempts(self):
        self.login_attempts = 0
        print(''当前登录次数为%d'' % self.login_attempts)

if __name__ == ''__main__'':

    joe = User(''joe'',''black'',19,''男'',''15768476789'')
    joe.describe_user()
    joe.greet_user()

    joe.increment_login_attempts()
    joe.increment_login_attempts()
    joe.increment_login_attempts()

    joe.reset_login_attempts()

三、继承和多态

　　继承：

　　在现实生活中，继承一般指的是子女继承父辈的财产。那么在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中可以描述为猫和狗都继承自动物。同理，波斯猫和家猫都继承自猫。而斑点狗，泰迪都继承之狗。程序中当我们定义一个 class 的时候，可以从某个现有的 class 继承，新的 class 称之为子类（Subclass），而被继承的 class 称之为基类、父类或超类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

　　子类的__init__()

class Animal():
    def __init__(self,name,food):
        self.name = name
        self.food = food

    def eat(self):
        print(''%s爱吃%s''%(self.name,self.food))

#声明一个子类继承Animal
class Dog(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Dog,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(''%s爱喝%s''%(self.name,self.drink))

class Cat(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Cat,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(''%s爱喝%s''%(self.name,self.drink))

    #重写父类的eat方法
    def eat(self):
        print(''%s特别爱吃%s''% (self.name, self.food))


dog1 = Dog(''金毛'',''骨头'',''可乐'')
dog1.eat()
dog1.drinks()

dog1 = Cat(''波斯猫'',''秋刀鱼'',''雪碧'')
dog1.eat()
dog1.drinks()

　　多继承

　　Python 中多继承的语法格式如下：

　　class DerivedClassName(Base1, Base2, Base3):

　　<statement-1>

　　.

　　.

　　.

　　<statement-N>

　　注意：圆括号中父类的顺序，如果继承的父类中有相同的方法名，而在子类中使用时未指定，python 将从左至右查找父类中是否包含方法。

 

class A():
    def a(self):
        print(''我是A里面的a方法'')

class B():
    def b(self):
        print(''我是B里面的b方法'')

    def a(self):
        print(''我是B里面的a方法'')


class C():
    def c(self):
        print(''我是C里面的C方法'')

class D(A,B,C):
    def d(self):
        print(''我是D里面的d方法'')

dd = D()
dd.d() #调用自己的方法
dd.c()
dd.a()

　　重新

class Animal():
    def __init__(self,name,food):
        self.name = name
        self.food = food

    def eat(self):
        print(''%s爱吃%s''%(self.name,self.food))

#声明一个子类继承Animal
class Dog(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Dog,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(''%s爱喝%s''%(self.name,self.drink))

class Cat(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Cat,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(''%s爱喝%s''%(self.name,self.drink))

    #重写父类的eat方法
    def eat(self):
        print(''%s特别爱吃%s''% (self.name, self.food))


dog1 = Dog(''金毛'',''骨头'',''可乐'')
dog1.eat()
dog1.drinks()

dog1 = Cat(''波斯猫'',''秋刀鱼'',''雪碧'')
dog1.eat()
dog1.drinks()

　　练习

 

''''''
冰淇淋小店：冰其淋小店是一种特殊的餐馆。
编写一个名为IceCreamStand的类，让它继承你为完成练习1或练习4而编写的Restaurant类。
这两个版本Restaurant类都可以，挑选你更喜欢的那个即可。
添加一个名为flavors的属性,用于存储一个由各种口味的冰淇淋组成的列表。
编写一个显示这些冰淇淋的方法。创建一IceCreamStand实例,并调用这个方法。
''''''
from Restaurant import Restaurant

class IceCreamStand(Restaurant):
    #加载父类方法  并且增加新的属性
    def __init__(self,restaurant_name,cuisine_type,flavors,number_served = 0):
        super(IceCreamStand,self).__init__(restaurant_name,cuisine_type,number_served = 0)
        self.flavors = flavors

    def get_info(self):
        print(''这家冰激凌小店的名字是%s,他的特色是%s,冰激凌的口味是%s''%(self.restaurant_name,self.cuisine_type,self.flavors))

queen = IceCreamStand(''冰雪换后'',''手工制作冰激凌'',''草莓味'',''巧克力味'',''奶油味'')
queen.get_info()

 

　　

 

''''''
    管理员：管理员是一种特殊的用户。
    编写一个名为Admin的类，让它继承你为完成练习3或练习5而编写的User类。
    添加一个名为privileges的属性，用于存储一个由字符串（如“can add post”、
    “can delete post”、“can ban user”等）组成的列表。
    编写一个名为show_privileges()的方法,它显示管理员的权限，创建一个Admin实例，
    并调用这个方法。

''''''

from User import User

class Admin(User):
    privileges = [''can add post'',''can delete post'',''can ban user'']
    def __init__(self,first_name,last_name,age,sex,phone,login_attempts = 0):
        super(Admin,self).__init__(first_name,last_name,age,sex,phone,login_attempts = 0)

    def show_privileges(self):
        print(''管理员：%s%s具有以下权限。''%(self.first_name,self.last_name))
        for i in Admin.privileges:
            print(i)

admin1 = Admin(''susan'',18,''女'',''1243778494'')
admin1.show_privileges()

　　四、类属性和实例属性

　　属性

　　尽量把需要用户传入的属性作为实例属性，而把同类都一样的属性作为类属性。实例属性在每创造一个类是都会初始化一遍，不同的实例的实例属性可能不同，不同实例的类属性都相同。

　　1：实例属性： 　　　　

　　在__init__(self,...) 中初始化 　　　　

　　内部调用时都需要加上 self. 　　　　

　　外部调用时用 “对象名。属性名” 调用

　　2: 类属性： 　　　　

　　在__init__() 里初始化 　　　　

　　在内部用 classname. 类属性名调用 　　　　

　　外部既可以用 classname. 类属性名又可以用 instancename. 类属性名来调用

　　3：私有属性： 　　　　

　　双下划线__开头：外部不可通过 “对象名。属性名” 来访问或者更改实际将其转化为了 “_类名__属性名”

　　__foo__: 定义的是特殊方法，类似 __init__() 之类的。

　　_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问 (创建的实例可以访问)，不能用于 from module import *

　　__foo: 双下划线的表示的是私有类型 (private) 的变量，只能是允许这个类本身进行访问了。

class person():
    ''''''
    这是一个人类
    ''''''

    country = ''中国'' #类属性
    #实例属性通过构造方法来声明
    #self不是关键字，代表的是当前对象（类似于this）
    def __init__(self,name,age,sex,address): #构造方法
        #构造方法不需要调用 在实例化的时候自动调用
        print(''我是构造方法，在实例化的时候调用'')
        self.name = name #通过self 创建实例属性 并且赋值
        self.age = age
        self.sex = sex
        self.__address = address #私有属性

    #创建普通方法
    def getName(self):
        #私有属性在类里面使用可以正常使用
         print(''我的名字叫:%s,我来自%s,我住在%s'' %(self.name,person.country,self.__address))#在方法里面使用实例属性

    #外部要修改私有属性，预留一个接口去访问或者修改私有属性  这是正确的打开方式
    def getAddress(self,pwd):
        if pwd == ''123'':
            return self.__address
        else:
            return ''权限不够''

#实例化对象
people01 = person(''joe'',12,''男'',''上海'')
people01.getName()
#这个people01 就要具有三个属性，并且可以使用getName方法

#通过对象名.属性名访问私有属性
# print(people01.__address) #外部无法使用这种方式访问

#推荐使用
print(people01.getAddress(''123''))

#强制访问 不要使用
print(people01._person__address)

people01.__address = ''北京'' #看上去好像改了  其实没有  你给当前对象声明了一个新属性
print(people01.__address)

print(people01.getAddress(''123''))

五、访问限制

　　私有类属性

　　私有对象属性 为了保护属性不被随意修改和访问，可以将属性定义为私有属性。

　　如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，

　　在 Python 中，实例变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问. 

　　注意：

　　1. 设置为私有属性不能直接通过对象访问属性，但是可以通过 “实例化对象名._类名__属性名” 直接进行访问。但是不建议这样操作。不同版本的 Python 解释器可能会把 “__属性名” 改成不同的变量名。总的来说就是，Python 本身没有任何机制阻止你干坏事，一切全靠自觉。

　　2. 通过 “对象名.__属性名” 直接修改私有属性。 表面上看好像修改了其实并没有，因为 Python 解释器已经将对象内部的属性名解释成 “_类名__属性名”。如果在外部修改相当于另外声明一个属性。类属性可以直接修改通过类名._类名__属性名 =(可通过类方法定义) 

六、类方法和静态方法

　　类方法与静态方法

　　1：普通方法： 　　　　

　　　　def fun_name(self,...): 　　　　　　

　　　　pass 　　　　

　　　　外部用实例调用

　　2：静态方法：通过装饰器 @staticmethod 装饰 　　　　　　

　　　　不能访问实例属性

　　　　参数不能传入 self 　　　　　　

　　　　与类相关但是不依赖类与实例的方法

　　3: 类方法：@classmethod 　　　　　

　　　　不能访问实例属性 参数必须传入 cls 　　　　　

　　　　必须传入 cls 参数（即代表了此类对象 ----- 区别 ------self 代表实例对象），并且用此来调用类属性：cls. 类属性名

　　静态方法与类方法都可以通过类或者实例来调用。其两个的特点都是不能够调用实例属性

　　静态方法不需要接收参数，使用类名。类属性

class person():
    ''''''
    这是一个人类
    ''''''

    country = ''中国'' #类属性
    #实例属性通过构造方法来声明
    #self不是关键字，代表的是当前对象（类似于this）
    def __init__(self,name,age,sex,address): #构造方法
        #构造方法不需要调用 在实例化的时候自动调用
        print(''我是构造方法，在实例化的时候调用'')
        self.name = name #通过self 创建实例属性 并且赋值
        self.age = age
        self.sex = sex
        self.__address = address #私有属性

    #创建普通方法
    def getName(self):
        #私有属性在类里面使用可以正常使用
         print(''我的名字叫:%s,我来自%s,我住在%s'' %(self.name,person.country,self.__address))#在方法里面使用实例属性

    #创建一个静态方法
    @staticmethod
    def aa(): #不需要传递实例
        #静态方法不能访问实例属性
        #静态方法只能访问类属性
        print(''我的名字叫:%s'' % person.country)

    #类方法
    @classmethod
    def bb(cls):   #class 也不是关键字
        # 类方法不能访问实例属性
        print(''我的名字叫:%s'' % cls.country) #使用cls.类属性
        print(''我的名字叫:%s'' % person.country)

#实例化对象
people01 = person(''joe'',12,''男'',''上海'')
#通过对象来调用静态方法
people01.aa()
#通过对象来调用类方法
people01.bb()

#静态方法和类方法的调用  推荐使用类名的方式去调用
#通过类名来调用静态方法
person.aa()
#通过类名来调用类方法
person.bb()

　　

''''''
练习：亡者农药小游戏

1、创建三个游戏人物，分别是：
属性:
    名字：name,定位：category,血量：Output技能：Skill
英雄：
    铠，战士，血量：1000 技能：极刃风暴
    王昭君，法师 ，血量：1000 技能：凛冬将至
    阿轲，刺客，血量：1000 技能：瞬华

2、游戏场景，分别：

偷红buff，释放技能偷到红buff消耗血量300
solo战斗，一血，消耗血量500
补血，加血200

''''''
class hero():

    #定义属性
    def __init__(self,name,category,skill,output = 0,score = 0):
        self.name = name
        self.category = category
        self.skill = skill
        self.output = output
        self.score = score

    #战队场景1：偷红buff
    def red_buff(self):
        self.output -= 300
        print(''%s%s到对面野区偷红buff,消耗血量300'')

    #战斗场景2：solo战斗
    def solo(self,n = 1):
        self.output -= 500
        if self.output < 0:
            print(''%s%s,送了一个人头，血染王者峡谷''%(self.category,self.name))
        else:
            if self.score == 0:
                self.score += n
                print(''%s%s战斗拿到一血，血量消耗500''%(self.category,self.name))
            else:
                self.score += n
                print(''%s%s solo战斗收割%d个人头，血量消耗500''%(self.category,self.name,n))
    #场景三：加血
    def add_xue(self):
        self.output += 200
        print(''%s%s被辅助及时奶了一口，加血200''%(self.category,self.name))
    #查看英雄信息
    def getInfo(self):
        if self.output <= 0:
            print(''%s%s 正在复活。拿到%d个人头''%(self.category,self.name,self.score))
        else:
            print(''%s%s超神了！血量还有%d,拿到%d个人头''%(self.category,self.name,self.output,self.score))

#实例化对象
kai = hero(''铠'',''战士'',''极刃风暴'')

#操作
kai.red_buff()
kai.getInfo()
kai.solo()
kai.getInfo()
kai.add_xue()
kai.getInfo()
kai.solo()
kai.getInfo()

　　

''''''
模拟一个简单的银行进行业务办理的类

类：
    创建一个银行类
属性：
    一个属于银行的类属性
        用来存储所用银行的开户信息，包含卡号、密码、用户名、余额
        （外界不能随意访问和修改。开户时要进行卡号验证，查看卡号是否已经存在）

    每个对象拥有
        卡号、密码、用户名、余额
        （外界不能随意访问和更改）

方法：
    银行类拥有
        查看本银行的开户总数
        查看所有用户的个人信息（包含卡号、密码、用户名、余额）
    每个对象拥有
        实例化对象的时候传入相关参数
            初始化对象及类属性
        取钱（需要卡号和密码验证）
            通过验证卡号和密码对个人的余额进行操作，如果取钱大于余额，返回余额不足
        存钱（需要卡号和密码验证）
            通过验证卡号和密码对个人的余额进行操作，返回操作成功
        查看个人详细信息（需要卡号密码验证）
            返回个人的卡号，用户名，余额信息
''''''

class Bank():
    #一个属于银行的类属性
    __Users = {}

    #每个对象拥有 卡号 密码 用户名 余额
    def __init__(self,CardId,pwd,name,balance):
        if CardId not in Bank.__Users:
            Bank.__Users[CardId] = {''pwd'':pwd,''Username'':name,''Balance'':balance}
            self.__CardId = CardId
            self.__pwd = pwd
            self.__name = name
            self.__balance = balance

    #查看本银行的开户总数
    @classmethod
    def nums(cls):
         print(''当前用户数%d''%(len(cls.__Users)))

    #查看所有用户的个人信息（包含卡号、密码、用户名、余额）
    @classmethod
    def get_Users(cls):
        for key,val in cls.__Users.items():
            print(''卡号：%s \n用户名：%s \n密码：%d \n 余额：%d''%(key,val[''Username''],val[''pwd''],val[''Balance'']))
            print()

     #验证方法
    @staticmethod
    def check_User(CardId,pwd):
        if (CardId in Bank.__Users) and (pwd == Bank.__Users[CardId][''pwd'']):
            return True
        else:
            return False

    #验证金额
    @staticmethod
    def check_money(money):
        if isinstance(money,int):
            return True
        else:
            return False

    #取钱（需要卡号和密码验证）
    def q_money(self,CardId,pwd,money):
        if Bank.check_User(CardId,pwd):
            #开始取钱
            if Bank.check_money(money):
                if Bank.__Users[CardId][''Balance''] >= money:
                   Bank.__Users[CardId][''Balance''] -= money
                   print(''当前卡号%s,当前取款金额%d,当前余额%d''%(CardId,money,Bank.__Users[CardId][''Balance'']))
                else:
                    print(''余额不足'')
            else:
                print(''您输入的金额有误'')
        else:
            print(''卡号或者密码有误'')

    #存钱（需要卡号和密码验证）
    def c_money(self,CardId,pwd,money):
        if Bank.check_User(CardId,pwd):
            #开始取钱
            if Bank.check_money(money):
                Bank.__Users[CardId][''Balance''] += money
                print(''当前卡号%s,当前存款金额%d,当前余额%d''%(CardId,money,Bank.__Users[CardId][''Balance'']))
            else:
                print(''您输入的金额有误'')
        else:
            print(''卡号或者密码有误'')

    #查看个人详细信息
    def getInfo(self,CardId,pwd):
        if Bank.check_User(CardId, pwd):
            print(''当前卡号%s,当前用户名%s,当前余额%d'' %(CardId, Bank.__Users[CardId][''Username''], Bank.__Users[CardId][''Balance'']))
        else:
            print(''卡号或者密码有误'')

joe = Bank(''1001'',111111,''joe'',100)
joe2 = Bank(''1001'',111111,''joe'',100)
Bank.nums()
print(''_''*50)
Bank.get_Users()
print(''_''*50)
joe.c_money(''1001'',111111,500)
print(''_''*50)
joe.q_money(''1001'',111111,300)
print(''_''*50)
joe.getInfo(''1001'',111111)

　　

 

我们今天的关于Python复数属性和方法操作实例和python复数类型的分享已经告一段落，感谢您的关注，如果您想了解更多关于13_Python 类的属性和方法、Python - 类属性和实例属性、python 为 class 添加新的属性和方法、Python 之路 - 面向对象 & 继承和多态 & 类属性和实例属性 & 类方法和静态方法的相关信息，请在本站查询。

本文标签：

上一篇python中for循环中使用range、len、enumerate函数的操作实例（python for 循环中的range怎么用）

下一篇第4章 处理用户输入与显示数据------------(创建本地临时文件、在/temp中创建临时文件、创建临时目录、tee命令)

相关文章