一、列表

 1 names = "ZhangYang GuYun XiangPeng XuLiangchen"
 2 names = ["ZhangYang", "GuYun", "XiangPeng", "ChengRongHua","XuLiangchen"]
 3 names.append("LeiHaiDong") #在列表最后追加一个元素
 4 names.insert(1,"ChengRongHua")#在列表中插入一个元素，insert后第一个参数是要插入的下表值，第二个参数是要插入的元素
 5 names.insert(3,"XinZhiYu")
 6 #names[2] = "XieDi" #替换列表下标为2的元素为XieDi
 7 print(names)
 8 #print(names[0],names[2]) #取列表值，第一个从0开始
 9 #print(names[1:3])#切片
10 #print(names[-1])#切片取最后一个值
11 #print(names[-2:])#切片取最后两个值
12 #print(names[:3])#切片取前三个值
13 # delete
14 #names.remove("ChengRongHua") #按照查找元素删除
15 #del names[1] #删除下标为1的元素
16 #names.pop() #默认删除列表最后一个元素
17 #names.pop(1)#删除下标为1的元素与 del names[1] 效果相等
18 #print(names.index("GuYun")) #查找列表中GuYun所在的位置
19 #print(names[names.index("GuYun")])#查找列表中GuYun所在的位置,并将查找位置当列表值的下标
20 #print(names.count("ChengRongHua"))#统计列表中元素是ChengRongHua的数量
21 #names.clear()#
22 #names.reverse()#列表反转,最后一个元素与第一个元素对调，后续依次类推
23 #names.sort()#列表排序，排序规则按照ASCII排序
24 names2 = ["LiJian","LiLei"]
25 names.extend(names2) #将names2列表合并到names最后面
26 del names2 #删除names2整个列表

#列表copy 浅copy 和深copy 列表外层被完整复制，当原列表发生变化后，新复制的列表不变
import copy

names = ["ZhangYang", "GuYun", "XiangPeng", "ChengRongHua","XuLiangchen"]
names.insert(3,"XinZhiYu")
#print(names)
names2 = names.copy()
print(names,‘\n‘,names2)
names[3] = "向鹏"
print("----------------")
print(names,‘\n‘,names2)

‘‘‘
执行结果
E:\software\pystudy\venv\Scripts\python.exe E:/software/pystudy/day2/names.py
[‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘XinZhiYu‘, ‘ChengRongHua‘, ‘XuLiangchen‘]
 [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘XinZhiYu‘, ‘ChengRongHua‘, ‘XuLiangchen‘]
----------------
[‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘向鹏‘, ‘ChengRongHua‘, ‘XuLiangchen‘]
 [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘XinZhiYu‘, ‘ChengRongHua‘, ‘XuLiangchen‘]

Process finished with exit code 0

‘‘‘

#列表copy 浅copy 和深copy 列表外层被完整复制,但被复制的列表中的子列表发生改变时，新列表也会同时发生变化，这是由于子列表在内存中保存机制导致，
#子列表打印时调用的是内存地址，并不是子列表本身元素值。#当执行names.copy时，实际上子列表是copy的内存地址
import copy

names = ["ZhangYang", "GuYun", "XiangPeng", ["alex", "Jack"], "ChengRongHua","XuLiangchen"]
#print(names)
names2 = names.copy()
print(names, ‘\n‘, names2)
names[2] = "向鹏"
names[3][0] = "ALEX"
print("----------------")
print(names, ‘\n‘, names2)

‘‘‘
 E:\software\pystudy\venv\Scripts\python.exe E:/software/pystudy/day2/names.py
[‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
 [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
----------------
[‘ZhangYang‘, ‘GuYun‘, ‘向鹏‘, [‘ALEX‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
 [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘ALEX‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]

Process finished with exit code 0
‘‘‘

#列表copy 深copy 是完成创建一个相同的列表，完全独立的两个列表
import copy

names = ["ZhangYang", "GuYun", "XiangPeng", ["alex", "Jack"], "ChengRongHua","XuLiangchen"]
#print(names)
names2 = copy.deepcopy(names)
print(names, ‘\n‘, names2)
names[2] = "向鹏"
names[3][0] = "ALEX"
print("----------------")
print(names, ‘\n‘, names2)

‘‘‘
E:\software\pystudy\venv\Scripts\python.exe E:/software/pystudy/day2/names.py
[‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
 [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
----------------
[‘ZhangYang‘, ‘GuYun‘, ‘向鹏‘, [‘ALEX‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
 [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]

Process finished with exit code 0
‘‘‘

#列表 循环

names = ["ZhangYang", "GuYun", "XiangPeng", ["alex", "Jack"], "ChengRongHua","XuLiangchen"]
print(names )
print("------------")
for i in names:
    print(i)
print("------------")
print(names[0:-1:2] )#切片步长取列表值，列表从第一个元素起，每间隔一个元素，打印一个元素
print(names[0:-1:2] )#与上面结果相同

‘‘‘
E:\software\pystudy\venv\Scripts\python.exe E:/software/pystudy/day2/names.py
[‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
------------E:\software\pystudy\venv\Scripts\python.exe E:/software/pystudy/day2/names.py
[‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘]
------------
ZhangYang
GuYun
XiangPeng
[‘alex‘, ‘Jack‘]
ChengRongHua
XuLiangchen
------------
[‘ZhangYang‘, ‘XiangPeng‘, ‘ChengRongHua‘]
[‘ZhangYang‘, ‘XiangPeng‘, ‘ChengRongHua‘]

Process finished with exit code 0

‘‘‘

二、 元组：

元组其实和列表差不多，也是存一组数，只是它一旦创建，便无法修改，所以又叫只读列表。

语法：

   names("alex", "jack", "eric")

它只有两个方法，一个count，一个index，完毕

#购物车程序
‘‘‘
1、启动程序后，输入用户名密码后，让用户输入工资，然后打印商品列表
2、允许用户根据商品编号购买商品
3、用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
4、可随时退出，退出时，打印已购买商品和余额
5、在用户使用过程中，
关键输出，如余额，商品已加入购物车等消息，需高亮显示
‘‘‘
product_list = [
    (‘Iphone‘, 5800,),
    (‘Mac Pro‘, 9800),
    (‘Bike‘, 800),
    (‘Watch‘, 10600),
    (‘Coffee‘, 31),
    (‘Alex Python‘, 120),
]
shoping_list = [] #定义临时列表存放已购买的商品
salary = input("Input your salary:")
if salary.isdigit(): #isdigit 判断整数
    salary = int(salary)
    while True:
        for index, item in enumerate(product_list):#enumerate将列表下标取出来
            print(index, item)
        user_choice = input("选择要购买的商品>>>:")
        if user_choice.isdigit():#isdigit判断是否是数字
            user_choice = int(user_choice)
            if user_choice < len(product_list) and user_choice  >= 0:
                p_item = product_list[user_choice]
                if p_item[1] <= salary: #工资够买选择的商品
                    shoping_list.append(p_item)
                    salary -= p_item[1]
                    print("Added  %s into shopping cart, you current balance is \033[31;1m%s\033[0m" %(p_item,salary)) #打印字体为红色，31是红色，32是绿色 33 黄色
                else:
                    print("\033[41;1m你的余额只剩[%s]啦，不够支付本次购买商品!\033[0m"  % salary) #打印背景为红色
            else:
                print("product code \033[34;1m[%s]\033[0m is not exists!" % user_choice) #34蓝色
        elif user_choice == ‘q‘:
            print("--------------shopping list ------------")
            for item_list in shoping_list:
                print(item_list)
            print("you current balance is \033[33;1m%s\033[0m" % salary)
            exit()
        else:
            print("invalid option")
else:
    print("invalid salary!")
    exit()

三、字符串

name = "my name is alex"
name2 = "我是人民子弟兵"
print(name2.encode("utf-8")) #将字符串转换成二进制
print(name.count("a")) #统计字符串中有多少个a
print(name.capitalize())#字符串首字母大写
print(name.center(50, "-")) #字符串打印总长度50，不够用"-"补齐，并将name字符串居中显示
print(name.endswith("ex")) #以什么结尾 返回True or False

name = "my \tname is alex"
print(name.expandtabs(tabsize=5))# 将\t table键 转换成多少空格
print(name.find(‘name‘)) #查找某个字符/字符串开始位置 字符串第一个字符从0开始，\t算一个table键，所以name前面有4个字符
print(name[name.find(‘name‘):]) #字符串切片

name ="my \tname is {name} and i am {year} old"
print(name.format(name=‘alex‘, year=23)) #format 将花括号中的变量赋值，  打印结果：my     name is alex and i am 23 old
print(name.format_map({‘name‘:‘alex‘,‘year‘:12}))#format_map 是用字典的形式给变量传值。此语法很少用
print(name.index(‘n‘))#字符串索引开始位置，\t算一个table键，所以n前面有4个字符 打印结果：4
print(‘aA23‘.isalnum()) #判断是否是安拉博字符(英文字符和数字) 执行结果：True
print(‘aA 23‘.isalnum()) #判断是否是安拉博字符(英文字符和数字) 执行结果：False
print(‘aAb‘.isalpha()) #判断是否是纯英文字符  执行结果：True
print(‘aA2b‘.isalpha()) #判断是否是纯英文字符  执行结果：False
print(‘0x1A‘.isdecimal()) #判断是否是十进制   执行结果：False
print(‘987‘.isdecimal()) #判断是否是十进制   执行结果：True
print(‘1.2‘.isdigit()) #判断是否是一个整数 执行结果：False
print(‘133‘.isdigit()) #判断是否是一个整数 执行结果：True
print(‘__‘.isidentifier()) #判断是否是一个合法的标识符(变量名) 执行结果：True
print(‘1__‘.isidentifier()) #判断是否是一个合法的标识符(变量名) 执行结果：False 变量名只能以_和英文字母开头，不能以数字开头
print(‘aa‘.isnumeric()) #判断是不是一个数字 执行结果：False
print(‘33‘.isnumeric()) #判断是不是一个数字 执行结果：True
print(" ".isspace()) #判断是否是一个空格 执行结果：True
print(‘My Name Is‘.istitle()) #判断是否是一个标题 每个单词首字母要大写 执行结果：True
print(‘My Name Is‘.isprintable()) #判断是否能打印，字符串都是可以打印的，只有linux中设备tty开头的文件不能打印的
print(‘My Name Is‘.isupper()) #判断字符串全是大写
print(‘,‘.join([‘1‘,‘2‘,‘3‘,‘4‘])) #把列表变成字符串 执行结果：1,2,3,4
print(‘+‘.join([‘1‘,‘2‘,‘3‘,‘4‘])) #把列表变成字符串 执行结果：1+2+3+4
print(name.ljust(50,‘*‘)) #长度50 不够用*补 补后面
print(name.rjust(50,‘-‘)) #长度50 不够补 补前面
print(‘ALEX‘.lower()) #把大写变成小写
print("alex".upper()) #小写变成大写
print(‘\nAlex‘.lstrip()) #从左边去空格和回车
print(‘Alex\n‘.rstrip()) #从右边去掉空格和回车
print(‘\n Alex\n‘.strip()) #去掉空格和回车
p = str.maketrans(‘abcdef‘,‘123456‘)
print(‘abcdefalex li‘.translate(p)) #maketrans将字符串abcde替换成123456，a换成1，b换成2 称为加密
print(‘alex li‘.replace(‘l‘,‘L‘,1)) #替换字符串，将小写l替换成大写L，最后一个参数是替换几个， 执行结果：aLex li
print(‘alex li‘.replace(‘l‘,‘L‘,2)) #替换字符串，将小写l替换成大写L，最后一个参数是替换几个， 执行结果：aLex Li
print(‘alex li‘.rfind(‘ex‘)) #字符/字符串最后出现的位置 执行结果：2
print(‘alex li ex‘.rfind(‘ex‘)) #字符/字符串最后出现的位置 执行结果：8
print("alex".split(‘e‘)) #按照关键字将字符串分成列表 执行结果为：[‘al‘, ‘x‘]
print(‘1+2+\n3+4‘.splitlines()) #按换行符分成列表  执行结果为：[‘1+2+‘, ‘3+4‘]
print(‘1+2+\n3+4‘.startswith(‘1+‘)) #以关键字开头 执行结果：True
print(‘1+2+\n3+4‘.startswith(‘+‘)) #以关键字开头 执行结果：False
print(‘Alex Li‘.swapcase()) #大小写颠倒 执行结果：aLEX lI
print(‘Alex i‘.title()) #把每个单词首字母变成大写 执行结果：Alex I
print(‘lex li‘.zfill(50)) #50字符 不够用0左填充

四、字典

字典一种key-value的数据类型，使用就像我们上学用的字典，通过笔画、字母来查找对应页的详细内容。

语法：

#key - value　　info = {
 ‘stu1101‘: ‘ZhangSan‘,
 ‘stu1102‘: ‘LiSi‘,
 ‘stu1103‘: ‘WangWu‘,
}print(info)执行结果：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘, ‘stu1103‘: ‘WangWu‘}

字典的特性：

 dict是无序的。

 key必须是唯一的，so天生去重

# 字典的增删改查
info = {
 ‘stu1101‘: ‘ZhangSan‘,
 ‘stu1102‘: ‘LiSi‘,
 ‘stu1103‘: ‘WangWu‘,
}

#print(info["stu1102"]) #根据字典的key值查找后面的value 执行结果：LiSi
#print(info["stu1104"]) #根据字典的key值查找后面的value 执行结果：LiSi ,如果字典中没有key值，程序就抛异常
#print(info.get("stu1104"))#安全查找方法，如果有就返回，无就返回none
#print("stu1103" in info ) #判断字典中的key值是否存在，存在返回True 不存在返回flase

#info["stu1102"] = "李四"#根据字典的key值修改后面的value值 打印执行结果为：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘李四‘, ‘stu1103‘: ‘WangWu‘}
#info["stu1106"] = "李四" #如果要修改的字典的key值不存在，就添加到字典中 打印执行结果为：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘, ‘stu1103‘: ‘WangWu‘, ‘stu1106‘: ‘李四‘}
b = {‘stu1101‘: ‘ZhangSan‘,
     "stu1108": "zsy",
     "stu1109": "ts",}
info.update(b) #字典合并，info中有的值保留，b字典中如果有info中的key值的，更新字典中的值。执行结果：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘, ‘stu1103‘: ‘WangWu‘, ‘stu1108‘: ‘zsy‘, ‘stu1109‘: ‘ts‘}
print(info.items())#将字典转换成列表：执行结果：dict_items([(‘stu1101‘, ‘ZhangSan‘), (‘stu1102‘, ‘LiSi‘), (‘stu1103‘, ‘WangWu‘), (‘stu1108‘, ‘zsy‘), (‘stu1109‘, ‘ts‘)])
# del
#del info #删除整个字典
#del info["stu1102"] #删除字典中key值是stu1102的元素 ：执行结果：{‘stu1101‘: ‘ZhangSan‘, ‘stu1103‘: ‘WangWu‘}
#info.pop("stu1102") #删除字典中key值是stu1102的元素 ：执行结果：{‘stu1101‘: ‘ZhangSan‘, ‘stu1103‘: ‘WangWu‘}
#info.popitem()#随机删除字典中一个元素 执行结果为：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘}

print(info)

#字典的循环for i in info:    print(i, info[i])

#dict1 = info.fromkeys([‘5‘,‘8‘,‘9‘]) #创建一个字典，每个value值都为空 dict1 = info.fromkeys([5, 8, 9], "ys") #创建一个字典，每个value值都为ys dict1[8] = "ysys" #如果字典value是字符串等简单的数据类型，修改value修改的只是对应的value print(dict1) dict1 = info.fromkeys([‘5‘, ‘8‘, ‘9‘] , ["776", {"name" : "alex"}, "98"]) #创建一个字典，每个value值都为列表 ["776",{"name" : "alex"},"98"] dict1[‘8‘][1] ["name"] = "spring" #如果字典value是列表，修改value值时，对应的每个key值的value都会修改，此时的value实际上对应的是内存地址。 print(dict1)

多级字典：

#字典的多级嵌套---三级菜单（三种方式）

#要求：
#1.可以进入子菜单
#2.可以返回上一级
#3.可以从任意一级直接退出
data = {
         ‘山东‘: {
                   ‘青岛‘: [‘四方‘, ‘黄岛‘, ‘崂山‘, ‘李沧‘, ‘城阳‘],
                   ‘济南‘: [‘历城‘, ‘槐荫‘, ‘高新‘, ‘长青‘, ‘章丘‘],
                   ‘烟台‘: [‘龙口‘, ‘莱山‘, ‘牟平‘, ‘蓬莱‘, ‘招远‘]
                 },
         ‘江苏‘: {
                   ‘苏州‘: [‘沧浪‘, ‘相城‘, ‘平江‘, ‘吴中‘, ‘昆山‘],
                   ‘南京‘: {‘白下‘:[‘超市‘,‘便利店‘], ‘秦淮‘:[‘超市‘,‘便利店‘], ‘浦口‘:[‘超市‘,‘便利店‘], ‘栖霞‘:[‘超市‘,‘便利店‘], ‘江宁‘:[‘超市‘,‘便利店‘]},
                   ‘无锡‘: [‘崇安‘, ‘南长‘, ‘北塘‘, ‘锡山‘, ‘江阴‘]
                 },
         }
# key值尽量不要写中文，可能会存在字符编码导致无法正常操作
#data["江苏"]["无锡"][2] = "北塘" #修改字典key对应的value值，执行结果为：{‘山东‘: {‘青岛‘: [‘四方‘, ‘黄岛‘, ‘崂山‘, ‘李沧‘, ‘城阳‘], ‘济南‘: [‘历城‘, ‘槐荫‘, ‘高新‘, ‘长青‘, ‘章丘‘], ‘烟台‘: [‘龙口‘, ‘莱山‘, ‘牟平‘, ‘蓬莱‘, ‘招远‘]}, ‘江苏‘: {‘苏州‘: [‘沧浪‘, ‘相城‘, ‘平江‘, ‘吴中‘, ‘昆山‘], ‘南京‘: [‘白下‘, ‘秦淮‘, ‘浦口‘, ‘栖霞‘, ‘江宁‘], ‘无锡‘: [‘崇安‘, ‘南长‘, ‘北塘‘, ‘锡山‘, ‘江阴‘]}}
#data.setdefault("QH",{"XN" : "huangzhong"}) #字典中创建一个新值，如果要创建的值字典中存在，就保留原值不变，创建无效
#print(data)

#城市只能选择南京，其他的数据最下层不对
exit_flag = False
while not exit_flag:
  for i in data:
      print(i)
  choice = input("请选择进入省份》》：")
  if choice in data:
      while not exit_flag:
          for j in data[choice]:
              print("\t", j)
          choice2 = input("请选择进入城市》》：")
          if choice2 in data[choice]:
              while not exit_flag:
                  for k in data[choice][choice2]:
                      print("\t\t",k)
                  choice3 = input("请选择进入区县》》：")
                  if choice3 in data[choice][choice2]:
                      for l in data[choice][choice2][choice3]:
                          print("\t\t\t",l)
                      choice4 = input("进入最后一层了，选择b返回，q退出》》：")
                      if choice4 == "b":
                         pass
                      elif choice4 == "q":
                         exit_flag = True
                  elif  choice3 == "b":
                      break
                  elif  choice3 == "q":
                      exit_flag = True
          elif  choice2 == "b":
              break
          elif  choice2 == "q":
              exit_flag = True
  elif choice == "q":
      exit_flag = True

五、集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

去重，把一个列表变成集合，就自动去重了，

关系测试，测试两组数据之间的交集、差集、并集等关系

list_1=[1, 3, 5, 7, 9]
list_1 = set(list_1)
#print(list_1, type(list_1)) #打印集合，以及集合类型

list_2 = set([2, 4, 6, 3, 9, 10])
print(list_1, list_2) # 执行结果：{1, 3, 5, 7, 9} {2, 3, 4, 6, 9, 10}
#交集
print(list_1.intersection(list_2)) # 交集是将两个集合中共有的元素，执行结果:{9, 3}
print(list_1 & list_2) #交集的运算符写法
#并集
print(list_1.union(list_2)) #并集是将两个集合合并，重复的元素只显示一次，执行结果：{1, 2, 3, 4, 5, 6, 7, 9, 10}
print(list_1 | list_2)
#差集
print(list_1.difference(list_2)) #差集是去掉两个集合中共有的元素，显示list_1剩余的元素，执行结果：{1, 5, 7}
print(list_2.difference(list_1)) #差集是去掉两个集合中共有的元素，显示list_2剩余的元素，执行结果：{2, 10, 4, 6}
print(list_1 - list_2)
print(list_2 - list_1)
#子集
list_3 = set([3,5,7])
print(list_3.issubset(list_1)) #子集是判断list_1中是否全部包含list_3的元素，执行结果：True
print(list_3.issubset(list_2))# 执行结果：False

#父集
print(list_1.issuperset(list_3)) #执行结果：True

#对称差集
print(list_1.symmetric_difference(list_2)) #对称差集是将两个集合合并，两个集合中重复的元素全部去除掉，执行结果：{1, 2, 4, 5, 6, 7, 10}
print(list_1 ^ list_2)

#其他关系测试
list_4 = set([2,4,6])
print(list_1.isdisjoint(list_2)) #如果两个集合中没有交集，返回Ture,执行结果：False
print(list_1.isdisjoint(list_4))#执行结果：True

#集合添加操作
list_1.add(99)
print(list_1) #执行结果：{1, 3, 99, 5, 7, 9}
list_1.update([888, 444, 333])
print(list_1)#添加多个元素，执行结果：{1, 3, 99, 5, 7, 9, 333, 888, 444}
#集合的删除，集合是去重的，不可能有重复的元素
list_1.remove(99) #删除如果不存在的元素，系统会提示异常
print(list_1)#执行结果：{1, 3, 5, 7, 9, 333, 888, 444}
print(list_2.pop())#删除任意一个集合中的元素，并返回删除的元素，执行结果：2
list_2.discard(8)#删除不存在的元素不会提示异常
print(list_2)#执行结果：{3, 4, 6, 9, 10}
list_2.discard(10)#删除不存在的元素不会提示异常
print(list_2)#执行结果：{3, 4, 6, 9}

#集合的长度
print(len(list_1))#执行结果：8
#检查元素是否在集合中存在
print(9 in list_1)#执行结果：True
#检查元素是否不是集合中的成员
print(9 not in list_1) #执行结果：False
print(6 not in list_1) #执行结果：True

六、文件操作

#文件操作

#文件读取 r是文件读模式，w是文件的写模式是创建文件，如果原来有文件就会覆盖原来的文件；a=append是文件的追加模式，不能读取文件
f = open("yesterday",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象
data = f.read() #当文件被读取后，第二次再读取文件已经跳的行尾，所以再次读取文件是就读不到文件
data2 = f.read()
f.close()
print(data)
print("--data2--", data2)

#文件写操作，w模式
#读取到yesterday中内容，写入yesterday2中
f = open("yesterday",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象
data = f.read() #当文件被读取后，第二次再读取文件已经跳的行尾，所以再次读取文件是就读不到文件
f.close()
f = open("yesterday2", ‘w‘, encoding="utf-8") #文件的句柄，也就是内存对象
f.write(data)
f.close()
#文件的追加操作 a=append,不能读取文件.
f = open("yesterday2", ‘a‘, encoding="utf-8") #文件的句柄，也就是内存对象
f.write("我爱北京天安门\n")
f.write("天安门上太阳升\n")
f.close()

#文件的循环读取操作，要求第十行不打印,f.readlines()是默认将文件预先读取到内存中，如果文件太大就无法使用该方法.
f = open("yesterday2",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象
for index, line in enumerate(f.readlines()):#f.readlines()是把文件读取成一个列表，enumerate取列表下标，
    if index == 9:
        print("------我是分割线--------") #为了标识清楚，打印成分割线
        continue
    print(index,line.strip())#windows文件存储，默认每行后面有换行符，strip作用是去掉换行和回车
f.close()
#文件的高效读取，逐行读取文件，读取完成后释放内存，使用迭代技术，后面会学到
count =0
f = open("yesterday2",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象
for line in f:
     if count == 9:
        print("------我是分割线--------") #为了标识清楚，打印成分割线
        count += 1
        continue
     print(count, line)
     count += 1
f.close()

#进度条
import sys, time

for i in range(50):
    sys.stdout.write("#") #stdout标准输出方法
    sys.stdout.flush()
    time.sleep(0.1)

#文件操作方法
f = open("yesterday2",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象
print(f.tell()) #查看文件光标，文件开始从0开始，
print(f.readline()) #f.readline()读取文件中一行内容
#print(f.read(5)) #读取5个字符
print(f.encoding)#打印文件编码
print(f.fileno())#返回文件句柄在内存中的编号，python打开文件实际上是调用操作系统方法接口实现的，文件系统是给所有程序使用的。 基本上不用它
print(f.name) #打印文件名称
#f.readable() f.writable() #后面自己学习
print(f.flush()) #写文件时，系统不是把每次的操作都写入硬盘，有一个内存缓存，会先写入内存缓存中，在提交到硬盘中，执行f.flush()会立马将文件写入硬盘
print(f.tell()) #查看文件光标，文件开始从0开始，当用f.readlines()方法读取文件后，f.readlines()值变为32，tell的计数是按照字符串个数计数的，并不是读取一行后tell值变为1
f.seek(0)#将光标移到文件开始位置，也可以f.seek(10)的位置
#f.truncate() #清除全部文件，慎用
f.truncate(20)#截断文件，保留前20个字符

#文件的读写模式 r+ ，文件写的内容只能添加的文件最后，不能修改原文件原来的内容
f = open("yesterday2",‘r+‘,encoding="utf-8") #文件的句柄，也就是内存对象
print(f.readline())
print(f.readline())
print(f.readline())
f.write("你好，python")

文件操作还有w+模式 a+模式 基本不用，就不举例了，wb和rb模式是二进制文件，网络传输会用到。

#文件修改，将一个文件逐行读出，并查找到要修改的内容，将原来的内容替换成新的内容，将原文件逐行写入新文件中
f = open("yesterday2", ‘r‘, encoding="utf-8") #文件的句柄，也就是内存对象
f_new = open("yesterday3", ‘w‘, encoding="utf-8") #文件的句柄，也就是内存对象

for line in f:
    if "有那么多肆意的快乐等我享受" in line: #要查找的内容在这行存在
        line = line.replace("有那么多肆意的快乐等我享受", "有那么多肆意的快乐等ALEX享受")
    f_new.write(line)
f.close()
f_new.close()

#with 语法 ,好处不用自己关闭文件。
print("------------with------------")
with  open("yesterday2", ‘r‘, encoding="utf-8")  as f:
    for line in f:
        print(line)
#同时打开多个文件， 新的写法，如果一行过长为了便于查看代码，可以用\符号，再第二行再写
with  open("yesterday2", ‘r‘, encoding="utf-8")  as f,         open("yesterday3", ‘r‘, encoding="utf-8")  as f2:
    for line in f:
        print(line)

七、字符编码与转码

详细文章：https://www.cnblogs.com/luotianshuai/p/5735051.html

课程笔记地址：https://www.cnblogs.com/alex3714/articles/5717620.html

https://www.cnblogs.com/alex3714/articles/5740985.html

先说python2

1. py2里默认编码是ascii
2. 文件开头那个编码声明是告诉解释这个代码的程序 以什么编码格式 把这段代码读入到内存，因为到了内存里，这段代码其实是以bytes二进制格式存的，不过即使是2进制流，也可以按不同的编码格式转成2进制流，你懂么？
3. 如果在文件头声明了#_*_coding:utf-8*_，就可以写中文了， 不声明的话，python在处理这段代码时按ascii，显然会出错， 加了这个声明后，里面的代码就全是utf-8格式了
4. 在有#_*_coding:utf-8*_的情况下，你在声明变量如果写成name=u"大保健"，那这个字符就是unicode格式，不加这个u,那你声明的字符串就是utf-8格式
5. utf-8 to gbk怎么转，utf8先decode成unicode,再encode成gbk

再说python3

1. py3里默认文件编码就是utf-8,所以可以直接写中文，也不需要文件头声明编码了，干的漂亮
2. 你声明的变量默认是unicode编码，不是utf-8, 因为默认即是unicode了（不像在py2里，你想直接声明成unicode还得在变量前加个u）, 此时你想转成gbk的话，直接your_str.encode("gbk")即可以
3. 但py3里，你在your_str.encode("gbk")时，感觉好像还加了一个动作，就是就是encode的数据变成了bytes里，我擦，这是怎么个情况，因为在py3里，str and bytes做了明确的区分，你可以理解为bytes就是2进制流，你会说，我看到的不是010101这样的2进制呀， 那是因为python为了让你能对数据进行操作而在内存级别又帮你做了一层封装，否则让你直接看到一堆2进制，你能看出哪个字符对应哪段2进制么？什么？自己换算，得了吧，你连超过2位数的数字加减运算都费劲，还还是省省心吧。　　
4. 那你说，在py2里好像也有bytes呀，是的，不过py2里的bytes只是对str做了个别名(python2里的str就是bytes, py3里的str是unicode)，没有像py3一样给你显示的多出来一层封装，但其实其内部还是封装了的。 这么讲吧， 无论是2还是三， 从硬盘到内存，数据格式都是 010101二进制到-->b‘\xe4\xbd\xa0\xe5\xa5\xbd‘ bytes类型－－>按照指定编码转成你能看懂的文字

编码应用比较多的场景应该是爬虫了，互联网上很多网站用的编码格式很杂，虽然整体趋向都变成utf-8，但现在还是很杂，所以爬网页时就需要你进行各种编码的转换，不过生活正在变美好，期待一个不需要转码的世界。

最后，编码is a piece of fucking shit, noboby likes it.

#encode编码 decode 解码
#python3中encode编码后除了将编码集修改，同时将字符串变成byte类型。
import sys
print(sys.getdefaultencoding())

s = "你好"
print("1-----", type(s))
s_to_gbk = s.encode("gbk")
print("2-----", s_to_gbk)#python3中默认是unicode，python2中默认是ascii码， 所以在python3中不需要将中文先解码成utf-8，可以直接编码成gbk。执行结果：b‘\xc4\xe3\xba\xc3‘
print(s_to_gbk.decode("gbk").encode("utf-8").decode()) #针对socket网络传输的bytes是gbk格式的，使用此语句就可以将bytes转码成utf-8正常显示。
gbk_to_unicode = s_to_gbk.decode("gbk") #将gbk解码变成unicode
print("3------", gbk_to_unicode)
print("4-------", type(gbk_to_unicode))
gbk_to_utf8 = gbk_to_unicode.encode("utf-8")#将unicode编码成utf-8
print(gbk_to_utf8)
print(type(gbk_to_utf8))
gbk_to_utf8 = gbk_to_utf8.decode("utf-8")
print(type(gbk_to_utf8))
print(gbk_to_utf8)

#print(s.encode("gbk").decode("gbk").encode("utf-8").decode("utf-8"))

原文地址：https://www.cnblogs.com/spring33410/p/12318041.html