python之day3(文件操作、字符转

文件操作

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)