一、IO

1.文件的打开、读取和关闭：

txt = open("points.txt")
print(txt.read())
txt.close()

open() ：同源目下直接使用文件名；路径（相对、绝对）
read()：读取文件内容
close()：open后一定要关闭文件

open方法全格式：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型

常用权限参数：
r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb：默认为文本模式，如果要以二进制模式打开，加上 b 。

2.file对象

一个文件对象是使用open函数创建，每一个文件都是file 对象。
file对象的常用方法：
open() : 默认是只读打开文件， 想写入文件，要改变相应参数
read() ：读取文件
seek() ：选择读取文件的光标所在位置
readline() ： 读取一行文件
truncate() ：清空文件
write() ：写入文件

复制：
可读一个文件内容存成变量， 写入新文件。可以利用一些包，异步复制文件。

temp = open("data-Ariel.xlsx",'rb')
new_file = open("data_copy.xlsx",'wb')
new_file.write(temp.read())
#实现复制data-Ariel.xlsx 为data_copy.xlsx
temp.close()
new_file.close()

补充：
全局变量关键字 global：引用全局变量，不需要golbal声明，修改全局变量，需要使用global声明。

a = 1
b = [2, 3]

def func():
    global a
    a = 2
    print( "in func a:", a)
    b[0] = 1
    print("in func b:", b)

if __name__ == '__main__':
    print ("before func a:", a)
    print ("before func b:", b)
    func()
    print ("after func a:", a)
    print ("after func b:", b)

输出函数：print(123,end=" ") 输出语句以空格结尾 不会换行

二、字符串常用方法

1、方法介绍

大小写转换：lower() upper() swapcase() title()
搜索替换: find(substring,[start,end]) count(substring,[start,end]) strip() replace(old,new,count)
分割:split(分隔符,count)
编码:encode()
解码:decode()

补充：
计算机编码简介：
由于计算机最底层只能表示高低电平0-1，所以表示字符你就必须多很多位数0011...然而，要处理很多的的01，就必须要很高的频率。所以，cpu频率越高运算速度越快。所以，系统的位数越高，每次处理的数据越多 32 /64。
我们学了很多进制，二进制、十六进制，但这样只可以表示数字。为了表示字母，人们就需要asc2字符编码，但是西方世界字母太少了（26），只要127位就搞定了所有西方世界字符。聪明的西方人，预留了128给未来用计算机的东方世界。
万万没想到，不够用！！
于是呢最早的中文索引把255位编码作为索引，在另一张汉字索引表中对应中文，这张表是方阵94 x 72 ，就是最早的 gb2312 ， 一共7440个字符。然而，汉字太多，早期的表不再够用！！
05年，用更多的位数搞了更大的表，GB18030，每个字符可变字节，这样能装好几万个字。这里，我们所说的Bytes是一个字节，一个字节是2^8，这里的8指的就是计算机底层的位（bit）。
国际组织为求统一，unicode诞生，2^16，让每个字符占用两个字节。但是对英文来说，这是浪费空间啊，于是人们搞出了可动态变化的utf-8：英文一字节，中文三字节。（当然这里只是简述，还有utf-2 utf-16，这里不同的是编码方式，字符集都是unicode）
由于python诞生得早，最早版本英文都是用asc2根本不能解释中文。所以，只有后来的python3.x才可以解释中文（utf-8），py2中要加上这么一句：#-*-coding:utf-8-*- ， 蛋疼的是我们系统（win）大部分都是用GBK编码，所以总涉及到编码问题。

2、代码演示

s = "Python is really fun."

print("{1}",s.lower())
print("{2}",s.upper())
print("{3}",s.swapcase())
print("{4}",s.title())


print("{5}",s.find('y'))
print("{6}",s.find('y',3))
print("{7}",s.count('is',0,20))

print("{8}",s.split(" "))

{1} python is really fun.
{2} PYTHON IS REALLY FUN.
{3} pYTHON IS REALLY FUN.
{4} Python Is Really Fun.
{5} 1
{6} 15
{7} 1
{8} ['Python', 'is', 'really', 'fun.']

三、面向过程与函数式编程

1、区别

面向过程：
把功能抽取出来，将大段可以复用的代码定义为函数。
函数就是面向过程的程序设计的基本单元。
严格意义上讲，过程是没有返回值的函数。
函数式编程：
函数式编程指的是，数学意义上的函数。
一个函数的值仅决定于函数参数的值，不依赖其他状态。
举个伪代码例子，a = 1 + 2;b = a * 3;c = b - 4;函数式编程：c = mul(sum(1,2),3)-4

2、lambda表达式

语法：lambda argument_list: expression
注意：lambda函数匿名；有输入、有返回值，返回语句中计算结果；只解决简单问题。

add = lambda a,b : a+b
print(add(1,2))

四、导入模块 import

1、import module1[, module2[,... moduleN]
解释器会在搜索路径上寻找被导入模块，一个模块只会被导入一次
2、from modname import name1[, name2[, ... nameN]]
从一个模块中导入部分函数
3、import matplotlib.pyplot as plt
导入包也使用import，as可以将其作为一个变量，用“.”区分次级目录。
import sound.effects.echo

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py

详情参考