python代码学习1

\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

![在这里插入图片描述](https://img-blog.csdnimg.cn/2e7300dadf204e54bdc923fed3b790ab.png#pic_center)