python_day2(数据类型，字符编码，文件操作)

一、补充day1 

       1、python2 与 python3 input的区别

           python2 的 raw_input() 与 python3的 input() 是一个功能

           Python2 的 input() 的功能也为输入功能，只不过是在输入是必须输入一个明确的类型 

>>>
>>> age = input("age>>: ")
age>>: 18
>>> type(age)
<type 'int'>
>>>
>>>
>>> name = input("name>>: ")
name>>: lxg
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'lxg' is not defined
>>>
>>> name = input("name>>: ")
name>>: "lxg"
>>> type(name)
<type 'str'>
>>>
>>>
>>>
>>> age = input("age>>: ")
age>>: Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyboardInterrupt
>>>
>>>
>>>
>>> age = raw_input("age>>: ")
age>>: 18
>>> type(age)
<type 'str'>
>>>
>>> name = raw_input("name>>: ")
name>>: lxg
>>>
>>> type(name)
<type 'str'>
>>>

其中“lxg” 在python的input()中就是明确指定 输入为字str类型而18 为int类型，而在 raw_input()中默认会把所有的输入转换为str类型 和python3的input()是一个功能

二、数字类型

整型int
1 用途：年龄，等级，qq号等

2 定义方式
age=18 #age=int(18)

二：该类型总结
1 存一个值or存多个值
  只能存一个值

 3 可变or不可变
 ！！！不可变
 x=11
 print(id(x))
 x=12
 print(id(x))

浮点型float
 1 用途：身高，体重，体质参数等

 2 定义方式
 salary = 3.1 # salary=float(3.1)

了解：
长整型：python2中
 x=3L

复数
 x=1+2j
 print(x.real)
 print(x.imag)
 print(type(x))

 1 存一个值or存多个值
 只能存一个值

 3 可变or不可变
 ！！！不可变

三、字符串类型

#用途：姓名，性别，住址等描述性的数据
#定义方式：‘’ ，“”，''' '''内定义的一串字符
msg='hello world'

msg = "hello world"
# 优先掌握的操作：
# 1、按索引取值（正向取值+反向取值）：只能读
print(msg[0],type(msg[0]))
#h <class 'str'>
print(msg[-1])
#d

#2、切片(顾头不顾尾,步长)
print(msg[0:3])  #>=0 <3
#hel
print(msg[0:7:1])
#hello w
print(msg[0:7:2]) #从0开始,0要打印然后开始步长
#hlow
print(msg[:])
#hello world
print(msg[5:0]) #从左到右 5开始到1 所以娶不到值
#
print(msg[6:0:-1]) #步长为 -1 所以是从有右到左 不包括0
#w olle
print(msg[-1::-1]) #反转
#dlrow olleh

#3、长度
print(msg.__len__()) #以__ 开头的方法一般是python内部调用的方法
#11
print(len(msg))
#11

#4、成员运算in和not in
msg = "hello world"
print("he" in msg)
#True
print("he" not in msg)
#False

#5、移除空白strip()
password = "    lxg123   "
print(password.strip())
#lxg123
print(password.lstrip())
#lxg123    ###
print(password.rstrip())
#    lxg123
password = "lxg  123"
print(password.strip()) # 并不会去掉字符串中的空格
#lxg  123
print(password.strip("xl32"))
#g  1
print(password.strip("xl12"))
#g  123

#6、切分split 指定分隔符 返回列表
user_info = "root:x:0:0:/root:/bin/bash"
print(user_info.split(":"))
#['root', 'x', '0', '0', '/root', '/bin/bash']
res = user_info.split(":",2)
print(res)
#['root', 'x', '0:0:/root:/bin/bash']

file_path = "C:\a\d.txt"
print(file_path.split("\",1))
#['C:', 'a\d.txt']
print(file_path.rsplit("\",1))
#['C:\a', 'd.txt']

#7、循环
msg = "hello world"
count = 0
while count < len(msg):
    print(msg[count])
    count+=1
# h
# e
# l
# l
# o
#
# w
# o
# r
# l
# d

for n in msg:
    print(n)
# h
# e
# l
# l
# o
#
# w
# o
# r
# l
# d
for n in range(len(msg)): #range顾头不顾尾 range(0,10,2) 可加步长
    print(msg[n])
# h
# e
# l
# l
# o
#
# w
# o
# r
# l
# d

#需要掌握的方法
#1、lower,upper
print("LXG".lower())
#lxg
print("lxg".upper())
#LXG

#2、startswith,endswith  注意和strip的区分,strip的多个字符没有先后顺序(可能是递归去去) 而此处的两个是有先后顺序的
msg = "lhf is teach"
print(msg.startswith("lh"))
#True
print(msg.startswith("hl"))
#False
print(msg.endswith("ch"))
#True

#3、format的三种用法
print("my name is %s lxg,my age is %d" %("lxg",18))
#my name is lxg lxg,my age is 18
print("my name is {} lxg,my age is {}".format("lxg",18))
#my name is lxg lxg,my age is 18
print("my name is {name} lxg,my age is {age}".format(age=18,name="lxg"))
#my name is lxg lxg,my age is 18
print("my name is {0} lxg,my age is {1},mysql age is {1}".format("lxg",18))
#my name is lxg lxg,my age is 18,mysql age is 18

#4、join
print(":".join(['root', 'x', '0', '0', '/root', '/bin/bash']))
#root:x:0:0:/root:/bin/bash
l = [1,2,3]
#' '.join(l)   #只有在列表内的元素全是字符串类型,才能用join方法拼接
#TypeError: sequence item 0: expected str instance, int found

#5、replace 替换
msg = "my name is lxg.my name is lxg"
print(msg.replace("lxg","zl"))
#my name is zl.my name is zl
print(msg.replace("lxg","zl",1))
#my name is zl.my name is lxg

#6、isdigit
#age = input("age>>: ").strip()
a = "123"
print(a.isdigit())
#True
a = "123a"
print(a.isdigit())
#False

#了解
#1、find,rfind,index,rindex,count,center,ljust,rjust,zfill,expandtabs
msg = "hello world"
print(msg.find("o"))
#4
print(msg.find("z"))
#-1
print(msg.index("o"))
#4
#print(msg.index("z"))
#ValueError: substring not found 报错
print(msg.count("l"))
#3

print(msg.count("ll"))
#1

print(msg.center(30,"*")) #center 居中显示 凑够30
#*********hello world**********

print(msg.ljust(30,"*")) #左对齐
#hello world*******************

print(msg.rjust(30,"*")) #右对齐
#*******************hello world

print(msg.zfill(30)) #用0填充 右对齐
#0000000000000000000hello world

print("hello	world".expandtabs(10)) #tab键定义为10个空格
#hello     world

print("lxg zl".capitalize()) #首字母大写
#Lxg zl

print("lxg zl".title()) #每一个单词大写
#Lxg Zl

print("AbC".swapcase()) #大小反转
#aBc

#is 数字系列
num1 = b'4' #bytes
num2 = u'4' #unicode ,python3中无需加u就是unicode
num3 = "四"
num4 = "Ⅳ"
#bytes,unicode
print(num1.isdigit())
#True
print(num2.isdigit())
#True
print(num3.isdigit())
#False
print(num4.isdigit())
#False

#unicode
print(num2.isdecimal())
#True
print(num3.isdecimal())
#False
print(num4.isdecimal())
#False

#unicode，中文，罗马
print(num2.isnumeric())
#True
print(num3.isnumeric())
#True
print(num4.isnumeric())
#True

#二、该类型总结
#1、存一个值or存多个值
#只能存一个值
#2、有序
#3、可变or不可变
#不可变

#6、is其他
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print('print1111'.isidentifier()) #字符里是否包含关键字
print('abcA'.islower()) #字符是否全是有小写组成
print(name.isupper())   #字符是否全是有大写组成
print('    '.isspace())  #字符是否是全是又空格
print('Am Ia'.istitle()) #字符是否是标题

三、列表类型

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

#定义：[]内可以有多个任意类型的值，逗号分隔
# my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
# print(list('hello'))
# print(int('123'))
# print(str(123))

#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]

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

#3、长度
print(my_girl_friends.__len__())
print(len(my_girl_friends))

#4、成员运算in和not in
print('wupeiqi' in my_girl_friends)

#5、追加
#my_girl_friends[5]=3 #IndexError: list assignment index out of range
my_girl_friends.append(6)
print(my_girl_friends)
#['alex', 'wupeiqi', 'yuanhao', 4, 5, 6]

#6、删除
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]

#单纯的删除
del my_girl_friends[0]
print(my_girl_friends)
#['wupeiqi', 'yuanhao', 4, 5]

res=my_girl_friends.remove('yuanhao') #若有多个删除第一个
print(my_girl_friends)
#['wupeiqi', 4, 5]
print(res)
print(my_girl_friends)
#None

#删除并拿到结果:取走一个值
res=my_girl_friends.pop(2) #按索引取走 默认是最后一个
print(res)
#5
res=my_girl_friends.pop()
print(res)
#4

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print(my_girl_friends.pop(0))
#'alex'
print(my_girl_friends.pop(0))
#'wupeqi'
print(my_girl_friends.pop(0))
#'yuanhao'

#7、循环
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]

i=0
while i < len(my_girl_friends):
    print(my_girl_friends[i])
    i+=1

for item in my_girl_friends:
    print(item)

for i in range(10):
    if i== 3:
        break
        # continue
    print(i)
else:
    print('===>')







#掌握的方法
my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
my_girl_friends.insert(1,'egon') #按照索引添加
print(my_girl_friends)
#['alex', 'egon', 'wupeiqi', 'yuanhao', 'yuanhao', 4, 5]


my_girl_friends.clear() #清空列表
print(my_girl_friends)
#[]

#拷贝  copy()
my_girl_friends = ['alex','wupeiqi','yuanhao','yuanhao',4,5]
l=my_girl_friends.copy() #拷贝列表 浅拷贝
print(l)
#['alex', 'wupeiqi', 'yuanhao', 'yuanhao', 4, 5]


#统计元素的个数
print(my_girl_friends.count('yuanhao'))
#2

# extend()    把一个可迭代的数据迭代到列表的后面
l=['egon1','egon2']
my_girl_friends.extend(l)
print(my_girl_friends)
#['alex', 'wupeiqi', 'yuanhao', 'yuanhao', 4, 5, 'egon1', 'egon2']

my_girl_friends.extend('hello')
print(my_girl_friends)
#['alex', 'wupeiqi', 'yuanhao', 'yuanhao', 4, 5, 'egon1', 'egon2', 'h', 'e', 'l', 'l', 'o']

#my_girl_friends.extend(1)
#TypeError: 'int' object is not iterable


my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
print(my_girl_friends.index('yuanhao')) #返回第一个找到的索引
#2

#print(my_girl_friends.index('wupeiqissssss'))
#ValueError: 'wupeiqissssss' is not in list


my_girl_friends.reverse()  #翻转
my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
my_girl_friends.reverse()
print(my_girl_friends)
#[5, 4, 'yuanhao', 'yuanhao', 'wupeiqi', 'alex']


#排序
l=[1,10,4,11,2,]
l.sort()
print(l)
#[1, 2, 4, 10, 11]
l.sort(reverse=True)
print(l)
#[11, 10, 4, 2, 1]

x='healloworld'
y='he2'
print(x > y)
#Ture
l=['egon','alex','wupei']
l.sort()
print(l)
#['alex', 'egon', 'wupei'] #从第一个字母排序,只要是比到就停止  并不会按照元素的长度排序



#二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型

# 2 有序

# 3 可变or不可变
#     ！！！可变：值变，id不变。可变==不可hash


#练习
# 1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data=['alex',49,[1900,3,18]]
name = data[0]
age = data[1]
birthday = str(data[2][0])+"-"+str(data[2][1])+"-"+str(data[2][2])
print(name,age,birthday)
#alex 49 1900-3-18

# 2. 用列表模拟队列（先进先出）
l=[]
l.append('alex')
l.append('wupeiqi')
l.append('yuanhao')
l.append('huowentian')
print(l)

print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
###########################
l=[]
l.insert(0,'alex')
l.insert(0,'wupeqiqi')
l.insert(0,'yuanhao')
l.insert(0,'huowentian')
print(l)

print(l.pop())
print(l.pop())
print(l.pop())
print(l.pop())

# 3. 用列表模拟堆栈(先进后出，后进先出)
l.append('alex')
l.append('wupeiqi')
l.append('yuanhao')
l.append('huowentian')
print(l)

print(l.pop())
print(l.pop())
print(l.pop())
print(l.pop())
##################
l=[]
l.insert(0,'alex')
l.insert(0,'wupeqiqi')
l.insert(0,'yuanhao')
l.insert(0,'huowentian')
print(l)
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

# 4. 有如下列表，请按照年龄排序（涉及到匿名函数）

元组

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

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55) #本质age=tuple((11,22,33,44,55))
print(type(age))
#<class 'tuple'>
#age[0]=12
#TypeError: 'tuple' object does not support item assignment


t=(1,2,['a','b']) 
print(id(t[2]))
#4339298696

t[2][0]='A'
print(id(t[2]))
#4339298696 #因为列表是可变的,所以可以更改,但是id不变
print(t)
#(1, 2, ['A', 'b'])


#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
age=(11,22,33,44,55)
print(age[0:3])
#(11, 22, 33)
print(age)
#(11, 22, 33, 44, 55)

#3、长度
age=(11,22,33,44,55)
print(len(age))
#5

#4、成员运算in和not in
age=(11,22,33,44,55)
print(11 in age)
#True

#5、循环
for item in age:
    print(item)


#掌握
age=(11,22,33,44,55)
print(age.index(33))
#2

#print(age.index(33333))
#ValueError: tuple.index(x): x not in tuple

#统计元素的个数
print(age.count(33))
#1



#二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型

# 2 有序

# 3 可变or不可变
#     ！！！不可变：值变，id就变。不可变==可hash

字典

#用途：存放多个值，key:value,存取速度快

#定义：key必须是不可变类型（int，float，str，tuple），value可以是任意类型
info={'name':'egon','age':18,'sex':'male'} #info=dict({'name':'egon','age':18,'sex':'male'})
#了解
info=dict(age=18,sex='male',name='egon')
print(info)
#{'age': 18, 'sex': 'male', 'name': 'egon'}

info=dict([('name','egon'),('age',18),('sex','male')])
print(info)
#{'name': 'egon', 'age': 18, 'sex': 'male'}

info=dict([['name','egon'],['age',18],['sex','male']])
print(info)
#{'name': 'egon', 'age': 18, 'sex': 'male'}

info={}.fromkeys(['name','age','sex'],None) #key可以是可迭代的类型
print(info)
#{'name': None, 'age': None, 'sex': None}

info={}.fromkeys('hello',None)
print(info)
#{'h': None, 'e': None, 'l': None, 'o': None}


#优先掌握的操作：
#1、按key存取值：可存可取
d={'name':'egon'}
print(d['name'])
#egon

#添加值
d['age']=18
print(d)
#{'name': 'egon', 'age': 18}

#2、长度len
info={'name':'egon','age':18,'sex':'male'}
print(len(info))
#3

#3、成员运算in和not in
info={'name':'egon','age':18,'sex':'male'}
print('name' in info)
#True

#4、删除
info={'name':'egon','age':18,'sex':'male'}
print(info.pop('name'))
#egon
print(info)
#{'age': 18, 'sex': 'male'}

print(info.popitem())
print(info)
#('sex', 'male') #随机

del info["age"]
print(info)
#{}

#5、键keys()，值values()，键值对items() #了解 返回的是一个可迭代数据
info={'name':'egon','age':18,'sex':'male'}
print(info.keys())
#dict_keys(['name', 'age', 'sex']) #返回的是一个可迭代数据

print(list(info.keys())[0]) #用list() 转换成列表
#name

print(list(info.values()))
#['egon', 18, 'male']  #用list() 转换成列表

print(list(info.items()))
#[('name', 'egon'), ('age', 18), ('sex', 'male')] #用list() 转换成列表 返回列表一个item为一个元组

#6、循环
info={'name':'egon','age':18,'sex':'male'}
for k in info:
    print(k,info[k])


#其他需要掌握的方法
info={'name':'egon','age':18,'sex':'male'}
#print(info['hobbies'])
print(info.get('hobbies'))
#None
print(info.get('hobbies','没有'))
#没有
#print(info.pop('name1'))
#KeyError: 'name1'
print(info.pop('name1',None))
#None

d={'x':1,'y':2,'name':'EGON'}
info.update(d) #追加并更新
print(info)
#{'name': 'EGON', 'age': 18, 'sex': 'male', 'x': 1, 'y': 2}

# setdefault()  若有key就返回value  若没有返回第二个参数 并添加到字典中
info={'name':'egon','sex':'male'}
value=info.setdefault('age',18)
print(value)
#18
print(info)
{'name': 'egon', 'sex': 'male', 'age': 18}

info={'name':'egon','age':16,'sex':'male'}
value=info.setdefault('age',18) #如果key存在，则不修改，返回已经有的key对应的value
print(value)
#16
print(info)
#{'name': 'egon', 'age': 16, 'sex': 'male'}

info={'name':'egon',}
info['hobbies']=[]
info['hobbies'].append('music')
info['hobbies'].append('read')
print(info)
#{'name': 'egon', 'hobbies': ['music', 'read']}

info={'name':'egon',}
if 'hobbies' not in info:
    info['hobbies']=[]
else:
    info['hobbies'].append('music')

hobbies_list=info.setdefault('hobbies',[])
print(hobbies_list)
#[]
hobbies_list.append('play')
hobbies_list.append('read')
print(info)
#{'name': 'egon', 'hobbies': ['play', 'read']}


#二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型,key必须是不可变类型
#
# 2 无序

# 3 可变or不可变
#     ！！！可变：值变，id不变。可变==不可hash

关于字典的练习题

#简单购物车实现
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
goods=[]
while True:
    for k in msg_dic:
        print(k,msg_dic[k])
    choice=input('商品名: ').strip()
    if choice not in msg_dic: # or len(choice) == 0:
        print('商品名非法')
        continue
    while True:
        num=input('购买个数: ').strip()
        if num.isdigit():
            break
    goods.append((choice,msg_dic[choice],int(num)))
    print('购物车',goods)

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

nums=[11,22,33,44,55,66,77,88,99,90]
d={'k1':[],'k2':[]}

for num in nums:
    if num > 66:
        d['k1'].append(num)
    if num < 66:
        d['k2'].append(num)

print(d)
d = {}
nums=[11,22,33,44,55,66,77,88,99,90]
for n in nums:
    if n > 66:
        d.setdefault("k1",[]).append(n)
    elif n < 66:
        d.setdefault("k2",[]).append(n)

print(d)

2 统计s='hello alex alex say hello sb sb'中每个单词的个数
s='hello alex alex say hello sb sb'
words=s.split()
d={}
for word in words:
    # print(word)
    d.setdefault(word,s.count(word)) #{'hello':2}  换成d.setdefaul(word,s.words.count(word)) 更合理,防止 helloohello的出现
print(d)

集合

pythons=['egon','axx','ysb','wxx']
linuxs=['egon','oldboy','oldgirl','smallboy','smallgirl']

python_linux=[]

for student in pythons:
    if student in linuxs:
        python_linux.append(student)

print(python_linux)
#['egon']

#作用：关系运算，去重
#定义集合：{}内用逗号分割每个元素都必须是不可变类型,元素不能重复,无序
#s={1,'a',[1,2]}
# #TypeError: unhashable type: 'list'
s={1,2,3,1} #s=set({1,2,3,1})
print(s,type(s))
#{1, 2, 3} <class 'set'>

#优先掌握的操作：
# 1、长度len
s={1,2,3,1} #s=set({1,2,3,1})
print(len(s))
#3

#2、成员运算in和not in
names={'egon','alex'}
print('egon' in names)
#True

#3、|合集
pythons={'egon','axx','ysb','wxx'}
linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}

#4、&交集:同时报名两门课程的学生
print(pythons & linuxs)
#{'egon'}
print(pythons.intersection(linuxs))
#{'egon'}

#5、|合集:老男孩所有的学生
print(pythons | linuxs)
#{'smallboy', 'egon', 'ysb', 'wxx', 'smallgirl', 'axx', 'oldboy', 'oldgirl'}
print(pythons.union(linuxs))
#{'smallboy', 'egon', 'ysb', 'wxx', 'smallgirl', 'axx', 'oldboy', 'oldgirl'}


#6、^对称差集:没有同时报名两门课程
print(pythons ^ linuxs)
#{'ysb', 'axx', 'oldboy', 'wxx', 'smallgirl', 'oldgirl', 'smallboy'}
print(pythons.symmetric_difference(linuxs))
#{'ysb', 'axx', 'oldboy', 'wxx', 'smallgirl', 'oldgirl', 'smallboy'}

#7.1  -差集：只报名python课程的学生
print(pythons - linuxs)
#{'axx', 'ysb', 'wxx'}
print(pythons.difference(linuxs))
#{'axx', 'wxx', 'ysb'}

#7.2  -差集：只报名linux课程的学生
print(linuxs-pythons)
#{'oldboy', 'smallgirl', 'smallboy', 'oldgirl'}

#8 父集:>,>=,子集：<，<=
s1={1,2,3}
s2={1,2,}
print(s1 >= s2)
#True
print(s1.issuperset(s2))
#True
print(s2.issubset(s1))
#True

linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}
for student in linuxs:
    print(student)

字符编码

1、存取文件不乱码的法则：用什么编码存的，就要用什么编码读
2、unicode-----encode----->gbk
    gbk-------->decode----->unicode

3、
    python3解释器默认使用的字符编码是utf-8
    python2解释器默认使用的字符编码是ascii
4
    python2的str就是python3的bytes
    python2的unicode就是python3的str

5、文件开头的coding:utf-8 为python解释器打开文件的编码   python2默认是ascii  python3默认是utf-8

6、python2 的 coding:utf-8 不只是和python解释器打开文件有关，还和python存变量时有关，python在存变量时会默认把变量按照文件开头知道的字符编码存默认是ascii 而python3会把变量存储成unicode 

7、python2在存变量的时候所用的是文件打开是的字符编码格式若不指定默认是ascii（如文件开头指定的coding:gbk,变量在内存中的格式就是gbk。）但是在print的时候所用的解码是运行平台决定的，（pycharm默认是utf-8，win是gbk，unix一般是utf-8）所以在打印的是后会出现乱码，而在python3中会把变量默认存为unicode所以在print的时候可以跨平台。（以上所说的是变量的编码）
   python2和python3在打开文件是时不同为python2因为在开文件时存的变量为bytes所以在打开文件时就是直接直接把磁盘的二进制直接拷贝到内存，所以要跨平台读时要用decode方法来转换成unicode 而python3的变量在内存中存时用的是unicode所以在打开文件是要转换成uncide所以在python3的打开文件的open方法中多了encoding的参数就是来指定转换的格式,默认是操作系统的编码。

文件处理

# f=open(r'C:UsersAdministratorPycharmProjectspython20期day2a.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


#读操作: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()


#写操作:w只写模式，默认是wt文本写，如果文件不存在则创建，存在则清空+覆盖
f=open('a.txt','w',encoding='utf-8')
f.write('11111
')
f.write('222222
')
f.write('1111
2222
3333
')
f.writelines(['哈哈哈哈
','你好','alex'])
f.close()