\n 换行符号
\r 回车
\b 后退一个格
\t 制表符（4个字符为一组，当不字符被占有时，重新生成一个制表符。如果被占据，不满4个字符时，生成剩余部分空格。）
#原字符 不希望字符串中转义字符起作用，字符串前加r或R
print(r'hello \r \t world')
import keyword#查询关键字
print(keyword.kwlist)
print(0b101)#0b是二进制
print(0o21)#0o是八进制
print(0x21)#0x是十六进制
n1 = 1.1
n2 = 2.2
print(n1+n2)#3.3000000000000003 二进制存储，存储浮点数有误差
from decimal import Decimal
print(Decimal('1.1')+Decimal('1.2'))#2.3
print(1%3)#取余
print(11//2)#整除
print(2**3)#次方
for 和while 使用else，但运行中没有遇到break时，循环正常循环次数后，就会执行else语句。
for item in range(3):
pwd = input('输入密码')
if pwd == '9999':
print('密码正确')
break
else:
print('密码错误')
else:
print('三次密码错误')
a = 0
while a < 3:
pwd = input('输入密码')
if pwd == '999':
print('密码正确')
break
else:
print('密码不正确')
a+=1
else:
print('密码三次输出错误')
二重循环中break和continue用于控制本层循环。
列表
lst = [ 23,‘SD’,‘EW4’] list内置函数创建列表 lst2 = list([112,313,‘dsd’])
列表元素按顺序有序排列
索引映射唯一数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存
lst = ['hello','world',98,'hello']
print(lst.index('hello'))#如果列表中有相同元素，只返回相同元素的第一个元素索引
print(lst.index('hello',1,4))#从1到3寻找元素
列表名[start:stop:step]左闭右开区间 产生一个新的列表
list[-1: -3:-1]
元素 not in / in 列表名
for i in lst:
print(i)
append()不产生新列表，在原列表中添加新元素 将列表作为一个元素
extend()将列表中元素作为扩充对象
insert()在列表任意位置添加一个元素
lst = ['hell',3,'dfe']
lst2 = ['hello','world']
lst.append(lst2)
print(lst)
lst.extend(lst2)
print(lst)
['hell', 3, 'dfe', ['hello', 'world'], 'hello', 'world']
#切片添加元素
lst = ['hell',3,'dfe']
lst3 =[True,False,'hello']
lst[1:1]=lst3
print(lst) ['hell', True, False, 'hello', 3, 'dfe']
lst = [10,20,30,40,50,60,30]
lst.remove(30)#从列表中移除一个元素，如果有重复元素只移除第一个元素
print(lst) [10, 20, 40, 50, 60, 30]
lst.pop(1)#根据索引移除元素 [10, 30, 40, 50, 60，30]
lst.pop()#如果没有索引，则移除最后一个元素[10, 30, 40, 50, 60]
print(lst)
lst[1:3] = []
print(lst) [10, 40, 50, 60, 30]
lst.clear()#清除列表元素
print(lst)
del lst #删除列表
print(lst)
lst = [10,20,30,40]
lst[2] = 100
print(lst) [10, 20, 100, 40]
lst[1:3]=[200,300,400]
print(lst) [10, 200, 300, 400, 40]
lst.sort()#调用列表对象的sort方法，在原列表上升序排列
print(lst) [10, 20, 30, 40]
lst.sort(reverse=True)降序排列
print(lst) [40, 30, 20, 10]
lst = [20,40,10,98,54]
#new_list = sorted(lst,reverse=True)降序排列
new_list = sorted(lst)#产生新的列表进行排序
print(lst) [20, 40, 10, 98, 54]
print(new_list) [10, 20, 40, 54, 98]
列表生成式：
lst3 = [i for i in range(1,10)]
print(lst3)
字典
字典是一个无序序列，以键值对的方式存储 根据hash函数存储位置 存储不可变的序列
键可以不可重复，值可重复，如果出现重复，就会值覆盖 键是不可变对象
空间动态伸缩 会浪费大量空间，用空间换时间的方法。
scores = {'张三':100,'李四':98,'王五':45}
a = dict(name = 'jack',age = 20)
print(scores['张三'])#如果找不到，则为KeyError
print(a['name'])
print(scores.get('张三')) #如何找不到，则为None
print(scores.get('麻七',99))#如果寻找value不存在，则提供一个默认值
print('张三' in scores)
print('张三'not in scores)
del scores['张三']
print(scores) {'李四': 98, '王五': 45}
scores.clear()# 清空
print(scores) {}
scores['陈六'] = 98
print(scores) {'张三': 100, '李四': 98, '王五': 45, '陈六': 98}
scores['陈六'] = 100 #修改
print(scores) {'张三': 100, '李四': 98, '王五': 45, '陈六': 100}
keys = scores.keys()
print(keys)#获得所有键值
values = scores.values()
print(values)#获得所有值
items = scores.items()#获得所有键值对
print(items)
for item in scores:
print(item) 输出所有键
张三
李四
王五
for item in scores:
print(scores[item],scores.get(item))#获取值的两种方法
100 100
98 98
45 45
items = ['fruit','books','others']
prices = [96,78,85]
d = {item.upper():price for item, price in zip(items,prices)}
print(d) {'FRUIT': 96, 'BOOKS': 78, 'OTHERS': 85}
元组
不可变序列 (不可变序列（元组和字符串）没有增删改操作。
可变序列（集合，列表和字典）具有增删改操作，对象地址不发生改变
可变序列
lst = [10,20,30]
print(id(lst))2118426108736
lst.append(100)
print(id(lst))2118426108736
不可变序列
s = 'fdjsf'
print(id(s)) 1547348002992
s = s+'de'
print(id(s)) 1547351023280
元组
t0 = ('python','world',98)
t1 = 'python','world',98 #省略括号
t3 = tuple(('python','world',98))
#如果只包含一个元组的元素需要使用逗号和小括号
t = (10,)
#空列表
lst=[]
lst1 = list()
#空字典
d ={}
d2 = dict()
#空元组
t4 = ()
t5 = tuple()
为什么将元组设计为不可变序列
在多任务环境下，同时操作对象时不需要加锁
元组中存储的是对象的引用
如果元组中对象本身不可变对象，则不能再引用其他对象
如果元组中对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
t = (10,[20,30],9)
print(t)
t[1].append(100)
print(t)
t = ('Python','world',98)
for item in t:
print(item)
Python
world
98
集合
没有value的字典 hash函数计算来存储 存储内容不重复
s = {5,1,2,12,12,51,6,2}
print(s) {1, 2, 51, 5, 6, 12}
s1 = set(range(6))
print(s1){0, 1, 2, 3, 4, 5}
将列表中元素转为集合类型
vs1 = set([1,2,2,4,5])
print(s1) {1, 2, 4, 5}
将元组元素转为集合类型
s1 = set((1,2,2,4,5))
print(s1) {1, 2, 4, 5}
将字符串元素转为集合类型
s1 = set('python')
print(s1) {'y', 'o', 'p', 't', 'n', 'h'}
将集合转为集合类型
s1 = set({1,2,5,5,6,4})
print(s1) {1, 2, 4, 5, 6}
set()定义新集合，{}定义为字典
s1 = {1,5,2,10,15}
print(10 in s1)
print(100 in s1)
True
False
s1 = {1,5,2,10,15}
s1.add(100) #add一次只添加一个元素
print(s1)
s1.update({200,300,400}) #update一次添加至少一个元素
s1.update([20,30,40])
s1.update((12,33,44))
print(s1) {1, 2, 33, 100, 5, 200, 40, 10, 300, 12, 44, 15, 400, 20, 30}
s1 = {1,5,2,10,15}
s1.remove(10) #一次删除一个指定元素，如果指定的元素不存在 则抛出KeyError
print(s1) {1, 2, 5, 15}
s1.discard(5)#一次删除一个指定元素，如果指定元素不存在，不抛出异常
print(s1) {1, 2, 15}
s1.pop()#一次删除一个任意元素
print(s1) {2, 15}
s1.clear() #清除所有元素
print(s1) set()
s1 = {1,5,2,10,15}
s2 = {1,5,10,15}
print(s1==s2)
print(s1!=s2)
False
True
s1 = {1,5,2,10,15}
s2 = {1,5,10,15}
print(s2.issubset(s1))True
print(s1.issuperset(s2))True
print(s1.isdisjoint(s2))False 有交集为false 没有交集为true
s1 = {1,5,2,10,15}
s2 = {1,5,10,15}
#(1)交集
print(s1.intersection(s2))
print(s1 & s2)
#(2)并集
print(s1.union(s2))
print(s1 | s2)
#(3)差集
print(s1.difference(s2))
print(s1 - s2)
#(4)对称差
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
s = {i for i in range(10)} 集合生成式
print(s)
字符串
不可变字符序列，
字符串具有驻留机制，对相同字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是将该字符串的地址赋予新创建的变量。
s = 'hello,hello'
print(s.index('lo'))#查找第一次出现的字符，不存在，则返回ValueError
print(s.find('lo'))#查找第一次出现的字符，不存在，则返回-1
print(s.rindex('lo'))#查找最后一次出现的字符，不存在，则返回ValueError
print(s.rfind('lo'))#查找最后一次出现的字符，不存在，则返回-1
大小写转化操作
s = 'hello,hello'
a = s.upper() #s字符串大小写不变 转化为大写
print(a) HELLO,HELLO 产生一个新的字符串
s = 'hello,hello'
a = s.lower()转换为小写 产生一个新的字符串
print(a) hello,hello
s = 'hello,Python'
a = s.swapcase() 大小写互换
print(a)HELLO,pYTHON
s = 'hello,Python'
a = s.capitalize()把第一个字符转化为大写，其余转化为小写
print(a)Hello,python
s = 'hello,python'
a = s.title() 把每个单词的第一个字符转化为大写，把其他字符转化为小写
print(a) Hello,Python
字符串内容对齐操作
s = 'hello,python'
print(s.center(20,"*"))#居中对齐
print(s.ljust(20,"*"))#左对齐
print(s.rjust(20,'*'))#右对齐
print(s.zfill(20))#用0进行填充的右对齐
****hello,python****
hello,python********
********hello,python
00000000hello,python
字符串的劈分
s = 'hello python'
lst = s.split()
print(lst)
s = 'hello|world|python'
lst1 = s.split(sep="|")#从左边开始劈分，默认为空格为劈分，sep指定劈分符号 maxsplit为最大劈分次数
print(lst1)
print(s.split(sep='|',maxsplit=1))
print(s.rsplit(sep="|",maxsplit=1))#从右侧开始劈分，默认为空格为劈分，sep指定劈分符号 maxsplit为最大劈分次数
字符串判断方法
字符串的替换和合并
s = 'hello,python'
print(s.replace('python','java'))被替换字符 替换字符 最大替换次数
hello,java
s = 'hello,python python python'
print(s.replace('python','java',2)) hello,java java python
s = ['hello','java','Python']
print('|'.join(s)) join将列表元组中字符串合成为一个字符串
print(''.join(s))
t = ('hello','java','Python')
print(''.join(t))
print('*'.join('Python'))
hello|java|Python
hellojavaPython
hellojavaPython
P*y*t*h*o*n
字符串比较
print('apple'>'app')
print('apple'>'banana')原始值比较 97>98 False
True
False
== 比较的是value相等
is 比较的是id是否相等
字符串切片
切片产生新的对象
s = 'hello,Python' 切片[start:end:step]
s1 = s[:5]
s2 = s[6:]
s3 = '!'
print(s1)
print(s2)
print(s1+s3+s2)
hello
Python
hello!Python
print(s[::-1]) nohtyP,olleh
格式化字符串
%为占位符
#(1)%
name = 'aaa'
age = 20
print('我叫%s，今年%d' % (name,age))
{}为占位符
name = 'aaa'
age = 20
print('我叫{0}，今年{1}'.format (name,age))
print('{0:.3}'.format(3.14159))# .3表示一共3位数
print('{0:10.3f}'.format(3.14159)) 10宽度 .3f表示3位小数
f-string为占位符
name = 'aaa'
age = 20
print(f'我叫{name}，今年{age}')
print('我叫%10s，今年%.3f' % (name,age)) #10表示宽度 .3浮点数后三位
print('%10.3f'%3.1415926)
我叫 aaa，今年20.000
3.142
]
s2 = s[6:]
s3 = ‘!’
print(s1)
print(s2)
print(s1+s3+s2)
hello
Python
hello!Python
print(s[::-1]) nohtyP,olleh
## 格式化字符串
%为占位符
#(1)%
name = ‘aaa’
age = 20
print(‘我叫%s，今年%d’ % (name,age))
{}为占位符
name = ‘aaa’
age = 20
print(‘我叫{0}，今年{1}’.format (name,age))
print(‘{0:.3}’.format(3.14159))# .3表示一共3位数
print(‘{0:10.3f}’.format(3.14159)) 10宽度 .3f表示3位小数
f-string为占位符
name = ‘aaa’
age = 20
print(f’我叫{name}，今年{age}')
print(‘我叫%10s，今年%.3f’ % (name,age)) #10表示宽度 .3浮点数后三位
print(‘%10.3f’%3.1415926)
我叫 aaa，今年20.000
3.142
![[附源码]Python计算机毕业设计SSM加油站管理信息系统（程序+LW)](https://img-blog.csdnimg.cn/319a77e43e6f47038eade0799a8d8e6b.png)
