文件操作
f=open(“yesterday”,”r”,encoding=”utf-8”) #以只读模式打开文件
data=f.read() #读取所有内容
data2=f.read() #读取所有内容
print(data) #再次读取所有内容
print(“--------------data2--------------------”)
print(data2) #此时无内容，因为读一次完毕后，光标已经移到最后
f.close() #关闭文件
f=open(“yesterday”,”w”,encoding=”utf-8”) #以写模式创建一个文件，如果文件存在则清空
f.write(“我爱北京天安门,\n”)
f.write(“天安门前太阳升”)
f.close()
f=open(“yesterday”,”a”,encoding=”utf-8”)#以追加的方式打开文件，内容增加到结尾，不能读
f.write(“我爱北京天安门,\n”)
f.write(“天安门前太阳升”)
f.readline() #逐行读取文件信息
for i inrange(5): #打印前五行
print(f.readline())
f.readlines() #把文件中的每一行读取出来作为元素，组成一个大的列表
for linein f.readlines(): #打印文件中的所有内容
print(line.strip())
forindex,line in enumerate(f.readlines()): #判断第十行打印分隔线
if index==9:
print(“------------我是分隔线-----------------”)
continu
print(line.strip())
当文件很大时，readlines()是一次性把所有内容读取到内存中，这种情况下内存不够使用，所以只适合读小文件。大文件的处理办法是，一行一行读取，内存中只保存一行
for linein f: #一行一行读，内存中只保留一行
print(line)
count =0 #高效方法
for linein f:
count +=1
if count ==10:
print(“--------------我是分隔符---------------------”)
continue
print(line)
文件操作之增删改查
f.tell() #光标位置，按照字符的个数计数
f.read(5) #只读5个字符
f.seek(0) #回到文件初始位置
f.detach() #文件编辑过程中，从一种编码转换成另一种编码
f.encoding() #文件编码
f.name() #打印文件名字
f.flush() #刷新，默认是内存满了才写到文件中，用该命令会强制刷新直接写入
比如在DOS界面下执行以下命令可进行验证
f=open(“test.text”,”w”,encoding=”utf-8”)
f.write(“The first line.\n”) #此时打开该文件发现并没有写进去
f.flush() #执行刷新命令后，内容立刻写入文件
f.write(“The second line.\n”) #再次写入内容，打开文件仍然没有第二行内容
f.flush() #执行刷新命令后，内容立刻写入文件
有趣的程序，进度条
import sys,time #导入模块
for i in range(50)
sys.stdout.write(“#”) #标准输出
sys.stdout.flush() #标准输出刷新
time.sleep(0.1) #间隔0.1秒输出#
f.truncate() #什么都不写，表示清空文件
f.truncate(10) #表示从头开始截取10个字符，与seek到什么位置无关
f=open(“yesterday”,”r+”,encoding=”utf-8”) #以读写（确切的说是读和追加）模式打开文件
f.readline()
f.readline() #光标到第二行
f.write(“I am coming.”) #光标虽然已经移动到第二行，但写入的内容增加到结尾部分
f=open(“yesterday”,”w+”,encoding=”utf-8”) #以写读模式打开文件
f.readline()
f.readline() #先读两行，此时读不出内容，因为先以写模式打开，此时会清空文件
f.write(“I am coming.”) #再写入文件，写入成功，但写入的内容也会加到结尾部分
注：以上的模式都无法完成对原文件插入内容，写的内容均会写入文件的结尾部分
f=open(“yesterday”,”a+”,encoding=”utf-8”) #以追加写读模式打开文件
f=open(“yesterday”,”rb”,encoding=”utf-8”) #二进制文件，以读模式打开，不需要加encoding，3.0网络传输（socket）只能用二进制，下载的视频文件是二进制文件
f=open(“yesterday”,”wb”,encoding=”utf-8”) #二进制文件，以写模式打开
f.wirte(“hello binary.”) #此时会报错，不能写入字符类型的
f.wirte(“hello binary”.encode()) #转换成字节类型，写入成功
U表示在读取时，可以将\r\n \n自动转换成\n（可以结合使用rU或r+U）
文件修改，可以把内容先写入另外一个文件
with语句：当with代码块执行完毕时，内部会自动关闭释放文件资源
with open(“log”,”r”) as f1 , open(“log1”,”r”)as f2:
forline in f1:
print(line)
字符转编码操作
utf-8（unicode的扩展集，为可变长的）:英文字符按照ascii的方式存储占用一个字节，中文统一占用三个字节
Unicode（万国编码集）：中文和英文统一占用两个字节，不同编码转换必须经过unicode
ascii码：只能存储英文和特殊字符，并统一占用一个字节
python3中默认为unicode
#-*-coding:utf-8-*-
importsys #打印系统默认编码
print(sys.getdefaultencoding())
在电脑的python2的环境下（DOS界面直接运行 ）
>>>a="你好"
>>>import sys
>>>print(sys.getdefaultencoding()) #打印默认编码
ascii
>>>a_to_unicode=a.encode("utf-8") #对a自动解码，解码时使用默认编码即ascii
Traceback(most recent call last):
File "<stdin>", line 1, in<module>
UnicodeDecodeError:'ascii' codec can't decode byte 0xc4 in position 0: ordinal not in range(128)
>>>a_to_unicode=a.decode("utf-8") #指定使用utf-8解码，报错
Traceback(most recent call last):
File "<stdin>", line 1, in<module>
File "C:\Python27\lib\encodings\utf_8.py",line 16, in decode
return codecs.utf_8_decode(input, errors,True)
UnicodeDecodeError:'utf8' codec can't decode byte 0xc4 in position 0: invalid continuation byte
>>>a_to_unicode=a.decode("gbk") #指定GBK解码成功，说明不指定编码集使用系统默认编码
>>>print(type(a_to_unicode))
<type'unicode'>
>>>a_to_utf8=a.decode("gbk").encode("utf-8")
>>>print(a_to_utf8) #已经转化成utf-8，但显示的时候使用的是GBK，所以会乱码
浣犲ソ
>>>
python3中默认是unicode
import sys
print(sys.getdefaultencoding()) #打印显示utf-8
a="你好"
a_to_gbk=a.encode("gbk") #因为默认是unicode,直接encode即可
print(a_to_gbk)
a_to_utf8=a.encode("utf-8") #也可以写成a.encode()
print(a_to_utf8)
函数
1、 函数是逻辑结构化和过程化的一种编程方法，主要有以下几种方式：
面向对象：类----class
面向过程：过程----def
函数式编程：函数----def
2、 过程与函数（无明显界限）
def func1(): #定义函数
'''print func1'''
print("this is func1.")
return 0
def func2(): #定义过程，无返回值（python默认返回none）
"""printfunc2"""
print("this is func2")
func1() #调用
func2()
3、 面向过程
import time
def log():
time_format='%Y-%m-%d %X'
time_current=time.strftime(time_format)
with open("logging.txt","a") as f:
f.write("%s write alert in logging.\n" %time_current)
def func1():
print("in the func1.")
log()
def func2():
print("in the func2.")
log()
def func3():
print("in the func3.")
log()
func1()
func2()
func3()
4、 为什么要使用函数
代码重复利用
保持一致性
可扩展性
5、 函数的返回值
def test1():
print("in the test1.")
return 0
print("end of function.") #return后面无论什么语句都不执行
test1()#运行结果正常不报错，只打印了“in the test1.”返回值任意类型：
def test1():
print("in the test1.")
def test2():
print("in the test2.")
return 0
def test3():
print("in the test3.")
return 1,"hello",['tone',123],{"name":"tone"}
x=test1()
y=test2()
z=test3()
print(x)
print(y)
print(z)运行结果：
None
0
(1, 'hello', ['tone',123], {'name': 'tone'})
为什么要有返回值：整个函数执行的结果，根据结果判断执行下面不同的程序。
返回值为另一个函数（高阶函数）
6、 函数的参数与调用
位置参数（实参和形参要一一对应，不能多也不能少）：
def test(x,y) #x,y为形参，如果不调用，xy不会占用空间
print(x)
print(y)
test(1,2) #1，2为实参，内存中真实存在关键字调用：
def test(x,y)
print(x)
print(y)
test(y=1,x=2)注意：关键字参数不能在位置参数前面：不能写成test(x=2,4)
默认参数（调用参数的时候，默认参数非必要传递）：
def test(x,y=2)
print(x)
print(y)
test(1) #test(1,y=3)#test(4,3)用途：指定软件安装的默认路径
参数组（实参数目不固定）
位置参数：把N个位置参数转换为元组
def test(*args):
print(args)
test(1,3,4,3,4) #与test(*[1,3,4,3,4])一样，可以传递个数实参混合使用：
def test(x,*args):
print(x)
print(args)
test(1,[3,4],4,3,4)字典参数：把N个关键字参数转换为字典
def test(**kwargs):
print(kwargs)
print(kwargs["name"])
print(kwargs["age"])
test(name="tone",age=23)
test(**{"name":"tone","age":23})大混合模式：
def test(name,age,height=120,*args,**kwargs):
print(name)
print(age)
print(height)
print(args)
print(kwargs)
test("tone",23,height=180,sex="M",hobby="basketball")
7、 作用域、局部变量和全局变量
程序是按顺序执行的，所以定义的函数、过程最好放在最前面
例子程序1：
定义的函数中可以调用全局变量。
def change_name(name):
print("before change ",name)
name="Alex" #name为局部变量，只在函数中生效即作用域为本函数体
print("after change",name)
name="alex" #name为全局变量，整个程序中都生效
change_name(name)
print(name) #打印的结果仍为全局变量的值
执行结果：
C:\Python35\python3.exe D:/python_file/day3/test1.py
before change alex
after change Alex
alex
局部变量默认无法改全局变量的内容，除非使用global强制声明，如：globalname
例子程序2：
列表、字典、集合、类在子程序即函数中修改局部变量就会影响全局变量，如：
def change_name(name):
print("inside function ",name)
name[0]="Alex"
names=["alex","tone","tom"]
change_name(names)
print(names)
执行结果：
C:\Python35\python3.exe D:/python_file/day3/test1.py
inside function ['alex', 'tone','tom']
['Alex', 'tone', 'tom']
当全局变量与局部变量重名时，在定义局部变量的子程序内，局部变量起作用，在其他程序中全局变量起作用。
8、 递归：在函数内部，可以调用其它函数，如果一个函数在内部调用自身，这个函数就是递归函数。
递归函数的特性：
必须要有一个明确的结束条件；（否则是死循环，程序默认保护机制循环999，然后报错）
每次进入更深一层递归时，问题规模相比上次递归都应有所减少；
递归效率不够，递归层次过多会导致栈溢出；
def calc(n):
print(n)
if int(n)>1:
return calc(int(n/2))
print("---->",n)
calc(10)
9、 eo
函数式编程介绍
python对函数式编程只支持一部分
函数式编程语言有：erlang\lisp\hashshell
函数式编程举例，想要实现(1+2)*3-4，函数式编程：
varresult=subtract(multiply(add(1,2),3),4)
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就叫高阶函数。
abs是内置函数，取一个数的绝对值：
def add(x,y,f):
return f(x)+f(y)
res=add(3,-6,abs)
print(res)
