python_字符_函数

Posted 2020-09-21

一、字符集和字符编码

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 = f.read()# 读取剩下的所有内容,文件大时不要用
print(data) #打印读取内容
f.close() #关闭文件

 

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 = file.read()
file.close()

这里有两个问题。一是可能忘记关闭文件句柄；二是文件读取数据发生异常，没有进行任何处理。

然而with可以很好的处理上下文环境产生的异常。下面是with版本的代码：

with open("/tmp /foo.txt") as file:
    data = 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
{}