什么是转义字符呢？
1. 就是反斜杠+想要实现的转义功能首字母。
为什么需要转义字符？
1. 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义）
  1. 反斜杠：\\
  2. 单引号：\'
  3. 双引号：\\"
当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符.
1. 1. 换行：\n
  2. 回的：\r
  3. 水平制表符：\t
  4. 退格：\b

Python中的标识符和保留字
我的保留字
1. 有一些单词被我赋予了特定的意义，这些单词你在给你的任何对象起名字的时候都不能用。


#实例
import keyword 
print(keyword. kwlist)
#运行结果
['False', 'None', 'True', '__peg_parser__', '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']

我的规则你必须要知道
变量、函数、类、模块和其它对象的起的名字就叫标识符
1. 规则：
  1. 字母、数字、下划线-
  2. 不能以数字开头
  3. 不能是我的保留字
  4. 我是严格区分大小写的


#实例
name='马丽亚”
print（name）
print（'标识'，id（name））
print（'类型'，type（name））
print（'值'，name）
#运行结果
马丽亚
标识2633937837872
类型<class 'str'>'
值 马丽亚

10.变量的多次赋值。


#实例
name= '马丽亚'
name='楚溜冰'
print（name)
#运行结果
楚溜冰

11.Python中常见的数据类型

常用的数据类型
整数类型→int →98
点数类型→float →3.14159
布尔类型→bool →True，False
字符串类型→str →'人生苦短，我用Python'

12.数据类型-整数类型


#实例
nl=90
n2=-76
n3=0
print(nl, type(n1))
print(n2, type(n2))
print(n3, type(n3))
#整数可以表示为二进制，十进制，八进制，十六进制
print（'十进制'，118）
print（'二进制'，Ob10101111）    #想要输出二进制前面必须加0b
print（'八进制'，0o176）    #八进制以00开头
print（'十六进制'，Ox1EAF）
#运行结果
90 <class'int'>
-76 <class 'int'>
0 <class' int'>
十进制 118
二进制 175
八进制126
十六进制7855
验证:打开windows系统Dos窗口键入calc打开程序计算器

13.数据类型浮点类型


#浮点类型
#浮点数整数部分和小数部分组成
#浮点数存储不精确性
#使用浮点数进行计算时，可能会出现小数位数不确定的情况
print（1.1+2.2）#3.30000000000
print（1.1+2.1）#3.2
解决方案
导入模块decimal 
from decimal import Decimal 
print（Decimal（'1.1'）+Decimal（'2.2'））#3.3
#实例
a=3.14159
print（a，type（a））
nl=1.1
n2-2.2
print（nl+n2）
#运行结果
3.14159 <class ' float'>
3.3000000000000003
解决浮点不精确
from decimal import Decimal 
print (Decimal (' 1. 1')+Decimal (' 2. 2'))
#运行结果
3.3
浮点数与浮点数相加就会出现这个问题，二进制的底层逻辑问题
#实例
fl=True 
f2=False 
print (fl, type(f1))
print (f2, type (f2))
#布尔值可以转成整数计算
print（fl+1）
    #21+1的结果为2 True表示1
print（f2+1）
    #10+1的结果为1，False表示0
#运行结果
True <class'bool' >
False <class 'bool' >
2
1

14.数据类型布尔类型

布尔类型

用来表示真或假的值

True表示真，False表示假

布尔值可以转化为整数

True→1

False→0

print（True+1）#2

15.数据类型_字符串类型

字符串类型
字符串又被称为不可变的字符序列
可以使用单引号”双引号””三引号””，或”””"”"来定义
单引号和双引号定义的字符串必须在一行三引号定义的字符串可以分布在连续的多行


str1='人生苦短，我用Python'
str2="人生苦短，我用Python"
str3=""人生苦短，我用Python""
str4=""人生苦短，
我用Python""
#实例
strl='人生苦短，我用Python'
str2="人生苦短，我用Python"    #单引号和双引号只能在一行实现
str3="""人生苦短，
我用Python"""
str4
='''人生苦短，
我用Python'''                #而三引号和三单引号可以多行实现
print(strl,type(str1)) 
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))
#运行结果
人生苦短，我用Python <class'str'>
人生苦短，我用Python <class'str'>
人生苦短，
我用Python <class'str'>
人生苦短，
我用Python <class'str'>

16.类型转换_str（）函数与int（）函数


#实例1
name='张三'
age=20
print（type（name），type（age））#说明name与age的数据类型不相同
print（'我叫'+name+'今年，'+age+'岁'）#当将str类型与int类型进行连接时，报错，解决方案，类型转换
#解决方案
print（'我'+name+'Af，'+str（age）+'岁'）
#将int类型通过str（）函数转成了str类型
#运行结果（报错实例）1
<class'str'> <class 'int' >
Traceback（most recent call last）：
    File"E:/vippython/chap2/demo8.py"，line 8，in（module>
        print（'我'+name+'今年，'+age+''）
TypeError：can only concatenate rstr（not"int"）to str
#运行结果（解决实例）1
<class
'str'> <class 'int' >
我叫张三今年，20岁
#实例2
print（'-----str（）将其它类型转成str类型-----'）
a=10
b=198.8
c=False 
print（type（a），type（b），type（c））
print（str（a），str（b），str（c），type（str（a）），type（str（b）），type（str（c）））
#运行结果2
---str（）将其它类型转成str类型----
<class'int'> <class'float'> <class'bool'>
10 198.8 False <class'str'> <class'str'> <class'str'>
#实例3
print（'--------int（）将其它的类型转int类型------'）
s1='128'
f1=98.7
s2='76.77'
ff=True 
s3='hello'
print（type（s1），type（f1），type（s2），type（ff），type（s3）)
print（type（s1），type（fl），type（s2），type（ff），type（s3））
print（int（sl），type（int（s1）））    #将str转成int类型，前提是字符串为数字串


print(int(f1)，type(int(f1)))    #float转成int类型，截取整数部分，舍掉小数部分
#print(int(s2)，type(int(s2))) #将str转成int类型，报错，因为字符串为小数串
print(int(ff)，type(int(ff)))
#print(int(s3)，type（int(s3))) #将str转成int类型时，字符串必须为数字串（整数），非数字串是不允许转换
#运行结果3
-----int（）将其它的类型转int类型----
<class'str'> <class'float'> <class'str'> <class'bool'> <class'str'>
128 <class
'int'>
98 <class 'int'>
1
<class ' int'>
#实例4
print（'-----float（）函数，将其它数据类型转成float类型'）
s1='128.98'
s2='76'
ff=True 
s3='hello'
i=98
print（type（s1），type（s2），type（ff），type（s3），type（i））
print（float（sl），type（float（s1）））
print（float（s2），type（float（s2）））
print（float（ff），type（float（ff）））
#print（float（s3），type（float（s3）））     #字符串中的数据如果是非数字串，则不允许转换
print (float (i), type (float (i)))
#运行结果4
128.98 <class float'>
76.0 <class 'float'>
1.0 <class 'float'>
98.0 <class ' float' >

18.Python中的注释

注释
1. 在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性
2. 注释的内容会被Python解释器忽略
3. 通常包括三种类型的注释
  1. 单行注释→以"#"开头，直到换行结束
  2. 多行注释→并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
  3. 中文编码声明注释→在文件开头加上中文声明注释，用以指定源码文件的编码格式


# coding:gbk
# coding:utf-8    中文编码声明注释，语句需要写在文档最前面
#输入功能（单行注释）
print（'hello'）
'''嘿嘿
,我是
多行注释'''

19.input函数的使用


#实例
#输入函数input 
present=input（'大圣想要什么礼物呢？'）
print（present，type（present））
#运行结果
大圣想要什么礼物呢？ 定海神针    #后面的定海神针手动在运行结果中输入
定海神针<class 'str'>

20.input函数的高级使用


#练习题题干
#从键盘录入两个整数，计算两个整数的和
#实例
a=input('请输入一个加数：')
a=int(a)    #将转换之后的结果存储到a中
b-input('请输入另一个加数:')
b=int(b)
print(type(a),type(b))
print（a+b）
#运行结果
请输入一个加数：10    #后面的10这个要求输入的加数手动在运行结果中输入
请输入另一个加数：20    #后面的20这个要求输入的加数手动在运行结果中输入
1020    #没转数据类型的错误值
30    #转int数据类型后的正确值
#从运行结果得知，10加20应为30，但实际输出结果为1020，原因分析是数据类型问题，数据类型为str，因此+号就变成了连接作用
#当然也可以直接把转换写进去，写成嵌套的形式
a=int(input('请输入一个加数：'))
#a=int(a）    
#将转换之后的结果存储到a中。这句目前为注释掉
b=int(input('请输入另一个加数:'))
#b=in(b）    #这句目前为注释掉
print(type(a)，type(b))
print(a+b)

21.运算符_算术运算符


#标准运算符实例1
print（1+1）#加法运算
print（1-1）#减法运算
print（2*4）#乘法运算
print（1/2）#除法运算
print（11/2）#除法运算
print（11//2）#5 整除运算
#运行结果1
2
0
8
0.5
5.5
5
#取余运算符实例（也称取模运算）2
print（11%2）#取余运算
#运行结果2
1
#幂余运算符实例（也称取模运算）3
print（2**2）#表示的是2的2次方
print（2**3）#表示的是2的3次方 2*2*2
#运行结果3
4
8

算数运算符


#实例
print (9//4) #2
print (-9//-4) # 2    负负得正
print (9//-4) #-3    9/-4等于2.2多少，2除完还有余数上10，继续2。因此按照算数运算符的整数运算规则：一正一负向下取整，所以是-3.  
print (-9//4) # -3
print（9%-4）    #-3     公式 余数=被除数-除数*商  9-（-4）*（-3）     9-12-->  -3
print（-9%4）    #3    
-9-4*（-3）  -9+12--> 3
#运行结果
2
2
-3
-3
-3
3

22.运算符_赋值运算符


#赋值运算符，运算顺序从右到左
#实例1
a=3+4    #运算逻辑：先将等号右侧计算结果，然后再将结果赋值给a
print(a)
#运行结果1
7
#链式赋值
#实例2
a-b=c=20
print(a，id(a))
print(b，id(b))
print(c，id(c))
#运算结果2
20 140708881340672    #值都是20，标识都相同，标识就是内存地址，可理解为a值的唯一识别码
20 14070888134067
2    #它的type肯定是Int，value都是20
20 140708881340672    #所以这里的链式赋值只有一个整数对象，但却有abc三个引用在指向这个位置上，这就是所说的链式赋值
#参数赋值
实例1
print（'-------支持参数赋值-----）
a=20
a+=30
    #相当于a=a+30
print（a）
a-=10
    #相当于a=a-10
print（a）
a*=2
    #相当于a=a*2
print（a）
print(type(a))    #得出结论数据类型为int
a/=3
print(a)
print(type(a))    #得出结论数据类型为float
a//=2
print(a)    #float类型a和2进行整除，结果还是float类型
a%=3
print(a)
#运行结果1
50
40
80
<class 'int'>
26.666666666666668
<class 'float'>
13.0
<class 'float'>
1.0
#支持系列解包赋值
a,b,c=20,30,40    #简单讲就是分别赋值，20赋值给a、30赋值给b，40赋值给c（要求等号两边相同，否则会报错)
#实例2
print（'-----解包赋值-------')
a，b，c=20，30，40
print（a，b，c）
#a，b=20，30，40     报错，因为左右变量数的个和值的个数不对应
#运行结果2
------解包赋值-----
20 30 40
解包赋值好处：在其他编程软件中，如果要实现两个变量的交换，可能需要中间变量，但python中一句代码就可以
#实例3
print（'-------交换两个变量的值-------')
a，b=10，20
print('交换之前：',a,b)
#交换
a，b-b，a print('交换之后：',a,b)
#运行结果3
-----交换两个变量的值-----
交换之前：10 20
交换之后：20 10

23.运算符-比较运算符


#实例1
#比较运算符，比较运算符的结果为bool类型
a,b=10,20
print('a>b吗？'，a>b)    #False 
print('a<b吗？'，a<b)    #True 
print('a<=b吗？'，a<=b)    #True 
print('a>=b吗？'，a>=b)    #False
print('a==b吗？'，a==b)    #False     #一个=称为赋值运算符，==称为比较运算符
print('a!=b吗？'，a!=b)    #True
#运行结果
a>b吗？False 
a<b吗？True 
a<=b吗？True 
a>=b吗？False
a==b吗？False 
a!=b吗？True
'''一个变量由三部分组成，标识，类型，值
比较的是值还是标识呢？    比较的是值
比较对象用is    #id标识
'''
a=10
b=10    #a和b赋值都是10，它会现在内存当中看下有没有10这个值，如果有就不再新创建了，它会把标识也叫做和10赋值的标识一样的，同样也会指向这个标识
print（a==b）
    #True 说明，a与b的value 相等
print（a is b）    #True 说明，a与b的id标识，相等
#以下代码本节之前没有，后面会有
#实例2
lst1=[11，22，33，44]
lst2=[11，22，33，44]
print（lstl==lst2）
    #value
 -->True     
print（lstl is lst2）    #id
     -->False 
print（id（1st1））
print（id（1st2））
print（a is not b）#False a的id与b的id是不相等的吗？运行结果是false，为不相等
print（lstl is not lst2）#True    a的id与b的id是不相等的吗？运行结果是true，为相等
#运行结果
2672524714432
2672525955712    #得出结论两个id标识并不相同
False
True

24.运算符_布尔运算符


#实例
#布尔运算符
a，b=1，2
print('-----and并且-------')
print（a==1 and b==2）    #True True and True-->True 
print（a==1 and b>2）    #False True and False-->False 
print（a!=1 and b==2）    
#False False and True-->False 
print（a!=1 and b!=2）    #False False and False-->False
print('-----or或者-------')
print（a==1 or b==2）    #True or True -->True
print（a==1 or b<2）    #True or False -->True
print（a!=1 or b==2）  #False
or
True -->True
print（a!=1 or b!=2）    #False or
False -->False   
print('-----not 对bool类型操作数取反-------')
f=True
f2=False
print（not f）
print（not f2）
print('-----in与not in-------')
s='helloworld'
print（'w’in s）#True    w在s中吗？
print（'k'in s）#False    k在s中吗？
print（'w'not in s）#False    w不在s中（实际上是在的，因此返回为false)
print（'k'not in s）#True     w在s中（确实不在，因此返回为true)
#运行结果
-----and并且-------
True
False
False
False
-----or或者-------
True
True
True
False
-----not 对bool类型操作数取反-------
False
True
-----in与not in-------
True
False
False
True

25.运算符_位运算

将数据转成二进制进行计算

位与&：对应数位都是1，结果数位才是1，否则为

十进制4的二进制为100,十进制4的二进制为1000，没有的部分0补齐


#实例
print(4&8)#按位与&，同为1时结果为1
#运行结果
0

位或|：对应二进制数位都是0，结果数位才是0，否则为1

可以看到，结果为1100。dos窗口cals程序员计算器验证一下。


#实例
print（4 8）#按位或，同为0时结果为0
#运行结果
12

左移位运算符<<：高位溢出舍弃，低位补0

右移位运算符>>：低位溢出舍弃，高位补0

26.运算符的优先级

从左向右看得出结论（按优先级排序）
通常情况下：①算数运算符先算乘除后算加减，有幂运算先进行幂运算②位运算符③比较运算符④布尔运算符⑤赋值运算符
通常情况之外另外注意：有括号会先计算括号内的内容，括号的优先级是最高的。

27.程序的组织结构_顺序结构

1996年，计算机科学家证明了这样的事实：任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合。

程序从上到下顺序地执行代码，中间没有任何的判断和跳转，直到程序结束。


#顺序结构实例
print('-----程序开始-----')
print（'1.把冰箱门打开'）
print（'2.把大象放冰箱里'）
print（'3.把冰箱门关上'）
print('-----程序结束-----')
#运行结果
-----程序开始-----
1.把冰箱门打开
2.把大象放冰箱里
3.把冰箱门关上
-----程序结束-----

28.对象的布尔值

Python一切皆对象，所有对象都有一个布尔值
1. 获取对象的布尔值
  1. 使用内置函数bool（）
以下对象的布尔值为False
1. False
2. 数值0
3. None
4. 空字符串
5. 空列表
6. 空元组
7. 空字典
8. 空集合


#实例（验证）
-#测试对象的布尔值
print('------以下对象的布尔值为false-------')
print(bool(False))#False
print(bool(0))#False
print(bool(0.0))#False
print(bool(None))#False
print(bool('')) #False    空字符串
print(bool("")) #False    空字符串
print(bool([])) #空列表
print(bool(list()))    #空列表
print(bool(())) #空元组
print(bool(tuple()))    #空元组
print(bool(())) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合
#运行结果
False
False
False
False
False
False
False
False
False
False
print('------其它对象的布尔值为True-------')   #除上面一些情况外其它都为true
print (bool (18))
print (bool (True))
print (bool (' helloworld')
#运行结果
True
True
True

29.分支结构_单分支结构

1. 程序根据判断条件的布尔值选择性的执行部分代码；
2. 明确的让计算机知道在什么条件下，该去做什么；

单分支结构
1. 中文语义：如果...就...
  1. 1. 1. 如果你是妖怪，就该被孙悟空打
      2. 如果下雨，就带伞
      3. 如果是周六，就不上班
  2. 语法结构：
    1. if条件表达式：
      1. 条件执行体


#实例
money=1000 #余额
s=int(input('请输入取款金额')) #取款金额（解析：input本身为str类型，通过int将其完成类型转换，尔后赋值给s）
#判断余额是否充足
if money>=s:
    money=money-s #只有条件为true时才执行这条语句
    print('取款成功，余额为:',money)
#运行结果
请输入取款金额900
取款成功，余额为: 100

30.分支结构_双分支结构

4/2=2余0，6/2=3余0；

5/2=2余1，9/2=4余1；

由此可见，只要是偶数除和2的余数都为0，基数和2的余数都为1


#实例
 '''从键盘录入一个整数，编写程序让计算机判断是奇数还是偶数'''
num=int(input('请输入一个整数'))
#条件判断
if num%2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')
#运行结果
请输入一个整数11
11 是奇数
请输入一个整数10
10 是偶数

31.分支结构_多分支结构

从流程图可以得知，只有当程序运行第一个逻辑判断表达式为true时，才有机会继续向下运行，否则直接结束
方括号[]当中的语法是可以省略的，也就是说在多分支结构当中，else是可以不写的


题干要求
'''多分支结构，多选一执行
从键盘录入一个整数 成绩
90-100 A
80-89 B
70-79 C
60-69 D
0-59 E
小于0或大于100为非法数据（不是成绩的有效范围）
'''
#实例写法1
score=int(input('请输入一个成绩：'))
#判断
if score>=90 and score<=100:
    print('A级')
elif score>=80 and score<=89:
    print('B级别')
elif score>=70 and score<=79:
    print('C级')
elif score>=60 and score<=69:
    print('D级')
elif score>=0 and score<=60:
    print('E级')
else:
    print('对不起，成绩有误，不在成绩的有效范围')
#运行结果1
请输入一个成绩：90
A级
请输入一个成绩：66
D级
请输入一个成绩：101
对不起，成绩有误，不在成绩的有效范围
#实例写法2(这种写法在其它编程语言中是不可以的，在python中可以)
score=int(input('请输入一个成绩：'))
#判断
if 90<=score<=100:
    print('A级')
elif 80<=score<=89:
    print('B级别')
elif 70<=score<=79:
    print('C级')
elif 60<=score<=69:
    print('D级')
elif 0<=score<=60:
    print('E级')
else:
    print('对不起，成绩有误，不在成绩的有效范围')

32.分支结构_嵌套if的使用


#实例
'''会员 >=200 8折
        >=100 9折
        不打折
    非会员 >=200   9.5折
        不打折'''
 
answer=input('你是会员吗?y/n')
money=float(input('请输入您的购物金额:'))
#外层判断是否是会员
if answer=='y': #会员
    if money>=200:
        print('打8折，付款金额为：',money*0.8)
    elif money>=100:
        print('打9折，付款金额为：',money*0.9)
    else:
        print('不打折，付款金额为：',money)
else: #非会员
    if money>=200:
        print('打9.5折，付款金额为:',money*0.95)
    else:
        print('不打折，付款金额为：',money)
#运行结果
你是会员吗?y/n    y
请输入您的购物金额:230
打8折，付款金额为： 184.0
你是会员吗?y/n    y
请输入您的购物金额:60
不打折，付款金额为： 60.0
你是会员吗?y/n    n
请输入您的购物金额:600
打9.5折，付款金额为: 570.0
你是会员吗?y/nn
请输入您的购物金额:160
不打折，付款金额为： 160.0

33.条件表达式

条件表达式
1. 条件表达式是if...else双分支结构的简写
2. 语法结构：

x if 判断条件 else y

1. 运算规则

如果判断条件的布尔值为True，条件表达式的返回值为x，否则条件表达式的返回值为


#实例
'''从键盘录入两个整数，比较两个整数的大小'''
num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
'''正常的一个写法
if num_a>=num_b:
    print(num_a,'大于等于',num_b)
else:
    print(num_a,'小于',num_b)
'''
print('使用条件表达式进行比较')
#第1种写法
#print(  (num_a,'大于等于',num_b)  if num_a>=num_b  else  (num_a,'小于',num_b) )
#第2种写法
#前面将num_已经转成int类型，因此现在如果想对其进行连接就必须将其转为字符串类型str；
#条件判断if num_a>=num_b执行结果为true就运行左边的代码，如果为false就执行右边的代码；
print( str(num_a)+'大于等于'+str(num_b)  if num_a>=num_b else  str(num_a)+'小于'+str(num_b) )
#运行结果
请输入第一个整数10
请输入第二个整数2
使用条件表达式进行比较
10大于等于2

34.pass语

pass语句
1. 语句什么都不做，只是一个占位符，用在语法上需要语句的地方
2. 什么时候使用：
  1. 先搭建语法结构，还没想好代码怎么写的时候
3. 哪些语句一起使用
  1. if语句的条件执行体
  2. for-in语句的循环体
  3. 定义函数时的函数体


#实例
answer=input('您是会员吗？y/n')
#判断是否是会员
if answer=='y':
    pass
else:
    pass
#语法结构搭建完毕，而且程序不报错，所以pass经常在需要写语句的地方使用它，先占一个语句的位置，让语法不报错。
#运行结果


#补充实例
age=int(input('请输入您的年龄'))
if age:     #由下面两个注释解释可以得出结论，可以直接把对象放在条件表达式处做判断
    print(age)  #假设我们键入18这个数字，18的布尔值为true，所以18就是true
else:
    print('年龄为：',age)    #假设我们键入0，0的布尔值为false，所以0就是false
#运行结果
请输入您的年龄18
18
请输入您的年龄0
年龄为： 0

35.range函数的使用


#实例
#range()的三种创建方式
'''第一种创建方式，只有一个参数（小括号中只给了一个数）'''
r=range(10) #[0,1,2,3,4,5,6,7,8,9],默认从0开始，默认相差1称为步长
print(r) #range(0,10)
print(list(r)) #用于查看range对象中的整数序列   -->list是列表的意思
'''第二种创建方式，给了两个参数（小括号中给了两个数）'''
r=range(1,10) #因为指定了起始值，从1开始，到10结束（不包含10），默认步长为1
print(list(r)) #[1,2,3,4,5,6,7,8,9]
'''第三种创建方式，给了三个参数（小括号中给了三个数）'''
r=range(1,10,2)
print(list(r)) #[1,3,5,7,9]
'''判断指定的整数，在序列中是否存在in,not in'''
print(10 in r) #false,10不是当前的r这个整数序列中
print(9 in r) #true，9在当前的r这个序列中
print(10 not in r) #True
print(9 not in r) #false
print(range(1,20,1)) #[1...19]
print(range(1,101,1)) #[1...100]
#运行结果
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
False
True
True
False
range(1, 20)
range(1, 101)

36.while循环


#实例
a=1
#判断条件表达式
#if a<10:
while a<10:
    #执行条件执行体
    print(a)
    a+=1
#运行结果
1
1
9


#实例
#计算0到4之间的累加和4步循环法
'''四步循环法
    1.初始化变量
    2.条件判断
    3.条件执行体（循环体）
    4，改变变量
总结：初始化的变量与条件判断的变量与改变的变量为同一个'''
sum=0 #用于存储累加和
'''初始化变量为0'''
a=0
'''条件判断'''
while a<5:
    '''条件执行体（循环体）'''
    sum+=a
    '''改变变量'''
    a+=1
print('和为：',sum)
#运行结果
和为： 10

37.while练习题1到100之间的偶数和


#实例
'''计算1到100之间的偶数和'''
print(bool(0)) #输出0的布尔值，用于查看0的布尔值是什么
sum=0 #用于存储偶数和
'''初始化变量'''
a=1 #赋值
'''条件判断'''
while a<=100:
    '''条件执行体（求和）'''
    #条件判断是否为偶数
#    if a%2==0: 和为2550  -->写法一    判断2的余数是不是等于0然后赋值给a
#    if bool(a%2): 和为2500  -->写法二     判断2的余数是true还是false，2的余数是0，0为false，因此就变成了奇数和
     if not bool(a%2): #和为2550  -->写法三     判断2的余数是true还是false，2的余数是0，0为false，使用not bool进行取反就变成了偶数和
        sum+=a
    '''改变变量'''
    a+=1
print('1-100之间的偶数和：',sum)
#运行结果
1-100之间的偶数和2550

38.for_in循环


#实例1
for item in 'python': #第一次取出来的是p，将p赋值给item，将item的值输出。其中python就是可迭代对象
    print(item)
#运行结果1
p
y
n
#实例2
#range() 产生一个整数序列， -->也一个可迭代对象
for i in range(10):
    print(i)
#运行结果2
1
9
#实例3
#如果在循环体中不许要使用到自定义变量，可将自定义变量写为“_”
for _ in range(5):
    print('人生苦短，我用Python')
print('使用for循环，计算1到100之间的偶数和')
sum=0 #用于存储偶数和
for item in range(1,101): #item为自定义变量
    if item %2==0:
        sum+=item
print('1-100之间的偶数和为：',sum)
#运行结果3
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
使用for循环，计算1到100之间的偶数和
1-100之间的偶数和为： 2550

39.for_in练习题100到999之间的水仙花数

概念：水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153，也就是1*1*1+5*5*5+3*3*3=153.

水仙花数只是自幂数的一种，严格来说3位数的3次幂数才称为水仙花数。

1. 常见的水仙花数
2. 三位的水仙花数有四个：153、370、371、407
3. 四位的四叶玫瑰数有三个：1634、8208、9474
4. 五位的五角星数有三个：54748、92727、93084
5. 六位的六合数只有一个：548834


#题干案例
'''  输出100到999之间的水仙花数举例；
      153=3*3*3+5*5*5+1*1*1    '''
#比如说153要想求到它个位上的3，需要除以10，也就是153/10=15余3，因此得到153的个位3
#那十位如何计算呢？用item --> 153整除10，也就是153//10=15；再取和10的余数，得到十位153的5
#百位直接整除100就可以了，item --> 153//100=1,得到百位153的1，到这里就全部得到了三位的水仙花数153
#实例
for item in range(100,1000):
    ge=item%10 #个位
    shi=item//10%10 #十位
    bai=item//100#百位
    #print(bai,shi,ge)
    #判断
    if ge**3+shi**3+bai**3==item: #如果个位十位百位的3次方相加和item这个数本身相等的话它就是水仙花数，直接输出即可
        print(item)
#运行结果
153
370
371
407

40.流程控制语句break

用于结束循环结构，通常与分支结构if一起使用


#题干要求
'''从键盘录入密码，最多录入3次，如果正确就结束循环'''
#实例1
for _ in range(3): #执行3次,由于这里不需要赋值对象所以可以为”_“
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break #一旦条件为True就会执行break退出for循环后续就不会再执行了
    else:
        print('密码不正确')
#运行结果1
请输入密码：1231
密码不正确
请输入密码：8888
密码正确
#实例2
'''初始化变量'''
a=0
'''条件判断'''
while a<3: #小于几呢？0是一次，1是一次，2是一次，所以小于3即可
    '''条件执行体（循环体）'''
    pwd=input('请输入密码：')
    if pwd=='8888': #如果pwd和8888相等
        print('密码正确') #则密码正确
        break #然后直接退出循环
    else: #否则
        print('密码不正确')
    '''改变变量'''
    a+=1
#运行结果2
请输入密码：8888
密码正确 #此处正确直接break退出
请输入密码：1231
密码不正确
请输入密码：456413
密码不正确
请输入密码：1235
密码不正确 #此处共循环3次后退出

41.流程控制语句continue

用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用


#题干要求
'''要求输出1到50之间所有5的倍数，5，10，15，20，25.
#实例
    5的倍数的共同点：和5的余数为0的数都是5的倍数
    什么样的数不是5的倍数，   1，2，3，4，6，7，8，9...   与5的余数不为0的数都不是5的倍数
'''
#写法1  -->>不使用continue实现(如果问什么数是5的倍数，可以用这种写法）
for item in range(1,51):
    if item%5==0:
        print(item)
#写法2  -->>使用continue实现(如果问什么数不是5的倍数，就应该用continue这种写法）
for item in range(1,51):
    if item%5!=0: #如果item和5的取模运算不等于0，
        continue #就continue
        print(item) #等于0输出
#运行结果
5
10
15
...
50

42.else语句


#实例1（与for搭配）
for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else: #此else是与for搭配的
    print('对不起，三次密码都输入错误')
#运行结果1
请输入密码：9999
密码不正确
请输入密码：5555
密码不正确
请输入密码：6666
密码不正确
对不起，三次密码都输入错误
#实例2（与while搭配）
'''初始化变量'''
a=0
'''条件执行体（循环体）'''
while a<3:
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    '''改变变量'''
    a+=1
else:
    print('对不起错，三次密码均输入错误')
#运行结果2
请输入密码：7777
密码不正确
请输入密码：4444
密码不正确
请输入密码：6666
密码不正确
对不起错，三次密码均输入错误

43.嵌套循环

循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行


#实例1
'''输出一个三行四列的矩形'''
'''外层for控制的是行数，内层for控制的是一行打印的个数也就是次数'''
for i in range(1,4): #行表，执行三次，一次是一行
    for j in range(1,5): #在这里执行4次，执行1次该行增加1个个*，4次执行完后执行第一条for语句到下一行继续执行这条语句。直到for3次和for4次循环全部执行输出完
        print('*',end='\t') #不换行输出
    print() #开始输出下一行
#运行结果1
*	*	*	*	
*	*	*	*	
*	*	*	*


#实例2（9*9乘法表框架）
for i in range(1,10): #循环行的次数为9，赋值给i
    for j in range(1,i+1): #特点为星的行数与个数相等
       print('*',end='\t') #输出星且不换行
    print()
#运行结果2
*	
*	*	
*	*	*	
*	*	*	*	
*	*	*	*	*	
*	*	*	*	*	*	
*	*	*	*	*	*	*	
*	*	*	*	*	*	*	*	
*	*	*	*	*	*	*	*	*	
#实例3（9*9乘法表实现）
for i in range(1,10): #循环行的次数为9，赋值给i
    for j in range(1,i+1): #特点为星的行数与个数相等。
       print(i,'*',j,'=',i*j,end='\t') #输出i，链接星，链接=，链接j，链接不换行
    print()
#运行结果3
1 * 1 = 1	
2 * 1 = 2	2 * 2 = 4	
3 * 1 = 3	3 * 2 = 6	3 * 3 = 9	
4 * 1 = 4	4 * 2 = 8	4 * 3 = 12	4 * 4 = 16	
5 * 1 = 5	5 * 2 = 10	5 * 3 = 15	5 * 4 = 20	5 * 5 = 25	
6 * 1 = 6	6 * 2 = 12	6 * 3 = 18	6 * 4 = 24	6 * 5 = 30	6 * 6 = 36	
7 * 1 = 7	7 * 2 = 14	7 * 3 = 21	7 * 4 = 28	7 * 5 = 35	7 * 6 = 42	7 * 7 = 49	
8 * 1 = 8	8 * 2 = 16	8 * 3 = 24	8 * 4 = 32	8 * 5 = 40	8 * 6 = 48	8 * 7 = 56	8 * 8 = 64	
9 * 1 = 9	9 * 2 = 18	9 * 3 = 27	9 * 4 = 36	9 * 5 = 45	9 * 6 = 54	9 * 7 = 63	9 * 8 = 72	9 * 9 = 81

44.二重循环中的break与continue

二重循环中的break和continue用于控制本层循环


#实例1（二重循环下的break）
'''流控制语句break与continue在二重循环中的使用'''
for i in range(5): #代表外层循环要执行5次
    for j in range(1,11):
        if j%2==0: #如果j和2的余数等于0就break退出；因此第一次循环j1和2的余数是不等于0的因此直接跳到print输出；继续执行外层for循环，而第二次j2和2的余数是等于0的，break直接退出，开始执行外层for循环
            break	
        print(j)
#运行结果
1
1
1
1
1
#实例2（二重循环下的continue）
 '''流控制语句break与continue在二重循环中的使用'''
for i in range(5): #代表外层循环要执行5次
    for j in range(1,11):
        if j%2==0: #1和2的余数不等于0为falses跳到print(j,end='\t')输出，接着2和2的余数等于0为True执行continue，3和2的余数不等于0，执行print(j,end='\t')，而这时候J为3因此输出3，后面循环同理
            continue
        print(j,end='\t')
    print()
#运行结果2
1	3	5	7	9	
1	3	5	7	9	
1	3	5	7	9	
1	3	5	7	9	
1	3	5	7	9

45.为什么需要列表

变量可以存储一个元素a=10一个对象由id：886；type:int；value:10三部分组成，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体操作
列表相当于其它语言中的数组
可以存储不同数据类型，而且还可以存储多个

列表示意图


#实例
a=10 #变量存储的是一个对象的引用
lst=['hello','world','98']
print(id(lst))
print(type(lst))
print(lst) #当只输出列表对象的时候，它会把列表当中的所有对象都会输出
#运行结果
2020913840512
<class 'list'>
['hello', 'world', '98']

46.列表对象的创建

列表需要使用中括号[]，元素之间使用英文的逗号进行分隔


#实例
print('---创建列表的第一种方式，使用[]---')
lst=['hello','world',98]
print(lst)
print('---创建列表的第二种方式，使用内置函数list()---')
lst2=list(['hello','world',98])
print(lst2)
#运行结果
---创建列表的第一种方式，使用[]---
['hello', 'world', 98]
---创建列表的第二种方式，使用内置函数list()---
['hello', 'world', 98]

结构图如下

47.列表的特点

解析：

列表元素按顺序有序排序


#实例
lst=['hello','world',98]
print(lst)
#运行结果
['hello', 'world', 98] #验证为有序排序无异议

索引映射唯一个数据


#实例
lst=['hello','world',98]
print(lst[0],lst[-3]) #这里分别验证了正序和逆序索引映射，正序起始为0，逆序起始为1
#运行结果
hello hello #验证可以索引映射唯一个数据;此外还验证了正序也可以逆序进行索引映射

列表可以存储重复数据


#实例（如果在列表中在增加一个对象呢？）
lst=['hello','world',98,'hello'] #增加一个重复对象
print(lst[0],lst[-4]) #因为列表中增加一个对象，所以逆序缩影映射应为-4
#运行结果
hello hello #由此得出结论，如果列表中对象有变动，要想跟之前索引映射内容一致，可能要涉及调整索引映射号。这就叫做重复数据

任意数据类型混存：从上述几个实例的列表对象看，hello是str类型，98是int类型，因此验证该特点

根据需要动态分配和回收内存：永远不需要担心存100、1000个元素能否存下，存1000个和存1个所占的内存空间是什么样的，这些都不需要担心，只需要有数据放进去就可以，会自动根据元素的多少来动态分配空间，不用担心多也用担心不够用

48.获取指定元素的索引


实例
'''验证'''
lst=['hello','world',98,'hello']
print(lst.index('hello')) #运行结果为0，并没获取到地4个元素hello的索引-1   -->如果列表中有相同元素只返回列表中相同元素的第一个元素的索引
print(lst.index('python')) #运行结果为ValueError: 'python' is not in list  -->如果查询的元素在列表中不存在，则会抛出ValueError
print(lst.index('hello',1,3)) #运行结果为ValueError: 'hello' is not in list  -->索引为1的world，从1开始查找，从1-3之间查找但是不包括3，查找hello是查不到的，因为不包括3，所以应该是1-4
print(lst.index('hello',1,4)) #运行结果为3   -->还可以在指定的start和stop之间进行查找

49.获取列表中指定的元素

通俗讲就是你给我一个指定的索引，然后我根据这个索引在这个列表中给你看是否存在

N-1如果是0-5，那么最大索引就是5-1为4其它同理


实例
lst=['hello','world',98,'hello','world',234]
#获取索引为2的元素,这是正向索引
print(lst[2]) #运行结果为98   -->
#获取索引为-3的元素，这是逆向索引
print(lst[-3]) #运行结果为hello  -->
#获取索引为10的元素
print(lst[10]) #运行结果为IndexError: list index out of range 译文：对list列表的索引超出了范围  -->指定索引不存，抛出IndexError

50.获取列表中的多个元素_切片操作

之前都是获取列表中单个元素，那如果想获取列表中多个元素，索引就不起作用了，这时候就需要使用到“切片操作”


#实例
lst=[10,20,30,40,50,60,70,80]
#start=1,stop=6,step1   起始1终止6步长1
#print(lst[1:6:1]) #运行结果为[20, 30, 40, 50, 60]；1-6这个区间不包括6，因此运行结果是20-60，新切出来的这是个新的列表对象
print('原列表',id(lst))
lst2=lst[1:6:1]
print('切的片段：',id(lst2))
print('--------step为正数的情况1----------')
print(lst[1:6]) #如果省略步长，将默认步长为1
print('--------step为正数的情况2----------')
print(lst[1:6:]) #冒号后面步长不写，也代表默认步长为1
print('--------step为正数的情况3----------')
print(lst[1:6:2]) #给步长2切片就按步长2来切
print('--------step为正数的情况4----------')
print(lst[:6:2]) #start=默认,stop=6,step2  -->不给起始值默认从第1个索引按照步长2，切到索引为6的
print('--------step为正数的情况5----------')
print(lst[1::2]) #start=1,stop=默认,step2  -->不给终止值一直按照起始1，步长2，一直向后切
print('--------step为负数的情况1----------')
print('原列表',lst)
print(lst[::-1]) #start=默认,stop=默认,step-1
print('--------step为负数的情况2----------')
print(lst[7::-1]) #start=7,stop=默认,step-1
print('--------step为负数的情况3----------')
print(lst[6:0:-2]) #start=6,stop=0,step2
#运行结果
'''原列表:2250708747072
切的片段： 2250705749184
--------step为正数的情况1----------
[20, 30, 40, 50, 60] #如果省略步长，将默认步长为1  运行结果
--------step为正数的情况2----------
[20, 30, 40, 50, 60] #冒号后面步长不写，也代表默认步长为1  运行结果
--------step为正数的情况3----------
[20, 40, 60] #给步长2切片就按步长2来切 运行结果
--------step为正数的情况4----------
[10, 30, 50] #start=默认,stop=6,step2 运行结果
--------step为正数的情况5----------
[20, 40, 60, 80] #start=1,stop=默认,step2 运行结果
--------step为负数的情况1----------
原列表 [10, 20, 30, 40, 50, 60, 70, 80]    #提示：切片的第一个元素默认是列表的最后一个元素,切片的最后一个元素默认是列表的第一个元素
[80, 70, 60, 50, 40, 30, 20, 10]
--------step为负数的情况2----------
[80, 70, 60, 50, 40, 30, 20, 10]
--------step为负数的情况3----------
[70, 50, 30] #提示：根据start=6,stop=0,step2，对照列表中实际索引也就是从左向右第6个70的值开始，按照步长-2（负数反方向切）向左切，由于没指定终止值，所以一直切
'''

51.列表元素的判断及遍历

判断指定元素在列表中是否存在

列表元素的遍历


#实例
print('---------复习-----------')
print('p' in 'python') #运行结果True  -->释义：p在python中是否存在
print('k' in 'python') #运行结果True  -->释义：k在python中不存在
print('---------本次内容：判断指定元素在列表中是否存在-----------')
lst=[10,20,'python','hello']
print(10 in lst) #运行结果True -->10在这个列表中是否存在
print(100 in lst) #运行结果false -->100在这个列表中是否存在
print(10 not in lst) #运行结果false -->10在这个列表中不存在
print(100 not in lst) #运行结果true -->100在这个列表中不存在
print('---------本次内容：列表元素的遍历-----------')
for item in lst: #item是可迭代变量，然后in在lst列表中
    print(item) #它会从lst列表中依次取出元素对象赋给item可迭代变量，因此输出item就可以将列表中的元素依次输出
#运行结果
---------本次内容：列表元素的遍历-----------
10
20
python
hello

52.列表元素的添加操作

列表元素的增加操作


#实例
print('------在列表的末尾添加一个元素append-----')
lst=[10,20,30]
print('添加元素之前',lst,id(lst))
lst.append(100)
print('添加元素之后',lst,id(lst))
print(id(lst))
print('------在列表的末尾至少添加一个元素extend-----')
lst2=['hello','world']
#lst.append(lst2) #将lst2作为一个元素添加到列表的末尾
lst.extend(lst2) #使用extend把lst2列表中的每一个元素添加到lst列表的末尾  -->向列表的末尾一次性添加多个元素
print(lst)
print('------在列表的任意位置添加一个元素insert-----')
lst.insert(1,90) #在lst列表中第1个索引的位置，添加一个90的值   -->在任意位置上添加一个元素
print(lst)
print('------在列表的任意位置添加至少一个元素 切片-----')
lst3=[True,False,'hello']
lst[1:]=lst3 #start:1 stop：默认 step：默认  从lst列表第1个索引位置开始按照步长1一直切，然后把切掉的部分用一个新的列表lst3进行替换
print(lst) #输出lst列表
#运行结果
------在列表的末尾添加一个元素append-----
添加元素之前 [10, 20, 30] 2430581863744
添加元素之后 [10, 20, 30, 100] 2430581863744
2430581863744
------在列表的末尾至少添加一个元素extend-----
[10, 20, 30, 100, 'hello', 'world']
------在列表的任意位置添加一个元素insert-----
[10, 90, 20, 30, 100, 'hello', 'world']
------在列表的任意位置添加至少一个元素 切片-----
[10, True, False, 'hello']

53.列表元素的删除操作

列表元素的删除操作


#实例
print('-----remove------')
lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素，如果有重复元素只移除第一个元素
print(lst)
#print('-----当元素不存在抛出ValueError------')
#lst.remove(100) #运行结果为ValueError: list.remove(x): x not in list 译文：移除的这个value值在列表中不存在或不在这个列表中  -->元素不存在抛出ValueError
print('-----pop根据索引移除元素------')
lst.pop(1) #移除索引为1的元素
print(lst)
#print('-----pop指定索引移除不存在抛出IndexError------')
#lst.pop(5) #运行结果为IndexError: pop index out of range  译文：索引pop的值超出了边界
print('-----不指定索引，删除列表中最后一个元素------')
lst.pop() #如果不指定参数（索引），将删除列表中最后一个元素
print(lst)
print('-----切片操作--删除至少一个元素，将产生一个新的列表对象------')
#提示：切片会产生一个新的列表对象
new_list=lst[1:3]
print('原列表',lst)
print('切片后的新列表',new_list)
print('-----切片操作--不产生新的列表对象，而是删除原列表中的内容-----')
lst[1:3]=[] #其实不是真正删除，而是使用一个空列表把这个位置的元素进行替代
print(lst)
print('-----clear清空列表-----')
lst.clear() #清空列表中的所有元素
print(lst)
'''
print('-----del删除列表-----')
del lst #运行结果为NameError: name 'lst' is not defined  译文：名为lst的列表没有定义或不存在
print(lst)
'''
#运行结果
-----remove------
[10, 20, 40, 50, 60, 30]
-----pop根据索引移除元素------
[10, 40, 50, 60, 30]
-----不指定索引，删除列表中最后一个元素------
[10, 40, 50, 60]
-----切片操作--删除至少一个元素，将产生一个新的列表对象------
原列表 [10, 40, 50, 60]
切片后的新列表 [40, 50]
-----切片操作--不产生新的列表对象，而是删除原列表中的内容-----
[10, 60]
-----clear清空列表-----
[]

54.列表元素的修改操作

1. 列表元素的修改操作
  1. 为指定索引的元素赋予一个新值
  2. 为指定的切片赋予一个新值


#实例
print('----为指定索引的元素赋予一个新值----')
lst=[10,20,30,40]
lst[2]=100 #一次修改一个值 解析：将lst列表中索引为2的元素使用100进行替换
print(lst)
print('----为指定的切片赋予一个新值----')
lst[1:3]=[300,400,500,600] #对lst列表进行切片，起始索引为1，终止3，步长没写默认为1；尔后将这个区间使用300，400，500，600进行替换
print(lst)
#运行结果
#实例
print('----为指定索引的元素赋予一个新值----')
lst=[10,20,30,40]
lst[2]=100 #一次修改一个值 解析：将lst列表中索引为2的元素使用100进行替换
print(lst)
print('----为指定的切片赋予一个新值----')
lst[1:3]=[300,400,500,600] #对lst列表进行切片，起始索引为1，终止3，步长没写默认为1；尔后将这个区间使用300，400，500，600进行替换
print(lst)

55.列表元素的排序操作

1. 列表元素的排序操作
  1. 常见的两种方式
    1. 调用sort（）方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序
    2. 调用内置函数sorted（），可以指定reverse=True，进行降序排序，原列表不发生改变


#实例
print('---')
lst=[20,40,10,98,54]
print('---sort()对原列表进行排序---')
print('排序前的列表',lst,id(lst)) #加个id查看标识有无被更改，如果没有被更改说明是在原列表的基础上进行的
lst.sort() #开始排序，调用列表对象sort方法，进行升序排序
print('排序后的列表',lst,id(lst))
print('---通过指定关键字参数，将列表中的元素进行降序排序---')
lst.sort(reverse=True) #reverse=true 表示降序排序，reverse=false就是升序排序
print(lst)
lst.sort(reverse=False)
print(lst)
print('---调用内置函数sorted()，将产生一个新的列表对象---')
lst=[20,40,10,98,54]
print('原列表',lst)
new_list=sorted(lst) #开始排序
print('新列表',new_list)
print('---指定关键字参数，实现列表元素的降序排序---')
desc_list=sorted(lst,reverse=True)
print(desc_list)
#运行结果
---sort()对原列表进行排序---
排序前的列表 [20, 40, 10, 98, 54] 2254162753344
排序后的列表 [10, 20, 40, 54, 98] 2254162753344
---通过指定关键字参数，将列表中的元素进行降序排序---
[98, 54, 40, 20, 10]
[10, 20, 40, 54, 98]
---调用内置函数sorted()，将产生一个新的列表对象---
原列表 [20, 40, 10, 98, 54]
新列表 [10, 20, 40, 54, 98]
---指定关键字参数，实现列表元素的降序排序---
[98, 54, 40, 20, 10]

56.列表生成式

列表生成式简称“生成列表的公式”

注意事项：“表示列表元素的表达式”中通常包含自定义变量


#实例
print('---写法1---')
lst=[i for i in range(1,10)] #解析：1-9的可迭代序列要放到列表总因此用[]括起来，之后列表中存的是整数序列，产生的整数序列是i所以在for前加i，所以最后lst列表中存储的就是i的值1-9
print(lst)
print('---写法2---')
lst=[i*i for i in range(1,10)] #解析：产生的是1-9的序列，然后这个序列再乘以它本身
print(lst)
#注意：使用”列表生成式“的情况也会经常遇到，但是要想使用列表生成式要求列表当中元素都有一定规则
print('---写法3---')
'''题干要求:列表中的元素的值为2,4,6,8,10'''
lst=[i*2 for i in range(1,6)] #解析：第一次迭代1赋给i,i*2=1；第二次迭代2,赋给i,i*2=4,以此类推直到完成指定的5次迭代,继而列表生成式
print(lst)
#运算结果
#实例
print('---写法1---')
lst=[i for i in range(1,10)] #解析：1-9的可迭代序列要放到列表总因此用[]括起来，之后列表中存的是整数序列，产生的整数序列是i所以在for前加i，所以最后lst列表中存储的就是i的值1-9
print(lst)
print('---写法2---')
lst=[i*i for i in range(1,10)] #解析：产生的是1-9的序列，然后这个序列再乘以它本身
print(lst)
#注意：使用”列表生成式“的情况也会经常遇到，但是要想使用列表生成式要求列表当中元素都有一定规则
print('---写法3---')
'''题干要求:列表中的元素的值为2,4,6,8,10'''
lst=[i*2 for i in range(1,6)] #解析：第一次迭代1赋给i,i*2=1；第二次迭代2,赋给i,i*2=4,以此类推直到完成指定的5次迭代,继而列表生成式
print(lst)

提示：关于列表的操作需要勤加练习，它是python中很重要的数据结构

57.什么是字典

1. Python内置的数据结构之一，与列表一样是一个可变序列可以执行增删改等操作
2. 以键值对的方式存储数据，字典是一个无序的序列(第一个放进来的不一定在第一个位置上)
3. 列表[ ]字典{ }

字典的实现原理
1. 字典的实现原理与查字典类似，查字典是先根据部首或拼音查找汉字对应的页码，Python中的字典是根据key查找value所在的位置
要把key键放到hash函数中进行计算，它就算的就是存储位置，因此它位置并不是根据放置先后顺序得来的。所以要求放在字典中的键必须是不可变序列，否则各个键会接二连三的变，会存在很多不确定因素。如果是不可变序列作为键的话，无论怎么动它的哈希值计算出来的都是相同的
那么谁是不可变序列？“整数”序列和“str字符串”序列的值就是不可变序列
不可变序列的特点：它不可以进行增删改等操作
可变序列：“列表”和本节内容的“字典”，它们都是可以执行增删改操作的

58.字典的实现原理

字典的实现原理
1. 字典的实现原理与查字典类似，查字典是先根据部首或拼音查找汉字对应的页码，Python中的字典是根据key查找value所在的位置

不会因为元素的多少而影响查找效率，因为无论多少都是先通过哈希函数计算，所以它的速度是非常快的

59.字典的创建

字典的创建
最常用的方式：使用花括号

scores={ '张三'： 100 ，'李四' ： 98， '王五'：45 }

使用内置函数dict（）提示：等号右侧加不加单引号取决于数据类型，左侧因为是赋值的形式所以不加

dict（ name='jack',age=20 ） #提示:因为jack是字符串的形式所以加单引号，20是数据类型因此不加单引号


#实例
print('---字典的创建方式__第1种---')
'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':45} #解析：键为张三：值为100，尔后将其赋值给scores
print(scores)
print(type(scores)) #使用内置函数type输出scores的数据类型
print('---字典的创建方式__第2种创建dict()---')
student=dict(name='jack',age=20)
print(student)
print('---字典的创建方式__第3种创建空字典---')
d={}
print(d)
#运行结果
---字典的创建方式__第1种---
{'张三': 100, '李四': 98, '王五': 45}
<class 'dict'>
---字典的创建方式__第2种创建dict()---
{'name': 'jack', 'age': 20}
---字典的创建方式__第3种创建空字典---
{}

60.字典元素的获取

1. 字典中元素的获取


#实例（获取字典的元素）
scores={'张三':100,'李四':98,'王五':45}
print('---第1种写法，使用[]---')
print(scores['张三'])
#print(scores['陈六']) #运行结果为KeyError  译文：键错误或不存在
print('---第2种写法，使用get[]---')
print(scores.get('张三'))
print(scores.get('陈六')) #运行结果为None  得出结论：如果查找的键不存在，使用[]的写法会报错，而使用get()的写法不会报错会输出None
print('---第2种写法，使用get[]，如果查找的值不存在，返回默认值---')
print(scores.get('麻七',99)) #99是在查找“麻七”键所对应的value不存在时，提供的一个默认值
#运行结果	
#实例（获取字典的元素）
scores={'张三':100,'李四':98,'王五':45}
print('---第1种写法，使用[]---')
print(scores['张三'])
#print(scores['陈六']) #运行结果为KeyError  译文：键错误或不存在
print('---第2种写法，使用get[]---')
print(scores.get('张三'))
print(scores.get('陈六')) #运行结果为None  得出结论：如果查找的键不存在，使用[]的写法会报错，而使用get()的写法不会报错会输出None
print('---第2种写法，使用get[]，如果查找的值不存在，返回默认值---')
print(scores.get('麻七',99)) #99是在查找“麻七”键所对应的value不存在时，提供的一个默认值

1. []取值与使用get（）取值的区别
  1. []如果字典中不存在指定的key，抛出keyError异常
  2. get（）方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

61.字典元素的增_删_改操作


#实例
print('---key的判断---')
scores={'张三':100,'李四':98,'王五':45}
print(scores)
print('张三' in scores)
print('张三' not in scores)
print('---字典元素的删除del---')
del scores['张三'] #删除指定的key-value对   键-值对
#scores.clear() #清空字典元素clear
print(scores)
print('---新增元素---')
scores['陈六']=98
print(scores)
print('---修改元素---')
scores['陈六']=100
print(scores)
#运行结果
---key的判断---
{'张三': 100, '李四': 98, '王五': 45}
True
False
---字典元素的删除del---
{'李四': 98, '王五': 45}
---新增元素---
{'李四': 98, '王五': 45, '陈六': 98}
---修改元素---
{'李四': 98, '王五': 45, '陈六': 100}

62.获取字典视图

获取字典视图的三个方法提示： key键，value值


#实例
scores={'张三':100,'李四':98,'王五':45}
print('---获取所有的key键---')
keys=scores.keys()
print(keys)
print(type(keys)) #输出keys且输出它的数据类型
print(list(keys)) #将所有key组成的视图转换成表
print('---获取所有的value值---')
values=scores.values()
print(values)
print(type(values))
print(list(values)) #将所有的values值组成的试图转换成表
print('---获取所有的key-value键值对---')
items=scores.items()
print(items)
print(list(items)) #元组(),每个逗号分隔开的()内的内容称为一个元组；因此转换之后的列表元素是由元组组成的()
#运行结果
---获取所有的key键---
dict_keys(['张三', '李四', '王五'])
<class 'dict_keys'>
['张三', '李四', '王五']
---获取所有的value值---
dict_values([100, 98, 45])
<class 'dict_values'>
[100, 98, 45]
---获取所有的key-value键值对---
dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
[('张三', 100), ('李四', 98), ('王五', 45)]

63.字典元素的遍历

释义：就是从字典当中依次将字典中的元素进行获取。

分析：scores是一个字典，从字典中获取元素赋给item，item实际上是字典中的一个key键


#实例
scores={'张三':100,'李四':98,'王五':45}
print('---字典元素的遍历---')
for item in scores:
    print(item,scores[item],scores.get(item)) #使用前面[]和get()两种方法，根据key键获取字典中元素的一个值；且目前不会抛异常报错，因为key键在字典{}中都是存在的
#运行结果
---字典元素的遍历---
张三 100 100
李四 98 98
王五 45 45

64.字典的特点

1. 字典中的所有元素都是一个key-value 对，key键不允许重复，value值可以重复
2. 字典中的元素是无序的
3. 字典中的key必须是不可变对象
4. 字典也可以根据需要动态地伸缩
5. 字典会浪费较大的内存，是一种使用空间换时间的数据结构(通过哈希值计算存储位置，尽管查找速度快，但会浪费较大内存）


#实例
print('---key键不允许重复---')
d={'name':'张三','name':'李四'}  #一旦重复会出现value值覆盖的情况
print(d)
print('---value值可以重复---')
d={'name':'张三','nikename':'张三'}
print(d)
print('---字典中的元素是无序的_复习列表---')
lst=[10,20,30]
lst.insert(1,100)
print(lst) #在列表中可以通过insert在指定索引位置插入元素，但没有办法在字典中指定位置插入元素，因为字典本身是无序的，它会根据键计算值所存在的位置，这个位置是通过哈希计算出来的，所以并不是人为指定的
print('---字典中的key键是不可变对象---')
#到本节内容，目前所学的不可变对象有int整数和str字符串，但是列表是可变对象所以不可以
d={lst:100}
print(d) #运行结果为TypeError: unhashable type: 'list'  译文：list是一个可变对象，不允许用于计算哈希值
#运行结果
---key键不允许重复---
{'name': '李四'}
---value值可以重复---
{'name': '张三', 'nikename': '张三'}
---字典中的元素是无序的_复习列表---
[10, 100, 20, 30]
---字典中的key键是不可变对象---
Traceback (most recent call last):
  File "C:\file\pycharm\temp1\venv\demo18.py", line 17, in <module>
    d={lst:100}
TypeError: unhashable type: 'list'

65.字典生成式

1. 内置函数zip（）
  1. 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表


#实例
items=['Fruits','Books','Others'] #创建名为items的列表，其中Fruits等是列表中的元素
prices=[96,78,85]
#prices=[96,78,85,100,120] #增加两个值，查看运行结果到底是三个还是五个元素组成，结果是三个；所以在压缩在zip打包的过程当中，它会以元素少的那个为基准来进行生成
'''#price不带有s复数，代表单个的意思，当然这个变量名字其实叫什么都行；对zip()中的两个列表进行打包，item:price 一个作为key键、一个作为value值,最后存储到对象d'''
#d={item:price for item,price in zip(items,prices)} #运行结果为{'Fruits': 96, 'Books': 78, 'Others': 85}  -->的确第一个items列表作为键，第二个prices作为值了
d={item.upper():price for item,price in zip(items,prices)} #加上upper()将键大写
print(d)
#运行结果
{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

66.什么是元组

元组
1. Python内置的数据结构之一，是一个不可变序列
不可变序列与可变序列
1. 不变可变序：字符串、元组
  1. 不变可变序列：没有增、删，改的操作
2. 可变序列：列表、字典
  1. 可变序列：可以对序列执行增、删、改操作，对象地址不发生更改


#实例
#print('---不可变序列  可变序列---')
print('---可变序列  列表、字典---')
lst=[10,20,30]
print('连接之前',id(lst))
lst.append(300) #向lst列表中append添加元素后内存地址并没发生更改依然是688，这种就称为可变序列
print('连接之后',id(lst))
print('---不可变序列  字符串、元组---')
s='hello' #不可变序列不可执行增删改操作
print('连接之前',id(s))
s=s+'world' #原内存地址400，增加后变为880，连接后发生改变，这种称为不可变序列
print('连接之后',id(s))
print(s)
#列表是使用方括号[]定义，元组是使用小括号()定义，它存储的元素和列表是相似的
#运行结果
---可变序列  列表、字典---
连接之前 2161312397952
连接之后 2161312397952
---不可变序列  字符串、元组---
连接之前 2161306128880
连接之后 2161312305904
helloworld

67.元组的创建方式


#---------------规范---------------
#直接小括号
t=('Python；'hello',90)
#90使用内置函数tuple()
t= tuple(('Python','hello',90))
#只包含一个元组的元素需要使用逗号和小括号
t=(10,)
#实例
print('---第一种创建方式，使用()---')
t=('Python','world',98)
print(t)
print(type(t))
print('---第一种创建方式，使用()__省略小括号写法---')
t2='Python','world',98
print(t2)
print(type(t2))
print('---第二种创建方式，使用内置函数tuple()---')
t1=tuple(('python','world',98))
print(t1)
print(type(t1))
print('---第三种创建方式，只包含一个元组的元素需要使用逗号和小括号---')
#t3=('Python') #如果创建一个元组不写逗号，Python会是str字符串类型；如果是10则会是int类型
t3=('Python',) #如果元组中只有一个元素，逗号不能少
print(t3)
print(type(t3))
print('---复习空列表创建---')
lst=[]
lst1=list()
print('空列表',lst,lst1)
print('---复习空字典创建---')
d={}
d2=dict()
print('空字典',d,d2)
print('---第三种创建方式，空元组创建---')
t4=()
t5=tuple()
print('空元组',t4,t5)
#运行结果
---第一种创建方式，使用()---
('Python', 'world', 98)
<class 'tuple'>
---第一种创建方式，使用()__省略小括号写法---
('Python', 'world', 98)
<class 'tuple'>
---第二种创建方式，使用内置函数tuple()---
('python', 'world', 98)
<class 'tuple'>
---第三种创建方式，只包含一个元组的元素需要使用逗号和小括号---
('Python',)
<class 'tuple'>
---复习空列表创建---
空列表 [] []
---复习空字典创建---
空字典 {} {}
---第三种创建方式，空元组创建---
空元组 () ()

68.为什么要将元组设计成不可变序列

为什么要将元组设计成不可变序列
1. 一旦创建了不可变序列，对象内容的数据就不能再被修改了，这样就避免了由于修改数据而导致的错误
2. 在多任务环境下，同时操作对象时不需要加锁（解析：有很多人都要操作数据，因此这么多人同时对数据进行增删改操作，人多就会乱，那么第一个人进来就锁上，那其它的客户进来想增删改都操作不了都要等待，这个是可变序列对象，使用锁的一个方式来保证数据安全性；不可变序列就不存在要不要加锁的情况，因为没人可以操作它，可以看数据也可以取数据，但不能对数据进行增删改的操作，所以就不涉及到锁的问题）
3. 因此，在程序中尽量使用不可变序列
注意事项：元组中存储的是对象的引用
1. 1. a）如果元组中对象本身不可对象，则不能再引用其它对象
  2. b）如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变（可以增删内容）


#实例
t=(10,[20,30],9)
print(t) #输出t元组
print(type(t)) #输出t元组的数据类型
print(t[0],type(t[0]),id(t[0])) #输出t元组中为0索引的数据,再输出t0的数据类型，再通过id()查看内存地址/标识
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
#print('---尝试将t[1]修改为100---')
#不让它指向列表，让它指向100
#print(id(100)) #运行结果为TypeError: 'tuple' object does not support item assignment  解析：它原来是列表，现在让它指向100这不可能实现
#t[1]=100 #验证了元组是不允许修改元素的
print('---由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变---')
t[1].append(100) #向列表中使用append()添加元素
'''此时列表中已经增加了一个100，但是增加100后id是不变的'''
print(t,id(t[1])) #不允许元组中元素的引用，但可以修改元组中元素的添加内容,如果这个元素是可变的
#运行结果
(10, [20, 30], 9)
<class 'tuple'>
10 <class 'int'> 1602803100240
[20, 30] <class 'list'> 1602811395200
9 <class 'int'> 1602803100208
---由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变---
(10, [20, 30, 100], 9) 1602811395200

69.元组的遍历

元组是可选代对象，所以可以使用for...in进行遍历

解析：元组到元素的获取可以像列表一样通过索引获取，当然使用索引获取需要知道列表中有多少个元素，否则会出现索引越线的问题。但是如果我们不知道元组中有多少元素时，最好的方式就是使用for...in进行遍历


#实例
t=('Python','world',98)
print('---第一种获取元组元素的方式，使用索引---')
print(t[0]) #采取这种方式从元组获取元素，前提条件是得知道有多少个元素，这样才知道索引序号
print(t[1])
print(t[2])
#print(t[3]) #运行结果为IndexError: tuple index out of range 译文：对元组的索引超出了范围  -->根本就没有这个索引的元素
print('---第二种获取元组元素的方式，遍历元组---')
for item in t: #元组名称是t，赋给item
    print(item) #输出item遍历，代表的就是元组中每一个元素
#运行结果
---第一种获取元组元素的方式，使用索引---
Python
world
98
---第二种获取元组元素的方式，遍历元组---
Python
world
98

70.集合的概述与创建

集合的概述
1. Python语言提供的内置数据结构
2. 与列表、字典一样都属于可变类型的序列（可变类型：可以进行增删改）
  1. 解析：字典数据结构是由花括号{} key键:value值对、来定义，集合也是用花括号{}但它没有value值，只有key键，也就是{key键: } 它的底层结构也采用了哈希hash表，
3. 集合是没有value值的字典.

解析：我们用的是abde来表示向集合当中添加元素的顺序，但是在集合中所添加的顺序并不是最终呈现出来的结果，因为在向集合中添加数据的时候，它首先要经过如上图哈希hash函数去计算存储位置，所以第一个放到集合中的元素未必是在第一位，这就是集合。

集合的创建
1. 直接花括号{}

1. 使用内置函数set()

1. 解析s=set(range(6))：range(6)会产生一个0~5的整数序列，把这个序列通过set()转为集合赋给s
2. 解析print(set([3,4,53,56]))：方括号[]内为列表，通过内置函数set()将“列表“中的元素转为集合中的元素
3. 解析pritn(set((3,4,,43,435)))：将“元组”小括号内的元素转为集合中的元素
4. 解析print('Python')：将“字符串”转为集合中的元素
5. 解析print(set({124,3,4,4,5}))：花括号{}内本身定义的就是集合，它可以把这个集合当中元素通过set()内置函数转成我们的集合类型（提示：实际上不转它也是集合类型）
6. 解析print(set())：如果想定义空集合，需要使用set()，内置函数什么都不写，那它就是一个空集合


#实例
#集合概念：是python当中的一种“内置数据结构”
print('---第一种集合创建方式，直接花括号{}---')
s={2,3,4,5,5,6,7,7} #由运行结果得出结论：集合中的元素不允许重复（字典中是键不能重复，而集合中是存储单个元素不能重复，会把重复的去掉）
print(s)
print('---第二种集合创建方式，直接set()_写法1--')
s1=set(range(6)) #range(6)会产生一个0~5的整数序列，把这个序列通过set()转为集合赋给s
print(s1,type(s)) #输出s1集合，同时输出s集合的数据类型
print('---第二种集合创建方式，直接set()_写法2--')
s2=set([1,2,4,5,5,5,6,6]) #方括号[]内为列表，通过内置函数set()将“列表”中的元素转为集合中的元素
print(s2,type(s2)) #由运行结果得出结论：将列表中的元素转为集合类型，同时去掉了重复元素
print('---第二种集合创建方式，直接set()_写法3--')
s3=set((1,2,4,4,5,65)) #将“元组”小括号内的元素转为集合中的元素
print(s3,type(s3)) #由运行结果得出结论：元组中的最后一个索引为-1的元素65，转换后变成了集合中第一个元素 -->验证了集合中的元素是无序的；不允许重复元素
print('---第二种集合创建方式，直接set()_写法4--')
s4=set('Python') #将“字符串”转为集合中的元素
print(s4,type(s4)) #由运行结果得出结论：这一次毋庸置疑，明显可以看出集合是无序的
print('---第二种集合创建方式，直接set()_写法5--')
s5=({12,4,34,55,66,44,4}) #花括号{}内本身定义的就是集合，它可以把这个集合当中元素通过set()内置函数转成我们的集合类型（提示：实际上不转它也是集合类型）
print(s5,type(s5)) #由运行结果得出结论：34跑到了前面，同时去掉了重复元素4
print('---第二种集合创建方式，直接set()_写法6--')
s6={} #定义一个空集合
print(s6,type(s6)) #由运行结果得出结论：不可以直接使用花括号{}定义空集合，否则是“字典”dict类型
s7=set({}) #如果想定义空集合，需要使用set()，内置函数什么都不写，那它就是一个空集合
print(s7,type(s7)) #可以把输出s7去掉，这样就完全是一个空集合
#运行结果
---第一种集合创建方式，直接花括号{}---
{2, 3, 4, 5, 6, 7}
---第二种集合创建方式，直接set()_写法1--
{0, 1, 2, 3, 4, 5} <class 'set'>
---第二种集合创建方式，直接set()_写法2--
{1, 2, 4, 5, 6} <class 'set'>
---第二种集合创建方式，直接set()_写法3--
{65, 1, 2, 4, 5} <class 'set'>
---第二种集合创建方式，直接set()_写法4--
{'P', 'y', 'n', 'o', 'h', 't'} <class 'set'>
---第二种集合创建方式，直接set()_写法5--
{34, 66, 4, 55, 12, 44} <class 'set'>
---第二种集合创建方式，直接set()_写法6--
{} <class 'dict'>
set() <class 'set'>

71.集合的相关操作

集合元素的判断操作
1. in或not in（解析：检查集合当中是否存在指定的元素）
集合元素的新增操作
1. 调用add（）方法，一次添中一个元素
2. 调用update（）方法至少添中一个元素
集合元素的删除操作
1. 调用remove（）方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
2. 调用discard（）方法，一次删除一个指定元素，如果指定的元素不存在不抛异常
3. 调用pop（）方法，一次只删除一个任意元素
4. 调用clear（）方法，清空集合


#实例
print('---判断操作：in或not in检查集合当中是否存在指定的元素---')
s={10,20,30,405,60}
print(10 in s) #True
print(100 in s) #False
print(10 not in s) #False
print(100 not in s) #True
print(s)
print('---新增操作：调用add（）方法，一次添中一个元素---')
s.add(80) #由运行结果得出结论：80已经被添加到集合中
print(s)
print('---新增操作：调用update（）方法至少添中一个元素---')
s.update({200,400,300}) #由运行结果得出结论：update的4个元素已经添加到集合中，也就是说把一个集合中的内容添加到了指定的集合内容中
print(s)
s.update([100,99,8]) #由运行结果得出结论：还可以放列表
s.update((78,64,56)) #由运行结果得出结论：还可以放元组
print(s) #再次运行结果 （因此，根据需求如果想一次添加一个就用add，想添加多个就用update
print('---删除操作：调用remove（）方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError---')
s.remove(100)
print(s)
#s.remove(500) #运行结果为keyError:500  -->指定的元素不存在抛出KeyError
#print(s)
print('---删除操作：调用discard（）方法，一次删除一个指定元素，如果指定的元素不存在不抛异常---')
s.discard(500) #通俗讲，这种方法就是如果指定的数据存在就会删掉，不存在则也不抛异常-
s.discard(300)
print(s)
print('---删除操作：调用pop（）方法，一次只删除一个任意元素---')
s.pop() #任意元素解释：不知道删谁
#s.pop(400) #运行结果为TypeError: set.pop() takes no arguments (1 given) 译文：它是没有参数的，不能指定参数 验证：一旦指定参数就会抛异常
print(s)
print('---删除操作：调用clear（）方法，清空集合---')
s.clear()
print(s) #根据运行结果可以看出已经全部清空
#运行结果
---判断操作：in或not in检查集合当中是否存在指定的元素---
True
False
False
True
{20, 405, 10, 60, 30}
---新增操作：调用add（）方法，一次添中一个元素---
{80, 20, 405, 10, 60, 30}
---新增操作：调用update（）方法至少添中一个元素---
{200, 10, 300, 80, 400, 20, 405, 60, 30}
{64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
---删除操作：调用remove（）方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError---
{64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
---删除操作：调用discard（）方法，一次删除一个指定元素，如果指定的元素不存在不抛异常---
{64, 99, 200, 8, 10, 78, 80, 400, 20, 405, 56, 60, 30}
---删除操作：调用pop（）方法，一次只删除一个任意元素---
{99, 200, 8, 10, 78, 80, 400, 20, 405, 56, 60, 30}
---删除操作：调用clear（）方法，清空集合---
set()

72.集合间的关系

两个集合是否相等
1. 可以使用运算符==或！=进行判断
一个集合是否是另一个集合的子集（解析：如果B集合中的所有内容在A集合中都存在，就称为b是a的子集）
1. 可以调用方法issubset进行判断
2. B是A的子集
一个集合是否是另一个集合的超集
1. 可以调用方法issuperset进行判断
2. A是B的超集
两个集合是否没有交集
1. 可以调用方法isdisjoint进行判断


#实例
print('---两个集合是否相等：使用运算符==或！=进行判断---')
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2) #运行结果为True  提示：集合中元素是无序的，因此只要集合中的元素内容相同，那么它就为相同
print(s!=s2) #运行结果为False
print('---一个集合是否是另一个集合的子集---')
#可以调用方法issubset进行判断
s1={10,20,30,40,50,60} #
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1)) #True 解析：s2是否是s1的子集
print(s3.issubset(s1)) #False  解析：s3是否是s3的子集
print('---一个集合是否是另一个集合的超集---')
#调用方法issuperset进行判断
print(s1.issuperset(s2)) #True 解析：s1是否是s2的超集（如果s2是s1的子集，那么s1就称是s2的超集，反过来即可）
print(s1.issuperset(s3)) #False 解析：s1是否是s3的超集
print('---两个集合是否没有交集---')
#调用方法isdisjoint进行判断
print(s2.isdisjoint(s3)) #False 提示：由交集为False
s4={100,200,300}
print(s2.isdisjoint(s3)) #True 提示：无交集为True
#运行结果
---两个集合是否相等：使用运算符==或！=进行判断---
True
False
---一个集合是否是另一个集合的子集---
True
False
---一个集合是否是另一个集合的超集---
True
False
---两个集合是否没有交集---
False
False

73.集合的数据操作


#实例（集合的数学操作）
s1={10,20,30,40}
s2={20,30,40,50,60}
print('原始A集合s1元素：',s1)
print('原始B集合s2元素：',s2)
print('---求交集:写法1__使用intersection---')
print(s1.intersection(s2))
print('---求交集:写法2__使用“&”---')
#intersection()与&是等价的，它们都是求交集操作
print(s1 & s2) #“&”符号在python中是求交集的意思
print('---求并集:写法1__使用intersection---')
print(s1.union(s2)) #由运行结果可以看出，s1与s2集合已经进行了并集操作
print('---求并集:写法2__使用“|”---')
print(s1 | s2) #union()与 | 是等价的，它们都是求并集操作
print('---求差集:写法1__使用defference---')
print(s1.difference(s2)) #解析：差集通俗讲这里就是A集合（s1）减去B集合（s2）
print('---求差集:写法2__使用“-” ---')
print(s1 - s2) #difference()与 - 是等价的，它们都是求差集操作
print('---求差集:输出两个原集合查看有无发生变化---')
print(s1) #关于差集解析：从最原始的两个集合元素来看，A集合s1与B集合s2共有（交集）的元素是20、30、40，不看这些A集合s1还有10，B集合s2还有50、60，因此差集就是减掉它们交集部分同时还要减掉B集合s2，最后只剩下10
print(s2)
print('---求对称差集:写法1__使用“symmetric_difference”---')
print(s1.symmetric_difference(s2)) #关于对称解析：对称差集无非就是两个集合一起去减掉A集合s1和B集合s2它们的交集部分
print('---求对称差集:写法2__使用“ ^ ”---')
print(s1 ^ s2) #symmetric_difference()与 ^ 是等价的，它们都是求对称差集操作
#运行结果
原始A集合s1元素： {40, 10, 20, 30}
原始B集合s2元素： {50, 20, 40, 60, 30}
---求交集:写法1__使用intersection---
{40, 20, 30}
---求交集:写法2__使用“&”---
{40, 20, 30}
---求并集:写法1__使用intersection---
{40, 10, 50, 20, 60, 30}
---求并集:写法2__使用“|”---
{40, 10, 50, 20, 60, 30}
---求差集:写法1__使用defference---
{10}
---求差集:写法2__使用“-” ---
{10}
---求差集:输出两个原集合查看有无发生变化---
{40, 10, 20, 30}
{50, 20, 40, 60, 30}
---求对称差集:写法1__使用“symmetric_difference”---
{50, 10, 60}
---求对称差集:写法2__使用“ ^ ”---
{50, 10, 60}

74.集合生成式

用于生成集合的公式

将{}修改为[]就是列表生成式^_^
没有元组生成式
回顾
1. 列表生成式，字典生成式，元组没有生成式（元组是唯一一个不可变序列，所以它没有生成式），集合生成式


#实例
print('---回顾：列表生成式---')
lst=[i*i for i in range(6)] #首先列表生成式是方括号[]，range(6)产生0~5之间的整数赋给i，然后在将i*i(就是2次方），然后放到名为lst列表中存储
print(lst)
print('---回顾：集合生成式---')
s={i*i for i in range(6)} #集合生成式只需要把列表生成式写法的方括号[]换成花括号{}，输出后就是集合，所以它就式集合生成式
print(s)
s={i*i for i in range(10)} #把range()改大时可以发现集合中元素是无序的，刚好符合了集合的无序特点
print(s)
#运行结果
---回顾：列表生成式---
[0, 1, 4, 9, 16, 25]
---回顾：集合生成式---
{0, 1, 4, 9, 16, 25}
{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

补充：
1. ......
2. 字典中的key键实际上就是集合set()，由于字典dict和集合set数据结构是相同的，所以它们都是无序的，因为需要通过调用哈希hash来计算存储位置。
3. 字典也是用花括号{}进行定义的，但不一样的地方就是它是{key:value}{键:值}对的形式
4. 一般会在实际写项目代码时根据实际情况选择合适的数据结构使用

75.字符串的创建与驻留机制

字符串
1. 在Python中字符串是基本数据类型，是一个不可变的字符序列
什么叫字符串驻留机制呢？
1. 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

#实例

未完待续…...

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/203227?site