某酷菌

Python重要知识点梳理一

Python·Summary of important knowledge points in notes

摘要：

　　本文主要是对照平时经常用到的Python知识点，结合一些实例而梳理，用于温故知新不断加深印象。也算是对这门语言的一个复盘总结与回顾。Python的详细语法请参阅官网或耳熟能详的在线网站。

Python官网

Python 3 _菜鸟教程

Python·Summary of important knowledge points in notes

一、python position and function。

二、Setting up the Python environment

10.变量的多次赋值。

11.Python中常见的数据类型

12.数据类型-整数类型

13.数据类型浮点类型

18.Python中的注释

19.input函数的使用

20.input函数的高级使用

22.运算符_赋值运算符

23.运算符-比较运算符

24.运算符_布尔运算符

25.运算符_位运算

26.运算符的优先级

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

28.对象的布尔值

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

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

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

34.pass语

35.range函数的使用

36.while循环

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

38.for_in循环

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

40.流程控制语句break

41.流程控制语句continue

42.else语句

43.嵌套循环

44.二重循环中的break与continue

45.为什么需要列表

46.列表对象的创建

47.列表的特点

48.获取指定元素的索引

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

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

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

52.列表元素的添加操作

53.列表元素的删除操作

54.列表元素的修改操作

55.列表元素的排序操作

56.列表生成式

57.什么是字典

58.字典的实现原理

59.字典的创建

60.字典元素的获取

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

62.获取字典视图

63.字典元素的遍历

64.字典的特点

65.字典生成式

66.什么是元组

67.元组的创建方式

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

69.元组的遍历

70.集合的概述与创建

71.集合的相关操作

72.集合间的关系

73.集合的数据操作

74.集合生成式

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

一、python position and function。

为什么能成为网红？
1. 对大数据分析、人工智能中至关重要的机器学习、深度学习都提供了大力的支持
2. 背后有最最庞大的“代码库”
3. 大家习惯称为“胶水语言”
能做些啥？
1. 抢火车票、数据分析少踩杭、开发网站、开发游戏

二、Setting up the Python environment

1.安装Python解释器；2.安装pycharm集成环境(IDE)

Welcome to Python.org官网

Python Release Python 3.8.1 | Python.org

什么是转义字符呢？
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
类型'
值 马丽亚

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 
-76 
0 
十进制 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 
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 
False 
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 
人生苦短，我用Python 
人生苦短，
我用Python 
人生苦短，
我用Python

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
 
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
 
我叫张三今年，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类型----
  
10 198.8 False   
#实例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类型----
    
128 
98 
1

#实例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 
76.0 
1.0 
98.0

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））
#运行结果
大圣想要什么礼物呢？ 定海神针    #后面的定海神针手动在运行结果中输入
定海神针

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

26.666666666666668

13.0

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)    #False
print('a==b吗？'，a==b)    #False     #一个=称为赋值运算符，==称为比较运算符
print('a!=b吗？'，a!=b)    #True
#运行结果
a>b吗？False 
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

['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}

---字典的创建方式__第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(['张三', '李四', '王五'])

['张三', '李四', '王五']
---获取所有的value值---
dict_values([100, 98, 45])

[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