python学习笔记-核心基本数据类型方法

备注：在函数的括号[]中的为可选参数，本文介绍的是python3中的用法

一、字符串

不可变对象

1.索引或切片

s是一个字符串,如：s=”Hello World”
s[i]：索引运算符，选取字符串s的第(i+1)即索引为 i 的字符
s[i:j]：切片运算符，选取索引 i 到索引 j 之间的字符，不包括索引 j，即[i,j)
s[i:j:stride]：扩展切片运算符，在 [i,j) 之间每隔(stride-1)个字符选取一个字符，stride的使用与range函数的步长类似，默认为1
示例：

a = "Hello World"
b = "我爱中国"
print(a[1:8:2])
print(b[1:4:2])

输出结果：

el o
爱国

索引分正向索引和负向索引，正向索引和负向索引的绝对值之和为字符串的长度。
即：
0 1 2 3 4 5 6 7 8 9
h e l l o w o r l d
-10 -9 -8 -7 –6 -5 -4 -3 -2 -1
s[-3::-1]表示从倒数第三个到正数第一个

2.适用于字符串的操作

s是一个字符串,如：s=”Hello World”

2.1 大小写转换

s.captitalize()：首字符变大写(整个字符串的首字母大写,只有一个)
s.title()： 首字母大写(整个字符串的每个单词首字母都大写)
s.lower()： 转换为小写形式(只能转换ASCII码中的大写即[A-Z]
s.upper()：转换为大写形式
s.casefold()：可以将其他的大写转化为小写，如：德语
s.swapcase() ：使大小写互换

2.2 连接、替换和分割

a+b：a和b是两个字符串，a+b可以将两个字符串连接，返回一个新的字符串
s.join(t)： 使用s作为分隔符连接序列t
s.replace(old,new[,maxreplace])： 替换一个字符串，后面可以加替换的次数
s.expandtabs(tabsize=8): 把字符串中的制表符换为空格,默认换成8个空格
s.format()：常用于格式化输出字符串,例子：“{0}:{1}”.format(x,y)(x,y为变量)
s.split([sep[,maxsplit]])：使用sep作为分隔符对一个字符串从左向右进行划分，maxsplit是划分的最大次数，默认为按空格分割
s.rsplit([sep[,maxsplit]])：与split类似，区别是从右向左寻找
s.splitlines([keepends])：按照行(‘\r’,’\r\n’,’\n’)进行分割,keepend为True时保留换行符,默认为False
s.partition(‘.’) ：以从左向右第一个’.’作为分隔符,返回三元元组,(头部,分隔符,尾部)，分隔符可以随意更换
s.rpartition(‘.’)：与partition类似，区别是从右向左

2.3 填充

s.center(30,’#’) 总长度为30,居中显示,其余部分用#填充，长度和填充符号都可以替换
s.ljust(长度值,’符号’)： 让s长度为长度值,在尾部以符号填充
s.rjust(长度值,’符号’)： 让s长度为长度值,在头部以符号填充
s.zfill(width)： 用0填充字符串的左边

2.4 寻找、计数和删除空白

s.index(‘x’[,start[,end]])：从左向右寻找字符x在字符串[,start[,end]]中的最小位置,找不到报错ValueError
r.rindex(‘x’[,start[,end]])：与index类似，区别是从右向左寻找
s.find(‘x’[,start[,end]])： x字符是否在str[start,end]中,若在则返回x的从左向右的最小位置,不在,返回-1
s.rfind()：与find类似，区别是从右向左
s.count(‘x’[,start[,end]])：x字符在字符串[start,end]中的个数，未指定[start,end]则计数x在字符串中的格式
s.strip([chrs]) 如果没有指定删除的字符chrs，则删除开头和结尾的空白，如果指定字符，则删除开头和结尾的字符chrs
s.lstrip([chrs])：与strip类似，只删除左边的
s.rstrip([chrs])：与strip类似，只删除右边的

2.5 判断

s.endswith(‘.log’)： 判断是否以其结尾，是则返回true，括号中可随意更换
s.istitle()：判断字符串是不是首字母大写,其他小写
s.isalnum()：s至少有一个字符,且仅由字母和数字构成，是则返回True，否返回False
s.isalpha()： s至少有一个字符,且仅由字母构成
s.isdigit()： 判断是否是数字
- True:Unicode数字,byte数字(单字节),全角数字(双字节),罗马数字
- False:汉字数字
- Error:无
s.isdecimal() ：检查字符串是否只包含十进制字符,这种方法只存在于unicode对象
- True:Unicode数字,全角数字(双字节)
- False:汉字数字,罗马数字
- Error:byte数字(单字节)
s.isnumeric()： 判断是否是数字
- True:Unicode数字,全角数字(双字节),罗马数字,汉字数字
- False:无
- Error:byte数字(单字节)
s.isspace()：是否由空白字符组成(包括空格,制表符,换行符,回车符等)
s.isidentifier()：是否是有效的python标识符(是就返回True)

二、列表

1.容器类型

1）任意对象的有序集合
2）通过索引访问其中的元素
3）可变对象
4）异构(可以包含多种不同类型的元素)，任意嵌套

2.列表的操作

2.1 创建(深复制和浅复制)

创建列表：l1=[1,2,3] 或 l1=list([1,2,3])
list(l1)： l1必须为可迭代的对象
l1 * 10： 相当于把n个列表 l1 连接在一起，返回一个新列表
l1+l2： 合并两个列表，返回一个新的列表，不会修改原列表
深复制与浅复制
l3=l1： l3与l1是同一个id(id可以理解为在内存中的位置)
l3=l1[:]： l3与l1 不是同一个id 与 l5=copy.deepcopy(l1),l5=l1.copy()(浅拷贝) 一个效果 ，但是l3=l1[:]是浅拷贝,l5=copy.deepcopy(l1)是深拷贝，如果id相同，更改一个对象的内容，其他对象的内容也会改变，id不同，则不会相互影响，下面是一个案例，可以清楚地体会到他们的区别

import copy
l1 = [1,2,3,[1,2,3]]
l2 = l1
l3 = l1[:]
l4 = copy.deepcopy(l1)
print(id(l1))   #2454392243208
print(id(l2))   #2454392243208
print(id(l3))   #2454392244040
print(id(l4))   #2454392243976
print(id(l1[3]))#2454392243016
print(id(l2[3]))#2454392243016
print(id(l3[3]))#2454392243016
print(id(l4[3]))#2155310712520
l1[0] = 100
l1[3][0]= 200
print(l1)   #[100, 2, 3, [200, 2, 3]]
print(l2)   #[100, 2, 3, [200, 2, 3]]
print(l3)   #[1, 2, 3, [200, 2, 3]]
print(l4)   #[1, 2, 3, [1, 2, 3]]

2.2 添加

l3=[1,2,3] ，l4=[‘x’,’y’,’z’]
l3.append(l4) ： 返回值为None，更改 l3 的值为 [1,2,3,[‘x’,’y’,’z’]]
l3.extend(l4)：返回值为None，更改 l3 的值为 [1,2,3,‘x’,’y’,’z’]，即以迭代的方式把l4加到l3中
l3.insert(index,sub) 在索引index前插入内容sub

2.3删除

l3[1:3]=[]： 表示把1,2索引的元素删除，也可以使用 del(l2[1:3])
l3.pop([index])： 按索引弹，弹出元素，返回弹出的元素,在原来的id上操作即删除原列表的元素，如果索引超出列表范围，报错IndexError
l3.remove(sub)：按内容弹出，返回None，如果值不存在报错ValueError(删除指定值的操作,使用try,except语句或者先行进行判断),在原来的id上操作
l3.clear()：清空列表,在原来的id上操作，返回值为None

2.4 查找、计数和排序

l3.index(value[,start[,stop]])：在列表的索引为 [start,stop) 之间查找值为value的元素，返回值为其索引，没找到报错ValueError
l3.count(x) ：返回x在列表 l3 中出现的次数，没查到返回0
l3.reverse() ：将列表 l3 逆序排列，在原处修改，返回值为None
l3.sort(reverse=False)：排序,在原处修改,返回None,reverse默认是False,按升序排列，reverse为True时，按降序排列
sorted(l3)：sorted可以对所有可迭代的对象进行排序，本笔记介绍的(字符串、列表、元组、字典、集合)都可以通过sorted函数进行排序，返回排序后的结果

三、元组

1.容器类型

1）任意对象的有序集合
2）通过索引访问其中的元素
3）不可变对象，长度固定
4）异构(可以包含多种不同类型的元素，如列表)，嵌套

虽然元组本身不可变，但如果元组内嵌套了可变类型的元素，那么此类元素的修改不会返回一个新的元组，可以看作是一个不可以更改的list

a = (1,2,[1,2,3])
a[0] = 3    #报错TypeError
a[2][0]=3   #可以修改，a变为(1, 2, [3, 2, 3])

2.元组操作

2.1创建元组

t= () 或 t=(1,) 或 t = 1, 或 t=(1,2,3) 或 t = 1,2,3 或 t = tuple(a) a 需为可迭代对象
例如：t = tuple(“hello”)

2.2计数和插入

t.index(value[,start[,stop]])：在元组的索引为 [start,stop) 之间查找值为value的元素，返回值为其索引，没找到报错ValueError
t.count(x) ：返回x在元组 t 中出现的次数，没查到返回0

四、字典

1.简介

1）通过键实现元素存取
2）无序集合
3）可变对象
4）异构
5）嵌套
kv对的key必须是可哈希的值,比如int,string,float,tuple但是list,set,dict不行,value可以是任何值

2.字典操作

2.1创建字典

D={} 或 D=dict() 或 D={“one”:1,”two”:2,”three”:3}
或 D=dict({“one”:1,”two”:2,”three”:3})
或 D=dict(one=1,two=2,three=3) 或 D=dict([(“one”,1),(“two”,2),(“three”,3)])
D[‘four’] = 4：可以 添加字典中的元素
字典复制
d3=d1.copy()：id不同(浅复制)
d3=d1：id相同
d1 = copy.deepcopy(d)：id不同(深复制)
与列表类似，就不详细介绍了

2.2返回字典键、值

d1 = {‘one’:1,’two’:2}
d1.items()： 将字典分为几个元组，有几个键值对就分几个元组，返回的是dict_items([(‘one’, 1), (‘two’, 2)])，可以用for循环遍历
d1.keys()：返回字典的所有键值，dict_keys([‘one’, ‘two’])
d1.values()：返回字典的所有值 ，dict_values([1, 2])
d1.get(‘one’, ‘hi’)：如果’one’在字典d1中,获得的是a[”one],否则获得的是 hi

2.3删除

删除操作:del d1[“one”]
d1.pop(key[,d])：删除键的值为key的元素，如果key在字典中，返回d1[key]，如果key在字典中不存在,返回 d
d1.popitem()：删除字典d中的一个键值对，返回此键值对，如果字典为空，报错KeyError

2.4 fromkeys和update

fromkeys：使用指定的序列作为键,使用一个值作为字典的所有键的值
使用示例：

In [1]: l = [1,2,3,4]
In [2]: dict.fromkeys(l,"hi")
Out[2]: {1: 'hi', 2: 'hi', 3: 'hi', 4: 'hi'}
In [3]: dict.fromkeys("hi",l)
Out[3]: {'h': [1, 2, 3, 4], 'i': [1, 2, 3, 4]}

d.update(e)：更新字典中的键值对,可以修改存在的键对应的值,也可以添加新的键值对到字典中,没有返回值
案例：

d = {'one':1,'two':2}
d.update({'three':3,'four':4})      #传一个字典
d.update(five=5,six=6)              #传一个关键字
d.update([('seven',7),('eight',8)]) #传一个包含多个元组的列表
d.update((['nine',9],['ten',10]))   #传一个包含多个列表的元组
d.update(zip(['eleven','twelve'],[11,12])) #传一个zip函数
d.update(one=111,two=222)       #使用以上任意方法修改存在键对应的值
输出结果：
{'one': 1, 'two': 2}
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8}
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10}
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10, 'eleven': 11, 'twelve': 12}
{'one': 111, 'two': 222, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10, 'eleven': 11, 'twelve': 12}

五、集合

1.容器类型

1）无序排列
2）内部数据元素具有唯一性,可以用来排除重复数据
3）可变对象
不支持：索引、元素获取、切片

2.集合操作

2.1 创建

s = set([1,2,3])，s1 = set([3,4,5])
s1 = s：s1的id与s的id相同
s2 = s.copy()：s2的id与s的id不同
s2 = s.union(s1)：并集，返回一个新集合，等价于 s2 = s | s1
s2 = s.intersection(s1) ：交集 等价于 s2 = s&t
s.intersection_update(s1)：进行交集,更新实例自己,返回None，等价于 s &= s1
s2 = s.difference(s1)：差集,返回一个新的set，等价于 s2 = s - s1
s.difference_update(s1)：进行差集,更新实例自己,返回None，等价于 s -= s1
s2 = s.symmetric_difference(s1)： 对称差集(返回所有在s或t中，但又不同时在这两个集合中的项)，返回一个新的集合，等价于 s2 = s ^ s1
s.symmetric_difference_update(s1)： 对称差集，更新实例，返回None，等价于 s ^= s1

2.2添加和删除

s.add(value)：向集合内添加值value，原地修改，返回值为None
s.clear()：原地清空数据
s.remove(value)：移除指定的值value,直接改变原有值,返回值为None，如果要删除的值不存在,报错
s.discard(value)：移除集合中指定的值,与remove一样,删除值不存在不报错
s.pop()： 移除元素,返回移除的元素,不需要参数
s.update(l)：l需要是一个可迭代对象，如：s.update([3,4])，将[3,4]加入到集合中，如有重复元素，自动去重

2.3判断

s.isdisjoint(s1)：如果两个集合没有交集,返回True，否则返回False
s.issubset(s1)：检查集合 s 是否为另一个集合 s1 的子集，是则返回True
s.issuperset(s1)：检查一个集合s是否为另一个集合是的超集(或父集)，是返回True

六、总结

1.可变对象与不可变对象

可变对象指内存地址不变，内容可以改变
不可变指内容改变，地址改变
列表：a = [“小红”,”小白”] a[1]
元组：b = (“小红”,”小白”) 不能改变内容 b[1]

2.5种数据类型都适用的常用方法

max(s)：返回序列s的最大值，适用于能够对元素进行排序的序列
min(s)：与max类似，返回序列 s 的最小值
len(s)：返回序列s的长度
sorted(s,reverse=False)：返回排序后的s序列，默认reverse为False，是升序排列，reverse设置为True是为降序排列

3.引用计数

所有对象都有引用计数,用sys.getrefcount(name) 可查看引用次数
1）增加对象的引用计数的场景：
对象创建时
将对象添加进容器时，类似list.append
当对象被当做参数传递给函数时
为对象创建另外变量名
2）减少引用计数：
引用此对象的某变量名被显式销毁：del x
给引用此对象的某变量名重新赋值
从容器中移除对象时，类似list.pop()
容器本身被销毁

4.概述

列表和元组并不真正存储数据，而是存放数据引用
python的一切数据是对象，一切命名是引用
列表和字典都支持两种类型的复制操作：深复制和浅复制

---

本文由博主根据多方面资料总结而成。还有未涉及的，会不定期更新，有错误请指正。
如果这篇博文对您有帮助，您一定要转载，请带上后缀和本文地址。