\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('密码正确')breakelse:print('密码错误')
else:print('三次密码错误')

a = 0
while a < 3:pwd = input('输入密码')if pwd == '999':print('密码正确')breakelse: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
Trues1 = {1,5,2,10,15}
s2 = {1,5,10,15}
print(s2.issubset(s1))Trueprint(s1.issuperset(s2))Trueprint(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!Pythonprint(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.0003.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)

python代码学习1相关推荐

python代码学习-数据处理图片加遮挡、噪声、模糊
python代码学习-数据处理图片加遮挡.噪声.模糊 (一)python代码学习-数据处理图片加遮挡代码: from matplotlib import pyplot as plt from PIL ...
python代码学习——类与对象提升（继承、超继承，类的例题，魔术方法）
python代码学习--类与对象提升继承继承的特殊属性: 代码示例方法的重写和覆盖(overrrid) 总结超继承继承中的初始化多继承例题类的魔术方法哈希(hash)和eq方法 bo ...
python代码学习——python文件处理及路径处理
python代码学习--python文件处理存储相关路径处理 os.path 目录的新建与删除路径操作绝对/相对路径方式获取路径信息路径拼接和realpath方法路径拼接 realpath ...
爬虫（二）京东抢购python代码学习
抢购代码学习笔记主函数:main.py 配置文件config Log模块:log.py 扩展模块网页请求,jd_spider_requests.py 定时器 timer.py 客户端信息:util ...
Python代码学习之给图片添加文字或图片水印
前言图片加水印有什么好处?在现今的数字化时代,网络上的图片泛滥,盗图现象也越来越严重.因此,在发布文章时,为了保护自己的原创作品版权,很多人选择使用水印来保护他们的图片.这样就能更好地做到: 1.版 ...
python代码学习
python中的类class和实例instance 面向对象最重要的概念就是类(class)和实例(instance),类是抽象的模板,实例是根据类创建出来的一个个具体的"对象". ...
2018~2019第二学年17级信管班杨秀璋老师《大数据技术及运用》课堂python代码学习汇总（第二部分）
1.python定义类型 print "abc"strl=raw_input("please input a string:") print (strl) pr ...
python股票分析系统代码_Python 代码学习，用于股票分析
最近,一位常年研究股票系统的开发者 pythonstock 用 Python 写了一个股票分析系统,发布数天就获得了不少关注. 于是我们就推荐给大家,既能学习 python 又能练习炒股.但正如项目作 ...
多目标遗传算法NSGAII求解环境经济调度（Python代码实现）
目录 1 电力系统环境经济调度数学模型 2 算例--IEEE10节点 2.1 数据 2.2 Python代码学习 3 一点拓展知识 1 电力系统环境经济调度数学模型 2 算例--IEEE10节点 ...

python代码学习1

列表

字典

元组

集合

字符串