1 数据类型内置方法

1.1 整形类型内置方法

\ + - * / // % **

1.2 浮点型类型内置方法

\ + - * / // % **

1.3 字符串类型内置方法

1.3.1 优先掌握

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

1.3.2 需要掌握

1. lstip/rstip
2. rsplit
3. upper/lower
4. startwith
5. endwith
6. isdigit
7. ijoin
8. replace

1.3.3 了解

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

1.4 列表类型内置方法

1.4.1 优先掌握

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

1.4.2 需要掌握

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

1.5 元组类型内置方法

优先掌握

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

1.6 字典类型内置方法

1.6.1 优先掌握

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

1.6.2 需要掌握

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

1.7 集合类型内置方法

1.7.1 优先掌握

1. 去重
2. 长度
3. 成员运算
4. 并集 |
5. 交集 &
6. 差集 -
7. 对称差集 ^
8. 父集 > >=
9. 子集 < <=
10. 比较 ==

1.7.2 需要掌握

1. add
2. remove
3. difference_update
4. discard ( 相较于remove 不报错)
5. isdisjoint

2 数据类型总结

2.1 可变 or 不可变

2.2 有序 or 无序

2.3 存一个值 or 多个值

2.4 拷贝、浅拷贝、深拷贝（可变对象）

2.4.1 拷贝

l1 = [1,2]
l2 = l1

当l2是l1的拷贝对象时，l1发生变化时，l2也会随之发生变化

2.4.2 浅拷贝

import copy
l1 = [1,2,[1,2]]
l2 = copy.copy(l1)

当l2是l1的浅拷贝对象时，l1中的可变元素发生变化时，l2也会随之发生变化，l1中的不可变元素发生变化时，l2不会发生变化

2.4.3 深拷贝

import copy
l1 = [1,2,[1,2]]
l2 = copy.deepcopy(l1)

当l2是l1的深拷贝对象时，无论l1中的可变元素还是不可变元素发生变化，l2均不发生变化

3 字符编码

用什么编码写的文件就是什么编码打开，unicode->gbk = 编码encode ; gbk -> unicode 解码 decode。

python3解释器编码

当python3解释器启动，并生成变量时，会以unicode的形式把变量读入内存，当我们使用print方法时，print会自动按照终端的字符编码，编码unicode形式的变量

生成变量时，以unicode丢入内存，终端是gbk还是utf8，终端都可以识别

4 文件操作

4.1 打开文件的流程

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

4.2 with管理上下文

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

4.3 打开文件的三种模式

1. r只读 （默认
2. w清空只写
3. a追加写入
4. t文本模式 （默认的
5. b二进制模式

4.4 同时打开两个文件

with open(文件1),open(文件2),open(文件3)……： 
	操作

文件复制

with open('a.txt','r',encoding ='utf8') as fr,\
	open('swap_a.txt','w',encoding = 'utf8') as fw:
  data = fr.read
  #做一些处理之后
  fw.write(data)
  fw.flush
import os
os.remove('a.txt')
os.rename('swap_a.txt','a.tex')

4.5 打开文件file后，file的方法

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

5 函数

5.1 定义函数

def 函数名():
  代码块

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

5.2 函数三种形式

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

5.3 调用函数

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

调用阶段才执行代码

5.4 函数的返回值

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

5.5 函数的参数

1. 形参：接受实参，具有某种描述意义，但没有具体的值
   1. 位置形参：最普通的参数，从左到右接受一一对应的实参
   2. 默认形参：具有默认值，必须写在位置形参的后面
2. 实参：具有具体的值
   1. 位置实参，从左到右传值给一一对应的形参
   2. 关键字实参：指定参数传给形参，必须写在位置实参后面

5.6 可变长参数

5.6.1 *

• *实参：把元组/列表打散成位置实参一个个穿给形参，类似与解压缩
• *形参：接受多余的位置实参，以元组的形式储存

5.6.3 **

• **实参：把字典打散多个关键字实参一个个传个形参
• **形参：接受多余的关键字实参，存储为字典形式

5.7 函数对象

def f1():
  pass
# 1.引用
f = f1()

# 2.当作返回值
def f2():
  return f1

# 3.当作参数传入
def f3(func):
  func()
f3(f1)

# 4.作为容器元素
list = [1,2,f1,f2]
list[3]()

5.8 函数嵌套

def f1():
  def f2():
    pass

5.9 名称空间与作用域

1. 内置名称空间
2. 全局名称空间
3. 局部名称空间
4. 执行顺序：内置 --》全局 --》局部
5. 查找顺序：从当前位置开始，如果当前为局部，则为 局部 --》全局 --》内置
6. 作用域：全局变量和局部变量没有任何关系，即使两者中有同一名字的变量，同一名字的变量之间的操作不会互相影响

下面的仅作了解：

1. global 声明全局
2. nonlocal 从内部声明到外部，但还是在函数里

5.10 闭包函数

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

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

5.11 装饰器

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

@deco  #time_sleep(赋值后的) = deco(time_sleep(真正的))
def time_sleep(name):
  print(name)
  return 123

登陆装饰器

is_login = {'username':None}
def login(func):
  def wrapper(*args,**kwargs): 
    
    if not is_login['username']:
    
      username = input("请输入你的用户名>>>").strip()
      if username != sch:
        print('非法登录')
        retuen

      is_login['username'] = username

      res = func(*args,**kwargs)  

      return res
    else:
      res = func(*args,**kwargs)
      return res
  return wrapper

@login
def shopping():
  print('from shopping')
@login
def pay():
  print("from pay")
@login
def withdraw():
  print("from withdraw")