Python--字符串&列表&元组&字典
Python--字符串&列表&元组&字典
- 数据类型
- 字符串
- 列表
- 元组
- 集合
- 字典
- 比较
数据类型
不可变数据类型在第一次声明赋值声明的时候, 会在内存中开辟一块空间, 用来存放这个变量被赋的值, 而这个变量实际上存储的,并不是被赋予的这个值, 而是存放这个值所在空间的内存地址, 通过这个地址, 变量就可以在内存中取出数据了. 所谓不可变就是说, 我们不能改变这个数据在内存中的值, 所以当我们改变这个变量的赋值时, 只是在内存中重新开辟了一块空间,将这一条新的数据存放在这一个新的内存地址里, 而原来的那个变量就不在引用原数据的内存地址而转为引用新数据的内存地址了.
结合不可变数据类型，可变数据类型就很好理解来，可变数据类型是指变量所指向的内存地址处的值是可以被改变的。
从另外一个角度来看：
可变类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型。
可变数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型。
不可变：Number（数字）、String（字符串）、Tuple（元组）。
可以变：Set（集合）、List（列表）、Dictionary（字典）
字符串
| 字符串运算符 | |
|---|---|
| + | 字符串连接 a + b 输出结果： HelloPython |
| * | 重复输出字符串 a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True ‘H’ in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True ‘M’ not in a 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 |
| % | 格式字符串 |
| 字符串格式化符号: | |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
| 格式化操作符辅助指令 | |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| 在正数前面显示空格 |
|
| 在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) | |
| 0 | 显示的数字前面填充’0’而不是默认的空格 |
| % | ‘%%‘输出一个单一的’%’ |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
| 字符串内建函数 | |
|---|---|
| capitalize() | 将字符串的第一个字符转换为大写 |
| center(width, fillchar) | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| bytes.decode(encoding=“utf-8”, errors=“strict”) | Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 |
| decode() | 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| encode(encoding=‘UTF-8’,errors=‘strict’) | 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ |
| endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
| expandtabs(tabsize=8) | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| find(str, beg=0, end=len(string)) | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| index(str, beg=0, end=len(string)) | 跟find()方法一样，只不过如果str不在字符串中会报一个异常。 |
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| isdigit() | 如果字符串只包含数字则返回 True 否则返回 False… |
| islower() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False. |
| istitle() | 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| join(seq) | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| len(string) | 返回字符串长度 |
| ljust(width[, fillchar]) | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| lower() | 转换字符串中所有大写字符为小写. |
| lstrip() | 截掉字符串左边的空格或指定字符。 |
| maketrans() | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| max(str) | 返回字符串 str 中最大的字母。 |
| min(str) | 返回字符串 str 中最小的字母。 |
| replace(old, new [, max]) | 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 |
| rfind(str, beg=0,end=len(string)) | 类似于 find()函数，不过是从右边开始查找. |
| rindex( str, beg=0, end=len(string)) | 类似于 index()，不过是从右边开始. |
| rjust(width,[, fillchar]) | 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| rstrip() | 删除字符串字符串末尾的空格. |
| split(str="", num=string.count(str)) | 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 |
| splitlines([keepends]) | 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| startswith(substr, beg=0,end=len(string)) | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| strip([chars]) | 在字符串上执行 lstrip()和 rstrip() |
| swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
| title() | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| translate(table, deletechars="") | 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| upper() | 转换字符串中的小写字母为大写 |
| zfill (width) | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| isdecimal() | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
| 常用内建函数 | |
|---|---|
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| isdigit() | 如果字符串只包含数字则返回 True 否则返回 False… |
| islower() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| istitle() | 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
s='abcde'
print(s[0]) #取第一个字符
print(s[1]) #取第二个字符
print(s[-1])#取最后一个字符
print(s[0:3])
print(s[0:4:2])#s[start:stop:step] start是起始索引 stop是终止索引 step是步长
print(s[::-1]) #反转
print(s[1:]) #除了第一个的所有字符
print(s[s*10])
'hello'.count('l')
len('hello')
s.split('/') #以/为分隔符切片
判断一个数是不是回文数
num = input('num:')
if num == num[::-1]:
print('回文数')
else:
print('不是')
判断文件名称的开头和结尾
filename = 'hello.log'
if filename.endswith('.log')
print(filename)
else:
print('error')
补齐字符串
交换数值
a=1
b=2
a,b=b,a
列表
| list.append(obj) | 在列表末尾添加新的对象 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
| list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置，索引从0开始 |
| list.insert(index, obj) | 将对象插入列表 |
| list.pop(obj=list[-1]) | 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值 |
| list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| list.reverse() | 反向列表中元素，倒转 |
| list.sort([func]) | 对原列表进行排序 |
list=[1,1.2,True,'westos'] #可以存储不同数据类型
list=[1,1.2,True,'westos',[1,2,3]] #列表嵌套
li = ["span",[18,188,1888],"python","金融","FX-EXchange"]
li.extend("Math")
li.extend([1,2,3])
print(li)
>>>['span', [18, 188, 1888], 'python', '金融', 'FX-EXchange', 'M', 'a', 't', 'h', 1, 2, 3]
拆包
拆包就是把元组中的元素分别赋值给变量，值得注意的是，元素的个数需要和变量的个数相对应，当然，在实际的应用中，有时我们需要的变量没有那么多，或者变量的个数比元素的个数多，这就需要我们用一个符号：* 来解决问题，正如上面的代码，当变量的个数多的时候，用一个 星号可以将多的变量赋值成一个空的列表；当元素个数多的时候，用一个星号就可以把多出来的元素组成一个列表赋值给最后一个元素。
在赋值的时候，星号代表的是装包，在打印的时候，星号代表的是拆包。
元组
元组这种数据结构同列表类似，都可以描述一组数据的集合，它们都是容器，是一系列组合的对象，不同的地方在于，元组里的元素是不能更改的
可以在元组中添加列表，这样可以间接修改元组 声明：使用小括号对元组进行声明，和列表的区别在于，列表是用中括号和列表的区别：列表一般用于不确定个数的数据的集合中，当不知道元素的个数是，用列表来表示，而元组一般用于描述一个东西的特性，可以用来描述一个学生的学号、姓名、出生年月、年龄和身高，
访问元组中的值 就如同列表一样，访问方法也是使用“[]”加上“:”来访问 元组的创建和特性
元组和列表很相似，不过元组是不能在原处改变的对象，这点性质和字符串一致，虽然元组不支持任何方法调用，但是元组具有列表的大多数属性，以下是元组的一些特性。
支持索引和切片 既可以通过索引和切片读取元组内的数据
固定长度 由于元组为不可变的序列，所以是不能在生成一个拷贝的情况下进行增删的
任意嵌套 即元组和列表、字典都支持其他的复合对象，比如其他的元组，字典，列表等
| cmp(tuple1, tuple2) | 比较两个元组元素。 |
| len(tuple) | 计算元组元素个数。 |
| max(tuple) | 返回元组中元素最大值。 |
| min(tuple) | 返回元组中元素最小值。 |
| tuple(seq) | 将列表转换为元组。 |
求平均成绩，（去掉最高分和最低分）
scores = (100,89,45,78,65)
scores = sorted(scores)
minscores,*middlescore,maxscore = scores
print(middlescore)# 除去最大值最小值
avg = sum(middlescore)/len(middlescore)
集合
集合的定义： 集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，
注意：创建一个空集合必须用 set() 而不是 { }，因为 { }是用来创建一个空字典。
集合的特性
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
集合的其他用法：
s1 = {
1,2,3}
s1 = {
2,3,4}
#并集
print(s1.union(s2))
print(s1|s2)
#交集
print(s1.union(s2))
print(s1&s2)
#差集
print(s1.difference(s2))
s3 = {
1,2}
s4 = {
1,2,3}
print(s4.issuperset(s3)) #超集
print(s4.issubset(s3)) #子集
print(s4.isdisjoint(s3)) #子集
练习：输出一个元素个数为N的集合，元素值在1~1000以内
字典
字典的定义： 字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。 字典的创建
把所有的key都设置成相同的value值
字典的特性
添加字典元素
查看字典元素
如果key值不存在，则报错
d = {
'a': 2, 'A': 1, 'c': 3, 'b': 2}
sorted_key_list = sorted(d) #通过key正向排序
sorted_key_list = sorted(d, key=lambda x:d[x]) #通过value正向排序
| 字典内置函数&方法 | |
|---|---|
| cmp(dict1, dict2) | 比较两个字典元素。 |
| len(dict) | 计算字典元素个数，即键的总数。 |
| str(dict) | 输出字典可打印的字符串表示。 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
| dict.clear() | 删除字典内所有元素 |
| dict.copy() | 返回一个字典的浅复制 |
| dict.fromkeys() | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| dict.get(key, default=None) | 返回指定键的值，如果值不在字典中返回default值 |
| dict.has_key(key) | 如果键在字典dict里返回true，否则返回false |
| dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
| dict.keys() | 以列表返回一个字典所有的键 |
| dict.setdefault(key, default=None) | 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default |
| dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| dict.values() | 以列表返回字典中的所有值 |
数字重复统计:
1). 随机生成1000个整数;
2). 数字的范围[20, 100],
3). 升序输出所有不同的数字及其每个数字重复的次数;
1. 随机生成100个卡号；
卡号以6102009开头， 后面3位依次是 （001， 002， 003， 100），
2. 生成关于银行卡号的字典， 默认每个卡号的初始密码为"redhat";
3. 输出卡号和密码信息， 格式如下:
卡号 密码
6102009001 000000
比较
这里只列举一些基本方法，还可以通过调用函数或者遍历等方法进行实现，篇幅有限，就不列举了
| 字符串 | 列表 | 元组 | |
|---|---|---|---|
| 定义 | str = ‘westos’ | list=[1,2] | s=(1,2) s=(1,) 一个元素也要加逗号 |
| 空 | str=‘’ | list=[] | 由于不能改变，空元组无意义 |
| 增 | list.append() list.extend 追加 list.insert(1,‘h’) 指定索引插入 |
tuple1+tuple2生成新元组 可以嵌套列表实现添加 |
|
| 删 | del str | list.remove() 删除指定 list.pop() 删除最后一个 list.pop(1) 删除索引 |
del tuple |
| 改 | str=‘redhat’ | list[0]='a’ 通过索引重新赋值 |
由于不可变 修改后会改变地址 可以嵌套列表实现更改 |
| 查 | list.count()统计次数 list.index()查看索引 len(list) max/main(list) |
同列表 | |
| 索引 | str[0]第一个字符 str[-1]最后 一个字符 |
list[0] list[-1] |
s[0] s[-1] |
| 切片 | str[:3] 显示前3个字符 s[0:4:2] 步长为2 |
list[:3] list[0:4:2] |
s[:3] s[0:4:2] 步长为2 |
| 反转 | str[::-1] | list[::-1] list.reverse() list.sort(reverse=True) |
tuple[::-1] |
| 排序 | list.sort()永久的 sorted(list)临时的 |
tuple.sort() | |
| 重复 | str * 10 | list * 10 | s * 10 |
| 连接 | ‘hello ’ + ‘python’ ’ '.join(list) |
list+list1 | 由于不可变 连接后会改变地址 |
| 成员操作 | ‘he’ in str | ‘he’ in list | ‘he’ in tuple |
| 遍历 | for i in str | for i in list for i,v in enumerate(list) 返回index和对应value |
for i in tuple |
| 集合 | 字典 | |
|---|---|---|
| 定义 | set1=set(1,2)不能有重复 | dict={a:1,b:2} dict={a=1,b=2} |
| 空 | set1=set() | dict={} |
| 增 | 同list | key存在则更新 不存在则添加 dict.update() |
| 删 | 同list | del dict(a) dict.clear()清空 dict.pop(a)删除指定 dict.popitem()删除最后 |
| 改 | 同list | dict[a]=3 |
| 查 | 同list | dict.keys()返回列表 dict.values() dict.items() dict.get(key, default=None) len(dict) |
| 索引 | 同list | 键值即索引 |
| 切片 | 同list | {k: ori_dict[k] for k in list(ori_dict.keys())[start:end]} |
| 重复 | 不能重复 | 键值必须唯一 |
| 遍历 | 同list | for k,v in dict.items |
| 连接 | dict(dict1,**dict2) dict.update(dict1) dict(d1.items() + d2.items()) |
|
| 排序 | 同list | sorted(dict) sorted(dict, key=lambda x:dict[x]) 通过value排序 |
| 成员操作 | ‘he’ in set | ‘he’ in dict |