Python自学16（其它常用语言特性）

" 我一直等着你出现，直到晴天变成了雨天，反复练习的思念也长了茧 "

1、索引和切片相关

1.1、索引

%1
# 序列（列表、元组、字符串）的索引为正值、此时将按正序从序列中的取元素
list1 = [1,2,3,4,5]
str1 = '12345'
tuple1 = (1,2,3,4,5)
print(list1[1])
print(str1[1])
print(tuple1[1])
# output:2
#        2
#        2

%2
# 序列（列表、元组、字符串）的索引可以为负值、此时将按逆序从序列中的取元素
list1 = [1,2,3,4,5]
str1 = '12345'
tuple1 = (1,2,3,4,5)
print(list1[-4])
print(str1[-4])
print(tuple1[-4])
# output:2
#        2
#        2

1.2、切片

%1
# 切片的用法、使用它可以从序列中取出一个子序列
# 切片以索引区间 [起始索引:结束索引] 来表示、注意这是一个左闭右开区间
list1 = [1,2,3,4,5]
str1 = '12345'
tuple1 = (1,2,3,4,5)
print(list1[0:2])
print(str1[0:2])
print(tuple1[0:2])
# output:[1, 2]
#         12
#        (1, 2)

%2
# 如果起始索引为 0、则可以省略起始索引
list1 = [1,2,3,4,5]
str1 = '12345'
tuple1 = (1,2,3,4,5)
print(list1[:2])
print(str1[:2])
print(tuple1[:2])
# output:[1, 2]
#         12
#        (1, 2)

%3
# 如果结束索引等于序列长度、则可以省略结束索引
# 此时相当于从起始索引一直取到最后一个元素
list1 = [1,2,3,4,5]
str1 = '12345'
tuple1 = (1,2,3,4,5)
print(list1[2:])
print(str1[2:])
print(tuple1[2:])
# output:[3, 4, 5]
#         345
#        (3, 4, 5)

%4
# 既省略起始索引也省略结束索引、那么将取整个序列
list1 = [1,2,3,4,5]
str1 = '12345'
tuple1 = (1,2,3,4,5)
print(list1[:])
print(str1[:])
print(tuple1[:])
# output:[1, 2, 3, 4, 5]
#         12345
#        (1, 2, 3, 4, 5)

%5
# 起始索引和结束索引可以为负值
list1 = [1,2,3,4,5]
str1 = '12345'
tuple1 = (1,2,3,4,5)
print(list1[1:-1])
print(str1[1:-1])
print(tuple1[1:-1])
# output:[2, 3, 4]
#         234
#        (2, 3, 4)

%6
# 切片中可以指定步长、用第三个参数表示
# 步长表示索引的间隔、如 [0:5:2] 表示从索引 0 至 5、每隔 2 个索引取一次值
list1 = [1, 2, 3, 4, 5]
str1 = '12345'
tuple1 = (1, 2, 3, 4, 5)
print(list1[1:-1:2])
print(str1[1:-1:2])
print(tuple1[1:-1:2])
# output:[2, 4]
#         24
#        (2, 4)

%7
# 步长也可以为负值、使用如下方式即可翻转一个序列
list1 = [1, 2, 3, 4, 5]
str1 = '12345'
tuple1 = (1, 2, 3, 4, 5)
print(list1[::-1])
print(str1[::-1])
print(tuple1[::-1])
# output:[5, 4, 3, 2, 1]
#         54321
#        (5, 4, 3, 2, 1)

2、赋值相关

2.1、连续赋值

# Python 允许连续赋值操作
# 连续赋值时、从右至左依次被赋值
a = b = c = 1

# 等效于
c = 1
b = c
a = b

2.2、拆包

%1
# 多个变量和多个值可以用一个赋值符号（=）做到同时赋值
# 赋值时、将根据位置关系、将（=）右侧的值分别赋值给左侧的变量
a, b = 1, 2
print(a)
print(b)
# output:1
#        2

# 等效于
a, b = (1, 2)
# 将元祖中的每个元素拆解出来、然后分别赋值给前面的变量、这种操作叫作拆包

%2
# 类似的、列表、字符串、字典也可以被拆包
a, b = [1,2]
c, d = '12'
e, f = {
     'jingzhou':'000','wuhan':'090'}
# 注意字典拆包时拆出来的是每个键
print(a,b)
print(c,d)
print(e,f)
# output:1 2
#        1 2
#        jingzhou wuhan

%3
# 拆包时、= 右侧的序列的长度需要与左侧的变量个数相同
# 如果不相同、可以使用 *变量 的形式一次接收多个元素
a, *b = (1, 2, 3, 4)
print(a)
print(b)
# output:1
#        [2, 3, 4]

# 元组中多出来的元素被整合为了一个列表

%4
# 扩展：交换两个变量的值，可以简单地使用
a, b = b, a

3、赋值中的 or 关键字

%1
# or 关键字一般用在 if 语句中、表达多个条件间的或操作
# or 也常被用在赋值中
x = a or b

# 它表达的是、如果 bool(a) 为 True、则将 a 赋值给 x、否则将 b 赋值给 x
a, b = 1, 2
c, d = 0, 2
e, f = None, 2
g, h = '', 2
x1 = a or b
x2 = c or d
x3 = e or f
x4 = g or h
print(x1,x2,x3,x4)
# output:1 2 2 2

4、控制语句相关

4.1、If 三元表达式

%1
# 假如我们要计算一个数的绝对值、可以使用 if else 语句来表达
# 语法
if x > 0:
    result = x
else:
    result = -x

x = 15
if x > 0:
    result = x
else:
    result = -x
print(result)
# output:15

%2
# 这有一种简化的写法 —— if else 三元表达式
# 语法
result = x if x > 0 else -x

x = 15
result = x if x > 0 else -x
print(result)
# output:15

# if 三元表达式从语句中间的 if 条件开始读
# 若条件满足、则获得左边的值 x
# 若条件不满足、则获得 else 下的值 -x

4.2、for else 语句

%1
# for 循环后面可以接一个 else 语句
for i in range(3):
    print(i)
else:
    print('所有项被迭代使用')
# output:0
#        1
#        2
#        所有项被迭代使用

# 如果 for 循环中所有的项被迭代、则会继续执行 else 语句中的代码

%2
# 被 break 修饰
for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print('所有项被迭代使用')
# output:0
#        1
#        2

# 一旦 for 循环被 break、后续的 else 语句将不被执行

4.3、while else 语句

%1
i = 0
while i < 3:
    print(i)
    i += 1
else:
    print('这是 else 语句')
# output:0
#        1
#        2
#        这是 else 语句

# 一旦 while 循环被 break、则后续的 else 语句将不被执行

4.4、try except else 语句

# 语法
# 如果 try 下有异常抛出、则不执行 else 语句
# 如果没有异常抛出、则执行 else 语句
try:
    pass
except:
    print('有异常发生，不执行 else 语句')
else:
    print('没有异常发生，执行 else 语句')

%1
try:
    pass
except:
    print('有异常发生，不执行 else 语句')
else:
    print('没有异常发生，执行 else 语句')
# output:没有异常发生，执行 else 语句

%2
try:
    raise  Exception
except:
    print('有异常发生，不执行 else 语句')
else:
    print('没有异常发生，执行 else 语句')
# output:有异常发生，不执行 else 语句

5、类相关

5.1、类属性 / 对象属性动态绑定

# 此前使用类属性或对象属性时、属性是在定义类的时候一起被定义的
# 另外我们也可以在运行时动态地给类或对象添加属性

class A:
        pass
A.apple = '甜'
A.orange = '酸'
print(A.orange)
print(A.apple)
a = A()
print(a.apple)
print(a.orange)
# output:酸
#        甜
#        甜
#        酸

# 只要向一个不存在的属性赋值、便会创建出这个属性

5.2、@property

%1
# 装饰器 @property 可以将类中的方法转换为属性
class A:
    @property
    def apple(self):
        return 'apple'
a = A()
print(a.apple)
# output:apple

%2
# 被 @property 装饰的方法、可以像属性一样被使用
# 但是有一个限制、这个属性是只读的、不能被修改、如果修改将会报错

class A:
    @property
    def apple(self):
        return 'apple'
a = A()
a.apple = 'orange'
# output: a.apple = 'orange'
#         AttributeError: can't set attribute

%3
# 让这个属性可以被修改、也就是变成可写的
class A:
    @property
    def apple(self):
        return self._apple
    
    @apple.setter
    def apple(self, value):
        self._apple = value

a = A()
a.apple = 'orange'
print(a.apple)
# output:orange

5.1、自定义异常

# Python 中内置有很多异常
# 当我们需要使用异常时、从中挑选出合适的异常即可
# 但有些时候、可能需要自定义自己的异常
# 自定义异常的方式很简单、只需要定义一个类、这个类继承自 Exception 类或其子类即可

class FileParseException(Exception):
    pass

6、函数相关

6.1、函数参数类型标注

# 函数参数类型标注的写法如下、在每个参数的后面加上冒号（:）并标明类型
def say_hello(name: str):
	print(name, ', hello!')

# 上述便指明了参数 name 为 str 类型
# Python 并不会根据标注对参数作类型校验、这只是为了方便阅读和 IDE 静态分析

6.2、函数返回值类型标注

# 函数的返回值类型标注如下、在参数列表的后面加上右箭头（->）并标明类型
def say_hello(name) -> str:
	print(name, ', hello!')

# Python 并不会根据标注对返回值作类型校验、只是方便阅读和 IDE 静态分析