Python自学之路——Python基础（二）——常用数据类型

.pyc文件

Python是一门高级的语言，计算机是不能识别的，所以需要将高级语言转化为计算机能识别的计算机语言，而这个过程分为两类，一类是编译，一类是解释。

PyCodeObject是将Python运行过程中编译的结果在内存中保存，并在Python程序运行结束时，Python解释器将PyCodeObject写回到pyc文件中。

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

所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

常用数据类型

• 列表（list)

下标是从0开始

从列表中取数的相关操作

>>> age=27
>>> list=["xiaoming","xiaohong","xiaofang",1,2,3,age]#列表元素可以是变量
>>> list
['xiaoming', 'xiaohong', 'xiaofang', 1, 2, 3, 27]
>>> list[0]    #下标从0开始 
'xiaoming'
>>> list[-1]   #取最后一个元素
27
>>> list[0:1] #取数“顾头不顾尾”
['xiaoming']
>>> list[2:4]
['xiaofang', 1]
>>> list[-5:-1]
['xiaofang', 1, 2, 3]
>>> list[-5:] #这种方式才能一起取到最后一个元素
['xiaofang', 1, 2, 3, 27]
>>> list[:]    #取所有元素
['xiaoming', 'xiaohong', 'xiaofang', 1, 2, 3, 27]
>>> list[:5]
['xiaoming', 'xiaohong', 'xiaofang', 1, 2]
>>> list[:5][1] #切片
'xiaohong'
>>> list[:5][1][2]
'a'

 基本操作

几点说明：

1. 当列表中的元素也有列表类元素时，使用.copy()操作只能copy列表的第一层，列表元素中的列表并不能copy,因为该元素实质是指向另一个内存地址的。当你想全部copy时，可以使用copy()标准库  copy.deepcopy()来实现。换句话说，copy是软链接，而deepcopy是真正的克隆
2. 列表赋值给列表和使用copy操作修改列表元素是有区别的，详见代码
3. python3中，sort()排序操作会出错

>>> list[1]="xiaolan"               #列表元素更改
>>> list.insert(2,"xiaopang")       #按下标插入元素
>>> list.append("lin")              #在列表末尾插入元素
>>> list.remove("xiaopang")         #删除指定元素
>>> list.pop()                      #默认删除列表最后一个元素，也可以按下标删除指定元素
'wangwu'
>>> list.pop(1)
3
>>> del list[3:5]                   #可连续删除多个元素
>>> print(list[0::2])               #按步长取数，步长默认是1
>>> 3 in list
>>> num=list.count(3)               #对相同元素进行计数
>>> position=list.index(3)          #返回第一个出现指定元素的下标
>>> list.extend(list1)              #扩展列表 
>>> list1.reverse                   #列表反序排列

 #列表的copy
 >>> list=['xiaoming', 'xiaolan', 'xiaofang', [3, 27], 'lin', 'zhangsan', 'lisi']
>>> list1=list.copy()
>>> list[0]="xiaopang"
>>> list
['xiaopang', 'xiaolan', 'xiaofang', [3, 27], 'lin', 'zhangsan', 'lisi']
>>> list1
['xiaoming', 'xiaolan', 'xiaofang', [3, 27], 'lin', 'zhangsan', 'lisi']
>>> list1[3][0]=33333
>>> list
['xiaopang', 'xiaolan', 'xiaofang', [33333, 27], 'lin', 'zhangsan', 'lisi']
>>> list1
['xiaoming', 'xiaolan', 'xiaofang', [33333, 27], 'lin', 'zhangsan', 'lisi']
>>> list1[3][0]=44444
>>> list
['xiaopang', 'xiaolan', 'xiaofang', [44444, 27], 'lin', 'zhangsan', 'lisi']
>>> list1
['xiaoming', 'xiaolan', 'xiaofang', [44444, 27], 'lin', 'zhangsan', 'lisi']
>>> import copy
>>> list2=copy.deepcopy(list)
>>> list2
['xiaopang', 'xiaolan', 'xiaofang', [44444, 27], 'lin', 'zhangsan', 'lisi']
>>> list[3][0]=1111111
>>> list2
['xiaopang', 'xiaolan', 'xiaofang', [44444, 27], 'lin', 'zhangsan', 'lisi']
>>> list1
['xiaoming', 'xiaolan', 'xiaofang', [1111111, 27], 'lin', 'zhangsan', 'lisi']


#列表的赋值
>>> name=[1,2,3,4]
>>> name1=name
>>> name1[1]=33333
>>> name
[1, 33333, 3, 4]

• 元组(tuple)

元组的元素是不可变的，但是元组里元素的元素是可变的

常用的操作包括 计数count()和索引index()

>>> tuple=(1,2,3,"alex",[2,3,4])
>>> tuple
(1, 2, 3, 'alex', [2, 3, 4])
>>> num=tuple.count(2)
>>> print(num)
1
>>> index=tuple.index(3)
>>> print(index)
2
>>> tuple[4][0]=2222
>>> tuple
(1, 2, 3, 'alex', [2222, 3, 4])        #元素的元素可改

• 字符串(string)

字符串是最常用的数据类型，常用操作也比较多

http://www.runoob.com/python3/python3-string.html

一些代码练习

name=input("Please input your name:")
print("hei:%s is you" % (name.strip()))        #默认是移除空白，也可以移除别的格式
names="alex,eric,jack"
names_split=names.split(",")
print(names_split)
print("|".join(names_split))
print(names.index("alex"))
print("eric" in names)

#输出结果
Please input your name:lidna  
hei:lidna is you
['alex', 'eric', 'jack']
alex|eric|jack
0
True

msg="Hello,{name},it's been a long {age} since last time sopke..."
msg2="haha {0},hehe {1}"
print(msg2.format("lind","zqq"))
msg2=msg.format(name="linda",age=22)
print(msg2)
#输出结果：
haha lind,hehe zqq
Hello,linda,it's been a long 22 since last time sopke...

name="Linda lin"
print(name.center(40,'-'))
---------------Linda lin----------------  #输出结果
 
name="Linda lin"
print(name.find("i"))        #返回第一个下标，若查找为空，则返回-1；

•  字典(dict)

字典也是一个存储数据的模型，可存储任意类型的对象。

字典的键值对（key->value)用:分割，每个键值对用,分割，整个字典用({})标识

几点注意：

1. key必须是唯一的，如果创建重复的key时，后一个会被记住；value不必
2. value可以是任意类型的数据，但是key必须是不可变的，如字符串、数字、元组

字典的常用操作

访问字典的值

 dic={'name':"rose",'age':27,'addr':"USA"}
 print("dic[name]:",dic['name'])
 print("dic[age]:",dic['age'])
 输出结果：
 dic[name]: rose
 dic[age]: 27

修改字典的值

dic={'name':"rose",'age':27,'addr':"USA"}
dic['name']="Jack"
dic['sex']="Woman"
print("dic[name]:",dic['name'])                #修改信息
print("dic[sex]:",dic['sex'])                  #增加信息
输出结果：
dic[name]: Jack
dic[sex]: Woman

 删除字典

dic={'name':"rose",'age':27,'addr':"USA"}
del dic['name']                                 #删除指定的元素
print(dic)
dic.clear()                                     #删除字典里的所有元素，留下一个空字典
print(dic)
del dic                                         #这样删除会把整个字典删除，print命令会出错，因为dic这个字典已经不存在了
print(dic)
输出结果：
{'addr': 'USA', 'age': 27}
{}
    print(dic)
NameError: name 'dic' is not defined

字典的内置函数和方法

内置函数

内置方法

• 集合（set)

集合是一类无序不重复的数据类型，支持union(并）intersection(交) difference(差)symmetric_difference(对称差)等数学运算，但由于集合是无序的，所以它不能使用index split等序列化的操作。

创建集合

s = set()
print(s)
st = 'alex'
s = set(st)
print(s)
lis = [11, 22, 33]
s = set(lis)
print(s)
dic = {'age': 22, 'name': 'jack'}
s = set(dic)
print(s)
输出结果：
set()
{'l', 'e', 'a', 'x'}
{33, 11, 22}
{'age', 'name'}

集合操作

s = set()
print(s)
s.add(1)#添加一个元素
print(s)
s.clear()#清除所有元素
print(s)
s1 = {11, 22, 33}
s2 = {22, 33, 44}
s3 = s1.difference(s2)#s1中存在，s2中不存在的元素（差）
print(s3)
s3 = s1.symmetric_difference(s2)#s1,s2中不相同的元素（对称差）
print(s3)
s1.difference_update(s2)#从当前集合中删除与s2相同的元素
print(s1)
s1 = {11, 22, 33}
s1.symmetric_difference_update(s2)#将对称差集更新到s1中
print(s1)
输出结果：
set()
{1}
set()
{11}
{11, 44}
{11}
{11, 44}

s1 = {11, 22, 33}
s1.discard(11)#删除指定元素，不存在不报错
print(s1)
s1.discard(1111)
s1.remove(22)#删除指定元素，不存在会报错
print(s1)
#s1.remove(11111)
s1 = {11, 22, 33}
res = s1.pop()#返回删除的元素
print(res)

s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.union(s2)#合并两个集合
print(s3)
s3 = s1.intersection(s2)#取集合的交集
print(s3)
s1.intersection_update(s2)#取s1和s2的交集并且更新到s1中
print(s1)
st = 'alexalex'
s1.update(st)#将st里的元素更新到s1中
print(s1)
输出结果：
{33, 22}
{33}
33
{33, 22, 11, 44}
{33, 22}
{33, 22}
{33, 'l', 'x', 'e', 22, 'a'}