循环，终止，字符换格式化
while循环
语法：
whlie 条件:
执行代码
执行代码
'''
当条件成立时，代码会一直执行。
当条件不成立时，条件就不会执行。
'''
条件: 1.比较条件 2. 布尔值条件 3.变量条件
最后while循环都会讲条件转换成为布尔值，False和True循环终止参数
循环终止，只有在循环是才能使用。
分为2种：
1.**break** 作用：帮助终止循环，只要代码执行到break时，不论是后面有多少代码，都不会执行。
2.**continue** 作用：结束本次循环，开始下一次循环，遇到 continue，后面不论多少代码，都会停止到最初代码。
while 和 else使用
while 条件： # 当while的条件不成立时
代码...
代码...
代码...
else: # 执行else中代码
代码....
当遇到break时，代码不会执行，因为break中止循环字符串格式化
字符串格式化分为：
1.%百分号
%百分号的使用
%s:就是一个占位符号
name = wkx
text = “我叫什么%s”%（“wkx”） 字符串
text = “我叫什么%s”%（name） 变量
text=“我叫什么%（name）”%{“wkx”}
当遇到内容中有百分号%时，又想用%号占位符就需要特殊处理：%%使用两个百分号
2.format
format
text = “我叫什么{}” .format（name） 变量
text = “我叫什么{}” .format（123） 字符串或者其他类型
需要复用的情况下需要，设置一个标志性的符号进行复用
其他用法
3.1415926 {:.2f} 3.14 保留小数点后两位
3.1415926 {:+.2f} +3.14 带符号保留小数点后两位
-1 {:-.2f} -1.00 带符号保留小数点后两位
2.71828 {:.0f} 3 不带小数
5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)
5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)
10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4)
1000000 {:,} 1,000,000 以逗号分隔的数字格式
0.25 {:.2%} 25.00% 百分比格式
1000000000 {:.2e} 1.00e+09 指数记法
13 {:>10d} 13 右对齐 (默认, 宽度为10)
13 {:<10d} 13 左对齐 (宽度为10)
13 {:^10d} 13 中间对齐 (宽度为10)
3.f
f
text = f“我叫什么{‘name’}” 变量
text = f“我叫什么{‘123’}” 字符串或者其他类型
text = f“我叫什么{19+2=}” 可以在内部进行计算for循环
for循环 对每个元素进行遍历（已知的）
语法：
for i in 元素或者长度：
print（i） 打印
元素或者长度值 赋值给了i ，通过i打印获取每次迭代的内容运算符
运算符 + - / * % ** //
+ 两个数相加，字符串也可以
- 两个数向减
/ 两个数向除
* 两个数相乘，字符串也可以相乘的数必须是整数
% 取两个数的余数
** 取次方
// 取两个数的 整数部分比较运算符
== ！= <> > < >= <=
== 比较两个对象是否相等
！= 判断两个对象不等于
> 大于
< 小于
>= 大于等于
<= 小于等于赋值运算
= += -= *= /= %= **= //=
= 赋值
+= 加法赋值
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 取余赋值
**= 次方赋值
//= 取整赋值成员运算符
in not in
not in 判断一个对象在没在另一个对象当中 存在False ,不存在True
in 判断一个对象在没在另一个对象当中 返回True/False逻辑运算符
and or not
and
a and d 当a d 都正确的情况下 返回True ，有一个不存在 就返回False
or
a or d 当a d 一个存在就会返回 True
not
not a 当a 存在返回False 不存在返回True运算符的优先级
加减乘除>比较>not >and >or运算符补充
print(10//3) # 整除只去 整数部分
print(10%6) # 整除后 取小数部分
print(2**2) # 开平方 指数
print((1*1)+1) # 先计算括号内的
+ 合并 字符串 列表 元组 (两个值进行合并一起)
* 复制 字符串 列表 元组(将元组*整数 获取的值)
in 判断存在 字符串 列表 元组 字典 集合
not in 判断不存在 字符串 列表 元组 字典 集合
max() 获取数据的最大值
min() 获取数据的最小值
enumeratre() 作用只针对可迭代的类型 循环获取对应的下标索引已经值循环与判断高级用法
三元运算（if）
如果程序中有简单的if else判断条件 就可以使用三元运算
做简单的逻辑运算
结果 = 条件成立结果 if 条件 else不成立结果：
条件成立：
name = 666 if 1==1 else 999
name 输出 666
条件不成立
name = 666 if 1==2 else 999
name输出 999推导式（for）
推导式 就是 for 循环写到一行中
示例：
[接受值 for i in 循环内容例如：（range（10）） 可以写入条件 if ]
列表中的推导式案例
name = [i for i in range(10)]
同时列表推导式中可以写上条件
name = [i for i in range(10) if i > 6]
集合和字典都是相同
特殊情况：
如果是元组推导式就会变成一个生成器
data = （i for i in range（10））
# data 是一个生成器可以用 next（）取值，也可以用for循环取值
for i in data：
print（i）
列表推导式：在列表内的作用域，只能在自己的作用域运行
列表推导式和在外部的for循环一样，当遇到函数时，
for i in range（10）：
print（i） 结果就是 9
在for循环内部打印是1....9
而在for 循环外部打印的结果 9 获取的是for循环最后的一个值
匿名函数
[lambda x :x+i for i in range(10)]
这个i 就是 9 和上面在为外部的循环一样。
for循环内部有自己的作用域，而获取的值就是for循环最后的一个值。9条件判断和输出
条件
单条件语句
if "条件" :
"条件成立后执行的代码"
"条件成立后执行的代码"
"条件成立后执行的代码"
else:
"条件不成立执行的代码"
"条件不成立执行的代码"
"条件不成立执行的代码"多条件语句
if 条件A：
A 成立 执行代码
elif 条件B：
B成立 执行代码
elif 条件C：
C成立 执行代码
......
else:
都不成立就执行else的代码输出
输出是实现用户和程序之间的交互
在用户输出的内容都是字符串的格式
name = input("输入账户:") 输出的内容是字符串进制和编码
进制
python代码的运行方式：脚本式（用pycharm）
交互式（用终端）用于测试计算机底层都是 0101 储存的 被称为2进制
2进制 满2进一位（整数存在）
8进制 满8进一位（字符串存在）
10进制 满10进一位（字符串存在）
16进制 满16进一位 （字符串存在）10进制 可以转换为 2进制 8进制 16进制
2进制 只能通过10进制转换成其他进制
8进制 只能通过10进制转换成其他进制
16进制 只能通过10进制转换成其他进制10进制通过转换：
bin（） 转换2进制
oct（） 转换8进制
hex（） 转换16进制
其他进制转换10进制
int（“2进制”，base=2）
int（“8进制”，base=8）
int（“10进制”，base=16）计算机的单位
计算机单位：
b 位 最小
B 字节 8位一个字节
KB 千字节 1024个字节 = 1KB
M 兆 1024KB = 1M
G 千兆 1024M = 1G
T 万亿字节 1T = 1024G编码
编码：
文字和2进制的对照表
ascii编码
1 个字节表示字母2进制对对应关系 2**8 = 256
gb-2312编码 由国家信息委员会制作（1980年）
gbk 对gb-2312扩展 包含中日韩等文字（1995年）
gbk 双字节表示对应关系 2**16 =65536
unicode被称为万国码，为每个文字都分配了一个码位（2进制表示）
ucs2 用固定的2个字节表示文字 2**16 =65536
ucs4 用固定的4个字节表示文字 2**32=4294967296
utf-8编码
包含所有文字和2进制对应关系，对unicode的压缩
对应用范围 进行表示
0000-007f 1个字节
0080-07ff 2字节
0800-ffff 3个字节
10000-10ffff 4个字节
中文都是第三个模板 ，都是3个字节
转换为2进制对应的数，按照6位对应模板，不够就补0数据类型
整形
整形：int 就是数字123
公共功能：+-*/
转换：
布尔转换整形 True = 0 False = 1
字符串转整形 只能时 数字才能转换“666”这种
python 3 只有只有一种 整形（int）
python 2 有两种代表：长整型（long无限制） 和整形（int）布尔型
任何数据都可以转换为布尔型
True 只要带有数值 都是true
False 全部的空字符串空字典，0 都是false
在做条件是，自动转换为布尔类型字符串
1.独有功能：
1.判断开头是什么
字符串变量和字符串.startswith（“判断开头内容”）
返回结果True/False 赋值给新的变量
2.判断以什么结尾
字符串变量和字符串.endswith（“判断结尾内容”）
返回结果True/False 赋值给新的变量
3.判断是否时十进制整数
字符串变量和字符串.isdecimal（）
返回结果True/False 赋值给新的变量
4.取两边的空白，制表符，换行符
字符串变量和字符串.strip（）
取除左空白
字符串或者字符串变量名赋值.lstrip（）
去除右空白
字符串或者字符串变量名赋值.rlstrip（）
5.全部将内容大写
不改变原先的值，重新赋值。
字符串或者字符串变量名赋值.upper（）
6.全部将内容小写
不改变原先的值，重新赋值。
字符串或者字符串变量名赋值.lower（）
7.字符串指定的内容进行替换
不改变原先的值，重新赋值
字符串或者字符串变量名赋值.replace（“字符串原内容”，“替换内容”）
8.字符串切割
不改变原先，重新赋值
输出一个列表类型
根据字符串的指定内容进行切割
字符串或者字符串变量名赋值.split（“切割的符号或者内容”）
split（“切割的符号或者内容”，“加入整数，按照数字进行切割几个（1从左到右第一个）”）
切割完成后输出一个新的（列表类型）
9.字符串拼接
将内容字符串进行拼接成为 新字符串
接受变量 = “拼接的符号（可以空值）”.join（需要拼接的内容）
10.字符串格式化
接受变量 = “{}{}”.format（传入的信息或者时变量）
11.字符串转换字节类型
接受变量 = 转换变量.encode（“utf-8”）
将字符串转换为字节类型
接受变量 = 转换变量.decode（“utf-8”）
将字节类型转换为字符串
12.将字符串居中，居左，居右
接受变量 = 转换变量.center（填补数量，“填补符号”）居中
ljust（填补数量，“填充符号”） 左
rjust（填补数量，“填充符号”） 右
13.自动填充补零
接受变量 = 转换变量.zfill（填充数量）
主要作用处理二进制数据
14. .isalpha()
字符串中最少一个是字母 返回true or false
15. .isdigit()
字符串必须是纯数字 返回true or false
16. .isalnum()
字符串必须是字母或者字符 不能是其他 返回true or false
17. .isspace()
只是空白的情况下 返回true 否则返回false公共功能：
相加，相乘
相加：字符串+字符串
相乘：字符串+整数
1.len（内容变量）获取长度
2.加索引取字符（只能获取，不能修改，因为字符串时最小单位）
3.切片（取的是字符串的一片的内容（前取后不去））
4.步长(跳着去获取数据[范围开始：范围结束：跳着的范围])（生成一个新的数据）
5.循环while for 循环
6.range（数字）创建一系列的数字
注意：字符串在创建时不可以被修改列表类型
list []
有序的可变的容器，内部可以放不同的类型数据，有序：先进后出，可变的：内部元素可以修改独有功能
1.列表追加（默认为最后一个）
列表.append（追加的值或者变量）
默认追加到最后一个
2.批量追加
将一个列表添加到另一个列表中
列表.extend（追加的列表）
追加的必须是列表
3.插入（插入指定的位置）
列表.insert（插如索引位置，插入元素（变量，各种类型））
4.从列表根据值删除
如果删除的值不存在列表会报错
列表.remove（删除的值）
5.根据索引位置删除
不输入索引按照默认最后一个开始删除
获取删除的值 = 列表.pop（索引位置）
pop可以获取到删除的值
6.清空列表
清空成为空列表
列表.clear（）
7.根据元素获取索引位置
接受值在列表的索引位置 = 列表.index（元素）
8.列表元素排序
转换为unicode的编码进行排序
列表.sort（）
注意：不能有多种数据类型在列表中进行排序
9.列表翻转
列表.reverse（）
将列表中的数据进行翻转。列表的公共功能
相加，相乘
相加：字符串+字符串
相乘：字符串+整数
1.运算符 in 判断元素是否在列表中
2.获取长度 len（）
3.索引（可以在获取索引对索引的值进行 读 改 ，删de）
del 只能对列表中的元素删除
4.切片（取前不取后）
5.步长（取前不去后）（生成一个新的数据）
6.for循环
列表是可以嵌套的元组
tuple（）
有序的不可变的容器，可以放不同的元素在里面
不可以修改，可以针对在元组内部的可变元素进行修改
在元组后面加上，（11，）因为这样系统才认为这是元组，如果（11）那么系统会认为是int元组的公共功能
相加，相乘
相加：字符串+字符串
相乘：字符串+整数
1.运算符 in 判断元素是否在列表中
2.获取长度 len（）
3.索引（可以在获取索引对索引的值进行 读 改 ，删de）
del 只能对列表中的元素删除
4.切片（取前不取后）（生成一个新的数据）
5.步长（取前不去后）（生成一个新的数据）
6.for循环
7.tuples.index(0) # 获取元素在当前元组的下标
元组是可以嵌套的集合
set{}
集合（set）
无序可变，不可重复的容器
无序：不可以通过索引取值
可变：可以删除，可以添加
不可以重复
元素必须哈希
可哈希数据：int bool str tuple
不可哈希： list，set，dict
查找速度特别快
独有功能
1.add（）
作用给集合添加元素
2.删除元素
集合2.discard（）
删除集合的元素
3.交集
两个集合相同的值
集合2.intersection（集合1）
4.并集
将两个集合重复的剔除
集合2..union（集合1）
5.差集
取两个集合没有的值
集合1.difference（集合2）
公共功能
- 计算差集
&交集
|计算并集
len（）获取长度
for循环字典
dict{}
无序，键不可重复，元素只能是键值对的可变容器
键必须是可哈希的 int str bool tuple
不可以：set dict list
获取的结果更明显独有功能
1.通过键获取值
字典.get（“键”）
2.获取所有的键
字典.keys（）
获取一个高仿的列表，列表内都是键
可以for循环，可以别in的判断
3.获取所有的值
字典.values（）
获取一个高仿的列表，列表内都是值
可以for循环，可以别in的判断
4.获取所有的键值
字典.items（）
得到的结果是一个元组[（键，值），（键，值）]列表内部套元组，可以循环获取
5.设置新值
在不存在的情况，可以设置值
字典.setdefault（“键”，值）
6.更新字典键值对
在字典中，如果字典中没有这键值对，就添加，如果有就更新值
字典.update（{“键”：值，“键”：值}）
7.从字典中移除键值对
通过键移除
赋值变量 = 字典.pop（“键”）
可以将移除的值赋值给 变量
8.移除键值对（后进先出）
按照顺序移除
变量 = 字典.popitem（）
获取到的是个元组（“键”，值）字典的公共功能
并集（重复的剔除）
长度 len（）
in 是否包含
通过索引（键）获取值
根据键修改值，添加值，del 删除键值对
for 循环 可以单独循环 键 值浮点型
float
在转换整数时，只保留整数位
round（变量，保留多少位的整数）
精确小数：
使用decimal模块
decimal.Decimal（小数）补充点
pass 的做用：确保语言的完整性
is 和 == 的区别 == 用于比较两个值相等 is 表示两个值内存地址是否一直
none 是个空值关于可变哈希与不可变
哈希(散列计算),可以将任意长度的输出，通过散列算法变为固定长度输出,简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
1.可哈希类型:
数字类型（int，float，bool）字符串str、元组tuple
注意：int与float类型通过hash计算后还是原来的值,取决于__hash__魔术方法的运算过程
bool：在通过hash运算后为1,0
可以理解为:当前变量值为key，那么hash运算后的值为value
使用str类型举例:
string1 = 'string'
string2 = 'str' + 'ing'
print(string2 == string1) # True
# 使用is判断对比(is内存地址是否相同)
print(string1 is string2) # True 说明内存地址相同
# 查看当前两个值的内存地址[是相同的]
print(id(string1)) # 2243838658608
print(id(string2)) # 2243838658608
# 通过hash函数查看计算后的哈希值
print(hash(string1), hash(string2)) # 1023839165698568095 1023839165698568095
# 如果可哈西变量发生变化，那么内存地址也会进行变化，[string2发生变化，就不会指向string1的内存地址，而是找到一个新的内存地址存储]
可以断定: 当前两个变量指向是同一块内存地址，那么hash值也相同,也满足了hash表的特点，通过变量元素找到key的内存地址
2.不可哈希类型:
list set dict(dict中得必须是可哈希类型的)
对于可变对象而言，比如一个列表，更改列表的值，但是对象的地址本身是不变的，也就是说不同的Key,映射到了相同的Value，这显然是不符合哈希值的特性的，即出现了哈希运算里面的冲突
可以理解为: 不可哈希类型中内部的值是可以变化的，但是占用的内存地址是不会变化的
利用列表为举例:
lis = [11,22,33]
print(id(lis)) # 内存地址为:2295695012736
lis.append('wkxxx') # 添加一个新的元素
print(id(lis)) # 内存地址为:2295695012736
内存地址不会变化，但是里面的值发生了变化
3.为什么dict中得key必须是可哈希的？
字典的哈希表实现使用从键值计算的哈希值来查找键
比如:
d = {[1, 2]: '100'} # 构造一个字典，key是列表[1,2] ，是一个可变对象，是不可哈希的
print(d[[1, 2]]) # 通过key去访问字典的值，TypeError错误
但是由于列表list是可变对象，虽然这两行的列表值一样，但是他们并不是同一个对象，它们的存储地址是不一样的，即id是不一样的，id不一样也导致了根据id计算得到的哈希值是不一样的，自然没有办法找到原来的那一个
'''
因为(不可哈希)可变类型,虽然值是相同的，但是内存地址不同，无法找到。
为什么用可哈希(不可变类型),你是用的值在内存中存储的都是相同的位置,比如:'xxx' ，那么怕10个变量使用这个值，那么也是执行当前这个值得内存地址的。另外字典的哈希表时从key进行计算哈希找到value的。如果是(不可哈希)可变类型，那么永远也找不到对应value
'''if name == 'main' 作用
if __name__ == '__main__' 作用
test.py :
在当前文件中进行打印 print(__name__) # 结果就被解析为 __mian__
show.py
import test # 导入 test脚本 执行当前show.py脚本
在test.py文件中打印 print(__name__) # 就变为 test 也就是当前的文件名
当模块被导入时，模块名称是文件名；而当模块作为脚本独立运行时，名称为 __main__。
让模块既可以导入又可以执行