这节课继续学习python 元组 与 字典 两个数据类型还有循环、条件判断等相关知识，知识点有零散，但工作中需要把这些零散的知识点串起来解决问题。
在学习之前先回顾下列表有哪些方法可以操作呢？这里用一张表格总结如下：
序号 | 分类 | 关键字 / 函数 / 方法 | 说明 |
1 | 增加 | 列表.insert(索引, 数据) | 在指定位置插入数据 |
列表.append(数据) | 在末尾追加数据 | ||
列表.extend(列表2) | 将列表2 的数据追加到列表 | ||
2 | 修改 | 列表[索引] = 数据 | 修改指定索引的数据 |
3 | 删除 | del 列表[索引] | 删除指定索引的数据 |
列表.remove[数据] | 删除第一个出现的指定数据 | ||
列表.pop | 删除末尾数据 | ||
列表.pop(索引) | 删除指定索引数据 | ||
列表.clear | 清空列表 | ||
4 | 统计 | len(列表) | 列表长度 |
列表.count(数据) | 数据在列表中出现的次数 | ||
5 | 排序 | 列表.sort() | 升序排序 |
列表.sort(reverse=True) | 降序排序 | ||
列表.reverse() | 逆序、反转 |
对于字符串操作可以有哪些呢？这里可以通过工具查看如下方法可以使用。
三、元组
第一，基础操作
相对列表来说元组长度是固定，而且不能改，下面创建一个元组查看元组有什么函数可以操作。
>>> s=(12,3)
>>> type(s)
<class 'tuple'>
>> dir(s)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
从上面可以看出它可用的函数比较少，它也支持切片，也支持索引操作。
>>> s=(12,3,3,4,545,566,65)
>>> type(s)
>>> s[1]
3
>>> s[1::]
(3, 3, 4, 545, 566, 65)
>>> s[::-1]
(65, 566, 545, 4, 3, 3, 12)
>>> s[1:3]
(3, 3)
>>>
>>> s+('wwe',) # 追加一个元组
(12, 3, 3, 4, 545, 566, 65, 'wwe')
>>>在目前工作中元组使用场景比较少，这节课主要学习字典的操作还有其它的知识点。
四、字典
第一，基础操作
字典是由 key=>value 中间冒号:分割，加括号 {} 组成中 ,我们先快速定义一个字典，在看看它支持哪些函数。
>>> d = {}
>>> type(d)
<class 'dict'>
>>>
>>> dir(d)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>>
相对于列表与元组，字典性能更优，特别是查找、添加、删除。
>>> d = {}
>>> d['a']='My' # 添加
>>> d['b']='name'
>>> d['c']='python'
>>> d #输出
{'a': 'My', 'b': 'name', 'c': 'python'}
>>>
>>> d['c']='java' #修改
>>> d
{'a': 'My', 'b': 'name', 'c': 'java'}
>>>
>>> d.clear() #清空
>>> d
{}
>>>
>>> d={'a':'my','b':'name','c':'python'}
>>> d
{'a': 'my', 'b': 'name', 'c': 'python'}
>>> d.get('a') #单独获取一个元素
'my'
>>>这里还需要学习一个知识点就是遍历 for 循环。对于字符串、列表、元组、字典都可以通过 for 遍历。
for 表达式为：
for 变量 in 集合:
循环体代码
else:
其它内容输出>>> d={'a':'my','b':'name','c':'python'}
>>> for k,v in d.items():
... print(k,v)
...
a my
b name
c python
>>>
>>> for k in d.items():
... print(k)
...
('a', 'my')
('b', 'name')
('c', 'python')
>>>
>>>回顾下其它类型遍历：
#字符串遍历
>>> c = 'My name'
>>> for i in c:
... print(i)
...
M
y
n
a
m
e
>>>
#列表遍历
>>> a = [1,2,3,4,54]
>>> for i in a:
... print(i)
...
1
2
3
4
54
>>>注意遍历，有两种遍历方式，一种是按坐标遍历，一种是按值遍历
#值遍历
>>> a = [1,2,3,4,54]
>>> for i in a:
... print(i)
...
1
2
3
4
54
>>>
#坐标遍历
>>> for i in range(len(a)):
... print(a[i])
...
1
2
3
4
54
>>>解释下 range(start, stop[, step])含义
- start: 从 start 开始
- stop: 到 stop 结束
- step：步长，默认为1
操作如下：
>>> range(1,10)
range(1, 10)
>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
>>> list(range(1,10,1))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>循环中还有一个关键字就是while
它的表达式为：
初始条件设置 —— 通常是重复执行的 计数器
while 条件(判断 计数器 是否达到 目标次数):
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
处理条件(计数器 + 1)- 计算 0 ~ 100 之间所有数字的累计求和结果
# 计算 0 ~ 100 之间所有数字的累计求和结果
# 0. 定义最终结果的变量
result = 0
# 1. 定义一个整数的变量记录循环的次数
i = 0
# 2. 开始循环
while i <= 100:
print(i)
# 每一次循环，都让 result 这个变量和 i 这个计数器相加
result += i
# 处理计数器
i += 1
print("0~100之间的数字求和结果 = %d" % result)- 计算 0 ~ 100 之间 所有 奇数 的累计求和结果
# 0. 最终结果
result = 0
# 1. 计数器
i = 0
# 2. 开始循环
while i <= 100:
# 判断奇数
if i % 2 != 0:
print(i)
result += i
# 处理计数器
i += 1
print("0~100之间奇数求和结果 = %d" % result)继续学习字典操作
>>> d.pop('a') #根据元素删除字典元素
'my'
>>> d
{'b': 'name', 'c': 'python'}
>>>上面是字典部分函数操作，还有一些函数没有介绍自己可以通过dir查看有哪些函数，多多练习就能掌握字典的使用。
到这里一起学习了字符串、列表、元组、字典等相关操作，也学习了遍历知识点。对于集合类型还数字类型，不单独介绍，后面在使用过程中介绍相关知识点。
这里还的学习一个知识点就是 break 和 continue 它们的使用；
break和continue是专门在循环中使用的关键字
break某一条件满足时，退出循环，不再执行后续重复的代码continue某一条件满足时，不执行后续重复的代码
break和continue只针对 当前所在循环 有效
break
- 在循环过程中，如果 某一个条件满足后，不再希望 循环继续执行，可以使用
break跳出循环
i = 0
while i < 10:
# break 某一条件满足时，退出循环，不再执行后续重复的代码
# i == 7
if i == 7:
break
print(i)
i += 1
print("over")
break只针对当前所在循环有效
continue
- 在循环过程中，如果 某一个条件满足后，不希望 执行循环代码，但是又不希望退出循环，可以使用
continue - 也就是：在整个循环中，只有某些条件，不需要执行循环代码，而其他条件都需要执行
i = 0
while i < 10:
# 当 i == 6 时，不希望执行需要重复执行的代码
if i == 6:
# 在使用 continue 之前，同样应该修改计数器
# 否则会出现死循环
i += 1
continue
# 重复执行的代码
print(i)
i += 1
continue只针对当前所在循环有效
对于想用 python 上手工作还需要学习几个知识点才能工作。可以猜猜看是什么？类型、循环、条件判断，文件操作...，对就是条件 if 语句、while。
在 Python 中，if 语句 格式如下：
if 条件:
条件成立时，要做的事情
……注意：代码的缩进为一个
tab键，或者 4 个空格 —— 建议使用空格
else，格式如下：
if 条件:
条件成立时，要做的事情
……
else:
条件不成立时，要做的事情
……例子：
>>> a = '小明'
>>> if a == '小明':
... print("在学习") # 为真执行这句
... else:
... print("开开心心去公园") #为假就执行这句
...
在学习
>>>对于if条件判断很简单，相信大家看看就会了，需要注意的是 python 中真与假表达需要用（True,False ） 这两个字母表达。
#注意这里表达式
>>> if True:
... print("yes")
... else:
... print("no")
...
yes
>>>
# 注意这里表达式
>>> if False:
... print("no")
... else:
... print('yes')
...
yes
>>>python 中也支持in 、and 、or等表达式。
>>> a='123456'
>>> 's' in a
False
>>> '1' in a
True
>>>
>>> a = 10
>>> b = 30
>>> if a==10 and b==30:
... print('yes')
... else:
... print('no')
...
yes
>>>
>>> if a==10 or a == 20:
... print('yes')
... else:
... print('no')
...
yes
>>>对于 in 与 not in 总结如下：
运算符 | 描述 | 实例 |
in | 如果在指定的序列中找到值返回 True，否则返回 False |
|
not in | 如果在指定的序列中没有找到值返回 True，否则返回 False |
|
有这些知识后，还需要学一个文件操作就可以工作了。咱们这个课程目标是先能胜任工作，在工作中深入、持久、循环掌握 python 不同知识点。
对于 python 操作文件有两个方法可以使用，一个是open另一个是with open('文件')这两个方法，下面一起学习这两个方法怎么使用,可以在当前目前下新建一个文件夹之后在里面新建一个 testFile.py 文件还可以直接在终端编写代码，并且在文件夹新建一个文件 test.txt 内容可以随便写一句。
为了学习文件操作，先在终端输入该open命令，通过dir看看该方法支持什么函数操作文件：
>>> f = open('test.txt')
>>> dir(f)
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
>>>
在实际工作中用的最多的就read , readline ,readlines 这几个函数。下面一起学习怎么使用这几个函;
>>> f = open('test.txt') #打开文件把内容放入f变量中
>>> f.read() #读取文件内容
' 你好！开始学习文件操作呢！\n\n'
>>> f.close() #关闭具柄
>>>read表示一次性全部读取文件readline只读取一行readlines全部读取文件，内容按一行一行组合成个list
打开刚才文件，添加几行文字一起学习上面的函数怎么操作文件。
使用命令 vim test.txt 编辑文件内容。
先使用 readline 操作文件
>>> f = open('test.txt')
>>> f.readline()
' 你好！开始学习文件操作呢！\n'
>>> f.readline()
' 学习是一件愉快的事情；\n'
>>> f.readline()
' 每天学一点就好啦;\n'
>>> f.readline()
' 半亩方塘一鉴开，天光云影共徘徊。\n'
>>> f.readline()
' 问渠那得清如许？为有源头活水来。\n'
>>> f.readline()
'\n'
>>> f.close()
>>>上面一目了然就知道 readline 是一行一行读取，并且每执行一次就读下一行数据。
假如问如果机器内存只有2G,文件有10G。这种情况下怎么读取文件内容？
通过上面操作大家应该知道怎么读取10G内容了吧。
>>> f = open('test.txt')
>>> f.readlines()
[' 你好！开始学习文件操作呢！\n', ' 学习是一件愉快的事情；\n', ' 每天学一点就好啦;\n', ' 半亩方塘一鉴开，天光云影共徘徊。\n', ' 问渠那得清如许？为有源头活水来。\n', '\n']
>>> f.close()
>>> f.readlines()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.
>>>
通过 readlines() 读取文件内容后，自动会把内容放入一个list中并且把\n追加到后面。
注意：上面报错内容是因为关闭文件流后，在读取文件就出现这样的现象。
文件有读还得有文件写才构成一个小闭环。在python中写文件有很多模式，这里只介绍几种，相关资料可以去查找。
1、如果有文件直接覆盖直接写入，如果没有新建一个文件再把内容写入，
>>> with open("a.txt",'w') as f:
... f.write("学习写入文件操作！")
...
9
>>>
>>> f = open('a.txt')
>>> f.read()
'学习写入文件操作！'
>>> f.close()
>>>2、追加写入
>>> with open("a.txt",'a') as f: #追加写入
... f.write("我要追加文件！")
...
7
>>> f = open('a.txt') #读取文件
>>> f.read()
'学习写入文件操作！我要追加文件！'
>>> f.close()
>>>回顾内容:
这节课学了元组、字典、条件判断、文件操作等相关知识，这节课知识点比较多，大家可以在家慢慢练习，复习几遍就熟了，熟了后就能再工作灵活使用。
有句话是这样说的，人的一生其实都在为自己的认知买单：你所赚的每一分钱，都是你对这个世界认知的兑现；你所亏的每一分钱，都是因为对这个世界认知有缺陷。
