一、变量

1.1 命名规范

和其他语言一样，python的关键字（包括内置函数）也不能成为标识符。

标识符命名规则:

1. 由字符（数字,字母,下划线）组成,名词最好可以见名知意.
2. 不能以数字开头,不建议使用下划线开头,下划线使用建议:my_name
3. 不能使用关键字
4. 严格区分大小写
5. 命名使用驼峰模式

1.2 关键字和内置函数的查询

import keyword
keyword.kwlist 
#如果是在文件中，则需要print()函数才能看到
print(keyword.kwlist);

1.3 定义变量

# 变量名称 = 值
name = "Bob"
#使用原则：先定义、后引用

1.4 删除变量

del 变量名

1.5变量的缓存机制

在同一文件中，
对于int类型，范围：[-5,∞)，值相同则id一致。
对于float类型，范围：[0,∞)，值相同则id一致。
对于布尔类型，值相同则id一致。
对于复数而言，含有实数+虚数时，值相同id永不相同。（版本3.9和3.11检测虚数和实数的形式，id是一致的！）
对于复数而言，只有虚数时，值相同，id相同。
对于字符串而言，值相同的情况下，id相同。
对于元组而言，变量同为空元组时，id相同，其他情况不相同。
对于列表、非空元组、字典、集合无论什么情况下，id都不相同。

数值类型

一、int类型

int类型：整型包含了数学意义上的正整数、0和负整数。

int_val = 18
print(int_val)
#console: 18
print(type(int_val))
#console:<class 'int'>
# 地址值的获取
print(id(int_val))
#通常有二进制、十进制、八进制、十六进制的展示暂时不深入学习，预习到此在添加

二、float类型

float类型：浮点数：即数学意义上的小数

float_val = 3.1415926
print(float_val,type(float_val))
#console: 3.1415926 <class 'float'>

2.1科学计数法

# 科学计数法属于小数
float_val2 = 3.15e17  # 小数点向右移17位
float_val3 = 3e18
float_val4 = 1e-2  # 小数点向左移2位
print(float_val2, type(float_val2))
#console：3.15e+17 <class 'float'>
print(float_val3, type(float_val3))
#console：3e+18 <class 'float'>
print(float_val4, type(float_val4))
#conso：0.01 <class 'float'>

在科学计数法中，即使最终结果位整数的表达式，它的类型也是float类型。

三、boolean类型

布尔类型：在数学意义上的判断，值只有True和False。

# boolean
boolean_val_T = True
boolean_val_F = False
print(boolean_val_T, type(boolean_val_T))
#console：True <class 'bool'>
print(boolean_val_F, type(boolean_val_F))
#console：False <class 'bool'>

四、complex复数类型

即数学意义上的复数。复数类型：由实数和虚数组成。虚数j：如果有一个数他的平方等于-1,那么这个数就是j，目的是为了表达高精度。

complex_val1 = 12 + 4j
complex_val2 = 12 - 4j
print(complex_val1, type(complex_val1))
# console:(12+4j) <class 'complex'>
print(complex_val2, type(complex_val2))
# console:(12-4j) <class 'complex'>

使用函数定义复数：

complex_val3 = complex(3, -4)
print(complex_val3, type(complex_val3))
# console：(3-4j) <class 'complex'>

长度和下标的关系：长度以1开始，下标以0开始。所以长度自始至终比下标多1。

五、String类型

5.1 String类型的特征

字符串是有序的，可获取的，不可修改的。

5.2 定义

字符串是指被引号引起来的部分--就是语文中某人说的一句话。
在python中，字符串的引号可以是单引号，双引号，三单引号，三双引号。

其中三单（双）引号若不赋值时可以作为注释使用。也可以理解为python中没有多行注释。python的垃圾回收机制是，当一个变量被引用次数为0时，系统则会回收。

# 单引号字符串
str_val1 = '123木头人'
# 双引号字符串
str_val2 = "用整个宇宙换一颗红豆"
# 三引号字符串
str_val3 = '''
时光是琥珀 泪一滴滴 被反锁
情书再不朽 也磨成沙漏
青春的上游 白云飞走 苍狗与海鸥
闪过的念头 潺潺地溜走
命运好幽默 让爱的人都沉默
一整个宇宙 换一颗红豆
回忆如困兽 寂寞太久而渐渐温柔
放开了拳头 反而更自由
慢动作 缱绻胶卷 重播默片 定格一瞬间
我们在 告别的演唱会 说好不再见
你写给我 我的第一首歌
你和我 十指紧扣 默写前奏
可是那然后呢
还好我有 我这一首情歌
轻轻地 轻轻哼着 哭着笑着
我的 天长地久
陪我唱歌 清唱你的情歌
舍不得 短短副歌
心还热着 也该告一段落
还好我有 我下一首情歌
生命宛如 静静的 相拥的河
永远 天长地久
'''
print(str_val1)
print(str_val2)
print(str_val3)

三引号的特点是可以保留文本格式在打印过程中文本格式不被破坏，但是转义符仍然可以生效。

5.3 空字符串

str1 = ""
print(str1, type(str1))
# console: <class 'str'>
str2 = str()
print(str2, type(str2))
# console: <class 'str'>

5.4 字符串的下标

自左向右：0~N-1，自右向左：-1 ~ -N。

str1 = "12345"
# 下标自左向右：0 1 2 3 4
# 下标自右向左：-1 -2 -3 -4 -5

5.5 字符串长度

# 使用len(self)获取长度
str1 = "1234"
print(len(str1))
# console:4

5.6 转义符

5.6.1格式

\+字符

字符：是指常见的字母和英文符号

5.6.2 作用

1.可以将无意义的字符串变的有意义

2.可以将有意义的字符串变的无意义

5.6.3 常见的转义符

\n:换行
\t:缩进（水平制表符）
\r:将/r后面的字符串拉到当前行的行首

# 含转义符的字符串
str_val = "青春的上游白云飞走苍狗与海鸥"
print(str_val)
# console：青春的上游白云飞走苍狗与海鸥
str_val = "青春的上游\n白云飞走苍狗与海鸥"
print(str_val)
# console：青春的上游
#白云飞走苍狗与海鸥
str_val = "青春的上游白云飞走\r苍狗与海鸥"
print(str_val)
# console:苍狗与海鸥
str_val = "青春的上游白云飞\t走苍狗与海鸥"
print(str_val)
# console:青春的上游白云飞    走苍狗与海鸥
str_val = "青春的上游白云\"\"飞走苍狗与海鸥"
print(str_val)
# console:青春的上游白云""飞走苍狗与海鸥

5.7 元字符串

在单引号和双引号字符串前增加r字符，可以保留字符串原始格式不会进行转换和其他格式的转换。

# 元字符串
str_rStr = "D:\tython32_python\tay02"
print(str_rStr)
# console：D:\python32_python    ay02
str_rStr = r"D:\python32_python\tay02"
print(str_rStr)
# console：D:\python32_python\tay02
# 与三引号字符串对比
str_rStr = """D:\python32_python\tay02"""
print(str_rStr)
# console：D:\python32_python\tay02

5.8 字符串格式

%d 整型占位符
%f 浮点占位符
%s 字符串占位符

5.8.1 语法

val = 表达式
str_val = "%d个苹果"%(表达式)

5.8.2 作用

方便在字符串中加入变量，并且对字符串中的字符串进行规范。

5.8.3 %d的常见用法

%空格数.0填充数d--->空格数可以为负数，0的填充数不能为负数。

num = 1
str_d = "日照香%20d炉生紫烟" % (num)
print(str_d)
# console：日照香                   1炉生紫烟
#当占位符d前为正整数时，向右对齐，用空格填充
num = 1
str_d = "日照香%-3d炉生紫烟" % (num)
print(str_d)
# console：日照香1  炉生紫烟
#当占位符d前为负整数时，向左对齐，用空格填充
num = 12345
str_d = "日照香%-6.5d炉生紫烟" % (num)
print(str_d)
# console：日照香12345 炉生紫烟
#当占位符d前为小数时例如-6.5，则是向左对齐，总占位6个字符，其中变量不足5个字符时左侧以0填充，右侧为空格。当变量展位数超出6位时，则规则被打破，以变量的实际位数为准。
num = 12
str_d = "日照香%6.4d炉生紫烟" % (num)
print(str_d)
# console：日照香  0012炉生紫烟
#当占位符d前为小数时例如6.4，则是向右对齐，总占位6个字符，其中变量不足4个字符时左侧以0填充，左侧为空格。当变量展位数超出6位时，则规则被打破，以变量的实际位数为准。
# 即(空格数).(0填充数)

5.8.4 %f的常见用法

%空格数.0填充数f--->空格数可以为负数，0的填充数不能为负数。
%f默认保留6为小数

price = 6.9
str_price = "奥利奥的价格是%f元"%(price)
print(str_price)
# console：奥利奥的价格是6.900000元
price = 6.9
str_price = "奥利奥的价格是%.2f元"%(price)
print(str_price)
# console:奥利奥的价格是6.90元
price = 1.3
str_price = "奥利奥的价格是%-4.20f元"%(price)
print(str_price)
# console:奥利奥的价格是1.30000000000000004441元
# float类型具有足够的位数，且不精确。
# 当出现空格数大于填充数时，空格生效。反之则会出现最精准的小数。

5.8.5 %s的常见用法

%s可以兼容%d和%f，但是%d和%f不能兼容%s，在不清楚语句具体要放什么数据时可以设置为%s。
在%s中填充数不在生效，只生效空格数。

str_sth = "手工皂"
str = "沐浴露没有%s好"%(str_sth)
str1 = "沐浴露没有%6s好"%(str_sth)
str2 = "沐浴露没有%-6.80s好"%(str_sth)
print(str)
# console：沐浴露没有手工皂好
print(str1)
# console：沐浴露没有   手工皂好
print(str2)
#console：沐浴露没有手工皂   好

5.9 f-String字符串

5.9.1 格式

f"字符串{表达式}字符串"

5.9.2 常见用法

new_news = "飞儿换主唱了"
srt_f = f"新闻：{new_news}"
print(srt_f)
# console：新闻：飞儿换主唱了

在花括号中可以使用表达式（变量和常量也是一种表达式）。

5.10 字符串的格式化--format

5.10.1 传参的方法

# 第一种--顺序传参
val = "{} say 'hello {}'".format("Tom","world")
print(val)
# 第二种--索引传参
val = "{0} say 'hello {1}'".format("Tom","world")
print(val)
val = "{1} say 'hello {0}'".format("Tom","world")
print(val)
# 第三种--关键字传参
val = "{who1} say 'hello {who2}'".format(who1="Tom",who2="world")
print(val)
# 第四种--容器类型数据（列表、元组）传参
val = "{0[0]} say 'hello {1[1]}'".format(["Tom","Bob","Moon"],["world","China","Sun"])
print(val)
val = "{a[0]} say 'hello {b[1]}'".format(a=["Tom","Bob","Moon"],b=["world","China","Sun"])
print(val)
val = "{a[a1]} say 'hello {b[1]}'".format(a={"a1":"Tom","a2":"Bob","a3":"Moon"},b=["world","China","Sun"])
print(val)
#  注意一.如果该容器是字典,通过键取值时,不需要加引号  注意二.通过下标取值时,不能使用负号(逆向索引)

5.10.2 format占位符

"""
    ^ 原字符串居中显示
    > 原字符串居右显示
    < 原字符串居左显示
    {who:*^10}
    * : 填充的符号
    ^ : 原字符串居中显示
    10: 原字符串长度 + 填充符号的长度 = 10
"""
strvar = "{who:*^10}去长春长生医药公司,{do:>>10},感觉{feel:!<10}".format(who="李亚峰",do="扎疫苗",feel="血槽被掏空")
print(strvar)
# 进制转换等特殊符号的使用( :d :f :s :, )
# :d 整型占位符 (强制要求类型是整型)
strvar = "刘一峰昨天晚上买了{:d}个花露水泡脚".format(9)
print(strvar)
# :3d 占3位,不够三位拿空格来补位(原字符串居右)
strvar = "刘一峰昨天晚上买了{:3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:<3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:^3d}个花露水泡脚".format(9)
print(strvar)
# :f 浮点型占位符 (强制要求类型是浮点型) 默认保留小数6位
strvar = "王雨涵毕业之后的薪资是{:f}".format(9.9)
print(strvar)
# :.2f 小数点后保留2位,存在四舍五入
strvar = "王雨涵毕业之后的薪资是{:.2f}".format(9.188888)
print(strvar)
# :s 字符串占位符
strvar = "{:s}".format("杨元涛真帅")
print(strvar)
# :, 金钱占位符
strvar = "{:,}".format(12345678)
print(strvar)
# 综合案例
strvar = "{:s}开工资{:,.2f}元,买了{:d}个兰博基尼".format("孙坚",300000.12345,10)
print(strvar)

5.11 字符串相关函数

vstr = "how are you! Tom"
# capitalize 字符串首字符大写
print(vstr.capitalize())
# title 每个单词首字母大写
print(vstr.title())
# upper 将所有字母变成大写
print(vstr.upper())
# lower 将所有字母变成小写
print(vstr.lower())
''' is相关函数
    isupper 判断字符串是否都大写
    islower 判断字符串是否都小写
    isdecimal 判断字符串是否都是数字组成
'''
print(vstr.isupper())
print(vstr.islower())
print(vstr.isdecimal())
# swapcase 大小写互换
print(vstr.swapcase())
# len 计算字符串长度
print(len(vstr))
# count 统计某个字符串中某个元素的数量
'''count(字符[,开始值,结束值])'''
print("count函数开始")
print(vstr.count("o"))
print(vstr.count("o",6))# 从6开始
print(vstr.count("o",1,8))
print("count函数结束")
# find 查找某个字符串第一次出现的索引位置
'''find(字符[,开始值，结束值])'''
print("find函数开始")
print(vstr.find("o"))
print(vstr.find("o",10))# 从10开始
print(vstr.find("o",1,11))
print("find函数结束")
# index 查找某个字符串第一次出现的索引位置
'''index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错'''
# print(vstr.index("oo"))
print(vstr.find("oo"))
# startswith/endswith 判断是否以某个字符串开头/结束
"""
startswith(字符[,开始值,结束值])
endswith(字符[,开始值,结束值])
"""
print("start/end方法开始")
print(vstr.startswith("ho"))
print(vstr.startswith("ho",2))
print(vstr.startswith("ho",4,10))
print(vstr.endswith("om"))
print(vstr.endswith("om",2))
print(vstr.endswith("o",-2,-1))
print("start/end方法结束")

# split 将字符串以某个字符（串）为节点进行拆分，默认为空格
print("split方法开始")
print(vstr.split())
print(vstr.split("o"))
print("split结束")
# join 将列表元素以某个字符（串）为介质进行连接(容器类型都可)  
print("join方法开始")
list_val = ["good","good","study"]
print(" ".join(list_val))
print("^".join(list_val))
print("join方法结束")
# replace 把字符串的旧字符换成新字符
"""字符串.replace('旧字符','新字符'[, 限制替换的次数])"""
strvar = "101010101"
print(id(strvar))
res = strvar.replace("1","2")
print(id(strvar))
print(res)
# 选择替换的次数
res = strvar.replace("1","5",1)
print(id(strvar))
print(res)
# strip 默认去掉首尾两边的空白符
'''空白符：空格 制表符 \n \t \r '''
vstr = "    情歌"
print(vstr)
print(vstr.strip())
# center 填充字符串，原字符串居中
"""center(字符长度,填充符号)"""
vstr = "情歌"
print(vstr.center(10))
print(vstr.center(10,"#"))

六、列表

6.1 特征

可获取、可修改、有序

6.2 空列表

# 空列表
list_var = []
print(list_var)
# console:[]
list_var = list()
print(list_var)

6.3 常规使用

list_val = [1, 0, -1, 1.1, 1e4, 1e-3, "西洋参", [1, 2, 3]]
print(list_val)
# console：[1, 0, -1, 1.1, 10000.0, 0.001, '西洋参', [1, 2, 3]]

6.4 列表的下标

自左向右：0 ~ N-1
自右向左：-1 ~ -N

6.5 列表的长度

# 使用len(self)方法获取长度
list_val = [1, 0, -1, 1.1, 1e4, 1e-3, "西洋参", [1, 2, 3]]
print(len(list_val))
# console：8

6.6 改变列表中的值

list_val = [1, 0, -1, 1.1, 1e4, 1e-3, "西洋参", [1, 2, 3]]
list_val[-1] = "修改"
print(list_val)
# console：[1, 0, -1, 1.1, 10000.0, 0.001, '西洋参', '修改']

6.7 列表相关操作

lval1 = ["这","世","界","有","那","么","多","人"]
lval2 = ["莫","文","蔚"]
# 列表的拼接
print(lval1 + lval2)
# 列表的重复
print(lval2 * 3)
# 列表的切片
'''
语法：列表[开始索引:结束所有：间隔值]
  (1)[开始索引:]  从开始索引截取到列表的最后
    (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
    (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
    (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
    (5)[:]或[::]  截取所有列表
'''
song_list = ["情歌","这世界有那么多人","痛快","十七","纸短情长"]
# (1)[开始索引:]  从开始索引截取到列表的最后
print(song_list[1:])
# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
print(song_list[:2])
# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
print(song_list[1:-1])
# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
print(song_list[0:-1:2])
print(song_list[::-1])
# (5)[:]或[::]  截取所有列表
print(song_list[:])
print(song_list[::])
# 列表的获取
#               0      1              2     3     4
song_list = ["情歌","这世界有那么多人","痛快","十七","纸短情长"]
#             -5       -4             -3   -2     -1
print(song_list[-1])
# 列表的修改
song_list[0] = "梁静茹--《勇气》"
print(song_list)
# 修改多个值
song_list[1:3] = "莫"
print(song_list)
song_list = ["情歌","这世界有那么多人","痛快","十七","纸短情长"]
song_list[1:3] = "莫文蔚"
print(song_list)
song_list = ["情歌","这世界有那么多人","痛快","十七","纸短情长"]
song_list[1:3] = ["莫文蔚","SHE","FIR"]
print(song_list)
# 使用步长修改多个值
"""带有步长的切片修改,切出几个元素就修改几个元素,数量要一致."""
song_list = ["情歌","这世界有那么多人","痛快","十七","纸短情长"]
song_list[::2] = "123"
print(song_list)
# 删除列表
song_list = ["情歌","这世界有那么多人","痛快","十七","纸短情长"]
del song_list[0]
print(song_list)
del song_list[1:-1]
print(song_list)
a = [1,2,3]
dela = a
del dela #删除的是变量不是列表a 
print(a)
# 对于多级容器的获取和修改
song_list = ["情歌","这世界有那么多人","痛快","十七","纸短情长",(1,2,3)]
print(song_list[-1][-1])
song_tuple = (1,2,3,[1,12,15])
song_tuple[-1][-1] = 25
print(song_tuple)

6.8 列表相关函数

song_list = ["情歌", "这世界有那么多人", "痛快", "十七", "纸短情长"]
'''
增加元素
append() 向列表的末尾添加新的元素
insert() 在指定索引前面插入新元素
'''
song_list.append("七里香")
print(song_list)
song_list.insert(2, "ABC")
print(song_list)
'''
extend 迭代追加所有元素
迭代追加的数据是可迭代性数据(容器类型数据,range对象,迭代器)
'''
song_list.extend("12311")
print(song_list)
song_list.extend(song_list)
print(song_list)
song_list.extend(range(3))
print(song_list)
'''
删除
1.pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐)
2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个
3.clear 清空列表
'''
# 1.pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐)
song_list = ["情歌", "这世界有那么多人", "痛快", "十七", "纸短情长"]
song_list.pop(3)
print(song_list)
song_list.pop()
print(song_list)
# 2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个
song_list = ["情歌", "这世界有那么多人", "痛快", "十七", "纸短情长", "这世界有那么多人", "这世界有那么多人"]
print(song_list)
song_list.remove("这世界有那么多人")
print(song_list)
song_list.remove("情歌")
print(song_list)
# 3.clear 清空列表
song_list = ["情歌", "这世界有那么多人", "痛快", "十七", "纸短情长"]
song_list.clear()
print(song_list)
'''
其他函数
'''
# index 获取某个值在列表中的索引,若重复则返回首个值所在的索引
lst = ['a', 'b', 'a', 'c', 'a', 'd']
print(lst.index('a'))
print(lst.index('a',3))
print(lst.index('a',1,5))
# count 计算某个元素出现的次数
print(lst.count('a'))
'''
排序：
sort() 将列表的元素按照字符集的顺序从小到大排序
sort(reverse=True) 将列表的元素按照字符集的顺序从大到小排序
reverse() 列表反操作
'''
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)
lst.reverse()
print(lst)
'''
拷贝
模块：copy
方法：copy()
'''
import copy as c
lst1 = [1,2,3]
lst2 = c.copy(lst1)
lst1.append(10)
print(lst1)
print(lst2)
#--------------------
lst1 = [1,2,3]
lst2 = lst1.copy()
lst1.append(10)
print(lst1)
print(lst2)

# 2.深拷贝
"""把所有层级的容器元素都单独拷贝一份,放到独立的空间中"""
# 现象
lst1 = [1,2,3,[4,5,6]]
lst2 = c.copy(lst1)
lst1[-1].append(77)
lst1.append(8888)
print(lst2)
print(lst1)

lst1 = [1,2,3,[4,5,6]]
lst2 = c.deepcopy(lst1)
lst1[-1].append(999)
print(lst2)
print(lst1)

# 其他容器的深拷贝
lst1 = (1,2,3,{"a":1,"b":[10,20]})
lst2 = c.deepcopy(lst1)
lst1[-1]["b"].append(30)
print(lst1)
print(lst2)

七、 元组

7.1 特征

元组的特点必须有逗号，即元组的标志是有逗号，否则单个元素容易让系统误解。元组可获取，不可修改，有序。

# 为什么说逗号才是元组的标志
tuple_val = 1
print(tuple_val,type(tuple_val))
# console：1 <class 'int'>
tuple_val = 1,
print(tuple_val,type(tuple_val))
# console：(1,) <class 'tuple'>

7.2 空元组

tupleval = ()
print(tupleval)
# console:()
tupleval2 = tuple()
print(tupleval2)
# console:()

7.3 常规使用

tuple_val = (1, 0, -1, 1.2, "hello", [1, 2, 3], (1, 2, 3))
print(tuple_val, type(tuple_val))
# console: (1, 0, -1, 1.2, 'hello', [1, 2, 3], (1, 2, 3)) <class 'tuple'>

7.4 元组下标

自左向右：0 ~ N-1
自右向左：-1 ~ -N

7.5 元组长度

tuple_val = (1, 0, -1, 1.2, "hello", [1, 2, 3], (1, 2, 3))
print(len(tuple_val))
# console: 7

八、集合

8.1 特征

无序，自动去重，不可获取，不可修改

8.2 空集合

set_val = set()
print(set_val,type(set_val))
# console: set() <class 'set'>
set_val = {}# 这不是空集合，这是空字典

8.3 常规使用

set_val = {1,1,1,0,-1,1.1,"hello",(1,2,3)}
print(set_val,type(set_val))
# console：{0, 1, 1.1, 'hello', (1, 2, 3), -1} <class 'set'>

8.4 集合长度

set_val = {1, 1, 1, 0, -1, 1.1, "hello", (1, 2, 3)}
print(len(set_val))
# console: 6

8.5 集合相关操作

'''
集合的相关操作
交集
差集
并集
是否互为父(子)集合
是否相交
'''
mn = {"纯牛奶","优酸乳","真果粒","安慕希"}
yl = {"纯牛奶","酸酸乳","纯甄"}
nn = {"纯牛奶"}
# intersection() & 交集
res = mn.intersection(yl)
print(res)
res = mn & yl
print(res)
# difference() - 差集
res = mn.difference(yl)
print(res)
res = mn - yl
print(res)
# union() | 并集
res = mn.union(yl)
print(res)
res = mn | yl
print(res)
# symmetric_difference()  ^ 对称差集(补集情况)
res = mn.symmetric_difference(yl)
print(res)
res = mn ^ yl
print(res)
# issubset() < 判断是否为子集
print(nn.issubset(mn))
print(nn<mn)
# issuperset() > 判断是否为父集
print(nn.issuperset(mn))
print(mn > nn)
#isdisjoint() 判断是否不相交,不相交为 True, 相交为 Flase
print(mn.isdisjoint(yl))
'''
集合的相关函数
增
删
改
查
'''
s1 = {"SHE","萧敬腾","周杰伦","蔡依林","南拳妈妈"}
# 增
s1.add("张韶涵")
print(s1)
# 改
lst = [1,2,3]
s1.update(lst)
print(s1)
# 删
# 指定删除集合中的值,不存在不删除
s1.discard("SHE")
# 指定删除集合中的值,不存在则报错
s1.remove(1)
# 随机删除一个数据
s1.pop()
# 清空集合
s1.clear()

# ### 3.冰冻集合 (额外了解)
"""frozenset 单纯的只能做交差并补操作,不能做添加或者删除的操作"""
lst = ["王文","宋健","何旭彤"]
fz1 = frozenset(lst)
print(fz1, type(fz1))


# 不能再冰冻集合中添加或者删除元素
# fz1.add(1)
# fz1.update("abc")
# fz1.discard("王文")

# 冰冻集合只能做交差并补
lst2 = ["王文","王同培","刘一缝"]
fz2 = frozenset(lst2)
print(fz2, type(fz2))

# 交集
res = fz1 & fz2
print(res)

# 遍历冰冻集合
for  i in fz2:
    print(i)

九、 字典

9.1 特征

表面有序，实质无序，具有键值对存储，通过键获取值。可修改值，键不能修改。
3.6版本之前，完全无序。
3.6版本之后，定义时保留了字面顺序，获取内存中数据时重新按照字面顺序做了排序，即读取有序，在内存中无序。

9.2 空字典

dict_val = {}
print(dict_val,type(dict_val))
# console:{} <class 'dict'>
dict_val = dict()
print(dict_val,type(dict_val))
# console:{} <class 'dict'>

9.3 常规使用

dict_val = {"one": 1, 2: "two", 1.1: "1,1", "1":{1,2,3}, }
print(dict_val["1"])
# console: {1,2,3}

9.4 字典的键

字典的键可以是int、float、boolean、complex、string、tuple
字典的键不能是list、set、dict

9.5 字典的值

字典的值没有限制。

9.6 字典的长度

dict_val = {"one": 1, 2: "two", 1.1: "1,1", "1":{1,2,3}, }
print(len(dict_val))
# console: 4

集合和字典的底层算法是哈希算法，哈希算法一定是无序的散列，所以集合和字典都是无序的。

9.7 字典常用函数

'''
字典的相关函数
增
-- 普通方法
-- fromkeys(键(容器类型),默认值(同一地址值))
删
-- pop(删除的键,"当键不存在时,向系统输出,避免异常")
-- popitem()删除最后一个键值对
-- clear()清空字典
改
-- update()-->可以单个更新,也可以批量更新
查
-- get(查询的键,提示信息)通过键获取值(若没有该键可设置默认值,预防报错)
其他函数
-- keys() 将字典的键组成新的可迭代对象
-- values() 将字典中的值组成新的可迭代对象
-- items() 将字典的键值对凑成一个个元组,组成新的可迭代对象
'''
# 增 -- 普通方法
dic1 = {}
dic1["FIR"] = "我们的爱"
dic1["SHE"] = "恋人未满"
dic1["周杰伦"] = "夜曲"
dic1["蔡依林"] = "日不落"
print(dic1)
# 增 -- fromkeys(键(容器类型),默认值(同一地址值))
dic2 = {}
tup = ("a", "b", "c")
dic2 = dic2.fromkeys(tup, [])
dic2["a"].append("123")
print(dic2)  # 此时 dic2的键指向同一个地址值 0x1001(此地址值为假设)
dic2["a"] = "abc"  # "abc"是新地址,地址值为 0x1002(此地址值为假设)
print(dic2)
# 删 -- pop(删除的键,当没有该键时抛出异常)
dic3 = dic1
print(dic3)
dic3.pop("周杰伦")
print(dic3.pop("周杰伦", "没有此键"))
print(dic3)
# 删 -- popitem()
dic3.popitem()
print(dic3)
# 删 -- clear()
dic4 = dic1
print(dic4)
dic4.clear()
print(dic4)
# 改 --  update()无则新增,有则更新
dic1 = {"abc":"123"}
dic2 = {"bac":"213"}
dic1.update(dic2)
print(dic1)
dic3 ={"abc":"234"}
dic1.update(dic3)
print(dic1)
dicd = {}
dicd.update(ww="123")
print(dicd)
# 查 -- get()
dic1 = {}
dic1["FIR"] = "我们的爱"
dic1["SHE"] = "恋人未满"
dic1["周杰伦"] = "夜曲"
dic1["蔡依林"] = "日不落"
dicc = dic1
print(dicc)
print(dicc.get("FIR","提示信息"))
print(dicc.get("梁静茹","不存在"))
# 其他操作
#keys()   将字典的键组成新的可迭代对象
dic = {"top":"the bug","support":"xboyww","xiaozhang":"王思聪"}
res = dic.keys()
print(res , type(res))
#values() 将字典中的值组成新的可迭代对象 ***
res = dic.values()
print(res , type(res))
#items()  将字典的键值对凑成一个个元组,组成新的可迭代对象 ***
res = dic.items()
print(res , type(res))

十、类型转换

10.1 数值类型的强制转换

10.1.1 将其他类型强制转换为int类型

规则：可以强制转换为int类型的数据类型为int、float、bool、纯数字字符串

int()#Int()参数必须是字符串、类字节对象或实数
# 基本数据类型为 int float bool complex
var_int = 11
var_float = 1.23
var_bool = True
var_com = 1+1j
# 强制转换为int类型
print(int(var_int))
# console:11
print(int(var_float))
# console:1 浮点类型是直接截取整数部分
print(int(var_bool))
# console：1 True的整型为1
print(int(False))
# console：0 False的整型为0
# print(int(var_com))
# error：复数会报错
# print(int("123ABC"))  
# error：上述字符串为非纯数字的字符串
print(int("123456"))
# console：123456

10.1.2 将其他类型强制转换为float类型

规则：可以强制转换为float类型的数据类型为int、float、bool、纯数字字符串

# 基本数据类型为 int float bool complex
var_int = 11
var_float = 1.23
var_bool = True
var_com = 1+1j
# 强制转换为float类型
print(float(var_int))
# console: 11.0
print(float(var_float))
# console: 1.23
print(float(var_bool))
# console: 1.0
print(float(False))
# console:0.0
# print(float(var_com))
# Error
# print(float("123ABC"))
# Error
print(int("123456"))
# console:123456.0

10.1.3 将其他类型强制转换为complex类型

规则：可以强制转换为complex类型的数据类型为int、float、bool、纯数字字符串和complex

# 强制转换为complex类型
print(complex(11))
# console：(11+0j)
print(complex(12.34))
# console：(12.34+0j)
print(complex(True))
# console：(1+0j)
print(complex(False))
# console：0j
# print(complex("123abc"))
# Error
print(complex("123"))
# console：(123+0j)
print(complex(1+1j))
# console：(1+1j)

10.1.4 将其他类型强制转换为bool类型

布尔型可以强转一切数据类型

""" 0 , 0.0 , False , 0j '' [] () set() {} None """
res = bool(None)
print(res , type(res))
"""None 代表空的,代表什么也没有,一般用于初始化变量"""
a =None
b =None

10.2 数值类型的自动转换

低精度默认向高精度进行转换
bool -> int -> float -> complex
小数的精度损耗 (小数后面一般有时截取15~18位,但是不完全,存在精度损耗)
"""不要用小数作比较,咬不准"""

10.3 二进制的运算总结

二进制 1 + 1 = `10

八进制 7 + 1 = 10

十六进制 f + 1 = 10

10.4容器类型的强制转换

# 字符串
var1 = "hello world!"
# 列表
var2 = ["how","are","you"]
# 元组
var3 = (1,2,3)
# 集合
var4 = { "1","32","hello",123 }
# 字典
var5 = {1:"hello1",2:"python2"}
var6 = 90
var7 = True

10.4.1 转换为字符串类型

# 在当前的数据类型两边套上引号
# 字符串
var1 = "hello world!"
# 列表
var2 = ["how","are","you"]
# 元组
var3 = (1,2,3)
# 集合
var4 = { "1","32","hello",123 }
# 字典
var5 = {1:"hello1",2:"python2"}
var6 = 90
var7 = True
print(str(var1))
print(str(var2))
print(str(var3))
print(str(var4))
print(str(var5))
print(str(var6))
print(str(var7))
# 使用repr()函数，可以看到引号

10.4.2 强制转换为list列表

如果是字符串:把字符串中的每个元素单独拿出来,作为列表中的新元素
如果是字典: 只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型德两边换上[]括号

# 字符串
var1 = "hello world!"
# 列表
var2 = ["how","are","you"]
# 元组
var3 = (1,2,3)
# 集合
var4 = { "1","32","hello",123 }
# 字典
var5 = {1:"hello1",2:"python2"}
var6 = 90
var7 = True
print(list(var1))
print(list(var2))
print(list(var3))
print(list(var4))
print(list(var5))
# print(list(var6))
# print(list(var7))

10.4.3 强制转换为tuple元组

如果是字符串:把字符串中的每个元素单独拿出来,作为元组中的新元素
如果是字典: 只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上()括号

# 字符串
var1 = "hello world!"
# 列表
var2 = ["how","are","you"]
# 元组
var3 = (1,2,3)
# 集合
var4 = { "1","32","hello",123 }
# 字典
var5 = {1:"hello1",2:"python2"}
var6 = 90
var7 = True
print(tuple(var1))
print(tuple(var2))
print(tuple(var3))
print(tuple(var4))
print(tuple(var5))
# print(tuple(var6))
# print(tuple(var7))

10.4.4 强制转换为set集合

如果是字符串:把字符串中的每个元素单独拿出来,作为集合中的新元素
如果是字典: 只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上{}括号

# 字符串
var1 = "hello world!"
# 列表
var2 = ["how","are","you"]
# 元组
var3 = (1,2,3)
# 集合
var4 = { "1","32","hello",123 }
# 字典
var5 = {1:"hello1",2:"python2"}
var6 = 90
var7 = True
print(set(var1))
print(set(var2))
print(set(var3))
print(set(var4))
print(set(var5))
# print(set(var6))
# print(set(var7))

因为set集合的特性是去重，所以如果list、string、tuple中有重复元素，则会被过滤。

# 多滤掉列表中所有重复元素;
lst = [1,222,3,3,3,44,88,999,77,88,1]
print(lst)
res = set(lst)
print(res)
# 在把当前的集合转换成原来的列表
res2 = list(res)
print(res2)

10.4.5 容器的等级

一级容器：无任何嵌套
二级容器：有一层嵌套
三级容器：有两层嵌套
四级容器：有三层嵌套

10.4.5.1 容器的相互嵌套规则

list和元组内可以容纳int、float、布尔、复数、列表、元组、集合、字典。
set集合不能容纳列表、集合和字典。
字典的键可以是int、float、boolean、complex、string、tuple
字典的键不能是list、set、dict

 # 四级容器
container = [1,2,3,(4,5,6,{"a":1,"b":[11,"bingo"]})]
# (4,5,6,{"a":1,"b":[11,"bingo"]})
res1 = container[-1]
print(res1)

# {'a': 1, 'b': [11, 'bingo']}
res2 = res1[-1]
print(res2)

# [11, 'bingo']
res3 = res2["b"]
print(res3)

# bingo
res4 = res3[-1]
print(res4)

# 一步简写
res = container[-1][-1]["b"][-1]
print(res)

10.4.5.2 等长的列表

# 等长的二级容器
"""外面是容器,里面的元素也是容器,且元素个数相同"""
lst = [(1,2,3),[4,5,6],{7,8,9}]

10.4.6 字典的强制转换

要求: 必须是等长的二级容器,并且里面的元素个数是2个;
外层是列表,元组,集合 , 里层是列表或者元组的等长二级容器 => 字典;

# 1.外层是列表,里层是列表或者元组
lst = [ ["a",1] , ("b",2) ]
dic = dict(lst)
print(dic , type(dic)) # {'a': 1, 'b': 2} <class 'dict'>

# 2.外层是元组,里层是列表或者元组
tup = ( ["a",1] , ("b",2) )
dic = dict(lst)
print(dic , type(dic))

# 3.外层是集合,里层是元组
setvar = { ("a",1) , ("b",2) }
dic = dict(setvar)
print(dic , type(dic))

# 例外1:外层是列表/元组,里层放集合
"""可以实现,不推荐使用,因为达不到想要的目的,集合无序,不推荐使用"""
lst = [ ["a",1] , {"b","250"} ]
dic = dict(lst)
print(dic)

# 例外2:外层是列表/元组,里层放字符串
""" 字符串长度只能是2位,有极大的局限性,不推荐使用"""
lst = ["a1","b2"]
# lst = ["a11","b22"] error 
# dic = dict(lst)
# print(dic)

10.4.7 判断类型

方法1：
isinstance(数据,类型)
如果该数据是这个类型,返回True 反之,返回False
类型: int float complex bool str list tuple set dict
方法2：
isinstance( 数据, (类型1,类型2,类型3...) )
如果该数据在所对应的类型元组当中,返回True,反之,返回False

# 使用方法一
n = 123
res = isinstance(n , int)
print(res)
n = [1,2,3]
res = isinstance(n , list)
res = isinstance(n , tuple)
print(res)
# 使用方法二
n = "1233"
res = isinstance(n , (list , tuple ,set , str)  )
print(res)
n = {"a":1}
res = isinstance(n , (list , tuple ,set , str)  )
print(res)

十一、运算符

11.1加减乘除和基本逻辑运算

python中对于数值类型的加减乘除是符合数学的预算逻辑。
python中对于数值类型和需要比较的地方也是符合数学的基本逻辑。

# 基本逻辑运算
>  # 大于号
<  # 小于号
>= # 大于等于
<= # 小于等于
== # 恒等于
# 加减乘除
+ - * /

在python中两个整数相除，其结果肯定是小数，如果是整除，则整数后面增加.0。

11.1.1//--地板除

 # python中使用两个除号时运算结果会截取小数点左侧的数值。
 # 整数之间相除，结果是整数。
 # 两数任一一个为小数的，结果是小数。
print(2//3)
print(1.5//2)
print(1.5//0.2)

11.1.2取余 %

var1 = 7
var2 = 4
res = var1 % var2
res = -7 % 4  # -3 + 4 = 1
res = 7 % -4  # 3 + (-4) = -1
res = -7 % -4 # -3 (被除数和除数都是负的,正常结果加负号)
res = 81 % 7   # 4
res = 81 % -7  # -3
res = -81 % 7  # 3
res = -81 % -7 # -4
print(res)

11.1.3 ** 幂运算

res = 2 ** 3
print(res)

11.2 赋值运算符

# 赋值运算符:  = += -= *= /= //= %= **=
# = 赋值运算符 将右侧的值赋值给左侧变量
a = 10
b = 12
# +=
a += b
print(a)
# -=
a -= b
print(a)
# *=
a *= b
print(a)
# /=
a /= b
print(a)
# //=
a //= b
print(a)
# **=
a **= b
print(a)
# %=
a %= b
print(a)

11.3 成员运算符 in & not in

# 成员运算符:  in 和 not in (针对于容器型数据)
"""字符串判断时,必须是连续的片段"""
strvar = "今天天气要下雨,赶紧回家收衣服"

res = "今" in strvar
res = "天气" in strvar
res = "赶回" in strvar
print(res)

# 针对于列表,元组,集合
container = ["赵沈阳", "赵万里", "赵世超"]
container = ("赵沈阳", "赵万里", "赵世超")
container = {"赵沈阳", "赵万里", "赵世超"}
# res = "赵沈阳" in container
# res = "赵万里" not in container
res = "赵世" not in container
print(res)

# 针对于字典 (判断的是字典的键,不是值)
container = {"zsy": "赵沈阳", "zwl": "赵万里", "zsc": "赵世超"}
res = "赵沈阳" in container  # False
res = "zsy" in container
print(res)

11.4 身份运算符 is & is not

# 整型 -5~正无穷 
var1 = 100
var2 = 100
print(var1 is var2)

# 浮点型 非负数
var1 = -9.1
var2 = -9.1
print(var1 is var2)

# bool 相同即可
var1 = True
var2 = True
print(var1 is var2)

# complex 相同即可（3.9版本和3.11版本有效）
var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)

# 容器: 相同字符串 , 空元组相同即可  剩下的所有容器都不相同
container1 = ()
container2 = ()
print(container1 is not container2)

container1 = "你"
container2 = "你"
print(container1 is not container2)

container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)

11.5 逻辑控制符 not and or

# 逻辑运算符:  and or not
# and 逻辑与   
"""全真则真,一假则假"""
res = True and True    # True
print(res)
res = True and False   # False
print(res)
res = False and True   # False
print(res)
res = False and False  # False
print(res)

# or  逻辑或  
"""一真则真,全假则假"""
res = True or True    # True
print(res)
res = False or True   # True
print(res)
res = True or False   # True 
print(res)
res = False or False  # False
print(res)

# not 逻辑非  
res = not True
print(res)
res = not False
print(res)

# 逻辑短路

"""
无论后面的表达式是True 还是False 都已经无法改变最后的结果,那么直接短路,后面的代码不执行;
(1) True or print("程序执行了 ~ 1111")
(2) False and print("程序执行了 ~ 2222")

True or print("程序执行了 ~ 1111")
True or True => True
True or False => True
False and print("程序执行了 ~ 2222")
False and True  => False
False and False => False
计算规律:
    先脑补计算当前表达式的布尔值是True还是False
    如果出现了 True or 表达式  或者 False and 表达式的情况,直接返回前者,后面代码不执行
    如果没有出现短路效果,直接返回后者
"""

res = 5 and 6 # 6

True and True =>True
True and False => False

res = 5 or 6  # 5
res = 0 and 999
res = 0 or "abc"
print(res)

# 逻辑运算符的优先级
""" 优先级从高到低: () > not > and > or   """
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
"""
not (False or False) => True
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
res = True or False and True or True and True
res = True or False or True
res = True or True => True
"""
print(res)

11.6 位运算符（了解，极少数开发使用）

# ### (7)位运算符:    & |  ^ << >> ~

var1 = 19
var2 = 15

# & 按位与
res = var1 & var2
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""
print(res)

# | 按位或
res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
print(res)

# ^ 按位异或
"""两个值不相同=>True 反之返回False"""
res = var1 ^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
print(res)

# << 左移 (相当于乘法)
"""5乘以2的n次幂"""
res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)

"""
000 ... 101  => 5
000 .. 1010  => 10
000 ..10100  => 20
000 .101000  => 40
"""

# >> 右移 (相当于除法)
"""5地板除2的n次幂"""
res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""
print(res)


# ~ 按位非 (针对于补码进行操作,按位取反,包含每一位)
""" -(n+1) """
# res = ~22
res = ~19
print(res)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011

补码:   000 ... 10011
按位非: 111 ... 01100

给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""

res = ~-19
print(res)
"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101

补码:   111 ... 01101
按位非: 000 ... 10010

给你补码->原码 (因为是整数 ,原反补相同)
000 ... 10010 => 19
"""

11.7 运算符的优先级

个别运算符:
    运算符优先级最高的: **
    运算符优先级最低的: =
    ()可以提升优先级
    
一元运算符 > 二元运算符 (优先级)
    一元运算符 : 同一时间,操作一个值 ~ - 
    二元运算符 : 同一时间,操作一个值 + - * / ....
    
同一种类运算符:
    算数运算符 : 乘除 > 加减
    逻辑运算符 : () > not > and > or 
    位运算符   : ( << >> ) > & > ^ > |

整体排序:
    算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
    赋值运算符用来做收尾
    

res = 5+5 << 6 // 3 is 40 and False
res = 10 << 2 is 40 and False
res = 40 is 40 and False
res = True and False
res = False
print(res)
# 用括号提升下优先级
res = (5+5) << (6//3) is 40 and False

十二、流程控制

流程: 代码执行的过程
控制: 对代码执行过程中的把控
程序的三大结构:
(1)顺序结构: 默认代码从上到下,依次执行
(2)分支结构: 单项分支 双向分支 多项分支 巢状分支
(3)循环结构: while / for

12.1 代码块

代码块 (以冒号作为开始,用缩进来划分相同的作用域,这个整体是代码块)
不同于其他语言的代码块，Python的代码块的作用域是靠缩进来体现的

if 10 == 11:# 以冒号开始
    print(1)# 作用域的范围
    print(2)# 作用域的范围
    print(3)# 作用域的范围
# 结束缩进，代表代码块的作用域结束
print(4)#此行代码与if语句同级。

12.1.1 快捷键

tab 向右缩进
shift + tab 向左缩进

12.2 判断结构

12.2.1 单项分支

'''
if 条件表达式:
    code1
    code2
'''
gongzi = 20000
if gongzi >= 18000:
    print("拿高薪")

12.2.2 双项分支

"""
if 条件表达式:
    code1  ..
else:
    code2 ... 
如果条件表达式成立,返回True ,执行if这个区间的代码块
如果条件表达式不成立,返回False,执行else这个区间的代码块
if   分支的代码块也叫做真区间
else 分支的代码块也叫做假区间
"""
zhiye = "美团外卖骑手"
zhiye = "律师"
if zhiye == "美团外卖骑手":
    print("注意安全！")
else:
    print("为正义而战！")

12.2.3 多项分支

"""
if 条件表达式1:
    code1 
elif 条件表达式2:
    code2
elif 条件表达式3:
    code3
else:
    `code4
如果条件表达式1成立,执行对应的分支code1,反之判断条件表达式2是否成立
如果条件表达式2成立,执行对应的分支code2,反之判断条件表达式3是否成立
如果条件表达式3成立,执行对应的分支code3,如果不成立,直接走else分支,到此程序执行完毕
elif 可以是0个 或者 多个
else 可以是0个 或者 一个
"""

12.2.4 巢状分支

单项分支,双向分支,多项分支的互相嵌套组合

12.3 循环结构

特点:减少冗余代码,提升执行效率

12.3.1 while--do--

'''
i = 0
while 条件表达式：
  code
  迭代语句
i：声明一个变量作为控制循环迭代
条件表达式：判断条件
code：循环语句
迭代语句：自增或自减
'''
# 打印1 ~ 100
# (1) 初始化一个变量
i = 1
# (2) 写上循环的条件
while i <= 100:
    # (4) 写上循环的逻辑
    print(i)
    # (3) 自增自减的值
    i += 1 # i = i + 1
"""
代码解析:
第一次循环
i = 1  i<=100 判断为真,执行循环体 print(1)
i += 1 i => 2 
第二次循环
代码回到17行,重新进行条件判定 
i = 2  i<=100 判断为真,执行循环体 print(2)
i += 1 i => 3
第三次循环
代码回到17行,重新进行条件判定 
i = 3  i<=100 判断为真,执行循环体 print(3)
i += 1 i => 4
...
以此类推 
直到i = 101  i <= 100 判断为假,不执行循环体,到此循环结束...
1 ~ 100
"""
# 1 ~ 100的累加和
# (1) 初始化一个变量
i = 1
total = 0

# (2) 写上循环的条件
while i <= 100 :
    # (4) 写上自定义的逻辑
    total += i
    # (3) 自增自减的值
    i += 1
print(total)

"""
代码解析:
第一次循环
i = 1 i <= 100 判定为真True 执行循环体 total += i => total = total + i => 0 + 1
i += 1  => i = 2
第二次循环
i = 2 i <= 100 判定为真True 执行循环体 total += i => total = total + i => 0 + 1 + 2
i += 1  => i = 3
第三次循环
i = 3 i <= 100 判定为真True 执行循环体 total += i => total = total + i => 0 + 1 + 2 + 3 
i += 1  => i = 4
...
依次类推
当i = 101 101 <= 100 判定为假False 不执行循环体,到此,循环结束..
total += i => total + i => 0 + 1 + 2 + 3 + 4 + .... + 100 => 5050
"""
# 死循环
"""
while True:
    print(1)
"""
# 用死循环的方法实现 1 ~ 100累加和
i = 1
total = 0
sign = True
while sign:
    total += i
    i+=1
    
# 判断i是否加到了101 , 不参与循环
    if i == 101:
# 终止循环
        sign = False
print(total) #1 ~ 100 = 5050

12.3.2 关键字pass break continue

# ### 关键字的使用  pass break continue
# pass 过 (代码块中的占位符)
"""
if 20 == 20:
    pass
    
while True:
    pass
"""

# break 终止当前循环 (只能用在循环之中)
# 1 ~ 10 遇到5终止循环
i = 1
while i <= 10:
    print(i)
    if i == 5:
        break
    i +=1
i = 1
while i <= 3:
    
    j = 1
    while j <=3:
        if j == 2:
            break
        print(i,j)
        j+=1
    i +=1
# 1 1
# 2 1 
# 3 1
"""
if 5 == 5: error
    break
"""
# continue 跳过当前循环,从下一次循环开始
# 打印 1 ~ 10 跳过5
i = 1
while i <= 10:    
    if i == 5:
        # 在跳过之前,因为会终止执行后面的代码,从下一次循环开始
        # 为了避免死循环,手动加1
        i += 1
        continue
    print(i)
    i +=1
# 1 ~ 100 打印所有不含有4的数字
# 方法一
print("<============>")
i = 1
while i <= 100:
    strvar = str(i)
    # print(strvar)
    if "4" in strvar:
        i += 1
        continue
    print(i)
    i +=1
# 方法二
print("<============>")
i = 1
while i <= 100:
    if i // 10 == 4 or i % 10 == 4:
        i+=1
        continue
    print(i)
    i+=1

12.3.3 for循环

for循环把容器中的元素一个一个获取出来。

'''
Iterable 可迭代性数据：1.容器类型数据 2.range对象 3.迭代器
for 变量 in Iterable:
    code1.
'''
# 字符串
container = "北京和深圳温差大概20多度"
for i in container:
    print(i)
# 列表
container = [1,2,3,4,4,5]
for i in container:
    print(i)
# 元组
container = ("孙开洗","孙健","孙悟空")
for i in container:
    print(i)
# 集合 
container = {"陈璐","曹静怡","王志国","邓鹏","合力"}
for i in container:
    print(i)
# 字典
container = {"cl":"风流倜傥","cjy":"拳击选手","wzg":"寻花问柳","dp":"帅气,祖国的栋梁","hl":"你是个好人"}
for i in container:
    print(i)
print("<===================>")
# 1.遍历不等长多级容器
container = [1,2,3,4,("嗄","234",{"马春配","李虎凌","刘子涛"})]
for i in container:
    # 判断当前元素是否是容器,如果是,进行二次遍历,如果不是,直接打印
    if isinstance(i,tuple):
        # ("嗄","234",{"马春配","李虎凌","刘子涛"})
        for j in i:
            # 判断当前元素是否是集合,如果是,进行三次遍历,如果不是,直接打印
            if isinstance(j,set):
                # j = {"马春配","李虎凌","刘子涛"}
                for k in j :
                    print(k)
            else:
                print(j)
                
    # 打印数据
    else:
        print(i)
# 2.遍历不等长多级容器
container = [("刘玉波","历史源","张光旭"), ("上朝气","于朝志"),("韩瑞晓",)]
for i in container:
    for j in i:
        print(j)
# 3.遍历等长的容器
container = [("马云","小马哥","马春配") , ["王健林","王思聪","王志国"],{"王宝强","马蓉","宋小宝"}]
for a,b,c in container:
    print(a,b,c)
# 变量的解包
a,b,c = "poi"
a,b = (1,2)
a,b = 1,2
a,b,c = [10,11,12]
a,b = {"林明辉","家率先"}
a,b = {"lmh":"林明辉","jsx":"家率先"}
a,b,c = ("马云","小马哥","马春配")
print(a,b,c)

# ### range对象
"""
range([开始值,]结束值[,步长])
取头舍尾,结束值本身获取不到,获取到它之前的那一个数据
"""

# range(一个值)
for i in range(5): # 0 ~ 4
    print(i)

# range(二个值)
for i in range(3,8): # 3 4 5 6 7 
    print(i)

# range(三个值) 正向的从左到右
for i in range(1,11,3): # 1 4 7 10 
    print(i)

# range(三个值) 逆向的从右到左
for i in range(10,0,-1): # 10 9 8 7 ... 1 
    print(i)
# 总结:
"""
while 一般用于处理复杂的逻辑关系
for   一般用于迭代数据
部分情况下两个循环可以互相转换;
"""
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
        j+=1
    print()    
    i +=1
for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
    print()
# 打印 1 ~ 10 跳过5
i = 1
while i <= 10:    
    if i == 5:
        i += 1
        continue
    print(i)
    i +=1
for i in range(1,11):
    if i == 5:
        continue
    print(i)

内置函数

type()#返回对应的数据类型
id()#返回变量的内存地址值
#print函数的用法
print(val01,val02,...,valn)
complex(实数,虚数)#函数定义复数
int()#Int()参数必须是字符串、类字节对象或实数
repr()#不转移字符原型化输出字符串
# 默认不加任何值,转换成该数据类型的空值
str() 
list()  
tuple()  
set()  
dict()
# 输入
input("请输入文字！")# 与用户交互的函数，用户输入文本与程序交互。