干货杂货铺

1.input函数

简单，一笔带过

C=float(input('输入合适的摄氏度C：'))
#input函数的类型转换，初始为字符串
F=9*C/5+32
print("对应的华摄氏度为%.2f"%F)

2.eval函数

其功能是将一个输入的字符串转换成一个python表达式，这个机制可以动态地生成运行代码

a=eval('1+1')
print(a)

输出结果自然是：

2

更加深入地理解一下：

a=eval('1.2')
print(type(a))

输出：

<class 'float'>

可见eval函数相当于解析字符串内部的内容而直接忽略掉引号

from math import *
a=eval('exp(2)')
print('%.2f'%a)
print(type(a))

输出

7.39
<class 'float'>

如果要用eval解析一个字符串：

print(type(eval('"ZDZ很帅"')))

这里必须嵌套两个引号，单引号或双引号谁在外面都可以，才能够只被eval解析一层而输出

<class 'str'>

我试了一下，如果只有一层，会输出

NameError: name 'ZDZ很帅' is not defined

也就是说这里引号内内容被认为是一个没有被定义的变量名
################################################
1月6日继续（标明日期可以彻底说明我的懒惰，哎~~）
eval函数可以根据用户的输入将其转变成相应的类型，看这样一段代码：

n1=eval(input('n1='))
n2=eval(input('n2='))
n=n1+n2
print('%s + %s becomes %s\n with value %s'%(type(n1),type(n2),type(n),n))

这样测试时可以看到float与int相加成float,还可以列表、字符串等相加，注意输入字符串时要在外面加上引号：

#此为终端的输入内容
n1=n
Traceback (most recent call last):
  File "c:\Users\lenovo\Desktop\python\ZDZ的博文模板.py", line 1, in <module>
    n1=eval(input('n1='))
  File "", line 1, in <module>
NameError: name 'n' is not defined

可见第一个值输入即会报错，正确示例：

#此为终端内容
n1='n'
n2='m'
<class 'str'> + <class 'str'> becomes <class 'str'>
 with value nm

3.exec函数

功能是可以动态地执行复杂的python代码，比eval函数只能执行表达式字符串的功能强大得多，看个例子先意会一下它怎么用：

i=5
j=15
exec('answer=j/i')
print('答案是：%s'%answer)

输出：

答案是：3.0

这里我们注意到代码中使用了 %s，说明exec将 answer 解释成了一个字符串！！如果用 %.1f 呢：

答案是：3.0

啊这。。。也输出了，只能说python的容错能力太强大了。
好，继续：
可见，exec 函数执行了引号内的合理的代码，将结果赋给了变量answer,再看一个复杂的例子：

g='def f(n):\n\treturn 1 if n==1 else n*f(n-1)'
exec(g)
print(f(6))

这里 g 的字符串内是一段符合 python 语法规则的定义阶乘函数的代码，包括换行与制表符也要合乎情理，从而可以被exec解析，成功把 f(n) 定义了出来，输出结果为：

720

而 exec 的实际应用价值在于调用一些代码，比如说我已经定义了一个函数，并且将它写入了文件1.txt(为了避开路径问题以便于调用，将文件放在相同文件夹可直接调用)：

def f(n):
    return n**3
print(f(6))

现在我想调用它：

with open('1.txt','r') as f:
	s=f.read()
exec(s)

输出：

216

以此类推，无论多么复杂的代码，我可以保存于文件中用 exec 调用，而它的朴素的本质是 open 文件后默认是字符串，因此可以用 exec 直接调用内容
######################################################
1月7日 19：00

4.字典（1）

字典可以储存任意类型的对象，每个键值key与value用 : 分割，类比于列表用 [ ] 合并，字典用 { } ,每个元素即 item 用逗号隔开，形如：

dic={
     key1:value1,key2:value2,key3:value3,...}

其中规定key是唯一不可变的，如字符串，整型，浮点型，但值（的数据类型）任意，每个 key : value 称作一个 item
访问键值的方法：

color={
     'apple':'red','banana':'yellow','grape':'purple'}
print(color['apple'])

即字典名后面加中括号里的 key 名称，当然输入未定义的 key 会报错：

##终端说：
Traceback (most recent call last):
  File "c:\Users\lenovo\Desktop\python\ZDZ的博文模板.py", line 2, in <module>
    print(color['orange'])
KeyError: 'orange'

继续修改上述代码：

color={
     'apple':'red','banana':'yellow','grape':'purple'}
color['apple']='green'
color['orange']='orange'
print(color['apple'])
print(color['orange'])

第二行直接修改了 apple 的键值，第三行会默认直接加上新的 item,删除操作：

del color['apple'] #删除键'apple'
color.clear()      #清空字典
del color		   #删除字典

字典被删除后当然不可再调用
值得注意的是，同一个字典的 key 名称不能重复，否则系统取***后者***为实际值，而且，key 的类型不能是 list ,但可以是 tuple
下面整理一些字典的内置函数与方法：

#len()
#计算 item 个数
len(dict)

#str()
#输出字符串形式的可打印的字典（即在外面加上引号）,可以用 eval() 还原
str(dict)

#清空字典
dict.clear()

#返回一个字典的浅复制
dict.copy()

暂停一下，让我们先搞懂什么是浅复制与深复制：

5.浅谈深浅复制

这是一件很有意思的事情，浅复制是说 b=a.copy() 后 b 复制了 a 的第一层元素，没有复制深层的元素，可以理解为深层的元素仍然被别人左右着，即修改 a 的最外层元素时 b 不会发生变化，但修改 a 的更深层元素时 b 会随之改变：

a=[1,2,3,[4,5]]
b=a.copy()
a[1]=1
print(a)
print(b)
a[3][1]=1
print(a)
print(b)

############
#终端输出：
[1, 1, 3, [4, 5]]
[1, 2, 3, [4, 5]]
[1, 1, 3, [4, 1]]
[1, 2, 3, [4, 1]]

那么深复制就是复制后就与原对象没有了任何联系，只是开始与之一模一样而已，代码为：

a=[1,2,3,[4,5]]
import copy
b=copy.deepcopy(a)
print(b)

注意代码有较大变化，调用了 copy 库，事实上浅拷贝也可以写成：

a=[1,2,3,[4,5]]
import copy
b=copy.copy(a)
print(b)

6.字典（2）

继续我们的字典的内置函数与方法：

# dict.items()
#返回以每组 key 与 value 组成的元组为元素的列表，有点拗口，看例子
color={
     'apple':'red','banana':'yellow','grape':'purple'}
a=color.items()
print(a)
#输出：
dict_items([('apple', 'red'), ('banana', 'yellow'), ('grape', 'purple')])
#其中 dict_items([...])是系统加上的

# pop() 函数
#删除字典某个 key 对应的值，返回值是被删除的值，与此同时字典也被‘瘦身’了：
```python
color={
     'apple':'red','banana':'yellow','grape':'purple'}
a=color.pop('apple')
b=color.pop('banana')
print(a,end='\t')
print(b)
print(color)

输出：

red     yellow
{
     'grape': 'purple'}

dict.keys():
#返回一个迭代器，可以用 list 转换为列表
color={‘apple’:‘red’,‘banana’:‘yellow’,‘grape’:‘purple’}
a=color.keys()
print(a)
print(list(a))
#输出：
dict_keys([‘apple’, ‘banana’, ‘grape’])
[‘apple’, ‘banana’, ‘grape’]
#迭代器？再插入一段吧：

7.初识迭代器（与生成器）（暂未完成）

迭代器是访问集合元素的一种方式，是一个可以记住遍历位置的对象，它从第一个元素开始访问，直到所有的元素被访问完结束，它只能往前不可以后退，有两个基本方法：iter() 与 next(),字符串，列表，元组对象都可以用于创建迭代器：

list=[1,2,3]
n=iter(list) #创建迭代器对象
print(next(n))#从第一个元素开始输出下一个对象
print(next(n))
print(next(n))
print(next(n))#不可以超出范围（迭代器已经停止）
输出：
1
2
3
Traceback (most recent call last):
  File "c:\Users\lenovo\Desktop\python\ZDZ的博文模板.py", line 6, in <module>
    print(next(n))
StopIteration

类似得：

str='123'
n=iter(str) #创建迭代器对象
print(next(n))#从第一个元素开始输出下一个对象
print(next(n))
print(next(n))
print(next(n))#不可以超出范围（迭代器已经停止
#输出：
1
2
3
Traceback (most recent call last):
  File "c:\Users\lenovo\Desktop\python\ZDZ的博文模板.py", line 6, in <module>
    print(next(n))
StopIteration

以及：

tuple=(1,2,3)
n=iter(tuple) #创建迭代器对象
print(next(n))#从第一个元素开始输出下一个对象
print(next(n))
print(next(n))
print(next(n))#不可以超出范围（迭代器已经停止）
#输出：
1
2
3
Traceback (most recent call last):
  File "c:\Users\lenovo\Desktop\python\ZDZ的博文模板.py", line 6, in <module>
    print(next(n))#不可以超出范围（迭代器已经停止）
StopIteration

另外，迭代器对象可以使用 for 循环遍历：

 list=[1,2,3]
n = iter(list)    # 创建迭代器对象
for x in n:
    print (x, end=''）

显然这和：

list=[1,2,3]
#n = iter(list)    # 创建迭代器对象
for x in list:
    print (x, end=' ')

输出结果一样
（1月9日 周六 一下午）
另外还有 next() 函数：

import sys
str='zhaode'
i=iter(str)
while True:
    try:
        print(next(i),end=' ')
    except StopIteration:
        sys.exit()

我此时想写写 sys ，以后吧，不然跑题太远了，我们尽量针对期末考试，上面输出结果是：

z h a o d e

我们注意到调用 next ( ) 函数并不需要加任何前缀，此处用 sys 只是为了在迭代结束后退出循环
#####################################################
（啊，突然意识到自己跑题太远了，我还有事，前路漫漫，以后再找时间扩展，哎，但不得不说其余的干货也是十分有用的）