Python程序设计--第2章 python序列

灵活高效的序列，最能体现python特点的部分

#                          2   python序列
#序列的下标从0开始，支持双向索引，最右边为-1，既len(x)-1
#                          2.1列表
#一对[]中，可以修改         
#                          2.1.1 列表的创建与删除
a_list=[123,'aa',[12,23]]
a_list=[]    #空列表或  
a_list=list()  #空列表，上世更方便
#使用list()函数，可以将元组、range对象，字符串或其他类型的可迭代对象的数据转换为列表
a=(123,4,6)   #元组tuple，元组的值不可以修改
a_list=list(a)    #将tuple改为list类型
x=range(1,10,2)   #range数据类型
a_list=list(x)    #将range类型转换为list
x=list('abc123')  #['a', 'b', 'c', '1', '2', '3']

#range([start,] stop [,step])   #起点：默认值0，终止值：不包含该值，步长：默认1，返回值为range类型
#                         2.1.2   列表元素的增加
x=[1,2,3]
y=[4,5]
x=x+y   #列表的 + 运算符
x.extend(y)  #extend操作，与 + 操作效果一样

x.append(9)   #不是x=x.append(9) ！！！
x.insert(-1,6)  #使6成为索引处的新值，而不是在末尾
x.insert(len(x),7)  #在末尾插入

x=[1,2]
x=x*2    #列表的 * 运算，[1, 2, 1, 2]

# 重头依次取出并删除各个元素          pop
x=[1,2,3]
while len(x)>0:
    a=x.pop(0)   #缺省为尾部取出

x=[1,2,3]
i=x.index(2)   #值不存在会抛出异常  index
b=20
if b in x:     #通过 in 判断值是否在列表中  in
    i=x.index(b)

#切片操作，起点：截止：步长，注意：截止但不包括,各个参数含义与range抑制
x=[1,2,3]
y=x[1:1]   #y为[]空列表
x='abc123'
y=x[:3]  #y='abc'

x=['a','b']
y='-'.join(x)   # a-b   join函数的应用

#  列表的排序
x=[3,9,1]
x.sort()   #缺省为升序，1,3,9
x.sort(reverse=True)   #降序排列，9,3,1

#逆序排列2
x=[3,9,1]
x.sort()
x.reverse()

#python基于值的内存管理，有时它的行为与你的想象不同
x=[3,9,1]
y=x   #这里让y和x指向同一个地址,即id()值相同，对x进行的操作==对y操作,即所谓的浅复制
x[0]=2   #此时 y[0]==2       ！！！

#deepcopy
import copy
x=[1,2]
y=copy.deepcopy(x)
y[0]=4
print(x)  #[1,2]


# 列表推导式，生成列表的简单方式，一句话可以代替一段代码[x for x in]
x=[i*2 for i in range(1,5)]   #[2,4,6,8]
#相当于
x=[]
for i in range(1,5):
    x.append(i*2)

x=[1,2,3,4,5,6,-1,9,-3]
y=[i for i in x if i>0]    #添加条件的列表推导式

#检索最高分名单            
scores={'zhang':80,'wang':88,'li':88,'zhao':78}
n_max=max(scores.values())
best=[name for name,score in scores.items() if score==n_max]
#列表推导式中可以使用复杂的表达式
x=['good' if i>80 else 'pass' for i in scores.values() if i>=60] 

#                2.2  元组 tuple
#简单的可将元组理解为只读的列表，其执行效率高
#元组不支持sort()，reverse()操作
x=('a')      #str类型
x=('a',)     #tuple类型，只含有一个元素
x=(1,2,3,'a','b')

#序列解包
a=(1,2,3)
x,y,z=1,2,3   #多个变量同时赋值
x,y,z=a       #利用序列解包同时给多个变量赋值
b=['a',2,3]
x,y,z=b

#      2.3 字典dict
#将dict理解为一种特殊的列表，其键为下标，便于保存键-值对数据
a={} #空字典
dic={'a':1,'b':2,'c':3}   #字典dict，key不可以重复,字符串，数字等可作为key
x,y,z=dic   #默认对键值进行操作,等效于
x,y,z=dic.keys()    #'a','b','c'
x,y,z=dic.items()   #tuple类型x=('a',1)
x,y,z=dic.values()  #1,2,3

x=dic['b']  #键值的访问，键为下标，不存在的键出发异常
x=dic.get('b',0)   #get()函数访问键值，可以设置键不存在时的默认值
dic['abc']=123     #新建或更新键值对
m_key='x'
dic[m_key]=dic.get(m_key,0)+1  #实现类似缺省字典的功能 defaultdict
dic['x']=dic.get('x',0)+1 


from collections import defaultdict
x=defaultdict(int)    #defaultdict自动初始化
x['3']+=1    #x[3]自动初始化为0

#字典的按键值排序,字典不支持.sort(),.reverse()函数
x={}
x['a']=2
x['c']=8
x['b']=5
key=list(x.keys())    #利用list函数将字典的keys()转换成list
key.sort()
for i in key:
    print(x[i])

#                2.4 集合 set
#与字典一样使用大括号，集合中每个元素都是唯一的，对于大量数据，集合的效率较高
a={3,5}    #集合赋初始值
a.add(7)   #set不支持append()，而使用add
a.add(3)   #自动忽略重复的值

#使用set函数将列表、元组等对象转换为set，自动去掉重复的值
lis_1=[1,2,3,1]
set_1=set(lis_1)   #1,2,3
x={}      #dict类型，不是空集合
x=set()   #空集合
#集合不支持sort
#集合中元素不可通过下标访问，x[0]，可在for 循环中访问



#pop函数
x=[1,2,3]
y=x.pop()   #y=3,list从后面截取
x=(1,2,3)
#y=x.pop()   #tuple不支持pop操作
x={'a':1,'b':2,'c':3}
y=x.pop('b')  #dict必须有key值
x={1,2,3}
y=x.pop()    #y=1,set从前面截取


#生成不重复的随机整数函数1--使用列表
def RandomInt(number,start,end):
    data=[]
    if end-start+1<number:
        number=end-start+1
    import random
    n=0
    while n<number:
        x=random.randint(start,end)
        if x not in data:
            data.append(x)
            n+=1
    return data

x=RandomInt(6,1,100)
x=RandomInt(number=5,start=6,end=80)

x.sort()
x.reverse()


#生成不重复的随机整数函数2--使用集合
def RandomInt2(number,start,end):
    data=set()
    if end-start+1<number:
        number=end-start+1
    import random
    while len(data)<number:
        x=random.randint(start,end)
        data.add(x)
    return data

y=RandomInt2(6,1,100)
#集合不支持.sort()和.reverse()

#生成不重复的随机整数函数3--使用字典
def RandomInt3(number,start,end):
    data={}
    if end-start+1<number:
        number=end-start+1
    import random
    while len(data)<number:
        x=random.randint(start,end)
        data[x]=1
    return list(data.keys())

y=RandomInt3(6,1,100)
#小结 
#列表list支持sort、reverse，通过append新增，通过下标访问；元组tuple相当于只读list，字符串str可以当做特殊list处理。3者均可以通过下标访问。
#字典dict用于键值对的保存，不支持sort，通过键访问值；通过get()方法访问不存在的键值不触发错误，还可以赋缺省值
#集合set相当于dict的keys，通过add新增，值不重复，不可以通过下标访问。

 

转载于:https://www.cnblogs.com/imhuanxi/p/11187147.html