python数据结构类型：字符串、列表、元组、字典、集合

一、字符串

name = 'alex'
# 首字母大写
print(name.capitalize())
name = 'ALex Li english hahae'
# 首字母小写
print(name.casefold())
# 指定长度居中，用=补齐
print(name.center(10, '='))
# 制定范围统计
print(name.count('e', 0, 5))
# 判断是否以指定字符串结尾
print(name.endswith('ae'))
name = 'alex\tLi'
 # 指定tab键占用的空格数
print(name.expandtabs(20))
# 指定字符串在原字符串中的位置
print(name.find('Li'))
# 格式化赋值
msg = "my name is {0}, and i am {1} years old"
msg2 = "my name is {name}, and i am {age} years old"
print(msg.format('alex',22))
print(msg2.format(age=22, name='jack'))
# 是否英文字母
print('ad'.isalpha())
# 是否数字和字母
print('a3d'.isalnum())
# 是否十进制
print('2'.isdecimal())
# 是否正整数
print('2'.isdigit()) 
# 是否合法的变量名
print('al_ex'.isidentifier()) 
# 是否小写
print('al_ex'.islower()) 
# 是否大写
print('al_ex'.isupper()) 
# 是否数字
print('3'.isnumeric()) 
# 是否可打印
print('3'.isprintable()) 
# 是否数字
print('3'.isnumeric()) 
# 每个单子首字母是否大写
print('My Name Is Alex'.istitle())
# 将列表所有元素用，连接成一个字符串，作用与split相反
print(','.join(['alex','jack','rain']))
# 左对齐
print('3'.ljust(50,'-'))
# 右对齐
print('3'.rjust(50,'-'))
# 字符串小写
print('Alex'.lower())
# 左边去空格
print('    Alex  \n'.lstrip())
# 右边去空格和回车
print('    Alex  \n'.rstrip())
# 创建一个转义规则，根据规则转义字符串
from_str = '!@#$%^&'
to_str = 'abcdefg'
trans_table = str.maketrans(to_str,from_str)
str = 'alex'
str.translate(trans_table)
# 根据指定的字符串分割字符串
print('alex li'.partition('e'))
# 替换字符串内容
print('alex li'.replace('l','L',1))
# 以换行符分割字符串
print("alex\n l\ni".splitlines())
# 默认以空格为分隔符分割字符串
print("alex\n l\ni".split())
# 右对齐，用0填充
print('alex li'.zfill(40))

 

二、列表

　　列表相对于字符串来说，可以存储更多的数据，查找更方便

names = ['alex', 'jack', 'rain', 'mack', 'rain', 'bob']
# 切片
print(names[1:4:2])
print(names[-2:])
print(names[:2])
# 查找索引
first_index = names.index("rain")
# 查找第二个重复值rain的索引
second_index = names[first_index+1:].index("rain")
print(first_index, second_index)
# 删除列表元素
del names[first_index+second_index+1]
print(names)
# 删除
names.pop(4)
print(names)
# 修改列表元素值
names[4] = "Jason"
print(names)
# 列表相加
names += [1, 2, 3, 4]
print(names.extend([1, 2, 3, 4]))
print(names)
# 列表的嵌套与取值
names2 = [['alex', 22, ['Teacher', 3000]], ['oldboy', 56]]
print(names2)
print(names2[0][1])
names2[0][2][1] = 30000
print(names2)

 

三、元组

　　就是个只读的列表，不可修改。只有两个方法：count、index

 

四、字典

　　特点：无序，key唯一，查询效率高

names = {
    'stu1101': {'name':'Alex','age':22,'hobbie':'girl'},
    'stu1102': 'Jack',
    'stu1103': 'rain',
}
# search
print(names['stu1101']['hobbie'])
# print(names['stu1104'])
print(names.get('stu1104','sdfsdf'))

# add
names['stu1104'] = ['yangJian',31,'DBA']

# update
names['stu1104'][0] = 'wescker'
print(names)

# delete
print(names.pop('stu1105','ssss'))
del names['stu1103']
print(names)

 

五、集合

　　特点：无序、去重、关系测试

name = {9,2,6,'a',11,1,'d',2,3,4,5,3,4,2}
name.add(111)
name.remove(9)
a = {1,3,5,7,10}
b = {2,3,4,5,6,8}
a & b 交集 a和b都有
a.intersection(b)
a.intersection_update(b) -> a = a.intersection(b)
b - a 差集 b有a没有
b.difference(a)
a - b 差集 a有b没有
a.difference(b)
a | b 并集 所有的
a.union(b)
a ^ b 对称差集 并集-交集
a.symmetric_difference(b)
a.issubset(b) 子集
a.issuperset(b) 父集

 

 

六、关于深copy和浅copy

　　首先说一下最基础的字符串的赋值，为什么修改了name的值后name2不变呢，从他们的id值可以看出，name在命名时，是在内存中开辟了一块名叫'Alex'的空间，而name这个变量指向了这个内存空间，当将name赋值给name2的时候，实际上是将name2指向了同样的一个内存空间，因此这时的两个变量id值是一样的。当name被重新赋值，也就是说在内存中开辟了另一块叫做'Jack'的空间，将name指向了这个内存空间，而原先的那个'Alex'内存空间由于还有name2在指向并不会消失，而此时的两个id值是不一样的。所以说字符串的赋值只是变量在内存地址的指向发生了变化，而并不是真的将一个值赋给变量。下面的图片可以更好地诠释这个问题。

name = 'Alex'
name2 = name
print(id(name),id(name2))

name = 'Jack'
print(id(name),id(name2))

　　其次，再说说列表和字典的赋值，因为性质是相同的，所以就拿列表来举例吧。从以下的代码可以看出修改列表a后，列表b也会被修改，这和字符串恰恰相反啊，这要怎么理解呢，下面咱就来分析一下。首先内存中开辟了一块空间用来存放列表[1,2,3]，此时a和b都指向了这块内存空间，而当我们修改列表中的第三个元素时，其实整个列表所占用内存空间没有变更，变更的只是列表中的值，所以并不是重新开辟的内存空间，而结果呢就是a的元素被修改后b的元素也被修改了。

>>> a = [1,2,3]
>>> b = a
>>> id(a)
140227175556488
>>> id(b)
140227175556488
>>> a[2] = 4
>>> id(a)
140227175556488
>>> id(b)
140227175556488
>>> a
[1, 2, 4]
>>> b
[1, 2, 4]

　　

　　最后，说一说浅copy和深copy的问题，深copy是有一个叫做copy的模块，导入后，有一个copy.deepcopy()的方法，使用这个方法就是深copy。普通的copy就是浅copy。

两个copy的区别可以从下面的代码中看出来。每次的copy都会在内存中开辟一块新的空间。浅copy只能保证第一层不会随着a的变更而变更，从最后两行代码也可以看出，浅copy后的b列表和a列表的id值一样，也就是两个列表用的是同一块内存空间。而深copy则是完完全全开辟了一块新的空间，因此不管a如何变更，深copy后的c字典都不会变。

>>> a = {'a':1,'b':[1,2,3]}
>>> b = a.copy()
>>> c = copy.deepcopy(a)
>>> print("%s\n%s\n%s" % (id(a),id(b),id(c)))
140227172861896
140227172803272
140227172979144
>>> a['a'] = 0
>>> a['b'][0] = 0
>>> print("a = %s\nb = %s\nc = %s" % (a,b,c))
a = {'a': 0, 'b': [0, 2, 3]}
b = {'a': 1, 'b': [0, 2, 3]}
c = {'a': 1, 'b': [1, 2, 3]}

  >>> id(a['b'])
  140227172830472
  >>> id(b['b'])
  140227172830472

  >>> id(c['b'])
  140227172803208