Python自学--part2

概要

1. 列表、元组操作
2. 字符串操作
3. 字典操作
4. 集合操作
5. 文件操作
6. 字符编码与转码

---

一、列表、元祖操作

列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作

定义列表

 names = ['Richard',"Tom",'Jack']

通过下标访问列表中的元素，下标从0开始计数

 >>> names[0]
 'Richard'
 >>> names[2]
 'Jack'
 >>> names[-1]
 'Jack'
 >>> names[-2] #还可以倒着取
 'Tom'

切片:取多个元素

 >>> names = ["Richard", "Tom", "Jack", "Rain", "Bob", "Amy"]
 >>> names[1:4]    #取下标1至下标4之间的数字，包括1，不包括4
 ['Tom', 'Jack', 'Rain']
 >>> names[1:-1]    #取下标1至-1的值，不包括-1
 ['Tom', 'Jack', 'Rain', 'Bob']
 >>> names[0:3]
 ['Richard', 'Tom', 'Jack']
 >>> names[:3]    #如果是从头开始取，0可以忽略，跟上句效果一样
 ['Richard', 'Tom', 'Jack']
 >>> names[3:]    #如果想取最后一个，必须不能写-1，只能这么写
 ['Rain', 'Bob', 'Amy']
 >>> names[3:-1]    #这样-1就不会被包含了
 ['Rain', 'Bob']
 >>> names[0::2]    #后面的2是代表，每隔一个元素，就取一个
 ['Richard', 'Jack', 'Bob']
 >>> names[::2]    #和上一句效果一样
 ['Richard', 'Jack', 'Bob']

追加

 >>> names = ["Richard", "Tom", "Jack", "Rain", "Bob", "Amy"]
 >>> names.append("Jim")
 >>> names
 ['Richard', 'Tom', 'Jack', 'Rain', 'Bob', 'Amy', 'Jim']

插入

 >>> names
 ['Richard', 'Tom', 'Jack', 'Rain', 'Bob', 'Amy', 'Jim']
 >>> names.insert(2,"强行从Jack前面插入")
 >>> names
 ['Richard', 'Tom', '强行从Jack前面插入', 'Jack', 'Rain', 'Bob', 'Amy', 'Jim']
 >>> names.insert(5,"从Jack后面插入")
 >>> names
 ['Richard', 'Tom', '强行从Jack前面插入', 'Jack', 'Rain', '从Jack后面插入', 'Bob', 'Amy', 'Jim']
 >>> 

修改

 >>> names
 ['Richard', 'Tom', '强行从Jack前面插入', 'Jack', 'Rain', '从Jack后面插入', 'Bob', 'Amy', 'Jim']
 >>> names[2] = "该换人了"
 >>> names
 ['Richard', 'Tom', '该换人了', 'Jack', 'Rain', '从Jack后面插入', 'Bob', 'Amy', 'Jim']
 >>> 

删除

 >>> del names[2] #删除指定位置的值
 >>> names
 ['Richard', 'Tom', 'Jack', 'Rain', '从Jack后面插入', 'Bob', 'Amy', 'Jim']
 >>> del names[4]
 >>> names
 ['Richard', 'Tom', 'Jack', 'Rain', 'Bob', 'Amy', 'Jim']

 >>> names.remove("Tom") #删除指定元素
 >>> names
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy', 'Jim']

 >>> names.pop() #删除列表最后一个值，并返回结果
 'Jim'
 >>> names
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy']

扩展

 >>> names
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy']
 >>> b = [1,2,3]
 >>> names.extend(b)
 >>> names
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy', 1, 2, 3]

拷贝

 >>> names
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy', 1, 2, 3]
 >>> name_copy = names.copy()
 >>> name_copy
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy', 1, 2, 3]

关于浅拷贝和深拷贝后面再补充。。。

统计

 >>> names
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy', 1, 2, 3]
 >>> names.count("Richard")
 1

排序&翻转

 >>> names
 ['Richard', 'Jack', 'Rain', 'Bob', 'Amy', 1, 2, 3]
 >>> names.insert(2,"Bob")
 >>> names.insert(6,"Andy")
 >>> names
 ['Richard', 'Jack', 'Bob', 'Rain', 'Bob', 'Amy', 'Andy', 1, 2, 3]
 >>> names.sort() #排序
 Traceback (most recent call last):
   File "<pyshell#36>", line 1, in <module>
     names.sort() #排序
 TypeError: '<' not supported between instances of 'int' and 'str'  #3.0里不同数据类型不能放在一起排序了，擦
 >>> names[-1] = ""
 >>> names[-2] = ""
 >>> names[-3] = ""
 >>> names
 ['Amy', 'Andy', 'Bob', 'Bob', 'Jack', 'Rain', 'Richard', '', '', '']
 >>> names.sort()
 >>> names
 ['', '', '', 'Amy', 'Andy', 'Bob', 'Bob', 'Jack', 'Rain', 'Richard']
 >>>
 >>> names.reverse()
 >>> names
 ['Richard', 'Rain', 'Jack', 'Bob', 'Bob', 'Andy', 'Amy', '', '', '']

获取下标

 >>> names
 ['Richard', 'Rain', 'Jack', 'Bob', 'Bob', 'Andy', 'Amy', '', '', '']
 >>> names.index("Richard")
 0
 >>> names.index("Bob") #只返回找到的第一个值的下标
 3

元组

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

语法

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

它只有2个方法，一个是count,一个是index，完毕。

程序练习

程序：购物车程序

需求:

1. 启动程序后，让用户输入工资，然后打印商品列表
2. 允许用户根据商品编号购买商品
3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
4. 可随时退出，退出时，打印已购买商品和余额

 print('----------欢迎进入自助购物。----------')
 golds_list = [
     ('macbook', 12000),
     ('iphone', 5800),
     ('book', 15),
     ('coffee', 35),
     ('glass', 20),
     ('bike', 1000)
 ]   #定义一个商品列表
 shopping_car = []   #定义一个空的购物车列表

 while True:
     salary = input('请输入余额：')
     if salary.isdigit():    #判断输入值是否是数字
         salary = int(salary)    #如果是数字则转成整数型
         while True:
             for id,p_item in enumerate(golds_list): #打印出商品列表，enumerate()方法是按编号输出
                 print(id+1, p_item)
             user_choice = input('请输入所购商品编号（退出请按：q/Q）:') #提示用户输入搜购买商品编号，或按q/Q退出
             if user_choice.isdigit():   #判断输入值是否是数字
                 user_choice = int(user_choice)  #如果是数字则转成整数型
                 if user_choice > 0 and user_choice < len(golds_list):   #判断输入的编号是否在商品列表范围之内
                     p_item = golds_list[user_choice - 1]
                     if salary >= p_item[1]: #判断余额是否大于输入编号所对应商品的价钱
                         salary -= p_item[1] #成立则余额对应减少
                         print('已添加{0}至购物车，当前余额为{1}'.format(p_item[0], salary))
                         shopping_car.append(p_item) #将所选商品存入"购物车"列表
                     else:
                         print('余额不足，无法购买，请选择其他商品！')
                         continue
                 else:
                     print('请输入正确的商品编号，或输入q/Q退出')
                     continue
             elif user_choice == 'q' or user_choice == 'Q':  #输入q/Q则退出，并打印所购商品以及余额
                 print('--------shopping lists--------')
                 for id, i in enumerate(shopping_car):
                     print(id+1, i)
                 print('所剩余额为：{}。'.format(salary))
                 print('--------shopping   end--------')
                 exit()  #退出程序
             else:
                 print('格式有误，请重新输入！')
                 continue
     else:
         print('格式有误，请重新输入！')
         continue

二、字符串操作

特性：不可修改

 name.capitalize()  首字母大写
 name.casefold()   大写全部变小写
 name.center(50,"-")  输出 '---------------------Alex Li----------------------'
 name.count('lex') 统计 lex出现次数
 name.encode()  将字符串编码成bytes格式
 name.endswith("Li")  判断字符串是否以 Li结尾
  "Alex\tLi".expandtabs(10) 输出'Alex      Li'， 将\t转换成多长的空格
  name.find('A')  查找A,找到返回其索引， 找不到返回-1 

 format :
     >>> msg = "my name is {}, and age is {}"
     >>> msg.format("alex",22)
     'my name is alex, and age is 22'
     >>> msg = "my name is {1}, and age is {0}"
     >>> msg.format("alex",22)
     'my name is 22, and age is alex'
     >>> msg = "my name is {name}, and age is {age}"
     >>> msg.format(age=22,name="ale")
     'my name is ale, and age is 22'
 format_map
     >>> msg.format_map({'name':'alex','age':22})
     'my name is alex, and age is 22'

 msg.index('a')  返回a所在字符串的索引
 '9aA'.isalnum()   True

 ''.isdigit() 是否整数
 name.isnumeric
 name.isprintable
 name.isspace
 name.istitle
 name.isupper
  "|".join(['alex','jack','rain'])
 'alex|jack|rain'

 maketrans
     >>> intab = "aeiou"  #This is the string having actual characters.
     >>> outtab = "" #This is the string having corresponding mapping character
     >>> trantab = str.maketrans(intab, outtab)
     >>>
     >>> str = "this is string example....wow!!!"
     >>> str.translate(trantab)
     'th3s 3s str3ng 2x1mpl2....w4w!!!'

  msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 

  >>> "alex li, chinese name is lijie".replace("li","LI",1)
      'alex LI, chinese name is lijie'

  msg.swapcase 大小写互换

  >>> msg.zfill(40)
 '00000my name is {name}, and age is {age}'

 >>> n4.ljust(40,"-")
 'Hello 2orld-----------------------------'
 >>> n4.rjust(40,"-")
 '-----------------------------Hello 2orld'

 >>> b="ddefdsdff_哈哈"
 >>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
 True

三、字典操作

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

语法:

info = {
    'stu1101': "Richard",
    'stu1102': "Alex",
    'stu1103': "William",
}

　　

字典的特性：

• dict是无序的
• key必须是唯一的,so 天生去重

增加

 >>> info["stu1104"] = "Rain"
 >>> info
 {'stu1102': 'Alex', 'stu1104': 'Rain', 'stu1103': 'William', 'stu1101': 'Richard'}

修改

 >>> info['stu1101'] = "理查德"
 >>> info
 {'stu1102': 'Alex', 'stu1103': 'William', 'stu1101': '理查德'}

删除

 >>> info = {
     'stu1101': "Richard",
     'stu1102': "Alex",
     'stu1103': "William",
 }
 >>> info
 {'stu1101': 'Richard', 'stu1102': 'Alex', 'stu1103': 'William'}
 >>> info.pop("stu1101")#第一种，删除指定的内容，返回删除的值
 'Richard'
 >>> info
 {'stu1102': 'Alex', 'stu1103': 'William'}
 >>> del info['stu1103'] #第二种，删除后无返回值
 >>> info
 {'stu1102': 'Alex'}
 >>> info = {'stu1101': "Richard",'stu1102': "Alex",'stu1103': "William",}
 >>> info
 {'stu1101': 'Richard', 'stu1102': 'Alex', 'stu1103': 'William'}
 >>> info.popitem() #第三种，随机删除一个，并返回结果
 ('stu1103', 'William')
 >>> info
 {'stu1101': 'Richard', 'stu1102': 'Alex'}

查找

 >>> info = {'stu1101': "Richard",'stu1102': "Alex",'stu1103': "William",}
 >>> "stu1102" in info  #第一种，返回布尔值
 True
 >>> info.get('stu1102') #第二种，获取并返回其值（常用）
 'Alex'
 >>> info['stu1102'] #第三种，同上，但是如果key不在则会报错
 'Alex'
 >>> info['stu1105']
 Traceback (most recent call last):
   File "<pyshell#68>", line 1, in <module>
     info['stu1105']
 KeyError: 'stu1105'
 >>> 

多级字典嵌套及操作

 >>> city= {
     "北京市":{
         "大兴区": ["亦庄镇"],
         "朝阳区": ["朝阳群众贼厉害！"],
         "东城区": ["天安门广场","王府井大街"]
     },
     "广州市":{
         "海珠区":["广州塔","夜晚还是挺漂亮的！"]
     },
     "深圳市":{
         "福田区":["平安大厦","港铁4号线"]
     }
 }
 >>> city["广州市"]["海珠区"][1] += "，一起去饮茶！"
 >>> city["广州市"]["海珠区"]
 ['广州塔', '夜晚还是挺漂亮的！，一起去饮茶！']

其它姿势

 >>> info = {'stu1101':'Richard','stu1102':'Andy'}
 >>> info
 {'stu1101': 'Richard', 'stu1102': 'Andy'}
 >>> info.values() #得到所有字典的value
 dict_values(['Richard', 'Andy'])

 >>> info.keys()    #得到所有字典的key
 dict_keys(['stu1101', 'stu1102'])

 >>> info.setdefault('stu1105','Yucoo') #如果key不存在字典中，则添加此键
 'Yucoo'

 >>> info
 {'stu1101': 'Richard', 'stu1102': 'Andy', 'stu1105': 'Yucoo'}
 >>> info.setdefault('stu1102','安迪') #如果key存在，则返回key值
 'Andy'
 >>> info
 {'stu1101': 'Richard', 'stu1102': 'Andy', 'stu1105': 'Yucoo'}
 >>>
 >>> info
 {'stu1101': 'Richard', 'stu1102': 'Andy', 'stu1105': 'Yucoo'}
 >>> b = {'stu1102':'安迪',1:2,3:4}
 >>> info.update(b) #把字典2中的keys/values更新到字典1中，有重复的key时，覆盖字典1中的value
 >>> info
 {'stu1101': 'Richard', 'stu1102': '安迪', 'stu1105': 'Yucoo', 1: 2, 3: 4}
 >>>
 >>>
 >>> info.items() #转换成列表
 dict_items([('stu1101', 'Richard'), ('stu1102', '安迪'), ('stu1105', 'Yucoo'), (1, 2), (3, 4)])

循环dict

 #方法1
 for key in info: #推荐使用，效率跟高
     print(key,info[key])

 #方法2
 for k,v in info.items(): #会先把dict转成list,数据里大时莫用
     print(k,v)

程序练习

程序: 三级菜单

要求:

1. 打印省、市、县三级菜单
2. 可返回上一级
3. 可随时退出程

代码待提交！！！

四、集合操作

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

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

常用操作

 s = set([3,5,9,10])      #创建一个数值集合  

 t = set("Hello")         #创建一个唯一字符的集合  

 a = t | s          # t 和 s的并集  

 b = t & s          # t 和 s的交集  

 c = t – s          # 求差集（项在t中，但不在s中）  

 d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  

 基本操作：  

 t.add('x')            # 添加一项  

 s.update([10,37,42])  # 在s中添加多项  

 使用remove()可以删除一项：  

 t.remove('H')  

 len(s)
 set 的长度  

 x in s
 测试 x 是否是 s 的成员  

 x not in s
 测试 x 是否不是 s 的成员  

 s.issubset(t)
 s <= t
 测试是否 s 中的每一个元素都在 t 中  

 s.issuperset(t)
 s >= t
 测试是否 t 中的每一个元素都在 s 中  

 s.union(t)
 s | t
 返回一个新的 set 包含 s 和 t 中的每一个元素  

 s.intersection(t)
 s & t
 返回一个新的 set 包含 s 和 t 中的公共元素  

 s.difference(t)
 s - t
 返回一个新的 set 包含 s 中有但是 t 中没有的元素  

 s.symmetric_difference(t)
 s ^ t
 返回一个新的 set 包含 s 和 t 中不重复的元素  

 s.copy()
 返回 set “s”的一个浅复制

五、文件操作

对文件操作流程

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

打开文件的模式有：

• r，只读模式（默认）。
• w，只写模式。【不可读；不存在则创建；存在则删除内容；】
• a，追加模式。【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

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

• rU
• r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

• rb
• wb
• ab

with语句

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

 with open('log','r') as f:

     ...

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

 with open('log1') as obj1, open('log2') as obj2:
     pass