python学习知识总结
基础篇
- 制表位—— \t
- 占满四个空格后 会重新开一个制表位
- 不占满就填充完整
- 变量
- 标识:表示对象存储的内存地址
- 类型:表示对象的存储类型
- 值:对象的具体的数据
name = '陈姝怡'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
- 整数的进制
- 十进制——默认
- 二进制——以0b开头
- 八进制——以0o开头
- 十六进制——以0x开头
- 字符串
- 单引号和双引号只能在一行使用
- 三引号可以不在同一行
- 字符类型转换
- 将str转为int型,str必须为数字串(整数),若str为小数串例如’23.22’,则转换失败。
- float型转成int型,截取整数部分,舍掉小数部分
- bool类型转换为int型,True转换为1,False转换为0
- str转float型,如果是非数字串,则不能转换
- int型转换为float,会将1转换为1.0
- 注释
- 单行注释用#
- 多行注释用三个引号
#coding:utf-8
# 作者:吴海帆
# 开发时间:2022/5/24 16:39
- 输入函数input
#从键盘录入2个整数 计算整数和
a=int(input('请输入一个加数'))
b=int(input('请输入另外一个加数'))
print(a+b)
- 运算符
- //是整除符号 例:11//2 =5
- %是取余(取模)运算
- 2**2表示22
print(9//4)
print(-9//-4)
print(-9//4)#-3 一正一负向下取整数
print(9%-4) #公式 余数=被除数-除数*商 9-(-4)*(-3) 9-12=-3
- 赋值运算符
- 支持链式赋值
b=g=k=20
print(b,id(b))
print(g,id(g))
print(k,id(k))
b g k变量指向同一个id,存储位置一样
- 支持参数赋值
i=30
i+=10
i-=10
i*=2
i/=3 #i从int型变为floa型
i//=3
print(i)
- 测试布尔值
#测试对象的布尔值
print('以下对象布尔值均为False')
print(bool(False)) #False
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([]))#空列表
print(bool(list()))#空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空字典
print(bool(set())) #空集合
- for-in循环结构
- 语法结构:for 自定义的变量 in 可迭代对象:循环体
- 当循环中不需要使用
- break语句:直接退出循环
- continue语句:结束当前循环,进入下一次循环
- else:
- if…else 若if不成立则执行else
- while…else 若没有遇到break,则执行else
- for…else 若没有遇到break,则执行else
- 循环练习——打印九九乘表
for i in range(1,10):
for j in range(1,i+1):
print(i,'*',j,'=',i*j,end='\t')
print()
- 二重循环中,break和continue只负责控制本层循环
- 列表:
- 变量可以存储一个元素,而列表是一个"大容器"可以存储N多个元素,程序可以方便地对这些数据进行整体操作
- 列表相当于其它语言中的数组
- 列表的查询操作
- 获取列表的索引——index
- 如果列表中存在N个相同元素,只返回相同元素中第一个元素的索引
- 如果查找的元素在列表不存在,返回ValueError错误
- 获取列表的单个元素——lst[2]
- 正向索引从0-N-1
- 逆向索引从-N到-1
- 获取列表的多个元素——切片
- 列表名[start: stop : step ]
- 切片范围[start,stop)
- 默认步长为1
- 步长为负数,表示逆向
- 判断指定元素是否在列表中
print('p' in 'python')
print('p' not in 'python')
lst=[10,20,'python','hello']
print(10 in lst)
print(100 in lst)
print(10 not in lst)
- 列表的元素的遍历
lst=[10,20,'python','hello']
for item in lst:
print(item)
- 列表元素的增删改操作
- 列表的新增的操作
- append()在列表末尾添加一个元素
- exend()在列表末尾至少添加一个元素
- insert()在列表任意位置添加一个元素
- 切片在列表任意位置添加至少一个元素
- 列表的删除操作
- remove()
- 一次只删除一个元素
- 重复的元素只删除第一个
- 元素不存在,抛出异常ValueError
- pop()
- 删除一个指定位置上的元素
- 指定索引不存在抛出IndexError
- 不指定索引,删除最后一个元素
- 切片
- 一次至少删除一个元素
- 原列表不变,产生一个新的列表对象
- 若想要在原列表上进行删除,可以使用如下方式
'''不产生新的列表,而是删除原来列表的内容'''
lst=[10,20,30,40,50,60,70,30]
lst[1:3]=[]
print(lst)
- clear()
- 清空列表中的所有元素
'''清除列表中的所有元素'''
lst.clear()
print(lst)
- del()
- 删除整个列表对象
'''清除列表对象'''
del lst
print(lst)
- 列表的修改
lst=[10,20,30,40,50]
lst[0]=1
print(lst)
lst[1:3]=[100,200,300,400]
print(lst)
- 列表的排序
- sort()方法
- sort()默认列表元素从小到大排序,可以通过指定reverse=Ture,进行降序排序
- 调用内置函数sorted(),可以指定reverse=True,进行降序排序,原列表不发生改变
lst=[20,30,50,10,90,40]
print('排序前的列表',lst,id(lst))
#开始排序,调用列表对象的sort方法,默认升序
lst.sort()
print('排序后的列表',lst,id(lst))
#通过指定关键字参数,将列表中的元素进行降序排序
lst.sort(reverse=True) #reverse=True 表示降序排序,reverse=False 表示升序排序
print(lst)
lst.sort(reverse=False)#相当于lst.sort()
print(lst)
- 内置函数sorted()
- 使用内置函数sorted()将创建一个新的对象
#指定关键字参数,实现列表的降序排序
desc_lst=sorted(lst,reverse=True)
print(desc_lst)
- 列表生产式
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7OFJniz-1654590250126)(C:\Users\吴海帆\AppData\Roaming\Typora\typora-user-images\image-20220527214125978.png)]
- 字典
- python的内置数据结构,与列表一样,属于可变序列
- 以键值对的方式存储数据,字典是个无序序列
- 列表——单身、有序
字典——夫妻档、无序 - 字典的创建
- 常用方式:使用花括号
scores={‘张三’:100,‘李四’:98} - dict{name=‘jack’, age =20}
- 字典的获取
'''获取字典的元素'''
scores={'张三':100,'王五':98,'李四':86}
'''第一种方式'''
print(scores['张三'])
#print(scores['陈六 '])
'''第二种方式,get()方法,指定元素不存在时,不会抛出异常'''
print(scores.get('张三'))
print(scores.get('陈六'))
print(scores.get('玛丽',99))#若不存在’玛丽‘,则返回99
- 字典key的判断
'''key的判断'''
scores={'张三':100,'王五':98,'李四':86}
print('张三' in scores)
print('张三' not in scores)
- 字典的删除、新增、修改
del scores['张三']#删除指定的键值对
#scores.clear() #清空字典的所有元素
print(scores)
scores['陈六']=98
print(scores)
scores['陈六']=100
print(scores)
- 获取字典视图的三个方法
scores={'张三':100,'王五':98,'李四':86}
#获取所有的键key
keys=scores.keys()
print(keys)
print(type(keys))
print(list(keys)) #将所有键组成的视图转成列表
#获取所有的值value
values=scores.values()
print(values)
print(type(values))
print(list(values))
#获取所有的键值对key-value
items=scores.items()
print(items)
- 字典的遍历
scores={'张三':100,'王五':98,'李四':86}
for item in scores:
# print(item,scores.get(item))
print(item,scores[item])#2种方式
- 字典的特点
- 键不允许重复,值可以重复
d={'name':'张三','name':'李四'}#key不准重复
print(d)
d={'name':'张三','nikename':'张三'}#value 可以重复
print(d)
- 字典的元素是无序的
- 字典的key必须是不可变对象
- 字典可以根据需要动态伸缩
- 字典会浪费较大的内存,是一种使用空间换时间的数据结构
- 字典生成式
items=['Fruits','Books','Others']
prices=[96,78,85,200]
lst=zip(items,prices)
d={item.upper():price for item ,price in lst}
print(d)
- 元组
- 可变序列:列表、字典
- 可变序列:可以对序列进行增删改查,对象的地址不发生改变
- 不可变序列:字符串、元组
- 不可变序列:不能进行增删改查操作
- 元组的创建:
#元组的创建
'''第一种,使用()'''
t=('python','world',98)
print(t)
print(type(t))
t2='python','world',98 #省略了小括号
print(t2)
print(type(t2))
t3=('python',) #若元组中支包含一个元素,逗号不能省略
print(t3)
print(type(t3))
'''第二种创建方式,使用内置函数tuple()'''
t1=tuple(('Python','world',98))
print(t1)
print(type(t1))
'''空元组的创建方式'''
'''空列表的创建方式'''
lst=[]
lst1=list()
#空字典
d={}
d2=dict()
#空元组
t4=()
t5=tuple()
print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)
- 元组的遍历
'''元组的遍历'''
t=('python','world',98)
'''第一种获取元组元素的方式,使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3])
'''遍历元组'''
for item in t:
print(item)
- 集合
- 集合的创建
#集合的创建方式
'''第一种创建方式使用{}'''
s={1,2,3,4,4,4,5,6,7,6}#集合中的元素不允许重复
print(s)
'''第二种创建方式'''
s1=set(range(6))
print(s1)
print(type(s1))
s2=set([1,2,3,4,4,5,4,4,3,1])
print(s2)
s3=set((1,2,3,4,65))#集合中的元素是无序的
print(s3)
s4=set('python')
print(s4)
s5=set({12,34,5,6,6,3})
print(s5)
- 集合的相关操作
#集合相关操作
s={10,20,304,40,4,43}
print(10 in s)
print(20 in s)
print(43 not in s)
print(4 in s)
s.add(3) #add一次添加一个元素
print(s)
s.update([20,30,4]) #一次至少添加一个元素
print(s)
s.update({2,3,4})
print(s)
s.update((2,3))
print(s)
#s.remove(3333) #一次删除指定一个元素,如果指定元素不存在则抛出异常
print(s)
s.discard(299)#299,不存在,删除失败,但是不抛出异常
print(s)
s.pop() #一次只删除一个任意随机元素,pop()不能抛出异常
print(s)
s.clear() #清空集合中的元素
print(s)
- 集合间的关系
'''两个集合是否相等'''
s1={10,20,30,40,50}
s2={20,10,30,40,50}
print(s1==s2)
print(s1!=s2)
'''一个集合是否是另外一个集合的子集'''
s1={10,20,30,40,50,60,70}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1)) #TRUE
print(s3.issubset(s2)) #FALSE
'''一个集合是否是另外一个集合的超集'''
print(s1.issuperset(s2)) #TRUE
print(s2.issuperset(s3)) #FALSE
'''两个集合是否没有交集?'''
print(s2.isdisjoint(s3)) #有交集,所以返回false
s4={100,200,300}
print(s2.isdisjoint(s4)) #没有交集,所以返回True
- 集合的数学操作
#集合的数学操作
#1.交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2) #intersection()与 & 等价,交集操作
#2.并集
print(s1.union(s2))
print(s1 | s2) #union()与 | 等价,并集操作
#3.差集
print(s1.difference(s2))
print(s1 - s2) #difference()与 - 等价,差集操作
#4.对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2) # symmetric_difference()与 ^ 等价
- 集合生成式
#列表生成式
lst=[i*i for i in range(10)]
print(lst)
#集合生成式
s={i*i for i in range(10)}
print(s)
- 字符串
- 字符串的常用操作
- 字符串的查询操作
#字符串的查询操作
s='hello,hello'
print(s.index('lo'))#3
print(s.find('lo'))#3
print(s.rindex('lo')) #9
print(s.rfind('lo'))#9
#print(s.index('k')) #index 查找不存在时抛出异常
print(s.find('k')) #find查找不存在的元素时,不抛出异常,返回-1
#print(s.rindex('k')) #抛出异常
print(s.rfind('k')) #不抛出异常,返回-1
index()查找子串str第一次出现的位置,不存在返回异常
find()查找子串str第一次出现的位置,不存在返回-1
rindex()查找子串str最后一次出现的位置,不存在返回异常
rfind()查找子串str最后一次出现的位置,不存在返回-1
- 字符串的大小写转换操作
#字符串的大小写转换操作
s='hello,python'
a=s.upper() #小写全部转换成大写
print(a,id(a)) #转换成大写后,会产生一个新的字符串对象
print(s,id(s))
b=s.lower()#大写转换成小写
print(b,id(b))#转换后,会产生一个新的字符串
print(b==s)#True b和s中的内容是相等的
print(b is s)#False b和s的地址时不相同的
s2='hello,Python'
print(s2.swapcase())#swapcase()大写变成小写,小写变成大写
print(s2.title())#把每个单词的第一个字母变成大写,把每个单词的剩余部分转换成小写
- 字符串内容对齐操作
s='hello,Python'
'''居中对齐'''
print(s.center(20,'*'))
'''左对齐'''
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))
'''右对齐'''
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))
'''右对齐,使用0进行填充'''
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))
- 字符串劈分操作
- split()
- 从字符串左边开始劈分,默认的劈分字符是空格字符串,返回的值是一个列表
- 通过参数sep指定劈分字符串的劈分符
- 通过maxseplit指定劈分字符串的最大劈分次数,经历过最大劈分次数后,剩余的子串会单独做为一部分
- rsplit()
- 从字符串右边开始劈分,默认的劈分字符是空格字符串,返回的值是一个列表
- 同上
- 同上
- 字符串判断相关操作
- isidentifier()是否属于合法的标识符
- isspac()判断指定字符串是否全部由空白字符组成
- islapha()判断指定的字符串是否全部由字母组成
- isdecima()判断指定字符串是否全部由十进制数组成
- isnumeric()判断指定字符串是否全部由数字组成
- isalnum()判断指定字符串是否全部由字母和数字组成
s='hello,python'
print('1. ',s.isidentifier())#False 判断是否是合法的标识符,字母、数字、下划线属于合法,逗号不包括
print('2. ','hello'.isidentifier())#Ture
print('3. ','张三'.isidentifier())#Ture
print('4. ','张三_123'.isidentifier())#Ture
print('5. ','\t'.isspace())#True
print('6. ','abc'.isalpha())#True
print('7. ','张三'.isalpha())#True
print('8. ','张三1'.isalpha())#False
print('9. ','123'.isdecimal())#True
print('10. ','123四'.isdecimal())#False
print('11. ','ⅩⅠⅡⅢ'.isdecimal())#False
print('12. ','123'.isnumeric())#Ture
print('13. ','123四'.isnumeric())#Ture
print('14. ','ⅩⅠⅡⅢ'.isnumeric())#Ture
print('15. ','123a'.isalnum())#Ture
print('16. ','张三123'.isalnum())#Ture
print('17. ','123!'.isalnum())#False
- 字符串操作的其他方法
- 字符串的替换replace()
- 第一个参数指定被替换的子串,第二个参数指定替换子串的字符串,该方法返回替换得到的字符串,替换前的字符串不发生任何变化,调用该方法时,可以通过第三个参数指定最大的替换次数。
- 字符串的合并join()
- 将列表或者元组的字符串合并成一个字符串
s='hello,python'
print(s.replace('python','Java'))
s1='hello,python,python,python'
print(s1.replace('python','Java',2))
print(s1)
lst=['hello','java','python']
print('|'.join(lst))
print(''.join(lst))
t=('hello','java','python')
print(''.join(t))
print('*'.join('Python'))
- 字符串的比较操作
'''比较规则:
依次比较2个字符串的首个字符,当第一个字符和第二个字符不相等时,比较家结果就是当前这2个字符的比较结果,若相同的话,则依次比较下去
'''
#字符串的比较
print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))
print(ord('吴'))
print(chr(97),chr(98))
print(chr(21556))
'''== 与 is的区别 :
==比较的是value的值是否相等
is 比较的是id是否相等(内存地址)
'''
a=b='python'
c='python'
print(a==b)#TRUE
print(b==c)#TRUE
print(a is b)
print(a is c)
print(id(a))
print(id(b))
print(id(c))
- 字符串的切片
- 字符串是不可变类型,不具备增、删、改等操作
- 切片操作将产生新的对象
#字符串的切片操作
s='hello,python'
s1=s[:5]
s2=s[6:]
s3='!'
newstr=s1+s2+s3
print(s1)
print(s2)
print(newstr)
print("-----------------")
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))
print(s[1:5:1])
print(s[::2])#默认从0开始,没有写结束,默认到字符串的最后一个元素,步长为2,两个元素之间的索引间隔为2
print(s[::-1])#默认从字符串的最后一个元素开始,到字符串的第一个元素结束,因为步长为负数(逆向输出)
print(s[-6::1])#从索引为-6开始,到最后一个元素结束,步长为1
- 格式化字符串
1. ```python
#格式化字符串
#(1) % 占位符
name='张三'
age=24
print('我叫%s,今年%d岁' % (name,age))
#(2) {}
print('我叫{0},今年{1}岁'.format(name,age))
#(3) f-string
print(f'我叫{name},今年{age}岁')
```
- 字符串的宽度和精度
1. ```python
print('%10d' % 99)# 10表示的是宽度
print('%.3f' % 3.1415926)# .3表示的是小数点后三位
#同时表示宽度和精度
print('%10.3f' % 3.141592653)#总宽度为10,保留到小数点后3位
```
2. ```python
print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.1415926))
print('{0:.3f}'.format(3.1415926))
print('{0:10.3f}'.format(3.1215)) #同时设置宽度与精读,一共10位,3位是小数
```
},今年{age}岁’)
```
6. 字符串的宽度和精度
1. ```python
print('%10d' % 99)# 10表示的是宽度
print('%.3f' % 3.1415926)# .3表示的是小数点后三位
#同时表示宽度和精度
print('%10.3f' % 3.141592653)#总宽度为10,保留到小数点后3位
```
2. ```python
print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.1415926))
print('{0:.3f}'.format(3.1415926))
print('{0:10.3f}'.format(3.1215)) #同时设置宽度与精读,一共10位,3位是小数
```