目录
-
数据类型内置方法
-
数字类型内置方法
- 整型
- 浮点型
- 字符串类型内置方法
- 列表类型内置方法
- 元祖类型内置方法
- 字典类型内置方法
- 集合类型内置方法
- 布尔类型
- 数据类型总结
- 拷贝
- 浅拷贝
- 深拷贝
-
数字类型内置方法
- 0531总复习
-
数据类型内置方法
- 整形类型内置方法
- 浮点型类型内置方法
-
字符串类型内置方法
- 优先掌握
- 需要掌握
- 了解
-
列表类型内置方法
- 优先掌握
- 需要掌握
-
元组类型内置方法
- 优先掌握
-
字典类型内置方法
- 优先掌握
- 需要掌握
-
集合类型内置方法
- 优先掌握
- 需要掌握
-
数据类型总结
- 可变or不可变
- 有序or无需
- 存一个值or多个值
- 拷贝
- 浅拷贝
- 深拷贝
-
字符编码
- Python3解释器编码
-
文件操作
- 打开文件的流程
- with管理上下文
- 打卡文件的三种模式
-
同时打开两个文件
- 文件复制
- 打开文件file后，file的方法
-
函数
- 定义函数
- 函数的三种形式
- 调用函数
- 函数的返回值
-
函数的参数
- 形参：接受实参，具有某种描述意义，但没有具体的值
- 实参：具有具体的值
-
可变长参数
- *
- **
- 函数对象
- 函数嵌套
-
名称空间与作用域
- 可变的作用域事项（了解）
- 闭包函数
-
装饰器
- 无参装饰器
- 有参装饰器
数字类型内置方法
整型
- 作用:定义年龄/身高/体重/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"'- 方法
- 优先掌握
- 索引取值
- 切片
- 长度
- 切分split
- 除两边空白strip
- 成员运算in&emsp；not in
- for循环
- 需要掌握
- lstrip/rstrip
- rsplit
- upper/lower
- startstwith/endswith
- join
- replace
- isdigit
- 了解
- find/rfind/index/rindex/count
- center/ljust/rjust/zfill
- expantabs
- capitalize/swapcase/title
- is系列
- 优先掌握
- 多个值or一个值:一个值
- 有序or无序:有序
- 可变or不可变:不可变
列表类型内置方法
- 作用:多个女朋友/
- 定义方式:[]内用逗号隔开多个任意数据类型的元素
friends_list = ['longzeluola'，'canglaoshi'，'qiaobenai'，'nick']
lis = list('abcd')- 方法:
- 优先掌握
- 索引取值(即可取又可改)
- 切片
- 长度
- append
- 成员运算
- for循环
- 需要掌握
- count
- remove
- reverse
- pop
- insert
- sort
- index
- del
- extend
- clear
- 优先掌握
- 多个值or一个值:多个值
- 有序or无序:有序
- 可变or不可变:可变
元祖类型内置方法
- 作用:类似于列表，可以取不可以存
- 定义方式:
friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')- 方法
- 优先掌握
- 索引取值(无法更改)
- 切片
- 长度
- 成员运算
- for循环
- count
- 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)- 方法
- 优先掌握
- 按键取值
- 长度
- keys/values/items
- for循环
- 成员运算
- 需要掌握
- pop
- fromkeys
- setdefault
- get
- update
- del
- 优先掌握
- 多个值or一个值:多个值
- 有序or无序:无序
- 可变or不可变:可变
集合类型内置方法
- 作用:存多个值，为了集合之间做运算
- 定义方式:
s = set()
s = {1，2，3，4，5，1}- 方法:
- 优先掌握
- 去重
- 并集 |
- 交集 &
- 差集 -
- 对称差集 ^
- 父集 >&emsp；>=
- 子集 <&emsp；<=
==
- 需要掌握
- add
- difference_update
- isdisjoint
- remove # 值不存在会报错
- 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不变
浅拷贝
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
整形类型内置方法
+ - * / // % **
浮点型类型内置方法
+ - * / // % **
字符串类型内置方法
优先掌握
- 索引取值
- 切片
- 切割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形式的变量
生成变量时以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')- ==装饰器是为了给函数增加功能，但是不改变函数内部语法，不改变函数调用方式==/
