天池龙珠训练营Python_Task1：从变量到异常处理-CSDN博客

本文链接：https://blog.csdn.net/liucuiyin/article/details/113704751

本教程介绍了Python的基础知识，包括变量的使用、各种运算符（算术、比较、逻辑、位运算）及其应用，以及数据类型（整型、浮点型、布尔型）的概念。还讲解了注释、条件语句（if-else）、循环语句（while、for）以及异常处理，帮助初学者掌握Python编程的核心概念。

摘要由CSDN通过智能技术生成

1.简介

Python是一种通用编程语言，其在和学计算和机器学习领域具有广泛的应用。发果我们打算利用Python来执行机器学习，那么对Python有一些基本的了解就是至关重要的。本Python入门系列体验就是为这样的初学者精心准备的。

本实验包括以下内容：

2.变量、运算符与数据类型

1.注释
2.运算符
3.变量和赋值
4.数据类型与转换
5.print() 函数

3.位运算

1.原码、反码和补码
2.按位非操作 ~
3.按位与操作 &
4.按位或操作 |
5.按位异或操作 ^
按位左移操作 <<
按位右移操作 >>
利用位运算实现快速计算
利用位运算实现整数集合

4.条件语句

1.if 语句
2.if - else 语句
3.if - elif - else 语句
4.assert 关键词

5.循环语句

while 循环
while - else 循环
for 循环
for - else 循环
range() 函数
enumerate()函数
break 语句
continue 语句
pass 语句
推导式

6.异常处理

Python 标准异常总结
Python 标准警告总结
try - except 语句
try - except - finally 语句
try - except - else 语句
raise语句

2.变量、运算符与数据类型

1.注释

#后的内容是对代码的注释

例单行注释

#这是一个注释

print('Hellow world')

例:多行注释 ''' 注释内容''' 或者 """注释内容“”“

'''

这是多行注释内容

'''

print（“Hello”）

2. 运算符

算术运算符

操作符	名称	示例
+	加	1+1
-	减	2-1
*	乘	3*4
/	除	3/4
//	整除（地板除）	3//4
%	取余	3%4
**	幂	2**3

运算示例

print(1 + 1) # 2

print(2 - 1) # 1

print(3 * 4) # 12

print(3 / 4) # 0.75

print(3 // 4) # 0

print(3 % 4) # 3

print(2 ** 3) # 8

比较运算符:运算结果只有True, False 两个值

操作符	名称	示例
>	大于	2>1
>=	大于等于	2>=4
<	小于	1<2
<=	小于等于	5<=4
==/	等于	3==4
!= **	不等于	3!=5

关系运算示例

print(2 > 1) # True

print(2 >= 4) # False

print(1 < 2) # True

print(5 <= 2) # False

print(3 == 4) # False

print(3 != 5) # True

逻辑运算符：

操作符	名称	示例
And	与	(3>2)and (3<5)
or	或	(1>3) or (9<2)
not	非	not(2>1)

位运算符：

操作符	名称	示例
~	按位取反	~4
&	按位与	4&5
\|	按位或	\|
^	按位异或	4^5
<<	左移	4<<2
>>	右移	4>>2

运算示例：

print(bin(4)) # 0b100

print(bin(5)) # 0b101

print(bin(~4), ~4) # -0b101 -5

print(bin(4 & 5), 4 & 5) # 0b100 4

print(bin(4 | 5), 4 | 5) # 0b101 5

print(bin(4 ^ 5), 4 ^ 5) # 0b1 1

print(bin(4 << 2), 4 << 2) # 0b10000 16

print(bin(4 >> 2), 4 >> 2) # 0b1 1

三元运算符

x,y=4,5

If x<y:

small=x

Else:

small=y

print(small)

使用三元运算符，可以用一条语句来完成以上条件判断和赋值操作

x,y=4,5

small=x if x<y else y

print(small)

其他运算符

运算符	名称	示例
In	存在	'A' in ['A','B','C']
Not in	不存在	'h' not in ['A','B','C']
Is	是	"hellow" is "hello"
Not is	不是	"hello" is not "hello"

letters=['A','B','C']

if 'A' in letters:

print('A'+'exists')

if 'h' in letters:

print('h'+' not exists')

示例：比较两个变量均指向不可变类型

a="hello"

b="hello"

print(a is b ,a ==b) # True True

print(a is not b, a !=b) # False Flase

示例：比较两个变量均指向可变类型

a=["hello"]

b=["hello"]

print(a is b, a==b) #False True

print(a is not b, a !=b)# True False

注意：

is,is not 对比的是两个变量的内存地址
＝＝，！＝对比的是两个变量的值
比较的两个变量，指向的都是地址不可变的类型（str等），那么is, is not 和==，！=是完全等价的。
对比的两个变量，指向的是地址可变的类型（list,dict,tuple等），则两者是区别的。

运算符的优先级

大致：单目，算术，位，关系，逻辑，不背诵，使用时查文档

3变量和赋值

变量在使用前，必须要赋值

变量名命名可由字母、数字、下划线组合，但变量名不能以数字头

Python变量名的大小写敏感，ｆｏｏ　与Ｆｏｏ　是两个不同的变量

示例　：

tea="毛峰"

print(tea)

num1=56

num2=32

num3=num1+num2

print(num3)

s1="小明学编程"

s2="小琴学编程"

wes=s1+','+s1

pirnt(wes) #小明学编程，小琴学编程

set_1={"爱上"，"Python","编程"}

print(set_1.pop) #欢迎

４．数据类型与转换

类型	名称	示例
Int	整型	895
Float	浮点型	3.01445
bool	布尔型	True,False

整型<class 'int'>

a=1031

print(a,type(a))

通过print可看出a的值，以及类 (class) 是int。Python 里面万物皆对象（object），整型也不例外，只要是对象，就有相应的属性（attributes）和方法（methods）

b=dir(int)

print(b) #把整型对象的属性与方法全部打印出来。

例：找出一个整数的二进制表示，并返回其长度。

a=1030

print(bin(a)) #00b100000001111

print (a.bin_length()) #11 这里使用bin_length()这一方法

#查看浮点型数据类型

print(1,type(2.33))

#2.33 <class 'float'>

例：使用decimal包中的Decimal对象和getcontext()方法来实现。

import decimal

from deciaml import Decimal

????没完成

3.位运算

1.原码、反码和补码

2.按位运算

3.利用位运算实现快速计算

4.利用位运算实现整数集合

4.条件语句

1.if 语句（是执行还是不执行）

格式

if expression:

expr_true_suite

只有expression的值为true时，expr_true_suite才会被执行，否则将继续执行紧跟在该代码块后面的语句。

expresion可以由布尔操作，and ,or 和not 实现多重条件判断的表达式。

#例

if 2>1 and not 2 >3:

print('Correct Judgement!') #输出Correrct Judgement!

2.if - else 语句（二选一执行）

语法格式：

if expression:

expr_true_suite

else:

expr_false_suite

Expression值为真，执行expr_true_suite，否则为假，执行expr_false_suite .

例

temp=input("猜猜小姐姐想的是哪个数字？")

guess=int(temp) #input 的返回数据类型为str，这里做数据类型的转换

if guess==666:

print("你太了解小姐姐的心思了！")

else:

print("铺错了，现在心里想的是666！")

print("游戏结束，不玩儿啦！")

if与else 后面的代码，只能二选一个执行，选谁执行，由if 后的表达式值是true还是false 来决定.

If-else 的选择结构可以进行嵌套，可以在if-else各自后面的语句又可是if 或 if-else语句，从而构成多层次的选择控制执行结构。

例：

hi=6

if hi>2:

if hi>7:

print("好棒！好棒！")

else:

print("切~") #无输出

例：

temp=input("猜猜小姐姐想的是哪个数字？")

guess=int(temp) #input 的返回数据类型为str，这里做数据类型的转换

if guess>8:

print("大了，大了")

else:

if guess==8:

print("你太了解小姐姐的心思了！")

print("猜对了也没奖励！")

else:

print("铺错了，现在心里想的是666！")

print("游戏结束，不玩儿啦！")

#这里：外层的if-else 语句的else控制的子句嵌入了一个if-elsey语句。

3.if -elif -else 语句

语法格式：

if expression1:

expr1_true_suite

elif expression2:

expr2_true_suite

.

elif expressionN:

exprN_true_suite

else:

expr_false_suite

elif 语句即为 else if，用来检查多个表达式是否为真，并在为真时执行特定代码块中的代码。

temp = input('请输入成绩:')

source = int(temp)

if 100 >= source >= 90:

print('A')

elif 90 > source >= 80:

print('B')

elif 80 > source >= 60:

print('C')

elif 60 > source >= 0:

print('D')

else:

print('输入错误！')

输入成绩:99

这里要注意写程序时条件判断的冗余。

4.assert 关键词

Assert 称之为“断言”，当这个关键词后边的条件为False时，程序自动崩溃并抛出AssertionError的异常。

例：在进行单元测试时，可以用来在程序中置入检查点，只有条件为 True 才能让程序正常工作。

assert 7 > 3 #这个条件满足时才执行

print('1')

print('2')

# 1 2

##修改为以下面的代码

assert 7 > 9 #这个条件满足时才执行

print('1')

print('2') #程序给出异常AssertionError

5.循环语句

1.while 循环

2.while -else 循环

3.for 循环

4.for -else 循环

#在java与C中没看到for-else 函数

格式：

for 迭代变量 in 可迭代对象：

代码块

　　 else:

　代码块

例：列10-20之间合数与质数。对于合数定出其因数的乘积。

for num in range(10,20):

for i in range(2,num):

if num%i==0: #确定第一个因子

j=num/i #计算第二个因子

print('%d 等于%d *%d ' %(num,i,j)

else: #循环else部分

print(num,'是一个质数')

5.range()函数

格式： range([start,] stop[, step=1])

Built-in function 有三个参数，其中用中括号括起来的两个表示可选.

step:是默认步长.

Range: 生成从[start stop)的数值序列

6.enumerate ()函数

格式： enumrate(sequece,[start=0])

Sequence: 一个序列、迭代器或其他支持迭代对象

Start: 下标起始位置

返回enumearte(枚举）对象

例：enumerate (seasons)返回了 seasons列表中的所有元素，和元素相应的索引值（从0开始）。

seasons=['Spring','Summer','Fall','Winter']

lst=list(enumerate(seasons)) #用enumerate（）函数获得列表中的元素

print(lst)

lst=list(enumerate(seasons, start=1)) #使用enumerate函数获得列表中的元素，并且设置起始值为1

print(lst)

例：enumerate （）与for 一起使用

格式：for i a in enumerate (A)

do something with a

例如：字符串组合

#第一种方式用for 循环

languages=['Python', 'R', 'Matlab', 'C++']

for language in languages:

print('I love',language)

print('Done!')

#第二种方用 enumerate()函数来完成。.

languages=['Python', 'R', 'Matlab', 'C++']

for language in enumerate(languages):

#用下面的这种方式也可以

#for i,language in enumerate(languages,2): #2的解释

print("I love",language)

I love Python

I love R

I love Matlab

I love C++

Done!

2 I love Python

3 I love R

4 I love Matlab

5 I love C++

Done!

7.break语句

中断循环执行

例：

import random

secret=random.randit(1,10) #[1，10]之间的随机数

while True:

temp=input("猜一猜小姐姐想的是哪个数字？")

guess=int（temp)

if guess>secret:

print("大了"）

else:

if guess==screet:

print("你猜中了")

print("猜对也没有奖励！")

break

else:

print("小了")

print("游戏结束了")

8.Continue 语句

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

#如筛选出1-10中的奇数

for i in range(10):

if i%2!=0:

print(i)

continue

9.pass语句

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

在编写程序时，可以用pass语句来替代还未完成的代码

def a_func():

# 不写pass 会出错 SyntaxError: unexpected EOF while parsing

#改写在加上pass的空函数

def a_func():

pass

#pass是空语句，不做任何操作，只起到占位的作用，其作用是为了保持程序结构的完整性。尽管pass语句不做任何操作，但如果暂时不确定要在一个位置放上什么样的代码，可以先放置一个pass语句，让代码可以正常运行

10.推导式

列表推导式：利用列表,for , if-else,in 语句组合在推导式解决复杂问题

格式：[ expr for value in collection [if condition] ]

例：计算X列表中的元素，全部*2 构成y列表

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

y=[a*2 for a in x] #X列表中的元素，全部*2 构成y列表

print(y)

[-8, -4, 0, 4, 8]

例：计算1-9 每个整数的平方

x=[i**2 for i in range(1,10)] #1-9 每个整数的平方

print(x)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

例：1-100中除的通3，但除不通2的数

x=[i for i in range(100) if (i%2)!=0 and (i%3)==0]

print（x）

#[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]

例：形成数对列表（x,y） x in (0,3),y in (0,3)，对两个变量进行了范围说明分别是

for i in range(0,3)

for j in range(0,3)

a=[(i,j) for i in range(0,3) for j in range(0,3）]

print(a)

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

例：类似,得到元素为列表的列表

a=[[i,j] for i in range(0,3) for j in range(0,3）]

print(a)

#[[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

例：对参数进行大小限定，其中i<1, j>1。两个参数进行限定范围，并加上条件筛选。

a=[(i,j) for i in range(0,3) if i<1 for j in range(0,3) if j>1]

print(a)

#a=[(i,j) for i in range(0,3) if i<1 for j in range(0,3) if j>1]

print(a)

元组推导式

格式：(expr for value in collection [if condition])

例：

a=(x for x in range(10)) #得到0-9之间的整数构成的元组

print(a) #这里会出错，#怎么解释？？？

修改为：

a=(x for x in range(10))

print(tuple(a)) #输出(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

字典推导式

格式｛key_expr:value_expr for value in collection [if condition]}

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

print (b)

#{0: True, 3: False, 6: True, 9: False}

#对字典的键进行了推导设置，对值没有做处理。

集合推导式

{ expr for value in collection [ if condition ] }

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

#c={i: for i in [1,2,3,4,5,5,6,4,3,2,1]} 也可以

print(c)

#{1, 2, 3, 4, 5, 6}

其它

next ( iterator [ , default ] ) Return the next item from the iterator. If default is given

And the iterator is exhausted, it is returned instead of raising StopIteration.

返回迭代器中下一项，默认返回迭代器中所有项，

例

e=（i for i in range(10)) #这里是推导式建立了一个元组print(tuple(e))可以将数据全部输出

print(e) #<generator object <genexpr> at 0x000002D23AA6F468>

#修改为

print (next(e)) #0 解释：next()得到迭代器中的一项，指针指向下一项

print(next(e)) #1

#下方采用迭代器将e中的数据全部读出

for each in e:

print(each,end='')

'''

输出结果为

<generator object <genexpr> at 0x000002D23A667BF8>

0

1

23456789

'''

例：求一个列表的和，分别以列表和元素的行式用推导式实现

s = sum([i for i in range(101)])

print(s) # 5050

s = sum((i for i in range(101)))

print(s) # 5050

6.异常处理

异常就是运行期检测到的错误。计算机语言针对可能出现的错定义了异常类型，某种错误引发对应的异常时，异常处理程序将被启动，从而恢复程序的正常运行。

1.Python 标准异常总结

BaseException：所有异常的基类
Exception：常规异常的基类
StandrdError：所有的内建标准异常的基类
ArithmeticErro：所有数值计算异常的基类
FloatingPointError：浮点计算异常
OverflowError：数值运算超出最大限制
ZeroDivisionError：除数为零
AssertionError：断言语句(assert)失败
AttributeError：尝试访问未知的对象属性
EOFError：没有内建输入，到达EOF标记
EnvironmnetError：操作系统异常的基类
IOError：输入/输出操作失败
OSError：操作系统产生的异常（如打开一个不存在的文件）
WindowsError：系统调用失败
ImportError：导入模块失败的时侯
keyboardInterrupt：用户中断执行
LookupError：无效数据查询的基类
IndexError：索引超出序列的范围
KeyError：找一个不存在的关键字
MemoryError：内在溢出（可通过删除对象释放内存）
NameError：尝试访问一个不存在的变量
UnboundLocalError：访问未初始化的本地变量
ReferenceError：弱引用试图访问已经垃圾回收了的对象
RuntimeError：一般的运行时异常
NotImplementedError：尚未实现的方法
SyntaxErro：语法错误导致的异常
IndentationError：缩进错误导致的异常
TabError：Tab和空格混用
SyetemError：一般的解释器系统异常
TypeError：不同类型间的无效操作
ValueError：传入无效的参数
UnicodeError：Unicode相关的异常
UnicodeDecodeError：Unicode解码时的异常
UnicodeEncodeError： Unicode编码错误导致的异常
UnicodeTranslateError：Unicode转换错误导致的异常

Python异常体系的内部关系如图所示

2.位运算标准警告总结

Warning:警告基类
DeprecationWarning:关于被弃用的特征的警告
FutureWarning：关于构造将来语义会有改变的警告
UserWarning：用户代码生成的警告
PendingDeprecationWarning:关于特性将会被废弃的警告
RuntimeWarning：可疑的运行时行为警告
SyntaxWarning：可疑语法的警告
ImportWarning：用于在导入模块过程中触发的警告
UnicodeWarning：与Unicode相关的警告
BytesWarning:与字节或字节码相关的警告
Resource:Warning：与资源使用相关的警告

3.try-except 语句

语法：

Try:

检测范围

Except Exception[as reason]:

出现异常后的处理代码

工作步骤：

首先，执行try子句（try 与except之间的代码）
如果没有异常发生，忽略except子句，try 子句执行后结束。
如try后检测的代码发生异常，那么这部分语句将被忽略。而且如异常类型和except之后的名称相符，那么except后的子句将被执行。
如果一个异常没有任何一个except匹配，那么这个异常将会传递给上层的try中。 ????

#1-打开文件出错

try:

f=open('test.text')

print(f.read())

f.close()

excpet OSError:

print('打开文件出错')

# 运行结果

# 打开文件出错

# 原因是：[Errno 2] No such file or directory: 'test.txt'

#2-给出具体的出错描述

try:

f=open('test.text')

print(f.read())

f.close()

excpet OSError as error:

print('打开文件出错的原因是： '+str(error)) #将错误描述输出

# 运行结果

# 打开文件出错的原因是：[Errno 2] No such file or directory: 'test.txt'

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

try:

int("abc")

s=1+'1'

f=open('text.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))

# 数值出错

# 原因是：invalid literal for int() with base 10: 'abc'

例

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

try:

x=dict1['y'] #在字典中是没有该项，出现查询错误

except LookupError:

print('查询错误'）

except KeyError:

print('键错误'）

else:

print(x)

#查询错误

Try-except-else 语句尝试在查询不存于dict中的键值对，会引发异常。该异常称为KeyError。因为keyError是 LookupError的子类，且LookupError置于keyError之前【？】，所以程序优先执行该except代码块。所以，使用多个except代码块时，必须坚持对其进行规范排序，要从最针对性的异常到最通用的异常。

例

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

try:

x=dict1['y']

except KeyError: #针对性的在前

print('键错误 ')

except LookupError:

print('键错误 ')

else:

print(x)

#运行：键错误

例：一个 except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。