编程语言与Python学习（二）

1.1 流程控制之for循环

1 迭代式循环：for，语法如下　

for i in range(10):

　　　　缩进的代码块

2 break与continue（同上）

3 循环嵌套

for i in range(1,10):

    for j in range(1,i+1):

        print('%s*%s=%s' %(i,j,i*j),end=' ')

    print()

for+else

1.2 开发工具IDE

1.2.1 为何要用IDE

到现在为止，我们也是写过代码的人啦，但你有没有发现，每次写代码要新建文件、写完保存时还要选择存放地点，执行时还要切换到命令行调用python解释器，好麻烦呀，能否一气呵成，让我简单的写代码？此时开发工具IDE上场啦，一个好的IDE能帮你大大提升开发效率。

很多语言都有比较流行的开发工具，比如JAVA 的Eclipse, C#,C++的VisualStudio, Python的是啥呢？ Pycharm，最好的Python 开发IDE

1.2.2 安装

下载地址:https://www.jetbrains.com/pycharm/download 选择Professional 专业版

Comunnity社区版是免费的，但支持的功能不多，比如以后我们会学的Django就不支持，所以还是用专业版，但专业版是收费的，一年一千多，不便宜。唉，万能的淘宝。。。不宜再多说啦。

注册完成后启动，会让你先创建一个项目，其实就是一个文件夹，我们以后的代码都存在这里面

图1-1

1.2.3 创建目录

你以后写的项目可能有成百上千个代码文件 ，全放在一起可不好，所以一般把同样功能的代码放在一个目录，我们现在以天为单位，为每天的学习创建一个目录day1,day2,day3...这样

图1-2

1.2.4 创建代码文件

图1-3

1.2.5 执行代码

图1-4

1.3 数据

1.3.1 什么是数据？

　　x=10，10是我们要存储的数据

1.3.2 为何数据要分不同的类型

　　数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

1.3.3 数据类型

l  数字（整形，长整形，浮点型，复数）

l  字符串

l  字节串：在介绍字符编码时介绍字节bytes类型

l  列表

l  元组

l  字典

l  集合

1.4 数字

整型与浮点型

复制代码

#整型int

　　作用：年纪，等级，身份证号，qq号等整型数字相关

　　定义：

　　　　age=10 #本质age=int(10)

#浮点型float

　　作用：薪资，身高，体重，体质参数等浮点数相关

salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制

复制代码

其他数字类型（了解）

复制代码

#长整形（了解）

在python2中（python3中没有长整形的概念）：　　　　　　

   >>> num=2L

    >>> type(num)

    <type 'long'>

1.5 字符串

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\双引号\三引号内，由一串字符组成

name='egon'

#优先掌握的操作：

#1、按索引取值(正向取+反向取) ：只能取

#2、切片(顾头不顾尾，步长)

#3、长度len

#4、成员运算in和not in

#5、移除空白strip

#6、切分split

#7、循环

1.5.1 需要掌握的操作

复制代码

#1、strip,lstrip,rstrip

#2、lower,upper

#3、startswith,endswith

#4、format的三种玩法

#5、split,rsplit

#6、join

#7、replace

#8、isdigit

#strip

name='*egon**'

print(name.strip('*'))

print(name.lstrip('*'))

print(name.rstrip('*'))

#lower,upper

name='egon'

print(name.lower())

print(name.upper())

#startswith,endswith

name='alex_SB'

print(name.endswith('SB'))

print(name.startswith('alex'))

#format的三种玩法

res='{} {} {}'.format('egon',18,'male')

res='{1} {0} {1}'.format('egon',18,'male')

res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

#split

name='root:x:0:0::/root:/bin/bash'

print(name.split(':')) #默认分隔符为空格

name='C:/a/b/c/d.txt' #只想拿到顶级目录

print(name.split('/',1))

name='a|b|c'

print(name.rsplit('|',1)) #从右开始切分

#join

tag=' '

print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串

#replace

name='alex say :i have one tesla,my name is alex'

print(name.replace('alex','SB',1))

#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法

age=input('>>: ')

print(age.isdigit())

1.6 列表

#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔

my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])

或

l=list('abc')

#优先掌握的操作：

#1、按索引存取值(正向存取+反向存取)：即可存也可以取

#2、切片(顾头不顾尾，步长)

#3、长度

#4、成员运算in和not in

#5、追加

#6、删除

#7、循环

#ps:反向步长

l=[1,2,3,4,5,6]

#正向步长

l[0:3:1] #[1, 2, 3]

#反向步长

l[2::-1] #[3, 2, 1]

#列表翻转

l[::-1] #[6, 5, 4, 3, 2, 1]

1.7 元组

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()

age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

#优先掌握的操作：

#1、按索引取值(正向取+反向取)：只能取

#2、切片(顾头不顾尾，步长)

#3、长度

#4、成员运算in和not in

#5、循环

#简单购物车,要求如下：

实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic={

'apple':10,

'tesla':100000,

'mac':3000,

'lenovo':30000,

'chicken':10,

}

msg_dic={

'apple':10,

'tesla':100000,

'mac':3000,

'lenovo':30000,

'chicken':10,

}

goods_l=[]

while True:

    for key,item in msg_dic.items():

        print('name:{name} price:{price}'.format(price=item,name=key))

    choice=input('商品>>: ').strip()

    if not choice or choice not in msg_dic:continue

    count=input('购买个数>>: ').strip()

    if not count.isdigit():continue

    goods_l.append((choice,msg_dic[choice],count))

    print(goods_l)

1.8 字典

#作用：存多个值,key-value存取，取值速度

#定义：key必须是不可变类型，value可以是任意类型

info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})

或

info=dict(name='egon',age=18,sex='male')

或

info=dict([['name','egon'],('age',18)])

或

{}.fromkeys(('name','age','sex'),None)

#优先掌握的操作：

#1、按key存取值：可存可取

#2、长度len

#3、成员运算in和not in

#4、删除

#5、键keys()，值values()，键值对items()

#6、循环

1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

a={'k1':[],'k2':[]}

c=[11,22,33,44,55,66,77,88,99,90]

for i in c:

    if i>66:

        a['k1'].append(i)

    else:

        a['k2'].append(i)

print(a)

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

s='hello alex alex say hello sb sb'

l=s.split()

dic={}

for item in l:

    if item in dic:

        dic[item]+=1

    else:

        dic[item]=1

print(dic)

s='hello alex alex say hello sb sb'

dic={}

words=s.split()

print(words)

for word in words: #word='alex'

    dic[word]=s.count(word)

    print(dic)

#利用setdefault解决重复赋值

'''

setdefault的功能

1：key存在，则不赋值，key不存在则设置默认值

2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值

d={}

print(d.setdefault('a',1)) #返回1

d={'a':2222}

print(d.setdefault('a',1)) #返回2222

'''

s='hello alex alex say hello sb sb'

dic={}

words=s.split()

for word in words: #word='alex'

    dic.setdefault(word,s.count(word))

    print(dic)

#利用集合，去掉重复，减少循环次数

s='hello alex alex say hello sb sb'

dic={}

words=s.split()

words_set=set(words)

for word in words_set:

    dic[word]=s.count(word)

    print(dic)

1.9 集合

#作用：去重，关系运算，

#定义：

知识点回顾

可变类型是不可hash类型

不可变类型是可hash类型

#定义集合:

集合：可以包含多个元素，用逗号分割，

集合的元素遵循三个原则：

1：每个元素必须是不可变类型(可hash，可作为字典的key)

2:没有重复的元素

3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

优先掌握的操作：

#1、长度len

#2、成员运算in和not in

#3、|合集

#4、&交集

#5、-差集

#6、^对称差集

#7、==

#8、父集：>,>=

#9、子集：<,<=

.关系运算

　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合

　　pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}

　　linuxs={'wupeiqi','oldboy','gangdan'}

　　1. 求出即报名python又报名linux课程的学员名字集合

　　2. 求出所有报名的学生名字集合

　　3. 求出只报名python课程的学员名字

　　4. 求出没有同时这两门课程的学员名字集合

# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}

linuxs={'wupeiqi','oldboy','gangdan'}

# 求出即报名python又报名linux课程的学员名字集合

print(pythons & linuxs)

# 求出所有报名的学生名字集合

print(pythons | linuxs)

# 求出只报名python课程的学员名字

print(pythons - linuxs)

# 求出没有同时这两门课程的学员名字集合

print(pythons ^ linuxs)

去重

　　 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序

　　 2.在上题的基础上，保存列表原来的顺序

　　 3.去除文件中重复的行，肯定要保持文件内容的顺序不变

　　 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

l=[

    {'name':'egon','age':18,'sex':'male'},

    {'name':'alex','age':73,'sex':'male'},

    {'name':'egon','age':20,'sex':'female'},

    {'name':'egon','age':18,'sex':'male'},

    {'name':'egon','age':18,'sex':'male'},

]　　

#去重,无需保持原来的顺序

l=['a','b',1,'a','a']

print(set(l))

#去重,并保持原来的顺序

#方法一:不用集合

l=[1,'a','b',1,'a']

l1=[]

for i in l:

    if i not in l1:

        l1.append(i)

print(l1)

#方法二:借助集合

l1=[]

s=set()

for i in l:

    if i not in s:

        s.add(i)

        l1.append(i)

print(l1)

#同上方法二,去除文件中重复的行

import os

with open('db.txt','r',encoding='utf-8') as read_f,\

        open('.db.txt.swap','w',encoding='utf-8') as write_f:

    s=set()

    for line in read_f:

        if line not in s:

            s.add(line)

            write_f.write(line)

os.remove('db.txt')

os.rename('.db.txt.swap','db.txt')

#列表中元素为可变类型时,去重,并且保持原来顺序

l=[

    {'name':'egon','age':18,'sex':'male'},

    {'name':'alex','age':73,'sex':'male'},

    {'name':'egon','age':20,'sex':'female'},

    {'name':'egon','age':18,'sex':'male'},

    {'name':'egon','age':18,'sex':'male'},

]

# print(set(l)) #报错:unhashable type: 'dict'

s=set()

l1=[]

for item in l:

    val=(item['name'],item['age'],item['sex'])

    if val not in s:

        s.add(val)

        l1.append(item)

print(l1)

　　

#定义函数,既可以针对可以hash类型又可以针对不可hash类型

def func(items,key=None):

    s=set()

    for item in items:

        val=item if key is None else key(item)

        if val not in s:

            s.add(val)

            yield item

print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))

1.10 数据类型总结

按存储空间的占用分（从低到高）

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型       数字，字符串

容器类型            列表，元组，字典

按可变不可变区分

可变        列表，字典

不可变    数字，字符串，元组

按访问顺序区分

直接访问                  数字

顺序访问（序列类型）    字符串，列表，元组

key值访问（映射类型）  字典

1.11 运算符

身份运算（is ，is not）

is比较的是id，而双等号比较的是值

毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同

>>> x=1234567890

>>> y=1234567890

>>> x == y

True

>>> id(x),id(y)

(3581040, 31550448)

>>> x is y

False

1.12 字符编码

1.12.1 操作系统基础

图1-5

1.12.2 文本编辑器存取文件的原理（nodepad++，pycharm，word）

#1、打开编辑器就打开了启动了一个进程，是在内存中的，所以，用编辑器编写的内容也都是存放与内存中的，断电后数据丢失

#2、要想永久保存，需要点击保存按钮：编辑器把内存的数据刷到了硬盘上。

#3、在我们编写一个py文件（没有执行），跟编写其他文件没有任何区别，都只是在编写一堆字符而已。

1.12.3 python解释器执行py文件的原理 ，例如python test.py

#第一阶段：python解释器启动，此时就相当于启动了一个文本编辑器

#第二阶段：python解释器相当于文本编辑器，去打开test.py文件，从硬盘上将test.py的文件内容读入到内存中(小复习：pyhon的解释性，决定了解释器只关心文件内容，不关心文件后缀名)

#第三阶段：python解释器解释执行刚刚加载到内存中test.py的代码( ps：在该阶段，即真正执行代码时，才会识别python的语法，执行文件内代码，当执行到name="egon"时,会开辟内存空间存放字符串"egon")

1.12.4 总结python解释器与文件本编辑的异同

#1、相同点：python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样

#2、不同点：文本编辑器将文件内容读入内存后，是为了显示或者编辑，根本不去理会python的语法，而python解释器将文件内容读入内存后，可不是为了给你瞅一眼python代码写的啥，而是为了执行python代码、会识别python语法。

1.13 字符编码介绍

1.13.1 什么是字符编码

复制代码

　　计算机要想工作必须通电,即用‘电’驱使计算机干活,也就是说‘电’的特性决定了计算机的特性。电的特性即高低电平(人类从逻辑上将二进制数1对应高电平,二进制数0对应低电平)，关于磁盘的磁特性也是同样的道理。结论：计算机只认识数字

　　很明显，我们平时在使用计算机时，用的都是人类能读懂的字符（用高级语言编程的结果也无非是在文件内写了一堆字符），如何能让计算机读懂人类的字符？

　　必须经过一个过程：

　　#字符--------（翻译过程）------->数字

　　#这个过程实际就是一个字符如何对应一个特定数字的标准，这个标准称之为字符编码

以下两个场景下涉及到字符编码的问题：

#1、一个python文件中的内容是由一堆字符组成的，存取均涉及到字符编码问题（python文件并未执行，前两个阶段均属于该范畴）

#2、python中的数据类型字符串是由一串字符组成的（python文件执行时，即第三个阶段）

1.13.2 字符编码的发展史与分类

计算机由美国人发明，最早的字符编码为ASCII，只规定了英文字母数字和一些特殊字符与数字的对应关系。最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号

图1-6

当然我们编程语言都用英文没问题，ASCII够用，但是在处理数据时，不同的国家有不同的语言，日本人会在自己的程序中加入日文，中国人会加入中文。

而要表示中文，单拿一个字节表表示一个汉子，是不可能表达完的(连小学生都认识两千多个汉字)，解决方法只有一个，就是一个字节用>8位2进制代表，位数越多，代表的变化就多，这样，就可以尽可能多的表达出不通的汉字，所以中国人规定了自己的标准gb2312编码，规定了包含中文在内的字符－>数字的对应关系。

日本人规定了自己的Shift_JIS编码，韩国人规定了自己的Euc-kr编码，所以迫切需要一个世界的标准（能包含全世界的语言）于是unicode应运而生。

ascii用1个字节（8位二进制）代表一个字符

unicode常用2个字节（16位二进制）代表一个字符，生僻字需要用4个字节

这时候乱码问题消失了，所有的文档我们都使用但是新问题出现了，如果我们的文档通篇都是英文，你用unicode会比ascii耗费多一倍的空间，在存储和传输上十分的低效

本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间

1.13.3 总结字符编码的发展可分为三个阶段

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

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

ASCII最初只用了后七位，127个数字，已经完全能够代表键盘上所有的字符了（英文字符/键盘的所有其他字符），后来为了将拉丁文也编码进了ASCII表，将最高位也占用了

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

GBK:2Bytes代表一个中文字符，1Bytes表示一个英文字符

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

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

#阶段三：各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。如何解决这个问题呢？？？

1、能够兼容万国字符

#2、与全世界所有的字符编码都有映射关系，这样就可以转换成任意国家的字符编码

这就是unicode（定长），　统一用2Bytes代表一个字符，　虽然2**16-1=65535，但unicode却可以存放100w+个字符，因为unicode存放了与其他编码的映射关系，准确地说unicode并不是一种严格意义上的字符编码表

nicode的详情：

链接：https://pan.baidu.com/s/1dEV3RYp

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

于是产生了UTF-8（可变长，全称Unicode Transformation Format），对英文字符只用1Bytes表示，对中文字符用3Bytes，对其他生僻字用更多的Bytes去存

#总结：

内存中统一采用unicode，浪费空间来换取可以转换成任意编码（不乱码），硬盘可以采用各种编码，如utf-8，保证存放于硬盘或者基于网络传输的数据量很小，提高传输效率与稳定性。

1.13.4 总字符编码应用之文件编辑器

#1、保证不乱吗的核心法则就是，字符按照什么标准而编码的，就要按照什么标准解码，此处的标准指的就是字符编码

#2、在内存中写的所有字符，一视同仁，都是unicode编码，比如我们打开编辑器，输入一个“你”，我们并不能说“你”就是一个汉字，此时它仅仅只是一个符号，该符号可能很多国家都在使用，根据我们使用的输入法不同这个字的样式可能也不太一样。只有在我们往硬盘保存或者基于网络传输时，才能确定”你“到底是一个汉字，还是一个日本字，这就是unicode转换成其他编码格式的过程了

unicode----->encode-------->utf-8

utf-8-------->decode---------->unicode

图1-7

1.13.5 字符编码应用之python

执行python程序的三个阶段

python test.py   （执行test.py的第一步，一定是先将文件内容读入到内存中）

阶段一：启动python解释器

阶段二：python解释器此时就是一个文本编辑器，负责打开文件test.py,即从硬盘中读取test.py的内容到内存中

此时，python解释器会读取test.py的第一行内容，#coding:utf-8，来决定以什么编码格式来读入内存，这一行就是来设定python解释器这个软件的编码使用的编码格式这个编码，

可以用sys.getdefaultencoding()查看，如果不在python文件指定头信息＃-*-coding:utf-8-*-,那就使用默认的

python2中默认使用ascii，python3中默认使用utf-8

阶段三：读取已经加载到内存的代码（unicode编码格式），然后执行，执行过程中可能会开辟新的内存空间，比如x="egon"

内存的编码使用unicode，不代表内存中全都是unicode，

在程序执行之前，内存中确实都是unicode,比如从文件中读取了一行x="egon",其中的x，等号，引号，地位都一样，都是普通字符而已，都是以unicode的格式存放于内存中的，但是程序在执行过程中，会申请内存（与程序代码所存在的内存是俩个空间）用来存放python的数据类型的值，而python的字符串类型又涉及到了字符的概念

比如x="egon",会被python解释器识别为字符串，会申请内存空间来存放字符串类型的值，至于该字符串类型的值被识别成何种编码存放，这就与python解释器的有关了，而python2与python3的字符串类型又有所不同。

1.14 python2与python3字符串类型的区别

在python2中有两种字符串类型str和unicode

str类型

当python解释器执行到产生字符串的代码时（例如x='上'），会申请新的内存地址，然后将'上'编码成文件开头指定的编码格式

要想看x在内存中的真实格式，可以将其放入列表中再打印，而不要直接打印，因为直接print()会自动转换编码，这一点我们稍后再说。

#coding:gbk

x='上'

y='下'

print([x,y]) #['\xc9\xcf', '\xcf\xc2']

#\x代表16进制，此处是c9cf总共4位16进制数，一个16进制四4个比特位，4个16进制数则是16个比特位，即2个Bytes，这就证明了按照gbk编码中文用2Bytes

print(type(x),type(y)) #(<type 'str'>, <type 'str'>)

内存中的数据通常用16进制表示，2位16进制数据代表一个字节，如\xc9，代表两位16进制，一个字节

gbk存中文需要2个bytes，而存英文则需要1个bytes，它是如何做到的？？？！！！

gbk会在每个bytes，即8位bit的第一个位作为标志位，标志位为1则表示是中文字符，如果标志位为0则表示为英文字符

x=‘你a好’

转成gbk格式二进制位

8bit+8bit+8bit+8bit+8bit=(1+7bit)+(1+7bit)+(0+7bit)+(1+7bit)+(1+7bit)

这样计算机按照从左往右的顺序读：

#连续读到前两个括号内的首位标志位均为1，则构成一个中午字符：你

#读到第三个括号的首位标志为0，则该8bit代表一个英文字符：a

#连续读到后两个括号内的首位标志位均为1，则构成一个中午字符：好

也就是说，每个Bytes留给我们用来存真正值的有效位数只有7位，而在unicode表中存放的只是这有效的7位，至于首位的标志位与具体的编码有关，即在unicode中表示gbk的方式为：

(7bit)+(7bit)+(7bit)+(7bit)+(7bit)

图1-8

按照上图翻译的结果，我们可以去unicode关于汉字的对应关系中去查：链接：https://pan.baidu.com/s/1dEV3RYp

# f=open(r'C:\Users\Administrator\PycharmProjects\python20期\day2\a.txt')

# f=open('a.txt','r',encoding='utf-8')

# data=f.read()

# print(data)

# print(f)

# f.close() #文件关闭，回收操作系统的资源

# print(f)

# f.read()

# with open('a.txt','r',encoding='utf-8') as f: #f=open('a.txt','r',encoding='utf-8')

#     pass

1.15 文件处理

1.15.1 读操作:r只读模式，默认是rt文本读

# f=open('a.txt','r',encoding='utf-8')

# # data1=f.read()

# # print('=1===>',data1)

# # data2=f.read()

# # print('=2===>',data2)

#

# # print(f.readlines())

#

# # print(f.readline(),end='')

# # print(f.readline(),end='')

# # print(f.readline(),end='')

#

#

# f.close()

1.15.2 写操作:w只写模式，默认是wt文本写，如果文件不存在则创建，存在则清空+覆盖

f=open('a.txt','w',encoding='utf-8')

# f.write('11111\n')

# f.write('222222\n')

# f.write('1111\n2222\n3333\n')

# f.writelines(['哈哈哈哈\n','你好','alex'])

f.close()

图1-9

可以看到“”上“”对应的gbk（G0代表的是gbk）编码就为494F，即我们得出的结果，而上对应的unicode编码为4E0A，我们可以将gbk-->decode-->unicode

#coding:gbk

x='上'.decode('gbk')

y='下'.decode('gbk')

print([x,y]) #[u'\u4e0a', u'\u4e0b'] 

unicode类型

当python解释器执行到产生字符串的代码时（例如s=u'林'），会申请新的内存地址，然后将'林'以unicode的格式存放到新的内存空间中，所以s只能encode，不能decode

#coding:gbk

x=u'上' #等同于 x='上'.decode('gbk')

y=u'下' #等同于 y='下'.decode('gbk')

print([x,y]) #[u'\u4e0a', u'\u4e0b']

print(type(x),type(y)) #(<type 'unicode'>, <type 'unicode'>)

unicode这么好，不会乱码，那python2为何还那么别扭，搞一个str出来呢？python诞生之时，unicode并未像今天这样普及，很明显，好的东西你能看得见，龟叔早就看见了，龟叔在python3中将str直接存成unicode，我们定义一个str，无需加u前缀，就是一个unicode

在python3 中也有两种字符串类型str和bytes

str是unicode

#coding:gbk

x='上' #当程序执行时，无需加u，'上'也会被以unicode形式保存新的内存空间中,

print(type(x)) #<class 'str'>

#x可以直接encode成任意编码格式

print(x.encode('gbk')) #b'\xc9\xcf'

print(type(x.encode('gbk'))) #<class 'bytes'>

很重要的一点是：看到python3中x.encode('gbk') 的结果\xc9\xcf正是python2中的str类型的值,而在python3是bytes类型，在python2中则是str类型

python2中的str类型就是python3的bytes类型，查看python2的str()源码可以发现

图1-10