Python 入门学习第二部分：模块、数据运算、列表、元祖和字典。

 

声明：本文章是基于老男孩IT教育中Alex老师所上的课程的总结，所用内容基本上都引用自于Alex老师的课程以及他的博客http://www.cnblogs.com/alex3714/  在此十分感谢Alex老师的精彩课程，能够让我这个小白走上Python的学习道路。

一、初识模块

   Pyhon具有非常丰富和强大的标准库与第三方库，几乎能实现你想要的任何功能。python中的模块分为两种类型，一种是标准库，不需要了另外安装，直接在写程序的时候通过import指令导入就行；还有一种是第三方库，必须要下载安装到对应的文件目录下，才能使用。具体的呢下面最下简单的介绍。

1、两个例子

  1）Sysm模块

    当运行如下代码的时候，sys的path功能输出的结果是python 的全局环境变量，即python调用该模块时进行索引的路径。argv的功能则是打印模块的相对位置，同时可以用来调用参数。

import sys
print(sys.path)#打印环境变量
print(sys.argv)

2）os模块

import os  #调用模块
cmd_res1=os.system("dir") #system线路是让系统执行一条命令，但是这个命令只能执行不能储存
cmd_res1=os.popen("dir").read() #popen线路就是可以储存的，但是这里在执行了之后实际上是相当于暂时放在内存的一个地方， #需要通过read()来调用出来，否则是一堆机器码
print(cmd_res1)
os.mkdir("new_dir")#这个用于创建一个新的目录，mkdirs则是用来创建一个新的多级目录。

2、关于自己创建模块  

    最好不要用中文，另外要么放在和import的文件同一个目录下，要么放在前面提到过的site-packages里边，要么修改环境变量。

 

还有在python3中有个问题：我们给Pyhon file命名的时候一定不要和模块的名字重到，否则Python会优先选择当前目录下的.py文件。

 

二、关于pyc的一点小知识

   我们在之前的第一部分当中已经提到过，编程语言分为编译型语言和解释型语言。

   编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言，java等。

   解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby，python等。

   然后我们又提到，两种类型的语言在运行速度、内存要求等方面具有一些不同的差异，同时呢随着技术慢慢慢慢地发展，两者之间的界限呢也变得越来越模糊。

   好了下面说回到python。

   当我们在命令行中输入python hello.py时，其实是激活了Python的“解释器”，告诉“解释器”：你要开始工作了。可是在“解释”之前，其实执行的第一项工作和Java一样，是编译。

     说编译可能不太确切，准确地说应该是预编译。当Python程序开始运行时，预编译的结果被储存在了内存中的PyCodeObject文件当中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

   当Python程序第二次运行时，程序首先会在硬盘当中寻找pyc文件，如果能找到则直接载入，否则重复上面的过程。

  那么如果当源代码发生了更改之后该怎么办？Python在执行文件之前会预先搜索pyc文件，在找到之后，它会通过算法（C)对pyc文件的保存时间和源代码的更改时间进行比较，然后由此决定是否运行pyc文件。

    所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。.pyc实际上是预编译后的自解码文件（15%的半成品）。

三、数据类型

简单介绍常用的几种数据类型。

 1、数字

   1）int（整型）

       在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，

       即-21474836482147483647~21474836482147483647　　

       在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，        

       即-9223372036854775808～9223372036854775807

       另外，在Python3当中不存在整型和和长整型之分，只有整型。

   2）float(浮点型)

　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。

浮点的表示形式是小数，但浮点≠小数

3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。

   3）complex(复数)

      复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。实际上就是所谓的可以用来表示三维空间当中的向量的一系列数。

 2、布尔值

　　真或假

　　1 或 0

  对--->true 1

  不对-->false 0

3、字符串

 字符串的常用功能包括移除空白、分割、长度、索引、切片等，在后边的字符串操作部分中会详细介绍。

四、数据运算

  1、算术运算

   常用的加减乘除，即“+”，“-”，“*”，“/”自不必多说。

   “%”，取模返回x的余数，可以应用于相邻两个单位不同的循环情况；

   “**”，幂 x**y即表示x的y次幂；

   “//”，取整除，返回商的整数部分

  2、比较运算

    >、<、<=、>=不多说。

   “！=”，不等于 

   “<>”，同上，不过不常用

   “==”等于

 3、赋值运算

  

4、逻辑运算

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20

 

5、身份运算

 

例子如下：

a=[1,2,3,4]
print(type(a))
type(a) is list

这里最后的输出结果应该为“True”，即表明a确实是一个列表。

6、二进制位运算

计算机中能表示的最小单位，是一个二进制位；

计算机中能存储的最小单位，是一个二进制位。（bit)

8bit =1byte （字节）

1024byte=1kbyte

1024kbyte=1mbyte

1024mb=1gb

1024gb=1T

  

7、关于各个运算的优先级

  

五、入门知识拾遗

  1、三元运算

a,b,c=3,6,7
d=a if a<b else c
print(d)
#输出结果
3

2、进制

• 二进制，01
• 八进制，01234567
• 十进制，0123456789
• 十六进制，0123456789ABCDEF 

二进制到十六进制的转化：

http://jingyan.baidu.com/album/47a29f24292608c0142399cb.html?picindex=1

十六进制的表示法：后缀为H——如BH表示十六进制数11

前缀为0X——0x23表示16进制的23

在进行从二进制到十六进制的转换过程中，

在向左（或向右）取四位时，取到最高位（最低位）如果无法凑足四位，就可以在小数点的最左边（或最右边）补0，进行换算。

3、bytes的数据类型

在Python3当中，文本的unicode都有字符串数据（str）来表示；

二进制的数据类型，诸如视频、音频等则都由bytes类型来表示。

另外在Python3当中，所有的数据传输都采用二进制来进行。

程序中string和bytes的转换示意图如下：

msg="你大爷"
print(msg.encode("utf-8"))
print(msg.encode("utf-8").decode("utf-8"))

比如上面的代码。

在encode当中，一定要写明原先是哪一种数据类型，如果不写的话，默认是按照utf-8来进行。

六、列表的使用

  1、列表的基本格式

names=["a","b","c","d","e","b"]

2、对于列表的对象查询

print(names[3])#调用列表中的对象，从左到右依次为0,1,2,3...
print(names[1:3])#切片，从左边开始的话，顾头不顾尾
print(names[-1])#切片，调用最后一位，从右开始数
print(names[-3:-1])#切片，按照从最后开始数的方法，但是切片还是从左往右并且顾头不顾尾的。
print(names[-3:])#如果要取最后一位，那么：后边应该不写东西
print(names[:2])#同理，如果说是从第一个开始，前面是0，也可以不写。
print(names[0:-1:2])#跳着切片，最后一个2为步长

3、对于列表的一些拓展功能的使用

 1)增加元素

names.append("F")#添加元素到后边
names.insert(1,"F")#添加元素到指定位置，想到那个位置就写那个位置的下标

2）更改元素

names[1]="B" #更改对应位置上的元素

3）删除元素

names.remove("c")#这种方式直接写要删除对象的内容
del names[2]#这个就是指定位置下标来删
names.pop(2) #pop和del起的作用其实基本是一样的，不过要是默认不写下标的话就会删除最后一个对象。

4）查询元素

print (names.index("c"))#对于已知内容的对象，打印其位置。
print(names.count("b"))#打印相同对象在列表中出现的次数

5）其他的一些

names.clear()#清空整个表格
names.reverse()#反转整个表格
names.sort()#排序，按照ASCII码的顺序进行排列
names2=["1","2","3"]
names.extend(names2)#拓展表格
print(names)

6）关于list_.copy()的一些用法

  a.在只有一级列表的情况下，直接用copy是能够实现完全copy的，并且当names列表当中有元素变化时，names2是不会变化的。

names=["a","b","c","d","e","b"]
names2=names.copy()
print(names)
print(names2)

#输出结果：
['a', 'b', 'c', 'd', 'e', 'b']
['a', 'b', 'c', 'd', 'e', 'b']

 b.在这里有两级列表，然后更改原始列表中的第一级的一个元素，names2当中并不会发生变化。

names=["a","b","c",[1,2,3],"d","e","b"]
names2=names.copy()
names[1]="B"
print(names)
print(names2)

#输出结果：
['a', 'B', 'c', [1, 2, 3], 'd', 'e', 'b']
['a', 'b', 'c', [1, 2, 3], 'd', 'e', 'b']

c、但是看下边，当二级列表中的元素发生改变时，names2也变了。

names=["a","b","c",[1,2,3],"d","e","b"]
names2=names.copy()
names[1]="B"
names[3][1]="贰"
print(names)
print(names2)

#输出结果：
['a', 'B', 'c', [1, '贰', 3], 'd', 'e', 'b']
['a', 'b', 'c', [1, '贰', 3], 'd', 'e', 'b']

 d、如果不使用copy,直接用前面的赋值:那么最后连最浅的一层也复制不了。

names=["a","b","c",[1,2,3],"d","e","b"]
names2=names
names[1]="B"
names[3][1]="贰"
print(names)
print(names2)

#输出结果：
['a', 'B', 'c', [1, '贰', 3], 'd', 'e', 'b']
['a', 'B', 'c', [1, '贰', 3], 'd', 'e', 'b']

e、上面的copy情况呢，就是所谓的浅copy,如果需要进行彻底的deepcopy，就需要调用copy模块。

import copy
names=["a","b","c",[1,2,3],"d","e","b"]
names2=copy.deepcopy(names)
names[1]="B"
names[3][1]="贰"
print(names)
print(names2)

#输出结果：
['a', 'B', 'c', [1, '贰', 3], 'd', 'e', 'b']
['a', 'b', 'c', [1, 2, 3], 'd', 'e', 'b']

但是一般来说这种deepcopy不建议常用，因为毕竟有的时候有的列表动辄上万的数据量，如果完全复制一份，则会白白占据大量的空间，没必要。

 

f.关于浅copy的应用，这里举一个例子，但是事先说一下，在实际生活中不是用这种方法来弄的。

  可以利用浅copy事先如下功能：

  创立一个多个人的共同账户，当一个账户的余额有变动时，其余的账户也跟着变动。

  

import copy
person=["name",["saving",100]]

pres1=copy.copy(person)
pres2=person[:]
pres3=list(person)

pres1[0]="Dad"
pres2[0]="Mun"
pres3[0]="Daughter"

pres1[1][1]=50

print(pres1)
print(pres2)
print(pres3)

#输出结果
['Dad', ['saving', 50]]
['Mun', ['saving', 50]]
['Daughter', ['saving', 50]]

 g、关于列表的循环

names=["a","b","c","d","e","b"]
for i in names:
    print(i)

#输出结果：
a
b
c
d
e
b

七、元组

元组其实跟列表差不多，也是存一组数，只不过它一旦被创建，就不能更改。是一种只读语法。

它有两个方法，一个是count，一个是index。

在列表中也可以嵌套元组。

names=("lilei","hanmeimei","xiaoming")

八、购物车练习

   作业要求：创建一个购物车程序

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

我初次编写的程序如下：

money=int(input("Your salary:"))#需要改进：需要先判断输入的是否为数字，然后再进行转换，而非一开始就转换，，
commodities=[[1,"iphone",int(5800)],[2,"mac book",int(10000)],[3,"Unicolo",int(200)],[4,"bicycle",int(2000)]]
   #需要改进：1、商品编号不够灵活  2、应该用嵌套模型，即元组。
shoppingmart=[]
while True:
  print(commodities)
  i=int(input("The code of what you want:"))

  if commodities[i-1][2]<=money:
     money=money-commodities[i-1][2]
     shoppingmart.append("{commodity},¥{price}".format(commodity=commodities[i-1][1],price=commodities[i-1][2]))
     print("Add {commodity} to your shopping cart!".format(commodity=commodities[i-1][1]))
     print("Your balance:",money)
  else:
     print("Your balance is insufficient!")

  question=input("Do you wanna quit?")
  if question=="Y":
      print("You have bought:",shoppingmart)
      print("Your balance:",money)
      break

事实上上述程序存在如下问题：

  1、虽然能够实现输入编号选择商品，但不够灵活，加入商品增加并且商品名称、编号发生变化，那么会涉及到较大的改动。

  2、没有验证用户输入的数据类型以及输入的数据范围是否合理，一旦错误，程序就会报错导致无法运行。

  3、无法真正实现“随时都能退出”的要求。

 经过老师讲解后，程序改正如下：

# Author DingRenpeng
commodities=[
        ("iphone",5800),
        ("mac book",10000),
        ("Unicolo",200),
        ("bicycle",2000)
]
shoppingmart=[]
money=input("Your salary:")
if money.isdigit():
   money=int(money)
   while True:
       for index,item  in enumerate(commodities):
           print(index,item)

       user_choice=input("The code of what you want:")
       if user_choice.isdigit():
           user_choice=int(user_choice)
           if user_choice<len(commodities) and user_choice>=0:
               p_item=commodities[user_choice]#这一步走的好啊，直接就定义了p_item是个嵌入的元组。
               if p_item[1]<=money:
                   shoppingmart.append(p_item)
                   money=money-p_item[1]
                   print("已添加%s至您的购物车，您的账户余额为33[31:1m%s33[0m"%(p_item,money))
               else:
                   print("33[41:1m您的余额只剩%s，无法支付本商品！33[0m"%money)
           else:
               print("您输入的编号不存在，请重新输入。")

       elif user_choice=="q":
          print("------购物车商品列表------")
          for shpping_item in shoppingmart:
              print(shpping_item)
          print("您目前的余额为%s"%money)
          exit()
else:
  print("编号格式输入错误！请重启页面输入！")

该表格的提升在于：

 1、使用了表格的嵌套模型；

 2、利用字符串操作 isdigit来判断输入的数据类型

 3、高亮部分直接定义了p_item为一个列表中的元祖，后边的列表扩展就显得很简单。

 4、没了。

九、字符串操作

具体所有的操作如下：

name="MY name is Dingtou"
print(name.capitalize())#首字母大写
print(name.casefold())#大写全部变小写

print("Dingtou".center(50,"-")) #保证打印出来满50个字符，不够用横线补足，前面字符放中间
                                  #输出结果：---------------------Dingtou----------------------
print("Ding".count("D")) #统计某个字符出现次数
print("Ding".encode()) #把字符串编译成bytes格式
print("Ding".endswith("g") )  #判断是否以某个特定字符结尾，可用于判断邮箱是否以》com结尾
print("Din	g".expandtabs(10) ) #输出“Din       g”,把	转化成此相昂应长度的空格
print("My name is {name}".format(name="ding"))
print("My name is {name},my age is {age}".format_map({'name':'ding','age':23}))#用于放入字典，但不常用

print("Ding".index("i") ) #返回i在字符串里边的索引
print("Ding123".isalnum() )#如果是数字或者字母，都能返回true
print("Ding".isalpha() )#如果是数字，则返回true
print("Ding".isdecimal() )#p判断字符串是否为十进制
print("123".isdigit() )#如果全部为数字，则返回true
print("Ding".isidentifier() )#判断是不是一个合法的标识符，就是一个合法的变量名
print("ding".islower() ) #判断字符串是否全部为小写
print("ding".isupper())#判断是否是全部大写
print("Ding".istitle()) #判断是否为标题，即每个单词首字母大写
print("+".join(['1','2','3']))#输出结果为’1+2+3‘
print("Ding".ljust(50,"*"))#在右边用*补齐50
print("Ding".rjust(50,"*"))#左边用*补齐50
print("Ding".lower())#全部转化为小写
print("Ding".upper())#全部转化为大写
print("
Ding".lstrip())#删除字符串左边的空格或回车
print("Ding
".rstrip())#删除右边的空格或回车
print("
Ding
".strip())#删除两边的空格或回车

p=str.maketrans("abcdefghijklmn","123456789!@#$%")
print("Ding".translate(p))  #使用相应的密码来进行翻译  输出结果：D9%7
print("Ding".replace("D","P"))#对字符串中的某个字符进行替换
print("Ding Renpeng".replace("n","N",1))#数字表示想要替换当中的第几个目标
print("Ding Renpeng".rfind('n'))#找到最右边对应字符的下标并返回
print("1+2+3+4".split("+")) #输出结果按照括号中的对应字符进行列表的划分。 输出：['1', '2', '3', '4'
print("Ding".swapcase()) #输出结果：dING rENPENG 大小写全部转化
print("Ding tou".title())#转化为标题格式
print("Ding".zfill(10)) #输出结果：000000Ding

十、字典的使用

1、字典的基本格式如下面代码所示：

   字典是无序的，不存在下标，因此打印出来的结果中，顺序也是随机的。

#key-value
info={
    "stu01":"Li lei",
    "stu02":"Hanmeimei",
    "stu03":"Lidan"
}
print(info)  

2、增加对象

  下面的代码中，字典还是为上面已有的info。

info["stu01"]="李雷"#修改
info["stu04"]="Ding"#添加对象

setdefult:

检索看是否有key 如果有那么就返回这个key.如果没有就根据输入的value创建新的值

比如下面代码：

info.setdefault("stu01","李雷")
print(info)
#输出结果
{'stu01': 'Li lei', 'stu02': 'Hanmeimei', 'stu03': 'Lidan'}

info.setdefault("stu09","李雷")
print(info)
#输出结果
{'stu01': 'Li lei', 'stu02': 'Hanmeimei', 'stu03': 'Lidan', 'stu09': '李雷'}

3、删除对象

del info["stu01"]
info.pop("stu01")#也是删除
info.popitem()#随机删

4、更改对象内容

   首先是单个对象的更改：

info["stu01"]="李雷"#修改

  下边是合并列表，并更新交叉的信息。

b={
    "stu01":"Xiaogang",
    1:2,
    3:3
}
info.update(b)#合并并且更新交叉的信息
print(info)

5、查询对象

print(info["stu01"])#这个在找不到的时候会报错
print(info.get("stu05"))#正经查找，而且找不到的时候不会报错
print("stu05" in info) #查询某对象是否处于列表当中，打印true or false

6、关于item

   item 的作用是 把字典转化成为一个大的列表。

print(info.items())#把字典转化成一个大的列表
#输出结果
dict_items([('stu01', 'Li lei'), ('stu02', 'Hanmeimei'), ('stu03', 'Lidan')])

7、关于fromkeys

c=dict.fromkeys([6,7,8],"Yo!")#初始化一个新的字典
#输出结果
{6: 'Yo!', 7: 'Yo!', 8: 'Yo!'}

  这里有一点需要提及的地方。看下面代码：

d=dict.fromkeys([6,7,8],{"name":"Ding"})
print(d)
#输出结果
{6: {'name': 'Ding'}, 7: {'name': 'Ding'}, 8: {'name': 'Ding'}}

d[7]["name"]="Jack"
print(d)
#输出结果
{6: {'name': 'Jack'}, 7: {'name': 'Jack'}, 8: {'name': 'Jack'}}

我们发现当第二级的字典当中内容更改之后，整个最后输出的列表也改了，这其中的道理其实和前面提到的浅copy是一样的。

8、字典的循环

  info={
    "stu01":"Li lei",
    "stu02":"Hanmeimei",
    "stu03":"Lidan"}
for i in info:
    print(i,info[i])
#或者
for k,v in info.items():
    print(k,v)

上面两种循环，看起来效果似乎是一样的，但是

第二种方法涉及到了将字典转化成列表的过程，一旦数据量变大，会大大增加运算时间。因此一般不建议使用。

9、多级嵌套

  具体代码如下，拷贝自Alex老师的博客。

  

av_catalog = {
    "欧美":{
        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
        "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
    },
    "日韩":{
        "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
    },
    "大陆":{
        "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    }
}

av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
print(av_catalog["大陆"]["1024"])
#ouput
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

 十一、这里有一个三级菜单的作业

   作业要求如下：

• 三级菜单
• 可依次选择进入各子菜单
• 所需新知识点：列表、字典

首先画出该作业的流程图，大致如下：

  

具体代码如下：

# Author DingRenpeng
data={
    "江苏省":{
        "南京市":{"玄武区","秦淮区","建邺区"},
        "无锡市":{"崇安区","南长区","滨湖区"},
        "苏州市":{"姑苏区","吴中区","相城区"}},
    "浙江省":{
        "杭州市":{"西湖区","滨江区","萧山区"},
        "宁波市":{"海曙区","镇海区","慈溪市"},
        "温州市":{"鹿城区","龙湾区","瑞安市"}},
    "广东省":{
        "广州市":{"荔湾区","白云区","越秀区"},
        "深圳市":{"南山区","宝安区","盐田区"},
        "汕头市":{"龙湖区","金平区","潮阳区"}}
}
exit_flag=False

while not exit_flag:
    for i1 in data:
        print(i1)
    choice1=input("请选择>>>")
    if choice1 in data:
        while not exit_flag:
          for i2 in data[choice1]:
            print(i2)
          choice2=input("请选择>>>")
          if choice2 in data[choice1]:
              while not exit_flag:
                for i3 in data[choice1][choice2]:
                   print(i3)
                choice3=input("请选择>>>")
                if choice3 in data[choice1][choice2]:
                   choice4=input("选择完毕，请输入b返回或输入q退出")
                   if choice4=="b":
                      pass
                   elif choice4=="q":
                      exit_flag=True
                if choice3=="b":
                    break
                elif choice3=="q":
                    exit_flag=True
          if choice2=="b":
              break
          elif choice2=="q":
              exit_flag=True
    elif choice1=="q":
        exit_flag=True

整个三级菜单的程序当中：

while循环 保证了当输入的不是对应内容的时候，不会出错，而是重新返回到一开始打印并要求输入的地方

exit_flag=False,这个很有意思，也很巧妙，实现了在每一级都能退出程序的效果。

（话说如果直接用exit会是什么效果？？）结果发现 直接用exit()也能实现相同的功能啊~~~

所以注意了：break用于退出循环，exit 用于退出程序。

 

 

上面就是第二部分所学内容的整理与思考。