Python 第三天学习整理①

今天学习的内容包括以下几个方面：1.字符编码 2.文件操作 3.函数

1.字符编码

关于字符编码，关注以下几个点

1.1 什么是字符编码

字符编码：字符转化为数字的过程所遵循的标准

字符编码包括：unicode，gbk，utf-8等。

字符编码的核心原则：保持存取一致

1.2 字符编码的发展史

阶段一：现代计算机起源于美国，最早诞生也是基于英文考虑的ASCII

　　ASCII:一个Bytes代表一个字符（英文字符/键盘上的所有其他字符），1Bytes=8bit，8bit可以表示0-2**8-1种变化，即可以表示256个字符

　　　　ASCII最初只用了后七位，127个数字，已经完全能够代表键盘上所有的字符了（英文字符/键盘的所有其他字符）

　　　　后来为了将拉丁文也编码进了ASCII表，将最高位也占用了

阶段二:为了满足中文，中国人定制了GBK

　　GBK:2Bytes代表一个字符

　　为了满足其他国家，各个国家纷纷定制了自己的编码

　　日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里

阶段三：各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。

于是产生了unicode，　统一用2Bytes代表一个字符，　2**16-1=65535，可代表6万多个字符，因而兼容万国语言

但对于通篇都是英文的文本来说，这种编码方式无疑是多了一倍的存储空间（二进制最终都是以电或者磁的方式存储到存储介质中的）

于是产生了UTF-8，对英文字符只用1Bytes表示，对中文字符用3Bytes

需要强调的一点是：

unicode：简单粗暴，所有字符都是2Bytes，优点是字符->数字的转换速度快，缺点是占用空间大

utf-8：精准，对不同的字符用不同的长度表示，优点是节省空间，缺点是：字符->数字的转换速度慢，因为每次都需要计算出字符需要多长的Bytes才能够准确表示

　　　　

1. 内存中使用的编码是unicode，用空间换时间（程序都需要加载到内存才能运行，因而内存应该是尽可能的保证快）
2. 硬盘中或者网络传输用utf-8，网络I/O延迟或磁盘I/O延迟要远大与utf-8的转换延迟，而且I/O应该是尽可能地节省带宽，保证数据传输的稳定性。

ps:用户态和内核态，表示cpu的两种运行状态，内核态具有对操作系统的所有权限。

ps:所有进程都跑在内存中，存数据其实是把内存中的数据刷到硬盘上，硬盘上不存在修改这么一说，都是重写。

ps:pycharm和普通的文本编辑器在从硬盘读取数据到内存中时，是没有任何区别的，只有在pycharm在对读取到内存中的数据执行编译的时候才有区别，这是他的特有功能。

2. 文件操作

对文件进行一系列的读写的操作。

2.1 文件处理流程

1.打开文件，得到文件句柄，并赋值给一个变量

2.通过句柄文件进行操作

3.关闭文件

1 #/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 f = open('a.txt','r',encoding='utf-8') #打开文件，字符编码是utf-8，只读
5 data = f.read()  #读取文件内所有内容，赋值给data
6 f.close()  # 关闭文件，一般读写完成后都要关闭文件

2.2 文件打开模式

1 #/usr/bin/env python
2 # -*- coding:utf-8 -*-
3
4 f = open('打开的文件名','打开文件的模式')

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

• r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
• w，只写模式【不可读；不存在则创建；存在则清空内容】
• x， 只写模式【不可读；不存在则创建，存在则报错】
• a， 追加模式【可读；   不存在则创建；存在则只追加内容】

"+" 表示可以同时读写某个文件

• r+， 读写【可读，可写】
• w+，写读【可读，可写】
• x+ ，写读【可读，可写】
• a+， 写读【可读，可写】

"b"表示以字节的方式操作

• rb  或 r+b
• wb 或 w+b
• xb 或 w+b
• ab 或 a+b

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

2.3 文件内光标移动

注意：read(3)代表读取3个字符，其余的文件内光标移动都是以字节为单位如seek，tell，read，truncate

1 #/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 f = open('a.txt','r',encoding='utf-8')
4 f.seek(0,0) #表示从开始读取
5 f.seek(0,1) #表示从当前位置开始读取
6 f.seek(0,2) #表示从文件结尾
7 data = f.readline()
8 f.close()

ps:seek()代表一次移动几个字节，如果是用b模式打开，seek()里面可以有负数，例如seek(-1,2)

2.4 open函数语法详解

1. open()语法

open(file[, mode[, buffering[, encoding[, errors[, newline[, closefd=True]]]]]])
open函数有很多的参数，常用的是file，mode和encoding
file文件位置，需要加引号
mode文件打开模式，见下面3
buffering的可取值有0，1，>1三个，0代表buffer关闭（只适用于二进制模式），1代表line buffer（只适用于文本模式），>1表示初始化的buffer大小；
encoding表示的是返回的数据采用何种编码，一般采用utf8或者gbk；
errors的取值一般有strict，ignore，当取strict的时候，字符编码出现问题的时候，会报错，当取ignore的时候，编码出现问题，程序会忽略而过，继续执行下面的程序。
newline可以取的值有None, \n, \r, ”, ‘\r\n'，用于区分换行符，但是这个参数只对文本模式有效；
closefd的取值，是与传入的文件参数有关，默认情况下为True，传入的file参数为文件的文件名，取值为False的时候，file只能是文件描述符，什么是文件描述符，就是一个非负整数，在Unix内核的系统中，打开一个文件，便会返回一个文件描述符。

2. Python中file()与open()区别
两者都能够打开文件，对文件进行操作，也具有相似的用法和参数，但是，这两种文件打开方式有本质的区别，file为文件类，用file()来打开文件，相当于这是在构造文件类，而用open()打开文件，是用python的内建函数来操作，建议使用open

3. 参数mode的基本取值

Character	Meaning
‘r'	open for reading (default)
‘w'	open for writing, truncating the file first
‘a'	open for writing, appending to the end of the file if it exists
‘b'	binary mode
‘t'	text mode (default)
‘+'	open a disk file for updating (reading and writing)
‘U'	universal newline mode (for backwards compatibility; should not be used in new code)

r、w、a为打开文件的基本模式，对应着只读、只写、追加模式；
b、t、+、U这四个字符，与以上的文件打开模式组合使用，二进制模式，文本模式，读写模式、通用换行符，根据实际情况组合使用、

常见的mode取值组合

#/usr/bin/env python
# -*- coding:utf-8 -*-
r或rt 默认模式，文本模式读
rb   二进制文件

w或wt 文本模式写，打开前文件存储被清空
wb  二进制写，文件存储同样被清空

a  追加模式，只能写在文件末尾
a+ 可读写模式，写只能写在文件末尾

w+ 可读写，与a+的区别是要清空文件内容
r+ 可读写，与a+的区别是可以写到文件任何位置

2.5 文件操作一些方法

 1 #/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 f = open('a','r',encoding='utf-8')
 4 data = f.read() #全部读取，文件过大不建议使用这个
 5 data = f.readline() #读取一行，光标移动到下一行
 6 data = f.readlines() #全部读取，列表形式
 7 print(f.close) # 文件是否关闭，返回True 或者False
 8 print(f.name) # 返回文件的名字
 9 print(f.readable) # 是否可读，返回True 或者 False
10 print(f.tell()) # 返回光标的位置
11 print(f.wirteable) # 文件是否可写，返回True 或者False
12 f.close()

2.6 上下文管理

不用关闭文件，自动帮你管理

1 with open('a.txt','w') as f:
2     pass
3
4 with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
5     data=read_f.read()
6     write_f.write(data)

2.7 文件的修改

 1 import os
 2 with open('a.txt','r',encoding='utf-8') as read_f,\
 3         open('.a.txt.swap','w',encoding='utf-8') as write_f:
 4     for line in read_f:
 5         if line.startswith('hello'):
 6             line='厉害了,我的哥\n'
 7         write_f.write(line)
 8
 9 os.remove('a.txt')
10 os.rename('.a.txt.swap','a.txt')

3 函数

首先，为什么要使用函数呢，因为函数有以下好处：

1.代码重用

2.保持一致性，易维护

3.可扩展性

在python中 函数是什么呢，函数就相当于一些工具，因此，我们所知道的内置函数，就相当于python提供给我们的便利的使用工具，不需要在去具体写，例如max(2,3),就可以很方便的得出谁最大，这样是很便利的，但是python提供的方法呢，并不能够满足我们的所有需求，所以，我们可以自定义函数。因此有了自定义函数。

3.1 函数分类

内置函数和自定义函数

3.2 函数和过程

过程定义：过程就是简单特殊没有返回值的函数

这么看来我们在讨论为何使用函数的的时候引入的函数，都没有返回值，没有返回值就是过程，没错，但是在python中有比较神奇的事情

 1 def test01():
 2     msg='hello The little green frog'
 3     print msg
 4
 5 def test02():
 6     msg='hello WuDaLang'
 7     print msg
 8     return msg
 9
10
11 t1=test01()
12
13 t2=test02()
14
15
16 print 'from test01 return is [%s]' %t1
17 print 'from test02 return is [%s]' %t2

ps:函数None的三种情况：

1.不写return 默认返回None

2.return 默认返回None

3.return None 返回None

ps:函数有些可以不写返回值，如果只是做一些操作，例如print操作结果之类的，有些则需要返回值，比如像比大小一些功能，则需要返回值。

3.3 函数参数

函数参数的分类：无参函数(一般不需要传参数的操作)，位置参数，关键字参数，可变长参数

1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

3.3.1 无参函数

无参函数，顾名思义，就是函数没有传入参数

1 def foo():

2 print('这是个无参函数')# 这个函数只是执行打印的功能，不需要传入参数

3.3.2 位置参数

直接上代码

1 def foo(x,y,z):
2   res = x+y+z
3   return res
4
5 foo(1,2,3) #调用foo()函数
6   

ps:形参没有一一对应这个概念，只有实参才有一一对应这个概念，对应形参。

3.3.3 关键字参数

直接上代码

1 def foo(x,y):
2   res = x+y
3   return res
4
5 print(foo(x=1,y=2)) 

ps:关键字参数位置无需固定

ps:传参的时候一般先是位置参数，如果有默认参数则跟在位置参数后边

3.3.4 可变长参数

直接上代码

def foo(*args):
   for i in args:
     res += i return res

print(foo(1,2,3,4,5,6,7,8))

def foo2(**kwargs):
   print(kwargs)

foo2(x=1,y=2,c=3,b=4,k=8)  

def foo3(*args,**kwargs):
  print(args)
  print(kwargs)

foo3(1,2,3,x=6,y=7,b=8)

ps:foo(*[1,2,3,4,5])  <=============>foo(1,2,3,4,5) 只要是*，全部打散了转化成位置参数

ps:foo(**{'x':1,'y':2}) <=============>foo(x=1,y=2) 只要是**，全部转化成关键字参数

3.3.5 解压

a,_,b = (1,2,3,)
print(a)
print(b) # 只输出 a 和 b _ 相当于占位

c,*_,d = (1,2,3,4,5,6,7,8,9)
print(c)
print(d) #只输出c 和 d 

3.3.6 函数的使用方式

1.当成语句使用

2.当表达式使用

3.当作参数使用(嵌套)

def foo(x,y):
   res = x if x > y else y
   return res

b = foo(2,5)

a = foo(2,5)**2 #表达式使用

b = foo(foo(2,5),8) #当作参数使用

ps:空函数，据说很有用

 1 def select():
 2    pass
 3
 4 def insert():
 5    pass
 6
 7 def update():
 8    pass
 9
10 def delete():
11    pass