1.整型：int ? py2： ? -超出范围后，Python回自动将其转换long（长整型） ? py3： ? -所有整型均为int类型 ? 在py2中，整型的除法只能保留整数位，而py3保留所有 ? 2.布尔值(bool/boolean) ? 只有两个值： ? -true/false ? 转换： ?
字符串特有的
.upper()/.lower():大小写转换
.isdigit()：判断是否是数字 ? .rstrip()/.lstrip()：去除左右边的空格 ? .replce("被替换的字符/子序列","要替换的内容")/ .replace("被替换的字符/子序列"，"要替换的内容"，1) ? .split("根据什么东西进行分割")/ .split(‘根据什么东西进行分割‘,1) /rsplit
公共 - len , 计算长度。（字符串->计算字符串的个数）
- 索引取值 [] ---0作为开始
正值：从前往后取值
负值：从后往前取值
- 切片 --- 0作为开始
v = "oldboy"
v1 = v[2:4]
v2 = v[3:]
v3 = v[:-1]
v4 = v[3:-1]
print(v1)
print(v2)
print(v3)
print(v4)
示例：
#需求：取最后两个字符
#方式一
data = input("请输入：")
v = data[-2:]
print(v)
#方式二
total_len = len(data)
data[total_len-2:total_len]
print(v)
组织使用 -1，创建组织 -2，邀请进入组织： 设置- 成员- 添加组织成员 -3，加入组织 -4，创建仓库：仓库名称，仓库介绍 -5，如果有疑：Issues 进入自己的项目，点issues - 新建问题
上传文件至码云 -1，进入文件夹，右击，Git Bush Here -2，进行设置 git init --初始化 git config -- global user.email"....@qq.com" --设置邮箱 git config --global user.name"wcc342425" --设置用户名 git remote add origin http://码云地址 --添加码云地址 git push origin master --上传文件 提示：输入用户名和密码（码云）
提交文件至码云
进入需要提交的文件目录
右击，Git Bush Here
git status --- 查看当前目录状态
git add . --- 收集文件，执行完成后，变成绿色
git commit -m ‘第三天作业‘ ---写入提交记录
git push origin master ---上传文件
提交文件上时，忘记提交其他文件
git status
git add.
git commit -m ‘描述性文字‘
git push origin master
第一次配置码云
公司如何用git做开发？
在码云或者是GitHub等代码托管的网站创建自己的仓库，创建之后码云会给我一个仓库地址。如：https://gitee.com/wcc342425/python_study.git
自己在本地写代码
将代码提交到远程仓库
初始化
进入一个任意文件夹
git init
git config 邮箱
git config 姓名
git remote add origin https://gitee.com/wcc342425/python_study.git
注意：至此git已经将文件夹目录管理起来，以后此文件夹有任何变化，git都会检测到（使用git status命令可以查看状态）
代码收集并提交
git status
git add .
git commit -m "记录"
git push origin master -- 将本地文件夹目录下的内容同步到码云仓库
修改代码或删除文件等对本地文件夹下任何文件进项操作
git status
git add .
git commit -m "记录"
git push origin master -- 将本地文件夹目录下的内容同步到码云仓库
【避免】如果远程有本地没有的代码，必须先执行：【可能会引发合并问题】
git pull origin master
git status
git add .
git commit -m "记录"
git push origin master -- 将本地文件夹目录下的内容同步到码云仓库
1，思维导图 ? 2，笔记，博客
encode -- 编码
format -- 格式控制
join -- 循环每个元素，并在元素和元素之间加入连接符
for循环：
name = ‘alex‘
for item in name :
print(item)
name = ‘alex‘
for item in name:
print(item)
break
print(‘123‘)
name = ‘alex‘
for item in name:
print(item)
continue
print(‘123‘)
注意：1.以for循环打印字符串的每个元素： for > while
2.死循环 ：while > for
range（） -- 帮助生成某范围区间的数字，前取后不取
range（1,11） -- 1，2 ，3,4,5,6,7,8，9,10
for i in range(1,11):
if i == 7:
pass
else:
print(i)
若想要表示多个"事物"，可以使用列表。
user = ["李少奇"，"李启航"，99]
len
users = ["李少奇"，"李启航"，99]
val = len(users)
print(val) # 3
索引
users = ["李少奇"，"李启航"，99]
val = users[0]
切片
users = ["李少奇"，"李启航"，99]
val = users[0:2]
步长
users = ["李少奇"，"李启航"，99]
val = users[0:2:2]
for循环
## 1. for循环
users = [‘李少奇‘,‘李启航‘,‘张三丰‘, ‘李子树‘]
for i in users:
print(i)
?
for i in users:
for ele in i :
print(ele, end= ‘ ‘)
print(‘ ‘)
?
#练习题： 请通过for循环和数字计数器实现：users = [‘李少奇‘,‘李启航‘,‘张三丰‘, ‘李子树‘]
‘‘‘
0 李少奇
1 李启航
2 张三丰
3 李子树
‘‘‘
#方式一
count = 0
for i in users:
print(count , i)
count += 1
?
#方式二
users_len = len(users)
for index in range(0, users_len):
print(index, users[index])
删除
users = [‘李少奇‘, ‘起航‘, 99]
#方式一
users.pop[1]
print(users)
?
#方式二
del users[1]
print(users)
注意：字符串本身不能被修改或删除【不可变类型】
列表是可变类型
修改（字符串、数字、布尔除外）
users = [‘李少奇‘, ‘起航‘, 99]
users[2] = 66
?
users[0] =‘wcc‘
?
users[0][1] # -- 不可被修改
extend() -- 添加/插入
‘‘‘
1.有列表 users= [‘李忠伟‘,‘唐开发‘] people = [‘李鹏‘,‘张师傅‘]
users.extend(people) #users中增加
people.extend(users) #people中增加
?
2.有列表 users= [‘李忠伟‘,‘唐开发‘] 元组：people = (‘李鹏‘,‘张师傅‘)
users.extend(people) #users中增加
people.extend(users) #只有列表有extend功能，元组是没有的
‘‘‘
- 整数加法计算器
‘‘‘
实现一个整数加法计算器（两个数相加）
如：content = input （“请输入内容”），用户输入5+9或5+ 9，或5 + 9，然后进行分割转换最终进行整数的计算得到结果
‘‘‘
?
content = input(‘请输入：‘) # 5+9或5+ 9，或5 + 9
# 思路一：
content = content.strip()
v1 = int(content[0])
v2 = int(content[-1])
v3 = v1 + v2
?
#思路二：
content_len = len(content)
index = 0
total = 0
while True:
char = content[index]
if char.isdigit():
total += int(char)
index += 1
if index == content_len:
break
print(total)
?
#思路三：
result = content.split()
print(result) #[‘55‘, ‘+99‘]
v1 = int(result[0])
print(v1)# 55
v2 = int(result[-1])
print(v2) # 99
v3 = v1 + v2
print(v3)
append() -- 在列表最后追加元素
users = [] users.append(‘wcc‘) print(users)
## 示例一：
#1. 在列表最后追加一个元素
users = []
while True:
mane = input("请输入姓名：")
users.append(mane)
print(users)
### 示例二：
#录入用户名和密码
for i in range(0, 3):
name = input("请输入姓名：")
result = users.append(name)
print(users)
#用户名和密码进行校验
username = input("请输入用户名：")
password = input("请输入密码")
for item in users:
result = item.split(‘,‘)
user = result[0]
pwd = result[1]
if user == username and pwd == password:
print("登录成功")
break
insert -- 在指定索引位置进行插入元素
users = [‘李少奇‘,‘李启航‘,‘张三丰‘, ‘李子树‘] users.insert(1, ‘wcc‘) print(users) #[‘李少奇‘, ‘wcc‘, ‘李启航‘, ‘张三丰‘, ‘李子树‘]
remove -- 删除
users = [‘李少奇‘,‘李启航‘,‘张三丰‘, ‘李子树‘] users.remove(‘张三丰‘) print(users) #[‘李少奇‘, ‘李启航‘, ‘李子树‘]
pop -- 删除，将被删除的数据赋值给变量
users = [‘李少奇‘, ‘张三丰‘,‘李启航‘,‘张三丰‘, ‘李子树‘] # users.pop(1) users.pop() #不加，默认删除最后一个 print(users) #[‘李少奇‘, ‘张三丰‘, ‘李启航‘, ‘张三丰‘]
clear -- 清空
users = [‘李少奇‘, ‘张三丰‘,‘李启航‘,‘张三丰‘, ‘李子树‘] users.clear() print(users) #[]
del -- 删除
增
append / insert
删
remove / pop / clear / del users[2]
改
users[3] = "新值"
查
索引 / 切片
列表的嵌套
user = ["alex", 0,True,[11,22,33,"老男孩"],[1,[‘alex‘,‘oldboy‘]2,3]] user[0] user[2] user[0][2] user[3] #[11,22,33,"老男孩"] user[3][-1] #"老男孩" user[3][-1][1] #‘男‘ user[3] = 666
反转:reverse
reverse = Flase -- 从小到大（默认）
reverse = True --- 从大到小
排序：sort
user = [11,22,33,‘老男孩‘] # -- 列表（可变） user = (11,22,33,‘老男孩‘) # -- 元祖（不可变）
1，索引 （排除：int / bool)
2，切片（排除：int / bool)
3，步长（排除：int / bool)
4，删除 （排除：tuple / str / int / bool）
5，修改 （排除：tuple / str / int / bool）
6，for循环（排除：int / bool)
7，len（排除：int / bool)
users = (11, 22, 33, "老男孩")
#索引
print(users[0])
print(users[-1])
#切片
print(users[0:2])
#步长
print(users[0:2:2])
#for 循环
for item in users:
print(item)
#len
print(len(users))
元祖中的元素（儿子）不可被修改 、删除
#示例一： v1 = (11,22,33) v1[1] = 999 #错误 v1 = 999 #正确 #示例二：可以嵌套 v1 = (11,22,33(44,55,66),(11,2,(11,99),2)) #示例三：嵌套 v2 = [11,22,33(44,11,33)] v1[-1][1] = 99 #错误 v2[-1] = 123 #正确 #示例四：嵌套 v3 = (11,[2,3,4],22,33) v3[1] = 666 #错误 v3[1][2] = 123 #正确
列表（可变）
公共
索引、切片、步长、修改、删除、for、len
独有
append、insert、pop、remove、clera
列表嵌套
元祖（不可变）
公共
索引、切片、步长、for、len
独有功能 ---- 无
元祖嵌套
v3 = (11,[2,3,4],22,33) v3[1] = 666 #错误 v3[1][2] = 123 #正确
类型转换
‘‘‘ 字符串转数字 数字转字符串 列表转元组 元组转列表 ‘‘‘
#练习题： join连接时，元素必须是字符串
num = [11,22,33,44]
for i in range(0, len(num)):
num[i] = str(num[i])
result = ‘_‘.join(num)
print(result)
注意："".join([元素必须是字符串，元素必须是字符串，])
帮助用户去表示一个事物的信息（事物是有多个属性）
info = {"name":"liwei","age":14,"gender":"男","hobby":‘同桌‘} # 键值
data = {键：值，键：值，键：值，键：值，键：值}
#示例：
userinfo = {‘username‘:‘alex‘,‘password‘:‘oldboy‘}
user = input(‘请输入用户名：‘)
pwd = input(‘请输入密码‘)
if userinfo[‘username‘] == user and userinfo[‘password‘] == pwd:
print(‘登陆成功‘)
else:
print (‘用户名或密码错误‘)
keys ， 获取字典中所有的键 --- [‘name‘,‘age‘,‘gender‘,‘hobby‘]
for item in info.keys():
print(item)
values ， 获取字典中所有的值
for item in info.values():
print(item)
items ， 获取字典中的所有键值对
for v1,v2 in info.items():
print(v1,v2)
len
info = {"name": "liwei", "age": 14, "gender": "男", "hobby": ‘同桌‘}
print(len(info))
索引
info = {"name": "liwei", "age": 14, "gender": "男", "hobby": ‘同桌‘}
print(info[‘name‘])
print(info[‘age‘])
for 循环
修改 --- 存在就修改，不存在就增加
## 改值
info = {"name": "liwei", "age": 14, "gender": "男", "hobby": ‘同桌‘}
info[‘age‘] = 12
print(info)
## 改键 --- 删除后再增加
del info[‘hobby‘]
info[‘xxxx‘] = ‘xxx1‘
删除 ---- 键值对 作为一个整体，要删就全部删除
info = {"name": "liwei", "age": 14, "gender": "男", "hobby": ‘同桌‘}
del info[‘name‘]
print(info)
重点： int 、 bool 、 str 、 list 、 tuple 、 dict
.get() --- 取值，与索引的区别是，get()若字典中存在，则取值；若不存在，也不会报错，会返回None
None数据类型，该类型表示空（无任何功能，专门用于提供空值）
.update -- 不存在，则添加；存在，则更新
判断一个字符串是否有敏感字符
str
v = ‘python全栈21期‘
if ‘全栈‘ in v:
print(‘包含敏感词汇‘)
list
v = [‘alex‘,‘oldboy‘,‘canglaiosh‘,‘kliqihang‘]
if ‘liqihang‘ in v:
print(‘包含敏感词汇‘)
dict
v = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v4‘}
#默认按照建判断，即：判断x是否是字典的建
if ‘x‘ in v:
pass
#请判断：k1是否在其中？
#方式一：循环判断
flag = ‘不存在‘
for v in v.values():
if v == v2:
flag = "存在"
print(flag)
#方式二：
if ‘v2‘ in list(v.values（）) #强制转换改成列表 [‘v1‘,‘v2‘,‘v3‘]
pass
练习题
#让用户输入任意字符串，然后判断次字符串是否包含指定的敏感字符
char_list == [‘李启航‘,‘唐油光‘,‘渣渣辉‘]
content = input(‘请输入内容‘)
success = True
for v in char_list:
if v in content:
print(‘包含敏感字符‘)
success = False
break
if success:
print(content)
无序的，且不可重复的
v = {1,2,3,4,5,6,4,5,}
### 注意：
v = {} #空字典
print(type(v))
v1 = set() #空集合
print(type(v1))
add 、 discard 、 update 、 intersection 、 union 、 difference
# ### 1，空集合
# v = {} #空字典
# print(type(v))#
# v1 = set() #空集合
# print(type(v1))
# #2,独有功能
# # 2.1 add 添加
# v = {1,2}
# v.add(‘ads‘)
# v.add(‘ads‘) # 集合不可重复添加
# print(v)
# # 2.2 删除
# v= {1,2,‘lishaoqi‘}
# print(v)
# v.discard(‘lishaoqi‘)
# print(v)
##2.3 update -- 往里面批量添加
# v= {1,2,‘lishaoqi‘}
# v.update({11,22,33})
# print(v)
## 2.4 交集 ---- 生成新的值
# v= {1,2,‘lishaoqi‘}
# result = v.intersection({1,‘lisahoqi‘})
# print(v)
# print(result)
#2.5 并集
# v= {1,2,‘lishaoqi‘}
# result = v.union({1,‘lishaoqi‘,‘xiaoghe‘})
# print(v)
# print(result)
# # 2.6 差集
# v= {1,2,‘lishaoqi‘}
# result = v.difference({1,‘lishaoqi‘,‘xiaohei‘}) # v中有且后者没有
# print(v)
# print(result)
####注意：
# v= {1,2,‘lishaoqi‘}
# result = v.intersection([1,‘lisahoqi‘])#可以是列表等
# print(v)
# print(result)
len，for循环 --- 有的
索引，步长，切片，删除，修改 ---- 没有的
- 列表、字典、集合 --> 不能放在集合中+ 不能作为字典key（unhashable）
通过id()可以来查看内存地址
1，整型： -5 ~256
2， 字符串：“Alex”，‘sadd’ ------ "f_*" * 3 -- 重新开辟内存
- == 用于比较值是否相等 - is 用于比较内存地址是否相等
深浅拷贝是一样的
只有一层情况下深浅拷贝是一样的
嵌套两层以上，深浅拷贝是不一样的
浅拷贝：拷贝第一层
深拷贝：拷贝所有数据(可变)
# 1，str + int + bool v1 = ‘alex‘ import copy v2 = copy.copy(v1) print(id(v1),id(v2)) v3 = copy.deepcopy(v1) print(id(v1), id(v3)) # 2,list + tuple + set -- 无嵌套 v1 = [1,2,3,4] import copy v2 = copy.copy(v1) print(id(v1),id(v2)) v3 = copy.deepcopy(v1) print(id(v1), id(v3)) #3,list + tuple + set -- 嵌套 v1 = [1,2,3,4,[11,22,33]] import copy v2 = copy.copy(v1) print(id(v1),id(v2)) print(id(v1[4]),id(v2[4])) v3 = copy.deepcopy(v1) print(id(v1), id(v3)) print(id(v1[4]),id(v2[4]))
浅拷贝 - 只拷贝第一层；深拷贝 - 拷贝层次里面的所有的可变类型，不可变类型都不拷贝
r -- 只读不能写；若文件不存在，则报错【**】
# 1 打开文件 file_object = open(‘log.txt‘, mode=‘r‘,encoding=‘utf-8‘) # w = write , r = read ,a = append #读取文件 content = file_object.read() print(content) #关闭文件 file_object.close()
w -- 只写不能读，会先清空文件 ； 文件不存在，则新建 【**】
a -- 用于写入文件，在原文件尾部添加新内容 ； 若文件不存在，则新建 【*】
## 写入文件 # #打开文件 # file_object = open(‘log.txt‘, mode=‘w‘,encoding=‘utf-8‘) # w = write（只写 - 先清空，一般用于新建文件） , r = read ,a = append # # #写入文件 # file_object.write(‘长春‘) # # #关闭文件 # file_object.close() # #打开文件 file_object = open(‘log.txt‘, mode=‘a‘,encoding=‘utf-8‘) # w = write（只写 - 先清空，一般用于新建文件） , r = read ,a = append #写入文件 file_object.write(‘长春‘) #关闭文件 file_object.close()
r+ ： 可读可写，
读取：默认从最开始位置（0）开始读，也可以通过seek调整光标的位置
写入：根据光标的位置，从当前光标位置开始进行写入操作（可能会将其他的文字覆盖）
seek - 改变光标位置
w+
读：默认光标永远在写入的最后或0，也可以通过seek调整光标的位置
写：光标先清空
a+
读：默认光标在最后，也可通过seek调整光标的位置，然后去读取
写：永远写在最后
读文件
read()
read(2) #字符
readlines()
file_object = open(‘log.txt‘, mode=‘r‘,encoding=‘utf-8‘)
#读取文件的所有内容到内存
data = file_object.read()
#从当前光标所在的位置向后读取文件的前两个字符
data = file_object.read(2)
#读取文件的所有内容到内存，并按照每一行进行分割到列表中
data = file_object.readline()
#如果以后读取一个特别大的字符(*****************)
for line in file_object:
line = line.strip()
print(line)
file_object.close()
# print(data)
写
write
#####x写 file_object = open(‘log.txt‘, mode=‘w‘,encoding=‘utf-8‘) file_object.write(‘adsda\n‘) file_object.write(‘sadsada\n‘) file_object.close()
#打开文件 f = open(‘要打开的文件路径‘, mode = ‘r/w/a‘,encoding = ‘文件原来写入时定义的编码‘) #操作 data = f.read() # 读取文件的内容到内存（全部） f.write(‘要写入的内容‘) # 关闭文件 f.close()
# 示例第一 ---- 一般用于文字的写入 f = open(‘a.txt‘, mode = ‘w‘,encodingg = ‘utf-8‘) #a.将‘你好‘, 根据encoding指定的编码转换成二进制 #b.将二进制写入到文件中 f.write(‘你好‘) # w 打开文件，则write传入字符串 f.close() ###示例二 ----- 一般用于图片、音频、视频、未知编码 f = open(‘a.txt‘, mode = ‘wb‘) # wb打开文件，则需要直接传入二进制 #1，将要写入的字符串转换成二进制 data = ‘我好困‘ content = data.encode(‘utf-8‘) print(content) #2，再讲二进制写到文件中 f.write(content) f.close()
f = open(‘a.txt‘, mode = ‘rb‘) #直接读取到的是二进制的数据 data = f.read() f.close() print(data)
文件操作
模式
r/a/w （只读只写字符串）
r+ / w+ / a+（可读可写字符串）
rb / wb / ab （只读只写二进制）
字符串转换’二进制‘
v = “你好”
data = v.encode(‘utf-8‘)
二进制转换成字符串
v = b‘\xe6\x88\x91\xe5\xa5\xbd\xe5\x9b\xb0‘
data = v.decode(‘utf-8‘)
v = 前面 if 条件 else 后面 # 相当于下面 的代码： if 条件： v = 前面 else： v = 后面
# 让用户输入值，如果是整数，则转换成整数，否则赋值为None data = input(‘>>>‘) value = int(data) if data.isdecimal() else None
本质：将N行代码拿到别处并给他起个名字，以后通过名字就可以找到这段代码并执行
场景
代码重复执行
代码量特别多，超过一屏，可以选择通过函数进行代码的分割
#函数的定义
def 函数名(): #函数名 同变量名命名规则一样
#函数内容
pass
#函数的执行
函数名()
def get_list_first_data():
v = [11,22,33,44]
print(v)
get_list_first_data()
# 参数基本结构
def get_list_first_data(aaa): # aaa 叫形式参数
data = [11, 22, 33, 44]
print(data[aaa])
get_list_first_data(1) #2,1 等 调用函数时，叫实际参数
get_list_first_data(2)
get_list_first_data(3)
get_list_first_data(0)
练习题
#1，请写一个函数，函数计算列表info = [11,22,33,44,55]中所有元素的和
def sum_info():
info = [11, 22, 33, 44, 55]
print(info)
sum = 0
for i in rinfo:
sum += i
print(sum)
sum_info()
#2,请写一个函数，函数计算列表中所有元素的和
def get_list_sum(a1):
data = 0
for item in a1:
data += item
print(data)
get_list_sum([11,22,33])
get_list_sum([11,22,33,44])
#3, 请写一个函数，将两个列表拼接起来
def join_list(a1,a2):
result = []
result.extend(a1)
result.extend(a2)
print(result)
join_list([11,22,33],[12,34])
def func(arg):
#....
return 9 # 返回值为9，默认：return None
val = func(‘dasda‘)
#1,让用户输入一段字符串，计算字符串中有多少个A的个数，有多少个就在文件a.txt中写多少个‘李劭祺‘
def get_char_count(data):
sum_counter = 0
for i in data:
if i == "A":
sum_counter += 1
return sum_counter
def write_file(line):
if len(line) == 0:
return False #函数的执行过程中，一旦遇到return，则停止函数的执行
with open(‘a.txt‘, mode= ‘w‘,encoding=‘utf-8‘) as f:
f.write(line)
return True
content = input("请输入")
counter = get_char_count(content)
write_data = ‘李劭祺‘ * counter
status = write_file(write_data)
if status:
print("successful")
else:
print("error")
#情况1
def f1():
pass
f1()
#情况2
def f2():
pass
f2()
#情况3
def f3():
return 1
v1 = f3()
#情况4
def f4(a1,a2):
return a1+a1
v2 = f4(4,1)
# 1， 写函数，检测 计算一个列表中有多少个数字，最终打印：列表中有%s个数字
#提示：type(‘x‘) == int 判断是否是数字
def number(list):
count =0
for item in list:
if type(item) == int:
count += 1
return count
# print("列表中有%s个数字"%(count,))
# list_input = input("请输入列表：")
list_input = [11,22,‘a‘,‘c‘]
a = number(list_input)
print("列表中有%s个数字"%a)
#2,写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回
‘‘‘def get_oeder(li):
list = []
for i in range(0,len(li),2):
# list = list.extend(int(i))
list.append(li[i])
print(list)
lis = [1,2,3,4,5,6,6,7,‘a‘,9]
get_oeder(lis)
‘‘‘
def data_list1(arg): # 切片
v = arg[::2]
return v
data =data_list1([11,223,4,55,2])
print(data)
#3， 读取文件，将文件的内容构造成指定格式的数据，并返回
‘‘‘
a.log文件
alex|123|12
eric|uiuf|13
...
目标结构：
a = [‘alex|123|12","eric|uiuf|13"]并返回
b = [[‘alex|123|12"],["eric|uiuf|13"]]
c = {
{‘name‘:‘alex,‘pwd‘:123,‘age‘:‘12‘}
{‘name‘:‘eric,‘pwd‘:uiuf,‘age‘:‘13‘}
}
‘‘‘
任意个数
任意类型
def func(a1,a2,a3):
print(a1,a2,a3)
func(1,‘ad‘,Ture)
调用函数并传入参数
def func(a1,a2):
print(a1,a2)
func(1,2)
def func(a1,a2):
print(a1,a2)
func(a2 = 99, a1 = 22)
# 关键字传参和位置传参可以混合使用 (位置传入的参数 > 关键字参数 在后 = 总参数个数)
def func(a1,a2,a3):
print(a1,a2,a3)
func(11,22, a3 = 22)
def func(a1,a2 = 9):
pass
"""
func 函数接受两个参数，调用函数进行传值时：
func(1,2)
func(1,a2 = 12)
"""
*args 可以接受任意个数的参数，并将参数转换成元组
有 *
无 *
只能有位置传参，不能用关键字传参
def func(*args):
print(args)
func(1)
func(1,2)
func(1,2,[11,22,33],12312,55,"true",‘alex‘)
func((11,22,33,44,55))
func(*(11,22,33,44,55))
**kwargs : 可以接受任意个数的关键字参数，并将参数转换成字典
只能有关键字传参
调用函数 无 **
def func(**kwargs):
print(kwargs)
func(k1 =1, k2 = ‘alex‘)
调用函数 有 **
def func(**kwargs):
print(kwargs)
func(**{‘k1‘ :‘1‘, ‘k2‘ : ‘alex‘}) #{‘k1‘: ‘1‘, ‘k2‘: ‘alex‘}
综合应用
def func(*args,**kwargs):
print(args,kwargs)
func(1,2,3,4,5,k1 = 2,k2 = 43,k3 = 999) #(1, 2, 3, 4, 5) {‘k1‘: 2, ‘k2‘: 43, ‘k3‘: 999}
定义函数
def func(a1,a2):
pass
def func2(a1,a2 = None):
psss
def func3(*args,**kwargs):
pass
调用函数
位置参数 > 关键字参数
全局作用域 --- 以后必须全部大写
局部作用域
总结
一个函数就是一个作用域
作用域中查找数据的规则：优先在自己的作用域找数据，自己没有就去"父级"->"父级"直到全局，没有就报错。注意：父级作用域中的值到底是什么
子作用域中只能 找到 父级中的值，默认 无法为父级的变量重新赋值；如果非要为父级变量进行赋值，则使用global关键字（global直接找到全局关键字，nonlocal 找到上级关键字）
- 函数名可以当做变量使用
def func():
print(123)
v1 = func
func()
v1()
def func():
print(123)
func_list = [func,func,func]
func_list[0]()
func_list[1]()
func_list[2]()
for item in func_list:
item()
####### 容易混淆
def func():
# print(123)
return 123
func_list1 = [func,func,func]
func_list2 = [func(),func(),func()]
print(func_list2)
函数可以当做参数进行传递
def func(arg):
# print(arg)
v1 = arg()
print(v1)
def show():
print(666)
func(show)
用于表示简单的函数
# 三元运算，为了坚决简单的if else 的情况，如：
if 1 == 1：
a = 213
else :
a = 2333
a = 123 if 1 ==1 else 342
#lambda 表达式，为了解决简单函数的情况，如：
def func1(a1, a2):
return a1 + 100
func2 = lambda a1,a2:a1+100
func1 = lambda : 100 func2 = lambda x1,:x1 * 10 func3 = lambda *args,**kwargs:len(args)+ len(kwargs) func4 = lambda n1,n2:n1 if n1 > n2 else n2
########### 总结：列表所有方法基本上都是返回None；字符串的所有方法都是返回新值
#练习题1
USER_LIST = []
func1 = lambda x:USER_LIST.append(x)
v1 = func1("alex")
print(v1)
print(USER_LIST)
#练习题2
def func0(x):
v = x.strip()
return v
result = func0(" alex")
print(result)
自定义函数
内置函数
其他
len
open
renge
id
type
输入输出
input
强制转换
dict()
list()
tuple()
int()
str()
bool()
set()
数学相关
abs ：绝对值
float ：转换成小数
max / min ： 最大最小值
sum： 求和
divmod： 两数相除，得商和余数
#练习题：分页
USER_LIST= []
for i in range(1,856):
temp = {‘name‘:‘nishaoqi-%s‘%i,‘email‘:‘123@qq.com-%s‘%i}
USER_LIST.append(temp)
#请通过分页对数据进行展示
"""
要求：
每页显示10条数据
让用户输入哟啊查看的页面：页码
"""
#数据总总条数
total_cont = len(USER_LIST)
#每页显示10条
per_page_count =10
#总页码数
max_page_num,a = divmod(total_cont,per_page_count)
if a > 0:
max_page_num +1
pager = int(input("要查看第几页"))
if pager < 1 or pager >max_page_num:
print("页码不合法，必须是1~%s"%max_page_num)
else:
"""
#第1页：USER_LIST[0:10]
#第2页：USER_LIST[10:20]
#第3页：USER_LIST[20:30]
#第4页：USER_LIST[30:40]
....
"""
start = (pager -1)* 10
end = pager*per_page_count
data = USER_LIST[start:end]
for item in data:
print(item)
bin： 将十进制转换成二进制
num = 15 v = bin(num) print(v)
oct：将十进制转换成八进制
num = 8 v = oct(num) print(v)
int： 将其他进制转换成十进制
### 二进制转换成十进制 v1 = ‘0b1110‘ result = int(v1,base = 2) print(result,bin(result)) ### 八进制转换成十进制 v1 = ‘0o1110‘ result = int(v1,base = 8) print(result,bin(result)) ### 十六进制转换成十进制 v1 = ‘0x1110‘ result = int(v1,base = 16) print(result,bin(result))
hex：将十进制转换成十六进制
num = 16 v = hex(num) print(v)
# 1字节等于8位
#IP ： 192.168.12.79 -> 001010010.001010010.001010010.001010010
#请将ip = "192.168.12.79"中的每个十进制转换成二进制，并通过，链接起来，生成一个新的字符串
ip = "192.168.12.79"
ip_list = ip.split(‘.‘) #[‘192‘,‘168‘,‘12‘,‘79‘]
result = []
for item in ip_list:
result.append(bin(int(item)))
print(‘,‘.join(result)) #0b11000000,0b10101000,0b1100,0b1001111
## 2.请将ip = "192.168.12.79"中的每个十进制转换成二进制：
## 0b11000000,0b10101000,0b1100,0b1001111 -> 十进制的值
def func():
print(1232)
def bar():
# print(func)
return func
v = bar()
v()
闭包：为函数常见一块区域（内部变量），并为其维护自己数据，为以后执行提供数据
应用场景：装饰器， SQLAlchemy源码
def func(name):
def inner():
print(name)
return inner
v1 = func(‘alex‘)
v1()
v2 = func(‘eric‘)
v2()
#不是闭包
def func1(name):
def inner()：
return 123
return inner
#是闭包：封装值 + 内层函数需要使用
def func2(name):
def inner():
print(name)
return 12
return inner
把函数当做参数传递
把函数当做返回值
注意：对函数进行赋值
chr ： 将十进制数字转换成Unicode编码中对应字符串
v = chr(65) print(v)
ord ： 根据字符在Unicode编码中找到其对应的十进制
num = ord(‘中‘)
import random
def get_random_code(length = 6):
data = []
for i in range(6):
v = random.randint(65,90)
data.append(chr(v))
return ‘‘.join(data)
code = get_random_code()
print(code)
import random # 导入一个模块 v = random.randint(起始，终止) #得到一个随机数
map : 循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新列表中，并返回。
v1 = [11,22,33,44] #第一个参数：必须是一个函数 #第二个参数必须是：可迭代类型（可以被for循环） # def func(arg): # return arg + 100 # result = map(func,v1) # 将函数的返回值添加到 [None,] # print(list(result)) result = map(lambda x:x+100,v1) print(result) #[111, 122, 133, 144] -- py2 print(list(result)) #特殊 -- py3 print(v1) #map 操作不影响 v1
filter ：
v1 = [11,22,33,‘asd‘,44,‘xf‘]
def func(x):
# if type(x) == int:
# return True
# return False
# return True if type(x) == int else False
# return type(x ) == int
result = filter(func,v1)
print(list(result))
reduce --- 累乘、累加等操作
import functools
v1 = [11,22,33]
def func(x,y):
return x+y
result = functools.reduce(func,v1)
print(result)
getpass
hashlib
random
import hashlib
def get_md5(data):
obj = hashlib.md5()
obj.update(data.encode(‘utf-8‘))
result = obj.hexdigest()
return result
val = get_md5(‘123‘)
print(val)
加盐
import hashlib
def get_md5(data):
obj = hashlib.md5(‘sadsa‘.encode(‘utf-8‘))
obj.update(data.encode(‘utf-8‘))
result = obj.hexdigest()
return result
val = get_md5(‘123‘)
print(val)
应用
import hashlib
User_LIST = []
def get_md5(data):
obj = hashlib.md5(‘sadsa‘.encode(‘utf-8‘))
obj.update(data.encode(‘utf-8‘))
result = obj.hexdigest()
return result
def register():
print(‘请创建账户‘)
while True:
user = input("请输入用户名")
if user == "N":
return
pwd = input("请输入密码")
temp = {‘username‘:user,‘password‘:get_md5(pwd)}
User_LIST.append(temp)
def login():
print("用户登录")
user = input(‘请输入用户名‘)
pwd = input(‘请输入密码‘)
for item in User_LIST:
if item["username"] == user and item[‘password‘] == get_md5(pwd):
return True
register()
result = login()
if result:
print("登录成功")
else:
print("登录失败")
密码不显示 --- 只能在终端运行
import getpass
pwd = getpass.getpass("请输入密码：")
if pwd == "123":
print("输入正确")
def base():
print(1)
def bar():
print(2)
bar = base
bar()
def func(arg):
def inner():
print(arg)
return inner
v1 = func(1)
v2 = func(2)
def func(arg):
def inner():
return arg()
return inner
def index():
print(‘123‘)
return 666
index = func(index)
index()
###示例一
v1 = index() #执行 index函数，打印123并返回666赋值给v1
####示例二
v2 = func(index) #v2 是inner函数，arg = index函数
index = 666
v3 = v2()
####示例三
v4 = func(index)
index = v4 #index ==>inner
index()
def func(arg):
def inner():
print(‘before‘)
v = arg()
print(‘after‘)
return v
return inner
#第一步：执行func函数并将下面的函数参数传递，相当于：func(index)
#第二步：将func的返回值重新赋值给下面的函数名。index = func(index)
@func
def index():
print(‘123‘)
return 666
# print(index)
v = index()
print(v)
装饰器：在不改变原函数内部代码的基础上，在函数执行之前和之后自动执行某个功能
import time
‘‘‘
def func1():
time.sleep(2)
print(123)
def func2():
time.sleep(2)
print(123)
def func3():
time.sleep(2)
print(123)
start_time = time.time() #获取当前时间
func1()
end_time = time.time() #获取当前时间
print(end_time - start_time)
start_time = time.time() #获取当前时间
func2()
end_time = time.time() #获取当前时间
print(end_time - start_time)
start_time = time.time() #获取当前时间
func3()
end_time = time.time() #获取当前时间
print(end_time - start_time)
‘‘‘
‘‘‘
############## 场景一
def wraper(func):
def inner():
start_time = time.time()
v = func()
end_time = time.time()
print(end_time - start_time)
return v
return inner
@wraper
def func1():
time.sleep(2)
print(123)
def func2():
time.sleep(1)
print(345)
func1()
func2()
‘‘‘
#######场景二
def add_user():
#1,判断用户是否已经登录
#2，已经登录可以继续
pass
def del_user():
# 1,判断用户是否已经登录
# 2，已经登录可以继续
pass
def update_user():
# 1,判断用户是否已经登录
# 2，已经登录可以继续
pass
目的：在不改变原函数的基础上，在函数执行前后自定义功能
编写装饰器
@x 作用
#第一步：执行func函数并将下面的函数参数传递，相当于：func(index) #第二步：将func的返回值重新赋值给下面的函数名。index = func(index
#装饰器的编写
def x(func):
def y():
ret =func()
return ret
return y
#装饰器的应用
@x
def index():
pass
@x
def manager():
pass
#执行函数，自动触发装饰器
v= index（）
print(v)
应用场景
想要为函数扩展功能时，可选择用装饰器
编写格式：
def 外层函数(参数):
def 内层函数(*args,**kwargs):
return 参数(*args,**kwargs)
return 内层函数 ## 不能加
应用格式
@外层函数
def index():
pass
index()
应用：：flask框架 + Django缓存+ 写装饰器实现被装饰的函数要执行N次
‘‘‘
def x(func):
def inner (a1):
return func(a1)
return inner
@x
def index():
pass
# index -> inner
# index(1)
‘‘‘
‘‘‘
def x(func):
def inner (a1,a2):
return func()
return inner
@x
def index(a1,a2):
pass
#func = 原来的index函数
# index -> inner
index(1,2)
‘‘‘
关于返回值
#######关于返回值
def x1(func):
def inner(*args,**kwargs):
data = func(*args,**kwargs)
return 666
return inner()
@x1
def f1():
print(123)
return 666
v1 = f1()
print(v1)
装饰器建议写法
def x1(func):
def inner(*args,**kwargs):
data = func(*args,**kwargs)
return data
return inner()
#第一步：执行ret = xxx(index)
#第二步：将返回值赋值给index = ret
@xxx
def index():
pass
#第一步：执行v1 = uuu(9)
#第二步：@v1 --> ret = v1(index)
#第三步：index = ret
@uuu(9)
def index():
pass
#########普通装饰器
def wrapper(func):
def inner(*args,**kwargs):
data = func(*args,**kwargs)
return data
return inner()
@wrapper
def index():
pass
#########带参数的装饰器
def x(counter):
def wrapper(func):
def inner(*args,**kwargs):
data = func(*args,**kwargs)
return data
return inner()
@x(9) #index = x(9)(index) # <=> @wrapper
def index():
pass
元数据：flask框架
多个装饰器：flask框架
@x1
@x2
def func():
pass
列表推导式
目的：方便的生成一个列表
格式：
v1 = [i for i in 可迭代对象] v2 = [i for i in 可迭代对象 if 条件] #条件为true 才进行append
#########列表推导式
v1 = [ i for i in range(10)]
v2 = [ i+100 for i in range(10)]
v3 = [ 99 if i >5 else 66 for i in range(10)]
print(v3)
def func():
pass
v4 = [ func for i in range(10)]
v5 = [ lambda :100 for i in range(10)]
result = v5[0]()
def func():
return 1
v6 = [ func for i in range(10)]
result = v6[5]()
v7 = [ lambda :i for i in range(10)]
result = v7[5]()
‘‘‘
####面试题：
v8 = [ lambda x:x*i for i in range(10)]
#面试题：
#1，请问v8是什么
#2，请问v8[0](2)
result = v8[0](2)
def num():
return [lambda x:i*x for i in range(4)] #循环完，i=3
#num() -> [函数，函数，函数，函数]
print([m(2) for m in num()]) #[6,6,6,6]
‘‘‘
##########筛选#######
v9 = [i for i in range(10) if i > 5]
集合推导式
v1 = { i for i in ‘alex‘}
字典推导式
v1 = { ‘k‘+str(i) :i for i in range(10)}
python 解释器相关的数据。
sys.getrefcount -- 获取一个值的应用计数
#获取一个值的应用次数 a = [11,22,33] b = a print(sys.getrefcount(a))
sys.getrecursionlimit --- python 默认支持的递归数量
sys.stdout.out ---- print (进度)
示例：读文件进度
import os
import time
#1，读取文件大小
file_size = os.stat(‘001.Python介绍_特性_版本问题_应用范围.mp4‘).st_size
print(file_size)
#2, 一点一点的读取文件
# chunk_size = 1024
read_size = 0
with open(‘001.Python介绍_特性_版本问题_应用范围.mp4‘,mode= ‘rb‘) as f1,open(‘a.mp4‘,mode=‘wb‘) as f2:
while read_size < file_size:
chunk = f1.read(1024) #每次最多去读取1024字节
read_size += len(chunk)
val = int(read_size / file_size * 100)
print(‘%s%%\r‘%val,end= ‘‘)
# time.sleep(0.01)
sys.argv ----- 重要
""" 删除文件的脚本 """ import sys # print(sys.argv) #获取用户执行脚本时，传入的参数 path = sys.argv[1] # print(‘删除‘,path) import shutil shutil.rmtree(path)
sys.path
和操作系统相关的数据
os.path.exists(path) 如果path存在，返回True；如果pat不存在，返回False
os.stat(‘001.Python介绍特性版本问题_应用范围.mp4‘).st_size 获取文件大小
os.path.abspath() #获取绝对路径
path = ‘001.Python介绍_特性_版本问题_应用范围.mp4‘ import os v1 = os.path.abspath(path) print(v1)
os.path.dirname 获取路径的上级目录
import os v = r‘E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块\001.Python介绍_特性_版本问题_应用范围.mp4‘ print(os.path.dirname(v))
r == 转义，
os.path.join --- 路径的拼接
import os path = "D:\code\s21day14" v = "n.txt" result = os.path.join(path,v) print(result)
os.listdir --- 查看一个目录下的所有文件 【第一层】
import os
result = os.listdir(r‘E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块‘)
for path in result:
print(path)
os.listdir --- 查看一个目录下的所有文件 【第一层】
import os
result = os.walk(r‘E:\pycharm\Workplace\python_study\路飞学城‘)
for a,b,c in result:
# print(a,b,c)
#a,正在查看的目录；b，此目录下的文件夹；c，此目录下的文件
for item in c:
path = os.path.join(a,item)
print(path)
import shutil # #删除目录 # shutil.rmtree(‘test‘) # # #重命名 # shutil.move(‘test‘,‘ttt‘) #压缩文件 # shutil.make_archive(‘zzh‘, ‘zip‘, ‘E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块\db‘) #解压文件 shutil.unpack_archive(‘zzh.zip‘, format = ‘zip‘)
练习题
import shutil
import os
from datetime import datetime
ctime = datetime.now().strftime(‘%Y-%m-%d-%H-%M-%S‘)
print(ctime)
if os.path.exists(‘code‘):
os.makedirs(‘code‘)
#1,压缩lizhongwei文件夹zip
shutil.make_archive(os.path.join(‘code‘,ctime),‘zip‘,‘E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块\lizhongwei‘)
#2，放到code目录（默认不存在）
#3，将文件解压到D:\x1目录中
file_path = os.path.join(‘code‘,ctime)+‘.zip‘
shutil.unpack_archive(file_path,r‘D:\x1‘,‘zip‘)
import time time.time()
os.mkdir 创建目录（x）
os.makedirs 创建目录和子目录
import os
file_path = r‘db\xx\xxx.txt‘
file_folder = os.path.dirname(file_path)
if not os.path.exists(file_folder):
os.makedirs(file_folder)
with open(file_path,mode=‘w‘,encoding=‘utf-8‘) as f:
f.write(‘adsa‘)
重命名
import os os.rename(‘db‘,‘sb‘)
os.path.join
os.path.dirname
os.path.abspath
os.path.exists
os.stat(‘文件路径‘)
os.listdir
os.walk
sys.argv
sys.path , 默认python去导入模块时，会按照sys.path 中的路径挨个查找
import sys
sys.path.append(r‘D:‘)
for path in sys.path:
print(path)
sys 是解释器相关的数据：递归次数、引用次数
json是一个特殊的字符串-- 长得像列表、字典、字符串、数字、真假
dumps
loads
import json
#序列化，将python的值转换为json合适的字符串
# v = [12,3,4,{‘k1‘:‘v1‘},True,‘adas‘]
# v1 = json.dumps(v)
# print(v)
v2 = ‘["alex",123]‘
print(type(v2))
v3 = json.loads(v2) ###反序列化
print(v3,type(v3))
json：优点：所有语言通用；缺点：只能序列化基本的数据类型 list、dict、int......
pickle， 优点：python中所有的东西都可以被他序列化（socket对象）；缺点：序列化的内容只有python认识
import pickle
‘‘‘
v = {1,2,3,4}
val = pickle.dumps(v)
print(val)
data = pickle.loads(val)
print(data,type(data))
‘‘‘
def f1 ():
print(‘f1‘)
v1 = pickle.dumps(f1)
print(v1)
v2 = pickle.loads(v1)
print(v2)
from datetime import datetime,timezone,timedelta
import time
#####获取datetime类型时间
# v1 = datetime.now() #当前本地时间
# print(v1)
#
# tz = timezone(timedelta(hours=7)) #当前东7区时间
# v2 = datetime.now(tz)
# print(v2)
#
# v3 = datetime.utcnow() #当前utc时间
# print(v3)
############把datetime格式转换成字符串
# v1 = datetime.now()
# print(v1,type(v1))
# val= v1.strftime("%Y--%m==%d %H:%M:%S")
# print(val)
# #########字符串转成datetime#
# v1 =datetime.strptime(‘2011-11-11‘,‘%Y-%m-%d‘)
# print(v1,type(v1))
#
#
# #########datetime时间的加减#
# v1 = datetime.strptime(‘2011-11-11‘,‘%Y-%m-%d‘)
# v2 = v1 + timedelta(days= 140)
# print(v2)
# date = v2.strftime(‘%Y-%m-%d‘)
# print(date)
#########时间戳和datetime的关系#
# ctime = time.time()
# print(ctime)
# v1 = datetime.fromtimestamp(ctime)
# print(v1)
v1 = datetime.now()
val = v1.timestamp()
print(val)
下载、安装、使用
#把pip.exe 所在目录添加到环境变量中 pip install 要安装的模块名称 #pip install xlrd
xxxx.py
def f1():
print(‘f1‘)
def f2():
print(‘f2‘)
使用自定义模块
import xxxx xxxx.f1()
sys.path
导入
import
from xxx import xxxxx
# try: # val = input(‘请输入数字‘) # num = int(val) # except Exception as e: # print(‘操作异常‘)
练习题
#1,写函数，函数接受一个列表，将列表中元素每个都 + 100
def func(arg):
result = []
for item in arg:
if item.isdecimal():
result.append(int (item)+100)
return result
#2,写函数，接受一个列表，列表中都是url，请访问每个地址并获取结果
import requests
def func1(url_list):
result = []
try:
for url in url_list:
response = response.get(url)
result.append(response.text)
except Exception as e:
pass
return result
def func2(url_list):
result = []
for url in url_list:
try:
response = response.get(url)
result.append(response.text)
except Exception as e:
pass
return result
func([‘http://www.baidu.com‘,‘http://www.google.com‘,‘http://www.bing.com‘])
任务：请展示列表中所有的数据
while + 索引 + 计数器
迭代器，帮助你对某种对象(str/list/tuple/dict/set类创建的对象)中的元素进行逐一获取,
表象：具有__next()__方法，且每次调用都获取可迭代对象中的元素(从前到后一个一个获取)
列表转换成迭代器： v1 = iter([11,22,33,44])
迭代器想要获取每个值：反复调用val = v1.__next__()
直到报错：StopIteration错误，表示已经迭代完毕
"""
v1 = iter([11,22,33,44])
#列表转换成迭代器
v2 = iter(v1)
result1 = v2.__next__()
print(result1)
result2 = v2.__next__()
print(result2)
result3 = v2.__next__()
print(result3)
result4 = v2.__next__()
print(result4)
"""
v1 = iter([11,22,33,44])
#v2 = iter(v1)
v2 = v1.__iter__()
while True:
try:
val = v2.__next__()
print(val)
except Exception as e:
break
如何判别一个对象是否是迭代器：内部是否有__next__()
for循环 使用迭代器原理
v1 = [11,22,33,44]
#1,内部会将v1转换成迭代器
#2，内部反复执行 迭代器.__next()__
#3,取完不报错
for item in v1:
print(item)
具有__iter__()方法，且返回一个迭代器(***)
v1 = [11,22,33,44] result = v1.__iter__()
能被for循环的对象
for循环内部进行的操作
#1,内部会将v1转换成迭代器# #2，内部反复执行 迭代器.__next()__
# ###函数 # def func(): # return 123 # func()
###生成器函数（内部是否包含yield）
def func():
# arg =arg + 1
print(‘f1‘)
yield 1
print(‘f2‘)
yield 2
print(‘f3‘)
yield 100
print(‘f111‘)
#函数内部代码不会执行，返回一个生成器对象
v1 = func()
# 生成器 是可以被for循环，一旦开始循环，那么函数内部代码就会开始执行
for item in v1:
print(item)
练习题
def func():
count = 1
while True:
yield count
count += 1
val = func()
for item in val :
print(item)
总结：函数中如果存在yield，那么该函数就是一个生成器函数，调用生成器函数会返回一个生成器，生成器只有被for循环时，生成器函数内部的代码才会执行，每次循环都会获取yield返回的值
封装思想：将同一类的函数封装到一个类中。
#定义类
class 类名：
def 方法名(self,name):
print(name)
return 123
#调用类中的方法
#1，创建该类的对象
obj = 类名()
#2,通过对象调用方法
result = obj.方法名(‘alex‘)
print(result)
应用场景：遇到很多函数，需要给函数做归类与划分【封装】
存储一些值，方便以后使用
class File:
def read(self):
print(‘打开文件并读取内容‘)
with open(self.xxx,mode = ‘r‘,encoding= ‘utf-8‘) as f:
data = f.read()
def write(self, conter):
with open(self.xxx, mode =‘a‘,encoding=‘utf-8‘) as f:
f.write(conter)
print(‘打开文件并写入内容‘)
#实例化了一个File类的对象
obj = File()
#在对象中写了一个xxx= ‘test.log‘
obj.xxx = "test.log"
#通过对象调用类中的read方法，read方法与self就是obj
obj.read()
obj.write(‘alex‘)
示例 - 初始化对象
class Person:
def __init__(self,n,a,g):
# print(‘zhixing init‘)
self.name = n
self.age = a
self.gender = g
def show(self):
temp = "我是%s，年龄%s，性别%s"%(self.name,self.age,self.gender)
print(temp)
p1 = Person(‘lishaoqi ‘,19,‘nan‘)
p1.show()
p2 = Person(‘lishqo‘,12,‘nv‘)
p2.show()
总结：将数据封装到对象，方便使用
示例：
# #1，循环让用户输入：用户名、密码、邮箱，输入完成后再进行数据打印
#
# #不使用面向对象
#
# USER_LIST = []
# while True:
# user = input(‘请输入用户名：‘)
# pwd = input(‘请输入密码：‘)
# email = input(‘请输入邮箱：‘)
# temp = {‘username‘:user,‘password‘:pwd,‘email‘:email}
# USER_LIST.append(temp)
#
# for item in USER_LIST:
# temp = "我的名字：%s，密码：%s，邮箱：%s"%(item[‘username‘,item[‘password‘,item[‘email‘]]])
# print(temp)
#面向对象写法
class Person:
def __init__(self,user,pwd,email):
self.username = user
self.password = pwd
self.email = email
def info(self):
return "我的名字：%s，密码：%s，邮箱：%s" % (item.username, item.password, item.email)
USER_LIST = []
while True:
user = input(‘请输入用户名：‘)
pwd = input(‘请输入密码：‘)
email = input(‘请输入邮箱：‘)
# temp = {‘username‘:user,‘password‘:pwd,‘email‘:email}
p = Person(user,pwd,email)
USER_LIST.append(p)
for item in USER_LIST:
msg = item.info()
print(msg)
#父类(基类）
class Base:
def f1(self):
pass
#子类（派生类）
class Foo(Base):
def f2(self):
pass
#创建一个子类的对象
obj =Foo()
#执行对象.方法时，优先在自己的类中找，如果没有就去父类中找
obj.f1()
obj.f2()
#创建了一个父类的对象
obj = Base()
obj.f1()
问题：什么时候使用继承？ - 多个类中如果有公共的方法，可以放到基类中，避免重复编写
class Base:
def f1(self):
pass
class Foo(Base):
def f2(self):
pass
class Bar(Base):
def f3(self):
pass
obj1 = Foo()
obj2 = Bar()
继承关系中的查找方法的顺序
self 到底是谁？
self 是哪个类创建的，就从此类开始找，自己没有就找父类
#示例一
class Base:
def f1(self):
print(‘base.f1‘)
class Foo(Base):
def f2( )
原文：https://www.cnblogs.com/wcc342425/p/11761411.html