Python,Day2 - 数据类型,运算,列表操作,字典

本节内容

• 1.Python PYC

• 2.Python数据类型

• 3.数据运算

• 4.列表、元组操作

• 5.元组

• 6.字符串操作　

• 7.字典操作

1.Python PYC

预编译后的字节码 

1.1Python是一门解释型语言？ 

初学Python一直听别人说，Python是一门解释性语言，直到发现了.pyc文件的存在。如果是解释型语言，那么生成的.pyc文件是什么呢？c应该是compiled的缩写才对啊！ 
为了防止其他学习Python的人也被这句话误解，那么我们就在文中来澄清下这个问题，并且把一些基础概念给理清。 

1.2解释型语言和编译型语言 

计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类，第一种是编译，第二种是解释。 
编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。 
解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。

通过以上的例子，我们可以来总结一下解释型语言和编译型语言的优缺点，因为编译型语言在程序运行之前就已经对程序做出了“翻译”，所以在运行时就少掉了“翻译”的过程，所以效率比较高。但是我们也不能一概而论，一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。

此外，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种。 
用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

1.3Python到底是什么

Python也是一门基于虚拟机的语言，我们先来从表面上简单地了解一下Python程序的运行过程吧。

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

1.4简述Python的运行过程

在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。 
我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。

当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。 
当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到则直接载入，否则就重复上面的过程。 
所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

2.Python数据类型

2.1 int(整数)

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

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

2.2 long（长整型）

注：python3不存在长整型，变为整型，需要注意。

1.跟C语言不同，Python的长整数没有指定位宽，

2.即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

3.注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

2.3 float（浮点型）

1.浮点数用来处理实数，即带有小数的数字。

2.浮点表示的形式是小数，但小数不一定都是浮点型,23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。

2.4 complex（复数）

复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

2.5 布尔值

真或假 
1或0

xuliangwei:~ xuliangwei$ python3
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 0
>>> if a :print("a")
...
>>> a =1
>>> if a :print("a")
...
a

2.6 查看数据类型

xuliangwei:~ xuliangwei$ Python3
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print (type("xuliangwei.com"))
<class 'str'>  #字符串
>>> print (type(1.22))
<class 'float'>  #浮点
>>> print (type(1))
<class 'int'>  #整数

3.数据运算

3.1算术运算

操作符	描述符	示例
+	加法 - 对操作符的两侧增加值	a + b = 30
-	减法- 减去从左侧操作数右侧操作数	a - b = -10
*	乘法 - 相乘的运算符两侧的值	a * b = 200
/	除 - 由右侧操作数除以左侧操作数	b / a = 2
%	模 - 由右侧操作数和余返回除以左侧操作数	b % a = 0
**	指数- 执行对操作指数（幂）的计算	a**b = 10 的幂 20
//	取整除 - 操作数的除法，其中结果是将小数点后的位数被除去的商。	9//2 = 4 而 9.0//2.0 = 4.0

3.2比较运算

运算符	描述符	示例
==	检查，两个操作数的值是否相等，如果是则条件变为真。	(a == b) 不为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	(a != b) 为 true.
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	(a <> b) 为 true。这个类似于 != 运算符
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	(a > b) 不为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	(a < b) 为 true.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	(a >= b) 不为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	(a <= b) 为 true.

3.3赋值运算

运算符	描述符	示例
=	简单的赋值运算符，赋值从右侧操作数左侧操作数	c = a + b将指定的值 a + b 到 c
+=	加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数	c += a 相当于 c = c + a
-=	减AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数	c -= a 相当于 c = c - a
*=	乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数	c *= a 相当于 c = c * a
/=	除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数	c /= a 相当于= c / a
%=	模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数	c %= a is equivalent to c = c % a
**=	指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数	c **= a 相当于 c = c ** a
//=	地板除，并分配一个值，执行地板除对操作和赋值给左操作数	c //= a 相当于 c = c // a

3.4位运算

操作符	描述符	示例
&	二进制和复制操作了一下，结果，如果它存在于两个操作数。	(a & b) = 12 即 0000 1100
|	二进制或复制操作了一个比特，如果它存在一个操作数中。	(a | b) = 61 即 0011 1101
^	二进制异或运算符的副本，如果它被设置在一个操作数而不是两个比特。	(a ^ b) = 49 即 0011 0001
~	二进制的补运算符是一元的，并有“翻转”位的效果。	(~a ) = -61 即 1100 0011以2的补码形式由于带符号二进制数。
<<	二进位向左移位运算符。左操作数的值左移由右操作数指定的位数。	a << 2 = 240 即 1111 0000
>>	二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动。	a >> 2 = 15 即 0000 1111

3.5逻辑运算

运算符	描述	示例
and	所谓逻辑与运算符。如果两个操作数都是真的，那么则条件成立。	(a and b) 为 true.
or	所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。	(a or b) 为 true.
not	所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真，则逻辑非运算符将返回false。	not(a and b) 为 false.

3.6三元运算

result = 值1 if 条件 else 值2

xuliangwei:~ xuliangwei$ python3
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> a,b,c = 1,3,5  #定义值
>>> d = a if a>b else c
>>> d
5
>>> d = a if a <b else c
>>> d
1

3.7进制类型

• 二进制，01

• 八进制，01234567

• 十进制，0123456789

• 十六进制，0123456789ABCDEF

3.8bytes类型

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

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

#!/usr/bin/env python
# Author:xuliangwei
#encode 编码
#decode 解码
msg = "徐亮伟架构师之路"
print (msg)
print (msg.encode(encoding="utf-8"))  #转换为bytes
print (msg.encode("utf-8").decode(encoding="utf-8"))  #转为字符串

执行结果

徐亮伟架构师之路 
b'\xe5\xbe\x90\xe4\xba\xae\xe4\xbc\x9f\xe6\x9e\xb6\xe6\x9e\x84\xe5\xb8\x88\xe4\xb9\x8b\xe8\xb7\xaf '
徐亮伟架构师之路 

4. 列表、元组操作

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

4.1定义列表

names = ['Alex',"Tenglan",'Eric']

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

>>> names[0]
'Alex'
>>> names[2]
'Eric'
>>> names[-1]
'Eric'
>>> names[-2] #还可以倒着取
'Tenglan'

4.2切片:取多个元素　　

注：列表的切片原则为 顾头不顾尾

>>> 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']

4.3追加

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

4.4插入

>>> 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', '我是新来的']

4.5修改

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

4.6删除

>>> del names[2] 
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']>>> del names[4]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> 
>>> names.remove("Eric") #删除指定元素
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.pop() #删除列表最后一个值 '我是新来的'
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

4.7扩展

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> b = [1,2,3]>>> names.extend(b)    #将列表b的内容复制到列表names中。
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

4.8拷贝

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

4.8.1深copy

name=["1","2","3"]
print ("name:%s" %name)

print ("---")
import copy
name1=copy.deepcopy(name)
print ("name1:%s" %name1)
结果：
name:['1', '2', '3']
---
name1:['1', '2', '3']

深入理解
import copy
name=["1","2","3"]
print ("name:%s" %name)

name2=copy.deepcopy(name)
print("name:%s" %name2)

name[1]="b"
print ("name:%s  name2:%s"%(name,name2))
结果：
name:['1', '2', '3']
name:['1', '2', '3']
name:['1', 'b', '3']  name2:['1', '2', '3']

4.9统计

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

4.10排序&翻转

>>> 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']

4.11获取下标

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

例：
list=['xiaofeng.gao','zhourui']
list[list.index('zhourui')]='ganna'
print (list)
>>>['xiaofeng.gao', 'ganna']

5.元组

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

语法

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

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

程序练习 

请闭眼写出以下程序。

程序：购物车程序

需求:

1. 启动程序后，让用户输入工资，然后打印商品列表

2. 允许用户根据商品编号购买商品

3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒 

4. 可随时退出，退出时，打印已购买商品和余额

 

6. 字符串操作　　　　

利用字符串操作：
name2="my name is {name} and age is {age}"
print (name2.format(name="alex",age="22"))
结果：
my name is alex and age is 22

利用字典操作

n3_arg={'name':'alex','age':33}
n3='my name is {name} and age is {age}'
print(n3.format(name=n3_arg['name'],age=n3_arg['age']))
结果：
'my name is alex and age is 33'

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

>>> n4.rjust(40,"-")'
-----------------------------Hello 2orld'
>>> s = "Hello World!"
>>> p = str.maketrans("abcdefg","3!@#$%^")
>>> s.translate(p)'H$llo Worl#!
>>> b="ddefdsdff_哈哈" 
>>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则True

>>>name2="asdf {name} sdf {year}"
>>>print (name2.format(name="alex",year="22"))
>>>asdf alex sdf 22

 

7. 字典操作

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

语法:

info = {
    'stu1101': "zhangsan",
    'stu1102': "lizi",
    'stu1103': "wangwu",
}

7.1字典的特性：

• dict是无序的

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

7.2增加

info={
    'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'
}
info["stu1104"] = "苍井空"
print(info)

7.3修改

info={
    'stu1102': 'LongZe Luola', 'stu1104': 'cangjingkong', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'
}
info["stu1104"] = "苍井空"
print(info)

7.4删除

>>> 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'}

7.5查找

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

7.6多级字典嵌套及操作

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

 

7.7其它姿势

#values>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])#keys
>>> 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'}#itemsinfo.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'}

7.8循环dict 

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

8.程序练习

程序: 三级菜单

要求: 

1. 打印省、市、县三级菜单

2. 可返回上一级

3. 可随时退出程序

注：

range(1,10,2) #循环里按照步长打印 ,打印1到10,步长是2

特别鸣谢：Alex，徐亮伟的微博

转载于:https://blog.51cto.com/xiaofengcanyue/1833381