day4-迭代器、生成器、面向過程編程、三元表達式等等

時間  2019-11-21
標籤 day4 day 迭代 成器 面向 過程 編程 三元 3元 表達式 等等 简体版
原文   原文鏈接

 

第1章 迭代器

1.1 什麼是迭代？

#1 什麼是迭代：指的是一個重複的過程，每一次重複稱爲一次迭代，而且每一次重複的結果是下一次重複的初始值html

# while True:

#     print('=====>')      #只是單純地重複，於是不是迭代

 

# l=['a','b','c']

# count=0

# while count < len(l):    #迭代

#     print(l[count])

#     count+=1
View Code

1.2 爲什麼要有迭代器？什麼是可迭代的對象？什麼是迭代器對象？

1.2.1 爲何要有迭代器？

#2 爲何要有迭代器？python

#對於序列類型：str，list，tuple，能夠依賴索引來迭代取值，linux

# 可是對於dict，set，文件,python必須爲咱們提供一種不依賴於索引的迭代取值的方式-》迭代器git

對於序列類型：字符串、列表、元組，咱們可使用索引的方式迭代取出其包含的元素。但對於字典、集合、文件等類型是沒有索引的，若還想取出其內部包含的元素，則必須找出一種不依賴於索引的迭代方式，這就是迭代器。github

 

1.2.2 可迭代的對象

#3 可迭代的對象(下列都是)：obj.__iter__算法

可迭代對象指的是內置有__iter__方法的對象，即obj.__iter__，以下sql

# name='egon'

# l=[1,2,3]

# t=(1,2,3)

# d={'name':'egon','age':18,'sex':'male'}

# s={'a','b','c'}

# f=open('a.txt','w',encoding='utf-8')

#

# name.__iter__

# l.__iter__

# t.__iter__

# d.__iter__

# s.__iter__

# f.__iter__
可迭代的對象實例

1.2.3 迭代器對象

#4 迭代器對象（文件是）：obj.__iter__,obj.__next__express

# f.__iter__編程

# f.__next__api

可迭代的對象執行obj.__iter__()獲得的結果就是迭代器對象

而迭代器對象指的是即內置有__iter__又內置有__next__方法的對象

 

文件類型是迭代器對象

open('a.txt').__iter__()

open('a.txt').__next__()

 

1.2.4 總結

#1 可迭代對象不必定是迭代器對象

#2 迭代器對象必定是可迭代的對象

#3 調用obj.__iter__()方法,獲得的是迭代器對象(對於迭代器對象，執行__iter__獲得的仍然是它自己)。

 

1.3 迭代器對象的使用

# d={'name':'egon','age':18,'sex':'male'}

# d_iter=d.__iter__()

 

# f=open('a.txt','w',encoding='utf-8')

# f_iter=f.__iter__().__iter__().__iter__().__iter__()

#

# print(f_iter is f)

 

 

# d={'name':'egon','age':18,'sex':'male'}

# d_iter=d.__iter__()

#

# print(d_iter.__next__())

# print(d_iter.__next__())

# print(d_iter.__next__())

# print(d_iter.__next__()) #迭代器d_iter沒有值了，就會拋出異常StopIteration

 

 

 

# f=open('a.txt','r',encoding='utf-8')

# print(f.__next__())

# print(f.__next__())

# print(f.__next__())

# print(f.__next__())

# f.close()

 

 

# l=['a','b','c']

# l_iter=l.__iter__()

#

# print(l_iter.__next__())

# print(l_iter.__next__())

# print(l_iter.__next__())

# print(l_iter.__next__())

 

 

 

# d={'name':'egon','age':18,'sex':'male'}

# d_iter=iter(d) #d_iter=d.__iter__()

#

# #len(obj) 等同於obj.__len__()

#

# while True:

#     try:

#         print(next(d_iter)) #print(d_iter.__next__())

#     except StopIteration:

#         break

#

# print('=>>>')

# print('=>>>')

# print('=>>>')

# print('=>>>')
View Code

 

dic={'a':1,'b':2,'c':3}

iter_dic=dic.__iter__() #獲得迭代器對象，迭代器對象即有__iter__又有__next__，可是：迭代器.__iter__()獲得的仍然是迭代器自己

iter_dic.__iter__() is iter_dic #True

 

print(iter_dic.__next__()) #等同於next(iter_dic)

print(iter_dic.__next__()) #等同於next(iter_dic)

print(iter_dic.__next__()) #等同於next(iter_dic)

# print(iter_dic.__next__()) #拋出異常StopIteration，或者說結束標誌

 

#有了迭代器，咱們就能夠不依賴索引迭代取值了

iter_dic=dic.__iter__()

while 1:

    try:

        k=next(iter_dic)

        print(dic[k])

    except StopIteration:

        break

       

#這麼寫太醜陋了，須要咱們本身捕捉異常，控制next，python這麼牛逼，能不能幫我解決呢？能，請看for循環
View Code

1.4 for循環

#for循環詳解:

#一、調用in後的obj_iter=obj.__iter__()

#二、k=obj_iter.__next__()

#三、捕捉StopIteration異常，結束迭代

# d={'name':'egon','age':18,'sex':'male'}

# for k in d:

#     print(k)

 

#基於for循環，咱們能夠徹底再也不依賴索引去取值了

dic={'a':1,'b':2,'c':3}

for k in dic:

    print(dic[k])

 

#for循環的工做原理

#1：執行in後對象的dic.__iter__()方法，獲得一個迭代器對象iter_dic

#2: 執行next(iter_dic),將獲得的值賦值給k,而後執行循環體代碼

#3: 重複過程2，直到捕捉到異常StopIteration,結束循環
for循環詳解

1.5 迭代器的優缺點

#總結迭代器的優缺點：

#優勢:

#一、提供一種統一的、不依賴於索引的取值方式，爲for循環的實現提供了依據

#二、迭代器同一時間在內存中只有一個值——》更節省內存，

 

#缺點：

#一、只能日後取，而且是一次性的

#二、不能統計值的個數，即長度

 

# l=[1,2,3,4,5,6]

# l[0]

# l[1]

# l[2]

# l[0]

 

# l_iter=l.__iter__()

# # print(l_iter)

# print(next(l_iter))

# print(next(l_iter))

# print(next(l_iter))

# print(next(l_iter))

# print(next(l_iter))

# print(next(l_iter))

# print(next(l_iter))

#

# l_iter=l.__iter__()

# print(next(l_iter))

# print(next(l_iter))

# print(next(l_iter))

 

# print(len(l_iter))
迭代器的優缺點

第2章 生成器

2.1 什麼是生成器？

#1 什麼是生成器：只要在函數體內出現yield關鍵字，那麼再執行函數就不會執行函數代碼，會獲得一個結果，該結果就是生成器

def func():

    print('=====>1')

    yield 1

    print('=====>2')

    yield 2

    print('=====>3')

yield 3

g=func()

print(g) #<generator object func at 0x0000000002184360>
生成器實例

2.2 生成器就是迭代器

g.__iter__

g.__next__

#二、因此生成器就是迭代器，所以能夠這麼取值

res=next(g)

print(res)

 

 

#生成器就是迭代器

# g=func()

#

# res1=next(g)

# print(res1)

#

#

# res2=next(g)

# print(res2)

#

#

# res3=next(g)

# print(res3)

#yield的功能：

#一、yield爲咱們提供了一種自定義迭代器對象的方法

#二、yield與return的區別1：yield能夠返回屢次值 #2：函數暫停與再繼續的狀態是由yield幫咱們保存的

 

# obj=range(1,1000000000000000000000000000000000000000000000000000000000000000,2)

# obj_iter=obj.__iter__()

# print(next(obj_iter))

# print(next(obj_iter))

# print(next(obj_iter))

# print(next(obj_iter))

# print(next(obj_iter))

 

 

# def my_range(start,stop,step=1):

#     while start < stop:

#         yield start #start=1

#         start+=step #start=3

#

#

# g=my_range(1,5,2)

# print(g)

 

# print(next(g))

# print(next(g))

# print(next(g))

# print(next(g))

# print(next(g))

# print(next(g))

# print(next(g))

# for i in my_range(1,5,2):

#     print(i)
生成器就是迭代器

2.3 練習

一、自定義函數模擬range(1,7,2)

二、模擬管道，實現功能:tail -f access.log | grep '404'

#題目一：

def my_range(start,stop,step=1):

    while start < stop:

        yield start

        start+=step

 

#執行函數獲得生成器，本質就是迭代器

obj=my_range(1,7,2) #1  3  5

print(next(obj))

print(next(obj))

print(next(obj))

print(next(obj)) #StopIteration

 

#應用於for循環

for i in my_range(1,7,2):

    print(i)

 

#題目二

import time

def tail(filepath):

    with open(filepath,'rb') as f:

        f.seek(0,2)

        while True:

            line=f.readline()

            if line:

                yield line

            else:

                time.sleep(0.2)

 

def grep(pattern,lines):

    for line in lines:

        line=line.decode('utf-8')

        if pattern in line:

            yield line

 

for line in grep('404',tail('access.log')):

    print(line,end='')

 

#測試

with open('access.log','a',encoding='utf-8') as f:

    f.write('出錯啦404\n')
練習 
#小練習：:tail -f access.log | grep '404'

# import time

# def tail(filepath):

#     with open(filepath,'rb') as f:

#         f.seek(0,2)

#         while True:

#             line=f.readline()

#             if line:

#                 yield line

#             else:

#                 time.sleep(0.05)

#

# def grep(lines,pattern):

#     for line in lines:

#         line=line.decode('utf-8')

#         if pattern in line:

#             yield line

#

#

# lines=grep(tail('access.log'),'404')

#

# for line in lines:

#     print(line)
小練習

2.4 協程函數（瞭解）

#yield關鍵字的另一種使用形式：表達式形式的yield

def eater(name):

    print('%s 準備開始吃飯啦' %name)

    food_list=[]

    while True:

        food=yield food_list

        print('%s 吃了 %s' % (name,food))

        food_list.append(food)

 

g=eater('egon')

g.send(None) #對於表達式形式的yield，在使用時，第一次必須傳None，g.send(None)等同於next(g)

g.send('蒸羊羔')

g.send('蒸鹿茸')

g.send('蒸熊掌')

g.send('燒素鴨')

g.close()

g.send('燒素鵝')

g.send('燒鹿尾')
View Code 
#瞭解知識點：yield表達式形式的用法

def eater(name):

    print('%s ready to eat' %name)

    food_list=[]

    while True:

        food=yield food_list#food=yield='一盆骨頭'

        food_list.append(food)

        print('%s start to eat %s' %(name,food))

 

 

e=eater('alex')

 

#首先初始化：

print(e.send(None)) # next(e)

#而後e.send:1 從暫停的位置將值傳給yield  二、與next同樣

print(e.send('一桶泔水'))

print(e.send('一盆骨頭'))
瞭解知識點：yield表達式形式的用法

2.5 練習

1、編寫裝飾器，實現初始化協程函數的功能

二、實現功能：grep  -rl  'python'  /etc

#題目一：

def init(func):

    def wrapper(*args,**kwargs):

        g=func(*args,**kwargs)

        next(g)

        return g

    return wrapper

@init

def eater(name):

    print('%s 準備開始吃飯啦' %name)

    food_list=[]

    while True:

        food=yield food_list

        print('%s 吃了 %s' % (name,food))

        food_list.append(food)

 

g=eater('egon')

g.send('蒸羊羔')

 

#題目二：

#注意：target.send(...)在拿到target的返回值後纔算執行結束

import os

def init(func):

    def wrapper(*args,**kwargs):

        g=func(*args,**kwargs)

        next(g)

        return g

    return wrapper

 

@init

def search(target):

    while True:

        filepath=yield

        g=os.walk(filepath)

        for dirname,_,files in g:

            for file in files:

                abs_path=r'%s\%s' %(dirname,file)

                target.send(abs_path)

@init

def opener(target):

    while True:

        abs_path=yield

        with open(abs_path,'rb') as f:

            target.send((f,abs_path))

@init

def cat(target):

    while True:

        f,abs_path=yield

        for line in f:

            res=target.send((line,abs_path))

            if res:

                break

@init

def grep(pattern,target):

    tag=False

    while True:

        line,abs_path=yield tag

        tag=False

        if pattern.encode('utf-8') in line:

            target.send(abs_path)

            tag=True

@init

def printer():

    while True:

        abs_path=yield

        print(abs_path)

 

 

g=search(opener(cat(grep('你好',printer()))))

# g.send(r'E:\CMS\aaa\db')

g=search(opener(cat(grep('python',printer()))))

g.send(r'E:\CMS\aaa\db')
練習

2.6 yield總結

#一、把函數作成迭代器

#二、對比return，能夠返回屢次值，能夠掛起/保存函數的運行狀態

 

2.7 面向過程編程

2.7.1 定義

#一、首先強調：面向過程編程絕對不是用函數編程這麼簡單，面向過程是一種編程思路、思想，而編程思路是不依賴於具體的語言或語法的。言外之意是即便咱們不依賴於函數，也能夠基於面向過程的思想編寫程序

#二、定義

面向過程的核心是過程二字，過程指的是解決問題的步驟，即先幹什麼再幹什麼

基於面向過程設計程序就比如在設計一條流水線，是一種機械式的思惟方式

#三、優勢：複雜的問題流程化，進而簡單化

#四、缺點：可擴展性差，修改流水線的任意一個階段，都會牽一髮而動全身

#五、應用：擴展性要求不高的場景，典型案例如linux內核，git，httpd

#六、舉例

流水線1：

用戶輸入用戶名、密碼--->用戶驗證--->歡迎界面

流水線2：

用戶輸入sql--->sql解析--->執行功能
定義面向過程編程

2.7.2 舉例

#grep -rl 'python' /etc

#補充：os.walk

# import os

# g=os.walk(r'D:\video\python20期\day4\a')

# # print(next(g))

# # print(next(g))

# # print(next(g))

# # print(next(g))

# for pardir,_,files in g:

#     for file in files:

#         abs_path=r'%s\\%s' %(pardir,file)

#         print(abs_path)

 

 

 

 

#分析一：

 

 

# #第一步：拿到一個文件夾下全部的文件的絕對路徑

# import os

#

# def search(target): #r'D:\video\python20期\day4\a'

#     while True:

#         filepath=yield #fllepath=yield=r'D:\video\python20期\day4\a'

#         g=os.walk(filepath)

#         for pardir, _, files in g:

#             for file in files:

#                 abs_path = r'%s\%s' % (pardir, file)

#                 # print(abs_path)

#                 target.send(abs_path)

#

# # search(r'D:\video\python20期\day4\a')

# # search(r'D:\video\python20期\day4')

#

#

# #第二步：打開文件拿到文件對象f

# def opener():

#     while True:

#         abs_path=yield

#         print('opener func--->',abs_path)

#

#

# target=opener()

# next(target) #target.send('xxxx')

#

# g=search(target)

# next(g)

# g.send(r'D:\video\python20期\day4\a')

 

 

 

 

#分析二：

# 第一步：拿到一個文件夾下全部的文件的絕對路徑

import os

def init(func):

    def inner(*args,**kwargs):

        g=func(*args,**kwargs)

        next(g)

        return g

    return inner

 

@init

def search(target):  # r'D:\video\python20期\day4\a'

    while True:

        filepath = yield

        g = os.walk(filepath)

        for pardir, _, files in g:

            for file in files:

                abs_path = r'%s\%s' % (pardir, file)

                #把abs_path傳給下一個階段

                target.send(abs_path)

 

# 第二步：打開文件拿到文件對象f

@init

def opener(target):

    while True:

        abs_path = yield

        with open(abs_path,'rb') as f:

            #把(abs_path,f)傳給下一個階段

            target.send((abs_path,f))

 

#第三步：讀取f的每一行內容

@init

def cat(target):

    while True:

        abs_path,f=yield

        for line in f:

            #把(abs_path,line)傳給下一個階段

            res=target.send((abs_path,line))

            #知足某種條件，break掉for循環

            if res:

                break

 

#第四步：判斷'python' in line

@init

def grep(target,pattern):

    pattern = pattern.encode('utf-8')

    res=False

    while True:

        abs_path,line=yield res

        res=False

        if pattern in line:

            #把abs_path傳給下一個階段

            res=True

            target.send(abs_path)

 

#第五步：打印文件路徑

@init

def printer():

    while True:

        abs_path=yield

        print('<%s>' %abs_path)

 

g=search(opener(cat(grep(printer(),'python')))) #'python' in b'xxxxx'

g.send(r'D:\video\python20期\day4\a')

 

#面向過程編程：核心是過程二字，過程指的就是解決問題的步驟，即先幹什麼後幹什麼。。。。

#基於該思路編寫程序就比如設計一條流水線，是一種機械式的思惟方式

 

#優勢：複雜的問題流程化、進而簡單化

#缺點：可擴展性差
舉例說明

ps：函數的參數傳入，是函數吃進去的食物，而函數return的返回值，是函數拉出來的結果，面向過程的思路就是，把程序的執行當作一串首尾相連的功能，該功能能夠是函數的形式，而後一個函數吃，拉出的東西給另一個函數吃，另一個函數吃了再繼續拉給下一個函數吃。。。

 

第3章 三元表達式、列表推導式、生成器表達式

3.1 三元表達式

name=input('姓名>>: ')

res='SB' if name == 'alex' else 'NB'

print(res)
實例一：

def my_max(x,y):

    if x >= y:

        return x

    else:

        return y

#以上函數演變爲如下三元表達式：

       

x=10

y=20

 

# res=x if x >= y else y     ===>此爲三元表達式

# print(res)

 

 

實例二：

name=input('>>: ').strip()

 

res='Sb' if name == 'alex' else 'NB'

print(res)
實例

3.2 列表推導式

#一、示例

egg_list=[]

for i in range(10):

    egg_list.append('雞蛋%s' %i)

 

egg_list=['雞蛋%s' %i for i in range(10)]

 

#二、語法

[expression for item1 in iterable1 if condition1

for item2 in iterable2 if condition2

...

for itemN in iterableN if conditionN

]

相似於

res=[]

for item1 in iterable1:

    if condition1:

        for item2 in iterable2:

            if condition2

                ...

                for itemN in iterableN:

                    if conditionN:

                        res.append(expression)

 

#三、優勢：方便，改變了編程習慣，可稱之爲聲明式編程
示例 
#1 列表推導式

# l=[]

# for i in range(1,11):

#     res='egg'+str(i)

#     l.append(res)

#

# print(l)

 

# l=['egg'+str(i) for i in range(1,11)]

# print(l)

 

# l1=['egg'+str(i) for i in range(1,11) if i >= 6]

# print(l1)

 

# l1=[]

# for i in range(1,11):

#     if i >= 6:

#         l1.append('egg'+str(i))
列表推導式

3.3 生成器表達式

#一、把列表推導式的[]換成()就是生成器表達式

#二、示例：生一筐雞蛋變成給你一隻老母雞，用的時候就下蛋，這也是生成器的特性

>>> chicken=('雞蛋%s' %i for i in range(5))

>>> chicken

<generator object <genexpr> at 0x10143f200>

>>> next(chicken)

'雞蛋0'

>>> list(chicken) #因chicken可迭代，於是能夠轉成列表

['雞蛋1', '雞蛋2', '雞蛋3', '雞蛋4',]

#三、優勢：省內存，一次只產生一個值在內存中
#2 生成器表達式

 

# g=('egg'+str(i) for i in range(0,1000000000000000000000000000000000))

# print(g)

# print(next(g))

# print(next(g))

# print(next(g))
生成器表達式實例

3.4 聲明式編程練習題

一、將names=['egon','alex_sb','wupeiqi','yuanhao']中的名字所有變大寫

二、將names=['egon','alex_sb','wupeiqi','yuanhao']中以sb結尾的名字過濾掉，而後保存剩下的名字長度

3、求文件a.txt中最長的行的長度（長度按字符個數算，須要使用max函數）

4、求文件a.txt中總共包含的字符個數？思考爲什麼在第一次以後的n次sum求和獲得的結果爲0？（須要使用sum函數）

5、思考題：

with open('a.txt') as f:

    g=(len(line) for line in f)

print(sum(g)) #爲什麼報錯？

6、文件shopping.txt內容以下：

mac,20000,3

lenovo,3000,10

tesla,1000000,10

chicken,200,1

求總共花了多少錢？

打印出全部商品的信息，格式爲[{'name':'xxx','price':333,'count':3},...]

求單價大於10000的商品信息,格式同上

 

 

題1：

names=['egon','alex_sb','wupeiqi','yuanhao']

 

# names=[name.upper() for name in names]

# print(names)

題2：

names=['egon','alex_sb','wupeiqi','yuanhao']

# sbs=[name for name in names if name.endswith('sb')]

# print(sbs)

題3：

with open('a.txt',encoding='utf-8') as f:

print(max(len(line) for line in f))

題4：

with open('a.txt', encoding='utf-8') as f:

    print(sum(len(line) for line in f))

    print(sum(len(line) for line in f)) #求包換換行符在內的文件全部的字符數，爲什麼獲得的值爲0?

print(sum(len(line) for line in f)) #求包換換行符在內的文件全部的字符數，爲什麼獲得的值爲0?

 

#題目五（略）

 

#題目六：每次必須從新打開文件或seek到文件開頭，由於迭代完一次就結束了

with open('a.txt',encoding='utf-8') as f:

    info=[line.split() for line in f]

    cost=sum(float(unit_price)*int(count) for _,unit_price,count in info)

    print(cost)

 

 

with open('a.txt',encoding='utf-8') as f:

    info=[{

        'name': line.split()[0],

        'price': float(line.split()[1]),

        'count': int(line.split()[2]),

    } for line in f]

    print(info)

 

 

with open('a.txt',encoding='utf-8') as f:

    info=[{

        'name': line.split()[0],

        'price': float(line.split()[1]),

        'count': int(line.split()[2]),

    } for line in f if float(line.split()[1]) > 10000]

    print(info)
聲明式編程練習題

3.5 遞歸與二分法

3.5.1 遞歸調用的定義

#遞歸調用是函數嵌套調用的一種特殊形式，函數在調用時，直接或間接調用了自身，就是遞歸調用

3.5.2 遞歸分爲兩個階段：遞推，回溯

#遞歸必備的兩個階段：一、遞推  二、回溯

 

# import sys

# print(sys.getrecursionlimit())

# sys.setrecursionlimit(2000)

# print(sys.getrecursionlimit())

 

# def func(n):

#     print('---->',n)

#     func(n+1)

#

# func(0)

 

 

# def bar():

#     print('from bar')

#     func()

#

# def func():

#     print('from func')

#     bar()

#

# func()

 

 

# age(5) = age(4) + 2

# age(4) = age(3) + 2

# age(3) = age(2) + 2

# age(2) = age(1) + 2

#

# age(1) = 18

 

# age(n)=age(n-1)+2 # n > 1

# age(1) = 18 #n = 1

 

 

# def age(n):

#     if n == 1:

#         return 18

#     return age(n-1) + 2

#

# res=age(5)

# print(res)

 

 

# l=[1,[2,[3,[4,[5,[6,[7,]]]]]]]

#

#

# def func(l):

#     for item in l:

#         if type(item) is list:

#             func(item)

#         else:

#             print(item)

 

 

 

# def func():

#     print('===>')

#     func()

#

# func()
遞歸回溯實例 
#圖解。。。

# salary(5)=salary(4)+300

# salary(4)=salary(3)+300

# salary(3)=salary(2)+300

# salary(2)=salary(1)+300

# salary(1)=100

#

# salary(n)=salary(n-1)+300     n>1

# salary(1) =100                n=1

 

def salary(n):

    if n == 1:

        return 100

    return salary(n-1)+300

 

print(salary(5))
View Code

3.5.3 python中的遞歸效率低且沒有尾遞歸優化

#python中的遞歸

python中的遞歸效率低，須要在進入下一次遞歸時保留當前的狀態，在其餘語言中能夠有解決方法：尾遞歸優化，即在函數的最後一步（而非最後一行)調用本身，尾遞歸優化：http://egon09.blog.51cto.com/9161406/1842475

可是python又沒有尾遞歸，且對遞歸層級作了限制

#總結遞歸的使用：

1. 必須有一個明確的結束條件

2. 每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減小

3. 遞歸效率不高，遞歸層次過多會致使棧溢出（在計算機中，函數調用是經過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。因爲棧的大小不是無限的，因此，遞歸調用的次數過多，會致使棧溢出）
python中的遞歸

3.5.4 能夠修改遞歸最大深度

import sys

sys.getrecursionlimit()

sys.setrecursionlimit(2000)

n=1

def test():

    global n

    print(n)

    n+=1

    test()

 

test()

雖然能夠設置，可是由於不是尾遞歸，仍然要保存棧，內存大小必定，不可能無限遞歸
修改遞歸最大深度

3.6 二分法

想從一個按照從小到大排列的數字列表中找到指定的數字，遍歷的效率過低，用二分法（算法的一種，算法是解決問題的方法）能夠極大低縮小問題規模

3.6.1 實現相似於in的效果

l=[1,2,10,30,33,99,101,200,301,402] #從小到大排列的數字列表

 

def search(num,l):

    print(l)

    if len(l) > 0:

        mid=len(l)//2

        if num > l[mid]:

            #in the right

            l=l[mid+1:]

        elif num < l[mid]:

            #in the left

            l=l[:mid]

        else:

            print('find it')

            return

        search(num,l)

    else:

        #若是值不存在，則列表切爲空

        print('not exists')

        return

search(100,l)
實現相似於in的效果

3.6.2 實現相似於l.index(30)的效果

l=[1,2,10,30,33,99,101,200,301,402]

 

def search(num,l,start=0,stop=len(l)-1):

    if start <= stop:

        mid=start+(stop-start)//2

        print('start:[%s] stop:[%s] mid:[%s] mid_val:[%s]' %(start,stop,mid,l[mid]))

        if num > l[mid]:

            start=mid+1

        elif num < l[mid]:

            stop=mid-1

        else:

            print('find it',mid)

            return

        search(num,l,start,stop)

    else: #若是stop > start則意味着列表實際上已經所有切完，即切爲空

        print('not exists')

        return

 

search(301,l)
實現相似於i.index（30）的效果

3.6.3 小練習

#瞭解的知識點

l=[1,2,10,30,33,99,101,200,301,402] #從小到大排列的數字列表

 

def binary_search(l,num):

    print(l)

    if len(l) == 0:

        print('not exists')

        return

    mid_index=len(l) // 2

    if num > l[mid_index]:

        #往右找

        binary_search(l[mid_index+1:],num)

 

    elif num < l[mid_index]:

        #往左找

        binary_search(l[0:mid_index],num)

    else:

        print('find it')

 

# binary_search(l,301)

binary_search(l,302)
瞭解的知識點

第4章 匿名函數與內置函數

4.1 什麼是匿名函數？

匿名就是沒有名字

def func(x,y,z=1):

    return x+y+z

 

匿名

lambda x,y,z=1:x+y+z #與函數有相同的做用域，可是匿名意味着引用計數爲0，使用一次就釋放，除非讓其有名字

func=lambda x,y,z=1:x+y+z

func(1,2,3)

#讓其有名字就沒有意義
匿名函數的含義

4.2 有名字的函數與匿名函數的對比

#有名函數與匿名函數的對比

有名函數：循環使用，保存了名字，經過名字就能夠重複引用函數功能

匿名函數：一次性使用，隨時隨時定義

應用：max，min，sorted,map,reduce,filter

4.3 實例

# def func(): #func=內存地址

#     print('from func')

#

# func()

# func()

 

 

# 內存地址

# def my_sum(x,y):

#     return x+y

 

# print(lambda x,y:x+y)

# print((lambda x,y:x+y)(1,2))

 

# func=lambda x,y:x+y

# # print(func)

# print(func(1,2))

 

 

#max，min，sorted,map,reduce,filter

# salaries={

#     'egon':3000,

#     'alex':100000000,

#     'wupeiqi':10000,

#     'yuanhao':2000

# }

# print(max(salaries))

 

# s='hello'

# l=[1,2,3]

# g=zip(s,l)

# # print(g)

# print(list(g))

 

# g=zip(salaries.values(),salaries.keys())

# # print(list(g))

# print(max(g))

 

# def func(k):

#     return salaries[k]

 

# print(max(salaries,key=func)) #key=func('egon')

 

# print(max(salaries,key=lambda k:salaries[k])) #key=func('egon')

# print(min(salaries,key=lambda k:salaries[k])) #key=func('egon')

 

 

 

 

 

 

#sorted

# salaries={

#     'egon':3000,

#     'alex':100000000,

#     'wupeiqi':10000,

#     'yuanhao':2000

# }

# print(sorted(salaries,key=lambda k:salaries[k]))

# print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

 

 

#map,reduce,filter

# names=['alex','wupeiqi','yuanhao']

# l=[]

# for name in names:

#     res='%s_SB' %name

#     l.append(res)

#

# print(l)

 

# g=map(lambda name:'%s_SB' %name,names)

# # print(g)

# print(list(g))

 

 

# names=['alex_sb','wupeiqi_sb','yuanhao_sb','egon']

# g=filter(lambda x:x.endswith('sb'),names)

# print(g)

# print(list(g))

 

 

 

from functools import reduce

print(reduce(lambda x,y:x+y,range(1,101),100))
實例

4.4 內置函數

#注意：內置函數id()能夠返回一個對象的身份，返回值爲整數。這個整數一般對應與該對象在內存中的位置，但這與python的具體實現有關，不該該做爲對身份的定義，即不夠精準，最精準的仍是之內存地址爲準。is運算符用於比較兩個對象的身份，等號比較兩個對象的值，內置函數type()則返回一個對象的類型

#更多內置函數：https://docs.python.org/3/library/functions.html?highlight=built#ascii

 

 

4.4.1 format(瞭解便可)

#字符串能夠提供的參數 's' None

>>> format('some string','s')

'some string'

>>> format('some string')

'some string'

 

#整形數值能夠提供的參數有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None

>>> format(3,'b') #轉換成二進制

'11'

>>> format(97,'c') #轉換unicode成字符

'a'

>>> format(11,'d') #轉換成10進制

'11'

>>> format(11,'o') #轉換成8進制

'13'

>>> format(11,'x') #轉換成16進制 小寫字母表示

'b'

>>> format(11,'X') #轉換成16進制 大寫字母表示

'B'

>>> format(11,'n') #和d同樣

'11'

>>> format(11) #默認和d同樣

'11'

 

#浮點數能夠提供的參數有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None

>>> format(314159267,'e') #科學計數法，默認保留6位小數

'3.141593e+08'

>>> format(314159267,'0.2e') #科學計數法，指定保留2位小數

'3.14e+08'

>>> format(314159267,'0.2E') #科學計數法，指定保留2位小數，採用大寫E表示

'3.14E+08'

>>> format(314159267,'f') #小數點計數法，默認保留6位小數

'314159267.000000'

>>> format(3.14159267000,'f') #小數點計數法，默認保留6位小數

'3.141593'

>>> format(3.14159267000,'0.8f') #小數點計數法，指定保留8位小數

'3.14159267'

>>> format(3.14159267000,'0.10f') #小數點計數法，指定保留10位小數

'3.1415926700'

>>> format(3.14e+1000000,'F')  #小數點計數法，無窮大轉換成大小字母

'INF'

 

#g的格式化比較特殊，假設p爲格式中指定的保留小數位數，先嚐試採用科學計數法格式化，獲得冪指數exp，若是-4<=exp<p，則採用小數計數法，並保留p-1-exp位小數，不然按小數計數法計數，並按p-1保留小數位數

>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點

'3e-05'

>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留1位小數點

'3.1e-05'

>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留2位小數點

'3.14e-05'

>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，E使用大寫

'3.14E-05'

>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留0位小數點

'3'

>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留1位小數點

'3.1'

>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留2位小數點

'3.14'

>>> format(0.00003141566,'.1n') #和g相同

'3e-05'

>>> format(0.00003141566,'.3n') #和g相同

'3.14e-05'

>>> format(0.00003141566) #和g相同

'3.141566e-05'
format(瞭解便可)

4.4.2 ！！！lambda與內置函數結合使用！！！

字典的運算：最小值，最大值，排序
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

迭代字典，取得是key，於是比較的是key的最大和最小值
>>> max(salaries)
'yuanhao'
>>> min(salaries)
'alex'

能夠取values，來比較
>>> max(salaries.values())
>>> min(salaries.values())
但一般咱們都是想取出，工資最高的那我的名，即比較的是salaries的值，獲得的是鍵
>>> max(salaries,key=lambda k:salary[k])
'alex'
>>> min(salaries,key=lambda k:salary[k])
'yuanhao'



也能夠經過zip的方式實現
salaries_and_names=zip(salaries.values(),salaries.keys())

先比較值，值相同則比較鍵
>>> max(salaries_and_names)
(100000000, 'alex')


salaries_and_names是迭代器，於是只能訪問一次
>>> min(salaries_and_names)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: min() arg is an empty sequence



sorted(iterable，key=None,reverse=False)
lambda與內置函數結合使用

4.4.3 eval與exec

#一、語法
# eval(str,[,globasl[,locals]])
# exec(str,[,globasl[,locals]])

#二、區別
#示例一：
s='1+2+3'
print(eval(s)) #eval用來執行表達式，並返回表達式執行的結果
print(exec(s)) #exec用來執行語句，不會返回任何值
'''
6
None
'''

#示例二：
print(eval('1+2+x',{'x':3},{'x':30})) #返回33
print(exec('1+2+x',{'x':3},{'x':30})) #返回None

# print(eval('for i in range(10):print(i)')) #語法錯誤，eval不能執行表達式
print(exec('for i in range(10):print(i)'))
eval與exec

4.4.4 complie（瞭解便可）

compile(str,filename,kind)

filename:用於追蹤str來自於哪一個文件，若是不想追蹤就能夠不定義

kind能夠是：single表明一條語句，exec表明一組語句，eval表明一個表達式

s='for i in range(10):print(i)'

code=compile(s,'','exec')

exec(code)

 

 

s='1+2+3'

code=compile(s,'','eval')

eval(code)
complie(瞭解)

4.5 階段性練習

1、文件內容以下,標題爲:姓名,性別,年紀,薪資

egon male 18 3000

alex male 38 30000

wupeiqi female 28 20000

yuanhao female 28 10000

要求:

從文件中取出每一條記錄放入列表中,

列表的每一個元素都是{'name':'egon','sex':'male','age':18,'salary':3000}的形式

2 根據1獲得的列表,取出薪資最高的人的信息

3 根據1獲得的列表,取出最年輕的人的信息

4 根據1獲得的列表,將每一個人的信息中的名字映射成首字母大寫的形式

5 根據1獲得的列表,過濾掉名字以a開頭的人的信息

6 使用遞歸打印斐波那契數列(前兩個數的和獲得第三個數，如：0 1 1 2 3 4 7...)

7 一個嵌套不少層的列表，如l=［1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]］，用遞歸取出全部的值
#1

with open('db.txt') as f:

    items=(line.split() for line in f)

    info=[{'name':name,'sex':sex,'age':age,'salary':salary} \

          for name,sex,age,salary in items]

 

print(info)

#2

print(max(info,key=lambda dic:dic['salary']))

 

#3

print(min(info,key=lambda dic:dic['age']))

 

# 4

info_new=map(lambda item:{'name':item['name'].capitalize(),

                          'sex':item['sex'],

                          'age':item['age'],

                          'salary':item['salary']},info)

 

print(list(info_new))

 

#5

g=filter(lambda item:item['name'].startswith('a'),info)

print(list(g))

 

#6

#非遞歸

def fib(n):

    a,b=0,1

    while a < n:

        print(a,end=' ')

        a,b=b,a+b

    print()

 

fib(10)

#遞歸

def fib(a,b,stop):

    if  a > stop:

        return

    print(a,end=' ')

    fib(b,a+b,stop)

 

fib(0,1,10)

 

 

#7

l=[1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]]

 

def get(seq):

    for item in seq:

        if type(item) is list:

            get(item)

        else:

            print(item)

get(l)
答案

第5章 做業

做業需求：

模擬實現一個ATM + 購物商城程序

額度 15000或自定義

實現購物商城，買東西加入 購物車，調用信用卡接口結帳

能夠提現，手續費5%

每個月22號出帳單，每個月10號爲還款日，過時未還，按欠款總額 萬分之5 每日計息

支持多帳戶登陸

支持帳戶間轉帳

記錄每個月平常消費流水

提供還款接口

ATM記錄操做日誌

提供管理接口，包括添加帳戶、用戶額度，凍結帳戶等。。。

用戶認證用裝飾器

示例代碼 https://github.com/triaquae/py3_training/tree/master/atm　

簡易流程圖：https://www.processon.com/view/link/589eb841e4b0999184934329

 
做業要求：

下週五中午十二點以前交：

1，本週博客。

2，做業流程圖。

3，實現做業中任意五個功能

做業位置：http://www.cnblogs.com/linhaifeng/articles/7532512.html

預習博客是在本次做業博客的下一篇！但願各位利用元旦假期的時間，複習以前的知識，預習下週要講的東西，你們加油，爭取用最短的時間拿下python

 

 

####簡易流程圖

 

####說明

ATM.py爲核心代碼文件

其餘爲引用寫入文件（商城商品列表文件shoplist.txt，帳戶餘額usercardmoney.txt，信用卡登錄帳號userinfo.txt，信用卡消費記錄xiaofeilist.txt）

#!/usr/bin/python
# --*-- coding:utf-8 --*--
import time#引入時間模塊
import datetime#引入日期小時


'''
各類全局變量、與全局參數
'''
tempusercardmoney = []#定義用戶信用卡臨時消費總額度的列表
f9 = open('usercardmoney.txt','r',encoding='utf-8')#只讀打開用戶消費信用卡總額度文件
for p in f9.readlines():#讀取用戶消費信用卡總額度文件中每行內容
    tempusercardmoney.append(p)#讀取用戶消費信用卡總額度文件中每行內容，到用戶信用卡臨時消費總額度的列表，對用戶查詢用戶可用額度有用
    #print p
    f9.close()
    #print int(tempusercardmoney[0])
    inittotalmoney = int(tempusercardmoney[0])#從用戶信用卡臨時消費總額度的列表的第一個元素，把數據變成整形數據，賦值初始總可用額度
    shishitotalmoney = []#實時變化的總餘額列表
    shishitotalmoney.append(inittotalmoney)#把初始總可用額度值增長到實時消費總額度的列表中
    shouxufei = []#總手續費變化列表
    jiamoney = []#金錢增長的列表
    jianmoney = []#金錢減小的列表
    buyshop = []#消費商場購物購買的商品


'''
讀取當前系統的時間
'''
def curtime():
    #now = int(time.time())
    now = datetime.datetime.now()#獲取當前時間時分秒
    otherstyletime = now.strftime('%Y-%m-%d %H:%M:%S')#顯示當前時間的時分秒
    #print otherstyletime
    return otherstyletime#返回當前時間的時分秒

'''
查詢帳單要求：全部用戶共享一個xiaofeilist.txt文件，用戶查詢只顯示當前用戶帳單信息，
還款記錄在日誌中高亮顯示出來，用戶查詢顯示收入、支出和消費總額(此條未實現)
'''
def searchbill():
    gudingedu = 15000#固定總額度
    bl_hktotalmoney = gudingedu - shishitotalmoney[-1]#帳單還款總額度等於固定總額度減去實時花費的總額度
    bl_min_hktotalmoney = bl_hktotalmoney*0.01#最低還款額度等於帳單還款總額度的百分之一
    print('信用卡總額度爲15000￥,信用卡可用額度爲%d,本期還款總額爲%d，本期最低還款額度爲%d' %(shishitotalmoney[-1],bl_hktotalmoney,bl_min_hktotalmoney))
    print('-'*79)
    bl_file = open('xiaofeilist.txt','r',encoding='utf-8')#只讀打開消費清單文件
    for p in bl_file.readlines():#讀取消費清單文件中每行內容
        print(p)
        bl_file.close()

'''
消費商城要求：
一、產品及產品價格
二、消費後扣除價格：判斷帳戶餘額是否足夠，將消費記錄寫入xiaofeilist.txt帳單
'''
def buy():#消費商城
    products = []#定義能夠購買商品名稱的列表
    prices = []#定義能夠購買商品價格的列表
    xf_money = 0#初始商品的價格
    xf_date = []#定義消費購物清單列表
    f_shoplist = open('shoplist.txt','r',encoding='utf-8')#只讀方式打開商城能夠購買的商品文件
    for p in f_shoplist.readlines():#每行數據讀取
        new_p = p.split()#對商城能夠購買的商品文件中每一個元素進行空格分割
        products.append(new_p[0])#把每行讀取的元素第一個值賦值給購買商品名稱的列表
        prices.append(new_p[1])#把每行讀取的元素第二個值賦值給購買商品價格的列表
    print(products)
    print(prices)
    while True:
        choice = input('請輸入要購買的產品：')#輸入須要購買的商品名稱
        f_choice = choice.strip()#對輸入的商品名稱進行整塊先後空格過濾
        #print f_choice
        if f_choice != 'q':#若是輸入不是字母q，則進入
            if f_choice in products:#若是輸入商品名稱在能夠購買商品名稱的列表中，則進入
                #print products.index(f_choice)#能夠購買的商品在能夠購買商品名稱的列表中索引編號
                xf_money = int(prices[products.index(f_choice)])#利用能夠購買的商品在能夠購買商品名稱的列表中索引編號，來定位對應的價格，爲整形
                #print type(xf_money)#打印類型
                #print shishitotalmoney[-1]#打印實時變化的且可用的餘額
                if xf_money <= shishitotalmoney[-1] and shishitotalmoney[-1] > 0:#輸入的商品價格小於可用餘額，並可用餘額大於0
                    buyshop.append(f_choice)#把成功購買的商品加入全局的購物清單中
                    jianmoney.append(xf_money)#把成功購買的商品價格增長到全局的減金額的列表中
                    curtime()#引入當前時間函數，查看當前交易時間
                    xf_date.append(curtime())#把當前交易時間增長到消費購物清單列表
                    xf_date.append(str(f_choice))#把成功購買的商品增長到消費購物清單列表
                    xf_date.append(str(xf_money))#把成功購買商品價格增長到消費購物清單列表
                    xf_date.append('0')#把購物手續費0元增長到消費購物清單列表
                    #print xf_date
                    #print buyshop,jianmoney
                    print('恭喜你購買了%s' %f_choice)
                    creditcardmoneyleft()#引入總餘額函數，查看當前能夠餘額,必須放到減金額列表才能實時查看餘額
                    f7 = open('xiaofeilist.txt','a+',encoding='utf-8')#使用追加寫入的方式打開消費清單文件
                    f7.write(xf_date[-4])#把交易時間列表中倒數第4個元素寫入消費清單中
                    f7.write('\t')#把一個tab寫入消費清單中
                    f7.write('購買：')#寫入‘購買’說明信息
                    f7.write(xf_date[-3])#把交易時間列表中倒數第三個元素寫入消費清單中
                    f7.write('\t')
                    f7.write(xf_date[-2])#把交易時間列表中倒數第二個元素寫入消費清單中
                    f7.write('\t\t')
                    f7.write(xf_date[-1])#把交易時間列表倒數中第一個元素寫入消費清單中
                    f7.write('\n')
                    f7.close()
                else:
                    print('餘額不足！請存入足夠的金額進行購買!按q鍵退出購物！')
            else:
                print('你購買的商品，商鋪清單沒有！請選擇商鋪存在的物品！')
        else:
            print('你購買的清單以下：')
            print(buyshop)
            break#退出該函數模塊

'''
存款要求：額度不能低於100,額度不能高於2000,必須爲100的整數倍，
存款金額只能爲數字爲字母時會提示，將該筆寫入xiaofeilist.txt帳單
'''
def deposit():#存款
    ck_totalmoney = 0#初始存款的總金額
    ck_shouxufei = 0#初始存款的手續費金額
    ck_date = []#定義交易時間列表
    while True:
        ck_money = int(input('額度不低於100，不高於2000，必須爲100整數倍，請輸入你要存款的金額：'))#輸入存款金額
        if ck_money%100 == 0:#存款金額爲100的整數倍
            if ck_money > 99 and ck_money < 2001:#存款金額不低於100,不高於2000
                curtime()#引入當前時間函數，計算當前存款的時間
                ck_date.append(curtime())#把當前時間值加入交易時間列表中
                ck_date.append(str(ck_money))#把當前輸入的存款金額轉換成字符存入交易時間列表中
                ck_date.append(str(ck_shouxufei))#把當前輸入存款的手續費金額轉換成字符存入交易時間列表中
                print('你存入的金額爲%d' % ck_money)
                jiamoney.append(ck_money)#把存款金額加入金錢增長的列表
                creditcardmoneyleft()#引入總餘額函數，查看當前能夠餘額,必須放到加金額列表才能實時查看餘額
                f6 = open('xiaofeilist.txt','a+',encoding='utf-8')#使用追加寫入的方式打開消費清單文件
                f6.write(ck_date[0])#把交易時間列表中第一個元素寫入消費清單中
                f6.write('\t')#把一個tab寫入消費清單中
                f6.write('存款')#寫入‘存款’說明信息
                f6.write('\t\t')
                f6.write(ck_date[1])#把交易時間列表中第二個元素寫入消費清單中
                f6.write('\t\t')
                f6.write(ck_date[2])#把交易時間列表中第三個元素寫入消費清單中
                f6.write('\n')
                f6.close()
                break#退出該函數模塊
            else:
                print('你輸入的存款金額不能低於100元,不能高於2000元！')
        else:
            print('輸入的存款金額不爲100的整數倍，請輸入100整數倍！')


'''
取款要求：額度不能低於100,額度不能高於2000,必須爲100的整數倍，扣除% 5的手續費，
取現額度不能超過餘額，取款金額只能爲數字爲字母時會提示，將該筆記錄寫入xiaofeilist.txt帳單
'''
def withdraw():#取款
    qk_totalmoney = 0#初始取款的總金額
    qu_shouxufei = 0#初始取款的手續費
    qk_date = []#定義交易時間列表
    while True:
        qk_money = int(input('取款金額不低於100元，不高於2000元，爲100整數倍，請輸入取款金額：'))#輸入取款金額
        if qk_money < shishitotalmoney[-1] and shishitotalmoney[-1] > 0 and qk_money > 0:#取款金額小於總可用餘額，總可用餘額大於0,取款金額大於0
            print(shishitotalmoney[-1])
            if qk_money%100 == 0:#取款金額爲100的整數倍
                if qk_money > 99 and qk_money < 2001:#取款金額不低於100,不高於2000
                    qk_shouxufei = qk_money * 0.05#計算取款手續費
                    qk_totalmoney = qk_money + qk_shouxufei#取款總金額
                    curtime()#引入當前時間函數
                    qk_date.append(curtime())#把當前時間值加入交易時間列表中
                    qk_date.append(str(qk_totalmoney))#把當前輸入的取款金額轉換成字符存入交易時間列表中
                    qk_date.append(str(qk_shouxufei))#把當前輸入取款的手續費金額轉換成字符存入交易時間列表中
                    jianmoney.append(qk_money)#把取款金額加入金錢減小的列表
                    shouxufei.append(qk_shouxufei)#把手續費金額加入金錢減小的列表
                    #print qk_date[1],qk_date[2]
                    print('取款實際金額爲%d元，手續費爲%d元，總取款花費金額爲%d元' %(qk_money,qk_shouxufei,qk_totalmoney))
                    creditcardmoneyleft()#引入總餘額函數，查看當前能夠餘額,必須放到減金額列表才能實時查看餘額
                    f5 = open('xiaofeilist.txt','a+',encoding='utf-8')#使用追加寫入的方式打開消費清單文件
                    f5.write(qk_date[0])#把交易時間列表中第一個元素寫入消費清單中
                    f5.write('\t')
                    f5.write('取款')
                    f5.write('\t\t')
                    f5.write(qk_date[1])#把交易時間列表中第二個元素寫入消費清單中
                    f5.write('\t\t')
                    f5.write(qk_date[2])#把交易時間列表中第三個元素寫入消費清單中
                    f5.write('\n')
                    f5.close()
                    break#退出該函數模塊
                else:
                    print('你輸入的取款金額不能低於100元,不能高於2000元！')
            else:
                print('輸入的取款金額不爲100的整數倍，請輸入100整數倍！')
        else:
            print('你輸入的取款金額超過總餘額，請從新輸入大於0的金額!')

'''
查詢當前帳戶可用餘額
'''
def creditcardmoneyleft():#查詢當前可用餘額
        zhengtotalmoney = 0#初始正符號的總金額
        futotalmoney = 0#初始負符號的總金額
        jiatotalmoney = []#定義加的總金額的列表
        jiantotalmoney = []#定義減的總金額的列表
        for p in range(len(shouxufei)):#遍歷手續費列表中全部元素
            #print shouxufei[p]
            jiantotalmoney.append(shouxufei[p])#把手續費的每一個元素增長到‘減的總金額列表’中
        for m in range(len(jianmoney)):#遍歷減金額列表中全部元素
            #print jianmoney[m]
            jiantotalmoney.append(jianmoney[m])##把減金額的每一個元素增長到‘減的總金額列表’中
        for n in range(len(jiamoney)):#遍歷加金額列表中全部元素
            #print jiamoney[n]
            jiatotalmoney.append(jiamoney[n])#把加金額的每一個元素增長到‘加的總金額列表’中
        for i in range(len(jiatotalmoney)):#遍歷加的金額列表中全部元素
            #print jiatotalmoney[i]
            zhengtotalmoney = zhengtotalmoney + jiatotalmoney[i]#計算正符號金額總額
        for j in range(len(jiantotalmoney)):#遍歷減的金額列表中全部元素
            #print jiantotalmoney[j]
            futotalmoney = futotalmoney + jiantotalmoney[j]#計算負符號金額總額
        totalmoney = inittotalmoney + zhengtotalmoney - futotalmoney#計算總餘額
        shishitotalmoney.append(totalmoney)#把實時變化的總餘額增長到shishitotalmoney列表中
        f8 = open('usercardmoney.txt','w',encoding='utf-8')#寫入方式打開用戶消費信用卡總額度文件
        f8.write(str(int(totalmoney)))#總金額變成整形數據，而後變成字符類型寫入用戶消費信用卡總額度文件
        f8.close()
        print('-'*31)
        print('你的總可用的餘額爲%d' %totalmoney)
        print('-'*31)


'''
修改密碼要求：舊密碼驗證後才能提示修改新密碼
新密碼需輸入兩次。兩次相同便可經過
密碼長度必須在6位以上
'''
def modpassword():
    pd_oldtmp = []#定義臨時修改舊密碼列表
    pd_old = input('請輸入信用卡的舊的密碼：')#輸入舊密碼
    f3 = open('userinfo.txt','r',encoding='utf-8')#只讀打開用戶信息文件
    for p in f3.readlines():#每行讀取用戶信息文件內容
        new_p = p.split()[1]#對用戶信息文件中元素使用空格分割，並把第二個元素值賦值給new_p
    #print new_p
    pd_oldtmp.append(new_p)#把賦值給new_p的值增長到臨時修改舊密碼列表中
    if pd_old == pd_oldtmp[0]:#若是輸入舊密碼與存入臨時修改舊密碼列表中第一個元素值相等，則進入
        moduser = []#定義修改用戶列表
        modpd = []#定義修改密碼列表
        moduserinfo = []#定義修改用戶、密碼列表
        f1 = open('userinfo.txt','r',encoding='utf-8')#只讀打開用戶信息文件
        #print type(f1)
        for p in f1.readlines():#每行讀取用戶信息文件內容
            new_p = p.split()#對用戶信息文件中元素使用空格分割，並把每一個元素值循環賦值給new_p
            moduser.append(new_p[0])#把取到的第一個元素增長到修改用戶列表中
            modpd.append(new_p[1])#把取到的第二個元素增長到修改用戶列表中
            f1.close()
            #print moduser,modpd
            moduserinfo.append(moduser[0])#把修改用戶的第一個元素值增長到‘修改用戶、密碼列表’中
            moduserinfo.append(modpd[0])#把修改密碼的第一個元素值增長到’修改用戶、密碼列表‘中
            pd_new1 = input('請輸入新信用卡密碼，至少6位以上：')#第一次輸入的密碼值
            pd_new2 = input('請再次輸入新信用卡密碼，至少6位以上：')#第二次輸入的密碼值
            if pd_new1 == pd_new2:#若是第一次輸入的密碼值與第二次輸入的密碼值相等，則進入
                #print moduserinfo
                moduserinfo[1] = pd_new1#把第一次輸入的密碼值賦值到‘修改用戶、密碼列表’中第二個元素
                #print moduserinfo
                f1 = open('userinfo.txt','w',encoding='utf-8')#寫入模塊打開用戶信息文件
                f1.write('')#把用戶信息文件全部內容清空
                f1.close()
                f2 = open('userinfo.txt','a+',encoding='utf-8')#追加寫入模式打開用戶信息文件
                f2.write(moduserinfo[0])#把修改用戶、密碼列表’中第一個元素用戶寫入用戶信息文件中
                f2.write('\t')
                f2.write(moduserinfo[1])#把修改用戶、密碼列表’中第二個元素用戶寫入用戶信息文件中
                f2.close()
                print('恭喜您！信用卡密碼修改爲功！')
            else:
                print('你輸入的兩次新的信用卡密碼不相同！請從新輸入！')
    else:
        print('你輸入的信用卡密碼錯誤，請從新輸入！')

'''
轉帳要求：額度不能低於100元，額度不能高於20000元
必須爲100的整數倍，扣除手續費10%
將該筆記錄寫入帳單中
'''
def tranfer():
    tr_totalmoney = 0#初始轉帳總金額
    tr_shouxufei = 0#初始轉帳手續費
    tr_date = []#定義轉帳交易時間清單列表
    while True:
        tr_money = int(input('轉帳金額不低於100元，不高於2000元，爲100整數倍，請輸入轉帳金額：'))#輸入轉帳金額
        if tr_money < shishitotalmoney[-1] and shishitotalmoney[-1] > 0 and tr_money > 0:#轉帳金額小於總餘額，總餘額與轉帳金額必須大於0
            if tr_money%100 == 0:#轉帳金額爲100整數倍
                if tr_money > 99 and tr_money < 2001:#轉帳金額大於100,不高於2000
                    tr_shouxufei = tr_money*0.1#計算轉帳手續費
                    tr_totalmoney = tr_money + tr_shouxufei#計算轉帳總金額
                    curtime()#引入當前交易時間函數
                    tr_date.append(curtime())#增長當前時間到轉帳交易時間清單列表中
                    tr_date.append(str(tr_totalmoney))#增長轉帳總金額到轉帳交易時間清單列表中
                    tr_date.append(str(tr_shouxufei))##增長轉帳手續費到轉帳交易時間清單列表中
                    #print tr_date[1],tr_date[2]
                    jianmoney.append(tr_money)#把轉帳金額增長到加金額列表中
                    shouxufei.append(tr_shouxufei)#把轉帳手續費增長到手續費列表中
                    print('轉帳實際金額爲%d元，手續費爲%d元，總轉帳金額花費爲%d元' %(tr_money,tr_shouxufei,tr_totalmoney))
                    creditcardmoneyleft()#引入總餘額函數，查看當前能夠餘額,必須放到減金額列表才能實時查看餘額
                    f4 = open('xiaofeilist.txt','a+',encoding='utf-8')#追加寫入方式打開消費清單文件
                    f4.write(tr_date[0])#把轉帳交易時間清單列表中第一個元素寫入消費清單文件中
                    f4.write('\t')
                    f4.write('轉帳')
                    f4.write('\t\t')
                    f4.write(tr_date[1])##把轉帳交易時間清單列表中第二個元素寫入消費清單文件中
                    f4.write('\t\t')
                    f4.write(tr_date[2])#把轉帳交易時間清單列表中第三個元素寫入消費清單文件中
                    f4.write('\n')#換行寫入
                    f4.close()
                    break#退出該函數模塊
                else:
                    print('你輸入的轉帳金額不能低於100元,不能高於2000元！')
            else:
                print('輸入的轉帳金額不爲100的整數倍，請輸入100整數倍！')
        else:
            print('你輸入的轉帳金額超過總餘額，請從新輸入大於0的金額!')

def gongneng():#選擇的業務功能模塊
    print('''
    請選擇操做的業務：(輸入q退出系統)
     (1) 消費商城購物
     (2) 查詢餘額
     (3) 存款
     (4) 取款
     (5) 轉帳
     (6) 查詢帳單
     (7) 修改密碼
     ''')
    while True:
        choice = input('請輸入須要操做業務編號：')
        f_choice = choice.strip() #除去空格
        if f_choice != 'q':
            if f_choice != ''or f_choice ==1 or f_choice ==2 or f_choice ==3 or f_choice ==4 or f_choice ==6 or f_choice ==7:
                if f_choice == '1':
                    buy()
                elif f_choice == '2':
                    creditcardmoneyleft()
                elif f_choice == '3':
                    deposit()
                elif f_choice == '4':
                    withdraw()
                elif f_choice == '5':
                    tranfer()
                elif f_choice == '6':
                    searchbill()
                elif f_choice == '7':
                    modpassword()
            else:
                continue
        else:
            print('你已經退出中國銀行ATM取款系統！歡迎下次光臨！')
            exit()

'''
多個帳戶（未實現）/單個帳戶登陸驗證，密碼輸入超過三次錯誤凍結賬號30秒
'''
while True:
    counttime = 5#初始鎖定時間值
    count = 3#初始初始次數
    user = []#定義用戶列表
    pd = []#定義密碼列表
    file = open('userinfo.txt','r+',encoding='utf-8')#只讀打開用戶信息文件
    for p in file.readlines():#每行讀取用戶信息文件
        new_p = p.split()#把每一個元素空格分割，並循環賦值給new_p
        user.append(new_p[0])#把new_p取到的第一個元素增長到用戶列表中
        pd.append(new_p[1])#把new_p取到的第二個元素增長到用戶列表中
        file.close()
        #print user[0],pd[0]
        creditcard = input('請輸入信用卡卡號：')#輸入用戶信用卡信息
        #f_creditcard = creditcard.strip()
        if creditcard == user[0]:#若是輸入用戶信用卡信息與用戶列表中第一個元素相等，則進入
            creditcardpd = pd[0]#把密碼列表中第一個元素賦值給creditcardpd
            while True:
                if count != 0:#若是鎖定次數不等於0，初始值爲3，則進入
                    creditcardpassword = input('請輸入信用卡密碼：')#輸入用戶密碼
                    #f_creditcardpassword = creditcardpassword.strip()
                    if creditcardpassword != creditcardpd:#若是不想等，則進入
                        count -= 1#每次循環遞減1次
                        print('輸入的密碼不對，還有%d次機會，請從新輸入密碼' %count)
                    else:
                        print('恭喜你！歡迎進入中國銀行ATM取款系統！')
                        curtime()#引入當前時間函數
                        gongneng()#引入業務功能函數
                else:
                    print('對不起，你輸入密碼錯誤次數已達到3次，將鎖定5秒！')
                    timeseconds = 0#設置鎖定時間值，鎖定功能,倒計時
                    while (counttime != timeseconds):#鎖定時間參數不等於設置鎖定時間值，則進入
                        time.sleep(1)#5秒倒計時
                        counttime -= 1#每次減小一秒
                        print(counttime)
                    break#倒計到0秒退出，跳到用戶輸入信用卡賬號
        else:
            print('輸入的信用卡號%s錯誤！請從新輸入你的信用卡號碼！' %creditcard)
ATM.py 
2018-01-02 22:13:44    購買：mouse    799        0
2018-01-02 22:14:10    存款        2000        0
2018-01-02 22:14:20    存款        2000        0
2018-01-02 22:14:30    取款        105.0        5.0
2018-01-02 22:14:43    轉帳        110.0        10.0
2018-01-03 11:09:13    存款        2000        0
2018-01-03 11:09:24    取款        105.0        5.0
2018-01-03 11:09:52    轉帳        110.0        10.0
xiaofeilist.txt 
6321
usercardmoney.txt 
1234567890    123456
userinfo.txt 
BMW 50000
computer 15000
iphone 6999
TV 2089
LVbag 799
book 69
Apple 12
shoplist.txt
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程