5-day5-字符编码-函数-文件操作

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "w.z"
# Date: 2017/6/9

# review-list
# list 删除
# pop
l = [1, 2, 3, [3, 4]]
print(l[3])
l[3].pop(0)
print(l)

# del
l = [1, 2, 3, [3, 4]]
del l[3][1]
print(l)

# remove 指定元素的值，对元素进行删除
l = [1, 2, 3, [3, 4]]
print(l[3].remove(4))
print(l)

# 字符串多重赋值
a, b, c, d, e = 'hello'
print(a, e)
a, *_, e = 'hello'
print(a, e)


# 1. 字典通过key取value的方法

# 字典打印 keys ,打印出来类型是dict_keys ，可通过list函数转化为列表(list)类型,或者通过 for ... in ... 打印
dict1 = {'name': 'lisan', 'class': '5', 'room':'room32'}
print(list(dict1.keys()))
print(type(dict1.keys()))

for i in dict1.keys():
    print(i)

# 打印 字典的 values, dict1.values的类型是dict_keys ，可通过list()函数转化
dict1 = {'name': 'lisan', 'class': '5', 'room':'room32'}
print(dict1.values())
print(list(dict1.values()))
print(list(dict1.values())[1])

# {}.get('key')  {}['key']
# {}.get('a','cant find')  //key不存在，返回null,返回 str
dd = {'a': '1', 'b': '2'}
print(dd['a'])
print(dd.get('bb', 'the key do not exits'))           # 此处的返回值，只有在取不到的时候才能返回

# 2.打印字典的key value
# for i in dd :打印出来的是key的值
dd = {'a': '1', 'b': '2'}  # 打印key
for i in dd:
    print(i)

# items()
# for i in  dict1.items(): 类型为dict.items
dict1 = {'name': 'lisan', 'class': '5', 'room': 'room32'}
print(dict1.items())     # dict_items([('name', 'lisan'), ('class', '5'), ('room', 'room32')])
print(type(dict1.items()))
for dd in dict1.items():
    print(dd)
    print(type(dd))  # ddd ('key','value')  打印key-value组成的元组

for k, v in dict1.items():
    print(k, v)      # 通过 k,v 两个变量打印元组里的两个值

# print(dd.popitem()) 随机删除字典元素，其实是删除最后一位
dict3 = {'ads': '1', 'store': '2', 'epd': '3'}
print(dict3.popitem())
print(dict3)

# 3 . 字典的赋值
dd1 = dict({'a': '1', 'b': '2'})
print(dd1)

d3 = dict(name='zhangwei', age=18)
print(d3)

a1 = {}
a2 = dict()
print(a1, a2)

a5 = dict([('b', 1), ('c', 2), ('d', 3)])  # dict可以把列表里面的元组队，转化为字典，合理
print(a5)

dd6 = {}.fromkeys(['name', 'age'], ['1'])
dd7 = {}.fromkeys(['name', 'age'], ['egon', '18'])  # key value 值是一样的
print(dd7)
print(dd6)

# 4.字典的删除操作： pop() popitem()
dict1 = {'name': 'lisan', 'class': '5', 'room': 'room32'}
print(dict1.pop('room3', 'bu cun zai '))

dict1 = {'name': 'lisan', 'class': '5', 'room': 'room32'}
print(dict1.popitem())
print(dict1)

# 5. setdefault 存在key 则返回values,不存在key,则把key-value值加上去
dict1 = {'name': 'lisan', 'class': '5', 'room': 'room32'}
print(dict1.setdefault('name2', 'dasdsa'))
print(dict1)

# 6.update()  把dict5 里没有的键值对
dict5 = {'name': 'alex', 'class': 'six'}
dict6 = {'name': 'alex', 'socre':'99'}
dict5.update(dict6)
print(dict5)




# 集合
# dict 逻辑操作
# c1.update(c2)    ## 把c2的值给c1 ，key一样覆盖，key不一样，增加

# set 对集合进行排重
set1 ={'a', 's', 'd', 's', 'f', 'a'}
print(set(set1))

names = ['egon', 'alex', 'tim', 'ben']
print(set(names))
print(list(set(names)))

# 数据类型自带bool值 ，空或者不为空
l = ['1']
if not l:
    print('空')
else:
    print('不空')


# 集合 ：

# 集合内元素必须是唯一的
# 集合内的元素必须是可hash的，也就是不变类型，比如，不能是列表
set3 = {'egon', 'alex', 'tim', 'ben'}
set4 = {'alex', 'xiaoxue', 'songjia'}
print(set3)
print(set3 & set4)        # 取交集
print(set3 | set4)        # 取合集
print(set3 - set4)        # 取差集

# 集合方法
# difference() 取差集
set3 = {'egon', 'alex', 'tim', 'ben'}
set4 = {'alex', 'xiaoxue', 'songjia'}
print(set3.difference(set4))

# difference_update()  取差集，并且更新集合
set3 = {'egon', 'alex', 'tim', 'ben'}
set4 = {'alex', 'xiaoxue', 'songjia'}
print(set3.difference_update(set4))
print(set3)

# 交集 并集 差集
set3 = {'egon', 'alex', 'tim', 'ben'}
set4 = {'alex', 'xiaoxue', 'songjia'}

print(set3 & set4)  # 同时报名set3 和set4 的同学
print(set3.intersection(set4))

print(set3 | set4)   # 报名的所有同学
print(set3.union(set4))

print(set3 - set4)    # 只报名set3的同学
print(set3.difference(set4))

print(set4 - set3)    # 只报名set4的同学
print(set4.difference(set3))


# is disjoint 没有交集，返回True
s1 = {1, 2, 'q'}
s2 = {1, 2, 3,}
s3 = {1, 2}
s4 = {'a', 'b'}
print(s1.isdisjoint(s2))
print(s3.issubset(s2))
s3.update(s4)
print(s3)

#
s1 = {'a', 1}
s1.add(2)
s1.discard(1)
s1.remove('a')
s1.pop()
print(s1)

names = ['egon', 'alex', 'tim', 'aterm']
print(list(set(names)))





#文件操作

file1 = open('a','w')
file1.write('dasdsa')
file1.write('
ok')
file1.close()

#rb 模式 
f= open('a', rb)
print(f.read())
print(f.read().decode(utf-8))

# a 模式。文件不存在创建，文件存在打开,追加
file2 = open('a','a',encoding='utf-8')
file2.close

# file3 = open('a','r',encoding='utf-8')
f.write('dasdas')
f.flush()  #把内存数据刷新到硬盘
file2.close()
print(file2.close()) #判断文件是否关闭
file2.readlines()
file2.readable()


#文件内移动光标

#seek
file4 = open('a','r',encode='utf-8')
print('first-read', f.read())
f.seek(0)
print('secnd', f.read())
f.seek(3)     #移动2个字节 utf-8 三个字节
print(f.tell())  #当前光标的位置
f.seek(3,0)# 0 文件开头 1 当前位置 2 末尾。

#seek 1 模式,必须rb，因为以字节方式打开
file5 = open('a','r',encode='utf-8')

#截断 truncate()
file5 = open('a','r',encode='utf-8')
f.truncate(3)        #只保留前三个字节


#上下文管理
with open('a', 'w') as open_file ,:






# 函数

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "Q1mi"
# Date: 2017/6/12

# 1、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操作

import os


def modify(x, y, z):
    file1 = open(x, 'r')
    file2 = open('b.txt', 'w')
    for line1 in file1:
        if y in line1:
            line1 = line1.replace(y, z)
        file2.write(line1)
    file1.close()
    file2.close()
    os.remove(x)
    os.rename('b.txt', x)

# modify('a', 'ALEX', 'alexsb')
modify('a', 'alexsb', 'ALEX')

# 2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数


def classify(x):
    classify_num = 0
    classify_abc = 0
    classify_space = 0
    classify_oth = 0
    for i in x:
        if i.isdigit() is True:
            classify_num += 1
        elif i.isspace() is True:
            classify_space += 1
        elif i.isalpha() is True:
            classify_abc += 1
        else:
            classify_oth += 1
    print('num %s, abc %s, space %s, other %s' % (classify_num, classify_abc, classify_space, classify_oth))

classify('avc 132 $$$')

# 3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。


def judge_len(x):
    if len(x) > 5:
        print('大于')
    else:
        print('不大于')

judge_len(['a', 'b', 'c', 'd', 'e', 'f'])
judge_len('abc')
judge_len(('abc', 'dasdas', 'ewq', 1, 312312, 'dasda'))


# 4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

def check_space(x):
    for i in x:
        for j in i:
            if j.isspace() is True:
                print('there is space in ', x)
                break
check_space('dasdas dasdas')
check_space('dasadsad')
check_space(['ads', 'dadad ddd', 'dasda', ' '])
check_space(['ads', 'dadadddd', 'dasda', ' '])
check_space(['ads', 'dadadddd', 'dasda'])
# isspace 不能判断数字

# 5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。


def return_f2(x):
    if len(x) > 2:
        return x[0:2]
    else:
        print('长度小于2 ')
r = return_f2(['a', 'ad', 'ads', 'ads2'])
print(r)

# 6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

new_list = []


def return_ji(x):
    for i in range(0, len(x)):
        if i % 2 == 0:
            new_list.append(x[i])
    return new_list

xx = return_ji(['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7'])
print(xx)

# 7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
#  dic = {"k1": "v1v1", "k2": [11,22,33,44]}
#  PS:字典中的value只能是字符串或列表


def check_lendic(xx):
    for i in xx.keys():
        if len(xx[i]) > 2:
            xx[i] = xx[i][0:2]
    return xx
cc = check_lendic({"k1": "v1v1", "k2": [11, 22, 33, 44]})
print(cc)