python 學習第二週總複習

時間 2019-12-13

原文原文鏈接

目錄python

數據類型內置方法

數字類型內置方法

整型

做用:定義年齡/身高/體重/id號
定義方式:

age = 18
age = int('18')

方法: + - * / % // **
多個值or一個值:一個值
有序or無序:壓根沒有有序無序這一說
可變or不可變:不可變

可變:值變id不變，值變id也變

浮點型

做用:定義薪資/價格
定義方式:

salary = 3.2

salary = float('3.2')

方法:+ - * / % // **
多個值or一個值:一個值
有序or無序:壓根沒有有序無序這一說
可變or不可變:不可變

字符串類型內置方法

做用:姓名/
定義方式:

name = 'nick'
name = "nick"
name = '''
nick
nick
'''
name = """
nick
nick
"""
name = "'nick'"
name = '"nick"'

方法
1. 優先掌握
  1. 索引取值
  2. 切片
  3. 長度
  4. 切分split
  5. 除兩邊空白strip
  6. 成員運算in&emsp；not in
  7. for循環
2. 須要掌握
  1. lstrip/rstrip
  2. rsplit
  3. upper/lower
  4. startstwith/endswith
  5. join
  6. replace
  7. isdigit
3. 瞭解
  1. find/rfind/index/rindex/count
  2. center/ljust/rjust/zfill
  3. expantabs
  4. capitalize/swapcase/title
  5. is系列
多個值or一個值:一個值
有序or無序:有序
可變or不可變:不可變

列表類型內置方法

做用:多個女友/
定義方式:[]內用逗號隔開多個任意數據類型的元素

friends_list = ['longzeluola'，'canglaoshi'，'qiaobenai'，'nick']
lis = list('abcd')

方法:
1. 優先掌握
  1. 索引取值(便可取又可改)
  2. 切片
  3. 長度
  4. append
  5. 成員運算
  6. for循環
2. 須要掌握
  1. count
  2. remove
  3. reverse
  4. pop
  5. insert
  6. sort
  7. index
  8. del
  9. extend
  10. clear
多個值or一個值:多個值
有序or無序:有序
可變or不可變:可變

元祖類型內置方法

做用:相似於列表，能夠取不能夠存
定義方式:

friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')

方法
1. 優先掌握
  1. 索引取值(沒法更改)
  2. 切片
  3. 長度
  4. 成員運算
  5. for循環
  6. count
  7. index
多個值or一個值:多個值
有序or無序:有序
可變or不可變:無可變不可變這一說

字典類型內置方法

做用:值太多列表存容易，取麻煩時使用字典
定義方式:

nick_info_dict = {
'name':'nick'，
'height':180，
'weight':140，
'hobby_list':['read'，'run'，'music'，'fishing'，'programming'，'coding'，'debugging']
}

for k，v in nick_info_dict.items():
    print(k，v)

方法
1. 優先掌握
  1. 按鍵取值
  2. 長度
  3. keys/values/items
  4. for循環
  5. 成員運算
2. 須要掌握
  1. pop
  2. fromkeys
  3. setdefault
  4. get
  5. update
  6. del
多個值or一個值:多個值
有序or無序:無序
可變or不可變:可變

集合類型內置方法

做用:存多個值，爲了集合之間作運算
定義方式:

s = set()

s = {1，2，3，4，5，1}

方法:
1. 優先掌握
  1. 去重
  2. 並集 |
  3. 交集 &
  4. 差集 -
  5. 對稱差集 ^
  6. 父集 >&emsp；>=
  7. 子集 <&emsp；<=
  8. ==
2. 須要掌握
  1. add
  2. difference_update
  3. isdisjoint
  4. remove # 值不存在會報錯
  5. discard # 不會報錯
多個值or一個值:多個值
有序or無序:無序
可變or不可變:可變

布爾類型

做用:通常用於判斷，除了0/None/空/False自帶布爾值爲False，其餘的數據類型自帶布爾值爲True

數據類型總結

一個值	多個值
整型/浮點型/字符串	列表/元祖/字典/集合/

有序	無序
字符串/列表/元祖	字典/集合

可變	不可變
列表/字典/集合	整型/浮點型/字符串

拷貝

==拷貝/淺拷貝/深拷貝都是針對可變類型數據而言的==

l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = l1

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']

若是l2是l1的拷貝對象，則l1內部的任何數據類型的元素變化，則l2內部的元素也會跟着改變，由於可變類型值變id不變git

淺拷貝

import copy


l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']]

若是l2是l1的淺拷貝對象，則l1內的不可變元素髮生了改變，l2不變；若是l1內的可變元素髮生了改變，則l2會跟着改變mongodb

深拷貝

import copy


l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

若是l2是l1的深拷貝對象，則l1內的不可變元素髮生了改變，l2不變；若是l1內的可變元素髮生了改變，l2也不會變，即l2永遠不會由於l1的變化而變化api

age = 18  # 答案
count = 0  # 遊戲次數控制
prize_dict = {
    0:'布娃娃',
    1:'變形金剛',
    2:'奧特曼',
    3:'<Python從入門到放棄>'
}

# 核心代碼
while count < 3:
    inp_age = input('請輸入你的年齡>>>').strip()  # 與用戶交互

    # 判斷用戶是否騷擾
    if not inp_age.isdigit():
        print('傻逼,你的年齡輸錯了')
        continue

    inp_age_int = int(inp_age)

    # 核心邏輯,判斷年齡
    if inp_age_int == age:
        print('猜對了')
        
        print(prize_dict)  # 打印獎品
        
        # 獲取兩次獎品
        for i in range(2):
            prize_choice = input('請輸入你想要的獎品,若是不想要,則輸入"n"退出!!!').strip()  # 與用戶交互獲取獎品
            
            # 判斷是否須要獎品
            if prize_choice != 'n':
                print(f'恭喜你得到獎品: {prize_dict[int(prize_choice)]}')
            else:
                break
       break
       
    elif inp_age_int < age:
        print('猜小了')
    else:
        print('猜大了')
    
    count += 1  # 成功玩一次遊戲
    
    if count != 3:
        continue
        
    again_choice = input('是否繼續遊戲,繼續請輸入"Y",不然任意鍵直接退出.').strip() # 交互是否再一次

    # 判斷是否繼續
    if again_choice == 'Y':
        count = 0

0531總複習

數據類型內置方法

整形類型內置方法

+ - * / // % **閉包

浮點型類型內置方法

+ - * / // % **app

字符串類型內置方法

優先掌握

索引取值
切片
切割split
長度
成員運算
去除空白strip
for循環取值

須要掌握

lstrip/rstrip
rsplit
upper/lower
startswith
endswith
isdigit
join
replace

瞭解

find/rfind/index/rindex/count
center/ljust/rjust/zfill
swapcase/capitalize/title
extendtaps
is系列

列表類型內置方法

優先掌握

索引取值，索引更改值
切片
長度
成員運算
append
del
for循環

須要掌握

insert
index
sort
remove
extend
count
pop
clear
copy
reverse

元組類型內置方法

優先掌握

索引取值
切片
長度
成員運算
count
index
for循環

字典類型內置方法

優先掌握

按鍵取值
長度
成員運算
keys/vlaues/items
for循環
del
pop（隨機刪除，由於字典是無序的）

須要掌握

fromkeys
get
update
setdefault

集合類型內置方法

優先掌握

去重
長度
成員運算
|
&
^
> >=
< <=
= =

須要掌握

add
remove
difference_update
discard(不報錯）
isdisjoint

數據類型總結

可變or不可變

可變	不可變
列表，字典，集合	字符串，整形，浮點型

有序or無需

有序	無序
字符串，列表，元組	字典，集合

存一個值or多個值

存一個值	存多個值
整型，浮點型，字符串	列表，集合，字典，元組

拷貝

l1= [1,1]
l2 = l1

當l2爲l1的拷貝對象時，l1發生變化，l2也會隨之發生變化

淺拷貝

l1 = [1,2,[1,2]]
import copy

l2 = copy.copy(l1)

當l2爲l1的淺拷貝時，l1內部的不可變元素髮生變化，l2不變；l1內部的可變元素髮生變化，l2也會隨着發生變化

深拷貝

l1 = [1,2,3,[2,3]]
import copy

l2 = copy.deepcopy(l1)

當l2爲l1的深拷貝對象時，l1內部的元素髮生變換，l2都不會發生變化
==拷貝/淺拷貝/深拷貝都是針對可變類型數據而言的==

字符編碼

用什麼編碼寫的文件，就用什麼編碼打開，unicode--》gbk 編碼encode；gbk ---》 unicode 解碼 decode

Python3解釋器編碼

當python3解釋器啓動，並生成變量時，會以unicode的形式把變量讀入內存，當咱們使用print方法時，print會自動按照終端的字符編碼編碼unicode形式的變量dom

生成變量時以unicode丟入內存，終端時gbk，仍是utf8，這終端均可以識別。
生成變量時以utf8丟入內存，終端爲utf8，能夠，可是終端爲gbk，不能夠了。==錯誤==函數

文件操做

打開文件的流程

打開文件 open
讀寫文件 read/write
關閉文件 close

with管理上下文

with open(文件名，打開模式，編碼格式) as f:
    f.操做命令

打卡文件的三種模式

r只讀（默認）
w清空只寫
a追加寫入

t 文本模式（默認）
b 二進制模式

同時打開兩個文件

with open(文件一),open(文件二),open(文件三)……

文件複製

with open('a.txt','r',encoding='utf8') as fr,                           open('a_swap.txt','w',encoding='utf8') as fw:
    data = fr.read()
    # 作一些處理以後
    fw.write(data)
    fw.flush()
    
import os

os.remove('a.txt')
os.rename('a_swap.txt','a.txt')

打開文件file後，file的方法

f.read() # read(n)意味着讀幾個字符
f.write()
f.readline()
f.readlines() （若是取出來時for循環的話，能夠for i in f）
f.flush()
f.seek()
f.tell()
f.truncate()

函數

定義函數

def 函數名():
    代碼塊

定義階段只檢測語法，不執行代碼

函數的三種形式

無參函數
有參函數
空函數

調用函數

def f1():
    return 2
    
f1()
f = f1()

調用階段才執行代碼

函數的返回值

默認爲None，若是遇到return則會終止函數，能夠返回多個值（接收的時候爲元組形式），而且值爲任意數據類型

函數的參數

形參：接受實參，具備某種描述意義，但沒有具體的值

位置形參：最普通的參數，從左到右接收一一對應的實參
默認形參：具備默認值，必須的寫在位置形參的後面

實參：具備具體的值

位置實參：從左到右傳值給一一對應的形參
關鍵字實參：指定參數傳給形參，必須寫在位置實參後面

可變長參數

*

*實參：把元組/列表打散成位置實參一個個傳給形參，相似於解壓縮
*形參：接收多餘的位置實參，儲存爲元組的形式

import random
import time

with open('0531總複習.md','r',encodint='utf8') as fr:
    for i in range(50):
        fr.read(random.randint(1,300))
        time.sleep(30)

**

**實參：把字典打散成關鍵字實參一個個傳給形參，
**形參：接收多餘的關鍵字實參，存儲爲字典的形式，**kwargs

函數對象

def f1():
    pass

# 1.引用
f = f1

# 2.看成返回值
def f2():
    return f1
    
# 3. 看成參數傳入
def f3(func):
    func()
f3(f1)

# 4. 做爲容器元素

lis = [1,2,3,[2,3],f1,f2,f3]

函數嵌套

def f1():
    def f2():
        pass

名稱空間與做用域

內置名稱空間
全局名稱空間
局部名稱空間

執行順序：內置--》全局--》局部
查找順序：從當前位置開始，若是當前爲局部，則爲局部--》全局--》內置

做用域: 全局的變量和局部的變量沒有任何關係，即便二者中有同一名字的變量，贊成名字的變量之間進行任何操做都不會影響對方編碼

x = 10

def f1():
    x = 2
    print(x)  # 2
    
f1()

print(x)  # 10

可變的做用域事項（瞭解）

lis = [1]

def f1():
    lis[0] = 2

f1()

print(lis)  # [2]

閉包函數

def f1(x):
    def f2():
        print(x)
    return f2
    
f = f1(5)  # f-->f2,x=5
f()  # f()-->f2(),x=5  # 5
f()  # 5


f3 = f1(3)  # f-->f2,x=3
f3()  # f()-->f2(),x=3  # 3
f3()  # 3

把內部定義的變量放到內部的函數中，讓二者一塊兒返回出去

裝飾器

def deco(func):
    def wrapper(*args,**kwargs):  # 賦值後的time_sleep
        res = func(*args,**kwargs)  # 真正的time_sleep
        
        return res
    return wrapper

@deco  # time_sleep（賦值後的） = deco(time_sleep（真正的）)
def time_sleep(name):
    print(name)
    return 123

無參裝飾器

is_login_dict = {'username': None}


def login_deco(func):
    
    def wrapper(*args, **kwargs):  # 賦值後的time_sleep

        if not is_login_dict['username']:

            username = input('請輸入你的用戶名》》》').strip()

            if username != 'fanping':
                print('非法登陸')

                return

            is_login_dict['username'] = username

            res = func(*args, **kwargs)  # 真正的time_sleep

            return res
        else:
            res = func(*args, **kwargs)  # 真正的time_sleep

            return res         

    return wrapper


@login_deco
def shopping():
    print('from shopping')


@login_deco
def withdraw():
    print('from withdraw')

有參裝飾器

is_login_dict = {'username': None}

def auth(origin):
    
    def login_deco(func):

        def wrapper(*args, **kwargs):  # 賦值後的time_sleep

            if origin == 'file':

                if not is_login_dict['username']:

                    username = input('請輸入你的用戶名》》》').strip()

                    if username != 'fanping':
                        print('非法登陸')

                        return

                    is_login_dict['username'] = username

                    res = func(*args, **kwargs)  # 真正的time_sleep

                    return res
                else:
                    res = func(*args, **kwargs)  # 真正的time_sleep

                    return res

            elif origin == 'mongodb':
                print('非法登陸')
                
            else:
                print('dsb')


        return wrapper
    
    return login_deco


# f = origin('file')  # login_deco
# shopping = f(shopping)
# shopping()


@auth('file')
def shopping():
    print('from shopping')


@auth('mongodb')
def withdraw():
    print('from withdraw')