首页 > 代码库 > python_字符_函数
python_字符_函数
一、字符集和字符编码
1.定义
计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果。通俗的说，按照何种规则将字符存储在计算机中，如‘a‘用什么表示，称为"编码"；反之，将存储在计算机中的二进制数解析显示出来，称为"解码"，如同密码学中的加密和解密。在解码过程中，如果使用了错误的解码规则，则导致‘a‘解析成‘b‘或者乱码。
字符（Character）：是一个信息单位，在计算机里面，一个中文汉字是一个字符，一个英文字母是一个字符，一个阿拉伯数字是一个字符，一个标点符号也是一个字符。
字符集（Charset）：是一个系统支持的所有抽象字符的集合。通常以二维表的形式存在，二维表的内容和大小是由使用者的语言而定，可以是英语，是汉语，或者阿拉伯语。
字符编码（Character Encoding）：是一套法则，使用该法则能够对自然语言的字符的一个集合（如字母表或音节表），与其他东西的一个集合（如号码或电脉冲）进行配对。在这里我们把字符集中的字符编码为特定的二进制数，以便在计算机中存储。编码方式一般就是对二维表的横纵坐标进行变换的算法。即在符号集合与数字系统之间建立对应关系，它是信息处理的一项基本技术。即：字符--------（翻译过程）------->二进制数
2.常用的字符集和字符编码
字符集和字符编码一般都是成对出现的，如ASCII、GBK、Unicode、UTF-8等，都是即表示了字符集又表示了对应的字符编码，以后统称为编码。
3.字符编码的发展史
第一阶段：起源，ASCII
计算机是美国人发明的，人家用的是美式英语，字符比较少，所以一开始就设计了一个不大的二维表，128个字符，取名叫ASCII（American Standard Code for Information Interchange）。但是7位编码的字符集只能支持128个字符，为了表示更多的欧洲常用字符对ASCII进行了扩展，ASCII扩展字符集使用8位（bits）表示一个字符，共256字符。即其最多只能用 8 位来表示（一个字节）。
第二阶段：GBK
当计算机传到了亚洲，尤其是东亚，国际标准被秒杀了，路边小孩随便说句话，256个码位就不够用了。于是，中国定制了GBK。用2个字节代表一个字符（汉字）。其他国家也纷纷定制了自己的编码，例如：
日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里。
第三阶段：unicode
当互联网席卷了全球，地域限制被打破了，不同国家和地区的计算机在交换数据的过程中，就会出现乱码的问题，跟语言上的地理隔离差不多。为了解决这个问题，一个伟大的创想产生了——Unicode（万国码）。Unicode编码系统为表达任意语言的任意字符而设计。
规定所有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536，注：此处说的的是至少2个字节（16位），可能更多。
第四阶段：UTF-8
unicode的编码方式虽然包容万国，但是对于英文等字符就会浪费太多存储空间。于是出现了UTF-8，是对Unicode编码的压缩和优化，遵循能用最少的表示就用最少的表示，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存。
补充：
unicode：包容万国，优点是字符->数字的转换速度快，缺点是占用空间大 utf-8：精准，对不同的字符用不同的长度表示，优点是节省空间，缺点是：字符->数字的转换速度慢，因为每次都需要计算出字符需要多长的Bytes才能够准确表示
内存中使用的编码是unicode，用空间换时间，为了快
因为程序都需要加载到内存才能运行，因而内存应该是尽可能的保证快。
硬盘中或者网络传输用utf-8，网络I/O延迟或磁盘I/O延迟要远大与utf-8的转换延迟，而且I/O应该是尽可能地节省带宽，保证数据传输的稳定性。
因为数据的传输，追求的是稳定，高效，数据量越小数据传输就越靠谱，于是都转成utf－8格式的，而不是unicode。
如下图：
4.字符编码的使用
1）文本编辑器存取文件的原理（nodepad++，pycharm，word）
打开编辑器就打开了启动了一个进程，是在内存中的，所以在编辑器编写的内容也都是存放与内存中的，断电后数据丢失。因而需要保存到硬盘上，点击保存按钮，就从内存中把数据刷到了硬盘上。在这一点上，我们编写一个py文件（没有执行），跟编写其他文件没有任何区别，都只是在编写一堆字符而已。
无论是何种编辑器，要防止文件出现乱码，核心法则就是，文件以什么编码保存的，就以什么编码方式打开。
2）python解释器执行py文件的原理 （python test.py）
第一阶段：python解释器启动，此时就相当于启动了一个文本编辑器
第二阶段：python解释器相当于文本编辑器，去打开test.py文件，从硬盘上将test.py的文件内容读入到内存中
第三阶段：python解释器解释执行刚刚加载到内存中test.py的代码
补充：
所以，在写代码时，为了不出现乱码，推荐使用UTF-8，会加入 # -*- coding: utf-8 -*-
即
#!/usr/bin/env python # -*- coding: utf-8 -*- print "你好，世界"
python解释器会读取test.py的第二行内容，# -*- coding: utf-8 -*-，来决定以什么编码格式来读入内存，这一行就是来设定python解释器这个软件的编码使用的编码格式这个编码。
如果不在python文件指定头信息＃-*-coding:utf-8-*-,那就使用默认的python2中默认使用ascii，python3中默认使用utf-8
总结：
1）python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样
2）与文本编辑器不一样的地方在于，python解释器不仅可以读文件内容，还可以执行文件内容
5.python2和python3的一些不同
1) python2中默认使用ascii，python3中默认使用utf-8
2) Python2中，str就是编码后的结果bytes，str=bytes,所以s只能decode。
3) python3中的字符串与python2中的u‘字符串‘，都是unicode，只能encode，所以无论如何打印都不会乱码，因为可以理解为从内存打印到内存，即内存->内存，unicode->unicode
4) python3中，str是unicode，当程序执行时，无需加u，str也会被以unicode形式保存新的内存空间中,str可以直接encode成任意编码格式，s.encode(‘utf-8‘)，s.encode(‘gbk‘)
#unicode(str)-----encode---->utf-8(bytes) #utf-8(bytes)-----decode---->unicode
5)在windows终端编码为gbk，linux是UTF-8.
二、文件操作
1.文件处理的流程
1）打开文件，得到文件句柄并赋值给一个变量
2）通过句柄对文件进行操作
3）关闭文件
例如：
f = open(‘chenli.txt‘) #打开文件 first_line = f.readline() print(‘first line:‘,first_line) #读一行 data = http://www.mamicode.com/f.read()# 读取剩下的所有内容,文件大时不要用>
2.文件操作基本用法
1）基本用法：
file_object = open(file_name, access_mode = ‘r’, buffering = -1)
open函数有很多的参数，常用的是file_name，mode和encoding
file_name:打开的文件名,若非当前路径，需指出具体路径
access_mode文件打开模式
buffering的可取值有0，1，>1三个，0代表buffer关闭（只适用于二进制模式），1代表line buffer（只适用于文本模式），>1表示初始化的buffer大小；
encoding表示的是返回的数据采用何种编码，一般采用utf8或者gbk；
2)文件打开模式
- r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
- w，只写模式【不可读；不存在则创建；存在则清空内容】
- x， 只写模式【不可读；不存在则创建，存在则报错】
- a， 追加模式【可读； 不存在则创建；存在则只追加内容】，文件指针自动移到文件尾。
"+" 表示可以同时读写某个文件
- r+， 读写【可读，可写】
- w+，写读【可读，可写】，消除文件内容，然后以读写方式打开文件。
- x+ ，写读【可读，可写】
- a+， 写读【可读，可写】，以读写方式打开文件，并把文件指针移到文件尾。
"b"表示以字节的方式操作，以二进制模式打开文件，而不是以文本模式。
- rb 或 r+b
- wb 或 w+b
- xb 或 w+b
- ab 或 a+b
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码
3）以读r的方式打开文件
#!/usr/bin/env python # -*- coding:utf-8 -*- f=open(‘1.txt‘,encoding=‘utf-8‘,mode=‘r‘) print(f) data1=f.read() print(data1)
1.txt
55542342 123
输出：
<_io.TextIOWrapper name=‘1.txt‘ mode=‘r‘ encoding=‘utf-8‘> 55542342 123
补充：
1）python中有三个方法来处理文件内容的读取： read() #一次读取全部的文件内容。 readline() #每次读取文件的一行。 readlines() #读取文件的所有行，返回一个字符串列表。 2）print(f.readable()) #判断文件是否是r模式打开的
3）print(f.closed) #判断文件是否是关闭状态
4）python中在文本文件内容移动的操作 file.seek(offset,whence=0) #从文件中给移动指针，从whence(0起始，1当前，2末尾)偏移offset个字节，正往结束方向移动，负往开始方向移动 file.tell() #返回当前文件中的位置。获得文件指针位置
5） file.truncate(size=file.tell()) #截取文件到最大size个字节，默认为当前文件位置
4）以w方式写入文件
f=open(‘a.txt‘,‘w‘,encoding=‘utf-8‘) # f=open(‘b.txt‘,‘r‘,encoding=‘utf-8‘) #以读的方式打开文件，文件不存在则报错 f=open(‘b.txt‘,‘w‘,encoding=‘utf-8‘) # print(f.writable()) f.write(‘111111\n22222222‘) f.seek(0) f.write(‘\n333333\n444444‘) f.writelines([‘\n55555\n‘,‘6666\n‘,‘77777\n‘]) f.close()
a.txt 为空
b.txt
333333 444444 55555 6666 77777
补充：
file.write(str) #向文件中写入字符串(文本或二进制) file.writelines(seq) #写入多行，向文件中写入一个字符串列表，注意，要自己加入每行的换行符 file.flush() #刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入.
5）文件修改
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
read_f=open(‘b.txt‘,‘r‘)
write_f=open(‘.b.txt.swap‘,‘w‘)
for line in read_f.readlines():
if line.startswith(‘1111‘):
line=‘2222222222\n‘
write_f.write(line)
read_f.close()
write_f.close()
os.remove(‘b.txt‘)
os.rename(‘.b.txt.swap‘,‘b.txt‘)
3.上下文管理with语句
当你做文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。
正常情况下，代码如下：
file = open("/tmp/foo.txt")
data = http://www.mamicode.com/file.read()>
这里有两个问题。一是可能忘记关闭文件句柄；二是文件读取数据发生异常，没有进行任何处理。
然而with可以很好的处理上下文环境产生的异常。下面是with版本的代码：
with open("/tmp /foo.txt") as file:
data = http://www.mamicode.com/file.read()
with的基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。
补充：
模拟 tail -f access.log
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# tail -f access.log
import time
with open(‘access.log‘,‘r‘,encoding=‘utf-8‘) as f:
f.seek(0,2)
while True:
line=f.readline().strip()
if line:
print(‘新增一行日志‘,line)
time.sleep(0.5)
三、函数
1.什么是函数？
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率，可扩展性强。
2.函数的分类
在python中函数分两类：内置函数，自定义函数
1）内置函数
python本身自己定义的函数，可直接调用
sum max min a=len(‘hello‘) print(a) b=max([1,2,3]) print(b)
2）自定义函数
自己根据需求，按照函数定义方法去自定函数
3.函数的定义
1)为什么要定义函数？
先定义后使用，如果没有定义而直接使用，就相当于引用了一个不存在的变量名
函数的使用包含两个阶段：定义阶段和使用阶段
注：定义函数，只检测语法，不执行代码
2)函数定义的语法
def functionname( parameters ): "函数_文档字符串" function_suite return [expression]
例如：
def printme( str ):
print str
return
3）定义函数的三种形式
#一：无参数函数：如果函数的功能仅仅只是执行一些操作而已，就定义成无参函数，无参函数通常没有返回值
def print_star():
print(‘#‘*6)
#二：定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数通常都有返回值
# def my_max(x,y):
# res=x if x >y else y
# return res
# 三元表达式
x=10
y=2
# if x > y:
# print(x)
# else:
# print(y)
#
res=x if x > y else y print(res)
#三：空函数
在一开始思考代码架构时，可以先把扩展功能写下来，后期完善
# def auth(): # """认证功能""" # pass # auth() def insert(): """插入功能""" pass def select(): """查询功能""" pass def delete(): """删除功能""" pass def update(): """更新功能""" pass
4）函数的调用
def foo():
print(‘from foo‘)
def bar(name):
print(‘bar===>‘,name)
#按照有参和无参可以将函数调用分两种
foo() #定义时无参，调用时也无需传入参数
bar(‘egon‘) #定义时有参，调用时也必须有参数
#按照函数的调用形式和出现的位置，分三种
foo() #调用函数的语句形式
def my_max(x,y):
res=x if x >y else y
return res
# res=my_max(1,2)*10000000 #调用函数的表达式形式
# print(res)
res=my_max(my_max(10,20),30) #把函数调用当中另外一个函数的参数
print(res)
5）函数的参数
函数的参数分两种：形参(变量名)，实参（值）
#定义阶段 def foo(x,y): #x=1,y=2 print(x) print(y) #调用阶段 foo(1,2)
详细的区分函数的参数分为五种：
位置参数，关键字参数，默认参数，可变长参数（*args，**kwargs）,命名关键字参数
- 位置参数
def foo(x,y,z):#位置形参:必须被传值的参数
print(x,y,z)
foo(1,2,3) #位置实参数：与形参一一对应
输出：
1 2 3
- 关键字参数
def foo(x,y,z):
print(x,y,z)
foo(z=3,x=1,y=2)
#关键字参数需要注意的问题：
# 1：关键字实参必须在位置实参后面
# 2: 不能重复对一个形参数传值
# foo(1,z=3,y=2) #正确
# foo(x=1,2,z=3) #错误
# foo(1,x=1,y=2,z=3)
- 默认参数
# def register(name,age,sex=‘male‘): #形参：默认参数 # print(name,age,sex) # # register(‘asb‘,age=40) # register(‘a1sb‘,39) # register(‘a2sb‘,30) # register(‘a3sb‘,29) # # register(‘钢蛋‘,20,‘female‘) # register(‘钢蛋‘,sex=‘female‘,age=19) #默认参数需要注意的问题： #一：默认参数必须跟在非默认参数后 # def register(sex=‘male‘,name,age): #在定义阶段就会报错 # print(name,age,sex) #（了解）二：默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次 # a=100000000 # def foo(x,y=a): # print(x,y) # a=0 # foo(1) #三：默认参数的值通常定义成不可变类型
- 可变长参数
*args *会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
def foo(x,y,*args): #*会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
print(x,y)
print(args)
#
foo(1,2,3,4,5)
例如：
# def add(*args): # res=0 # for i in args: # res+=i # return res # print(add(1,2,3,4)) # print(add(1,2))
输出：
10 3
**kwargs **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
# def foo(x, y, **kwargs): # **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs # print(x, y) # print(kwargs) # foo(1,2,a=1,name=‘egon‘,age=18)
例如：
def foo(name,age,**kwargs):
print(name,age)
if ‘sex‘ in kwargs:
print(kwargs[‘sex‘])
if ‘height‘ in kwargs:
print(kwargs[‘height‘])
foo(‘egon‘,18,sex=‘male‘,height=‘185‘)
foo(‘egon‘,18,sex=‘male‘)
输出：
egon 18 male 185 egon 18 male
foo(*[1,2,3]) #foo(1,2,3)
foo(**{‘x‘:1,‘b‘:2} #foo(x=1,b=2)
- 命名关键字参数
# def foo(name,age,*,sex=‘male‘,height): # print(name,age) # print(sex) # print(height) # #*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值 # foo(‘egon‘,17,height=‘185‘)
例如
def foo(x,y,z):
print(‘from foo‘,x,y,z)
def wrapper(*args,**kwargs):
print(args) #args=(1,2,3)
print(kwargs) #kwargs={‘a‘:1,‘b‘:2}
foo(*args,**kwargs) #foo(*(1,2,3),**{‘a‘:1,‘b‘:2}) #foo(1,2,3,b=2,a=1)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)
输出
(1,)
{‘z‘: 2, ‘y‘: 3}
from foo 1 3 2
6）函数的返回值
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
例如
def foo():
print(‘from foo‘)
return None
res=foo()
print(res)
输出
from foo None
补充：
以三种情况返回值都为None：
没有return return 什么都不写 return None
return 一个值 函数调用返回的结果就是这个值
def foo():
print(‘from foo‘)
x=1
return x
res=foo()
print(res)
输出：
from foo 1
return 值1,值2，值3,... 返回结果:(值1,值2，值3,...)
def foo():
print(‘from foo‘)
x=1
return 1,[2,3],(4,5),{}
res=foo()
print(res) #打印结果：(1,[2,3],(4,5),{})
a,b,c,d=foo()
print(d)
输出：
from foo
(1, [2, 3], (4, 5), {})
from foo
{}
python_字符_函数