LearnPython_week2

1、    列表、元组

2、    字典

3、    集合

4、    字符串的各种姿势

5、    OPEN文件操作

1、   列表、元组

列表

 names = ['wong','caiyun','dudu','junry','wong','huazai','tudou']
2 print(names)
3 print(type(names))

###查找

 # 列表是有序的，

 # 存在位置索引编号，由0开始,

 # 可以倒着取

 print(names[0])    #打印第一个元素

 print(names[-1])    #打印最后一个元素

###切片，取列表中一段元素

 # 切片用':'分隔，

 # 顺序从左到右，

 # 顾前不顾后，

 # 可以隔着取

 # 0可以忽略

 print(names[0:2])   #取编号为0-1的元素

 print(names[0:-1])

 print(names[0:])    #取编号大于等于0的元素

 print(names[:])

 print(names[:-1])   #取编号小于倒数第一个元素编号的元素

 print(names[0::2])  #从编号为0的元素开始，隔着取

 print(names[::2])

 print(names[1::2])

###追加

 names.append('我是新来的')

 print(names)

###插入

 names.insert(2,'强行插入')

 names.insert(5,'猥琐插入')

 print(names)

###修改

 names[2] = '你不能强行插入'

 print(names)

###删除

 names.pop() #删除最后一个

 print(names)

 del names[2]    #删除第三个

 print(names)

 names.remove('猥琐插入')    #删除指定元素

 print(names)

###拷贝

 # 浅拷贝，

 # 深拷贝,默认一般为浅拷贝，即只拷贝一层(列表里面可能还有列表)

 #法1

 names3 = names.copy()

 print(names3)

 #法2

 import copy

 names3.extend(['猥琐发育，别浪'])　　#合并列表

 names4 = copy.copy(names3)　　　　#浅拷贝

 names5 = copy.deepcopy(names3)　　#深拷贝

 print(names4)

关于深copy和浅copy

###扩展

 #合并列表

 names2 = [1,2,3]

 names.extend(names2)

 print(names)

 #统计

 print(names.count('wong'))

 #排序&倒转，python3中，int类型和str类型无法比较排序

 #print(names.sort())会报错

 names[7] = ''

 names[8] = ''

 names[9] = ''

 names.sort()    #从小到大

 print(names)

 names.reverse() #反转排序

 print(names)

 #获取元素下标

 print(names.index('caiyun'))

元组

'''

关于元组的简单介绍

* 元组是有序的

* 元组不可变,可理解为不可更改的列表，又叫只读列表

* 工作中通常用它在存放不可变的内容，如id

'''

fruit = ('apple','orange','banana','pear','apple','strawberry')

print(fruit.index('banana'))

print(fruit.count('apple'))

print(fruit[2])

 

2、   字典

字典

 dict = {'wong':23,'dudu':22,'caiyun':66,'junry':23,'huazai':55,'tudou':29}
 print(type(dict))
 print(dict)

###查找

 # 查找相应的key对应的value

 print(dict.get('caiyun1'))  #用get方法，如key不存在会返回None

 print(dict['caiyun'])  #直接key调用，如key不存在会报错

 # 获取字典内所有的key

 dictkey = dict.keys()

 print(dictkey)

 # 获取字典内所有的value

 print(dict.values())
  

###添加&修改

 # 如果字典中没有，则添加一项（无修改功能），

 # 以(k,d=None)的格式，默认value为空

 dict.setdefault('Cdong')

 dict.setdefault('Egeng',55)

 print(dict)

 # 添加或修改多个项，如果key已存在，则修改当前key对应的value

 dict.update({'pingan':16,'xiaomi':15,'Cdong':33})

 print(dict)

 # 单项修改

 dict['caiyun'] = 666

 print(dict.get('caiyun'))

###删除

 dict.pop('huazai')  #指定删除的元素

 print(dict)

 del dict['wong']    #其他删除方式

 print(dict)

 dict.popitem()      #随机删除一项

 print(dict)

###扩展

 # 字典返回一个列表，原字典的key和value分别作为列表内的小元组形式存在

 # for i in dict.items():

 #     for j in i:

 #         print(j)

 dict4 = dict.items()

 print(dict4)

 # 返回一个初始化字典，不同的key相同的value

 dict3 = dict.fromkeys(['dudu','caiyun','tudou'],'')

 print(dict3)

 # 字典拷贝

 dict2 = dict.copy()

 print(dict2)

 # 清空字典内容

 dict.clear()

 print(dict)

 # 删除字典

 del dict

 print(dict)

3、   集合

集合

 list1 = ['wong','成都','茂名',1,2,3,'成都']
 list2 = ['wong',11,22,33,44,'北京','wong']
 set1 = set(list1)
 set2 = set(list2)

###基本用法

 #添加

 set1.add('成都2')

 print(set1)

 #删除指定元素,如果没有这个元素，则do nothing

 set1.discard('茂名')

 print(set1)

 #删除指定元素,如果没有这个元素，则报错

 set1.remove('成都')

 print(set1)

 #删除任意元素

 set1.pop()

 print(set1)

 #清空

 set1.clear()

 print(set1)

 #拷贝

 set3 = set1.copy()

 print(set3)

###关系判断

 s = set([3,6])

 t = set([3,5,6,77])

 #交集判断，如没有交集则返回True，否则False

 print(s.isdisjoint(t))

 #set1是否包含在set2内（子集）

 print(s.issubset(t))

 print(t.issuperset(s))

###集合间操作

 ##法1

 #取差集，set1有 set2没有

 print(set1.difference(set2))  #返回差集

 set.difference_update(set2)   #执行差集修改操作

 print(set1)

 #取交集

 print(set1.intersection(set2)) #返回交集

 set1.intersection_update()      #执行交集修改操作

 print(set)

 #取对称差集，你有我没有 我没有你有

 print(set1.symmetric_difference(set2))   #返回对称差集

 set1.symmetric_difference_update(set2)   #执行对称差集修改操作

 print(set1)

 #取并集

 print(set1.union(set2))       #返回并集

 set1.update(set2)             #执行并集修改操作

 print(set1)

 ##法2

 #并集

 print(set1 | set2)

 #交集

 print(set1 & set2)

 #差集

 print(set1 - set2)

 #对称差集

 print(set1 ^ set2)

4、   字符串的各种姿势

 Introduction = '\nmy name is {_name}, I am {_age} YEARS OLD.\tHow do you do...\n'
 print(Introduction)

###判断方法

 #判断是否为数字

 age = ''

 print(age.isdigit())

 print(age.isnumeric())

 #判断是否为数字和字母的任意组合

 name = 'wong23dfd'

 print(name.isalnum())

 #判断是否全为字母

 name2 = 'wongdu'

 print(name2.isalpha())

 #判断是否只有十进制字符

 print(age.isdecimal())

 #判断字符串是否是有效的标识符，可简单理解为能成为变量名

 print(name2.isidentifier())

 #判断字符串内字母是否全为小写

 print(name.islower())

 #判断字符串中是否存在制表符

 Introduction2 = 'my name is {_name}, I am {_age} YEARS OLD.How do you do..'

 print(Introduction2.isprintable())

 #判断字符串是否为空白字符串

 space = ' \t       '

 print(space.isspace())

 #判断字符串是否为标题格式，即单词首字母全部大写

 Introduction3 = 'My Name Is Wong'

 print(Introduction3.istitle())

 #判断字符串中字母自否全为大写

 Introduction4 = '\nMY NAME IS WONG...               \n'

 print(Introduction4.isupper())

 # 判断字符串是否以...（开始）结尾

 print(Introduction.startswith('my'))

 print(Introduction.endswith('...'))

###格式化输出

 #美观输出？

 print(Introduction.center(66,'*'))  #左右补'*'

 print(Introduction.ljust(66,'#'))   #右边补'#'

 print(Introduction.rjust(66,'#'))   #左边补'#'

 print(Introduction.zfill(66))       #左边补'0'

 #格式化输出

 print(Introduction.format(_name='Wong',_age=23))

 print(Introduction.format_map( {'_name':'Wong','_age':23} ))
  

###字符串修改

 print(Introduction.capitalize())    #字符串首字母变大写，其余变小写

 print(Introduction.casefold())  #字符串变小写（其他字符也有效，如德语）

 print(Introduction.upper()) #字符串变大写

 print(Introduction.lower()) #字符串变小写

 print(Introduction.title()) #字符串变title格式，即单词首字母大写

 print(Introduction.swapcase())  #字符串大写变小写，小写变大写

 #把制表符转换成空格，默认为8个

 print(Introduction.expandtabs(50))

 #组合

 sort = ''

 print(Introduction.join(sort))

 #删除字符串首尾空格或换行符

 Introduction5 = '\t\n      MY NAME IS WONG...               \n'

 print(Introduction5.lstrip())   #左

 print(Introduction5.rstrip())   #右

 print(Introduction5.strip())    #左右

 #列表单个字符一一替换；a-->1，o-->2

 print(Introduction.maketrans('ao',''))

 print(Introduction.translate(Introduction.maketrans('ao','')))

 #字符串替换

 print(Introduction.replace('name',''))

 #指定分隔符将字符串分成3段组成元组，如分隔符不存在，则在字符串末尾加两个空元素

 print(Introduction.partition('names'))

 print(type(Introduction.partition('a')))

 #指定分隔符，将字符串分隔成为列表，默认分隔符为空格

 print(Introduction.rsplit('a',3))    #从右开始

 print(Introduction.split('a',2))    #从左开始

 print(Introduction.splitlines(keepends=False))  #行符分割
  

###其他姿势

 #统计
 print(Introduction.count('do')) 

 #指定字符串编码格式

 print(Introduction.encode(encoding='utf-8').decode())

 #从左边开始，查看符合的第一个字符串所在下标，不存在返回-1

 print(Introduction.find('name'))

 #从右边开始，查看符合的第一个字符串所在下标，不存在返回-1

 print(Introduction.rfind('name'))

 #从右边开始，返回符合的第一个字符串所在的下标，不存在则报错

 print(Introduction.index('name'))

 #从右边开始，返回符合的第一个字符串所在的下标，不存在则报错
 print(Introduction.rindex('name'))
  

 

5、   OPEN文件操作

文件操作流程
1、打开文件，得到文件句柄并赋值给一个变量
2、通过句柄对文件进行操作
3、关闭文件

文件操作基本格式

 # f = open('song','r',encoding='utf-8')     #打开

 # fread = f.readline()    #读取一行

 # print(fread)

 # print('分割线'.center(50,'*'))

 # print(f.read())     #当文件过大时，很耗费内存

 #

 # f.close()      #关闭
  

###打开模式
r 以读的方式打开文件，只读
w 以写的方式打开文件，一打开就清空文件，可用来创建文件
a 以追加的方式打开文件，可在文件内容末尾追加内容

+ 可写又可读，如下：
r+ 打开文件，可读写
w+ 打开文件，覆盖文件原本内容，可读写

a+ 和r+差不多

U 表示在读取时，可以将 \r \n \r\n自动转换成 \n
（与 r 或 r+ 模式同使用）
比如：rU、r+U

b 表示处理二进制文件
比如：rb、wb、ab

为了避免打开文件后忘记关闭，可以通过with打开文件，当with结束，文件关闭

 with open('song','r',encoding='utf-8') as f:

      pass

6、小结：
关于文件读取，我们应尽量的少占用内存资源。如下两个例子：
### 字典

 dict = {
     'wong':23,
     'tudou':29,
     'Egeng':36
 }
 #把dict直接一次性读到内存中，再取出来，耗费内存，不建议使用
 for k,v in dict.items():
     print(k,v)
 #每次循环只读取dict的一个key和value，建议使用
 for i in dict:
     print(i,dict[i])

###文件操作

 #把文件内容全部读取到内存中，再进行调用，耗费内存，不建议使用
 f = open('song','r',encoding='utf-8')   #打开
 f_read = f.readlines()  #读取成列表的形式到内存
 for f_list in f_read:
     print(f_list.strip())
 f.close()
 #每次循环只读取f文件的一行，建议使用
 f = open('song','r',encoding='utf-8')   #打开
 for line in f:
     print(line.strip())
 f.close()

2018-02-24