第二篇、数据类型

 序列操作:

s + r      连接
s * n     重复s的n次复制
v1,v2...vn = s     变量解包(unpack)
s[i]         索引
s[i:j]                  切片
s[i:j:stride]         扩展切片
x in s,x not in s   成员关系
for x in s:           迭代
all(s)      如果s中的所有项都为True，则返回True
any(s)    如果s中的任意项为True，则返回True
len(s)     长度,元素个数
min(s)    s中的最小项
max(s)   s中的最大项
sum(s [,initial])    具有可选初始值的项的和
del s[i]     删除一个元素
del s[i:j]   删除一个切片
del s[i:j:stride]    删除一个扩展切片

 字符串操作

str.capitalize()    将字符串的首字母变大写
str.title()         将字符串中的每个单词的首字母大写
str.upper()         将字符串变成大写
str.lower()         将字符串变成小写
str.index()         找出索引对应的字符串
str.find()          同上
str.count()         找出字符串中元素出现的次数
str.format()        也是格式化的一种
str.center()        以什么字符从字符串两边填充
str.join()          以str为分隔符连接字符串
str.split()         以什么为分隔符分隔字符串
str.strip()         将字符串两边中的空格去掉
str.replace()       查找替换
str.isupper()       判断是否为大写
str.islower()       判断是否为小写
str.isalnum()       判断是否是字母数字
str.isalpha()       判断是否是字母下划线
str.isdigit()       判断是否是数字
str.isspace()       判断是否为空
str.startswith()    找出以什么为开头的字符元素
str.endswith()      找出以什么为结尾的字符元素

 列表操作

list.insert() 在列表中指定索引位置前插入元素
list.append() 在列表尾部插入
list.remove() 删除指定的元素
list.pop() 没有指定索引，则弹出最后一个元素，返回的结果是弹出的索引对应的元素
list.copy() 浅复制,只会复制第一层,如果有嵌套序列则不会复制,如果需要复制则要导入copy模块
list.extend() 把另外一个列表合并，并不是追加
list.index() 列表中元素出现的索引位置
list.count() 统计列表中元素的次数
list.reverse() 进行逆序
list.sort() 进行排序,python3无法把数字和字符串一起排序
l1 + l2 :  合并两个列表，返回一个新的列表，不会修改原列表
l1 * N :   把l1重复N次，返回一个新列表

通过索引修改元素
>>> print(l2)
[1, 2, 3, 4, 5]

>>> l2[1] = 32

>>> print(l2)
[1, 32, 3, 4, 5]

>>> l2[3] = 'xyz'

>>> print(l2)
[1, 32, 3, 'xyz', 5]

>>> print(l1)
[1, 2, 3]

>>> l1[1:] = ['m','n','r']

>>> print(l1)
[1,'m','n','r']
通过分片进行删除
>>> l2[1:3]
[32, 3]

>>> l2[1:3] = []

>>> print(l2)
[1, 'xyz', 5]
通过内置的函数进行删除
>>> del(l2[1:])

>>> print(l2)
[1]
通过列表的方法进行增删改
>>> l3 = [1,2,3,4,5,6]

>>> l3.append(77)

>>> print(l3)
[1, 2, 3, 4, 5, 6, 77]

>>> l4 = ['x','y','z']

>>> l3.append(l4)

>>> print(l3)
[1, 2, 3, 4, 5, 6, 77, ['x', 'y', 'z']]

 

 遍历列表下标两种方法:

方法一:
L=[1,0]

L=[L[x]-L[x-1] for x in range(len(L))]
print(L)  #[1, -1]

方法二:
L=[L[x]+L[x-1] for x ,y in enumerate(L)]
print(L)#([1,1])
理解这里的方式,因为这里是列表,,有两个值,也就有两个下标,遍历两次遍历第一次,就是L的第一个值，遍历第二次就是L的第二个值

 

元祖操作

tuple.count() 统计元组中元素的个数
tuple.index() 找出元组中元素的索引位置

 

元祖解析：

color=["blank","white"]
colors=tuple(i for i in color)
print(colors)

元祖可以用作不可辨列表，还可以用作没有字段名的记录

lax_coordinates=(33.9425,-118)  #洛杉矶坐标
city,year,pop,chg,area=("beijing",2003,32450,0.66,8014)  #携带信息
traveler_ids=[("usa","31195855"),("BRA","CE342567")]
country=(country for country,_ in traveler_ids)   #获取城市信息
while True:
    try:
        print(next(country))
    except Exception:
        break

元祖拆包：

拆包一

lax_coordinates=(339425,-118.408056)
lattude,longitude=lax_coordinates
print(lattude)
print(longitude)

拆包二

a,b=b,a

拆包三、利用*

t=(20,8)
print(divmod(*t))

 

具名元祖

import collections
card=collections.namedtuple("card",["rank","suit"])
i=card("a","b")
print(i,i.rank,i.suit,card._fields)

　　

切片：

点击这里

对列表使用+或者×都会建立新的列表，如果对于列表中的列表用×会创建一个软连接，这里注意

 

 数组：

如果需要一个只包含数字的列表，那么array.array比list要更高高效，支持列表所有的操作，并且提供从文件读取和存入文件的更好的方法.frombytes   .tofile  （二进制会更快）

 

集合：

运算符：

s | t   s和t的并集
s & t   s和t的交集
s - t   求差集
s ^ t   求对称差集
len(s)  集合中项数
max(s)  最大值
min(s)  最小值    

 方法：

s.add(item)     将item添加到s中。如果item已经在s中，则无任何效果
s.remove(item)  从s中删除item。如果item不是s的成员，则引发KeyError异常
s.discard(item) 从s中删除item.如果item不是s的成员，则无任何效果
s.pop()         随机删除一个任意集合元素，并将其从s删除,如果有变量接收则会接收到删除到的那个元素
s.clear()       删除s中的所有元素
s.copy()        浅复制
s.update(t)     将t中的所有元素添加到s中。t可以是另一个集合、一个序列或者支持迭代的任意对象

s.union(t)        求并集。返回所有在s和t中的元素
s.intersection(t) 求交集。返回所有同时在s和t中的都有的元素
s.intersection_update(t)   计算s与t的交集，并将结果放入s
s.difference(t)            求差集。返回所有在set中，但不在t中的元素
s.difference_update(t)     从s中删除同时也在t中的所有元素
s.symmetric_difference(t)  求对称差集。返回所有s中没有t中的元素和t中没有s中的元素组成的集合
s.sysmmetric_difference_update(t) 计算s与t的对称差集，并将结果放入s

s.isdisjoint(t)   如果s和t没有相同项，则返回True
s.issubset(t)     如果s是t的一个子集，则返回True
s.issuperset(t)   如果s是t的一个超集，则返回True

 

 

字典：

遍历方法

第一种：
for k,v in dict.items():
    print(k,v)


第二种：高效
for key in dict:
    print(key,dict[key])

 

 

方法：

dict.get(key)      取得某个key的value
dict.has_key(key)  判断字典是否有这个key,在python3中已经废除,使用in 判断
dict.keys()        返回所有的key为一个列表
dict.values()      返回所有的value为一个列表
dict.items()       将字典的键值拆成元组，全部元组组成一个列表
dict.pop(key)      弹出某个key-value
dict.popitem()     随机弹出key-value
dict.clear()       清除字典中所有元素
dict.copy()        字典复制，d2 = d1.copy(),是浅复制,如果深复制需要copy模块
dict.fromkeys(S)   生成一个新字典
dict.update(key)   将一个字典合并到当前字典中
dict.iteritems()   生成key-value迭代器，可以用next()取下个key-value
dict.iterkeys()    生成key迭代器
dict.itervalues()  生成values迭代器

 

变量解包：

一、
>>> d1.items()
[('y', [1, 2, 3, 4]), ('x', 32)]

>>> t1,t2 = d1.items()

>>> print(t1)
('y', [1, 2, 3, 4])

>>> print(t2)
('x', 32)
二、
>>> d3,d4 = {'x':32,'y':80}

>>> print(d3)
y

>>> print(d4)
x

合并字典：相同的key会覆盖原有的key
>>> d1 = {'x':1,'y':2}

>>> d2 = {'m':21,'n':76,'y':44}

>>> d1.update(d2)

>>> print(d1)
{'y': 44, 'x': 1, 'm': 21, 'n': 76}

　　

 

 

 

字典推导：

country_code={(86,"china"),(91,"india"),(7,"rissia")}
country={country:code for code,country in country_code}
print(country)


{'china': 86, 'india': 91, 'rissia': 7}

　　

 

 

 

 

 

 

 深浅拷贝：

import copy
s='abc'
print(s.replace('c','222'))         # 打印出 ab222
print(s)                            # s='abc' s并没有被修改
s1=copy.deepcopy(s)
s2=copy.copy(s)
 
#可以看出下面的值和地址都一样，所以对于字符串和数字，深浅拷贝不一样，数字和字符串一样就不演示了，大家可以去试一下
print(s,id(s2))                     # abc 1995006649768
print(s1,id(s2))                    # abc 1995006649768
print(s2,id(s2))                    # abc 1995006649768