Python 学习笔记03(数据/流程)下

Author Avatar
EmptinessBoy 6月 25, 2020
  • 在其它设备中阅读本文章

序列

列表 [] list

列表内部可以存储多个元素,元素与元素之间逗号隔开,元素可以是任意数据类型

name_list = [111,11.11,'jason',[12,3,4,5,6]]
name_list = ['jason', 'egon', 'tank', 'sean', 'oscar']
print(name_list[2])  # 索引取值  索引0开始

list() 函数

可以使用这个函数把字符串转换为列表

地址问题

可以借助工具:http://www.pythontutor.com/

图中,t2 相当于是指向了 t1 的内存地址,因此操作 t2 的时候,t1 的值被改变了

list-pointer.png

正确拷贝列表:

可以用切片的方式拷贝一个列表

list-cpoy.png

也可以用 cpoy 类的 cpoy 和 deepcopy 方法

list-copy.png

修改元素

可以用子序列的方法直接修改列表内值

list-modify.png

也可以使用同样的方法进行插入

list-append.png

删除也雷同:

list-del.png

当然也可以用 del 命令来删除:

del t[2:4]

特殊方法

append() 用于追加一个列表项:

>>> t = [1,2,3]
>>> t
[1, 2, 3]
>>> t.append(4)
>>> t
[1, 2, 3, 4]
>>>

extend() 用于列表后面加一个列表,和 “+” 用法一致

如果使用 append/extend 追加一个列表,那么会形成子列表(二维列表)

>>> t
[1, 2, 3, 4]
>>> t.append([6,7,8])
>>> t
[1, 2, 3, 4, [6, 7, 8]]

insert(<在元素编号前面>,<增加的值>)

remove(值) 删除对应值的元素

pop() 出栈,删除并返回指定元素,默认为最后一个

reverse() 反转列表

index(‘查找的值’) 查找单个元素第一次在列表出现的位置

TIPS

推荐的把输入以空格分割的字符串变成数字列表:

# 法一
l = list(map(int,input().split()))

# 法二
l = input().split(" ")
l = [int(l[i]) for i in range(len(l))]

元组 () tuple

元组与列表相似 也是可以存储多个任意类型的元素不同之处在于元组的元素不能被修改(和字符串一样),即元祖相当于不可变的列表

元组用于记录多个固定不允许修改的值 单纯的用于查看

定义一个元组

可以直接定义:

# 定义一个元组
>>> p = 3,4
>>> p
(3, 4)
>>>

标准的是使用圆括号:

>>> countries = ('中国','日本','美国')
>>> print(type(countries))
<class 'tuple'>
>>>

只有一个元素时,需要在括号后面加逗号 “,” 否则括号会被忽略。

names = ('jason')
print(type(names))  # <class 'str'>

# 元组里面如果只有一个元素 不加逗号的情况下元素是什么类型就是什么类型

names = ('jason',)
print(type(names))  # <class 'tuple'>

我们在使用可以存储多个数据的数据类型的时候,哪怕只有一个元素 也要习惯性的把逗号加上

tuple(<list>) 函数可以把一个列表变成元组

字典类型 {} dict

字典类型是用 key:value 的形式存储数据 其中 key 就是对 value 的描述性信息 (字典中的数据是无序的)

  • key 一般情况下都是字符串 但是只要key是不可变数据类型都可以
  • value 可以是任意数据类型

创建字典

用花括号 {} 来表示,每个元素用冒号分隔 键和数据。可以用 {} 或者 dict() 来创建空字典。

### 法一
person_info = {'name':'jason','age':18,'hobby':['read','DBJ']}
### 法二
fac = dict(("math","0001"), ("python","0002"), ("c","0003")) 
### 法三
fac = dict(math="0001", python="0002", c="00003")

[] 运算符操作字典

此方法容易抛出异常

访问值:

person_info['name']

修改/增加值:

person_info['name'] = "emptinessboy"

删除值:

del(person_info['name'])

遍历字典:

法1:

for 键 in 字典:
    print(字典[键])
for a in person_info:
    print(person_info[a])

法2:items() 方法

for key,value in score.items:
    print(key + ':' + str (value))

函数操作字典

字典大小: 用函数 len() 得到字典的条目的数量。

判断存在: 用 in 和 not in 运算符检测一个是否在字典中存在。

完全相同: 用 == 和 !== 比较 2 个字典是否完全相同(键和值都相同)

字典方法:

函数返回值和说明
keys()返回由全部的键组成的一个序列
values()返回由全部的值组成的一个序列
items()返回一个序列,其中的每一项是一个元组,每个元组由键和它对应的值组成
clear()删除所有条目
get(key)返回这个键所对应的值
pop(key)返回这个键所对应的值,同时删除这个条目

函数 get() 和运算符 [] 不同之处,在于如果键 key 在字典中不存在,则 get(key) 返回 None 值,而运算符 [] 会抛出 KeyError 异常。

函数 keys()、values() 和 items() 都是返回一个序列。由于字典中键不重复,所以 keys 和 items 的返回结果可以转换成元组;而 values 返回值由于可能存在重复值,应该转换为列表。

栗子 eg:

score = {'张三':78, '李四':92, '王五':92}
v = list(score.values())
print(v)

>>> [78, 92, 92]

get(键,默认值) 函数返回指定键的值,如果值不在字典中,则返回默认值。

countchar[c] = countchar.get(c,0) + 1

集合 set

集合是一个无序的容器,使用集合只在下面两种情况下使用

  1. 去重
  2. 关系运算(交叉并集)
# 直接定义集合
se = {1,2,3,4,5,6,7}

# 定义空集合
se = set()

set() 函数可以把序列变成集合

常用方法:

函数示例结果说明
len()len(s)5返回集合中元素的数量
min()min(s)2返回集合中最小的元素
max()max(s)11返回集合中最大的元素
sum()sum(s)27将集合中所有的元素累加起来
add()s.add(13){2,3,5,7,11,13}将一个元素加入集合中
remove()s.remove(3){2,5,7,11}从集合中删除一个元素,如果这个元素在集合中不存在,则抛出KeyError异常

运算符 in 和 not in 用于判断某个元素是否在集合中

集合运算

如果集合 s1 中的元素,同样都在集合 s2 中,则称 s1 为 s2 的子集,s2 为 s1 的超集。

  • 使用 s1.issubset(s2) 来判断s1是否为s2的子集。
  • 使用 s2.issuperset(s1) 来判断s1是否为s2的超集。

使用关系运算符 == 和 != 判断2个集合是否包含完全相同的元素。

使用关系运算符 < , <= , > , >= :

  • 如果 s1 是 s2 的真子集,则s1<s2是True
  • 如果 s1 是 s2 的子集,则s1<=s2是True
  • 如果 s1 是 s2 的真超集,则s1>s2是True
  • 如果 s1 是 s2 的超集,则s1>=s2是True

s1是s2的真子集的意思是s1是s2的子集,但是s2中至少有一个s1中不存在的元素; s1是s2的真超集的意思是s1是s2的超集,但是s1中至少有一个s2中不存在的元素。

交差并集

假设2个集合:s1 = {2,3,5,7,11},s2 = {2,3,4,5,6,7},

运算函数运算符示例结果说明
并集union()|s1.union(s2){2,3,4,5,6,7,11}结果是包含两个集合中所有元素的新集合
交集intersection()&s1 & s2{2,3,5,7}交集是只包含两个集合中都有的元素的新集合
差集difference()-s1 - s2{11}s1-s2的结果是出现在s1但不出现在s2的元素的新集合
对称差symmertric_difference()^s1 ^ s2{4,6,11}结果是一个除了共同元素之外的所有元素

去重后顺序

若要使去重后的元素顺序跟之前一样,如:

a = ['a','b','c','d','d','c','b','a']
b = list(set(a))
# 使B按照A的顺序排序
b.sort(key = a.index)

输出结果

['a', 'b', 'c', 'd']

b.sort(key = a.index)

这句代码让sort()方法按照a列表中索引顺序进行排列

分支语句

if 逻辑表达式:
    语句块1
else:
    语句块2

例如:

x = int(input())
if x % 2 == 0:
    print("是一个偶数")
else:
    print("是一个奇数")

连续分支

if 逻辑表达式:
    语句块1
elif:
    语句块2
elif:
    语句块3
else:
    语句块4

循环语句

FOR 循环

基本语法:

for variable in 列表:
    语句块

例如:(遍历列表)

for i in [1, 3, 5, 7, 9]:
    print(i,end=" ")

运行结果:

python-forlist.png

range 函数

产生一个自然数序列

range(start,stop,step)

start:计数从start开始。默认是从0开始。

例如 range(5)等价于range(0,5)

stop: 计数到stop结束,但不包括 stop。

例如:list(range(0,5))是[0, 1, 2, 3, 4]没有5

step:步长,默认为1。

例如:range(0,5)等价于range(0, 5, 1)

产生列表:

>>> range(1,10)
range(1, 10)
>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

列表推导式

列表推导式(又称列表解析式)提供了一种简明扼要的方法来创建列表。它可以将循环和条件判断结合,从而避免语法冗长的代码,同时提高程序性能。

基本格式:
[ expression for item in iterable ]

例如:

# 交错序列 1-2/3+3/5-4/7+5/9-6/11
>>> n = 6
>>> l = [num / (num * 2 - 1) if num % 2 != 0 else num / (num * 2 - 1) * (-1) for num in range(1, n + 1)]
>>> l
[1.0, -0.6666666666666666, 0.6, -0.5714285714285714, 0.5555555555555556, -0.5454545454545454]

# 交错序列 0, -1, 2, -3, 4, -5
>>> l = [i if i%2==0 else i*(-1) for i in range(6)]
>>> l
[0, -1, 2, -3, 4, -5]

# 偶数
>>> l = [i if i%2==0 else i*(-1) for i in range(6) if i% 2 == 0]
>>> l
[0, 2, 4]

>>> l = [i for i in range(6) if i% 2 == 0]
>>> l
[0, 2, 4]
>>>

# 叠数
>>> l = [int('6' * i) for i in range(1,8+1)]
>>> l
[6, 66, 666, 6666, 66666, 666666, 6666666, 66666666]
>>>

WHILE 循环

语法结构:

while 条件:
  while 子代码1
  while 子代码2
  while 子代码3

如果条件为True 那么就依次执行while的子代码执行完毕之后再次回去判断条件是否为True如果还是继续执行 直到条件为False为止停止循环

全局标志位

如果嵌套了很多层 如何做到一次性结束所有的循环层?

  • 方式1 有几个 while 就写几个 break
  • 方式2 利用全局标志位
flag = True
while flag:
    while 语句块

高级循环控制

break / continue

break # 结束本层循环(结束掉离break最近的上面的那一个while)

continue # 结束本次循环直接开始下一次循环

while/for + else

如果循环被正常结束,则执行 else 语句块:

count = 1
while count < 6:
    循环内语句块
else:  # 当while没有被人为故意打断的情况下 才会走else
    语句块
for i in range(10):
    循环内语句块
else:  # 当for正常结束的情况下 才会走else
    语句块

异常

在程序运行过程中如果发生异常,Python 会输出错误消息和关于错误发生处的信息,然后终止程序。

除了直接将异常进行抛出,比较合理的方法是捕获并处理异常

可使用 try except 语句实现异常处理。

例如:

short_list = [1,2]
try:
    short_list[6]
except:
    print('产生了下标越界的异常')

当 try 中的语句抛出异常时,就会执行 except 下的语句块

语法格式

try:
    语句块1
except 异常类型1:
    语句块2
except 异常类型2:
    语句块3
…
except 异常类型N:
    语句块N+1
except:
    语句块N+2
else:
    语句块N+3
finally:
    语句块N+4

当没有捕获任何异常的时候,所有 except 下语句都不会执行,但是 else 下的内容会被执行。而不论如何 finally 的语句一定会执行。

except 不指定异常类型,则匹配所有异常

常见的标准异常

异常名称描述
SystemExit解释器请求退出
FloatingPointError浮点计算错误
OverflowError数值运算超出最大限制
ZeroDivisionError除(或取模)零(所有数据类型)
KeyboardInterrupt用户中断执行,通常是输入 ^C
ImportError导入模块对象失败
IndexError序列中没有此索引(index)
RuntimeError一般的运行时错误
AttributeError对象没有这个属性
IOError输入输出操作失败
OSError操作系统错误
KeyError映射中没有这个键
TypeError对类型无效的操作
ValueError传入无效的参数

高级异常操作

有时需要除了异常类型以外其他的异常细节,可以使用下面的格式获取整个异常对象:

except Exception as name

例如:

short_list = [1, 2,3]
while True:
    value = input('Position [q to quit]? ')
    if value == 'q':
        break
    try:
        position = int (
        print( short_list [
    except IndexError as err:
        print('Bad index:', position)
    except Exception as other:
        print('Something else broke:', other)

运行效果:

python-exception.png

前面讨论了异常处理,但是其中讲到的所有异常都是在 Python 或者它的标准库中提前定义好的。根据自己的目的可以使用任意的异常类型,同时也可以自己定义异常类型。

This blog is under a CC BY-NC-ND 4.0 Unported License
本文链接:https://coding.emptinessboy.com/2020/06/Python-%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B003%EF%BC%88%E6%95%B0%E6%8D%AE-%E6%B5%81%E7%A8%8B%EF%BC%89%E4%B8%8B%20-%20%E5%89%AF%E6%9C%AC/