码迷,mamicode.com
首页 > 编程语言 > 详细

python_字符_函数

时间:2017-06-02 23:58:52      阅读:485      评论:0      收藏:0      [点我收藏+]

标签:位置   删除   文件处理   方法   i/o   else   限制   表示   初始化   

一、字符集和字符编码

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
{}

 

python_字符_函数

标签:位置   删除   文件处理   方法   i/o   else   限制   表示   初始化   

原文地址:http://www.cnblogs.com/MR-HAIBO/p/6935515.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!