python学习知识总结

最新推荐文章于 2024-05-08 19:12:11 发布

weixin_44671324

最新推荐文章于 2024-05-08 19:12:11 发布

阅读量509

点赞数

文章标签： python 学习开发语言

本文链接：https://blog.csdn.net/weixin_44671324/article/details/125167945

版权

python学习知识总结

基础篇

制表位—— \t
1. 占满四个空格后会重新开一个制表位
2. 不占满就填充完整
变量
1. 标识：表示对象存储的内存地址
2. 类型：表示对象的存储类型
3. 值：对象的具体的数据
```
name = '陈姝怡'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
```
整数的进制
1. 十进制——默认
2. 二进制——以0b开头
3. 八进制——以0o开头
4. 十六进制——以0x开头
字符串
1. 单引号和双引号只能在一行使用
2. 三引号可以不在同一行
字符类型转换
1. 将str转为int型，str必须为数字串（整数），若str为小数串例如’23.22’，则转换失败。
2. float型转成int型，截取整数部分，舍掉小数部分
3. bool类型转换为int型，True转换为1，False转换为0
4. str转float型，如果是非数字串，则不能转换
5. 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表示2²

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循环结构
1. 语法结构：for 自定义的变量 in 可迭代对象：循环体
2. 当循环中不需要使用
break语句：直接退出循环
continue语句：结束当前循环，进入下一次循环
else：
1. if…else 若if不成立则执行else
2. while…else 若没有遇到break，则执行else
3. 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
1. 如果列表中存在N个相同元素，只返回相同元素中第一个元素的索引
2. 如果查找的元素在列表不存在，返回ValueError错误
获取列表的单个元素——lst[2]
1. 正向索引从0-N-1
2. 逆向索引从-N到-1
获取列表的多个元素——切片
1. 列表名[start: stop : step ]
2. 切片范围[start，stop）
3. 默认步长为1
4. 步长为负数，表示逆向

判断指定元素是否在列表中

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)

列表元素的增删改操作
1. 列表的新增的操作
  1. append()在列表末尾添加一个元素
  2. exend()在列表末尾至少添加一个元素
  3. insert()在列表任意位置添加一个元素
  4. 切片在列表任意位置添加至少一个元素
2. 列表的删除操作
  1. remove()
    1. 一次只删除一个元素
    2. 重复的元素只删除第一个
    3. 元素不存在，抛出异常ValueError
  2. pop()
    1. 删除一个指定位置上的元素
    2. 指定索引不存在抛出IndexError
    3. 不指定索引，删除最后一个元素
  3. 切片
    1. 一次至少删除一个元素
    2. 原列表不变，产生一个新的列表对象
    3. 若想要在原列表上进行删除，可以使用如下方式
      1. '''不产生新的列表，而是删除原来列表的内容''' lst=[10,20,30,40,50,60,70,30] lst[1:3]=[] print(lst)
  4. clear()
    1. 清空列表中的所有元素
    2. ```
    '''清除列表中的所有元素'''
    lst.clear()
    print(lst)
```
5. del()
  1. 删除整个列表对象
  2. ```
  '''清除列表对象'''
  del lst
  print(lst)
```
3. 列表的修改
  1. ```
  lst=[10,20,30,40,50]
  lst[0]=1
  print(lst)
  lst[1:3]=[100,200,300,400]
  print(lst)
```
4. 列表的排序
  1. sort()方法
    1. sort()默认列表元素从小到大排序，可以通过指定reverse=Ture,进行降序排序
    2. 调用内置函数sorted(),可以指定reverse=True，进行降序排序，原列表不发生改变
    3. ```
    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)
```
2. 内置函数sorted()
  1. 使用内置函数sorted()将创建一个新的对象
  2. ```
  #指定关键字参数，实现列表的降序排序
  desc_lst=sorted(lst,reverse=True)
  print(desc_lst)
```
5. 列表生产式
  1. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7OFJniz-1654590250126)(C:\Users\吴海帆\AppData\Roaming\Typora\typora-user-images\image-20220527214125978.png)]

字典

python的内置数据结构，与列表一样，属于可变序列
以键值对的方式存储数据，字典是个无序序列
列表——单身、有序

字典——夫妻档、无序
字典的创建
1. 常用方式：使用花括号
  
  scores={‘张三’：100,‘李四’:98}
2. 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)

元组

可变序列：列表、字典
1. 可变序列：可以对序列进行增删改查，对象的地址不发生改变
不可变序列：字符串、元组
1. 不可变序列：不能进行增删改查操作

元组的创建：

#元组的创建
'''第一种，使用（）'''
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))

字符串劈分操作
1. split()
  1. 从字符串左边开始劈分，默认的劈分字符是空格字符串，返回的值是一个列表
  2. 通过参数sep指定劈分字符串的劈分符
  3. 通过maxseplit指定劈分字符串的最大劈分次数，经历过最大劈分次数后，剩余的子串会单独做为一部分
2. rsplit()
  1. 从字符串右边开始劈分，默认的劈分字符是空格字符串，返回的值是一个列表
  2. 同上
  3. 同上

字符串判断相关操作

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()
1. 第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，该方法返回替换得到的字符串，替换前的字符串不发生任何变化，调用该方法时，可以通过第三个参数指定最大的替换次数。

字符串的合并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位是小数
                            ```