标签：总结 jason res 代码 五天 dict l1 print
本周总结
数据类型
1.整形
大白话意思就是整数
2.浮点型
大白话意思就是小数点
3.字符串
文本型的数据，引号引起来的部分都是字符串
4.列表
可以储存多个数据值，数据值之间用逗号隔开，用中括号括起来的数据[]
5.字典
用大括号括起来的数据{}，字典只能按k取值，因为字典是无序的，没有索引的概念
6.布尔值
判断事物的对错 True False
python中所有数据自带布尔值
储存布尔值的变量名一般使用is开头
7.元组
不可变的列表，元组内部索引绑定的内存地址不能修改
小括号括起来 内部存放多个数据值 数据值之间都用逗号隔开
t1 = (11， 22， 33)
8.集合
集合只能用于重合关系运算
集合内数据只能是不可变类型
大括号括起来内部存放多个数据值 数据值之间用逗号隔开
数据值不是k: v键对值
与用户交互
1.获取用户数据input
username = input('请输入用户名')
2.输入内部信息print
两种使用方式
print 数据值
print(数据值)
格式化输出
1.提前定义好一些内容 将来需要的时候可以方便修改比如：奖状 合同
2.生活中大部分都是使用下划线来提示别人填写内容
但是在程序代码中需要使用占位符：%s %d
info = '%同学你好'
单个占位符
print(info % 'shanlin') #shanlin同学你好
多个占位符
desc = '姓名:%s 年龄:%s 爱好:%s'
# print(desc % ('jason', 18, 'read'))
# print('姓名:%s 年龄:%s 爱好:%s' % ('tony', 28, 'rap'))
运算符
'基本运算符'
1.数学运算符
+ - * / % // **
简化写法
n = 10
n += 1 # n = n + 1
n -= 1 # n = n - 1
n *= 1 # n = n * 1
n /= 1 # n = n / 1
n %= 1 # n = n % 1
n //= 1 # n = n // 1
n **= 1 # n = n ** 1
2.比较运算符
< > <= >= ==(等于号) !=(不等于)
'常用运算符'
链式赋值
交叉赋值
解压赋值
解压赋值在使用的时候需要保证左边与右边变量名个数一致
'逻辑运算符'
主要配合条件一起使用 and 和 and连接的多个条件必须成立结果才成立 or 或者 or连接的多个条件有一个成立，结果就成立
'成员运算符'
判断个体在不在群体内
'身份运算符'
"""
id() 返回一串数字 该数字可以看成是内存地址
"""
is 判断内存地址是否相同
== 判断数据值是否相同
# l1 = [11, 22, 33, 44, 55, 66, 77, 88]
# l2 = [11, 22, 33, 44, 55, 66, 77, 88]
# print(l1 == l2) # True
# print(id(l1))
# print(id(l2))
# print(l1 is l2) # False
# 小整数池
i1 = 11
i2 = 11
print(i1 is i2)
s1 = 'jason jason jason'
s2 = 'jason jason jason'
print(s1 is s2)
不同的环境下可能优化的程度不一样
"""
了解值相同 内存地址可能不同
内存地址相同 值肯定相同
"""
垃圾回收机制
1.引用计数
当数据值圣上的引用计数为零0的时候就会被垃圾回收机制回收
当数据值不为0就不会被回收
2.标记清除
主要是针对循环引用问题
当内存占用达到临界值的时候，程序会自动停止，并且扫描程序中所有数据，并且打上标记，之后一次性清除
3.分带回收
垃圾回收机制频繁运行也会消耗资源
越往下检测频率越低
流程控制理论
1.顺序结构
从上往下执行
2.分支结构
事物的执行会根据条件的不同做出不同的执行策略
3.循环结构
事物会根据某个条件出现反复重合
在代码里，很多时候可能会出现三者混合
流程控制必备知识
1.python中使用代码缩进的表示代码的从属关系(缩进代码简称子代码)
从属关系：子代码是否执行取决于上方的非子代码
2.不是所有代码都可以拥有子代码
if关键字
3.如果多行子代码属于一个父代码 子代码必须保证相同的缩进量
python对缩进量没要求 但是一般使用4个空格(快捷键tab)
4.只要代码的缩进量相同 就按照顺序依次执行
5.如果一行代码需要编写子代码 那么结尾一定需要冒号 :
分支结构
单 if 分支结构
if条件:
条件成立后才会执行代码块
if else 分支结构
if 条件：
条件成立之后执行的子代码
else
条件不成立执行的子代码
if的嵌套使用
4.if的嵌套使用(有点难)
age = 28
height = 170
weight = 110
is_beautiful = True
is_success = False
username = 'tony'
if username == 'tony':
print('tony发现目标')
if age < 30 and height > 160 and weight < 150 and is_beautiful:
print('大妹纸 手机掏出来 让我加微信')
if is_success:
print('吃饭 看电影 天黑了...')
else:
print('去你妹的 流氓!!!')
else:
print('不好意思 认错人了')
else:
print('不是tony做不出来这件事')
循环结构
就是想一些代码反复运行
while 条件：
条件成立之后执行的子代码(循环体代码)
1.先判断条件是否成立
2.如果成立执行循环体代码
3.循环体代码执行完毕后再次回到条件判断处 判断条件是否成立
4.成立的话就继续执行循环体代码
5.按照规律执行，直到条件不成立才会结束循环体代码的执行
while 条件：
循环体代码
else：
循环体代码没有被强制结束的情况下 执行完毕就会执行else子代码
1.死循环
无法靠自生控制终止的循环 在编辑中无法靠自身终止的程序
一定要避免长时间死循环 除非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循环在一些场景下使用更简单
主要场景为：循环获取多个数据的数据内部数据值
for循环语法结构
for 变量名 in 带遍历数据
for循环代码
for循环特点
1.擅长遍历取值
2.不需要结束条件 遍历完就可以自动结束
for循环主要的遍历的数据类型有(常见的 字符串 列表 元组 字典 集合)
for循环语法结构中的变量名如何命名
看到啥意思就是啥意思
如果遍历出来的数据没有具体含义就用常见的
i k j v
for循环代码中如果运行到break 会直接结束整个for循环
for循环代码中如果运行到了continue也会结束当前循环并且直接开始下一次循环
for 变量名 in 待遍历的数据：
for循环代码
else：
for循环体代码没有被break强制结束的情况下运行完毕后运行
range方法
range语法:range(start, stop[,stpe]);start指的是计数起始值 默认是0 ， stop指的是计数结束值， step是步长 默认为一 不可以为零
range()方法生成一段左闭右开的整数范围
简单来说就是帮我们产生一个内部含有多个数字的数值
for i in range(1001): # 起始位置为0 终止位置为1000
print(i)
for i in range(100, 200): # 第一个为起始位 第二个终止位
print(i)
for i in range(100, 200,50): 第三个 为等差数值 不写默认是1
print(i)
在python2中
range()直接产生一个列表 内部含有多个数值
xrange()其实就是python3中的range
在python3中
range() 在python3中类似于一个工厂 需要就生产
数据类型的内置方法理论
1.我们之前学过的每一种数据类型都有一系列的操作方法，内置方法是最多的，
内置方法就是本身自带的功能在python中数据类型调用的方式是句点符
比如 'suttn'. 就可以调用字符串内置方法
要用绑定字符串的变量名加上 . 号 (键盘问号边上那个)就可以使用内置方法
整形的内置方法操作
1.类型转换 将其他数据转换成整形
int(其他数据类型)
浮点型可以直接转，字符串取整数
2.进制数转换
print(bin(100)) # 0b1100100 # 二进制
print(oct(100)) # 0o144 #八进制
print(hex(100)) # 0x64 #十六进制
开头为0b是二进制 0o是八进制 0x是16进制
print(int("0b1100100", 2))
print(int("0x64", 16))
print(int("0o144", 8))
就可以转换为10进制
！！pyython这门语言对数字的敏感度很低
浮点型的内置方法与操作
类型转换
float(别的数据类型)
字符串里面可以出现一个小数点，只可以一个多了不要
而且其他必须都是纯数字
字符串的内置方法与操作
str(其他任意数值)
可以转换任意数据，但是要在前后加上引号
1.索引取值
s1 = '12345678' 起始值为0，超出立马报错
print(s1[0])
print(s1[-1]) 支持复数
2.切片取值
s1 = '123456789'
print(s1[1:5]) # 索引1一直取到索引4
print(s1[--5:-1]) # 默认顺序从左往右
3.修改切片方向(间隔)
print(s1[1:5:1]) # 默认值是1
print(s1[1:5:2]) #改成2 代码取值13
print(s1[:] # 不填写数字就是默认都要
4.统计字符串中的个数
#关键字len
print(len(s1)) # 用于统计有多少个数
5.移除字符串字符串首尾指定的字符
# 关键字 strip 去除首尾空格
mane = '##pig##'
print(mane.strip('#')) # 首尾都去除
print(mane.lstrip('#')) # 首部去除
print(mane.rstrip('#')) # 尾部去除
6.切割字符中的指定符号
#关键字split
res = 'ping|456|song'
print(res.split('|')) 该处理方法是变成列表
#['ping', '456', 'song']
name, pwd, hobby = res.split('|')
print(res.split('|', maxsplit=1))#从左往右切指定个数
#['ping', '456|song']
print(res.rsplit('|',maxsplit=1)) #从右往左切指定个数
['ping|456', 'song'] #从右往左切指定个数
7.字符串格式化输出
format第一种等同于占位符
res = 'my name is {} my age is {}'.format('123', '456')
print(res)
# my name is 123 my age is 456
format第二种索引取值并且支持反复使用
res = 'my name is {0} my age is {1{0{0{1}'.format('7878', 9696)
print(res
# my name is 7878 my age is 9696 7878 7878 9696
format第三种
name = input('username>>>:')
age = input('age>>>:')
res = f'my name is {name} my age is {age}'
print(res)
# username>>>:jame
# age>>>:99
# my name is jame my age is 99
format第四种
res = 'my name is {name1} my ag{age1}'.format(name1='jason', age1=123)
print(res)
# my name is jason my age is 123 jason 123 jason 前面说到过format第一种方法相当于占位符，使用到此代码，见名之意
8.字符串需要了解的方法
# upper lower 关键字
res = 'YUTYjis SJAJ JSAJ 666'
print(res.upper()) # YUTYJIS SJAJ JSAJ 666
# 把所有英文字母打印成大写
print(res.lower()) # yutyjis sjaj jsaj 666
# 把所有英文字母打印成小写
9.判断字符串中是否为纯数字
res = 'YUTYjis SJAJ JSAJ 666'
print(res.upper()) # YUTYJIS SJAJ JSAJ 666
# 把所有英文字母打印成大写
print(res.lower()) # yutyjis sjaj jsaj 666
# 把所有英文字母打印成小写
10.字符串的拼接
res = 'YUTYjis SJAJ JSAJ 666'
print(res.upper()) # YUTYJIS SJAJ JSAJ 666
# 把所有英文字母打印成大写
print(res.lower()) # yutyjis sjaj jsaj 666
# 把所有英文字母打印成小写
11.统计字符串出现的次数
res = 'ddddyyyyooooshkajdhka'
print(res.count('y')) 出现四次
12.判断字符串开头或者结尾
res = 'name king in for ture'
print(res.startswith('n')) # True
print(res.startswith('na')) # True
print(res.startswith('nam')) # True
print(res.startswith('name')) # True
print(res.startswith('king')) # False
print(res.startswith('k')) # False
列表的内置方法及操作
1.类型转换
list()任意数据类型 能被for循环的数据类型都可以转换成列表
list('i')
print(list('kping'))
print(list({'qwer': 'asdf', 'fgh': 369}))
print(list((6, 2, 3, 4)))
print(list({1, 2, 3, 4, 5}))
# ['k', 'p', 'i', 'n', 'g']
# ['qwer', 'fgh']
# [6, 2, 3, 4]
# [1, 2, 3, 4, 5]
需要掌握的方法：
l1 = [118, 272, 393, 4464, 5535, 6676, 7377, 8388]
print(l1[0]) # 118 索引取值
print(l1[-1]) # 8388
print(l1[0:5]) # [118, 272, 393, 4464, 5535]
print(l1[:]) # [118, 272, 393, 4464, 5535, 6676, 7377, 8388] 切片操作
print(l1[::-1]) 间隔数 方向
# [8388, 7377, 6676, 5535, 4464, 393, 272, 118]
print(len(l1)) # 8 统计列表数据值
l1[4] = 6666 # 数据值修改
print(l1)
# [118, 272, 393, 4464, 6666, 6676, 7377, 8388]
l1.append('我好菜') # 尾部追加数据1
print(l1)
# [118, 272, 393, 4464, 5535, 6676, 7377, 8388, '我好菜']
l1.append(['963, 666, 666']) # 尾部追加数据2
print(l1)
#[118, 272, 393, 4464, 5535, 6676, 7377, 8388, ['963, 666, 666']]
l1.insert(0, 'jason') 任意位置插入数据值
print(l1)
# ['jason', 118, 272, 393, 4464, 5535, 6676, 7377, 8388]
ll1 = [11, 22, 33]
ll2 = [44, 55, 66]
print(ll1 + ll2) 合并列表
# [11, 22, 33, 44, 55, 66]
ll1.extend(ll2) # for循环+append
print(ll1)
for i in ll2:
ll1.append(i)
print(ll1)
del l1[0] # 删除关键字 del
print(l1)
l1.remove(444) # 括号内填写数据值 remove
print(l1)
l1.pop(3) # 括号内填写索引值 pop
print(l1)
l1.pop() # 默认尾部弹出数据值
print(l1)
res = l1.pop(3) # 4464
print(res)
8.排序
ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.sort() # 默认是升序
print(ss) # [12, 33, 43, 54, 55, 76, 76, 88, 99, 99, 100]
ss.sort(reverse=True)
print(ss) #改为降序
# [100, 99, 99, 88, 76, 76, 55, 54, 43, 33, 12]
9.统计列表中某个数据值出现的次数
print(l1.count(111))
10.颠倒列表顺序
l1.reverse()
print(l1)
可变类型与不可变类型
s1 = '$$jason$$'
l1 = [11, 22, 33]
s1.strip('$')
print(s1) # $$jason$$
字符串在使用内置方法后不会修改自己 二十产生了一个新结构
如何查看使用方法之后有没有新结果 可以在调用方法的代码左侧添加变量名和赋值符号
res = s1.strip('$')
l1 = [11, 22, 33]
ret = l1.append(44)
print(l1) # [11, 22, 33, 44]
print(ret) # Nome
列表在调用内置方法后 没有产生新的结果
可变类型:值改变 内存地址不变
l1 = [11, 22, 33]
print(l1) # [11, 22, 33]
print(id(l1)) # 2374029652544
l1.append(44)
print(l1) # [11, 22, 33, 44]
print(id(l1)) # 2374029652544
# 不可变类型:值改变 内存地址肯定变
res = '$$hello world$$'
print(res)
print(id(res))
res.strip('$')
print(res)
print(id(res))
字典的相关操作和内置方法
1.类型转换
关键字 dict()
字典使用转换太麻烦了，所以一般不推荐使用，建议手动转
2.字典必须掌握的操作 # 这是按k取值不推荐
user_dict = {'username': 'pig', 'password': 111,
'happy': ['ren', 'misuy', 'rong']}
print(user_dict['username']) ## pig
print(user_dict[poiu]) # k不在字典会直接报错
#### 这是按内置方法get取值
print(user_dict.get('username')) # pig
print(user_dict.get('kkkkkkk')) # None
print(user_dict.get('kkkkk', '你瞎了吗')) # 你瞎了吗
## 内置方法get取值如果字典内没有键会默认返回None，所以可以通过第三行代码展示第二个参数自定义返回名称
### 这是修改数据值
user_dict['username'] = 'oiuio'
print(user_dict) # username 中的pig 修改成 oiuio
### 这是新增键对值
user_dict['moye'] = 1996
print(user_dict) # 会在字典内最末端增加 'moye': 1996
### 这是删除数据
del user_dict['happy'] # 删除happy
print(user_dict)
res = user_dict.pop('username')
print(user_dict) # 和上面一样的意思 删除username
print(res) # pig # 只要username所对应的值
### 这是统计字典中统计键值对的个数
print(len(user_dict)) # 3个
### 字典三大常用
1.一次性获取所有键
print(user_dict.keys()) # 值去掉取键
# dict_keys(['username', 'password', 'happy'])
2.一次性获取字典所有的值
print(user_dict.values()) # 键去掉取值
# dict_values(['pig', 111, ['ren', 'misuy', 'rong']])
3.一次性获取所有键值对的数据值
print(user_dict.items())
# dict_items([('username', 'pig'), ('password', 111), ('happy', ['ren', 'misuy', 'rong'])])
'当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'
元组的内置方法与操作
1.类型转换
tuple()
只要是支持for循环的数据类型都可以转换成元组
2.元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66)
# 1.索引取值
print(t1[]) 填入需要的取值 起始值为0 支持复数
# 2.切片操作
print(t1[ : ]) 默认顺序从左往右 可以使用复数修改方向
# 3.间隔，方向
print(t1[ : : ]) 第三个不填默认是1
# 4.统计元组内的数据值个数
print(len(t1))
# 5.统计元组内指定数值出现次数
print(t1.count(11))
# 6.统计元组内指定数据值的索引值
print(t1.index(22))
# 7.元组内只有一个值逗号不能少
# 8.元组内索引绑定的内存地址不能被修改
# 9.元组不能新增或者删除数据
集合内置方法与相关操作
1.类型转换
set()
集合内数据必须是不可变类型(整形 浮点型 字符串 元组)
集合内数据是无序数据 没有索引的概念
2.集合需要掌握方法
去重
关系运算
只有碰到上述两种需求才考虑使用集合
3.去重
t1 = {1, 2, 3, 1, 1, 1, 2, 2, 2, }
l1 = [1, 6, 1, 4, 6, 3, 8, 9, 9, ]
t1 = set(l1)
l1 = list(s1)
print(l1)
集合的去重无法保留原先数据的排列顺序
4.关系运算
全体之间做差异化校验
eg：两个QQ号之间有不同的好友 和相同的好友
w1 = {'pig', 'jason', 'jerry', 'oscar'} # 用户1的好友列表
w2 = {'pig', 'jason', 'tom', 'tony'} # 用户2的好友列表
# 1.求两个人的共同好友
print(w1 & w2) # {'pig', 'jason'}
# 2.求用户1独有的好友
print(w1 - w2) # {'jerry', 'oscar'}
# 3.求两个人所有的好友
print(w1 | w2)
# {'jerry', 'tom', 'pig', 'tony', 'oscar', 'jason'}
# 4.求两个人各自独有的好友
print(w1 ^ w2)
# {'oscar', 'jerry', 'tom', 'tony'}
# 5.父集 子集
print(w1 > w2) # False
print(w1 < w2) # False
标签：总结,
jason,
res,
代码,
五天,
dict,
l1,
print
From： https://www.cnblogs.com/lsl1/p/16767269.html