python创建变量score_MyPython-->进阶篇-->类

标签：class Student(object):

pass

bart = Student()

print(bart) #<__main__.student object at>指向Student的一个类

bart.name=‘cc‘ #可以自由的给一个实例变量绑定属性

print(bart.name)

class st(object):

def __init__(self,name,score):

self.name=name

self.score=score

#类可以起到模板的作用，在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去，通过定义一个特殊的__int__方法，在

#创建实例的时候，就把name score等属性绑上去

#__init__方法第一个参数永远是self，表示创建的实例本身，因此在__init方法内部，就可以吧各种属性绑定到self，因为self就指向创建的实例本身

# 有了init方法，在创建实例的时候，就不能传入空的参数了，必须传入与init方法匹配的参数，但self不需要传

bart2 = st(‘cc‘,22)

print(bart2.name,bart2.score)

#还是可以用默认参数 可变参数 关键字参数和命名关键字参数

# 数据封装

def print_str(std):

print(‘name:%s,score:%s‘%(std.name,std.score))

print_str(bart2)

class stu(object):

def __init__(self,name,score):

self.name=name

self.score=score

def print_str(self):

print(‘name:%s,score:%s‘ % (self.name, self.score))

def get_grade(self):

if self.score >90:

print(‘good‘)

elif self.score>60:

print(‘pass‘)

else:

print(‘good good study‘)

bart3 = stu(‘bb‘,23)

bart3.print_str()

bart3.get_grade()

bart3.name = ‘cd‘

bart3.print_str()

#可发现外部可以对其修改，为了让内部属性不被外部访问，可以再属性的名称前加两个下划线__，在python中，实力的变量名如果以__开头，就变成私有变量(private)

#只有内部可以访问，外部不能访问

class stus(object):

def __init__(self,name,score):

self.__name=name

self.__score=score

def print_stus(self):

print(self.__name,self.__score)

bart4 = stus(‘dd‘,23)

#bart4.name = ‘pp‘#改不了了

bart4.print_stus()#dd 23

#print(bart4.__name)无法访问到name的值

#这样外部就无法访问到内部的值了 ，但是想访问怎么办 再加方法

class stusf(object):

def __init__(self,name,score):

self.__name=name

self.__score=score

def print_stus(self):

print(self.__name,self.__score)

def get_name(self):

return self.__name

def get_score(self):

return self.__score

#如果允许修改怎么做

def set_name(self,name):

self.__name=name

def set_score(self,score):

self.__score=score

bart5 = stusf(‘sas‘,7)

bart5.set_name(‘sos‘)

bart5.set_score(23)

bart5.print_stus()

# 你也许会问，原先那种直接通过bart.score = 59也可以修改啊，为什么要定义一个方法大费周折？因为在方法中，可以对参数做检查，避免传入无效的参数

# def set_score(self,score):

# if 0

# self.__score = score

# else:

# raise ValueError(‘bad score‘)

#python中，变量名类似__xx__，是特殊变量，特殊变量是可以直接访问的不是private变量，所以，不能用__name__这种变量名

#_name不能直接访问时因为，python解释器对外吧__name变量改成了__Student__name，所以可以通过__Student__nanme来访问__nmae变量，不要这么干！

class animal(object):

def run(self):

print(‘animal is running‘)

class dog (animal):#继承animal，animal父类，dog子类

def run(self):

print(‘dog is running‘)

def eat(self):

print(‘dog eat‘)

class cat(animal):

def run(self):#多态，覆盖了父类的run()

print(‘cat is running‘)

d=dog()

d.run()

d.eat()

c=cat()

c.run()

#判断一个变量是否是某个类型可以用isinstance()判断

print(isinstance(d,animal))#t

print(isinstance(d,dog))#t

a=animal()

print(isinstance(a,dog))#f

def run_twice(animal):

animal.run()

run_twice(animal())

run_twice(cat())

# python动态语言，我们不需要保证传入的是animal类型，我们只需保证传入的对象有一个run(方法就可以了

class bark(object):

def run(self):

print(‘dark from animal‘)

run_twice(bark()) # dark from animal

#这就是动态语言的鸭子类型，他并不要求严格的继承体系，一个对象只要看起来像鸭子，走起路来像鸭子，那他就可以被看做是鸭子

#python的file like object就是一种鸭子类型。对真正的文件对象他又一个reda()方法，返回其内容。但是许多对象，只要有read()方法，都被视为file-like object。

#许多参数接受的参数就是file-like object，你不一定要传入真正的文件对象，完全可以实现read()方法的对象

# type()

#我们拿到一个对象的引用时，如何知道这个对象是什么类型有那么些方法呢

print(type(abs))#

print(type(a))#

ba=bark()

def uz():

pass

import types

#判断基本数据类型可以直接写int，str，但如果判断的对象是否是函数怎么办？可以用types模块中定义的常量

def fn():

pass

print(type(fn)==types.FunctionType)

print(type(abs)==types.BuiltinFunctionType)

print(type(lambda x:x)==types.LambdaType)

print(type((x for x in range(10)))==types.GeneratorType)

# isinstance()

#对于class的继承关系来说，使用type()就很不方便，我们要判断class类型，可以使用isinstance()函数

class hsk(dog):

def run(self):

print(‘hsk‘)

a1=animal()

d1=dog()

h1=hsk()

print(‘isinstance 判断是否是对应类‘)

print(isinstance(h1,hsk))

print(isinstance(h1,dog))

print(isinstance(hsk(),dog))

#能用type()判断的基本类型用isinstance()也可以判断

print(isinstance(‘abc‘,str))

# dir()

#如果要获得一个对象的所有属性和方法，可以使用dir()函数，团战返回一个包含字符串的list，比如获得一个str获得的所有属性和方法

print(dir(‘abc‘))

print(dir(list))

#python中类似__xxx__的属性和方法在python中有是有特殊用途的，不如__len__方法返回长度，在python中，如果你调用len()函数试图获取一个对象的长度

#在len()函数内部，他自动调用该对象的__len—__()方法，所以以下代码是等价的

abc=‘abcc‘

print(len(abc))

print(abc.__len__())

#如果我们想自己写的类，可以写一个__len__()方法

class doglen():

def __len__(self):

return 100

print(len(doglen()))

class myobject():

def __init__(self):

self.x = 9

def power(self):

return self.x * self.x

# getattr() setattr() hasattr() 结果这三个函数我们可以直接操作

print(‘-----------‘)

myobj=myobject()

print(hasattr(myobj,‘x‘))# 有熟悉x吗

setattr(myobj,‘y‘,23)# 添加属性y

print(hasattr(myobj,‘y‘))

print(getattr(myobj,‘y‘))#获取y属性的值

#print(getattr(myobj,‘c‘))

# 如果试图获取不存在的属性，会抛出AttributeError的错误：

#

# >>> getattr(obj, ‘z‘) # 获取属性‘z‘

# Traceback (most recent call last):

# File "", line 1, in

# AttributeError: ‘MyObject‘ object has no attribute ‘z‘

#如果获取属性不存在 就会抛出AttributeError，我们可以传入一个default参数，如果属性不存在就返回默认值

print(getattr(myobj,‘z‘,404))

#还可以获得对象的方法

print(hasattr(myobj,‘power‘))

# 实例属性和类属性

# 由于python是动态语言，根据类创建的实例，可以任意绑定属性。给实例绑定属性的方法是通过实例变量，或者通过self变量

class stud(object):

age = ‘student‘

def __init__(self,name):

self.name=name

s1=stud(‘chen‘)

s1.score=100

hasattr(s1,‘score‘)

print(‘---111111‘)

#但是如果stud类本身需要绑定一个属性呢 可以直接在class中定义属性，这种属性是类属性，归stud类所有

print(s1.age)

s1.age = ‘www‘

print(s1.age)

s1.age = ‘del‘

print(s1.age)

del s1.age

print(s1.age)

标签：