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

数据类型分为intfloatbool,而且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.0bool(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 是立即把内容输出到流文件,不作缓存。

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

位运算

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

原码:就是二进制的表示形式(注意:其中有一位是符号位),反码:正数的反码就是原码,负数的反码则是符号位不变,其余位取反(注意:对应的正数按位取反),补码:正数的补码就是原码,负数的补码是反码+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))

重点记忆:

Pythonbin 一个负数(十进制表示),输出的是它的原码的二进制表示加上个负号,巨坑。

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!')

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

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页