Python入门基础：从变量说到异常处理

Python入门基础：从变量说到异常处理

Python中的基本概念：变量、运算符与数据类型

变量是计算机编程中的一个重要概念。变量是一个可以存储值的字母或名称。当你编程时，可使用变量表示程序所需的任何信息。

注释就是对代码的解释和说明，其目的是让人们能够更加轻松地了解代码。注释是编写程序时，写程序的人给一个语句、程序段、函数等的解释或提示，能提高程序代码的可读性。注释只是为了提高可读性，不会被计算机编译。

Python中的注释分为单行和多行注释，分别用#和’’’’’’或者””””””表示——

# 单行注释
print("Hello World!")


'''
多行注释，要用三个单引号或者三个双引号
记得，是三个，三个，三个
'''
print("Hello China!")

运算符个人分为二元运算符和多元运算符。在这些运算符中，按运算功能又分为不同类型，比如算术运算符、比较运算符、逻辑运算符、位运算符以及其他运算符。

算术运算符就是常规的加减乘除，取余求幂，还有整除，看一下后三个——

 

'''

取余就是除剩下的数

求幂就是某个数的多少次自乘

整除刚好和取余，一个包含被除数多少个，一个还剩多少

'''

print(5%2)

print(2**3)

print(11//3)

比较运算符就是大于、小于、不等于，以及三者组合的运算，逻辑就是或、与、非啦。位运算顾名思义就是按照给出的数每一位进行逻辑运算或者位移——

'''

这里测试一下位运算

里面当然包含了逻辑运算

'''

print("按位取反：",~0)

print("按位与操作：",1&1)

print("按位或操作：",1|0)

print("按位异或操作：",1^1)

print("按位左移3位：",11 << 3)

print("按位右移2位：",11 >> 2)



# 三元运算符

x,y = 4,5

print(x if x < y else y)


'''

'''
is, is not 对比的是两个变量的内存地址

==, != 对比的是两个变量的值

-假如比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。

-假如对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的

'''

a = ["Hello"]

b = ["Hello"]

print(a is b, a == b)



a = "Hello"

b = "Hello"

print(a is b, a == b)

 

这里要注意一下运算符的优先级：

1、一元运算符优先于二元运算符；

2、先算术运算，后移位运算，最后位运算，例如1<<3+2&7等价于(1<<(3+2))&7;

3、逻辑运算最后结合起来。

Python中的变量在使用之前需要进行赋值操作，同时对变量的取名有一定的要求：可以包含字母、数字、下划线等，但是不能以数字开头，不然无法辨认，而且对于字母的大小写是敏感的。

数据类型分为int、float、bool，而且python里面是对象的概念，万物为对象，既然是对象，就有相应的属性(attributes)和方法(methods)了。可以尝试print(dir(int))看看整型的属性和方法。

Python 里面有很多用途广泛的包 (package)，用什么你就引进 (import) 什么。包也是对象，也可以用上面提到的dir(decimal) 来看其属性和方法。比如 getcontext() 显示了 Decimal 对象的默认精度值是 28 位 ( prec=28 )。

# 找到一个整数的二进制表示，再返回其长度

a = 1031

print(bin(a))

print(a.bit_length())



import decimal

from decimal import Decimal


a = decimal.getcontext()

print(a)



# 用getcontext().prec来调整精度

decimal.getcontext().prec = 4

c = Decimal(1)/Decimal(3)

print(c)

 

除了直接给变量赋值 True 和 False ，还可以用 bool(X) 来创建变量，其中 X 可以是：

1. 基本类型：整型、浮点型、布尔型

2. 容器类型：字符、元组、列表、字典和集合

bool 作用在基本类型变量：X 只要不是整型 0、浮点型 0.0，bool(X) 就是 True ，其余就是 False。

bool 作用在容器类型变量：X 只要不是空的变量，bool(X) 就是 True ，其余就是 False。

注意：确定bool(X) 的值是 True 还是 False ，就看 X 是不是空，空的话就是 False ，不空的话就是 True 。

1. 对于数值变量，0 , 0.0 都可认为是空的。

2. 对于容器变量，里面没元素就是空的。

# bool判断不同类型的变量，空就是False,否则就是true

print(type(True),bool(True),bool(False))

print(type(()),bool(()),bool((10,)))

print(type(5.2))

获取对象的类型信息，上文用到的type(object)、isinstance(object,classinfo):

# 获取类型信息

print(type(1))

print(type(True))



print(isinstance('5.2',str))

print(isinstance(True,bool))

 

注：

1. type() 不会认为子类是一种父类类型，不考虑继承关系。

2. isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

Python中的数据类型转换，很直接地可以用类似于int(x)、float(y)等进行转换。

这里，复习一下最常用的函数print，必用函数之一：

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

 

1. 将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按str() 方式进行转换为字符串输出；

2. 关键字参数sep 是实现分隔符，比如多个参数输出时想要输出中间的分隔字符；

3. 关键字参数end 是输出结束时的字符，默认是换行符\n ；

4. 关键字参数file 是定义流输出的文件，可以是标准的系统输出sys.stdout ，也可以重定义为别的文件；

5. 关键字参数flush 是立即把内容输出到流文件，不作缓存。

别说，还真是学到了，以前是直接用，没考虑过里面包含的几个不常用的诸如end、flush参数的用法和意义！

位运算

这一块单独拿出来，我猜想是因为计算机二进制的原因？二进制常用的有原码、反码和补码三种，二计算机内部使用的是补码！

原码：就是二进制的表示形式(注意：其中有一位是符号位),反码：正数的反码就是原码，负数的反码则是符号位不变，其余位取反(注意：对应的正数按位取反),补码：正数的补码就是原码，负数的补码是反码+1。最高位是符号位，0表示正数，1表示负数，位运算中符号位也参与运算。

位运算中的或、与、非以及异或、位移分为左位移与右位移，重点要巩固一下异或：满足交换律和结合律。

位运算可以实现快速计算：<<，>>快速计算2的倍数问题，^快速交换2个整数，a&(-a)快速获取a的最后为1的位置的整数。

n << 1 -> 计算 n*2

n >> 1 -> 计算 n//2，负奇数的运算不可用

n << m -> 计算 n*(2^m)，即乘以 2 的 m 次方

n >> m -> 计算 n//(2^m)，即除以 2 的 m 次方

1 << n -> 2^n

 

a ^= b

b ^= a

a ^= b

 

00 00 11 10 -> 14

&

11 11 00 10 -> -14

位运算可以实现整数集合：一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。

比如集合 {1, 3, 4, 8} ，可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。

元素与集合的操作：

a | (1<<i) -> 把 i 插入到集合中

a & ~(1<<i) -> 把 i 从集合中删除

a & (1<<i) -> 判断 i 是否属于该集合（零不属于，非零属于）

集合之间的操作：

a 补 -> ~a

a 交 b -> a & b

a 并 b -> a | b

a 差 b -> a & (~b)

 

# 利用位运算进行整数集合

print(bin(3))

print(bin(-3&0xffffffff))

重点记忆：

Python中bin 一个负数（十进制表示），输出的是它的原码的二进制表示加上个负号，巨坑。

2. Python中的整型是补码形式存储的。

3. Python中整型是不限制长度的不会超范围溢出。

所以为了获得负数（十进制表示）的补码，需要手动将其和十六进制数0xffffffff 进行按位与操作，再交给bin() 进行输出，得到的才是负数的补码表示。

条件语句

说白了，其实也就是满足某个条件就允许你执行接下来的动作的操作。条件判断分为一重、二重和多重判断，简单说就是不同场景受限制的因素个数不一样。表达式如下：

if expression1:

expr1_true_suite

elif expression2:

expr2_true_suite

.

.

elif expressionN:

exprN_true_suite

else:

expr_false_suite

其中的elif就是else if的简写。

留意一下，条件语句中有个assert关键词，术语称之为“断言”——当这个关键词后面的条件为False时，程序自动崩溃并抛出AssertionError的异常。

循环语句

和条件语句其实一样，某种程度上来说，可以理解为条件语句的特殊形式，通常为while或者for的条件成立，就执行后续的动作。重点看一下循环中常用的几个函数：

Range()函数——range([start,] stop[, step=1])

1. 这个BIF（Built-in functions）有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。

2. step=1 表示第三个参数的默认值是1。

3. range 这个BIF的作用是生成一个从start 参数的值开始到stop 参数的值结束的数字序列，该序列包含start 的值但不包含stop 的值。

enumerate()函数——enumerate(sequence, [start=0])

1. sequence -- 一个序列、迭代器或其他支持迭代对象。

2. start -- 下标起始位置。

3. 返回 enumerate(枚举) 对象

Break语句——break 语句可以跳出当前所在层的循环。

continue语句——continue 终止本轮循环并开始下一轮循环。

pass语句——pass 语句的意思是“不做任何事”，如果你在需要有语句的地方写任何语句，那么解释器会提示出错，而 pass 语句就是用来解决这些问题的。

推导式——

(1)、列表推导式：[ expr for value in collection [if condition] ]

(2)、元组推导式：( expr for value in collection [if condition] )

(3)字典推导式：{ key_expr: value_expr for value in collection [if condition] }

(4)集合推导式：{ expr for value in collection [if condition] }

# range函数

print(range(2,9))



# 列表推导式

x = [-4,-2,0,2,4]

print([a*2 for a in x])



# 元组推导式

print(x for x in range(10))



# 字典推导式

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}

print(b)



# 集合推导式

c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}

print(c)

 

异常处理

异常就是运行期检测到的错误。计算机语言针对可能出现的错误定义了异常类型，某种错误引发对应的异常时，异常处理

程序将被启动，从而恢复程序的正常运行。

异常体系内部有层次关系，Python异常体系中的部分关系如下所示：

 

在日常的工作中，我们在代码应用中总会有预料之外的影响和非正常状况，总而需要对这种计划之外的状况进行处理，那就需要把这种称谓异常的情况单独列出来并处理掉。

常见的异常处理语句如下——

try-except语句：

try:

检测范围

except Exception[as reason]:

出现异常后的处理代码

try 语句按照如下方式工作：

1. 首先，执行try 子句（在关键字try 和关键字except 之间的语句）

2. 如果没有异常发生，忽略except 子句， try 子句执行后结束。

3. 如果在执行try 子句的过程中发生了异常，那么try 子句余下的部分将被忽略。如果异常的类型和except 之后的名称相符，那么对应的except 子句将被执行。最后执行try 语句之后的代码。

4. 如果一个异常没有与任何的except 匹配，那么这个异常将会传递给上层的try 中。

一个try 语句可能包含多个except 子句，分别来处理不同的特定的异常。最多只有一个分支会被执行
 

# try-except语句

try:

    int("abc")

    s = 1 + '1'

    f = open('test.txt')

    print(f.read())

    f.close()

except OSError as error:

    print('打开文件出错\n原因是：' + str(error))

except TypeError as error:

    print('类型出错\n原因是：' + str(error))

except ValueError as error:

    print('数值出错\n原因是：' + str(error))

try-except-else语句尝试查询不在dict 中的键值对，从而引发了异常。这一异常准确地说应属于KeyError ，但由

于KeyError 是LookupError 的子类，且将LookupError 置于KeyError 之前，因此程序优先执行该except 代码块。

所以，使用多个except 代码块时，必须坚持对其规范排序，要从最具针对性的异常到最通用的异常。

# try-except-else 语句

dict1 = {'a': 1, 'b': 2, 'v': 22}

try:

    x = dict1['y']

except KeyError:

    print('键错误')

except LookupError:

    print('查询错误')

else:

    print(x)

try-except-finally语句：

try:

检测范围

except Exception[as reason]:

出现异常后的处理代码

finally:

无论如何都会被执行的代码

不管try 子句里面有没有发生异常， finally 子句都会执行。

如果一个异常在try 子句里被抛出，而又没有任何的except 把它截住，那么这个异常会在finally 子句执行后被抛出。

# try-except-finally语句

def divide(x, y):

try:

    result = x / y

    print("result is", result)

except ZeroDivisionError:

    print("division by zero!")

finally:

    print("executing finally clause")



divide(2, 1)

divide(2, 0)

divide("2", "1")

 

try-except-else语句

如果在try 子句执行时没有发生异常，Python将执行else 语句后的语句。

try:

检测范围

except:

出现异常后的处理代码

else:

如果没有异常执行这块代码

使用except 而不带任何异常类型，这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息，因为它捕获所有的异常。

try:

检测范围

except(Exception1[, Exception2[,...ExceptionN]]]):

发生以上多个异常中的一个，执行这块代码

else:

如果没有异常执行这块代码
 

# try-except-else语句

try:

    fh = open("testfile", "w")

    fh.write("这是一个测试文件，用于测试异常!!")

except IOError:

    print("Error: 没有找到文件或读取文件失败")

else:

    print("内容写入文件成功")

    fh.close()

注意： else 语句的存在必须以except 语句的存在为前提，在没有except 语句的try 语句中使用else 语句，会引发语法错误。

raise语句

Python 使用raise 语句抛出一个指定的异常。

# raise语句

try:

    raise NameError('HiThere')

except NameError:

    print('An exception flew by!')

也算是巩固入门的知识了，不得不说很多小的知识点是查缺补漏出来了，也仍然有很多不明白的地方，还需要继续入门的探索！