目录
数值类型
整型进制表示法
- 二进制：0b开头,只能包含0、1
- 八进制：0o开头,能包含0-7
- 十六进制：0x开头,能包含0-F
整形进制操作
- bin：任意进制转二进制,接收一个int,返回一个str
- oct：任意进制转八进制,接收一个int,返回一个str
- hex：任意进制转十六进制,接收一个int,返回一个str
- int：任意进制转十进制,接收一个int/str,返回一个int
float：不精确的小数,因为它是用二进制表示的
decimal：精确的小数
复数complex：
实部和虚部都存在的浮点数，基本形式为a+bi，其中a、b是实数，i是虚数；a称为实部，bi称为虚部
实部和虚部都是浮点型
布尔类型
布尔类型的取值范围：只有 True 和 False
哪些值的布尔值为假
0，0.0，None，False，空字符串''，空列表[]，空元组()，空字典{}
哪些值的布尔值为真
除了为假的，其他的都为真字符串
转义字符
\n 换行
\t 横向制表符
\\ 反斜杠本身
\' 单引号
\" 双引号
字符串取值
1、下标取值法：下标从0开始
2、切片取值法
print(suda[start:end:step])
1、step为正还是为负，默认为1
为正,方向从左往右;为负,方向从右往左
2、start和end的位置
3、step步长的长度字符串常用方法
1、判断系列(True/False)
str.isdigit( )
字符串中是否只包含数字
str.isnumeric( )
字符串中是否只包含数字(包括中文一到九)
str.isalnum( )
字符串中是否只包含字母或数字
str.istitle( )
字符串中是否每个单词首字母大写，其他字母小写
str.isalpha( )
字符串中是否只包含字母(汉字会算作字母)
str.isupper( )
字符串中是否全为大写
str.islower( )
字符串中是否全为小写
str.isidentifier( )
字符串是否为合法标识符
str.isprintable( )
字符串是否为可打印字符
str.isspace( )
字符串中是否只包含空格(Tab也算空格)
str.startswith( ) 字符串是否以某个字符串开始
print(suda.startswith('a'))
str.endswith( ) 字符串是否以某个字符串结束
print(suda.endswith('a'))2、查找统计类
len(str)
统计字符串长度
str.count( )
统计某个字符在字符串里出现的次数
str.index( )
统计某个字符在字符串中第一次出现的下标位置，没有会报错
str.find( )
查找某个字符，找到返回其起始位置，找不到返回-13、字符串转换类
str.upper( )
将字符串转换为大写
str.lower( )
将字符串转换为小写
str.title( )
将字符串中的单词首字母大写，其他字母小写
str.split('sep')
指定'sep'作为分隔符将字符串切割成列表，分割符可以是任意字符(默认是空格)
'str'.join( )
将列表用str拼接成一个大字符串
# 举例
suda =['hunan','changsha','nongda','student','huyuxuan']
print('-'.join(suda))
输出:hunan-changsha-nongda-student-huyuxuan
str.strip( )
去除字符串里首尾的字符串，不带参数默认去除空格
# 举例
suda = '#####hunannongda-yuanlongpingyuanshi#####'
print(suda.strip('#'))
输出:hunannongda-yuanlongpingyuanshi
str.zfill(number)
返回指定长度的字符串，原字符串右对齐，前面填充0
str.replace('old','new',[count])
用新字符替换老字符，还可以指定替换的个数，默认全部替换
str.capitalize( )
句子首字母大写
str.expandtabs(number)
将\t转换为number个空格
str.center(width,[fillchar])
返回一个原字符串居中对齐，width为总长度，两边用字符fillchar填充
# 举例
suda = 'changsha--huyuxuan'
print(suda.center(30,'~'))
输出:~~~~~~changsha--huyuxuan~~~~~~
str.ljust(width,[fillchar])
返回一个原字符串靠左对齐，width为总长度，两边用字符fillchar填充
str.rjust(width,[fillchar])
返回一个原字符串靠右对齐，width为总长度，两边用字符fillchar填充字符串格式化
基本格式:%[(name)][flags][width].[precision]typecode
([]括起来的都是可加可不加的)
(name):命名(不常用)
flags:+,-,' '或0。+表示正数前面加号;-表示左对齐;' '为一个空格,表示在正数的左侧填充一个空格,从而与负数对齐;0表示使用0填充。
width:表示显示的宽度
precision:表示小数点后的精度几个常用的字符串格式化类型
%s 字符串
%d 十进制整数
%f 浮点数
%x 十六进制整数
%c 单个字符
%% 字符"%"本身
# 举例
print('第一个格式化:%010.2f'%2.345678)
输出:第一个格式化:0000002.35format格式化
{变量:[填充字符][对齐方式<^>][宽度][格式]}
# 举例
name = 'suda'
age = 20
print("姓名:{},年龄:{}".format(name,age))
输出:姓名:suda,年龄:20
print('第一个format:{1:*^14}'.format('aa','suda'))
输出:第一个format:*****suda*****
# 千分位格式化
print('{0:,}'.format(12345678))
输出:12,345,678标识符格式化(f)
# 举例
name = 'suda'
age = 20
print(f'姓名:{name},年龄:{age}')
结果:姓名:suda,年龄:20列表
特点
- 有序项目集合
- 可以存放任何数据类型
- 可变数据类型
基本操作
切片
与字符串切片类似
# slice函数
my_list = ['a','b','c','d']
suda = slice(0,3,1)
print(my_list[suda])
结果:['a', 'b', 'c'] (左闭右开)增加
(1)append
在末尾,作为整体追加,类型不限,每次只能增加一个函数
my_list = ['a','b','c']
my_list.append('d')
print(my_list)
(2)insert
在index位置插入元素
my_list = ['a','c','d']
my_list.insert(1,'b')
print(my_list)
(3)extend
扩展列表
my_list = ['a']
my_list.extend('bcd')
print(my_list)
结果:['a', 'b', 'c', 'd']删除
(1)pop
默认删除最后一个,可以指定下标删除
会返回被删除的值
# 举例
my_list = ['a','b','c','d']
my_list.pop()
print(my_list)
结果:['a', 'b', 'c']
(2)remove
指定元素删除第一个,没有这个元素就报错
# 举例
my_list = ['a','b','c','a']
my_list.remove('a')
print(my_list)
结果:['b', 'c', 'a']
(3)del
根据下标删除或切片删除
# 举例
my_list = ['a','b','c','d','e']
del my_list[0:3]
print(my_list)
结果:['d','e']
(4)clear
清空列表
# 举例
my_list = ['a','b','c','d']
my_list.clear()
print(my_list)
结果: [ ]修改
修改元素主要是利用下标和切片来修改或增加、删除。
# 举例
my_list = ['a','b','c','d']
my_list[0] = 'suda'
print(my_list)
my_list[0:1] = "hyx"
print(my_list)
结果:['suda', 'b', 'c', 'd']
['h', 'y', 'x', 'b', 'c', 'd']反转
reverse
# 举例
my_list = ['a','b','c','d']
my_list.reverse()
print(my_list)
结果:['d','c','b','a']
my_list = ['a','b','c','d']
print(my_list[::-1])
结果:['d','c','b','a']排序
sort
# 举例
my_list = ['a','A','B','b']
my_list.sort()
print(my_list)
结果:['A', 'B', 'a', 'b'] --按照ASCLL码表的顺序排序统计
len # 统计列表总长度/返回列表中元素的个数
my_list = ['a','b','c','d']
print(len(my_list))
结果:4
count # 统计出现次数
my_list = ['a','b','c','a']
print(my_list.count('a'))
结果:2
index # 返回指定下标位置
my_list = ['a','b','c','d']
print(my_list.index('c'))
结果:2元组
特点
- 有序项目集合
- 可以存放任何类型对象
- 不可变数据类型
列表和元组最大的区别
列表是可变数据类型，元组是不可变数据类型，但元组中嵌套列表时，列表是可以修改的
当元组中只有一个元素的时候，需要在元素后面加逗号，用来区分这个括号是结合运算符还是元组
当元组中只有一个元素的时候,需要在元素后面加逗号,用来区分这个括号是结合运算符还是元组
基本操作
切片
和列表切片基本相同
统计
len,count,index (与列表统计类似)
遍历元组
my_tuple = ('aa','bb','cc','dd')
for i in enumerate(my_tuple):
print(i)
结果:
(0, 'aa')
(1, 'bb')
(2, 'cc')
(3, 'dd')
enumerate：枚举函数
给列表元素加上编号,编号默认从0开始字典
特点
- 键值映射的数据结构
- 字典是无序的,没有下标,不能切片
- 可变数据类型
格式
{key1:value,key2:value}
key必须是唯一的,且天生去重
字典的key必须是可hash对象
字典的value可以为任何值基本操作
取值
dicts[key] # 当key不存在时,会引发KeyError错误
# 举例
my_dict = {'a':1,'b':2,'c':3}
print(my_dict['a'])
dicts.get(key, default) # 当key不存在时,返回default值
# 举例
my_dict = {'a':1,'b':2,'c':3}
print(my_dict.get('a',0))
print(my_dict.get('d',0))
结果:
1
0增加/修改
当key不存在时,表示增加一个键值对
当key存在时,表示修改对应的value值
举例
my_dict = {'a':1,'b':2}
my_dict['c'] = 3
print(my_dict)
my_dict['c'] = 5
print(my_dict)
结果:
{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 5}删除
(1) dicts.pop(key)
my_dict = {'a':1,'b':2,'c':3}
print(my_dict.pop('c'))
print(my_dict)
结果:
3 (删掉的数据以其value值的形式返回)
{'a': 1, 'b': 2}
(2) dicts.popitem( ) ==>默认删除最后一个
my_dict = {'a':1,'b':2,'c':3}
print(my_dict.popitem())
print(my_dict)
结果:
('c', 3) (删掉的数据以元组的形式返回)
{'a': 1, 'b': 2}合并字典
(1)update
dict1.update(dict2) # 将dict2合并到dict1
# 举例
my_dict = {'a':1,'b':2}
my_dicts = {'c':3,'d':4}
my_dict.update(my_dicts)
print(my_dict)
结果:
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
(2)
dict(dict1,**dict2) # 将dict1和dict2合并生成一个新字典,原来的字典没有变化
# 举例
my_dict = {'a':1,'b':2}
my_dicts = {'c':3,'d':4}
my_newdict = dict(my_dict,**my_dicts)
print(my_newdict)
结果:
{'a': 1, 'b': 2, 'c': 3, 'd': 4}成员关系
in 和 not in
# 举例
my_dict = {'a':1,'b':2,'c':3}
print('a' in my_dict) (成员关系直接判断的是key)
print('b' not in my_dict)
print(1 in my_dict.values())
print(2 not in my_dict.values())
结果:
True
False
True
False遍历字典
# 举例
my_dict = {'a':1,'b':2,'c':3}
for i in my_dict: (遍历字典直接遍历的是key)
print(i)
for j in my_dict.values():
print(j)
for item in my_dict.items():
print(item)
结果:
a
b
c
1
2
3
('a', 1)
('b', 2)
('c', 3)集合
特点
- 集合是一个无序的、不重复的数据组合
- 集合是一个只含有key的字典
- 集合天生去重(集合最大的优势)
- 集合是可变数据类型
- 集合元素必须是可hash对象,跟字典一样
- 集合和字典的唯一区别仅在于没有存储对应的value
基本操作
添加
(1)add
# 举例
my_set = {1,2,3}
my_set.add(4)
print(my_set)
结果:
{1,2,3,4}
(2)update
# 举例
my_set = {1,2,3}
my_set.update('xyz')
print(my_set)
结果:
{'y', 1, 2, 'x', 3, 'z'}移除
(1)remove
移除目标不存在会出错KeyError
# 举例
my_set = {1,2,3}
my_set.remove(3)
print(my_set)
结果:
{1,2}
(2)discard
移除目标不存在则什么也不做
# 举例
my_set = {1,2,3}
my_set.discard(3)
print(my_set)
my_set.discard(4)
print(my_set)
结果:
{1,2}
{1,2}集合运算
(1)并集 # 返回一个新的set包含s1和s2中的每一个元素
举例
s1 = {1,2,3}
s2 = {2,3,4}
print(s1 | s2)
结果:
{1,2,3,4}
(2)交集 # 返回一个新的set包含s1和s2中的公共元素
举例
s1 = {1,2,3}
s2 = {2,3,4}
print(s1 & s2)
结果:
{2,3}
(3)差集 # 返回一个新的set包含s1中有但是s2中没有的元素
举例
s1 = {1,2,3}
s2 = {2,3,4}
print(s1 - s2)
结果:
{1}
(4)对称差集 # 返回一个新的set包含s1和s2中不重复的元素(在s1或s2中,但不会同时出现在二者中)
举例
s1 = {1,2,3}
s2 = {2,3,4}
print(s1 ^ s2)
结果:
{1,4}可变数据类型和不可变数据类型
区别
看修改之后,id是否发生变化
修改之后id没有发生变化,即为可变数据类型；修改之后id发生了变化,即为不可变数据类型
- string字符串是一个不可变数据类型
- list列表是一个可变数据类型
- tuple元组是一个不可变数据类型
- dict字典是一个可变数据类型
- set集合是一个可变数据类型
总结
字符串和元组是不可变数据类型，列表、字典和集合是可变数据类型
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
