python學習列表字符串字典集合文件操做字符串編碼與轉換

時間  2020-07-26
標籤 python 學習 列表 字符串 字典 集合 文件 編碼 轉換 欄目 Python 简体版
原文   原文鏈接

 

 

1、列表

 

 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

'''

2、 元組：

 元組其實和列表差很少，也是存一組數，只是它一旦建立，便沒法修改，因此又叫只讀列表。html

語法：python

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

它只有兩個方法，一個count，一個index，完畢linux

 

#購物車程序
'''
一、啓動程序後，輸入用戶名密碼後，讓用戶輸入工資，而後打印商品列表 
二、容許用戶根據商品編號購買商品 
三、用戶選擇商品後，檢測餘額是否夠，夠就直接扣款，不夠就提醒 
四、可隨時退出，退出時，打印已購買商品和餘額 
五、在用戶使用過程當中， 
關鍵輸出，如餘額，商品已加入購物車等消息，需高亮顯示 
'''
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()

 3、字符串

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()) #去掉空格和回車
print（'000Alex00'.strip(0)）#去掉字符串先後的0

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左填充

 

4、字典

字典一種key-value的數據類型，使用就像咱們上學用的字典，經過筆畫、字母來查找對應頁的詳細內容。git

語法： spring

#key - value　　
info = { 'stu1101': 'ZhangSan', 'stu1102': 'LiSi', 'stu1103': 'WangWu', }
print(info)
執行結果：
{'stu1101': 'ZhangSan', 'stu1102': 'LiSi', 'stu1103': 'WangWu'}

 字典的特性：windows

 dict是無序的。api

 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

 

5、集合

 集合是一個無序的，不重複的數據組合，它的主要做用以下：網絡

      去重，把一個列表變成集合，就自動去重了，

      關係測試，測試兩組數據之間的交集、差集、並集等關係

 

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

 

6、文件操做

#文件操做

#文件讀取 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)

 

7、字符編碼與轉碼

詳細文章：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"))
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程