python自动化--语言基础五面向对象、迭代器、range和切片的区分

面向对象

一、面向对象简单介绍：

class Test():            #类的定义
    car = "buick"        #类变量，定义在类里方法外，可被对象直接调用，具有全局效果
    def __init__(self):    #构造方法
        self.name = 1      #成员变量，可以在类的不同方法间调用,也可以由类创建的对象进行调用
        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 = [1,2,3,4]
it = iter(list1)   #创建一个对象并赋值给it
print(next(it))    #1
print(next(it))    #2
print(next(it))    #3
print(next(it))    #4

range和切片的比较：

range：

range(strat,end,step)
range(4) range(0,4) range(0,4,1)
range(-3,3)
range(3,-3,-1)

range(-3,3,-1)          #输出为空
range(0,4,-1)           #输出为空
range(3,2,1)            #输出为空

切片：

a[start,end,seq]
seq如果为正，从左往右走，如果start大于end显示为空
seq如果为负，从右往左走，如果start小于end显示为空
如果start为空，表示从头开始走
如果end为空，表示走到末尾
如果start和end都为空，取全部

如下 标记位：

# 0   1   2   3
# a   b   c   d
# -4 -3 -2  -1

练习：

求圆的面积和周长
from math import pi
class Shape():
    def getArea(self,r):
        print("圆的面积是：%.2f"%(pi*(r**2)))

    def getLong(self,r):
        print("圆的周长是：%.2f"%(2*pi*r))

y = Shape()
y.getArea(5)
y.getLong(5)

统计员工信息和工资
class Employee:

    count = 0
    def __init__(self,name,salory):
        self.name = name
        self.salory = salory
        Employee.count += 1

    def emp_info(self):
        print("name=",self.name,"salory=",self.salory)

    def emp_count(self):
        print("num=",self.count)

u = Employee('han',100)
u.emp_count()
u.emp_info()
u1 = Employee('xiaobei',2000)
u1.emp_count()
u1.emp_info()

思考面向对象的执行顺序：

class Test():
    s = "我是一个类变量，嘎嘎"

    def __init__(self):
        print("构造方法就是初始化，来一下")
        self.a = 1      #可以由类创建的对象调用
        self.b = 28

    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