本文章主要讨论Python基础语法中的一下四部分内容（更新中）：
1.变量类型 2.数据结构 3.循环语句 4.判断语句
目录
1. 变量类型
Python3中有6个标准的数据类型：Number，String，List，Tuple，Set，Dictionary
| 数据类型 | 描述 | ||
| 不可变数据 | Number （数字） | 整数int | 01 在Python 3里，只有一种整数类型 int，表示为长整型。 02 运算符 “ // ” 计算返回 |
| 浮点数float | 01 int 和 float 混合运算时， 会将 int 转换为 float 进行计算 02 “ / ” 计算返回 | ||
| 布尔bool | bool 是 int 的子类：True 和 False 和数字相加 | ||
| complex | 表示方法：a + bj 或 complex(a,b) | ||
| 内置函数 type() 可以查询变量所指对象的类型 | |||
| String（字符串） | 01 支持索引和切片操作 02Python没有单独的字符类型，一个字符就是长度为1 的字符串 | ||
| Tuple（元组） | 01 支持数字和字符串的组合及嵌套 | ||
| 可变数据 | List （列表） | 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。 | 01 支持数字和字符串的组合及嵌套 02 支持拼接 03 切片支持步长 |
| Dictionary（字典） | 01 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合，也即，字典的元素就是键值对。 02 键(key)必须使用不可变类型。 03 在同一个字典中，键(key)必须是唯一的。 构造字典方法如下 >>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)]) | ||
| Set（集合） | 01 使用 { } 或者 set( ) 创建集合，而创建空集合只能是 set ( ) 02 自动删除重复的元素 03 支持进行集合运算 | ||
2. 数据结构
2.1 序列概述
重点讨论两种序列：列表和元组。列表和元组的主要不同在于，列表是可以更改的，但元组不可以。也即，列表可以中途添加元素对序列进行修改；而元组出于某种考虑吧需要禁止修改序列。元组作为字典键是不可以用列表代替的，其他情况下均可以用列表代替元组。
2.2 序列的操作
| 序列操作 | 备注 | 示例 | |
| 索引 | 01 索引的正负 02 可以直接对序列进项索引操作，可以但是没有必要先赋值给某个变量 03 索引操作不是就地操作，有返回值。 | ||
| 切片 | 01 访问单个元素 02 切片访问特定范围内的元素 03 使用两个索引指定切片的边界，并用冒号分隔开来。（其中，第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含再切片内。） 04 如果第一个索引指定的元素位于第二个索引指定的元素后面，结果就为空序列。 05 如果切片始于序列开头（结束于序列末尾），可以省略第二（一）个索引。 06 复制整个序列，则两个索引都省略。 07 切片的第三个参数：步长； 08 步长可以为负数，此时第一个索引指定的元素位于第二个索引指定的元素后面，否则结果为空序列 09 省略起始和结束索引时，步长正负均可以正常迭代。 | a[0] a[0:2] a[0:] a[:9] a[:] a[0:10:1] a[0:10:2] a[10:0:-2] a[::-1] a[::1] | |
| 序列相加 | 运用加法运算来拼接序列 | >>> [1,2,3]+[4,5,6] [1,2,3,4,5,6] | |
| 乘法 | 重复某序列x次以创建一个新序列 | >>> 'why'*5 whywhywhywhywhy >>> [5]*5 [5,5,5,5,5] | |
| 成员资格 | 01 为布尔运算符 02 判断满足条件，返回True，否则返回False 03 可用于检查指定的字符串是否是另外一个字符串的子串。 | 'x' in a if a in b (a 和 b 均为字符串) | |
| 内置函数 | 长度 | 确定序列的长度 | len(a) |
| 最大值 | 找出序列的最大值 | max(a) | |
| 最小值 | 找出序列的最小值 | min(a) | |
迭代：对序列的每个元素都进行特定的操作。
2.3 列表
2.3.1 函数 list
鉴于不能像修改列表那样修改字符串，可以使用函数 list 将字符串创建为列表，以便修改。
与 list 相反的操作为 join ，其功能为将字符串列表转换字符串。
2.3.2 列表的操作
| 操作 | 说明 | 示例 |
| 修改列表：赋值 | 01 使用索引法给特定（单个）元素赋值 02 不可给不存在的元素赋值 | 类比切片赋值 |
| 删除元素 del | 01 删除所选元素，改变列表长度 02 可以删除单个或多个对象 | del name[2] : 删除 name 的第二个元素 |
| 给切片赋值 | 01 替换序列 02 插入序列（不限制数量） 03 同时替换和插入序列 04 插入空切片 | 01-03 替换还是插入：索引的起始值和终止值之间的索引差值并不一定和将要替换或插入元素的数量相等； 04 : a[3:6] = [ ] 相当于 del a[3:6] |
2.3.3 列表方法
方法是对象（列表、数、字符串）联系紧密的函数。调用方法：object.method(arguments)
| 方法 | 说明 | 示例 |
| append | 01 将一个对象附加至末尾（注意该对象层次） 02 就地修改，不会返回新列表 | a = [1,2,3] a.append(4) 结果：a = [1,2,3,4] |
| clear | 01 就地清空列表的内容 02 清空对象不可为列表切片 a[1:2].clear()错误 03 清空后改变列表长度 | a.clear() 相当于 a[:] = [ ] |
| copy | 01 常规复制：只是将另一个变量名关联到列表 02 copy 为浅拷贝 03浅拷贝中判断拷贝者是否重新指向新的对象 04 就地拷贝，不返回新列表 | b = a.copy() 等价于 b = list(a) 或 b = a[ : ], 两者同样为浅拷贝 |
| count |
01 非就地计算指定的元素在列表中出现了多少次
02 注意索引深浅
03 返回重复值
| a.count(1) / a.count([1,2,3]) |
| extend |
01 同时将多个值就地附加到列表末尾
02 和 apennd 功能相同
03 就地添加，不返回新列表
| a = [1,2,3] b = [4,5,6] a.extend(b) 结果 : a = [1,2,3,4,5,6] 等价于 a + b 等价于 a.extend([4,5,6]) 等价于 a[len(a):] = b |
| index |
01 在列表中查找指定值第一次出现的索引
02 有返回值，返回所查找元素的索引
| a.index(1) / a.index([1,2]) / a.index('Hello') |
| insert | 用于将一个对象就地插入列表 | a = [1,2,3,5,6,7] a.insert(3,4) 结果 : a = [1,2,3,4,5,6,7] |
| pop | 01 从列表当中删除一个元素（末尾为最后一个元素） 02 执行后返回被删除的元素 03 pop是唯一既修改列表又返回一个非None值的列表方法 04 pop 可以实现后进先出（LIFO） 05 pop 和 append 的效果相反，将刚弹出的的值压入（或附加）之后，得到的栈和原来的相同，也即x.append(x.pop()) 最后输出的结果为 a 其本身 | a.pop() : 表示删除列表末尾最后一个 a.pop(1) : 表示删除该列表索引为1的元素 x = [1,2,3] x.append(x.pop()) 输出结果 x = [1,2,3] |
| remove | 01 用于就地删除第一个指定的元素 02 remove就是修改且不返回值的方法之一 03 与 pop 不同的是，它修改列表，但是不返回任何值。而且 remove() 括号中是要删除的元素，而 pop() 括号中是要删除的元素的索引值 | a = [1,2,3,4,5,6,7] a.remove(1) 结果（不返回） a = [2,3,4,5,6,7] a.pop(0) 结果（返回删除的值但不返回a） a = [2,3,4,5,6,7] |
| reserve |
01 就地倒序排列列表中的元素
02 不返回任何值
| a = [1,2,3] a.reverse() 结果 a = [3,2,1] list(reversed(a)) 直接返回 [3,2,1] |
| 03 等价用法 list(reversed(a)) 直接返回倒序的结果，其中reversed(a)返回的是一个迭代器，不是修改后的列表。 | ||
| sort | 01 对列表就地顺序排列：直接对原序列进行修改，不会产生修改后的副本列表 | a = [2,4,1,3,5] a.sort() 不返回 ： a = [1,2,3,4,5] sorted(a) 直接返回 [1,2,3,4,5] b = sorted(a) 不返回 ： b = [1,2,3,4,5] |
| 02 sorted(a) 直接返回排列之后的列表，但不修改原列表。和 reversed(a) 不一样；可合法复制 y = sorted(a)，使得 y 可以作为排序之后的副本。 |
以上方法中就地操作不可以直接复制给某一个变量，有返回值的可以直接复制给某一个变量。
sort / reverse 和 sorted / reversed 不同，前两者是方法，后两者是函数。
2.4 元组
（1）与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。
（2）对元组执行的操作：创建和访问：
| 元组的创建 | |||
| 命令 | 执行结果 | ||
| 创建 | 不加括号创建 | >>> 1, 2, 3 | (1,2,3) |
| 加括号创建 | >>> (1,2,3) | (1,2,3) | |
| 创建空元组 | >>> ( ) | ( ) | |
| 创建单元素元组 | >>> 42, | (42) | |
| >>> 42 >>> 3*(42,) | 42 (42,42,42) | ||
| 访问 | 元素访问 | >>> a[1} | 01 元组做映射中的键 02 内置函数和方法返回元组 内置函数：min( )，max( )，len( )... |
| 切片访问 | >>> a[0:2] | ||
（3）函数tuple的工作原理与 list 很像：它将一个序列作为参数，并将其转换为元组。
>>> list([1,2,3]) [1, 2, 3]
>>> tuple([1,2,3]) (1, 2, 3)
>>> list('abc') ['a', 'b', 'c']
>>> tuple('abc') ('a', 'b', 'c')
>>> list((1,2,3)) [1, 2, 3]
>>> tuple((1,2,3)) (1, 2, 3)
2.5 字符串
2.5.1 概述
（1）不能像修改列表那样修改字符串，可使用函数 list 将字符串创建成为列表。（当然，也有将字符列表转换为字符串的反向操作）
（2）Python 没有专门表示字符的类型，字符串和字符之间的关系：字符串是由字符组成的序列，一个字符就是包含一个元素的字符串。
（3）所有标准字序列操作都适用于字符串，但是字符串是不可改变的，元素赋值和切片赋值均为非法。
2.5.2 字符串方法
| 方法 | 说明 | 示例 |
| center |
通过在两边添加填充字符（默认为空格）让字符串居中
格式：“字符串”.center (整体长度，“填充字符”)
| 'Hello,world!'. center(39) "Hello,world!".center(100,"*") |
| find | 01 在字符串中查找子串 02 找到则返回 子串的第一个字符的索引 03 找不到则返回-1 （该方法返回的不是布尔值） 04 可以直接在字符串后面使用，也可以先赋值给变量再使用 05 相比之下，in 只能检查单个字符是否包含在字符串当中 06 在方法 find 中，可以指定搜索的起点和终点 格式： 将搜索的字符串.find("搜索的子串",起点,终点) |
subject.find('$$$') subject.find('$$$', 1) subject.find('!!!', 0, 16)
|
| join | 01 用于合并序列（字符串列表而不能是数字列表）的元素 02 可以直接在字符串后面使用，也可以先赋值给变量再使用 03 作用和 split 相反 格式： ’分隔符（或变量）‘.join( ) 分隔符可以是单一元素也可以是字符串，或两者对应的变量，但是不能是字符串列表。 join() 中()内只能是字符串或者包含字符串的单一变量，不能是未赋值给变量的字符串列表本身（only for one argument） | a = ['H','e','l','l','o'] b = "world!" c = list(b) d = '+' 以下均为合法操作 '+'.join(a) d.join(c) == d.join(list(b)) b.join() |
| lower | 01 返回字符串的小写版本 02 有返回值：并非就地操作，意味着可以赋值给某个变量 |  |
| replace |
01 将指定子串都替换为另一个字符串
02 支持多字符替换
03 返回替换后的结果，不影响被替换字符串原序列
04 被替换字符串可以未切片字符串（切片字符串还是字符串）
| a.replace('b','c') |
| split |
01
用于将字符串拆分为序列
02 其作用与
join
相反
03
如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符
等）处进行拆分
|
|
| strip |
01 将字符串开头和末尾的空白（但不包括中间的空白）删除并02 返回删除后的结果。
03 可在一个字符串中（只能是开头和结尾）指定删除哪些字符
| >>> '*** SPAM * for * everyone!!! ***'.strip(' *!') |
| translate | 01 只能进行单字符替换 02 能够同时替换多个字符（参数表中一一对应即可） 03 创建转换表作为 tanslate 的参数 04 支持第三个参数，删除指定字符 |
>>> table = str.maketrans('cs', 'kz',' ')
>>> 'this is an incredible test'. translate (table)
'thizizaninkredibletezt'
|
| 其他方法 |
判断字符串是否满足特定的条件
isalnum
、
isalpha
、
isdecimal
、
isdigit
、
isidentifier
、
islower
、
isnumeric
、
isprintable
、
isspace
、
istitle
、
isupper
|
2.5.3 字符串格式设置方法
设置字符串的格式设置：对字符串调用方法 format。每个值都被插入字符串当中，以替换用花括号括起来的替换字段。
替换字段 = 替换字段名 + 转换标志 + 格式说明符。
| 01 替换字段名 | ||
| 未命名参数 | 按顺序将字段和参数进行配对 |
"{ } { } { } { }".format(1, 2, 3, 4)
|
| 命名参数 | 命名参数的顺序不一定和字段相对应 | “{A} {B} {C}”.format(B = 2, C = 3, A = 1) |
| 以上两者混合 | 除命名参数外按顺序将字段和参数对应 format() 中未命名参数先行 | “{ } {B} {C} { }”.format( 1, 4, B = 2, C = 3) |
| 利用索引将未命名参数与字段顺序 format() 中未命名参数先行 | “{0} {B} {C} {1}”.format( 1, 4, B = 2, C = 3)
>>> "{3} {
0
} {2} {1} {3} {
0
}".format("be", "not", "or", "to")
'to be or not to be'
| |
| 不能同时使用手工编号和自动编号 不可以混合使用 "{ 0} { 1} { } { }".format(1, 2, 3, 4) | ||
| 参数成员 | 替换字段配对的不一定是参数值，也可以是参数成员 |
>>> fullname = ["Alfred", "Smoketoomuch"]
>>> "Mr {name[1]}".format(name=fullname)
'Mr Smoketoomuch'
|
| 02 基本转换 | ||
| 转换标志 | （s、r和a）指定分别使用str、repr和ascii进行转换。 |
>>> print("{pi!s} {pi!r} {pi!a}".format(pi="
π
"))
π
'
π
' '\u03c0'
|
| 转换类型 | 含义 | 示例 |
| b | 将整数转换为二进制数 | >>> {num:b}".format(num=42) 'The number is 101010' |
| c | 将整数解读为 Unicode 码点 | >>> "{num:c}".format(num=42) '*' |
| d | 01 将整数视为十进制数进行处理 02 且为整数默认使用的说明符 | >>> "{num:d}".format(num=42) '42' |
| e / E | 使用科学计数法表示小数：用 e 表示指数 | >>> "{num:e}".format(num=42) '4.200000e+01' |
| f | 用小数表示定点数 | >>> "{num:f}".format(num=42) '42.000000' |
| F | 与 f 相同， 但对于特殊值（nan和 inf）用大写表示 | >>> "{num:F}".format(num=42) '42.000000' |
| g | 自动在定点表示法和科学表示法之间做出选择 小数默认使用的说明符（此时至少有一位小数） | >>> "{num:g}".format(num=42) '42' >>> "{num:g}".format(num=42.1) '42.1' |
| G | 和 g 相同，但使用大写来表示指数和特殊值 | |
| n | 和 g 相同，但插入随区域而异的数字分隔符 | |
| 0 | 将整数表示为八进制数 | >>> "{num:o}".format(num=42) '52' |
| s | 保持字符串格式不变，字符串默认使用的说明符 | |
| x | 将整数表示十六进制数，并用小写字母表示 | >>> "{num:x}".format(num=42) '2a' |
| X | 将整数表示十六进制数，并用小写字母表示 | >>> "{num:X}".format(num=42) '2A' |
| % | 将数表示为百分比值 乘以100，按说明符 f 设置格式，再在后面加上 % | >>> "{num:%}".format(num=42) '4200.000000%' |
| 03 宽度、精度和千位分隔符 | ||
| 宽度 | 数字和字符串的对齐方式不同 默认：数字右对齐，字符串左对齐 |
>>> "{
num:10
}".format(num=3)
' 3'
|
|
>>> "{
name:10
}".format(name="Bob")
'Bob '
| ||
| 精度 | 01 一般用于数字 02 可以用于字符串的截取 |
>>> "Pi day is {
pi:.2f
}".format(pi=pi)
'Pi day is
3.14
'
>>> "{
pi:10.2f
}".format(pi=pi)
' 3.14'
>>> "{
:.5
}".format("Guido van Rossum")
'Guido'
|
| 千位分隔符 | 使用逗号 | >>> '{:,}'.format(10**10) '10,000,000,000' |
| 04 符号、对齐和用 0 填充 | ||
| 对齐 | 左对齐、右对齐和居中对齐分别使用< > ^ |
>>> from math import pi
>>> print('{0：<10.2f}\n {0:^10.2f}\n {0:>10.2f}' .format(pi))
3.14
3.14
3.14
|
| 填充 | 01 填充的符号 02 对齐方式 03 宽度 | >>> print("{:$^20}".format(" WIN BIG ")) $$$$$ WIN BIG $$$$$$ >>> print("{: ^20}".format(" WIN BIG ")) WIN BIG |
| 符号使用顺序： "{ 变量 + : + 填充符号 + 对齐方式 + 宽度 + . 精度 }".format(变量 = 字符串/ 数字) "{ None + : + 填充符号+(对齐方式)+(宽度)+(. 精度) }".format(字符串 / 数字) "{ 索引1+ : +填充符号+对齐方式+宽度+. 精度} + { (索引2)...}".format(字符串1/数字1，字符串2/数字2) | ||
| = | 更具体地将填充字符放在符号和数字之间 |
>>> print('{0:10.2f}\n{1:10.2f}'.format(pi, -pi))
3.14
-3.14
>>> print('{0:10.2f}\n{1:=10.2f}'.format(pi, -pi))
3.14
- 3.14
|
| - / + | 默认状态下地说明符 正数加上正号，使用说明符+ 若指定空格为说明符，空格加在正数前面 |
>>> print('{0:-.2}\n{1:-.2}'.format(pi, -pi))
3.1
-3.1
>>> print('{0:+.2}\n{1:+.2}'.format(pi, -pi))
+3.1
-3.1
>>> print('{0: .2}\n{1: .2}'.format(pi, -pi))
3.1
-3.1
|
| # | 放在符号说明符和宽度之间 触发一种转换方式 二进制、八进制和十六进制前加前缀 十进制数包括小数点 |
>>> "{:b}".format(42)
'101010'
>>> "{:#b}".format(42)
'0b101010'
>>> "{:g}".format(42)
'42'
>>> "{:#g}".format(42)
'42.0000'
|
字符串格式设置示例
width = int(input('Please enter width'))
price_width = 10
item_width = width - price_width
header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width)
fmt= '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width)
print('='* width)
print(header_fmt.format('Item', 'Price'))
print('-'*width)
print(fmt.format('Apples', 0.4))
print(fmt.format('Pears', 0.5))
print(fmt.format('Cantaloupes', 1.92))
print(fmt.format('Dried Apricots', 8))
print(fmt.format('Prunes', 12))
结果
Please enter width50
==================================================
Item Price
--------------------------------------------------
Apples 0.40
Pears 0.50
Cantaloupes 1.92
Dried Apricots 8.00
Prunes 12.00
2.6 字典（更新中）
2.6.1概述
2.6.2 字典的创建和使用
（1）字典以类似于下面的方式表示： phonebook = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'} 。其中，键为名字，而 值为电话号码。每个键与其值之间都用冒号（:）分隔，项之间用逗号分隔，而整个字典放在花 括号内。
（2）字典由键及其相应的值组成，这种键—值对称为项（item）。在字典（以及其他映射类型）中，键必须是独一无二的，而字典中的值无需如此。
（3）将字符串格式设置功能用于字典
通过映射提供所需信息：
指定任意数量地转换说明符：
2.6.3 字典方法（大概了解，用时再琢磨）
| 方法 | 描述 | 示例 |
| clear | 00 就地操作，无返回值 | |
| copy | 00有返回值 01copy 和 deepcopy 的区别和使用 02 理解"修改"和"替换"之间的关系和含义 | |
| fromkey | 00有返回值 01 创建空字典后调用fromkey，指定键不指定值 02 直接对 dict 进行调用方法fromkey 03 默认值为 None，可提供别的值 |
>>> {}.fromkeys(['name', 'age'])
{'age': None, 'name': None}
>>> dict.fromkeys(['name', 'age'])
{'age': None, 'name': None}
>>> dict.fromkeys(['name', 'age'], '(unknown)')
{'age': '(unknown)', 'name': '(unknown)'}
|
| get | 00有返回值 01 避免在访问不存在的值时发生异常 02 指定返回值 03 字典中包含指定的键-值对，则正常查找字典 |
>>> d = {}
>>> print(d.get('name'))
None
>>> d.get('name', 'N/A')
'N/A'
>>> d['name'] = 'Eric'
>>> d.get('name')
'Eric'
|
| item | 00 返回一个包含所有字典项的列表，列表中的每个元素都为（key，value）的形式。列表中的排列顺序不确定。 01 | |
| keys | 返回一个字典视图，包含字典的键 | |
| pop | 00 删除指定键-值对 01 返回被删除的值 | |
| popitem | 随机删除字典中某一键-值对 | |
| setdefault | 01 方法setdefault有点像get，因为它也获取与指定键相关联的值，但除此之外，setdefault
还在字典不包含指定的键时，在字典中添加指定的键-
值对。
02
setdefault
返回指定的值并相应地更新字典。如果指定的键
存在，就返回其值，并保持字典不变。与
get
一样，值是可选的；如果没有指定，默认为
None
。
| |
| update | 01 方法update使用一个字典中的项来更新另一个字典。 02 对于通过参数提供的字典，将其项添加到当前字典中。如果当前字典包含键相同的项，就替
换它。
| |
3. 循环语句
3.1 while循环
（1）while(condition) : 条件满足时，即执行 while 循环体。
（2）Python 中没有 do ... while 循环。
（3）快捷结案 CTRL+C 可以退出无限循环
（4）while 循环中可以使用 else 语句。也即 while(): 中的条件不成立时，执行 else 后面的语句。
3.2 for循坏
（1）for 循环也可以有 else 语句。
（2）可迭代对象是可使用 for 循环进行遍历的对象。迭代（遍历）特定范围内的数是一种常见的任务，Python提供了一种创建范围的内置函数。以下是一些例子。
3.3 迭代字典
遍历字典中所有的关键字，可像遍历序列那样使用普通的 for 语句。
3.4 迭代工具
3.4.1 并行迭代
names = ['anne','beth','george','damon']
ages = [12,45,32,102]
for i in range(len(names)):
print(names[i],'is',ages[i],'years old')
运行结果：
anne is 12 years old
beth is 45 years old
george is 32 years old
damon is 102 years old
（2）使用并行迭代工具：内置函数 zip 实现上述功能。zip 的功能是将两个序列缝合起来，并返回一个由元组组成的序列。
names = ['anne','beth','george','damon'] ages = [12,45,32,102] # list(zip(names,ages)) for name, age in zip(names, ages): print(name,'is',age,'years old') 运行结果 anne is 12 years old beth is 45 years old george is 32 years old damon is 102 years old
（3）函数zip可用于“缝合”任意数量的序列。需要指出的是，当序列的长度不同时，函数zip将在最短的序列用完后停止“缝合”。
b = list(zip(range(5), range(100000000))) print(b) 运行结果： [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
3.4.2 迭代时获取索引
3.4.3 反向迭代和排序后再迭代
reversed 和 sorted 函数，不就地修改对象，有返回值。
对于排序后再迭代函数 sorted 来说，如果要按字母进行排序（不区分大小写），则先进行小写转换。为此，可将 sort 或 sorted 的关键字 key 参数设置为 str.lower。如下例子所示。
y = sorted('AsfGKlITdmxpWmR',key=str.lower)
print(y)
运行结果
['A', 'd', 'f', 'G', 'I', 'K', 'l', 'm', 'm', 'p', 'R', 's', 'T', 'W', 'x']
3.5 终止循环
| 语句 | 描述 | 说明 |
| break | 跳出循环 | |
| continue | 01 结束当前迭代，并跳到下一次迭代开头。 02 跳过了本次循环体剩下的内容，并非结束整个循环。 | |
| while true / break | 01 并非只能像常规while循环那样在循环开头结束循环，而是可在循环体的任何地方结束循环。 |  |
| pass | 可将其用作占位符 |
对于你不再使用的对象，Python通常会将其删除（因为没有任何变量或数据结构成员指向它）。
4.条件语句
（2）布尔值True和False属于类型bool，而bool与list、str和tuple一样，可用来转换其他的值。
（3）条件语句
if 语句的关键字为：if-else-elif:
- 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
- 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
| 条件语句 | 说明 | 示例 |
| if | 条件为真时执行相应模块的语句 |
num = int(input('Enter a number: '))
if num > 0:
print('The number is positive')
elif num < 0:
print('The number is negative')
else:
print('The number is zero')
|
| else | ||
| elif | ||
633
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
