第二周笔记
‘容器类型（字符串，列表，元组，字典，以及函数）’
第5天
字符串的获取（长度，位置，切片,join拼接符）
s = '千锋教育北科Python2101期开班典礼'
# 1. 获取字符串的长度
print(len(s))
# 2. 根据下标获取指定位置的字符
'''
Python中的下标 有两种表示方法
1. 正整数格式的下标
[0, 长度-1]
2. 负整数格式的下标
[-长度, -1]
这两个下标的顺序 都是从左向右描述的
'''
# 获取第一个位置字符
print(s[0])
print(s[-len(s)])
# 获取最后一个位置的
print(s[len(s) - 1])
print(s[-1])
# 不可变的
# s[-1] = '\n'
# TypeError: 'str' object does not support item assignment 字符串对象不支持元素被再赋值
# 3.切片: 提取子串
'''
根据下标来提取子串
格式: 字符串[start:stop:step]
根据start下标和stop下标 确定提取位置 在这个位置的范围中根据步长进行提取
下标的两种方式 是可以混用的 【因为是确定位置的】
:step -- 可以省略 默认是步长是1
start和stop也是可以省略的
start --- 表示提取子串的起始位置
如果省略的情况下
步长为正 表示从左边开始
步长为负 表示从右边开始
stop --- 表示提取子串的结束位置
如果省略的情况下
步长为正 表示到右边结束 【包含最右边】
步长为负 表示到左边结束 【包含最左边】
stop不省略的情况下 提取位置的范围是前闭后开的 [start， stop)
start和stop之间的冒号不可以省略 切片的情况下必须存在
'''
sub_s = s[:] # 表示从头取到尾
print(sub_s)
sub_s = s[:5] # 提取前5个字符
print(sub_s)
sub_s = s[::-1] # 将序列内容倒序
print(sub_s) # 礼典班开期1012科北育教锋千
sub_s = s[-5:] # 提取后5个字符
print(sub_s)
sub_s = s[4::-1] # 提取前5个 并进行倒序
print(sub_s)
sub_s = s[::2]
print(sub_s)
# 4.获取指定子串第一次出现的位置
'''
index -- 在指定范围中 从左向右第一次出现的位置
rindex --- 在指定范围中 从右向左第一次出现的位置 【在指定范围中 从左向右最后一次出现的位置】
如果找到的话 获取的是子串中第一个字符对应的下标 如果找不到就报错
find -- 在指定范围中 从左向右第一次出现的位置
rfind -- 在指定范围中 从右向左第一次出现的位置 【在指定范围中 从左向右最后一次出现的位置】
如果找到的话 获取的是子串中第一个字符对应的下标 如果找不到获取的-1
'''
s = s * 2
print(s) # 千锋教育北科2101期开班典礼千锋教育北科2101期开班典礼
'''
S.index(sub[, start[, end]]) -> int
start,end
设置的是下标
使用方式
S.index(sub) --- 从左向右查找sub第一次出现的位置
S.index(sub, start) - 从start开始 到最右边 查找sub第一次出现的位置
S.index(sub, start, end) --- 在[start, end)范围中查找sub第一次出现的位置
'''
pos = s.index('北科')
print(pos) # 4
pos = s.index('北科', 5)
print(pos) # 25
# pos = s.index('北科', 5, 20)
# print(pos) # ValueError: substring not found
# S.rindex(sub[, start[, end]]) -> int
pos = s.rindex('北科')
print(pos) # 25
pos = s.rindex('北科', 10)
print(pos) # 25
# pos = s.rindex('北科', 3, 10)
# print(pos) #4
pos = s.find('北科')
print(pos) # 4
pos = s.find('北科', 5)
print(pos) # 25
pos = s.find('北科', 5, 10)
print(pos) # -1 表示没有找到
pos = s.rfind('北科')
print(pos) # 25
s = '千锋教育北科Python2101010期开班典礼' * 2
print(s) # 千锋教育北科Python2101010期开班典礼千锋教育北科Python2101010期开班典礼
# 5.统计子串在原串中出现的次数
count = s.count('010') # 找的时候不会把字符重复定位查找 也就是找过的就过了 不会在反复校验的
print(count)
# 假如没有这个方法 想看一下子串出现的次数
'''
使用find 从起始位置是0的地方开始找 01这个子串 找到的话会返回01第一次出现的位置pos
使用find 从起始位置是pos+len(子串)的地方开始找 01这个子串 找到的话会返回01在这个范围中第一次出现的位置pos1
使用find 从起始位置是pos1+len(子串)的地方开始找 01这个子串 找到的话会返回01在这个范围中第一次出现的位置pos2
直到find给返回的是-1
'''
# # 计数器
count = 0
# 起始位置
start = 0
while True:
pos = s.find('010', start)
if pos != -1:
# 次数+1
count += 1
# 查找的起始位置要发生变化
start = pos + len('010')
else:
break
print(count)
"""
start = pos + 1
可以把找过的子串的内容 再找一下
start = pos + len('010')
找过的就过了 不再查找了
"""
"""
len -- 获取字符串的长度
"""
count = 0
for ch in s:
count += 1
print(count)
# s[start:stop:step] 切片
#
s = '千锋北科Python2101010期开班典礼千锋教育北科Python2101010期开班典礼'
# 判断字符串是否以千锋教育开头
start_s = '千锋教育'
sub = s[:len(start_s)]
if sub == start_s:
print('%s是以%s开头的' % (s, start_s))
else:
print('%s不是以%s开头的' % (s, start_s))
# 判断字符串是否以开班典礼结尾
end_s = '开班典礼'
sub = s[-len(end_s):]
if sub == end_s:
print('%s是以%s结尾的' % (s, end_s))
else:
print('%s不是以%s结尾的' % (s, end_s))
#### 将字符串进行拼接（join）
```
'''
'拼接符'.join(序列)
用指定的拼接符 将指定的容器中的数据 拼接在一起
注意：本质上使用的是+运算符 把数据拼接在一起的
序列中的元素都是字符串类型的才可以
因为+运算符拼接字符串的时候 只能字符串和字符串进行拼接
'''
print('a' + 'b')
# print('a' + 1) # TypeError: can only concatenate str (not "int") to str
values = ['good', 'nice', 'bye']
new_s = ' '.join(values)
print(new_s) # good nice bye
'''
找一个英文语句
看一下英文语句中是否有 word back luck 这些单词
如果有的话 就把这些单词 首字母替换成大写的
一模一样的才进行替换 包含都不进行替换
'''
sen = 'word world break back luck luckly back word'
#要进行替换的单词
words = ['word', 'back', 'luck']
values = sen.split()
print(values) # ['word', 'world', 'break', 'back', 'luck', 'luckly', 'back', 'word']
# 声明一个新的列表 这个列表中包含的替换之后的单词
new_list = []
# 遍历语句中的所有单词
for w in values:
# 如果这个w在要替换的单词中
if w in words:
# append 是在列表中添加数据
new_list.append(w.capitalize())
else:
new_list.append(w)
print(new_list) # ['Word', 'world', 'break', 'Back', 'Luck', 'luckly', 'Back', 'Word']
# 转换成字符串
new_s = ' '.join(new_list)
print(new_s) # Word world break Back Luck luckly Back Word
```
sub_strings = s.split('a', maxsplit=2)
切割字符串（split）
# 1. 切割字符串
s = ' If everyone makes contribution to protecting the environment, ' \
'the world will become much more beautiful'
s = 'abcameanaamiss'
# 结果是列表类型
sub_strings = s.split('a')
print(sub_strings) # ['', 'bc', 'me', 'n', '', 'miss']
'''
'' 'bc' 'me' ’n‘ '' 'miss'
'''
'''
有两个形参可以设置
sep -- 切割符
如果不给切割符 默认是以任意空白符号( \n \t \r)为切割符 在结果中会把切割出来的空字符串给移除
```
注意：1.切割符作为切割点 不参与结果
2. 只有在没有传递切割符的基础上 默认使用空白符号为切割符时 结果中的空字符串才会被移除
```
maxsplit
--- 设置切割的次数 默认是能切割几次就是几次
'''
s = 'abc \nmean '
sub_strings = s.split()
print(sub_strings) # ['abc', 'mean']
s = 'abcabcabc'
sub_strings = s.split('a', maxsplit=2)
print(sub_strings)
s = ' If everyone makes contribution to protecting the environment, ' \
'the world will become much more beautiful'
# 统计一下这个语句中单词长度大于6的单词有哪些
words = s.split()
print(words)
# 遍历单词列表
for w in words:
if len(w) > 6:
print(w)
'''
输出以b开头的那些单词
'''
for w in words:
if w.startswith('b'):
print(w)
字符串的转换
s = 'good good Study Day Day UP,mean dfghjsa-vfghbjncs'
# 1. 小写字母转换为大写 其他不变
upper_s = s.upper()
print(upper_s)
# 2. 大写字母转换为小写 其他不变
lower_s = s.lower()
print(lower_s)
# 3.每个单词的首字母大写 其他的英文字母小写
'''
单词：使用间隔符分开的就是一个单词
'''
title_s = s.title()
print(title_s)
# 4. 字符串的首字母大写[前提是第一个是英文字母] 其他的小写
capitalize_s = s.capitalize()
print(capitalize_s)
'''
录入一个英文名字 这个英文名字大小写不缺分
看一下是否和lucy同名
'''
# name = input('请输入一个英文名字：')
# if name.lower() == 'lucy':
# print('同名')
# else:
# print('不同名')
# 编码和解码
# 把熟悉的字符串的内容 转化成 字节数据
s = '你好'
encode_s = s.encode(encoding='gbk')
print(encode_s) # b'\xc4\xe3\xba\xc3' 字节数据(十六进制显示每个字节 1个字节是8位)
'''
一个字节是8位， 一个字节能存储的数字 2^8 = 256个 正数0-255
\xc4 十六进制 这个字节的数据 c4 = 1100 0100
\xe3 e3 = 1110 0011
\xba ba = 1011 1010
\xc3 c3 = 1100 0011
11000100111000111011101011000011
'''
# 解码：把不熟悉的字节数据 转换为熟悉的字符串数据
s = encode_s.decode(encoding='gbk')
print(s)
encode_s = s.encode(encoding='utf-8')
print(encode_s) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(encode_s.decode(encoding='utf-8'))
# 注意 编码和解码的 遵守的编码规则是一致的
# 获取字符对应的十进制数据
ord_num = ord('子')
print(ord_num)
ord_num = ord('孑')
print(ord_num)
ord_num = ord('一')
print(ord_num) # 4e00 十六进制
# 19968 # 十进制
print(hex(19968)) # 把十进制转化为十六进制 0x4e00
# 注意这个方法只能接受长度为1的字符串
ord_num = ord('饕')
print(ord_num)
# 把十进制数转化为字符
ch = chr(50010)
print(ch)
# 把数据转化为十六进制
print(hex(0b10101001011001))
print(hex(0o7656))
# 把数据转化为二进制
print(bin(323))
print(bin(0o4567))
print(bin(0x18abc))
# 把数据转化为八进制
print(oct(0b10101010001))
print(oct(0x198ab))
print(oct(13125))
# a --- > A
'''
从内存上生成一个新的数据 新的数据就有新的地址
字符 ---- 内存中的地址
字符 -- 十进制 --- 二进制
'''
lower_ch = 'a'
lower_num = ord(lower_ch)
print(lower_num)
upper_num = lower_num - 32
# 根据十进制数据 转化为字符
upper_ch = chr(upper_num)
print(upper_ch)
# 将字符串中大写英文字母 转化为小写 小写英文字母转化为大写
new_s = '' # 接受转换之后的新的字符串
s = 'wertyCVBN3456'
# 遍历
for ch in s:
if 'a' <= ch <= 'z':
lower_num = ord(ch) # 获取对应的十进制数据
# 转化成大写
upper_num = lower_num - 32
# 转换成字符
new_ch = chr(upper_num)
# 把转换成功的新字符 添加到新的字符串中
new_s += new_ch
elif 'A' <= ch <= 'Z':
upper_num = ord(ch) # 获取对应的十进制数据
# 转化成大写
lower_num = upper_num + 32
# 转换成字符
new_ch = chr(lower_num)
# 把转换成功的新字符 添加到新的字符串中
new_s += new_ch
else:
new_s += ch
print(new_s)
# 字符串中提供了这个方法
print(s.swapcase()) # 把字符串中的小写字母转换为大写 大写转换为小写
字符串中的判断
s = '熊猛今年18岁'
#1. 判断字符串是否以指定内容开头
print(s.startswith('熊猛1'))
# 2. 判断是否以指定内容结尾
print(s.endswith('18岁'))
# 3. 判断字符串的内容是否是纯数字
print(s.isdigit())
print('1092'.isdigit()) # True
# 4. 判断字符串的内容是否是英文字母或者汉字
print(s.isalpha()) # False
print('abc你'.isalpha())
# 5. 判断字符串的内容是否是数字 英文字母 或者 汉字的
print(s.isalnum()) # True
# 6.判断字符串中包含的字母是否是小写的
print('abT123你好%……&'.islower())
# 7. 判断字符串中包含的字母是否是大写的
print('abT123你好%……&'.isupper())
# 8. 判断字符串是否满足 每个单词首字母都是大写的 --- title
print('Good Good'.istitle()) # True
# 9. 判断字符串的内容是否是属于显示空白的
print(' \n\t\f\v'.isspace()) # True
'''
\n 换行
\r 回车
\t 制表符
\f 换页符
\v 纵向的制表符
'''
print('hello \t 于波') # hello 于波
print('hello \v 于波')
'''
hello
于波
'''
# 判断字符串的内容是否是纯英文字母的
'''
逻辑：
需要遍历字符串 获取每个字符
从头到尾判断每个字符是否是英文字母
如果从头到尾都是 才表示这个字符串是纯英文字母的
否则的话就不是
'''
# content = input('请输入一个字符串：')
# # 声明一个变量 标记这个字符串是否是纯英文字母的
# flag = True # 假设是
# # 遍历字符串
# for ch in content:
# if not('a' <= ch <= 'z' or 'A' <= ch <= 'Z'):
# # 假设就不成立
# flag = False
# # 退出校验
# break
# # 循环结束了 flag还是True 那就表示假设是成立的
# print(flag)
#自己写的
a = input('请输入一个标识符:')
key = True
if a.isalnum() == True :
for i in a :
if '0' <= i <= '9' or '\u4e00' <= i <= '\u9fef' :
key = False
break
else :
key = True
else :
key = False
print(key)
# 校验内容是否是纯汉字
# content1 = input('请输入字符串的内容：')
# # 设个标记假设是
# flag1 = True
# # 遍历字符串
# for ch in content1:
# # 得借助unicode码 表示'\u十六进制数据'
# if not('\u4e00' <= ch <= '\u9fef'):
# # 假设不成立
# flag1 = False
# break
# print(flag1)
'''
标识符的校验
标识符要求： 1.只能包含数字 字母 下划线
2. 不能以数字开头
键盘录入一个数据 判断其是否满足标识符要求
'''
name = input('请输入标识符：')
# 设置一个标记 假设是符合要求的
name_flag = True
# 先判断第一个字符是否以数字开头
if name[0].isdigit():
name_flag = False
print('不能以数字开头')
else:
# 第一个字符不是以数字开头的
# 遍历
for ch in name:
if not (ch.isdigit() or 'a' <= ch <= 'z' or 'A' <= ch <= 'Z' or ch =='_'):
print('不允许包含数字 字母 下划线之外的符号')
# 假设不成立
name_flag = False
# 退出校验
break
print(name_flag)
第6天
函数
封装的作用
把是一段具有独立功能的代码进行封装，封装成函数，便于使用这个功能的时候直接调用函数即可
例如：求指定半径的圆的面积
S = 圆周率 * 半径的平方
语法：
def 函数名(形式参数,形式参数1,...,形式参数n):
功能实现的部分
return 功能的返回值
解读：
def --- 关键字 定义声明一个函数
函数名 --- 自定义的名字 遵守标识符规范
英文字母都是小写的 单词和单词之间使用下划线隔开 例如 circle_area
形式参数 ---- 简称形参， 是定义的变量， 用于接受参数功能运算的未知项的 比如半径
有几个未知项 就有几个形式参数
实际参数 ---- 简称实参 调用函数功能时 给未知项赋予的数据就是 实参
return --- 结束函数 并把功能的运算的结果 返回到调用功能的位置处
如果函数是不需要返回值的 return 可以省略 或者 写为return None
注意： 只要在函数对应的逻辑中没有出现return 那就表示返回值是None
调用函数
函数名(实际参数1， 实际参数2,...实际参数n)
实际参数就是参与功能运算的未知项的准确的数据 他是给形参赋值的
有几个形参就有几个实参， 而且位置是一一对应的
三元运算符：
其他语言 条件表达式 ? 表达式1 : 表达式2
条件表达式成立 运行表达式1 否则运行表达式2
Python 使用if-else做了一个三元
表达式1 if 条件表达式 else 表达式2
条件表达式成立 运行表达式1 否则运行表达式2
昨天讲的那些功能都是字符串对象所特有的
字符串对象.swapcase()
对象点语法 --- 因为字符串是有很多对象的, 这个点语法表达就是哪个对象在进行这个操作
‘a’
'b'
s = 'hello'
s.upper() # 就是把字符串对象中小写字母转化为大写 这里已经使用点语法的形式 把对象告诉upper这个功能了
没有其他的未知项参与运算 小括号中就没有实参
s1 = ’good‘
s1.upper()
’123‘.isdigit()
判断字符串对象是否以指定内容开头
’‘.startswith('') True False
# 圆的面积功能进行封装
'''
def 函数名(形式参数,形式参数1,...,形式参数n):
功能实现的部分
return 功能的返回值
'''
def y_d_m_j(r) :
s = 3.14 * r ** 2
return s
a = y_d_m_j(2)
print(a)
# # 获取两个数的最大值 --- 封装成函数
# '''
# 分析：未知项有2个 --- 形参有2个
# 需要把结果返回 -- return
# '''
def get_zuida(x,y):
if x < y :
return y
elif x == y :
return 'xiangtong'
else :
return x
x = get_zuida(1,2)
print(x)
3.字符串格式化的操作
s = 'hello'
# 1. 在指定宽度范围内居中对齐
'''
两个未知项
width -- 宽度
fillchar -- 字符串不足指定的宽度 左右两边填充的字符是什么 默认是空格
'''
new_s = s.center(10)
print(new_s)
# 指定填充字符
new_s = s.center(10, '*')
print(new_s)
# 2. 在指定宽度范围内左对齐
new_s = s.ljust(10)
print(new_s)
new_s = s.ljust(10, '*')
print(new_s)
# 3. 在指定的范围内右对齐
new_s = s.rjust(10)
print(new_s)
new_s = s.rjust(10, '*')
print(new_s)
# 4. 在指定的宽度中 以0为填充符 进行右对齐 左填充
new_s = s.zfill(10)
print(new_s)
# 随机生成一个学号 0-10000中
'''
0000
0999
9999
'''
import random
sid = random.randint(0, 10000)
print(sid)
new_sid = str(sid).zfill(5)
print(new_sid)
# 5. r或者R字符串标记符
'''
\ - 转义符
\n - 换行
\t - 制表符
r标记的字符串使用\不具有转义的含义 保持\本意
'''
# 程序中打开文件
# open(要打开的文件的路径)
#
# print(file=)
path = 'C:/liuyanan/Documents/note.txt'
print(path)
'''
windows 下路径的分隔符是\
在程序中\具有转义符的含义， 但是在路径分割中 不应该具备转义符的含义
所以使用路径的时候
1. 使用r/R进行标记 --- 建议使用这个方法
2. 使用\再进行一次转义
3. 把\换成/
'''
# 6. format的使用
# % 去进行字符串的格式化
'''
字符串要表示的文本格式(但是格式中有未知项 使用%s %d 进行站位) % (给占位符赋值)
'''
name = '于波'
age = 18
info = '我叫%s, 今年%d' % (name, age)
print(info)
'''
字符串要表示的文本格式(但是格式中有未知项 使用{}进行占位).format(给占位符赋值)
'''
# 占位符和填充数据要一一对应
info = '我叫{}, 今年{}岁'.format(name, age)
print(info)
# 另外一种写法
'''
{占位符名} format赋值的时候 根据对应的占位符名填充数据
'''
info = '我叫{key}, 今年{key1}岁'.format(key=name, key1=age)
print(info)
# 标记占位符名的好处：填充数据的时候是根据占位符名定位到对应的占位符，所以填充的时候顺序可以随意设置，只要占位符名写对即可
info = '我叫{key}, 今年{key1}岁'.format(key1=age, key=name)
print(info)
# 还有一种写法 填充数据下标法
# 数学成绩和英语成绩一样
info = '数学成绩{0},语文成绩{1},英语成绩{0}'.format(80,88)
print(info)
# Python3.6之后 f/F标记字符串的语法 类似于format
# 使用f标记的话 可以直接在{}中填充数据
info = F'我叫{name},今年{age}岁, 考试成绩是{89.774:.2f}, 十六进制{23:x} 八进制{23:o} 二进制{23:b}'
print(info)
"""
保留几位小数 {数据:.nf} n就是保留的小数位数
转化成对应的进制 {数据:x} 十六进制 {数据:o} 八进制 {数据:b}
name = '于波'
age = 18
info1 = '我叫%s, 今年%d' % (name, age)
info2 = '我叫{}, 今年{}岁'.format(name, age)
info3= '我叫{key}, 今年{key1}岁'.format(key=name, key1=age)
info4 = '数学成绩{0},语文成绩{1},英语成绩{0}'.format(80,88)
info5 = F'我叫{name},今年{age}岁, 考试成绩是{89.774:.2f}, 十六进制{23:x} 八进制{23:o} 二进制{23:b}'
print(info1)
print(info2)
print(info3)
print(info4)
print(info5)
字符串数据对齐
{数据:填充符<宽度} 左对齐 填充符可以不用设置 默认是空格
:填充符>宽度 右对齐
:填充符^宽度 居中
整数按照几位数进行格式化
{数据:0nd} n指定的位数
"""
# hex()
# bin()
# oct()
# int()
info = f'{"hello":+>8} {77:05d}'
print(info)
# 8. 引号嵌套的问题
'''
字符串本身就得使用引号包含数据， 如果呈现的内容 也要有引号
'''
message = '昵称"波波"'
print(message) # 昵称"波波"
message = "昵称'波波'"
print(message) # 昵称'波波'
# 单引号包含单引号 --- 也能办 把内容中的引号使用 \进行转义
message = '昵称\'波波\''
print(message) # 昵称'波波'
# 如果字符串的内容比较多 可以使用\ 连接两个引号包含的字符串 这样的话就在编辑器上换行显示了
message = '问女何所思，问女何所忆。女亦无所思，女亦无所忆。昨夜见军帖，可汗大点兵，军书十二卷，卷卷有爷名。' \
'阿爷无大儿，木兰无长兄，愿为市鞍马，从此替爷征'
print(message)
# 预格式化文本：内容的格式已经确定
# 三对引号
print('************\n***********')
print('''
***********
***********
''')
4.去除字符串两端指定符号
s = ' ***abc**abc*****'
print(s)
new_s = s.strip()
"""
移除字符串两端指定符号 如果没有指定 默认移除的是字符串两端的空白符号
"""
print(new_s)
# 移除指定符号
s = '***abc**abc*****'
print(s)
new_s = s.strip('*')
print(new_s) # abc**abc
# 只移除左边的
l_s = s.lstrip('*')
print(l_s)
# 只移除右边的
r_s = s.rstrip('*')
print(r_s)
1.去除字符串两端指定符号（strip）
s = ' ***abc**abc*****'
print(s.strip())
"""
移除字符串两端指定符号 如果没有指定 默认移除的是字符串两端的空白符号
"""
# 移除指定符号
s = '***abc**abc*****'
print(s.strip('*'))
# 只移除左边的
l_s = s.lstrip('*')
print(l_s)
# 只移除右边的
r_s = s.rstrip('*')
print(r_s)
2.字符串替换（replace）
s = 'hello 你好 你好啊'
new_s = s.replace('你好', 'nihao')
print(new_s)
print(s)
# '''
# old 要替换的旧子串
# new 替换成的新子串
# count 替换几次 默认全部替换
# '''
#
# new_s = s.replace('你好', 'nihao', 1)
# print(new_s)
s = 'hello 你好 你好啊'
# values = ['你', '好']
if '你' in s:
new_s = s.replace('你', 'ni')
print(new_s)
print(s)
# 要把好替换
if '好' in new_s:
res = new_s.replace('好', 'hao')
print(res)
# if '啊' in res:
例题
# 要替换的敏感词汇
sensitive_words = ['色情', '暴力', '赌博', '枪', '军火']
'''
逻辑：
遍历所有的敏感词汇
校验这个敏感词汇是否出评论的话语中
在的话 要把话语的内容替换成*
要求：评论的不超过10个字 最少得有1个字 去除无用字符的情况下
'''
content = input('请输入评论：')
print(content)
# 去除无用的字符
content = content.strip()
print(content)
# 判断内容是否在1-10个字之间
if 1 <= len(content) <= 10:
# 合法的场景下 校验有没有敏感词
for word in sensitive_words:
# 判断这个敏感词是否在内容中
if word in content: # 因为这一块始终校验的是content这个变量对应的内容
# 要替换 为什么使用的是content这个变量来接受替换后的内容
content = content.replace(word, '*')
print(f'发表评论：{content}')
else:
print('内容长度不合法')
'''
找一个英文语句
看一下英文语句中是否有 word back luck 这些单词
如果有的话 就把这些单词 首字母替换成大写的
'''
sen = 'word world break back luck luckly back word'
words = ['word', 'back', 'luck']
for w in words:
if w in sen:
sen = sen.replace(w, w.capitalize())
print(sen)
"""
这个逻辑是只要包含列出的单词 就进行替换
"""
第7天
列表
列表的声明(有序不可变)
# import keyword
# print(keyword.kwlist)
'''
['False', 'None', 'True', 'and', 'as', 'assert', 'async',
'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal',
'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
'''
# for = 1
'''
命名的时候：
1.不可以以数字开头
2.不可以使用关键字
3.不可以使用Python已经使用过的名字 print input str
因为系统给提供的这些都有自己特有的功能
如果使用这个名字来自定义名字 会把系统的功能覆盖掉
'''
# print(1)
# print = 100 # 赋值成整型的数据
# 还想再去使用原来的输出的功能
# print(1) # TypeError: 'int' object is not callable
# list = [12, 34]
# list 把其他容器型数据转化成列表的功能
# list('abc')
# 有两种形式
# 1. 使用字面量的形式
list0 = [12, 34, 56]
print(list0)
# 声明空列表
list0 = []
print(list0)
# 2. 使用list() 构造一个列表数据
list1 = list() # 构造的一个空列表
print(list1)
# 把其他容器类型转化为列表类型
list1 = list('abc') # 声明一个新的列表 列表中存储的是指定容器中的元素
print(list1) # ['a', 'b', 'c']
print(range(1, 10))
print(list(range(1, 10)))
列表中可用的运算符
'''
怎么查看这个类型可以使用哪些运算符
+ 生成的是一个新列表 存放的是两个列表中所有的元素 将两个列表拼接在一起 存在一个新的列表中
+= 在前者的列表中 追加后者的元素
* 乘以一个正整数n 结果生成一个新的列表 将原列表中的元素重复了n次
>=
>
<=
<
==
!=
相同位置的数据进行比较 直到比较出来结果 结束比较
in 成员运算符
判断指定元素是否在列表中
not in 判断指定元素是否不在列表中
'''
'''
abc < adc True
abc
adc
'''
list0 = [1, 2,3]
list1 = [4,5,6]
new_list = list0 + list1
print(new_list, list0, list1)
list0 += list1
print(list0)
print(list1)
new_list = list1 * 3
print(new_list, list1)
list2 = [1, 2, 5]
list3 = [1, 3, 5]
print(list2 > list3) # False
# 列表中存放的是字符串数据
list4 = ['good', 'bye']
list5 = ['good', 'byte']
print(list4 > list5) # 结果 False
列表中的索引和切片
nums = [77, 66, 33, 29, 19, 45]
print(nums)
'''
两种表达方式
正数形式 [0, 长度-1]
负数形式 [-长度, -1]
'''
# 可以通过下标获取元素
print(nums[0])
# 可以通过下标修改元素
nums[-1] = 28 # 通过下标定位到列表中对应的位置 修改对应位置的元素
print(nums)
'''
切片
语法：
列表[start:stop:step]
start 和 stop都是下标
在start和stop确定的范围内 按照step提取列表中的元素
:step 可以省略 默认是1 从start确定的位置 到 stop确定的位置
步长为负数的情况下
start 是从右开始的
stop 到左结束
步长为正数
start 从左开始
stop 到右结束
stop不省略的情况下是不包含的
'''
print(nums) # [77, 66, 33, 29, 19, 28]
# 提取奇数下标位置的元素
sub_list = nums[1::2]
print(sub_list)
# 提取后三个并进行反转
sub_list = nums[-1:-4:-1]
print(sub_list)
# 将第一个和最后一个除外的元素进行反转
sub_list = nums[-2:0:-1]
print(sub_list)
sub_list = nums[::-1]
print(sub_list)
sub_list = nums[:] # 拷贝出来一份新的
print(sub_list)
列表中常用的操作（没有删除和修改用新的列表）
print(nums) # [28, 46, 51, 29, 30, 77, 88, 99]
# 拷贝: 生成一个新的列表 列表中元素与原列表中的元素一致
copy_nums = nums.copy()
print(copy_nums)
print(id(copy_nums))
print(id(nums))
# 反转序列 -- 这个影响的是列表本身
nums.reverse()
print(nums)
# nums[::-1] --- 生成的是一个新的列表 对本身没有影响
# 排序
'''
默认是按照元素大小进行升序排序
'''
# nums.sort()
# print(nums) # [28, 29, 30, 46, 51, 77, 88, 99]
# 按照元素大小进行降序排序 降序就是在升序的基础上进行了反转
nums.sort(reverse=True)
print( nums) # [99, 88, 77, 51, 46, 30, 29, 28]
# 按照指定的格式的数据 对元素进行排序
values = ['good', 'bye', 'beautiful']
values.sort()
print(values)
# 按照字符串的长度 对字符串进行升序排序 [bye good beautiful]
'''
key 接受的是一个函数 这个函数就是来获取元素进行排序时比较的标准
key这个函数可以获取字符串的长度 len
函数名 -- 代表的是函数
函数名() --- 代表的是调用函数 函数的运行结果
'''
values.sort(key=len)
print(values) # ['bye', 'good', 'beautiful']
遍历列表(拆包)
nums = [77, 65, 48, 29, 14]
# 可以直接遍历列表中的元素
for ele in nums:
print(ele)
# 可以通过下标遍历 [0, 长度-1]
print(list(range(len(nums))))
for i in range(len(nums)):
print(nums[i])
# enumerate -- 枚举的功能
'''
可以展示出序列中元素及其对应的下标
'''
print(list(enumerate(nums)))
# [(0, 77), (1, 65), (2, 48), (3, 29), (4, 14)]
for item in enumerate(nums):
print(item)
# 声明变量的时候 多个变量赋予不同的值
a = b = c = 20
print(a, b, c)
a, b = 10, 20 # (10, 20)
print(a, b)
# 拆包：把容器中的数据赋值给不同的变量
m = 10, 20 # ===> (10, 20)
print(type(m)) # <class 'tuple'>
# a, b = m = (10, 20)
# index, ele = item = (下标， 元素)
# 遍历的时候拆包
for index, ele in enumerate(nums):
print(f'{index} - {ele}')
# 需求： 查看一下 列表中哪些位置是偶数 这个偶数是什么
for pos, ele in enumerate(nums):
if ele % 2 == 0:
print(f'第{pos + 1}个位置处的偶数是{ele}')
# 声明一个列表 列表中包含的是字符串数据
# 在列表中查找哪些包含i这个符号的 字符串 并找到这种字符串在列表对应的位置
ss=['word', 'miss', 'like', 'look']
for i,n in enumerate(ss):
if 'i' in n:
print( f'第{i+1}个位置包含i,字符串为{n}')
'''
eval --- 解析字符串 把字符串外层引号给去掉的 透漏出数据原本的类型
'[12, 34, 56, 78]' eval('[12, 34, 56, 78]') ---- [12, 34, 56, 78]
str -- 把数据转化为字符串， 本质上就是在数据的外层添加了引号
str([12, 34, 56, 78]) -----> '[12, 34, 56, 78]'
'''
value = '[12, 34, 56, 78]'
print(type(value)) # <class 'str'>
nums = eval(value) # [12, 34, 56, 78]
print(type(nums)) # <class 'list'>
data = input('请输入一个列表：')
print(data, type(data)) # '[12, 34, 56, 77]' <class 'str'>
new_data = eval(data)
print(new_data, type(new_data)) # [12, 34, 56, 77] <class 'list'>
'''
输入的本身是个字符串数据 注意引号不要先成对的打出来
先打'内容'
如果是先成对的打出来 在退回光标写内容的话 程序不识别这种数据
'''
获取列表中的最值以及遍历
nums = [28, 77, 36, 52, 19, 44]
'''
假设 第一个是最大的
遍历列表中之后的元素
将假设的值与列表中的元素进行比较
进而获取真正最大值
'''
max_value = nums[0] # 假设第一个是最大的
# 遍历
for ele in nums[1:]:
# 判断元素是否比假设的大 如果比假设的大
if ele > max_value:
# 要获取真正的最大值
max_value = ele
print(max_value)
# 第二种思路
'''
从下标入手 -- 获取最大值对应的下标
假设下标0这个位置对应的元素是最大的
根据下标遍历列表
判断假设是否成立 如果不成立进行修改
直到获取到最大值对应的下标
'''
max_index = 0
# 遍历
for i in range(1, len(nums)):
if nums[i] > nums[max_index]:
max_index = i
print(nums[max_index])
冒泡排序
'''
以升序为例
规则：
比较相邻的元素 如果前者大于后者 交换两个位置的元素，对每一对相邻的元素都进行这样的对比，这样比较一次完成之后 出现最大值
按照上面的流程就绪对比相邻的元素 一直到排序完成
'''
'''
******
*****
****
***
**
*
行 列
1 6
2 5
3 4
4 3
5 2
6 1
每一行的列数 = 7 - 当前行数
7 -- 列表的长度
6 行 列表长度-1行
'''
nums = [17, 22, 56, 38, 42, 19, 33]
for r in range(1, len(nums)): # 外层
for c in range(len(nums) - r):
# c的数据 0 1 2 3 4 5 --把他当做下标 去获取列表中元素 两两进行比较
if nums[c] > nums[c + 1]:
nums[c], nums[c+1] = nums[c+1], nums[c]
print(nums)
words = ['nice', 'looked', 'goods', 'lucky', 'beautiful']
for i in range(1, len(words)):
for j in range(len(words) - i):
if len(words[j]) > len(words[j+1]):
words[j], words[j+1] = words[j+1], words[j]
print(words)
'''
按照数据本身大小 进行比较 如果前者大于后者 两者交换位置 --- 按照大小排序
按照字符串的长度来进行排序
如果前者的长度大于后者的长度 两者交换位置
列表中sort方法
sort方法中有一个形参key --- 作用于if比较的位置
'''
'''
换一个需求：
按照字符串的末尾字符来进行排序
--- 排序的时候应该按照最后一个字符进行比较的
需要一个函数 --- 需要获取字符串的最后一个字符
'''
def get_last_char(string):
return string[-1]
for i in range(1, len(words)):
for j in range(len(words) - i):
if get_last_char(words[j]) > get_last_char(words[j+1]):
words[j], words[j+1] = words[j+1], words[j]
print(words)
#转化为系统的排序的方法
words.sort(key=get_last_char, reverse=True)
print(words)
选择排序
'''
升序为例
规则：
第一次进行遍历操作的时候
将第一个位置的元素与之后每个位置的元素进行比较 如果前者大于后者 两者交换位置 获取到最小值
第二次进行遍历操作的时候
将第二个位置的元素与之后每个位置的元素进行比较 如果前者大于后者 两者交换位置 获取到次小值
...
直到排序完成
'''
# nums = [47, 35, 26, 18, 22, 19]
# # 需要长度-1次 操作
# for i in range(0, len(nums)-1):
# pos = i # 每一次遍历的时候 固定位置与对应的行一样的
# # 获取固定位置之后的元素 将其与固定位置进行比较
# for j in range(pos + 1, len(nums)):
# if nums[pos] > nums[j]:
# nums[pos], nums[j] = nums[j], nums[pos]
# print(nums)
'''
每一次比较的都是获取到最小值 把最小值放在每一次固定的位置上
遍历的时候 获取到最小值对应的位置 将这个位置的元素与每一次固定的位置对应的元素交换
从下标入手
每一次找的最小元素对应的下标
将固定位置的元素与找到的最值下标对应的元素 进行交换
'''
nums = [47, 35, 26, 18, 22, 19]
for r in range(0, len(nums)-1):
# 假设固定位置的下标对应的元素是最小的
min_index = r
# 遍历列表 找到真正的最小值对应的下标
for c in range(r + 1, len(nums)):
# 如果假设的不成立
if nums[c] < nums[min_index]:
min_index = c
# 遍历完成之后 最小值对应的下标已经找到了
# 最小值对应的下标和固定位置的元素进行交换
nums[r], nums[min_index] = nums[min_index], nums[r]
print(nums)
插入排序
'''
序列中是部分有序的 更有利
规则：
第一次遍历 将下标为1的元素与下标为0的元素进行比较 如果前者小于后者 两者交换位置
第二次遍历 将下标为2的元素与下标为1的元素进行比较 如果前者小于后者 两者交换位置
将下标为1的元素与下标为0的元素进行比较 如果前者小于后者 两者交换位置
第三次遍历 将下标为3的元素与下标为2的元素进行比较 如果前者小于后者 两者交换位置
将下标为2的元素与下标为1的元素进行比较 如果前者小于后者 两者交换位置
将下标为1的元素与下标为0的元素进行比较 如果前者小于后者 两者交换位置
。。。
直到排序完成
'''
nums = [19, 27, 55, 48, 32, 16]
for r in range(1, len(nums)):
# 内层
for c in range(r,0,-1):
if nums[c] < nums[c-1]:
nums[c], nums[c-1] = nums[c-1], nums[c]
else:
# 因为从后向前排的 前面数据是有顺序的
break
print(nums)
第8天
元组
# 1. 元组的声明
# 可以使用字面量
tuple0 = (10, 20, 30)
print(tuple0)
tuple0 = (10)
print(type(tuple0)) # <class 'int'>
tuple0 = (10,)
print(type(tuple0)) # <class 'tuple'>
# 使用tuple()构造方法创建一个元组对象 --- 生成一个新的元组，将其他容器类型的数据中的元素存放于元组中
tuple1 = tuple([12, 34, 56])
print(tuple1)
# 索引和切片
# 可以通过索引获取元素
print(tuple1[0])
# 元组中元素的地址不允许发生变化 --- 元组中元素是不可变的
# tuple1[0] = 22 # TypeError: 'tuple' object does not support item assignment
# print(tuple1)
# 容器数据是可以嵌套的
list0 = [[23, 7, 39],[12, 34]] # 二维列表
# 获取39这个数据怎么获取
sub_list = list0[0] # [23, 7, 39]
# 获取39
print(sub_list[-1])
#
print(list0[0][-1])
tuple2 = (12, 34, [77, 88])
tuple2[-1][0] = 75 # 不会报错
# tuple2[0] = 22 # 会报错
print(tuple1) # (12, 34, 56)
print(tuple1[::2])
print(tuple1[::-2])
'''
+ 生成一个新的元组 将多个元组的内容存放于新的元组中
* 乘以一个整数n 生成一个新的元组 存放原元组中数据的n
>=
>
<=
<
==
!=
相同位置的数据进行比较 直到比较出结果
in 成员运算符
'''
tuple0 = (12, 34)
tuple1 = (17, 28)
new_tuple = tuple0 + tuple1
print(new_tuple, tuple1, tuple0)
new_tuple = tuple0 * 3
print(new_tuple)
print(tuple0 > (12, 35))
# 方法
# count 统计元组中指定元素出现的次数
# index 获取指定元素在指定范围中第一次出现的位置 如果找不到就报错
tuple0 = (12, 34, 5, 61, 12, 78,65, 12)
count = tuple0.count(12)
print(count)
pos = tuple0.index(12)
print(pos)
pos = tuple0.index(12, 3)
print(pos)
# pos = tuple0.index(12, 5, 6)
# print(pos) # ValueError: tuple.index(x): x not in tuple
字典
字典的声明
# 1. 字面量的形式
dict0 = {}
print(dict0, type(dict0)) # {} <class 'dict'>
dict0 = {'英语':77, '数学':87, '政治':77}
print(dict0)
# 2.dict构造
# 可以使用二维序列构造字典 注意： 内层的序列只能有两个元素 第一个元素为键 第二个元素为值
values = [['a', 97], ['b', 98], ['c', 99]]
dict1 = dict(values)
print(dict1) # {'a': 97, 'b': 98, 'c': 99}
# 可以使用key=value 进行转化
dict1 = dict(A=65, B=66, C=67)
print(dict1) # {'A': 65, 'B': 66, 'C': 67}
字典的常用操作
dict1 = dict(A=65, B=66, C=67)
print(dict1)
# 1. 添加键值对
# 字典[键] = 值
'''
如果这个键已存在 完成的是修改的操作 新值覆盖旧值
如果键不存在 完成的添加的动作
'''
dict1['D'] = 68
print(dict1)
dict1['A'] = 77 # 修改的动作只有这一个
print(dict1) # {'A': 77, 'B': 66, 'C': 67, 'D': 68}
# 字典自带的方法 -- 只完成添加的动作
# 注意：如果这个键存在 什么操作也不做
dict1.setdefault('E',69)
print(dict1) # {'A': 77, 'B': 66, 'C': 67, 'D': 68, 'E': 69}
dict1.setdefault('A',65)
print(dict1)
# 删除
# 根据键删除键值对
dict1.pop('A')
print(dict1)
# 清空字典
# dict1.clear()
# print(dict1) # {}
# 查
# 根据键获取值 字典[键] 缺点：如果键不存在 报错
value = dict1['B']
print(value)
# value = dict1['A']
# print(value) # KeyError: 'A'
# 字典自带的方法: 如果键存在 就获取对应的值 如果不存在 返回的是None
value = dict1.get('A')
print(value)
# 这个方法 如果键不存在 又不想获取的是None 可以设置一个默认值获取
value = dict1.get('A', 0)
print(value)
value = dict1.get('C', 0)
print(value)
# 获取所有的键
keys = dict1.keys()
print(keys) # dict_keys(['B', 'C', 'D', 'E'])
# 获取所有的值
values = dict1.values()
print(values) # dict_values([66, 67, 68, 69])
# 获取每一对的键值对组合
items = dict1.items()
print(items) # dict_items([('B', 66), ('C', 67), ('D', 68), ('E', 69)])
# 合并字典
dict1.update({'F':70, 'G':71})
print(dict1) # {'B': 66, 'C': 67, 'D': 68, 'E': 69, 'F': 70, 'G': 71}
# 拷贝字典
copy_dict = dict1.copy()
print(copy_dict) # {'B': 66, 'C': 67, 'D': 68, 'E': 69, 'F': 70, 'G': 71}
字典的遍历
dict0 = {'B': 66, 'C': 67, 'D': 68, 'E': 69, 'F': 70, 'G': 71}
print(dict0)
# 直接遍历字典 --- 只能获取字典的键
for ele in dict0:
print(ele)
# 遍历字典的键
for ele in dict0.keys():
print(ele)
# 遍历字典的值
for v in dict0.values():
print(v)
# 键值对组合
for item in dict0.items():
print(item)
# 可以既获取键 也获取值
for k, v in dict0.items():
print(f'{k} - {v}')
# 字典筛选
scores = {'语文':77, '数学':65, '英语':27, '政治':58}
# 去除不及格的科目
new_scores = {}
# 遍历老字典
for k, v in scores.items():
if v >= 60:
new_scores[k] = v
print(new_scores)
第9天
函数
函数的定义
将一段独立功能的代码进行封装，方便使用该功能的时候进行调用。
函数分为两种：
系统函数
自定义函数
系统函数
1.把数据转化成二进制(binary) --- bin
2.把数据转化成八进制 --- oct
3.把数据转化成十六进制 --- hex
4.获取字符对应的十进制数据 --- ord
5.把十进制数据转化为对应的字符 --- chr
6.四舍五入 --- round
round(数据) --- 结果是整数的
将小数部分四舍五入 保留整数部分
round(4.57) --- 5
round(数据, 小数保留的位数)
round(4.573, 2) --- 4.57
7.求指定数的幂数 ---- pow(x, y) 求x的y次方 ====》 x ** y
8.输出功能 --- print
9.输入功能 ---- input
10.获取数据的类型 --- type
11.获取数据对应的地址 --- id
12.求指定序列(多个数中)的最大值 --- max(容器型数据|使用逗号分开的多个数据)
max('adfgsbo') --- 's'
max(12, 34, 56, 71, 28) --- 71
13. 求指定序列(多个数中)的最小值 --- min(容器型数据|使用逗号分开的多个数据)
min('adfgsbo') --- 'a'
min(12, 34, 56, 71, 28) --- 12
14. 求指定序列的数据和
sum(容器型数据)
sum([12, 34, 15]) --- 61
15.解析字符串 ---- eval
跟 str是对立的
str 把数据转化成字符串
str([12, 34]) ---- '[12, 34]'
eval 解析字符串 获取字符串内部原本的数据
eval('[12, 34]') --- [12, 34]
16.求绝对值 --- abs
自定义函数的格式
def 函数名(形式参数1,形式参数1,...,形式参数n):
功能代码的实现
return 运算结果
解读:
def --- 关键字 定义函数的一个关键字
函数名 --- 自定义功能名
遵守标识符规范
1.不能以数字开头
2.不能使用关键字
3.不能使用Python已经占用的名字 否则会覆盖原本的功能
形式参数 --- 简称形参 他其实就是一个变量
参与功能运算的未知项的个数 决定形参的个数
实际参数 ---- 简称实参 调用功能的时候参与功能运算的具体数据 他是给形参赋值的
return --- 作用结束函数，并将功能的运行结果返回给调用的位置
有些功能没有返回值，一般是省略return不写的，隐式做了一个返回操作，返回的是None
没有return这个关键字的函数是怎么运行结束的？？ -- 把功能体执行完 自行结束 并默认return None
函数的调用
函数名(实际参数, 实际参数1,...,实际参数n)
如果这个功能有返回值 可以声明变量接受运行结果 变量 = 函数名(实参...)
函数的参数
位置参数
实参的个数要和形参是一致的 并且是一一对应的
关键字参数
调用函数时 通过对应的形参名 给与对应的值 这种就不用了考虑形参的顺序了
print(get_day(month=2, year=2020))
默认参数
print( *values,sep=' ', end='\n')
# sep=' ', end='\n'
在一般的场景下 某些未知项的值是通用的 可以设置一个默认数据，在这些场景下使用的时候 就不用了管这个未知项的值了，会默认使用设置的默认值。在一些特殊的场景下，这个未知项的值发生变化，可以重新给他赋值，执行功能时 使用新值。这个未知项就成为默认参数
例如print 一般场景下 输出完一句话 就以换行结束
但是在一些特殊场景下 比如之前打印* 一行没有打印完不允许换行 就给end重新赋值即可
不定长参数
形式参数的个数不固定
有些功能的未知项的个数不确定 --- 形参个数不确定 ---- 不定长参数
*args
接受多个数据，数据在函数体被元组包含
求多个数的和 --- 封装成一个功能
**kwargs
在接受数据的时候 调用函数传值的时候 数据呢需要有一个标记名 格式 key=value, 类似于关键字参数的传值，在函数体中以字典的形式包含
与关键字参数的区别：
关键参数的key=value中的key 是已存在的形参名
但是在可变参数中key=value中的key 是自定义的
注册的时候 有必填项和选填项
这个选填项可以写 也可以不写
声明函数的时不同参数的位置顺序的注意事项
1.必须参数和默认参数：必须参数排在第一位
2.必须参数和不定长可变参数(*args): 如果*args在前面， 调用函数传值的时候 需要使用关键字参数给必须参数传值
def show1(*args, x):
print(x, args)
show1(12, 34, 6, 67, x=67)
一般建议 必须参数在前 可变参数
3.必须参数和不定长参数(**kwargs): 必须参数在前
4. 注意一点：默认参数必须在必须参数之后， 在不定长参数**kwargs之前
作用域
函数有自身的一个独立的作用范围，这个范围就是这个函数的函数体，在函数内声明的内容，只能作用域函数内部，出了函数没有任何意义
当函数运行完成之后 在内存中会被立即释放
内存 --- 分为不同的区域的
栈区：存储数据的特点先进后出
被调用的函数会存放到栈中， 当函数被执行完时 函数所占的内存会被立即释放
堆区：存放的是除了数字 和 字符串 布尔类型数据之外的其他数据
内存引用计数机制：
对象 -- 地址 --- 对地址被引用有一个计数器 当这个计数器的值为0的时候 这个对象就会在内存中被释放
list0 = [12, 34, 56] # 列表这个对象的引用计数器1
list1 = list0 # 列表这个对象的引用计数器2
list0 = None # 列表这个对象的引用计数器1
list1 = None # 列表这个对象的引用计数器0
方法区：
存放着声明的函数 定义类型
方法压栈 --- 其实说的就是方法的调用
在方法区中拷贝一个调用的函数放在栈中进行调用 调用完成之后把拷贝的那份给释放掉了
全局变量和局部变量
局部变量 --- 在函数中声明的变量，作用范围只在函数体中
生命周期：函数被调用时 它出生 当函数结束时 他被释放
全局变量 --- 在程序中任意位置都可以被访问的数据 就是全局的
声明周期：从被加载的那一刻起 到 程序结束
global
在函数中要修改全局变量的值或者 定义一个全局变量 需要使用关键字global标记， 否则那个变量只是局部
匿名函数
简单功能的函数的简化
lambda 形式参数...:返回值
可以把匿名函数赋值给变量，不然匿名参数只可以用一次
eg:key = len
*key = len(s) 是把len函数运行的值给了key
其中len的功能就传递给key了
324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
