python基础复习2

1.input 输入

a_input = input('Please give a number:')  # return type str
# a_input = int(input('Please give a number:'))  也可以进行类型转换
# print('This number is:', a_input)

if a_input == '1':
    print('This is One')
elif a_input == '2':
    print('This is Two')
else:
    print('See you')

2.元组tuple()  /   列表list[]

list是一种有序的集合，可以随时添加和删除其中的元素。 下列代码中a_list换成元组则输出元组中的index和对应值。索引超出范围会报IndexError错误。

如果要取列表最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素。

a_tuple = (12, 3, 5, 15, 6)
another_tuple = 12, 3, 5, 6  #元组也可以不加括号定义

a_list = [12, 6, 4, 7, 8]
for index in range(len(a_list)):
    print('index=', index, 'number=', a_list[index])

结果：
index= 0 number= 12
index= 1 number= 6
index= 2 number= 4
index= 3 number= 7
index= 4 number= 8

a_list = [12, 6, 4, 7, 8]

# 在列表尾部加元素
a_list.append(0)
print(a_list)
# 在索引为1处加元素
a_list.insert(1, 0)
print(a_list)
# 删除元素，有相同元素 则删除第一次出现的那个元素  传入的不是index是value
a_list.remove(0)
print(a_list)

print(a_list[-3:]) # 从倒数第一位输出到倒数第三位 按照列表顺序
# 结果：[7, 8, 0]

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改。没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，但不能对其赋值成另外的元素。

由于tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple的陷阱：当定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来：

t = (1, 2)
print(t)
#结果：(1, 2)

要定义一个空的tuple，可以写成()：

t = ()
print(t)
#结果：()

要定义一个只有1个元素的tuple必须加一个逗号','  来消除运算符号()的歧义：

# 不加逗号默认()为运算符号
t = (1)
print(t)
# 结果：1  

# 加逗号才是元组
t = (1,)
print(t)
# 结果：(1,)

3.字典dic{}

key-value一一对应，没有顺序

d = {'apple': 1, 'pear': 2}
print(d['apple'])

结果：
1

# 删除key，随之删除对应的value
del d['apple']
print(d)

# 添加
d['b'] = 20
print(d)

结果：
{'pear': 2}
{'pear': 2, 'b': 20}

4.载入模块 import

# 打印当前时间
import time
print(time.localtime())

# 对导入模块起别称
import time as t
print(t.localtime())

# 只导入需要的功能   不需要time.xxx
from time import time, localtime
print(localtime())
print(time())

# from time import *   # 导入所有功能

自己创建模块（脚本）

载入模块脚本与当前脚本在同一个目录下可直接用import xx

5.错误处理

在程序运行的过程中，如果发生了错误，可以事先约定返回一个错误代码，这样，就可以知道是否有错，以及出错的原因。

当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。可以没有finally语句。

try:
    file = open('eeee')
except Exception as e:
    print(e)


try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

[Errno 2] No such file or directory: 'eeee'

try...
except: division by zero
finally...
END

如果没有错误发生，可以在except语句块后面加一个else，当没有错误发生时，会自动执行else语句：

try:
    print('try...')
    r = 10 / int('2')    # 除数变为2
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

try...
result: 5.0
no error!
finally...
END

Python的错误是class，所有的错误类型都继承类BaseException，在使用except时需要注意的是，它不但捕获该类型的错误，还把其子类也全捕获到。

6.zip/map/lambda

zip

a = [1, 2, 3]
b = [4, 5, 6]
zip(a, b)
print(zip(a, b))
print(list(zip(a, b)))
# 输出：
# <zip object at 0x000001E42225BE00>
# [(1, 4), (2, 5), (3, 6)]

for i, j in zip(a, b):
    print(i/2, j*2)
# 输出：
# 0.5 8
# 1.0 10
# 1.5 12

a_list = list(zip(a, a, b))
print(a_list)
# [(1, 1, 4), (2, 2, 5), (3, 3, 6)]

lambda

def fun1(x, y):
    return x + y


a = fun1(2, 3)
print(a)
# 5
fun2 = lambda x, y: x + y
b = fun2(4, 5)
print(b)
# 9

map

def fun1(x, y):
    return x + y


a = list(map(fun1, [1], [2]))# 参数是列表形式 
print(a)
b = list(map(fun1, [1, 5], [2, 7]))
print(b)
# [3]
# [3, 12]

7.浅复制/深复制

copy只将浅层的放置到新的内存空间，深层的仍共用内存空间。

deepcopy是完全放置到新的内存空间。

import copy

# 地址相同
a = [1, 2, 3]
b = a
print(id(a))
print(id(b))
# 2108628340352
# 2108628340352

# 改变a or b 会同时改变
b[0] = 11
print(a)
print(b)
print(id(a) == id(b))
# [11, 2, 3]
# [11, 2, 3]
# True

# 改变a or c 不会同时改变
c = copy.copy(a)
print(id(a) == id(c))
# False

a = [1, 2, [3, 4]]
d = copy.copy(a)
print(id(a) == id(d))
# False
print(id(a[2]) == id(d[2]))
# True
# 改变[3,4]内容会同时改变，其他不会

# deepcopy
c = copy.deepcopy(a)
print(id(a[2])==id(c[2]))
# False