python 语句、容器、索引切片

上次讲到python运算符，链接如下：
https://blog.csdn.net/python1386/article/details/90760622
习题答案2； True： True； True； 3

语句

条件语句

让程序根据条件选择性的执行语句。
语法:

    if 条件1:
        语句块1
    elif 条件2:
        语句块2
    else:
        语句块3

说明:
elif 子句可以有0个或多个。
else 子句可以有0个或1个，且只能放在if语句的最后。
if 语句的真值表达式

if 100:
	print("真值")

等同于

if bool(100):
    print("真值")

条件表达式

语法：变量 = 结果1 if 条件 else 结果2
作用：根据条件(True/False) 来决定返回结果1还是结果2

a= 1 if 3>2 else 2
print(a)

打印结果：1

循环语句

重复着做着同样的操作，不管是有限还是无限，这样的操作可以通过循环来解决。
循环分为for、while循环，如下开始介绍。

for 循环语句

for循环是对于一个可迭代对象，遍历其元素。
之前数据基本类型中，字符串、列表、元组、字典等都是可迭代对象。

语法：

for 变量 in 可迭代对象:
	循环体
else:
	代码块
注：else表示循环完成后，要执行的内容，else可以省略。
    循环体中break语句执行后，将跳出for循环，且else语句不执行。

while 循环语句

可以让循环体重复执行，直至满足条件结束。
语法：

while 条件:
    满足条件执行的语句
else:
    不满足条件执行的语句

注：else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
当循环条件不满足时才走else

跳转语句

break 立即跳出所在循环
continue 不运行所在循环的后续代码，进行下次循环

pass占位语句

pass用来填充代码空白，不进行任何操作。

if True:
	pass

##循环语句运用
打印0~10之内的奇数
下面两个代码实现同一个功能

for item in range(10):
    if item % 2==0:
        continue
    print(item,end=" ")

i = 1
while True:
    if i % 2 != 0:
        print(i, end=" ")
    i += 1
    if i > 10:
        break

打印结果:1 3 5 7 9

容器

容器由一系列元素组成，是数据的集合。

容器操作

索引

通过索引访问容器(字符串、列表等)，得到元素。
语法：容器[整数]
说明:
正向索引从0开始，第二个索引为1，最后一个为len(s)-1。
反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。

切片

通过切片获取容器(字符串、列表等)部分元素，重新组成一个容器。
语法：
容器[(开始索引):)结束索引)(:步长)]
说明:
小括号()括起的部分代表可省略
结束索引不包含该位置元素
步长是切片每次获取完当前元素后移动的偏移量

字符串

定义
由一系列字符组成的不可变序列容器，存储的是字符的编码值。

字符串使用索引

string="hello world"
print(string[2])

输出：l

字符串使用切片

string="hello world"
print(string[2:6:1])
print(string[2:6:2])

输出：
llo
lo

列表

定义
由一系列变量组成的可变序列容器。
基础操作：

1. 创建列表：
   列表名 = []
   列表名 = list(可迭代对象)

2. 添加元素：
   列表名.append(元素)
   列表.insert(索引，元素)

3. 定位元素：
   索引、切片

4. 遍历列表：
   正向：

	for 变量名 in 列表名:
		变量名就是元素
		反向： print(i)
	for 索引名 in range(len(列表名)-1,-1,-1):
		列表名[索引名]就是元素

5. 列表推导式
   1. 定义：
      使用简易方法，将可迭代对象转换为列表。
   2. 语法：
      变量 = [表达式 for 变量 in 可迭代对象]
      变量 = [表达式 for 变量 in 可迭代对象 if 条件]
   3. 说明:
      如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
      例：

list01=[i for i in range(10)]
print(list01)

打印结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

元组

定义
1. 由一系列变量组成的不可变序列容器。
2. 不可变是指一但创建，不可以再添加/删除/修改元素。
基本操作

1. 创建空元组：
   元组名 = ()
   元组名 = tuple()
2. 创建非空元组：
   元组名 = (20,)
   元组名 = (1, 2, 3)
   元组名 = 100,200,300
   元组名 = tuple(可迭代对象)
3. 获取元素：
   索引、切片
4. 遍历元组：
   正向：

	for 变量名 in 列表名:
		变量名就是元素

反向：

	for 索引名 in range(len(列表名)-1,-1,-1):
		元祖名[索引名]就是元素

字典

定义

1. 由一系列键值对组成的可变散列容器。

2. 散列：每条记录无序。

3. 键必须惟一且不可变(字符串/数字/元组)，值没有限制。
   基础操作

4. 创建字典：
   字典名 = {键1：值1，键2：值2}
   字典名 = dict (可迭代对象)

5. 添加/修改元素：
   语法:
   字典名[键] = 数据
   说明:
   键不存在，创建记录。
   键存在，修改映射关系。

6. 获取元素：
   变量 = 字典名[键] # 没有键则错误

7. 遍历字典：

	for 键名 in 字典名:
		字典名[键名]
	for 键名,值名 in 字典名.items():
		语句

5. 删除元素：

	del 字典名[键]

​
字典推导式

1. 定义：
   使用简易方法，将可迭代对象转换为字典。
2. 语法:
   {键:值 for 变量 in 可迭代对象}
   {键:值 for 变量 in 可迭代对象 if 条件}

集合 set

定义
1. 由一系列不重复的i不可变类型变量组成的可变散列容器。
2. 相当于只有键没有值的字典(键则是集合的数据)。
基础操作

1. 创建空集合：
   集合名 = set()
   集合名 = set(可迭代对象)
2. 创建具有默认值集合：
   集合名 = {1, 2, 3}
   集合名 = set(可迭代对象)
3. 添加元素：
   集合名.add(元素)
4. 删除元素：
   集合名.discard(元素)

运算

1. 交集&：返回共同元素。
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 & s2 # {2, 3}

2. 并集：返回不重复元素
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 | s2 # {1, 2, 3, 4}

3. 补集-：返回只属于其中之一的元素
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s1 - s2 # {1} 属于s1但不属于s2

   补集^：返回不同的的元素
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)

4. 子集<：判断一个集合的所有元素是否完全在另一个集合中

5. 超集>：判断一个集合是否具有另一个集合的所有元素
   s1 = {1, 2, 3}
   s2 = {2, 3}
   s2 < s1 # True
   s1 > s2 # True

6. 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。
   s1 = {1, 2, 3}
   s2 = {3, 2, 1}
   s1 == s2 # True
   s1 != s2 # False
   子集或相同,超集或相同 <= >=

例：

a = {1, 2, 3}
b = {2, 3, 4}
print(a & b) #{2, 3}        #交集&  a,b都有
print(a | b) #{1, 2, 3, 4}  #并集|  a,b合并
print(a ^ b) #{1, 4}        #补集^  a,b各特有的总和
print(a - b) #{1}           #差集-  a有但b没有的
print(b - a) #{4}           #差集-  b有但a没有的
c={1,2}
print(c < a) #True          #子集 < a包含c
print(a > c) #True          #超集 > a包含c

集合推导式

1. 定义：
   使用简易方法，将可迭代对象转换为集合。
2. 语法:
   {表达式 for 变量 in 可迭代对象}
   {表达式 for 变量 in 可迭代对象 if 条件}