目录
python特点：
1.可读性强
2.简洁
3.面向对象
4.免费和开源
5.可移植性和跨平台
6.丰富的库
7.可拓展性 可嵌入到C和c++语言 胶水式语言
8.Python是动态类型语言，变量不需要显示声明类型
9.Python是强类型语言，每个对象都有数据类型，只支持该类型支持的操作
注意：
1.不要在程序的行开头处增加空格，空格在python中有缩进的含义 缩进是Python语法强制的规定
2.符号都是英符号，不是中文
Python的基本语法格式
1.恰当的空格、缩进问题
<1>逻辑行首的空白符（空格/制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组.
<2>语句从新行的第一列开始。
<3>缩进风格统一
（1）每个缩进层次使用单个制表符或四个空格
（2）Python用缩进而不是{}表示程序块
注释：
<1>行注释 #
<2>段注释 ‘’‘ ’‘’ 或“ ” “ ” ” “
\行连接符：
一行程序的长度是没有限制的，但是为了可读性更强，通常将一行较长的程序分为多行如下图所示：
a='vhgbjhnj\
gujnjnhbh\
vhbhnj'
Python程序的构成
1.Python程序由模块组成。一个模块对应Python源文件，一般后缀为.py
2.模块由语句组成。运行Python程序时，按照模块中语句的顺序依次进行
3.语句时Python程序的构造单元，用于创建对象，变量赋值，调用函数，控制语句等……
对象
python中，一切皆对象，每个对象由：标识（identity），类型（type），值（value）组成
1.标识通常对应对象地址，使用内置函数id（obj）可返回其标识
2.类型用于表示对象存储的数据类型，可用type（obj）获取其类型
3.值表示对象所存储 的数据信息，使用print（obj）可直接打印出值
对象的本质：
一个内存块，拥有特定的值，支持特定类型的相关操作
引用
在Python中，变量也成为对象的引用。因为，变量存储的就是对象的地址，变量通过地址引用了对象。
变量位于：栈内存
对象位于：堆内存
标识符
基本用法：用于变量、函数、类、模块等的名称
特定规则：
1.区分大小写
2.第一个字符必须是字母或下划线，且有字母、下划线和数字构成
3.不能使用关键字
4.以双下划线开头和结尾的名称通常有特殊含义，尽量避免
Python标识符命名规则：
-
模块和包头 全小写字母，尽量简单，多个单词之间用下划线隔开
-
函数名 全小写字母，多个单词之间用下划线隔开
-
类名 首字母大写，采用驼峰原则，多个单词时，每个单词第一个字母大写，其余小写
-
常量名 全大写字母，多个单词之间用下划线隔开
变量和简单赋值语句
1.变量的声明与赋值
变量名=表达式 变量在使用之前必须先初始化（先赋值）
2.删除变量和垃圾回收机制
可以通过del语句删除不再使用的变量 若对象无变量引用，就会被垃圾回收器回收，清空内存空间
3.链式赋值
链式赋值相当于把一个对象赋给多个变量
x=y=54.系列解包赋值
系列数据赋值给相对应相同个数的变量（个数必须保持一致）
a，b，c = 1,2,3常量
Python 不支持常量。 即没有语法规则限制改变一个常量的值，只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改 实际上可以改，只能逻辑上不做修改
最基本的内置数据类型介绍
-
整型（int）
-
浮点型（float）
-
布尔型（boor）
-
字符串型（str）
基本运算符
加 减 乘 + - *
浮点数除法 / 7/2 3.5 整数除法 // 7//2 3 模（取余） % 7%2 1 幂 ** 2**3 8 使用divmod（）函数同时得到商和余数
divmod（13,3）结果：（4,1）其中前一位是商，后一位是余数
-
增强型赋值运算符
| 运算符 | 例句 | 等价 |
|---|---|---|
| += | a+=2 | a=a+2 |
| -= | a-=2 | a=a-2 |
| *= | a*=2 | a=a*2 |
| /= | a/=2 | a=a/2 |
| //= | a//=2 | a=a//2 |
| **= | a**=2 | a=a**2 |
| %= | a%=2 | a=a%2 |
符号与符号之间不能加空格
比较运算符
| 符号 | 含义 | 返回值 |
|---|---|---|
| == | 等于 | （a==b）返回 True |
| != | 不等于 | （a!=b）返回 True |
| > | 大于 | （a>b）返回 True |
| < | 小于 | （a<b）返回 True |
| >= | 大于或等于 | （a>=b）返回 True |
| <= | 小于或等于 | （a<=b）返回 True |
逻辑运算符
| 运算符 | 例句 | 含义 |
|---|---|---|
| or（或） | x or y | x为True，返回True，否则返回y |
| and（与） | x and y | x为True，返回y，否则返回false |
| not（非） | x not y | x为True，返回false，否则返回true |
同一运算符
同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址
is 判断两个标识符是否引用同一个对象，及比较对象的地址
not is 判断两个标识符是否引用不同对象
is 与 == 的区别：
==用于判断引用变量引用对象的值是否相等，默认调用对象的"——eq——()"方法
整数缓存问题
python仅仅对较小的整数对象进行缓存（范围：[-5,256]),而非所有的整数对象，需要注意的是，这仅仅是在命令行中执行，而在pycharm或者保存为文件执行，结果是不一样的，这是因为解释器做了部分优化。（范围：[-5,无穷大]）对于缓存下来的数，若再用变量对其进行引用，其地址等一切都相等
总结：
is运算符比==效率高，在变量和None进行比较时，应用is
字符串
字符串的基本特点
本质：字符序列
Python的字符串是不可变的，无法对其做任何修改
but 可将字符串的一部分复制到新创建的字符串，达到看起来修改的效果
Python不支持单字符类型，单字符也是作为一个字符串使用
字符串的编码
Python 3 直接支持Unicode编码
在Unicode编码中，一个汉字只算一个字符
引号创建字符串
可通过单引号或双引号创建字符串 a='abc' b="abc"
好处： 可以创建本身就包含引号的字符串，无需转义字符
连续三个单引号或三个上引号可创建多行字符串
空字符串和len（）函数
Python允许空字符串的存在，不包含任何字符且长度为0
len（）用于计算字符串含有多少字符
转义字符
| 续行符 | 反斜杠符 | 单引号 | 双引号 | 退格 | 换行 | 横向制表符 | 回车 | |
|---|---|---|---|---|---|---|---|---|
| \ | \\ | \' | \" | \b | \n | \t | \r |
字符串拼接
1.可用多个+将多个字符串拼接起来 'aa'+'bb'=>'aabb' 每运算一个+，都要新创建一个字符串
（1）若+两边都是字符串，则拼接
（1）若+两边都是字符串，则拼接
（2）若+两边都是数字，则加法运算
（3）若+两边类型不同，则抛出异常
2.可将多个字符串直接放到一起实现拼接（中间用空格隔开）'aa' 'bb'=>'aabb'
字符串复制
使用*可实现字符串复制
a="abc"*3 #等价于a="abcabcabc"不换行打印
在调用print时，会自动打印一个换行符，若不想换行时，可通过参数end="任意字符串"，实现末尾添加任何内容
print("sxt",end="#") #其输出为 sxt#
print("sxt",end="") #默认一个空格从控制台读取字符串
使用input（）从控制台读取键盘输入的内容
myname=input("请输入名字：") #应用格式，“”中内容可省略
print(myname)str（）实现数字转型字符串
str（）可帮助将其他数据类型转换为字符串
例：str（5.20）=> ‘5.20’ str(3.14e2) => '314.0' str(True) =>'True'
当调用print函数时，解释器自动调用了str（）将非字符串的对象转化为字符串
使用[]提取字符
字符串的本质就是字符序列，因此可通过在字符串后面添加[]，在[]里面指定偏移量，可提取该位置的单个字符
正向搜索：
最左侧第一个字符，偏移量是0，第二是1，依此类推直到len（str）-1为止
反向搜索：
最右侧第一个字符，偏移量是-1，以此类推，直到-len（str）为止
例： a='abcdef' a[0]='a' a[-1]='f'
replace()实现字符串替代
字符串是不可改变的，我们通过[]可以获取字符串指定位置的字符，但是不能改变字符串，而当需要改变某些字符时，只能通过创建新字符串来实现
a="abcdefg"
a=a.replace('c',"高") #创建一个新字符串，将原本a中的c改为‘高’并赋给a字符串切片slice操作 包头不包尾
切片slice操作可快速提取字符串，标准格式：[起始偏移量start：终止偏移量end：步长step]
| 操作 | 实例/含义 | 结果 |
|---|---|---|
| [:]提取整个字符串 | "abcdef"[:] | "abcdef" |
| [start:]从start索引开始到结尾 | "abcdef"[2:] | "cdef" |
| [:end]从头开始直到end-1 | "ancdef"[:2] | "an" |
| [start：end : step]从start提取到end-1，步长是step | "abcdef"[1:5:2] | "bd" |
| "abcdef"[-3:] | 倒数三个 | "def" |
| "abcdefghijk"[-8:-3] | 倒数第8到倒数第3 | "defgh" |
| "abc"[::-1] | 倒输出 | "cba" |
split()分割和join（）合并
split（）可基于指定分隔符将字符串分隔成多个子字符串（存储到列表中）若不指定分隔符，则默认使用空白字符（换行符，空格，制表符）
a="to be or not to be"
print(a.split()) #输出 ['to','be','or','not','to','be']
print(a.split('be')) #输出 ['to ',' or not to ','']join()的作用与split（）的作用恰好相反，用于将一系列子字符串连接起来
a=['sxt','sxt99']
print('*'.join(a)) #输出:"sxt*sxt99"join（）函数在拼接字符串之前会计算字符串的长度，然后逐一拷贝，只新建一次对象，因此其比+拼接符更好
字符串驻留机制和字符串比较
字符串驻留：仅保存一份相同且不可变字符串的方法。不同的值被存放在字符串驻留池中。Python支持其机制，对于符合标识符规则的字符串（仅包含下划线，字母和数字）会启动字符串驻留机制
字符串比较和同一性：
可用==，!=对字符串进行比较，是否含有相同的字符
用is，not is 判断两个对象是否同一个对象，比较的是地址
成员操作符：
in，not in 关键字，判断两个字符（子字符串）是否存在于字符串中
字符串常用查找方法
| 方法 | 含义 |
|---|---|
| len(a) | 字符串长度 |
| a.startswith('xx') | 是否以指定字符串开头 |
| a.endswith("xx") | 是否以指定字符串结尾 |
| a.find('x') | 第一次出现指定字符串的位置 |
| a.rfind('x') | 最后一次出现指定字符串的位置 |
| a.count('x') | 出现指定字符串的次数 |
| a.isalnum() | 所有字符是否全为字符或数字 |
去除首尾信息
可通过strip（）去除字符串首尾指定信息，通过lstrip（）除去字符串左边指定信息，rstrip（）除去字符串右边指定信息
a="**s*x*t**"
print(a.strip('*')) #输出："s*x*t"
print(a.lstrip('*')) #输出："s*x*t**"
print(a.rstrip('*')) #输出："**s*x*t"大小写转换
a="abT ab"
| 函数 | 含义 | 结果 |
|---|---|---|
| a.capitalize() | 产生新的字符串，首字母大写 | "AbT ab" |
| a.title() | 产生新的字符串，每个单词的首字母大写 | "AbT Ab" |
| a.upper() | 产生新的字符串，所有字母转换成大写 | "ABT AB" |
| a.lower() | 产生新的字符串，所有字符转换成小写 | "abt ab" |
| a.swapcase() | 产生新的字符串，所有大小写互换 | "abT ab" |
格式排版
center（）,ljust(),rjust()用于字符串实现排版
a="sxt"
print(a.center(10,'*')) #输出："***sxt****"
print(a.ljust(10,"#")) #输出："sxt#######"
print(a.center(10)) #输出：" sxt " ,未指定填充字符，默认空格其他方法
| 函数 | 含义 |
|---|---|
| isalnum() | 是否为字母或数字 |
| isalpha() | 检测字符串是否只由字母组成（含汉字） |
| isdigit() | 检测字符串是否由数字组成 |
| isspace() | 检测是否为空白符 |
| isupper() | 是否为大写字母 |
| islower() | 是否为小写字母 |
字符串的格式化
format函数可以接受不限个参数，位置可以不按顺序
a="名字是{0},年龄是{1}"
print(a.format("小李",18)) #输出：名字是小李，年龄是18
print(a.format("小张",20)) #输出：名字是小张，年龄是20
b="名字是{name},年龄是{age}"
print(b.format(age=28,name="小敏")) #输出：名字是小敏，年龄是28填充与对齐
^ < > 分别是居中，左对齐，右对齐；后面带宽度，：号后面带填充字符，只能带一个，不带默认空格
print("{:*>8}".format("234")) #输出："*****234" {:*>8}表示字符串长度为8，右对齐，用*填充数字格式化
浮点数通过f，整数通过d进行需要的格式化
| 数据 | 格式化 | 结果 | 含义 |
|---|---|---|---|
| 3.14159 | {:.2f} | 3.14 | 保留两位小数 |
| 3.14159 | {:+.2f} | 3.14 | 带符号保留两位小数 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补0（填充左边，宽度为2） |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字形式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
可变字符串
Python中，字符串属于不可变对象，不支持原地修改，可使用io：StringIO对象或array模块
import io
s="hello,sxt"
sio=io:StringIO(s)
print(sio) #输出：<IO.StringIO object at ox02F242B0>
print(sio.getvalue()) #输出："hello,sxt"
sio.seek(7)
sio.write("g")
print(sio.getvalue()) #输出："hello,gxt"基本运算符
and or not 与 或 非
| ^ & 按位 或 异或 与
<< >> 位移 a>>2 =>a=a*4
1.比较运算符可以连用，并且含义和日常使用完成一致
a=3
if 3<a<10:
print("True")
else:
print("False")
#输出:"True"2.位运算
bin（）可以将数字转换成二进制
3.加法运算
列表，元组等合并
[10,20,30]+[10,20,30]==[10,20,30,10,20,30]4.乘法运算
[10,20,30]*2==[10,20,30,10,20,30]5.复合赋值运算符
"<<" 左移赋值 a<<=2 a=a<<2
">>" 右移赋值 a>>=2 a=a>>2
与c和java不一样，Python不支持自增（++）自减（--）操作
运算符优先级问题
1.乘除优先加减
2.位运算和算术运算>比较运算符>赋值运算符>逻辑运算符
复杂的表达式一定要使用小括号组织
序列
序列是一种数据存储方式，用来存储一系列的数据
Python中常用的序列结构：字符串，列表，元组，字典。集合
列表
列表：用于存储任意数目，任意类型的数据集合
列表是内置可变序列，其中元素可以各不相同，是不同类型
常用方法
| 方法 | 作用 | 含义 |
|---|---|---|
| list.append(x) | 增加元素 | 将元素x加入至列表尾部 |
| list.extend(alist) | 增加元素 | 将列表alist所有元素加到列表list尾部 |
| list.insert(index ,x) | 增加元素 | 在列表指定位置index处插入元素x |
| list.remove(x) | 删除元素 | 从列表list中删除首次出现的元素x |
| list.pop([index]) | 删除元素 | 删除并返回列表list指定为止index处的元素，默认最后一个 |
| list.clear() | 删除所有元素 | 删除列表中所有元素，并不是删除列表 |
| list.index() | 访问元素 | 返回第一个x的索引位置，若不存在，抛出异常 |
| list.count() | 计数 | 返回指定元素x在列表中出现的次数 |
| len(list) | 列表长度 | 返回列表所含元素个数 |
| list.reverse() | 翻转列表 | 所有元素远点翻转 |
| list.sort() | 排序 | 所有元素原地排序 |
| list.copy() | 浅拷贝 | 返回列表对象的浅拷贝 |
Python的列表大小可变，根据需要随时增加或缩小
列表的创建
1.基本语法[]创建
a=[10,20,30]
b=[] #创建一个空的列表
2.list（）创建
使用list（）可将任何可迭代的数据转换为列表对象
a=list() #创建一个空的列表
a=list(range(10)) #a=[1,2,3,4,5,6,7,8,9]
3.range()创建整数列表
语法格式： range（[start,]end[,step])
start参数：可选，表示起始数字，默认是0
end参数：必选，表示结尾数字
step参数：可选，表示步长，默认是1
Python 3 中range（）返回的是一个range对象，而不是列表，需通过list（）方法将其转换成列表对象
4.推导式生成列表
例： a=[x*2 for x in range(5)] #循环创造多个元素 输出：a=[0,2,4,6,8]
列表元素访问和计数
与字符串一般可通过索引直接访问元素
index（）获得指的是元素在列表中首次出现的索引
语法： index（value，[start,[end]]）其中start，end指定了搜索范围
成员资格判断
用in，not in关键字判断是否存在包含关系
列表同样使用字符串的切片slice
列表的遍历
for obj in list obj:
print(obj)
列表排序
修改原列表，不建新列表的排序
例： a=[20,10,30,40]
a.sort() #默认是升序排列
print(a） #输出：[10,20,30,40]
a.sort(reverse=True) #降序排列
print（a） #输出：[40,30,20,10]
import random
random.shuffle(a) #打乱顺序
print（a) #输出：[20,40,10,30]
新建列表的排序
通过内置函数sorted（）进行排序，这个方法返回新列表，不对原列表做修改
例： a=[20,10,40,30]
b=sorted(a) #升序排列
print(b) #输出：[10,20,30,40]
print(a) #输出：[20,10,40,30]
reversed()返回迭代器
内置函数reversed（）也支持进行逆序排列，与列表对象reverse（）方法不同的是，内置函数reversed（）不对原列表做任何修改，只是返回一个逆序排序的迭代器对象
例： a=[20,10,40,30]
c=reversed(a)
print(c) #输出：<list_reverseiterator object at oc0000000002BCCEBB>
print(list(c)) #输出：[10,20,30,40]
print(list(c)) #输出：[] reversed()一次，只能使用一次
列表相关的其他内置函数汇总
max和min
用于返回列表中最大，最小值
sum
对数值型列表的所有元素进行求和操作，对非数值型列表运算报错
多维列表
二维列表：可存储二维，表格的数据
例：
a = [
["高小一"，18,30000]，
["高小二"，19,20000]
]
元组
属于不可变序列，不能修改元组中的元素，无增加元素，修改元素，删除元素的相关方法
元组支持
1.索引访问
2.切片操作
3.连接操作
4.成员关系操作
5.比较运算操作
6.计数：元组长度len（），最大值max，最小值min，求和sum
元组的创建
1.通过（）创建元组
例：
a=(10,20,30) 或者 a=10,20,30
若元组中只含一个元素时，其后必须加逗号，否则解释器会将其认为整数
2.通过tuple（）创建元组
a=tuple() #创建一个空元组
a=tuple("abc")
a=tuple(range(3))
a=tuple([2,3,4])总结：tuple（）可以接收列表字符串，其他序列类型，迭代器等生成元组
list（）可以接收元组，字符串，其他类型，迭代器生成列表
元组的访问和计数
1.远足的元素不能修改
2.元组的元素访问和列表一样，只不过返回的是元组对象
3.列表关于排序的方法list.sorted()是修改列表对象，元组没有该方法，若要对元组排序，只能使用内置函数sorted(tuple obj)，并生成新的列表对象
zip
zip（列表1，列表2……）将多个列表对应位置的元素组合成为元组，并返回这个zip对象
例：
a = [1,2,3]
b=[4,5,6]
c=[7,8,9]
d=zip(a,b,c)
print(list(d)) #输出：[(1,2,3),(4,5,6),(7,8,9)]
生成器推导式创建元组
从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表，也不是元组，而是一个生成器对象
s=[x*2 for x in range(5)]
print(s) #输出：<generator object <genexpy> at ox000000002BDEB48>
print(s.__next__()) #输出：0
print(tuple(s)) #输出：(0,2,4,6,8)
print(list(s)) #输出：[] 只能访问一次，第二次就为空了，需要再生成一次才能再次输出元组总结
1.元组的核心特点：不可变序列
2.元组的访问和处理速度比列表快
3.与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用
字典
字典是“键值对”的无序可变序列，字典中的每个原先都是一个“键值对”，包含“键对象”和“值对象”。可通过“键对象”实现快速获取，删除。更新对应的“值对象”
“键”是任意的不可变数据。比如：整型，浮点型，字符串，元组。但是：列表，字典，集合这些可变对象，不能作为“键”，并且“键”不可重复
“值”可以是任意的数据，并且可重复
字典的创建
1.通过{}，duct（）来创建字典对象
a={"name":"gaiqi","age":18}
b=dict(name="gaoqi",age=18)
a=dict([("name","gaoqi"),("age",18)])2.通过zip（）创建字典对象
a=["name","age"]
b=["gaoqi",18]
c=dict(zip(a,b)) #前者为键，后者为值
print(c) #输出：{"name":"gaoqi","age":18}3.通过fromkeys创建值为空的字典
a=dict.fromkeys(["name","age"])
print(a) #输出：{'name':None,'age':None}字典元素的访问
1.通过[键]获得“值”，若键不存在，则抛出异常
2.通过get（）方法获得“值”。
优点：指定键不存在时，返回None，也可以设定当指定键不存在时，默认返回的对象
3.列出所有的键值对
a.item()
4.列出所有的键和值
a.keys() a.values()
5.len()键值对的个数
6.检测一个键是否在字典中
in ，not in
字典元素添加，修改，删除
1.给字典新增“键值对”，若“键”已存在，则覆盖旧的键值对，若不存在，则新增键值对
2.使用update（）将新字典中所有键值对全部添加到旧的字典对象上，若key有重复，则直接覆盖
3.字典中元素的删除，可以使用del（）方法，或者clear（）删除所有键值对，pop删除指定键值对，并返回对应的“值对象”
4.popitem：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素，最后一个元素的概念，popitem弹出随机的项，因为字典并没有“最后的元素”或者其他有关顺序的概念，若想一个接一个地移除项，这个方法非常有效
序列解包
序列解包可用于元组，列表，字典。序列解包可方便对多个变量赋值
序列解包用于字典时，默认是对“键”进行操作，若需对“键值对”进行操作，则需使用item（），对值进行操作，则需使用values（）
s={"name":"gaoqi","age":18}
name,age=s
print(name) #输出：name
name,age=s.item()
print(name) #输出：("name","gaoqi")
name,age=s.values()
print(age) #输出： 18用法总结
1.键必须可散列
（1）数字，字符串，元组都是可散列的
（2）自定义对象需支持以下三点
<1>支持hash（）函数
<2>支持通过——eq——（）方法检测相等性
<3>若a==b为真，则hash（a）==hash（b）也为真
2.字典在内存中开销巨大，典型的空间换时间
3.键查询速度很快
4.往字典里面添加新键可能导致扩容，导致散列表中键的次序变化，因此，不要在遍历字典的同时进行字典的修改
集合
集合是无序可变，元素不能重复的序列，实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复且唯一的
集合创建和删除
1.使用{}创建集合对象，并使用add（）方法添加元素
a={1,3,6}
a.add(9)
print(a) #输出：{9,1,3,6}2.使用set（）将列表，元组等可迭代对象转化成集合，若有重复数据，则值保留一个
3.remove（）删除指定元素，clear（）清空整个集合
a.remove(x) a,clear(x)
集合相关操作
a|b == a.union(b) #并集
a&b == a.intersection(b) #交集
a-b == a.difference(b) #差集 只显示a中有b中无的
控制语句
选择结构
1.单分支选择结构语句
语法形式： if 条件表达式（逻辑，关系，算术等表达式）：
语句 （多条语句，缩进必须一致）
2.双分支选择语句
语法形式： if 条件表达式：
语句
else：
语句
三元条件运算符
语法格式： 条件为真时的语句 if （条件表达式） else 条件为假时的语句
3.多分支选择语句
语法形式： if 条件表达式：语句
elif 条件表达式：语句
……
[else: 语句]
计算机行业，描述语法格式时，使用括号[]表示可选，非必选
4.条件表达式详解
在选择，循环结构中，条件表达式的值为false的情况如下
false，0, 0.0， 空值， None， 空序列对象， 空range对象， 空迭代对象
条件表达式中，不能有赋值操作符“=”
循环语句
1.while 循环
语法格式： while 条件表达式
循环体语句
2.for循环和可迭代对象遍历
for循环语法格式： for 变量 in 可迭代对象
循环体语句
可迭代对象：（Python）
1.序列。包含：字符串，列表，元组
2.字典
3.迭代器对象
4.生成器对象
5.range对象
break语句
结束本层循环
continue语句
结束本次循环，直接进入下一次
扫一扫
51万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
