python 3语言学习

1. 安装和配置环境

1.环境使用python3，下载地址：https://www.python.org/
2.集成软件IDE使用pyCharm，下载地址：https://www.jetbrains.com/pycharm/download/
3下载完成后要配置好环境变量，并且在windows命令框测验自己python版本安装是否成功。（只需要在命令窗口输出python然后回车就行）

2.相关语法

1.注释

单行注释：
在python中使用#来注释内容（在pycharm中如果多行注释可以使用快捷键ctrl + /进行多行注释）
多行注释：
使用三个单引号或者三个双引号
‘’’ 注释内容 ‘’’ 或者 “”" 注释内容 “”"

2.缩进

在python中缩进非常重要，使用缩进来表示代码块不需要大括号{}，如果同一个代码块中的代码缩进不到位会报错！
下面是未缩进的代码：
下面是错误提示：

3.等待用户输入

使用input来让用户输入(使用input执行后必须敲回车键才可以输入！)，input(“按下回车输入”)

4.print输出

print默认是输出换行，如果想要不换行必须在print()里面加入end="“符号，双引号里面可以自由填补。例：
y = “b”
print( y, end=” a c d " )
上面输出结果就是b a c d

5.import与from …import

在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *

6.String字符串的相关语法

例如：(看注释！)
str=“helloworld”
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次，也可以写成 print (2 * str)
print (str + “TEST”) # 连接字符串

7.List列表

列表是写在方括号 [] 之间、用逗号分隔开的元素列表
列表截取的语法格式如下：
变量 [头下标：尾下标]
例如：
#定义一个列表
list = [ ‘abcd’, 786 , 2.23, ‘helloworld’, 70.2 ]
#列表截取演示
list[0:2]
#注意下标第一个是从零开始！上面的是从第一个到第三个的截取
list[0:-1]
#这里的-1代表最后一个都是倒退的，同理其他的都是一样的，-2代表倒数第二个，-3代表倒数第三个。

8.Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
例如：tuple = ( ‘abcd’, 786 , 2.23, ‘runoob’, 70.2 )
截取与列表相同语法也是一样的。

9.Set（集合）

1.集合概述

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。

2.集合语法格式

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
格式：
集合名 = {value01,value02,…}
或者
集合名(value)

3.集合移除元素

集合移除元素：
格式：set.remove( x ) 或者 set.discard( x ) （并且使用这两个在删除时如果不存在不会报错）
还有一个随意删除语法：set.pop()
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

4.清空集合

语法：set.clear()

5.计算集合元素个数

语法：len(set)

6.判断元素是否在集合中存在

语法：x in set
以上五种比较常用，还有很多函数需要实践中多多学习。

10.dictionary字典

1.字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
2.列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
注意事项：键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的
dict = {‘name’: ‘helloworld’,‘code’:1, ‘site’: ‘www.baidu.com’}
print (dict) # 输出完整的字典
print (dict.keys()) # 输出所有键
print (dict.values()) # 输出所有值

11.查看类型type

使用type()查看类型，注意有些赋值可以随便复制复制类型变化type查看之后的类型也会变化。
主要的类型如下图：

12.运算符

1.算数运算符

1.+加，-减，*乘，/除，%取余
2.***两个乘号代表次方 例如：a ** b意思就是a的b次方
3.// 取整除 - 向下取接近商的整数

2.比较运算符

1.等于==，不等于！=
2.大于>，小于<
3.大于等于>=，小于等于<=

3.赋值运算符

1.=简单的赋值运算符
2.+=加法赋值运算符
3.-=减法赋值运算符
4.=乘法赋值运算符
5./=除法赋值运算符
6.%=取模赋值运算符
7.**=幂赋值运算符
8.//=取整除赋值运算符
9.:=海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。

4.位运算符

1.&与
2.| 或
3.^异或
4.<<左移动运算符
5.>>右移动运算符
6.~按位取运算符

5.逻辑运算符

1.and 与
2.or 或
3.not 非
优先级：优先级顺序为 NOT、AND、OR。

6.身份运算符

1.is 是判断两个标识符是不是引用自一个对象
2.is not 是判断两个标识符是不是引用自不同对象

7.各个运算符的优先级

从上到下，由高到低。
（如果运算符优先级相同运算的法则是先算左边的再算右边的，从左到右）

13.转义字符

14.字符串运算符

15.字符串格式化

下面是相关格式化符号：

添加一点，在python中三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
如下：

代码：
para_str = “”“这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
“””
print (para_str)

输出：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。

16.pycharm格式化

1.快捷键

ctrl + alt + L
这个快捷键很关键！
PEP-8很多时候逗号后面需要添加空格，这个格式化就简单多了
尖叫提示：这个快捷键有可能会锁住QQ，如果界面有登录QQ的要注意了。

2.格式化输出

例如：
age = 18
print（“我现在%d岁了！” % age）
上面的%d就代表了age所要输出的。
看下面图都是代表的：

格式化字符

3.python条件语句

1.if 语句

Python中if语句的一般形式如下所示：
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
if-elif-else的格式。

2.while 循环

Python 中 while 语句的一般形式：

while 判断条件(condition)：
执行语句(statements)……

3. while 循环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块。语法格式如下：
while :
<statement(s)>
else:
<additional_statement(s)>

4.for 语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
for循环的一般格式如下：
for in :

else:

5.range()内置函数的一些功能

1.遍历数字队列

实例：
for i in range(5):
… print(i)
输出结果为：
0
1
2
3
4

2.指定区间的值

实例：
for i in range(5,9) :
print(i)
输出如下：
5
6
7
8

3.以指定数字开始并指定不同的增量

(甚至可以是负数，有时这也叫做’步长’)
实例：
for i in range(0, 10, 3) :
print(i)
输出结果：（步长为3）
0
3
6
9

4.结合range()和len()函数以遍历一个序列的索引

实例：
a = [‘Google’, ‘Baidu’, ‘Runoob’, ‘Taobao’, ‘QQ’]
for i in range(len(a)):
… print(i, a[i])
输出结果：
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ

6.continue和break

break用于中断循环的。
continue用于跳过一次循环。

7.pass 语句

Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句

4.python2与python3的区别

注意：
1.在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

5. 在Python中1和0表示什么

1在python中等于true。
0在python中等于false。
可以做一个项目查看一下1true，0false是否返回的true。
因此在有些if，while语句中会直接让变量等于1或者0来表示true和false。

6.在python中的交换

实例：
a,b=b,a 这条指令，先是变量a被赋“b值”的地址，然后变量b被赋“a值”的地址，与c语言等语言不同，非常简便。

7.迭代器和生成器

1.迭代器

1.迭代器的概述

迭代是Python最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter()和nest()。

2.实例

list = [1,2,3,4]
it = iter(list) # 创造迭代器对象
print(next(it)) #输出迭代器的下一个对象
结果：1
print(next(it)) #再次执行一个next方法
结果：2

3.创建类作为迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 _ iter_()与_next_()
__ iter __() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __ next __() 方法并通过 StopIteration 异常标识迭代的完成。
__ next __() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
实例如下：
class MyNumbers:
def __ iter __(self): #创建_iter_方法
self.a = 1
return self

def __ next __(self): #创建_next_方法
x = self.a
self.a += 1
return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

4.Stoplteration

StopIteration异常用于标识迭代的完成，防止出现无限循环的情况，在_next_()方法中我们可以设置在完成指定循环次数后触发StopIterarion异常来结束迭代。
实例：
class MyNumbers:
def __ iter __(self):
self.a = 1
return self

def __ next __(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration #StopIterarion结束迭代

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
print(x)

5.生成器

在python中，使用了yield的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
以下实例使用 yield 实现斐波那契数列：
#!/usr/bin/python3

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
输出结果为：0 1 1 2 3 5 8 13 21 34 55

8.函数

1.格式

Python 定义函数使用 def 关键字，一般格式如下：
def 函数名（参数列表）：
函数体

2.调用

格式： 函数名（） #括号里面可以添加参数值

3.可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

4.必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
例如：
#!/usr/bin/python3
#可写函数说明
def printme( str ):
“打印任何传入的字符串”
print (str)
return

调用 printme 函数，不加参数会报错

printme()
报错如下：
Traceback (most recent call last):
File “test.py”, line 10, in
printme()
TypeError: printme() missing 1 required positional argument: ‘str’

5.关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
这个关键字参数很简单就是提前在参数中赋值即可。

6.默认参数

调用函数时，如果没有传递参数，则会使用默认参数。

实例：
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
“打印任何传入的字符串”
print ("名字: ", name)
print (“年龄: “, age)
return
#调用printinfo函数
printinfo( age=50, name=“runoob” )
print (”------------------------”)
printinfo( name=“runoob” )
以上实例输出结果：
名字: runoob
年龄: 50
#------------------------
名字: runoob
年龄: 35

7.不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
“函数_文档字符串”
function_suite
return [expression]
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
实例(Python 3.0+)
#!/usr/bin/python3
#可写函数说明
def printinfo( arg1, *vartuple ):
“打印任何传入的参数”
print ("输出: ")
print (arg1)
print (vartuple)
#调用printinfo 函数
printinfo( 70, 60, 50 )
以上实例输出结果：
输出:
70
(60, 50)

8.匿名函数（lambda）

python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,…argn]]:expression
如下实例：
实例(Python 3.0+)
#!/usr/bin/python3
#可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

以上实例输出结果：
相加后的值为 : 30
相加后的值为 : 40

9.return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

实例(Python 3.0+)
#!/usr/bin/python3

#可写函数说明
def sum( arg1, arg2 ):

返回2个参数的和."

total = arg1 + arg2
print ("函数内 : ", total)
return total
#调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

以上实例输出结果：
函数内 : 30
函数外 : 30

10.主函数main

在python中也有主函数，只需要在pycharm中输入main，下面就有提示直接套用。
格式：
if _ _ name _ _ == _ _ main _ _
注意：python的执行顺序是从上到下来执行的，因此main这个主函数必须要在最后，防止出错！

9.Python3 数据结构

1.list列表

Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

1.将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。（就是像栈一样进进出出）

2.将列表当作队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。（也可以像队列一样进进出出）

3.列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

这里我们将列表中每个数值乘三，获得一个新的列表：
实例：
vec = [2, 4, 6]
[3*x for x in vec]
结果：
[6, 12, 18]

4.嵌套列表解析

Python的列表还可以嵌套。
以下实例展示了3X4的矩阵列表：
matrix = [
… [1, 2, 3, 4],
… [5, 6, 7, 8],
… [9, 10, 11, 12],
… ]

以下实例将3X4的矩阵列表转换为4X3列表：>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
以下实例也可以使用以下方法来实现：
transposed = []
for i in range(4):
… transposed.append([row[i] for row in matrix])
…
transposed
结果如下：
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
另外一种实现方法：>>> transposed = []
for i in range(4):
… # the following 3 lines implement the nested listcomp
… transposed_row = []
… for row in matrix:
… transposed_row.append(row[i])
… transposed.append(transposed_row)
…
transposed
结果如下：
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

5.del语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。
pop函数解释一下：pop()函数是主要作用在列表(list)中,移除列表中的元素,且通过下标值来实现功能,默认情况下移除列表的最后一个元素,每次只能移除一个。

6.元组和序列

元组由若干逗号分隔的值组成。
元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

7.集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典
细节：
集合在创建的时候会删除重复的，因为无序嘛。

8.字典

另一个非常有用的 Python 内建数据类型是字典。
序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。
理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
一对大括号创建一个空的字典：{}。

9.遍历技巧

1.在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来

案例如下：
knights = {‘gallahad’: ‘the pure’, ‘robin’: ‘the brave’}
for k, v in knights.items():

 print(k, v)

输出结果：
gallahad the pure
robin the brave

2.在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到

案例如下：
for i, v in enumerate([‘tic’, ‘tac’, ‘toe’]):

print(i, v)

输出结果：
0 tic
1 tac
2 toe

3.同时遍历两个或更多的序列，可以使用 zip() 组合：

案例如下：

questions = [‘name’, ‘quest’, ‘favorite color’]

answers = [‘lancelot’, ‘the holy grail’, ‘blue’]

for q, a in zip(questions, answers):

 print('What is your {0}?  It is {1}.'.format(q, a))

输出结果：

What is your name? It is lancelot.

What is your quest? It is the holy grail.

What is your favorite color? It is blue.

3.要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

案例如下：
for i in reversed(range(1, 10, 2)):

 print(i)

输出结果：
9

7

5

3

1

4.要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

案例如下：
basket = [‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’]

for f in sorted(set(basket)):

 print(f)

输出结果：
apple
banana
orange
pear

10.模块相关的函数

dir() 函数
内置的函数 dir() 可以找到模块内定义的所有名称。
如果需要导入具体的包或者查看其他的都可以用这个函数

11.python输出和输入

1.输出格式美化的函数

str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式。

2.读取键盘输入

Python提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。
input 可以接收一个Python表达式作为输入，并将运算结果返回。

3.读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。


以下实例将字符串写入到文件 foo.txt 中

1.写入文件 f.write()

格式：f.write()
写入文件实例：
#!/usr/bin/python3

#打开一个文件
f = open("/tmp/foo.txt", “w”)
f.write( “Python 是一个非常好的语言。\n是的，的确非常好!!\n” )

#关闭打开的文件
f.close()

2.读取文件 f.read()

格式：f.read()
为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
以下实例假定文件 foo.txt 已存在（上面实例中已创建）
读取文件实例：
#!/usr/bin/python3
#打开一个文件
f = open("/tmp/foo.txt", “r”)
str = f.read()
print(str)

#关闭打开的文件
f.close()

执行以上程序，输出结果为：
Python 是一个非常好的语言。
是的，的确非常好!!

3.读取文件中的一行 f.readline()

格式：f.readline()
f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
实例
#!/usr/bin/python3

#打开一个文件
f = open("/tmp/foo.txt", “r”)
str = f.readline()
print(str)

#关闭打开的文件
f.close()

执行以上程序，输出结果为：
Python 是一个非常好的语言。

4.1读取文件中的所有行 f.readlines()

格式：f.readlines()
f.readlines() 将返回该文件中包含的所有行。
如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
实例
#!/usr/bin/python3

#打开一个文件
f = open("/tmp/foo.txt", “r”)
str = f.readlines()
print(str)

#关闭打开的文件
f.close()

执行以上程序，输出结果为：
[‘Python 是一个非常好的语言。\n’, ‘是的，的确非常好!!\n’]

4.2另一种方式是迭代一个文件对象然后读取每行:

实例
#!/usr/bin/python3
#打开一个文件
f = open("/tmp/foo.txt", “r”)
for line in f:
print(line, end=’’)

#关闭打开的文件
f.close()

执行以上程序，输出结果为：
Python 是一个非常好的语言。
是的，的确非常好!!
这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用。

5.f.tell()

f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

6.f.seek()

如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：
seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符
from_what 值为默认为0，即文件开头。

7.关闭文件

格式：f.close()
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

8.pickle模块

python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
基本接口：
pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开:
x = pickle.load(file)
注解：从 file 中读取一个字符串，并将它重构为原来的python对象。
file: 类文件对象，有read()和readline()接口。
实例1：
#!/usr/bin/python3
import pickle

#使用pickle模块将数据对象保存到文件
data1 = {‘a’: [1, 2.0, 3, 4+6j],
‘b’: (‘string’, u’Unicode string’),
‘c’: None}
selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)
output = open(‘data.pkl’, ‘wb’)

#Pickle dictionary using protocol 0.
pickle.dump(data1, output)
#Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()

实例 2
#!/usr/bin/python3
import pprint, pickle

#使用pickle模块从文件中重构python对象
pkl_file = open(‘data.pkl’, ‘rb’)
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()

11.库、镜像源、github

1.国内镜像源

国内镜像源：
清华：https://pypi.tuna.tsinghua.edu.cn/simple
阿里云：http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
华中理工大学：http://pypi.hustunique.com/
山东理工大学：http://pypi.sdutlinux.org/
豆瓣：http://pypi.douban.com/simple/

2.更改pycharm镜像源操作

1. File – Settings – Project:XXXXXXXX 左三角 – Project Interpreter 点击右边的+号，点击Manage Repositories，在新弹出的窗口中更改为国内源。
2. 切换国内的源之后，可以搜索要使用的库并安装了。File – Settings – Project:XXXXXXXX 左三角 – Project Interpreter 点击右边的+号，在输入框中输入要下载的库的名称。搜索完成后，在结果中选中要安装的库，点击Install Package,等待安装。
3. 如果安装失败，可能是多种原因造成的，要根据错误的信息来排查。

3.pyecharts（数据可视化）和Github

【数据可视化pyecharts】Github：全球最大的代码托管平台
网站：https://github.com/
建议注册一个。
pyecharts的网站：
Pyecharts：https://github.com/pyecharts/pyecharts
https://pyecharts.org/#/

以上是部分内容，后续内容马上补充！