python 函數的高階特性,類的解析 -开发者知识库

python 函數的高階特性,類的解析 -开发者知识库,第1张

python的高級特性

切片

  • 字符串,列表,元組是有序的序列,可以執行切片操作;
  • 集合和字典是無序的,不能通過下標進行切片;
    s[m:n:x]

迭代

  • 迭代: 遍歷目標變量中的每一個元素的過程; 只要可以通過for循環遍歷的對象都是可迭代,可迭代對象通過for循環遍歷;
from collections import  Iterable

In [10]: isinstance(1,int)
Out[10]: True

In [11]: isinstance(1,Iterable)
Out[11]: False

In [12]: isinstance("hello",Iterable)
Out[12]: True

In [13]: isinstance({},Iterable)
Out[13]: True

In [14]: isinstance({"a":"1"},Iterable)
Out[14]: True

In [15]: isinstance({1,2,3},Iterable)
Out[15]: True
  • 默認情況下,字典遍歷是遍歷字典的key值;
In [16]: d = {"ftp":21,"ssh":22}

In [17]: for i,j in d.items():
....: print i,j
....:
ftp 21
ssh 22

In [18]: for i in d:
....: print i
....:
ftp
ssh

In [21]: for host,port in [("server1",80),("server2",8080)]:
print host ":" str(port)
....:
server1:80
server2:8080

列表生成式

  • 生成列表的一個式子;list comprehension.
  • 格式: [i.lower() for i in l]

  • 簡單的列表生成式
    [i**2 for i in range(1,10)]
    [abs(i) for i in range(1,10)]
    [fun(i) for i in range(1,11)]

  • 嵌套if語句
    [i for i in range(1,10) if isprime(i)]

  • 嵌套for循環
    “abc” “123”
    [i j for i in “abc” for j in “123”]
    [service ”:” str(port) for service,port in d.items()]

練習:
l = [“westos”,18,”red”],將所有的字符串變成大寫並輸出;

[i.upper() for i in l if isinstance(i,str)]
[i.upper() for i in l if type(i)==str]

生成器

通過列表生成式可以修改為生成器;
優勢:
1). 節省內存空間;
2). 可以一邊循環一邊計算;

  • 生成器的創建
    1). 通過列表生成式可以修改為生成器;
    2). 關鍵字yield,函數中有yield時,這個函數執行返回結果是一個生成器;

  • 生成器的查看:
    1). g.next()
    2). for循環

函數式編程

內置的高階函數

  • map函數,map(函數, 序列),將傳入的函數作用於列表中的每一個元素,返回一個列表;

  • reduce函數,reduce(函數, 序列),將函數的執行結果相加.
    reduce(f,range(1,11)) = f(f(f(1,2),3),4)

  • filter函數,filter(函數, 序列),將函數作用於序列的每一個元素,將滿足條件的返回;

  • sorted函數,sorted(序列,函數),按照自定義格式排序;

裝飾器(器,就是函數,裝飾器就是用來裝飾函數的函數)

普通的函數:
def 函數名(形參): # 變量名
函數體
return 變量|常量

print 函數名(實參)

匿名函數

lambda 形參 : 返回值

面向對象編程

面向過程: 程序從上至下依次執行;

CS:
role: 警察,恐怖分子,人質

role1

name=”唐浩”
role=”人質”
life_value=100

role2

name=”豆鵬強”
role=”恐怖分子”
weapon=”AK47”
life_value=100
money=16000

role3

name=”嚴貴清”
role=”警察”
weapon=”M4”
life_value=100
money=16000

class Police:
pass

class Kongbu:
pass

class Renzhi:
pass

什么是面向對象?

類 ===== 建房子的圖紙 (三室一廳,兩室一廳…….)
對象===== 實際建出來的房子(門牌號)

class ThreeRoom:
pass

seven_zero_one = ThreeRoom()
seven_zero_one.live()
seven_zero_one.clean()

面向對象的三個特性

封裝,繼承,多態

舉個栗子

裝飾器

# 裝飾器: 裝飾函數的一個函數,
#


# 該方法實現了裝飾器的功能,但是調用函數的方式發生了改變;


def dtimer(fun):
def timer(*args,**kwargs): # 高階函數 #args = (1,2,3,4)
start_time = time.time()
fun(*args,**kwargs) # args =(1,2,3,4), 解包*(1,2,3,4)
stop_time = time.time()
return "run %s" % (stop_time - start_time)

return timer # 返回的是timer的地址,要執行該函數需要timer()


@dtimer # fun1 = dtimer(fun1)
def fun1(*args,**kwargs):
print "in the fun1....."
print args
time.sleep(1)


def fun2():
print "in the fun2....."
time.sleep(0.5)


print fun1(1,2,3,4)
# print timer(fun2)

閉包

# 閉包: 函數里面嵌套函數,並且外面函數的返回值是一個函數;
#
def lazy_sum(*args):
def add():
return sum(args)
return add # add函數

a = lazy_sum(1,2,3,4)
print a #a實質是add函數
print a()
def add(x, y):
c = x y
return c # c=3


a = add(1, 2)
print a

# 高階函數:把函數名當作實參傳入函數的函數稱為高階函數;
print map(add, range(1, 10))

類的第一個特性:封裝

# 類的第一個特性:封裝
# - self實質上是什么? 實例化出來的對象
# - 封裝是把實例化的對象和它的屬性封裝在一起,便於其他函數的使用;
# - 訪問對象屬性的兩種方式:
# self.name
# tianfeng.name




class People(object): # 類
def __init__(self,name,age): # 構造函數
self.name = name # 屬性
self.age = age
def eat(self): #方法
print " %s 正在吃辣條....." %(self.name)
def echo_self(self):
print self


tianfeng = People("田峰",18) # 通過類實例化出來的對象
print tianfeng
tianfeng.echo_self()
# print tianfeng.name
# print tianfeng.age
# tianfeng.eat()

# wangweibo= People("王偉波",18) # 通過類實例化出來的對象
# print wangweibo
# wangweibo.echo_self()

類的第二個特性:繼承

# 類的第二個特性:繼承


class People(object): # 類
def __init__(self, name, age): # 構造函數,在實例化對象時自動運行
self.name = name # 屬性
self.age = age

def eat(self): # 方法
print " %s 正在吃辣條....." % (self.name)

def echo_self(self):
print self


class Animal(object):
def __init__(self, name, age):
self.name = name # 屬性
self.age = age

def eat(self): # 方法
print " %s 正在吃辣條....." % (self.name)

def drink(self):
print "%s is drinking...." % (self.name)


class Student(People, Animal): # Student是子類/派生類, People是父類/基類
pass


tianfeng = People("田峰", 18)
tianfeng.eat()
fentiao = Student("粉條", 18)
fentiao.eat()
fentiao.drink()

類的優先級

# 當你的類是新式類,多繼承的算法是廣度優先;
# 當你的類是經典類,多繼承的算法是深度優先;



class D(object): # 新式類
# class D: # 經典類
def eat(self):
print "D eating"

pass


class C(D):
# def eat(self):
# print "C eating"
pass


class B(D):
def run(self):
print "runing"
# def eat(self):
# print "B eating"


class A(B, C):
pass


a = A()
a.eat()

類的第三個特性:多態

 # 類的第三個特性:多態


class Animal(object):
def __init__(self,name):
self.name = name

def eat(self):
print "%s 正在吃......" %(self.name)

class Cat(Animal):
def __init__(self,name,kind):
# Animal.__init__(self,name) # self.name = name
super(Cat, self).__init__(name)
self.kind = kind


def eat(self):
print "%s 正在吃貓糧......" %(self.name)


class Dog(Animal):
# def __init__(self,name,age):
#
def eat(self):
print "%s 正在吃狗糧......" % (self.name)

c = Cat("fentiao","美短")
c.eat()

# d = Dog("fentiaotiao")
# d.eat()

if __name__ == "__main__":
pass

類的私有屬性

# 類的私有屬性

class People(object):
def __init__(self, name, money):
self.name = name
self.__money = money # python內部將self.__money給它重命名為_類名__money

def get_money(self):
return "%s 擁有 %d 美元資產" % (self.name, self.__money)

def eat(self):
print "%s 正在吃......" % (self.name)


p = People("豆鵬強", 1000000)
print p.name
print p.get_money()
p.__money = 100
print p.__money
print p.get_money()
p._People__money = 100
print p.get_money()

class Date(object):
def __init__(self,year, month,day):
self.year = year
self.month = month
self.day = day

def echo_date(self):
print "Year:",self.year
print "Month:",self.month
print "Day:",self.day

@classmethod
def from_str(cls,s): # class,類方法的第一個參數是類本身,cls = Date
year, month, day = map(int, s.split("-"))
d = cls(year,month,day) # d = Date(year,month,day)
return d # 對象

@staticmethod
def is_date_legal(s): # 靜態方法,第一個參數既不是對象,也不是類本身,
year, month, day = map(int, s.split("-"))
return year >= 1970 and 0 < month <= 12 and 0 < day <= 31

# d = Date(2017,9,9)
# d.echo_date()
#
# d1 = Date.from_str('2018-10-19')
# d1.echo_date()

print "legal" if Date.is_date_legal('2017-13-16') else "illegal"

最佳答案:

本文经用户投稿或网站收集转载,如有侵权请联系本站。

发表评论

0条回复