1. 技术文章
  2. Python自动化开发S14 Day2

Python自动化开发S14 Day2

由 与世无争的帅哥 提交于 2020-04-28 22:17:49

 一、模块初识

- sys

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

print(sys.path)

>>> python test.py
['', 'C:\\Program Files\\Python36\\Lib\\idlelib', ......省略部分内容...... 'C:\\Program Files\\Python36\\lib\\site-packages']

###### 神奇的分隔符 ######

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

print(sys.argv)

>>> python test.py hello world
['test.py', 'hello', 'world']

- os

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os

os.system("dir")     # 执行命令，不保存结果
os.popen("dir").read()
os.mkdir("new_dir")      # 创建目录

注：如果希望将自己写的python模块能够被调用，应将文件放到python全局变量目录里，例如我的路径为C:\Program Files\Python36\Lib\site-packages目录下，如果不确定自己的目录在哪里，可以用print(sys.path)查看python环境变量列表。

二、.pyc是什么？

1、python是一门解释性语言

2、解释型语言和编译型语言的区别

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

- 解释型语言没有编译过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，例如Perl。

- 优点：

        解释型:可移植性好,只要有运行相应需要的解释环境,可以在不同的操作系统上运行,修改调试也非常方便

        编译型:相比解释执行编译执行效率高，占用资源小，适合复杂程序

- 缺点：

        解释型:一句一句执行解释,浪费计算机资源,效率低

        编译型:兼容性差,编译型程序虽然源代码也可以移植，但前提是必须针对不同的系统分别进行编译.

3、.pyc是什么

- pyc是一种二进制文件，是由py文件经过编译后，生成的文件，是一种byte code。

- py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨平台的字节码，是由python的虚拟机来执行的，这个是类似于JAVA或者.NET的虚拟机的概念。

- pyc的内容，是跟python的版本相关的，不同版本编译后的pyc文件是不同的，2.5编译的pyc文件，2.4版本的python是无法执行的。

三、数据类型初识

1、数字

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
 
long（长整型）
　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
注：Python3.x中取消了长整型的概念，只有int型了。

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

complex（复数）
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注：Python中存在小数字池：-5 ～ 257

2、布尔值

真或假，即真为1，假为0

四、数据运算

- 数学运算

- 比较运算

- 赋值运算

- 逻辑运算

- 成员运算

- 身份运算

- 位运算

#!/usr/bin/env python
# -*- coding: utf-8 -*-
  
a = 60            # 60 = 0011 1100
b = 13            # 13 = 0000 1101
c = 0
  
c = a & b;        # 12 = 0000 1100
print "Line 1 - Value of c is ", c
  
c = a | b;        # 61 = 0011 1101
print "Line 2 - Value of c is ", c
  
c = a ^ b;        # 49 = 0011 0001 #相同为0，不同为1
print "Line 3 - Value of c is ", c
  
c = ~a;           # -61 = 1100 0011
print "Line 4 - Value of c is ", c
  
c = a << 2;       # 240 = 1111 0000
print "Line 5 - Value of c is ", c
  
c = a >> 2;       # 15 = 0000 1111
print "Line 6 - Value of c is ", c

- 运算符优先级

五、入门知识拾遗

1、三元运算

result = 值1 if 条件 else 值2

如果条件为真：result = 值1

如果条件为假：result = 值2

2、进制

- 二进制，01

- 八进制，01234567

- 十进制，0123456789

- 十六进制，0123456789ABCDEF

PS：二进制到十六进制转换https://jingyan.baidu.com/album/47a29f24292608c0142399cb.html?picindex=1

3、数据类型

- Python3 bytes/str之别

Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，正是这使得两者的区分特别清晰。你不能拼接字符串和字节包，也无法在字节包里搜索字符串（反之亦然），也不能将字符串传入参数为字节包的函数（反之亦然）。这是件好事。

不管怎样，字符串和字节包之间的界线是必然的，下面的图解非常重要，务请牢记于心：

 

字符串可以编码成字节包，而字节包可以解码成字符串。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

msg = "我爱北京天安门"

print(msg)

# 字符串转换成字节码
print(msg.encode(encoding="utf-8"))

# 字节码再转换成字符串
print(msg.encode(encoding="utf-8").decode(encoding="utf-8"))


# 输出结果
我爱北京天安门
b'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8'
我爱北京天安门

 

六、列表、元祖操作

1、列表（List）

- 创建列表

name_list = ['devil', 'jack', 'tony']
或
name_list = list(['devil', 'jack', 'tony'])

- 切片

使用下标索引来访问列表中的值，同样也可以使用方括号的形式截取字符。

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

- 插入列表元素

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.insert(2,"强行从Eric前面插入")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.insert(5,"从eric后面插入试试新姿势")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

- 修改列表元素

>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> names[2] = "该换人了"
>>> names
['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

- 删除列表元素

#!/bin/env python
#-*- coding: utf-8 -*-

list1 = ['physics', 'chemistry', 1997, 2000]
 
print(list1)
del list1[2]
# 或者还可以使用 list1.remove(1997) 删除数据，效果与del结果一样。
print("After deleting value at index 2 : ")
print(list1)


# 输出结果
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

- 更新列表

可以使用该方法对数据项进行添加、修改或更新。

#!/bin/env python
# -*- coding: utf-8 -*-

list = []          # 空列表
list.append('www')   # 使用 append() 添加元素
list.append('91donkey')
list.append('com')
print(list)


# 输出结果
['www', '91donkey', 'com']

- 扩展列表元素

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> b = [1,2,3]
>>> names.extend(b)
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

- 拷贝列表元素

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

>>> name_copy = names.copy()
>>> name_copy
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

# 这只是浅拷贝，还有深拷贝用copy.deepcopy()函数

- 统计列表元素

>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.count("Amy")

- 排序&翻转

>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了，擦
>>> names[-3] = '1'
>>> names[-2] = '2'
>>> names[-1] = '3'
>>> names
['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']

- 获取下标

>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
>>> names.index("Amy")
2 #只返回找到的第一个下标

- Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式 结果 描述
len([1, 2, 3]) 3 长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复
3 in [1, 2, 3] True 元素是否存在于列表中
for x in [1, 2, 3]: print x, 1 2 3 迭代

 - 更详细的使用方法

http://www.runoob.com/python/python-lists.html

2、元组（不可变列表）

Python的元组与列表类似，不同之处在于元组的元素不能修改，同时它只有2个方法，一个是count，一个是index。

元组使用小括号，列表使用方括号。

- 创建元组

在括号中添加元素，并使用逗号隔开。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

# 空元组
tup1 = ()

# 元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)

元组与字符串类似，下标索引从0开始，可以进行截取、组合等。

- 访问元组

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])


# 输出结果
tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

- 修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)


# 输出结果
(12, 34.56, 'abc', 'xyz')

- 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

tup = ('physics', 'chemistry', 1997, 2000)
 
print(tup)
del tup
print "After deleting tup : "
print(tup)


# 输出结果
('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print tup
NameError: name 'tup' is not defined

- 元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print x, 1 2 3 迭代

- 元组索引、截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素。

L = ('spam', 'Spam', 'SPAM!')
Python 表达式 结果 描述
L[2] 'SPAM!' 读取第三个元素
L[-2] 'Spam' 反向读取，读取倒数第二个元素
L[1:] ('Spam', 'SPAM!') 截取元素

* 程序练习

程序：购物车程序

需求:

  1. 启动程序后，让用户输入工资，然后打印商品列表
  2. 允许用户根据商品编号购买商品
  3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒 
  4. 可随时退出，退出时，打印已购买商品和余额
 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # @Author: ma.yulong
 4 # @Time: '2019/4/3 17:43'
 5 
 6 
 7 product_list = [('IPhoneX',5800), ("Mac Pro",12000), ("Coffee",31), ("Bike",800), ("Alex Python Book",89)]
 8 shopping_list = []
 9 salary = input("Welcome to Tianmao Supermarket，Please enter your salary: ")
10 if salary.isdigit():
11     salary = int(salary)
12     while True:
13         item_num = 1
14         print("List of commodities:")
15         for item in product_list:
16             print(item_num,item)
17             item_num +=1
18         user_choice = input("选择要买的商品: ")
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 - 1 ]
23                 if p_item[1] <= salary:     # 买得起
24                     shopping_list.append(p_item)
25                     salary = salary - p_item[1]
26                     print("Added %s into shopping cart, your current balance is \033[31;1m%s\033[0m" % (p_item,salary))
27                 else:
28                     print("你的余额只剩 %s 啦!" % salary)
29             else:
30                 print("商品 [ %s ] 不存在" % user_choice)
31         elif user_choice == 'q':
32             print("您所购买的商品如下: ")
33             for p in shopping_list:
34                 print(p)
35             print("账户余额为%d" % salary)
36             exit()
37         else:
38             print("Invaild option")
View Code

 

3、字符串

最常用的数据类型，可以使用引号来创建字符串。

var1 = "Hello world"

注意：字符串是不可以修改的。

- 字符串更新

使用+号将前后信息拼接到一起，但+号每出现一次就会在内存中开辟一块空间，要尽量避免使用+号拼接。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
var1 = 'Hello World!'
 
print "更新字符串 :- ", var1[:6] + '91donkey!'


# 输出结果
更新字符串 :-  Hello 91donkey!

- 转义字符

需要在字符中使用特殊字符时，用反斜杠(\)转义字符。

转义字符 描述
\(在行尾时) 续行符
\\ 反斜杠符号
\' 单引号
\" 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出

- 字符串格式化输出

name = "devil"
print("i am %s " % name)

# 输出
i am devil

- 字符串格式化符号

    符   号 描述
      %c  格式化字符及其ASCII码
      %s  格式化字符串
      %d  格式化整数
      %u  格式化无符号整型
      %o  格式化无符号八进制数
      %x  格式化无符号十六进制数
      %X  格式化无符号十六进制数（大写）
      %f  格式化浮点数字，可指定小数点后的精度
      %e  用科学计数法格式化浮点数
      %E  作用同%e，用科学计数法格式化浮点数
      %g  %f和%e的简写
      %G  %f 和 %E 的简写
      %p  用十六进制数格式化变量的地址

- 字符串运算符

下表实例变量a值为字符串““Hello”，b变量值为“Python”

操作符 描述 实例
+ 字符串连接
>>>a + b
'HelloPython'
* 重复输出字符串
>>>a * 2
'HelloHello'
[] 通过索引获取字符串中字符
>>>a[1]
'e'
[ : ] 截取字符串中的一部分
>>>a[1:4]
'ell'
in 成员运算符 - 如果字符串中包含给定的字符返回 True
>>>"H" in a
True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True
>>>"M" not in a
True
r/R 原始字符串 - 所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
>>>print r' \n'
\n
>>> print R'\n'
\n
% 格式字符串   
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
a = "Hello"
b = "Python"
 
print "a + b 输出结果：", a + b 
print "a * 2 输出结果：", a * 2 
print "a[1] 输出结果：", a[1] 
print "a[1:4] 输出结果：", a[1:4] 
 
if( "H" in a) :
    print "H 在变量 a 中" 
else :
    print "H 不在变量 a 中" 
 
if( "M" not in a) :
    print "M 不在变量 a 中" 
else :
    print "M 在变量 a 中"
 
print r'\n'
print R'\n'


# 输出结果
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

- 字符串常用功能

移除空白

分割

长度

索引

分片

- 常用函数语法

name = "Alex Li"
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

'9'.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 = "12345" #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

　　

 4、字典（无序）

字典的每个键值 key=>value对用冒号 :分割，每个键值对之间用逗号 ,分割，整个字典包括在花括号 {}中。

- 语法：

d = {key1 : value1, key2 : value2 }

示例：
info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
}

键一般是唯一的，如果重复，最后的一个键值对会替换前面的，值不需要唯一。

>>> dict = {'a': 1, 'b': 2, 'b': '3'}
>>> dict['b']
'3'
>>> dict
{'a': 1, 'b': '3'}

划重点，所以字典的特性：

　　- dict是无序的

　　- key必须是唯一的，所以字典天生去重

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }

 

- 在字典中增加键值

# 增加
>>> info["stu1104"] = "苍井空"
>>> info
{'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}

# 访问
>>> info['stu1102']
'LongZe Luola'

 

- 修改字典

>>> info['stu1101'] = "武藤兰"
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

 

- 删除字典元素

>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
>>> info.pop("stu1101") #标准删除姿势
'武藤兰'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> del info['stu1103'] #换个姿势删除
>>> info
{'stu1102': 'LongZe Luola'}
>>> 
>>> 
>>> 
>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
>>> info.popitem()
('stu1102', 'LongZe Luola')
>>> info
{'stu1103': 'XiaoZe Maliya'}

>>> del info　　# 删除字典
>>> del info['stu1102']　　# 删除键是 ‘stu1102’ 的条目
>>> info.clear()　　# 清空字典所有条目

 

- 查找

>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> 
>>> "stu1102" in info # Python3.x 标准用法，等价于 Python2.x 中的 info.has_key('stu1102')
True
>>> info.get("stu1102")  #获取
'LongZe Luola'
>>> info["stu1102"] #同上，但是看下面
'LongZe Luola'
>>> info["stu1105"]  #如果一个key不存在，就报错，get不会，不存在只返回None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'stu1105'

 

- 多级字典嵌套及操作

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 
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

 

- 其他姿势

# 打印所有的 values，不包含 keys
>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])

# 打印所有的 keys，不包含 values
>>> info.keys()
dict_keys(['stu1102', 'stu1103'])


#setdefault
>>> info.setdefault("stu1106","Alex")
'Alex'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}


# update 有就更新，没有就创建
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

# items 字典转元祖
>>> info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])


# 初始化一个新的字典，通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}

 

- 循环字典

#方法1
for key in info:
    print(key,info[key])

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

 

常用操作：

- 索引

- 新增

- 删除

- 键、值、键值对

- 循环

- 长度

 

* 程序练习

程序: 三级菜单

要求: 

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

* 程序练习

程序：购物车优化

要求：

　　用户接口：

　　1. 商品信息存在文件里

　　2. 已购商品，余额记录长期留存。

　　商家入口：

　　1. 可以添加商品，修改商品价格

标签
rain
Apache Chemistry
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!