Python基础之数据结构

一.列表(可变数据类型)

列表生成式

list3 = list(range(1, 11))
list4 = [x * x for x in range(1, 11)]    # 方式1
list5 = [x * x for x in range(1, 11) if x % 2 == 0]    # 方式2
list6 = [m + n for m in 'abc' for n in 'def']
list7 = [x if x % 2 == 0 else -x for x in range(1, 11)]    # 方式3

灵活使用列表生成式可以简化代码.

列表切片

list1 = [1, 2, 2, 3, 4, 5, 3, 10, 7, 199]
print(list1[1:3])
print(list1[:3])
print(list1[1:])
print(list1[1:9:2])
print(list1[::-1])

其他数据结构也可以用类似方法切片,左闭右开,-1代表最后一个元素,如果-1是间隔则代表后退.

列表的常见操作

list1 = [1, 2, 2, 3, 4, 5, 3, 10, 7, 199]
list2 = [6, 7, 8, 9]
print(list1 + list2)  # 列表叠加
print(list1 * 2)  # 列表重复
print(1 in list1)  # 判断某个元素是否在列表内
print(1 not in list1) # 判断某元素是否不在列表内
list1.append(6)  # 追加元素,参数为1个对象
list1.extend(list2)  # 拓展列表,参数为1个可迭代对象
list1.insert(8, 100)  # 指定位置插入对象
list1.remove(1)  # 移除元素(按值)，且只会删除第一个
list1.pop(0)  # 移除元素(按下标),无参数则移除末尾一个元素
list1.clear()  # 移除所有元素
list1.index(5)  # 返回指定值的下标,可选参数开始和结束位置
list1.count(2)  # 返回指定值在列表中出现的次数
list1.sort()  # 原地稳定排序列表,可选关键字key=func,reverse=True/False
list1.sort(key=list1.count) # 依据元素出现频率进行排序
list1.sort(reverse=True)  # 逆序
list1.reverse()  # 原地反转列表
len(list1)  # 获取列表的长度
max(list1)  # 获取列表最大值
min(list1)  # 获取列表最小值
list3 = list1.copy()  # 复制列表
del list1[0:4]  # 使用 del 语句可以从一个列表中依索引而不是值来删除一个元素
for i, j in enumerate(['a', 'b', 'c']):     # 把一个列表变成索引-元素对
    print(i, j)

 二.字符串(不可变数据类型)

字符串的格式化输出

常见转义字符:

1. "\":续行符
2. "\\":反斜杠符号
3. "\'":单引号
4. "\"":双引号
5. "\a":响铃
6. "\b":退格
7. "\000":空
8. "\n":换行
9. "\v":纵向制表符
10. "\t":横向制表符
11. "\r":回车(区别开换行)
12. "\f":换页
13. "\yyy":三位八进制数代表的ascll字符
14. "\xyy":两位十六进制数代表的ascll字符

常见的字符串格式化符号:

1. %c:格式化ASCLL码字符
2. %s:格式化字符串
3. %d:格式化整数
4. %u:格式化无符号整数
5. %o:格式化无符号八进制数
6. %x:格式化无符号十六进制数
7. %f:格式化浮点数,指定精度
8. %e:科学计数法格式化浮点数
9. %g:%e和%f的简写
10. %p:用十六进制格式化变量的地址

格式化操作符标志指令:

1. *:定位宽度或小数点精度
2. -:用作左对齐
3. +:用作右对齐
4. <sp>:在正数前面显示空格
5. #:在八进制数前面显示零'0'，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
6. 0:显示的数字前面填充0而不是空格
7. %:%%输出一个单一的%
8. m.n.:m 是显示的最小总宽度,n 是小数点后的位数

%格式化字符串的格式: 

                        %[(name)][flags][width].[precision]typecode
name:命名
flags:可以有 +，-，' '或 0。+ 表示右对齐。- 表示左对齐。' ' 为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0 表示使用 0 填充。
width:总宽度
precision:小数点后的宽度
typecode:类型码    

格式化输出字符串的几种方式:

language, time = "python", 10000
print("I love %s %d 年"%("python", 10000))    # 方式1
print("I love {} {} 年".format("python", 10000)) # 方式2
print("I love {language} {time} 年") # 方式3

 字符串的常见操作

print('a' in "abc")  # 成员运算符
print('a' not in "abc")  # 成员运算符
print(r"\n\n\n\n")  # 原始字符串
print(str(1.234))  # 转换为字符串
print(str.capitalize('qwer'))  # 字符串首字母大写, 其他字母全部变成小写
print('abcdaaaa'.count('a'))  # 统计指定子串的出现次数            str.count(sub, start, end)
print('abcdefg'.find('d'))  # 寻找子串首次出现位置(从左向右)    str.find(sub, start, end)
print('abcdefg'.rfind('d'))  # 寻找子串首次出现位置(从右向左)    str.rfind(sub, start, end)
print("abcdefgaabbccd".replace("a", "b", 2))  # 把string中的str1替换成str2,如果num指定，则替换不超过num 次.
print("aaa".center(10))  # 原字符串居中,并用第二个参数fillchar填充至width长度的字符串
print("aBcD".swapcase())  # 大小写反转
print("sandoainfnwqoid".startswith("sa", __start=0, __end=10))  # 判断字符串是否以某个字串结尾
print("sandoainfnwqoid".endswith("id", __start=1, __end=10))  # 判断字符串是否以某个字串结尾
print(str.isalnum('aaaaa asf'))  # 判断字符串是否全是字母或数字
print(str.isalpha('asnasfn1312'))  # 判断字符串是否全是字母
print(str.isdigit('13241emeqw'))  # 判断字符串是否全是数字
print('(\n\r\f\t\v)'.isspace())  # 判断字符串是否只包含(\n、\r、\f、\t、\v)
print('abc'.islower())  # 判断指定字符串是否全是小写字母
print('abc'.isupper())  # 判断指定字符串是否全是大写字母
print(','.join(['p', 'y', 't', 'h', 'o', 'n']))  # str.join(iterable)以指定字符串作为分隔符，将iterable中所有的元素(必须是字符串)合并为一个新的字符串。
print('abc'.lower())  # 指定字符串转换为小写
print('abc'.upper())  # 指定字符串转换为大写
print('abc'.split(sep=',', maxsplit=-1))  # sep参数指定分隔符，maxsplit参数为最大分割次数，-1代表无限次
print(str.strip("  hello,world  "))  # 去掉字符串首尾空格
print(' asf '.rstrip())  # 去除字符串末尾空白
print(' asad '.lstrip())  # 去除字符串开头空白

 三.元组(不可变,适用于存储在程序运行期间可能变化的数据)

列表使用[]创建,元组使用()创建,元组操作大部分类似于列表.

元组中只包含一个元素时，需要在元素后面添加逗号 , 否则括号会被当作运算符使用.

当元组的元素是可变对象时,对象的内部属性是可以修改的.

四.集合(可变,无序不重复元素的集,基本功能包括关系测试和消除重复元素。)

创建空集合必须使用set()而不是{},{}用来创建空的字典

集合不能使用下标访问到元素

两个集合的运算

a = set('abracadabra')
b = set('alacazam')
print(a - b)  # 在a中不在b中
print(a | b)  # 在a中或在b中
print(a & b)  # 同时在a和b中
print(a ^ b)  # 不同时在a和b中

集合的常见操作

s = {1, 'a', 'abc', [1, 2, 3], (4, 5, 6)}
s.add({7, 8, 9})  # 往集合里添加元素,参数不能有列表
s.update("abcd")   # 往集合里添加元素,参数可以是列表,会把复合元素分散开插入
s.update({"abcd"})   # 往集合里添加元素,参数可以是列表,不会把复合元素分散开插入
s.remove(1) # 将元素从集合中删除,不存在则报错
s.discard(1)    # 将元素从集合中删除,不存在也不会报错
s.pop() # 随机删除某个元素,返回被删除的元素
len(s)  # 统计个数
s.clear()   # 清空集合
print('1' in s) # 成员运算

 五.字典(可变,无序的键值对,键必须唯一)

键必须唯一且是不可变类型,如果出现了两个键一样,则保留后面那个键对应的值,值不必须唯一.
字典的每个键值对用冒号:分割，每个对之间用逗号(,)分割，整个字典包括在花括号{}中.

字典的创建

book = {}
book = dict()  # 创建空字典
mapping = zip(("掌握Python的字典类型",), (210,))
book1 = dict(mapping)  # 使用mapping对象来创建字典
book2 = {
    "name": "python",
    "price": 1,
}
book3 = {zip(["a", "b", "c"], [1, 2, 3])}  # 使用列表来创建字典

字典的遍历

alien0 = {'color': 'blue', 'point': 5, 'xposition': 0, 'yposition': 25}
# 字典的遍历
for key, value in alien0.items():  # 遍历字典
    print(key + ': ' + str(value))
for key in alien0.keys():  # 遍历字典中的键
    print(key)
for value in alien0.values():  # 遍历字典中的值
    print(value)

字典的操作 

print(alien0["name"])  # 访问字典
alien0["name"]="new_name"   # 修改字典值
alien0.copy()  # 返回字典的一个浅复制
sorted(alien0)  # 字典临时排序
dict.fromkeys(["a", 'b', 'c'], 3)   # 第一个参数为键(可迭代对象),第二个参数为值(value),创建字典
alien0.get("name")  # 得到指定键的值
alien0.items()  # 以列表的方式返回可遍历的(key,val)元组
alien0.keys()  # 以列表返回一个字典所有的键
alien0.values()  # 以列表返回一个字典所有的值
alien0.pop("name")  # 删除字典给定键 key 所对应的值，返回值为被删除的值
alien0.popitem()  # 返回并删除字典中的最后一对键和值。
alien0.update({"size": 100})  # 把字典dict2的键/值对更新到dict里
del alien0['color']  # 删除字典的某个键是指定值的条目
alien0.clear()  # 清空字典
# del alien0  # 删除字典

 六.数字(不可变数据类型)

四种类型    int/float/bool/complex
            10  10.0  True  1+2j
类型转换
int(x [,base ])         将x转换为一个指定进制的整数
long(x [,base ])        将x转换为一个长整数
float(x)                将x转换到一个浮点数
complex(real [,imag ])  创建一个复数
str(x )                 将对象 x 转换为字符串
repr(x )                将对象 x 转换为表达式字符串
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )               将序列 s 转换为一个元组
list(s )                将序列 s 转换为一个列表
chr(x )                 将一个整数转换为一个字符
unichr(x )              将一个整数转换为Unicode字符
ord(x )                 将一个字符转换为它的整数值
hex(x )                 将一个整数转换为一个十六进制字符串
oct(x )                 将一个整数转换为一个八进制字符串
bin(x )                 将一个整数转换为一个二进制字符串