Python中类、继承的使用

知识点1：

# 创建一个“handsome”的类
class handsome:
	def __init__(self):    # 构造方法（self参数必须是第一个参数，用于访问类中的属性和方法）
		print("我是帅哥!")
Handsome = handsome()   # 创建handsome类似实例

# 运行结果
我是帅哥！

知识点2: 继承和super().init()的用法 1. 子类继承父类，但不重写构造函数__init__(初始化)，那么子类会自动继承父类属性和方法

class Person:
    def __init__(self):
        self.name = "ABC"
        self.age = "24"
    def Hello(self):
        print("成功继承父类方法")

class Go(Person):
    pass

p = Person()
g = Go()

print('父类属性name: ', p.name)
print('父类属性age: ', p.name)
print('继承父类属性name: ', g.name)
print('继承父类属性age: ', g.name)

# 运行结果
父类属性name:  ABC
父类属性age:  ABC
继承父类属性name:  ABC
继承父类属性age:  ABC

2. 子类继承父类，重写构造函数__init__(初始化)，但不使用super初始化父类构造函数，那么子类不会自动继承父类的属性，会继承方法

class Person:
    def __init__(self):
        self.name = 'name'
        self.age = 'age'

    def Hello(self):
        print("成功继承父类方法")

class Gao(Person):
    def __init__(self):
        self.height = 'height'

p = Person()
g = Gao()
g.Hello()
print('父类属性：', p.name)
print('父类属性：', p.age)
print('子类属性：', g.height)
print('继承父类属性：', g.age)

运行结果：Person()类里面的方法Hello()可以被继承，而Person()类里面的属性age不可以被继承：

3子类继承父类，重写构造函数__init__(初始化)，且使用super初始化父类构造函数，那么子类会自动继承父类的属性和方法

class Person:
    def __init__(self):
        self.name = '123'
        self.age = '26'

    def Hello(self):
        print("成功继承父类方法")


class Go(Person):
    def __init__(self):
        super().__init__()
        self.height = '172cm'

p = Person()
g = Go()
g.Hello()
print('父类属性name：', p.name)
print('父类属性age：', p.age)
print('子类属性name：', g.height)
print('继承父类属性age：', g.age)

# 运行结果
成功继承父类方法
父类属性name： 123
父类属性age： 26
子类属性name： 172cm
继承父类属性age： 26

知识点2 （多参数）：

// An highlighted block
var foo = 'bar';

# 创建一个“handsome”的类（方法一）
class handsome:
	def __init__(self, nane, age. score):    # 构造方法（self参数必须是第一个参数，用于访问类中的属性和方法）
		print("我是帅哥!")
		print("我叫" + nane)
		print("今年" + age)
		print("取得分数" + score)

name = "hdy"
age = "24"
score = "100"

Handsome = handsome(nanme, age, score)   # 创建handsome类似实例


# 创建一个“handsome”的类（方法二）
class handsome:
     def __init__(self, name, age, score):
         print("帅哥")
         print("我叫" + name)
         print("今年" + age)
         print("分数" + score)

if __name__ == '__main__':
    handsome = handsome(name = "hdy", age = "24", score = "100")

# 运行结果
我是帅哥！
我叫hdy
今年24
取得分数100

类知识点3：

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

    def name1(self, name):
        print("1方法中的名字 %s:" %name)
        print("1类中的名字 %s :" %self.name)

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

    def Diaoyong(self, name):
        self.name1(name)

if __name__ == '__main__':
    person = Person()        # person 等值于Person()
    person.name1("A")        # person继承了Person(),并赋值name1=A,调用name1属性

    new_person = New_person("ABC")  # new_person等值于（继承Person的New_person）,并引入参数ABC
    new_person.Diaoyong("b")        # new_person继承了New_person，并调用了Diaoyong属性

#运行结果
1方法中的名字 A:
1类中的名字 小绿 :
1方法中的名字 b:
1类中的名字 ABC :

定义了一个类，其内部属性可以被更改：

class Student(object):

    def __init__(self, name = "hdy", score = "59"):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

stu = Student("ABC", "100")
stu.print_score()

# 运行结果
ABC: 100

若要使内部属性不被外部访问和更改，可以把属性的名称前加上两个下划线：

class Student(object):

    def __init__(self, name = "hdy", score = "59"):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

stu = Student("ABC", "100")
print('%s:' %(stu.__name))

出现报错信息：

Traceback (most recent call last):
  File "F:/PyQt/Demo-01/lj.py", line 33, in <module>
    print('%s:' %(stu.__name))
AttributeError: 'Student' object has no attribute '__name'