【重温Python基础】最全Python基础知识点，加班熬夜花了三天终于总结出来了，非常详细

一、开发环境搭建 1.1 Python解释器的安装

Python解释器下载/安装/环境配置/模块安装/解决pip下载模块慢

1.2 集成开发环境PyCharm安装

pycharm安装/基本操作/快捷键等所有操作

二、基本语法元素

Python语言基本语法元素

2.1 程序的格式框架

程序的格式框架，即段落格式，是Python语法的一部分，可以提高代码的可读性和可维护性。

2.1.1 缩进

Python语言采用严格的缩进来表示程序逻辑。也就是我们所说的Python程序间的包含与层次关系。一般代码不要求缩进，顶行编写且不留空白。在if、while、for、def、class等保留字所在完整语句后通过英文的“:”结尾并在之后行进行缩进，表明后续代码与紧邻无缩进语句的所属关系。

缩进可以用Tab键实现，也可以用多个空格实现（一般是4个空格），但两者不能混用。建议采用4个空格方式书写代码。

2.1.2 注释

注释是代码中的辅助性文字，会被编译器或解释器略去，不被计算机执行，一般用于程序员对代码的说明。Python语言中使用“#”表示一行注释的开始。注释可以在一行中任意位置通过“#”开始，其后面的本行内容被当作注释，而之前的内容依然是Python执行程序的一部分。

注释的作用：

• 注释一般用于在代码中标明作者和版权信息
• 解释代码原理和用途
• 通过注释单行代码辅助程序调试。

# 单行注释 '''多行注释''' """多行注释""" 

2.1.3 续行符

Python程序是逐行编写的，每行代码长度并无限制，但从程序员角度，单行代码太长并不利于阅读。这个时候就可以使用续行符将单行代码分割为多行表达。

Python中的续行符为“\”。续行符之后不允许再存在空格，即续行符后直接换行。

print("云南的城市有{}\n{}\n{}\n{}".format('昆明',\ '曲靖',\ '大理',\ '丽江')) 

2.2 语法元素的名称

Python语言的基本单位是单词，少部分单词是Python语言规定的，被称为保留字。大部分单词是用户自己定义的，通过命名过程形成了变量或函数，用来代表数据或代码，称为标识符。

2.2.1 变量

变量是保存和表示数据值的一种语法元素，变量的值是可以改变的，通过赋值运算符“=”方式被修改。Python语言中，变量可以随时命名、随时赋值、随时使用。

由三部分组成：

"""
标识：     id
类型：     type
值：       value  
""" 

多次赋值后将指向新的空间

name = 'hello' # 第一次赋值 print(id(name)) # 标识 # 2026989330544 name = 'world' # 第二次赋值 print(id(name)) # 2026989317168 

2.2.2 保留字

保留字也称keyword关键字，被编程语言内部定义并保留使用的，每种程序设计语言都有一套保留字，保留字一般用来构成程序的整体框架，Python3.x中一共有35个保留字。

import keyword # 导入关键字模块 print(keyword.kwlist) # 调用keyword模块的kwlist方法 

Python3.x中的35个保留字

and as assert async await break class continue def del elif else except False finally for from global if import in is lambda None nonlocal not or pass raise return True try while with yield 

Python二级考试涉及到的保留字一共有22个。选学5个：None、finally、lambda、pass、with。 Python中的保留字也是大小写敏感的。举例：True为保留字，而true则不是保留字。

2.2.3 标识符

标识符可以简单的理解为一个名字，主要用来标识变量、函数、类、模块和其他对象的名称。

标识符的命名规则

• 字母、数字、下划线
• 不能以数字开头
• 不能是Python中的保留字
• 只允许使用ISO-Latin(ISO-8859-1)字符集中的A-Z和a-z
• 允许使用中文，但不建议
• 注意：标识符对大小写敏感，name和Name是两个不同的名字。

2.3 数据类型 2.3.1 二进制与字符编码

二进制是一套计数方法，每个位置上的数有 2 种可能（0 - 1）；二进制是计算机的执行语言，但是早在计算机出现前就存在这套计数方法，最早可追溯到古埃及。在日常生活中，我们使用的是十进制，每个位置上的数有 10 种可能（0 - 9）。

早期的程序员爸爸为了让计算机能够认识我，将我能够认识的符号和数字对应好，然后做成一张表叫ASCII表，告诉计算机某种符号你应该使用哪个整数表示,A使用了8个位（置）才能装得下我，在计算机中他们叫一个字节。

ASCII码表

ASCII值 控制字符 ASCII值 控制字符 ASCII值 控制字符 ASCII值 控制字符 0 NUT 32 (space) 64 @ 96 、 1 SOH 33 ！ 65 A 97 a 2 STX 34 ” 66 B 98 b 3 ETX 35 # 67 C 99 c 4 EOT 36 $ 68 D 100 d 5 ENQ 37 % 69 E 101 e 6 ACK 38 & 70 F 102 f 7 BEL 39 , 71 G 103 g 8 BS 40 ( 72 H 104 h 9 HT 41 ) 73 I 105 i 10 LF 42 * 74 J 106 j 11 VT 43 + 75 K 107 k 12 FF 44 , 76 L 108 l 13 CR 45 - 77 M 109 m 14 SO 46 . 78 N 110 n 15 SI 47 / 79 O 111 o 16 DLE 48 0 80 P 112 p 17 DCI 49 1 81 Q 113 q 18 DC2 50 2 82 R 114 r 19 DC3 51 3 83 S 115 s 20 DC4 52 4 84 T 116 t 21 NAK 53 5 85 U 117 u 22 SYN 54 6 86 V 118 v 23 TB 55 7 87 W 119 w 24 CAN 56 8 88 X 120 x 25 EM 57 9 89 Y 121 y 26 SUB 58 : 90 Z 122 z 27 ESC 59 ; 91 [ 123 { 28 FS 60 < 92 / 124 丨 29 GS 61 = 93 ] 125 } 30 RS 62 > 94 ^ 126 ~ 31 US 63 ? 95 — 127 DEL

ASCII码表字符解释

NUL 空 VT 垂直制表 SYN 空转同步 SOH 标题开始 FF 换页键 ETB 信息组传送结束 STX 正文开始 CR 回车 CAN 作废 ETX 正文结束 SO 移位输出 EM 纸尽 EOY 传输结束 SI 移位输入 SUB 代替 ENQ 请求 DLE 空格 ESC 换码 ACK 收到通知 DC1 设备控制1 FS 文字分隔符 BEL 报警 DC2 设备控制2 GS 组分隔符 BS 退一格 DC3 设备控制3 RS 记录分隔符 HT 水平制表符 DC4 设备控制4 US 单元分隔符 LF 换行 NAK 拒绝 DEL 删除 2.3.2 数值类型

Python提供的3种数值类型： 整数类型：与数学中的整数一致，包含正、负、0。一个整数有二进制、八进制、十进制、十六进制4种表示方式。

浮点数类型：与数学中的小数一致，没有取值范围限制，可正、可负。有两种表示形式，一种是小数点的形式，另外一种是科学计数法。浮点数只有十进制形式。

复数：与数学中的复数一致，采用a+bj的形式表示，存在实部和虚部。

2.3.3 字符串类型

计算机经常处理文本信息，文本信息在程序中使用字符串类型表示。在Python中使用单引号或双引号括起来的一个或多个字符来表示。单引号和双引号的作用相同。

# 字符串类型   被称为不可变的字符序列 print('我用python') print("我用python") print('''我用python''') print(type('我用python')) print(type("我用python")) print(type('''我用python''')) 

字符序列有两种序号体系：

正向递增序号： 有效范围为[0,N-1]，其中N为字符串中字符的个数。最左侧的字符序号为0，依次向右递增，最右侧字符序号为N-1。

反向递减序号： 有效范围为[-1,-N]，其中N为字符串中字符的个数。最右侧的字符序与为-1，依次向左递减，最左侧的字符序号为-N。

两种索引可以同时使用，以下代码为对单个字符进行的索引。

s = 'hello word' print(s[0]) # h print(s[-10]) # h 

还可以采用[N:M]格式获取字符串的子串，这种操作被称为切片操作。[N:M]获取字符串中从N到M（但不包含M）的连续的子字符串。N和M都表示的是索引序号，可以混合使用正向递增序号和反向递减序号。

s = 'hello word' print(s[0:5]) # hello print(s[0:-5]) # hello 

通过Python默认提供的len()函数获取字符串的长度，一个中文字符和一个英文字符的长度都记为1。

print(len(s)) # 10 

2.4 程序的语句元素 2.4.1 表达式

产生或计算新数据值的代码片段称为表达式。类似于数学中的公式，一般由数据和操作符构成。

2.4.2 赋值语句

对变量进行赋值的一行代码被称为赋值语句。在Python中使用一个“=”表示“赋值”，即将等号右侧表达式计算后的结果值赋给左侧的变量。

基本赋值语句语法：

变量 = 表达式

同步赋值语句就是同时给多个变量进行赋值。

同步赋值语句语法：

变量1,变量2,…变量N = 表达式1,表达式2,…,表达式N

同步赋值语句应用最多的就是互换变量的值，即交换两个变量的值。

2.4.3 引用

Python程序会经常使用到当前程序之外已有的功能代码，这个过程叫引用。

Python语言中使用import这个保留字引用当前程序以外的功能库。 import <功能库名称> 引用功能库之后使用 功能库.函数名()的方式调用基本功能，这种方式简称为“A.B()”方式。

2.4.4 其他语句

除了赋值语句之外，Python还有分支语句和循环语句。先简单介绍一下使用，后面后详细讲解。

分支语句：根据判断条件选择程序执行路径。一般包含单分支结构、双分支结构和多分支结构。 单分支语法结构：

if 条件: 语句块

任何能够产生True或False的语句都可以作为条件，当条件为True时，则执行语句块中的内容。

双分支语法结构：

if 条件：
     语句块1 else: 语句块2 

当条件为True时，执行语句块1，当条件为False时，执行语句块2。其中if…else 都是保留字。

循环结构与分支结构一样都是程序控制语句，它的作用是根据判断条件确定一个程序是否再执行一次或者多次。

条件循环的语法结构：

while 条件: 语句块1 语句块2 

当条件为True时，执行语句块1，然后再次判断条件，当条件为False时，退出循环，执行语句块2。

2.5 基本输入输出函数 2.5.1 input( )函数

input()函数是从控制台获得用户的一行输入，无论用户输入什么内容，input()函数都以字符串类型返回。input()函数可以包含一些提示性文字，用来提示用户。

input语法格式：

变量=input(‘提示性文字’)   无论用户输入的是数字还是字符，input()函数统一按照字符串类型输出，为了后续能够操作用户输入的信息，需要将输入指定一个变量进行存储。

input()函数的提示性文字不是必须的，可写可不写。

2.5.2 eval( )函数

eval(s)函数将去掉字符串s最外侧的引号，并按照Python语句方式执行去掉引号后的字符内容。

eavl语法格式：

变量 = eval(字符串)

变量用来保存对字符串内存进行Python运算的结果。

eval()函数去掉了字符串’1.2’最外侧的引号，结果赋值给a，所以a的类型为float类型。eval()函数去掉了字符串’1.2+3.4’最外侧的引号，对其内容当作Python语句进行运算，运算的结果为4.6，保存到变量a中，所以a的类型是float类型。

当eval()函数处理字符串’python’时，字符串去掉了两边的引号，Python语句将其解释为一个变量，由于这个变量在之前别有定义，因此解释器报错。如果定义变量python并赋值为123，再运行这个语句时就没有问题，如果输出为123。

eval()函数经常和input()函数一起使用，用来获取用户输入的数字。

eval()与input()函数一起使用的语法：

变量=eval(input(提示性文字))

用户输入的数字、包括小数和负数，input()解析为字符串，再由eval()去掉字符串引号，将被直接解析为数字保存到变量中。

2.5.3 print()函数

print()函数用于输出运算结果。

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
    """ pass 

sep=’ ‘分隔符，默认为一个空格 end=’\n’结束符，默认以换行结束

print()函数的三种用法：

• 仅用于输出字符串或单个变量

print(待输出字符串或变量) 

对于字符串，print()函数输出后将出掉两侧引号，对于其它类型，则会直接输出。

当print()输出字符串表示时，字符串统一使用单引号表达。在[]中的字符串都使用了双引号，但是在被print()函数打印输出时，输出结果都采用了单引号。

• 用于输出一个或多个变量 ，输出后的各变量之间用一个空格分隔。

print(变量1,变量2,......,变量N) 

• 用于混合输出字符串与变量的值，其中输出字符串模板中使用{}表示一个槽位，每个槽位对应.format()中的一个变量。

print(输出字符串模板.format(变量1,变量2,......,变量N)) print()函数输出的输出内容

'''可以输出数字   int   ''' print(2) # 2 '''可以输出字符串   str   ''' print('hello') # hello '''输出含有运算符的表达式  ''' print(2+3) # 5 

print()函数输出的目的地

'''将内容输出到显示器''' print('hello,world') # hello,world '''将内容输出到文件''' # 注意：所指定的盘符存在；使用file = fp; fp = open('E:\\text.txt', 'a') print('hello,world!', file=fp) fp.close() 

‘整数{}和整数{}的差是：{}’是输出字符串模板，也就是混合字符串输出的样式，大括号{}表示一个槽位，括号中的内容由后面紧跟着的format()方法中的参数按顺序填充。

2.6转义字符与原字符 2.6.1 转义字符

就是反斜杠+想要实现的转义功能首字母。

为什么需要转义字符?

当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义）。

• 反斜杠 :\
• 单引号:’
• 双引号: \“

print('\\') # \ print('\'') # ' print('\"') # " 

当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符。

• 换行:\n
• 回车:\r
• 水平制表符 : \t
• 退格 :\b

# 回车\r print('hello\rhelloworld') # 将hello覆盖 # 换行\n print('hello\nworld') # 退格\b print('helloo\bworld') # 水平制表\t print('hello\tworld\t你好\t好') 

2.6.2 原字符

原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符创之前加上

注意事项，最后一个字符不能是反斜线

# 原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符创之前加上 r 或 R # 注意事项，最后一个字符不能是反斜线 print(r'hello \n word') # hello \n word 

三、运算符

python 的运算符

3.1 数值运算操作符

Python提供了9个基本的数值运算操作符。

3.2 数值运算函数

所谓函数表现为对参数的特定运算。

Python解释器自身提供了一些预先编写好的函数称为内置函数，其中与数值运算相关的函数如下：

3.3 算数运算符

'''
算数运算符：
    加 +
    减 -
    乘 *
    除 /
    整除 //
    取余 %
    幂 **
''' print(-9 // -4) # 2 print(9 // 4) # 2 print(-9 // 4) # -3 一正一负整除公式，商取下整 print(9 // -4) # -3 print(9 % -4) # -3  公式  余数=被除数-除数*商  9-（-4）*（-3）= -3 print(-9 % 4) # 3      -9 - 4*（-3）= 3 # 规律:规律就是  取余数是负数 结果就是负数 

3.4 赋值运算符

赋值运算符：运算顺序从右到左

'''
赋值运算符:运算顺序从右到左
=   a=10
+=  a+=b    a=a+b
-=  a-=b    a=a-b
*=  a*b     a=ab
/=  a/=b    a=a/b
//= a//=b   a=a//b
%   a%=b    a=a%b
''' 

链式赋值,id相同

'''链式赋值,id相同''' a = b = c = 20 print(a, type(a), id(a)) print(b, type(b), id(b)) print(c, type(c), id(c)) print('-------------------------') output: 20 <class 'int'> 140725395003648 20 <class 'int'> 140725395003648 20 <class 'int'> 140725395003648 ------------------------- 

参数赋值

'''参数赋值''' a = 20 a += 30 # a = a+30 print(a) # 50 

系列解包赋值

'''解包赋值''' a, b, c = 10, 20, 30 print(a, id(a)) print(b, id(b)) print(c, id(c)) print('---------交换两个变量的值-----------') a, b = 10, 20 print(a, b) a, b = b, a print(a, b) output: 10 140725395003328 20 140725395003648 30 140725395003968 ---------交换两个变量的值----------- 10 20 20 10 

3.5 布尔运算符

布尔类型 用来表示真或假

• True 表示真
• False表示假
• 布尔值可以转化为整数
• True:1
• False:0

Python中一切皆对象，所有对象都有一个布尔值，获取对象布尔值使用内置函数bool()

# Python中一切皆对象，所有对象都有一个布尔值 # 获取对象布尔值使用内置函数bool() '''
以下对象布尔值为False：
    False
    数值0
    None
    空字符串 ''
    空列表 []
    空字典 {}
    空元组 ()
    空集合 {}
''' print(bool(False)) print(bool(0)) print(bool(0.0)) print(bool(None)) print(bool('')) print(bool([])) # 空列表 print(bool(list())) print(bool({})) # 空字典 print(bool(dict())) print(bool(())) # 空元组 print(bool(tuple())) print(bool(set())) # 空集合 print('-------------以上对象bool值均为False------------') 

3.6 比较运算符

比较运算符: 比较的值为True 或 False

''''
   >	大于
   <	小于
  ==  	等于  比较的是值：value
  !=  	不等于
  >=    大于等于
  <=    小于等于 
 
 对象id的比较 is   is not 
 ''' 

3.7 位运算 & |

'''
位运算符:

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

位或 | 对应位数都是0，结果才为0

左移运算符   <<  高位溢出，低位补0
右移运算符   >>  低位溢出，高位补0 
''' 

3.8 逻辑运算符：and or not

True 和 False 二元数值构成了基本的真假逻辑，因此诞生了逻辑运算。

'''
and 且      全真为真
or  或      有真则真
not 非      对bool类型操作数取反  
      
in  在...里       
not in 不在...里
''' 

3.9 运算符的优先级

指数运算运算（最高优先级） ** 算数运算 * / // % + - 位运算 << >> & | 比较运算符 > < >= <= 等于运算符 == != 身份运算符 is is not 成员运算符 in not in 逻辑运算符 and or not 

四、流程控制

Python流程控制

4.1 顺序结构

程序按照线性顺序依次执行的一种运行方式。

例：把大象装冰箱分几步：

# 把大象装冰箱分几步 print('--------程序开始--------') print('1.把冰箱门打开') print('2.把大象装进冰箱') print('3.关上冰箱门') print('--------程序结束--------') 

4.2 分支结构（选择结构）

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

4.2.1 单分支 if

语法结构：

if 条件表达式: 条件执行体

if条件语句：判断一次，条件为True时执行一次

# if条件语句 判断一次 条件为True时执行一次 money = 100 s = int(input('请输入取款金额:')) if s <= 100: money = money - s print('取款成功，余额为', money) 

4.2.2 双分支 if…else

语法结构：

if 条件表达式：
  条件执行体 else：
  条件执行体2 

双分支结构if…else,二选一执行

'''双分支结构if...else,二选一执行''' # 从键盘输入一个整数，编写程序让计算机判断是奇数还是偶数 num = int(input('请输入一个整数:')) if num % 2 == 0: print(num, '是偶数') else: print(num, '是奇数') 

4.2.3 多分支 if…elif…else

语法结构：

if 条件表达式：
   条件执行体 elif 条件表达式：
   条件执行体 elif 条件表达式：
  条件执行体 elif 条件表达式：
  条件执行体 else: 条件执行体

例： 从键盘录入一个整数成绩： 90-100 ： A 80-89 ： B 70-79 ： C 60-69 ： D 0-59 ：E 小于0或大于100 不及格

代码：

num = int(input('从键盘输入一个成绩:')) if 90 <= num <= 100: print('A') elif 80 <= num <= 89: print('B') elif 70 <= num <= 79: print('C') elif 60 <= num <= 69: print('D') elif 0 <= num <= 59: print('E') else: print('不及格') 

4.2.4 嵌套if的使用

语法结构：

if 条件表达式1: if 内层条件表达式：
        内层执行体1 else：
    内层执行体2 else: 条件执行体

例：商场消费

会员： >=200 8折 >=100 9折 <100 不打折
非会员: >=200 9.5折 <100 不打折

代码：

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) 

4.2.5 三元表达式

语法结构：x if 判断条件 else y

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

# 条件表达式   x if 判断条件 else y a = int(input('请输入第一个整数:')) b = int(input('请输入第二个整数:')) '''if a >= b:
    print(a, '>=', b)
else:
    print(a, '<', b)''' # 条件表达式 print(str(a) + '小于' + str(b)) if a < b else (str(a) + '大于' + str(b)) 

4.2.6 pass语句

pass语句什么都不做，只是一个占位符，用在语法上需要语句的地方

def fun(a, b): pass 

什么时候使用pass语句:先搭建语法结构，还没想好代码怎么写的时候 。

pass语句与哪些语句一起使用：

• if语句的条件执行体
• for-in语句的循环体
• 定义函数def时的函数体

a = 1 b = 2 if a < b: pass for i in range(10): pass def fun(a, b): pass 

4.3循环结构

反复做同一件事情的情况，称为循环，Python语言的循环结构包括两种：遍历循环和无限循环。遍历循环使用保留字forin依次提取遍历结构各元素进行处理；无限循环使用保留字while根据判断条件执行程序

4.3.1 range()函数的使用

range():用于生成一个整数序列

创建range对象的三种方式

# 第一种创建方式  range(stop) range(10) print(range(10)) # range(0,10) 返回值是一个迭代器对象 默认从0开始，默认步长为1 print(list(range(10))) # 用于查看range对象中的整数序列 list-->列表 # 第二种创建方式 range(start, stop) print(range(0, 10)) # 第三种创建方式 range(start,stop,step) print(range(0, 10, 1)) 

range()函数的返回值是一个迭代器对象

range类型的优点 :不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start,stop和step，只有当用到range对象时，才会去计算序列中的相关元素

'''内置函数 range(start(开始)未指定从0开始, stop(结束), step(步长)未指定步长为1)''' r = range(1, 10, 2) print(r) print(list(r)) # 列表 [1, 3, 5, 7, 9] print(tuple(r)) # 元组 (1, 3, 5, 7, 9) print(set(r)) # 字典 {1, 3, 5, 7, 9} 

in与not in 判断整数序列中是否存在（不存在）指定的整数

'''判断指定整数在序列中是否存在 in， not in''' print(3 in r) # True print(4 in r) # False print(3 not in r) # False print(4 not in r) # True for value in range(10): print(value, end=' ') 

4.3.2 遍历循环for-in

for-in循环

• in表达从（字符串、序列等）中依次取值，又称为遍历
• for-in遍历的对象必须是可迭代对象

for-in的语法结构

for 自定义的变量 in 可迭代对象: 循环体

代码演示：

# for in循环 # in 表达是依次 从 （字符串，序列等） 中依次取值，又称遍历 # for in遍历对象必须是可迭代对象 '''for in 语法结构''' # for 自定义变量 in 可迭代对象: #    循环体 for i in 'hello': print(i, end=' ') print('') for i in range(10): print(i, end=' ') print('') # 在循环体中如果不需要使用到自定义变量，可将自定义变量写为下划线('_') for _ in range(3): # 3表示次数 print('hello') 

使用for循环 计算1-100之间的偶数和

# 使用for循环 计算1-100之间的偶数和 sum = 0 for item in range(101): if item % 2 == 0: sum += item print('1-100之间的偶数和为:', sum) 

输出100-999之间的水仙花数

'''输出100-999之间的水仙花数  这个数的个位上的三次方 + 十位上的三次方 + 百位上的三次方  = 这个数''' for item in range(100, 1000): ge = item % 10 shi = item % 100 // 10 # item//10%10 bai = item // 100 if item == ge**3+shi**3+bai**3: print(item) 

4.3.3无限循环while

语法结构：

while 条件表达式: 条件执行体(循环体) 

四步循环法:

1. 初始化变量
2. 条件判断
3. 条件执行体（循环体）
4. 改变变量
5. 打印输出

计算0-4之间的累加和

a = 0 # 1.初始化变量 s = 0 while a <= 4: # 2.条件判断 s += a # 3.条件执行体 a += 1 # 4.改变变量 print(s) # 5.打印输出 

选择结构的if与循环结构while的区别

• If是判断一次，条件为True执行一行
• while是判断N+1次，条件为True执行N次

4.3.4循环控制break和continue

循环结构有两个辅助循环控制的保留字:break与continue。

• break语句

break用来跳出最内层for或while循环，脱离该循环后程序继续执行循环后续代码，通常与 分支结构 if 一起使用。

例：从键盘录入密码，最多录入三次，如果正确就结束循环

# for 循环 for _ in range(3): # range()函数可以用作for循环的循环次数 3 表示for执行了3次 pwd = '888' a = input('请输入密码:') if a == pwd: print('密码正确') break else: print('密码错误，请重新输入密码') # while 循环，四步循环法 a = 0 while a < 3: '''条件执行体(循环体)''' b = '888' pwd = input('请输入密码：') if pwd == b: print('密码正确') break else: print('密码错误') a += 1 

• continue语句

continue语句用来结束当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环，进入下一次循环，通常与分支结构 if 一起使用

例：要求输出1-50-之间所有5的倍数

# for 循环 for i in range(1, 51): if i % 5 == 0: print(i) # while 循环 a = 1 while a <= 50: if a % 5 == 0: print(a) a += 1 # continue 语句 for item in range(1, 51): if item % 5 != 0: continue print(item) 

4.3.5嵌套循环

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

例1：打印一个三行四列矩形

for _ in range(3): for _ in range(4): print('-', end='\t') print() 

例2：输出乘法口诀表

for i in range(1, 10): for j in range(1, i+1): print(i, 'x', j, '=', i*j, end='\t') print() 

五、组合数据类型 5.1 列表类型

Python组合数据类型——序列类型：列表

5.1.1 列表的定义

列表类型是包含0个或多个元素的有序序列，属于序列类型。列表可以进行元素的增加、删除、替换、查找等操作。列表没有长度限制，无素类型可以不同，不需要预定长度。

列表类型用中括号[]表示，也可以通过list(x)函数将集合或字符串类型转换成列表类型。list()函数可生成空列表。

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

列表示意图：

列表创建方式

1. 使用[]方括号

lst = ['hello', 'world', 'java'] print(lst) 

1. 使用内置函数list()

lst2 = list(['hello', 'world', 'java'] + ['hello', 'world', 'java']) print(lst2) 

1. 列表生成式

lst = [i for i in range(1, 11)] print(lst) 

5.1.2 列表的特点

1. 列表元素按顺序有序排列
2. 索引映射唯一一个数据
3. 列表可以存储重复数据
4. 任意数据类型混存
5. 根据需要动态分配内存空间

5.1.3 列表的索引

索引是列表的基本操作，用于获得列表第一个元素。该操作沿用序列类型的索引方式，即正向递增序号和反向递减序号，使用中括号作为索引操作符，索引序号不能超过列表的元素范围，否则会产生IndexErrorr的错误。

获取列表中指定元素索引

语法：列表或列表变量.index（‘要获取索引的元素’,起始位置,结束位置）

如果列表中含有相同元素，只返回相同元素的第一个元素的索引。

# 如果列表中含有相同元素，只返回相同元素的第一个元素的索引 lst = ['hello', 'world', 'java', 'hello', 'world', 'java'] print(lst.index('java')) # 2 print(lst.index('java', 3, 6)) # 5 

可以使用遍历循环对列表类型的元素进行遍历操作。

语法：for 迭代变量 in 列表名:

# 列表元素的遍历 lst = [10, 20, 30, 40, 50, 60, 70, 80] for i in lst: print(i) output: 10 20 30 40 50 60 70 80 

5.1.4 列表的切片

切片是列表的基本操作，用于获得列表的一个片段，即获得零个或多个元素。切片后的结果也是列表类型。

切片有两种使用方式：

• 列表或列表变量[N:M]
• 列表或列表变量[N:M:K]

根据索引获取元素值

lst = ['hello', 'world', 'java', 'hello', 'world', 'java'] '''获取单个元素''' # 获取列表索引为 2的元素 print(lst[2]) # java # 获取列表索引为-3的元素 print(lst[-3]) # hello '''获取多个元素   返回值为一个列表''' # lst = [start(默认0开始) : stop（默认最后） : step（默认步长1）] # step 为负数时相反 print(lst[0:5:1]) # ['hello', 'world', 'java', 'hello', 'world'] 

5.1.5 列表操作函数

ls = [1, 3, 5, 7, 9] print(len(ls)) print(max(ls)) print(min(ls)) x = (1, 3, 5, 7, 9) print(list(x)) 

5.1.6 列表操作方法

列表类型的一些常用操作方法：

5.1.7 列表元素的增加操作

lst = [10, 20, 30] lst1 = ['hello', 'world'] print(lst) print("添加元素之前id:", id(lst)) # 1. append(要添加的元素)  在列表末尾添加一个元素 lst.append(100) print(lst) print("添加元素之后id:", id(lst)) # 2. extend() 在列表末尾至少添加一个元素 lst.extend(lst1) print(lst) # 3. insert(索引, 要添加的对象)在任意（指定索引）位置添加一个元素 lst.insert(4, 'python') print(lst) # 4.切片 在任意位置添加至少一个元素 # lst[要切的位置索引 : 结束位置 : 步长默认为以1]=要添加的列表 lst[1:5:3] = lst1 print(lst) 

5.1.8 列表元素的删除操作

代码：

lst = [10, 20, 30, 20, 40, 50, 60, 70, 80, 90] # 1. remove(要移除的元素)  从列表中移除一个元素，重复只删一个，元素不存抛异常 lst.remove(20) print(lst) # 2. pop(索引)  删除一个指定索引上的元素，不指定索引删除最后一个元素，指定索引不存在抛异常 lst.pop(7) print(lst) lst.pop() print(lst) # 3. 切片操作 删除至少一个元素，将产生一个新的列表对象 new_lst = lst[1:4] # 索引 1,2,3,产生一个新列表 print(new_lst) '''不产生新的列表对象，而是删除原列表中的内容''' lst[1:6] = [] print(lst) # 4. clear 清空列表 lst.clear() print(lst) # 5. del  删除列表 del lst # print(lst) 

运行结果：

5.1.9 列表元素的修改操作

# 为指定索引的元素赋予一个新值 lst = [10, 20, 30, 40] lst[2] = 100 print(lst) # 为指定的切片赋予一个新值 lst[1:2] = [100, 200, 300] print(lst) 

5.1.10 列表元素的排序操作

sort()方法

class list(object): def sort(self, *args, **kwargs): # real signature unknown """
        Sort the list in ascending order and return None.
        
        The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
        order of two equal elements is maintained).
        
        If a key function is given, apply it once to each list item and sort them,
        ascending or descending, according to their function values.
        
        The reverse flag can be set to sort in descending order.
        """ pass 

按升序对列表进行排序，返回None。 排序是原地的(即列表本身被修改)和稳定的(即 保持两个相等元素的顺序)。 如果给出了一个键函数，对每个列表项应用一次，并对它们进行排序， 根据它们的函数值升序或降序。 反向标志可以设置为降序排序。

内置函数sorted()

def sorted(*args, **kwargs): # real signature unknown """
    Return a new list containing all items from the iterable in ascending order.
    
    A custom key function can be supplied to customize the sort order, and the
    reverse flag can be set to request the result in descending order.
    """ pass 

返回一个新列表，其中包含可迭代对象中的所有项，按升序排列。 可以提供自定义键函数来自定义排序顺序 可以设置reverse标志，以降序请求结果。

# 1.调用 sort()方法，sort()方法默认是 升序 排序，在调用该方法后，列表中的元素会按照从小到大的顺序排列 lst = [23, 46, 67, 12, 8, 27] lst.sort() print(lst) # 2.如果我们想让其降序 排序，则可以通过指定关键字参数reverse lst = [20, 40, 10, 98, 54] print('排序前的列表', lst) lst.sort(reverse=True) print('排序后的列表', lst) # 升序 lst.sort(reverse=False) print('排序后的列表', lst) # 使用内置函数 sorted() 对列表进行排序，将产生一个新的对象 lst = [20, 40, 10, 98, 54] print(sorted(lst)) # 未指定升序 print(sorted(lst, reverse=True)) # 指定降序 

5.1.11 列表生成式 列表生成式： 简称列表生成的公式。

语法格式： lst = [列表元素表达式 for 自定义变量 in 可迭代对象] 例：lst = [i for i in range(1, 11)]

lst = [i for i in range(1, 11)] print(lst) 

5.2 字典

Python组合数据类型——映射类型：字典

5.2.1 什么是字典

**字典：**Python内置的数据结构之一，与列表一样是一个可变序列，以键值对的方式存储数据，字典是一个无序的序列。Python语言中的字典使用大括号{ }建立，每个元素是一个键值对。

“键值对”是组织数据的一种重要方式，广泛应用在当代大型信息系统中，如Web系统。键值对的基本思想是将“值”信息关联一个“键”信息，进而通过键信息找对应的值信息，这个过程叫映射。Python语言中通过字典类型实现映射。

5.2.2 字典示意图

5.2.3 字典的原理

字典的原理：Python中的字典是根据key查找value所在的位置

5.2.4 创建字典的方式

在 python中创建一个字典对象，常用的方式有两种。

1. 第一种方式，使用花括号{ }

'''
第一种方式，使用花括号{}，语法如下所示
使用{}创建字典
scores = {'张三': 100, '李四': 98, '王五': 45}
''' scores = {'张三': 29, '李四': 10, '王五': 40} print(scores) # {'张三': 29, '李四': 10, '王五': 40} print(type(scores)) #  

1. 第二种方式，使用内置函数dict()。

'''第二种方式，使用内置函数dict()。dict即dictionary(字典)的缩写，语法如下所示。
字典名 = dict(键1=值1, 键2=值2)
''' dic = dict(name='张三', age=20) print(dic) # {'name': '张三', 'age': 20} 

1. 创建空字典

d = {} print(d) # {} 

5.2.5 字典元素的获取

根据键key获取字典的值value

# 1.使用 [] 获取 scores = {'张三': 29, '李四': 10, '王五': 40} print('张三' in scores) # True print('张三' not in scores) # False print(scores['张三']) # 29 # 2.使用 get()方法 print(scores.get('张三')) # 29 print(scores.get('柽柳')) # None print(scores.get('麻子', 99)) # 99是在查找 麻子值的（value）不存在时的一个默认值 

5.2.6 字典的操作函数

Python内置数据结构：字典dict()类源代码：

class dict(object): """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object's
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """ def clear(self): # real signature unknown; restored from __doc__ """ D.clear() -> None.  Remove all items from D. """ pass def copy(self): # real signature unknown; restored from __doc__ """ D.copy() -> a shallow copy of D """ pass @staticmethod # known case def fromkeys(*args, **kwargs): # real signature unknown """ Create a new dictionary with keys from iterable and values set to value. """ pass def get(self, *args, **kwargs): # real signature unknown """ Return the value for key if key is in the dictionary, else default. """ pass def items(self): # real signature unknown; restored from __doc__ """ D.items() -> a set-like object providing a view on D's items """ pass def keys(self): # real signature unknown; restored from __doc__ """ D.keys() -> a set-like object providing a view on D's keys """ pass def pop(self, k, d=None): # real signature unknown; restored from __doc__ """
        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
        If key is not found, d is returned if given, otherwise KeyError is raised
        """ pass def popitem(self, *args, **kwargs): # real signature unknown """
        Remove and return a (key, value) pair as a 2-tuple.
        
        Pairs are returned in LIFO (last-in, first-out) order.
        Raises KeyError if the dict is empty.
        """ pass def setdefault(self, *args, **kwargs): # real signature unknown """
        Insert key with a value of default if key is not in the dictionary.
        
        Return the value for key if key is in the dictionary, else default.
        """ pass def update(self, E=None, **F): # known special case of dict.update """
        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]
        """ pass def values(self): # real signature unknown; restored from __doc__ """ D.values() -> an object providing a view on D's values """ pass def __contains__(self, *args, **kwargs): # real signature unknown """ True if the dictionary has the specified key, else False. """ pass def __delitem__(self, *args, **kwargs): # real signature unknown """ Delete self[key]. """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __getitem__(self, y): # real signature unknown; restored from __doc__ """ x.__getitem__(y) <==> x[y] """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ """
        dict() -> new empty dictionary
        dict(mapping) -> new dictionary initialized from a mapping object's
            (key, value) pairs
        dict(iterable) -> new dictionary initialized as if via:
            d = {}
            for k, v in iterable:
                d[k] = v
        dict(**kwargs) -> new dictionary initialized with the name=value pairs
            in the keyword argument list.  For example:  dict(one=1, two=2)
        # (copied from class doc)
        """ pass def __iter__(self, *args, **kwargs): # real signature unknown """ Implement iter(self). """ pass def __len__(self, *args, **kwargs): # real signature unknown """ Return len(self). """ pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self