数组（1174536086）←v是有序的元素序列。用于差异数组的各个元素的数字编号称为下标。若将有限个类型相同的变量的集结命名，那么这个名称为数组名。数组是一个固定长度的存储相同数据类型的数据结构，数组中的元素被存储在一段接连的内存空间中。组成数组的各个变量称为数组的分量，数组是在程序设计中，为了处理便当， 把具有相同类型的若干元素按有序的方法组织起来的一种方法。也称为数组的元素，有时也称为下标变量。这些有序摆放的同类数据元素的集结叫数组。它是最简略的数据结构之一，大多数现代编程言语都内置数组支撑

内容概览

1. 模块
2. python运行过程
3. 基本数据类型（数字，字符串）
4. 序列类型（列表，元组，字典）

• 模块使用

1. 模块我们可以把它想象成导入到python以增强其功能的一种拓展。需要使用import来导入模块
2. 常用的模块之一：os（用于调用系统命令等）

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. import os
4. print(os.path) #打印当前路所在的路径
5. cmd=os.system("dir") #定义cmd执行系统的dir命令
6. print(cmd) #返回cmd的状态信息，成功为0，反之不为0
7. cmd_1 = os.mkdir("SSS") #定义cmd执行在当前路径下创建文件夹SSS
8. print(cmd_1) #打印状态
9. cmd_2 = os.rmdir("SSS") #定义cmd执行在当前路径下删除SSS文件夹
10. ##如果要通过print来打印定义的cmd命令变量的话就需要popen这个参数
11. cmd_3=os.system('ipconfig')
12. print(cmd_3)
13. cmd_4=os.popen("ipconfig").read() #执行系统命令ipconfig
14. print(cmd_4)

　　3.sys模块

1. #!/usr/bin/env python
2. import sys
3. print(sys.path) #打印python相关路径
4. print(sys.argv) #传参数的功能
   print(sys.argv[1]) #打印第二个参数

　　4.自定义模块

　　　　自定义模块：当要导入的自定义模块，需要具备和需要导入模块的程序在同一级目录或者在系统默认的库目录下例如在：pythom35\\lib\\site-packages

• python运行过程

　　　　对于Python的运行我们还是得追溯到那个神奇的*.pyc字节码文件，这就是在python解释器运行python代码的时候生成的一个字节码文件。

　　　　那么生成的*.pyc文件是什么呢？c应该是compiled的缩写才对啊！

　　　　为了防止其他学习Python的人也被这句话误解，那么我们就在第一篇文章中做了形象的说明。

• 基本数据类型

1. 数字类型之整型（int）：这是用于存储数值的一种数据类型

　　　　对于变量的复制除了var = value 的这种方式，也还能通过var1,var2,var3,..=value1,value2,value3,...的方式来进行

　　　　在python3.x中对于int这个整形数据类型不再有long int这种说法，这样有效的防止了所谓的溢出问题

• • 数据运算
  • 算术运算

• • 比较运算

• • 赋值运算

• • 逻辑运算

• • 成员运算

• • 位运算：这个比较恶心，涉及到二进制移位操作

　　　　这玩意儿得用点代码来表示：

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
4. a = 50 #二进制表示50=110010
5. b = 150 #二进制表示150=10010110
6. c = a & b #与运算
7. print(c) #试了一把结果出来的值是18，这个的话尽量忘记吧。和后面的| ;^; ~ ;<< ;>>;这些玩意儿都一路货色
8. d = a | b
9. print(d) #或运算，得到的结果182
10. e = a ^ b
11. print(e) #异或的操作得到结果164
12. #f = a ~ b
13. #print(f)
14. g = a << 2
15. print(g) #左移位2下得到结果200
16. h = a >> 2
17. print(h) #右移位2得到结果12

　其他的数据操作，请看此处的引用：http://www.runoob.com/python/python-operators.html

　　　　下面是变量赋值的操作截图：

　　　　下面是装逼的三元运算，感觉66的：

　　　  三元运算解释：

1. result = 值1 if 条件 else 值2
2. #如果条件为真：result = 值1
3. #如果条件为假：result = 值2
4. #!/usr/bin/env python
5. # -*- coding:utf-8 -*-
6. #Author:wanghui
7. a = 1
8. b = 2
9. c = 3
10. if a > b:
11. d = a
12. print(d)
13. elif a > c:
14. d = a
15. print(d)
16. ###三元操作
17. a,b,c=1,2,3
18. d=a if a>b else c

　　2.python3.x严格区分string和byte：

　　　　在Python3.x下，文本用unicode表示，二进制数据则使用byte来表示。下图就说明了二者之间的关系：

　　　　　代码表示：

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. #Author:wanghui
4. msg = "呵呵哒！！"
5. #print(msg.encode(encoding='utf-8')) ##编码的过程，指定字符编码

　　b'\xe5\x91\xb5\xe5\x91\xb5\xe5\x93\x92\xef\xbc\x81\xef\xbc\x81'   #结果

1. print(msg.encode(encoding='utf-8').decode(encoding='utf-8')) ##解码的过程
   呵呵哒！！

　　3.字符串：也是比较常见的数据类型了，下面是字符串的一些操作

序列类型

1. 列表：

2. 1. #!/usr/bin/env python
   2. # -*- coding:utf-8 -*-
   3. #Author:wanghui
   4. names = ["chenjing","huangjie","huyuedong"]
   5. '''
   6. ##切片操作
   7. print(names[0]) #切片打印第一个位置元素
   8. print(names[0:2]) #打印前两个元素（顾头不顾尾）
   9. print(names[-2:]) #打印倒数后两个元素，不建议用[-2:-1]
   10. '''
   12. ###添加元素
   13. #names.append("shaolin") #在最后位置追加shaolin这个新元素
   14. #print(names)
   15. #names.insert(2,"wanghuihui") #在第三个位置插入wanghuihui
   16. #print(names)
   17. #b = ["wanghui","huangjie","chenyibo","huyuuedong"]
   18. #names.extend(b) #在 names中拓展b列表
   19. #print(names)
   21. ###修改元素
   22. #names[2] = "alex" #修改第二个位置的元素为alex
   23. #print(names)
   24. #names[3] = "fengjie" #如果第四个位置没有fengjie这个元素的话就会报错
   25. #print(names)
   27. ###索引（用于索引引用）
   28. #print(names.index("alex")) #获取alex的位置索引
   29. #print(names[names.index("alex")]) #根据alex索引位置值显示对应的内容
   31. ###统计
   32. # names.append("alex")
   33. # names.extend(["wanghui","jeck","alex"])
   34. # names.insert(3,"wanghui")
   35. # print(names.count("wanghui")) #经过一系列的增加操作之后统计“wanghui”出现的次数
   37. ###删除操作
   38. #方法一：del操作
   39. # print(names)
   40. # del names[2] #按照元素的索引位置删除
   41. # print(names)
   42. #方法二：remove操作
   43. # print(names)
   44. # names.remove("huyuedong") #按照元素的value删除
   45. # print(names)
   46. #方法三：pop操作
   47. # print(names)
   48. # names.pop() #删除结尾的一个元素
   49. # print(names)
   50. # names.pop(0) #指定索引位置删除
   51. # print(names)
   52. #方法四：清空
   53. # print(names)
   54. # names.clear() #直接清空列表
   55. # print(names)
   57. ###排序操作
   58. names.append("Alex")
   59. names.extend(["","","",""])
   60. names.insert(3,"####") #还是一系列的新增操作
   61. print(names)
   62. names.sort()
   63. print(names) #排序的优先级是符号>数字>大写>小写

　       此处还有一个比较重要的概念就是深浅拷贝

　　　　需要了解：变量是一个系统表的元素，拥有指向对象的连接的空间
　　　　　　　　　对象是被分配的一块内存，存储其所代表的值
　　　　　　　　   引用是自动形成的从变量到对象的指针
　　　　特别注意: 类型属于对象，不是变量

　　　  深浅拷贝，即可用于序列，也可用于字典

1. ##浅拷贝
2. import copy
3. a=["hahaha","xixixi","lalala",["hehe",123],"wuwuwu"]
4. b=copy.copy(a)
5. print(a) ->输出['hahaha', 'xixixi', 'lalala', ['hehe', 123], 'wuwuwu']
6. print(b) ->输出['hahaha', 'xixixi', 'lalala', ['hehe', 123], 'wuwuwu']
7. a[0]="hahaha" #修改第一个元素为hahaha
8. print(a) ->输出['hahaha', 'xixixi', 'lalala', ['hehe', 123], 'wuwuwu']
9. print(b) ->输出['hahaha', 'xixixi', 'lalala', ['hehe', 123], 'wuwuwu']
10. a[2][1]=789 #修改第三个元素的第二个元素为789
11. print(a) ->输出['hahaha', 'xixixi', 'lalala', ['hehe', 789], 'wuwuwu']
12. print(b) ->输出['hahaha', 'xixixi', 'lalala', ['hehe', 789], 'wuwuwu']

1. ##深拷贝
2. import copy
3. names = ["wanghui","huangjie","chenyibo","王辉",["alex","jack"]]
4. name2 = copy.deepcopy(names)
5. print(names)
6. print(name2)
7. names[-1][0]="ALEX"
8. print(names)
9. print(name2) ##保持原状不变，这就是深拷贝

　　　  参考详情：http://www.cnblogs.com/Eva-J/p/5534037.html

　 2.元组：不能修改的列表，同样支持count和index方法

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. names = ("huangjie","liurun","huyuedong")
4. names.count('huangjie') #通过count方法来获取黄姐出现的次数
5. names.index('huangjie') #通过index方法来获取huangjie的下标
6. names[names.index("huangjie")]
7. #切片操作
8. print(names[1:]) #打印第一个到最后一个元素
9. print(names[0:2]) #打印第一个到第三个元素
11. #不能对元组元素进行增加和删除操作

　　3.字符串操作：比较多

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
4. a="name is hehehe"
5. print(a.capitalize()) #首字母大写
6. print(a.count('h')) #统计h出现的次数
7. print(a.center(10,"-")) #按照10字节的字符，如果不够就用-补充，字符串居中
8. print(a.encode()) #字符串编码
9. print(a.endswith('he')) #判断是否以he结尾
10. print(a.expandtabs(tabsize=50)) #实现的字符串中得有\t占位符才能读取到
11. print(a.find('hehe')) #打印hehe的下标位置方便切片print(a[a.find("hehe"):])
12. #print(a[a.find("hehe"):]) #切片
13. #print(a.format()) print("hello {name}".format(neme="hehe))
14. #print(a.format_map({"hehe":23,"haha",44})) #传入字典
15. print(a.index("is")) #打印is的index编号
16. print(a.isalnum()) #阿拉伯数字，有特殊字符就不行了
17. print(a.isalpha()) #纯英文字符包括大小写
18. print(a.isdecimal()) #是否为十进制
19. print(a.isalnum()) #是否为数字
20. print(a.isdigit()) #是否为整数
21. print(a.isidentifier()) #判断是否为一个合法的变量名
22. print(a.islower()) #判断字符串是否为小写
23. print(a.isnumeric()) #是否为数字（小数不包括）
24. print(a.isspace()) #是否为空格
25. print(a.istitle()) #是否为标题
26. print(a.isprintable()) #是否可打印（tty或者设备文件不可打印）
27. print(a.isupper()) #是否为大写
28. print('+'.join(['1','2','3','4'])) #拼接成1+2+3+4的形式
29. print(a.ljust(50,'*')) #保证长度50然后右侧填充*
30. print(a.rjust(30,'#')) #保证长度50然后左侧填充#
31. print(a.lower()) #把大写转成小写
32. print("\n\n\nhehehe\n\nkkk".lstrip()) #去除左边的空格或者回车
33. print("\n\n\nhehehe\n\nkkk").rstrip() #去除右边的回车或者空格
34. print("\n\n\nhehehe\n\nkkk").strip() #去除两侧的回车或者空格
35. '''
36. p = str.maketrans("abcdef",'123456')
37. print("wanghui".translate(p)) #把字符串转换成后面对应的数字的值w1nghui
38. '''
39. print(a.replace('h','H',2)) #替换字符串里的h为H，指定数字的话代表第几个
40. print(a.rfind('e')) #找到最右边的e的位置下标并返回
41. print('1+2+3+4'.split('+')) #按照+作为分隔符分割字符串
42. #print('1+2\n+3\n+4'.splitlines('+')) #按照+号作为分隔符分割（忽略回车或者空格）
43. print(a.startswith("heh")) #判断字符串是否以heh开头
44. print(a.swapcase()) #小写转大写
45. print(a.title()) #变title
46. print(a.zfill(50)) #补位操作

　　4.字典及其操作

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. dic = {
4. 'wanghui':12345,
5. 'jack':123456,
6. 'sam':1234567,
7. 'sary':12345678
8. }
9. #字典是无序的，key是唯一的，so天生去重
10. print(dic) #无序打印字典
11. print(dic['wanghui']) #按照wanghui打印出对应的值
12. dic['wanghui']='wanghui' #修改wanghui的值为wanghui
13. print(dic['wanghui']) #打印
14. dic['henry']='henry' #新增字典元素
15. print(dic) #打印字典
16. # del dic['wanghui'] #删除wanghui和对应的值
17. # print(dic)
18. # dic.pop('henry') #指定删除
19. # dic.popitem() #随机删除
20. print(dic.get('wanghui') #安全的查找方式，如果存在返回其值。否则返回none
21. dic_1 = {
22. 'wanghui':12345,
23. 'alex':234567,
24. 'huyuedong':23455
25. }
26. dic.update(dic_1) #合并两个字典，如果有交叉，就更新字典，如果没有交叉就创建
27. print(dic)
28. print(dic.items() #字典转成了列表
30. c = dic.fromkeys([6,7,8]) #创建了新的字典
31. print(c) #->输出：{8: None, 6: None, 7: None}
33. d = dic.fromkeys([6,7,8],"test") #初始化字典创建
34. print(d) #->输出：{8: 'test', 6: 'test', 7: 'test'}
35. e = dic.fromkeys([9,10,11],[1,{"name":'wanghui'},1234])
36. print(e) #->输出:{9: [1, {'name': 'wanghui'}, 1234], 10: [1, {'name': 'wanghui'}, 1234], 11: [1, {'name': 'wanghui'}, 1234]}

1. 嵌套字典：
2. dic={
3. "甘肃省 ":{
4. '张掖市':['甘州区','民乐县','山丹县','高台县'],
5. '武威市':['凉州区','古浪县','民勤县'],
6. '酒泉市':['敦煌市','玉门市','肃州区']
7. },
8. "山东省":{
9. '潍坊市':['寒亭区','高密市','寿光市','昌乐县'],
10. '济南市':['长清区','历下区','禹城市'],
11. '青岛市':['即墨市','黄岛区','崂山区']
12. },
13. "陕西省":{
14. '西安市':['未央区','长安区','雁塔区','新城区'],
15. '咸阳市':['秦都区','渭城区','礼泉县'],
16. '安康市':['汉阴县','白河县','紫阳县']
17. }
18. }
19. dic['陕西省']['西安市'][2]="碑林区" #修改操作
20. print(dic)
21. print(dic.values())
22. dic.setdefault('台湾省',{'baidu.com':[1,2,3]}) #设置默认值
23. print(dic)

课堂程序

程序：购物车程序

需求:

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

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. product_list = [
4. ('Iphone',5800),
5. ('Mac Pro',9800),
6. ('Bike',800),
7. ('Watch',10600),
8. ('Coffee',31),
9. ('Alex Python',120),
10. ]
11. shopping_list = []
12. salary = input("Please input your salary:")
13. if salary.isdigit():
14. salary=int(salary)
15. while True:
16. for num,item in enumerate(product_list):
17. print(num,item)
18. user_choice = input("Please choice your item:")
19. if user_choice.isdigit():
20. user_choice=int(user_choice)
21. if user_choice < len(product_list) and user_choice >= 0:
22. p_item = product_list[user_choice]
23. if p_item[1] <= salary:
24. shopping_list.append(p_item)
25. salary -= p_item[1]
26. print("added %s into shopping car,your current balence is \033[31;1m%s\033[0m" %(p_item,salary))
27. else:
28. print("your money is not enough to buy,you have \033[41;1m%s\033[0m left" %(salary))
29. else:
30. print("your choice %s is out of shopping_list" %(user_choice))
31. elif user_choice == 'q':
32. print("shopping_list".center(50,"*"))
33. for i in shopping_list:
34. print(i)
35. print("your current balence:",salary)
36. exit()
37. else:
38. print("Invalid option!!")
39. else:
40. print("invalid salary!!")

三级菜单程序：

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. #Author:wanghui
4. ##三级菜单字典定义
5. zone = {
6. "甘肃省": {
7. "张掖市": ["甘州区", "民乐县", "山丹县"],
8. "武威市": ["凉州区", "古浪县", "民勤县"],
9. },
10. "山东省": {
11. "济南市":["历下区","长清区","禹城市"],
12. "潍坊市":["昌乐县","潍城区","寒亭区"]
13. },
14. "陕西省": {
15. "西安市":["雁塔区","新城区","未央区"],
16. "咸阳市":["礼泉县","秦都区","渭城区"]
17. }
18. }
19. ##退出循环标志位定义
20. exit_flag = True
21. while exit_flag:
22. for i in zone: #读取第一级菜单
23. print(i)
24. choice = input("first,press q to exit:") #第一级菜单输入
25. if choice == "q":
26. exit_flag =False
27. if choice in zone:
28. while exit_flag:
29. for i2 in zone[choice]: #第二级菜单读取
30. print("\t\t",i2)
31. choice2 = input("second,press b return back and q to quit！！！:") #第二级菜单输入
32. if choice2 in zone[choice]:
33. while exit_flag:
34. for i3 in zone[choice][choice2]:
35. print("\t\t\t\t",i3)
36. choice3 = input("last one,press b return back and q to quit！！！") #第三级菜单输入
37. if choice3 == 'b':
38. break
39. elif choice3 == "q":
40. exit_flag=False
41. if choice2 == 'b':
42. break
43. elif choice2 == 'q':
44. exit_flag = False

升级版三级菜单（以后可以当模板）：

1. current = zone
2. last = []
4. while True:
5. for i in current:
6. print(i)
7. choice = input(">>:")
8. if len(choice) == 0 :continue
9. if choice == 'b':
10. if len(last) == 0:break #防止第一级为空报错，直接退出
11. current=last[-1] #打印当前一级
12. last.pop() #往上走一级，就删除当前
13. if choice not in current:continue
14. last.append(current) #保存上级菜单
15. current = current[choice] #当前菜单