python 学习第二周总复习

目录

• 数据类型内置方法
  • 数字类型内置方法
    • 整型
    • 浮点型
  • 字符串类型内置方法
  • 列表类型内置方法
  • 元祖类型内置方法
  • 字典类型内置方法
  • 集合类型内置方法
  • 布尔类型
  • 数据类型总结
  • 拷贝
  • 浅拷贝
  • 深拷贝
• 0531总复习
• 数据类型内置方法
  • 整形类型内置方法
  • 浮点型类型内置方法
  • 字符串类型内置方法
    • 优先掌握
    • 需要掌握
    • 了解
  • 列表类型内置方法
    • 优先掌握
    • 需要掌握
  • 元组类型内置方法
    • 优先掌握
  • 字典类型内置方法
    • 优先掌握
    • 需要掌握
  • 集合类型内置方法
    • 优先掌握
    • 需要掌握
• 数据类型总结
  • 可变or不可变
  • 有序or无需
  • 存一个值or多个值
  • 拷贝
  • 浅拷贝
  • 深拷贝
• 字符编码
  • Python3解释器编码
• 文件操作
  • 打开文件的流程
  • with管理上下文
  • 打卡文件的三种模式
  • 同时打开两个文件
    • 文件复制
  • 打开文件file后，file的方法
• 函数
  • 定义函数
  • 函数的三种形式
  • 调用函数
  • 函数的返回值
  • 函数的参数
    • 形参：接受实参，具有某种描述意义，但没有具体的值
    • 实参：具有具体的值
  • 可变长参数
    • *
    • **
  • 函数对象
  • 函数嵌套
  • 名称空间与作用域
    • 可变的作用域事项（了解）
  • 闭包函数
  • 装饰器
    • 无参装饰器
    • 有参装饰器

数字类型内置方法

整型

1. 作用:定义年龄/身高/体重/id号
2. 定义方式:

age = 18
age = int('18')

1. 方法: + - * / % // **
2. 多个值or一个值:一个值
3. 有序or无序:压根没有有序无序这一说
4. 可变or不可变:不可变

• 可变:值变id不变，值变id也变

浮点型

1. 作用:定义薪资/价格
2. 定义方式:

salary = 3.2

salary = float('3.2')

1. 方法:+ - * / % // **
2. 多个值or一个值:一个值
3. 有序or无序:压根没有有序无序这一说
4. 可变or不可变:不可变

字符串类型内置方法

1. 作用:姓名/
2. 定义方式:

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

1. 方法
   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系列
2. 多个值or一个值:一个值
3. 有序or无序:有序
4. 可变or不可变:不可变

列表类型内置方法

1. 作用:多个女朋友/
2. 定义方式:[]内用逗号隔开多个任意数据类型的元素

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

1. 方法:
   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
2. 多个值or一个值:多个值
3. 有序or无序:有序
4. 可变or不可变:可变

元祖类型内置方法

1. 作用:类似于列表，可以取不可以存
2. 定义方式:

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

1. 方法
   1. 优先掌握
      1. 索引取值(无法更改)
      2. 切片
      3. 长度
      4. 成员运算
      5. for循环
      6. count
      7. index
2. 多个值or一个值:多个值
3. 有序or无序:有序
4. 可变or不可变:无可变不可变这一说

字典类型内置方法

1. 作用:值太多列表存容易，取麻烦时使用字典
2. 定义方式:

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. 优先掌握
      1. 按键取值
      2. 长度
      3. keys/values/items
      4. for循环
      5. 成员运算
   2. 需要掌握
      1. pop
      2. fromkeys
      3. setdefault
      4. get
      5. update
      6. del
2. 多个值or一个值:多个值
3. 有序or无序:无序
4. 可变or不可变:可变

集合类型内置方法

1. 作用:存多个值，为了集合之间做运算
2. 定义方式:

s = set()

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

1. 方法:
   1. 优先掌握
      1. 去重
      2. 并集 |
      3. 交集 &
      4. 差集 -
      5. 对称差集 ^
      6. 父集 >&emsp；>=
      7. 子集 <&emsp；<=
      8. ==
   2. 需要掌握
      1. add
      2. difference_update
      3. isdisjoint
      4. remove # 值不存在会报错
      5. discard # 不会报错
2. 多个值or一个值:多个值
3. 有序or无序:无序
4. 可变or不可变:可变

布尔类型

1. 作用:一般用于判断，除了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不变

浅拷贝

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会跟着改变

深拷贝

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的变化而变化

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

整形类型内置方法

+ - * / // % **

浮点型类型内置方法

+ - * / // % **

字符串类型内置方法

优先掌握

1. 索引取值
2. 切片
3. 切割split
4. 长度
5. 成员运算
6. 去除空白strip
7. for循环取值

需要掌握

1. lstrip/rstrip
2. rsplit
3. upper/lower
4. startswith
5. endswith
6. isdigit
7. join
8. replace

了解

1. find/rfind/index/rindex/count
2. center/ljust/rjust/zfill
3. swapcase/capitalize/title
4. extendtaps
5. is系列

列表类型内置方法

优先掌握

1. 索引取值，索引更改值
2. 切片
3. 长度
4. 成员运算
5. append
6. del
7. for循环

需要掌握

1. insert
2. index
3. sort
4. remove
5. extend
6. count
7. pop
8. clear
9. copy
10. reverse

元组类型内置方法

优先掌握

1. 索引取值
2. 切片
3. 长度
4. 成员运算
5. count
6. index
7. for循环

字典类型内置方法

优先掌握

1. 按键取值
2. 长度
3. 成员运算
4. keys/vlaues/items
5. for循环
6. del
7. pop（随机删除，因为字典是无序的）

需要掌握

1. fromkeys
2. get
3. update
4. setdefault

集合类型内置方法

优先掌握

1. 去重
2. 长度
3. 成员运算
4. |
5. &
7. ^
8. > >=
9. < <=
10. = =

需要掌握

1. add
2. remove
3. difference_update
4. discard(不报错）
5. 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形式的变量

生成变量时以unicode丢入内存，终端时gbk，还是utf8，这终端都可以识别。
生成变量时以utf8丢入内存，终端为utf8，可以，但是终端为gbk，不可以了。==错误==

打开文件的流程

1. 打开文件 open
2. 读写文件 read/write
3. 关闭文件 close

with管理上下文

with open(文件名，打开模式，编码格式) as f:
    f.操作命令

打卡文件的三种模式

1. r只读 （默认）
2. w清空只写
3. 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的方法

1. f.read() # read(n)意味着读几个字符
2. f.write()
3. f.readline()
4. f.readlines() （如果取出来时for循环的话，可以for i in f）
5. f.flush()
6. f.seek()
7. f.tell()
8. f.truncate()

定义函数

def 函数名():
    代码块

• 定义阶段只检测语法，不执行代码

函数的三种形式

1. 无参函数
2. 有参函数
3. 空函数

调用函数

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

• 调用阶段才执行代码

函数的返回值

• 默认为None，如果遇到return则会终止函数，可以返回多个值（接收的时候为元组形式），并且值为任意数据类型

函数的参数

形参：接受实参，具有某种描述意义，但没有具体的值

1. 位置形参：最普通的参数，从左到右接收一一对应的实参
2. 默认形参：具有默认值，必须的写在位置形参的后面

实参：具有具体的值

1. 位置实参：从左到右传值给一一对应的形参
2. 关键字实参：指定参数传给形参，必须写在位置实参后面

可变长参数

*

1. *实参：把元组/列表打散成位置实参一个个传给形参，类似于解压缩
2. *形参：接收多余的位置实参，储存为元组的形式

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)

**

1. **实参：把字典打散成关键字实参一个个传给形参，
2. **形参：接收多余的关键字实参，存储为字典的形式，**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

名称空间与作用域

1. 内置名称空间
2. 全局名称空间
3. 局部名称空间

• 执行顺序：内置--》全局--》局部
• 查找顺序：从当前位置开始，如果当前为局部，则为局部--》全局--》内置

作用域: 全局的变量和局部的变量没有任何关系，即使两者中有同一名字的变量，同意名字的变量之间进行任何操作都不会影响对方

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')

• ==装饰器是为了给函数增加功能，但是不改变函数内部语法，不改变函数调用方式==/