class Test():            #类的定义

     car = "buick"        #类变量，定义在类里方法外，可被对象直接调用，具有全局效果

     def __init__(self):    #构造方法

         self.name =       #成员变量，可以在类的不同方法间调用,也可以由类创建的对象进行调用

         print("name=",self.name)

     def say(self):         #类方法必须包含参数self，且为第一个参数

         address = "china"  #方法中的局部变量

         print("address=",address)

         self.address = address #局部变量可以在类方法间使用

     def cry(self):

         print(self.address)    #打印上面局部变量

     @staticmethod              #静态方法可以被类名直接调用

     def fun1():

         print("我是静态方法")

 t = Test()   #t为类创建的对象

 # print(t.car) #打印类变量

 t.say()

 t.cry()

 Test.fun1()

 #方法(函数)、类变量、成员变量(init)、局部变量(def)

 class Parent():

     def myMthod(self):

         print("父类的方法")

 class Cjild(Parent):

     def myMthod(self):

         print("子类的方法")

 c = Cjild()

 c.myMthod() #先调用自己的方法，也叫做方法重写

 class Info():

     def __init__(self):

         self.__name = 'xiaohan'  #私有变量（一般只能在类内部使用）

     def say(self):

         print(self.__name)       #类的内部调用

 a = Info()

 # print(a.__name)       #类的外表调用报错，无法调用

 print(a._Info__name)    #注意：可以用a._Info__name这样的方式在类的外部调用，这就是python的灵活性

#迭代器一次返回一个成员

list1 = [,,,]

it = iter(list1)   #创建一个对象并赋值给it

print(next(it))    #

print(next(it))    #

print(next(it))    #

print(next(it))    #

 range(strat,end,step)

 range() range(,) range(,,)

 range(-,)

 range(,-,-)

 range(-,,-)          #输出为空

 range(,,-)           #输出为空

 range(,,)            #输出为空

 a[start,end,seq]

 seq如果为正，从左往右走，如果start大于end显示为空

 seq如果为负，从右往左走，如果start小于end显示为空

 如果start为空，表示从头开始走

 如果end为空，表示走到末尾

 如果start和end都为空，取全部

 求圆的面积和周长

 from math import pi

 class Shape():

     def getArea(self,r):

         print("圆的面积是：%.2f"%(pi*(r**)))

     def getLong(self,r):

         print("圆的周长是：%.2f"%(*pi*r))

 y = Shape()

 y.getArea()

 y.getLong()

 统计员工信息和工资

 class Employee:

     count =

     def __init__(self,name,salory):

         self.name = name

         self.salory = salory

         Employee.count += 

     def emp_info(self):

         print("name=",self.name,"salory=",self.salory)

     def emp_count(self):

         print("num=",self.count)

 u = Employee('han',)

 u.emp_count()

 u.emp_info()

 u1 = Employee('xiaobei',2)

 u1.emp_count()

 u1.emp_info()

 class Test():

     s = "我是一个类变量，嘎嘎"

     def __init__(self):

         print("构造方法就是初始化，来一下")

         self.a =       #可以由类创建的对象调用

         self.b = 

     def __del__(self):

         print("析构方法就是后期收拾残局的，我来")

     def foo(self):

         print("方法内的普通成员")

     @staticmethod

     def baba():

         print("类的静态方法，我可以被类名直接调用哦，来来")

 t = Test() #创建一个对象，对象啊对象

 '''

 思路：

 init和del在类中仅且执行一次，init是初始化（先勤部队）del是收拾残局（后勤部队）

 不管是几个方法的调用都会执行下init和del

 '''

 t.foo()         #如果单独执行打印init和del，中间打印foo

 Test.baba()     #如果单独执行打印init和del，中间打印baba

 print(Test.s)   #如果单独执行打印init和del，中间打印s

 #如果一起执行打印的顺序是：init、foo、baba、s、del