Python面向對象、疊代器、range和切片的區分

面向對象

一、面向對象代碼示例：

1 class Test():            #類的定義
 2     car = "buick"        #類變量，定義在類裡方法外，可被對象直接調用，具有全局效果
 3     def __init__(self):    #構造方法
 4         self.name = 1      #成員變量，可以在類的不同方法間調用,也可以由類建立的對象進行調用
 5         print("name=",self.name)
 6 
 7     def say(self):         #類方法必須包含參數self，且為第一個參數
 8         address = "china"  #方法中的局部變量
 9         print("address=",address)
10 
11         self.address = address #局部變量可以在類方法間使用
12 
13     def cry(self):
14         print(self.address)    #列印上面局部變量
15 
16     @staticmethod              #靜态方法可以被類名直接調用
17     def fun1():
18         print("我是靜态方法")
19 
20 t = Test()   #t為類建立的對象
21 # print(t.car) #列印類變量
22 t.say()
23 t.cry()
24 Test.fun1()
25 #方法(函數)、類變量、成員變量(init)、局部變量(def)      

二、類的繼承，子類可以使用父類的方法，父類不可以使用子類的方法

三、方法重寫:調用最新的方法

1 class Parent():
 2     def myMthod(self):
 3         print("父類的方法")
 4 
 5 class Cjild(Parent):
 6     def myMthod(self):
 7         print("子類的方法")
 8 
 9 c = Cjild()
10 c.myMthod() #先調用自己的方法，也叫做方法重寫      

四、私有變量和方法

1 class Info():
 2     def __init__(self):
 3         self.__name = 'xiaojia'  #私有變量（一般隻能在類内部使用）
 4 
 5     def say(self):
 6         print(self.__name)       #類的内部調用
 7 
 8 a = Info()
 9 # print(a.__name)       #類的外部調用報錯，無法調用
10 print(a._Info__name)    #注意：可以用a._Info__name這樣的方式在類的外部調用，這就是python的靈活性      

疊代器

1 #疊代器一次傳回一個成員
2 list1 = [1,2,3,4]
3 it = iter(list1)   #建立一個對象并指派給it
4 print(next(it))    #1
5 print(next(it))    #2
6 print(next(it))    #3
7 print(next(it))    #4      

range和切片的比較：

range：

1 range(strat,end,step)
2 range(4) range(0,4) range(0,4,1)
3 range(-3,3)
4 range(3,-3,-1)
5 
6 range(-3,3,-1)          #輸出為空
7 range(0,4,-1)           #輸出為空
8 range(3,2,1)            #輸出為空      

切片：

1 a[start,end,seq]
2 seq如果為正，從左往右走，如果start大于end顯示為空
3 seq如果為負，從右往左走，如果start小于end顯示為空
4 如果start為空，表示從頭開始走
5 如果end為空，表示走到末尾
6 如果start和end都為空，取全部      

如下 标記位：

# 0   1   2   3

# a   b   c   d

# -4 -3 -2  -1

練習：

1 求圓的面積和周長
 2 from math import pi
 3 class Shape():
 4     def getArea(self,r):
 5         print("圓的面積是：%.2f"%(pi*(r**2)))
 6 
 7     def getLong(self,r):
 8         print("圓的周長是：%.2f"%(2*pi*r))
 9 
10 y = Shape()
11 y.getArea(5)
12 y.getLong(5)      

1 統計員工資訊和工資
 2 class Employee:
 3 
 4     count = 0
 5     def __init__(self,name,salory):
 6         self.name = name
 7         self.salory = salory
 8         self.count += 1
 9 
10     def emp_info(self):
11         print("name=",self.name,"salory=",self.salory)
12 
13     def emp_count(self):
14         print("num=",self.count)
15 
16 u = Employee('jia',100)
17 u.emp_count()
18 u.emp_info()
19 u = Employee('yannan',30000)
20 u.emp_count()
21 u.emp_info()      

思考面向對象的執行順序：

1 class Test():
 2     s = "我是一個類變量，嘎嘎"
 3 
 4     def __init__(self):
 5         print("構造方法就是初始化，來一下")
 6         self.a = 1      #可以由類建立的對象調用
 7         self.b = 28
 8 
 9     def __del__(self):
10         print("析構方法就是後期收拾殘局的，我來")
11 
12     def foo(self):
13         print("方法内的普通成員")
14 
15     @staticmethod
16     def baba():
17         print("類的靜态方法，我可以被類名直接調用哦，來來")
18 
19 t = Test() #建立一個對象，對象啊對象
20 '''
21 思路：
22 init和del在類中僅且執行一次，init是初始化（先勤部隊）del是收拾殘局（後勤部隊）
23 不管是幾個方法的調用都會執行下init和del
24 '''
25 t.foo()         #如果單獨執行列印init和del，中間列印foo
26 Test.baba()     #如果單獨執行列印init和del，中間列印baba
27 print(Test.s)   #如果單獨執行列印init和del，中間列印s
28 
29 #如果一起執行列印的順序是：init、foo、baba、s、del