标签：总结 123 res guts 第二周 dict l1 print
第二周总结
type(数据值)/type(变量名)查看数据值的类型
数据类型之整形int
大白话意思就是整数
应用场景：年龄 班级人数 年份
代码实现：
age = 22
stu_num = 66
year = 2022
整形内置方法与操作
1.类型转换(将其他数据类型钻换成整形)
int(其他类型数据)
ps：浮点型可以直接转换 字符串必须满足内部是纯数字才可以
2.进制数转换
十进制转换其他禁止
print(bin(100)) #0b1100100
print(oct(100)) #0o144
print(hex(100)) #0x64
'''
数字的开头如果是0b则为二进制 0o则为八进制 0x则为十六进制
'''
3.python自身对数字的敏感度较低(精确度低)
python这门语言其实真的一点都不厉害 主要是因为他背后有太多的大佬
如果需要精准的计算需要借助与模块numpy....
数据类型之浮点型float
大白话意思就是小数
应用场景：身高 体重 薪资
代码实现：
height = 1.99
weight = 66.6
salary = 4.5
数据类型之字符串str
大白话的意思就是文本类型的数据：引号引起来的部分都是字符串
应用场景：姓名 地址 爱好
代码实现;
name = 'guts'
addr = '上海'
hobby = '学习'
1.定义字符串有四种方式
name = 'guts'
name1 = "guts"
name2 = '''guts'''
name3 = """guts"""
2.为什么定义字符串需要有多种方式
我们在字符串中编写文本也可能会使用到引号 为了避免冲突 有了多种方式
info = "Jason老师说:'年轻不是用来挥霍的资本'"
3.如何区分三引号是字符串还是注释
关注左侧是否韩游赋值符号和变量名 如果有则为字符串 没有就为注释
字符串内置方法与操作
1.类型转换
str(其他数据类型)
ps:可以转换任意数据类型(只需要再前后加引号即可)
2.必须要掌握的方法
1.索引取值(起始位置0开始 超出范围直接报错)
s1 = 'hello word'
print(s1[0]) # h
print(s1[-1]) # d 支持负数 从末尾开始
2.切片操作
print(s1[1:5]) # ello 顾头不顾尾 从索引1一直切到索引4
print(s1[-1:-5]) # 默认顺序是从左往右 不能这么输
print(s1[-5:-1]) # 顾头不顾尾
3.修改切片的方向(间隔)
print(s1[1:5:1]) # 默认是1 第三个数字为间隔数
print(s1[1:5:2]) # el
print(s1[-1:-5:-1]) # dlro
print(s1[:]) # 不写数字就默认都要
print(s1[2:]) # 从索引2开始往后都要
print(s1[:5]) # 从索引0开始要到4
print(s1[::2]) # 每隔两个拿一个
4.统计字符串中字符的个数
print(len(s1))
5.移除字符串首尾指定的字符
username = input('username:').strip()
username = username.strip()
res = '$$guts$$'
print(res1.strip('$')) # guts
print(real.lstrip('$')) # guts$$
print(real.rstrip('$')) # $$guts
6.切割字符串中指定字符
res = 'guts|123|study'
print(res.split('|')) # ['guts', '123', 'study'] 该方法的处理结果是一个列表
name, pwd, hobby = res.split('|')
print(res.split('|', maxsplit=1)) #['guts'.'123|study'] # 从左往右切指定个数
print(res.rsplit('|', maxsplit=1)) #['guts|123', 'study'] # 从右往左切指定个数
7.字符串格式化输出
format玩法1：等价于占位符
res = 'my name is {} my age is {}'.format('guts',123)
print(res) # 大括号中的数字为.format()中的索引位置
format玩法2：索引取值并支持反复使用
res = 'my name is {0} my age is {1} {0} {1}'.format('guts', 123)
print(res)
format玩法3：占位符见名知意
res = 'my name is {name1} my age is {age1}'.format(name1 = 'gust', age1 = 123)
print(res)
format玩法4：推荐使用(*******)
name = input('name:')
age = input('age:')
res = f'my name is {name} my age is {age}'
print(res)
3.字符串需要了解的用法
1.大小写相关
res = 'hELlo WoRld 666'
print(res.upper()) # HELLO WORLD 666
print(res.lower()) # hello world 666
'''图片验证码：生成没有大小写统一的验证码 展示给用户看
获取用户输入的验证码 讲用户输入的验证码和当初生成的验证码统一转大写或小写再比对
'''
code = 'Bja6Cc'
print('展示给用户看到图片验证码'，code)
confirm_code = input('请输入验证码').strip()
if confirm_codde.upper() == code.upper():
print('验证码正确')
res = 'hello world'
print(res.isupper()) # 判断字符串是否是纯大写 Flase
print(res.islower()) # 判断字符串是否是纯小写 True
2.判断字符串是否是纯数字
res= ''
print(res.isdigit()) # False
guess_age = input('guess_age>>>:').strip()
if guess_age.isdigit():
guess_age = int(guess_age)
else:
print('年龄都不知道怎么输？')
3.替换字符串中指定的内容
res = 'my name is guts guts guts guts'
print(res.replace('guts', 'tonySB')) # my name is tonySB
print(res.replace('guts', 'tonySB', 1)) # my name is tonySB guts guts 从左往右替换指定个数的内容
4.字符串的拼接
ss1 = 'hello'
ss2 = 'world'
print(ss1 + '$$$' + ss2) # hello$$$world
print(ss1 * 10) # hellohellohellohellohellohellohellohellohellohello
print('|'.join(['guts','123','read','DBJ'])) # guts|123|read|DBJ
print('|'.join(['guts',123]) # 报错 参与拼接的必须都是字符串
5.统计指定字符出现的次数
res = 'hello world'
print(res.count('1')) # 3
6.判断字符串开头或者结尾
res = 'guts say hello'
print(res.startswith('guts')) # Ture
print(res.startswith('g')) # Ture
print(res.startswith('s')) # False
print(res.endswith('o')) # Ture
print(res.endswith('llo'))
print(res.endswith('hello'))
print(res.endswith('he')) # False
7.其他方法补充
res = 'hello woRLd HeLLo worLD'
print(res.title()) # Hello World Hello World
print(res.capitalize()) # Hello world hello world
print(res.swapcase()) # HELLO WOrlD hEllo WORld
print(res.index('o')) # 所选字符在字符串中的数量
print(res.find('o'))
print(res.index('c')) # 找不到直接报错
print(res.find('c')) # 找不到默认返回-1
print(res.find('lo')) # 索引字符串在字符串中的位置
数据类型之列表list
大白话意思就是可以储存多个数据值的类型 并且可以非常方便的取
应用场景：存储多个数据值 并且将来可能需要单独取其中一些
代码实现：
name_list = ['guts', 'tony', 'kevin', 'jason', 'jerry']
1.列表的文字描述
中括号括起来 内部可以存放多个数据值 数据值与数据值之间逗号隔开
l1 = [11, 11.11, 'guts',[11, 22]]
2.索引取值
起始数字是从0开始
l1[索引值]
列表内置方法及操作
1.类型转换
list(其他数据类型)
ps:能够被for循环的数据都可以转成列表
print(list('hello'))
print(list{'name':'guts', 'pwd':123})
print(list((1,2,3,4)))
print(list({1,2,3,4,5}))
2.需要掌握的方法
l1 = [111, 222, 333, 444, 555, 666, 777]
1.索引取值(正负数)
print(l1[0]) # 111
print(l1[-1]) # 777
2.切片操作 与字符串讲解操作一致
print(l1[0:5]) # [111, 222, 333, 444, 555]
print(l1[:]) # [111, 222, 333, 444, 555, 666, 777]
3.间隔数 方向 与字符串讲解操作一致
print(l1[::-1])
4.统计列表中数据值的个数
print(len(l1)) # 7
5.数据值修改
l1[0] 123 # 按照索引位置
print(l1)
6.列表添加数据值
方式1：在尾部追加数据值
l1.append('干饭')
print(l1) # [123, 222, 333, 444, 555, 666, 777, '干饭']
l1.append(['guts','jason','kevin','jerry'])
print(l1) # [123, 222, 333, 444, 555, 666, 777, ['guts', 'jason', 'kevin', 'jerry']]
方式2：扩展列表 合并列表
ll1 = [11.22.33]
ll2 = [44,55,66]
print(ll1+ll2) # [11, 22, 33, 44, 55, 66]
ll1.extend(ll2) # for循环+append
print(ll1) # [11, 22, 33, 44, 55, 66]
for i in 112:
ll1.append(i)
print(ll1) # [11, 22, 33, 44, 55, 66]
7.删除列表数据
方式1：通用的删除关键字del
del l1[0]
print(l1)
方式2：remove
l1.remove[444] # 括号内填写数据值
print(l1)
方式3：pop
l1.pop(3) # 括号内填写索引值
print(l1)
l1.pop() # 默认尾部弹出数据值
print(l1)
res = l1.pop(3)
print(res) # 444
res1 =l1.remove(444) # 直接销毁
print(res1) # None
8.排序
ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.sort() # 默认是升序
print(ss)
ss.sort(reverse = True)
print(ss) # 改为降序
9.统计列表中某个数据值出现的次数
print(l1.count(111))
10.颠倒列表顺序
l1.reverse()
print(l1)
数据类型之字典dict
能够非常精确的存储和表达数据值的含义
代码实现：
info_dict = {
'username': 'guts'
'age': 22
'hobby': 'read'
}
1.字典的文字描述
大括号括起来 内部可存放多个数据 数据的组织方式是K:V键值对
键值对与键值对之间用逗号隔开
K是对V的描述性性质的信息(解释说明) 一般都是字符串类型
V是真正的数据值 可以是任意数据类型
2.按K取值
字典只能按K取值 因为字典是无序的 没有索引的概念
info_dict['username']
字典内置方法相关操作
1.类型转换
dict()
字典的转换一般不使用关键字 而是自己手动转
2.字典必须要掌握
user_dict = {
'username': 'guts',
'password': 123,
'hobby': ['sing', 'jump', 'basketball']
}
1.按k取值(不推荐使用)
print(user_dicy['username']) # guts
print(user_dict['phone']) # k不存在会直接报错
2.按内置方法get取值(推荐使用)
print(user_dict.get('username')) # guts
print(user_dict.get('age')) # None
print(user_dict.get('username', '没有 给爷爬')) # guts 键存在的情况下获取对应的值
print(user_dict.get('phone', '没有 快爬')) # 没有 快爬 键不存在的情况下默认返回None 可以通过第二个参数字定义
3.修改值的数据
print(id(user_dict))
user_dict['username'] = 'tony' # 键存在则修改对应的值
print(id(user_dict))
print(user_dict)
4.新增键值对
user_dict['age'] = 18 # 键不存在则新增键值对
print(user_dict)
5.删除数据
del user_dict['username']
print(user_dict) # {'password': 123, 'hobby': ['sing', 'jump', 'basketball']}
res = user_dict.pop('password')
print(res) # 123
6.统计字典中键值对的个数
print(len(user_dict)) # 3
7.字典中的三剑客
print(user_dict.keys()) # 一次性获取字典中的所有键 dict_keys(['username', 'password', 'hobby'])
print(user_dict.values()) # 一次性获取字典中所有的值 dict_values(['jason', 123, ['read', 'music', 'run']])
print(user_dict.iteam()) # 一次性获取字典的键值对数据 dict_items([('username', 'jason'), ('password', 123), ('hobby', ['read', 'music', 'run'])])
for i in user_dict.items:
k, v = i
print(k,v)
'''
username guts
password 123
hobby ['sing', 'jump', 'basketball']
'''
8.补充说明
print(dict.fromkeys(['name','pwd','hobby',123])) # 快速生成值相同的字典
res = dict.fromkeys(['name','pwd','hobby'], [])
print(res) # {'name': [], 'pwd': [], 'hobby': []}
res['name'].append('guts')
res['pwd'].append(123)
res['hobby'].append('study')
print(res) # {'name': ['guts', 123, 'study'], 'pwd': ['guts', 123, 'study'], 'hobby': ['guts', 123, 'study']}
'''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''
res = user_dict.setdefault('username','tony')
print(user_dict, res)
res = user_dict.setdefault('age',123)
print(user_dict, res) # 键不存在则新增键值对 结果是新增的值
user_dict.popitem() # 弹出键值对 后进先出
基本数据类型之布尔值bool
1.用来判断事物的对错 是否可行 主要用于流程控制中
2.只有两种状态
Ture 对的 真的 可行的
False 错的 假的 不可行的
3.python中所有数据值都带有布尔值
布尔值为Flase的数据有：0 None '' [] {}
布尔值为Ture的数据值有：出了上面的都是Ture
4.存储布尔值的变量名一般推荐使用is开头
is_delete = Flase
is_alive = Ture
"""
很多程序中提供的注销账户功能其实底层没有删除数据 而是修改了数据的中泰
id username password phone is_delete
1 jason 123 110 1
2 kevin 321 120 0
"""
基本数据类型之元组tuple
1.也成为 '不可变'的列表
元组内索引绑定的内存地址不能修改
2.小括号括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 数据值可以是任意数据类型
3.代码实现
t1 = (11, 22, 'guts')
4.元组与列表的对比
l1 = [11, 22, 33]
print(l1[0]) # 获取索引0所对应的数据值
l1[0] = 666
print(l1) # [666, 22, 33]
t1 = (11, 22, [111, 222])
print(t1[0]) # 11
t1[0] = 999 # 报错
t1[2][1] = 666
print(t1) # (11, 22, 33, [111, 666])
5.元组内如果只有一个数据值
t1 = (1)
t2 = (11, 11)
t3 = ('jason')
print(type(t1),type(t2),type(t3)) # <class 'int'> <class 'float'> <class 'str'>
t1 = (1,)
t2 = (11.11,)
t3 = ('jason',)
print(type(t1), type(t2), type(t3)) # <class 'tuple'> <class 'tuple'> <class 'tuple'>
"""
建议:以后在使用可以存放多个数据值的数据类型时 如果里面暂时只有一个数据值 那么也建议你加上 逗号
"""
元组相关操作
1.类型转换
tuple()
ps:支持for循环的数据类型都可以转成元组
2.元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66)
1.索引取值
2.切片操作
3.间隔，方向
4.统计元组内数据值的个数
print(len(t1))
5.统计元组内某个数据值出现的次数
print(t1.count(l1))
6.统计元组内指定数据值的索引值
print(t1.index(22))
7.元组内如果只有一个数据值那么逗号也不能省略
8.元组内索引值绑定的内存地址不能修改 (注意区分 可变与不可变)
9.元组不能新增或者删除数据
基本数据类型之集合set
1.集合只能用于去重和关系运算
2.集合内数据只能是不可变类型
3.大括号括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 数据值不是K:V键值对
4.代码实现
a1 ={1, 2, 3, 4, 5, 6}
5.定义空集合与空字典
{} 默认是字典
set{} 定义空集合
集合相关操作
1.类型转变
set()
集合内数据必须是不可变类型(整形 浮点型 字符串 元组)
集合内数据是无序的 没有索引的概念
2.集合需要掌握的方法
去重
关系运算
ps：只有遇到上述两种需求的时候才会考虑使用集合
3.去重
l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
s1 = set(l1)
l1 = list(s1)
print(l1) # [33, 11, 22]
'''集合的去重无法保留原先数据的排列顺序'''
4.关系运算
群体之间做差异化校验
eg：两个微信账户之间 有不同的好友 有相同的好友
f1 = {'jason', 'tony', 'jerry', 'oscar'} # 用户1的好友列表
f2 = {'jack', 'jason', 'tom', 'tony'} # 用户2的好友列表
1.求两个人的共同好友
print(f1 & f2)
2.求用户1独有的好友
print(f1 - f2)
3.求两个人所有的好友
print(f1 | f2)
4.求两个人各自独有的好友
print(f1 ^ f2)
5.父级 子集
print(f1 > f2)
print(f1 < f2)
垃圾回收机制
1.引用计数
name = 'guts' 数据值guts身上的引用计数为1
name1 = name 数据值guts身上引用的计数加一 为2
del name1 数据值guts身上的引用计数减一 为1
当数据值身上的引用计数为0的时候 就会被垃圾回收机制当作垃圾回收掉
当数据值身上的引用计数不为0的时候 永远不会被垃圾回收机制回收
2.标记清除
主要针对循环引用问题
l1 = [11, 22] # 引用计数为1
l2 = [33, 44] # 引用计数为1
l1.append(l2) # l1 = [11, 22, l2列表] 引用计数为2
l2.append(l1) # l2 = [33, 44, l1列表] 引用计数为2
del l1 # 断开变量名l1与列表的绑定关系 引用计数为1
del l2 # 断开变量名l2与列表的绑定关系 引用计数为1
当内存占用达到临界值的时候 程序会自动停止 然后扫描程序中所有的数据
并给只产生循环引用的数据打上标记 之后一次性清除
3.分代回收
垃圾回收机制的频繁运行也会损耗各项资源
新生代、青春带、老年代（越往下渐层频率越低）
流程控制理论
流程控制>>>:控制事物的执行流程
事物执行流程总共可以分为三种
1.顺序结构
从上往下依次执行 我们之前所编写的代码都属于该结构
2.分支结构
事物的实行会根据条件的不同做出不同的执行策略
3.循环结构
事物的执行会根据某个条件出现重复
ps：在代码的世界里 很多时候可能会出现三者混合
1.python中使用代码的缩进来表示代码的从属关系
从属关系：缩进的代码（子代码）是否执行取决于上面有没有缩进
2.并不是所有的代码都可以拥有缩进的代码（子代码）
if关键字
3.如果有多行子代码属于同一个父代码 那么这些子代码需要保证相同的缩进量
4.python中针对缩进量没有具体的要求 但是推荐使用四个空格（Windows中的tab）
5.当某一行代码需要编写子代码的时候 那么这一行代码的结尾肯定需要冒号
6.相同的缩进量的代码彼此之间平起平坐 按照顺序结构依次执行
1.单if分支结构
if条件：
条件成立之后才会执行的代码块
ps：单if可以借助于流程控制图理解
username = input('username>>>:')
if username == 'guts':
print('老师好')
2.if...else...分支结构
if 条件：
条件成立之后执行的子代码
else：
条件不成立执行的子代码
username = input('username>>>:')
if username == 'jason':
print('老师好')
else:
print('去你妹的')
3.if...elif...else分支结构
if 条件1：
条件1成立之后执行的子代码
elif 条件2：
条件1不成立 条件2成立执行的子代码
elif 条件3：
条件1和2都不成立 条件3成立执行的子代码
else：
上述条件都不成立 执行的子代码
ps：中间的elif可以写多个、上述的子代码永远只会走一个
score = input('请输入学生成绩>>>:')
score = int(score) #将字符串的证书转换成整型的整数
if score >= 90:
print('A')
elif score >= 80:
print('B')
elif socre >= 70:
print('C')
elif socre >= 60：
print('D')
else:
print('挂科 交钱重修')
4.if的嵌套使用(有点难)
age = 22
height = 170
weight = 110
is_beautiful = True
is_success = False
username = 'tony'
if username == 'tony':
print('tony发现目标')
if age < 25 and height > 165 and weight < 120 and is_beautiful:
print('宝宝恰个V')
if is_success:
print('吃饭 看电影 一起吃早饭')
else:
print('不要呀！')
else：
print('不好意思 打扰了')
else:
print('不是tony干不出来这种事')
流程循环之while结构
就是想让一些代码反复的执行
while 条件：
条件成立之后执行的子代码(循环体代码)
1.先判断条件是否成立
2.如果成立则执行循环体代码
3.循环体代码执行完毕后再次回到条件判断处 判断条件是否成立
4.如果成立 则继续实行循环体代码
5.按照上述规律依次执行 知道条件不成立才会结束循环体代码的执行
count = 1
while count < 5:
print('hello world')
count += 1
print('想不想干饭')
break # 强行结束循环体
while循环体代码一旦执行得到break会结束循环
continue # 直接跳到条件判断出
while循环题代码一旦实行到continue会结束本次循环 开始下一次循环
while 条件：
循环体代码
else：
循环体代码没有被强制结束的情况下 执行完毕就会执行else子代码
1.死循环
真正的死循环是一旦执行 CPU功耗会急速上升 直到系统采取紧急措施
尽量不要让CPU长时间不间断运算
2.嵌套及全局标志位
强调:一个break只能结束它所在的那一层循环
强调:有几个while的嵌套 想一次性结束 就应该写几个break
强调:如果不想反复写break 可以使用全局标志位
is_flag = True
while is_flag:
username = input('username>>>:')
password = input('password>>>:')
if username == 'jason' and password == '123':
while is_flag:
cmd = input('请输入您的指令>>>:')
if cmd == 'q':
is_flag = False
print('正在执行您的指令:%s' % cmd)
else:
print('用户名或密码错误')
流程控制之for循环
for循环能够做到的事情while都可以做到 只不过for循环在一些场景下使用更简单
主要场景为:循环获取存储多个数据的数据内部数据值
实际案例:
name_list = ['jason', 'kevin', 'tony', 'oscar'] # 遍历
# 循环打印出列表中每一个数据值(while 索引取值>>>:超出范围会报错)
# count = 0
# while count < 4:
# print(name_list[count])
# count += 1
# for循环
for i in name_list:
print(i)
for循环语法结构
for 变量名 in 待遍历的数据:
for循环体代码
for循环特点
1.擅长遍历取值
2.不需要结束条件 自动结束(遍历完)
for循环主要遍历的数据类型有(常见有 字符串、列表、元组、字典、集合)
info = 'hello world'
for i in info:
print(i) # 单个单个字符
d = {'username': 'jason', 'password': 123}
for i in d:
print(i) # 只有键参与遍历
for循环语法结构中的变量名如何命名
1.见名知意
2.如果遍历出来的数据值没有具体的含义 可以使用常用的
i j k item v
for循环体代码中如果执行到break也会直接结束整个for循环
for循环体代码中如果执行到continue也会结束当前循环直接开始下一次循环
for 变量名 in 待遍历的数据:
for循环体代码
else:
for循环体代码没有被break强制结束的情况下运行完毕之后 运行
range方法
range可以简单的理解为是帮我们产生一个内部含有多个数字的数据
for i in range(101): # 起始位置为0 终止位置为100
print(i) # [0,.......100]
for i in range(10, 20): # 第一个为起始位置 第二个终止位置
print(i)
for i in range(1, 20, 2): # 第三个数为等差值 默认不写为1
print(i)
"""
在python2中
range()
直接产生一个列表 内部含有多个数值
xrange()
其实就是python3里面的range
在python3中
range()
类似于一个工厂 不会占用太多的内存空间 要就生产
"""
标签：总结,
123,
res,
guts,
第二周,
dict,
l1,
print
From： https://www.cnblogs.com/DragonY/p/16767471.html